LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/Cotix[P]cReddit/libreddit/comment.c
// Function: getMoreChildren
DEF_TOKEN_CALLBACK(getMoreChildren)
{
    ARG_MORECHILDREN
    char *kind = NULL;
    int arry_size = parser->tokens[parser->currentToken].size;
    int i = 0;

    TokenIdent ids[] = {
        ADD_TOKEN_IDENT_STRING("kind", kind), /* Note -- Keep this key first in
                                                 the array, or change the
                                                 number in readChild */
        ADD_TOKEN_IDENT_FUNC("data", readChild),
        {0}
    };

    parser->currentToken++;
    for (; i < arry_size; i++) {
        int nextObj = parser->currentToken + parser->tokens[parser->currentToken].full_size + 1;
        parseTokens(parser, ids, list, parent);
        free(kind);
        kind = NULL;
        parser->currentToken = nextObj;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdi, %rbx
movl (%rdx), %ecx
cmpq $0x29, %rcx
jae 0x2e3d
movq 0x10(%rdx), %rsi
movq %rcx, %rax
addq $0x8, %rax
movl %eax, (%rdx)
movq (%rsi,%rcx), %r14
cmpl $0x20, %ecx
ja 0x2e4c
addq 0x10(%rdx), %rax
addl $0x10, %ecx
movl %ecx, (%rdx)
jmp 0x2e58
movq 0x8(%rdx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rdx)
movq (%rax), %r14
movq 0x8(%rdx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rdx)
movq (%rax), %r15
xorl %eax, %eax
leaq 0x8(%rsp), %rcx
movq %rax, (%rcx)
movq 0x8(%rbx), %rdx
movslq 0x14(%rbx), %rsi
leaq (%rsi,%rsi,8), %rdi
leaq (%rdi,%rdi,2), %rdi
addq %rsi, %rdi
movl 0xc(%rdx,%rdi), %ebp
leaq 0x3283(%rip), %rdx      # 0x6106
movq %rdx, 0x10(%rsp)
movq $0x2, 0x18(%rsp)
movq %rcx, 0x20(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rsp)
movl $0x0, 0x38(%rsp)
movb $0x1, 0x3c(%rsp)
movq %rax, 0x40(%rsp)
leaq 0x3254(%rip), %rcx      # 0x610b
movq %rcx, 0x48(%rsp)
movabsq $0x200000003, %rcx      # imm = 0x200000003
movq %rcx, 0x50(%rsp)
movups %xmm0, 0x58(%rsp)
movups %xmm0, 0x65(%rsp)
leaq 0x17b(%rip), %rcx       # 0x3057
movq %rcx, 0x78(%rsp)
movaps %xmm0, 0x80(%rsp)
movaps %xmm0, 0x90(%rsp)
movaps %xmm0, 0xa0(%rsp)
movq %rax, 0xb0(%rsp)
leal 0x1(%rsi), %r13d
movl %r13d, 0x14(%rbx)
testl %ebp, %ebp
jle 0x2f5d
leaq 0x10(%rsp), %r12
movq 0x8(%rbx), %rax
movslq %r13d, %rcx
leaq (%rcx,%rcx,8), %rdx
leaq (%rdx,%rdx,2), %rdx
addq %rcx, %rdx
movl 0x14(%rax,%rdx), %eax
leal (%rcx,%rax), %r13d
incl %r13d
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x495b
movq 0x8(%rsp), %rdi
callq 0x2040
movq $0x0, 0x8(%rsp)
movl %r13d, 0x14(%rbx)
decl %ebp
jne 0x2f12
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x23df
movq 0x8(%r14), %rax
movslq 0x14(%r14), %rcx
leaq (%rcx,%rcx,8), %rdx
leaq (%rdx,%rdx,2), %rdx
addq %rcx, %rdx
movslq 0x14(%rax,%rdx), %rdi
movl %edi, 0x60(%rbx)
shlq $0x3, %rdi
callq 0x3520
movq %rax, 0x70(%rbx)
cmpl $0x0, 0x60(%rbx)
jle 0x304d
xorl %r15d, %r15d
movslq 0x14(%r14), %rax
leaq 0x1(%rax), %rcx
movl %ecx, 0x14(%r14)
movq (%r14), %rdx
movq 0x8(%r14), %rsi
movq (%rdx), %rdi
leaq (%rcx,%rcx,8), %rcx
leaq (%rcx,%rcx,2), %rcx
leaq 0x1(%rax,%rcx), %rax
movups (%rsi,%rax), %xmm0
movups 0xc(%rsi,%rax), %xmm1
movups %xmm1, 0x2c(%rsp)
movaps %xmm0, 0x20(%rsp)
movups 0x2c(%rsp), %xmm0
movups %xmm0, 0xc(%rsp)
movaps 0x20(%rsp), %xmm0
movups %xmm0, (%rsp)
callq 0x4406
movq 0x70(%rbx), %rcx
movq %rax, (%rcx,%r15,8)
incq %r15
movslq 0x60(%rbx), %rax
cmpq %rax, %r15
jl 0x2feb
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/Cotix[P]cReddit/libreddit/comment.c
// Function: readChild
DEF_TOKEN_CALLBACK(readChild)
{
    ARG_MORECHILDREN

    struct MoreChildren child = {0};
    RedditComment *comment, *foundParent;

    TokenIdent ids[] = {
        ADD_TOKEN_IDENT_STRING("parent_id",child.parent),
        ADD_TOKEN_IDENT_INT   ("count",    child.count),
        ADD_TOKEN_IDENT_FUNC  ("children", readMore),
        {0}
    };

    /* Note: Requires 'kind' to be the first key in the ids array */
    if (strcmp(*((char**)idents[0].value), "more") == 0) {
        parseTokens(parser, ids, parent, &child);
        free(child.parent);
    } else {
        comment = redditGetComment(parser, list);

        foundParent = redditCommentFindParent(parent, comment->parentId);
        if (foundParent == NULL)
            free(foundParent);
        else
            redditCommentAddReply(foundParent, comment);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xf0, %rsp
movq %rdi, %rbx
movl (%rdx), %ecx
cmpq $0x29, %rcx
jae 0x308f
movq 0x10(%rdx), %rdi
movq %rcx, %rax
addq $0x8, %rax
movl %eax, (%rdx)
movq (%rdi,%rcx), %r14
cmpl $0x20, %ecx
ja 0x309e
addq 0x10(%rdx), %rax
addl $0x10, %ecx
movl %ecx, (%rdx)
jmp 0x30aa
movq 0x8(%rdx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rdx)
movq (%rax), %r14
movq 0x8(%rdx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rdx)
movq (%rax), %r15
xorps %xmm0, %xmm0
movq %rsp, %rax
movaps %xmm0, (%rax)
leaq 0x2ffb(%rip), %rcx      # 0x60b8
movq %rcx, 0x10(%rsp)
movq $0x2, 0x18(%rsp)
movq %rax, 0x20(%rsp)
movups %xmm0, 0x28(%rsp)
movl $0x0, 0x38(%rsp)
movb $0x1, 0x3c(%rsp)
xorl %eax, %eax
movq %rax, 0x40(%rsp)
leaq 0x308f(%rip), %rcx      # 0x617f
movq %rcx, 0x48(%rsp)
movq $0x1, 0x50(%rsp)
leaq 0x8(%rsp), %rcx
movq %rcx, 0x58(%rsp)
movq %rax, 0x78(%rsp)
movaps %xmm0, 0x60(%rsp)
movq %rax, 0x6d(%rsp)
leaq 0x3067(%rip), %rcx      # 0x6185
movq %rcx, 0x80(%rsp)
movabsq $0x200000003, %rcx      # imm = 0x200000003
movq %rcx, 0x88(%rsp)
movaps %xmm0, 0x90(%rsp)
movups %xmm0, 0x9d(%rsp)
leaq 0x98(%rip), %rcx        # 0x31e7
movq %rcx, 0xb0(%rsp)
movq %rax, 0xe8(%rsp)
movups %xmm0, 0xd8(%rsp)
movups %xmm0, 0xc8(%rsp)
movups %xmm0, 0xb8(%rsp)
movq 0x10(%rsi), %rax
movq (%rax), %rdi
leaq 0x3009(%rip), %rsi      # 0x618e
callq 0x2120
testl %eax, %eax
je 0x31ba
movq %rbx, %rdi
movq %r14, %rsi
callq 0x24cc
movq %rax, %rbx
movq 0x28(%rax), %rsi
movq %r15, %rdi
callq 0x327d
testq %rax, %rax
je 0x31da
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2150
jmp 0x31da
leaq 0x10(%rsp), %rsi
movq %rsp, %r14
movq %rbx, %rdi
movq %r15, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x495b
movq (%r14), %rdi
callq 0x2040
addq $0xf0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl (%rdx), %ecx
cmpq $0x29, %rcx
jae 0x3218
movq 0x10(%rdx), %rsi
movq %rcx, %rax
addq $0x8, %rax
movl %eax, (%rdx)
movq (%rsi,%rcx), %rdi
cmpl $0x20, %ecx
ja 0x3227
addq 0x10(%rdx), %rax
addl $0x10, %ecx
movl %ecx, (%rdx)
jmp 0x3233
movq 0x8(%rdx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rdx)
movq (%rax), %rdi
movq 0x8(%rdx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rdx)
movq (%rax), %r15
movq (%r15), %rsi
callq 0x327d
testq %rax, %rax
je 0x325b
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2fa3
movl 0x8(%r15), %eax
movl %eax, 0x5c(%r14)
jmp 0x3277
movq 0x8(%rbx), %rax
movslq 0x14(%rbx), %rcx
leaq (%rcx,%rcx,8), %rdx
leaq (%rdx,%rdx,2), %rdx
addq %rcx, %rdx
movl 0x14(%rax,%rdx), %eax
addl %ecx, %eax
movl %eax, 0x14(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movl $0x320, %edi            # imm = 0x320
callq 0x3520
xorl %ecx, %ecx
cmpb $0x5f, 0x2(%r14)
movq %rax, %rbx
sete %cl
leaq (%rcx,%rcx,2), %rsi
addq %r14, %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0x2070
movq %r15, (%rbx)
movl $0x64, %ebp
xorl %r12d, %r12d
movl %r12d, %r13d
movq (%rbx,%r13,8), %r15
movq 0x18(%r15), %rsi
movq %r14, %rdi
callq 0x2120
testl %eax, %eax
je 0x3338
movl (%r15), %eax
testl %eax, %eax
jle 0x3328
leal (%rax,%r12), %ecx
cmpl %ebp, %ecx
jl 0x3311
movl %ebp, %ecx
movq %r14, %rbp
movl %eax, %r14d
addl %ecx, %r14d
leaq (,%r14,8), %rsi
movq %rbx, %rdi
callq 0x21a0
movq %rax, %rbx
movl (%r15), %eax
movl %r14d, %ecx
movq %rbp, %r14
movl %ecx, %ebp
leaq (%rbx,%r13,8), %rdi
movq 0x8(%r15), %rsi
movslq %eax, %rdx
shlq $0x3, %rdx
callq 0x2140
addl (%r15), %r12d
leal -0x1(%r12), %eax
testl %r12d, %r12d
movl %eax, %r12d
jg 0x32c2
xorl %r15d, %r15d
movq %rbx, %rdi
callq 0x2040
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x18, %edi
callq 0x3520
movq %rax, %rbx
movq %r15, %rdi
callq 0x20b0
leaq 0x1(%rax), %rdi
callq 0x3520
movq %rax, 0x8(%rbx)
movq %r14, %rdi
callq 0x20b0
leaq 0x1(%rax), %rdi
callq 0x3520
movq %rax, 0x10(%rbx)
movq 0x8(%rbx), %rdi
movq %r15, %rsi
callq 0x2070
movq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0x2070
leaq 0x5d83(%rip), %r14      # 0x9138
movq (%r14), %rax
testq %rax, %rax
jne 0x33c7
xorl %eax, %eax
callq 0x21f0
movq %rax, (%r14)
movq (%rax), %rax
movq %rax, (%rbx)
movq (%r14), %rax
movq %rbx, (%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rdi, %rdi
je 0x33fd
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x2040
movq 0x10(%rbx), %rdi
callq 0x2040
movq %rbx, %rdi
popq %rbx
jmp 0x2040
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0x5d2b(%rip), %rax      # 0x9138
movq (%rax), %r15
testq %r15, %r15
je 0x345c
movq %rdi, %rbx
xorl %r14d, %r14d
movq %r15, %rcx
movq %r14, %r12
movq (%rcx), %r14
testq %r14, %r14
je 0x345c
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0x2120
movq %r14, %rcx
testl %eax, %eax
jne 0x341e
testq %r12, %r12
movq (%r14), %rax
cmovneq %r12, %r15
movq %rax, (%r15)
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2110
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
leaq 0x5cc0(%rip), %r15      # 0x9138
movq (%r15), %rax
testq %rax, %rax
je 0x350e
movq (%rax), %r12
xorl %r13d, %r13d
testq %r12, %r12
je 0x350e
xorl %ebx, %ebx
movq 0x8(%r12), %rdi
callq 0x20b0
movq %rax, %r14
movq 0x10(%r12), %rdi
callq 0x20b0
addl %r14d, %eax
addl %eax, %r13d
addl $0x2, %r13d
movslq %r13d, %rsi
movq %rbx, %rdi
callq 0x3537
movq %rax, %rbx
movq (%r15), %rax
cmpq (%rax), %r12
je 0x34d8
movq %rbx, %rdi
callq 0x20b0
movw $0x26, (%rbx,%rax)
jmp 0x34db
movb $0x0, (%rbx)
movq 0x8(%r12), %rsi
movq %rbx, %rdi
callq 0x2220
movq %rbx, %rdi
callq 0x20b0
movw $0x3d, (%rbx,%rax)
movq 0x10(%r12), %rsi
movq %rbx, %rdi
callq 0x2220
movq (%r12), %r12
testq %r12, %r12
jne 0x3491
jmp 0x3510
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rax
callq 0x2160
testq %rax, %rax
je 0x352d
popq %rcx
retq
movl $0x1, %edi
callq 0x2240
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rax
callq 0x21a0
testq %rax, %rax
je 0x3544
popq %rcx
retq
movl $0x1, %edi
callq 0x2240
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rdi, %rdi
je 0x3a1f
pushq %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x2040
movq 0x28(%rbx), %rdi
callq 0x2040
movq 0x40(%rbx), %rdi
callq 0x2040
movq 0x38(%rbx), %rdi
callq 0x2040
movq 0x50(%rbx), %rdi
callq 0x2040
movq 0x48(%rbx), %rdi
callq 0x2040
movq 0x8(%rbx), %rdi
callq 0x2040
movq 0x10(%rbx), %rdi
callq 0x2040
movq 0x18(%rbx), %rdi
callq 0x2040
movq 0x20(%rbx), %rdi
callq 0x2040
movq %rbx, %rdi
popq %rbx
jmp 0x2040
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rdi, %rdi
je 0x3a8c
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x14(%rdi)
jle 0x3a6d
xorl %r14d, %r14d
movq 0x18(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x2170
incq %r14
movslq 0x14(%rbx), %rax
cmpq %rax, %r14
jl 0x3a54
movq 0x18(%rbx), %rdi
callq 0x2040
movq $0x0, 0x18(%rbx)
movl $0x0, 0x14(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rdi, %rdi
je 0x3abe
pushq %rbx
movq %rdi, %rbx
callq 0x2060
movq (%rbx), %rdi
callq 0x2040
movq 0x8(%rbx), %rdi
callq 0x2040
movq 0x20(%rbx), %rdi
callq 0x2040
movq %rbx, %rdi
popq %rbx
jmp 0x2040
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdx), %ecx
cmpq $0x28, %rcx
ja 0x424b
movq %rcx, %rax
addq 0x10(%rdx), %rax
addl $0x8, %ecx
movl %ecx, (%rdx)
jmp 0x4257
movq 0x8(%rdx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rdx)
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x42db
movq (%rax), %r13
addq $0x38, %rbx
leaq 0x1e99(%rip), %r15      # 0x6106
movq %r15, %rsi
callq 0x2120
testl %eax, %eax
je 0x4287
movq (%rbx), %rdi
addq $0x38, %rbx
testq %rdi, %rdi
jne 0x426d
jmp 0x42db
movq -0x28(%rbx), %rax
testq %rax, %rax
je 0x4279
movq (%rax), %rax
cmpb $0x74, (%rax)
jne 0x4279
cmpb $0x33, 0x1(%rax)
jne 0x4279
cmpb $0x0, 0x2(%rax)
jne 0x4279
movq %r14, %rdi
callq 0x3afa
movq %rax, %r12
movslq 0x14(%r13), %rax
leaq 0x1(%rax), %rcx
movl %ecx, 0x14(%r13)
movq 0x18(%r13), %rdi
leaq 0x8(,%rax,8), %rsi
callq 0x3537
movq %rax, 0x18(%r13)
movslq 0x14(%r13), %rcx
movq %r12, -0x8(%rax,%rcx,8)
jmp 0x4279
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rdi, %rdi
je 0x4337
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x431f
movq (%rdi), %r14
callq 0x2110
movq %r14, %rdi
testq %r14, %r14
jne 0x430f
movq 0x8(%rbx), %rdi
callq 0x2040
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2040
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movl $0x10, %edi
callq 0x3520
movq %rax, %rbx
movl $0x1, %edi
callq 0x3520
movq %rax, (%rbx)
movb $0x0, (%rax)
movq $0x0, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movl $0x18, %edi
callq 0x3520
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
xorl %r15d, %r15d
movq %r15, 0x10(%rax)
movl $0x10, %edi
callq 0x3520
movq %rax, %r14
movl $0x1, %edi
callq 0x3520
movq %rax, (%r14)
movb $0x0, (%rax)
movq %r15, 0x8(%r14)
movq %r14, (%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rdi, %rdi
je 0x4405
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x437b
movq 0x8(%rbx), %rdi
callq 0x2040
movq %rbx, %rdi
popq %rbx
jmp 0x2040
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl 0x38(%rsp), %r15d
movslq 0x34(%rsp), %r12
subl %r12d, %r15d
js 0x4447
movq %rdi, %rbx
leal 0x1(%r15), %edi
callq 0x3520
movq %rax, %r14
addq %r12, %rbx
movl %r15d, %r15d
movq %rax, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x2140
movb $0x0, (%r14,%r15)
jmp 0x444a
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movq %rdi, %rax
testl %esi, %esi
je 0x446b
movb $0x0, 0x4(%rax)
movl $0x65757274, (%rax)     # imm = 0x65757274
retq
movw $0x65, 0x4(%rax)
movl $0x736c6166, (%rax)     # imm = 0x736C6166
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x1, %r12d
movq %rsi, %rax
decq %r12
cmpq $0x0, (%rax)
leaq 0x38(%rax), %rax
jne 0x48bc
testq %r12, %r12
je 0x494c
movq 0x8(%r15), %rcx
movslq 0x14(%r15), %rax
leaq (%rax,%rax,8), %rdx
leaq (%rdx,%rdx,2), %rdx
addq %rax, %rdx
movl 0x14(%rcx,%rdx), %r13d
testl %r13d, %r13d
je 0x494c
jle 0x494c
negq %r12
addl %eax, %r13d
movq 0x8(%r15), %rcx
movslq %eax, %rsi
leaq (%rsi,%rsi,8), %rdx
leaq (%rdx,%rdx,2), %rdx
addq %rsi, %rdx
movl (%rcx,%rdx), %esi
decl %esi
cmpl $0x2, %esi
jb 0x4941
addq %rdx, %rcx
testb $0x1, 0x10(%rcx)
je 0x4941
xorl %ebp, %ebp
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
movq %rbx, %rcx
callq 0x4496
testl %eax, %eax
jne 0x493b
incl %ebp
cmpl %ebp, %r12d
jne 0x491a
movl 0x14(%r15), %eax
jmp 0x4941
movl 0x14(%r15), %eax
decl %eax
incl %eax
movl %eax, 0x14(%r15)
cmpl %r13d, %eax
jl 0x48f3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3520
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
movq $0x0, 0x20(%rax)
movq $-0x1, 0x18(%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rdi, %rdi
je 0x4f43
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x2040
movq 0x10(%rbx), %rdi
callq 0x2040
movq 0x8(%rbx), %rdi
callq 0x2040
movq %rbx, %rdi
popq %rbx
jmp 0x2040
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movl $0x10, %edi
callq 0x3520
movq %rax, %rbx
movl $0x28, %edi
callq 0x3520
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
movq $0x0, 0x20(%rax)
movq $-0x1, 0x18(%rax)
movq %rax, 0x8(%rbx)
movb $0x0, 0x4(%rbx)
movl $0xffffffff, (%rbx)     # imm = 0xFFFFFFFF
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10c0, %rsp           # imm = 0x10C0
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl $0x0, 0x4(%rsp)
leaq 0x3add(%rip), %rsi      # 0x8d60
leaq 0x10(%rsp), %rdi
movl $0xa8, %edx
callq 0x2140
testq %r14, %r14
sete %cl
testq %r15, %r15
sete %dl
movl $0x4, %eax
orb %cl, %dl
jne 0x5317
leaq 0x1006(%rip), %rdi      # 0x62b4
callq 0x2180
movzbl 0x4(%rbx), %esi
leaq 0xa(%rsp), %rdi
callq 0x4459
leaq 0xffb(%rip), %rsi       # 0x62c3
xorl %ebp, %ebp
leaq 0xc0(%rsp), %r12
movq %r12, %rdi
movq %rax, %rdx
movq %r15, %rcx
movq %r14, %r8
xorl %eax, %eax
callq 0x2230
leaq 0xffe(%rip), %rdi       # 0x62ea
leaq 0x10(%rsp), %rdx
leaq 0x4(%rsp), %rcx
movq %r12, %rsi
xorl %eax, %eax
callq 0x4c8e
movl %eax, %ecx
movl $0x2, %eax
testl %ecx, %ecx
jne 0x530f
movl 0x4(%rsp), %eax
movl %eax, %ecx
negl %ecx
sbbl %ebp, %ebp
movl %ebp, (%rbx)
addq $0x10c0, %rsp           # imm = 0x10C0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Cotix[P]cReddit/libreddit/user.c
// Function: redditUserLoggedUpdate
EXPORT_SYMBOL RedditErrno redditUserLoggedUpdate (RedditUserLogged *user)
{
    TokenParserResult res;
    char *kindStr = NULL;

    TokenIdent ids[] = {
        ADD_TOKEN_IDENT_STRING("kind", kindStr),
        ADD_TOKEN_IDENT_FUNC("data", userUpdateHelper),
        {0}
    };

    res = redditRunParser(REDDIT_API_ME, NULL, ids, &(user->userInfo));
    free(kindStr);

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

}

// Assembly:
pushq %r14
pushq %rbx
subq $0xb8, %rsp
xorl %eax, %eax
leaq 0x8(%rsp), %r14
movq %rax, (%r14)
leaq 0xcd9(%rip), %rcx       # 0x6106
leaq 0x10(%rsp), %rdx
movq %rcx, (%rdx)
movq $0x2, 0x8(%rdx)
movq %r14, 0x10(%rdx)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdx)
movl $0x0, 0x28(%rdx)
movb $0x1, 0x2c(%rdx)
movq %rax, 0x30(%rdx)
leaq 0xcad(%rip), %rcx       # 0x610b
movq %rcx, 0x38(%rdx)
movabsq $0x200000003, %rcx      # imm = 0x200000003
movq %rcx, 0x40(%rdx)
movups %xmm0, 0x48(%rdx)
movups %xmm0, 0x55(%rdx)
leaq 0x4f(%rip), %rcx        # 0x54ce
movq %rcx, 0x68(%rdx)
movaps %xmm0, 0x70(%rdx)
movaps %xmm0, 0x80(%rdx)
movaps %xmm0, 0x90(%rdx)
movq %rax, 0xa0(%rdx)
leaq 0x8(%rdi), %rcx
leaq 0xe68(%rip), %rdi       # 0x630f
xorl %esi, %esi
xorl %eax, %eax
callq 0x4c8e
xorl %ebx, %ebx
testl %eax, %eax
setne %bl
movq (%r14), %rdi
callq 0x2040
addl %ebx, %ebx
movl %ebx, %eax
addq $0xb8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/Cotix[P]cReddit/libreddit/user.c
// Function: userUpdateHelper
DEF_TOKEN_CALLBACK(userUpdateHelper)
{
    ARG_LIST_USER_UPDATE

    int i;
    for (i = 0; idents[i].name != NULL; i++) {
        if (strcmp(idents[i].name, "kind") == 0) {
            /*
             * Check contents of the name
             */
            if (idents[i].value != NULL && strcmp(*((char**)idents[i].value), "t2") == 0) {
                if (*user != NULL)
                    redditUserFree(*user);

                *user = redditGetUser(parser);
            }

            break;
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl (%rdx), %ecx
cmpq $0x28, %rcx
ja 0x54f2
movq %rcx, %rax
addq 0x10(%rdx), %rax
addl $0x8, %ecx
movl %ecx, (%rdx)
jmp 0x54fe
movq 0x8(%rdx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rdx)
movq (%r14), %rdi
testq %rdi, %rdi
je 0x5565
movq (%rax), %r12
addq $0x38, %r14
leaq 0xbf2(%rip), %r15       # 0x6106
movq %r15, %rsi
callq 0x2120
testl %eax, %eax
je 0x552e
movq (%r14), %rdi
addq $0x38, %r14
testq %rdi, %rdi
jne 0x5514
jmp 0x5565
movq -0x28(%r14), %rax
testq %rax, %rax
je 0x5565
movq (%rax), %rax
cmpb $0x74, (%rax)
jne 0x5565
cmpb $0x32, 0x1(%rax)
jne 0x5565
cmpb $0x0, 0x2(%rax)
jne 0x5565
movq (%r12), %rdi
testq %rdi, %rdi
je 0x5559
callq 0x2080
movq %rbx, %rdi
callq 0x4fa5
movq %rax, (%r12)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/jiqingxiaoxi[P]RPA/RPA.c
// Function: str2int
char str2int(char c)
{
	switch (c)
	{
		case 'A': case 'a': case '0':
			return 0;
		case 'C': case 'c': case '1':
			return 1;
		case 'G': case 'g': case '2':
			return 2;
		case 'T': case 't': case '3':
			return 3;
	}
	return 4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
cmpl $0x46, %edi
jg 0x133f
leal -0x30(%rdi), %ecx
cmpl $0x3, %ecx
ja 0x1370
leaq 0xccce(%rip), %rdx      # 0xe004
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
cmpl $0x62, %edi
jg 0x1355
cmpl $0x47, %edi
je 0x1368
cmpl $0x54, %edi
je 0x136c
cmpl $0x61, %edi
je 0x137c
jmp 0x137a
cmpl $0x74, %edi
je 0x136c
cmpl $0x67, %edi
je 0x1368
cmpl $0x63, %edi
jne 0x137a
movb $0x1, %al
jmp 0x137c
movb $0x2, %al
jmp 0x137c
movb $0x3, %al
jmp 0x137c
cmpl $0x41, %edi
je 0x137c
cmpl $0x43, %edi
je 0x1364
movb $0x4, %al
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jiqingxiaoxi[P]RPA/RPA.c
// Function: get_num_line
int get_num_line(char *path,int flag)
{
	FILE *fp;
	int i,size;
	char *line;

	i=strlen(path)+20;
        line=(char *)malloc(i);
        memset(line,'\0',i);
        strcpy(line,path);
	if(flag==0)
	        strcat(line,"triloop.ds");
	else
		strcat(line,"tetraloop.ds");

        if(access(line,0)==-1)
        {
                printf("Error! Don't have %s file!\n",line);
                exit(1);
        }
        fp=fopen(line,"r");
        if(fp==NULL)
        {
                printf("Error! Can't open the %s file!\n",line);
                exit(1);
        }

	size=0;
	while(fgets(line,i,fp)!=NULL)
		size++;
	return size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %r15d
movq %rdi, %r12
callq 0x10b0
movq %rax, %r14
addl $0x14, %r14d
movslq %r14d, %rsi
movl $0x1, %edi
callq 0x1140
movq %rax, %rbx
movq %rax, %rdi
movq %r12, %rsi
callq 0x1050
movq %rbx, %rdi
callq 0x10b0
addq %rbx, %rax
testl %r15d, %r15d
je 0x2b13
movabsq $0x73642e706f6f6c, %rcx # imm = 0x73642E706F6F6C
movq %rcx, 0x5(%rax)
movabsq $0x6f6f6c6172746574, %rcx # imm = 0x6F6F6C6172746574
movq %rcx, (%rax)
jmp 0x2b27
movabsq $0x2e706f6f6c697274, %rcx # imm = 0x2E706F6F6C697274
movq %rcx, (%rax)
movl $0x73642e, 0x7(%rax)    # imm = 0x73642E
movq %rbx, %rdi
xorl %esi, %esi
callq 0x11c0
cmpl $-0x1, %eax
je 0x2b75
leaq 0xb6de(%rip), %rsi      # 0xe21b
movq %rbx, %rdi
callq 0x11d0
testq %rax, %rax
je 0x2b7e
movq %rax, %r15
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl %r14d, %esi
movq %r15, %rdx
callq 0x1130
incl %r12d
testq %rax, %rax
jne 0x2b53
movl %r12d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xb59d(%rip), %rdi      # 0xe119
jmp 0x2b85
leaq 0xb5b0(%rip), %rdi      # 0xe135
movq %rbx, %rsi
xorl %eax, %eax
callq 0x10c0
movl $0x1, %edi
callq 0x1200
// File: /workspace/github_c_makefile_star2_O3/jiqingxiaoxi[P]RPA/RPA.c
// Function: tableStartATS
void tableStartATS(double atp_value, double atpS[])
{
        int i, j;

        for (i = 0; i < 5; ++i)
                for (j = 0; j < 5; ++j)
                        atpS[i*5+j] = 0.00000000001;
        atpS[3] = atpS[15] = atp_value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
movabsq $0x3da5fd7fe1796495, %rcx # imm = 0x3DA5FD7FE1796495
movq %rdi, %rdx
xorl %esi, %esi
movq %rcx, (%rdx,%rsi,8)
incq %rsi
cmpq $0x5, %rsi
jne 0x309b
incq %rax
addq $0x28, %rdx
cmpq $0x5, %rax
jne 0x3099
movsd %xmm0, 0x78(%rdi)
movsd %xmm0, 0x18(%rdi)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jiqingxiaoxi[P]RPA/RPA.c
// Function: initMatrix2
void initMatrix2(int Initint[],double enthalpyDPT[],double entropyDPT[],char numSeq1[])
{
	int i,j;
	for(i=1;i<=Initint[0];++i)
		for(j=i;j<=Initint[1];++j)
			if(j-i<4 || (numSeq1[i]+numSeq1[j]!=3))
			{
				enthalpyDPT[(i-1)*Initint[2]+j-1]=1.0*INFINITY;
				entropyDPT[(i-1)*Initint[2]+j-1]=-1.0;
			}
			else
			{
				enthalpyDPT[(i-1)*Initint[2]+j-1]=0.0;
				entropyDPT[(i-1)*Initint[2]+j-1]=-3224.0;
			}
}

// Assembly:
movl (%rdi), %eax
testl %eax, %eax
jle 0x31b7
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movslq 0x4(%rdi), %r8
leal 0x1(%r8), %r9d
incq %rax
leaq 0x1(%rcx), %r10
decq %r9
movl $0x1, %r11d
movsd 0xaf08(%rip), %xmm0     # 0xe030
movsd 0xaee8(%rip), %xmm1     # 0xe018
movsd 0xaef0(%rip), %xmm2     # 0xe028
cmpq %r8, %r11
jg 0x319f
leal -0x1(%r11), %ebx
xorl %r14d, %r14d
movl %r11d, %r15d
cmpq $0x3, %r14
ja 0x3153
movl 0x8(%rdi), %r12d
jmp 0x3176
movsbl (%rcx,%r11), %r12d
movsbl (%r10,%r14), %r13d
addl %r12d, %r13d
movl 0x8(%rdi), %r12d
cmpl $0x3, %r13d
jne 0x3176
imull %ebx, %r12d
xorps %xmm3, %xmm3
movaps %xmm2, %xmm4
jmp 0x3180
imull %ebx, %r12d
movaps %xmm1, %xmm3
movaps %xmm0, %xmm4
addl %r15d, %r12d
movslq %r12d, %r12
movsd %xmm3, -0x8(%rsi,%r12,8)
movsd %xmm4, -0x8(%rdx,%r12,8)
incl %r15d
incq %r14
cmpq %r14, %r9
jne 0x3147
incq %r11
incq %r10
decq %r9
cmpq %rax, %r11
jne 0x3138
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jiqingxiaoxi[P]RPA/RPA.c
// Function: Ss
double Ss(int i,int j,int k,double stackEntropies[],int Initint[],char numSeq1[],char numSeq2[])
{
	if(k==2)
	{
		if(i>=j)
			return -1.0;
		if(i==Initint[0]||j==Initint[1]+1)
			return -1.0;

		if(i>Initint[0])
			i-=Initint[0];
		if(j>Initint[1])
			j-=Initint[1];
		return stackEntropies[numSeq1[i]*125+numSeq1[i+1]*25+numSeq2[j]*5+numSeq2[j-1]];
	}
	else
		return stackEntropies[numSeq1[i]*125+numSeq1[i+1]*25+numSeq2[j]*5+numSeq2[j+1]];
}

// Assembly:
movl $0x1, %eax
cmpl $0x2, %edx
jne 0x31fd
movsd 0xae66(%rip), %xmm0     # 0xe030
cmpl %esi, %edi
jge 0x3246
movl (%r8), %eax
cmpl %edi, %eax
je 0x3246
movl 0x4(%r8), %edx
leal 0x1(%rdx), %r8d
cmpl %esi, %r8d
je 0x3246
xorl %r8d, %r8d
cmpl %edi, %eax
cmovgel %r8d, %eax
subl %eax, %edi
cmpl %esi, %edx
cmovll %edx, %r8d
subl %r8d, %esi
movq $-0x1, %rax
pushq %rbp
movq %rsp, %rbp
movq 0x10(%rbp), %rdx
movslq %edi, %rdi
movsbq (%r9,%rdi), %r8
movsbq 0x1(%r9,%rdi), %rdi
movslq %esi, %rsi
leaq (%rdx,%rsi), %r9
movsbq (%rdx,%rsi), %rdx
movsbq (%rax,%r9), %rax
imulq $0x3e8, %r8, %rsi       # imm = 0x3E8
addq %rsi, %rcx
imulq $0xc8, %rdi, %rsi
addq %rcx, %rsi
leaq (%rdx,%rdx,4), %rcx
leaq (%rsi,%rcx,8), %rcx
movsd (%rcx,%rax,8), %xmm0
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jiqingxiaoxi[P]RPA/RPA.c
// Function: Hs
double Hs(int i,int j,int k,double stackEnthalpies[],int Initint[],char numSeq1[],char numSeq2[])
{
	if(k==2)
	{
		if(i>= j)
			return 1.0*INFINITY;
		if(i==Initint[0]||j==Initint[1]+1)
			return 1.0*INFINITY;

		if(i>Initint[0])
			i-=Initint[0];
		if(j>Initint[1])
			j-=Initint[1];
		if(fabs(stackEnthalpies[numSeq1[i]*125+numSeq1[i+1]*25+numSeq2[j]*5+numSeq2[j-1]])<999999999)
			return stackEnthalpies[numSeq1[i]*125+numSeq1[i+1]*25+numSeq2[j]*5+numSeq2[j-1]];
		else
			return 1.0*INFINITY;
	}
	else
		return stackEnthalpies[numSeq1[i]*125+numSeq1[i+1]*25+numSeq2[j]*5+numSeq2[j+1]];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x10(%rbp), %rax
cmpl $0x2, %edx
jne 0x32ee
movsd 0xadb8(%rip), %xmm1     # 0xe018
cmpl %esi, %edi
jge 0x32e8
movl (%r8), %edx
cmpl %edi, %edx
je 0x32e8
movl 0x4(%r8), %r8d
leal 0x1(%r8), %r10d
cmpl %esi, %r10d
je 0x32e8
xorl %r10d, %r10d
cmpl %edi, %edx
cmovgel %r10d, %edx
subl %edx, %edi
cmpl %esi, %r8d
cmovll %r8d, %r10d
subl %r10d, %esi
movslq %edi, %rdx
movsbq (%r9,%rdx), %rdi
movsbq 0x1(%r9,%rdx), %rdx
movslq %esi, %rsi
movsbq (%rax,%rsi), %r8
movsbq -0x1(%rax,%rsi), %rax
imulq $0x3e8, %rdi, %rsi      # imm = 0x3E8
addq %rsi, %rcx
imulq $0xc8, %rdx, %rdx
addq %rcx, %rdx
leaq (%r8,%r8,4), %rcx
leaq (%rdx,%rcx,8), %rcx
movsd (%rcx,%rax,8), %xmm0
movapd 0xadea(%rip), %xmm2     # 0xe0c0
andpd %xmm0, %xmm2
movsd 0xad3e(%rip), %xmm3     # 0xe020
ucomisd %xmm2, %xmm3
ja 0x332b
movapd %xmm1, %xmm0
jmp 0x332b
movslq %edi, %rdx
movsbq (%r9,%rdx), %rdi
movsbq 0x1(%r9,%rdx), %rdx
movslq %esi, %rsi
movsbq (%rax,%rsi), %r8
movsbq 0x1(%rax,%rsi), %rax
imulq $0x3e8, %rdi, %rsi      # imm = 0x3E8
addq %rsi, %rcx
imulq $0xc8, %rdx, %rdx
addq %rcx, %rdx
leaq (%r8,%r8,4), %rcx
leaq (%rdx,%rcx,8), %rcx
movsd (%rcx,%rax,8), %xmm0
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jiqingxiaoxi[P]RPA/RPA.c
// Function: find_pos
int find_pos(char *ref,int ref_start,char *source,int length,int num)
{
	int flag,i,j;

	for(i=0;i<num;i++)
	{
		flag=0;
		for(j=0;j<length;j++)
		{
			if(ref[ref_start+j]!=source[i*length+j])
			{
				flag++;
				break;
			}
		}
		if(flag==0)
			return i;
	}
	return -1;
}

// Assembly:
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %r8d, %r8d
jle 0x3ea3
pushq %rbp
movq %rsp, %rbp
pushq %rbx
movslq %esi, %r9
movslq %ecx, %rsi
movl %r8d, %r8d
movl %esi, %r10d
addq %r9, %rdi
xorl %r9d, %r9d
testl %ecx, %ecx
jle 0x3e9e
xorl %r11d, %r11d
movb (%rdi,%r11), %bl
cmpb (%rdx,%r11), %bl
jne 0x3e91
incq %r11
cmpq %r11, %r10
jne 0x3e7d
jmp 0x3e9e
incq %r9
addq %rsi, %rdx
cmpq %r8, %r9
jne 0x3e76
jmp 0x3ea1
movl %r9d, %eax
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jiqingxiaoxi[P]RPA/RPA.c
// Function: max5
int max5(double a,double b,double c,double d,double e)
{
	if(a>b&&a>c&&a>d&&a>e)
		return 1;
	else if(b>c&&b>d&&b>e)
		return 2;
	else if(c>d&&c>e)
		return 3;
	else if(d>e)
		return 4;
	else
		return 5;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
ucomisd %xmm1, %xmm0
jbe 0x44fd
ucomisd %xmm2, %xmm0
jbe 0x44fd
ucomisd %xmm3, %xmm0
jbe 0x44fd
movl $0x1, %eax
ucomisd %xmm4, %xmm0
ja 0x4531
ucomisd %xmm2, %xmm1
jbe 0x4514
ucomisd %xmm3, %xmm1
jbe 0x4514
movl $0x2, %eax
ucomisd %xmm4, %xmm1
ja 0x4531
ucomisd %xmm3, %xmm2
jbe 0x4525
movl $0x3, %eax
ucomisd %xmm4, %xmm2
ja 0x4531
xorl %eax, %eax
ucomisd %xmm4, %xmm3
seta %al
xorl $0x5, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jiqingxiaoxi[P]RPA/RPA.c
// Function: drawHairpin
double drawHairpin(int bp[],double mh,double ms,int Initint[])
{
        int i,N;

        N=0;
        if(fabs(ms)>999999999||fabs(mh)>999999999)
        {
		return 0.0;
        }
        else
        {
		for(i=1;i<Initint[0];++i)
		{
			if(bp[i-1]>0)
				N++;
                }
                return mh/(ms+(((N/2)-1)*-0.51986))-273.15;
        }
}

// Assembly:
movapd 0x71d8(%rip), %xmm3     # 0xe0c0
movapd %xmm0, %xmm2
andpd %xmm3, %xmm2
ucomisd 0x7128(%rip), %xmm2     # 0xe020
xorpd %xmm2, %xmm2
ja 0x6f66
andpd %xmm1, %xmm3
ucomisd 0x7116(%rip), %xmm3     # 0xe020
ja 0x6f66
movslq (%rsi), %rax
cmpq $0x2, %rax
jl 0x6f3d
decq %rax
xorl %edx, %edx
xorl %ecx, %ecx
xorl %esi, %esi
cmpl $0x0, (%rdi,%rdx,4)
setg %sil
addl %esi, %ecx
incq %rdx
cmpq %rdx, %rax
jne 0x6f1c
shrl %ecx
decl %ecx
xorps %xmm2, %xmm2
cvtsi2sd %ecx, %xmm2
jmp 0x6f45
movsd 0x70eb(%rip), %xmm2     # 0xe030
pushq %rbp
movq %rsp, %rbp
mulsd 0x7117(%rip), %xmm2     # 0xe068
addsd %xmm1, %xmm2
divsd %xmm2, %xmm0
addsd 0x710f(%rip), %xmm0     # 0xe070
movapd %xmm0, %xmm2
popq %rbp
movapd %xmm2, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O3/jiqingxiaoxi[P]RPA/RPA.c
// Function: initMatrix
void initMatrix(int Initint[],double enthalpyDPT[],double entropyDPT[],char numSeq1[],char numSeq2[])
{
	int i,j;

	for(i=1;i<=Initint[0];++i)
	{
		for(j=1;j<=Initint[1];++j)
		{
			if(numSeq1[i]+numSeq2[j]!=3)
			{
				enthalpyDPT[(i-1)*Initint[2]+j-1]=1.0*INFINITY;
				entropyDPT[(i-1)*Initint[2]+j-1]=-1.0;
			}
			else
			{
				enthalpyDPT[(i-1)*Initint[2]+j-1]=0.0;
				entropyDPT[(i-1)*Initint[2]+j-1]=-3224.0;
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, -0x30(%rbp)
movl (%rdi), %eax
testl %eax, %eax
jle 0x7014
movq -0x30(%rbp), %rdi
movl 0x4(%rdi), %edi
movq %rdi, -0x38(%rbp)
leal 0x1(%rdi), %r10d
incq %rax
movl $0x1, %r11d
xorl %ebx, %ebx
movsd 0x7070(%rip), %xmm0     # 0xe018
leaq 0x7131(%rip), %r14      # 0xe0e0
cmpl $0x0, -0x38(%rbp)
jle 0x700a
movq -0x30(%rbp), %rdi
movl 0x8(%rdi), %r15d
imull %ebx, %r15d
movl $0x1, %r12d
movsbl (%rcx,%r11), %r9d
movsbl (%r8,%r12), %edi
addl %r9d, %edi
xorl %r13d, %r13d
xorps %xmm1, %xmm1
cmpl $0x3, %edi
sete %r9b
je 0x6fe6
movaps %xmm0, %xmm1
movb %r9b, %r13b
movsd (%r14,%r13,8), %xmm2
leal (%r15,%r12), %edi
movslq %edi, %rdi
movsd %xmm1, -0x8(%rsi,%rdi,8)
movsd %xmm2, -0x8(%rdx,%rdi,8)
incq %r12
cmpq %r12, %r10
jne 0x6fc7
incq %r11
incl %ebx
cmpq %rax, %r11
jne 0x6faf
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jiqingxiaoxi[P]RPA/RPA.c
// Function: drawDimer
double drawDimer(int *ps1,int *ps2,double H,double S,double Initdouble[],int Initint[])
{
        int i,N;

        if(fabs(Initdouble[3])>999999999)
                return 0.0;
        else
        {
                N=0;
                for(i=0;i<Initint[0];i++)
                {
                        if(ps1[i]>0)
                                ++N;
                }
                for(i=0;i<Initint[1];i++)
                {
                        if(ps2[i]>0)
                                ++N;
                }
                N=(N/2)-1;
                return (H/(S+(N*-0.51986)+Initdouble[2]))-273.15;
        }
}

// Assembly:
movsd 0x18(%rdx), %xmm3
andpd 0x5a21(%rip), %xmm3     # 0xe0c0
xorpd %xmm2, %xmm2
ucomisd 0x5975(%rip), %xmm3     # 0xe020
ja 0x8732
movslq (%rcx), %r8
testq %r8, %r8
jle 0x86d7
xorl %r9d, %r9d
xorl %eax, %eax
xorl %r10d, %r10d
cmpl $0x0, (%rdi,%r9,4)
setg %r10b
addl %r10d, %eax
incq %r9
cmpq %r9, %r8
jne 0x86be
jmp 0x86d9
xorl %eax, %eax
movslq 0x4(%rcx), %rcx
testq %rcx, %rcx
jle 0x86fa
xorl %edi, %edi
xorl %r8d, %r8d
cmpl $0x0, (%rsi,%rdi,4)
setg %r8b
addl %r8d, %eax
incq %rdi
cmpq %rdi, %rcx
jne 0x86e4
pushq %rbp
movq %rsp, %rbp
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
decl %ecx
xorps %xmm2, %xmm2
cvtsi2sd %ecx, %xmm2
mulsd 0x5950(%rip), %xmm2     # 0xe068
addsd %xmm1, %xmm2
addsd 0x10(%rdx), %xmm2
divsd %xmm2, %xmm0
addsd 0x5943(%rip), %xmm0     # 0xe070
movapd %xmm0, %xmm2
popq %rbp
movapd %xmm2, %xmm0
retq