LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/search.c
// Function: ficlPrimitiveSetCurrent
static void ficlPrimitiveSetCurrent(ficlVm *vm)
{
    ficlHash *hash = ficlStackPopPointer(vm->dataStack);
    ficlDictionary *dictionary = ficlVmGetDictionary(vm);
    ficlDictionaryLock(dictionary, FICL_TRUE);
    dictionary->compilationWordlist = hash;
    ficlDictionaryLock(dictionary, FICL_FALSE);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b30
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8f80
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/search.c
// Function: ficlPrimitiveSetOrder
static void ficlPrimitiveSetOrder(ficlVm *vm)
{
    int i;
    int wordlistCount = ficlStackPopInteger(vm->dataStack);
    ficlDictionary *dictionary = ficlVmGetDictionary(vm);

    if (wordlistCount > FICL_MAX_WORDLISTS)
    {
        ficlVmThrowError(vm, "set-order error: list would be too large");
    }

    ficlDictionaryLock(dictionary, FICL_TRUE);

    if (wordlistCount >= 0)
    {
        dictionary->wordlistCount = wordlistCount;
        for (i = wordlistCount-1; i >= 0; --i)
        {
            dictionary->wordlists[i] = ficlStackPopPointer(vm->dataStack);
        }
    }
    else
    {
        ficlDictionaryResetSearchOrder(dictionary);
    }

    ficlDictionaryLock(dictionary, FICL_FALSE);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b70
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8f80
movq %rax, -0x18(%rbp)
cmpl $0x10, -0x10(%rbp)
jle 0x141f1
movq -0x8(%rbp), %rdi
leaq 0x28c8(%rip), %rsi      # 0x16ab2
movb $0x0, %al
callq 0x8dc0
cmpl $0x0, -0x10(%rbp)
jl 0x1423d
movl -0x10(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0xa8(%rax)
movl -0x10(%rbp), %eax
subl $0x1, %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x1423b
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b30
movq %rax, %rdx
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq %rdx, 0x28(%rax,%rcx,8)
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1420d
jmp 0x14246
movq -0x18(%rbp), %rdi
callq 0x11b00
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/search.c
// Function: ficlPrimitiveFiclWordlist
static void ficlPrimitiveFiclWordlist(ficlVm *vm)
{
    ficlDictionary *dictionary = ficlVmGetDictionary(vm);
    ficlHash *hash;
    ficlUnsigned nBuckets;
    
    FICL_STACK_CHECK(vm->dataStack, 1, 1);

    nBuckets = ficlStackPopUnsigned(vm->dataStack);
    hash = ficlDictionaryCreateWordlist(dictionary, nBuckets);
    ficlStackPushPointer(vm->dataStack, hash);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8f80
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b50
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movl %eax, %esi
callq 0x11a80
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x4c60
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/search.c
// Function: ficlPrimitiveWidGetName
static void ficlPrimitiveWidGetName(ficlVm *vm)
{
    ficlHash *hash;
    char *name;
    ficlInteger length;

    hash = ficlVmPop(vm).p;
    name = hash->name;
    
    if (name != NULL)
        length = strlen(name);
	else
		length = 0;

    ficlVmPush(vm, FICL_LVALUE_TO_CELL(name));
    ficlVmPush(vm, FICL_LVALUE_TO_CELL(length));
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x9390
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x142f3
movq -0x18(%rbp), %rdi
callq 0x30d0
movq %rax, -0x20(%rbp)
jmp 0x142fb
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x93c0
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x93c0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/search.c
// Function: ficlPrimitiveWidSetName
static void ficlPrimitiveWidSetName(ficlVm *vm)
{
    char *name = (char *)ficlVmPop(vm).p;
    ficlHash *hash = ficlVmPop(vm).p;
    hash->name = name;
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x9390
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x9390
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/search.c
// Function: ficlPrimitiveSetParentWid
static void ficlPrimitiveSetParentWid(ficlVm *vm)
{
    ficlHash *parent, *child;

    FICL_STACK_CHECK(vm->dataStack, 2, 0);

    child  = (ficlHash *)ficlStackPopPointer(vm->dataStack);
    parent = (ficlHash *)ficlStackPopPointer(vm->dataStack);

    child->link = parent;
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b30
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b30
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/bit.c
// Function: ficlBitGet
int ficlBitGet(const unsigned char *bits, size_t index)
	{
	int byteIndex = index >> 3;
	int bitIndex = index & 7;
	unsigned char mask = (unsigned char)(128 >> bitIndex);

	return ((mask & bits[byteIndex]) ? 1 : 0);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
shrq $0x3, %rax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
andq $0x7, %rax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %ecx
movl $0x80, %eax
sarl %cl, %eax
movb %al, -0x19(%rbp)
movzbl -0x19(%rbp), %edx
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andl %eax, %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/bit.c
// Function: ficlBitSet
void ficlBitSet(unsigned char *bits, size_t index, int value)
	{
	int byteIndex = index >> 3;
	int bitIndex = index & 7;
	unsigned char mask = (unsigned char)(128 >> bitIndex);

	if (value)
		bits[byteIndex] |= mask;
	else
		bits[byteIndex] &= ~mask;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
shrq $0x3, %rax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
andq $0x7, %rax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %ecx
movl $0x80, %eax
sarl %cl, %eax
movb %al, -0x1d(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x1444f
movzbl -0x1d(%rbp), %esi
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movzbl (%rax,%rcx), %edx
orl %esi, %edx
movb %dl, (%rax,%rcx)
jmp 0x14467
movzbl -0x1d(%rbp), %esi
xorl $-0x1, %esi
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movzbl (%rax,%rcx), %edx
andl %esi, %edx
movb %dl, (%rax,%rcx)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/eric-lo[P]3150/9-File/no_buf.c
// Function: main
int main(void)
{
	if(setvbuf(stdout, NULL, _IONBF, 0) != 0)
	{
		perror("setvbuf");
		exit(1);
	}

	printf("H");	sleep(1);
	printf("E");	sleep(1);
	printf("L");	sleep(1);
	printf("L");	sleep(1);
	printf("O");	sleep(1);
	printf("\n");	sleep(1);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movq 0x2e4a(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %ecx
movl $0x2, %edx
movq %rcx, %rsi
callq 0x1040
cmpl $0x0, %eax
je 0x11c5
leaq 0xe4e(%rip), %rdi       # 0x2004
callq 0x1050
movl $0x1, %edi
callq 0x1060
leaq 0xe40(%rip), %rdi       # 0x200c
movb $0x0, %al
callq 0x1030
movl $0x1, %edi
callq 0x1070
leaq 0xe2a(%rip), %rdi       # 0x200e
movb $0x0, %al
callq 0x1030
movl $0x1, %edi
callq 0x1070
leaq 0xe14(%rip), %rdi       # 0x2010
movb $0x0, %al
callq 0x1030
movl $0x1, %edi
callq 0x1070
leaq 0xdfc(%rip), %rdi       # 0x2010
movb $0x0, %al
callq 0x1030
movl $0x1, %edi
callq 0x1070
leaq 0xde6(%rip), %rdi       # 0x2012
movb $0x0, %al
callq 0x1030
movl $0x1, %edi
callq 0x1070
leaq 0xdd0(%rip), %rdi       # 0x2014
movb $0x0, %al
callq 0x1030
movl $0x1, %edi
callq 0x1070
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/motet-a[P]libforks/tests/stop_wait.c
// Function: child_main
static void child_main(libforks_ServerConn conn, int socket_fd) {
  (void)conn;
  (void)socket_fd;

  check(signal(SIGTERM, SIG_IGN) != SIG_ERR);

  // sleep 10ms
  struct timespec ts = {
    .tv_sec = 0,
    .tv_nsec = 10 * 1000 * 1000,
  };
  check(nanosleep(&ts, NULL) == 0);

  check(write(pipe_fds[1], "a", 1) == 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0xf, %edi
movl $0x1, %esi
callq 0x1130
movq $-0x1, %rcx
cmpq %rcx, %rax
je 0x157c
jmp 0x1594
leaq 0x2bca(%rip), %rdi      # 0x414d
leaq 0x2a8e(%rip), %rsi      # 0x4018
movl $0xb, %edx
callq 0x1510
movq 0x2c15(%rip), %rax      # 0x41b0
movq %rax, -0x20(%rbp)
movq 0x2c12(%rip), %rax      # 0x41b8
movq %rax, -0x18(%rbp)
leaq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x10c0
cmpl $0x0, %eax
jne 0x15be
jmp 0x15d6
leaq 0x2bac(%rip), %rdi      # 0x4171
leaq 0x2a4c(%rip), %rsi      # 0x4018
movl $0x12, %edx
callq 0x1510
movl 0x5b4c(%rip), %edi      # 0x7128
leaq 0x2ba8(%rip), %rsi      # 0x418b
movl $0x1, %edx
callq 0x1090
cmpq $0x1, %rax
jne 0x15f5
jmp 0x160d
leaq 0x2b91(%rip), %rdi      # 0x418d
leaq 0x2a15(%rip), %rsi      # 0x4018
movl $0x14, %edx
callq 0x1510
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/xtanitfy[P]Murphy/test/test_queue.c
// Function: main
int main(void)
{

	QUEUE_s *pQ = QUEUE_create(sizeof(int),16);
	for (int i = 0;i < DIM_OF(arr);i++) {
		QUEUE_enqueue(pQ,&arr[i]);
	}

	int val;
	while(QUEUE_dequeue(pQ,&val) != QUEUE_EMPTY) {
		printf("val:%d\n",val);
	}

	
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl $0x4, %edi
movl $0x10, %esi
callq 0x11f0
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
cmpq $0x6, %rax
jae 0x11b9
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rax
leaq 0x2e9e(%rip), %rsi      # 0x4040
shlq $0x2, %rax
addq %rax, %rsi
callq 0x13e0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1189
jmp 0x11bb
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x14c0
cmpl $-0x2, %eax
je 0x11e0
movl -0x18(%rbp), %esi
leaq 0xe2d(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
jmp 0x11bb
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xtanitfy[P]Murphy/src/queue.c
// Function: QUEUE_create
QUEUE_s *QUEUE_create(int itemSize,int nMax)
{
	QUEUE_s *pQ = (QUEUE_s *)malloc(sizeof(QUEUE_s));
	CHECK_EXPR_RET(pQ == NULL,NULL);

	pQ->data = (void *)malloc(itemSize * nMax);
	CHECK_EXPR_RET(pQ->data == NULL,NULL);
	pQ->itemSize = itemSize;
	pQ->nMax = nMax;
	pQ->head = 0;
	pQ->tail = 0;
	return pQ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
movl $0x18, %edi
callq 0x1050
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1241
leaq 0xdf2(%rip), %rdi       # 0x200c
leaq 0xe01(%rip), %rsi       # 0x2022
leaq 0xe02(%rip), %rdx       # 0x202a
movl $0x9, %ecx
movb $0x0, %al
callq 0x1030
movq $0x0, -0x8(%rbp)
jmp 0x12c2
movl -0xc(%rbp), %eax
imull -0x10(%rbp), %eax
movslq %eax, %rdi
callq 0x1050
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x1291
leaq 0xd9f(%rip), %rdi       # 0x200c
leaq 0xdae(%rip), %rsi       # 0x2022
leaq 0xdaf(%rip), %rdx       # 0x202a
movl $0xc, %ecx
movb $0x0, %al
callq 0x1030
movq $0x0, -0x8(%rbp)
jmp 0x12c2
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x14(%rax)
movl -0x10(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/xtanitfy[P]Murphy/src/queue.c
// Function: QUEUE_empty
BOOL QUEUE_empty(QUEUE_s *pQ)
{
	CHECK_EXPR_RET(pQ == NULL,TRUE);

	if (pQ->head == pQ->tail ) {
		return TRUE;
	}

	return FALSE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x130a
leaq 0xd22(%rip), %rdi       # 0x200c
leaq 0xd31(%rip), %rsi       # 0x2022
leaq 0xd3f(%rip), %rdx       # 0x2037
movl $0x17, %ecx
movb $0x0, %al
callq 0x1030
movb $0x1, -0x1(%rbp)
jmp 0x1323
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jne 0x131f
movb $0x1, -0x1(%rbp)
jmp 0x1323
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/xtanitfy[P]Murphy/src/queue.c
// Function: QUEUE_lastItem
int QUEUE_lastItem(QUEUE_s *pQ,void *item)
{
	int last = pQ->tail % pQ->nMax;
	last--;
	if (last < 0) {
		last = pQ->nMax - last;
	}
	memcpy(item,(char *)pQ->data + last*pQ->itemSize,pQ->itemSize);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x8(%rbp), %rcx
cltd
idivl 0x10(%rcx)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x13ae
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
subl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
imull 0x14(%rcx), %eax
cltq
addq %rax, %rsi
movq -0x8(%rbp), %rax
movslq 0x14(%rax), %rdx
callq 0x1040
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/xtanitfy[P]Murphy/src/queue.c
// Function: QUEUE_enqueue
int QUEUE_enqueue(QUEUE_s *pQ,void *item)
{
	CHECK_EXPR_RET(pQ == NULL,-1);

	if (QUEUE_full(pQ) == TRUE) {
		printf("Queue is full!\n");
		return QUEUE_FULL;
	}
	
	memcpy((char *)pQ->data + pQ->tail*pQ->itemSize,item,pQ->itemSize);
	pQ->tail++;
	pQ->tail %= pQ->nMax;
	
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1424
leaq 0xc0e(%rip), %rdi       # 0x200c
leaq 0xc1d(%rip), %rsi       # 0x2022
leaq 0xc37(%rip), %rdx       # 0x2043
movl $0x36, %ecx
movb $0x0, %al
callq 0x1030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x14a9
movq -0x10(%rbp), %rdi
callq 0x1330
movsbl %al, %eax
cmpl $0x1, %eax
jne 0x144c
leaq 0xc15(%rip), %rdi       # 0x2051
movb $0x0, %al
callq 0x1030
movl $0xfffffffd, -0x4(%rbp) # imm = 0xFFFFFFFD
jmp 0x14a9
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x10(%rbp), %rcx
imull 0x14(%rcx), %eax
cltq
addq %rax, %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
movslq 0x14(%rax), %rdx
callq 0x1040
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl 0x4(%rax), %eax
cltd
idivl %ecx
movq -0x20(%rbp), %rax
movl %edx, 0x4(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xtanitfy[P]Murphy/src/queue.c
// Function: QUEUE_dequeue
int QUEUE_dequeue(QUEUE_s *pQ,void *item)
{
	CHECK_EXPR_RET(pQ == NULL,-1);

	if (QUEUE_empty(pQ) == TRUE) {
		return QUEUE_EMPTY;
	}

	memcpy(item,(char *)pQ->data + pQ->head*pQ->itemSize,pQ->itemSize);
	pQ->head++;
	pQ->head %= pQ->nMax;
	
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1501
leaq 0xb2e(%rip), %rdi       # 0x200c
leaq 0xb3d(%rip), %rsi       # 0x2022
leaq 0xb75(%rip), %rdx       # 0x2061
movl $0x46, %ecx
movb $0x0, %al
callq 0x1030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1573
movq -0x10(%rbp), %rdi
callq 0x12d0
movsbl %al, %eax
cmpl $0x1, %eax
jne 0x151b
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x1573
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
imull 0x14(%rcx), %eax
cltq
addq %rax, %rsi
movq -0x10(%rbp), %rax
movslq 0x14(%rax), %rdx
callq 0x1040
movq -0x10(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl (%rax), %eax
cltd
idivl %ecx
movq -0x20(%rbp), %rax
movl %edx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/error.c
// Function: gt_error_set
void gt_error_set(GtError *err, const char *format, ...)
{
  va_list ap;
  if (!err) return;
  va_start(ap, format);
  gt_error_vset(err, format, ap);
  va_end(ap);
}

// Assembly:
subq $0xd8, %rsp
testb %al, %al
je 0xc10c
movaps %xmm0, 0x30(%rsp)
movaps %xmm1, 0x40(%rsp)
movaps %xmm2, 0x50(%rsp)
movaps %xmm3, 0x60(%rsp)
movaps %xmm4, 0x70(%rsp)
movaps %xmm5, 0x80(%rsp)
movaps %xmm6, 0x90(%rsp)
movaps %xmm7, 0xa0(%rsp)
movq %r9, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rdi, 0xd0(%rsp)
movq %rsi, 0xc8(%rsp)
cmpq $0x0, 0xd0(%rsp)
jne 0xc13d
jmp 0xc18a
leaq 0xb0(%rsp), %rax
movq %rsp, %rcx
movq %rcx, 0x10(%rax)
leaq 0xe0(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq 0xd0(%rsp), %rdi
movq 0xc8(%rsp), %rsi
leaq 0xb0(%rsp), %rdx
callq 0xc1a0
leaq 0xb0(%rsp), %rax
addq $0xd8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/init.c
// Function: gt_lib_init
void gt_lib_init(void)
{
  const char *bookkeeping;
  bookkeeping = getenv("GT_MEM_BOOKKEEPING");
  gt_ma_init(bookkeeping && !strcmp(bookkeeping, "on"));
  proc_env_options();
  if (spacepeak && !(bookkeeping && !strcmp(bookkeeping, "on")))
    gt_warning("GT_ENV_OPTIONS=-spacepeak used without GT_MEM_BOOKKEEPING=on");
  gt_fa_init();
  if (spacepeak) {
    gt_spacepeak_init();
    gt_ma_enable_global_spacepeak();
    gt_fa_enable_global_spacepeak();
  }
  gt_log_init();
  if (showtime) gt_showtime_enable();
  gt_symbol_init();
  gt_class_alloc_lock_init();
  gt_ya_rand_init(0);
#ifdef HAVE_MYSQL
  mysql_library_init(0, NULL, NULL);
#endif
  gt_combinatorics_init();
}

// Assembly:
subq $0x18, %rsp
leaq 0x151d41(%rip), %rdi    # 0x15e22c
callq 0xb790
movq %rax, 0x10(%rsp)
xorl %eax, %eax
cmpq $0x0, 0x10(%rsp)
movb %al, 0xf(%rsp)
je 0xc520
movq 0x10(%rsp), %rdi
leaq 0x15ed14(%rip), %rsi    # 0x16b223
callq 0xb850
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
movzbl %al, %edi
andl $0x1, %edi
callq 0xd100
callq 0xc5c0
testb $0x1, 0x1a9d86(%rip)    # 0x1b62c1
je 0xc569
cmpq $0x0, 0x10(%rsp)
je 0xc55b
movq 0x10(%rsp), %rdi
leaq 0x15ecd2(%rip), %rsi    # 0x16b223
callq 0xb850
cmpl $0x0, %eax
je 0xc569
leaq 0x151cdd(%rip), %rdi    # 0x15e23f
movb $0x0, %al
callq 0x1c550
callq 0x7f4b0
testb $0x1, 0x1a9d4c(%rip)    # 0x1b62c1
je 0xc586
callq 0x16710
callq 0xdc50
callq 0x821e0
callq 0xc8d0
testb $0x1, 0x1a9d30(%rip)    # 0x1b62c2
je 0xc599
callq 0x166e0
callq 0x1ba70
callq 0x7b710
xorl %edi, %edi
callq 0x1ce20
callq 0x7b7f0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/init.c
// Function: proc_env_options
static void proc_env_options(void)
{
  int argc;
  char *env_options, **argv;
  GtSplitter *splitter;
  GtError *err;
  /* construct argument vector from $GT_ENV_OPTIONS */
  env_options = getenv("GT_ENV_OPTIONS");
  if (!env_options)
    return;
  env_options = gt_cstr_dup(env_options); /* make writeable copy */
  splitter = gt_splitter_new();
  gt_splitter_split(splitter, env_options, strlen(env_options), ' ');
  argc = gt_splitter_size(splitter);
  argv = gt_cstr_array_preprend((const char**) gt_splitter_get_tokens(splitter),
                             "env");
  argc++;
  /* parse options contained in $GT_ENV_OPTIONS */
  err = gt_error_new();
  switch (parse_env_options(argc, (const char**) argv, err)) {
    case GT_OPTION_PARSER_OK: break;
    case GT_OPTION_PARSER_ERROR:
      fprintf(stderr, "error parsing $GT_ENV_OPTIONS: %s\n", gt_error_get(err));
      gt_error_unset(err);
      break;
    case GT_OPTION_PARSER_REQUESTS_EXIT: break;
  }
  gt_error_delete(err);
  gt_free(env_options);
  gt_splitter_delete(splitter);
  gt_cstr_array_delete(argv);
}

// Assembly:
subq $0x48, %rsp
leaq 0x151cb1(%rip), %rdi    # 0x15e27c
callq 0xb790
movq %rax, 0x38(%rsp)
cmpq $0x0, 0x38(%rsp)
jne 0xc5e2
jmp 0xc711
movq 0x38(%rsp), %rdi
callq 0x7c400
movq %rax, 0x38(%rsp)
callq 0x16a10
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xb240
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rax, %rdx
movl $0x20, %ecx
callq 0x16a30
movq 0x28(%rsp), %rdi
callq 0x17010
movl %eax, 0x44(%rsp)
movq 0x28(%rsp), %rdi
callq 0x16ed0
movq %rax, %rdi
leaq 0x15f1bc(%rip), %rsi    # 0x16b809
callq 0x7cd90
movq %rax, 0x30(%rsp)
movl 0x44(%rsp), %eax
incl %eax
movl %eax, 0x44(%rsp)
callq 0xc0b0
movq %rax, 0x20(%rsp)
movl 0x44(%rsp), %edi
movq 0x30(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0xc800
movl %eax, %ecx
movl %ecx, 0x1c(%rsp)
testl %eax, %eax
je 0xc6a0
jmp 0xc68a
movl 0x1c(%rsp), %eax
subl $0x1, %eax
je 0xc6a2
jmp 0xc695
movl 0x1c(%rsp), %eax
subl $0x2, %eax
je 0xc6db
jmp 0xc6dd
jmp 0xc6dd
movq 0x1a792f(%rip), %rax    # 0x1b3fd8
movq (%rax), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rdi
callq 0xc330
movq (%rsp), %rdi
movq %rax, %rdx
leaq 0x151bc3(%rip), %rsi    # 0x15e28b
movb $0x0, %al
callq 0xb890
movq 0x20(%rsp), %rdi
callq 0xc2d0
jmp 0xc6dd
jmp 0xc6dd
movq 0x20(%rsp), %rdi
callq 0xc490
movq 0x38(%rsp), %rdi
leaq 0x151bbb(%rip), %rsi    # 0x15e2ae
movl $0x5f, %edx
callq 0xdab0
movq 0x28(%rsp), %rdi
callq 0x17060
movq 0x30(%rsp), %rdi
callq 0x7cfa0
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/init.c
// Function: gt_lib_clean
int gt_lib_clean(void)
{
  int fa_fptr_rval, fa_mmap_rval, gt_rval;
  if (spacepeak) {
    gt_ma_show_space_peak(stdout);
    gt_fa_show_space_peak(stdout);
    gt_spacepeak_show_space_peak(stdout);
    gt_ma_disable_global_spacepeak();
  }
  fa_fptr_rval = gt_fa_check_fptr_leak();
  fa_mmap_rval = gt_fa_check_mmap_leak();
  gt_fa_clean();
  gt_symbol_clean();
  gt_class_alloc_clean();
  gt_class_alloc_lock_clean();
  gt_ya_rand_clean();
  gt_log_clean();
  gt_spacepeak_clean();
  gt_combinatorics_clean();
  gt_rval = gt_ma_check_space_leak();
  gt_ma_clean();
#ifdef HAVE_MYSQL
  mysql_library_end();
#endif
  return fa_fptr_rval || fa_mmap_rval || gt_rval;
}

// Assembly:
subq $0x18, %rsp
testb $0x1, 0x1a9b76(%rip)    # 0x1b62c1
je 0xc77f
movq 0x1a785c(%rip), %rax    # 0x1b3fb0
movq (%rax), %rdi
callq 0xddd0
movq 0x1a784d(%rip), %rax    # 0x1b3fb0
movq (%rax), %rdi
callq 0x82300
movq 0x1a783e(%rip), %rax    # 0x1b3fb0
movq (%rax), %rdi
callq 0x16940
callq 0xdcb0
callq 0x81e90
movl %eax, 0x14(%rsp)
callq 0x82030
movl %eax, 0x10(%rsp)
callq 0x823a0
callq 0x1bb30
callq 0x7b680
callq 0x7b720
callq 0x1cf70
callq 0xca50
callq 0x169e0
callq 0x7bce0
callq 0xde80
movl %eax, 0xc(%rsp)
callq 0xe2d0
movb $0x1, %al
cmpl $0x0, 0x14(%rsp)
movb %al, 0xb(%rsp)
jne 0xc7ed
movb $0x1, %al
cmpl $0x0, 0x10(%rsp)
movb %al, 0xb(%rsp)
jne 0xc7ed
cmpl $0x0, 0xc(%rsp)
setne %al
movb %al, 0xb(%rsp)
movb 0xb(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/init.c
// Function: parse_env_options
static GtOPrval parse_env_options(int argc, const char **argv, GtError *err)
{
  GtOptionParser *op;
  GtOption *o;
  GtOPrval oprval;
  op = gt_option_parser_new("GT_ENV_OPTIONS='[option ...]' ...",
                         "Parse the options contained in the "
                         "environment variable GT_ENV_OPTIONS.");
  o = gt_option_new_bool("spacepeak", "show space peak on stdout upon deletion",
                         &spacepeak, false);
  gt_option_parser_add_option(op, o);
  o = gt_option_new_bool("showtime", "enable output for run-time statistics",
                         &showtime, false);
  gt_option_parser_add_option(op, o);
  gt_option_parser_set_max_args(op, 0);
  oprval = gt_option_parser_parse(op, NULL, argc, argv, gt_versionfunc, err);
  gt_option_parser_delete(op);
  return oprval;
}

// Assembly:
subq $0x38, %rsp
movl %edi, 0x34(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
leaq 0x151aa5(%rip), %rdi    # 0x15e2be
leaq 0x151ac0(%rip), %rsi    # 0x15e2e0
callq 0xe920
movq %rax, 0x18(%rsp)
leaq 0x1617be(%rip), %rdi    # 0x16dfef
leaq 0x151af0(%rip), %rsi    # 0x15e328
leaq 0x1a9a82(%rip), %rdx    # 0x1b62c1
xorl %ecx, %ecx
callq 0x13420
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xeb00
leaq 0x151aef(%rip), %rdi    # 0x15e350
leaq 0x151af1(%rip), %rsi    # 0x15e359
leaq 0x1a9a53(%rip), %rdx    # 0x1b62c2
xorl %ecx, %ecx
callq 0x13420
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xeb00
movq 0x18(%rsp), %rdi
xorl %esi, %esi
callq 0xfee0
movq 0x18(%rsp), %rdi
movl 0x34(%rsp), %edx
movq 0x28(%rsp), %rcx
movq 0x20(%rsp), %r9
xorl %eax, %eax
movl %eax, %esi
leaq 0xfbfc(%rip), %r8       # 0x1c4b0
callq 0xffb0
movl %eax, 0xc(%rsp)
movq 0x18(%rsp), %rdi
callq 0x131f0
movl 0xc(%rsp), %eax
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/logger.c
// Function: gt_logger_new
GtLogger* gt_logger_new(bool enabled, const char *prefix, FILE *target)
{
  GtLogger *l;
  gt_assert(target);
  l = (GtLogger*) gt_calloc((size_t) 1, sizeof (GtLogger));
  l->target = target;
  l->prefix = gt_cstr_dup(prefix);
  l->enabled = enabled;
  return l;
}

// Assembly:
subq $0x28, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, 0x27(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0xcab7
movq 0x1a7552(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x1515d6(%rip), %rsi    # 0x15e066
leaq 0x1519ac(%rip), %rdx    # 0x15e443
leaq 0x1518e9(%rip), %rcx    # 0x15e387
leaq 0x1518f0(%rip), %r8     # 0x15e395
movl $0x23, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xcab9
movl $0x1, %edi
movl $0x18, %esi
leaq 0x1518cb(%rip), %rdx    # 0x15e395
movl $0x24, %ecx
callq 0xd5b0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rdi
callq 0x7c400
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movb 0x27(%rsp), %cl
movq 0x8(%rsp), %rax
andb $0x1, %cl
movb %cl, 0x10(%rax)
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/logger.c
// Function: gt_logger_log_force
void gt_logger_log_force(GtLogger *logger, const char *format, ...)
{
  va_list ap;
  if (!logger) return;
  gt_assert(format);
  va_start(ap, format);
  gt_logger_log_va_force(logger, format, ap);
  va_end(ap);
}

// Assembly:
subq $0xd8, %rsp
testb %al, %al
je 0xcd1c
movaps %xmm0, 0x30(%rsp)
movaps %xmm1, 0x40(%rsp)
movaps %xmm2, 0x50(%rsp)
movaps %xmm3, 0x60(%rsp)
movaps %xmm4, 0x70(%rsp)
movaps %xmm5, 0x80(%rsp)
movaps %xmm6, 0x90(%rsp)
movaps %xmm7, 0xa0(%rsp)
movq %r9, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rdi, 0xd0(%rsp)
movq %rsi, 0xc8(%rsp)
cmpq $0x0, 0xd0(%rsp)
jne 0xcd50
jmp 0xcde4
jmp 0xcd52
cmpq $0x0, 0xc8(%rsp)
jne 0xcd95
movq 0x1a7274(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x1512f8(%rip), %rsi    # 0x15e066
leaq 0x151421(%rip), %rdx    # 0x15e196
leaq 0x151693(%rip), %rcx    # 0x15e40f
leaq 0x151612(%rip), %r8     # 0x15e395
movl $0x4d, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xcd97
leaq 0xb0(%rsp), %rax
movq %rsp, %rcx
movq %rcx, 0x10(%rax)
leaq 0xe0(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq 0xd0(%rsp), %rdi
movq 0xc8(%rsp), %rsi
leaq 0xb0(%rsp), %rdx
callq 0xcdf0
leaq 0xb0(%rsp), %rax
addq $0xd8, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/logger.c
// Function: gt_logger_log_va_force
void gt_logger_log_va_force(GtLogger *logger, const char *format, va_list ap)
{
  if (!logger) return;
  gt_assert(format && logger->target);
  if (logger->prefix != NULL)
    fprintf(logger->target, "%s", logger->prefix);
  (void) vfprintf(logger->target, format, ap);
  (void) putc('\n', logger->target);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0xce0f
jmp 0xceb1
jmp 0xce11
cmpq $0x0, 0x8(%rsp)
je 0xce24
movq 0x10(%rsp), %rax
cmpq $0x0, (%rax)
jne 0xce5c
movq 0x1a71ad(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x151231(%rip), %rsi    # 0x15e066
leaq 0x1515f5(%rip), %rdx    # 0x15e431
leaq 0x151607(%rip), %rcx    # 0x15e44a
leaq 0x15154b(%rip), %r8     # 0x15e395
movl $0x61, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xce5e
movq 0x10(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0xce89
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdx
leaq 0x15f02b(%rip), %rsi    # 0x16bead
movb $0x0, %al
callq 0xb890
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq 0xb7e0
movq 0x10(%rsp), %rax
movq (%rax), %rsi
movl $0xa, %edi
callq 0xbc50
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/logger.c
// Function: gt_logger_log
void gt_logger_log(GtLogger *logger, const char *format, ...)
{
  va_list ap;
  if (!logger) return;
  if (!logger->enabled) return;
  gt_assert(format);
  va_start(ap, format);
  gt_logger_log_va(logger, format, ap);
  va_end(ap);
}

// Assembly:
subq $0xd8, %rsp
testb %al, %al
je 0xcefc
movaps %xmm0, 0x30(%rsp)
movaps %xmm1, 0x40(%rsp)
movaps %xmm2, 0x50(%rsp)
movaps %xmm3, 0x60(%rsp)
movaps %xmm4, 0x70(%rsp)
movaps %xmm5, 0x80(%rsp)
movaps %xmm6, 0x90(%rsp)
movaps %xmm7, 0xa0(%rsp)
movq %r9, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rdi, 0xd0(%rsp)
movq %rsi, 0xc8(%rsp)
cmpq $0x0, 0xd0(%rsp)
jne 0xcf30
jmp 0xcfd7
movq 0xd0(%rsp), %rax
testb $0x1, 0x10(%rax)
jne 0xcf43
jmp 0xcfd7
jmp 0xcf45
cmpq $0x0, 0xc8(%rsp)
jne 0xcf88
movq 0x1a7081(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x151105(%rip), %rsi    # 0x15e066
leaq 0x15122e(%rip), %rdx    # 0x15e196
leaq 0x1514b4(%rip), %rcx    # 0x15e423
leaq 0x15141f(%rip), %r8     # 0x15e395
movl $0x58, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xcf8a
leaq 0xb0(%rsp), %rax
movq %rsp, %rcx
movq %rcx, 0x10(%rax)
leaq 0xe0(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq 0xd0(%rsp), %rdi
movq 0xc8(%rsp), %rsi
leaq 0xb0(%rsp), %rdx
callq 0xcfe0
leaq 0xb0(%rsp), %rax
addq $0xd8, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/logger.c
// Function: gt_logger_log_va
void gt_logger_log_va(GtLogger *logger, const char *format, va_list ap)
{
  if (!logger) return;
  if (!logger->enabled) return;
  gt_assert(format && logger->target);
  if (logger->prefix != NULL)
    fprintf(logger->target, "%s", logger->prefix);
  (void) vfprintf(logger->target, format, ap);
  (void) putc('\n', logger->target);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0xcfff
jmp 0xd0b1
movq 0x10(%rsp), %rax
testb $0x1, 0x10(%rax)
jne 0xd00f
jmp 0xd0b1
jmp 0xd011
cmpq $0x0, 0x8(%rsp)
je 0xd024
movq 0x10(%rsp), %rax
cmpq $0x0, (%rax)
jne 0xd05c
movq 0x1a6fad(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x151031(%rip), %rsi    # 0x15e066
leaq 0x1513f5(%rip), %rdx    # 0x15e431
leaq 0x15141e(%rip), %rcx    # 0x15e461
leaq 0x15134b(%rip), %r8     # 0x15e395
movl $0x6c, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xd05e
movq 0x10(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0xd089
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdx
leaq 0x15ee2b(%rip), %rsi    # 0x16bead
movb $0x0, %al
callq 0xb890
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq 0xb7e0
movq 0x10(%rsp), %rax
movq (%rax), %rsi
movl $0xa, %edi
callq 0xbc50
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/ma.c
// Function: gt_ma_init
void gt_ma_init(bool bookkeeping)
{
  gt_assert(!ma);
  ma = xcalloc(1, sizeof (MA), 0, __FILE__, __LINE__);
  gt_assert(!ma->bookkeeping);
  ma->allocated_pointer = gt_hashmap_new_no_ma(GT_HASH_DIRECT, NULL,
                                               (GtFree) ma_info_free);
  /* MA is ready to use */
  ma->bookkeeping = bookkeeping;
  bookkeeping_lock = gt_mutex_new();
  ma->global_space_peak = false;
}

// Assembly:
pushq %rax
movb %dil, %al
andb $0x1, %al
movb %al, 0x7(%rsp)
cmpq $0x0, 0x1a91be(%rip)    # 0x1b62d0
je 0xd14c
movq 0x1a6ebd(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x150f41(%rip), %rsi    # 0x15e066
leaq 0x151374(%rip), %rdx    # 0x15e4a0
leaq 0x151371(%rip), %rcx    # 0x15e4a4
leaq 0x151375(%rip), %r8     # 0x15e4af
movl $0x6a, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xd14e
movl $0x1, %edi
movl $0x28, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x15134c(%rip), %rcx    # 0x15e4af
movl $0x6b, %r8d
callq 0xd210
movq %rax, 0x1a915b(%rip)    # 0x1b62d0
movq 0x1a9154(%rip), %rax    # 0x1b62d0
testb $0x1, 0x8(%rax)
je 0xd1ba
movq 0x1a6e4f(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x150ed3(%rip), %rsi    # 0x15e066
leaq 0x151323(%rip), %rdx    # 0x15e4bd
leaq 0x151303(%rip), %rcx    # 0x15e4a4
leaq 0x151307(%rip), %r8     # 0x15e4af
movl $0x6c, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xd1bc
xorl %edi, %edi
xorl %eax, %eax
movl %eax, %esi
leaq 0x107(%rip), %rdx       # 0xd2d0
callq 0x86430
movq %rax, %rcx
movq 0x1a90f8(%rip), %rax    # 0x1b62d0
movq %rcx, (%rax)
movb 0x7(%rsp), %cl
movq 0x1a90ea(%rip), %rax    # 0x1b62d0
andb $0x1, %cl
movb %cl, 0x8(%rax)
callq 0x1c240
movq %rax, 0x1a90e0(%rip)    # 0x1b62d8
movq 0x1a90d1(%rip), %rax    # 0x1b62d0
movb $0x0, 0x9(%rax)
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/ma.c
// Function: xcalloc
static void* xcalloc(size_t nmemb, size_t size, GtUword current_size,
                     const char *src_file, int src_line)
{
  void *p;
  if ((p = calloc(nmemb, size)) == NULL) {
    fprintf(stderr, "cannot calloc("GT_ZU", "GT_ZU") memory\n", nmemb, size);
    fprintf(stderr, "attempted on line %d in file \"%s\"\n", src_line,
           src_file);
    if (current_size)
      fprintf(stderr, GT_WU " bytes were allocated altogether\n", current_size);
    exit(EXIT_FAILURE);
  }
  return p;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movl %r8d, 0x14(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0xb3f0
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
jne 0xd2b9
movq 0x1a6d8a(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
movq 0x30(%rsp), %rdx
movq 0x28(%rsp), %rcx
leaq 0x151414(%rip), %rsi    # 0x15e676
movb $0x0, %al
callq 0xb890
movq 0x1a6d68(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
movl 0x14(%rsp), %edx
movq 0x18(%rsp), %rcx
leaq 0x15129c(%rip), %rsi    # 0x15e51f
movb $0x0, %al
callq 0xb890
cmpq $0x0, 0x20(%rsp)
je 0xd2af
movq 0x1a6d3f(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
movq 0x20(%rsp), %rdx
leaq 0x1513ee(%rip), %rsi    # 0x15e696
movb $0x0, %al
callq 0xb890
movl $0x1, %edi
callq 0xb780
movq 0x8(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/ma.c
// Function: gt_malloc_mem
void* gt_malloc_mem(size_t size, const char *src_file, int src_line)
{
  MAInfo *mainfo;
  void *mem;
  gt_assert(ma);
  if (ma->bookkeeping) {
    gt_mutex_lock(bookkeeping_lock);
    ma->mallocevents++;
    mainfo = xmalloc(sizeof *mainfo, ma->current_size, src_file, src_line);
    mainfo->size = size;
    mainfo->src_file = src_file;
    mainfo->src_line = src_line;
    mem = xmalloc(size, ma->current_size, src_file, src_line);
    gt_hashmap_add(ma->allocated_pointer, mem, mainfo);
    add_size(ma, size);
    gt_mutex_unlock(bookkeeping_lock);
    return mem;
  }
  return xmalloc(size, ma->current_size, src_file, src_line);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
cmpq $0x0, 0x1a8fd6(%rip)    # 0x1b62d0
jne 0xd334
movq 0x1a6cd5(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x150d59(%rip), %rsi    # 0x15e066
leaq 0x15118d(%rip), %rdx    # 0x15e4a1
leaq 0x1511b3(%rip), %rcx    # 0x15e4ce
leaq 0x15118d(%rip), %r8     # 0x15e4af
movl $0x8c, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xd336
movq 0x1a8f93(%rip), %rax    # 0x1b62d0
testb $0x1, 0x8(%rax)
je 0xd415
movq 0x1a8f8a(%rip), %rdi    # 0x1b62d8
callq 0x1c340
movq 0x1a8f76(%rip), %rax    # 0x1b62d0
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
movq 0x1a8f63(%rip), %rax    # 0x1b62d0
movq 0x18(%rax), %rsi
movq 0x20(%rsp), %rdx
movl 0x1c(%rsp), %ecx
movl $0x18, %edi
callq 0xd450
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x20(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movl 0x1c(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x10(%rax)
movq 0x28(%rsp), %rdi
movq 0x1a8f14(%rip), %rax    # 0x1b62d0
movq 0x18(%rax), %rsi
movq 0x20(%rsp), %rdx
movl 0x1c(%rsp), %ecx
callq 0xd450
movq %rax, 0x8(%rsp)
movq 0x1a8ef6(%rip), %rax    # 0x1b62d0
movq (%rax), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x86510
movq 0x1a8edd(%rip), %rdi    # 0x1b62d0
movq 0x28(%rsp), %rsi
callq 0xd500
movq 0x1a8ed4(%rip), %rdi    # 0x1b62d8
callq 0x1c3e0
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0xd438
movq 0x28(%rsp), %rdi
movq 0x1a8eaf(%rip), %rax    # 0x1b62d0
movq 0x18(%rax), %rsi
movq 0x20(%rsp), %rdx
movl 0x1c(%rsp), %ecx
callq 0xd450
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/ma.c
// Function: xmalloc
static void* xmalloc(size_t size, GtUword current_size,
                     const char *src_file, int src_line)
{
  void *p;
  if ((p = malloc(size)) == NULL) {
    fprintf(stderr, "cannot malloc("GT_ZU") memory\n", size);
    fprintf(stderr, "attempted on line %d in file \"%s\"\n", src_line,
            src_file);
    if (current_size)
      fprintf(stderr, GT_WU " bytes were allocated altogether\n", current_size);
    exit(EXIT_FAILURE);
  }
  return p;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movl %ecx, 0xc(%rsp)
movq 0x20(%rsp), %rdi
callq 0xbcb8
movq %rax, (%rsp)
cmpq $0x0, %rax
jne 0xd4e8
movq 0x1a6b56(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
movq 0x20(%rsp), %rdx
leaq 0x15122a(%rip), %rsi    # 0x15e6bb
movb $0x0, %al
callq 0xb890
movq 0x1a6b39(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
movl 0xc(%rsp), %edx
movq 0x10(%rsp), %rcx
leaq 0x15106d(%rip), %rsi    # 0x15e51f
movb $0x0, %al
callq 0xb890
cmpq $0x0, 0x18(%rsp)
je 0xd4de
movq 0x1a6b10(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
movq 0x18(%rsp), %rdx
leaq 0x1511bf(%rip), %rsi    # 0x15e696
movb $0x0, %al
callq 0xb890
movl $0x1, %edi
callq 0xb780
movq (%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/ma.c
// Function: add_size
static void add_size(MA* ma, GtUword size)
{
  gt_assert(ma);
  ma->current_size += size;
  if (ma->global_space_peak)
    gt_spacepeak_add(size);
  if (ma->current_size > ma->max_size)
    ma->max_size = ma->current_size;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0xd54e
movq 0x1a6abb(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x150b3f(%rip), %rsi    # 0x15e066
leaq 0x150f73(%rip), %rdx    # 0x15e4a1
leaq 0x1511a1(%rip), %rcx    # 0x15e6d6
leaq 0x150f73(%rip), %r8     # 0x15e4af
movl $0x77, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xd550
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
addq 0x18(%rax), %rcx
movq %rcx, 0x18(%rax)
movq 0x10(%rsp), %rax
testb $0x1, 0x9(%rax)
je 0xd577
movq 0x8(%rsp), %rdi
callq 0x167a0
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x10(%rsp), %rcx
cmpq 0x20(%rcx), %rax
jbe 0xd59d
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x20(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/ma.c
// Function: gt_calloc_mem
void* gt_calloc_mem(size_t nmemb, size_t size, const char *src_file,
                    int src_line)
{
  MAInfo *mainfo;
  void *mem;
  gt_assert(ma);
  if (ma->bookkeeping) {
    gt_mutex_lock(bookkeeping_lock);
    ma->mallocevents++;
    mainfo = xmalloc(sizeof *mainfo, ma->current_size, src_file, src_line);
    mainfo->size = nmemb * size;
    mainfo->src_file = src_file;
    mainfo->src_line = src_line;
    mem = xcalloc(nmemb, size, ma->current_size, src_file, src_line);
    gt_hashmap_add(ma->allocated_pointer, mem, mainfo);
    add_size(ma, nmemb * size);
    gt_mutex_unlock(bookkeeping_lock);
    return mem;
  }
  return xcalloc(nmemb, size, ma->current_size, src_file, src_line);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movl %ecx, 0x14(%rsp)
cmpq $0x0, 0x1a8d01(%rip)    # 0x1b62d0
jne 0xd609
movq 0x1a6a00(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x150a84(%rip), %rsi    # 0x15e066
leaq 0x150eb8(%rip), %rdx    # 0x15e4a1
leaq 0x150eec(%rip), %rcx    # 0x15e4dc
leaq 0x150eb8(%rip), %r8     # 0x15e4af
movl $0xa2, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xd60b
movq 0x1a8cbe(%rip), %rax    # 0x1b62d0
testb $0x1, 0x8(%rax)
je 0xd6f9
movq 0x1a8cb5(%rip), %rdi    # 0x1b62d8
callq 0x1c340
movq 0x1a8ca1(%rip), %rax    # 0x1b62d0
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
movq 0x1a8c8e(%rip), %rax    # 0x1b62d0
movq 0x18(%rax), %rsi
movq 0x18(%rsp), %rdx
movl 0x14(%rsp), %ecx
movl $0x18, %edi
callq 0xd450
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rcx
imulq 0x20(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movl 0x14(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x10(%rax)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x1a8c34(%rip), %rax    # 0x1b62d0
movq 0x18(%rax), %rdx
movq 0x18(%rsp), %rcx
movl 0x14(%rsp), %r8d
callq 0xd210
movq %rax, (%rsp)
movq 0x1a8c16(%rip), %rax    # 0x1b62d0
movq (%rax), %rdi
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x86510
movq 0x1a8bfe(%rip), %rdi    # 0x1b62d0
movq 0x28(%rsp), %rsi
imulq 0x20(%rsp), %rsi
callq 0xd500
movq 0x1a8bef(%rip), %rdi    # 0x1b62d8
callq 0x1c3e0
movq (%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0xd722
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x1a8bc6(%rip), %rax    # 0x1b62d0
movq 0x18(%rax), %rdx
movq 0x18(%rsp), %rcx
movl 0x14(%rsp), %r8d
callq 0xd210
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/ma.c
// Function: subtract_size
static void subtract_size(MA *ma, GtUword size)
{
  gt_assert(ma);
  gt_assert(ma->current_size >= size);
  ma->current_size -= size;
  if (ma->global_space_peak)
    gt_spacepeak_free(size);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0xd97e
movq 0x1a668b(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x15070f(%rip), %rsi    # 0x15e066
leaq 0x150b43(%rip), %rdx    # 0x15e4a1
leaq 0x150d7a(%rip), %rcx    # 0x15e6df
leaq 0x150b43(%rip), %r8     # 0x15e4af
movl $0x81, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xd980
jmp 0xd982
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
cmpq 0x8(%rsp), %rax
jae 0xd9ca
movq 0x1a663f(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x1506c3(%rip), %rsi    # 0x15e066
leaq 0x150d43(%rip), %rdx    # 0x15e6ed
leaq 0x150d2e(%rip), %rcx    # 0x15e6df
leaq 0x150af7(%rip), %r8     # 0x15e4af
movl $0x82, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xd9cc
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x18(%rax)
movq 0x10(%rsp), %rax
testb $0x1, 0x9(%rax)
je 0xd9f6
movq 0x8(%rsp), %rdi
callq 0x16850
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/ma.c
// Function: xrealloc
static void* xrealloc(void *ptr, size_t size, GtUword current_size,
                      const char *src_file, int src_line)
{
  void *p;
  if ((p = realloc(ptr, size)) == NULL) {
    fprintf(stderr, "cannot realloc("GT_ZU") memory\n", size);
    fprintf(stderr, "attempted on line %d in file \"%s\"\n", src_line,
            src_file);
    if (current_size)
      fprintf(stderr, GT_WU " bytes were allocated altogether\n", current_size);
    exit(EXIT_FAILURE);
  }
  return p;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movl %r8d, 0x14(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0xba30
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
jne 0xdaa4
movq 0x1a659a(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
movq 0x28(%rsp), %rdx
leaq 0x150cb9(%rip), %rsi    # 0x15e706
movb $0x0, %al
callq 0xb890
movq 0x1a657d(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
movl 0x14(%rsp), %edx
movq 0x18(%rsp), %rcx
leaq 0x150ab1(%rip), %rsi    # 0x15e51f
movb $0x0, %al
callq 0xb890
cmpq $0x0, 0x20(%rsp)
je 0xda9a
movq 0x1a6554(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
movq 0x20(%rsp), %rdx
leaq 0x150c03(%rip), %rsi    # 0x15e696
movb $0x0, %al
callq 0xb890
movl $0x1, %edi
callq 0xb780
movq 0x8(%rsp), %rax
addq $0x38, %rsp
retq
nop