LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/findstr[P]version-database/./dr.h
// Function: dr_resize
static inline dr_t
dr_resize(dr_t d, int size)
{
	if (d->ref == 1) {
		d = realloc(d, size + sizeof(struct dr_));
		d->size = size;
	} else {
		dr_t n = dr_new(size, NULL);
		if (size > d->size)
			size = d->size;
		d->size = size;
		memcpy(n->buf, d->buf, size);
		dr_unref(d);
		d = n;
	}
	return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
cmpl $0x1, (%rdi)
jne 0x2f09
movslq %r14d, %rsi
addq $0xc, %rsi
movq %rbx, %rdi
callq 0x2210
movq %rax, %r15
movl %r14d, 0x4(%rax)
jmp 0x2f3c
movl %r14d, %edi
xorl %esi, %esi
callq 0x2e8c
movq %rax, %r15
movl 0x4(%rbx), %eax
cmpl %r14d, %eax
cmovll %eax, %r14d
movl %r14d, 0x4(%rbx)
leaq 0x8(%r15), %rdi
leaq 0x8(%rbx), %rsi
movslq %r14d, %rdx
callq 0x21c0
movq %rbx, %rdi
callq 0x2e50
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/findstr[P]version-database/history.c
// Function: history
void
history(int n)
{
	dr_t h;
	int i = 0;
	struct release rel;
	h = db_readhead(&rel, NULL);
	if (h->size == 0) {
		printf("Empty db\n");
	} else {
		for (;;) {
			struct tm *t;
			char datetime[200];
			t = localtime(&rel.time);
			strftime(datetime, sizeof(datetime),
				"%a %b %d %H:%M:%S %Z", t);
			printf("release:%s\n", h->buf);
			printf("finger:%s\n", rel.finger->buf);
			printf("Version:%s\n", rel.ver->buf);
			printf("Date:%s\n", datetime);
			printf("\n\t%s\n\n", rel.note->buf);
			if (rel.prev->size <= 0 || (n > 0 && ++i >= n))
				break;
			dr_unref(h);
			h = dr_ref(rel.prev);
			release_destroy(&rel);
			memset(&rel, 0, sizeof(rel));
			db_readrel(&rel, h);
		}
	}
	dr_unref(h);
	release_destroy(&rel);
	return ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movl %edi, %r14d
leaq -0x60(%rbp), %rdi
xorl %esi, %esi
callq 0x4f2b
movq %rax, %rbx
cmpl $0x0, 0x4(%rax)
je 0x305e
leaq -0x60(%rbp), %r15
leaq -0x130(%rbp), %r13
xorl %r12d, %r12d
movq %r15, %rdi
callq 0x2040
movl $0xc8, %esi
movq %r13, %rdi
leaq 0x5255(%rip), %rdx      # 0x81f5
movq %rax, %rcx
callq 0x2220
leaq 0x8(%rbx), %rsi
leaq 0x5257(%rip), %rdi      # 0x820a
xorl %eax, %eax
callq 0x2110
movq -0x38(%rbp), %rsi
addq $0x8, %rsi
leaq 0x524d(%rip), %rdi      # 0x8216
xorl %eax, %eax
callq 0x2110
movq -0x48(%rbp), %rsi
addq $0x8, %rsi
leaq 0x5242(%rip), %rdi      # 0x8221
xorl %eax, %eax
callq 0x2110
leaq 0x5240(%rip), %rdi      # 0x822d
movq %r13, %rsi
xorl %eax, %eax
callq 0x2110
movq -0x40(%rbp), %rsi
addq $0x8, %rsi
leaq 0x5230(%rip), %rdi      # 0x8236
xorl %eax, %eax
callq 0x2110
movq -0x58(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jle 0x306a
testl %r14d, %r14d
jle 0x3024
incl %r12d
cmpl %r14d, %r12d
jge 0x306a
movq %rbx, %rdi
callq 0x308d
movq -0x58(%rbp), %rbx
testq %rbx, %rbx
je 0x3037
incl (%rbx)
movq %r15, %rdi
callq 0x5725
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
movaps %xmm0, -0x50(%rbp)
movaps %xmm0, -0x60(%rbp)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4ed3
jmp 0x2f89
leaq 0x51d8(%rip), %rdi      # 0x823d
callq 0x20a0
movq %rbx, %rdi
callq 0x308d
leaq -0x60(%rbp), %rdi
callq 0x5725
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/findstr[P]version-database/diff.c
// Function: diff
void
diff(struct diff_args *args)
{
	dr_t head;
	struct release rel;
	if (args->r == 0)
		return diff_tree(args->a, args->b, args->o);
	head = db_readhead(&rel, NULL);
	if (head->size == 0) {
		printf("Empty db\n");
	} else {
		int i;
		for (i = 0; i < args->r || args->r < 0; i++) {
			dr_t h;
			if (rel.prev->size <= 0)
				break;
			h = dr_ref(rel.prev);
			diff_tree(h, head, args->o);
			release_destroy(&rel);
			db_readrel(&rel, h);
			dr_unref(h);
		}
	}
	dr_unref(head);
	release_destroy(&rel);
	return ;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
cmpl $0x0, (%rdi)
je 0x3144
xorl %r13d, %r13d
leaq -0x58(%rbp), %rdi
xorl %esi, %esi
callq 0x4f2b
movq %rax, %r14
cmpl $0x0, 0x4(%rax)
je 0x3160
leaq -0x58(%rbp), %r15
cmpl %r13d, (%rbx)
jbe 0x316c
movq -0x50(%rbp), %r12
cmpl $0x0, 0x4(%r12)
jle 0x316c
incl (%r12)
movq 0x18(%rbx), %rdx
movq %r12, %rdi
movq %r14, %rsi
callq 0x318c
movq %r15, %rdi
callq 0x5725
movq %r15, %rdi
movq %r12, %rsi
callq 0x4ed3
movq %r12, %rdi
callq 0x3a7a
incl %r13d
jmp 0x3100
movq 0x8(%rbx), %rdi
movq 0x10(%rbx), %rsi
movq 0x18(%rbx), %rdx
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x318c
leaq 0x50d6(%rip), %rdi      # 0x823d
callq 0x20a0
movq %r14, %rdi
callq 0x3a7a
leaq -0x58(%rbp), %rdi
callq 0x5725
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/findstr[P]version-database/./dr.h
// Function: drb_dump
static inline dr_t
drb_dump(drb_t *drb)
{
	dr_t d;
	d = dr_resize(drb->seq, drb->size);
	drb->seq = NULL;
	return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %r14
movl (%rdi), %r15d
cmpl $0x1, (%r14)
jne 0x3b0f
movslq %r15d, %rsi
addq $0xc, %rsi
movq %r14, %rdi
callq 0x2210
movq %rax, %r12
movl %r15d, 0x4(%rax)
jmp 0x3b44
movl %r15d, %edi
xorl %esi, %esi
callq 0x3b70
movq %rax, %r12
movl 0x4(%r14), %eax
cmpl %r15d, %eax
cmovll %eax, %r15d
movl %r15d, 0x4(%r14)
leaq 0x8(%r12), %rdi
leaq 0x8(%r14), %rsi
movslq %r15d, %rdx
callq 0x21c0
movq %r14, %rdi
callq 0x3a7a
andq $0x0, 0x8(%rbx)
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/findstr[P]version-database/diff.c
// Function: search
static int
search(dr_t old, int *SA, const uint8_t *ns, int nsize, int *pos)
{
	int n = 0, sim = 0;
	int osize = old->size;
	int m = 0, l = 0, r = osize;
	const uint8_t *p = old->buf;
	*pos = -1;
	while (l < r) {
		int c, s;
		m = (l + r) / 2;
		n = SA[m];
		c = match(&p[n], osize - n, ns, nsize, &s);
		if (c == 0) {	//contain
			*pos = n;
			sim = s;
			assert(s == nsize);
			break;
		} else {
			if (sim < s) {
				*pos = n;
				sim = s;
			}
			if (c < 0)
				l = m + 1;
			else
				r = m;
		}
	}
	return sim;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, -0x40(%rbp)
movl 0x4(%rdi), %eax
addq $0x8, %rdi
movq %r8, -0x38(%rbp)
orl $-0x1, (%r8)
xorl %r11d, %r11d
movl %eax, -0x2c(%rbp)
movl %eax, %ebx
xorl %r14d, %r14d
cmpl %ebx, %r11d
jge 0x3c8d
leal (%rbx,%r11), %r15d
shrl %r15d
movq -0x40(%rbp), %rax
movslq (%rax,%r15,4), %r12
movq %r12, %r10
addq %rdi, %r10
movl -0x2c(%rbp), %eax
subl %r12d, %eax
cmpl %ecx, %eax
movl %ecx, %r9d
cmovll %eax, %r9d
testl %r9d, %r9d
movl $0x0, %esi
cmovlel %esi, %r9d
xorl %r13d, %r13d
cmpq %r13, %r9
je 0x3c42
movb (%r10,%r13), %r8b
movb (%rdx,%r13), %sil
cmpb %sil, %r8b
jne 0x3c50
incq %r13
jmp 0x3c2b
xorl %r10d, %r10d
cmpl %ecx, %eax
setl %r10b
negl %r10d
jmp 0x3c65
jae 0x3c5b
pushq $-0x1
popq %r10
movl %r13d, %r9d
jmp 0x3c6a
seta %al
movzbl %al, %r10d
movl %r13d, %r9d
testl %r10d, %r10d
je 0x3c92
cmpl %r9d, %r14d
jae 0x3c79
movq -0x38(%rbp), %rax
movl %r12d, (%rax)
movl %r9d, %r14d
leal 0x1(%r15), %eax
testl %r10d, %r10d
cmovsl %eax, %r11d
cmovnsl %r15d, %ebx
jmp 0x3bef
movl %r14d, %ecx
jmp 0x3c9e
movq -0x38(%rbp), %rax
movl %r12d, (%rax)
cmpl %ecx, %r9d
jne 0x3caf
movl %ecx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4650(%rip), %rdi      # 0x8306
leaq 0x4611(%rip), %rsi      # 0x82ce
leaq 0x464d(%rip), %rcx      # 0x8311
pushq $0x3b
popq %rdx
callq 0x2130
// File: /workspace/github_c_makefile_star2_O2/findstr[P]version-database/list.c
// Function: list
void
list(struct list_args *args)
{
	int i, n;
	struct release r;
	struct tree t;
	dr_t hash = db_aliashash(args->hash);
	db_readrel(&r, args->hash);
	db_readtree(&t, r.tree);
	release_destroy(&r);
	dr_unref(hash);
	n = t.refn;
	for (i = 0; i < n; i++) {
		printf("%s ==> %s\n",
			t.refs[i].name->buf,
			t.refs[i].hash->buf);
	}
	printf("total:%d\n", n);
	tree_destroy(&t);
	return ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
movq (%rdi), %rdi
callq 0x4fe3
movq %rax, %rbx
movq (%r14), %rsi
leaq -0x60(%rbp), %r14
movq %r14, %rdi
callq 0x4ed3
movq 0x10(%r14), %rsi
leaq -0x30(%rbp), %rdi
callq 0x4eff
movq %r14, %rdi
callq 0x5725
testq %rbx, %rbx
je 0x4162
movl (%rbx), %ecx
leal -0x1(%rcx), %eax
movl %eax, (%rbx)
cmpl $0x1, %ecx
jg 0x4162
testl %eax, %eax
jne 0x41cd
movq %rbx, %rdi
callq 0x2030
movl -0x30(%rbp), %ebx
testl %ebx, %ebx
movl $0x0, %eax
cmovgl %ebx, %eax
imulq $0x18, %rax, %r15
leaq 0x4332(%rip), %r14      # 0x84ac
xorl %r12d, %r12d
cmpq %r12, %r15
je 0x41a7
movq -0x28(%rbp), %rax
movq (%rax,%r12), %rdx
movq 0x8(%rax,%r12), %rsi
addq $0x8, %rsi
addq $0x8, %rdx
movq %r14, %rdi
xorl %eax, %eax
callq 0x2110
addq $0x18, %r12
jmp 0x417d
leaq 0x4260(%rip), %rdi      # 0x840e
movl %ebx, %esi
xorl %eax, %eax
callq 0x2110
leaq -0x30(%rbp), %rdi
callq 0x5418
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3ead(%rip), %rdi      # 0x8081
leaq 0x3eb2(%rip), %rsi      # 0x808d
leaq 0x3eb2(%rip), %rcx      # 0x8094
pushq $0x2d
popq %rdx
callq 0x2130
nop
// File: /workspace/github_c_makefile_star2_O2/findstr[P]version-database/checkout.c
// Function: checkout
void
checkout(dr_t hash, dr_t outdir)
{
	int i;
	struct release r;
	struct tree t;
	hash = db_aliashash(hash);
	db_readrel(&r, hash);
	dr_unref(hash);
	db_readtree(&t, r.tree);
	printf("checkout tree:%s->%s\n", r.tree->buf, str(outdir));
	release_destroy(&r);
	dir_ensure(str(outdir));
	if (errno == EEXIST)
		printf("warning: checkout folder '%s' is exist\n", str(outdir));
	for (i = 0; i < t.refn; i++) {
		struct ref *f;
		f = &t.refs[i];
		f->data = db_read(f->hash);
		dir_writefile(str(f->name), f->data, outdir);
	}
	tree_destroy(&t);
	return ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
callq 0x4fe3
movq %rax, %r14
leaq -0x60(%rbp), %rdi
movq %rax, %rsi
callq 0x4ed3
testq %r14, %r14
je 0x4235
movl (%r14), %ecx
leal -0x1(%rcx), %eax
movl %eax, (%r14)
cmpl $0x1, %ecx
jg 0x4235
testl %eax, %eax
jne 0x42e3
movq %r14, %rdi
callq 0x2030
leaq -0x60(%rbp), %r15
movq 0x10(%r15), %rsi
leaq -0x30(%rbp), %rdi
callq 0x4eff
movq 0x10(%r15), %rsi
addq $0x8, %rsi
leaq 0x8(%rbx), %r14
leaq 0x425e(%rip), %rdi      # 0x84b7
movq %r14, %rdx
xorl %eax, %eax
callq 0x2110
movq %r15, %rdi
callq 0x5725
movq %r14, %rdi
callq 0x454f
callq 0x2050
cmpl $0x11, (%rax)
jne 0x428e
leaq 0x4249(%rip), %rdi      # 0x84cd
movq %r14, %rsi
xorl %eax, %eax
callq 0x2110
pushq $0x10
popq %r14
xorl %r15d, %r15d
movslq -0x30(%rbp), %rax
cmpq %rax, %r15
jge 0x42cd
movq -0x28(%rbp), %r12
movq -0x10(%r12,%r14), %rdi
callq 0x4d31
movq %rax, (%r12,%r14)
movq -0x8(%r12,%r14), %rdi
addq $0x8, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x475e
incq %r15
addq $0x18, %r14
jmp 0x4295
leaq -0x30(%rbp), %rdi
callq 0x5418
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3d97(%rip), %rdi      # 0x8081
leaq 0x3d9c(%rip), %rsi      # 0x808d
leaq 0x3d9c(%rip), %rcx      # 0x8094
pushq $0x2d
popq %rdx
callq 0x2130
// File: /workspace/github_c_makefile_star2_O2/findstr[P]version-database/dir.c
// Function: dir_scan
int
dir_scan(const char *path, dr_t **res, int skip)
{
	struct args args;
	args.num = 0;
	args.cap = 128;
	if (skip)
		args.prefix = strlen(path) + 1;
	else
		args.prefix = 0;
	args.list = malloc(128 * sizeof(dr_t));
	scan_r(path, &args);
	if (res == NULL) {
		int i;
		for (i = 0; i < args.num; i++)
			dr_unref(args.list[i]);
		free(args.list);
	} else {
		*res = args.list;
	}
	return args.num;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movabsq $0x8000000000, %rax     # imm = 0x8000000000
movq %rax, -0x38(%rbp)
testl %edx, %edx
je 0x4333
movq %r14, %rdi
callq 0x20e0
incl %eax
jmp 0x4335
xorl %eax, %eax
leaq -0x38(%rbp), %r15
movl %eax, 0x8(%r15)
movl $0x400, %edi            # imm = 0x400
callq 0x21f0
movq %rax, 0x10(%r15)
movq %r14, %rdi
movq %r15, %rsi
callq 0x43a7
testq %rbx, %rbx
je 0x4367
movq -0x28(%rbp), %rax
movq %rax, (%rbx)
movl -0x38(%rbp), %ebx
jmp 0x4398
movl -0x38(%rbp), %ebx
movq -0x28(%rbp), %r14
xorl %r15d, %r15d
testl %ebx, %ebx
movl $0x0, %r12d
cmovgl %ebx, %r12d
cmpq %r15, %r12
je 0x4390
movq (%r14,%r15,8), %rdi
callq 0x4513
incq %r15
jmp 0x437d
movq %r14, %rdi
callq 0x2030
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/findstr[P]version-database/dir.c
// Function: scan_r
static void
scan_r(const char *prefix, struct args *args)
{
	DIR *dir;
	struct stat st;
	struct dirent *ent;
	dir = scanbegin(prefix);
	while ((ent = readdir(dir))) {
		char buf[PATH_MAX];
		if (ent->d_name[0] == '.')
			continue;
		snprintf(buf, PATH_MAX, "%s/%s", prefix, ent->d_name);
		stat(buf, &st);
		if (S_ISDIR(st.st_mode)) {
			scan_r(buf, args);
		} else if (S_ISREG(st.st_mode)) {
			args->list[args->num++] = dr_newstr(buf + args->prefix);
			if (args->num >= args->cap) {
				int size;
				args->cap *= 2;
				size = args->cap * sizeof(dr_t);
				args->list = realloc(args->list, size);
			}
		}
	}
	scanend(dir);
	return ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1098, %rsp           # imm = 0x1098
movq %rsi, %r14
movq %rdi, %rbx
callq 0x20d0
testq %rax, %rax
je 0x44db
movq %rax, %r15
leaq 0x4209(%rip), %r12      # 0x85e2
leaq -0x10c0(%rbp), %r13
movq %rax, -0x30(%rbp)
movq %r15, %rdi
callq 0x21e0
testq %rax, %rax
je 0x44c1
cmpb $0x2e, 0x13(%rax)
je 0x43e4
addq $0x13, %rax
movl $0x1000, %esi           # imm = 0x1000
movq %r13, %rdi
movq %r12, %rdx
movq %rbx, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0x2120
movq %r13, %rdi
leaq -0xc0(%rbp), %rsi
callq 0x21a0
movl -0xa8(%rbp), %eax
movl $0xf000, %ecx           # imm = 0xF000
andl %ecx, %eax
movl %eax, %ecx
negw %cx
jo 0x444e
cmpl $0x4000, %eax           # imm = 0x4000
jne 0x43e4
movq %r13, %rdi
movq %r14, %rsi
callq 0x43a7
jmp 0x43e4
movslq 0x8(%r14), %rax
movq %r13, %r15
movq %rbx, %r13
movq %r12, %rbx
leaq (%rax,%rbp), %r12
addq $-0x10c0, %r12          # imm = 0xEF40
movq %r12, %rdi
callq 0x20e0
movl %eax, %edi
movq %r12, %rsi
movq %rbx, %r12
movq %r13, %rbx
movq %r15, %r13
movq -0x30(%rbp), %r15
callq 0x470e
movq 0x10(%r14), %rcx
movslq (%r14), %rdx
leal 0x1(%rdx), %esi
movl %esi, (%r14)
movq %rax, (%rcx,%rdx,8)
movl 0x4(%r14), %eax
cmpl %eax, %esi
jl 0x43e4
leal (%rax,%rax), %ecx
movl %ecx, 0x4(%r14)
shll $0x4, %eax
movq 0x10(%r14), %rdi
movslq %eax, %rsi
callq 0x2210
movq %rax, 0x10(%r14)
jmp 0x43e4
movq %r15, %rdi
callq 0x2150
addq $0x1098, %rsp           # imm = 0x1098
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x6b16(%rip), %rax      # 0xaff8
movq (%rax), %r14
callq 0x2050
movq %rax, %r15
movl (%rax), %edi
callq 0x22a0
leaq 0x40ed(%rip), %rsi      # 0x85e8
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x2190
movl (%r15), %edi
callq 0x2270
// File: /workspace/github_c_makefile_star2_O2/findstr[P]version-database/dir.c
// Function: dir_ensure
void
dir_ensure(const char *path)
{
	char buf[PATH_MAX];
	char *p, *s, *e;
	strcpy(buf, path);
	path = buf;
	p = s = (char *)path;
	errno = 0;
	while ((e = strchr(s+1, '/'))) {
		int ret;
		*e = 0;
		errno = 0;
		ret = MKDIR(p);
		if (ret == -1 && errno != EEXIST) {
			fprintf(stderr, "mkdir '%s' %s\n", p, strerror(errno));
			exit(errno);
		}
		*e = '/';
		s = e + 1;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1000, %rsp           # imm = 0x1000
movq %rdi, %rsi
leaq -0x1020(%rbp), %r14
movq %r14, %rdi
callq 0x2080
callq 0x2050
movq %rax, %rbx
andl $0x0, (%rax)
pushq $0x2f
popq %r15
movq %r14, %r12
incq %r12
movq %r12, %rdi
movl %r15d, %esi
callq 0x2100
testq %rax, %rax
je 0x45c4
movq %rax, %r12
movb $0x0, (%rax)
andl $0x0, (%rbx)
movq %r14, %rdi
movl $0x1ed, %esi            # imm = 0x1ED
callq 0x2090
cmpl $-0x1, %eax
jne 0x45ba
movl (%rbx), %edi
cmpl $0x11, %edi
jne 0x45d4
movb $0x2f, (%r12)
incq %r12
jmp 0x4585
addq $0x1000, %rsp           # imm = 0x1000
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x6a1d(%rip), %rax      # 0xaff8
movq (%rax), %r14
callq 0x22a0
leaq 0x3f0b(%rip), %rsi      # 0x84f5
leaq -0x1020(%rbp), %rdx
movq %r14, %rdi
movq %rax, %rcx
xorl %eax, %eax
callq 0x2190
movl (%rbx), %edi
callq 0x2270
// File: /workspace/github_c_makefile_star2_O2/findstr[P]version-database/dir.c
// Function: dir_readfile
dr_t
dir_readfile(const char *path, dr_t root)
{
	int fd;
	dr_t content;
	char buf[PATH_MAX];
	struct stat stat;
	path = changedir(buf, path, root);
	fd = open(path, O_RDONLY | O_BINARY);
	if (fd < 0)
		return NULL;
	fstat(fd, &stat);
	content = dr_new(stat.st_size, NULL);
	read(fd, content->buf, stat.st_size);
	close(fd);
	return content;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1098, %rsp           # imm = 0x1098
movq %rsi, %rdx
movq %rdi, %rsi
leaq -0x10b0(%rbp), %rdi
callq 0x4684
xorl %r14d, %r14d
movq %rax, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x2230
testl %eax, %eax
js 0x4673
movl %eax, %ebx
leaq -0xa8(%rbp), %r14
movl %eax, %edi
movq %r14, %rsi
callq 0x22b0
movq 0x30(%r14), %r15
movl %r15d, %edi
xorl %esi, %esi
callq 0x470e
movq %rax, %r14
leaq 0x8(%rax), %rsi
movl %ebx, %edi
movq %r15, %rdx
callq 0x2160
movl %ebx, %edi
callq 0x2140
movq %r14, %rax
addq $0x1098, %rsp           # imm = 0x1098
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/findstr[P]version-database/dir.c
// Function: changedir
static const char *
changedir(char buf[PATH_MAX], const char *path, dr_t root)
{
	if (root != NULL) {
		int n = strlen(path);
		int sz = root->size;
		memcpy(buf, root->buf, sz);
		if (buf[sz-1] != '/') {
			buf[sz] = '/';
			sz += 1;
		}
		memcpy(&buf[sz], path, n);
		buf[sz + n] = 0;
		path = buf;
	}
	return path;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
testq %rdx, %rdx
je 0x46f9
movq %rdx, %r13
movq %rdi, %rbx
movq %r14, %rdi
callq 0x20e0
movq %rax, -0x30(%rbp)
movl 0x4(%r13), %r15d
movslq %r15d, %r12
addq $0x8, %r13
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x21c0
cmpb $0x2f, -0x1(%rbx,%r12)
je 0x46d8
movb $0x2f, (%rbx,%r12)
incq %r12
movl %r12d, %r15d
addq %rbx, %r12
movq -0x30(%rbp), %r13
movslq %r13d, %rdx
movq %r12, %rdi
movq %r14, %rsi
callq 0x21c0
addl %r13d, %r15d
movslq %r15d, %rax
movb $0x0, (%rbx,%rax)
jmp 0x46fc
movq %r14, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/findstr[P]version-database/dir.c
// Function: dir_writefile
void
dir_writefile(const char *path, dr_t d, dr_t root)
{
	int fd, ret;
	char buf[PATH_MAX];
	path = changedir(buf, path, root);
	dir_ensure(path);
	fd = open(path, O_CREAT | O_RDWR | O_TRUNC | O_BINARY, 0644);
	if (fd < 0) {
		fprintf(stderr, "FATAL: write %s errno:%s\n",
			path, strerror(errno));
		exit(errno);
	}
	ret = write(fd, d->buf, d->size);
	assert(ret == d->size);
	close(fd);
	return ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1008, %rsp           # imm = 0x1008
movq %rsi, %rbx
movq %rdi, %rsi
leaq -0x1020(%rbp), %rdi
callq 0x4684
movq %rax, %r14
movq %rax, %rdi
callq 0x454f
movq %r14, %rdi
movl $0x242, %esi            # imm = 0x242
movl $0x1a4, %edx            # imm = 0x1A4
xorl %eax, %eax
callq 0x2230
testl %eax, %eax
js 0x47d0
movl %eax, %r15d
leaq 0x8(%rbx), %rsi
movslq 0x4(%rbx), %rdx
movl %eax, %edi
callq 0x20c0
cmpl %eax, 0x4(%rbx)
jne 0x4808
movl %r15d, %edi
callq 0x2140
addq $0x1008, %rsp           # imm = 0x1008
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x6821(%rip), %rax      # 0xaff8
movq (%rax), %rbx
callq 0x2050
movq %rax, %r15
movl (%rax), %edi
callq 0x22a0
leaq 0x3d14(%rip), %rsi      # 0x8504
movq %rbx, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x2190
movl (%r15), %edi
callq 0x2270
leaq 0x3d0f(%rip), %rdi      # 0x851e
leaq 0x3d17(%rip), %rsi      # 0x852d
leaq 0x3d16(%rip), %rcx      # 0x8533
movl $0xa4, %edx
callq 0x2130
// File: /workspace/github_c_makefile_star2_O2/findstr[P]version-database/dir.c
// Function: dir_rename
void
dir_rename(const char *from, const char *to, dr_t root)
{
	int ret;
	char fbuf[PATH_MAX], tbuf[PATH_MAX];
	from = changedir(fbuf, from, root);
	to = changedir(tbuf, to, root);
	dir_ensure(to);
	ret = rename(from, to);
	assert(ret == 0);
	return ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x2008, %rsp           # imm = 0x2008
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %rsi
leaq -0x2020(%rbp), %rdi
callq 0x4684
movq %rax, %r15
leaq -0x1020(%rbp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x4684
movq %rax, %rbx
movq %rax, %rdi
callq 0x454f
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2240
testl %eax, %eax
jne 0x4889
addq $0x2008, %rsp           # imm = 0x2008
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3cd0(%rip), %rdi      # 0x8560
leaq 0x3c96(%rip), %rsi      # 0x852d
leaq 0x3ccb(%rip), %rcx      # 0x8569
movl $0xb2, %edx
callq 0x2130
// File: /workspace/github_c_makefile_star2_O2/findstr[P]version-database/dir.c
// Function: dir_movdir
void
dir_movdir(dr_t from, dr_t to)
{
	int i, n, ret;
	int flen, tlen;
	dr_t *list;
	char buf[PATH_MAX];
	n = dir_scan(str(from), &list, 0);
	flen = from->size;
	tlen = to->size;
	memcpy(buf, to->buf, tlen);
	for (i = 0; i < n; i++) {
		dr_t d = list[i];
		memcpy(&buf[tlen], &d->buf[flen], d->size - flen);
		buf[d->size - flen + tlen] = 0;
		dir_ensure(buf);
		ret = remove(buf);
		assert(ret == 0 || (ret == -1 && errno == ENOENT));
		ret = rename((char *)d->buf, buf);
		assert(ret == 0);
		dr_unref(d);
	}
	free(list);
	return ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1028, %rsp           # imm = 0x1028
movq %rsi, %r15
movq %rdi, %rbx
addq $0x8, %rdi
leaq -0x48(%rbp), %rsi
xorl %r12d, %r12d
xorl %edx, %edx
callq 0x4300
movl %eax, %r14d
movslq 0x4(%rbx), %rbx
movslq 0x4(%r15), %r13
addq $0x8, %r15
movq %r15, %rsi
leaq -0x1050(%rbp), %r15
movq %r15, %rdi
movq %r13, %rdx
callq 0x21c0
movq %r13, -0x38(%rbp)
leaq -0x1050(,%r13), %rax
addq %rbp, %rax
movq %rax, -0x30(%rbp)
testl %r14d, %r14d
cmovlel %r12d, %r14d
movq %r14, -0x40(%rbp)
movq -0x48(%rbp), %rdi
cmpq %r12, -0x40(%rbp)
je 0x49bc
movq (%rdi,%r12,8), %r13
leaq (%rbx,%r13), %rsi
addq $0x8, %rsi
movslq 0x4(%r13), %r14
subq %rbx, %r14
movq -0x30(%rbp), %rdi
movq %r14, %rdx
callq 0x21c0
movslq %r14d, %rax
addq -0x38(%rbp), %rax
movb $0x0, -0x1050(%rbp,%rax)
movq %r15, %rdi
callq 0x454f
movq %r15, %rdi
callq 0x2060
testl %eax, %eax
je 0x499f
cmpl $-0x1, %eax
jne 0x49f2
callq 0x2050
cmpl $0x2, (%rax)
jne 0x49f2
leaq 0x8(%r13), %rdi
movq %r15, %rsi
callq 0x2240
testl %eax, %eax
jne 0x49d3
movq %r13, %rdi
callq 0x4513
incq %r12
jmp 0x4944
callq 0x2030
addq $0x1028, %rsp           # imm = 0x1028
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3b86(%rip), %rdi      # 0x8560
leaq 0x3b4c(%rip), %rsi      # 0x852d
leaq 0x3bde(%rip), %rcx      # 0x85c6
movl $0xd2, %edx
callq 0x2130
leaq 0x3ba2(%rip), %rdi      # 0x859b
leaq 0x3b2d(%rip), %rsi      # 0x852d
leaq 0x3bbf(%rip), %rcx      # 0x85c6
movl $0xd0, %edx
callq 0x2130
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/findstr[P]version-database/db.c
// Function: db_hash
dr_t
db_hash(dr_t d)
{
	int i;
	char *p;
	dr_t hash;
	uint8_t digest[HASH_SIZE];
	HASH_CTX ctx;
	hash = dr_new(HASH_SIZE * 2, NULL);
	HASH_Init(&ctx);
	HASH_Update(&ctx, d->buf, d->size);
	HASH_Final(digest, &ctx);
	p = (char *)hash->buf;
	for (i = 0; i < HASH_SIZE; i++) {
		sprintf(p, "%02x", digest[i]);
		p += 2;
	}
	return hash;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rdi, %r14
pushq $0x28
popq %rdi
callq 0x4aa8
movq %rax, %rbx
leaq -0xa0(%rbp), %r15
movq %r15, %rdi
callq 0x659c
movslq 0x4(%r14), %rdx
addq $0x8, %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x65b8
leaq -0x40(%rbp), %rdi
movq %r15, %rsi
callq 0x792f
movq %rbx, %r14
addq $0x8, %r14
leaq 0x3b95(%rip), %r15      # 0x8605
xorl %r12d, %r12d
cmpq $0x14, %r12
je 0x4a95
movzbl -0x40(%rbp,%r12), %edx
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x2260
addq $0x2, %r14
incq %r12
jmp 0x4a73
movq %rbx, %rax
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/findstr[P]version-database/db.c
// Function: db_tryread
dr_t
db_tryread(dr_t name)
{
	const char *p;
	dr_t d, full;
	char path[PATH_MAX];
	full = fullname(name);
	p = (char *)full->buf;
	snprintf(path, PATH_MAX, ROOT"/%c%c/%s", p[0], p[1], &p[2]);
	d = dir_readfile(path, NULL);
	if (d != NULL) {
		dr_t hash = db_hash(d);
		if (dr_cmp(hash, full) != 0) {
			fprintf(stderr, "FATAL:db_read %s content was corrupt\n",
				name->buf);
			exit(EFAULT);
		}
		dr_unref(hash);
	}
	dr_unref(full);
	return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1038, %rsp           # imm = 0x1038
movq %rdi, %rbx
movslq 0x4(%rdi), %r15
cmpq $0x28, %r15
movq %rdi, -0x38(%rbp)
jl 0x4afe
incl (%rbx)
movq %rbx, %r15
jmp 0x4bee
movsbl 0x8(%rbx), %ecx
movsbl 0x9(%rbx), %r8d
leaq 0x3c33(%rip), %rdx      # 0x8741
xorl %r14d, %r14d
leaq -0x1060(%rbp), %rdi
movl $0x1000, %esi           # imm = 0x1000
xorl %eax, %eax
callq 0x2120
cmpl $0x1000, %eax           # imm = 0x1000
jge 0x4cb2
leaq 0x8(%rbx), %rax
movq %rax, -0x40(%rbp)
leaq -0x1060(%rbp), %rdi
leaq -0x58(%rbp), %rsi
pushq $0x1
popq %rdx
callq 0x4300
leaq 0xa(%rbx), %rcx
movq %rcx, -0x48(%rbp)
addq $-0x2, %r15
testl %eax, %eax
cmovlel %r14d, %eax
movq %rax, -0x50(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x58(%rbp), %rdi
cmpq %r14, -0x50(%rbp)
je 0x4be5
movq (%rdi,%r14,8), %r12
cmpl %r15d, 0x4(%r12)
jge 0x4b92
leaq 0x8(%r12), %rdi
movq -0x48(%rbp), %rsi
movq %r15, %rdx
callq 0x2200
testl %eax, %eax
jne 0x4bd8
cmpq $0x0, -0x30(%rbp)
jne 0x4c6a
leaq 0x8(%r12), %rbx
movq %rbx, %rdi
callq 0x20e0
movq %rax, %r13
leal 0x2(%rax), %edi
callq 0x4aa8
movq -0x38(%rbp), %rcx
movb 0x8(%rcx), %dl
movb %dl, 0x8(%rax)
movb 0x9(%rcx), %cl
movb %cl, 0x9(%rax)
movq %rax, -0x30(%rbp)
leaq 0xa(%rax), %rdi
movslq %r13d, %rdx
movq %rbx, %rsi
callq 0x21c0
movq %r12, %rdi
callq 0x4cf5
incq %r14
jmp 0x4b68
callq 0x2030
movq -0x30(%rbp), %r15
movsbl 0x8(%r15), %ecx
movsbl 0x9(%r15), %r8d
leaq 0xa(%r15), %r9
leaq 0x3a07(%rip), %rdx      # 0x860a
leaq -0x1060(%rbp), %rbx
movl $0x1000, %esi           # imm = 0x1000
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2120
movq %rbx, %rdi
xorl %esi, %esi
callq 0x4605
movq %rax, %r14
testq %rax, %rax
je 0x4c4d
movq %r14, %rdi
callq 0x4a14
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
callq 0x4ccf
testl %eax, %eax
jne 0x4c8e
movq %r12, %rdi
callq 0x4cf5
movq %r15, %rdi
callq 0x4cf5
movq %r14, %rax
addq $0x1038, %rsp           # imm = 0x1038
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x6387(%rip), %rax      # 0xaff8
movq (%rax), %rdi
leaq 0x3b00(%rip), %rsi      # 0x877b
movq -0x40(%rbp), %rdx
xorl %eax, %eax
callq 0x2190
pushq $0x16
popq %rdi
callq 0x2270
movq 0x6363(%rip), %rax      # 0xaff8
movq (%rax), %rdi
movq -0x38(%rbp), %rdx
addq $0x8, %rdx
leaq 0x3977(%rip), %rsi      # 0x861e
xorl %eax, %eax
callq 0x2190
pushq $0xe
jmp 0x4c88
leaq 0x3a9a(%rip), %rdi      # 0x8753
leaq 0x3aa2(%rip), %rsi      # 0x8762
leaq 0x3aa0(%rip), %rcx      # 0x8767
pushq $0x33
popq %rdx
callq 0x2130
// File: /workspace/github_c_makefile_star2_O2/findstr[P]version-database/db.c
// Function: db_read
dr_t
db_read(dr_t name)
{
	dr_t d;
	d = db_tryread(name);
	if (d == NULL) {
		fprintf(stderr, "FATAL:db_read %s errno:%s\n",
			name->buf, strerror(errno));
		exit(errno);
	}
	return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x4acf
testq %rax, %rax
je 0x4d53
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x629e(%rip), %rax      # 0xaff8
movq (%rax), %r14
addq $0x8, %rbx
callq 0x2050
movq %rax, %r15
movl (%rax), %edi
callq 0x22a0
leaq 0x38cd(%rip), %rsi      # 0x8644
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x2190
movl (%r15), %edi
callq 0x2270
// File: /workspace/github_c_makefile_star2_O2/findstr[P]version-database/db.c
// Function: db_write
dr_t
db_write(dr_t name, dr_t d)
{
	dr_t hash, read;
	int n, ret;
	char path[PATH_MAX] ;
	hash = db_hash(d);
	read = db_tryread(hash);
	if (read) {
		int same;
		same = dr_cmp(d, read);
		dr_unref(read);
		if (same != 0) {
			fprintf(stderr, "FATAL:db_write %s hash conflict:%s\n",
				name->buf, hash->buf);
			exit(EEXIST);
		}
	} else {
		char *p;
		p = (char *)hash->buf;
		n = sprintf(path, ROOT"/%c%c", p[0], p[1]);
		ret = MKDIR(path);
		if (ret == -1 && errno != EEXIST) {
			fprintf(stderr, "FATAL:db_write %s hash %s errno:%s\n",
				path, p, strerror(errno));
			exit(errno);
		}
		sprintf(&path[n], "/%s", &p[2]);
		dir_writefile(path, d, NULL);
	}
	return hash;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1000, %rsp           # imm = 0x1000
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
callq 0x4a14
movq %rax, %rbx
movq %rax, %rdi
callq 0x4acf
testq %rax, %rax
je 0x4e0f
movq %rax, %r12
movq %r14, %rdi
movq %rax, %rsi
callq 0x4ccf
movl %eax, %r14d
movq %r12, %rdi
callq 0x4cf5
testl %r14d, %r14d
je 0x4e84
movq 0x6210(%rip), %rax      # 0xaff8
movq (%rax), %rdi
addq $0x8, %r15
addq $0x8, %rbx
leaq 0x3865(%rip), %rsi      # 0x865f
movq %r15, %rdx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2190
pushq $0x11
popq %rdi
callq 0x2270
movsbl 0x8(%rbx), %edx
movsbl 0x9(%rbx), %ecx
leaq 0x3865(%rip), %rsi      # 0x8683
leaq -0x1020(%rbp), %r15
movq %r15, %rdi
xorl %eax, %eax
callq 0x2260
movl %eax, %r12d
movq %r15, %rdi
movl $0x1ed, %esi            # imm = 0x1ED
callq 0x2090
cmpl $-0x1, %eax
jne 0x4e50
callq 0x2050
movl (%rax), %edi
cmpl $0x11, %edi
jne 0x4e97
movslq %r12d, %rax
leaq (%rax,%rbp), %rdi
addq $-0x1020, %rdi          # imm = 0xEFE0
movq %rbx, %rdx
addq $0xa, %rdx
leaq 0x37ae(%rip), %rsi      # 0x861a
xorl %eax, %eax
callq 0x2260
leaq -0x1020(%rbp), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x475e
movq %rbx, %rax
addq $0x1000, %rsp           # imm = 0x1000
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
addq $0x8, %rbx
movq 0x6153(%rip), %rax      # 0xaff8
movq (%rax), %r14
callq 0x22a0
leaq 0x37e0(%rip), %rsi      # 0x8694
leaq -0x1020(%rbp), %rdx
movq %r14, %rdi
movq %rbx, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0x2190
movl (%r15), %edi
callq 0x2270
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
leaq 0x3776(%rip), %rdi      # 0x86b8
xorl %esi, %esi
callq 0x4605
testq %rax, %rax
je 0x4f6f
movq %rax, %rbx
movq %r15, %rdi
movq %rax, %rsi
callq 0x4ed3
testq %r14, %r14
je 0x4f93
movq 0x10(%r15), %rsi
movq %r14, %rdi
callq 0x4eff
jmp 0x4f93
xorl %edi, %edi
callq 0x4aa8
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
movups %xmm0, 0x10(%r15)
movups %xmm0, 0x20(%r15)
testq %r14, %r14
je 0x4f93
movups %xmm0, (%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x5534
movq %rax, %r14
movq 0x18(%rbx), %rdi
movq %rax, %rsi
callq 0x4d8f
movq %rax, %rbx
leaq 0x36ef(%rip), %rdi      # 0x86b8
movq %rax, %rsi
xorl %edx, %edx
callq 0x475e
movq %r14, %rdi
callq 0x4cf5
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %r14
leaq 0x8(%rdi), %rbx
leaq 0x36ba(%rip), %rsi      # 0x86bc
pushq $0x4
popq %rdx
movq %rbx, %rdi
callq 0x2070
testl %eax, %eax
je 0x501e
testq %r14, %r14
je 0x5095
incl (%r14)
jmp 0x50cc
xorl %r15d, %r15d
cmpb $0x7e, 0xc(%r14)
jne 0x503e
leaq 0xd(%r14), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x21b0
movq %rax, %r15
cmpl $-0x1, %r15d
je 0x5016
leaq -0x58(%rbp), %rdi
xorl %esi, %esi
callq 0x4f2b
cmpl $0x0, 0x4(%rax)
je 0x50de
movq %rax, %r12
xorl %r14d, %r14d
leaq -0x58(%rbp), %r13
subl $0x1, %r15d
jb 0x509a
movq %r12, %rdi
callq 0x4cf5
movq -0x50(%rbp), %r12
testq %r12, %r12
je 0x5078
incl (%r12)
cmpl $0x0, 0x4(%r12)
je 0x50a1
movq %r13, %rdi
callq 0x5725
movq %r13, %rdi
movq %r12, %rsi
callq 0x4ed3
jmp 0x505d
xorl %r14d, %r14d
jmp 0x50cc
incl (%r12)
movq %r12, %r14
movq %r12, %rdi
callq 0x4cf5
leaq -0x58(%rbp), %rdi
callq 0x5725
testq %r14, %r14
je 0x50fc
leaq 0x8(%r14), %rdx
leaq 0x362a(%rip), %rdi      # 0x86ec
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2110
movq %r14, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x5f13(%rip), %rax      # 0xaff8
movq (%rax), %rcx
leaq 0x35d2(%rip), %rdi      # 0x86c1
pushq $0x10
popq %rsi
pushq $0x1
popq %rdx
callq 0x2280
jmp 0x5117
movq 0x5ef5(%rip), %rax      # 0xaff8
movq (%rax), %rdi
leaq 0x35c5(%rip), %rsi      # 0x86d2
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2190
pushq $0x16
popq %rdi
callq 0x2270
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
leaq 0x35d0(%rip), %rdi      # 0x86fd
movl $0x1ed, %esi            # imm = 0x1ED
callq 0x2090
testl %eax, %eax
jne 0x5155
leaq 0x35bf(%rip), %rdi      # 0x8701
movl $0x1ed, %esi            # imm = 0x1ED
callq 0x2090
testl %eax, %eax
jne 0x5155
popq %rbx
popq %r14
popq %rbp
retq
callq 0x2050
movq %rax, %rbx
movl (%rax), %edi
movq 0x5e92(%rip), %rax      # 0xaff8
movq (%rax), %r14
cmpl $0x11, %edi
jne 0x5185
leaq 0x3598(%rip), %rdi      # 0x870d
pushq $0x1d
popq %rsi
pushq $0x1
popq %rdx
movq %r14, %rcx
callq 0x2280
jmp 0x519e
callq 0x22a0
leaq 0x359a(%rip), %rsi      # 0x872b
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x2190
movl (%rbx), %edi
callq 0x2270
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movq 0x8(%rdi), %r12
movl (%rdi), %ecx
xorl %eax, %eax
testl %ecx, %ecx
cmovlel %eax, %ecx
imulq $0x18, %rcx, %rcx
pushq $0x8
popq %rdi
cmpq %rax, %rcx
je 0x5247
movq (%r12,%rax), %rdx
movq 0x8(%r12,%rax), %rsi
movl 0x4(%rsi), %esi
addl 0x4(%rdx), %edi
addl %esi, %edi
addl $0x8, %edi
addq $0x18, %rax
jmp 0x5228
xorl %r13d, %r13d
xorl %esi, %esi
callq 0x52ee
movq %rax, %rbx
movl $0x45455254, 0x8(%rax)  # imm = 0x45455254
movl (%r14), %eax
movl %eax, 0xc(%rbx)
movq %rbx, -0x30(%rbp)
addq $0x10, %rbx
testl %eax, %eax
movl $0x0, %ecx
cmovgl %eax, %ecx
imulq $0x18, %rcx, %rax
movq %rax, -0x38(%rbp)
cmpq %r13, -0x38(%rbp)
je 0x52db
movq (%r12,%r13), %rsi
movslq 0x4(%rsi), %r14
movl %r14d, (%rbx)
leaq 0x4(%rbx), %rdi
addq $0x8, %rsi
movq %r14, %rdx
callq 0x21c0
leaq (%rbx,%r14), %rax
addq $0x4, %rax
movq %rax, -0x40(%rbp)
movq 0x8(%r12,%r13), %rsi
movslq 0x4(%rsi), %r15
leaq (%rbx,%r14), %rdi
addq $0x8, %rdi
movl %r15d, -0x4(%rdi)
addq $0x8, %rsi
movq %r15, %rdx
callq 0x21c0
movq -0x40(%rbp), %rax
leaq (%r15,%rax), %rbx
addq $0x4, %rbx
addq $0x18, %r13
jmp 0x527b
movq -0x30(%rbp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
cmpl $0x45455254, 0x8(%rsi)  # imm = 0x45455254
jne 0x53fb
movq %rsi, %r14
movq %rdi, %r12
movl 0xc(%rsi), %r15d
movl %r15d, (%rdi)
addq $0x10, %r14
imull $0x18, %r15d, %eax
movslq %eax, %rsi
pushq $0x1
popq %rdi
callq 0x2170
movq %rax, 0x8(%r12)
pushq $0x8
popq %r13
xorl %ecx, %ecx
movslq %r15d, %rax
cmpq %rax, %rcx
jge 0x53ec
movq 0x8(%r12), %rbx
movslq (%r14), %r15
leaq 0x4(%r14), %rsi
movl %r15d, %edi
movq %rcx, -0x38(%rbp)
callq 0x52ee
movq %rax, -0x8(%rbx,%r13)
leaq (%r14,%r15), %rax
addq $0x4, %rax
movq %rax, -0x30(%rbp)
leaq (%r14,%r15), %rsi
addq $0x8, %rsi
movslq -0x4(%rsi), %r14
movl %r14d, %edi
callq 0x52ee
movq -0x38(%rbp), %rcx
movq %rax, (%rbx,%r13)
movq -0x30(%rbp), %rax
addq %rax, %r14
addq $0x4, %r14
incq %rcx
movl (%r12), %r15d
addq $0x18, %r13
jmp 0x5387
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3395(%rip), %rdi      # 0x8797
leaq 0x339b(%rip), %rsi      # 0x87a4
leaq 0x339d(%rip), %rcx      # 0x87ad
pushq $0x5e
popq %rdx
callq 0x2130
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
pushq $0x10
popq %r15
xorl %r12d, %r12d
movslq (%rbx), %rax
movq 0x8(%rbx), %r14
cmpq %rax, %r12
jge 0x545f
movq -0x10(%r14,%r15), %rdi
callq 0x5755
movq -0x8(%r14,%r15), %rdi
callq 0x5755
movq (%r14,%r15), %rdi
callq 0x5755
incq %r12
addq $0x18, %r15
jmp 0x542d
movq %r14, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2030
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movslq (%rsi), %r15
movl %r15d, (%rdi)
imulq $0x18, %r15, %rdi
callq 0x21f0
movq %rax, 0x8(%r14)
xorl %ecx, %ecx
testl %r15d, %r15d
movl $0x0, %edx
cmovgl %r15d, %edx
imulq $0x18, %rdx, %rdx
cmpq %rcx, %rdx
je 0x5529
movq 0x8(%rbx), %rsi
movq (%rsi,%rcx), %rdi
testq %rdi, %rdi
je 0x54fd
incl (%rdi)
movq %rdi, (%rax,%rcx)
movq 0x8(%rsi,%rcx), %rdi
testq %rdi, %rdi
je 0x550d
incl (%rdi)
movq %rdi, 0x8(%rax,%rcx)
movq 0x10(%rsi,%rcx), %rsi
testq %rsi, %rsi
je 0x551e
incl (%rsi)
movq %rsi, 0x10(%rax,%rcx)
addq $0x18, %rcx
jmp 0x54e9
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/findstr[P]version-database/object.c
// Function: release_marshal
dr_t
release_marshal(struct release *r)
{
	dr_t d;
	int sz;
	uint8_t *ptr;
	sz =	4 +				//type
		sizeof(uint64_t) +		//time
		4 + r->prev->size +		//prev
		4 + r->tree->size +		//tree
		4 + r->ver->size +		//ver
		4 + r->note->size +		//note
		4 + r->finger->size;		//finger
	d = dr_new(sz, NULL);
	ptr = d->buf;
	*(uint32_t *)ptr = RELEASE;			ptr += 4;
	*(uint64_t *)ptr = r->time;			ptr += sizeof(uint64_t);
	*(uint32_t *)ptr = r->prev->size;		ptr += 4;
	memcpy(ptr, r->prev->buf, r->prev->size);	ptr += r->prev->size;
	*(uint32_t *)ptr = r->tree->size;		ptr += 4;
	memcpy(ptr, r->tree->buf, r->tree->size);	ptr += r->tree->size;
	*(uint32_t *)ptr = r->ver->size;		ptr += 4;
	memcpy(ptr, r->ver->buf, r->ver->size);		ptr += r->ver->size;
	*(uint32_t *)ptr = r->note->size;		ptr += 4;
	memcpy(ptr, r->note->buf, r->note->size);	ptr += r->note->size;
	*(uint32_t *)ptr = r->finger->size;		ptr += 4;
	memcpy(ptr, r->finger->buf, r->finger->size);
	return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rcx
movl 0x4(%rax), %eax
movq 0x18(%rdi), %rdx
movq 0x20(%rdi), %rsi
movq 0x28(%rdi), %rdi
addl 0x4(%rcx), %eax
addl 0x4(%rdx), %eax
movl 0x4(%rdi), %ecx
addl 0x4(%rsi), %eax
leal (%rcx,%rax), %edi
addl $0x20, %edi
xorl %esi, %esi
callq 0x52ee
movq %rax, %r14
movl $0x204c4552, 0x8(%rax)  # imm = 0x204C4552
movq (%rbx), %rax
movq %rax, 0xc(%r14)
movq 0x8(%rbx), %rsi
movslq 0x4(%rsi), %r15
movl %r15d, 0x14(%r14)
leaq 0x18(%r14), %rdi
addq $0x8, %rsi
movq %r15, %rdx
callq 0x21c0
leaq (%r14,%r15), %r13
addq $0x18, %r13
movq 0x10(%rbx), %rsi
movslq 0x4(%rsi), %r12
leaq (%r14,%r15), %rdi
addq $0x1c, %rdi
movl %r12d, -0x4(%rdi)
addq $0x8, %rsi
movq %r12, %rdx
callq 0x21c0
leaq (%r12,%r13), %rax
addq $0x4, %rax
movq %rax, -0x30(%rbp)
movq 0x18(%rbx), %rsi
movslq 0x4(%rsi), %r15
leaq (%r12,%r13), %rdi
addq $0x8, %rdi
movl %r15d, -0x4(%rdi)
addq $0x8, %rsi
movq %r15, %rdx
callq 0x21c0
movq -0x30(%rbp), %rax
leaq (%r15,%rax), %r13
addq $0x4, %r13
movq 0x20(%rbx), %rsi
movslq 0x4(%rsi), %r12
leaq (%r15,%rax), %rdi
addq $0x8, %rdi
movl %r12d, -0x4(%rdi)
addq $0x8, %rsi
movq %r12, %rdx
callq 0x21c0
movq 0x28(%rbx), %rsi
movslq 0x4(%rsi), %rdx
leaq (%r12,%r13), %rdi
addq $0x8, %rdi
movl %edx, -0x4(%rdi)
addq $0x8, %rsi
callq 0x21c0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpl $0x204c4552, 0x8(%rsi)  # imm = 0x204C4552
jne 0x5706
movq %rsi, %r14
movq %rdi, %rbx
movq 0xc(%rsi), %rax
movq %rax, (%rdi)
movslq 0x14(%rsi), %r15
addq $0x18, %rsi
movl %r15d, %edi
callq 0x52ee
movq %rax, 0x8(%rbx)
leaq (%r14,%r15), %r12
addq $0x18, %r12
leaq (%r14,%r15), %rsi
addq $0x1c, %rsi
movslq -0x4(%rsi), %r14
movl %r14d, %edi
callq 0x52ee
movq %rax, 0x10(%rbx)
leaq (%r14,%r12), %r15
addq $0x4, %r15
leaq (%r14,%r12), %rsi
addq $0x8, %rsi
movslq -0x4(%rsi), %r14
movl %r14d, %edi
callq 0x52ee
movq %rax, 0x18(%rbx)
leaq (%r14,%r15), %r12
addq $0x4, %r12
leaq (%r14,%r15), %rsi
addq $0x8, %rsi
movslq -0x4(%rsi), %r14
movl %r14d, %edi
callq 0x52ee
movq %rax, 0x20(%rbx)
leaq (%r14,%r12), %rsi
addq $0x8, %rsi
movl -0x4(%rsi), %edi
callq 0x52ee
movq %rax, 0x28(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x30c9(%rip), %rdi      # 0x87d6
leaq 0x3090(%rip), %rsi      # 0x87a4
leaq 0x30cb(%rip), %rcx      # 0x87e6
movl $0xb2, %edx
callq 0x2130
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x5755
movq 0x10(%rbx), %rdi
callq 0x5755
movq 0x18(%rbx), %rdi
callq 0x5755
movq 0x20(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5755
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x10
popq %rsi
callq 0x57ee
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x5813
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x5867
movq (%rbx), %rsi
movq 0x8(%rbx), %rax
addq $0x8, %rsi
cvtsi2ssl 0x4(%rax), %xmm0
mulss 0x3040(%rip), %xmm0     # 0x8818
cvtss2sd %xmm0, %xmm0
leaq 0x3061(%rip), %rdi      # 0x8844
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
jmp 0x2110
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl 0x4(%rsi), %esi
addl $0x2, %esi
callq 0x5c03
movq %rax, %r15
movslq 0x4(%r14), %r12
movw %r12w, (%rax)
addq $0x2, %r15
addq $0x8, %r14
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x21c0
addl %r12d, %r15d
subl 0x8(%rbx), %r15d
addl $-0x8, %r15d
movl %r15d, (%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq