LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/tomcatzh[P]RealityBenchmark/external/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x40, %edi
callq *0x5f07(%rip)           # 0xc220
testq %rax, %rax
je 0x6382
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, (%rax)
movl $0x10, 0x18(%rax)
testq %r14, %r14
je 0x6372
movq %r14, %rdi
callq 0x20e0
movq %rax, %r15
incq %r15
movq %r15, %rdi
callq *0x5eca(%rip)           # 0xc220
testq %rax, %rax
je 0x6372
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x21d0
movq %r12, 0x20(%rbx)
jmp 0x6384
movq $0x0, 0x20(%rbx)
movq %rbx, %rdi
callq 0x4fa4
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/tomcatzh[P]RealityBenchmark/external/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x40, %edi
callq *0x5e3a(%rip)           # 0xc220
testq %rax, %rax
je 0x644f
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, (%rax)
movl $0x80, 0x18(%rax)
testq %r14, %r14
je 0x643f
movq %r14, %rdi
callq 0x20e0
movq %rax, %r15
incq %r15
movq %r15, %rdi
callq *0x5dfd(%rip)           # 0xc220
testq %rax, %rax
je 0x643f
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x21d0
movq %r12, 0x20(%rbx)
jmp 0x6451
movq $0x0, 0x20(%rbx)
movq %rbx, %rdi
callq 0x4fa4
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/tomcatzh[P]RealityBenchmark/external/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x40, %edi
callq *0x5daa(%rip)           # 0xc220
movq %rax, %rbx
testq %rax, %rax
je 0x6497
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, (%rbx)
movl $0x40, 0x18(%rbx)
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x5d88
testl %eax, %eax
jne 0x64b5
movq %rbx, %rdi
callq 0x4fa4
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/tomcatzh[P]RealityBenchmark/external/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
movl $0x40, %edi
callq *0x5d56(%rip)           # 0xc220
testq %rax, %rax
je 0x64e8
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, (%rax)
movl $0x40, 0x18(%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/tomcatzh[P]RealityBenchmark/external/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x40, %edi
callq *0x5d20(%rip)           # 0xc220
movq %rax, %rbx
testq %rax, %rax
je 0x6521
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, (%rbx)
movl $0x20, 0x18(%rbx)
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x5d88
testl %eax, %eax
jne 0x653f
movq %rbx, %rdi
callq 0x4fa4
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/tomcatzh[P]RealityBenchmark/external/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
movl $0x40, %edi
callq *0x5ccc(%rip)           # 0xc220
testq %rax, %rax
je 0x6572
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, (%rax)
movl $0x20, 0x18(%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/tomcatzh[P]RealityBenchmark/external/cJSON.c
// Function: cJSON_InsertItemInArray
CJSON_PUBLIC(void) cJSON_InsertItemInArray(cJSON *array, int which, cJSON *newitem)
{
    cJSON *after_inserted = NULL;

    if (which < 0)
    {
        return;
    }

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

    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;
    }
}

// Assembly:
testl %esi, %esi
sets %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x671c
movl %esi, %ecx
addq $0x10, %rdi
movq %rdi, %rax
movq (%rax), %rax
addq $-0x1, %rcx
setb %sil
testq %rax, %rax
je 0x66fc
testb %sil, %sil
jne 0x66e7
testq %rax, %rax
je 0x671d
movq %rax, (%rdx)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rdx)
movq %rdx, 0x8(%rax)
cmpq (%rdi), %rax
je 0x673d
movq 0x8(%rdx), %rax
movq %rdx, (%rax)
retq
testq %rdx, %rdx
je 0x671c
movq (%rdi), %rax
testq %rax, %rax
je 0x673d
movq %rax, %rcx
movq (%rax), %rax
testq %rax, %rax
jne 0x672a
movq %rdx, (%rcx)
movq %rcx, 0x8(%rdx)
retq
movq %rdx, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/tomcatzh[P]RealityBenchmark/external/cJSON.c
// Function: replace_item_in_object
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);
    replacement->type &= ~cJSON_StringIsConst;

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

    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
testq %rdx, %rdx
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
je 0x67ff
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
testb $0x2, 0x19(%rdx)
jne 0x681d
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x681d
callq *0x5a0b(%rip)           # 0xc228
movq %r15, %rdi
callq 0x20e0
movq %rax, %r12
incq %r12
movq %r12, %rdi
callq *0x59ec(%rip)           # 0xc220
movq %rax, %r13
testq %rax, %rax
je 0x684a
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x21d0
movq %r13, 0x38(%rbx)
andb $-0x3, 0x19(%rbx)
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x5c68
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x6741
// File: /workspace/github_c_makefile_star2_O3/tomcatzh[P]RealityBenchmark/external/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:
pushq %rbx
movq %rdi, %rbx
movl $0x40, %edi
callq *0x598c(%rip)           # 0xc220
testq %rax, %rax
je 0x68b6
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, (%rax)
movl $0x110, 0x18(%rax)      # imm = 0x110
movq %rbx, 0x20(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/tomcatzh[P]RealityBenchmark/external/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:
pushq %rbx
movq %rdi, %rbx
movl $0x40, %edi
callq *0x5959(%rip)           # 0xc220
testq %rax, %rax
je 0x68e9
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, (%rax)
movl $0x140, 0x18(%rax)      # imm = 0x140
movq %rbx, 0x10(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/tomcatzh[P]RealityBenchmark/external/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:
pushq %rbx
movq %rdi, %rbx
movl $0x40, %edi
callq *0x5926(%rip)           # 0xc220
testq %rax, %rax
je 0x691c
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, (%rax)
movl $0x120, 0x18(%rax)      # imm = 0x120
movq %rbx, 0x10(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/tomcatzh[P]RealityBenchmark/external/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;
    }

    return a;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testl %esi, %esi
sets %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x69e7
movl %esi, %ebp
movq %rdi, %r14
movl $0x40, %edi
callq *0x58d4(%rip)           # 0xc220
testq %rax, %rax
je 0x69e7
movq %rax, %rbx
xorpd %xmm0, %xmm0
movupd %xmm0, 0x10(%rax)
movupd %xmm0, 0x30(%rax)
movupd %xmm0, 0x20(%rax)
movupd %xmm0, (%rax)
movl $0x20, 0x18(%rax)
testl %ebp, %ebp
je 0x69e9
movl %ebp, %r15d
xorl %r13d, %r13d
xorl %r12d, %r12d
movl (%r14,%r12,4), %ebp
movl $0x40, %edi
callq *0x588e(%rip)           # 0xc220
testq %rax, %rax
je 0x69df
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
xorps %xmm1, %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm1, 0x30(%rax)
movups %xmm1, 0x20(%rax)
movups %xmm1, (%rax)
movl $0x8, 0x18(%rax)
movsd %xmm0, 0x30(%rax)
movl %ebp, 0x28(%rax)
testq %r12, %r12
je 0x69ce
movq %rax, (%r13)
movq %r13, 0x8(%rax)
jmp 0x69d2
movq %rax, 0x10(%rbx)
incq %r12
movq %rax, %r13
cmpq %r15, %r12
jb 0x6983
jmp 0x69e9
movq %rbx, %rdi
callq 0x4fa4
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/tomcatzh[P]RealityBenchmark/external/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;
    }

    return a;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testl %esi, %esi
sets %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x6afa
movl %esi, %ebp
movq %rdi, %r14
movl $0x40, %edi
callq *0x57f7(%rip)           # 0xc220
testq %rax, %rax
je 0x6afa
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, (%rax)
movl $0x20, 0x18(%rax)
testl %ebp, %ebp
je 0x6afc
movl %ebp, %r15d
xorl %r13d, %r13d
xorl %r12d, %r12d
movss (%r14,%r12,4), %xmm0
movss %xmm0, 0x4(%rsp)
movl $0x40, %edi
callq *0x57aa(%rip)           # 0xc220
testq %rax, %rax
je 0x6af2
movss 0x4(%rsp), %xmm2
xorps %xmm0, %xmm0
cvtss2sd %xmm2, %xmm0
xorps %xmm1, %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm1, 0x30(%rax)
movups %xmm1, 0x20(%rax)
movups %xmm1, (%rax)
movl $0x8, 0x18(%rax)
movsd %xmm0, 0x30(%rax)
movl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
ucomisd 0x1e35(%rip), %xmm0     # 0x88e8
jae 0x6acb
movl $0x80000000, %ecx       # imm = 0x80000000
movss 0x1e8e(%rip), %xmm0     # 0x8950
ucomiss %xmm2, %xmm0
jae 0x6acb
cvttss2si %xmm2, %ecx
movl %ecx, 0x28(%rax)
testq %r12, %r12
je 0x6add
movq %rax, (%r13)
movq %r13, 0x8(%rax)
jmp 0x6ae1
movq %rax, 0x10(%rbx)
incq %r12
movq %rax, %r13
cmpq %r15, %r12
jb 0x6a5f
jmp 0x6afc
movq %rbx, %rdi
callq 0x4fa4
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/tomcatzh[P]RealityBenchmark/external/cJSON.c
// Function: cJSON_CreateDoubleArray
CJSON_PUBLIC(cJSON *) cJSON_CreateDoubleArray(const double *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;
    }

    return a;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testl %esi, %esi
sets %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x6c0f
movl %esi, %ebp
movq %rdi, %r14
movl $0x40, %edi
callq *0x56e4(%rip)           # 0xc220
testq %rax, %rax
je 0x6c0f
movq %rax, %rbx
xorpd %xmm0, %xmm0
movupd %xmm0, 0x10(%rax)
movupd %xmm0, 0x30(%rax)
movupd %xmm0, 0x20(%rax)
movupd %xmm0, (%rax)
movl $0x20, 0x18(%rax)
testl %ebp, %ebp
je 0x6c11
movl %ebp, %r15d
xorl %r13d, %r13d
xorl %r12d, %r12d
movsd (%r14,%r12,8), %xmm0
movsd %xmm0, (%rsp)
movl $0x40, %edi
callq *0x5693(%rip)           # 0xc220
testq %rax, %rax
je 0x6c07
xorpd %xmm0, %xmm0
movupd %xmm0, 0x10(%rax)
movupd %xmm0, 0x30(%rax)
movupd %xmm0, 0x20(%rax)
movupd %xmm0, (%rax)
movl $0x8, 0x18(%rax)
movsd (%rsp), %xmm1
movsd %xmm1, 0x30(%rax)
movl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
ucomisd 0x1d21(%rip), %xmm1     # 0x88e8
jae 0x6be0
movl $0x80000000, %ecx       # imm = 0x80000000
movsd 0x1d1a(%rip), %xmm0     # 0x88f0
ucomisd %xmm1, %xmm0
jae 0x6be0
cvttsd2si %xmm1, %ecx
movl %ecx, 0x28(%rax)
testq %r12, %r12
je 0x6bf2
movq %rax, (%r13)
movq %r13, 0x8(%rax)
jmp 0x6bf6
movq %rax, 0x10(%rbx)
incq %r12
movq %rax, %r13
cmpq %r15, %r12
jb 0x6b77
jmp 0x6c11
movq %rbx, %rdi
callq 0x4fa4
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/tomcatzh[P]RealityBenchmark/external/cJSON.c
// Function: cJSON_CreateStringArray
CJSON_PUBLIC(cJSON *) cJSON_CreateStringArray(const char **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;
    }

    return a;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testl %esi, %esi
sets %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x6cb1
movl %esi, %ebp
movq %rdi, %r14
movl $0x40, %edi
callq *0x55d3(%rip)           # 0xc220
testq %rax, %rax
je 0x6cb1
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, (%rax)
movl $0x20, 0x18(%rax)
testl %ebp, %ebp
je 0x6cb3
movl %ebp, %r15d
xorl %r13d, %r13d
xorl %r12d, %r12d
movq (%r14,%r12,8), %rdi
callq 0x6303
testq %rax, %rax
je 0x6ca9
testq %r12, %r12
je 0x6c98
movq %rax, (%r13)
movq %r13, 0x8(%rax)
jmp 0x6c9c
movq %rax, 0x10(%rbx)
incq %r12
movq %rax, %r13
cmpq %r15, %r12
jb 0x6c7b
jmp 0x6cb3
movq %rbx, %rdi
callq 0x4fa4
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/tomcatzh[P]RealityBenchmark/external/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:
testq %rdi, %rdi
je 0x6f23
movabsq $0x100002600, %rax      # imm = 0x100002600
movq %rdi, %rcx
movq %rdi, %rdx
movzbl (%rdi), %esi
cmpq $0x2f, %rsi
ja 0x6e82
btq %rsi, %rax
jae 0x6e48
incq %rdx
movq %rdx, %rdi
jmp 0x6e2e
cmpq $0x22, %rsi
je 0x6e98
cmpq $0x2f, %rsi
jne 0x6e82
movzbl 0x1(%rdx), %esi
cmpl $0x2a, %esi
je 0x6ee6
leaq 0x1(%rdx), %rdi
cmpl $0x2f, %esi
jne 0x6e2e
addq $0x2, %rdx
movq %rdx, %rdi
movzbl (%rdi), %edx
testl %edx, %edx
je 0x6e2e
incq %rdi
cmpl $0xa, %edx
jne 0x6e71
jmp 0x6e2e
testl %esi, %esi
je 0x6f20
movb %sil, (%rcx)
incq %rdx
incq %rcx
movq %rdx, %rdi
jmp 0x6e2e
movb $0x22, (%rcx)
incq %rcx
movb 0x1(%rdx), %sil
incq %rdx
movq %rdx, %rdi
testb %sil, %sil
je 0x6e2e
movq %rdx, %rdi
movb %sil, (%rcx)
movzbl (%rdi), %edx
cmpl $0x5c, %edx
je 0x6ec2
cmpl $0x22, %edx
jne 0x6ed2
jmp 0x6f09
cmpb $0x22, 0x1(%rdi)
jne 0x6ed2
incq %rdi
movb $0x22, 0x1(%rcx)
incq %rcx
incq %rcx
movb 0x1(%rdi), %sil
incq %rdi
testb %sil, %sil
jne 0x6eb0
jmp 0x6e2e
addq $0x2, %rdx
movq %rdx, %rdi
movzbl (%rdi), %edx
cmpl $0x2a, %edx
je 0x6efe
testl %edx, %edx
jne 0x6f04
jmp 0x6e2e
cmpb $0x2f, 0x1(%rdi)
je 0x6f17
incq %rdi
jmp 0x6eed
movb $0x22, (%rcx)
incq %rdi
incq %rcx
jmp 0x6e2e
addq $0x2, %rdi
jmp 0x6e2e
movb $0x0, (%rcx)
retq
// File: /workspace/github_c_makefile_star2_O3/CerfVert94[P]lenet_cnn/main.c
// Function: evaluate
int evaluate(char *Input)
{
	
	float	Layer1_Neurons_CPU[IMG_WIDTH*IMG_HEIGHT],
				Layer2_Neurons_CPU[6*13*13],
				Layer3_Neurons_CPU[50*5*5],
				Layer4_Neurons_CPU[100];
	double Layer5_Neurons_CPU[10];
	double scoremax = 0.0;
	int i;

	int indexmax = -1;
	calculateLayer1(Input, Layer1_Neurons_CPU);
	calculateLayer2(Layer1_Neurons_CPU, Layer1_Weights_CPU, Layer2_Neurons_CPU);
	calculateLayer3(Layer2_Neurons_CPU, Layer2_Weights_CPU, Layer3_Neurons_CPU);
	calculateLayer4(Layer3_Neurons_CPU, Layer3_Weights_CPU, Layer4_Neurons_CPU);
	calculateLayer5(Layer4_Neurons_CPU, Layer4_Weights_CPU, Layer5_Neurons_CPU);

	scoremax = -999;
	indexmax = -1;
	for(i=0;i<10;i++)
	{
		if(Layer5_Neurons_CPU[i] > scoremax)
		{
			scoremax = Layer5_Neurons_CPU[i];
			indexmax = i;
		}
	}
	return indexmax;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x3280, %rsp           # imm = 0x3280
leaq -0xf20(%rbp), %rbx
movq %rbx, %rsi
callq 0x1800
leaq 0x2e40(%rip), %rsi      # 0x4090
leaq -0x1f00(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rdx
callq 0x1834
leaq 0x3097(%rip), %rsi      # 0x4300
leaq -0x3290(%rbp), %rbx
movq %r14, %rdi
movq %rbx, %rdx
callq 0x193a
leaq 0xaa5e(%rip), %rsi      # 0xbce0
leaq -0x1f0(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rdx
callq 0x1aac
leaq 0x84cf5(%rip), %rsi     # 0x85f90
leaq -0x60(%rbp), %rdx
movq %r14, %rdi
callq 0x1b6c
movsd 0xd59(%rip), %xmm0      # 0x2008
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
movsd -0x60(%rbp,%rcx,8), %xmm1
ucomisd %xmm0, %xmm1
cmoval %ecx, %eax
maxsd %xmm0, %xmm1
incq %rcx
movapd %xmm1, %xmm0
cmpq $0xa, %rcx
jne 0x12b6
addq $0x3280, %rsp           # imm = 0x3280
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/CerfVert94[P]lenet_cnn/main.c
// Function: read_data
void read_data(const char * path, char *Input) {
	
	FILE *ptr_file;
	int32_t size;
	int i, j, idx;
	const int pd_offset = 62; //offset to pd (pixel data)
	const int bpl = BYTE_TO_BITS(4); // bits_per_line = bpl.
	char ch;
	
	// Open the B&W bitmap file of the given path.
	ptr_file = fopen(path, "rb");
	
	// Null pointer signifies an error :
	if (!ptr_file) {
		fprintf(stdout, "Failed opening the data.\n");
		exit(EXIT_FAILURE);
	}
	// Get the size of the bitmap file.
	fseek(ptr_file, 0, SEEK_END);
	size = ftell(ptr_file);
	
	// Skips header info.
	fseek(ptr_file, pd_offset, SEEK_SET);
	
	// Read bitmap : 
	idx = 0;
	for (i = 0; i < size - pd_offset; i++) {
		ch = fgetc(ptr_file);
		// Each byte represents 8 pixels in reverse order.
		for (j = BYTE_TO_BITS(1) - 1; j >= 0 ; j--) {
			/* 
			Consider zero padding : 
			3 bytes are padded.
			
			Store only significant pixel data.
			*/
			if((idx % bpl) < IMG_WIDTH) {
				Input[Y_POS(idx, bpl, IMG_HEIGHT) + (idx % bpl)] = (ch >> j & 0x1);
			}
			idx++;
		}
	}
	fclose(ptr_file);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq 0xcd2(%rip), %rsi       # 0x2116
callq 0x10c0
testq %rax, %rax
je 0x151c
movq %rax, %r14
xorl %r12d, %r12d
movq %rax, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x10b0
movq %r14, %rdi
callq 0x10a0
movq %rax, %r15
movl $0x3e, %esi
movq %r14, %rdi
xorl %edx, %edx
callq 0x10b0
cmpl $0x3f, %r15d
jl 0x1506
addl $-0x3f, %r15d
xorl %eax, %eax
movl %eax, %r13d
movq %r14, %rdi
callq 0x1070
movsbl %al, %ecx
leal 0x8(%r13), %eax
movl $0x7, %edx
leal 0x1f(%r13), %esi
testl %r13d, %r13d
movl %r13d, %r8d
cmovsl %esi, %r8d
andl $-0x20, %r8d
movl %r13d, %edi
subl %r8d, %edi
cmpl $0x1c, %edi
jg 0x14f1
testl %r13d, %r13d
cmovnsl %r13d, %esi
sarl $0x5, %esi
movl %esi, %r8d
negl %r8d
leal (%r8,%r8,8), %r8d
leal (%r8,%r8,2), %r8d
subl %esi, %r8d
subl %esi, %r8d
btl %edx, %ecx
leal 0x32c(%rdi,%r8), %esi
movslq %esi, %rsi
setb (%rbx,%rsi)
incl %r13d
addl $-0x1, %edx
jb 0x14a4
leal 0x1(%r12), %ecx
cmpl %r15d, %r12d
movl %ecx, %r12d
jne 0x148d
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1030
movq 0x2ab5(%rip), %rax      # 0x3fd8
movq (%rax), %rcx
leaq 0xbec(%rip), %rdi       # 0x2119
movl $0x19, %esi
movl $0x1, %edx
callq 0x10f0
movl $0x1, %edi
callq 0x10e0
// File: /workspace/github_c_makefile_star2_O3/CerfVert94[P]lenet_cnn/main.c
// Function: write_data
void write_data(char (*Input)[841], int size) 
{
	FILE *ptr_file;
	int i, j, k;
	// Create a new data header file.
	ptr_file = fopen("data.h", "wb");
	// Null pointer signifies an error :
	if (!ptr_file) {
		fprintf(stdout, "Failed creating new header files\n");
		exit(EXIT_FAILURE);
	}
	fprintf(ptr_file,	"#ifndef _DATA_H_\n"\
						"#define	_DATA_H_\n"\
						"\tchar Input[10][29*29] = {");
	for (i = 0; i < size; i++) {
		fputs("{\n\t\t", ptr_file);
		for (j = 0; j < IMG_HEIGHT; j++) {
			for (k = 0; k < IMG_WIDTH; k++) {				
				fputc('0' + Input[i][j * IMG_HEIGHT + k], ptr_file);
				if (j == (IMG_HEIGHT - 1) && k == (IMG_WIDTH - 1)) 
					fputs("}", ptr_file);
				else {
					fputc(',', ptr_file);
				}
				
			}
			if (j < (IMG_HEIGHT - 1))
				fputs("\n\t\t", ptr_file);
		}
		if (i < (size - 1))
			fputs(",\n\t\t", ptr_file);
		
	}					
	fputs("};\n", ptr_file);
	fprintf(ptr_file, "#endif /* DATA_H_ */");
	fclose(ptr_file);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, %r15d
movq %rdi, %r14
leaq 0xbcf(%rip), %rdi       # 0x2133
leaq 0xbcf(%rip), %rsi       # 0x213a
callq 0x10c0
testq %rax, %rax
je 0x16a2
movq %rax, %rbx
leaq 0xbdc(%rip), %rdi       # 0x215f
movl $0x3c, %esi
movl $0x1, %edx
movq %rax, %rcx
callq 0x10f0
testl %r15d, %r15d
jle 0x1664
leal -0x1(%r15), %eax
movq %rax, -0x38(%rbp)
movl %r15d, %eax
movq %rax, -0x30(%rbp)
xorl %r15d, %r15d
movq %r15, -0x40(%rbp)
leaq 0xbe1(%rip), %rdi       # 0x219c
movq %rbx, %rsi
callq 0x1050
movq %r14, -0x48(%rbp)
xorl %r15d, %r15d
movq $-0x1d, %r13
movq %r15, %r12
xorq $0x1c, %r12
movsbl 0x1d(%r14,%r13), %edi
addl $0x30, %edi
movq %rbx, %rsi
callq 0x1080
movq %r13, %rax
notq %rax
orq %r12, %rax
je 0x1624
movl $0x2c, %edi
movq %rbx, %rsi
callq 0x1080
incq %r13
jne 0x15d8
cmpq $0x1c, %r15
je 0x1633
leaq 0xb91(%rip), %rdi       # 0x21a4
movq %rbx, %rsi
callq 0x1050
incq %r15
addq $0x1d, %r14
jmp 0x15ca
leaq 0xb76(%rip), %rdi       # 0x21a1
movq %rbx, %rsi
callq 0x1050
movq -0x40(%rbp), %r15
cmpq -0x38(%rbp), %r15
jae 0x164c
leaq 0xb5f(%rip), %rdi       # 0x21a3
movq %rbx, %rsi
callq 0x1050
incq %r15
movq -0x48(%rbp), %r14
addq $0x349, %r14            # imm = 0x349
cmpq -0x30(%rbp), %r15
jne 0x15b0
leaq 0xaa7(%rip), %rdi       # 0x2112
movq %rbx, %rsi
callq 0x1050
leaq 0xb2e(%rip), %rdi       # 0x21a8
movl $0x14, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x10f0
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1030
movq 0x292f(%rip), %rax      # 0x3fd8
movq (%rax), %rcx
leaq 0xa8a(%rip), %rdi       # 0x213d
movl $0x21, %esi
movl $0x1, %edx
callq 0x10f0
movl $0x1, %edi
callq 0x10e0
// File: /workspace/github_c_makefile_star2_O3/CerfVert94[P]lenet_cnn/main.c
// Function: write_weights
void write_weights(FILE *ptr_file1, FILE *ptr_file2, const char* layer_name, float *Layer_Weights_CPU, int size) {
	
	#define fprintfs(file1, file2, str) 	fprintf(file1, str);\
											fprintf(file2, str)
	int i;
	fprintf(ptr_file1, "short %s[%d] = {", layer_name, size);
	fprintf(ptr_file2, "char %s[%d] = {", layer_name, size);
	for (i = 0; i < size; i++) {
		fprintf(ptr_file1, "%d", (short)(Layer_Weights_CPU[i] * 100));
		fprintf(ptr_file2, "%d", (char)(Layer_Weights_CPU[i] * 10));
		if (i < (size - 1))
			fprintfs(ptr_file1, ptr_file2, ", ");
	}
	fprintfs(ptr_file1, ptr_file2, "};\n");
	
	#undef fprintfs
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, %r12d
movq %rcx, %r15
movq %rdx, %r13
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x9f8(%rip), %rsi       # 0x20eb
movl %r8d, %ecx
xorl %eax, %eax
callq 0x1090
leaq 0x9f8(%rip), %rsi       # 0x20fc
movq %rbx, %rdi
movq %r13, %rdx
movl %r12d, %ecx
xorl %eax, %eax
callq 0x1090
testl %r12d, %r12d
jle 0x17c0
leal -0x1(%r12), %eax
movq %rax, -0x38(%rbp)
movl %r12d, %eax
movq %rax, -0x30(%rbp)
leaq 0x9d8(%rip), %r12       # 0x210c
xorl %r13d, %r13d
movss (%r15,%r13,4), %xmm0
mulss 0x8cb(%rip), %xmm0      # 0x2010
cvttss2si %xmm0, %eax
movswl %ax, %edx
movq %r14, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x1090
movss (%r15,%r13,4), %xmm0
mulss 0x8ad(%rip), %xmm0      # 0x2014
cvttss2si %xmm0, %eax
movsbl %al, %edx
movq %rbx, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x1090
cmpq -0x38(%rbp), %r13
jae 0x179a
movl $0x2, %esi
movl $0x1, %edx
leaq 0x97d(%rip), %rdi       # 0x210f
movq %r14, %rcx
callq 0x10f0
movl $0x2, %esi
movl $0x1, %edx
leaq 0x964(%rip), %rdi       # 0x210f
movq %rbx, %rcx
callq 0x10f0
incq %r13
cmpq %r13, -0x30(%rbp)
jne 0x1737
leaq 0x94b(%rip), %r15       # 0x2112
movl $0x3, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %r14, %rcx
callq 0x10f0
movl $0x3, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %rbx, %rcx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x10f0
nop
// File: /workspace/github_c_makefile_star2_O3/CerfVert94[P]lenet_cnn/neural_network.c
// Function: calculateLayer1
void calculateLayer1(char* input, float* Layer1_Neurons_CPU){
	int i, j;
	for (i = 0; i < IMG_HEIGHT; i++) 
		for (j = 0; j < IMG_WIDTH; j++) 
			Layer1_Neurons_CPU[i * IMG_HEIGHT + j] = input[i * IMG_HEIGHT + j];
		
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
xorl %ecx, %ecx
movsbl (%rdi,%rcx), %edx
xorps %xmm0, %xmm0
cvtsi2ss %edx, %xmm0
movss %xmm0, (%rsi,%rcx,4)
incq %rcx
cmpq $0x1d, %rcx
jne 0x1808
incq %rax
addq $0x74, %rsi
addq $0x1d, %rdi
cmpq $0x1d, %rax
jne 0x1806
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/CerfVert94[P]lenet_cnn/neural_network.c
// Function: calculateLayer2
void calculateLayer2(float* Layer1_Neurons_CPU, WEIGHT_TYPE* Layer1_Weights_CPU, float* Layer2_Neurons_CPU){
	float somme;
	int i,j,k,m,n;
	for(i=0;i<6;i++)
		for(j=0;j<13;j++)
			for(k=0;k<13;k++){
				somme = Layer1_Weights_CPU[26*i];
				for(m=0;m<5;m++)
					for(n=0;n<5;n++)
						somme += Layer1_Weights_CPU[26*i+5*m+n+1] * Layer1_Neurons_CPU[29*(m+2*j)+n+2*k];
				Layer2_Neurons_CPU[13*13*i+13*j+k] = SIGMOID(CONV(somme));
			}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, -0x38(%rbp)
movq %rdi, -0x30(%rbp)
movq %rsi, -0x60(%rbp)
leaq 0x4(%rsi), %r12
xorl %ecx, %ecx
leaq (%rcx,%rcx,4), %rax
leaq (%rax,%rax,4), %rbx
addq %rcx, %rbx
movq %rcx, -0x40(%rbp)
imulq $0x2a4, %rcx, %rax      # imm = 0x2A4
addq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %r15
xorl %eax, %eax
movq %rax, -0x50(%rbp)
imulq $0x34, %rax, %r13
addq -0x48(%rbp), %r13
movq %r15, -0x58(%rbp)
xorl %r14d, %r14d
movq -0x60(%rbp), %rax
movss (%rax,%rbx,4), %xmm0
movq %r12, %rax
movq %r15, %rcx
xorl %edx, %edx
xorl %esi, %esi
movss (%rax,%rsi,4), %xmm1
mulss (%rcx,%rsi,4), %xmm1
addss %xmm1, %xmm0
incq %rsi
cmpq $0x5, %rsi
jne 0x18a1
incq %rdx
addq $0x74, %rcx
addq $0x14, %rax
cmpq $0x5, %rdx
jne 0x189f
cvtss2sd %xmm0, %xmm0
mulsd 0x913(%rip), %xmm0      # 0x21e8
callq 0x10d0
mulsd 0x90e(%rip), %xmm0      # 0x21f0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%r13,%r14,4)
incq %r14
addq $0x8, %r15
cmpq $0xd, %r14
jne 0x188e
movq -0x50(%rbp), %rax
incq %rax
movq -0x58(%rbp), %r15
addq $0xe8, %r15
cmpq $0xd, %rax
jne 0x187b
movq -0x40(%rbp), %rcx
incq %rcx
addq $0x68, %r12
cmpq $0x6, %rcx
jne 0x1857
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/CerfVert94[P]lenet_cnn/neural_network.c
// Function: calculateLayer3
void calculateLayer3(float* Layer2_Neurons_CPU, WEIGHT_TYPE* Layer2_Weights_CPU, float* Layer3_Neurons_CPU){
	float somme;
	int i,j,k,m,n;
	for( i=0;i<50;i++)
		for(j=0;j<5;j++)
			for(k=0;k<5;k++){
				somme = Layer2_Weights_CPU[26*6*i];

				for( m=0;m<5;m++)
					for( n=0;n<5;n++){
						somme += Layer2_Weights_CPU[26*6*i+1+6*(n+5*m)	] * Layer2_Neurons_CPU[13*13*0+13*(2*j+m)+(2*k+n)];
						somme += Layer2_Weights_CPU[26*6*i+1+6*(n+5*m)+1] * Layer2_Neurons_CPU[13*13*1+13*(2*j+m)+(2*k+n)];
						somme += Layer2_Weights_CPU[26*6*i+1+6*(n+5*m)+2] * Layer2_Neurons_CPU[13*13*2+13*(2*j+m)+(2*k+n)];
						somme += Layer2_Weights_CPU[26*6*i+1+6*(n+5*m)+3] * Layer2_Neurons_CPU[13*13*3+13*(2*j+m)+(2*k+n)];
						somme += Layer2_Weights_CPU[26*6*i+1+6*(n+5*m)+4] * Layer2_Neurons_CPU[13*13*4+13*(2*j+m)+(2*k+n)];
						somme += Layer2_Weights_CPU[26*6*i+1+6*(n+5*m)+5] * Layer2_Neurons_CPU[13*13*5+13*(2*j+m)+(2*k+n)];

					}
				Layer3_Neurons_CPU[5*5*i+5*j+k] = SIGMOID(CONV(somme));
				
			}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, -0x38(%rbp)
addq $0xd34, %rdi            # imm = 0xD34
movq %rdi, -0x30(%rbp)
movq %rsi, -0x60(%rbp)
leaq 0x18(%rsi), %r12
xorl %eax, %eax
imulq $0x9c, %rax, %rbx
movq %rax, -0x40(%rbp)
imulq $0x64, %rax, %rax
addq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %r15
xorl %eax, %eax
movq %rax, -0x50(%rbp)
leaq (%rax,%rax,4), %rax
movq -0x48(%rbp), %rcx
leaq (%rcx,%rax,4), %r13
movq %r15, -0x58(%rbp)
xorl %r14d, %r14d
movq -0x60(%rbp), %rax
movss (%rax,%rbx,4), %xmm0
movq %r12, %rax
movq %r15, %rcx
xorl %edx, %edx
movq %rax, %rsi
xorl %edi, %edi
movss -0x14(%rsi), %xmm1
mulss -0xd34(%rcx,%rdi,4), %xmm1
movss -0x10(%rsi), %xmm2
addss %xmm0, %xmm1
mulss -0xa90(%rcx,%rdi,4), %xmm2
addss %xmm1, %xmm2
movss -0xc(%rsi), %xmm0
mulss -0x7ec(%rcx,%rdi,4), %xmm0
addss %xmm2, %xmm0
movss -0x8(%rsi), %xmm1
mulss -0x548(%rcx,%rdi,4), %xmm1
addss %xmm0, %xmm1
movss -0x4(%rsi), %xmm2
mulss -0x2a4(%rcx,%rdi,4), %xmm2
addss %xmm1, %xmm2
movss (%rsi), %xmm0
mulss (%rcx,%rdi,4), %xmm0
addss %xmm2, %xmm0
incq %rdi
addq $0x18, %rsi
cmpq $0x5, %rdi
jne 0x19ae
incq %rdx
addq $0x34, %rcx
addq $0x78, %rax
cmpq $0x5, %rdx
jne 0x19a9
cvtss2sd %xmm0, %xmm0
mulsd 0x7a5(%rip), %xmm0      # 0x21e8
callq 0x10d0
mulsd 0x7a0(%rip), %xmm0      # 0x21f0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%r13,%r14,4)
incq %r14
addq $0x8, %r15
cmpq $0x5, %r14
jne 0x1998
movq -0x50(%rbp), %rax
incq %rax
movq -0x58(%rbp), %r15
addq $0x68, %r15
cmpq $0x5, %rax
jne 0x1981
movq -0x40(%rbp), %rax
incq %rax
addq $0x270, %r12            # imm = 0x270
cmpq $0x32, %rax
jne 0x1964
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/CerfVert94[P]lenet_cnn/neural_network.c
// Function: calculateLayer4
void calculateLayer4(float* Layer3_Neurons_CPU, WEIGHT_TYPE* Layer3_Weights_CPU, float* Layer4_Neurons_CPU){
	float somme;
	int i, j, k, m;
	for( i=0;i<100;i++){
		somme = Layer3_Weights_CPU[i*(1+50*25)];
		for( j=0;j<50;j++)
			for( k=0;k<5;k++)
				for ( m=0;m<5;m++)
					somme += Layer3_Weights_CPU[i*(1+50*25)+1 + m + k*5 + j*25] * Layer3_Neurons_CPU[m+5*k+25*j];

		Layer4_Neurons_CPU[i] = SIGMOID(CONV(somme));
	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x4(%rsi), %r12
xorl %r13d, %r13d
imulq $0x138c, %r13, %rax     # imm = 0x138C
movss (%r14,%rax), %xmm0
movq %r12, %rax
movq %r15, %rcx
xorl %edx, %edx
movq %rax, %rsi
movq %rcx, %rdi
xorl %r8d, %r8d
xorl %r9d, %r9d
movss (%rsi,%r9,4), %xmm1
mulss (%rdi,%r9,4), %xmm1
addss %xmm1, %xmm0
incq %r9
cmpq $0x5, %r9
jne 0x1aeb
incq %r8
addq $0x14, %rdi
addq $0x14, %rsi
cmpq $0x5, %r8
jne 0x1ae8
incq %rdx
addq $0x64, %rcx
addq $0x64, %rax
cmpq $0x32, %rdx
jne 0x1adf
cvtss2sd %xmm0, %xmm0
mulsd 0x6b6(%rip), %xmm0      # 0x21e8
callq 0x10d0
mulsd 0x6b1(%rip), %xmm0      # 0x21f0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%rbx,%r13,4)
incq %r13
addq $0x138c, %r12           # imm = 0x138C
cmpq $0x64, %r13
jne 0x1aca
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/CerfVert94[P]lenet_cnn/neural_network.c
// Function: calculateLayer5
void calculateLayer5(float* Layer4_Neurons_CPU, WEIGHT_TYPE* Layer4_Weights_CPU, double* Layer5_Neurons_CPU){
	float somme;
	int i, j;
	for( i=0;i<10;i++){
		somme = Layer4_Weights_CPU[101*i];
		for( j=0;j<100;j++)
			somme += Layer4_Weights_CPU[1+101*i+j] * Layer4_Neurons_CPU[j];
		Layer5_Neurons_CPU[i] = SIGMOID(CONV(somme));
		
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x4(%rsi), %r12
xorl %r13d, %r13d
imulq $0x194, %r13, %rax      # imm = 0x194
movss (%r14,%rax), %xmm0
xorl %eax, %eax
movss (%r12,%rax,4), %xmm1
mulss (%r15,%rax,4), %xmm1
addss %xmm1, %xmm0
incq %rax
cmpq $0x64, %rax
jne 0x1b99
cvtss2sd %xmm0, %xmm0
mulsd 0x62a(%rip), %xmm0      # 0x21e8
callq 0x10d0
mulsd 0x625(%rip), %xmm0      # 0x21f0
movsd %xmm0, (%rbx,%r13,8)
incq %r13
addq $0x194, %r12            # imm = 0x194
cmpq $0xa, %r13
jne 0x1b8a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/OhYee[P]computer_application_programming_experiment/hash_search/hashtable_search/hashtable_search.c
// Function: hash
int hash(char *s, int limit) {
    unsigned int code = 0;
    char *       ptr = s;

    int param = 1;
    while (compare_char(*ptr, '\0') != 0) {
        // code = code ^ (*ptr);
        code += (param * (*ptr)) % limit;
        param = (param * 9999991) % limit;
        ++ptr;
    }
    code = (code ^ 9999901) % limit;
    return code;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movsbl (%rdi), %edi
xorl %ebp, %ebp
xorl %esi, %esi
callq 0x23f4
testl %eax, %eax
je 0x33cf
incq %r14
movl $0x1, %r15d
movsbl -0x1(%r14), %eax
imull %r15d, %eax
cltd
idivl %ebx
addl %edx, %ebp
imull $0x989677, %r15d, %eax  # imm = 0x989677
cltd
idivl %ebx
movsbl (%r14), %edi
movl %edx, %r15d
xorl %esi, %esi
callq 0x23f4
incq %r14
testl %eax, %eax
jne 0x339a
xorl $0x98961d, %ebp         # imm = 0x98961D
jmp 0x33d4
movl $0x98961d, %ebp         # imm = 0x98961D
movl %ebp, %eax
xorl %edx, %edx
divl %ebx
movl %edx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/OhYee[P]computer_application_programming_experiment/hash_search/hashtable_search/hashtable_search.c
// Function: ht_init
hash_table *ht_init(int length) {
    hash_table *ht = mp_new(sizeof(hash_table));
    ht->length = length;
    ht->array = mp_new(ht->length * sizeof(link_list *));
    memset(ht->array, 0, ht->length * sizeof(link_list *));
    return ht;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
movl $0x10, %edi
callq 0x2710
movq %rax, %r14
movl %ebx, 0x8(%rax)
shll $0x3, %ebx
movl %ebx, %edi
callq 0x2710
movq %rax, (%r14)
movslq 0x8(%r14), %rdx
shlq $0x3, %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x10a0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/OhYee[P]computer_application_programming_experiment/hash_search/hashtable_search/hashtable_search.c
// Function: ht_add
void ht_add(hash_table *ht, char *s) {
    unsigned int code = hash(s, ht->length);
    link_list *       ptr = ht->array[code];

    if (ptr == NULL) {
        ptr = ht->array[code] = lk_init();
    }

    char *ss = mp_new(sizeof(char) * (strlen(s) + 1));
    strcpy(ss, s);
    lk_add(ptr, ss);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movl 0x8(%rdi), %esi
movq %rbx, %rdi
callq 0x3375
movq (%r15), %rcx
movl %eax, %r12d
movq (%rcx,%r12,8), %r14
testq %r14, %r14
jne 0x3460
xorl %eax, %eax
callq 0x29e8
movq %rax, %r14
movq (%r15), %rax
movq %r14, (%rax,%r12,8)
movq %rbx, %rdi
callq 0x1080
leal 0x1(%rax), %edi
callq 0x2710
movq %rax, %r15
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1040
movq %r14, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2a36
// File: /workspace/github_c_makefile_star2_O3/OhYee[P]computer_application_programming_experiment/hash_search/hashtable_search/hashtable_search.c
// Function: ht_exist
boolean ht_exist(hash_table *ht, char *s) {
    int   code = hash(s, ht->length);
    link_list *ptr = ht->array[code];

    if (ptr == NULL) {
        return F;
    }
    return NULL != lk_search(ptr, s, compare);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0x8(%rdi), %esi
movq %rbx, %rdi
callq 0x3375
movq (%r14), %rcx
cltq
movq (%rcx,%rax,8), %rdi
testq %rdi, %rdi
je 0x34d3
leaq -0x15a(%rip), %rdx      # 0x3364
movq %rbx, %rsi
callq 0x2af0
movq %rax, %rcx
xorl %eax, %eax
testq %rcx, %rcx
setne %al
jmp 0x34dc
leaq 0xbe2(%rip), %rax       # 0x40bc
movl (%rax), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/ikbenlike[P]nngutils/src/tee.c
// Function: parse_arg
struct tee_args *parse_arg(struct tee_args *args, int argc, char **argv){
    args->files = calloc(1, sizeof(char*) * argc);
    args->fcount = 0;
    for(int i = 1; i < argc; i++){
        if(argv[i][0] == '-'){
            if(!strcmp(argv[i], "-a")){
                args->append = true;
            }
            else if(!strcmp(argv[i], "-i")){
                args->ignore_interrupts = true;
            }
            else if(!strcmp(argv[i], "-p")){
                args->diagnose = true;
            }
            else {
                fprintf(stderr, "%s: invalid argument '%s'\n", argv[0], argv[i]);
                exit(1);
            }
        }
        else {
            args->files[args->fcount++] = argv[i];
        }
    }
    return args;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %r15d
movq %rdi, %r14
movslq %esi, %r13
leaq (,%r13,8), %rsi
movl $0x1, %r12d
movl $0x1, %edi
callq 0x1060
movq %rax, 0x8(%r14)
movl $0x0, 0x10(%r14)
cmpl $0x2, %r13d
jl 0x12c1
movl %r15d, %eax
xorl %ecx, %ecx
movq (%rbx,%r12,8), %rsi
cmpb $0x2d, (%rsi)
jne 0x1299
cmpb $0x61, 0x1(%rsi)
jne 0x127a
cmpb $0x0, 0x2(%rsi)
je 0x12b4
cmpb $0x69, 0x1(%rsi)
jne 0x1286
cmpb $0x0, 0x2(%rsi)
je 0x12ba
cmpb $0x70, 0x1(%rsi)
jne 0x12d3
cmpb $0x0, 0x2(%rsi)
jne 0x12d3
movb $0x1, 0x2(%r14)
jmp 0x12aa
movq 0x8(%r14), %rdx
movslq %ecx, %rdi
incl %ecx
movl %ecx, 0x10(%r14)
movq %rsi, (%rdx,%rdi,8)
incq %r12
cmpq %r12, %rax
jne 0x1265
jmp 0x12c1
movb $0x1, (%r14)
jmp 0x12aa
movb $0x1, 0x1(%r14)
jmp 0x12aa
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
callq 0x10c0
// File: /workspace/github_c_makefile_star2_O3/ikbenlike[P]nngutils/src/tee.c
// Function: main
int main(int argc, char **argv){
    struct tee_args *args = calloc(1, sizeof(struct tee_args));
    args = parse_arg(args, argc, argv);
    int *fds = calloc(1, sizeof(int) * args->fcount);
    for(int i = 0; i < args->fcount; i++){
        if(!strcmp(args->files[i], "-")){
            fds[i] = STDIN_FILENO;
            continue;
        }
        fds[i] = open(args->files[i], O_WRONLY);
        if(fds[i] == -1){
            fprintf(stderr, "%s: %s\n", argv[0], strerror(errno));
            return 1;
        }
    }
    char *buf = calloc(1, 4096 * sizeof(char));
    if(buf == NULL){
        fprintf(stderr, "%s: %s\n", argv[0], strerror(errno));
        return 1;
    }
    int buf_len = read(STDIN_FILENO, buf, 4096);
    while(buf_len != 0){
        for(int i = 0; i < args->fcount; i++){
            write(fds[i], buf, buf_len);
        }
        write(STDOUT_FILENO, buf, buf_len);
        buf_len = read(STDIN_FILENO, buf, 4096);
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movl %edi, %r14d
movl $0x1, %edi
movl $0x18, %esi
callq 0x1060
movq %rax, %rbx
movq %rax, %rdi
movl %r14d, %esi
movq %r15, %rdx
callq 0x121c
movslq 0x10(%rbx), %r12
leaq (,%r12,4), %rsi
movl $0x1, %edi
callq 0x1060
movq %rax, %r14
testq %r12, %r12
jle 0x1377
xorl %r13d, %r13d
movq 0x8(%rbx), %rax
movq (%rax,%r13,8), %rdi
cmpb $0x2d, (%rdi)
jne 0x1343
cmpb $0x0, 0x1(%rdi)
je 0x136d
movl $0x1, %esi
xorl %eax, %eax
callq 0x1080
movl %eax, (%r14,%r13,4)
cmpl $-0x1, %eax
je 0x13dd
movl 0x10(%rbx), %r12d
incq %r13
movslq %r12d, %rax
cmpq %rax, %r13
jl 0x1330
jmp 0x1377
movl $0x0, (%r14,%r13,4)
jmp 0x1360
movl $0x1, %edi
movl $0x1000, %esi           # imm = 0x1000
callq 0x1060
testq %rax, %rax
je 0x13dd
movq %rax, %r12
xorl %r15d, %r15d
movl $0x1000, %edx           # imm = 0x1000
xorl %edi, %edi
movq %r12, %rsi
callq 0x1050
testl %eax, %eax
je 0x13eb
cmpl $0x0, 0x10(%rbx)
movslq %eax, %r15
jle 0x13cb
xorl %r13d, %r13d
movl (%r14,%r13,4), %edi
movq %r12, %rsi
movq %r15, %rdx
callq 0x1040
incq %r13
movslq 0x10(%rbx), %rax
cmpq %rax, %r13
jl 0x13b0
movl $0x1, %edi
movq %r12, %rsi
movq %r15, %rdx
callq 0x1040
jmp 0x138e
movq %r15, %rdi
callq 0x10ed
movl $0x1, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/zpole[P]IICV/vl/aib.c
// Function: vl_aib_normalize_P
void vl_aib_normalize_P (double * P, vl_uint nelem)
{
    vl_uint i;
    double sum = 0;
    for(i=0; i<nelem; i++)
        sum += P[i];
    for(i=0; i<nelem; i++)
        P[i] /= sum;
}

// Assembly:
testl %esi, %esi
je 0x9be1
movl %esi, %eax
xorpd %xmm0, %xmm0
xorl %ecx, %ecx
addsd (%rdi,%rcx,8), %xmm0
incq %rcx
cmpq %rcx, %rax
jne 0x9bb8
testl %esi, %esi
je 0x9be1
xorl %ecx, %ecx
movsd (%rdi,%rcx,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rdi,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x9bcb
retq
// File: /workspace/github_c_makefile_star2_O3/zpole[P]IICV/vl/aib.c
// Function: vl_aib_new_nodelist
vl_uint *vl_aib_new_nodelist (vl_uint nentries)
{
    vl_uint * nodelist = vl_malloc(sizeof(vl_uint)*nentries);
    vl_uint n;
    for(n=0; n<nentries; n++)
        nodelist[n] = n;

    return nodelist;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
movl %edi, %r14d
leaq (,%r14,4), %rdi
callq 0x95b0
testl %ebx, %ebx
je 0x9c8f
leaq 0x1(%r14), %rcx
andq $-0x2, %rcx
decq %r14
movq %r14, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
movdqa 0x283e3(%rip), %xmm1    # 0x32000
xorl %edx, %edx
movdqa 0x283e9(%rip), %xmm2    # 0x32010
pxor %xmm2, %xmm0
pcmpeqd %xmm3, %xmm3
movdqa 0x283e9(%rip), %xmm4    # 0x32020
movdqa %xmm1, %xmm5
pxor %xmm2, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm7     # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5     # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
movd %xmm5, %esi
notl %esi
testb $0x1, %sil
je 0x9c6c
movl %edx, (%rax,%rdx,4)
pxor %xmm3, %xmm5
pextrw $0x4, %xmm5, %esi
testb $0x1, %sil
je 0x9c82
leal 0x1(%rdx), %esi
movl %esi, 0x4(%rax,%rdx,4)
addq $0x2, %rdx
paddq %xmm4, %xmm1
cmpq %rdx, %rcx
jne 0x9c37
addq $0x8, %rsp
popq %rbx
popq %r14
retq