LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/snej[P]zdelta/inftrees.c
// Function: inflate_trees_bits
int inflate_trees_bits(c, bb, tb, hp, z)
uIntf *c;               /* 19 code lengths */
uIntf *bb;              /* bits tree desired/actual depth */
inflate_huft * FAR *tb; /* bits tree result */
inflate_huft *hp;       /* space for trees */
zd_streamp z;            /* for messages */
{
  int r;
  uInt hn = 0;          /* hufts used in space */
  uIntf *v;             /* work area for huft_build */

  if ((v = (uIntf*)ZALLOC(z, 19, sizeof(uInt))) == ZD_NULL)
    return ZD_MEM_ERROR;
  r = huft_build(c, 19, 19, (uIntf*)ZD_NULL, (uIntf*)ZD_NULL,
                 tb, bb, hp, &hn, v);
  if (r == ZD_DATA_ERROR)
    z->msg = (char*)"oversubscribed dynamic bit lengths tree";
  else if (r == ZD_BUF_ERROR || *bb == 0)
  {
    z->msg = (char*)"incomplete dynamic bit lengths tree";
    r = ZD_DATA_ERROR;
  }
  ZFREE(z, v);
  return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x68, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq %r8, -0x38(%rbp)
movl $0x0, -0x40(%rbp)
movq -0x38(%rbp), %rax
movq 0x60(%rax), %rax
movq -0x38(%rbp), %rcx
movq 0x70(%rcx), %rdi
movl $0x13, %esi
movl $0x4, %edx
callq *%rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
jne 0xef16
movl $0xfffffffc, -0xc(%rbp) # imm = 0xFFFFFFFC
jmp 0xefb2
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %r9
movq -0x20(%rbp), %rbx
movq -0x30(%rbp), %r11
movq -0x48(%rbp), %rax
movl $0x13, %edx
xorl %ecx, %ecx
movl %ecx, %r8d
leaq -0x40(%rbp), %r10
movl %edx, %esi
movq %r8, %rcx
movq %rbx, (%rsp)
movq %r11, 0x8(%rsp)
movq %r10, 0x10(%rsp)
movq %rax, 0x18(%rsp)
callq 0xefc0
movl %eax, -0x3c(%rbp)
cmpl $-0x3, -0x3c(%rbp)
jne 0xef6f
movq -0x38(%rbp), %rax
leaq 0x2e97(%rip), %rcx      # 0x11e00
movq %rcx, 0x50(%rax)
jmp 0xef96
cmpl $-0x5, -0x3c(%rbp)
je 0xef7e
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
jne 0xef94
movq -0x38(%rbp), %rax
leaq 0x2e9f(%rip), %rcx      # 0x11e28
movq %rcx, 0x50(%rax)
movl $0xfffffffd, -0x3c(%rbp) # imm = 0xFFFFFFFD
jmp 0xef96
movq -0x38(%rbp), %rax
movq 0x68(%rax), %rax
movq -0x38(%rbp), %rcx
movq 0x70(%rcx), %rdi
movq -0x48(%rbp), %rsi
callq *%rax
movl -0x3c(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x68, %rsp
popq %rbx
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Genymobile[P]hiredis/test.c
// Function: test_free_null
static void test_free_null(void) {
    void *redisContext = NULL;
    void *reply = NULL;

    test("Don't fail when redisFree is passed a NULL value: ");
    redisFree(redisContext);
    test_cond(redisContext == NULL);

    test("Don't fail when freeReplyObject is passed a NULL value: ");
    freeReplyObject(reply);
    test_cond(reply == NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq $0x0, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movl 0xe372(%rip), %esi      # 0x121c0
addl $0x1, %esi
movl %esi, 0xe369(%rip)      # 0x121c0
leaq 0x92d0(%rip), %rdi      # 0xd12e
movb $0x0, %al
callq 0x20f0
leaq 0x9c5f(%rip), %rdi      # 0xdacb
movb $0x0, %al
callq 0x20f0
movq -0x8(%rbp), %rdi
callq 0x6c60
cmpq $0x0, -0x8(%rbp)
jne 0x3e93
leaq 0x92fe(%rip), %rdi      # 0xd188
movb $0x0, %al
callq 0x20f0
jmp 0x3eb0
leaq 0x9303(%rip), %rdi      # 0xd19d
movb $0x0, %al
callq 0x20f0
movl 0xe315(%rip), %eax      # 0x121bc
addl $0x1, %eax
movl %eax, 0xe30c(%rip)      # 0x121bc
movl 0xe30a(%rip), %esi      # 0x121c0
addl $0x1, %esi
movl %esi, 0xe301(%rip)      # 0x121c0
leaq 0x9268(%rip), %rdi      # 0xd12e
movb $0x0, %al
callq 0x20f0
leaq 0x9c2a(%rip), %rdi      # 0xdafe
movb $0x0, %al
callq 0x20f0
movq -0x10(%rbp), %rdi
callq 0x5880
cmpq $0x0, -0x10(%rbp)
jne 0x3efb
leaq 0x9296(%rip), %rdi      # 0xd188
movb $0x0, %al
callq 0x20f0
jmp 0x3f18
leaq 0x929b(%rip), %rdi      # 0xd19d
movb $0x0, %al
callq 0x20f0
movl 0xe2ad(%rip), %eax      # 0x121bc
addl $0x1, %eax
movl %eax, 0xe2a4(%rip)      # 0x121bc
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Genymobile[P]hiredis/test.c
// Function: test_invalid_timeout_errors
static void test_invalid_timeout_errors(struct config config) {
    redisContext *c;

    test("Set error when an invalid timeout usec value is given to redisConnectWithTimeout: ");

    config.tcp.timeout.tv_sec = 0;
    config.tcp.timeout.tv_usec = 10000001;

    c = redisConnectWithTimeout(config.tcp.host, config.tcp.port, config.tcp.timeout);

    test_cond(c->err == REDIS_ERR_IO);
    redisFree(c);

    test("Set error when an invalid timeout sec value is given to redisConnectWithTimeout: ");

    config.tcp.timeout.tv_sec = (((LONG_MAX) - 999) / 1000) + 1;
    config.tcp.timeout.tv_usec = 0;

    c = redisConnectWithTimeout(config.tcp.host, config.tcp.port, config.tcp.timeout);

    test_cond(c->err == REDIS_ERR_IO);
    redisFree(c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movl 0xd49a(%rip), %esi      # 0x121c0
addl $0x1, %esi
movl %esi, 0xd491(%rip)      # 0x121c0
leaq 0x83f8(%rip), %rdi      # 0xd12e
movb $0x0, %al
callq 0x20f0
leaq 0x9303(%rip), %rdi      # 0xe047
movb $0x0, %al
callq 0x20f0
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
movq $0x989681, 0x20(%rax)   # imm = 0x989681
movq 0x8(%rax), %rdi
movl 0x10(%rax), %esi
movq 0x18(%rax), %rdx
movq 0x20(%rax), %rcx
callq 0x7030
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x4d90
leaq 0x8401(%rip), %rdi      # 0xd188
movb $0x0, %al
callq 0x20f0
jmp 0x4dad
leaq 0x8406(%rip), %rdi      # 0xd19d
movb $0x0, %al
callq 0x20f0
movl 0xd418(%rip), %eax      # 0x121bc
addl $0x1, %eax
movl %eax, 0xd40f(%rip)      # 0x121bc
movq -0x8(%rbp), %rdi
callq 0x6c60
movl 0xd404(%rip), %esi      # 0x121c0
addl $0x1, %esi
movl %esi, 0xd3fb(%rip)      # 0x121c0
leaq 0x8362(%rip), %rdi      # 0xd12e
movb $0x0, %al
callq 0x20f0
leaq 0x92c0(%rip), %rdi      # 0xe09a
movb $0x0, %al
callq 0x20f0
movq -0x10(%rbp), %rax
movabsq $0x20c49ba5e353f7, %rcx # imm = 0x20C49BA5E353F7
movq %rcx, 0x18(%rax)
movq $0x0, 0x20(%rax)
movq 0x8(%rax), %rdi
movl 0x10(%rax), %esi
movq 0x18(%rax), %rdx
movq 0x20(%rax), %rcx
callq 0x7030
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x4e2c
leaq 0x8365(%rip), %rdi      # 0xd188
movb $0x0, %al
callq 0x20f0
jmp 0x4e49
leaq 0x836a(%rip), %rdi      # 0xd19d
movb $0x0, %al
callq 0x20f0
movl 0xd37c(%rip), %eax      # 0x121bc
addl $0x1, %eax
movl %eax, 0xd373(%rip)      # 0x121bc
movq -0x8(%rbp), %rdi
callq 0x6c60
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Genymobile[P]hiredis/test.c
// Function: test_append_formatted_commands
static void test_append_formatted_commands(struct config config) {
    redisContext *c;
    redisReply *reply;
    char *cmd;
    int len;

    c = connect(config);

    test("Append format command: ");

    len = redisFormatCommand(&cmd, "SET foo bar");

    test_cond(redisAppendFormattedCommand(c, cmd, len) == REDIS_OK);

    assert(redisGetReply(c, (void*)&reply) == REDIS_OK);

    free(cmd);
    freeReplyObject(reply);

    disconnect(c, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
leaq 0x10(%rbp), %rax
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
movq %rsp, %rax
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x5550
movq %rax, -0x8(%rbp)
movl 0xd32c(%rip), %esi      # 0x121c0
addl $0x1, %esi
movl %esi, 0xd323(%rip)      # 0x121c0
leaq 0x828a(%rip), %rdi      # 0xd12e
movb $0x0, %al
callq 0x20f0
leaq 0x923a(%rip), %rdi      # 0xe0ec
movb $0x0, %al
callq 0x20f0
leaq -0x18(%rbp), %rdi
leaq 0x8298(%rip), %rsi      # 0xd15c
movb $0x0, %al
callq 0x6660
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
callq 0x7880
cmpl $0x0, %eax
jne 0x4ef4
leaq 0x829d(%rip), %rdi      # 0xd188
movb $0x0, %al
callq 0x20f0
jmp 0x4f11
leaq 0x82a2(%rip), %rdi      # 0xd19d
movb $0x0, %al
callq 0x20f0
movl 0xd2b4(%rip), %eax      # 0x121bc
addl $0x1, %eax
movl %eax, 0xd2ab(%rip)      # 0x121bc
movq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x7710
cmpl $0x0, %eax
jne 0x4f25
jmp 0x4f44
leaq 0x91d8(%rip), %rdi      # 0xe104
leaq 0x8994(%rip), %rsi      # 0xd8c7
movl $0xef, %edx
leaq 0x91f1(%rip), %rcx      # 0xe130
callq 0x2130
movq -0x18(%rbp), %rdi
callq 0x2030
movq -0x10(%rbp), %rdi
callq 0x5880
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x5660
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Genymobile[P]hiredis/test.c
// Function: connect
static redisContext *connect(struct config config) {
    redisContext *c = NULL;

    if (config.type == CONN_TCP) {
        c = redisConnect(config.tcp.host, config.tcp.port);
    } else if (config.type == CONN_UNIX) {
        printf("Unix connection not supported\n");
        exit(1);
    } else if (config.type == CONN_FD) {
        printf("Unix connection not supported\n");
        exit(1);
    } else {
        assert(NULL);
    }

    if (c == NULL) {
        printf("Connection error: can't allocate redis context\n");
        exit(1);
    } else if (c->err) {
        printf("Connection error: %s\n", c->errstr);
        redisFree(c);
        exit(1);
    }

    return select_database(c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq $0x0, -0x8(%rbp)
cmpl $0x0, (%rax)
jne 0x5583
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movl 0x10(%rax), %esi
callq 0x6ed0
movq %rax, -0x8(%rbp)
jmp 0x55f4
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x55a4
leaq 0x873f(%rip), %rdi      # 0xdcd2
movb $0x0, %al
callq 0x20f0
movl $0x1, %edi
callq 0x2270
movq -0x10(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x55c5
leaq 0x871e(%rip), %rdi      # 0xdcd2
movb $0x0, %al
callq 0x20f0
movl $0x1, %edi
callq 0x2270
xorl %eax, %eax
testb $0x1, %al
jne 0x55cd
jmp 0x55cf
jmp 0x55ee
leaq 0x9338(%rip), %rdi      # 0xe90e
leaq 0x82ea(%rip), %rsi      # 0xd8c7
movl $0x6a, %edx
leaq 0x8708(%rip), %rcx      # 0xdcf1
callq 0x2130
jmp 0x55f0
jmp 0x55f2
jmp 0x55f4
cmpq $0x0, -0x8(%rbp)
jne 0x5613
leaq 0x8714(%rip), %rdi      # 0xdd16
movb $0x0, %al
callq 0x20f0
movl $0x1, %edi
callq 0x2270
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
je 0x5645
movq -0x8(%rbp), %rsi
addq $0x4, %rsi
leaq 0x871b(%rip), %rdi      # 0xdd46
movb $0x0, %al
callq 0x20f0
movq -0x8(%rbp), %rdi
callq 0x6c60
movl $0x1, %edi
callq 0x2270
jmp 0x5647
movq -0x8(%rbp), %rdi
callq 0x5730
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Genymobile[P]hiredis/test.c
// Function: disconnect
static int disconnect(redisContext *c, int keep_fd) {
    redisReply *reply;

    /* Make sure we're on DB 9. */
    reply = redisCommand(c,"SELECT 9");
    assert(reply != NULL);
    freeReplyObject(reply);
    reply = redisCommand(c,"FLUSHDB");
    assert(reply != NULL);
    freeReplyObject(reply);

    /* Free the context as well, but keep the fd if requested. */
    if (keep_fd)
        return redisFreeKeepFd(c);
    redisFree(c);
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x86e2(%rip), %rsi      # 0xdd5c
movb $0x0, %al
callq 0x7b80
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x568e
jmp 0x56ad
leaq 0x86d0(%rip), %rdi      # 0xdd65
leaq 0x822b(%rip), %rsi      # 0xd8c7
movl $0x51, %edx
leaq 0x8731(%rip), %rcx      # 0xddd9
callq 0x2130
movq -0x20(%rbp), %rdi
callq 0x5880
movq -0x10(%rbp), %rdi
leaq 0x873c(%rip), %rsi      # 0xddfd
movb $0x0, %al
callq 0x7b80
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x56d5
jmp 0x56f4
leaq 0x8689(%rip), %rdi      # 0xdd65
leaq 0x81e4(%rip), %rsi      # 0xd8c7
movl $0x54, %edx
leaq 0x86ea(%rip), %rcx      # 0xddd9
callq 0x2130
movq -0x20(%rbp), %rdi
callq 0x5880
cmpl $0x0, -0x14(%rbp)
je 0x5711
movq -0x10(%rbp), %rdi
callq 0x6d60
movl %eax, -0x4(%rbp)
jmp 0x5721
movq -0x10(%rbp), %rdi
callq 0x6c60
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Genymobile[P]hiredis/test.c
// Function: select_database
static redisContext *select_database(redisContext *c) {
    redisReply *reply;

    /* Switch to DB 9 for testing, now that we know we can chat. */
    reply = redisCommand(c,"SELECT 9");
    assert(reply != NULL);
    freeReplyObject(reply);

    /* Make sure the DB is emtpy */
    reply = redisCommand(c,"DBSIZE");
    assert(reply != NULL);
    if (reply->type == REDIS_REPLY_INTEGER && reply->integer == 0) {
        /* Awesome, DB 9 is empty and we can continue. */
        freeReplyObject(reply);
    } else {
        printf("Database #9 is not empty, test can not continue\n");
        exit(1);
    }

    return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x8615(%rip), %rsi      # 0xdd5c
movb $0x0, %al
callq 0x7b80
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x575b
jmp 0x577a
leaq 0x8603(%rip), %rdi      # 0xdd65
leaq 0x815e(%rip), %rsi      # 0xd8c7
movl $0x3b, %edx
leaq 0x85fe(%rip), %rcx      # 0xdd73
callq 0x2130
movq -0x10(%rbp), %rdi
callq 0x5880
movq -0x8(%rbp), %rdi
leaq 0x8613(%rip), %rsi      # 0xdda1
movb $0x0, %al
callq 0x7b80
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x57a2
jmp 0x57c1
leaq 0x85bc(%rip), %rdi      # 0xdd65
leaq 0x8117(%rip), %rsi      # 0xd8c7
movl $0x40, %edx
leaq 0x85b7(%rip), %rcx      # 0xdd73
callq 0x2130
movq -0x10(%rbp), %rax
cmpl $0x3, (%rax)
jne 0x57e0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x57e0
movq -0x10(%rbp), %rdi
callq 0x5880
jmp 0x57f8
leaq 0x85c1(%rip), %rdi      # 0xdda8
movb $0x0, %al
callq 0x20f0
movl $0x1, %edi
callq 0x2270
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Genymobile[P]hiredis/hiredis.c
// Function: redisFree
void redisFree(redisContext *c) {
    if (c == NULL)
        return;
    if (c->fd > 0)
#ifdef _WIN32
        closesocket(c->fd);
#else
        close(c->fd);
#endif
    if (c->obuf != NULL)
        sdsfree(c->obuf);
    if (c->reader != NULL)
        redisReaderFree(c->reader);
    if (c->tcp.host)
        free(c->tcp.host);
    if (c->tcp.source_addr)
        free(c->tcp.source_addr);
    if (c->unix_sock.path)
        free(c->unix_sock.path);
    if (c->timeout)
        free(c->timeout);
    free(c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x6c78
jmp 0x6d51
movq -0x8(%rbp), %rax
cmpl $0x0, 0x84(%rax)
jle 0x6c94
movq -0x8(%rbp), %rax
movl 0x84(%rax), %edi
callq 0x2150
movq -0x8(%rbp), %rax
cmpq $0x0, 0x90(%rax)
je 0x6cb2
movq -0x8(%rbp), %rax
movq 0x90(%rax), %rdi
callq 0x8210
movq -0x8(%rbp), %rax
cmpq $0x0, 0x98(%rax)
je 0x6cd0
movq -0x8(%rbp), %rax
movq 0x98(%rax), %rdi
callq 0xa380
movq -0x8(%rbp), %rax
cmpq $0x0, 0xb0(%rax)
je 0x6cee
movq -0x8(%rbp), %rax
movq 0xb0(%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rax
cmpq $0x0, 0xb8(%rax)
je 0x6d0c
movq -0x8(%rbp), %rax
movq 0xb8(%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rax
cmpq $0x0, 0xc8(%rax)
je 0x6d2a
movq -0x8(%rbp), %rax
movq 0xc8(%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rax
cmpq $0x0, 0xa8(%rax)
je 0x6d48
movq -0x8(%rbp), %rax
movq 0xa8(%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rdi
callq 0x2030
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Genymobile[P]hiredis/hiredis.c
// Function: redisContextInit
static redisContext *redisContextInit(void) {
    redisContext *c;

#ifdef _WIN32
    /* fireup Windows socket stuff */
    WORD wVersionRequested = MAKEWORD(2, 0);
    WSADATA wsaData;
    int ret;
    ret = WSAStartup(wVersionRequested, &wsaData);
    if (ret != 0) {
        fprintf(stderr, "error: WSAStartup() failed: %d\n", ret);
        return NULL;
    }
#endif

    c = calloc(1,sizeof(redisContext));
    if (c == NULL)
        return NULL;

    c->err = 0;
    c->errstr[0] = '\0';
    c->obuf = sdsempty();
    c->reader = redisReaderCreate();
    c->tcp.host = NULL;
    c->tcp.source_addr = NULL;
    c->unix_sock.path = NULL;
    c->timeout = NULL;

    if (c->obuf == NULL || c->reader == NULL) {
        redisFree(c);
        return NULL;
    }

    return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x1, %edi
movl $0xd0, %esi
callq 0x2190
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x6f6f
movq $0x0, -0x8(%rbp)
jmp 0x701a
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x4(%rax)
callq 0x8170
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x90(%rax)
callq 0x6c40
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x98(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0xb0(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0xb8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0xc8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0xa8(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x90(%rax)
je 0x6fff
movq -0x10(%rbp), %rax
cmpq $0x0, 0x98(%rax)
jne 0x7012
movq -0x10(%rbp), %rdi
callq 0x6c60
movq $0x0, -0x8(%rbp)
jmp 0x701a
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Genymobile[P]hiredis/hiredis.c
// Function: redisBufferWrite
int redisBufferWrite(redisContext *c, int *done) {
    int nwritten;

    /* Return early when the context has seen an error. */
    if (c->err)
        return REDIS_ERR;

    if (sdslen(c->obuf) > 0) {
#if _WIN32
        nwritten = send(c->fd,c->obuf,sdslen(c->obuf), 0);
#else
        nwritten = write(c->fd,c->obuf,sdslen(c->obuf));
#endif
        if (nwritten == -1) {
            if ((errno == EAGAIN && !(c->flags & REDIS_BLOCK)) || (errno == EINTR)) {
                /* Try again later */
            } else {
                __redisSetError(c,REDIS_ERR_IO,NULL);
                return REDIS_ERR;
            }
        } else if (nwritten > 0) {
            if (nwritten == (signed)sdslen(c->obuf)) {
                sdsfree(c->obuf);
                c->obuf = sdsempty();
            } else {
                sdsrange(c->obuf,nwritten,-1);
            }
        }
    }
    if (done != NULL) *done = (sdslen(c->obuf) == 0);
    return REDIS_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x7555
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7694
movq -0x10(%rbp), %rax
movq 0x90(%rax), %rdi
callq 0x5840
cmpq $0x0, %rax
jbe 0x7664
movq -0x10(%rbp), %rax
movl 0x84(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movq 0x90(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x90(%rax), %rdi
callq 0x5840
movl -0x2c(%rbp), %edi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
callq 0x20c0
movl %eax, -0x1c(%rbp)
cmpl $-0x1, -0x1c(%rbp)
jne 0x75fb
callq 0x2050
cmpl $0xb, (%rax)
jne 0x75cf
movq -0x10(%rbp), %rax
movl 0x88(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x75d9
callq 0x2050
cmpl $0x4, (%rax)
jne 0x75db
jmp 0x75f9
movq -0x10(%rbp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x6b60
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7694
jmp 0x7662
cmpl $0x0, -0x1c(%rbp)
jle 0x7660
movl -0x1c(%rbp), %eax
movl %eax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x90(%rax), %rdi
callq 0x5840
movq %rax, %rcx
movl -0x30(%rbp), %eax
cmpl %ecx, %eax
jne 0x7646
movq -0x10(%rbp), %rax
movq 0x90(%rax), %rdi
callq 0x8210
callq 0x8170
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x90(%rax)
jmp 0x765e
movq -0x10(%rbp), %rax
movq 0x90(%rax), %rdi
movl -0x1c(%rbp), %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x92f0
jmp 0x7660
jmp 0x7662
jmp 0x7664
cmpq $0x0, -0x18(%rbp)
je 0x768d
movq -0x10(%rbp), %rax
movq 0x90(%rax), %rdi
callq 0x5840
cmpq $0x0, %rax
sete %al
andb $0x1, %al
movzbl %al, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Genymobile[P]hiredis/net.c
// Function: redisSetBlocking
static int redisSetBlocking(redisContext *c, int blocking) {
#ifdef _WIN32
    int iResult;
    unsigned long flag;
    if (blocking)
        flag = 0;
    else
        flag = 1;
    iResult = ioctlsocket(c->fd, FIONBIO, &flag);
    if (iResult != NO_ERROR)
    {
        SETERRNO;
        __redisSetErrorFromErrno(c,REDIS_ERR_IO,"fcntl(F_SETFL)");
        redisContextCloseFd(c->fd);
        return REDIS_ERR;
    }
#else
    int flags;

    /* Set the socket nonblocking.
     * Note that fcntl(2) for F_GETFL and F_SETFL can't be
     * interrupted by a signal. */
    if ((flags = fcntl(c->fd, F_GETFL)) == -1) {
        __redisSetErrorFromErrno(c,REDIS_ERR_IO,"fcntl(F_GETFL)");
        redisContextCloseFd(c);
        return REDIS_ERR;
    }

    if (blocking)
        flags &= ~O_NONBLOCK;
    else
        flags |= O_NONBLOCK;

    if (fcntl(c->fd, F_SETFL, flags) == -1) {
        __redisSetErrorFromErrno(c,REDIS_ERR_IO,"fcntl(F_SETFL)");
        redisContextCloseFd(c);
        return REDIS_ERR;
    }
#endif
    return REDIS_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0x84(%rax), %edi
movl $0x3, %esi
movb $0x0, %al
callq 0x20b0
movl %eax, -0x18(%rbp)
cmpl $-0x1, %eax
jne 0xc3a4
movq -0x10(%rbp), %rdi
movl $0x1, %esi
leaq 0x2772(%rip), %rdx      # 0xeaff
callq 0xb900
movq -0x10(%rbp), %rdi
callq 0xc5d0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xc40e
cmpl $0x0, -0x14(%rbp)
je 0xc3b7
movl -0x18(%rbp), %eax
andl $0xfffff7ff, %eax       # imm = 0xFFFFF7FF
movl %eax, -0x18(%rbp)
jmp 0xc3c2
movl -0x18(%rbp), %eax
orl $0x800, %eax            # imm = 0x800
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x84(%rax), %edi
movl -0x18(%rbp), %edx
movl $0x4, %esi
movb $0x0, %al
callq 0x20b0
cmpl $-0x1, %eax
jne 0xc407
movq -0x10(%rbp), %rdi
movl $0x1, %esi
leaq 0x271e(%rip), %rdx      # 0xeb0e
callq 0xb900
movq -0x10(%rbp), %rdi
callq 0xc5d0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xc40e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Genymobile[P]hiredis/net.c
// Function: redisContextCloseFd
static void redisContextCloseFd(redisContext *c) {
    if (c && c->fd >= 0) {
#ifdef _WIN32
        closesocket(c->fd);
#else
        close(c->fd);
#endif
        c->fd = -1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xc60d
movq -0x8(%rbp), %rax
cmpl $0x0, 0x84(%rax)
jl 0xc60d
movq -0x8(%rbp), %rax
movl 0x84(%rax), %edi
callq 0x2150
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x84(%rax) # imm = 0xFFFFFFFF
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/seanpringle[P]xoat/./regex.c
// Function: regex_cache_empty
void
regex_cache_empty()
{
	for (int i = 0; i < REGEX_CACHE; i++)
	{
		RegexCache *rc = &regex_cache[i];
		if (rc->pattern)
		{
			regfree(&rc->regex);
			free(rc->pattern);
			rc->used = 0;
			rc->hash = 0;
			rc->pattern = NULL;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
cmpl $0x8, -0x4(%rbp)
jge 0x3ace
movslq -0x4(%rbp), %rcx
leaq 0xfe30(%rip), %rax      # 0x138a0
imulq $0x58, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x3ac1
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq 0x34e0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3220
movq -0x10(%rbp), %rax
movl $0x0, 0x50(%rax)
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
jmp 0x3ac3
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x3a5f
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/seanpringle[P]xoat/./regex.c
// Function: regex_match
int
regex_match(const char *pattern, const char *subject)
{
	int r = 0; regmatch_t pmatch[REGEX_GROUPS];
	regex_t *re = regex(pattern);
	if (re && subject && (r = regexec(re, subject, REGEX_GROUPS, pmatch, 0) == 0))
	{
		for (int i = 0; i < REGEX_GROUPS && pmatch[i].rm_so != (size_t)-1; i++)
		{
			free(regex_matches[i]);
			int len = pmatch[i].rm_eo - pmatch[i].rm_so;
			regex_matches[i] = malloc(len + 1);
			strncpy(regex_matches[i], subject + pmatch[i].rm_so, len);
			regex_matches[i][len] = 0;
		}
	}
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x37c0
movq %rax, -0x68(%rbp)
cmpq $0x0, -0x68(%rbp)
je 0x3c17
cmpq $0x0, -0x10(%rbp)
je 0x3c17
movq -0x68(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x60(%rbp), %rcx
movl $0x8, %edx
xorl %r8d, %r8d
callq 0x3180
cmpl $0x0, %eax
sete %al
movb %al, %cl
andb $0x1, %cl
movzbl %cl, %ecx
movl %ecx, -0x14(%rbp)
testb $0x1, %al
jne 0x3b50
jmp 0x3c17
movl $0x0, -0x6c(%rbp)
xorl %eax, %eax
cmpl $0x8, -0x6c(%rbp)
movb %al, -0x71(%rbp)
jge 0x3b75
movslq -0x6c(%rbp), %rax
movslq -0x60(%rbp,%rax,8), %rax
cmpq $-0x1, %rax
setne %al
movb %al, -0x71(%rbp)
movb -0x71(%rbp), %al
testb $0x1, %al
jne 0x3b81
jmp 0x3c15
movslq -0x6c(%rbp), %rcx
leaq 0xffd4(%rip), %rax      # 0x13b60
movq (%rax,%rcx,8), %rdi
callq 0x3220
movslq -0x6c(%rbp), %rax
movl -0x5c(%rbp,%rax,8), %eax
movslq -0x6c(%rbp), %rcx
subl -0x60(%rbp,%rcx,8), %eax
movl %eax, -0x70(%rbp)
movl -0x70(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
callq 0x3150
movq %rax, %rdx
movslq -0x6c(%rbp), %rcx
leaq 0xff9c(%rip), %rax      # 0x13b60
movq %rdx, (%rax,%rcx,8)
movslq -0x6c(%rbp), %rcx
leaq 0xff8d(%rip), %rax      # 0x13b60
movq (%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rsi
movslq -0x6c(%rbp), %rax
movslq -0x60(%rbp,%rax,8), %rax
addq %rax, %rsi
movslq -0x70(%rbp), %rdx
callq 0x3570
movslq -0x6c(%rbp), %rcx
leaq 0xff65(%rip), %rax      # 0x13b60
movq (%rax,%rcx,8), %rax
movslq -0x70(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl -0x6c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x6c(%rbp)
jmp 0x3b57
jmp 0x3c17
movl -0x14(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/seanpringle[P]xoat/./textbox.c
// Function: textbox_font
void textbox_font(Textbox *tb, char *font, char *fg, char *bg)
{
	if (tb->font) XftFontClose(display, tb->font);
	tb->font = XftFontOpenName(display, DefaultScreen(display), font);

	XftColorAllocName(display, DefaultVisual(display, DefaultScreen(display)), DefaultColormap(display, DefaultScreen(display)), fg, &tb->color_fg);
	XftColorAllocName(display, DefaultVisual(display, DefaultScreen(display)), DefaultColormap(display, DefaultScreen(display)), bg, &tb->color_bg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x3f67
movq 0xfc46(%rip), %rdi      # 0x13ba0
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0x30a0
movq 0xfc32(%rip), %rdi      # 0x13ba0
movq 0xfc2b(%rip), %rax      # 0x13ba0
movl 0xe0(%rax), %esi
movq -0x10(%rbp), %rdx
callq 0x3460
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq 0xfc0a(%rip), %rdi      # 0x13ba0
movq 0xfc03(%rip), %rax      # 0x13ba0
movq 0xe8(%rax), %rax
movq 0xfbf5(%rip), %rcx      # 0x13ba0
movslq 0xe0(%rcx), %rcx
shlq $0x7, %rcx
addq %rcx, %rax
movq 0x40(%rax), %rsi
movq 0xfbdc(%rip), %rax      # 0x13ba0
movq 0xe8(%rax), %rax
movq 0xfbce(%rip), %rcx      # 0x13ba0
movslq 0xe0(%rcx), %rcx
shlq $0x7, %rcx
addq %rcx, %rax
movq 0x50(%rax), %rdx
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %r8
addq $0x30, %r8
callq 0x3390
movq 0xfba4(%rip), %rdi      # 0x13ba0
movq 0xfb9d(%rip), %rax      # 0x13ba0
movq 0xe8(%rax), %rax
movq 0xfb8f(%rip), %rcx      # 0x13ba0
movslq 0xe0(%rcx), %rcx
shlq $0x7, %rcx
addq %rcx, %rax
movq 0x40(%rax), %rsi
movq 0xfb76(%rip), %rax      # 0x13ba0
movq 0xe8(%rax), %rax
movq 0xfb68(%rip), %rcx      # 0x13ba0
movslq 0xe0(%rcx), %rcx
shlq $0x7, %rcx
addq %rcx, %rax
movq 0x50(%rax), %rdx
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %r8
addq $0x40, %r8
callq 0x3390
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/seanpringle[P]xoat/./textbox.c
// Function: textbox_text
void textbox_text(Textbox *tb, char *text)
{
	if (tb->text) free(tb->text);
	tb->text = strdup(text ? text: "");
	tb->cursor = MAX(0, MIN(strlen(tb->text), tb->cursor));
	textbox_extents(tb);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0x4098
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x3220
cmpq $0x0, -0x10(%rbp)
je 0x40a9
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x40b6
leaq 0xb556(%rip), %rax      # 0xf606
movq %rax, -0x18(%rbp)
jmp 0x40b6
movq -0x18(%rbp), %rdi
callq 0x3430
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x3250
movq -0x8(%rbp), %rcx
movswq 0x20(%rcx), %rcx
cmpq %rcx, %rax
jae 0x40f8
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x3250
movq %rax, -0x20(%rbp)
jmp 0x4105
movq -0x8(%rbp), %rax
movswq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpq %rcx, %rax
jbe 0x4118
xorl %eax, %eax
movq %rax, -0x28(%rbp)
jmp 0x415b
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x3250
movq -0x8(%rbp), %rcx
movswq 0x20(%rcx), %rcx
cmpq %rcx, %rax
jae 0x4146
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x3250
movq %rax, -0x30(%rbp)
jmp 0x4153
movq -0x8(%rbp), %rax
movswq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x20(%rax)
movq -0x8(%rbp), %rdi
callq 0x42d0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/seanpringle[P]xoat/./textbox.c
// Function: textbox_moveresize
void textbox_moveresize(Textbox *tb, int x, int y, int w, int h)
{
	if (tb->flags & TB_AUTOHEIGHT)
		h = tb->font->ascent + tb->font->descent;

	if (tb->flags & TB_AUTOWIDTH)
		w = tb->extents.width;

	if (x != tb->x || y != tb->y || w != tb->w || h != tb->h)
	{
		tb->x = x; tb->y = y; tb->w = MAX(1, w); tb->h = MAX(1, h);
		XMoveResizeWindow(display, tb->window, tb->x, tb->y, tb->w, tb->h);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x41c2
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movl (%rax), %eax
movq -0x8(%rbp), %rcx
movq 0x28(%rcx), %rcx
addl 0x4(%rcx), %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
andq $0x2, %rax
cmpq $0x0, %rax
je 0x41de
movq -0x8(%rbp), %rax
movzwl 0x70(%rax), %eax
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
movswl 0x18(%rcx), %ecx
cmpl %ecx, %eax
jne 0x421e
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
movswl 0x1a(%rcx), %ecx
cmpl %ecx, %eax
jne 0x421e
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
movswl 0x1c(%rcx), %ecx
cmpl %ecx, %eax
jne 0x421e
movl -0x18(%rbp), %eax
movq -0x8(%rbp), %rcx
movswl 0x1e(%rcx), %ecx
cmpl %ecx, %eax
je 0x42c0
movl -0xc(%rbp), %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x18(%rax)
movl -0x10(%rbp), %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x1a(%rax)
movl $0x1, %eax
cmpl -0x14(%rbp), %eax
jle 0x424e
movl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4254
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x1c(%rax)
movl $0x1, %eax
cmpl -0x18(%rbp), %eax
jle 0x4276
movl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x427c
movl -0x18(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x1e(%rax)
movq 0xf90f(%rip), %rdi      # 0x13ba0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x8(%rbp), %rax
movswl 0x18(%rax), %edx
movq -0x8(%rbp), %rax
movswl 0x1a(%rax), %ecx
movq -0x8(%rbp), %rax
movswl 0x1c(%rax), %r8d
movq -0x8(%rbp), %rax
movswl 0x1e(%rax), %r9d
callq 0x3300
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/seanpringle[P]xoat/./textbox.c
// Function: textbox_extents
void textbox_extents(Textbox *tb)
{
	int length = strlen(tb->text) + strlen(tb->prompt);
	char *line = calloc(length + 1, sizeof(char));
	sprintf(line, "%s%s", tb->prompt, tb->text);
	XftTextExtentsUtf8(display, tb->font, (unsigned char*)line, length, &tb->extents);
	free(line);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x3250
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rdi
callq 0x3250
movq %rax, %rcx
movq -0x20(%rbp), %rax
addq %rcx, %rax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
movl $0x1, %esi
callq 0x3500
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rdx
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rcx
leaq 0xaf69(%rip), %rsi      # 0xf2a2
movb $0x0, %al
callq 0x32d0
movq 0xf859(%rip), %rdi      # 0x13ba0
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rsi
movq -0x18(%rbp), %rdx
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %r8
addq $0x70, %r8
callq 0x3520
movq -0x18(%rbp), %rdi
callq 0x3220
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/seanpringle[P]xoat/./textbox.c
// Function: textbox_free
void textbox_free(Textbox *tb)
{
	if (tb->flags & TB_EDITABLE)
	{
		XDestroyIC(tb->xic);
		XCloseIM(tb->xim);
	}

	if (tb->text) free(tb->text);
	if (tb->prompt) free(tb->prompt);
	if (tb->font) XftFontClose(display, tb->font);

	XDestroyWindow(display, tb->window);
	free(tb);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
andq $0x80000, %rax          # imm = 0x80000
cmpq $0x0, %rax
je 0x4469
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rdi
callq 0x3400
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x3670
movq -0x8(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0x4481
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x3220
movq -0x8(%rbp), %rax
cmpq $0x0, 0x58(%rax)
je 0x4499
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rdi
callq 0x3220
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x44b8
movq 0xf6f5(%rip), %rdi      # 0x13ba0
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0x30a0
movq 0xf6e1(%rip), %rdi      # 0x13ba0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x3280
movq -0x8(%rbp), %rdi
callq 0x3220
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/seanpringle[P]xoat/./textbox.c
// Function: textbox_insert
void textbox_insert(Textbox *tb, int pos, char *str)
{
	int len = strlen(tb->text), slen = strlen(str);
	pos = MAX(0, MIN(len, pos));
	// expand buffer
	tb->text = realloc(tb->text, len + slen + 1);
	// move everything after cursor upward
	char *at = tb->text + pos;
	memmove(at + slen, at, len - pos + 1);
	// insert new str
	memmove(at, str, slen);
	textbox_extents(tb);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x3250
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3250
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x4b2f
movl -0x1c(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0x4b35
movl -0xc(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jle 0x4b45
xorl %eax, %eax
movl %eax, -0x30(%rbp)
jmp 0x4b61
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x4b55
movl -0x1c(%rbp), %eax
movl %eax, -0x34(%rbp)
jmp 0x4b5b
movl -0xc(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rdi
movl -0x1c(%rbp), %eax
addl -0x20(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0x3630
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movslq -0xc(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movslq -0x20(%rbp), %rax
addq %rax, %rdi
movq -0x28(%rbp), %rsi
movl -0x1c(%rbp), %eax
subl -0xc(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdx
callq 0x33a0
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movslq -0x20(%rbp), %rdx
callq 0x33a0
movq -0x8(%rbp), %rdi
callq 0x42d0
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/seanpringle[P]xoat/./textbox.c
// Function: textbox_delete
void textbox_delete(Textbox *tb, int pos, int dlen)
{
	int len = strlen(tb->text);
	pos = MAX(0, MIN(len, pos));
	// move everything after pos+dlen down
	char *at = tb->text + pos;
	memmove(at, at + dlen, len - pos);
	textbox_extents(tb);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x3250
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x4c12
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x4c18
movl -0xc(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jle 0x4c28
xorl %eax, %eax
movl %eax, -0x28(%rbp)
jmp 0x4c44
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x4c38
movl -0x14(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0x4c3e
movl -0xc(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movslq -0xc(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x20(%rbp), %rsi
movslq -0x10(%rbp), %rax
addq %rax, %rsi
movl -0x14(%rbp), %eax
subl -0xc(%rbp), %eax
movslq %eax, %rdx
callq 0x33a0
movq -0x8(%rbp), %rdi
callq 0x42d0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/seanpringle[P]xoat/./textbox.c
// Function: textbox_keypress
int textbox_keypress(Textbox *tb, XEvent *ev)
{
	if (!(tb->flags & TB_EDITABLE)) return 0;

	KeySym key; Status stat; char pad[32];

	int len = XmbLookupString(tb->xic, &ev->xkey, pad, sizeof(pad), &key, &stat);
	pad[len] = 0;

	switch (key)
	{
		case XK_Left      : textbox_cursor_dec(tb);   return 1;
		case XK_Right     : textbox_cursor_inc(tb);   return 1;
		case XK_Home      : textbox_cursor_home(tb);  return 1;
		case XK_End       : textbox_cursor_end(tb);   return 1;
		case XK_Delete    : textbox_cursor_del(tb);   return 1;
		case XK_BackSpace : textbox_cursor_bkspc(tb); return 1;
		case XK_Return    : return -1;
		default:
			if (!iscntrl(*pad))
			{
				textbox_insert(tb, tb->cursor, pad);
				textbox_cursor_inc(tb);
				return 1;
			}
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
andq $0x80000, %rax          # imm = 0x80000
cmpq $0x0, %rax
jne 0x4d6f
movl $0x0, -0x4(%rbp)
jmp 0x4ed4
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rdi
movq -0x18(%rbp), %rsi
leaq -0x50(%rbp), %rdx
movl $0x20, %ecx
leaq -0x20(%rbp), %r8
leaq -0x24(%rbp), %r9
callq 0x34f0
movl %eax, -0x54(%rbp)
movslq -0x54(%rbp), %rax
movb $0x0, -0x50(%rbp,%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x60(%rbp)
subq $0xff08, %rax           # imm = 0xFF08
je 0x4e6e
jmp 0x4db3
movq -0x60(%rbp), %rax
subq $0xff0d, %rax           # imm = 0xFF0D
je 0x4e80
jmp 0x4dc5
movq -0x60(%rbp), %rax
subq $0xff50, %rax           # imm = 0xFF50
je 0x4e35
jmp 0x4dd3
movq -0x60(%rbp), %rax
subq $0xff51, %rax           # imm = 0xFF51
je 0x4e0b
jmp 0x4de1
movq -0x60(%rbp), %rax
subq $0xff53, %rax           # imm = 0xFF53
je 0x4e20
jmp 0x4def
movq -0x60(%rbp), %rax
subq $0xff57, %rax           # imm = 0xFF57
je 0x4e4a
jmp 0x4dfd
movq -0x60(%rbp), %rax
subq $0xffff, %rax           # imm = 0xFFFF
je 0x4e5c
jmp 0x4e89
movq -0x10(%rbp), %rdi
callq 0x4a70
movl $0x1, -0x4(%rbp)
jmp 0x4ed4
movq -0x10(%rbp), %rdi
callq 0x4a40
movl $0x1, -0x4(%rbp)
jmp 0x4ed4
movq -0x10(%rbp), %rdi
callq 0x4aa0
movl $0x1, -0x4(%rbp)
jmp 0x4ed4
movq -0x10(%rbp), %rdi
callq 0x4ac0
movl $0x1, -0x4(%rbp)
jmp 0x4ed4
movq -0x10(%rbp), %rdi
callq 0x4cd0
movl $0x1, -0x4(%rbp)
jmp 0x4ed4
movq -0x10(%rbp), %rdi
callq 0x4d00
movl $0x1, -0x4(%rbp)
jmp 0x4ed4
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4ed4
callq 0x3290
movq (%rax), %rax
movsbl -0x50(%rbp), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2, %eax
cmpl $0x0, %eax
jne 0x4ecb
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movswl 0x20(%rax), %esi
leaq -0x50(%rbp), %rdx
callq 0x4af0
movq -0x10(%rbp), %rdi
callq 0x4a40
movl $0x1, -0x4(%rbp)
jmp 0x4ed4
jmp 0x4ecd
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/seanpringle[P]xoat/./menubox.c
// Function: menubox_add
void menubox_add(Menubox *mb, int id, char *text)
{
	uint slot = mb->box_count++;

	mb->boxes = (Textbox**) realloc(mb->boxes, sizeof(Textbox) * mb->box_count);
	mb->ids   = (int*)      realloc(mb->ids,   sizeof(int)     * mb->box_count);
	mb->show  = (int*)      realloc(mb->show,  sizeof(int)     * mb->box_count);
	
	mb->boxes[slot] = textbox_create(mb->window, TB_AUTOHEIGHT|TB_AUTOWIDTH,
		mb->padding, mb->line_height*(slot+1)+mb->padding, mb->w-(mb->padding*2), 0,
		mb->font, mb->fg_blur, mb->bg_blur, text, NULL);

	mb->ids[slot]   = id;
	mb->show[slot]  = 1;
	
	if (mb->flags & (MB_AUTOWIDTH|MB_AUTOHEIGHT))
		menubox_moveresize(mb, mb->x, mb->y, mb->w, mb->h);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x18(%rbp), %rcx
movl 0x50(%rcx), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0x50(%rcx)
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rdi
movq -0x18(%rbp), %rax
movl 0x50(%rax), %eax
movl %eax, %esi
shlq $0x7, %rsi
callq 0x3630
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x18(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x18(%rbp), %rax
movl 0x50(%rax), %eax
movl %eax, %esi
shlq $0x2, %rsi
callq 0x3630
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x60(%rax)
movq -0x18(%rbp), %rax
movq 0x68(%rax), %rdi
movq -0x18(%rbp), %rax
movl 0x50(%rax), %eax
movl %eax, %esi
shlq $0x2, %rsi
callq 0x3630
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x68(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movw 0x22(%rax), %dx
movq -0x18(%rbp), %rax
movswl 0x20(%rax), %eax
movl -0x2c(%rbp), %ecx
addl $0x1, %ecx
imull %ecx, %eax
movq -0x18(%rbp), %rcx
movswl 0x22(%rcx), %ecx
addl %ecx, %eax
movw %ax, %cx
movq -0x18(%rbp), %rax
movswl 0x1c(%rax), %eax
movq -0x18(%rbp), %rsi
movswl 0x22(%rsi), %esi
shll %esi
subl %esi, %eax
movw %ax, %r8w
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rbx
movq -0x18(%rbp), %rax
movq 0x40(%rax), %r11
movq -0x18(%rbp), %rax
movq 0x48(%rax), %r10
movq -0x28(%rbp), %rax
movl $0x3, %esi
xorl %r9d, %r9d
xorl %r14d, %r14d
movswl %dx, %edx
movswl %cx, %ecx
movswl %r8w, %r8d
movq %rbx, (%rsp)
movq %r11, 0x8(%rsp)
movq %r10, 0x10(%rsp)
movq %rax, 0x18(%rsp)
movq $0x0, 0x20(%rsp)
callq 0x3c30
movq %rax, %rdx
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rax
movl -0x2c(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
movl -0x1c(%rbp), %edx
movq -0x18(%rbp), %rax
movq 0x60(%rax), %rax
movl -0x2c(%rbp), %ecx
movl %edx, (%rax,%rcx,4)
movq -0x18(%rbp), %rax
movq 0x68(%rax), %rax
movl -0x2c(%rbp), %ecx
movl $0x1, (%rax,%rcx,4)
movq -0x18(%rbp), %rax
movq (%rax), %rax
andq $0x3, %rax
cmpq $0x0, %rax
je 0x55d8
movq -0x18(%rbp), %rdi
movq -0x18(%rbp), %rax
movw 0x18(%rax), %si
movq -0x18(%rbp), %rax
movw 0x1a(%rax), %dx
movq -0x18(%rbp), %rax
movw 0x1c(%rax), %cx
movq -0x18(%rbp), %rax
movswl %si, %esi
movswl %dx, %edx
movswl %cx, %ecx
movswl 0x1e(%rax), %r8d
callq 0x5220
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/seanpringle[P]xoat/./menubox.c
// Function: menubox_grab
void menubox_grab(Menubox *mb)
{
	for (uint i = 0; i < 1000; i++)
	{
		if (XGrabKeyboard(display, mb->window, True, GrabModeAsync, GrabModeAsync, CurrentTime) == GrabSuccess)
			break;
		usleep(1000);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x3e8, -0xc(%rbp)      # imm = 0x3E8
jae 0x569d
movq 0xe53d(%rip), %rdi      # 0x13ba0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movl $0x1, %r8d
xorl %eax, %eax
movl %eax, %r9d
movl %r8d, %edx
movl %r8d, %ecx
callq 0x3550
cmpl $0x0, %eax
jne 0x5688
jmp 0x569d
movl $0x3e8, %edi            # imm = 0x3E8
callq 0x3320
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x5653
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/seanpringle[P]xoat/./menubox.c
// Function: menubox_draw
void menubox_draw(Menubox *mb)
{
	textbox_draw(mb->input);
	int filter = strlen(mb->input->text) > 0;

	for (uint i = 0, n = 0; i < mb->box_count; i++)
	{
		if (!filter || mb->show[i])
		{
			textbox_font(mb->boxes[i], mb->font, mb->box_active == i ? mb->fg_focus: mb->fg_blur, mb->box_active == i ? mb->bg_focus: mb->bg_blur);
			textbox_moveresize(mb->boxes[i], mb->padding, mb->line_height*(n+1)+mb->padding, mb->w-(mb->padding*2), 0);
			textbox_show(mb->boxes[i]);	
			textbox_draw(mb->boxes[i]);
			n++;
		}
		else
		{
			textbox_hide(mb->boxes[i]);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rdi
callq 0x44e0
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rax
movq 0x50(%rax), %rdi
callq 0x3250
cmpq $0x0, %rax
seta %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x50(%rcx), %eax
jae 0x584f
cmpl $0x0, -0xc(%rbp)
je 0x5722
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
movl -0x10(%rbp), %ecx
cmpl $0x0, (%rax,%rcx,4)
je 0x582b
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movl -0x10(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl 0x54(%rax), %eax
cmpl -0x10(%rbp), %eax
jne 0x575b
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x5767
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movl 0x54(%rax), %eax
cmpl -0x10(%rbp), %eax
jne 0x5789
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0x5795
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdx
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdi
movq -0x40(%rbp), %rcx
callq 0x3f30
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movl -0x10(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
movq -0x8(%rbp), %rax
movswl 0x22(%rax), %esi
movq -0x8(%rbp), %rax
movswl 0x20(%rax), %edx
movl -0x14(%rbp), %eax
addl $0x1, %eax
imull %eax, %edx
movq -0x8(%rbp), %rax
movswl 0x22(%rax), %eax
addl %eax, %edx
movq -0x8(%rbp), %rax
movswl 0x1c(%rax), %ecx
movq -0x8(%rbp), %rax
movswl 0x22(%rax), %eax
shll %eax
subl %eax, %ecx
xorl %r8d, %r8d
callq 0x4180
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movl -0x10(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
callq 0x43d0
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movl -0x10(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
callq 0x44e0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x583f
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movl -0x10(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
callq 0x4400
jmp 0x5841
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x56f7
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)