LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/antirez[P]stonky/canvas.c
// Function: createCanvas
canvas *createCanvas(int width, int height, int bgcolor) {
    canvas *canvas = malloc(sizeof(*canvas));
    canvas->width = width;
    canvas->height = height;
    canvas->pixels = malloc(width*height);
    memset(canvas->pixels,bgcolor,width*height);
    return canvas;
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movl %esi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
movl $0x10, %edi
callq 0x2430
movq %rax, (%rsp)
movl 0x14(%rsp), %ecx
movq (%rsp), %rax
movl %ecx, (%rax)
movl 0x10(%rsp), %ecx
movq (%rsp), %rax
movl %ecx, 0x4(%rax)
movl 0x14(%rsp), %eax
imull 0x10(%rsp), %eax
movslq %eax, %rdi
callq 0x2430
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movq (%rsp), %rax
movq 0x8(%rax), %rdi
movl 0xc(%rsp), %eax
movl 0x14(%rsp), %ecx
imull 0x10(%rsp), %ecx
movslq %ecx, %rdx
movzbl %al, %esi
callq 0x2120
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/antirez[P]stonky/canvas.c
// Function: drawLine
void drawLine(canvas *canvas, int x1, int y1, int x2, int y2, int color) {
    int dx = abs(x2-x1);
    int dy = abs(y2-y1);
    int sx = (x1 < x2) ? 1 : -1;
    int sy = (y1 < y2) ? 1 : -1;
    int err = dx-dy, e2;

    while(1) {
        drawPixel(canvas,x1,y1,color);
        if (x1 == x2 && y1 == y2) break;
        e2 = err*2;
        if (e2 > -dy) {
            err -= dy;
            x1 += sx;
        }
        if (e2 < dx) {
            err += dx;
            y1 += sy;
        }
    }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movl %edx, 0x28(%rsp)
movl %ecx, 0x24(%rsp)
movl %r8d, 0x20(%rsp)
movl %r9d, 0x1c(%rsp)
movl 0x24(%rsp), %eax
subl 0x2c(%rsp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movl %eax, 0x18(%rsp)
movl 0x20(%rsp), %eax
subl 0x28(%rsp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movl %eax, 0x14(%rsp)
movl 0x2c(%rsp), %edx
movl 0x24(%rsp), %esi
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl $0x1, %ecx
cmpl %esi, %edx
cmovll %ecx, %eax
movl %eax, 0x10(%rsp)
movl 0x28(%rsp), %edx
movl 0x20(%rsp), %esi
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl $0x1, %ecx
cmpl %esi, %edx
cmovll %ecx, %eax
movl %eax, 0xc(%rsp)
movl 0x18(%rsp), %eax
subl 0x14(%rsp), %eax
movl %eax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
movl 0x28(%rsp), %edx
movl 0x1c(%rsp), %ecx
callq 0x25d0
movl 0x2c(%rsp), %eax
cmpl 0x24(%rsp), %eax
jne 0x2763
movl 0x28(%rsp), %eax
cmpl 0x20(%rsp), %eax
jne 0x2763
jmp 0x27bc
movl 0x8(%rsp), %eax
shll %eax
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
xorl %ecx, %ecx
subl 0x14(%rsp), %ecx
cmpl %ecx, %eax
jle 0x2795
movl 0x14(%rsp), %ecx
movl 0x8(%rsp), %eax
subl %ecx, %eax
movl %eax, 0x8(%rsp)
movl 0x10(%rsp), %eax
addl 0x2c(%rsp), %eax
movl %eax, 0x2c(%rsp)
movl 0x4(%rsp), %eax
cmpl 0x18(%rsp), %eax
jge 0x27b7
movl 0x18(%rsp), %eax
addl 0x8(%rsp), %eax
movl %eax, 0x8(%rsp)
movl 0xc(%rsp), %eax
addl 0x28(%rsp), %eax
movl %eax, 0x28(%rsp)
jmp 0x2737
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/antirez[P]stonky/canvas.c
// Function: brailleTranslatePixelsGroup
static void brailleTranslatePixelsGroup(int byte, char *output) {
    int code = 0x2800 + byte;
    /* Convert to unicode. This is in the U0800-UFFFF range, so we need to
     * emit it like this in three bytes:
     * 1110xxxx 10xxxxxx 10xxxxxx. */
    output[0] = 0xE0 | (code >> 12);          /* 1110-xxxx */
    output[1] = 0x80 | ((code >> 6) & 0x3F);  /* 10-xxxxxx */
    output[2] = 0x80 | (code & 0x3F);         /* 10-xxxxxx */
}

// Assembly:
movl %edi, -0x4(%rsp)
movq %rsi, -0x10(%rsp)
movl -0x4(%rsp), %eax
addl $0x2800, %eax           # imm = 0x2800
movl %eax, -0x14(%rsp)
movl -0x14(%rsp), %eax
sarl $0xc, %eax
orl $0xe0, %eax
movb %al, %cl
movq -0x10(%rsp), %rax
movb %cl, (%rax)
movl -0x14(%rsp), %eax
sarl $0x6, %eax
andl $0x3f, %eax
orl $0x80, %eax
movb %al, %cl
movq -0x10(%rsp), %rax
movb %cl, 0x1(%rax)
movl -0x14(%rsp), %eax
andl $0x3f, %eax
orl $0x80, %eax
movb %al, %cl
movq -0x10(%rsp), %rax
movb %cl, 0x2(%rax)
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/antirez[P]stonky/cJSON.c
// Function: cJSON_SetValuestring
CJSON_PUBLIC(char*) cJSON_SetValuestring(cJSON *object, const char *valuestring)
{
    char *copy = NULL;
    /* if object's type is not cJSON_String or is cJSON_IsReference, it should not set valuestring */
    if (!(object->type & cJSON_String) || (object->type & cJSON_IsReference))
    {
        return NULL;
    }
    if (strlen(valuestring) <= strlen(object->valuestring))
    {
        strcpy(object->valuestring, valuestring);
        return object->valuestring;
    }
    copy = (char*) cJSON_strdup((const unsigned char*)valuestring, &global_hooks);
    if (copy == NULL)
    {
        return NULL;
    }
    if (object->valuestring != NULL)
    {
        cJSON_free(object->valuestring);
    }
    object->valuestring = copy;

    return copy;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x18(%rsp), %rax
movl 0x18(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x2dd9
movq 0x18(%rsp), %rax
movl 0x18(%rax), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
je 0x2de7
movq $0x0, 0x20(%rsp)
jmp 0x2e8d
movq 0x10(%rsp), %rdi
callq 0x20e0
movq %rax, (%rsp)
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x20e0
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
ja 0x2e32
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0x21f0
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x2e8d
movq 0x10(%rsp), %rdi
leaq 0x183e2(%rip), %rsi     # 0x1b220
callq 0x2ea0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x2e5b
movq $0x0, 0x20(%rsp)
jmp 0x2e8d
movq 0x18(%rsp), %rax
cmpq $0x0, 0x20(%rax)
je 0x2e75
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x2f30
movq 0x8(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/antirez[P]stonky/cJSON.c
// Function: cJSON_ParseWithOpts
CJSON_PUBLIC(cJSON *) cJSON_ParseWithOpts(const char *value, const char **return_parse_end, cJSON_bool require_null_terminated)
{
    size_t buffer_length;

    if (NULL == value)
    {
        return NULL;
    }

    /* Adding null character size due to require_null_terminated. */
    buffer_length = strlen(value) + sizeof("");

    return cJSON_ParseWithLengthOpts(value, buffer_length, return_parse_end, require_null_terminated);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
xorl %eax, %eax
cmpq 0x18(%rsp), %rax
jne 0x2f76
movq $0x0, 0x20(%rsp)
jmp 0x2fa4
movq 0x18(%rsp), %rdi
callq 0x20e0
addq $0x1, %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
movq (%rsp), %rsi
movq 0x10(%rsp), %rdx
movl 0xc(%rsp), %ecx
callq 0x2fb0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/antirez[P]stonky/cJSON.c
// Function: cJSON_PrintPreallocated
CJSON_PUBLIC(cJSON_bool) cJSON_PrintPreallocated(cJSON *item, char *buffer, const int length, const cJSON_bool format)
{
    printbuffer p = { 0, 0, 0, 0, 0, 0, { 0, 0, 0 } };

    if ((length < 0) || (buffer == NULL))
    {
        return false;
    }

    p.buffer = (unsigned char*)buffer;
    p.length = (size_t)length;
    p.offset = 0;
    p.noalloc = true;
    p.format = format;
    p.hooks = global_hooks;

    return print_value(item, &p);
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movl %edx, 0x4c(%rsp)
movl %ecx, 0x48(%rsp)
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x2120
cmpl $0x0, 0x4c(%rsp)
jl 0x3c86
cmpq $0x0, 0x50(%rsp)
jne 0x3c90
movl $0x0, 0x64(%rsp)
jmp 0x3cf4
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movslq 0x4c(%rsp), %rax
movq %rax, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movl $0x1, 0x28(%rsp)
movl 0x48(%rsp), %eax
movl %eax, 0x2c(%rsp)
movq 0x1755c(%rip), %rax     # 0x1b220
movq %rax, 0x30(%rsp)
movq 0x17558(%rip), %rax     # 0x1b228
movq %rax, 0x38(%rsp)
movq 0x17554(%rip), %rax     # 0x1b230
movq %rax, 0x40(%rsp)
movq 0x58(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x39d0
movl %eax, 0x64(%rsp)
movl 0x64(%rsp), %eax
addq $0x68, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/antirez[P]stonky/cJSON.c
// Function: add_item_to_array
static cJSON_bool add_item_to_array(cJSON *array, cJSON *item)
{
    cJSON *child = NULL;

    if ((item == NULL) || (array == NULL) || (array == item))
    {
        return false;
    }

    child = array->child;
    /*
     * To find the last item in array quickly, we use prev in array
     */
    if (child == NULL)
    {
        /* list is empty, start new one */
        array->child = item;
        item->prev = item;
        item->next = NULL;
    }
    else
    {
        /* append to the end */
        if (child->prev)
        {
            suffix_object(child->prev, item);
            array->child->prev = item;
        }
    }

    return true;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x4073
cmpq $0x0, 0x18(%rsp)
je 0x4073
movq 0x18(%rsp), %rax
cmpq 0x10(%rsp), %rax
jne 0x407d
movl $0x0, 0x24(%rsp)
jmp 0x40f8
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x40bd
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
movq $0x0, (%rax)
jmp 0x40f0
movq 0x8(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x40ee
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0x5370
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
jmp 0x40f0
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/antirez[P]stonky/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 0x16b71(%rip), %rdi     # 0x1b220
callq 0x31b0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x46dd
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: /workspace/github_c_makefile_star2_O0/antirez[P]stonky/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 0x4b3a
cmpq $0x0, -0x18(%rsp)
jne 0x4b48
movq $0x0, -0x8(%rsp)
jmp 0x4bf5
movq -0x18(%rsp), %rax
movq -0x10(%rsp), %rcx
cmpq 0x10(%rcx), %rax
je 0x4b6c
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 0x4b8c
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 0x4baf
movq -0x18(%rsp), %rax
movq (%rax), %rcx
movq -0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
jmp 0x4bd2
movq -0x18(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x4bd0
movq -0x18(%rsp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
jmp 0x4bd2
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: /workspace/github_c_makefile_star2_O0/antirez[P]stonky/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 0x4d9e
movl $0x0, 0x24(%rsp)
jmp 0x4e2f
movq 0x18(%rsp), %rdi
movslq 0x14(%rsp), %rsi
callq 0x3db0
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x4dcd
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x4040
movl %eax, 0x24(%rsp)
jmp 0x4e2f
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 0x4e16
movq 0x8(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x10(%rax)
jmp 0x4e27
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: /workspace/github_c_makefile_star2_O0/antirez[P]stonky/cJSON.c
// Function: cJSON_ReplaceItemViaPointer
CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemViaPointer(cJSON * const parent, cJSON * const item, cJSON * replacement)
{
    if ((parent == 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 0x4e6b
cmpq $0x0, 0x8(%rsp)
je 0x4e6b
cmpq $0x0, 0x10(%rsp)
jne 0x4e78
movl $0x0, 0x24(%rsp)
jmp 0x4f7c
movq 0x8(%rsp), %rax
cmpq 0x10(%rsp), %rax
jne 0x4e91
movl $0x1, 0x24(%rsp)
jmp 0x4f7c
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 0x4ecf
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 0x4f15
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq 0x18(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jne 0x4f05
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 0x4f51
movq 0x8(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x4f32
movq 0x8(%rsp), %rcx
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x4f4f
movq 0x8(%rsp), %rcx
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
jmp 0x4f51
movq 0x10(%rsp), %rax
movq $0x0, (%rax)
movq 0x10(%rsp), %rax
movq $0x0, 0x8(%rax)
movq 0x10(%rsp), %rdi
callq 0x2c50
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/antirez[P]stonky/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;

    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 0x5047
cmpq $0x0, 0x20(%rsp)
jne 0x5054
movl $0x0, 0x34(%rsp)
jmp 0x50e1
movq 0x18(%rsp), %rax
movl 0x18(%rax), %eax
andl $0x200, %eax            # imm = 0x200
cmpl $0x0, %eax
jne 0x5080
movq 0x18(%rsp), %rax
cmpq $0x0, 0x38(%rax)
je 0x5080
movq 0x18(%rsp), %rax
movq 0x38(%rax), %rdi
callq 0x2f30
movq 0x20(%rsp), %rdi
leaq 0x16194(%rip), %rsi     # 0x1b220
callq 0x2ea0
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x38(%rax)
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 0x3e70
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movq 0x18(%rsp), %rdx
callq 0x4e40
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/antirez[P]stonky/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 0x5260
cmpq $0x0, 0x38(%rsp)
jne 0x526e
movq $0x0, 0x40(%rsp)
jmp 0x5357
callq 0x4af0
movq %rax, 0x10(%rsp)
movq $0x0, 0x28(%rsp)
xorl %eax, %eax
cmpq $0x0, 0x10(%rsp)
movb %al, 0xf(%rsp)
je 0x52a3
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 0x52ad
jmp 0x5327
movq 0x38(%rsp), %rax
movq 0x28(%rsp), %rcx
cvtsi2sdl (%rax,%rcx,4), %xmm0
callq 0x4760
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x52e3
movq 0x10(%rsp), %rdi
callq 0x2c50
movq $0x0, 0x40(%rsp)
jmp 0x5357
cmpq $0x0, 0x28(%rsp)
jne 0x52fb
movq 0x20(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
jmp 0x530a
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x5370
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x5281
cmpq $0x0, 0x10(%rsp)
je 0x534d
movq 0x10(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x534d
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: /workspace/github_c_makefile_star2_O0/antirez[P]stonky/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 0x5680
cmpq $0x0, 0x38(%rsp)
jne 0x568e
movq $0x0, 0x40(%rsp)
jmp 0x5776
callq 0x4af0
movq %rax, 0x10(%rsp)
movq $0x0, 0x28(%rsp)
xorl %eax, %eax
cmpq $0x0, 0x10(%rsp)
movb %al, 0xf(%rsp)
je 0x56c3
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 0x56cd
jmp 0x5746
movq 0x38(%rsp), %rax
movq 0x28(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x4870
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x5702
movq 0x10(%rsp), %rdi
callq 0x2c50
movq $0x0, 0x40(%rsp)
jmp 0x5776
cmpq $0x0, 0x28(%rsp)
jne 0x571a
movq 0x20(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
jmp 0x5729
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x5370
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x56a1
cmpq $0x0, 0x10(%rsp)
je 0x576c
movq 0x10(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x576c
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: /workspace/github_c_makefile_star2_O0/antirez[P]stonky/sds.c
// Function: sdsReqType
static inline char sdsReqType(size_t string_size) {
    if (string_size < 1<<5)
        return SDS_TYPE_5;
    if (string_size < 1<<8)
        return SDS_TYPE_8;
    if (string_size < 1<<16)
        return SDS_TYPE_16;
#if (LONG_MAX == LLONG_MAX)
    if (string_size < 1ll<<32)
        return SDS_TYPE_32;
    return SDS_TYPE_64;
#else
    return SDS_TYPE_32;
#endif
}

// Assembly:
movq %rdi, -0x10(%rsp)
cmpq $0x20, -0x10(%rsp)
jae 0x8554
movb $0x0, -0x1(%rsp)
jmp 0x8595
cmpq $0x100, -0x10(%rsp)     # imm = 0x100
jae 0x8566
movb $0x1, -0x1(%rsp)
jmp 0x8595
cmpq $0x10000, -0x10(%rsp)   # imm = 0x10000
jae 0x8578
movb $0x2, -0x1(%rsp)
jmp 0x8595
movabsq $0x100000000, %rax      # imm = 0x100000000
cmpq %rax, -0x10(%rsp)
jae 0x8590
movb $0x3, -0x1(%rsp)
jmp 0x8595
movb $0x4, -0x1(%rsp)
movb -0x1(%rsp), %al
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/antirez[P]stonky/sds.c
// Function: sdsRemoveFreeSpace
sds sdsRemoveFreeSpace(sds s) {
    void *sh, *newsh;
    char type, oldtype = s[-1] & SDS_TYPE_MASK;
    int hdrlen, oldhdrlen = sdsHdrSize(oldtype);
    size_t len = sdslen(s);
    size_t avail = sdsavail(s);
    sh = (char*)s-oldhdrlen;

    /* Return ASAP if there is no space left. */
    if (avail == 0) return s;

    /* Check what would be the minimum SDS header that is just good enough to
     * fit this string. */
    type = sdsReqType(len);
    hdrlen = sdsHdrSize(type);

    /* If the type is the same, or at least a large enough type is still
     * required, we just realloc(), letting the allocator to do the copy
     * only if really needed. Otherwise if the change is huge, we manually
     * reallocate the string to use the different header type. */
    if (oldtype==type || type > SDS_TYPE_8) {
        newsh = s_realloc(sh, oldhdrlen+len+1);
        if (newsh == NULL) return NULL;
        s = (char*)newsh+oldhdrlen;
    } else {
        newsh = s_malloc(hdrlen+len+1);
        if (newsh == NULL) return NULL;
        memcpy((char*)newsh+hdrlen, s, len+1);
        s_free(sh);
        s = (char*)newsh+hdrlen;
        s[-1] = type;
        sdssetlen(s, len);
    }
    sdssetalloc(s, len);
    return s;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rax
movsbl -0x1(%rax), %eax
andl $0x7, %eax
movb %al, 0x26(%rsp)
movsbl 0x26(%rsp), %edi
callq 0x85a0
movl %eax, 0x1c(%rsp)
movq 0x38(%rsp), %rdi
callq 0x86b0
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rdi
callq 0x8a90
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rax
movslq 0x1c(%rsp), %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x8c93
movq 0x38(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x8dac
movq 0x10(%rsp), %rdi
callq 0x8540
movb %al, 0x27(%rsp)
movsbl 0x27(%rsp), %edi
callq 0x85a0
movl %eax, 0x20(%rsp)
movsbl 0x26(%rsp), %eax
movsbl 0x27(%rsp), %ecx
cmpl %ecx, %eax
je 0x8cc7
movsbl 0x27(%rsp), %eax
cmpl $0x1, %eax
jle 0x8d11
movq 0x30(%rsp), %rdi
movslq 0x1c(%rsp), %rsi
addq 0x10(%rsp), %rsi
addq $0x1, %rsi
callq 0xb3a0
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x8cfa
movq $0x0, 0x40(%rsp)
jmp 0x8dac
movq 0x28(%rsp), %rax
movslq 0x1c(%rsp), %rcx
addq %rcx, %rax
movq %rax, 0x38(%rsp)
jmp 0x8d93
movslq 0x20(%rsp), %rdi
addq 0x10(%rsp), %rdi
addq $0x1, %rdi
callq 0xb350
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x8d3c
movq $0x0, 0x40(%rsp)
jmp 0x8dac
movq 0x28(%rsp), %rdi
movslq 0x20(%rsp), %rax
addq %rax, %rdi
movq 0x38(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq $0x1, %rdx
callq 0x21b0
movq 0x30(%rsp), %rdi
callq 0xb3f0
movq 0x28(%rsp), %rax
movslq 0x20(%rsp), %rcx
addq %rcx, %rax
movq %rax, 0x38(%rsp)
movb 0x27(%rsp), %cl
movq 0x38(%rsp), %rax
movb %cl, -0x1(%rax)
movq 0x38(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x87d0
movq 0x38(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x8b90
movq 0x38(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/antirez[P]stonky/sds.c
// Function: sdsrange
void sdsrange(sds s, ssize_t start, ssize_t end) {
    size_t newlen, len = sdslen(s);

    if (len == 0) return;
    if (start < 0) {
        start = len+start;
        if (start < 0) start = 0;
    }
    if (end < 0) {
        end = len+end;
        if (end < 0) end = 0;
    }
    newlen = (start > end) ? 0 : (end-start)+1;
    if (newlen != 0) {
        if (start >= (ssize_t)len) {
            newlen = 0;
        } else if (end >= (ssize_t)len) {
            end = len-1;
            newlen = (start > end) ? 0 : (end-start)+1;
        }
    } else {
        start = 0;
    }
    if (start && newlen) memmove(s, s+start, newlen);
    s[newlen] = 0;
    sdssetlen(s,newlen);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rdi
callq 0x86b0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0xa2df
jmp 0xa420
cmpq $0x0, 0x28(%rsp)
jge 0xa309
movq 0x10(%rsp), %rax
addq 0x28(%rsp), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
jge 0xa307
movq $0x0, 0x28(%rsp)
jmp 0xa309
cmpq $0x0, 0x20(%rsp)
jge 0xa333
movq 0x10(%rsp), %rax
addq 0x20(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jge 0xa331
movq $0x0, 0x20(%rsp)
jmp 0xa333
movq 0x28(%rsp), %rax
cmpq 0x20(%rsp), %rax
jle 0xa348
xorl %eax, %eax
movq %rax, 0x8(%rsp)
jmp 0xa35b
movq 0x20(%rsp), %rax
subq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0xa3d1
movq 0x28(%rsp), %rax
cmpq 0x10(%rsp), %rax
jl 0xa384
movq $0x0, 0x18(%rsp)
jmp 0xa3cf
movq 0x20(%rsp), %rax
cmpq 0x10(%rsp), %rax
jl 0xa3cd
movq 0x10(%rsp), %rax
subq $0x1, %rax
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rax
cmpq 0x20(%rsp), %rax
jle 0xa3b2
xorl %eax, %eax
movq %rax, (%rsp)
jmp 0xa3c4
movq 0x20(%rsp), %rax
subq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, 0x18(%rsp)
jmp 0xa3cf
jmp 0xa3da
movq $0x0, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0xa403
cmpq $0x0, 0x18(%rsp)
je 0xa403
movq 0x30(%rsp), %rdi
movq 0x30(%rsp), %rsi
addq 0x28(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x23b0
movq 0x30(%rsp), %rax
movq 0x18(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x87d0
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/antirez[P]stonky/sds.c
// Function: sdscmp
int sdscmp(const sds s1, const sds s2) {
    size_t l1, l2, minlen;
    int cmp;

    l1 = sdslen(s1);
    l2 = sdslen(s2);
    minlen = (l1 < l2) ? l1 : l2;
    cmp = memcmp(s1,s2,minlen);
    if (cmp == 0) return l1>l2? 1: (l1<l2? -1: 0);
    return cmp;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rdi
callq 0x86b0
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
callq 0x86b0
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rax
cmpq 0x20(%rsp), %rax
jae 0xa534
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0xa53e
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x20f0
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
jne 0xa5a3
movq 0x28(%rsp), %rax
cmpq 0x20(%rsp), %rax
jbe 0xa57e
movl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0xa599
movq 0x28(%rsp), %rdx
movq 0x20(%rsp), %rsi
xorl %eax, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq %rsi, %rdx
cmovbl %ecx, %eax
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
movl %eax, 0x44(%rsp)
jmp 0xa5ab
movl 0x14(%rsp), %eax
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/antirez[P]stonky/stonky.c
// Function: xmalloc
void *xmalloc(size_t size) {
    void *p = malloc(size);
    if (p == NULL) {
        printf("Out of memory: malloc(%zu)", size);
        exit(1);
    }
    return p;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x2430
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0xb38d
movq 0x10(%rsp), %rsi
leaq 0xa300(%rip), %rdi      # 0x1567c
movb $0x0, %al
callq 0x2030
movl $0x1, %edi
callq 0x22b0
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/antirez[P]stonky/stonky.c
// Function: xrealloc
void *xrealloc(void *ptr, size_t size) {
    void *p = realloc(ptr,size);
    if (p == NULL) {
        printf("Out of memory: realloc(%zu)", size);
        exit(1);
    }
    return p;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x2438
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0xb3e5
movq 0x8(%rsp), %rsi
leaq 0xa2c3(%rip), %rdi      # 0x15697
movb $0x0, %al
callq 0x2030
movl $0x1, %edi
callq 0x22b0
movq (%rsp), %rax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/antirez[P]stonky/stonky.c
// Function: priceChangeToEmoji
const char *priceChangeToEmoji(double change) {
    int emoidx = 0;
    static const char *emoset[] = {"⚰️","🔴","🟢","🚀"};
    /* Note: ordering of the followign if statements is important. */
    if (change < 0) emoidx = 1;
    if (change < -8) emoidx = 0;
    if (change >= 0) emoidx = 2;
    if (change > 8) emoidx = 3;
    return emoset[emoidx];
}

// Assembly:
movsd %xmm0, -0x8(%rsp)
movl $0x0, -0xc(%rsp)
xorps %xmm0, %xmm0
ucomisd -0x8(%rsp), %xmm0
jbe 0xb911
movl $0x1, -0xc(%rsp)
movsd 0x9c57(%rip), %xmm0     # 0x15570
ucomisd -0x8(%rsp), %xmm0
jbe 0xb929
movl $0x0, -0xc(%rsp)
movsd -0x8(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0xb940
movl $0x2, -0xc(%rsp)
movsd -0x8(%rsp), %xmm0
movsd 0x9c2a(%rip), %xmm1     # 0x15578
ucomisd %xmm1, %xmm0
jbe 0xb95c
movl $0x3, -0xc(%rsp)
movslq -0xc(%rsp), %rcx
leaq 0xf8f8(%rip), %rax      # 0x1b260
movq (%rax,%rcx,8), %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/antirez[P]stonky/stonky.c
// Function: sqlEnd
void sqlEnd(sqlRow *row) {
    if (row->stmt == NULL) return;
    xfree(row->col);
    sqlite3_finalize(row->stmt);
    row->col = NULL;
    row->stmt = NULL;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
cmpq $0x0, (%rax)
jne 0xc571
jmp 0xc5a1
movq (%rsp), %rax
movq 0x10(%rax), %rdi
callq 0xb3f0
movq (%rsp), %rax
movq (%rax), %rdi
callq 0x23c0
movq (%rsp), %rax
movq $0x0, 0x10(%rax)
movq (%rsp), %rax
movq $0x0, (%rax)
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/antirez[P]stonky/stonky.c
// Function: sqlInsert
int sqlInsert(const char *sql, ...) {
    int64_t lastid = 0;
    va_list ap;
    va_start(ap,sql);
    int rc = sqlGenericQuery(NULL,sql,ap);
    if (rc == SQLITE_DONE) lastid = sqlite3_last_insert_rowid(DbHandle);
    va_end(ap);
    return lastid;
}

// Assembly:
subq $0xe8, %rsp
testb %al, %al
je 0xc8dc
movaps %xmm0, 0x30(%rsp)
movaps %xmm1, 0x40(%rsp)
movaps %xmm2, 0x50(%rsp)
movaps %xmm3, 0x60(%rsp)
movaps %xmm4, 0x70(%rsp)
movaps %xmm5, 0x80(%rsp)
movaps %xmm6, 0x90(%rsp)
movaps %xmm7, 0xa0(%rsp)
movq %r9, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdi, 0xe0(%rsp)
movq $0x0, 0xd8(%rsp)
leaq 0xc0(%rsp), %rax
movq %rsp, %rcx
movq %rcx, 0x10(%rax)
leaq 0xf0(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq 0xe0(%rsp), %rsi
leaq 0xc0(%rsp), %rdx
xorl %eax, %eax
movl %eax, %edi
callq 0xbf20
movl %eax, 0xbc(%rsp)
cmpl $0x65, 0xbc(%rsp)
jne 0xc97b
movq %fs:0x0, %rax
leaq -0x8(%rax), %rax
movq (%rax), %rdi
callq 0x2130
movq %rax, 0xd8(%rsp)
movl 0xd8(%rsp), %eax
addq $0xe8, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/antirez[P]stonky/stonky.c
// Function: sqlQuery
int sqlQuery(const char *sql, ...) {
    int64_t retval = 0;
    va_list ap;
    va_start(ap,sql);
    int rc = sqlGenericQuery(NULL,sql,ap);
    retval = (rc == SQLITE_DONE);
    va_end(ap);
    return retval;
}

// Assembly:
subq $0xe8, %rsp
testb %al, %al
je 0xc9cc
movaps %xmm0, 0x30(%rsp)
movaps %xmm1, 0x40(%rsp)
movaps %xmm2, 0x50(%rsp)
movaps %xmm3, 0x60(%rsp)
movaps %xmm4, 0x70(%rsp)
movaps %xmm5, 0x80(%rsp)
movaps %xmm6, 0x90(%rsp)
movaps %xmm7, 0xa0(%rsp)
movq %r9, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdi, 0xe0(%rsp)
movq $0x0, 0xd8(%rsp)
movq %rsp, %rax
movq %rax, 0xd0(%rsp)
leaq 0xf0(%rsp), %rax
movq %rax, 0xc8(%rsp)
movl $0x30, 0xc4(%rsp)
movl $0x8, 0xc0(%rsp)
movq 0xe0(%rsp), %rsi
xorl %eax, %eax
movl %eax, %edi
leaq 0xc0(%rsp), %rdx
callq 0xbf20
movl %eax, 0xbc(%rsp)
movl 0xbc(%rsp), %eax
subl $0x65, %eax
sete %al
movzbl %al, %eax
movq %rax, 0xd8(%rsp)
movl 0xd8(%rsp), %eax
addq $0xe8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/antirez[P]stonky/stonky.c
// Function: sqlSelectOneRow
int sqlSelectOneRow(sqlRow *row, const char *sql, ...) {
    va_list ap;
    va_start(ap,sql);
    int rc = sqlGenericQuery(row,sql,ap);
    if (rc == SQLITE_ROW) sqlNextRow(row);
    va_end(ap);
    return rc;
}

// Assembly:
subq $0xe8, %rsp
testb %al, %al
je 0xcb8c
movaps %xmm0, 0x30(%rsp)
movaps %xmm1, 0x40(%rsp)
movaps %xmm2, 0x50(%rsp)
movaps %xmm3, 0x60(%rsp)
movaps %xmm4, 0x70(%rsp)
movaps %xmm5, 0x80(%rsp)
movaps %xmm6, 0x90(%rsp)
movaps %xmm7, 0xa0(%rsp)
movq %r9, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rdi, 0xe0(%rsp)
movq %rsi, 0xd8(%rsp)
leaq 0xc0(%rsp), %rax
movq %rsp, %rcx
movq %rcx, 0x10(%rax)
leaq 0xf0(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq 0xe0(%rsp), %rdi
movq 0xd8(%rsp), %rsi
leaq 0xc0(%rsp), %rdx
callq 0xbf20
movl %eax, 0xbc(%rsp)
cmpl $0x64, 0xbc(%rsp)
jne 0xcc13
movq 0xe0(%rsp), %rdi
callq 0xc5b0
movl 0xbc(%rsp), %eax
addq $0xe8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/antirez[P]stonky/stonky.c
// Function: sqlSelectInt
int64_t sqlSelectInt(const char *sql, ...) {
    sqlRow row;
    int64_t i = 0;
    va_list ap;
    va_start(ap,sql);
    int rc = sqlGenericQuery(&row,sql,ap);
    if (rc == SQLITE_ROW) {
        sqlNextRow(&row);
        i = row.col[0].i;
        sqlEnd(&row);
    }
    va_end(ap);
    return i;
}

// Assembly:
subq $0x108, %rsp            # imm = 0x108
testb %al, %al
je 0xcc6c
movaps %xmm0, 0x30(%rsp)
movaps %xmm1, 0x40(%rsp)
movaps %xmm2, 0x50(%rsp)
movaps %xmm3, 0x60(%rsp)
movaps %xmm4, 0x70(%rsp)
movaps %xmm5, 0x80(%rsp)
movaps %xmm6, 0x90(%rsp)
movaps %xmm7, 0xa0(%rsp)
movq %r9, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdi, 0x100(%rsp)
movq $0x0, 0xe0(%rsp)
leaq 0xc0(%rsp), %rax
movq %rsp, %rcx
movq %rcx, 0x10(%rax)
leaq 0x110(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq 0x100(%rsp), %rsi
leaq 0xc0(%rsp), %rdx
leaq 0xe8(%rsp), %rdi
callq 0xbf20
movl %eax, 0xbc(%rsp)
cmpl $0x64, 0xbc(%rsp)
jne 0xcd1d
leaq 0xe8(%rsp), %rdi
callq 0xc5b0
movq 0xf8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0xe0(%rsp)
leaq 0xe8(%rsp), %rdi
callq 0xc560
movq 0xe0(%rsp), %rax
addq $0x108, %rsp            # imm = 0x108
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/antirez[P]stonky/stonky.c
// Function: makeHttpCall
sds makeHttpCall(const char *url, int *resptr) {
    if (DebugMode) printf("HTTP GET %s\n", url);
    CURL* curl;
    CURLcode res;
    sds body = sdsempty();

    curl = curl_easy_init();
    if (curl) {
        curl_easy_setopt(curl, CURLOPT_URL, url);
        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, makeHttpCallWriter);
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, &body);
        curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 1L);
        curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 1L);
        curl_easy_setopt(curl, CURLOPT_TIMEOUT, 15);
        curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, 15);

        /* Perform the request, res will get the return code */
        res = curl_easy_perform(curl);
        if (resptr) *resptr = res == CURLE_OK ? C_OK : C_ERR;

        /* Check for errors */
        if (res != CURLE_OK) {
            const char *errstr = curl_easy_strerror(res);
            body = sdscat(body,errstr);
        } else {
            /* Return C_ERR if the request worked but returned a 500 code. */
            long code;
            curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &code);
            if (code == 500 && resptr) *resptr = C_ERR;
        }

        /* always cleanup */
        curl_easy_cleanup(curl);
    }
    return body;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
cmpl $0x0, 0xe51b(%rip)      # 0x1b2b0
je 0xcdaa
movq 0x30(%rsp), %rsi
leaq 0x8944(%rip), %rdi      # 0x156e7
movb $0x0, %al
callq 0x2030
callq 0x8610
movq %rax, 0x10(%rsp)
callq 0x22e0
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0xcefc
movq 0x20(%rsp), %rdi
movq 0x30(%rsp), %rdx
movl $0x2712, %esi           # imm = 0x2712
movb $0x0, %al
callq 0x2280
movq 0x20(%rsp), %rdi
movl $0x4e2b, %esi           # imm = 0x4E2B
leaq -0xc1(%rip), %rdx       # 0xcd30
movb $0x0, %al
callq 0x2280
movq 0x20(%rsp), %rdi
movl $0x2711, %esi           # imm = 0x2711
leaq 0x10(%rsp), %rdx
movb $0x0, %al
callq 0x2280
movq 0x20(%rsp), %rdi
movl $0x40, %esi
movl $0x1, %edx
movb $0x0, %al
callq 0x2280
movq 0x20(%rsp), %rdi
movl $0x51, %esi
movl $0x1, %edx
movb $0x0, %al
callq 0x2280
movq 0x20(%rsp), %rdi
movl $0xd, %esi
movl $0xf, %edx
movb $0x0, %al
callq 0x2280
movq 0x20(%rsp), %rdi
movl $0x4e, %esi
movl $0xf, %edx
movb $0x0, %al
callq 0x2280
movq 0x20(%rsp), %rdi
callq 0x22f0
movl %eax, 0x1c(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0xce94
movl 0x1c(%rsp), %edx
xorl %ecx, %ecx
movl $0x1, %eax
cmpl $0x0, %edx
cmovel %eax, %ecx
movq 0x28(%rsp), %rax
movl %ecx, (%rax)
cmpl $0x0, 0x1c(%rsp)
je 0xcebf
movl 0x1c(%rsp), %edi
callq 0x2350
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x9350
movq %rax, 0x10(%rsp)
jmp 0xcef2
movq 0x20(%rsp), %rdi
movl $0x200002, %esi         # imm = 0x200002
movq %rsp, %rdx
movb $0x0, %al
callq 0x2140
cmpq $0x1f4, (%rsp)          # imm = 0x1F4
jne 0xcef0
cmpq $0x0, 0x28(%rsp)
je 0xcef0
movq 0x28(%rsp), %rax
movl $0x0, (%rax)
jmp 0xcef2
movq 0x20(%rsp), %rdi
callq 0x22d0
movq 0x10(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/antirez[P]stonky/stonky.c
// Function: makeHttpCallOpt
sds makeHttpCallOpt(const char *url, int *resptr, char **optlist, int optnum) {
    sds fullurl = sdsnew(url);
    if (optnum) fullurl = sdscatlen(fullurl,"?",1);
    CURL *curl = curl_easy_init();
    for (int j = 0; j < optnum; j++) {
        if (j > 0) fullurl = sdscatlen(fullurl,"&",1);
        fullurl = sdscat(fullurl,optlist[j*2]);
        fullurl = sdscatlen(fullurl,"=",1);
        char *escaped = curl_easy_escape(curl,
            optlist[j*2+1],strlen(optlist[j*2+1]));
        fullurl = sdscat(fullurl,escaped);
        curl_free(escaped);
    }
    curl_easy_cleanup(curl);
    sds body = makeHttpCall(fullurl,resptr);
    sdsfree(fullurl);
    return body;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movl %ecx, 0x3c(%rsp)
movq 0x50(%rsp), %rdi
callq 0x8630
movq %rax, 0x30(%rsp)
cmpl $0x0, 0x3c(%rsp)
je 0xcf58
movq 0x30(%rsp), %rdi
leaq 0x8ed4(%rip), %rsi      # 0x15e1d
movl $0x1, %edx
callq 0x92b0
movq %rax, 0x30(%rsp)
callq 0x22e0
movq %rax, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
cmpl 0x3c(%rsp), %eax
jge 0xd056
cmpl $0x0, 0x24(%rsp)
jle 0xcf9a
movq 0x30(%rsp), %rdi
leaq 0x8769(%rip), %rsi      # 0x156f4
movl $0x1, %edx
callq 0x92b0
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq 0x40(%rsp), %rax
movl 0x24(%rsp), %ecx
shll %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rsi
callq 0x9350
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
leaq 0x872f(%rip), %rsi      # 0x156f6
movl $0x1, %edx
callq 0x92b0
movq %rax, 0x30(%rsp)
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movq 0x40(%rsp), %rax
movl 0x24(%rsp), %ecx
shll %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rax
movl 0x24(%rsp), %ecx
shll %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdi
callq 0x20e0
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movl %eax, %edx
callq 0x23d0
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x9350
movq %rax, 0x30(%rsp)
movq 0x18(%rsp), %rdi
callq 0x2080
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0xcf6a
movq 0x28(%rsp), %rdi
callq 0x22d0
movq 0x30(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0xcd80
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
callq 0x8750
movq 0x10(%rsp), %rax
addq $0x58, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/antirez[P]stonky/stonky.c
// Function: makeBotRequest
sds makeBotRequest(const char *action, int *resptr, char **optlist, int numopt)
{
    sds url = sdsnew("https://api.telegram.org/bot");
    url = sdscat(url,BotApiKey);
    url = sdscatlen(url,"/",1);
    url = sdscat(url,action);
    sds body = makeHttpCallOpt(url,resptr,optlist,numopt);
    sdsfree(url);
    return body;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movl %ecx, 0x1c(%rsp)
leaq 0x864a(%rip), %rdi      # 0x156f8
callq 0x8630
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq 0xe1fc(%rip), %rsi      # 0x1b2c0
callq 0x9350
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
leaq 0x866d(%rip), %rsi      # 0x15747
movl $0x1, %edx
callq 0x92b0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x9350
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
movl 0x1c(%rsp), %ecx
callq 0xcf10
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x8750
movq 0x8(%rsp), %rax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/antirez[P]stonky/stonky.c
// Function: freeYahooData
void freeYahooData(ydata *y) {
    if (y == NULL) return;
    sdsfree(y->symbol);
    sdsfree(y->name);
    sdsfree(y->prechange);
    sdsfree(y->postchange);
    sdsfree(y->regchange);
    sdsfree(y->csym);
    sdsfree(y->exchange);
    sdsfree(y->summary);
    sdsfree(y->country);
    sdsfree(y->industry);
    sdsfree(y->exdivdate);
    free(y->ts_data);
    free(y);
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0xd141
jmp 0xd1f5
movq (%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x8750
movq (%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x8750
movq (%rsp), %rax
movq 0x48(%rax), %rdi
callq 0x8750
movq (%rsp), %rax
movq 0x50(%rax), %rdi
callq 0x8750
movq (%rsp), %rax
movq 0x58(%rax), %rdi
callq 0x8750
movq (%rsp), %rax
movq 0x70(%rax), %rdi
callq 0x8750
movq (%rsp), %rax
movq 0x60(%rax), %rdi
callq 0x8750
movq (%rsp), %rax
movq 0xc8(%rax), %rdi
callq 0x8750
movq (%rsp), %rax
movq 0xd0(%rax), %rdi
callq 0x8750
movq (%rsp), %rax
movq 0xd8(%rax), %rdi
callq 0x8750
movq (%rsp), %rax
movq 0xf0(%rax), %rdi
callq 0x8750
movq (%rsp), %rax
movq 0x80(%rax), %rdi
callq 0x2428
movq (%rsp), %rdi
callq 0x2428
popq %rax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/antirez[P]stonky/stonky.c
// Function: kvGet
sds kvGet(const char *key) {
    sds value = NULL;
    sqlRow row;
    sqlSelect(&row,"SELECT expire,value FROM KeyValue WHERE key=?s",key);
    if (sqlNextRow(&row)) {
        int64_t expire = row.col[0].i;
        if (!NoEvictMode && expire && expire < time(NULL)) {
            sqlQuery("DELETE FROM KeyValue WHERE key=?s",key);
        } else {
            value = sdsnewlen(row.col[1].s,row.col[1].i);
        }
    }
    sqlEnd(&row);
    return value;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq $0x0, 0x28(%rsp)
movq 0x30(%rsp), %rdx
leaq 0x10(%rsp), %rdi
leaq 0x7f9b(%rip), %rsi      # 0x158ee
movb $0x0, %al
callq 0xca80
leaq 0x10(%rsp), %rdi
callq 0xc5b0
cmpl $0x0, %eax
je 0xd9d9
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
cmpl $0x0, 0xd956(%rip)      # 0x1b2d4
jne 0xd9bb
cmpq $0x0, 0x8(%rsp)
je 0xd9bb
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
xorl %eax, %eax
movl %eax, %edi
callq 0x21e0
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jge 0xd9bb
movq 0x30(%rsp), %rsi
leaq 0x7f6b(%rip), %rdi      # 0x1591d
movb $0x0, %al
callq 0xc990
jmp 0xd9d7
movq 0x20(%rsp), %rax
movq 0x30(%rax), %rdi
movq 0x20(%rsp), %rax
movq 0x28(%rax), %rsi
callq 0x8300
movq %rax, 0x28(%rsp)
jmp 0xd9d9
leaq 0x10(%rsp), %rdi
callq 0xc560
movq 0x28(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)