LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/Cotix[P]cReddit/libreddit/comment.c
// Function: redditGetCommentList
EXPORT_SYMBOL RedditErrno redditGetCommentList (RedditCommentList *list)
{
    char fullLink[2048], *kindStr = NULL;
    TokenParserResult res;

    TokenIdent ids[] = {
        ADD_TOKEN_IDENT_STRING("id",   list->id),
        ADD_TOKEN_IDENT_STRING("kind", kindStr),
        ADD_TOKEN_IDENT_FUNC  ("data", getCommentListHelper),
        {0}
    };

    strcpy(fullLink, REDDIT_URL);
    strcat(fullLink, list->permalink);
    strcat(fullLink, REDDIT_JSON);

    if (list->baseComment == NULL)
        list->baseComment = redditCommentNew();

    res = redditRunParser(fullLink, NULL, ids, list, list->baseComment);

    free(kindStr);

    if (res == TOKEN_PARSER_SUCCESS)
        return REDDIT_SUCCESS;
    else
        return REDDIT_ERROR_RESPONSE;
}

// Assembly:
subq $0x908, %rsp            # imm = 0x908
movq %rdi, 0x8f8(%rsp)
movq $0x0, 0xe8(%rsp)
leaq 0x548b(%rip), %rax      # 0x835d
movq %rax, (%rsp)
movl $0x2, 0x8(%rsp)
movl $0x0, 0xc(%rsp)
movq 0x8f8(%rsp), %rax
addq $0x18, %rax
movq %rax, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movq $0x0, 0x20(%rsp)
movl $0x0, 0x28(%rsp)
movb $0x1, 0x2c(%rsp)
movq $0x0, 0x30(%rsp)
leaq 0x5488(%rip), %rax      # 0x83ae
movq %rax, 0x38(%rsp)
movl $0x2, 0x40(%rsp)
movl $0x0, 0x44(%rsp)
leaq 0xe8(%rsp), %rax
movq %rax, 0x48(%rsp)
movq $0x0, 0x50(%rsp)
movq $0x0, 0x58(%rsp)
movl $0x0, 0x60(%rsp)
movb $0x1, 0x64(%rsp)
movq $0x0, 0x68(%rsp)
leaq 0x543c(%rip), %rax      # 0x83b3
movq %rax, 0x70(%rsp)
movl $0x3, 0x78(%rsp)
movl $0x2, 0x7c(%rsp)
movq $0x0, 0x80(%rsp)
movq $0x0, 0x88(%rsp)
movq $0x0, 0x90(%rsp)
movl $0x0, 0x98(%rsp)
movb $0x0, 0x9c(%rsp)
leaq 0xf6(%rip), %rax        # 0x30c0
movq %rax, 0xa0(%rsp)
movq %rsp, %rdi
addq $0xa8, %rdi
xorl %esi, %esi
movl $0x38, %edx
callq 0x2100
leaq 0xf0(%rsp), %rdi
leaq 0x53c1(%rip), %rsi      # 0x83b8
callq 0x2070
leaq 0xf0(%rsp), %rdi
movq 0x8f8(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0x2260
leaq 0xf0(%rsp), %rdi
leaq 0x55c1(%rip), %rsi      # 0x85e5
callq 0x2260
movq 0x8f8(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x304a
callq 0x2110
movq %rax, %rcx
movq 0x8f8(%rsp), %rax
movq %rcx, (%rax)
leaq 0xf0(%rsp), %rdi
movq %rsp, %rdx
movq 0x8f8(%rsp), %rcx
movq 0x8f8(%rsp), %rax
movq (%rax), %r8
xorl %eax, %eax
movl %eax, %esi
movb $0x0, %al
callq 0x6ed0
movl %eax, 0xe4(%rsp)
movq 0xe8(%rsp), %rdi
callq 0x2040
cmpl $0x0, 0xe4(%rsp)
jne 0x309e
movl $0x0, 0x904(%rsp)
jmp 0x30a9
movl $0x2, 0x904(%rsp)
movl 0x904(%rsp), %eax
addq $0x908, %rsp            # imm = 0x908
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Cotix[P]cReddit/libreddit/comment.c
// Function: redditCommentAddMore
static void redditCommentAddMore (TokenParser *parser, RedditComment *parent)
{
    int i;

    redditCommentFreeChildren(parent);

    parent->directChildrenCount = parser->tokens[parser->currentToken].full_size;
    parent->directChildrenIds = rmalloc(parent->directChildrenCount * sizeof(char*));

    for (i = 0; i < parent->directChildrenCount; i++) {
        parser->currentToken++;
        parent->directChildrenIds[i] = getCopyOfToken(parser->block->memory, parser->tokens[parser->currentToken]);
    }
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x48(%rsp), %rdi
callq 0x24b0
movq 0x50(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x50(%rsp), %rcx
movslq 0x14(%rcx), %rcx
imulq $0x1c, %rcx, %rcx
addq %rcx, %rax
movl 0x14(%rax), %ecx
movq 0x48(%rsp), %rax
movl %ecx, 0x60(%rax)
movq 0x48(%rsp), %rax
movslq 0x60(%rax), %rdi
shlq $0x3, %rdi
callq 0x43a0
movq %rax, %rcx
movq 0x48(%rsp), %rax
movq %rcx, 0x70(%rax)
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
movq 0x48(%rsp), %rcx
cmpl 0x60(%rcx), %eax
jge 0x3b26
movq 0x50(%rsp), %rax
movl 0x14(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x14(%rax)
movq 0x50(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rdi
movq 0x50(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x50(%rsp), %rcx
movslq 0x14(%rcx), %rcx
imulq $0x1c, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq %rcx, 0x28(%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x30(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x38(%rsp)
movl 0x18(%rax), %eax
movl %eax, 0x40(%rsp)
leaq 0x28(%rsp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movl 0x18(%rax), %eax
movl %eax, 0x18(%rsp)
callq 0x5de0
movq %rax, %rdx
movq 0x48(%rsp), %rax
movq 0x70(%rax), %rax
movslq 0x44(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl 0x44(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x44(%rsp)
jmp 0x3a72
addq $0x58, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Cotix[P]cReddit/libreddit/comment.c
// Function: readMore
DEF_TOKEN_CALLBACK(readMore)
{
    RedditComment *base        = va_arg(args, RedditComment*);
    struct MoreChildren *child = va_arg(args, struct MoreChildren*);


    RedditComment *parent = redditCommentFindParent(base, child->parent);

    if (parent == NULL) {
        /* If we didn't find parent, we just advance past the array */
        parser->currentToken += parser->tokens[parser->currentToken].full_size;
    } else {
        redditCommentAddMore(parser, parent);
        parent->totalReplyCount = child->count;
    }

}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x28(%rsp)
movl (%rax), %eax
movl %eax, 0x34(%rsp)
cmpl $0x28, %eax
ja 0x3e64
movq 0x28(%rsp), %rcx
movl 0x34(%rsp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, 0x20(%rsp)
jmp 0x3e7d
movq 0x28(%rsp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x48(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
movl (%rax), %eax
movl %eax, 0x1c(%rsp)
cmpl $0x28, %eax
ja 0x3ebb
movq 0x10(%rsp), %rcx
movl 0x1c(%rsp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, 0x8(%rsp)
jmp 0x3ed4
movq 0x10(%rsp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rax
movq (%rax), %rsi
callq 0x3f50
movq %rax, 0x38(%rsp)
cmpq $0x0, 0x38(%rsp)
jne 0x3f29
movq 0x60(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x60(%rsp), %rcx
movslq 0x14(%rcx), %rcx
imulq $0x1c, %rcx, %rcx
addq %rcx, %rax
movl 0x14(%rax), %ecx
movq 0x60(%rsp), %rax
addl 0x14(%rax), %ecx
movl %ecx, 0x14(%rax)
jmp 0x3f48
movq 0x60(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x3a10
movq 0x40(%rsp), %rax
movl 0x8(%rax), %ecx
movq 0x38(%rsp), %rax
movl %ecx, 0x5c(%rax)
addq $0x68, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Cotix[P]cReddit/libreddit/comment.c
// Function: redditCommentFindParent
static RedditComment *redditCommentFindParent (RedditComment *base, char *parentId)
{
    char pid[8];
    RedditComment *current;

    int stackSize = 100;
    RedditComment **stack = rmalloc(sizeof(RedditComment*) * stackSize);;
    int top = 0;

    /* We might have, Ex. 't1_idvalu', we just want 'idvalu' from that */
    if (parentId[2] == '_')
        strcpy(pid, parentId + 3);
    else
        strcpy(pid, parentId);

    stack[0] = base;
    top = 0;
    /* Keep looping and decrementing our stack index until it's under zero */
    for(; top >= 0; top--) {

        /* Grab the RedditComment on the top of the stack */
        current = stack[top];

        /* If it's the right one, jump to the cleanup code */
        if (strcmp(pid, current->id) == 0)
            goto cleanup;

        /* If it's not and it has some replies to it, add all the replies to
         * the stack and keep going */
        if (current->replyCount > 0) {
            if (top + current->replyCount >= stackSize) {
                stackSize += current->replyCount;
                stack = realloc(stack, sizeof(RedditComment*) * stackSize);
            }
            /* Copy the contents of the replies array right onto the stack. */
            memcpy(stack + top, current->replies, current->replyCount * sizeof(RedditComment*));
            top += current->replyCount;
        }
    }

    current = NULL;

cleanup:;
    free(stack);
    return current;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl $0x64, 0x14(%rsp)
movslq 0x14(%rsp), %rdi
shlq $0x3, %rdi
callq 0x43a0
movq %rax, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
movq 0x28(%rsp), %rax
movsbl 0x2(%rax), %eax
cmpl $0x5f, %eax
jne 0x3fa4
leaq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
addq $0x3, %rsi
callq 0x2070
jmp 0x3fb3
leaq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x2070
movq 0x30(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movl $0x0, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jl 0x4091
movq 0x8(%rsp), %rax
movslq 0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rsi
callq 0x2160
cmpl $0x0, %eax
jne 0x4003
jmp 0x409a
movq 0x18(%rsp), %rax
cmpl $0x0, (%rax)
jle 0x407f
movl 0x4(%rsp), %eax
movq 0x18(%rsp), %rcx
addl (%rcx), %eax
cmpl 0x14(%rsp), %eax
jl 0x4045
movq 0x18(%rsp), %rax
movl (%rax), %eax
addl 0x14(%rsp), %eax
movl %eax, 0x14(%rsp)
movq 0x8(%rsp), %rdi
movslq 0x14(%rsp), %rsi
shlq $0x3, %rsi
callq 0x21e0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movslq 0x4(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rsi
movq 0x18(%rsp), %rax
movslq (%rax), %rdx
shlq $0x3, %rdx
callq 0x2180
movq 0x18(%rsp), %rax
movl (%rax), %eax
addl 0x4(%rsp), %eax
movl %eax, 0x4(%rsp)
jmp 0x4081
movl 0x4(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x3fc8
movq $0x0, 0x18(%rsp)
movq 0x8(%rsp), %rdi
callq 0x2040
movq 0x18(%rsp), %rax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Cotix[P]cReddit/libreddit/cookie.c
// Function: redditCookieNew
EXPORT_SYMBOL void redditCookieNew(char *name, char *data)
{
    RedditCookieLink *link = rmalloc(sizeof(RedditCookieLink));

    link->name = rmalloc(strlen(name) + 1);
    link->data = rmalloc(strlen(data) + 1);

    strcpy(link->name, name);
    strcpy(link->data, data);

    /*
     * If for whatever reason we don't have an allocated reddit-state yet
     * Make a new one
     */
    if (currentRedditState == NULL)
        currentRedditState = redditStateNew();

    /* Attach the link */
    link->next = currentRedditState->base;
    currentRedditState->base = link;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl $0x18, %edi
callq 0x43a0
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
callq 0x20d0
movq %rax, %rdi
addq $0x1, %rdi
callq 0x43a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rdi
callq 0x20d0
movq %rax, %rdi
addq $0x1, %rdi
callq 0x43a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq (%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0x2070
movq (%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0x2070
leaq 0x702f(%rip), %rax      # 0xb168
cmpq $0x0, (%rax)
jne 0x4153
movb $0x0, %al
callq 0x2230
movq %rax, %rcx
leaq 0x7018(%rip), %rax      # 0xb168
movq %rcx, (%rax)
leaq 0x700e(%rip), %rax      # 0xb168
movq (%rax), %rax
movq (%rax), %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movq (%rsp), %rcx
leaq 0x6ff6(%rip), %rax      # 0xb168
movq (%rax), %rax
movq %rcx, (%rax)
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Cotix[P]cReddit/libreddit/cookie.c
// Function: redditCookieFree
EXPORT_SYMBOL void redditCookieFree(RedditCookieLink *link)
{
    if (link == NULL)
        return ;
    free(link->name);
    free(link->data);
    free(link);
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x418e
jmp 0x41b1
movq (%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x2040
movq (%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x2040
movq (%rsp), %rdi
callq 0x2040
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Cotix[P]cReddit/libreddit/cookie.c
// Function: redditRemoveCookie
EXPORT_SYMBOL void redditRemoveCookie(char *name)
{
    RedditCookieLink *prev = NULL, *node;

    /* Incase no state has yet been set */
    if (currentRedditState == NULL) return ;

    for(node = currentRedditState->base; node != NULL; prev = node, node = node->next) {
        if (strcmp(node->name, name) == 0) {
            /* Found the node */
            if (prev != NULL)
                prev->next = node->next;
            else
                currentRedditState->base = node->next;

            redditCookieFree(node);
            break;
        }
    }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
leaq 0x6f8f(%rip), %rax      # 0xb168
cmpq $0x0, (%rax)
jne 0x41e1
jmp 0x4260
leaq 0x6f80(%rip), %rax      # 0xb168
movq (%rax), %rax
movq (%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x4260
movq (%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0x2160
cmpl $0x0, %eax
jne 0x4248
cmpq $0x0, 0x8(%rsp)
je 0x4229
movq (%rsp), %rax
movq (%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
jmp 0x423d
movq (%rsp), %rax
movq (%rax), %rcx
leaq 0x6f31(%rip), %rax      # 0xb168
movq (%rax), %rax
movq %rcx, (%rax)
movq (%rsp), %rdi
callq 0x2150
jmp 0x4260
jmp 0x424a
movq (%rsp), %rax
movq %rax, 0x8(%rsp)
movq (%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
jmp 0x41f2
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Cotix[P]cReddit/libreddit/cookie.c
// Function: redditGetCookieString
EXPORT_SYMBOL char *redditGetCookieString()
{
    char *cookieStr = NULL;
    int currentLength = 0;
    RedditCookieLink *node;

    if (currentRedditState == NULL) return NULL;

    for(node = currentRedditState->base; node != NULL; node = node->next) {
        int add_size = strlen(node->name) + strlen(node->data) + 2;
        currentLength += add_size;
        cookieStr = rrealloc(cookieStr, currentLength);
        if (node != currentRedditState->base)
            strcat(cookieStr, "&");
        else
            cookieStr[0] = 0;

        strcat(cookieStr, node->name);
        strcat(cookieStr, "=");
        strcat(cookieStr, node->data);
    }

    return cookieStr;
}

// Assembly:
subq $0x38, %rsp
movq $0x0, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
leaq 0x6edc(%rip), %rax      # 0xb168
cmpq $0x0, (%rax)
jne 0x42a0
movq $0x0, 0x30(%rsp)
jmp 0x4394
leaq 0x6ec1(%rip), %rax      # 0xb168
movq (%rax), %rax
movq (%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x438a
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x20d0
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x20d0
movq %rax, %rcx
movq 0x8(%rsp), %rax
addq %rcx, %rax
addq $0x2, %rax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addl 0x24(%rsp), %eax
movl %eax, 0x24(%rsp)
movq 0x28(%rsp), %rdi
movslq 0x24(%rsp), %rsi
callq 0x43e0
movq %rax, 0x28(%rsp)
movq 0x18(%rsp), %rax
leaq 0x6e4a(%rip), %rcx      # 0xb168
movq (%rcx), %rcx
cmpq (%rcx), %rax
je 0x4339
movq 0x28(%rsp), %rdi
leaq 0x4111(%rip), %rsi      # 0x8443
callq 0x2260
jmp 0x4341
movq 0x28(%rsp), %rax
movb $0x0, (%rax)
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0x2260
movq 0x28(%rsp), %rdi
leaq 0x4099(%rip), %rsi      # 0x83f9
callq 0x2260
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0x2260
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x18(%rsp)
jmp 0x42b2
movq 0x28(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Cotix[P]cReddit/libreddit/global.c
// Function: rmalloc
void *rmalloc(size_t bytes)
{
    void *m = malloc(bytes);
    if (m == NULL)
        exit(EXIT_FAILURE);
    return m;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x21a0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x43ca
movl $0x1, %edi
callq 0x22a0
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Cotix[P]cReddit/libreddit/global.c
// Function: rrealloc
void *rrealloc(void *old, size_t bytes)
{
    void *m = realloc(old, bytes);
    if (m == NULL)
        exit(EXIT_FAILURE);
    return m;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x21e0
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x4412
movl $0x1, %edi
callq 0x22a0
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Cotix[P]cReddit/libreddit/jsmn.c
// Function: jsmn_alloc_token
static jsmntok_t *jsmn_alloc_token(jsmn_parser *parser,
		jsmntok_t *tokens, size_t num_tokens) {
	jsmntok_t *tok;
	if (parser->toknext >= num_tokens) {
		return NULL;
	}
	tok = &tokens[parser->toknext++];
	tok->start = tok->end = -1;
	tok->size = 0;
	tok->is_key = 0;
#ifdef JSMN_PARENT_LINKS
	tok->parent = -1;
	tok->full_size = 0;
#endif
	return tok;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
movq -0x10(%rsp), %rax
movslq 0x4(%rax), %rax
cmpq -0x20(%rsp), %rax
jb 0x48ba
movq $0x0, -0x8(%rsp)
jmp 0x4935
movq -0x18(%rsp), %rax
movq -0x10(%rsp), %rdx
movl 0x4(%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x4(%rdx)
movslq %ecx, %rcx
imulq $0x1c, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rsp)
movq -0x28(%rsp), %rax
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
movq -0x28(%rsp), %rax
movl $0xffffffff, 0x4(%rax)  # imm = 0xFFFFFFFF
movq -0x28(%rsp), %rax
movl $0x0, 0xc(%rax)
movq -0x28(%rsp), %rax
movb 0x10(%rax), %cl
andb $-0x2, %cl
orb $0x0, %cl
movb %cl, 0x10(%rax)
movq -0x28(%rsp), %rax
movl $0xffffffff, 0x18(%rax) # imm = 0xFFFFFFFF
movq -0x28(%rsp), %rax
movl $0x0, 0x14(%rax)
movq -0x28(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Cotix[P]cReddit/libreddit/jsmn.c
// Function: jsmn_parse_string
static jsmnerr_t jsmn_parse_string(jsmn_parser *parser, const char *js,
		jsmntok_t *tokens, int on_key, size_t num_tokens) {
	jsmntok_t *token;

	int start = parser->pos;

	parser->pos++;

	/* Skip starting quote */
	for (; js[parser->pos] != '\0'; parser->pos++) {
		char c = js[parser->pos];

		/* Quote: end of string */
		if (c == '\"') {
			token = jsmn_alloc_token(parser, tokens, num_tokens);
			if (token == NULL) {
				parser->pos = start;
				return JSMN_ERROR_NOMEM;
			}
			jsmn_fill_token(token, JSMN_STRING, start+1, parser->pos, on_key);
#ifdef JSMN_PARENT_LINKS
			token->parent = parser->toksuper;
#endif
			return JSMN_SUCCESS;
		}

		/* Backslash: Quoted symbol expected */
		if (c == '\\') {
			parser->pos++;
			switch (js[parser->pos]) {
				/* Allowed escaped symbols */
				case '\"': case '/' : case '\\' : case 'b' :
				case 'f' : case 'r' : case 'n'  : case 't' :
					break;
				/* Allows escaped symbol \uXXXX */
				case 'u':
					/* TODO */
					break;
				/* Unexpected symbol */
				default:
					parser->pos = start;
					return JSMN_ERROR_INVAL;
			}
		}
	}
	parser->pos = start;
	return JSMN_ERROR_PART;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movl %ecx, 0x24(%rsp)
movq %r8, 0x18(%rsp)
movq 0x38(%rsp), %rax
movl (%rax), %eax
movl %eax, 0xc(%rsp)
movq 0x38(%rsp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq 0x30(%rsp), %rax
movq 0x38(%rsp), %rcx
movl (%rcx), %ecx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x4a96
movq 0x30(%rsp), %rax
movq 0x38(%rsp), %rcx
movl (%rcx), %ecx
movb (%rax,%rcx), %al
movb %al, 0xb(%rsp)
movsbl 0xb(%rsp), %eax
cmpl $0x22, %eax
jne 0x4a21
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x4890
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x49e2
movl 0xc(%rsp), %ecx
movq 0x38(%rsp), %rax
movl %ecx, (%rax)
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
jmp 0x4aa9
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %edx
addl $0x1, %edx
movq 0x38(%rsp), %rax
movl (%rax), %ecx
movl 0x24(%rsp), %r8d
movl $0x3, %esi
callq 0x4c70
movq 0x38(%rsp), %rax
movl 0x8(%rax), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x18(%rax)
movl $0x0, 0x44(%rsp)
jmp 0x4aa9
movsbl 0xb(%rsp), %eax
cmpl $0x5c, %eax
jne 0x4a83
movq 0x38(%rsp), %rax
movl (%rax), %ecx
incl %ecx
movl %ecx, (%rax)
movq 0x30(%rsp), %rax
movq 0x38(%rsp), %rcx
movl (%rcx), %ecx
movsbl (%rax,%rcx), %eax
addl $-0x22, %eax
movl %eax, %ecx
movq %rcx, (%rsp)
subl $0x53, %eax
ja 0x4a6c
movq (%rsp), %rax
leaq 0x3775(%rip), %rcx      # 0x81d4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x4a81
jmp 0x4a81
movl 0xc(%rsp), %ecx
movq 0x38(%rsp), %rax
movl %ecx, (%rax)
movl $0xfffffffe, 0x44(%rsp) # imm = 0xFFFFFFFE
jmp 0x4aa9
jmp 0x4a83
jmp 0x4a85
movq 0x38(%rsp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x4973
movl 0xc(%rsp), %ecx
movq 0x38(%rsp), %rax
movl %ecx, (%rax)
movl $0xfffffffd, 0x44(%rsp) # imm = 0xFFFFFFFD
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Cotix[P]cReddit/libreddit/jsmn.c
// Function: jsmn_parse_primitive
static jsmnerr_t jsmn_parse_primitive(jsmn_parser *parser, const char *js,
		jsmntok_t *tokens, int on_key, size_t num_tokens) {
	jsmntok_t *token;
	int start;

	start = parser->pos;

	for (; js[parser->pos] != '\0'; parser->pos++) {
		switch (js[parser->pos]) {
#ifndef JSMN_STRICT
			/* In strict mode primitive must be followed by "," or "}" or "]" */
			case ':':
#endif
			case '\t' : case '\r' : case '\n' : case ' ' :
			case ','  : case ']'  : case '}' :
				goto found;
		}
		if (js[parser->pos] < 32 || js[parser->pos] >= 127) {
			parser->pos = start;
			return JSMN_ERROR_INVAL;
		}
	}
#ifdef JSMN_STRICT
	/* In strict mode primitive must be followed by a comma/object/array */
	parser->pos = start;
	return JSMN_ERROR_PART;
#endif

found:
	token = jsmn_alloc_token(parser, tokens, num_tokens);
	if (token == NULL) {
		parser->pos = start;
		return JSMN_ERROR_NOMEM;
	}
	jsmn_fill_token(token, JSMN_PRIMITIVE, start, parser->pos, on_key);
#ifdef JSMN_PARENT_LINKS
	token->parent = parser->toksuper;
#endif
	parser->pos--;
	return JSMN_SUCCESS;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movl %ecx, 0x24(%rsp)
movq %r8, 0x18(%rsp)
movq 0x38(%rsp), %rax
movl (%rax), %eax
movl %eax, 0xc(%rsp)
movq 0x30(%rsp), %rax
movq 0x38(%rsp), %rcx
movl (%rcx), %ecx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x4bac
movq 0x30(%rsp), %rax
movq 0x38(%rsp), %rcx
movl (%rcx), %ecx
movsbl (%rax,%rcx), %eax
movl %eax, 0x8(%rsp)
addl $-0x9, %eax
subl $0x2, %eax
jb 0x4b55
jmp 0x4b1e
movl 0x8(%rsp), %eax
subl $0xd, %eax
je 0x4b55
jmp 0x4b29
movl 0x8(%rsp), %eax
subl $0x20, %eax
je 0x4b55
jmp 0x4b34
movl 0x8(%rsp), %eax
subl $0x2c, %eax
je 0x4b55
jmp 0x4b3f
movl 0x8(%rsp), %eax
subl $0x5d, %eax
je 0x4b55
jmp 0x4b4a
movl 0x8(%rsp), %eax
subl $0x7d, %eax
jne 0x4b57
jmp 0x4b55
jmp 0x4bc1
movq 0x30(%rsp), %rax
movq 0x38(%rsp), %rcx
movl (%rcx), %ecx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
jl 0x4b81
movq 0x30(%rsp), %rax
movq 0x38(%rsp), %rcx
movl (%rcx), %ecx
movsbl (%rax,%rcx), %eax
cmpl $0x7f, %eax
jl 0x4b99
movl 0xc(%rsp), %ecx
movq 0x38(%rsp), %rax
movl %ecx, (%rax)
movl $0xfffffffe, 0x44(%rsp) # imm = 0xFFFFFFFE
jmp 0x4c37
jmp 0x4b9b
movq 0x38(%rsp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x4ae7
movl 0xc(%rsp), %ecx
movq 0x38(%rsp), %rax
movl %ecx, (%rax)
movl $0xfffffffd, 0x44(%rsp) # imm = 0xFFFFFFFD
jmp 0x4c37
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x4890
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x4bf7
movl 0xc(%rsp), %ecx
movq 0x38(%rsp), %rax
movl %ecx, (%rax)
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
jmp 0x4c37
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %edx
movq 0x38(%rsp), %rax
movl (%rax), %ecx
movl 0x24(%rsp), %r8d
xorl %esi, %esi
callq 0x4c70
movq 0x38(%rsp), %rax
movl 0x8(%rax), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x18(%rax)
movq 0x38(%rsp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/Cotix[P]cReddit/libreddit/jsmn.c
// Function: jsmn_fill_token
static void jsmn_fill_token(jsmntok_t *token, jsmntype_t type,
                            int start, int end, int on_key) {
	token->type = type;
	token->start = start;
	token->end = end;
	token->size = 0;
	token->is_key = on_key;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl %edx, -0x10(%rsp)
movl %ecx, -0x14(%rsp)
movl %r8d, -0x18(%rsp)
movl -0xc(%rsp), %ecx
movq -0x8(%rsp), %rax
movl %ecx, (%rax)
movl -0x10(%rsp), %ecx
movq -0x8(%rsp), %rax
movl %ecx, 0x4(%rax)
movl -0x14(%rsp), %ecx
movq -0x8(%rsp), %rax
movl %ecx, 0x8(%rax)
movq -0x8(%rsp), %rax
movl $0x0, 0xc(%rax)
movl -0x18(%rsp), %ecx
movq -0x8(%rsp), %rax
movb %cl, %dl
movb 0x10(%rax), %cl
andb $0x1, %dl
andb $-0x2, %cl
orb %dl, %cl
movb %cl, 0x10(%rax)
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Cotix[P]cReddit/libreddit/link.c
// Function: redditLinkFree
EXPORT_SYMBOL void redditLinkFree (RedditLink *link)
{
    if (link == NULL)
        return ;

    free(link->selftext);
    free(link->title);

    free(link->selftextEsc);
    free(link->titleEsc);

    free(link->wselftextEsc);
    free(link->wtitleEsc);

    free(link->id);
    free(link->permalink);
    free(link->author);
    free(link->url);

    free(link);
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x4d11
jmp 0x4d9c
movq (%rsp), %rax
movq 0x30(%rax), %rdi
callq 0x2040
movq (%rsp), %rax
movq 0x28(%rax), %rdi
callq 0x2040
movq (%rsp), %rax
movq 0x40(%rax), %rdi
callq 0x2040
movq (%rsp), %rax
movq 0x38(%rax), %rdi
callq 0x2040
movq (%rsp), %rax
movq 0x50(%rax), %rdi
callq 0x2040
movq (%rsp), %rax
movq 0x48(%rax), %rdi
callq 0x2040
movq (%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x2040
movq (%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x2040
movq (%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x2040
movq (%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x2040
movq (%rsp), %rdi
callq 0x2040
popq %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Cotix[P]cReddit/libreddit/link.c
// Function: redditLinkListFreeLinks
EXPORT_SYMBOL void redditLinkListFreeLinks (RedditLinkList *list)
{
    int i;
    if (list == NULL)
        return ;
    for (i = 0; i < list->linkCount; i++)
        redditLinkFree(list->links[i]);
    free(list->links);
    list->links = NULL;
    list->linkCount = 0;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x4de3
jmp 0x4e44
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0x14(%rcx), %eax
jge 0x4e1d
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x21b0
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x4deb
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x2040
movq 0x10(%rsp), %rax
movq $0x0, 0x18(%rax)
movq 0x10(%rsp), %rax
movl $0x0, 0x14(%rax)
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Cotix[P]cReddit/libreddit/link.c
// Function: redditLinkListFree
EXPORT_SYMBOL void redditLinkListFree (RedditLinkList *list)
{
    if (list == NULL)
        return ;
    redditLinkListFreeLinks(list);
    free(list->subreddit);
    free(list->modhash);
    free(list->afterId);
    free(list);
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x4e5e
jmp 0x4e96
movq (%rsp), %rdi
callq 0x2060
movq (%rsp), %rax
movq (%rax), %rdi
callq 0x2040
movq (%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x2040
movq (%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x2040
movq (%rsp), %rdi
callq 0x2040
popq %rax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Cotix[P]cReddit/libreddit/link.c
// Function: getListingHelper
DEF_TOKEN_CALLBACK(getListingHelper)
{
    ARG_LIST_GET_LISTING


    /* Search for the 'kind' ident, and check if it was set to 't3' */
    int i;
    for (i = 0; idents[i].name != NULL; i++)
        if (strcmp(idents[i].name, "kind") == 0)
            if (idents[i].value != NULL && strcmp(*((char**)idents[i].value), "t3") == 0)
                redditLinkListAddLink(list, redditGetLink(parser));

}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movl (%rax), %eax
movl %eax, 0x20(%rsp)
cmpl $0x28, %eax
ja 0x5b34
movq 0x18(%rsp), %rcx
movl 0x20(%rsp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, 0x10(%rsp)
jmp 0x5b4d
movq 0x18(%rsp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
movq 0x38(%rsp), %rax
movslq 0x24(%rsp), %rcx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
je 0x5c18
movq 0x38(%rsp), %rax
movslq 0x24(%rsp), %rcx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rdi
leaq 0x2816(%rip), %rsi      # 0x83ae
callq 0x2160
cmpl $0x0, %eax
jne 0x5c06
movq 0x38(%rsp), %rax
movslq 0x24(%rsp), %rcx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, 0x10(%rax)
je 0x5c04
movq 0x38(%rsp), %rax
movslq 0x24(%rsp), %rcx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movq (%rax), %rdi
leaq 0x285f(%rip), %rsi      # 0x8438
callq 0x2160
cmpl $0x0, %eax
jne 0x5c04
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rdi
callq 0x4f10
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x2270
jmp 0x5c06
jmp 0x5c08
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x5b62
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Cotix[P]cReddit/libreddit/state.c
// Function: redditStateNew
EXPORT_SYMBOL RedditState *redditStateNew()
{
    RedditState *state;
    state = rmalloc(sizeof(RedditState));
    state->base = NULL;
    state->userAgent = NULL;

    return state;
}

// Assembly:
pushq %rax
movl $0x10, %edi
callq 0x43a0
movq %rax, (%rsp)
movq (%rsp), %rax
movq $0x0, (%rax)
movq (%rsp), %rax
movq $0x0, 0x8(%rax)
movq (%rsp), %rax
popq %rcx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Cotix[P]cReddit/libreddit/state.c
// Function: redditStateFree
EXPORT_SYMBOL void redditStateFree(RedditState *state)
{
    if (state == NULL)
        return ;
    /* First free the linked-list of cookies */
    RedditCookieLink *tmp;
    RedditCookieLink *node;
    for(node = state->base; node != NULL; node = tmp) {
        tmp = node->next;
        redditCookieFree(node);
    }

    free(state->userAgent);

    /* Free the actual state */
    free(state);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x5c63
jmp 0x5cae
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x5c96
movq (%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq (%rsp), %rdi
callq 0x2150
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
jmp 0x5c6f
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x2040
movq 0x10(%rsp), %rdi
callq 0x2040
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Cotix[P]cReddit/libreddit/token.c
// Function: memoryBlockNew
MemoryBlock *memoryBlockNew()
{
    MemoryBlock *block = rmalloc(sizeof(MemoryBlock));
    block->memory = rmalloc(1);
    block->memory[0] = 0;
    block->size   = 0;
    return block;
}

// Assembly:
pushq %rax
movl $0x10, %edi
callq 0x43a0
movq %rax, (%rsp)
movl $0x1, %edi
callq 0x43a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movq (%rsp), %rax
movq (%rax), %rax
movb $0x0, (%rax)
movq (%rsp), %rax
movq $0x0, 0x8(%rax)
movq (%rsp), %rax
popq %rcx
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Cotix[P]cReddit/libreddit/token.c
// Function: memoryBlockFree
void memoryBlockFree(MemoryBlock *block)
{
    if (block == NULL)
        return ;
    free(block->memory);
    free(block);
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x5d3e
jmp 0x5d53
movq (%rsp), %rax
movq (%rax), %rdi
callq 0x2040
movq (%rsp), %rdi
callq 0x2040
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Cotix[P]cReddit/libreddit/token.c
// Function: tokenParserNew
TokenParser *tokenParserNew()
{
    TokenParser *parser = rmalloc(sizeof(TokenParser));
    memset(parser, 0, sizeof(TokenParser));
    parser->block = memoryBlockNew();
    return parser;
}

// Assembly:
pushq %rax
movl $0x18, %edi
callq 0x43a0
movq %rax, (%rsp)
movq (%rsp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x2100
callq 0x5cf0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movq (%rsp), %rax
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Cotix[P]cReddit/libreddit/token.c
// Function: tokenParserFree
void tokenParserFree(TokenParser *parser)
{
    if (parser == NULL)
        return ;
    memoryBlockFree(parser->block);
    free(parser->tokens);
    free(parser);
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x5dae
jmp 0x5dd0
movq (%rsp), %rax
movq (%rax), %rdi
callq 0x5d30
movq (%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x2040
movq (%rsp), %rdi
callq 0x2040
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Cotix[P]cReddit/libreddit/token.c
// Function: getCopyOfToken
char *getCopyOfToken(const char *json, jsmntok_t token)
{
    char *copy;
    if (token.end - token.start + 1 < 1)
        return NULL;

    copy = rmalloc(token.end - token.start + 1);
    memcpy(copy, json + token.start, token.end - token.start);
    copy[token.end - token.start] = 0;
    return copy;
}

// Assembly:
subq $0x28, %rsp
leaq 0x30(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movq %rdi, 0x18(%rsp)
movl 0x8(%rcx), %eax
subl 0x4(%rcx), %eax
addl $0x1, %eax
cmpl $0x1, %eax
jge 0x5e0c
movq $0x0, 0x20(%rsp)
jmp 0x5e6c
movq 0x8(%rsp), %rcx
movl 0x8(%rcx), %eax
subl 0x4(%rcx), %eax
addl $0x1, %eax
movslq %eax, %rdi
callq 0x43a0
movq 0x8(%rsp), %rcx
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movslq 0x4(%rcx), %rax
addq %rax, %rsi
movl 0x8(%rcx), %eax
subl 0x4(%rcx), %eax
movslq %eax, %rdx
callq 0x2180
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rax
movl 0x8(%rdx), %ecx
subl 0x4(%rdx), %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Cotix[P]cReddit/libreddit/token.c
// Function: trueFalseString
char *trueFalseString(char *string, bool tf)
{
    if (tf)
        strcpy(string, "true");
    else
        strcpy(string, "false");

    return string;
}

// Assembly:
subq $0x18, %rsp
movb %sil, %al
movq %rdi, 0x10(%rsp)
andb $0x1, %al
movb %al, 0xf(%rsp)
testb $0x1, 0xf(%rsp)
je 0x5eac
movq 0x10(%rsp), %rdi
leaq 0x262a(%rip), %rsi      # 0x84cf
callq 0x2070
jmp 0x5ebd
movq 0x10(%rsp), %rdi
leaq 0x261c(%rip), %rsi      # 0x84d4
callq 0x2070
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Cotix[P]cReddit/libreddit/token.c
// Function: vparseTokens
void vparseTokens (TokenParser *p, TokenIdent *identifiers, va_list args)
{
    int tokenCount = 0, i;
    int identCount = 0;

    while (identifiers[identCount].name != NULL)
        identCount++;

    if (identCount == 0)
        return ;

    tokenCount = p->tokens[p->currentToken].full_size;
    if (tokenCount == 0)
        return ;

    tokenCount += p->currentToken;

    for (; p->currentToken < tokenCount; (p->currentToken)++) {
        if (p->tokens[p->currentToken].type == JSMN_OBJECT || p->tokens[p->currentToken].type == JSMN_ARRAY)
            continue;

        /* We only need to check key values */
        if (!p->tokens[p->currentToken].is_key)
            continue;

        for (i = 0; i < identCount; i++)
            if (performIdentAction(p, identifiers, i, args)) {
                (p->currentToken)--;
                break;
            }

    }

    return ;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl $0x0, 0x4(%rsp)
movq 0x18(%rsp), %rax
movslq 0x4(%rsp), %rcx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
je 0x6887
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x6863
cmpl $0x0, 0x4(%rsp)
jne 0x6893
jmp 0x69ac
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x20(%rsp), %rcx
movslq 0x14(%rcx), %rcx
imulq $0x1c, %rcx, %rcx
addq %rcx, %rax
movl 0x14(%rax), %eax
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jne 0x68bf
jmp 0x69ac
movq 0x20(%rsp), %rax
movl 0x14(%rax), %eax
addl 0xc(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rax
movl 0x14(%rax), %eax
cmpl 0xc(%rsp), %eax
jge 0x69aa
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x20(%rsp), %rcx
movslq 0x14(%rcx), %rcx
imulq $0x1c, %rcx, %rcx
addq %rcx, %rax
cmpl $0x1, (%rax)
je 0x691d
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x20(%rsp), %rcx
movslq 0x14(%rcx), %rcx
imulq $0x1c, %rcx, %rcx
addq %rcx, %rax
cmpl $0x2, (%rax)
jne 0x691f
jmp 0x6997
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x20(%rsp), %rcx
movslq 0x14(%rcx), %rcx
imulq $0x1c, %rcx, %rcx
addq %rcx, %rax
movb 0x10(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x6947
jmp 0x6997
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0x4(%rsp), %eax
jge 0x6995
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl 0x8(%rsp), %edx
movq 0x10(%rsp), %rcx
callq 0x5f10
cmpl $0x0, %eax
je 0x6986
movq 0x20(%rsp), %rax
movl 0x14(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x14(%rax)
jmp 0x6995
jmp 0x6988
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x694f
jmp 0x6997
movq 0x20(%rsp), %rax
movl 0x14(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x14(%rax)
jmp 0x68cf
jmp 0x69ac
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Cotix[P]cReddit/libreddit/token.c
// Function: writeToParser
static size_t writeToParser(void *contents, size_t size, size_t nmemb, void *userp)
{
    size_t realsize = size * nmemb;
    TokenParser *parser = (TokenParser*)userp;

    parser->block->memory = rrealloc(parser->block->memory, parser->block->size + realsize + 1);

    memcpy(parser->block->memory + parser->block->size, contents, realsize);
    parser->block->size += realsize;
    parser->block->memory[parser->block->size] = 0;

    return realsize;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x28(%rsp), %rax
imulq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rsi
addq 0x10(%rsp), %rsi
addq $0x1, %rsi
callq 0x43e0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rax
addq 0x8(%rax), %rdi
movq 0x30(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x2180
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq (%rax), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq 0x8(%rsp), %rcx
movq (%rcx), %rcx
movq 0x8(%rcx), %rcx
movb $0x0, (%rax,%rcx)
movq 0x10(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Cotix[P]cReddit/libreddit/token.c
// Function: tokenParserCreateTokens
static jsmnerr_t tokenParserCreateTokens(TokenParser *parser)
{
    jsmn_parser jsmnParser;
    jsmnerr_t result;
    const int chunk_size = 100;

    if (parser->tokens == NULL) {
        parser->tokens = rmalloc(chunk_size * sizeof(jsmntok_t));
        parser->tokenCount = chunk_size;
    }

    memset(parser->tokens, 0, parser->tokenCount * sizeof(jsmntok_t));
    jsmn_init(&jsmnParser);

    while ((result = jsmn_parse(&jsmnParser, parser->block->memory, parser->tokens, parser->tokenCount)) == JSMN_ERROR_NOMEM) {
        parser->tokenCount += chunk_size;
        parser->tokens = rrealloc(parser->tokens, parser->tokenCount * sizeof(jsmntok_t));
        memset(parser->tokens + parser->tokenCount - chunk_size, 0, chunk_size * sizeof(jsmntok_t));
    }

    if (result != JSMN_SUCCESS)
        parser->tokenCount = 0;
    else
        parser->tokenCount = jsmnParser.toknext - 1;

    return result;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl $0x64, 0xc(%rsp)
movq 0x20(%rsp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x6ddf
movl $0xaf0, %edi            # imm = 0xAF0
callq 0x43a0
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x20(%rsp), %rax
movl $0x64, 0x10(%rax)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x20(%rsp), %rax
movslq 0x10(%rax), %rax
imulq $0x1c, %rax, %rdx
xorl %esi, %esi
callq 0x2100
leaq 0x14(%rsp), %rdi
callq 0x4c40
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rsi
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rdx
movq 0x20(%rsp), %rax
movl 0x10(%rax), %ecx
leaq 0x14(%rsp), %rdi
callq 0x4440
movl %eax, 0x10(%rsp)
cmpl $-0x1, %eax
jne 0x6e9b
movq 0x20(%rsp), %rax
movl 0x10(%rax), %ecx
addl $0x64, %ecx
movl %ecx, 0x10(%rax)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x20(%rsp), %rax
movslq 0x10(%rax), %rax
imulq $0x1c, %rax, %rsi
callq 0x43e0
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x20(%rsp), %rax
movslq 0x10(%rax), %rax
imulq $0x1c, %rax, %rax
addq %rax, %rdi
addq $-0xaf0, %rdi           # imm = 0xF510
xorl %esi, %esi
movl $0xaf0, %edx            # imm = 0xAF0
callq 0x2100
jmp 0x6e06
cmpl $0x0, 0x10(%rsp)
je 0x6eb0
movq 0x20(%rsp), %rax
movl $0x0, 0x10(%rax)
jmp 0x6ebf
movl 0x18(%rsp), %ecx
subl $0x1, %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x10(%rax)
movl 0x10(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Cotix[P]cReddit/libreddit/token.c
// Function: redditParseEscCodesGeneric
static void *redditParseEscCodesGeneric (const void *text, int len, int wide)
{
    struct charParser parser;

    if (len == 0)
        return NULL;

    parser.wide = wide;
    parser.text = text;
    parser.cur = 0;
    parser.offset = 0;

    if (wide)
        parser.new_text = rmalloc((len + 1) * sizeof(wchar_t));
    else
        parser.new_text = rmalloc((len + 1) * sizeof(char));

    for (parser.cur = 0; parser.cur < len; parser.cur++)
        parseChar(&parser);

    if (wide)
        ((wchar_t*)(parser.new_text))[parser.offset] = L'\0';
    else
        ((char*)(parser.new_text))[parser.offset] = '\0';

    return parser.new_text;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movl %edx, 0x20(%rsp)
cmpl $0x0, 0x24(%rsp)
jne 0x6fc6
movq $0x0, 0x30(%rsp)
jmp 0x7079
movl 0x20(%rsp), %eax
movl %eax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movl $0x0, 0x8(%rsp)
movl $0x0, 0xc(%rsp)
cmpl $0x0, 0x20(%rsp)
je 0x7008
movl 0x24(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x2, %rdi
callq 0x43a0
movq %rax, 0x18(%rsp)
jmp 0x7020
movl 0x24(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x0, %rdi
callq 0x43a0
movq %rax, 0x18(%rsp)
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0x24(%rsp), %eax
jge 0x7047
movq %rsp, %rdi
callq 0x7090
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x7028
cmpl $0x0, 0x20(%rsp)
je 0x7061
movq 0x18(%rsp), %rax
movslq 0xc(%rsp), %rcx
movl $0x0, (%rax,%rcx,4)
jmp 0x706f
movq 0x18(%rsp), %rax
movslq 0xc(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Cotix[P]cReddit/libreddit/user.c
// Function: redditUserNew
EXPORT_SYMBOL RedditUser *redditUserNew()
{
    RedditUser *log = rmalloc(sizeof(RedditUser));

    memset(log, 0, sizeof(RedditUser));
    log->commentKarma = -1;
    log->linkKarma    = -1;

    return log;
}

// Assembly:
pushq %rax
movl $0x28, %edi
callq 0x43a0
movq %rax, (%rsp)
movq (%rsp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x2100
movq (%rsp), %rax
movl $0xffffffff, 0x18(%rax) # imm = 0xFFFFFFFF
movq (%rsp), %rax
movl $0xffffffff, 0x1c(%rax) # imm = 0xFFFFFFFF
movq (%rsp), %rax
popq %rcx
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Cotix[P]cReddit/libreddit/user.c
// Function: redditUserFree
EXPORT_SYMBOL void redditUserFree (RedditUser *log)
{
    if (log == NULL)
        return ;
    free(log->name);
    free(log->id);
    free(log->modhash);
    free(log);
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x734e
jmp 0x737d
movq (%rsp), %rax
movq (%rax), %rdi
callq 0x2040
movq (%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x2040
movq (%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x2040
movq (%rsp), %rdi
callq 0x2040
popq %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Cotix[P]cReddit/libreddit/user.c
// Function: redditUserLoggedNew
EXPORT_SYMBOL RedditUserLogged *redditUserLoggedNew()
{
    RedditUserLogged *user = rmalloc(sizeof(RedditUserLogged));

    user->userInfo     = redditUserNew();
    user->stayLoggedOn = false;
    user->userState    = REDDIT_USER_OFFLINE;

    return user;
}

// Assembly:
pushq %rax
movl $0x10, %edi
callq 0x43a0
movq %rax, (%rsp)
callq 0x20b0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movq (%rsp), %rax
movb $0x0, 0x4(%rax)
movq (%rsp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movq (%rsp), %rax
popq %rcx
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Cotix[P]cReddit/libreddit/user.c
// Function: redditUserLoggedFree
EXPORT_SYMBOL void redditUserLoggedFree(RedditUserLogged *user)
{
    if (user == NULL)
        return ;
    redditUserFree(user->userInfo);
    free(user);
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x73ce
jmp 0x73e4
movq (%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x2090
movq (%rsp), %rdi
callq 0x2040
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Cotix[P]cReddit/libreddit/user.c
// Function: redditUserLoggedLogin
EXPORT_SYMBOL RedditErrno redditUserLoggedLogin (RedditUserLogged *log, char *name, char *passwd)
{
    char loginInfo[4096];
    char tf[6];
    RedditErrno response = REDDIT_SUCCESS;

    TokenParserResult res;

    TokenIdent ids[] = {
        ADD_TOKEN_IDENT_FUNC("errors", handleErrorArray),
        ADD_TOKEN_IDENT_FUNC("cookie", handleCookie),
        {0}
    };

    /* If passwd or user isn't set then just exit */
    if (!(passwd) || !(name))
        return REDDIT_ERROR_USER;

    /* Remove any session cookie we may still have -- We'll get a new one after login
     * If you want to handle multiple-users logged on, make sure to switch out the global
     * state */
    redditRemoveCookie("reddit_session");

    sprintf(loginInfo, "api_type=json&rem=%s&user=%s&passwd=%s", trueFalseString(tf, log->stayLoggedOn), name, passwd);


    res = redditRunParser(REDDIT_API_LOGIN, loginInfo, ids, &response);

    if (res != TOKEN_PARSER_SUCCESS)
        response = REDDIT_ERROR_RESPONSE;

    if (response == REDDIT_SUCCESS)
        log->userState = REDDIT_USER_LOGGED_ON;
    else
        log->userState = REDDIT_USER_OFFLINE;

    return response;
}

// Assembly:
subq $0x10f8, %rsp           # imm = 0x10F8
movq %rdi, 0x10e8(%rsp)
movq %rsi, 0x10e0(%rsp)
movq %rdx, 0x10d8(%rsp)
movl $0x0, 0xc4(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x345a(%rip), %rsi      # 0xad60
movl $0xa8, %edx
callq 0x2180
cmpq $0x0, 0x10d8(%rsp)
je 0x7926
cmpq $0x0, 0x10e0(%rsp)
jne 0x7936
movl $0x4, 0x10f4(%rsp)
jmp 0x7a07
leaq 0xc31(%rip), %rdi       # 0x856e
callq 0x21c0
leaq 0xd0(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0xca(%rsp), %rdi
movq 0x10e8(%rsp), %rax
movb 0x4(%rax), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x5e80
movq 0x8(%rsp), %rdi
movq %rax, %rdx
movq 0x10e0(%rsp), %rcx
movq 0x10d8(%rsp), %r8
leaq 0xbf2(%rip), %rsi       # 0x857d
movb $0x0, %al
callq 0x2290
leaq 0xd0(%rsp), %rsi
leaq 0x10(%rsp), %rdx
leaq 0xbfe(%rip), %rdi       # 0x85a4
leaq 0xc4(%rsp), %rcx
movb $0x0, %al
callq 0x6ed0
movl %eax, 0xc0(%rsp)
cmpl $0x0, 0xc0(%rsp)
je 0x79d1
movl $0x2, 0xc4(%rsp)
cmpl $0x0, 0xc4(%rsp)
jne 0x79eb
movq 0x10e8(%rsp), %rax
movl $0x0, (%rax)
jmp 0x79f9
movq 0x10e8(%rsp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movl 0xc4(%rsp), %eax
movl %eax, 0x10f4(%rsp)
movl 0x10f4(%rsp), %eax
addq $0x10f8, %rsp           # imm = 0x10F8
retq
nopw %cs:(%rax,%rax)