LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/hughbarney[P]zepl/lisp.c
// Function: evalCond
Object *evalCond(Object ** args, Object ** env, GC_PARAM)
{
	if (*args == nil)
		return nil;
	else if ((*args)->car->type != TYPE_CONS)
		exceptionWithObject((*args)->car, "is not a list");
	else {
		GC_TRACE(gcCar, (*args)->car->car);
		GC_TRACE(gcCdr, (*args)->car->cdr);

		if ((*gcCar = evalExpr(gcCar, env, GC_ROOTS)) != nil)
			return (*gcCdr != nil) ? evalProgn(gcCdr, env, GC_ROOTS) : *gcCar;
		else {
			GC_TRACE(gcArgs, (*args)->cdr);
			return evalCond(gcArgs, env, GC_ROOTS);
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq (%rdi), %rcx
movq 0x60d5(%rip), %rax      # 0xd208
cmpq %rax, %rcx
je 0x71f4
movq %rdi, %r14
movq 0x10(%rcx), %rdi
cmpl $0x3, (%rdi)
jne 0x7200
movq %rsi, %rbx
movl $0x3, %eax
leaq 0x60(%rsp), %rdi
movl %eax, -0x10(%rdi)
xorl %esi, %esi
movq %rsi, -0x8(%rdi)
movq 0x10(%rcx), %r8
movq 0x10(%r8), %r8
movq %r8, (%rdi)
movq %rdx, 0x8(%rdi)
movq %rsp, %r15
movl %eax, (%r15)
movq %rsi, 0x8(%r15)
movq 0x10(%rcx), %rax
movq 0x18(%rax), %rax
movq %rax, 0x10(%r15)
leaq 0x50(%rsp), %r12
movq %r12, 0x18(%r15)
movq %rbx, %rsi
movq %r15, %rdx
callq 0x6c9c
movq %rax, 0x10(%r12)
movq 0x6061(%rip), %rcx      # 0xd208
cmpq %rcx, %rax
je 0x71c5
cmpq %rcx, 0x10(%rsp)
je 0x71f4
leaq 0x10(%rsp), %rdi
movq %rsp, %rdx
movq %rbx, %rsi
callq 0x703a
jmp 0x71f4
leaq 0x38(%rsp), %rdi
movl $0x3, -0x10(%rdi)
movq $0x0, -0x8(%rdi)
movq (%r14), %rax
movq 0x18(%rax), %rax
movq %rax, (%rdi)
movq %r15, 0x8(%rdi)
leaq 0x28(%rsp), %rdx
movq %rbx, %rsi
callq 0x711e
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x12f0(%rip), %rsi      # 0x84f7
xorl %eax, %eax
callq 0x4388
// File: /workspace/github_c_makefile_star2_O1/hughbarney[P]zepl/lisp.c
// Function: expandMacro
Object *expandMacro(Object ** macro, Object ** args, GC_PARAM)
{
	GC_TRACE(gcEnv, newEnv(macro, args, GC_ROOTS));
	GC_TRACE(gcBody, (*macro)->body);

	GC_TRACE(gcObject, evalProgn(gcBody, gcEnv, GC_ROOTS));
	*gcObject = evalExpr(gcObject, gcEnv, GC_ROOTS);

	return *gcObject;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rdx, %r14
movq %rdi, %r15
movl $0x3, %ebp
leaq 0x68(%rsp), %rbx
movl %ebp, -0x10(%rbx)
xorl %r12d, %r12d
movq %r12, -0x8(%rbx)
callq 0x4cea
movq %rax, (%rbx)
movq %r14, 0x8(%rbx)
leaq 0x40(%rsp), %rdi
movl %ebp, -0x10(%rdi)
movq %r12, -0x8(%rdi)
movq (%r15), %rax
movq 0x18(%rax), %rax
movq %rax, (%rdi)
leaq 0x58(%rsp), %rax
movq %rax, 0x8(%rdi)
leaq 0x18(%rsp), %r14
movl %ebp, -0x10(%r14)
movq %r12, -0x8(%r14)
leaq 0x30(%rsp), %r15
movq %rbx, %rsi
movq %r15, %rdx
callq 0x703a
movq %rax, (%r14)
movq %r15, 0x8(%r14)
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6c9c
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/hughbarney[P]zepl/lisp.c
// Function: expandMacroTo
Object *expandMacroTo(Object ** macro, Object ** args, Object ** cons, GC_PARAM)
{
	GC_TRACE(gcObject, expandMacro(macro, args, GC_ROOTS));

	if ((*gcObject)->type == TYPE_CONS) {
		(*cons)->car = (*gcObject)->car;
		(*cons)->cdr = (*gcObject)->cdr;
	} else {
		(*cons)->car = newSymbol("progn", GC_ROOTS);
		(*cons)->cdr = newCons(gcObject, &nil, GC_ROOTS);
	}

	return *cons;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r14
movq %rdx, %rbx
movl $0x3, (%rsp)
movq $0x0, 0x8(%rsp)
movq %rcx, %rdx
callq 0x72c0
movq %rax, 0x10(%rsp)
movq %r14, 0x18(%rsp)
cmpl $0x3, (%rax)
jne 0x73a2
movq 0x10(%rax), %rax
movq (%rbx), %rcx
movq %rax, 0x10(%rcx)
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
jmp 0x73e5
leaq 0x13b3(%rip), %rdi      # 0x875c
movq %rsp, %r14
movl $0x5, %esi
movq %r14, %rdx
callq 0x4ac8
movq (%rbx), %rcx
movq %rax, 0x10(%rcx)
movl $0x28, %esi
movl $0x3, %edi
movq %r14, %rdx
callq 0x481c
movq 0x10(%r14), %rcx
movq %rcx, 0x10(%rax)
movq 0x5e27(%rip), %rcx      # 0xd208
movq %rcx, 0x18(%rax)
movq (%rbx), %rcx
movq %rax, 0x18(%rcx)
movq (%rbx), %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/hughbarney[P]zepl/lisp.c
// Function: evalList
Object *evalList(Object ** args, Object ** env, GC_PARAM)
{
	if ((*args)->type != TYPE_CONS)
		return evalExpr(args, env, GC_ROOTS);
	else {
		GC_TRACE(gcObject, (*args)->car);
		GC_TRACE(gcArgs, (*args)->cdr);

		*gcObject = evalExpr(gcObject, env, GC_ROOTS);
		*gcArgs = evalList(gcArgs, env, GC_ROOTS);

		return newCons(gcObject, gcArgs, GC_ROOTS);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rbx
movq (%rdi), %rax
cmpl $0x3, (%rax)
jne 0x74a2
movl $0x3, %ecx
leaq 0x40(%rsp), %rdi
movl %ecx, -0x10(%rdi)
xorl %esi, %esi
movq %rsi, -0x8(%rdi)
movq 0x10(%rax), %r8
movq %r8, (%rdi)
movq %rdx, 0x8(%rdi)
leaq 0x18(%rsp), %r14
movl %ecx, -0x10(%r14)
movq %rsi, -0x8(%r14)
movq 0x18(%rax), %rax
movq %rax, (%r14)
leaq 0x30(%rsp), %r12
movq %r12, 0x8(%r14)
leaq 0x8(%rsp), %r15
movq %rbx, %rsi
movq %r15, %rdx
callq 0x6c9c
movq %rax, 0x10(%r12)
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x73f7
movq %rax, 0x10(%r15)
movl $0x28, %esi
movl $0x3, %edi
movq %r15, %rdx
callq 0x481c
movq 0x10(%r12), %rcx
movq %rcx, 0x10(%rax)
movq 0x10(%r15), %rcx
movq %rcx, 0x18(%rax)
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rbx, %rsi
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x6c9c
// File: /workspace/github_c_makefile_star2_O1/hughbarney[P]zepl/lisp.c
// Function: newRootEnv
Object *newRootEnv(GC_PARAM)
{
	GC_TRACE(gcEnv, newEnv(&nil, &nil, GC_ROOTS));
	GC_TRACE(gcVar, nil);
	GC_TRACE(gcVal, nil);

	// add constants
	envSet(&nil, &nil, gcEnv, GC_ROOTS);
	envSet(&t, &t, gcEnv, GC_ROOTS);

	// add primitives
	int nPrimitives = sizeof(primitives) / sizeof(primitives[0]);

	for (int i = 0; i < nPrimitives; ++i) {
		*gcVar = newSymbol(primitives[i].name, GC_ROOTS);
		*gcVal = newPrimitive(i, primitives[i].name, GC_ROOTS);

		envSet(gcVar, gcVal, gcEnv, GC_ROOTS);
	}

	// add standard library
	Stream stream = { STREAM_TYPE_STRING,.buffer = stdlib };
	GC_TRACE(gcObject, nil);

	while (peekNext(&stream) != EOF) {
		*gcObject = nil;
		*gcObject = readExpr(&stream, GC_ROOTS);
		evalExpr(gcObject, gcEnv, GC_ROOTS);
	}

	return *gcEnv;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %r14
movl $0x3, %r15d
leaq 0x88(%rsp), %r13
movl %r15d, -0x10(%r13)
xorl %ebp, %ebp
movq %rbp, -0x8(%r13)
leaq 0x5d20(%rip), %rbx      # 0xd208
movq %rbx, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x4cea
movq %rax, (%r13)
movq %r14, 0x8(%r13)
leaq 0x38(%rsp), %rdx
movl %r15d, -0x10(%rdx)
movq %rbp, -0x8(%rdx)
movq 0x5cf6(%rip), %rax      # 0xd208
movq %rax, (%rdx)
leaq 0x78(%rsp), %rcx
movq %rcx, 0x8(%rdx)
leaq 0x60(%rsp), %r12
movl %r15d, -0x10(%r12)
movq %rbp, -0x8(%r12)
movq %rax, (%r12)
leaq 0x28(%rsp), %rax
movq %rax, 0x8(%r12)
leaq 0x50(%rsp), %r14
movq %rbx, %rdi
movq %rbx, %rsi
movq %r13, %rdx
movq %r14, %rcx
callq 0x5924
leaq 0x5cb8(%rip), %rdi      # 0xd210
movq %rdi, %rsi
movq %r13, %rdx
movq %r14, %rcx
callq 0x5924
leaq 0x5cb3(%rip), %rbx      # 0xd220
movq %r13, %r15
movq (%rbx), %r13
movq %r13, %rdi
callq 0x20e0
movq %r13, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x4ac8
movq %rax, 0x38(%rsp)
movq (%rbx), %r13
movl $0x28, %esi
movl $0x6, %edi
movq %r14, %rdx
callq 0x481c
movl %ebp, 0x10(%rax)
movq %r13, 0x18(%rax)
movq %r15, %r13
movq %rax, 0x60(%rsp)
leaq 0x38(%rsp), %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x5924
incq %rbp
addq $0x18, %rbx
cmpq $0x43, %rbp
jne 0x756d
xorps %xmm0, %xmm0
leaq 0xa0(%rsp), %rdi
movaps %xmm0, (%rdi)
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x10(%rdi)
xorl %eax, %eax
movq %rax, 0x30(%rdi)
leaq 0x13df(%rip), %rcx      # 0x89d4
movq %rcx, 0x8(%rdi)
movl $0x3, (%rsp)
movq %rax, 0x8(%rsp)
movq 0x5bfc(%rip), %rax      # 0xd208
movq %rax, 0x10(%rsp)
movq %r14, 0x18(%rsp)
callq 0x5006
cmpl $-0x1, %eax
je 0x7685
leaq 0x10(%rsp), %r14
xorl %ebx, %ebx
leaq 0xa0(%rsp), %r15
movq %rsp, %r12
movq 0xc8(%rsp), %rax
leaq -0x1(%rax), %rcx
cmpq $0x2, %rax
cmovlq %rbx, %rcx
movq %rcx, 0xc8(%rsp)
movq 0x5bb3(%rip), %rax      # 0xd208
movq %rax, 0x10(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x51d2
movq %rax, 0x10(%rsp)
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x6c9c
movq %r15, %rdi
callq 0x5006
cmpl $-0x1, %eax
jne 0x7632
movq 0x88(%rsp), %rax
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/hughbarney[P]zepl/lisp.c
// Function: set_input_stream_buffer
void set_input_stream_buffer(Stream *stream, char *buffer)
{
	assert(stream != NULL);
	assert(buffer != NULL);
	assert(strlen(buffer) > 0);

	stream->type = STREAM_TYPE_STRING;
	stream->buffer = buffer;
	stream->length = strlen(buffer);
	stream->capacity = strlen(buffer);
	stream->offset = 0;
	stream->size = 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x0, (%rdi)
movq %rsi, 0x8(%rdi)
movq %rsi, %rdi
callq 0x20e0
movq %rax, 0x18(%r14)
movq %rbx, %rdi
callq 0x20e0
movq %rax, 0x20(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/hughbarney[P]zepl/lisp.c
// Function: reset_output_stream
void reset_output_stream()
{
	Stream *stream = &ostream; /* we only want 1 output stream */
	stream->type = STREAM_TYPE_STRING;
	stream->length = 0;
	if (stream->buffer != NULL) {
		free(stream->buffer);
		stream->buffer = NULL;
	}
}

// Assembly:
movl $0x0, 0x5ae1(%rip)      # 0xd1d0
movq $0x0, 0x5aee(%rip) # 0xd1e8
movq 0x5ad7(%rip), %rdi      # 0xd1d8
testq %rdi, %rdi
je 0x771b
pushq %rax
callq 0x2050
movq $0x0, 0x5ac1(%rip) # 0xd1d8
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/hughbarney[P]zepl/lisp.c
// Function: load_file_body
void load_file_body(Object ** env, GC_PARAM, Stream *input_stream)
{
	//debug("load_file_body\n");
	GC_TRACE(gcObject, nil);

	if (setjmp(exceptionEnv))
		return;

	while (peekNext(input_stream) != EOF) {
		*gcObject = nil;
		*gcObject = readExpr(input_stream, GC_ROOTS);
		*gcObject = evalExpr(gcObject, theEnv, GC_ROOTS);
		writeObject(*gcObject, true, &ostream);
		writeChar('\n', &ostream);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movl $0x3, (%rsp)
movq $0x0, 0x8(%rsp)
movq 0x5ac4(%rip), %rax      # 0xd208
movq %rax, 0x10(%rsp)
movq %rsi, 0x18(%rsp)
leaq 0x770b(%rip), %rdi      # 0xee60
callq 0x2180
testl %eax, %eax
jne 0x77fb
movq %rbx, %rdi
callq 0x5006
cmpl $-0x1, %eax
je 0x77fb
xorl %eax, %eax
movl %eax, %r14d
movq %rsp, %r15
leaq 0x5a4e(%rip), %r12      # 0xd1d0
movl $0x1, %ebp
movl $0xa, %r13d
movq 0x28(%rbx), %rax
leaq -0x1(%rax), %rcx
cmpq $0x2, %rax
cmovlq %r14, %rcx
movq %rcx, 0x28(%rbx)
movq 0x5a60(%rip), %rax      # 0xd208
movq %rax, 0x10(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x51d2
movq %rax, 0x10(%rsp)
movq 0x776c(%rip), %rsi      # 0xef30
leaq 0x10(%rsp), %rdi
movq %r15, %rdx
callq 0x6c9c
movq %rax, 0x10(%rsp)
movq %rax, %rdi
movl %ebp, %esi
movq %r12, %rdx
callq 0x4491
movl %r13d, %edi
movq %r12, %rsi
callq 0x4358
movq %rbx, %rdi
callq 0x5006
cmpl $-0x1, %eax
jne 0x778d
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/hughbarney[P]zepl/lisp.c
// Function: call_lisp_body
void call_lisp_body(Object ** env, GC_PARAM, Stream *input_stream)
{
	GC_TRACE(gcObject, nil);

	for (;;) {
		if (setjmp(exceptionEnv))
			return;

		*gcObject = nil;

		if (peekNext(input_stream) == EOF) {
			writeChar('\n', &ostream);
			return;
		}

		*gcObject = readExpr(input_stream, GC_ROOTS);
		*gcObject = evalExpr(gcObject, env, GC_ROOTS);
		writeObject(*gcObject, true, &ostream);
		writeChar('\n', &ostream);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movl $0x3, (%rsp)
movq $0x0, 0x8(%rsp)
movq 0x59d3(%rip), %rax      # 0xd208
movq %rax, 0x10(%rsp)
movq %rsi, 0x18(%rsp)
leaq 0x761a(%rip), %rdi      # 0xee60
callq 0x2180
testl %eax, %eax
jne 0x78f7
xorl %eax, %eax
movl %eax, %r15d
movq %rsp, %r12
leaq 0x596e(%rip), %r13      # 0xd1d0
leaq 0x75f7(%rip), %rbp      # 0xee60
movq 0x5998(%rip), %rax      # 0xd208
movq %rax, 0x10(%rsp)
movq %rbx, %rdi
callq 0x5006
cmpl $-0x1, %eax
je 0x78e6
movq 0x28(%rbx), %rax
leaq -0x1(%rax), %rcx
cmpq $0x2, %rax
cmovlq %r15, %rcx
movq %rcx, 0x28(%rbx)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x51d2
movq %rax, 0x10(%rsp)
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x6c9c
movq %rax, 0x10(%rsp)
movq %rax, %rdi
movl $0x1, %esi
movq %r13, %rdx
callq 0x4491
movl $0xa, %edi
movq %r13, %rsi
callq 0x4358
movq %rbp, %rdi
callq 0x2180
testl %eax, %eax
je 0x7869
jmp 0x78f7
leaq 0x58e3(%rip), %rsi      # 0xd1d0
movl $0xa, %edi
callq 0x4358
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/hughbarney[P]zepl/lisp.c
// Function: init_lisp
int init_lisp()
{
	theRoot = nil;

	//set_stream_file(&istream, STDIN_FILENO);
	set_stream_file(&ostream, STDOUT_FILENO);

	if (setjmp(exceptionEnv))
		return 1;

	symbols = nil;
	symbols = newCons(&nil, &symbols, theRoot);
	symbols = newCons(&t, &symbols, theRoot);

	temp_root.type = TYPE_CONS;
	temp_root.car = newRootEnv(theRoot);
	temp_root.cdr = theRoot;

	theEnv = &temp_root.car;
	theRoot = &temp_root;
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x58f7(%rip), %rax      # 0xd208
movq %rax, 0x7620(%rip)      # 0xef38
movl $0x1, %ebx
movl %ebx, 0x58ad(%rip)      # 0xd1d0
movl %ebx, 0x58b7(%rip)      # 0xd1e0
leaq 0x7530(%rip), %rdi      # 0xee60
callq 0x2180
movl %ebx, %ecx
testl %eax, %eax
jne 0x79fd
movq 0x58c2(%rip), %rax      # 0xd208
movq %rax, 0x75db(%rip)      # 0xef28
movq 0x75e4(%rip), %rdx      # 0xef38
movl $0x3, %ebx
movl $0x28, %r14d
movl %ebx, %edi
movq %r14, %rsi
callq 0x481c
movq 0x5898(%rip), %rcx      # 0xd208
movq %rcx, 0x10(%rax)
movq 0x75ad(%rip), %rcx      # 0xef28
movq %rcx, 0x18(%rax)
movq %rax, 0x75a2(%rip)      # 0xef28
movq 0x75ab(%rip), %rdx      # 0xef38
movl %ebx, %edi
movq %r14, %rsi
callq 0x481c
movq 0x5872(%rip), %rcx      # 0xd210
movq %rcx, 0x10(%rax)
movq 0x757f(%rip), %rcx      # 0xef28
movq %rcx, 0x18(%rax)
movq %rax, 0x7574(%rip)      # 0xef28
movl $0x3, 0x7582(%rip)      # 0xef40
leaq 0x757b(%rip), %rbx      # 0xef40
movq 0x756c(%rip), %rdi      # 0xef38
callq 0x74b5
movq %rax, 0x7578(%rip)      # 0xef50
leaq 0x7571(%rip), %rax      # 0xef50
movq 0x7552(%rip), %rcx      # 0xef38
movq %rcx, 0x756b(%rip)      # 0xef58
movq %rax, 0x753c(%rip)      # 0xef30
movq %rbx, 0x753d(%rip)      # 0xef38
xorl %ecx, %ecx
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/stevenmherring[P]DNS/fine-trie.c
// Function: new_leaf
struct trie_node * new_leaf (const char *string, size_t strlen, int32_t ip4_address) {
    struct trie_node *new_node = malloc(sizeof(struct trie_node));
    if (!new_node) {
      printf ("WARNING: Node memory allocation failed.  Results may be bogus.\n");
      return NULL;
    }

    assert(strlen < 64);
    assert(strlen > 0);
    new_node->next = NULL;
    new_node->strlen = strlen;
    strncpy(new_node->key, string, strlen);
    new_node->key[strlen] = '\0';
    new_node->ip4_address = ip4_address;
    new_node->children = NULL;
    int rv = pthread_mutex_init(&(new_node->lock), NULL);
    assert(rv == 0);
    rv = pthread_cond_init(&(new_node->c), NULL);
    assert(rv == 0);
    new_node->waiting = 0;
    return new_node;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
movl $0xb8, %edi
callq 0x1120
testq %rax, %rax
je 0x1364
cmpq $0x40, %r14
jae 0x137e
testq %r14, %r14
je 0x139d
movq %rax, %rbx
xorl %r12d, %r12d
movq %r12, (%rax)
movl %r14d, 0x8(%rax)
leaq 0x18(%rax), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1050
movb $0x0, 0x18(%rbx,%r14)
movl %ebp, 0xc(%rbx)
movq %r12, 0x10(%rbx)
leaq 0x58(%rbx), %rdi
xorl %esi, %esi
callq 0x11c0
testl %eax, %eax
jne 0x13bc
movq %rbx, %rdi
subq $-0x80, %rdi
xorl %esi, %esi
callq 0x10f0
testl %eax, %eax
jne 0x13db
movl $0x0, 0xb0(%rbx)
jmp 0x1372
leaq 0x30b0(%rip), %rdi      # 0x441b
callq 0x1080
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2d72(%rip), %rdi      # 0x40f7
leaq 0x2c78(%rip), %rsi      # 0x4004
leaq 0x2c7d(%rip), %rcx      # 0x4010
movl $0x21, %edx
callq 0x10b0
leaq 0x2ead(%rip), %rdi      # 0x4251
leaq 0x2c59(%rip), %rsi      # 0x4004
leaq 0x2c5e(%rip), %rcx      # 0x4010
movl $0x22, %edx
callq 0x10b0
leaq 0x2c87(%rip), %rdi      # 0x404a
leaq 0x2c3a(%rip), %rsi      # 0x4004
leaq 0x2c3f(%rip), %rcx      # 0x4010
movl $0x2a, %edx
callq 0x10b0
leaq 0x2c68(%rip), %rdi      # 0x404a
leaq 0x2c1b(%rip), %rsi      # 0x4004
leaq 0x2c20(%rip), %rcx      # 0x4010
movl $0x2c, %edx
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O1/stevenmherring[P]DNS/fine-trie.c
// Function: compare_keys
int compare_keys (const char *string1, int len1, const char *string2, int len2, int *pKeylen) {
    int keylen, offset1, offset2;
    keylen = len1 < len2 ? len1 : len2;
    offset1 = len1 - keylen;
    offset2 = len2 - keylen;
    assert (keylen > 0);
    if (pKeylen)
    *pKeylen = keylen;
    return strncmp(&string1[offset1], &string2[offset2], keylen);
  }

// Assembly:
cmpl %ecx, %esi
movl %ecx, %eax
cmovll %esi, %eax
testl %eax, %eax
jle 0x142a
testq %r8, %r8
je 0x140d
movl %eax, (%r8)
subl %eax, %ecx
subl %eax, %esi
movslq %esi, %rsi
addq %rsi, %rdi
movslq %ecx, %rcx
addq %rcx, %rdx
movl %eax, %eax
movq %rdx, %rsi
movq %rax, %rdx
jmp 0x1060
pushq %rax
leaq 0x2c20(%rip), %rdi      # 0x4052
leaq 0x2bcb(%rip), %rsi      # 0x4004
leaq 0x2c1d(%rip), %rcx      # 0x405d
movl $0x36, %edx
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O1/stevenmherring[P]DNS/fine-trie.c
// Function: init
void init(int numthreads) {
    //Initialization function, set root node to null, initialize the lock we will use for root.
    root = NULL;
    int rv = pthread_mutex_init(&root_lock, NULL);
    assert(rv == 0);
  }

// Assembly:
pushq %rax
movq $0x0, 0x5cba(%rip) # 0x7110
leaq 0x5cbb(%rip), %rdi      # 0x7118
xorl %esi, %esi
callq 0x11c0
testl %eax, %eax
jne 0x146a
popq %rax
retq
leaq 0x2bd9(%rip), %rdi      # 0x404a
leaq 0x2b8c(%rip), %rsi      # 0x4004
leaq 0x2c1c(%rip), %rcx      # 0x409b
movl $0x40, %edx
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O1/stevenmherring[P]DNS/fine-trie.c
// Function: search
int search  (const char *string, size_t strlen, int32_t *ip4_address) {
    //Search Controller
    //main thread communicates directly with this and this pushes us where to go.
    int32_t found;
    int rc;
    // Skip strings of length 0
    if (strlen == 0)
    return 0;
    struct trie_node *node = root;

    if(node == NULL)
    return 0;
    rc = pthread_mutex_lock(&(node->lock));
    assert(rc == 0);

    found = _search(node, string, strlen);

    if (found >= 0 && ip4_address)
    *ip4_address = found;

    return (found >= 0);
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
xorl %eax, %eax
testq %rsi, %rsi
je 0x1b48
movq 0x5608(%rip), %r12      # 0x7110
testq %r12, %r12
je 0x1b48
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x58(%r12), %rdi
callq 0x11d0
testl %eax, %eax
jne 0x1b54
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1489
testl %eax, %eax
sets %cl
testq %rbx, %rbx
sete %dl
orb %cl, %dl
jne 0x1b43
movl %eax, (%rbx)
notl %eax
shrl $0x1f, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x25b2(%rip), %rdi      # 0x410d
leaq 0x24a2(%rip), %rsi      # 0x4004
leaq 0x261b(%rip), %rcx      # 0x4184
movl $0x127, %edx            # imm = 0x127
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O1/stevenmherring[P]DNS/fine-trie.c
// Function: search_and_squat
int search_and_squat  (const char *string, size_t strlen, int32_t ip4_address) {
    int32_t found;
    int rc;
    // Skip strings of length 0
    if (strlen == 0)
    return 0;

    // in case the node was removed between trying to insert and squatting
    rc = pthread_mutex_lock(&(root_lock));
    assert(rc == 0);
    if(root != NULL)
    {
      found = _insert(string, strlen, ip4_address, root, NULL, NULL);
    }
    else
    {
      root = new_leaf (string, strlen, ip4_address);
      found = 1;
    }
    rc = pthread_mutex_unlock(&(root_lock));
    assert(rc == 0);

    while(!found)
    {
      rc = pthread_mutex_lock(&(root->lock));
      assert(rc == 0);


      found = _search_and_squat(root, string, strlen, ip4_address);

      // in case the node was removed between trying to insert and squatting
      if(!found)
      {
        found = insert(string, strlen, ip4_address);
      }
    }



    return (found >= 0);
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x1bc2
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x558a(%rip), %rdi      # 0x7118
callq 0x11d0
testl %eax, %eax
jne 0x1c5e
movq 0x556e(%rip), %rcx      # 0x7110
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
testq %rcx, %rcx
je 0x1bc6
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x1c9c
testl %eax, %eax
sete %bpl
jmp 0x1bd4
xorl %eax, %eax
jmp 0x1c34
callq 0x12dc
movq %rax, 0x553e(%rip)      # 0x7110
xorl %ebp, %ebp
leaq 0x553d(%rip), %rdi      # 0x7118
callq 0x1110
testl %eax, %eax
jne 0x1c7d
movl $0x1, %eax
testb %bpl, %bpl
je 0x1c34
movq 0x5517(%rip), %rdi      # 0x7110
addq $0x58, %rdi
callq 0x11d0
testl %eax, %eax
jne 0x1c3f
movq 0x5503(%rip), %rdi      # 0x7110
movq %r15, %rsi
movq %r14, %rdx
movl %ebx, %ecx
callq 0x1783
testl %eax, %eax
jne 0x1c2b
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x24d7
testl %eax, %eax
je 0x1bf2
notl %eax
shrl $0x1f, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x24c7(%rip), %rdi      # 0x410d
leaq 0x23b7(%rip), %rsi      # 0x4004
leaq 0x255c(%rip), %rcx      # 0x41b0
movl $0x14b, %edx            # imm = 0x14B
callq 0x10b0
leaq 0x24a8(%rip), %rdi      # 0x410d
leaq 0x2398(%rip), %rsi      # 0x4004
leaq 0x253d(%rip), %rcx      # 0x41b0
movl $0x13b, %edx            # imm = 0x13B
callq 0x10b0
leaq 0x2489(%rip), %rdi      # 0x410d
leaq 0x2379(%rip), %rsi      # 0x4004
leaq 0x251e(%rip), %rcx      # 0x41b0
movl $0x146, %edx            # imm = 0x146
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O1/stevenmherring[P]DNS/fine-trie.c
// Function: insert
int insert (const char *string, size_t strlen, int32_t ip4_address) {
        // Skip strings of length 0
        int rc;
        if (strlen == 0)
        return 0;
        int rv;
        // get root lock
        rc = pthread_mutex_lock(&(root_lock));
        assert(rc == 0);
        if (root == NULL) {
          root = new_leaf (string, strlen, ip4_address);
          rv =  1;
          rc = pthread_mutex_unlock(&(root_lock));
          assert(rc == 0);
        }
        else
        {
          rv = _insert (string, strlen, ip4_address, root, NULL, NULL);
          rc = pthread_mutex_unlock(&(root_lock));
          assert(rc == 0);
          if (!rv && allow_squatting)
          {
            search_and_squat(string, strlen, ip4_address);
          }
        }
        return rv;
      }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x254d
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x4c26(%rip), %rdi      # 0x7118
callq 0x11d0
testl %eax, %eax
jne 0x2587
movq 0x4c0a(%rip), %rcx      # 0x7110
testq %rcx, %rcx
je 0x2551
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x1c9c
movl %eax, %ebp
leaq 0x4bf1(%rip), %rdi      # 0x7118
callq 0x1110
testl %eax, %eax
jne 0x25a6
testl %ebp, %ebp
jne 0x257a
leaq 0x4c05(%rip), %rax      # 0x7140
cmpl $0x0, (%rax)
je 0x257a
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x1b73
xorl %ebp, %ebp
jmp 0x257a
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x12dc
movq %rax, 0x4bab(%rip)      # 0x7110
leaq 0x4bac(%rip), %rdi      # 0x7118
callq 0x1110
movl $0x1, %ebp
testl %eax, %eax
jne 0x25c5
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1b7f(%rip), %rdi      # 0x410d
leaq 0x1a6f(%rip), %rsi      # 0x4004
leaq 0x1d18(%rip), %rcx      # 0x42b4
movl $0x262, %edx            # imm = 0x262
callq 0x10b0
leaq 0x1b60(%rip), %rdi      # 0x410d
leaq 0x1a50(%rip), %rsi      # 0x4004
leaq 0x1cf9(%rip), %rcx      # 0x42b4
movl $0x26d, %edx            # imm = 0x26D
callq 0x10b0
leaq 0x1b41(%rip), %rdi      # 0x410d
leaq 0x1a31(%rip), %rsi      # 0x4004
leaq 0x1cda(%rip), %rcx      # 0x42b4
movl $0x267, %edx            # imm = 0x267
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O1/stevenmherring[P]DNS/fine-trie.c
// Function: delete
int delete  (const char *string, size_t strlen) {
          // Skip strings of length 0
          if (strlen == 0)
          return 0;
          int rc;

          rc = pthread_mutex_lock(&root_lock);
          assert(rc == 0);
          struct trie_node *parent = _delete(root, string, strlen);

          rc = pthread_mutex_unlock(&root_lock);
          assert(rc == 0);
          // release root lock

          int rv =(NULL != parent);

          if(parent != NULL && parent != ((struct trie_node *) 0x100100))
          {
            rc = pthread_mutex_unlock(&(parent->lock));
            assert(rc == 0);

          }


          return rv;
        }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0x2b85
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x4602(%rip), %rdi      # 0x7118
callq 0x11d0
testl %eax, %eax
jne 0x2b90
movq 0x45ea(%rip), %rdi      # 0x7110
movq %r14, %rsi
movq %rbx, %rdx
callq 0x25e4
movq %rax, %rbx
leaq 0x45dd(%rip), %rdi      # 0x7118
callq 0x1110
testl %eax, %eax
jne 0x2baf
testq %rbx, %rbx
setne %bpl
je 0x2b87
cmpq $0x100100, %rbx         # imm = 0x100100
je 0x2b87
addq $0x58, %rbx
movq %rbx, %rdi
callq 0x1110
testl %eax, %eax
je 0x2b87
leaq 0x15a0(%rip), %rdi      # 0x410d
leaq 0x1490(%rip), %rsi      # 0x4004
leaq 0x17d3(%rip), %rcx      # 0x434e
movl $0x35f, %edx            # imm = 0x35F
callq 0x10b0
xorl %ebp, %ebp
movzbl %bpl, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1576(%rip), %rdi      # 0x410d
leaq 0x1466(%rip), %rsi      # 0x4004
leaq 0x17a9(%rip), %rcx      # 0x434e
movl $0x353, %edx            # imm = 0x353
callq 0x10b0
leaq 0x1557(%rip), %rdi      # 0x410d
leaq 0x1447(%rip), %rsi      # 0x4004
leaq 0x178a(%rip), %rcx      # 0x434e
movl $0x357, %edx            # imm = 0x357
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O1/stevenmherring[P]DNS/fine-trie.c
// Function: print
void print() {
          // TODO get root lock
          printf ("Root is at %p\n", root);
          struct trie_node *node = root;
          // relese root lock

          if(node)
          {
            _print(node,0 ,0);
          }
        }

// Assembly:
pushq %rax
movq 0x441f(%rip), %rsi      # 0x7110
leaq 0x1714(%rip), %rdi      # 0x440c
xorl %eax, %eax
callq 0x10a0
movq 0x440a(%rip), %rdi      # 0x7110
testq %rdi, %rdi
je 0x2d15
xorl %esi, %esi
xorl %edx, %edx
popq %rax
jmp 0x2bce
popq %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O1/giometti[P]mastering_UNIX_programming/chapter_02/read.c
// Function: main
int main(void)
{
	int fd;
	int nr, nw;
	char buf[BUF_SIZE];

	fd = open(TMP_FILE, O_RDONLY);
	if (fd < 0) {
		perror("open");
		return -1;
	}

	do {
		nr = read(fd, buf, BUF_SIZE);
		if (nr < 0) {
			perror("read");
			return -1;
		}

		nw = writen(STDOUT_FILENO, buf, nr);
		if (nw < nr) {
			perror("write");
			return -1;
		}

		sleep(1);
	} while (nr > 0);

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
leaq 0xe65(%rip), %rdi       # 0x2004
xorl %esi, %esi
xorl %eax, %eax
callq 0x1060
testl %eax, %eax
js 0x120f
movl %eax, %ebp
movq %rsp, %r14
leaq 0xe5b(%rip), %rbx       # 0x2013
leaq 0xe59(%rip), %r12       # 0x2018
movl $0x10, %edx
movl %ebp, %edi
movq %r14, %rsi
callq 0x1050
movq %rax, %r15
testl %r15d, %r15d
js 0x121b
movl %r15d, %edx
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
movl $0x1, %edi
movq %r14, %rsi
callq 0x128a
cmpl %r15d, %eax
jl 0x1218
movl $0x1, %edi
callq 0x1080
testl %r15d, %r15d
jne 0x11bf
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xdf8(%rip), %rbx       # 0x200e
jmp 0x121b
movq %r12, %rbx
movq %rbx, %rdi
callq 0x1070
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x1202
nop
// File: /workspace/github_c_makefile_star2_O1/giometti[P]mastering_UNIX_programming/chapter_02/wrappers.c
// Function: readn
int readn(int fd, void *buf, size_t count)
{
        int nleft = count, nread;
        char *ptr = buf;

        while (nleft > 0) {
                nread = read(fd, ptr, nleft);
                if (nread < 0) {
                        if (errno != EAGAIN)
                                return -1;
                        nread = 0;
                } else if (nread == 0)
                        break;

                nleft -= nread;
                ptr += nread;
        }

        return count - nleft;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %ebx, %r15d
testl %ebx, %ebx
jle 0x1273
movq %rsi, %r14
movl %edi, %ebp
movl %ebx, %r15d
movl %r15d, %edx
movl %ebp, %edi
movq %r14, %rsi
callq 0x1050
testl %eax, %eax
js 0x125a
jne 0x1269
jmp 0x1273
callq 0x1030
movq %rax, %rcx
xorl %eax, %eax
cmpl $0xb, (%rcx)
jne 0x1283
movl %eax, %ecx
addq %rcx, %r14
subl %eax, %r15d
jg 0x1245
subl %r15d, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x1276
// File: /workspace/github_c_makefile_star2_O1/giometti[P]mastering_UNIX_programming/chapter_02/wrappers.c
// Function: writen
int writen(int fd, void *buf, size_t count)
{
        int nleft = count, nwritten;
        char *ptr = buf;

        while (nleft > 0) {
                nwritten = write(fd, ptr, nleft);
                if (nwritten < 0) {
                        if (errno != EAGAIN)
                                return -1;
                        nwritten = 0;
                }

                nleft -= nwritten;
                ptr += nwritten;
        }

        return count - nleft;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %ebx, %r15d
testl %ebx, %ebx
jle 0x12cd
movq %rsi, %r14
movl %edi, %ebp
movl %ebx, %r15d
movl %r15d, %edx
movl %ebp, %edi
movq %r14, %rsi
callq 0x1040
testl %eax, %eax
jns 0x12c3
callq 0x1030
movq %rax, %rcx
xorl %eax, %eax
cmpl $0xb, (%rcx)
jne 0x12dd
movl %eax, %ecx
addq %rcx, %r14
subl %eax, %r15d
jg 0x12a3
subl %r15d, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x12d0
// File: /workspace/github_c_makefile_star2_O1/joncampbell123[P]swfhax/c4_swf2svg.c
// Function: dump_font_to_svg
void dump_font_to_svg(swf_reader *swf,swf_DefineFont *nfo) {
	unsigned int i;
	uint64_t ofs;
	FILE *fp;

	for (i=0;i < nfo->nGlyphs;i++) {
		ofs = (unsigned long long)nfo->absoluteOffsetTable + (unsigned long long)nfo->OffsetTable[i];
		if (swf_reader_seek(swf,ofs) == 0) {
			char tmp[256];

			sprintf(tmp,"swf.font.%u.glyph.%u.svg",nfo->FontID,i);
			fp = fopen(tmp,"w");
			if (fp) do_dump_font_to_svg(swf,fp);
			fclose(fp);
		}
		else {
			fprintf(stderr,"!! Unable to seek to offset (likely reason: non-sequential offsets)\n");
		}
	}
}

// Assembly:
cmpw $0x0, 0x2(%rsi)
je 0x1a79
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x130(%rbp), %r12
xorl %r15d, %r15d
movq 0x8(%rbx), %rax
movzwl (%rax,%r15,2), %esi
addq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0x3627
testl %eax, %eax
jne 0x1a61
movzwl (%rbx), %edx
movq %r12, %rdi
leaq 0x57cc(%rip), %rsi      # 0x71eb
movl %r15d, %ecx
xorl %eax, %eax
callq 0x1190
movq %r12, %rdi
leaq 0x57d1(%rip), %rsi      # 0x7204
callq 0x1170
movq %rax, %r13
testq %rax, %rax
je 0x1a4b
movq %r14, %rdi
movq %r13, %rsi
callq 0x17ac
movq %r13, %rdi
callq 0x1060
incq %r15
movzwl 0x2(%rbx), %eax
cmpq %rax, %r15
jb 0x19f9
jmp 0x1a68
callq 0x11c0
jmp 0x1a53
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/sasairc[P]yasuna/src/libbenly/src/column.c
// Function: tablize
int tablize(char** const array[])
{
    int     status  = 0;

    size_t  x       = 0,
            y       = 0,
        *   length  = NULL;

    regex_t reg;

    y = count_lines(array);
    x = count_cols(array);
    if (regcomp(&reg, ANSI_ESCSEQ, REG_EXTENDED) != 0) {
        status = -1; goto ERR;
    }
    if (count_length(array, x, y, &length, &reg) < 0) {
        status = -2; goto ERR;
    }
    put(array, x, y, length, &reg);
    regfree(&reg);
    free(length);

    return 0;

ERR:
    switch (status) {
        case    -1:
            break;
        case    -2:
            regfree(&reg);
            break;
    }

    return status;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
movq $-0x1, %r13
cmpq $0x0, 0x8(%rbx,%r13,8)
leaq 0x1(%r13), %r13
jne 0x11d4
movq (%rbx), %rax
movl $0x1, %r12d
movq $-0x8, %r14
decq %r12
cmpq $0x0, 0x8(%rax,%r14)
leaq 0x8(%r14), %r14
jne 0x11f0
leaq 0xdfa(%rip), %rsi       # 0x2000
leaq 0x28(%rsp), %rdi
movl $0x1, %edx
callq 0x10a0
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
testl %eax, %eax
je 0x1236
testl %eax, %eax
jne 0x136f
leaq 0x28(%rsp), %rdi
callq 0x1070
jmp 0x136f
movl %eax, 0xc(%rsp)
movq %r12, %rax
negq %rax
movq %rax, 0x10(%rsp)
movq %r14, %rdi
callq 0x10b0
movq %rax, %r14
testq %rax, %rax
sete %al
testq %r12, %r12
sete %cl
orb %al, %cl
jne 0x12a7
xorl %ebp, %ebp
movq $0x0, (%r14,%rbp,8)
testq %r13, %r13
je 0x129d
xorl %r15d, %r15d
movq (%rbx,%r15,8), %rax
movq (%rax,%rbp,8), %rdi
testq %rdi, %rdi
je 0x129d
leaq 0x28(%rsp), %rsi
callq 0x1390
cltq
cmpq %rax, (%r14,%rbp,8)
jae 0x1295
movq %rax, (%r14,%rbp,8)
incq %r15
cmpq %r15, %r13
jne 0x1272
incq %rbp
cmpq %rbp, 0x10(%rsp)
jne 0x1262
testq %r14, %r14
je 0x1381
testq %r13, %r13
je 0x135a
xorl %r15d, %r15d
movq %r13, 0x20(%rsp)
movq %r12, 0x18(%rsp)
testq %r12, %r12
je 0x133a
xorl %ebp, %ebp
movq (%rbx,%r15,8), %rax
movq (%rax,%rbp,8), %rdi
testq %rdi, %rdi
je 0x133a
movq 0x2cff(%rip), %rax      # 0x3fe0
movq (%rax), %rsi
callq 0x1090
movq %rbx, %r13
movq (%rbx,%r15,8), %rax
movq (%rax,%rbp,8), %rdi
leaq 0x28(%rsp), %rsi
callq 0x1390
movslq %eax, %rbx
movq %r14, %r12
movq (%r14,%rbp,8), %r14
cmpq %rbx, %r14
jb 0x132a
incq %rbx
movl $0x20, %edi
callq 0x1040
testl %eax, %eax
je 0x132a
leaq 0x1(%rbx), %rax
cmpq %r14, %rbx
movq %rax, %rbx
jbe 0x1310
incq %rbp
cmpq %rbp, 0x10(%rsp)
movq %r13, %rbx
movq %r12, %r14
jne 0x12cd
movl $0xa, %edi
callq 0x1040
incq %r15
movq 0x20(%rsp), %r13
cmpq %r15, %r13
movq 0x18(%rsp), %r12
jne 0x12c6
leaq 0x28(%rsp), %rdi
callq 0x1070
movq %r14, %rdi
callq 0x1030
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0xfffffffe, %r15d      # imm = 0xFFFFFFFE
movl 0xc(%rsp), %eax
jmp 0x121f
// File: /workspace/github_c_makefile_star2_O1/sasairc[P]yasuna/src/libbenly/src/column.c
// Function: mbstrlen_with_regex
static
int mbstrlen_with_regex(char* src, regex_t* reg)
{
    int         ch      = 0,
                len     = 0;

    char*       p       = src;

#ifdef  WITH_GLIB
    gunichar*   cpoints;
/* WITH_GLIB */
#endif

    regmatch_t  match;

    setlocale(LC_CTYPE, LOCALE);

    while (*p != '\0') {
        /* get string length */
        if ((ch = mblen(p, MB_CUR_MAX)) < 0)
            return 0;

#ifdef  WITH_GLIB
        /*
         * true : multi byte
         * false: ascii
         */
        if (ch > 1) {
            /* get unicode code point */
            cpoints = g_utf8_to_ucs4_fast(p, sizeof(*p), NULL);
            /*
             * # multi byte
             * true : hankaku kana
             * false: other
             */
            if ((*cpoints >= 0xff65 && *cpoints <= 0xff9f) ||
                    *cpoints == 0x001b) {
                len++;
            } else {
                len += 2;
            }
            g_free(cpoints);
        } else {
            len++;
        }
#else
        /*
         * true : multi byte
         * false: ascii
         */
        if (ch > 1) {
            len += 2;
        } else {
            len++;
        }
/* WITH_GLIB */
#endif
        /* seek offset */
        p += ch;
    }

    /* regex match */
    while (regexec(reg, src, 1, &match, 0) != REG_NOMATCH) {
        src += match.rm_eo;
        len -= match.rm_eo - match.rm_so;
    }

    return len;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xc69(%rip), %rsi       # 0x2011
xorl %ebp, %ebp
xorl %edi, %edi
callq 0x10d0
cmpb $0x0, (%r14)
je 0x142c
movq %r14, %r15
xorl %ebp, %ebp
callq 0x1080
movq %r15, %rdi
movq %rax, %rsi
callq 0x1050
testl %eax, %eax
js 0x1474
movl %eax, %r12d
movl $0x1, %r13d
cmpl $0x2, %eax
jl 0x141b
movl $0x1, %esi
movq %r15, %rdi
xorl %edx, %edx
callq 0x10e0
movl (%rax), %ecx
leal -0xff65(%rcx), %edx
cmpl $0x3b, %edx
setb %dl
cmpl $0x1b, %ecx
sete %cl
orb %dl, %cl
movzbl %cl, %ecx
movl $0x2, %r13d
subl %ecx, %r13d
movq %rax, %rdi
callq 0x1060
addl %r13d, %ebp
movl %r12d, %eax
cmpb $0x0, (%r15,%rax)
leaq (%r15,%rax), %r15
jne 0x13bc
movq %rsp, %rcx
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
xorl %r8d, %r8d
callq 0x10c0
cmpl $0x1, %eax
je 0x1476
movq %rsp, %r15
movslq 0x4(%rsp), %rax
addq %rax, %r14
subl %eax, %ebp
addl (%rsp), %ebp
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rcx
xorl %r8d, %r8d
callq 0x10c0
cmpl $0x1, %eax
jne 0x144a
jmp 0x1476
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lh3[P]fermi-lite/misc.c
// Function: fml_opt_init
void fml_opt_init(fml_opt_t *opt)
{
	opt->n_threads = 1;
	opt->ec_k = 0;
	opt->min_cnt = 4;
	opt->max_cnt = 8;
	opt->min_asm_ovlp = 33;
	opt->min_merge_len = 0;
	mag_init_opt(&opt->mag_opt);
	opt->mag_opt.flag = MAG_F_NO_SIMPL | MAG_F_POPOPEN;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movaps 0x14c21(%rip), %xmm0    # 0x17370
movups %xmm0, (%rdi)
movq $0x21, 0x10(%rdi)
addq $0x18, %rdi
callq 0x11cc4
movl $0xc0, 0x18(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/lh3[P]fermi-lite/misc.c
// Function: fml_opt_adjust
void fml_opt_adjust(fml_opt_t *opt, int n_seqs, const bseq1_t *seqs)
{
	int i, log_len;
	uint64_t tot_len = 0;
	if (opt->n_threads < 1) opt->n_threads = 1;
	for (i = 0; i < n_seqs; ++i) tot_len += seqs[i].l_seq; // compute total length
	for (log_len = 10; log_len < 32; ++log_len) // compute ceil(log2(tot_len))
		if (1ULL<<log_len > tot_len) break;
	if (opt->ec_k == 0) opt->ec_k = (log_len + 12) / 2;
	if (opt->ec_k%2 == 0) ++opt->ec_k;
	opt->mag_opt.min_elen = (int)((double)tot_len / n_seqs * 2.5 + .499);
}

// Assembly:
cmpl $0x0, (%rdi)
jg 0x2777
movl $0x1, (%rdi)
testl %esi, %esi
jle 0x279c
movl %esi, %eax
shlq $0x3, %rax
leaq (%rax,%rax,2), %rcx
xorl %r8d, %r8d
xorl %eax, %eax
movslq (%rdx,%r8), %r9
addq %r9, %rax
addq $0x18, %r8
cmpq %r8, %rcx
jne 0x278a
jmp 0x279e
xorl %eax, %eax
movl $0xa, %edx
movq %rdx, %rcx
movq %rax, %r8
shrq %cl, %r8
incq %rdx
cmpq $0x1f, %rcx
ja 0x27ba
testq %r8, %r8
jne 0x27a3
cmpl $0x0, 0x4(%rdi)
jne 0x27c8
addl $0xb, %edx
shrl %edx
movl %edx, 0x4(%rdi)
movl 0x4(%rdi), %ecx
testb $0x1, %cl
jne 0x27d6
orl $0x1, %ecx
movl %ecx, 0x4(%rdi)
movq %rax, %xmm0
punpckldq 0x14b9d(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x14ba5(%rip), %xmm0    # 0x17390
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtsi2sd %esi, %xmm0
divsd %xmm0, %xmm1
mulsd 0x14b96(%rip), %xmm1    # 0x173a0
addsd 0x14b96(%rip), %xmm1    # 0x173a8
cvttsd2si %xmm1, %eax
movl %eax, 0x20(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/lh3[P]fermi-lite/misc.c
// Function: fml_mag_clean
void fml_mag_clean(const fml_opt_t *opt, struct mag_t *g)
{
	magopt_t o = opt->mag_opt;
	o.min_merge_len = opt->min_merge_len;
	mag_g_merge(g, 1, opt->min_merge_len);
	mag_g_clean(g, &o);
	mag_g_trim_open(g, &o);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq 0x48(%rdi), %rax
movq %rsp, %r14
movq %rax, 0x30(%r14)
movups 0x18(%rdi), %xmm0
movups 0x28(%rdi), %xmm1
movups 0x38(%rdi), %xmm2
movaps %xmm2, 0x20(%r14)
movaps %xmm1, 0x10(%r14)
movaps %xmm0, (%r14)
movl 0x14(%rdi), %edx
movl %edx, 0x20(%r14)
movq %rsi, %rdi
movl $0x1, %esi
callq 0x10122
movq %rbx, %rdi
movq %r14, %rsi
callq 0x11d27
movq %rbx, %rdi
movq %r14, %rsi
callq 0x11ffb
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/lh3[P]fermi-lite/misc.c
// Function: fml_utg_print_gfa
void fml_utg_print_gfa(int n, const fml_utg_t *utg)
{
	int i, j;
	FILE *fp = stdout;
	fputs("H\tVN:Z:1.0\n", fp);
	for (i = 0; i < n; ++i) {
		const fml_utg_t *u = &utg[i];
		fprintf(fp, "S\t%d\t", i);
		fputs(u->seq, fp);
		fprintf(fp, "\tLN:i:%d\tRC:i:%d\tPD:Z:", u->len, u->nsr);
		fputs(u->cov, fp);
		fputc('\n', fp);
		for (j = 0; j < u->n_ovlp[0] + u->n_ovlp[1]; ++j) {
			fml_ovlp_t *o = &u->ovlp[j];
			if (i < o->id)
				fprintf(fp, "L\t%d\t%c\t%d\t%c\t%dM\n", i, "+-"[!o->from], o->id, "+-"[o->to], o->len);
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, 0x8(%rsp)
movl %edi, %ebp
movq 0x19570(%rip), %rax     # 0x1cfc0
movq (%rax), %r14
leaq 0x139ad(%rip), %rdi     # 0x17407
movq %r14, %rsi
callq 0x20f0
testl %ebp, %ebp
jle 0x3b70
movl %ebp, %eax
movq %rax, 0x10(%rsp)
movl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
leaq 0x139c5(%rip), %r15     # 0x17443
xorl %ebp, %ebp
leaq (,%rbp,4), %rbx
addq %rbp, %rbx
movq %r14, %rdi
leaq 0x1397e(%rip), %rsi     # 0x17413
movl %ebp, %edx
xorl %eax, %eax
callq 0x2160
movq 0x8(%rsp), %r13
movq 0x8(%r13,%rbx,8), %rdi
movq %r14, %rsi
callq 0x20f0
movl (%r13,%rbx,8), %edx
movl 0x4(%r13,%rbx,8), %ecx
movq %r14, %rdi
leaq 0x13955(%rip), %rsi     # 0x17419
xorl %eax, %eax
callq 0x2160
movq 0x10(%r13,%rbx,8), %rdi
movq %r14, %rsi
callq 0x20f0
movl $0xa, %edi
movq %r14, %rsi
callq 0x2120
movl 0x1c(%r13,%rbx,8), %eax
addl 0x18(%r13,%rbx,8), %eax
jle 0x3b62
movq 0x8(%rsp), %rax
leaq (%rax,%rbx,8), %r13
xorl %ebx, %ebx
movq 0x20(%r13), %rax
movq (%rax,%rbx,8), %rax
movq %rax, %r8
shrq $0x20, %r8
movl %r8d, %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
cmpq %rcx, %rbp
jae 0x3b4f
andl %r12d, %r8d
movl %eax, %ecx
shrl $0x1f, %ecx
xorq $0x1, %rcx
movsbl (%rcx,%r15), %ecx
movq %rax, %rdx
shrq $0x3f, %rdx
movsbl (%rdx,%r15), %r9d
andl %r12d, %eax
movl %eax, (%rsp)
movq %r14, %rdi
leaq 0x138ea(%rip), %rsi     # 0x17430
movl %ebp, %edx
xorl %eax, %eax
callq 0x2160
incq %rbx
movslq 0x18(%r13), %rax
movslq 0x1c(%r13), %rcx
addq %rax, %rcx
cmpq %rcx, %rbx
jl 0x3afc
incq %rbp
cmpq 0x10(%rsp), %rbp
jne 0x3a80
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lh3[P]fermi-lite/misc.c
// Function: fml_utg_destroy
void fml_utg_destroy(int n, fml_utg_t *utg)
{
	int i;
	for (i = 0; i < n; ++i) {
		free(utg[i].seq);
		free(utg[i].cov);
		free(utg[i].ovlp);
	}
	free(utg);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
testl %edi, %edi
jle 0x3bbf
movl %edi, %eax
shlq $0x3, %rax
leaq (%rax,%rax,4), %r14
xorl %r15d, %r15d
movq 0x8(%rbx,%r15), %rdi
callq 0x2040
movq 0x10(%rbx,%r15), %rdi
callq 0x2040
movq 0x20(%rbx,%r15), %rdi
callq 0x2040
addq $0x28, %r15
cmpq %r15, %r14
jne 0x3b98
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2040
// File: /workspace/github_c_makefile_star2_O1/lh3[P]fermi-lite/misc.c
// Function: fml_assemble
fml_utg_t *fml_assemble(const fml_opt_t *opt0, int n_seqs, bseq1_t *seqs, int *n_utg)
{
	rld_t *e;
	mag_t *g;
	fml_utg_t *utg;
	fml_opt_t opt = *opt0;
	float kcov;

	*n_utg = 0;
	fml_opt_adjust(&opt, n_seqs, seqs);
	if (opt.ec_k >= 0) fml_correct(&opt, n_seqs, seqs);
	kcov = fml_fltuniq(&opt, n_seqs, seqs);
	e = fml_seq2fmi(&opt, n_seqs, seqs);
	if (e == 0) return 0; // this may happen when all sequences are filtered out
	g = fml_fmi2mag(&opt, e);
	opt.mag_opt.min_ensr = opt.mag_opt.min_ensr > kcov * MAG_MIN_NSR_COEF? opt.mag_opt.min_ensr : (int)(kcov * MAG_MIN_NSR_COEF + .499);
	opt.mag_opt.min_ensr = opt.mag_opt.min_ensr < opt0->max_cnt? opt.mag_opt.min_ensr : opt0->max_cnt;
	opt.mag_opt.min_ensr = opt.mag_opt.min_ensr > opt0->min_cnt? opt.mag_opt.min_ensr : opt0->min_cnt;
	opt.mag_opt.min_insr = opt.mag_opt.min_ensr - 1;
	fml_mag_clean(&opt, g);
	utg = fml_mag2utg(g, n_utg);
	return utg;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %r14
leaq 0x10(%rsp), %r12
movl $0x14, %ecx
movq %r12, %rdi
movq %r14, %rsi
rep  movsl (%rsi), %es:(%rdi)
movl $0x0, (%rbx)
movq %r12, %rdi
movl %ebp, %esi
callq 0x276c
cmpl $0x0, 0x4(%r12)
js 0x3c1c
leaq 0x10(%rsp), %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0x727a
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0x7286
movss %xmm0, 0xc(%rsp)
xorl %edx, %edx
cmpl $0x2, (%r12)
setge %dl
movl %ebp, %edi
movq %r15, %rsi
callq 0x281a
testq %rax, %rax
je 0x3cc8
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0xc0d0
movl 0x24(%r15), %ecx
xorps %xmm0, %xmm0
cvtsi2sd %ecx, %xmm0
cvtss2sd 0xc(%rsp), %xmm1
mulsd 0x1373a(%rip), %xmm1    # 0x173b0
ucomisd %xmm1, %xmm0
addsd 0x13726(%rip), %xmm1    # 0x173a8
cvttsd2si %xmm1, %edx
cmoval %ecx, %edx
movl %edx, 0x24(%r15)
movl 0xc(%r14), %ecx
cmpl %ecx, %edx
cmovgel %ecx, %edx
movl %edx, 0x24(%r15)
movl 0x8(%r14), %ecx
cmpl %ecx, %edx
cmovlel %ecx, %edx
movq %rax, %r14
movl %edx, 0x24(%r15)
decl %edx
movl %edx, 0x28(%r15)
movq %r15, %rdi
movq %rax, %rsi
callq 0x2c56
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2cbc
jmp 0x3cca
xorl %eax, %eax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/lh3[P]fermi-lite/bseq.c
// Function: seq_reverse
void seq_reverse(int l, unsigned char *s)
{
	int i;
	for (i = 0; i < l>>1; ++i) {
		int tmp = s[l-1-i];
		s[l-1-i] = s[i]; s[i] = tmp;
	}
}

// Assembly:
movl %edi, %eax
sarl %eax
testl %eax, %eax
jle 0x4204
movl %eax, %eax
decl %edi
xorl %ecx, %ecx
movslq %edi, %rdi
movb (%rsi,%rdi), %dl
movb (%rsi,%rcx), %r8b
movb %r8b, (%rsi,%rdi)
movb %dl, (%rsi,%rcx)
incq %rcx
decl %edi
cmpq %rcx, %rax
jne 0x41e9
retq
// File: /workspace/github_c_makefile_star2_O1/lh3[P]fermi-lite/bseq.c
// Function: seq_revcomp6
void seq_revcomp6(int l, unsigned char *s)
{
	int i;
	for (i = 0; i < l>>1; ++i) {
		int tmp = s[l-1-i];
		tmp = (tmp >= 1 && tmp <= 4)? 5 - tmp : tmp;
		s[l-1-i] = (s[i] >= 1 && s[i] <= 4)? 5 - s[i] : s[i];
		s[i] = tmp;
	}
	if (l&1) s[i] = (s[i] >= 1 && s[i] <= 4)? 5 - s[i] : s[i];
}

// Assembly:
movl %edi, %eax
sarl %eax
testl %eax, %eax
jle 0x4261
movl %eax, %ecx
leal -0x1(%rdi), %edx
xorl %eax, %eax
movslq %edx, %rdx
movzbl (%rsi,%rdx), %r8d
movb $0x5, %r9b
subb %r8b, %r9b
leal -0x1(%r8), %r10d
cmpb $0x4, %r10b
movzbl %r9b, %r9d
cmovael %r8d, %r9d
movzbl (%rsi,%rax), %r8d
movb $0x5, %r10b
subb %r8b, %r10b
leal -0x1(%r8), %r11d
cmpb $0x4, %r11b
movzbl %r10b, %r10d
cmovael %r8d, %r10d
movb %r10b, (%rsi,%rdx)
movb %r9b, (%rsi,%rax)
incq %rax
decl %edx
cmpq %rax, %rcx
jne 0x4214
jmp 0x4263
xorl %eax, %eax
testb $0x1, %dil
je 0x4281
movzbl (%rsi,%rax), %ecx
movb $0x5, %dl
subb %cl, %dl
leal -0x1(%rcx), %edi
cmpb $0x4, %dil
movzbl %dl, %edx
cmovael %ecx, %edx
movb %dl, (%rsi,%rax)
retq