LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Eba-M[P]E3DC-Control/cJSON.c
// Function: create_reference(cJSON const*, internal_hooks const*)
static cJSON *create_reference(const cJSON *item, const internal_hooks * const hooks)
{
    cJSON *reference = NULL;
    if (item == NULL)
    {
        return NULL;
    }

    reference = cJSON_New_Item(hooks);
    if (reference == NULL)
    {
        return NULL;
    }

    memcpy(reference, item, sizeof(cJSON));
    reference->string = NULL;
    reference->type |= cJSON_IsReference;
    reference->next = reference->prev = NULL;
    return reference;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x5a69a
movq $0x0, 0x20(%rsp)
jmp 0x5a711
movq 0x10(%rsp), %rdi
callq 0x59500
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x5a6bc
movq $0x0, 0x20(%rsp)
jmp 0x5a711
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl $0x40, %edx
callq 0x2220
movq 0x8(%rsp), %rax
movq $0x0, 0x38(%rax)
movq 0x8(%rsp), %rax
movl 0x18(%rax), %ecx
orl $0x100, %ecx            # imm = 0x100
movl %ecx, 0x18(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x8(%rax)
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: Eba-M[P]E3DC-Control/cJSON.c
// Function: cJSON_AddNullToObject
CJSON_PUBLIC(cJSON*) cJSON_AddNullToObject(cJSON * const object, const char * const name)
{
    cJSON *null = cJSON_CreateNull();
    if (add_item_to_object(object, name, null, &global_hooks, false))
    {
        return null;
    }

    cJSON_Delete(null);
    return NULL;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
callq 0x5a810
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
leaq 0x13c0a(%rip), %rcx     # 0x6e3d8
xorl %r8d, %r8d
callq 0x5a4a0
cmpl $0x0, %eax
je 0x5a7e7
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x5a7fa
movq 0x8(%rsp), %rdi
callq 0x58fa0
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: Eba-M[P]E3DC-Control/cJSON.c
// Function: cJSON_CreateNull
CJSON_PUBLIC(cJSON *) cJSON_CreateNull(void)
{
    cJSON *item = cJSON_New_Item(&global_hooks);
    if(item)
    {
        item->type = cJSON_NULL;
    }

    return item;
}

// Assembly:
pushq %rax
leaq 0x13bc0(%rip), %rdi     # 0x6e3d8
callq 0x59500
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x5a833
movq (%rsp), %rax
movl $0x4, 0x18(%rax)
movq (%rsp), %rax
popq %rcx
retq
nopl (%rax)
// File: Eba-M[P]E3DC-Control/cJSON.c
// Function: cJSON_AddTrueToObject
CJSON_PUBLIC(cJSON*) cJSON_AddTrueToObject(cJSON * const object, const char * const name)
{
    cJSON *true_item = cJSON_CreateTrue();
    if (add_item_to_object(object, name, true_item, &global_hooks, false))
    {
        return true_item;
    }

    cJSON_Delete(true_item);
    return NULL;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
callq 0x5a8b0
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
leaq 0x13b6a(%rip), %rcx     # 0x6e3d8
xorl %r8d, %r8d
callq 0x5a4a0
cmpl $0x0, %eax
je 0x5a887
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x5a89a
movq 0x8(%rsp), %rdi
callq 0x58fa0
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: Eba-M[P]E3DC-Control/cJSON.c
// Function: cJSON_CreateTrue
CJSON_PUBLIC(cJSON *) cJSON_CreateTrue(void)
{
    cJSON *item = cJSON_New_Item(&global_hooks);
    if(item)
    {
        item->type = cJSON_True;
    }

    return item;
}

// Assembly:
pushq %rax
leaq 0x13b20(%rip), %rdi     # 0x6e3d8
callq 0x59500
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x5a8d3
movq (%rsp), %rax
movl $0x2, 0x18(%rax)
movq (%rsp), %rax
popq %rcx
retq
nopl (%rax)
// File: Eba-M[P]E3DC-Control/cJSON.c
// Function: cJSON_AddFalseToObject
CJSON_PUBLIC(cJSON*) cJSON_AddFalseToObject(cJSON * const object, const char * const name)
{
    cJSON *false_item = cJSON_CreateFalse();
    if (add_item_to_object(object, name, false_item, &global_hooks, false))
    {
        return false_item;
    }

    cJSON_Delete(false_item);
    return NULL;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
callq 0x5a950
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
leaq 0x13aca(%rip), %rcx     # 0x6e3d8
xorl %r8d, %r8d
callq 0x5a4a0
cmpl $0x0, %eax
je 0x5a927
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x5a93a
movq 0x8(%rsp), %rdi
callq 0x58fa0
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: Eba-M[P]E3DC-Control/cJSON.c
// Function: cJSON_CreateFalse
CJSON_PUBLIC(cJSON *) cJSON_CreateFalse(void)
{
    cJSON *item = cJSON_New_Item(&global_hooks);
    if(item)
    {
        item->type = cJSON_False;
    }

    return item;
}

// Assembly:
pushq %rax
leaq 0x13a80(%rip), %rdi     # 0x6e3d8
callq 0x59500
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x5a973
movq (%rsp), %rax
movl $0x1, 0x18(%rax)
movq (%rsp), %rax
popq %rcx
retq
nopl (%rax)
// File: Eba-M[P]E3DC-Control/cJSON.c
// Function: cJSON_AddBoolToObject
CJSON_PUBLIC(cJSON*) cJSON_AddBoolToObject(cJSON * const object, const char * const name, const cJSON_bool boolean)
{
    cJSON *bool_item = cJSON_CreateBool(boolean);
    if (add_item_to_object(object, name, bool_item, &global_hooks, false))
    {
        return bool_item;
    }

    cJSON_Delete(bool_item);
    return NULL;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
movl 0xc(%rsp), %edi
callq 0x5a9f0
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq (%rsp), %rdx
leaq 0x13a24(%rip), %rcx     # 0x6e3d8
xorl %r8d, %r8d
callq 0x5a4a0
cmpl $0x0, %eax
je 0x5a9cc
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x5a9de
movq (%rsp), %rdi
callq 0x58fa0
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: Eba-M[P]E3DC-Control/cJSON.c
// Function: cJSON_CreateBool
CJSON_PUBLIC(cJSON *) cJSON_CreateBool(cJSON_bool boolean)
{
    cJSON *item = cJSON_New_Item(&global_hooks);
    if(item)
    {
        item->type = boolean ? cJSON_True : cJSON_False;
    }

    return item;
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
leaq 0x139d9(%rip), %rdi     # 0x6e3d8
callq 0x59500
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x5aa2d
movl 0x14(%rsp), %edx
movl $0x1, %ecx
movl $0x2, %eax
cmpl $0x0, %edx
cmovnel %eax, %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x18(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: Eba-M[P]E3DC-Control/cJSON.c
// Function: cJSON_AddNumberToObject
CJSON_PUBLIC(cJSON*) cJSON_AddNumberToObject(cJSON * const object, const char * const name, const double number)
{
    cJSON *number_item = cJSON_CreateNumber(number);
    if (add_item_to_object(object, name, number_item, &global_hooks, false))
    {
        return number_item;
    }

    cJSON_Delete(number_item);
    return NULL;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x5aab0
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq (%rsp), %rdx
leaq 0x13960(%rip), %rcx     # 0x6e3d8
xorl %r8d, %r8d
callq 0x5a4a0
cmpl $0x0, %eax
je 0x5aa90
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x5aaa2
movq (%rsp), %rdi
callq 0x58fa0
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: Eba-M[P]E3DC-Control/cJSON.c
// Function: cJSON_CreateNumber
CJSON_PUBLIC(cJSON *) cJSON_CreateNumber(double num)
{
    cJSON *item = cJSON_New_Item(&global_hooks);
    if(item)
    {
        item->type = cJSON_Number;
        item->valuedouble = num;

        /* use saturation in case of overflow */
        if (num >= INT_MAX)
        {
            item->valueint = INT_MAX;
        }
        else if (num <= (double)INT_MIN)
        {
            item->valueint = INT_MIN;
        }
        else
        {
            item->valueint = (int)num;
        }
    }

    return item;
}

// Assembly:
subq $0x18, %rsp
movsd %xmm0, 0x10(%rsp)
leaq 0x13917(%rip), %rdi     # 0x6e3d8
callq 0x59500
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x5ab41
movq 0x8(%rsp), %rax
movl $0x8, 0x18(%rax)
movsd 0x10(%rsp), %xmm0
movq 0x8(%rsp), %rax
movsd %xmm0, 0x30(%rax)
movsd 0x10(%rsp), %xmm0
movsd 0x7ccb(%rip), %xmm1     # 0x627c8
ucomisd %xmm1, %xmm0
jb 0x5ab11
movq 0x8(%rsp), %rax
movl $0x7fffffff, 0x28(%rax) # imm = 0x7FFFFFFF
jmp 0x5ab3f
movsd 0x7cb7(%rip), %xmm0     # 0x627d0
ucomisd 0x10(%rsp), %xmm0
jb 0x5ab2f
movq 0x8(%rsp), %rax
movl $0x80000000, 0x28(%rax) # imm = 0x80000000
jmp 0x5ab3d
cvttsd2si 0x10(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x28(%rax)
jmp 0x5ab3f
jmp 0x5ab41
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: Eba-M[P]E3DC-Control/cJSON.c
// Function: cJSON_AddStringToObject
CJSON_PUBLIC(cJSON*) cJSON_AddStringToObject(cJSON * const object, const char * const name, const char * const string)
{
    cJSON *string_item = cJSON_CreateString(string);
    if (add_item_to_object(object, name, string_item, &global_hooks, false))
    {
        return string_item;
    }

    cJSON_Delete(string_item);
    return NULL;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x5abc0
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq (%rsp), %rdx
leaq 0x13852(%rip), %rcx     # 0x6e3d8
xorl %r8d, %r8d
callq 0x5a4a0
cmpl $0x0, %eax
je 0x5ab9e
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x5abb0
movq (%rsp), %rdi
callq 0x58fa0
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: Eba-M[P]E3DC-Control/cJSON.c
// Function: cJSON_CreateString
CJSON_PUBLIC(cJSON *) cJSON_CreateString(const char *string)
{
    cJSON *item = cJSON_New_Item(&global_hooks);
    if(item)
    {
        item->type = cJSON_String;
        item->valuestring = (char*)cJSON_strdup((const unsigned char*)string, &global_hooks);
        if(!item->valuestring)
        {
            cJSON_Delete(item);
            return NULL;
        }
    }

    return item;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
leaq 0x13808(%rip), %rdi     # 0x6e3d8
callq 0x59500
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x5ac28
movq (%rsp), %rax
movl $0x10, 0x18(%rax)
movq 0x8(%rsp), %rdi
leaq 0x137e1(%rip), %rsi     # 0x6e3d8
callq 0x591f0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x20(%rax)
movq (%rsp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x5ac26
movq (%rsp), %rdi
callq 0x58fa0
movq $0x0, 0x10(%rsp)
jmp 0x5ac31
jmp 0x5ac28
movq (%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: Eba-M[P]E3DC-Control/cJSON.c
// Function: cJSON_AddRawToObject
CJSON_PUBLIC(cJSON*) cJSON_AddRawToObject(cJSON * const object, const char * const name, const char * const raw)
{
    cJSON *raw_item = cJSON_CreateRaw(raw);
    if (add_item_to_object(object, name, raw_item, &global_hooks, false))
    {
        return raw_item;
    }

    cJSON_Delete(raw_item);
    return NULL;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x5acb0
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq (%rsp), %rdx
leaq 0x13762(%rip), %rcx     # 0x6e3d8
xorl %r8d, %r8d
callq 0x5a4a0
cmpl $0x0, %eax
je 0x5ac8e
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x5aca0
movq (%rsp), %rdi
callq 0x58fa0
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: Eba-M[P]E3DC-Control/cJSON.c
// Function: cJSON_CreateRaw
CJSON_PUBLIC(cJSON *) cJSON_CreateRaw(const char *raw)
{
    cJSON *item = cJSON_New_Item(&global_hooks);
    if(item)
    {
        item->type = cJSON_Raw;
        item->valuestring = (char*)cJSON_strdup((const unsigned char*)raw, &global_hooks);
        if(!item->valuestring)
        {
            cJSON_Delete(item);
            return NULL;
        }
    }

    return item;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
leaq 0x13718(%rip), %rdi     # 0x6e3d8
callq 0x59500
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x5ad18
movq (%rsp), %rax
movl $0x80, 0x18(%rax)
movq 0x8(%rsp), %rdi
leaq 0x136f1(%rip), %rsi     # 0x6e3d8
callq 0x591f0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x20(%rax)
movq (%rsp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x5ad16
movq (%rsp), %rdi
callq 0x58fa0
movq $0x0, 0x10(%rsp)
jmp 0x5ad21
jmp 0x5ad18
movq (%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: Eba-M[P]E3DC-Control/cJSON.c
// Function: cJSON_AddObjectToObject
CJSON_PUBLIC(cJSON*) cJSON_AddObjectToObject(cJSON * const object, const char * const name)
{
    cJSON *object_item = cJSON_CreateObject();
    if (add_item_to_object(object, name, object_item, &global_hooks, false))
    {
        return object_item;
    }

    cJSON_Delete(object_item);
    return NULL;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
callq 0x5ada0
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
leaq 0x1367a(%rip), %rcx     # 0x6e3d8
xorl %r8d, %r8d
callq 0x5a4a0
cmpl $0x0, %eax
je 0x5ad77
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x5ad8a
movq 0x8(%rsp), %rdi
callq 0x58fa0
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: Eba-M[P]E3DC-Control/cJSON.c
// Function: cJSON_CreateObject
CJSON_PUBLIC(cJSON *) cJSON_CreateObject(void)
{
    cJSON *item = cJSON_New_Item(&global_hooks);
    if (item)
    {
        item->type = cJSON_Object;
    }

    return item;
}

// Assembly:
pushq %rax
leaq 0x13630(%rip), %rdi     # 0x6e3d8
callq 0x59500
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x5adc3
movq (%rsp), %rax
movl $0x40, 0x18(%rax)
movq (%rsp), %rax
popq %rcx
retq
nopl (%rax)
// File: Eba-M[P]E3DC-Control/cJSON.c
// Function: cJSON_AddArrayToObject
CJSON_PUBLIC(cJSON*) cJSON_AddArrayToObject(cJSON * const object, const char * const name)
{
    cJSON *array = cJSON_CreateArray();
    if (add_item_to_object(object, name, array, &global_hooks, false))
    {
        return array;
    }

    cJSON_Delete(array);
    return NULL;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
callq 0x5ae40
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
leaq 0x135da(%rip), %rcx     # 0x6e3d8
xorl %r8d, %r8d
callq 0x5a4a0
cmpl $0x0, %eax
je 0x5ae17
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x5ae2a
movq 0x8(%rsp), %rdi
callq 0x58fa0
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: Eba-M[P]E3DC-Control/cJSON.c
// Function: cJSON_CreateArray
CJSON_PUBLIC(cJSON *) cJSON_CreateArray(void)
{
    cJSON *item = cJSON_New_Item(&global_hooks);
    if(item)
    {
        item->type=cJSON_Array;
    }

    return item;
}

// Assembly:
pushq %rax
leaq 0x13590(%rip), %rdi     # 0x6e3d8
callq 0x59500
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x5ae63
movq (%rsp), %rax
movl $0x20, 0x18(%rax)
movq (%rsp), %rax
popq %rcx
retq
nopl (%rax)
// File: Eba-M[P]E3DC-Control/cJSON.c
// Function: cJSON_DetachItemViaPointer
CJSON_PUBLIC(cJSON *) cJSON_DetachItemViaPointer(cJSON *parent, cJSON * const item)
{
    if ((parent == NULL) || (item == NULL))
    {
        return NULL;
    }

    if (item != parent->child)
    {
        /* not the first element */
        item->prev->next = item->next;
    }
    if (item->next != NULL)
    {
        /* not the last element */
        item->next->prev = item->prev;
    }

    if (item == parent->child)
    {
        /* first element */
        parent->child = item->next;
    }
    else if (item->next == NULL)
    {
        /* last element */
        parent->child->prev = item->prev;
    }

    /* make sure the detached item doesn't point anywhere anymore */
    item->prev = NULL;
    item->next = NULL;

    return item;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
cmpq $0x0, -0x10(%rsp)
je 0x5ae8a
cmpq $0x0, -0x18(%rsp)
jne 0x5ae98
movq $0x0, -0x8(%rsp)
jmp 0x5af45
movq -0x18(%rsp), %rax
movq -0x10(%rsp), %rcx
cmpq 0x10(%rcx), %rax
je 0x5aebc
movq -0x18(%rsp), %rax
movq (%rax), %rcx
movq -0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq -0x18(%rsp), %rax
cmpq $0x0, (%rax)
je 0x5aedc
movq -0x18(%rsp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rsp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rsp), %rax
movq -0x10(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jne 0x5aeff
movq -0x18(%rsp), %rax
movq (%rax), %rcx
movq -0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
jmp 0x5af22
movq -0x18(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x5af20
movq -0x18(%rsp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
jmp 0x5af22
movq -0x18(%rsp), %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rsp), %rax
movq $0x0, (%rax)
movq -0x18(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopl (%rax,%rax)
// File: Eba-M[P]E3DC-Control/cJSON.c
// Function: cJSON_InsertItemInArray
CJSON_PUBLIC(cJSON_bool) cJSON_InsertItemInArray(cJSON *array, int which, cJSON *newitem)
{
    cJSON *after_inserted = NULL;

    if (which < 0)
    {
        return false;
    }

    after_inserted = get_array_item(array, (size_t)which);
    if (after_inserted == NULL)
    {
        return add_item_to_array(array, newitem);
    }

    newitem->next = after_inserted;
    newitem->prev = after_inserted->prev;
    after_inserted->prev = newitem;
    if (after_inserted == array->child)
    {
        array->child = newitem;
    }
    else
    {
        newitem->prev->next = newitem;
    }
    return true;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq %rdx, 0x8(%rsp)
movq $0x0, (%rsp)
cmpl $0x0, 0x14(%rsp)
jge 0x5b0ee
movl $0x0, 0x24(%rsp)
jmp 0x5b17f
movq 0x18(%rsp), %rdi
movslq 0x14(%rsp), %rsi
callq 0x5a100
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x5b11d
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x5a390
movl %eax, 0x24(%rsp)
jmp 0x5b17f
movq (%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq (%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movq (%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jne 0x5b166
movq 0x8(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x10(%rax)
jmp 0x5b177
movq 0x8(%rsp), %rcx
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: Eba-M[P]E3DC-Control/cJSON.c
// Function: cJSON_ReplaceItemViaPointer
CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemViaPointer(cJSON * const parent, cJSON * const item, cJSON * replacement)
{
    if ((parent == NULL) || (parent->child == NULL) || (replacement == NULL) || (item == NULL))
    {
        return false;
    }

    if (replacement == item)
    {
        return true;
    }

    replacement->next = item->next;
    replacement->prev = item->prev;

    if (replacement->next != NULL)
    {
        replacement->next->prev = replacement;
    }
    if (parent->child == item)
    {
        if (parent->child->prev == parent->child)
        {
            replacement->prev = replacement;
        }
        parent->child = replacement;
    }
    else
    {   /*
         * To find the last item in array quickly, we use prev in array.
         * We can't modify the last item's next pointer where this item was the parent's child
         */
        if (replacement->prev != NULL)
        {
            replacement->prev->next = replacement;
        }
        if (replacement->next == NULL)
        {
            parent->child->prev = replacement;
        }
    }

    item->next = NULL;
    item->prev = NULL;
    cJSON_Delete(item);

    return true;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x5b1c7
movq 0x18(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x5b1c7
cmpq $0x0, 0x8(%rsp)
je 0x5b1c7
cmpq $0x0, 0x10(%rsp)
jne 0x5b1d4
movl $0x0, 0x24(%rsp)
jmp 0x5b2d8
movq 0x8(%rsp), %rax
cmpq 0x10(%rsp), %rax
jne 0x5b1ed
movl $0x1, 0x24(%rsp)
jmp 0x5b2d8
movq 0x10(%rsp), %rax
movq (%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
cmpq $0x0, (%rax)
je 0x5b22b
movq 0x8(%rsp), %rcx
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
cmpq 0x10(%rsp), %rax
jne 0x5b271
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq 0x18(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jne 0x5b261
movq 0x8(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x10(%rax)
jmp 0x5b2ad
movq 0x8(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x5b28e
movq 0x8(%rsp), %rcx
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x5b2ab
movq 0x8(%rsp), %rcx
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
jmp 0x5b2ad
movq 0x10(%rsp), %rax
movq $0x0, (%rax)
movq 0x10(%rsp), %rax
movq $0x0, 0x8(%rax)
movq 0x10(%rsp), %rdi
callq 0x58fa0
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: Eba-M[P]E3DC-Control/cJSON.c
// Function: replace_item_in_object(cJSON*, char const*, cJSON*, int)
static cJSON_bool replace_item_in_object(cJSON *object, const char *string, cJSON *replacement, cJSON_bool case_sensitive)
{
    if ((replacement == NULL) || (string == NULL))
    {
        return false;
    }

    /* replace the name in the replacement */
    if (!(replacement->type & cJSON_StringIsConst) && (replacement->string != NULL))
    {
        cJSON_free(replacement->string);
    }
    replacement->string = (char*)cJSON_strdup((const unsigned char*)string, &global_hooks);
    if (replacement->string == NULL)
    {
        return false;
    }

    replacement->type &= ~cJSON_StringIsConst;

    return cJSON_ReplaceItemViaPointer(object, get_object_item(object, string, case_sensitive), replacement);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movl %ecx, 0x14(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x5b3a7
cmpq $0x0, 0x20(%rsp)
jne 0x5b3b4
movl $0x0, 0x34(%rsp)
jmp 0x5b457
movq 0x18(%rsp), %rax
movl 0x18(%rax), %eax
andl $0x200, %eax            # imm = 0x200
cmpl $0x0, %eax
jne 0x5b3e0
movq 0x18(%rsp), %rax
cmpq $0x0, 0x38(%rax)
je 0x5b3e0
movq 0x18(%rsp), %rax
movq 0x38(%rax), %rdi
callq 0x59280
movq 0x20(%rsp), %rdi
leaq 0x12fec(%rip), %rsi     # 0x6e3d8
callq 0x591f0
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x38(%rax)
movq 0x18(%rsp), %rax
cmpq $0x0, 0x38(%rax)
jne 0x5b413
movl $0x0, 0x34(%rsp)
jmp 0x5b457
movq 0x18(%rsp), %rax
movl 0x18(%rax), %ecx
andl $0xfffffdff, %ecx       # imm = 0xFFFFFDFF
movl %ecx, 0x18(%rax)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl 0x14(%rsp), %edx
callq 0x5a1c0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movq 0x18(%rsp), %rdx
callq 0x5b190
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
// File: Eba-M[P]E3DC-Control/cJSON.c
// Function: cJSON_CreateStringReference
CJSON_PUBLIC(cJSON *) cJSON_CreateStringReference(const char *string)
{
    cJSON *item = cJSON_New_Item(&global_hooks);
    if (item != NULL)
    {
        item->type = cJSON_String | cJSON_IsReference;
        item->valuestring = (char*)cast_away_const(string);
    }

    return item;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
leaq 0x12f38(%rip), %rdi     # 0x6e3d8
callq 0x59500
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x5b4d4
movq 0x8(%rsp), %rax
movl $0x110, 0x18(%rax)      # imm = 0x110
movq 0x10(%rsp), %rdi
callq 0x5b4e0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nop
// File: Eba-M[P]E3DC-Control/cJSON.c
// Function: cJSON_CreateObjectReference
CJSON_PUBLIC(cJSON *) cJSON_CreateObjectReference(const cJSON *child)
{
    cJSON *item = cJSON_New_Item(&global_hooks);
    if (item != NULL) {
        item->type = cJSON_Object | cJSON_IsReference;
        item->child = (cJSON*)cast_away_const(child);
    }

    return item;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
leaq 0x12ed8(%rip), %rdi     # 0x6e3d8
callq 0x59500
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x5b534
movq 0x8(%rsp), %rax
movl $0x140, 0x18(%rax)      # imm = 0x140
movq 0x10(%rsp), %rdi
callq 0x5b4e0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nop
// File: Eba-M[P]E3DC-Control/cJSON.c
// Function: cJSON_CreateArrayReference
CJSON_PUBLIC(cJSON *) cJSON_CreateArrayReference(const cJSON *child) {
    cJSON *item = cJSON_New_Item(&global_hooks);
    if (item != NULL) {
        item->type = cJSON_Array | cJSON_IsReference;
        item->child = (cJSON*)cast_away_const(child);
    }

    return item;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
leaq 0x12e88(%rip), %rdi     # 0x6e3d8
callq 0x59500
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x5b584
movq 0x8(%rsp), %rax
movl $0x120, 0x18(%rax)      # imm = 0x120
movq 0x10(%rsp), %rdi
callq 0x5b4e0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nop
// File: Eba-M[P]E3DC-Control/cJSON.c
// Function: cJSON_CreateIntArray
CJSON_PUBLIC(cJSON *) cJSON_CreateIntArray(const int *numbers, int count)
{
    size_t i = 0;
    cJSON *n = NULL;
    cJSON *p = NULL;
    cJSON *a = NULL;

    if ((count < 0) || (numbers == NULL))
    {
        return NULL;
    }

    a = cJSON_CreateArray();

    for(i = 0; a && (i < (size_t)count); i++)
    {
        n = cJSON_CreateNumber(numbers[i]);
        if (!n)
        {
            cJSON_Delete(a);
            return NULL;
        }
        if(!i)
        {
            a->child = n;
        }
        else
        {
            suffix_object(p, n);
        }
        p = n;
    }

    if (a && a->child) {
        a->child->prev = n;
    }

    return a;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movl %esi, 0x34(%rsp)
movq $0x0, 0x28(%rsp)
movq $0x0, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
cmpl $0x0, 0x34(%rsp)
jl 0x5b5d0
cmpq $0x0, 0x38(%rsp)
jne 0x5b5de
movq $0x0, 0x40(%rsp)
jmp 0x5b6c7
callq 0x5ae40
movq %rax, 0x10(%rsp)
movq $0x0, 0x28(%rsp)
xorl %eax, %eax
cmpq $0x0, 0x10(%rsp)
movb %al, 0xf(%rsp)
je 0x5b613
movq 0x28(%rsp), %rax
movslq 0x34(%rsp), %rcx
cmpq %rcx, %rax
setb %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x5b61d
jmp 0x5b697
movq 0x38(%rsp), %rax
movq 0x28(%rsp), %rcx
cvtsi2sdl (%rax,%rcx,4), %xmm0
callq 0x5aab0
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x5b653
movq 0x10(%rsp), %rdi
callq 0x58fa0
movq $0x0, 0x40(%rsp)
jmp 0x5b6c7
cmpq $0x0, 0x28(%rsp)
jne 0x5b66b
movq 0x20(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
jmp 0x5b67a
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x5b6e0
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x5b5f1
cmpq $0x0, 0x10(%rsp)
je 0x5b6bd
movq 0x10(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x5b6bd
movq 0x20(%rsp), %rcx
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: Eba-M[P]E3DC-Control/cJSON.c
// Function: cJSON_CreateFloatArray
CJSON_PUBLIC(cJSON *) cJSON_CreateFloatArray(const float *numbers, int count)
{
    size_t i = 0;
    cJSON *n = NULL;
    cJSON *p = NULL;
    cJSON *a = NULL;

    if ((count < 0) || (numbers == NULL))
    {
        return NULL;
    }

    a = cJSON_CreateArray();

    for(i = 0; a && (i < (size_t)count); i++)
    {
        n = cJSON_CreateNumber((double)numbers[i]);
        if(!n)
        {
            cJSON_Delete(a);
            return NULL;
        }
        if(!i)
        {
            a->child = n;
        }
        else
        {
            suffix_object(p, n);
        }
        p = n;
    }

    if (a && a->child) {
        a->child->prev = n;
    }

    return a;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movl %esi, 0x34(%rsp)
movq $0x0, 0x28(%rsp)
movq $0x0, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
cmpl $0x0, 0x34(%rsp)
jl 0x5b750
cmpq $0x0, 0x38(%rsp)
jne 0x5b75e
movq $0x0, 0x40(%rsp)
jmp 0x5b84b
callq 0x5ae40
movq %rax, 0x10(%rsp)
movq $0x0, 0x28(%rsp)
xorl %eax, %eax
cmpq $0x0, 0x10(%rsp)
movb %al, 0xf(%rsp)
je 0x5b793
movq 0x28(%rsp), %rax
movslq 0x34(%rsp), %rcx
cmpq %rcx, %rax
setb %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x5b79d
jmp 0x5b81b
movq 0x38(%rsp), %rax
movq 0x28(%rsp), %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x5aab0
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x5b7d7
movq 0x10(%rsp), %rdi
callq 0x58fa0
movq $0x0, 0x40(%rsp)
jmp 0x5b84b
cmpq $0x0, 0x28(%rsp)
jne 0x5b7ef
movq 0x20(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
jmp 0x5b7fe
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x5b6e0
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x5b771
cmpq $0x0, 0x10(%rsp)
je 0x5b841
movq 0x10(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x5b841
movq 0x20(%rsp), %rcx
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: Eba-M[P]E3DC-Control/cJSON.c
// Function: cJSON_CreateStringArray
CJSON_PUBLIC(cJSON *) cJSON_CreateStringArray(const char *const *strings, int count)
{
    size_t i = 0;
    cJSON *n = NULL;
    cJSON *p = NULL;
    cJSON *a = NULL;

    if ((count < 0) || (strings == NULL))
    {
        return NULL;
    }

    a = cJSON_CreateArray();

    for (i = 0; a && (i < (size_t)count); i++)
    {
        n = cJSON_CreateString(strings[i]);
        if(!n)
        {
            cJSON_Delete(a);
            return NULL;
        }
        if(!i)
        {
            a->child = n;
        }
        else
        {
            suffix_object(p,n);
        }
        p = n;
    }

    if (a && a->child) {
        a->child->prev = n;
    }

    return a;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movl %esi, 0x34(%rsp)
movq $0x0, 0x28(%rsp)
movq $0x0, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
cmpl $0x0, 0x34(%rsp)
jl 0x5b9f0
cmpq $0x0, 0x38(%rsp)
jne 0x5b9fe
movq $0x0, 0x40(%rsp)
jmp 0x5bae6
callq 0x5ae40
movq %rax, 0x10(%rsp)
movq $0x0, 0x28(%rsp)
xorl %eax, %eax
cmpq $0x0, 0x10(%rsp)
movb %al, 0xf(%rsp)
je 0x5ba33
movq 0x28(%rsp), %rax
movslq 0x34(%rsp), %rcx
cmpq %rcx, %rax
setb %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x5ba3d
jmp 0x5bab6
movq 0x38(%rsp), %rax
movq 0x28(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x5abc0
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x5ba72
movq 0x10(%rsp), %rdi
callq 0x58fa0
movq $0x0, 0x40(%rsp)
jmp 0x5bae6
cmpq $0x0, 0x28(%rsp)
jne 0x5ba8a
movq 0x20(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
jmp 0x5ba99
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x5b6e0
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x5ba11
cmpq $0x0, 0x10(%rsp)
je 0x5badc
movq 0x10(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x5badc
movq 0x20(%rsp), %rcx
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
// File: Eba-M[P]E3DC-Control/cJSON.c
// Function: cJSON_Minify
CJSON_PUBLIC(void) cJSON_Minify(char *json)
{
    char *into = json;

    if (json == NULL)
    {
        return;
    }

    while (json[0] != '\0')
    {
        switch (json[0])
        {
            case ' ':
            case '\t':
            case '\r':
            case '\n':
                json++;
                break;

            case '/':
                if (json[1] == '/')
                {
                    skip_oneline_comment(&json);
                }
                else if (json[1] == '*')
                {
                    skip_multiline_comment(&json);
                } else {
                    json++;
                }
                break;

            case '\"':
                minify_string(&json, (char**)&into);
                break;

            default:
                into[0] = json[0];
                json++;
                into++;
        }
    }

    /* and null-terminate. */
    *into = '\0';
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x5bd50
jmp 0x5be46
jmp 0x5bd52
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x5be3e
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
movl %eax, 0x4(%rsp)
addl $-0x9, %eax
subl $0x2, %eax
jb 0x5bda5
jmp 0x5bd79
movl 0x4(%rsp), %eax
subl $0xd, %eax
je 0x5bda5
jmp 0x5bd84
movl 0x4(%rsp), %eax
subl $0x20, %eax
je 0x5bda5
jmp 0x5bd8f
movl 0x4(%rsp), %eax
subl $0x22, %eax
je 0x5bdfe
jmp 0x5bd9a
movl 0x4(%rsp), %eax
subl $0x2f, %eax
je 0x5bdb8
jmp 0x5be0f
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x5be39
movq 0x10(%rsp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x2f, %eax
jne 0x5bdd2
leaq 0x10(%rsp), %rdi
callq 0x5be50
jmp 0x5bdfc
movq 0x10(%rsp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x2a, %eax
jne 0x5bdec
leaq 0x10(%rsp), %rdi
callq 0x5beb0
jmp 0x5bdfa
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x5bdfc
jmp 0x5be39
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x5bf20
jmp 0x5be39
movq 0x10(%rsp), %rax
movb (%rax), %cl
movq 0x8(%rsp), %rax
movb %cl, (%rax)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x5bd52
movq 0x8(%rsp), %rax
movb $0x0, (%rax)
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: Eba-M[P]E3DC-Control/cJSON.c
// Function: skip_oneline_comment(char**)
static void skip_oneline_comment(char **input)
{
    *input += static_strlen("//");

    for (; (*input)[0] != '\0'; ++(*input))
    {
        if ((*input)[0] == '\n') {
            *input += static_strlen("\n");
            return;
        }
    }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq (%rax), %rcx
addq $0x2, %rcx
movq %rcx, (%rax)
movq -0x8(%rsp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x5bea8
movq -0x8(%rsp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
jne 0x5be95
movq -0x8(%rsp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x5bea8
jmp 0x5be97
movq -0x8(%rsp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x5be64
retq
nopl (%rax)
// File: Eba-M[P]E3DC-Control/cJSON.c
// Function: skip_multiline_comment(char**)
static void skip_multiline_comment(char **input)
{
    *input += static_strlen("/*");

    for (; (*input)[0] != '\0'; ++(*input))
    {
        if (((*input)[0] == '*') && ((*input)[1] == '/'))
        {
            *input += static_strlen("*/");
            return;
        }
    }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq (%rax), %rcx
addq $0x2, %rcx
movq %rcx, (%rax)
movq -0x8(%rsp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x5bf19
movq -0x8(%rsp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x2a, %eax
jne 0x5bf06
movq -0x8(%rsp), %rax
movq (%rax), %rax
movsbl 0x1(%rax), %eax
cmpl $0x2f, %eax
jne 0x5bf06
movq -0x8(%rsp), %rax
movq (%rax), %rcx
addq $0x2, %rcx
movq %rcx, (%rax)
jmp 0x5bf19
jmp 0x5bf08
movq -0x8(%rsp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x5bec4
retq
nopw (%rax,%rax)
// File: Eba-M[P]E3DC-Control/cJSON.c
// Function: minify_string(char**, char**)
static void minify_string(char **input, char **output) {
    (*output)[0] = (*input)[0];
    *input += static_strlen("\"");
    *output += static_strlen("\"");


    for (; (*input)[0] != '\0'; (void)++(*input), ++(*output)) {
        (*output)[0] = (*input)[0];

        if ((*input)[0] == '\"') {
            (*output)[0] = '\"';
            *input += static_strlen("\"");
            *output += static_strlen("\"");
            return;
        } else if (((*input)[0] == '\\') && ((*input)[1] == '\"')) {
            (*output)[1] = (*input)[1];
            *input += static_strlen("\"");
            *output += static_strlen("\"");
        }
    }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq (%rax), %rax
movb (%rax), %cl
movq -0x10(%rsp), %rax
movq (%rax), %rax
movb %cl, (%rax)
movq -0x8(%rsp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x10(%rsp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x8(%rsp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x5c03b
movq -0x8(%rsp), %rax
movq (%rax), %rax
movb (%rax), %cl
movq -0x10(%rsp), %rax
movq (%rax), %rax
movb %cl, (%rax)
movq -0x8(%rsp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x22, %eax
jne 0x5bfbf
movq -0x10(%rsp), %rax
movq (%rax), %rax
movb $0x22, (%rax)
movq -0x8(%rsp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x10(%rsp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x5c03b
movq -0x8(%rsp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x5c, %eax
jne 0x5c014
movq -0x8(%rsp), %rax
movq (%rax), %rax
movsbl 0x1(%rax), %eax
cmpl $0x22, %eax
jne 0x5c014
movq -0x8(%rsp), %rax
movq (%rax), %rax
movb 0x1(%rax), %cl
movq -0x10(%rsp), %rax
movq (%rax), %rax
movb %cl, 0x1(%rax)
movq -0x8(%rsp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x10(%rsp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x5c016
jmp 0x5c018
movq -0x8(%rsp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x10(%rsp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x5bf5c
retq
nopl (%rax)
// File: Eba-M[P]E3DC-Control/cJSON.c
// Function: update_offset(printbuffer*)
static void update_offset(printbuffer * const buffer)
{
    const unsigned char *buffer_pointer = NULL;
    if ((buffer == NULL) || (buffer->buffer == NULL))
    {
        return;
    }
    buffer_pointer = buffer->buffer + buffer->offset;

    buffer->offset += strlen((const char*)buffer_pointer);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x5c715
movq 0x10(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x5c717
jmp 0x5c747
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rsp), %rcx
addq 0x10(%rcx), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x2130
movq %rax, %rcx
movq 0x10(%rsp), %rax
addq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
addq $0x18, %rsp
retq
nopl (%rax)
// File: Eba-M[P]E3DC-Control/cJSON.c
// Function: parse_hex4(unsigned char const*)
static unsigned parse_hex4(const unsigned char * const input)
{
    unsigned int h = 0;
    size_t i = 0;

    for (i = 0; i < 4; i++)
    {
        /* parse digit */
        if ((input[i] >= '0') && (input[i] <= '9'))
        {
            h += (unsigned int) input[i] - '0';
        }
        else if ((input[i] >= 'A') && (input[i] <= 'F'))
        {
            h += (unsigned int) 10 + input[i] - 'A';
        }
        else if ((input[i] >= 'a') && (input[i] <= 'f'))
        {
            h += (unsigned int) 10 + input[i] - 'a';
        }
        else /* invalid */
        {
            return 0;
        }

        if (i < 3)
        {
            /* shift left to make place for the next nibble */
            h = h << 4;
        }
    }

    return h;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movl $0x0, -0x14(%rsp)
movq $0x0, -0x20(%rsp)
movq $0x0, -0x20(%rsp)
cmpq $0x4, -0x20(%rsp)
jae 0x5d72d
movq -0x10(%rsp), %rax
movq -0x20(%rsp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x30, %eax
jl 0x5d66f
movq -0x10(%rsp), %rax
movq -0x20(%rsp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x39, %eax
jg 0x5d66f
movq -0x10(%rsp), %rax
movq -0x20(%rsp), %rcx
movzbl (%rax,%rcx), %eax
subl $0x30, %eax
addl -0x14(%rsp), %eax
movl %eax, -0x14(%rsp)
jmp 0x5d705
movq -0x10(%rsp), %rax
movq -0x20(%rsp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x41, %eax
jl 0x5d6b3
movq -0x10(%rsp), %rax
movq -0x20(%rsp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x46, %eax
jg 0x5d6b3
movq -0x10(%rsp), %rax
movq -0x20(%rsp), %rcx
movzbl (%rax,%rcx), %eax
addl $0xa, %eax
subl $0x41, %eax
addl -0x14(%rsp), %eax
movl %eax, -0x14(%rsp)
jmp 0x5d703
movq -0x10(%rsp), %rax
movq -0x20(%rsp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x61, %eax
jl 0x5d6f7
movq -0x10(%rsp), %rax
movq -0x20(%rsp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x66, %eax
jg 0x5d6f7
movq -0x10(%rsp), %rax
movq -0x20(%rsp), %rcx
movzbl (%rax,%rcx), %eax
addl $0xa, %eax
subl $0x61, %eax
addl -0x14(%rsp), %eax
movl %eax, -0x14(%rsp)
jmp 0x5d701
movl $0x0, -0x4(%rsp)
jmp 0x5d735
jmp 0x5d703
jmp 0x5d705
cmpq $0x3, -0x20(%rsp)
jae 0x5d718
movl -0x14(%rsp), %eax
shll $0x4, %eax
movl %eax, -0x14(%rsp)
jmp 0x5d71a
movq -0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rsp)
jmp 0x5d61f
movl -0x14(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw (%rax,%rax)
// File: Eba-M[P]E3DC-Control/cJSON.c
// Function: case_insensitive_strcmp(unsigned char const*, unsigned char const*)
static int case_insensitive_strcmp(const unsigned char *string1, const unsigned char *string2)
{
    if ((string1 == NULL) || (string2 == NULL))
    {
        return 1;
    }

    if (string1 == string2)
    {
        return 0;
    }

    for(; tolower(*string1) == tolower(*string2); (void)string1++, string2++)
    {
        if (*string1 == '\0')
        {
            return 0;
        }
    }

    return tolower(*string1) - tolower(*string2);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x5e5be
cmpq $0x0, 0x10(%rsp)
jne 0x5e5cb
movl $0x1, 0x24(%rsp)
jmp 0x5e66f
movq 0x18(%rsp), %rax
cmpq 0x10(%rsp), %rax
jne 0x5e5e4
movl $0x0, 0x24(%rsp)
jmp 0x5e66f
jmp 0x5e5e6
movq 0x18(%rsp), %rax
movzbl (%rax), %edi
callq 0x23f0
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rax
movzbl (%rax), %edi
callq 0x23f0
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jne 0x5e645
movq 0x18(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x0, %eax
jne 0x5e625
movl $0x0, 0x24(%rsp)
jmp 0x5e66f
jmp 0x5e627
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x5e5e6
movq 0x18(%rsp), %rax
movzbl (%rax), %edi
callq 0x23f0
movl %eax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movzbl (%rax), %edi
callq 0x23f0
movl %eax, %ecx
movl 0x8(%rsp), %eax
subl %ecx, %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: Eba-M[P]E3DC-Control/SunriseCalc.cpp
// Function: SunriseCalc::date(int, int, int, bool)
void SunriseCalc::date(int y, int m, int d, bool dst)
{
  year = y;
  month = m;
  day = d;
  isDST = dst;

  calculated = false;
}

// Assembly:
movb %r8b, %al
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl %edx, -0x10(%rsp)
movl %ecx, -0x14(%rsp)
andb $0x1, %al
movb %al, -0x15(%rsp)
movq -0x8(%rsp), %rax
movl -0xc(%rsp), %ecx
movl %ecx, 0xc(%rax)
movl -0x10(%rsp), %ecx
movl %ecx, 0x10(%rax)
movl -0x14(%rsp), %ecx
movl %ecx, 0x14(%rax)
movb -0x15(%rsp), %cl
andb $0x1, %cl
movb %cl, 0x18(%rax)
movb $0x0, 0x19(%rax)
retq
nopw %cs:(%rax,%rax)
// File: agorenst[P]trie/prefixtree.cpp
// Function: main
int main(int argc, char* argv[]) {
    string line;
    prefix_tree<int> t;
    while (cin) {
        getline(cin, line);
        istringstream int_parser(line);
        int x;
        vector<int> int_stream;
        while (!int_parser.eof()) {
            int_parser >> x;
            int_stream.push_back(x);
        }
        t.insert(int_stream.rbegin(), int_stream.rend());
    }
    cout << 
"\\documentclass{standalone}\
\\usepackage{tikz}\
\\begin{document}\
\\usetikzlibrary{graphdrawing,graphdrawing.trees}\
\\begin{tikzpicture}\\begin{scope}[tree layout]";
    t.tikz_print(cout);
    cout <<
"\\end{scope}\
\\end{tikzpicture}\
\\end{document}";
    cout << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x220, %rsp            # imm = 0x220
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2160
leaq -0x40(%rbp), %rdi
callq 0x2580
jmp 0x236d
jmp 0x236f
movq 0x7c6a(%rip), %rdi      # 0x9fe0
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x2150
movb %al, -0x201(%rbp)
jmp 0x238d
movb -0x201(%rbp), %al
testb $0x1, %al
jne 0x239c
jmp 0x24e7
movq 0x7c3d(%rip), %rdi      # 0x9fe0
leaq -0x30(%rbp), %rsi
callq 0x2040
jmp 0x23ae
leaq -0x1d0(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movl $0x8, %edx
callq 0x21c0
jmp 0x23c5
leaq -0x1f0(%rbp), %rdi
callq 0x25a0
movq -0x1d0(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x1d0(%rbp,%rax), %rdi
callq 0x21f0
movb %al, -0x202(%rbp)
jmp 0x23f1
movb -0x202(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x23ff
jmp 0x2476
leaq -0x1d0(%rbp), %rdi
leaq -0x1d4(%rbp), %rsi
callq 0x20b0
jmp 0x2414
leaq -0x1f0(%rbp), %rdi
leaq -0x1d4(%rbp), %rsi
callq 0x25c0
jmp 0x2429
jmp 0x23d1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x255f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x2556
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x1f0(%rbp), %rdi
callq 0x2730
leaq -0x1d0(%rbp), %rdi
callq 0x2080
jmp 0x2556
leaq -0x1f8(%rbp), %rdi
movq %rdi, -0x218(%rbp)
leaq -0x1f0(%rbp), %rsi
movq %rsi, -0x220(%rbp)
callq 0x2690
movq -0x220(%rbp), %rsi
leaq -0x200(%rbp), %rdi
movq %rdi, -0x210(%rbp)
callq 0x26e0
movq -0x218(%rbp), %rsi
movq -0x210(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0x2630
jmp 0x24ca
leaq -0x1f0(%rbp), %rdi
callq 0x2730
leaq -0x1d0(%rbp), %rdi
callq 0x2080
jmp 0x236f
movq 0x7ae2(%rip), %rdi      # 0x9fd0
leaq 0x3b0f(%rip), %rsi      # 0x6004
callq 0x2110
jmp 0x24fc
movq 0x7acd(%rip), %rsi      # 0x9fd0
leaq -0x40(%rbp), %rdi
callq 0x2790
jmp 0x250e
movq 0x7abb(%rip), %rdi      # 0x9fd0
leaq 0x3b81(%rip), %rsi      # 0x609d
callq 0x2110
jmp 0x2523
movq 0x7aa6(%rip), %rdi      # 0x9fd0
movq 0x7a87(%rip), %rsi      # 0x9fb8
callq 0x2140
jmp 0x2538
leaq -0x40(%rbp), %rdi
callq 0x2800
leaq -0x30(%rbp), %rdi
callq 0x20c0
movl -0x4(%rbp), %eax
addq $0x220, %rsp            # imm = 0x220
popq %rbp
retq
leaq -0x40(%rbp), %rdi
callq 0x2800
leaq -0x30(%rbp), %rdi
callq 0x20c0
movq -0x48(%rbp), %rdi
callq 0x21e0
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: agorenst[P]trie/./prefixtree.h
// Function: void prefix_tree<int>::node::insert<std::reverse_iterator<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>>>(std::reverse_iterator<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>>, std::reverse_iterator<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>>)
void insert(Iter b, Iter e) {
            if (b == e) { return; } // we are the end of this input
    
            auto symb = *b++; // we advance b, having read from it.
            // we need to make a new child!
            if (edges.find(symb) == edges.end()) {
                edges[symb] = std::make_shared<node>();
            }
    
            // recursive call.
            edges[symb]->insert(b, e);
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdx, -0x90(%rbp)
movq %rsi, %rax
movq -0x90(%rbp), %rsi
movq %rax, -0x88(%rbp)
movq %rdi, %rax
movq -0x88(%rbp), %rdi
movq %rdi, -0x80(%rbp)
movq %rsi, -0x78(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
callq 0x44e0
testb $0x1, %al
jne 0x4374
jmp 0x4379
jmp 0x4462
movq -0x80(%rbp), %rsi
leaq -0x28(%rbp), %rdi
xorl %edx, %edx
callq 0x4520
leaq -0x28(%rbp), %rdi
callq 0x4560
movq -0x70(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
leaq -0x1c(%rbp), %rsi
callq 0x45c0
movq -0x70(%rbp), %rdi
movq %rax, -0x30(%rbp)
callq 0x45f0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x4590
testb $0x1, %al
jne 0x43c7
jmp 0x4418
leaq -0x48(%rbp), %rdi
callq 0x2a80
movq -0x70(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x4620
movq %rax, -0x98(%rbp)
jmp 0x43e6
movq -0x98(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x4700
leaq -0x48(%rbp), %rdi
callq 0x28d0
jmp 0x4418
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x28d0
jmp 0x446b
movq -0x70(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x4620
movq %rax, %rdi
callq 0x4300
movq -0x80(%rbp), %rsi
movq %rax, -0xa0(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x4480
movq -0x78(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x4480
movq -0xa0(%rbp), %rdi
leaq -0x60(%rbp), %rsi
leaq -0x68(%rbp), %rdx
callq 0x4320
addq $0xa0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x21e0
nopw %cs:(%rax,%rax)
nop