LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/findstr[P]version-database/db.c
// Function: db_readrel
void
db_readrel(struct release *rel, dr_t hash)
{
	dr_t relobj;
	relobj = db_read(hash);
	release_unmarshal(rel, relobj);
	dr_unref(relobj);
	return ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5e90
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6dd0
movq -0x18(%rbp), %rdi
callq 0x5e30
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/findstr[P]version-database/db.c
// Function: db_readhead
dr_t
db_readhead(struct release *rel, struct tree *tree)
{
	dr_t h;
	h = dir_readfile(HEAD, NULL);
	if (h == NULL) {
		h = dr_new(0, NULL);
		memset(rel, 0, sizeof(*rel));
		if (tree != NULL)
			memset(tree, 0, sizeof(*tree));
	} else {
		db_readrel(rel, h);
		if (tree != NULL)
			db_readtree(tree, rel->tree);
	}
	return h;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x6556(%rip), %rdi      # 0xc6ad
xorl %eax, %eax
movl %eax, %esi
callq 0x5390
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x61a3
xorl %edi, %edi
xorl %eax, %eax
movl %eax, %esi
callq 0x5a70
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x2140
cmpq $0x0, -0x10(%rbp)
je 0x61a1
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x2140
jmp 0x61ca
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x60c0
cmpq $0x0, -0x10(%rbp)
je 0x61c8
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x6100
jmp 0x61ca
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/findstr[P]version-database/db.c
// Function: db_writehead
dr_t
db_writehead(struct release *rel)
{
	dr_t relobj, relhash;
	relobj = release_marshal(rel);
	relhash = db_write(rel->ver, relobj);
	dir_writefile(HEAD, relhash, NULL);
	dr_unref(relobj);
	return relhash;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6b70
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x5f10
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq 0x6494(%rip), %rdi      # 0xc6ad
xorl %eax, %eax
movl %eax, %edx
callq 0x5560
movq -0x10(%rbp), %rdi
callq 0x5e30
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/findstr[P]version-database/db.c
// Function: db_aliashash
dr_t
db_aliashash(dr_t a)
{
	dr_t aa = a;
	dr_t h, ah = NULL;
	int i, an = -1;
	struct release rel;
	if (strncmp(str(aa), ALIAS, ALIAS_SIZE) == 0) {
		if (*(str(aa) + ALIAS_SIZE) == '~')
			an = strtol(str(aa) + ALIAS_SIZE + 1, NULL, 0);
		else
			an = 0;
	}
	if (an == -1)
		return dr_ref(a);
	h = db_readhead(&rel, NULL);
	if (h->size == 0) {
		fprintf(stderr, "FATAL: empty db\n");
		exit(EINVAL);
	}
	i = 0;
	for (;;) {
		if (i == an) {
			ah = dr_ref(h);
			break;
		}
		dr_unref(h);
		h = dr_ref(rel.prev);
		if (h->size == 0)
			break;
		release_destroy(&rel);
		db_readrel(&rel, h);
		i++;
	}
	dr_unref(h);
	release_destroy(&rel);
	if (ah == NULL) {
		fprintf(stderr, "FATAL: invalid alias %s \n", str(aa));
		exit(EINVAL);
	} else {
		printf("alias: %s -> %s\n", str(aa), str(ah));
		return ah;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x28(%rbp)
movl $0xffffffff, -0x30(%rbp) # imm = 0xFFFFFFFF
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
leaq 0x643f(%rip), %rsi      # 0xc6b1
movl $0x4, %edx
callq 0x2070
cmpl $0x0, %eax
jne 0x62b7
movq -0x18(%rbp), %rax
movsbl 0xc(%rax), %eax
cmpl $0x7e, %eax
jne 0x62ae
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
addq $0x4, %rdi
addq $0x1, %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x21c0
movl %eax, -0x30(%rbp)
jmp 0x62b5
movl $0x0, -0x30(%rbp)
jmp 0x62b7
cmpl $-0x1, -0x30(%rbp)
jne 0x62cf
movq -0x10(%rbp), %rdi
callq 0x63e0
movq %rax, -0x8(%rbp)
jmp 0x63d6
leaq -0x60(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x6140
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x630c
movq 0x9d07(%rip), %rax      # 0xfff8
movq (%rax), %rdi
leaq 0x63bb(%rip), %rsi      # 0xc6b6
movb $0x0, %al
callq 0x21a0
movl $0x16, %edi
callq 0x2270
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x30(%rbp), %eax
jne 0x632a
movq -0x20(%rbp), %rdi
callq 0x63e0
movq %rax, -0x28(%rbp)
jmp 0x636d
movq -0x20(%rbp), %rdi
callq 0x5e30
movq -0x58(%rbp), %rdi
callq 0x63e0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x634c
jmp 0x636d
leaq -0x60(%rbp), %rdi
callq 0x6f70
movq -0x20(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x60c0
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x6313
movq -0x20(%rbp), %rdi
callq 0x5e30
leaq -0x60(%rbp), %rdi
callq 0x6f70
cmpq $0x0, -0x28(%rbp)
jne 0x63b0
movq 0x9c6b(%rip), %rax      # 0xfff8
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
addq $0x8, %rdx
leaq 0x6328(%rip), %rsi      # 0xc6c7
movb $0x0, %al
callq 0x21a0
movl $0x16, %edi
callq 0x2270
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
movq -0x28(%rbp), %rdx
addq $0x8, %rdx
leaq 0x631a(%rip), %rdi      # 0xc6e1
movb $0x0, %al
callq 0x2100
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/findstr[P]version-database/db.c
// Function: db_init
void
db_init()
{
	int err;
	err = MKDIR(DB);
	if (err == 0)
		err = MKDIR(ROOT);
	if (err == 0) {
		return ;
	} else if (errno == EEXIST) {
		fprintf(stderr, "FATAL: not a empty directory\n");
		exit(errno);
	} else {
		fprintf(stderr, "FATAL: init fail '%s'", strerror(errno));
		exit(errno);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x62e3(%rip), %rdi      # 0xc6f2
movl $0x1ed, %esi            # imm = 0x1ED
callq 0x2090
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jne 0x6436
leaq 0x62cd(%rip), %rdi      # 0xc6f6
movl $0x1ed, %esi            # imm = 0x1ED
callq 0x2090
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jne 0x6442
addq $0x10, %rsp
popq %rbp
retq
callq 0x2050
cmpl $0x11, (%rax)
jne 0x6470
movq 0x9ba5(%rip), %rax      # 0xfff8
movq (%rax), %rdi
leaq 0x62a5(%rip), %rsi      # 0xc702
movb $0x0, %al
callq 0x21a0
callq 0x2050
movl (%rax), %edi
callq 0x2270
movq 0x9b81(%rip), %rax      # 0xfff8
movq (%rax), %rax
movq %rax, -0x10(%rbp)
callq 0x2050
movl (%rax), %edi
callq 0x22a0
movq -0x10(%rbp), %rdi
movq %rax, %rdx
leaq 0x6288(%rip), %rsi      # 0xc720
movb $0x0, %al
callq 0x21a0
callq 0x2050
movl (%rax), %edi
callq 0x2270
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/findstr[P]version-database/object.c
// Function: tree_marshal
dr_t
tree_marshal(struct tree *t)
{
	dr_t d;
	int i, sz;
	char *ptr;
	struct ref *refs = t->refs;
	sz =	4 +				//type
		4;				//refn
	for (i = 0; i < t->refn; i++) {
		struct ref *r = &refs[i];
		sz += 4 + r->hash->size + 4 + r->name->size;
	}
	d = dr_new(sz, NULL);
	ptr = (char*)d->buf;
	*(uint32_t *)ptr = TREE;			ptr += 4;
	*(uint32_t *)ptr = t->refn;			ptr += 4;
	for (i = 0; i < t->refn; i++) {
		struct ref *r = &refs[i];
		*(uint32_t *)ptr = r->hash->size;	ptr += 4;
		memcpy(ptr, r->hash->buf, r->hash->size);ptr += r->hash->size;
		*(uint32_t *)ptr = r->name->size;	ptr += 4;
		memcpy(ptr, r->name->buf, r->name->size);ptr += r->name->size;
	}
	return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movl $0x8, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x6640
movq -0x28(%rbp), %rax
movslq -0x14(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rax
movl 0x4(%rax), %eax
addl $0x4, %eax
addl $0x4, %eax
movq -0x30(%rbp), %rcx
movq 0x8(%rcx), %rcx
addl 0x4(%rcx), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x65f6
movl -0x18(%rbp), %edi
xorl %eax, %eax
movl %eax, %esi
callq 0x6780
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl $0x45455254, (%rax)     # imm = 0x45455254
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x676b
movq -0x28(%rbp), %rax
movslq -0x14(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rax
movl 0x4(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x38(%rbp), %rax
movq (%rax), %rsi
addq $0x8, %rsi
movq -0x38(%rbp), %rax
movq (%rax), %rax
movslq 0x4(%rax), %rdx
callq 0x21d0
movq -0x38(%rbp), %rax
movq (%rax), %rax
movl 0x4(%rax), %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x4(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rsi
addq $0x8, %rsi
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movslq 0x4(%rax), %rdx
callq 0x21d0
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x4(%rax), %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6691
movq -0x10(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/findstr[P]version-database/object.c
// Function: tree_unmarshal
void
tree_unmarshal(struct tree *t, dr_t d)
{
	int type, i, size;
	uint8_t *ptr = d->buf;
	type = *(uint32_t *)ptr;			ptr += 4;
	assert(type == TREE);
	t->refn = *(uint32_t *)ptr;			ptr += 4;
	size = t->refn * sizeof(struct ref);
	t->refs = MALLOC(size);
	memset(t->refs, 0, size);
	for (i = 0; i < t->refn; i++) {
		struct ref *r = &t->refs[i];
		size = *(uint32_t *)ptr;		ptr += 4;
		r->hash = dr_new(size, ptr);		ptr += size;
		size = *(uint32_t *)ptr;		ptr += 4;
		r->name = dr_new(size, ptr);		ptr += size;
	}
	return ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x28(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x28(%rbp)
cmpl $0x45455254, -0x14(%rbp) # imm = 0x45455254
jne 0x682c
jmp 0x684b
leaq 0x5f59(%rip), %rdi      # 0xc78c
leaq 0x5f5f(%rip), %rsi      # 0xc799
movl $0x5e, %edx
leaq 0x5f5c(%rip), %rcx      # 0xc7a2
callq 0x2120
movq -0x28(%rbp), %rax
movl (%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movslq (%rax), %rax
imulq $0x18, %rax, %rax
movl %eax, -0x1c(%rbp)
movslq -0x1c(%rbp), %rdi
callq 0x2200
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movslq -0x1c(%rbp), %rdx
xorl %esi, %esi
callq 0x2140
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x694c
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x18(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x28(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x28(%rbp)
movl -0x1c(%rbp), %edi
movq -0x28(%rbp), %rsi
callq 0x6780
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x28(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x28(%rbp)
movl -0x1c(%rbp), %edi
movq -0x28(%rbp), %rsi
callq 0x6780
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x689f
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/findstr[P]version-database/object.c
// Function: tree_destroy
void
tree_destroy(struct tree *t)
{
	int i;
	for (i = 0; i < t->refn; i++)
		ref_destroy(&t->refs[i]);
	FREE(t->refs);
	return ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x69a1
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movslq -0xc(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
callq 0x69c0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x6973
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2030
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/findstr[P]version-database/object.c
// Function: tree_clone
void
tree_clone(struct tree *to, struct tree *from)
{
	int i;
	to->refn = from->refn;
	to->refs = MALLOC(from->refn * sizeof(struct ref));
	for (i = 0; i < from->refn; i++)
		ref_clone(&to->refs[i], &from->refs[i]);
	return ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movslq (%rax), %rax
imulq $0x18, %rax, %rdi
callq 0x2200
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x6aff
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movslq -0x14(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movslq -0x14(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rsi
callq 0x6b10
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6abe
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/findstr[P]version-database/object.c
// Function: release_unmarshal
void
release_unmarshal(struct release *r, dr_t d)
{
	int type, size;
	uint8_t *ptr = d->buf;
	type = *(uint32_t *)ptr;			ptr += 4;
	assert(type == RELEASE);
	r->time = *(uint64_t *)ptr;			ptr += sizeof(uint64_t);
	size = *(uint32_t *)ptr;			ptr += 4;
	r->prev = dr_new(size, ptr);			ptr += size;
	size = *(uint32_t *)ptr;			ptr += 4;
	r->tree = dr_new(size, ptr);			ptr += size;
	size = *(uint32_t *)ptr;			ptr += 4;
	r->ver = dr_new(size, ptr);			ptr += size;
	size = *(uint32_t *)ptr;			ptr += 4;
	r->note = dr_new(size, ptr);			ptr += size;
	size = *(uint32_t *)ptr;			ptr += 4;
	r->finger = dr_new(size, ptr);
	return ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x20(%rbp)
cmpl $0x204c4552, -0x14(%rbp) # imm = 0x204C4552
jne 0x6e0c
jmp 0x6e2b
leaq 0x59b8(%rip), %rdi      # 0xc7cb
leaq 0x597f(%rip), %rsi      # 0xc799
movl $0xb2, %edx
leaq 0x59b5(%rip), %rcx      # 0xc7db
callq 0x2120
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x18(%rbp)
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x20(%rbp)
movl -0x18(%rbp), %edi
movq -0x20(%rbp), %rsi
callq 0x6780
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x18(%rbp), %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x18(%rbp)
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x20(%rbp)
movl -0x18(%rbp), %edi
movq -0x20(%rbp), %rsi
callq 0x6780
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movl -0x18(%rbp), %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x18(%rbp)
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x20(%rbp)
movl -0x18(%rbp), %edi
movq -0x20(%rbp), %rsi
callq 0x6780
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movl -0x18(%rbp), %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x18(%rbp)
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x20(%rbp)
movl -0x18(%rbp), %edi
movq -0x20(%rbp), %rsi
callq 0x6780
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movl -0x18(%rbp), %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x18(%rbp)
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x20(%rbp)
movl -0x18(%rbp), %edi
movq -0x20(%rbp), %rsi
callq 0x6780
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/findstr[P]version-database/object.c
// Function: release_destroy
void
release_destroy(struct release *r)
{
	dr_unref(r->prev);
	dr_unref(r->tree);
	dr_unref(r->ver);
	dr_unref(r->note);
	return ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6fc0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x6fc0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x6fc0
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x6fc0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/findstr[P]version-database/meta.c
// Function: ctrl_new
void
ctrl_new(drb_t *drb, struct NEW *c)
{
	writeact(drb, CTRL_NEW);
	writename(drb, c->name);
	writedata(drb, c->data);
	printf(".NEW %s size:%.3f KiB\n",
		c->name->buf, c->data->size/1024.f);
	return ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x10, %esi
callq 0x70a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x70f0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x7180
movq -0x10(%rbp), %rax
movq (%rax), %rsi
addq $0x8, %rsi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cvtsi2ssl 0x4(%rax), %xmm0
movss 0x578d(%rip), %xmm1     # 0xc80c
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x5782(%rip), %rdi      # 0xc810
movb $0x1, %al
callq 0x2100
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/findstr[P]version-database/meta.c
// Function: writename
static void
writename(drb_t *drb, dr_t name)
{
	uint8_t *p;
	int size;
	p = drb_check(drb, NAME_LEN_SIZE + name->size);
	NAME_LEN(p) = size = name->size;	p += NAME_LEN_SIZE;
	memcpy(p, name->buf, size);		p += size;
	drb_end(drb, p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq 0x4(%rax), %rax
addq $0x2, %rax
movl %eax, %esi
callq 0x78e0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x1c(%rbp)
movw %ax, %cx
movq -0x18(%rbp), %rax
movw %cx, (%rax)
movq -0x18(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
movslq -0x1c(%rbp), %rdx
callq 0x21d0
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x7960
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/findstr[P]version-database/meta.c
// Function: writedata
static void
writedata(drb_t *drb, dr_t data)
{
	int size;
	uint8_t *p;
	p = drb_check(drb, data->size);
	uint32(p) = size = data->size;		p += 4;
	memcpy(p, data->buf, size);		p += size;
	drb_end(drb, p);
	return ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x78e0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
movl %ecx, -0x14(%rbp)
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
movslq -0x14(%rbp), %rdx
callq 0x21d0
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x7960
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/findstr[P]version-database/meta.c
// Function: ctrl_dff
void
ctrl_dff(drb_t *drb, struct DFF *c)
{
	writeact(drb, CTRL_DFF);
	writename(drb, c->name);
	writedata(drb, c->patch);
	printf(".DFF %s patch:%d Byte\n",
		c->name->buf, c->patch->size);
	return ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x20, %esi
callq 0x70a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x70f0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x7180
movq -0x10(%rbp), %rax
movq (%rax), %rsi
addq $0x8, %rsi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x4(%rax), %edx
leaq 0x55cb(%rip), %rdi      # 0xc827
movb $0x0, %al
callq 0x2100
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/findstr[P]version-database/meta.c
// Function: ctrl_dfx
void
ctrl_dfx(drb_t *drb, struct DFX *c)
{
	writeact(drb, CTRL_DFX);
	writename(drb, c->name);
	writename(drb, c->namea);
	writedata(drb, c->patch);
	printf(".DFX %s -> %s patch:%d Byte\n",
		c->namea->buf, c->name->buf, c->patch->size);
	return ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x30, %esi
callq 0x70a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x70f0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x70f0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x7180
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
addq $0x8, %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
addq $0x8, %rdx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x4(%rax), %ecx
leaq 0x5555(%rip), %rdi      # 0xc83e
movb $0x0, %al
callq 0x2100
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/findstr[P]version-database/meta.c
// Function: ctrl_cpy
void
ctrl_cpy(drb_t *drb, struct CPY *c)
{
	writeact(drb, CTRL_CPY);
	writename(drb, c->name);
	writename(drb, c->namea);
	printf(".CPY %s => %s\n", c->namea->buf, c->name->buf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x40, %esi
callq 0x70a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x70f0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x70f0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
addq $0x8, %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
addq $0x8, %rdx
leaq 0x54b7(%rip), %rdi      # 0xc864
movb $0x0, %al
callq 0x2100
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/findstr[P]version-database/meta.c
// Function: ctrl_read
const uint8_t *
ctrl_read(const uint8_t *p, struct CTRL *ctrl)
{
	ctrl->act = uint8(p);	p += 1;
	switch (ctrl->act) {
	case CTRL_NEW:
		return ctrl_new_read(p, &ctrl->u.new);
	case CTRL_DFF:
		return ctrl_dff_read(p, &ctrl->u.dff);
	case CTRL_DFX:
		return ctrl_dfx_read(p, &ctrl->u.dfx);
	case CTRL_CPY:
		return ctrl_cpy_read(p, &ctrl->u.cpy);
	case CTRL_DEL:
		return ctrl_del_read(p, &ctrl->u.del);
	default:
		assert(0);
	}
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movb (%rax), %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movq -0x10(%rbp), %rax
incq %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x1c(%rbp)
subl $0x10, %eax
je 0x7420
jmp 0x73f8
movl -0x1c(%rbp), %eax
subl $0x20, %eax
je 0x7437
jmp 0x7402
movl -0x1c(%rbp), %eax
subl $0x30, %eax
je 0x744e
jmp 0x740c
movl -0x1c(%rbp), %eax
subl $0x40, %eax
je 0x7465
jmp 0x7416
movl -0x1c(%rbp), %eax
subl $0x50, %eax
je 0x747c
jmp 0x7493
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
callq 0x74c0
movq %rax, -0x8(%rbp)
jmp 0x74b2
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
callq 0x7540
movq %rax, -0x8(%rbp)
jmp 0x74b2
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
callq 0x75b0
movq %rax, -0x8(%rbp)
jmp 0x74b2
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
callq 0x7640
movq %rax, -0x8(%rbp)
jmp 0x74b2
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
callq 0x7690
movq %rax, -0x8(%rbp)
jmp 0x74b2
leaq 0x54ca(%rip), %rdi      # 0xc964
leaq 0x53d2(%rip), %rsi      # 0xc873
movl $0xd9, %edx
leaq 0x53cd(%rip), %rcx      # 0xc87a
callq 0x2120
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/findstr[P]version-database/meta.c
// Function: ctrl_new_read
static const uint8_t *
ctrl_new_read(const uint8_t *p, struct NEW *c)
{
	c->name = readname(&p);
	c->data = readdata(&p);
	printf(".NEW %s size:%.3f KiB\n",
		c->name->buf, c->data->size/1024.f);
	return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x7c10
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
leaq -0x8(%rbp), %rdi
callq 0x7c80
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rsi
addq $0x8, %rsi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cvtsi2ssl 0x4(%rax), %xmm0
movss 0x52f5(%rip), %xmm1     # 0xc80c
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x52ea(%rip), %rdi      # 0xc810
movb $0x1, %al
callq 0x2100
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/findstr[P]version-database/meta.c
// Function: ctrl_dff_read
static const uint8_t *
ctrl_dff_read(const uint8_t *p, struct DFF *c)
{
	c->name = readname(&p);
	c->patch = readdata(&p);
	printf(".DFF %s patch:%d Byte\n",
		c->name->buf, c->patch->size);
	return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x7c10
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
leaq -0x8(%rbp), %rdi
callq 0x7c80
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rsi
addq $0x8, %rsi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x4(%rax), %edx
leaq 0x5293(%rip), %rdi      # 0xc827
movb $0x0, %al
callq 0x2100
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/findstr[P]version-database/meta.c
// Function: ctrl_dfx_read
static const uint8_t *
ctrl_dfx_read(const uint8_t *p, struct DFX *c)
{
	c->name = readname(&p);
	c->namea = readname(&p);
	c->patch = readdata(&p);
	printf(".DFX %s -> %s patch:%d Byte\n",
		c->namea->buf, c->name->buf, c->patch->size);
	return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x7c10
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
leaq -0x8(%rbp), %rdi
callq 0x7c10
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
leaq -0x8(%rbp), %rdi
callq 0x7c80
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
addq $0x8, %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
addq $0x8, %rdx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x4(%rax), %ecx
leaq 0x521a(%rip), %rdi      # 0xc83e
movb $0x0, %al
callq 0x2100
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/findstr[P]version-database/meta.c
// Function: ctrl_destroy
void
ctrl_destroy(struct CTRL *ctrl)
{
	switch (ctrl->act) {
	case CTRL_NEW:
		ctrl_new_free(&ctrl->u.new);
		break;
	case CTRL_DFF:
		ctrl_dff_free(&ctrl->u.dff);
		break;
	case CTRL_DFX:
		ctrl_dfx_free(&ctrl->u.dfx);
		break;
	case CTRL_CPY:
		ctrl_cpy_free(&ctrl->u.cpy);
		break;
	case CTRL_DEL:
		ctrl_del_free(&ctrl->u.del);
		break;
	default:
		assert(0);
	}
	return ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0xc(%rbp)
subl $0x10, %eax
je 0x7725
jmp 0x76fd
movl -0xc(%rbp), %eax
subl $0x20, %eax
je 0x7734
jmp 0x7707
movl -0xc(%rbp), %eax
subl $0x30, %eax
je 0x7743
jmp 0x7711
movl -0xc(%rbp), %eax
subl $0x40, %eax
je 0x7752
jmp 0x771b
movl -0xc(%rbp), %eax
subl $0x50, %eax
je 0x7761
jmp 0x7770
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x77a0
jmp 0x778f
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x77d0
jmp 0x778f
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x7800
jmp 0x778f
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x7840
jmp 0x778f
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x7870
jmp 0x778f
leaq 0x51ed(%rip), %rdi      # 0xc964
leaq 0x50f5(%rip), %rsi      # 0xc873
movl $0xf2, %edx
leaq 0x5129(%rip), %rcx      # 0xc8b3
callq 0x2120
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/findstr[P]version-database/meta.c
// Function: patch_copy
void
patch_copy(drb_t *drb, struct COPY *copy)
{
	uint8_t *p = drb_check(drb, 1+4+4);
	uint8(p) = PATCH_COPY;	p += 1;
	uint32(p) = copy->pos;	p += 4;
	uint32(p) = copy->size;	p += 4;
	drb_end(drb, p);
	return ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x9, %esi
callq 0x78e0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movb $0x1, (%rax)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x7960
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/findstr[P]version-database/meta.c
// Function: patch_insert
void
patch_insert(drb_t *drb, struct INSERT *insert)
{
	int size = insert->size;
	uint8_t *p = drb_check(drb, 1+4+size);
	uint8(p) = PATCH_INSERT;	p += 1;
	uint32(p) = size;		p += 4;
	memcpy(p, insert->p, size);	p += size;
	drb_end(drb, p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
addl $0x5, %esi
callq 0x78e0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movb $0x2, (%rax)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movslq -0x14(%rbp), %rdx
callq 0x21d0
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x7960
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/findstr[P]version-database/meta.c
// Function: patch_read
const uint8_t *
patch_read(const uint8_t *p, struct PATCH *patch)
{
	patch->act = uint8(p);		p += 1;
	if (patch->act == PATCH_COPY)
		return patch_copy_read(p, &patch->u.copy);
	else if (patch->act == PATCH_INSERT)
		return patch_insert_read(p, &patch->u.insert);
	else
		assert(0);
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movb (%rax), %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x7b1b
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
callq 0x7b70
movq %rax, -0x8(%rbp)
jmp 0x7b5d
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x2, %eax
jne 0x7b3e
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
callq 0x7bc0
movq %rax, -0x8(%rbp)
jmp 0x7b5d
leaq 0x4e1f(%rip), %rdi      # 0xc964
leaq 0x4d27(%rip), %rsi      # 0xc873
movl $0x136, %edx            # imm = 0x136
leaq 0x4d7c(%rip), %rcx      # 0xc8d4
callq 0x2120
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/findstr[P]version-database/meta.c
// Function: readname
static dr_t
readname(const uint8_t **pp)
{
	int size;
	dr_t name;
	const uint8_t *p = *pp;
	size = NAME_LEN(p);	p += NAME_LEN_SIZE;
	name = dr_new(size, p); p += size;
	*pp = p;
	return name;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movzwl (%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x20(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %edi
movq -0x20(%rbp), %rsi
callq 0x7cf0
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/findstr[P]version-database/meta.c
// Function: readdata
static dr_t
readdata(const uint8_t **pp)
{
	int size;
	dr_t data;
	const uint8_t *p = *pp;
	size = uint32(p);	p += 4;
	data = dr_new(size, p);	p += size;
	*pp = p;
	return data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %edi
movq -0x20(%rbp), %rsi
callq 0x7cf0
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/findstr[P]version-database/dc3.c
// Function: radix_pass
static void
radix_pass(int *src, int *dst, int size, const int *buf, int space)
{
	int i, n, *c;
	space += 1;
	c = NEW(int, space);
	for (i = 0; i < space; i++)
		c[i] = 0;
	for (i = 0; i < size; i++) {
		int n = V(src[i]);
		++c[n];
	}
	n = 0;
	for (i = 0; i < space; i++) {
		int tmp = c[i];
		c[i] = n;
		n += tmp;
	}
	for (i = 0; i < size; i++) {
		int pos = c[V(src[i])]++;
		dst[pos] = src[i];
	}
	free(c);
	return ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movslq -0x24(%rbp), %rdi
shlq $0x2, %rdi
callq 0x2200
movq %rax, -0x38(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x882e
movq -0x38(%rbp), %rax
movslq -0x28(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x880c
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x886f
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq -0x28(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x3c(%rbp)
movq -0x38(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x8835
movl $0x0, -0x2c(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x88b5
movq -0x38(%rbp), %rax
movslq -0x28(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x40(%rbp)
movl -0x2c(%rbp), %edx
movq -0x38(%rbp), %rax
movslq -0x28(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x40(%rbp), %eax
addl -0x2c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x887d
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x890b
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rdx
movslq -0x28(%rbp), %rsi
movslq (%rdx,%rsi,4), %rdx
movslq (%rax,%rdx,4), %rdx
movl (%rcx,%rdx,4), %eax
movl %eax, %esi
addl $0x1, %esi
movl %esi, (%rcx,%rdx,4)
movl %eax, -0x44(%rbp)
movq -0x8(%rbp), %rax
movslq -0x28(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x10(%rbp), %rax
movslq -0x44(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x88bc
movq -0x38(%rbp), %rdi
callq 0x2030
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/findstr[P]version-database/dc3.c
// Function: dc3
int *
dc3(const uint8_t *dat, int size)
{
	int i, *p;
	int *SA = NEW(int, size);
	int *buf = NEW(int, size+3);
	p = buf;
	for (i = 0; i < size; i++)
		*p++ = dat[i]+1;
	for (i = 0; i < 3; i++)
		*p++ = TERM;
	dc3_r(buf, SA, size, 0xff+1);
	free(buf);
	return SA;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movslq -0xc(%rbp), %rdi
shlq $0x2, %rdi
callq 0x2200
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %eax
addl $0x3, %eax
movslq %eax, %rdi
shlq $0x2, %rdi
callq 0x2200
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x8a58
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movzbl (%rax,%rcx), %ecx
addl $0x1, %ecx
movq -0x18(%rbp), %rax
movq %rax, %rdx
addq $0x4, %rdx
movq %rdx, -0x18(%rbp)
movl %ecx, (%rax)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x8a25
movl $0x0, -0x10(%rbp)
cmpl $0x3, -0x10(%rbp)
jge 0x8a85
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x18(%rbp)
movl $0x0, (%rax)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x8a5f
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0xc(%rbp), %edx
movl $0x100, %ecx            # imm = 0x100
callq 0x7e60
movq -0x28(%rbp), %rdi
callq 0x2030
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/findstr[P]version-database/sha1.c
// Function: SHA1_Init
void SHA1_Init(SHA1_CTX *ctx)
{
	ctx->size = 0;

	/* Initialize H with the magic constants (see FIPS180 for constants) */
	ctx->H[0] = 0x67452301;
	ctx->H[1] = 0xefcdab89;
	ctx->H[2] = 0x98badcfe;
	ctx->H[3] = 0x10325476;
	ctx->H[4] = 0xc3d2e1f0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movl $0x67452301, 0x8(%rax)  # imm = 0x67452301
movq -0x8(%rbp), %rax
movl $0xefcdab89, 0xc(%rax)  # imm = 0xEFCDAB89
movq -0x8(%rbp), %rax
movl $0x98badcfe, 0x10(%rax) # imm = 0x98BADCFE
movq -0x8(%rbp), %rax
movl $0x10325476, 0x14(%rax) # imm = 0x10325476
movq -0x8(%rbp), %rax
movl $0xc3d2e1f0, 0x18(%rax) # imm = 0xC3D2E1F0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/findstr[P]version-database/sha1.c
// Function: SHA1_Update
void SHA1_Update(SHA1_CTX *ctx, const void *data, unsigned long len)
{
	unsigned int lenW = ctx->size & 63;

	ctx->size += len;

	/* Read the data into W and process blocks as they get full */
	if (lenW) {
		unsigned int left = 64 - lenW;
		if (len < left)
			left = len;
		memcpy(lenW + (char *)ctx->W, data, left);
		lenW = (lenW + left) & 63;
		len -= left;
		data = ((const char *)data + left);
		if (lenW)
			return;
		SHA1_Block(ctx, ctx->W);
	}
	while (len >= 64) {
		SHA1_Block(ctx, data);
		data = ((const char *)data + 64);
		len -= 64;
	}
	if (len)
		memcpy(ctx->W, data, len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
andq $0x3f, %rax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
cmpl $0x0, -0x1c(%rbp)
je 0x8bb5
movl $0x40, %eax
subl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl -0x20(%rbp), %ecx
cmpq %rcx, %rax
jae 0x8b54
movq -0x18(%rbp), %rax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rdi
addq $0x1c, %rdi
movl %eax, %eax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movl -0x20(%rbp), %eax
movl %eax, %edx
callq 0x21d0
movl -0x1c(%rbp), %eax
addl -0x20(%rbp), %eax
andl $0x3f, %eax
movl %eax, -0x1c(%rbp)
movl -0x20(%rbp), %eax
movl %eax, %ecx
movq -0x18(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl -0x20(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x8ba4
jmp 0x8c01
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x1c, %rsi
callq 0x8c10
jmp 0x8bb7
cmpq $0x40, -0x18(%rbp)
jb 0x8be5
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x8c10
movq -0x10(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
subq $0x40, %rax
movq %rax, -0x18(%rbp)
jmp 0x8bb7
cmpq $0x0, -0x18(%rbp)
je 0x8c01
movq -0x8(%rbp), %rdi
addq $0x1c, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x21d0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/findstr[P]version-database/sha1.c
// Function: SHA1_Final
void SHA1_Final(unsigned char hashout[20], SHA1_CTX *ctx)
{
	static const unsigned char pad[64] = { 0x80 };
	unsigned int padlen[2];
	int i;

	/* Pad with a binary 1 (ie 0x80), then zeroes, then length */
	padlen[0] = htonl((uint32_t)(ctx->size >> 29));
	padlen[1] = htonl((uint32_t)(ctx->size << 3));

	i = ctx->size & 63;
	SHA1_Update(ctx, pad, 1 + (63 & (55 - i)));
	SHA1_Update(ctx, padlen, 8);

	/* Output hash */
	for (i = 0; i < 5; i++)
		put_be32(hashout + i * 4, ctx->H[i]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
shrq $0x1d, %rax
movl %eax, %edi
callq 0x2130
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
shlq $0x3, %rax
movl %eax, %edi
callq 0x2130
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
andq $0x3f, %rax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movl $0x37, %eax
subl -0x1c(%rbp), %eax
andl $0x3f, %eax
addl $0x1, %eax
movslq %eax, %rdx
leaq 0xfdc(%rip), %rsi       # 0xc9d0
callq 0x8b00
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
movl $0x8, %edx
callq 0x8b00
movl $0x0, -0x1c(%rbp)
cmpl $0x5, -0x1c(%rbp)
jge 0xba4a
jmp 0xba1a
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl 0x8(%rax,%rcx,4), %edi
callq 0x2130
movl %eax, %edx
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
shll $0x2, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx)
jmp 0xba3f
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xba12
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/primatesv1hanuman80/ref/primate.cpp
// Function: GenerateRoundConstants()
void GenerateRoundConstants() //Generation of 5-bit round constant by using the primitive polynomial x^5+x^2+1 with initial value 1.
{
	//Round constants for p_1
	rc_p1[0]=1;
	//printf("\nRound constants for p_1: \n %.2x", rc_p1[0]);
	for(int i=1; i<p1rounds; i++){
		rc_p1[i] = ((rc_p1[i-1]<<1) ^ ((rc_p1[i-1]>>1)&1) ^ ((rc_p1[i-1]>>4)&1))&31;
		//printf("\n %.2x", rc_p1[i]);
	}

	//Round constant for p_4
	rc_p4[0] = ((rc_p1[p1rounds-1]<<1) ^ ((rc_p1[p1rounds-1]>>1)&1) ^ ((rc_p1[p1rounds-1]>>4)&1))&31;
	//printf("\nRound constants for p_4: \n %.2x", rc_p4[0]);
	for(int i=1; i<p4rounds; i++){
		rc_p4[i] = ((rc_p4[i-1]<<1) ^ ((rc_p4[i-1]>>1)&1) ^ ((rc_p4[i-1]>>4)&1))&31;
		//printf("\n %.2x", rc_p4[i]);
	}
}

// Assembly:
movq 0x2591(%rip), %rax      # 0x4fc8
movb $0x1, (%rax)
movl $0x1, -0x4(%rsp)
cmpl $0xc, -0x4(%rsp)
jge 0x2aba
movl -0x4(%rsp), %eax
subl $0x1, %eax
movslq %eax, %rcx
movq 0x256e(%rip), %rax      # 0x4fc8
movzbl (%rax,%rcx), %eax
shll %eax
movl -0x4(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rdx
movq 0x2557(%rip), %rcx      # 0x4fc8
movzbl (%rcx,%rdx), %ecx
sarl %ecx
andl $0x1, %ecx
xorl %ecx, %eax
movl -0x4(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rdx
movq 0x253b(%rip), %rcx      # 0x4fc8
movzbl (%rcx,%rdx), %ecx
sarl $0x4, %ecx
andl $0x1, %ecx
xorl %ecx, %eax
andl $0x1f, %eax
movb %al, %dl
movslq -0x4(%rsp), %rcx
movq 0x251e(%rip), %rax      # 0x4fc8
movb %dl, (%rax,%rcx)
movl -0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rsp)
jmp 0x2a42
movq 0x2507(%rip), %rax      # 0x4fc8
movzbl 0xb(%rax), %eax
shll %eax
movq 0x24fa(%rip), %rcx      # 0x4fc8
movzbl 0xb(%rcx), %ecx
sarl %ecx
andl $0x1, %ecx
xorl %ecx, %eax
movq 0x24e8(%rip), %rcx      # 0x4fc8
movzbl 0xb(%rcx), %ecx
sarl $0x4, %ecx
andl $0x1, %ecx
xorl %ecx, %eax
andl $0x1f, %eax
movb %al, %cl
movq 0x2500(%rip), %rax      # 0x4ff8
movb %cl, (%rax)
movl $0x1, -0x8(%rsp)
cmpl $0xc, -0x8(%rsp)
jge 0x2b7a
movl -0x8(%rsp), %eax
subl $0x1, %eax
movslq %eax, %rcx
movq 0x24de(%rip), %rax      # 0x4ff8
movzbl (%rax,%rcx), %eax
shll %eax
movl -0x8(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rdx
movq 0x24c7(%rip), %rcx      # 0x4ff8
movzbl (%rcx,%rdx), %ecx
sarl %ecx
andl $0x1, %ecx
xorl %ecx, %eax
movl -0x8(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rdx
movq 0x24ab(%rip), %rcx      # 0x4ff8
movzbl (%rcx,%rdx), %ecx
sarl $0x4, %ecx
andl $0x1, %ecx
xorl %ecx, %eax
andl $0x1f, %eax
movb %al, %dl
movslq -0x8(%rsp), %rcx
movq 0x248e(%rip), %rax      # 0x4ff8
movb %dl, (%rax,%rcx)
movl -0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rsp)
jmp 0x2b02
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/primatesv1hanuman80/ref/primate.cpp
// Function: InitializeState(unsigned char*, unsigned char*, unsigned char*)
void InitializeState(unsigned char *state, unsigned char *key, unsigned char *nonce)
{
	GenerateRoundConstants();

	for(int i=0; i<RateSizeElements; i++)
		state[i]=0;
	for(int i=0; i<KeySizeElements; i++)
		state[RateSizeElements+i]=key[i];
	for(int i=0; i<NonceSizeElements; i++)
		state[(RateSizeElements+KeySizeElements)+i]=nonce[i];
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
callq 0x1130
movl $0x0, 0xc(%rsp)
cmpl $0x8, 0xc(%rsp)
jge 0x2bc2
movq 0x20(%rsp), %rax
movslq 0xc(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x2ba0
movl $0x0, 0x8(%rsp)
cmpl $0x10, 0x8(%rsp)
jge 0x2bfd
movq 0x18(%rsp), %rax
movslq 0x8(%rsp), %rcx
movb (%rax,%rcx), %dl
movq 0x20(%rsp), %rax
movl 0x8(%rsp), %ecx
addl $0x8, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x2bca
movl $0x0, 0x4(%rsp)
cmpl $0x10, 0x4(%rsp)
jge 0x2c38
movq 0x10(%rsp), %rax
movslq 0x4(%rsp), %rcx
movb (%rax,%rcx), %dl
movq 0x20(%rsp), %rax
movl 0x4(%rsp), %ecx
addl $0x18, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x2c05
addq $0x28, %rsp
retq
nopl (%rax)