LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: AndreyVV-100[P]GachiLang/TreeBase/Tree.cpp
// Function: SaveElem(element*, _IO_FILE*, int)
void SaveElem (element* el, FILE* tree_file, int tab)
{
    assert (tree_file);

    if (!el)
    {
        fprintf (tree_file, "\n");
        return;
    }

    fprintf (tree_file, "%*s%s %s\n", tab * 4, "", TYPES_STR[el->type], el->ind);

    #define next(direction) fprintf (tree_file, "%*s{\n", tab * 4, "");   \
                            SaveElem (el->direction, tree_file, tab + 1); \
                            fprintf (tree_file, "%*s}\n", tab * 4, "")   

    next (left);
    next (right);
    #undef next
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x448c
jmp 0x44ab
leaq 0x2861(%rip), %rdi      # 0x6cf4
leaq 0x25b3(%rip), %rsi      # 0x6a4d
movl $0xb2, %edx
leaq 0x2858(%rip), %rcx      # 0x6cfe
callq 0x1080
cmpq $0x0, -0x8(%rbp)
jne 0x44c9
movq -0x10(%rbp), %rdi
leaq 0x2ac6(%rip), %rsi      # 0x6f83
movb $0x0, %al
callq 0x1140
jmp 0x45ad
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %edx
shll $0x2, %edx
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x5bee(%rip), %rax      # 0xa0d0
movq (%rax,%rcx,8), %r8
movq -0x8(%rbp), %rax
movq 0x18(%rax), %r9
leaq 0x282f(%rip), %rsi      # 0x6d24
leaq 0x2343(%rip), %rcx      # 0x683f
movb $0x0, %al
callq 0x1140
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %edx
shll $0x2, %edx
leaq 0x281a(%rip), %rsi      # 0x6d2e
leaq 0x2324(%rip), %rcx      # 0x683f
movb $0x0, %al
callq 0x1140
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
addl $0x1, %edx
callq 0x4470
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %edx
shll $0x2, %edx
leaq 0x27ea(%rip), %rsi      # 0x6d34
leaq 0x22ee(%rip), %rcx      # 0x683f
movb $0x0, %al
callq 0x1140
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %edx
shll $0x2, %edx
leaq 0x27c5(%rip), %rsi      # 0x6d2e
leaq 0x22cf(%rip), %rcx      # 0x683f
movb $0x0, %al
callq 0x1140
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
addl $0x1, %edx
callq 0x4470
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %edx
shll $0x2, %edx
leaq 0x2795(%rip), %rsi      # 0x6d34
leaq 0x2299(%rip), %rcx      # 0x683f
movb $0x0, %al
callq 0x1140
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: AndreyVV-100[P]GachiLang/TreeBase/Tree.cpp
// Function: LoadTree(Tree*)
bool LoadTree (Tree* tree)
{
    assert (tree);
    
    if (tree->head)
    {
        printf ("Load error: Tree maybe is already created.\n");
        return 0;
    }

    char* tree_file = nullptr;
    ReadTxt (&tree_file, "CompileResult/CreatedTree.txt");
    char* pos_now = tree_file;
    tree->head = LoadElem (tree, &pos_now);
    
    free (tree_file);
    return tree->head != PARSE_ERR;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x45d5
jmp 0x45f4
leaq 0x246c(%rip), %rdi      # 0x6a48
leaq 0x246a(%rip), %rsi      # 0x6a4d
movl $0xc8, %edx
leaq 0x274b(%rip), %rcx      # 0x6d3a
callq 0x1080
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x4612
leaq 0x274b(%rip), %rdi      # 0x6d50
movb $0x0, %al
callq 0x1040
movb $0x0, -0x1(%rbp)
jmp 0x4668
movq $0x0, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
leaq 0x2670(%rip), %rsi      # 0x6c95
callq 0x42b0
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x4680
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rdi
callq 0x1110
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq 0x5af0(%rip), %rax      # 0xa150
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: AndreyVV-100[P]GachiLang/TreeBase/Stack.cpp
// Function: StackConstructor(Stack*, unsigned long)
void StackConstructor (Stack* stk, const size_t max_size)
{
	assert (stk);
	assert (max_size);

	if (!((stk->buffer == ERR_FREE && stk->status_error == STK_DEL) ||
		  (stk->buffer == nullptr  && stk->status_error == NOT_CREATED)))
	{
		stk->status_error = BAD_CREATE;
		StackLog (stk);
		return;
	}

	stk_type* buf = (stk_type*) calloc (max_size + 2, sizeof (stk_type));
	
	if (!buf)
	{
		stk->status_error = DO_MEM_ERR;
		StackLog (stk);
		return;
	}
	
	*((storm*)  buf)				 = STORMY_PETREL;
	*((storm*) (buf + max_size + 1)) = STORMY_PETREL;

	StackPoison (buf + 1, max_size);

	stk->buffer		  = buf + 1;
	stk->status_error = STK_GOOD;
	stk->capacity     = max_size;
	stk->min_capacity = max_size;

	RecountHash (stk);

	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x4a69
jmp 0x4a88
leaq 0x2458(%rip), %rdi      # 0x6ec8
leaq 0x2455(%rip), %rsi      # 0x6ecc
movl $0xa, %edx
leaq 0x245c(%rip), %rcx      # 0x6edf
callq 0x1080
cmpq $0x0, -0x10(%rbp)
je 0x4a91
jmp 0x4ab0
leaq 0x2474(%rip), %rdi      # 0x6f0c
leaq 0x242d(%rip), %rsi      # 0x6ecc
movl $0xb, %edx
leaq 0x2434(%rip), %rcx      # 0x6edf
callq 0x1080
movq -0x8(%rbp), %rax
movl $0xe4, %ecx
cmpq %rcx, 0x8(%rax)
jne 0x4ac9
movq -0x8(%rbp), %rax
cmpl $0x2, 0x28(%rax)
je 0x4af7
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x4ade
movq -0x8(%rbp), %rax
cmpl $0xc, 0x28(%rax)
je 0x4af7
movq -0x8(%rbp), %rax
movl $0xd, 0x28(%rax)
movq -0x8(%rbp), %rdi
callq 0x4bb0
jmp 0x4ba2
movq -0x10(%rbp), %rdi
addq $0x2, %rdi
movl $0x30, %esi
callq 0x1090
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x4b2a
movq -0x8(%rbp), %rax
movl $0xb, 0x28(%rax)
movq -0x8(%rbp), %rdi
callq 0x4bb0
jmp 0x4ba2
movq -0x18(%rbp), %rax
movabsq $-0x452212e21844f85f, %rcx # imm = 0xBADDED1DE7BB07A1
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
imulq $0x30, -0x10(%rbp), %rcx
addq %rcx, %rax
movabsq $-0x452212e21844f85f, %rcx # imm = 0xBADDED1DE7BB07A1
movq %rcx, 0x30(%rax)
movq -0x18(%rbp), %rdi
addq $0x30, %rdi
movq -0x10(%rbp), %rsi
callq 0x4ee0
movq -0x18(%rbp), %rcx
addq $0x30, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x28(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rdi
callq 0x4f70
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: AndreyVV-100[P]GachiLang/TreeBase/Stack.cpp
// Function: StackPoison(element*, unsigned long)
void StackPoison (stk_type* buffer, size_t num)
{
	assert (buffer);
	
	for (size_t elem = 0; elem < num; elem++)
	{
		free (buffer[elem].ind);
		buffer[elem] = STK_POISON;
	}

	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x4ef9
jmp 0x4f18
leaq 0x2015(%rip), %rdi      # 0x6f15
leaq 0x1fc5(%rip), %rsi      # 0x6ecc
movl $0x43, %edx
leaq 0x2009(%rip), %rcx      # 0x6f1c
callq 0x1080
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x4f6a
movq -0x8(%rbp), %rax
imulq $0x30, -0x18(%rbp), %rcx
addq %rcx, %rax
movq 0x18(%rax), %rdi
callq 0x1110
movq -0x8(%rbp), %rdi
imulq $0x30, -0x18(%rbp), %rax
addq %rax, %rdi
leaq 0x1f46(%rip), %rsi      # 0x6e98
movl $0x29, %edx
callq 0x10b0
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x4f20
addq $0x20, %rsp
popq %rbp
retq
// File: AndreyVV-100[P]GachiLang/TreeBase/Stack.cpp
// Function: RecountHash(Stack*)
void RecountHash (Stack* stk)
{
	assert (stk);
	
	stk->stk_hash = 0;
	stk->buf_hash = 0;
	
	stk->stk_hash = CountHash ((char*) stk,			STK_HASH);
	stk->buf_hash = CountHash ((char*) stk->buffer, stk->capacity * sizeof (stk_type));

	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x4f85
jmp 0x4fa4
leaq 0x1f3c(%rip), %rdi      # 0x6ec8
leaq 0x1f39(%rip), %rsi      # 0x6ecc
movl $0x186, %edx            # imm = 0x186
leaq 0x243d(%rip), %rcx      # 0x73dc
callq 0x1080
movq -0x8(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x8(%rbp), %rdi
movl $0x44, %esi
callq 0x5750
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
imulq $0x30, 0x18(%rax), %rsi
callq 0x5750
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x38(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: AndreyVV-100[P]GachiLang/TreeBase/Stack.cpp
// Function: StackDestructor(Stack*)
void StackDestructor (Stack* stk)
{
	ASSERT_OK
	
	stk->buffer -= 1;

	StackPoison (stk->buffer, stk->capacity + 2);

	free (stk->buffer);

	stk->buffer = ERR_FREE;
	stk->size = 0;
	stk->capacity = 0;
	stk->status_error = STK_DEL;
	stk->buf_hash = 0;
	stk->stk_hash = 0;

	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x50b0
cmpl $0x0, %eax
je 0x5025
movq -0x8(%rbp), %rdi
callq 0x4bb0
jmp 0x50a3
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
addq $-0x30, %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
addq $0x2, %rsi
callq 0x4ee0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1110
movq -0x8(%rbp), %rax
movl $0xe4, %ecx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movl $0x2, 0x28(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x30(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: AndreyVV-100[P]GachiLang/TreeBase/Stack.cpp
// Function: StackError(Stack*)
int StackError (Stack* stk)
{
	if (!stk)
		return STK_NULL;

	if (stk->stormy_petrel_begin != STORMY_PETREL)
		return stk->status_error = STK_PETREL_B;

	if (stk->stormy_petrel_end != STORMY_PETREL)
		return stk->status_error = STK_PETREL_E;
	
	if (stk->buffer == ERR_FREE)
		return stk->status_error = STK_DEL;
	
	if (!stk->buffer)
		return stk->status_error = BUF_NULL;
	
	if (stk->size > stk->capacity)
		return stk->status_error = BAD_SIZE_CAP;

	if (stk->capacity < stk->min_capacity)
		return stk->status_error = BAD_CAP;
	
	if (*((storm*) (stk->buffer - 1)) != STORMY_PETREL)
		return stk->status_error = BUF_PETREL_B;

	if (*((storm*) (stk->buffer + stk->capacity)) != STORMY_PETREL)
		return stk->status_error = BUF_PETREL_E;

	if (stk->status_error != 0)
		return stk->status_error;

	// Warning^ It's isn't standart stack mode.
	// This return is used for agree to use all data.
	return STK_GOOD;

	unsigned long long hash1 = stk->stk_hash;
	unsigned long long hash2 = stk->buf_hash;
	RecountHash (stk);

	if (stk->stk_hash != hash1)
		return stk->status_error = ERR_HASH_STK;

	if (stk->buf_hash != hash2)
		return stk->status_error = ERR_HASH_BUF;
	
	return STK_GOOD;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x50cb
movl $0x1, -0x4(%rbp)
jmp 0x523a
movq -0x10(%rbp), %rax
movabsq $-0x452212e21844f85f, %rcx # imm = 0xBADDED1DE7BB07A1
cmpq %rcx, (%rax)
je 0x50f5
movq -0x10(%rbp), %rax
movl $0x7, 0x28(%rax)
movl $0x7, -0x4(%rbp)
jmp 0x523a
movq -0x10(%rbp), %rax
movabsq $-0x452212e21844f85f, %rcx # imm = 0xBADDED1DE7BB07A1
cmpq %rcx, 0x40(%rax)
je 0x5120
movq -0x10(%rbp), %rax
movl $0x8, 0x28(%rax)
movl $0x8, -0x4(%rbp)
jmp 0x523a
movq -0x10(%rbp), %rax
movl $0xe4, %ecx
cmpq %rcx, 0x8(%rax)
jne 0x5146
movq -0x10(%rbp), %rax
movl $0x2, 0x28(%rax)
movl $0x2, -0x4(%rbp)
jmp 0x523a
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x5168
movq -0x10(%rbp), %rax
movl $0x3, 0x28(%rax)
movl $0x3, -0x4(%rbp)
jmp 0x523a
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jbe 0x5191
movq -0x10(%rbp), %rax
movl $0x4, 0x28(%rax)
movl $0x4, -0x4(%rbp)
jmp 0x523a
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jae 0x51ba
movq -0x10(%rbp), %rax
movl $0x6, 0x28(%rax)
movl $0x6, -0x4(%rbp)
jmp 0x523a
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movabsq $-0x452212e21844f85f, %rcx # imm = 0xBADDED1DE7BB07A1
cmpq %rcx, -0x30(%rax)
je 0x51e6
movq -0x10(%rbp), %rax
movl $0x9, 0x28(%rax)
movl $0x9, -0x4(%rbp)
jmp 0x523a
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
imulq $0x30, 0x18(%rcx), %rcx
addq %rcx, %rax
movabsq $-0x452212e21844f85f, %rcx # imm = 0xBADDED1DE7BB07A1
cmpq %rcx, (%rax)
je 0x521d
movq -0x10(%rbp), %rax
movl $0xa, 0x28(%rax)
movl $0xa, -0x4(%rbp)
jmp 0x523a
movq -0x10(%rbp), %rax
cmpl $0x0, 0x28(%rax)
je 0x5233
movq -0x10(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x523a
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: AndreyVV-100[P]GachiLang/TreeBase/Stack.cpp
// Function: StackPush(Stack*, element)
void StackPush (Stack* stk, stk_type elem)
{
	ASSERT_OK

	/*
	if (stk->size == stk->capacity)
		StackResizeUp (stk);

	if (stk->status_error == DO_MEM_ERR)
		return;
	*/

	if (stk->size == stk->capacity)
	{
		stk->status_error = DO_MEM_ERR;
		StackLog (stk);
		return;
	}

	char* new_ind = (char*) calloc (elem.len + 1, sizeof (char));
	if (!new_ind)
	{
		stk->status_error = DO_MEM_ERR;
		StackLog (stk);
		return;
	}

	strncpy (new_ind, elem.ind, elem.len + 1);

	char* elem_ind_save = elem.ind;
	elem.ind = new_ind;

	*(stk->buffer + (stk->size)++) = elem;
	elem.ind = elem_ind_save;

	RecountHash (stk);

	ASSERT_OK

	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x50b0
cmpl $0x0, %eax
je 0x5270
movq -0x8(%rbp), %rdi
callq 0x4bb0
jmp 0x535e
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jne 0x529b
movq -0x8(%rbp), %rax
movl $0xb, 0x28(%rax)
movq -0x8(%rbp), %rdi
callq 0x4bb0
jmp 0x535e
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rdi
addq $0x1, %rdi
movl $0x1, %esi
callq 0x1090
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x52d5
movq -0x8(%rbp), %rax
movl $0xb, 0x28(%rax)
movq -0x8(%rbp), %rdi
callq 0x4bb0
jmp 0x535e
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x18(%rax), %rsi
movq 0x20(%rax), %rdx
addq $0x1, %rdx
callq 0x1070
movq -0x20(%rbp), %rsi
movq 0x18(%rsi), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, 0x18(%rsi)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x10(%rcx)
imulq $0x30, %rax, %rax
addq %rax, %rdi
movl $0x29, %edx
callq 0x10b0
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rdi
callq 0x4f70
movq -0x8(%rbp), %rdi
callq 0x50b0
cmpl $0x0, %eax
je 0x535c
movq -0x8(%rbp), %rdi
callq 0x4bb0
jmp 0x535e
jmp 0x535e
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: AndreyVV-100[P]GachiLang/TreeBase/Stack.cpp
// Function: StackPop(Stack*)
stk_type StackPop (Stack* stk)
{
	ASSERT_OK_POP
	
	if (stk->size == 0)
	{
		stk->status_error = BAD_SIZE_ZERO;
		StackLog (stk);
		return STK_POISON;
	}
	
	if (stk->capacity > stk->min_capacity &&
		stk->capacity >= STK_RESIZE * STK_RESIZE * stk->size)
			StackResizeDown(stk);

	if (stk->status_error == DO_MEM_ERR)
		return STK_POISON;

	stk_type popped = stk->buffer[--(stk->size)];
	*(stk->buffer + stk->size) = STK_POISON;

	RecountHash(stk);

	ASSERT_OK_POP

	return popped;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, -0x40(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x50b0
cmpl $0x0, %eax
je 0x53b5
movq -0x8(%rbp), %rdi
callq 0x4bb0
movq -0x48(%rbp), %rdi
leaq 0x1af2(%rip), %rsi      # 0x6e98
movl $0x30, %edx
callq 0x10b0
jmp 0x54e1
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x53ee
movq -0x8(%rbp), %rax
movl $0x5, 0x28(%rax)
movq -0x8(%rbp), %rdi
callq 0x4bb0
movq -0x48(%rbp), %rdi
leaq 0x1ab9(%rip), %rsi      # 0x6e98
movl $0x30, %edx
callq 0x10b0
jmp 0x54e1
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jbe 0x5422
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
shlq $0x2, %rcx
cmpq %rcx, %rax
jb 0x5422
movq -0x8(%rbp), %rdi
callq 0x54f0
movq -0x8(%rbp), %rax
cmpl $0xb, 0x28(%rax)
jne 0x5446
movq -0x48(%rbp), %rdi
leaq 0x1a61(%rip), %rsi      # 0x6e98
movl $0x30, %edx
callq 0x10b0
jmp 0x54e1
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rax
addq $-0x1, %rax
movq %rax, 0x10(%rcx)
imulq $0x30, %rax, %rax
addq %rax, %rsi
leaq -0x38(%rbp), %rdi
movl $0x30, %edx
callq 0x10b0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
imulq $0x30, 0x10(%rax), %rax
addq %rax, %rdi
leaq 0x1a0a(%rip), %rsi      # 0x6e98
movl $0x29, %edx
callq 0x10b0
movq -0x8(%rbp), %rdi
callq 0x4f70
movq -0x8(%rbp), %rdi
callq 0x50b0
cmpl $0x0, %eax
je 0x54cf
movq -0x8(%rbp), %rdi
callq 0x4bb0
movq -0x48(%rbp), %rdi
leaq 0x19d5(%rip), %rsi      # 0x6e98
movl $0x30, %edx
callq 0x10b0
jmp 0x54e1
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rsi
movl $0x30, %edx
callq 0x10b0
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: AndreyVV-100[P]GachiLang/TreeBase/Stack.cpp
// Function: StackResizeDown(Stack*)
void StackResizeDown (Stack* stk)
{
	ASSERT_OK

	stk_type* buf = stk->buffer - 1;

	if (!buf)
	{
		stk->status_error = DO_MEM_ERR;
		StackLog (stk);
		return;
	}

	*(buf + stk->capacity + 1) = STK_POISON;

	if (stk->capacity >= STK_RESIZE * stk->size && 
		stk->capacity >= STK_RESIZE * stk->min_capacity)
			buf = (stk_type*) realloc (buf, 
									  sizeof (stk_type) * (stk->capacity / STK_RESIZE + 2));

	stk->capacity /= STK_RESIZE;
	*((storm*) (buf + stk->capacity + 1)) = STORMY_PETREL;
	stk->buffer = buf + 1;

	RecountHash (stk);

	ASSERT_OK

	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x50b0
cmpl $0x0, %eax
je 0x5518
movq -0x8(%rbp), %rdi
callq 0x4bb0
jmp 0x561e
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
addq $-0x30, %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x5548
movq -0x8(%rbp), %rax
movl $0xb, 0x28(%rax)
movq -0x8(%rbp), %rdi
callq 0x4bb0
jmp 0x561e
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
imulq $0x30, 0x18(%rax), %rax
addq %rax, %rdi
addq $0x30, %rdi
leaq 0x1935(%rip), %rsi      # 0x6e98
movl $0x29, %edx
callq 0x10b0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
shlq %rcx
cmpq %rcx, %rax
jb 0x55bd
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x20(%rcx), %rcx
shlq %rcx
cmpq %rcx, %rax
jb 0x55bd
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
shrq %rax
addq $0x2, %rax
imulq $0x30, %rax, %rsi
callq 0x1160
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
shrq %rcx
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
imulq $0x30, 0x18(%rcx), %rcx
addq %rcx, %rax
movabsq $-0x452212e21844f85f, %rcx # imm = 0xBADDED1DE7BB07A1
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rcx
addq $0x30, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rdi
callq 0x4f70
movq -0x8(%rbp), %rdi
callq 0x50b0
cmpl $0x0, %eax
je 0x561c
movq -0x8(%rbp), %rdi
callq 0x4bb0
jmp 0x561e
jmp 0x561e
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: AndreyVV-100[P]GachiLang/TreeBase/Stack.cpp
// Function: StackResizeUp(Stack*)
void StackResizeUp (Stack* stk)
{
	ASSERT_OK

	stk_type* buf = stk->buffer - 1;

	buf = (stk_type*) realloc (buf, sizeof (stk_type) * (stk->capacity * STK_RESIZE + 2));

	if (!buf)
	{
		stk->status_error = DO_MEM_ERR;
		StackLog (stk);
		return;
	}

	(stk->capacity) *= STK_RESIZE;

	*((storm*)  buf)					  = STORMY_PETREL;
	*((storm*) (buf + stk->capacity + 1)) = STORMY_PETREL;

	StackPoison (buf + stk->size + 1, stk->capacity - stk->size);

	stk->buffer = buf + 1;

	RecountHash (stk);

	ASSERT_OK

	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x50b0
cmpl $0x0, %eax
je 0x5658
movq -0x8(%rbp), %rdi
callq 0x4bb0
jmp 0x5743
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
addq $-0x30, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
shlq %rax
addq $0x2, %rax
imulq $0x30, %rax, %rsi
callq 0x1160
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x56a8
movq -0x8(%rbp), %rax
movl $0xb, 0x28(%rax)
movq -0x8(%rbp), %rdi
callq 0x4bb0
jmp 0x5743
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
shlq %rcx
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movabsq $-0x452212e21844f85f, %rcx # imm = 0xBADDED1DE7BB07A1
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
imulq $0x30, 0x18(%rcx), %rcx
addq %rcx, %rax
movabsq $-0x452212e21844f85f, %rcx # imm = 0xBADDED1DE7BB07A1
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
imulq $0x30, 0x10(%rax), %rax
addq %rax, %rdi
addq $0x30, %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x8(%rbp), %rax
subq 0x10(%rax), %rsi
callq 0x4ee0
movq -0x10(%rbp), %rcx
addq $0x30, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rdi
callq 0x4f70
movq -0x8(%rbp), %rdi
callq 0x50b0
cmpl $0x0, %eax
je 0x5741
movq -0x8(%rbp), %rdi
callq 0x4bb0
jmp 0x5743
jmp 0x5743
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: AndreyVV-100[P]GachiLang/TreeBase/Stack.cpp
// Function: CountHash(char*, unsigned long)
unsigned long long CountHash (char* buffer, size_t num)
{
	const int shift = 5;
	unsigned long long ans = 0;
	char buf = 0;
	
	for (size_t count = 0; count < num; count++)
	{
		ans += buffer[count];
		buf = ans >> (sizeof (unsigned long long) - shift);
		ans = (ans << shift) + buf;
	}

	return ans;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x5, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x57c3
movq -0x8(%rbp), %rax
movq -0x30(%rbp), %rcx
movsbq (%rax,%rcx), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
shrq $0x3, %rax
movb %al, -0x21(%rbp)
movq -0x20(%rbp), %rax
shlq $0x5, %rax
movsbq -0x21(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x5777
movq -0x20(%rbp), %rax
popq %rbp
retq
// File: MiWitt[P]HLAbaits/main.cpp
// Function: Tokenize(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
vector<string> Tokenize(const string& str, const string& delimiters = "\t")
{
    vector<string> tokens;
    // Skip delimiters at beginning.
    string::size_type lastPos = str.find_first_not_of(delimiters, 0);
    // Find first "non-delimiter".
    string::size_type pos     = str.find_first_of(delimiters, lastPos);

    while (string::npos != pos || string::npos != lastPos)
    {
        // Found a token, add it to the vector.
        tokens.push_back(str.substr(lastPos, pos - lastPos));
        // Skip delimiters.  Note the "not_of"
        if(str.length() > pos && delimiters.find(str[pos]) != string::npos )
            lastPos=pos+1;
        else
            lastPos = str.find_first_not_of(delimiters, pos);
        // Find next "non-delimiter"
        pos = str.find_first_of(delimiters, lastPos);
    }
    return tokens;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x6370
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x3260
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x32a0
movq %rax, -0x30(%rbp)
movb $0x1, %al
movq $-0x1, %rcx
cmpq -0x30(%rbp), %rcx
movb %al, -0x71(%rbp)
jne 0x3808
movq $-0x1, %rax
cmpq -0x28(%rbp), %rax
setne %al
movb %al, -0x71(%rbp)
movb -0x71(%rbp), %al
testb $0x1, %al
jne 0x3814
jmp 0x38e2
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
subq %rdx, %rcx
leaq -0x50(%rbp), %rdi
callq 0x32f0
jmp 0x382e
movq -0x70(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x6390
jmp 0x383d
leaq -0x50(%rbp), %rdi
callq 0x35d8
movq -0x10(%rbp), %rdi
callq 0x34b0
cmpq -0x30(%rbp), %rax
jbe 0x38b3
movq -0x18(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x3360
movq -0x80(%rbp), %rdi
xorl %ecx, %ecx
movl %ecx, %edx
movsbl (%rax), %esi
callq 0x3420
cmpq $-0x1, %rax
je 0x38b3
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x38c8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x3902
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x35d8
jmp 0x3902
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x3260
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x32a0
movq %rax, -0x30(%rbp)
jmp 0x37e5
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x38f5
movq -0x70(%rbp), %rdi
callq 0x63c0
movq -0x68(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x63c0
movq -0x58(%rbp), %rdi
callq 0x3530
nopw %cs:(%rax,%rax)
// File: MiWitt[P]HLAbaits/main.cpp
// Function: cmd_exec(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string cmd_exec(const string& cmd)
{
    FILE* pipe = popen(cmd.c_str(), "r");
    if (!pipe)
        throw("ERROR from popen()");

    char buffer[128];
    ostringstream result("");

    while(!feof(pipe))
    {
        if(fgets(buffer, 128, pipe) != NULL)
           result << buffer;
    }
    pclose(pipe);

    return result.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x270, %rsp            # imm = 0x270
movq %rdi, -0x260(%rbp)
movq %rdi, %rax
movq %rax, -0x258(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3150
movq %rax, %rdi
leaq 0x86ad(%rip), %rsi      # 0xc004
callq 0x3110
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x398e
movl $0x8, %edi
callq 0x31b0
movq %rax, %rdi
leaq 0x868b(%rip), %rax      # 0xc006
movq %rax, (%rdi)
movq 0xe62b(%rip), %rsi      # 0x11fb0
xorl %eax, %eax
movl %eax, %edx
callq 0x3510
leaq -0x239(%rbp), %rdi
movq %rdi, -0x268(%rbp)
callq 0x3540
movq -0x268(%rbp), %rdx
leaq 0x8677(%rip), %rsi      # 0xc026
leaq -0x238(%rbp), %rdi
callq 0x62c0
jmp 0x39bd
leaq -0x218(%rbp), %rdi
leaq -0x238(%rbp), %rsi
movl $0x10, %edx
callq 0x3450
jmp 0x39d7
leaq -0x238(%rbp), %rdi
callq 0x35d8
leaq -0x239(%rbp), %rdi
callq 0x3330
movq -0x18(%rbp), %rdi
callq 0x34d0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x3a09
jmp 0x3ab0
movq -0x18(%rbp), %rdx
leaq -0xa0(%rbp), %rdi
movl $0x80, %esi
callq 0x34f0
movq %rax, -0x270(%rbp)
jmp 0x3a27
movq -0x270(%rbp), %rax
cmpq $0x0, %rax
je 0x3aab
leaq -0x218(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x32b0
jmp 0x3a49
jmp 0x3aab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x248(%rbp)
movl %eax, -0x24c(%rbp)
jmp 0x3a7d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x248(%rbp)
movl %eax, -0x24c(%rbp)
leaq -0x238(%rbp), %rdi
callq 0x35d8
leaq -0x239(%rbp), %rdi
callq 0x3330
jmp 0x3aec
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x248(%rbp)
movl %eax, -0x24c(%rbp)
leaq -0x218(%rbp), %rdi
callq 0x30c0
jmp 0x3aec
jmp 0x39ef
movq -0x18(%rbp), %rdi
callq 0x3460
jmp 0x3abb
movq -0x260(%rbp), %rdi
leaq -0x218(%rbp), %rsi
callq 0x32e0
jmp 0x3ad0
leaq -0x218(%rbp), %rdi
callq 0x30c0
movq -0x258(%rbp), %rax
addq $0x270, %rsp            # imm = 0x270
popq %rbp
retq
movq -0x248(%rbp), %rdi
callq 0x3530
nopl (%rax,%rax)
// File: MiWitt[P]HLAbaits/main.cpp
// Function: getUnmappedRegions(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
vector<pair<int,int> >  getUnmappedRegions(const string& matches)
{
    vector<pair<int,int> >  vctRet;
    size_t starter = matches.find_first_of("0",0);

    while(starter != string::npos)
    {
        int i = starter;
        int counter =0;
        for(; i < matches.size() && matches[i] == '0';i++)
            counter++;
        if(counter >= MIN_NEW_BAIT_SIZE)
            vctRet.push_back(pair<int,int>((int)starter,(int)starter+counter-1));
        starter = matches.find_first_of("0",i);
    }
    return vctRet;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x6420
movq -0x10(%rbp), %rdi
leaq 0x80ba(%rip), %rsi      # 0xc039
xorl %eax, %eax
movl %eax, %edx
callq 0x31c0
movq %rax, -0x20(%rbp)
cmpq $-0x1, -0x20(%rbp)
je 0x4072
movq -0x20(%rbp), %rax
movl %eax, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movslq -0x24(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3210
movq -0x68(%rbp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x59(%rbp)
jae 0x3fe0
movq -0x10(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq 0x3360
movsbl (%rax), %eax
cmpl $0x30, %eax
sete %al
movb %al, -0x59(%rbp)
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0x3fe9
jmp 0x3ffd
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x3fa5
cmpl $0x1e, -0x28(%rbp)
jl 0x4055
movl -0x20(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x20(%rbp), %edx
movl -0x28(%rbp), %eax
movl %eax, %ecx
movl %edx, %eax
leal -0x1(%rax,%rcx), %eax
movl %eax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x34(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x6530
jmp 0x402d
movq -0x58(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x6460
jmp 0x403c
jmp 0x4055
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x64c0
jmp 0x408f
movq -0x10(%rbp), %rdi
movslq -0x24(%rbp), %rdx
leaq 0x7fd5(%rip), %rsi      # 0xc039
callq 0x31c0
movq %rax, -0x20(%rbp)
jmp 0x3f8c
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x4085
movq -0x58(%rbp), %rdi
callq 0x64c0
movq -0x50(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3530
nopl (%rax,%rax)
// File: MiWitt[P]HLAbaits/CMultiFasta.cpp
// Function: CMultiFasta::operator[](std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string CMultiFasta::operator[](const string& val)
{
    map<string,string>::iterator iter = m_mapSequences.find(val);
    if(m_mapSequences.end() == iter)
        return "";
    return iter->second;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x48(%rbp)
addq $0x8, %rdi
movq -0x18(%rbp), %rsi
callq 0xb160
movq -0x48(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x8, %rdi
callq 0x6720
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x8b20
testb $0x1, %al
jne 0xb06c
jmp 0xb0b1
leaq -0x29(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x3540
movq -0x58(%rbp), %rdi
movq -0x60(%rbp), %rdx
leaq 0xf9e(%rip), %rsi       # 0xc026
callq 0x62c0
jmp 0xb08f
leaq -0x29(%rbp), %rdi
callq 0x3330
jmp 0xb0ca
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x29(%rbp), %rdi
callq 0x3330
jmp 0xb0d4
leaq -0x20(%rbp), %rdi
callq 0x69b0
movq -0x58(%rbp), %rdi
movq %rax, %rsi
addq $0x20, %rsi
callq 0x3160
movq -0x50(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x3530
nopl (%rax)
// File: CastellanZhang[P]lambdaFM/./src/FTRL/ftrl_model.h
// Function: ftrl_model::getOrInitModelUnit(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
ftrl_model_unit* ftrl_model::getOrInitModelUnit(string index)
{
    unordered_map<string, ftrl_model_unit*>::iterator iter = muMap.find(index);
    if(iter == muMap.end())
    {
        mtx.lock();
        ftrl_model_unit* pMU = new ftrl_model_unit(factor_num, init_mean, init_stdev);
        muMap.insert(make_pair(index, pMU));
        mtx.unlock();
        return pMU;
    }
    else
    {
        return iter->second;
    }
}

// Assembly:
subq $0xa8, %rsp
movq %rsi, 0x20(%rsp)
movq %rdi, 0x98(%rsp)
movq %rsi, 0x90(%rsp)
movq 0x98(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x5370
movq 0x28(%rsp), %rdi
movq %rax, 0x88(%rsp)
callq 0x53c0
movq %rax, 0x80(%rsp)
leaq 0x88(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x53a0
testb $0x1, %al
jne 0x3a46
jmp 0x3b2a
movq 0x28(%rsp), %rdi
addq $0x50, %rdi
callq 0x53f0
movl $0x88, %edi
callq 0x3300
movq %rax, %rdi
movq 0x28(%rsp), %rax
movq %rdi, %rcx
movq %rcx, 0x18(%rsp)
movl 0x38(%rax), %esi
movsd 0x48(%rax), %xmm0
movsd 0x40(%rax), %xmm1
callq 0x5420
jmp 0x3a82
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rax
movq %rax, 0x78(%rsp)
leaq 0x40(%rsp), %rdi
movq %rdi, (%rsp)
leaq 0x78(%rsp), %rdx
callq 0x5600
movq 0x28(%rsp), %rdi
movq (%rsp), %rsi
callq 0x55b0
movb %dl, 0xf(%rsp)
movq %rax, 0x10(%rsp)
jmp 0x3abd
movb 0xf(%rsp), %al
movq 0x10(%rsp), %rcx
movq %rcx, 0x30(%rsp)
movb %al, 0x38(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x5640
movq 0x28(%rsp), %rdi
addq $0x50, %rdi
callq 0x5650
movq 0x78(%rsp), %rax
movq %rax, 0xa0(%rsp)
jmp 0x3b43
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
callq 0x32e0
jmp 0x3b53
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x5640
jmp 0x3b53
leaq 0x88(%rsp), %rdi
callq 0x5660
movq 0x20(%rax), %rax
movq %rax, 0xa0(%rsp)
movq 0xa0(%rsp), %rax
addq $0xa8, %rsp
retq
movq 0x70(%rsp), %rdi
callq 0x34f0
nopl (%rax)
// File: CastellanZhang[P]lambdaFM/./src/FTRL/ftrl_model.h
// Function: ftrl_model::get_wi(std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, ftrl_model_unit*, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, ftrl_model_unit*>>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
double ftrl_model::get_wi(unordered_map<string, ftrl_model_unit*>& theta, const string& index)
{
    unordered_map<string, ftrl_model_unit*>::iterator iter = theta.find(index);
    if(iter == theta.end())
    {
        return 0.0;
    }
    else
    {
        return iter->second->wi;
    }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x5370
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0x53c0
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x53a0
testb $0x1, %al
jne 0x405b
jmp 0x4066
xorps %xmm0, %xmm0
movsd %xmm0, 0x30(%rsp)
jmp 0x407e
leaq 0x10(%rsp), %rdi
callq 0x5660
movq 0x20(%rax), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x30(%rsp), %xmm0
addq $0x38, %rsp
retq
nopl (%rax)
// File: CastellanZhang[P]lambdaFM/./src/FTRL/ftrl_model.h
// Function: ftrl_model::get_vif(std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, ftrl_model_unit*, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, ftrl_model_unit*>>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int)
double ftrl_model::get_vif(unordered_map<string, ftrl_model_unit*>& theta, const string& index, int f)
{
    unordered_map<string, ftrl_model_unit*>::iterator iter = theta.find(index);
    if(iter == theta.end())
    {
        return 0.0;
    }
    else
    {
        return iter->second->vi[f];
    }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movl %ecx, 0x14(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x5370
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x53c0
movq %rax, (%rsp)
leaq 0x8(%rsp), %rdi
movq %rsp, %rsi
callq 0x53a0
testb $0x1, %al
jne 0x40dc
jmp 0x40e7
xorps %xmm0, %xmm0
movsd %xmm0, 0x30(%rsp)
jmp 0x410d
leaq 0x8(%rsp), %rdi
callq 0x5660
movq 0x20(%rax), %rdi
addq $0x18, %rdi
movslq 0x14(%rsp), %rsi
callq 0x5780
movsd (%rax), %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x30(%rsp), %xmm0
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: CastellanZhang[P]lambdaFM/./src/FTRL/ftrl_model.h
// Function: ftrl_model::loadModel(std::basic_ifstream<char, std::char_traits<char>>&)
bool ftrl_model::loadModel(ifstream& in)
{
    string line;
    vector<string> strVec;
    while(getline(in, line))
    {
        strVec.clear();
        utils::splitString(line, ' ', &strVec);
        if(strVec.size() != 3 * factor_num + 4)
        {
            return false;
        }
        string& index = strVec[0];
        ftrl_model_unit* pMU = new ftrl_model_unit(factor_num, strVec);
        muMap[index] = pMU;
    }
    return true;
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0x98(%rsp)
movq %rsi, 0x90(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x30(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x33f0
leaq 0x58(%rsp), %rdi
callq 0x59f0
movq 0x90(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x3070
movq %rax, 0x28(%rsp)
jmp 0x42e1
movq 0x28(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x33b0
movb %al, 0x27(%rsp)
jmp 0x42fb
movb 0x27(%rsp), %al
testb $0x1, %al
jne 0x4308
jmp 0x4404
leaq 0x58(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x5a00
movq 0x18(%rsp), %rdx
leaq 0x70(%rsp), %rdi
movl $0x20, %esi
callq 0x119c0
jmp 0x432d
leaq 0x58(%rsp), %rdi
callq 0x5a20
movq 0x30(%rsp), %rcx
imull $0x3, 0x38(%rcx), %ecx
addl $0x4, %ecx
movslq %ecx, %rcx
cmpq %rcx, %rax
je 0x4373
movb $0x0, 0xa7(%rsp)
movl $0x1, 0x48(%rsp)
jmp 0x4414
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x4439
xorl %eax, %eax
movl %eax, %esi
leaq 0x58(%rsp), %rdi
callq 0x5a40
movq %rax, 0x40(%rsp)
movl $0x88, %edi
callq 0x3300
movq %rax, 0x10(%rsp)
jmp 0x4397
movq 0x10(%rsp), %rdi
movq 0x30(%rsp), %rax
movl 0x38(%rax), %esi
leaq 0x58(%rsp), %rdx
callq 0x5a60
jmp 0x43b0
movq 0x30(%rsp), %rdi
movq 0x10(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
movq 0x40(%rsp), %rsi
callq 0x5720
movq %rax, 0x8(%rsp)
jmp 0x43d9
movq 0x8(%rsp), %rax
movq (%rsp), %rcx
movq %rcx, (%rax)
jmp 0x42c8
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
callq 0x32e0
jmp 0x4439
movb $0x1, 0xa7(%rsp)
movl $0x1, 0x48(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x5ce0
leaq 0x70(%rsp), %rdi
callq 0x3598
movb 0xa7(%rsp), %al
andb $0x1, %al
addq $0xa8, %rsp
retq
leaq 0x58(%rsp), %rdi
callq 0x5ce0
leaq 0x70(%rsp), %rdi
callq 0x3598
movq 0x50(%rsp), %rdi
callq 0x34f0
nopw (%rax,%rax)
// File: CastellanZhang[P]lambdaFM/./src/FTRL/ftrl_predictor.h
// Function: ftrl_predictor::ftrl_predictor(double, std::basic_ifstream<char, std::char_traits<char>>&, std::basic_ofstream<char, std::char_traits<char>>&)
ftrl_predictor::ftrl_predictor(double _factor_num, ifstream& _fModel, ofstream& _fPredict):fPredict(_fPredict)
{
    pModel = new ftrl_model(_factor_num);
    if(!pModel->loadModel(_fModel))
    {
        cout << "load model error!" << endl;
        exit(-1);
    }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movsd %xmm0, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x5d40
movq 0x8(%rsp), %rdi
leaq 0x1584c(%rip), %rax     # 0x19ce0
movq %rax, (%rdi)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rdi)
addq $0x18, %rdi
callq 0x5360
movl $0x78, %edi
callq 0x3300
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movsd 0x38(%rsp), %xmm0
callq 0x3930
jmp 0x44cb
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq 0x8(%rax), %rdi
movq 0x30(%rsp), %rsi
callq 0x4290
testb $0x1, %al
jne 0x4531
movq 0x15ac6(%rip), %rdi     # 0x19fb8
leaq 0xdb1f(%rip), %rsi      # 0x12018
callq 0x32f0
movq %rax, %rdi
movq 0x15a78(%rip), %rsi     # 0x19f80
callq 0x3320
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x3380
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0x32e0
jmp 0x4536
addq $0x48, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x34f0
// File: CastellanZhang[P]lambdaFM/lambdafm_predict.cpp
// Function: argv_to_args[abi:cxx11](int, char**)
vector<string> argv_to_args(int argc, char* argv[])
{
    vector<string> args;
    for(int i = 1; i < argc; ++i)
    {
        args.push_back(string(argv[i]));
    }
    return args;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x70(%rsp)
movl %esi, 0x6c(%rsp)
movq %rdx, 0x60(%rsp)
movb $0x0, 0x5f(%rsp)
callq 0x59f0
movl $0x1, 0x58(%rsp)
movl 0x58(%rsp), %eax
cmpl 0x6c(%rsp), %eax
jge 0x4aa5
movq 0x60(%rsp), %rax
movslq 0x58(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, (%rsp)
leaq 0x37(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x3500
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
leaq 0x38(%rsp), %rdi
callq 0x33e0
jmp 0x4a35
movq 0x10(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x5de0
jmp 0x4a46
leaq 0x38(%rsp), %rdi
callq 0x3598
leaq 0x37(%rsp), %rdi
callq 0x3340
movl 0x58(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x58(%rsp)
jmp 0x49f1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0x4a8f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x3598
leaq 0x37(%rsp), %rdi
callq 0x3340
movq 0x10(%rsp), %rdi
callq 0x5ce0
jmp 0x4ac5
movb $0x1, 0x5f(%rsp)
testb $0x1, 0x5f(%rsp)
jne 0x4abb
movq 0x10(%rsp), %rdi
callq 0x5ce0
movq 0x18(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x34f0
nop
// File: CastellanZhang[P]lambdaFM/./src/FTRL/ftrl_model.h
// Function: ftrl_model_unit::ftrl_model_unit(int, double, double)
ftrl_model_unit(int factor_num, double v_mean, double v_stdev)
    {
        wi = 0.0;
        w_ni = 0.0;
        w_zi = 0.0;
        vi.resize(factor_num);
        v_ni.resize(factor_num);
        v_zi.resize(factor_num);
        for(int f = 0; f < factor_num; ++f)
        {
            vi[f] = utils::gaussian(v_mean, v_stdev);
            v_ni[f] = 0.0;
            v_zi[f] = 0.0;
        }
    }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
movsd %xmm0, 0x40(%rsp)
movsd %xmm1, 0x38(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x18(%rsp)
addq $0x18, %rdi
movq %rdi, 0x20(%rsp)
callq 0x6490
movq 0x18(%rsp), %rdi
addq $0x30, %rdi
movq %rdi, 0x8(%rsp)
callq 0x6490
movq 0x18(%rsp), %rdi
addq $0x48, %rdi
movq %rdi, 0x10(%rsp)
callq 0x6490
movq 0x18(%rsp), %rdi
addq $0x60, %rdi
callq 0x5360
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rdi
movq $0x0, (%rax)
movq $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
movslq 0x4c(%rsp), %rsi
callq 0x64a0
jmp 0x54b2
movq 0x18(%rsp), %rdi
addq $0x30, %rdi
movslq 0x4c(%rsp), %rsi
callq 0x64a0
jmp 0x54c7
movq 0x18(%rsp), %rdi
addq $0x48, %rdi
movslq 0x4c(%rsp), %rsi
callq 0x64a0
jmp 0x54dc
movl $0x0, 0x28(%rsp)
movl 0x28(%rsp), %eax
cmpl 0x4c(%rsp), %eax
jge 0x5598
movsd 0x40(%rsp), %xmm0
movsd 0x38(%rsp), %xmm1
callq 0x11db0
movsd %xmm0, (%rsp)
jmp 0x550a
movq 0x18(%rsp), %rdi
addq $0x18, %rdi
movslq 0x28(%rsp), %rsi
callq 0x5780
movsd (%rsp), %xmm0
movq 0x18(%rsp), %rdi
movsd %xmm0, (%rax)
addq $0x30, %rdi
movslq 0x28(%rsp), %rsi
callq 0x5780
movq 0x18(%rsp), %rdi
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
addq $0x48, %rdi
movslq 0x28(%rsp), %rsi
callq 0x5780
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x54e4
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0x6540
movq 0x8(%rsp), %rdi
callq 0x6540
movq 0x20(%rsp), %rdi
callq 0x6540
jmp 0x559d
addq $0x58, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x34f0
nopw (%rax,%rax)
// File: CastellanZhang[P]lambdaFM/./src/FTRL/ftrl_model.h
// Function: operator<<(std::ostream&, ftrl_model_unit const&)
inline ostream& operator <<(ostream& os, const ftrl_model_unit& mu)
    {
        os << mu.wi;
        for(int f = 0; f < mu.vi.size(); ++f)
        {
            os << " " << mu.vi[f];
        }
        os << " " << mu.w_ni << " " << mu.w_zi;
        for(int f = 0; f < mu.v_ni.size(); ++f)
        {
            os << " " << mu.v_ni[f];
        }
        for(int f = 0; f < mu.v_zi.size(); ++f)
        {
            os << " " << mu.v_zi[f];
        }
        return os;
    }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rax
movsd (%rax), %xmm0
callq 0x3540
movl $0x0, 0x44(%rsp)
movslq 0x44(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x48(%rsp), %rdi
addq $0x18, %rdi
callq 0x6630
movq %rax, %rcx
movq 0x30(%rsp), %rax
cmpq %rcx, %rax
jae 0x5882
movq 0x50(%rsp), %rdi
leaq 0xc7ca(%rip), %rsi      # 0x12014
callq 0x32f0
movq %rax, 0x28(%rsp)
movq 0x48(%rsp), %rdi
addq $0x18, %rdi
movslq 0x44(%rsp), %rsi
callq 0x71f0
movq 0x28(%rsp), %rdi
movsd (%rax), %xmm0
callq 0x3540
movl 0x44(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x44(%rsp)
jmp 0x5819
movq 0x50(%rsp), %rdi
leaq 0xc786(%rip), %rsi      # 0x12014
callq 0x32f0
movq %rax, %rdi
movq 0x48(%rsp), %rax
movsd 0x8(%rax), %xmm0
callq 0x3540
movq %rax, %rdi
leaq 0xc765(%rip), %rsi      # 0x12014
callq 0x32f0
movq %rax, %rdi
movq 0x48(%rsp), %rax
movsd 0x10(%rax), %xmm0
callq 0x3540
movl $0x0, 0x40(%rsp)
movslq 0x40(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x48(%rsp), %rdi
addq $0x30, %rdi
callq 0x6630
movq %rax, %rcx
movq 0x20(%rsp), %rax
cmpq %rcx, %rax
jae 0x5937
movq 0x50(%rsp), %rdi
leaq 0xc715(%rip), %rsi      # 0x12014
callq 0x32f0
movq %rax, 0x18(%rsp)
movq 0x48(%rsp), %rdi
addq $0x30, %rdi
movslq 0x40(%rsp), %rsi
callq 0x71f0
movq 0x18(%rsp), %rdi
movsd (%rax), %xmm0
callq 0x3540
movl 0x40(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x40(%rsp)
jmp 0x58ce
movl $0x0, 0x3c(%rsp)
movslq 0x3c(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rdi
addq $0x48, %rdi
callq 0x6630
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x59a8
movq 0x50(%rsp), %rdi
leaq 0xc6a4(%rip), %rsi      # 0x12014
callq 0x32f0
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rdi
addq $0x48, %rdi
movslq 0x3c(%rsp), %rsi
callq 0x71f0
movq 0x8(%rsp), %rdi
movsd (%rax), %xmm0
callq 0x3540
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x593f
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: CastellanZhang[P]lambdaFM/src/Frame/pc_frame.cpp
// Function: pc_frame::init(pc_task&, int, int, int)
bool pc_frame::init(pc_task& task, int t_num, int buf_size, int log_num)
{
    pTask = &task;
    threadNum = t_num;
    bufSize = buf_size;
    logNum = log_num;
    sem_init(&semPro, 0, 1);
    sem_init(&semCon, 0, 0);
    threadVec.clear();
    threadVec.push_back(thread(&pc_frame::proThread, this));
    for(int i = 0; i < threadNum; ++i)
    {
        threadVec.push_back(thread(&pc_frame::conThread, this));
    }
    return true;
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movl %edx, 0x94(%rsp)
movl %ecx, 0x90(%rsp)
movl %r8d, 0x8c(%rsp)
movq 0xa0(%rsp), %rdi
movq %rdi, 0x20(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x8(%rdi)
movl 0x94(%rsp), %eax
movl %eax, (%rdi)
movl 0x90(%rsp), %eax
movl %eax, 0xe0(%rdi)
movl 0x8c(%rsp), %eax
movl %eax, 0xe4(%rdi)
addq $0x38, %rdi
xorl %esi, %esi
movl %esi, 0x1c(%rsp)
movl $0x1, %edx
callq 0x3290
movl 0x1c(%rsp), %edx
movq 0x20(%rsp), %rdi
addq $0x58, %rdi
movl %edx, %esi
callq 0x3290
movq 0x20(%rsp), %rdi
addq $0xc8, %rdi
movq %rdi, 0x28(%rsp)
callq 0xc2b0
movq 0x20(%rsp), %rax
leaq 0x12d(%rip), %rcx       # 0xbc70
movq %rcx, 0x70(%rsp)
movq $0x0, 0x78(%rsp)
movq %rax, 0x68(%rsp)
leaq 0x80(%rsp), %rdi
movq %rdi, 0x30(%rsp)
leaq 0x70(%rsp), %rsi
leaq 0x68(%rsp), %rdx
callq 0xc300
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0xc2d0
jmp 0xbb83
leaq 0x80(%rsp), %rdi
callq 0x8720
movl $0x0, 0x58(%rsp)
movq 0x20(%rsp), %rcx
movl 0x58(%rsp), %eax
cmpl (%rcx), %eax
jge 0xbc4f
movq 0x20(%rsp), %rax
movq %rax, %rcx
addq $0xc8, %rcx
movq %rcx, 0x8(%rsp)
leaq 0x45c(%rip), %rcx       # 0xc020
movq %rcx, 0x40(%rsp)
movq $0x0, 0x48(%rsp)
movq %rax, 0x38(%rsp)
leaq 0x50(%rsp), %rdi
movq %rdi, 0x10(%rsp)
leaq 0x40(%rsp), %rsi
leaq 0x38(%rsp), %rdx
callq 0xc300
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xc2d0
jmp 0xbc01
leaq 0x50(%rsp), %rdi
callq 0x8720
movl 0x58(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x58(%rsp)
jmp 0xbb98
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x8720
jmp 0xbc5b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x8720
jmp 0xbc5b
movb $0x1, %al
andb $0x1, %al
addq $0xa8, %rsp
retq
movq 0x60(%rsp), %rdi
callq 0x34f0
nopw %cs:(%rax,%rax)