// File: /workspace/github_c_makefile_star2_O2/jech[P]dht/dht.c
// Function: dht_periodic
int
dht_periodic(const void *buf, size_t buflen,
             const struct sockaddr *from, int fromlen,
             time_t *tosleep,
             dht_callback_t *callback, void *closure)
{
    dht_gettimeofday(&now, NULL);

    if(buflen > 0) {
        int message;
        struct parsed_message m;
        unsigned short ttid;

        if(is_martian(from))
            goto dontread;

        if(node_blacklisted(from, fromlen)) {
            debugf("Received packet from blacklisted node.\n");
            goto dontread;
        }

        if(((char*)buf)[buflen] != '\0') {
            debugf("Unterminated message.\n");
            errno = EINVAL;
            return -1;
        }

        memset(&m, 0, sizeof(m));
        message = parse_message(buf, buflen, &m);

        if(message < 0 || message == ERROR || id_cmp(m.id, zeroes) == 0) {
            debugf("Unparseable message: ");
            debug_printable(buf, buflen);
            debugf("\n");
            goto dontread;
        }

        if(id_cmp(m.id, myid) == 0) {
            debugf("Received message from self.\n");
            goto dontread;
        }

        if(message > REPLY) {
            /* Rate limit requests. */
            if(!token_bucket()) {
                debugf("Dropping request due to rate limiting.\n");
                goto dontread;
            }
        }

        switch(message) {
        case REPLY:
            if(m.tid_len != 4) {
                debugf("Broken node truncates transaction ids: ");
                debug_printable(buf, buflen);
                debugf("\n");
                /* This is really annoying, as it means that we will
                   time-out all our searches that go through this node.
                   Kill it. */
                blacklist_node(m.id, from, fromlen);
                goto dontread;
            }
            if(tid_match(m.tid, "pn", NULL)) {
                debugf("Pong!\n");
                new_node(m.id, from, fromlen, 2);
            } else if(tid_match(m.tid, "fn", NULL) ||
                      tid_match(m.tid, "gp", NULL)) {
                int gp = 0;
                struct search *sr = NULL;
                if(tid_match(m.tid, "gp", &ttid)) {
                    gp = 1;
                    sr = find_search(ttid, from->sa_family);
                }
                debugf("Nodes found (%d+%d)%s!\n",
                       m.nodes_len/26, m.nodes6_len/38,
                       gp ? " for get_peers" : "");
                if(m.nodes_len % 26 != 0 || m.nodes6_len % 38 != 0) {
                    debugf("Unexpected length for node info!\n");
                    blacklist_node(m.id, from, fromlen);
                } else if(gp && sr == NULL) {
                    debugf("Unknown search!\n");
                    new_node(m.id, from, fromlen, 1);
                } else {
                    int i;
                    new_node(m.id, from, fromlen, 2);
                    for(i = 0; i < m.nodes_len / 26; i++) {
                        unsigned char *ni = m.nodes + i * 26;
                        struct sockaddr_in sin;
                        if(id_cmp(ni, myid) == 0)
                            continue;
                        memset(&sin, 0, sizeof(sin));
                        sin.sin_family = AF_INET;
                        memcpy(&sin.sin_addr, ni + 20, 4);
                        memcpy(&sin.sin_port, ni + 24, 2);
                        new_node(ni, (struct sockaddr*)&sin, sizeof(sin), 0);
                        if(sr && sr->af == AF_INET) {
                            insert_search_node(ni,
                                               (struct sockaddr*)&sin,
                                               sizeof(sin),
                                               sr, 0, NULL, 0);
                        }
                    }
                    for(i = 0; i < m.nodes6_len / 38; i++) {
                        unsigned char *ni = m.nodes6 + i * 38;
                        struct sockaddr_in6 sin6;
                        if(id_cmp(ni, myid) == 0)
                            continue;
                        memset(&sin6, 0, sizeof(sin6));
                        sin6.sin6_family = AF_INET6;
                        memcpy(&sin6.sin6_addr, ni + 20, 16);
                        memcpy(&sin6.sin6_port, ni + 36, 2);
                        new_node(ni, (struct sockaddr*)&sin6, sizeof(sin6), 0);
                        if(sr && sr->af == AF_INET6) {
                            insert_search_node(ni,
                                               (struct sockaddr*)&sin6,
                                               sizeof(sin6),
                                               sr, 0, NULL, 0);
                        }
                    }
                    if(sr)
                        /* Since we received a reply, the number of
                           requests in flight has decreased.  Let's push
                           another request. */
                        search_send_get_peers(sr, NULL);
                }
                if(sr) {
                    insert_search_node(m.id, from, fromlen, sr,
                                       1, m.token, m.token_len);
                    if(m.values_len > 0 || m.values6_len > 0) {
                        debugf("Got values (%d+%d)!\n",
                               m.values_len / 6, m.values6_len / 18);
                        if(callback) {
                            if(m.values_len > 0)
                                (*callback)(closure, DHT_EVENT_VALUES, sr->id,
                                            (void*)m.values, m.values_len);

                            if(m.values6_len > 0)
                                (*callback)(closure, DHT_EVENT_VALUES6, sr->id,
                                            (void*)m.values6, m.values6_len);
                        }
                    }
                }
            } else if(tid_match(m.tid, "ap", &ttid)) {
                struct search *sr;
                debugf("Got reply to announce_peer.\n");
                sr = find_search(ttid, from->sa_family);
                if(!sr) {
                    debugf("Unknown search!\n");
                    new_node(m.id, from, fromlen, 1);
                } else {
                    int i;
                    new_node(m.id, from, fromlen, 2);
                    for(i = 0; i < sr->numnodes; i++)
                        if(id_cmp(sr->nodes[i].id, m.id) == 0) {
                            sr->nodes[i].request_time = 0;
                            sr->nodes[i].reply_time = now.tv_sec;
                            sr->nodes[i].acked = 1;
                            sr->nodes[i].pinged = 0;
                            break;
                        }
                    /* See comment for gp above. */
                    search_send_get_peers(sr, NULL);
                }
            } else {
                debugf("Unexpected reply: ");
                debug_printable(buf, buflen);
                debugf("\n");
            }
            break;
        case PING:
            debugf("Ping (%d)!\n", m.tid_len);
            new_node(m.id, from, fromlen, 1);
            debugf("Sending pong.\n");
            send_pong(from, fromlen, m.tid, m.tid_len);
            break;
        case FIND_NODE:
            debugf("Find node!\n");
            new_node(m.id, from, fromlen, 1);
            debugf("Sending closest nodes (%d).\n", m.want);
            send_closest_nodes(from, fromlen,
                               m.tid, m.tid_len, m.target, m.want,
                               0, NULL, NULL, 0);
            break;
        case GET_PEERS:
            debugf("Get_peers!\n");
            new_node(m.id, from, fromlen, 1);
            if(id_cmp(m.info_hash, zeroes) == 0) {
                debugf("Eek!  Got get_peers with no info_hash.\n");
                send_error(from, fromlen, m.tid, m.tid_len,
                           203, "Get_peers with no info_hash");
                break;
            } else {
                struct storage *st = find_storage(m.info_hash);
                unsigned char token[TOKEN_SIZE];
                make_token(from, 0, token);
                if(st && st->numpeers > 0) {
                     debugf("Sending found%s peers.\n",
                            from->sa_family == AF_INET6 ? " IPv6" : "");
                     send_closest_nodes(from, fromlen,
                                        m.tid, m.tid_len,
                                        m.info_hash, m.want,
                                        from->sa_family, st,
                                        token, TOKEN_SIZE);
                } else {
                    debugf("Sending nodes for get_peers.\n");
                    send_closest_nodes(from, fromlen,
                                       m.tid, m.tid_len, m.info_hash, m.want,
                                       0, NULL, token, TOKEN_SIZE);
                }
            }
            break;
        case ANNOUNCE_PEER:
            debugf("Announce peer!\n");
            new_node(m.id, from, fromlen, 1);
            if(id_cmp(m.info_hash, zeroes) == 0) {
                debugf("Announce_peer with no info_hash.\n");
                send_error(from, fromlen, m.tid, m.tid_len,
                           203, "Announce_peer with no info_hash");
                break;
            }
            if(!token_match(m.token, m.token_len, from)) {
                debugf("Incorrect token for announce_peer.\n");
                send_error(from, fromlen, m.tid, m.tid_len,
                           203, "Announce_peer with wrong token");
                break;
            }
            if(m.implied_port != 0) {
                /* Do this even if port > 0.  That's what the spec says. */
                switch(from->sa_family) {
                case AF_INET:
                    m.port = htons(((struct sockaddr_in*)from)->sin_port);
                    break;
                case AF_INET6:
                    m.port = htons(((struct sockaddr_in6*)from)->sin6_port);
                    break;
                }
            }
            if(m.port == 0) {
                debugf("Announce_peer with forbidden port %d.\n", m.port);
                send_error(from, fromlen, m.tid, m.tid_len,
                           203, "Announce_peer with forbidden port number");
                break;
            }
            storage_store(m.info_hash, from, m.port);
            /* Note that if storage_store failed, we lie to the requestor.
               This is to prevent them from backtracking, and hence
               polluting the DHT. */
            debugf("Sending peer announced.\n");
            send_peer_announced(from, fromlen, m.tid, m.tid_len);
        }
    }

 dontread:
    if(now.tv_sec >= rotate_secrets_time)
        rotate_secrets();

    if(now.tv_sec >= expire_stuff_time) {
        expire_buckets(buckets);
        expire_buckets(buckets6);
        expire_storage();
        expire_searches(callback, closure);
    }

    if(search_time > 0 && now.tv_sec >= search_time) {
        struct search *sr;
        sr = searches;
        while(sr) {
            if(!sr->done &&
               sr->step_time + DHT_SEARCH_RETRANSMIT / 2 + 1 <= now.tv_sec) {
                search_step(sr, callback, closure);
            }
            sr = sr->next;
        }

        search_time = 0;

        sr = searches;
        while(sr) {
            if(!sr->done) {
                time_t tm = sr->step_time +
                    DHT_SEARCH_RETRANSMIT + random() % DHT_SEARCH_RETRANSMIT;
                if(search_time == 0 || search_time > tm)
                    search_time = tm;
            }
            sr = sr->next;
        }
    }

    if(now.tv_sec >= confirm_nodes_time) {
        int soon = 0;

        soon |= bucket_maintenance(AF_INET);
        soon |= bucket_maintenance(AF_INET6);

        if(!soon) {
            if(mybucket_grow_time >= now.tv_sec - 150)
                soon |= neighbourhood_maintenance(AF_INET);
            if(mybucket6_grow_time >= now.tv_sec - 150)
                soon |= neighbourhood_maintenance(AF_INET6);
        }

        /* Given the timeouts in bucket_maintenance, with a 22-bucket
           table, worst case is a ping every 18 seconds (22 buckets plus
           11 buckets overhead for the larger buckets).  Keep the "soon"
           case within 15 seconds, which gives some margin for neighbourhood
           maintenance. */

        if(soon)
            confirm_nodes_time = now.tv_sec + 5 + random() % 10;
        else
            confirm_nodes_time = now.tv_sec + 60 + random() % 120;
    }

    if(confirm_nodes_time > now.tv_sec)
        *tosleep = confirm_nodes_time - now.tv_sec;
    else
        *tosleep = 0;

    if(search_time > 0) {
        if(search_time <= now.tv_sec)
            *tosleep = 0;
        else if(*tosleep > search_time - now.tv_sec)
            *tosleep = search_time - now.tv_sec;
    }

    return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1728, %rsp           # imm = 0x1728
movq %r9, %r14
movq %r8, %r15
movl %ecx, %r12d
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, %rbp
leaq 0x983f(%rip), %rdi      # 0xdc10
xorl %esi, %esi
callq 0x2130
testq %r13, %r13
je 0x440a
movq %rbx, %rdi
callq 0x5abe
testl %eax, %eax
jne 0x440a
movq %rbx, %rdi
movl %r12d, %esi
callq 0x5b5b
testl %eax, %eax
je 0x4764
leaq 0x3f1c(%rip), %rdi      # 0x831f
xorl %eax, %eax
callq 0x3324
movq 0x97ff(%rip), %rax      # 0xdc10
cmpq 0x98a0(%rip), %rax      # 0xdcb8
jl 0x4426
callq 0x41a5
movq 0x97ea(%rip), %rax      # 0xdc10
cmpq 0x9893(%rip), %rax      # 0xdcc0
jl 0x45c5
movq %r15, 0x10(%rsp)
movq 0x9811(%rip), %rdi      # 0xdc50
callq 0x41f2
movq 0x980d(%rip), %rdi      # 0xdc58
callq 0x41f2
leaq 0x9809(%rip), %r13      # 0xdc60
movq $-0x780, %rbp           # imm = 0xF880
leaq 0x447c(%rip), %r12      # 0x88e1
movq %r13, %rax
xorl %ebx, %ebx
leaq 0x28(%rbx), %r15
testq %rbx, %rbx
movq (%rax), %rbx
cmoveq %r13, %r15
testq %rbx, %rbx
je 0x4535
movq 0x9788(%rip), %rax      # 0xdc10
addq %rbp, %rax
movl 0x14(%rbx), %edx
xorl %ecx, %ecx
movslq %ecx, %rsi
shlq $0x5, %rsi
cmpl %edx, %ecx
jge 0x44e0
movq 0x20(%rbx), %rdi
cmpq %rax, (%rdi,%rsi)
jl 0x44ad
incl %ecx
addq $0x20, %rsi
jmp 0x4497
decl %edx
movl %ecx, %r8d
cmpl %ecx, %edx
je 0x44d7
addq %rdi, %rsi
movslq %edx, %rdx
shlq $0x5, %rdx
movups (%rdi,%rdx), %xmm0
movups 0x10(%rdi,%rdx), %xmm1
movups %xmm1, 0x10(%rsi)
movups %xmm0, (%rsi)
movl 0x14(%rbx), %r8d
decl %r8d
movl %r8d, 0x14(%rbx)
movl %r8d, %edx
jmp 0x4490
testl %edx, %edx
jne 0x452c
movq 0x20(%rbx), %rdi
callq 0x2040
movq 0x28(%rbx), %rax
movq %rax, (%r15)
movq %rbx, %rdi
callq 0x2040
movq (%r15), %rbx
movl 0x9767(%rip), %eax      # 0xdc6c
leal -0x1(%rax), %ecx
movl %ecx, 0x975e(%rip)      # 0xdc6c
testl %eax, %eax
jg 0x4478
movq %r12, %rdi
xorl %eax, %eax
callq 0x3324
andl $0x0, 0x9745(%rip)      # 0xdc6c
jmp 0x4478
leaq 0x28(%rbx), %rax
jmp 0x446a
movq 0x96cc(%rip), %r13      # 0xdc08
xorl %ebx, %ebx
leaq 0x96c3(%rip), %r15      # 0xdc08
movq $-0xe88, %r12           # imm = 0xF178
leaq 0xce8(%rbx), %rbp
testq %rbx, %rbx
cmoveq %r15, %rbp
movq %r13, %rbx
testq %r13, %r13
je 0x45b9
movq 0xce8(%rbx), %r13
movq 0x96a0(%rip), %rax      # 0xdc10
addq %r12, %rax
cmpq %rax, 0x8(%rbx)
jge 0x454c
movq %r13, (%rbp)
decl 0x96e5(%rip)            # 0xdc68
testq %r14, %r14
je 0x45af
cmpl $0x0, 0x28(%rbx)
jne 0x45af
xorl %esi, %esi
cmpl $0x2, 0x4(%rbx)
setne %sil
addl $0x3, %esi
leaq 0x10(%rbx), %rdx
movq 0x1760(%rsp), %rdi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq *%r14
movq %rbx, %rdi
callq 0x2040
jmp 0x455a
movq 0x9650(%rip), %rax      # 0xdc10
movq 0x10(%rsp), %r15
movq 0x967c(%rip), %rcx      # 0xdc48
testq %rcx, %rcx
setle %dl
cmpq %rcx, %rax
setl %sil
orb %dl, %sil
pushq $0xa
popq %r12
jne 0x4688
leaq 0x961b(%rip), %rbx      # 0xdc08
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x4628
cmpl $0x0, 0x28(%rbx)
jne 0x461f
movq 0x8(%rbx), %rax
addq $0x6, %rax
cmpq 0x9606(%rip), %rax      # 0xdc10
jg 0x461f
movq %rbx, %rdi
movq %r14, %rsi
movq 0x1760(%rsp), %rdx
callq 0x34bf
addq $0xce8, %rbx            # imm = 0xCE8
jmp 0x45ed
andq $0x0, 0x9618(%rip)      # 0xdc48
leaq 0x95d1(%rip), %rbx      # 0xdc08
xorl %ecx, %ecx
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x4681
cmpl $0x0, 0x28(%rbx)
jne 0x4678
movq 0x8(%rbx), %r14
callq 0x2230
cqto
idivq %r12
leaq (%r14,%rdx), %rax
addq $0xa, %rax
movq 0x95e4(%rip), %rcx      # 0xdc48
testq %rcx, %rcx
je 0x466e
cmpq %rax, %rcx
jle 0x4678
movq %rax, 0x95d3(%rip)      # 0xdc48
movq %rax, %rcx
addq $0xce8, %rbx            # imm = 0xCE8
jmp 0x4639
movq 0x9588(%rip), %rax      # 0xdc10
movq 0x9601(%rip), %rdx      # 0xdc90
cmpq %rdx, %rax
jl 0x4727
pushq $0x2
popq %rdi
callq 0x6d95
movl %eax, %ebx
pushq $0xa
popq %rdi
callq 0x6d95
orl %ebx, %eax
movq 0x955d(%rip), %r14      # 0xdc10
jne 0x4701
leaq -0x96(%r14), %rax
xorl %ebx, %ebx
cmpq %rax, 0x95bb(%rip)      # 0xdc80
jl 0x46df
pushq $0x2
popq %rdi
callq 0x6ff9
movl %eax, %ebx
movq 0x9538(%rip), %r14      # 0xdc10
leaq -0x96(%r14), %rax
cmpq %rax, 0x95a2(%rip)      # 0xdc88
jl 0x46f9
pushq $0xa
popq %rdi
callq 0x6ff9
orl %eax, %ebx
movq 0x9517(%rip), %r14      # 0xdc10
testl %ebx, %ebx
je 0x478a
addq $0x5, %r14
callq 0x2230
cqto
idivq %r12
addq %r14, %rdx
movq %rdx, 0x9577(%rip)      # 0xdc90
movq 0x94f0(%rip), %rax      # 0xdc10
movq 0x9521(%rip), %rcx      # 0xdc48
xorl %esi, %esi
subq %rax, %rdx
cmovgq %rdx, %rsi
movq %rsi, (%r15)
pushq $0x1
popq %rax
testq %rcx, %rcx
jle 0x4752
subq 0x94ce(%rip), %rcx      # 0xdc10
jle 0x474e
cmpq %rcx, %rsi
jle 0x4752
movq %rcx, (%r15)
jmp 0x4752
andq $0x0, (%r15)
addq $0x1728, %rsp           # imm = 0x1728
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpb $0x0, (%rbp,%r13)
je 0x4797
leaq 0x3bd4(%rip), %rdi      # 0x8347
xorl %eax, %eax
callq 0x3324
callq 0x2060
movl $0x16, (%rax)
pushq $-0x1
popq %rax
jmp 0x4752
addq $0x3c, %r14
pushq $0x78
popq %r12
jmp 0x4705
leaq 0x24a(%rsp), %rdi
movl $0x14de, %edx           # imm = 0x14DE
xorl %esi, %esi
callq 0x2140
movslq %r13d, %rsi
cmpb $0x0, (%rbp,%rsi)
movq %r15, 0x10(%rsp)
je 0x47c6
leaq 0x4234(%rip), %rdi      # 0x89f5
jmp 0x49b3
leaq (%rsi,%rbp), %rax
movq %rax, 0x18(%rsp)
leaq 0x424e(%rip), %rdx      # 0x8a24
pushq $0x3
popq %rcx
movq %rbp, %rdi
movq %rsi, 0x20(%rsp)
callq 0x21f0
testq %rax, %rax
movq %rbx, 0x8(%rsp)
movl %r12d, 0x4(%rsp)
je 0x4854
addq $0x3, %rax
leaq 0x40(%rsp), %r12
pushq $0xa
popq %rdx
movq %rax, %rdi
movq %r12, %rsi
callq 0x21e0
movq (%r12), %rsi
testq %rsi, %rsi
je 0x4854
cmpb $0x3a, (%rsi)
jne 0x4854
movq %rax, %rbx
decq %rax
cmpq $0xe, %rax
ja 0x4854
leaq (%rsi,%rbx), %rax
incq %rax
cmpq 0x18(%rsp), %rax
ja 0x49ac
incq %rsi
leaq 0x24a(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rdx
callq 0x2200
movw %bx, 0x10(%r12)
leaq 0x3e26(%rip), %rdx      # 0x8681
pushq $0x7
popq %rcx
movq %rbp, %rdi
movq 0x20(%rsp), %rbx
movq %rbx, %rsi
callq 0x21f0
testq %rax, %rax
je 0x4898
leaq 0x1b(%rax), %rcx
cmpq 0x18(%rsp), %rcx
ja 0x49ac
movl 0x17(%rax), %ecx
movl %ecx, 0x26c(%rsp)
movups 0x7(%rax), %xmm0
movups %xmm0, 0x25c(%rsp)
leaq 0x3dea(%rip), %rdx      # 0x8689
pushq $0xe
popq %rcx
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x21f0
testq %rax, %rax
je 0x48d7
leaq 0x22(%rax), %rcx
cmpq 0x18(%rsp), %rcx
ja 0x49ac
movl 0x1e(%rax), %ecx
movl %ecx, 0x280(%rsp)
movups 0xe(%rax), %xmm0
movups %xmm0, 0x270(%rsp)
leaq 0x414a(%rip), %rdx      # 0x8a28
pushq $0x7
popq %rcx
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x21f0
testq %rax, %rax
je 0x492f
addq $0x7, %rax
leaq 0x40(%rsp), %rbx
pushq $0xa
popq %rdx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x21e0
movq (%rbx), %rcx
testq %rcx, %rcx
je 0x492a
cmpb $0x65, (%rcx)
jne 0x492a
leaq -0x1(%rax), %rcx
cmpq $0xfffe, %rcx           # imm = 0xFFFE
ja 0x492a
movw %ax, 0x298(%rsp)
movq 0x20(%rsp), %rbx
leaq 0x40fa(%rip), %rdx      # 0x8a30
pushq $0x10
popq %rcx
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x21f0
testq %rax, %rax
je 0x4987
addq $0x10, %rax
leaq 0x40(%rsp), %rbx
pushq $0xa
popq %rdx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x21e0
movq (%rbx), %rcx
testq %rcx, %rcx
je 0x4982
cmpb $0x65, (%rcx)
jne 0x4982
leaq -0x1(%rax), %rcx
cmpq $0xfffe, %rcx           # imm = 0xFFFE
ja 0x4982
movw %ax, 0x29a(%rsp)
movq 0x20(%rsp), %rbx
leaq 0x3fa4(%rip), %rdx      # 0x8932
pushq $0xb
popq %rcx
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x21f0
testq %rax, %rax
je 0x4a01
leaq 0x1f(%rax), %rcx
cmpq 0x18(%rsp), %rcx
jbe 0x49eb
leaq 0x4189(%rip), %rdi      # 0x8b3c
xorl %eax, %eax
callq 0x3324
leaq 0x399d(%rip), %rdi      # 0x835e
xorl %eax, %eax
callq 0x3324
movq %rbp, %rdi
movl %r13d, %esi
callq 0x5bc2
leaq 0x393d(%rip), %rdi      # 0x8317
xorl %eax, %eax
callq 0x3324
movq 0x10(%rsp), %r15
jmp 0x440a
movl 0x1b(%rax), %ecx
movl %ecx, 0x294(%rsp)
movups 0xb(%rax), %xmm0
movups %xmm0, 0x284(%rsp)
leaq 0x4039(%rip), %rdx      # 0x8a41
pushq $0x7
popq %rcx
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x21f0
testq %rax, %rax
je 0x4a82
addq $0x7, %rax
leaq 0x40(%rsp), %r12
pushq $0xa
popq %rdx
movq %rax, %rdi
movq %r12, %rsi
callq 0x21e0
movq (%r12), %rsi
testq %rsi, %rsi
je 0x4a7d
cmpb $0x3a, (%rsi)
jne 0x4a7d
movq %rax, %rbx
decq %rax
cmpq $0x7e, %rax
ja 0x4a7d
leaq (%rsi,%rbx), %rax
incq %rax
cmpq 0x18(%rsp), %rax
ja 0x49ac
incq %rsi
leaq 0x29c(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rdx
callq 0x2200
movw %bx, 0x80(%r12)
movq 0x20(%rsp), %rbx
leaq 0x3fc0(%rip), %rdx      # 0x8a49
pushq $0x7
popq %rcx
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x21f0
testq %rax, %rax
je 0x4b05
addq $0x7, %rax
leaq 0x40(%rsp), %r12
pushq $0xa
popq %rdx
movq %rax, %rdi
movq %r12, %rsi
callq 0x21e0
movq (%r12), %rsi
testq %rsi, %rsi
je 0x4b00
cmpb $0x3a, (%rsi)
jne 0x4b00
movq %rax, %rbx
decq %rax
cmpq $0x19f, %rax            # imm = 0x19F
ja 0x4b00
leaq (%rsi,%rbx), %rax
incq %rax
cmpq 0x18(%rsp), %rax
ja 0x49ac
incq %rsi
leaq 0x31e(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rdx
callq 0x2200
movw %bx, 0x1a0(%r12)
movq 0x20(%rsp), %rbx
leaq 0x3f45(%rip), %rdx      # 0x8a51
pushq $0x8
popq %rcx
movq %rbp, %rdi
movq %rbx, %rsi
movq %rcx, 0x28(%rsp)
callq 0x21f0
testq %rax, %rax
je 0x4b8d
addq $0x8, %rax
leaq 0x40(%rsp), %r12
pushq $0xa
popq %rdx
movq %rax, %rdi
movq %r12, %rsi
callq 0x21e0
movq (%r12), %rsi
testq %rsi, %rsi
je 0x4b88
cmpb $0x3a, (%rsi)
jne 0x4b88
movq %rax, %rbx
decq %rax
cmpq $0x25f, %rax            # imm = 0x25F
ja 0x4b88
leaq (%rsi,%rbx), %rax
incq %rax
cmpq 0x18(%rsp), %rax
ja 0x49ac
incq %rsi
leaq 0x4c0(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rdx
callq 0x2200
movw %bx, 0x260(%r12)
movq 0x20(%rsp), %rbx
leaq 0x3e42(%rip), %rdx      # 0x89d6
pushq $0x9
popq %rcx
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x21f0
testq %rax, %rax
je 0x4cbf
movq %rax, %rbx
subl %ebp, %ebx
addl $0x9, %ebx
xorl %r15d, %r15d
movl $0x0, 0x30(%rsp)
movslq %ebx, %r12
addq %rbp, %r12
movq %r12, %rdi
leaq 0x40(%rsp), %rsi
pushq $0xa
popq %rdx
callq 0x21e0
movq 0x40(%rsp), %rcx
testq %rcx, %rcx
je 0x4c90
cmpb $0x3a, (%rcx)
jne 0x4c90
testq %rax, %rax
jle 0x4c90
leaq (%rcx,%rax), %rbx
incq %rbx
cmpq 0x18(%rsp), %rbx
ja 0x49ac
incq %rcx
cmpq $0x12, %rax
je 0x4c49
cmpq $0x6, %rax
jne 0x4c79
cmpl $0x7fa, %r15d           # imm = 0x7FA
jg 0x4c89
movl %r15d, %edx
movslq %r15d, %rax
addl $0x6, %edx
movl %edx, %r15d
movzwl 0x4(%rcx), %edx
leaq 0xf24(%rsp), %rsi
movw %dx, -0x7fe(%rsi,%rax)
movl (%rcx), %ecx
movl %ecx, -0x802(%rsi,%rax)
jmp 0x4c89
movl 0x30(%rsp), %edx
cmpl $0x7ee, %edx            # imm = 0x7EE
jg 0x4c89
movslq %edx, %rax
addl $0x12, %edx
movl %edx, 0x30(%rsp)
movzwl 0x10(%rcx), %edx
leaq 0xf24(%rsp), %rsi
movw %dx, 0x10(%rsi,%rax)
movups (%rcx), %xmm0
movups %xmm0, (%rsi,%rax)
jmp 0x4c89
leaq 0x3dda(%rip), %rdi      # 0x8a5a
movl %eax, %esi
xorl %eax, %eax
callq 0x3324
subl %ebp, %ebx
jmp 0x4bbe
cmpl %r13d, %ebx
jge 0x4c9c
cmpb $0x65, (%r12)
je 0x4caa
leaq 0x3dda(%rip), %rdi      # 0x8a7d
xorl %eax, %eax
callq 0x3324
movw %r15w, 0xf22(%rsp)
movl 0x30(%rsp), %eax
movw %ax, 0x1724(%rsp)
leaq 0x3dda(%rip), %rdx      # 0x8aa0
pushq $0x7
popq %rcx
movq %rbp, %rdi
movq 0x20(%rsp), %rsi
callq 0x21f0
testq %rax, %rax
je 0x4d8c
movq %rax, %rbx
subl %ebp, %ebx
addl $0x7, %ebx
andw $0x0, 0x1726(%rsp)
xorl %r12d, %r12d
movslq %ebx, %r15
movzbl (%rbp,%r15), %esi
leal -0x31(%rsi), %eax
cmpb $0x8, %al
ja 0x4d73
addq %rbp, %r15
cmpb $0x3a, 0x1(%r15)
jne 0x4d7e
leal (%rbx,%rsi), %eax
addl $-0x2e, %eax
cmpl %r13d, %eax
jge 0x4d7e
leaq (%r15,%rsi), %rax
addq $-0x2e, %rax
cmpq 0x18(%rsp), %rax
ja 0x49ac
cmpl $0x32, %esi
jne 0x4d42
leaq 0x2(%r15), %rax
cmpw $0x346e, (%rax)         # imm = 0x346E
je 0x4d56
cmpw $0x366e, (%rax)         # imm = 0x366E
je 0x4d5c
leaq 0x3d5f(%rip), %rdi      # 0x8aa8
xorl %eax, %eax
callq 0x3324
movzbl (%r15), %eax
jmp 0x4d6c
orl $0x1, %r12d
jmp 0x4d60
orl $0x2, %r12d
movw %r12w, 0x1726(%rsp)
pushq $0x32
popq %rax
addl $-0x2e, %ebx
addl %eax, %ebx
jmp 0x4cf3
cmpl %r13d, %ebx
jge 0x4d7e
cmpb $0x65, %sil
je 0x4d8c
leaq 0x3d45(%rip), %rdi      # 0x8aca
xorl %eax, %eax
callq 0x3324
leaq 0x3d58(%rip), %rdx      # 0x8aeb
pushq $0x6
popq %rcx
movq %rbp, %rdi
movq 0x20(%rsp), %rbx
movq %rbx, %rsi
callq 0x21f0
movq %rax, %r12
testq %rax, %rax
je 0x4e6f
pushq $0x1
popq %r15
leaq 0x25c(%rsp), %rbx
leaq 0x346b(%rip), %rsi      # 0x8230
movq %rbx, %rdi
callq 0x33d2
testl %eax, %eax
je 0x49ba
leaq 0x8e54(%rip), %rsi      # 0xdc30
movq %rbx, %rdi
callq 0x33d2
testl %eax, %eax
je 0x4ef4
testq %r12, %r12
je 0x4f00
cmpw $0x4, 0x25a(%rsp)
movq 0x10(%rsp), %r15
jne 0x508b
movzbl 0x24a(%rsp), %eax
cmpl $0x61, %eax
je 0x52e9
cmpl $0x66, %eax
je 0x52c9
cmpl $0x67, %eax
je 0x53a1
cmpl $0x70, %eax
jne 0x5452
cmpb $0x6e, 0x24b(%rsp)
jne 0x5452
leaq 0x3597(%rip), %rdi      # 0x83e1
xorl %eax, %eax
callq 0x3324
pushq $0x2
popq %rcx
leaq 0x25c(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl 0x4(%rsp), %edx
callq 0x5cf4
jmp 0x440a
leaq 0x3c7c(%rip), %rdx      # 0x8af2
pushq $0x6
popq %rcx
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x21f0
testq %rax, %rax
jne 0x49ba
leaq 0x3c65(%rip), %rdx      # 0x8af9
pushq $0x6
popq %rcx
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x21f0
testq %rax, %rax
je 0x49ba
leaq 0x3c4e(%rip), %rdx      # 0x8b00
pushq $0x9
popq %rcx
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x21f0
pushq $0x2
popq %rcx
movl %ecx, %r15d
testq %rax, %rax
jne 0x4db6
leaq 0x3c34(%rip), %rdx      # 0x8b0a
pushq $0xe
popq %rcx
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x21f0
testq %rax, %rax
je 0x5483
pushq $0x3
jmp 0x4db4
leaq 0x3479(%rip), %rdi      # 0x8374
jmp 0x49da
movl 0x8da2(%rip), %eax      # 0xdca8
testl %eax, %eax
jne 0x4f3f
movq 0x8cff(%rip), %rcx      # 0xdc10
movq %rcx, %rax
subq 0x8d85(%rip), %rax      # 0xdca0
imull $0x64, %eax, %edx
cmpq $0x4, %rax
movl $0x190, %eax            # imm = 0x190
cmovll %edx, %eax
movl %eax, 0x8d78(%rip)      # 0xdca8
movq %rcx, 0x8d69(%rip)      # 0xdca0
testl %eax, %eax
je 0x5477
decl %eax
movl %eax, 0x8d61(%rip)      # 0xdca8
addl $-0x2, %r15d
leaq 0x32ce(%rip), %rax      # 0x8220
movslq (%rax,%r15,4), %rcx
addq %rax, %rcx
movabsq $0x3a303264693a32, %r13 # imm = 0x3A303264693A32
movabsq $0x693a3264723a3164, %r15 # imm = 0x693A3264723A3164
jmpq *%rcx
movzwl 0x25a(%rsp), %esi
leaq 0x3509(%rip), %rdi      # 0x8487
xorl %eax, %eax
callq 0x3324
pushq $0x1
popq %rcx
movq %rbx, %rdi
movq 0x8(%rsp), %rsi
movl 0x4(%rsp), %edx
callq 0x5cf4
leaq 0x34f3(%rip), %rdi      # 0x8493
xorl %eax, %eax
callq 0x3324
movzwl 0x25a(%rsp), %ebx
leaq 0x60(%rsp), %rdi
movq %r13, -0x1b(%rdi)
movq %r15, -0x20(%rdi)
movl 0x8c7e(%rip), %eax      # 0xdc40
movl %eax, -0x4(%rdi)
movaps 0x8c64(%rip), %xmm0     # 0xdc30
movups %xmm0, -0x14(%rdi)
leaq 0x3975(%rip), %rdx      # 0x894c
movl $0x1e0, %esi            # imm = 0x1E0
movl %ebx, %ecx
xorl %eax, %eax
callq 0x2110
testl %eax, %eax
js 0x507b
cmpl $0x1e0, %eax            # imm = 0x1E0
ja 0x507b
addl $0x20, %eax
leal (%rax,%rbx), %ebp
cmpl $0x200, %ebp            # imm = 0x200
ja 0x507b
movl %eax, %eax
leaq (%rsp,%rax), %rdi
addq $0x40, %rdi
movl %ebx, %edx
leaq 0x24a(%rsp), %rsi
callq 0x2200
cmpb $0x1, 0x8c56(%rip)      # 0xdc7c
jne 0x504b
cmpl $0x1f7, %ebp            # imm = 0x1F7
ja 0x507b
movl %ebp, %eax
addl $0x9, %ebp
movb 0x8c3d(%rip), %cl       # 0xdc78
movb %cl, 0x48(%rsp,%rax)
movq 0x8c2a(%rip), %rcx      # 0xdc70
movq %rcx, 0x40(%rsp,%rax)
movl %ebp, %eax
leaq (%rsp,%rax), %rdi
addq $0x40, %rdi
movl $0x200, %esi            # imm = 0x200
subl %ebp, %esi
leaq 0x3942(%rip), %rdx      # 0x89a5
xorl %eax, %eax
callq 0x2110
testl %eax, %eax
js 0x507b
addl %ebp, %eax
cmpl $0x200, %eax            # imm = 0x200
jbe 0x58c1
callq 0x2060
movl $0x1c, (%rax)
jmp 0x49e1
leaq 0x3327(%rip), %rdi      # 0x83b9
xorl %eax, %eax
callq 0x3324
movq %rbp, %rdi
movl %r13d, %esi
callq 0x5bc2
leaq 0x326c(%rip), %rdi      # 0x8317
xorl %eax, %eax
callq 0x3324
movq %rbx, %rdi
movq 0x8(%rsp), %rsi
movl 0x4(%rsp), %edx
callq 0x5c17
jmp 0x440a
leaq 0x33fc(%rip), %rdi      # 0x84cb
xorl %eax, %eax
callq 0x3324
pushq $0x1
popq %rcx
movq %rbx, %rdi
movq 0x8(%rsp), %rsi
movl 0x4(%rsp), %edx
callq 0x5cf4
leaq 0x270(%rsp), %rbx
leaq 0x3137(%rip), %rsi      # 0x8230
movq %rbx, %rdi
callq 0x33d2
testl %eax, %eax
je 0x54ee
movq %rbx, %rdi
callq 0x32ee
movq %rax, %rbp
leaq 0x40(%rsp), %r13
movq 0x8(%rsp), %rdi
xorl %esi, %esi
movq %r13, %rdx
callq 0x6d32
testq %rbp, %rbp
je 0x54aa
cmpl $0x0, 0x14(%rbp)
jle 0x54aa
movq 0x8(%rsp), %r15
cmpw $0xa, (%r15)
leaq 0x33e7(%rip), %rax      # 0x8533
leaq 0x31c5(%rip), %rsi      # 0x8318
cmoveq %rax, %rsi
leaq 0x33bd(%rip), %rdi      # 0x851b
xorl %eax, %eax
callq 0x3324
leaq 0x24a(%rsp), %rdx
movzwl 0x10(%rdx), %ecx
movzwl 0x14dc(%rdx), %r9d
movzwl (%r15), %eax
movq %r15, %rdi
movl 0x4(%rsp), %esi
movq %rbx, %r8
pushq $0x8
pushq %r13
pushq %rbp
pushq %rax
jmp 0x54e0
leaq 0x3309(%rip), %rdi      # 0x84a2
xorl %eax, %eax
callq 0x3324
pushq $0x1
popq %rcx
movq %rbx, %rdi
movq 0x8(%rsp), %r15
movq %r15, %rsi
movl 0x4(%rsp), %r12d
movl %r12d, %edx
callq 0x5cf4
leaq 0x284(%rsp), %rbx
movzwl 0x14a2(%rbx), %ebp
leaq 0x32dd(%rip), %rdi      # 0x84ae
movl %ebp, %esi
xorl %eax, %eax
callq 0x3324
movzwl -0x2a(%rbx), %ecx
subq $0x20, %rsp
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rsp)
andl $0x0, 0x18(%rsp)
andl $0x0, (%rsp)
leaq 0x26a(%rsp), %rdx
movq %r15, %rdi
movl %r12d, %esi
movq %rbx, %r8
movl %ebp, %r9d
jmp 0x54e0
leaq 0x3344(%rip), %rdi      # 0x8557
xorl %eax, %eax
callq 0x3324
pushq $0x1
popq %rcx
movq %rbx, %rdi
movq 0x8(%rsp), %rsi
movl 0x4(%rsp), %edx
callq 0x5cf4
leaq 0x270(%rsp), %rdi
leaq 0x2ff3(%rip), %rsi      # 0x8230
movq %rdi, %rbp
callq 0x33d2
testl %eax, %eax
je 0x5511
cmpw $0x8, 0x31c(%rsp)
jne 0x52a3
leaq 0x29c(%rsp), %r15
leaq 0x40(%rsp), %r12
movq 0x8(%rsp), %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x6d32
movq (%r12), %rax
cmpq (%r15), %rax
je 0x559d
pushq $0x1
popq %rsi
leaq 0x40(%rsp), %r12
movq 0x8(%rsp), %rdi
movq %r12, %rdx
callq 0x6d32
movq (%r12), %rax
cmpq (%r15), %rax
je 0x559d
leaq 0x32ff(%rip), %rdi      # 0x85a9
xorl %eax, %eax
callq 0x3324
leaq 0x24a(%rsp), %rdx
movzwl 0x10(%rdx), %ecx
leaq 0x3309(%rip), %r8       # 0x85cd
jmp 0x5532
cmpb $0x6e, 0x24b(%rsp)
jne 0x5452
leaq 0x303a(%rip), %rcx      # 0x8318
xorl %r15d, %r15d
xorl %r13d, %r13d
jmp 0x53d1
cmpb $0x70, 0x24b(%rsp)
jne 0x5452
movzwl 0x24c(%rsp), %ebp
leaq 0x3151(%rip), %rdi      # 0x8457
xorl %r15d, %r15d
xorl %eax, %eax
callq 0x3324
movq 0x8(%rsp), %rax
movzwl (%rax), %esi
movl %ebp, %edi
callq 0x61e9
testq %rax, %rax
je 0x5606
movq %rax, %r13
pushq $0x2
popq %rcx
movq %rbx, %rdi
movq 0x8(%rsp), %rsi
movl 0x4(%rsp), %edx
callq 0x5cf4
movl 0xce0(%r13), %eax
movq %r13, %rdi
addq $0x30, %rdi
testl %eax, %eax
cmovgl %eax, %r15d
incq %r15
decq %r15
je 0x5392
leaq 0xe8(%rdi), %r12
movq %rbx, %rsi
callq 0x33d2
movq %r12, %rdi
testl %eax, %eax
jne 0x5356
andq $0x0, -0x48(%r12)
movq 0x8892(%rip), %rax      # 0xdc10
movq %rax, -0x40(%r12)
movl $0x1, -0x4(%r12)
andl $0x0, -0x38(%r12)
movq %r13, %rdi
xorl %esi, %esi
callq 0x63da
jmp 0x49e1
cmpb $0x70, 0x24b(%rsp)
jne 0x5452
movzwl 0x24c(%rsp), %edi
movq 0x8(%rsp), %rax
movzwl (%rax), %esi
callq 0x61e9
movq %rax, %r13
leaq 0x3032(%rip), %rcx      # 0x8400
movb $0x1, %r15b
movzwl 0x4be(%rsp), %eax
movw $0x1a, %si
xorl %edx, %edx
divw %si
movl %eax, %esi
movl %edx, %ebx
movzwl 0x720(%rsp), %eax
movw $0x26, %di
xorl %edx, %edx
divw %di
movl %edx, %ebp
movzwl %si, %esi
movzwl %ax, %edx
leaq 0x2fe2(%rip), %rdi      # 0x83e8
xorl %eax, %eax
callq 0x3324
orw %bx, %bp
je 0x5545
leaq 0x2ff2(%rip), %rdi      # 0x840f
xorl %eax, %eax
callq 0x3324
leaq 0x25c(%rsp), %rdi
movq 0x8(%rsp), %rbx
movq %rbx, %rsi
movl 0x4(%rsp), %ebp
movl %ebp, %edx
callq 0x5c17
testq %r13, %r13
movq 0x10(%rsp), %r15
jne 0x57bc
jmp 0x440a
leaq 0x301b(%rip), %rdi      # 0x8474
xorl %eax, %eax
callq 0x3324
movq %rbp, %rdi
movl %r13d, %esi
callq 0x5bc2
leaq 0x2ea5(%rip), %rdi      # 0x8317
jmp 0x4403
leaq 0x2f13(%rip), %rdi      # 0x8391
jmp 0x49da
leaq 0x368f(%rip), %rdx      # 0x8b19
pushq $0xe
popq %rcx
movq %rbp, %rdi
movq 0x20(%rsp), %rsi
callq 0x21f0
testq %rax, %rax
je 0x5576
pushq $0x4
jmp 0x4db4
leaq 0x3088(%rip), %rdi      # 0x8539
xorl %eax, %eax
callq 0x3324
leaq 0x24a(%rsp), %rdx
movzwl 0x10(%rdx), %ecx
movzwl 0x14dc(%rdx), %r9d
movq 0x8(%rsp), %rdi
movl 0x4(%rsp), %esi
movq %rbx, %r8
pushq $0x8
pushq %r13
pushq $0x0
pushq $0x0
callq 0x661e
addq $0x20, %rsp
jmp 0x49e1
leaq 0x2fe2(%rip), %rdi      # 0x84d7
xorl %eax, %eax
callq 0x3324
leaq 0x24a(%rsp), %rdx
movzwl 0x10(%rdx), %ecx
leaq 0x2ff0(%rip), %r8       # 0x84ff
jmp 0x5532
leaq 0x304f(%rip), %rdi      # 0x8567
xorl %eax, %eax
callq 0x3324
leaq 0x24a(%rsp), %rdx
movzwl 0x10(%rdx), %ecx
leaq 0x3057(%rip), %r8       # 0x8589
movq 0x8(%rsp), %rdi
movl 0x4(%rsp), %esi
callq 0x6bc6
jmp 0x49e1
testq %r13, %r13
sete %al
andb %al, %r15b
cmpb $0x1, %r15b
jne 0x562d
leaq 0x2ed2(%rip), %rdi      # 0x8431
xorl %eax, %eax
callq 0x3324
pushq $0x1
popq %rcx
leaq 0x25c(%rsp), %rdi
jmp 0x561a
leaq 0x35ab(%rip), %rdx      # 0x8b28
pushq $0x13
popq %rcx
movq %rbp, %rdi
movq 0x20(%rsp), %rsi
callq 0x21f0
testq %rax, %rax
je 0x49ba
pushq $0x5
jmp 0x4db4
cmpw $0x0, 0x29a(%rsp)
je 0x55cd
movq 0x8(%rsp), %rax
movzwl (%rax), %eax
orl $0x8, %eax
cmpl $0xa, %eax
jne 0x55cd
movq 0x8(%rsp), %rax
movzwl 0x2(%rax), %eax
rolw $0x8, %ax
movw %ax, 0x298(%rsp)
movzwl 0x298(%rsp), %eax
testw %ax, %ax
je 0x5899
movl %eax, %ebx
movq 0x8(%rsp), %rax
movzwl (%rax), %eax
cmpl $0x2, %eax
je 0x58de
cmpl $0xa, %eax
jne 0x5a82
pushq $0x10
popq %rax
movl %eax, 0x18(%rsp)
jmp 0x58ed
leaq 0x2e24(%rip), %rdi      # 0x8431
xorl %eax, %eax
callq 0x3324
pushq $0x1
popq %rcx
movq %rbx, %rdi
movq 0x8(%rsp), %rsi
movl 0x4(%rsp), %edx
callq 0x5cf4
jmp 0x49e1
pushq $0x2
popq %rcx
leaq 0x25c(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl 0x4(%rsp), %edx
callq 0x5cf4
leaq 0x31e(%rsp), %rbx
movw $0x1a, %r15w
leaq 0x85d6(%rip), %rbp      # 0xdc30
xorl %r12d, %r12d
movzwl 0x4be(%rsp), %eax
xorl %edx, %edx
divw %r15w
movzwl %ax, %eax
cmpq %rax, %r12
jae 0x56ea
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x33d2
testl %eax, %eax
je 0x56de
andq $0x0, 0x48(%rsp)
movw $0x2, 0x40(%rsp)
movl 0x14(%rbx), %eax
movl %eax, 0x44(%rsp)
movzwl 0x18(%rbx), %eax
movw %ax, 0x42(%rsp)
movq %rbx, %rdi
leaq 0x40(%rsp), %rsi
pushq $0x10
popq %rdx
xorl %ecx, %ecx
callq 0x5cf4
testq %r13, %r13
je 0x56de
cmpl $0x2, 0x4(%r13)
jne 0x56de
subq $0x8, %rsp
movq %rbx, %rdi
leaq 0x48(%rsp), %rsi
pushq $0x10
popq %rdx
movq %r13, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq $0x0
callq 0x620b
popq %rcx
popq %rdx
incq %r12
addq $0x1a, %rbx
jmp 0x565d
leaq 0x4c0(%rsp), %rbx
leaq 0x48(%rsp), %r15
movw $0x26, %r12w
xorl %ebp, %ebp
movzwl 0x720(%rsp), %eax
xorl %edx, %edx
divw %r12w
movzwl %ax, %eax
cmpq %rax, %rbp
jae 0x579b
movq %rbx, %rdi
leaq 0x850e(%rip), %rsi      # 0xdc30
callq 0x33d2
testl %eax, %eax
je 0x578f
xorps %xmm0, %xmm0
movups %xmm0, -0x4(%r15)
andq $0x0, 0xc(%r15)
movw $0xa, 0x40(%rsp)
movups 0x14(%rbx), %xmm0
movups %xmm0, (%r15)
movzwl 0x24(%rbx), %eax
movw %ax, 0x42(%rsp)
movq %rbx, %rdi
leaq 0x40(%rsp), %rsi
pushq $0x1c
popq %rdx
xorl %ecx, %ecx
callq 0x5cf4
testq %r13, %r13
je 0x578f
cmpl $0xa, 0x4(%r13)
jne 0x578f
subq $0x8, %rsp
movq %rbx, %rdi
leaq 0x48(%rsp), %rsi
pushq $0x1c
popq %rdx
movq %r13, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq $0x0
callq 0x620b
popq %rcx
popq %rdx
incq %rbp
addq $0x26, %rbx
jmp 0x56fe
testq %r13, %r13
movq 0x10(%rsp), %r15
movl 0x4(%rsp), %ebp
movq 0x8(%rsp), %rbx
je 0x440a
movq %r13, %rdi
xorl %esi, %esi
callq 0x63da
movq %rbx, %rsi
leaq 0x29c(%rsp), %rbx
movzwl 0x80(%rbx), %eax
subq $0x8, %rsp
pushq $0x1
popq %r8
leaq 0x264(%rsp), %rdi
movl %ebp, %edx
movq %r13, %rcx
movq %rbx, %r9
pushq %rax
callq 0x620b
popq %rcx
popq %rdx
movzwl 0xc86(%rbx), %eax
movzwl 0x1488(%rbx), %ecx
movl %eax, %edx
orw %cx, %dx
je 0x440a
movw $0x6, %si
xorl %edx, %edx
divw %si
movzwl %ax, %esi
movw $0x12, %di
movl %ecx, %eax
xorl %edx, %edx
divw %di
movzwl %ax, %edx
leaq 0x2c1a(%rip), %rdi      # 0x8442
xorl %eax, %eax
callq 0x3324
testq %r14, %r14
je 0x440a
movzwl 0xf22(%rsp), %r8d
testq %r8, %r8
je 0x5860
leaq 0x10(%r13), %rdx
leaq 0x722(%rsp), %rcx
pushq $0x1
popq %rsi
movq 0x1760(%rsp), %rdi
callq *%r14
movzwl 0x1724(%rsp), %r8d
testq %r8, %r8
movq 0x10(%rsp), %r15
je 0x440a
addq $0x10, %r13
leaq 0xf24(%rsp), %rcx
pushq $0x2
popq %rsi
movq 0x1760(%rsp), %rdi
movq %r13, %rdx
callq *%r14
jmp 0x440a
leaq 0x2d4c(%rip), %rdi      # 0x85ec
xorl %esi, %esi
xorl %eax, %eax
callq 0x3324
leaq 0x24a(%rsp), %rdx
movzwl 0x10(%rdx), %ecx
leaq 0x2d57(%rip), %r8       # 0x8613
jmp 0x5532
movl %eax, %esi
leaq 0x40(%rsp), %rdi
xorl %edx, %edx
movq 0x8(%rsp), %rcx
movl 0x4(%rsp), %r8d
callq 0x7516
jmp 0x49e1
pushq $0x4
popq %rax
movl %eax, 0x18(%rsp)
pushq $0x4
popq %rax
movq %rax, 0x28(%rsp)
movq %rbp, %rdi
callq 0x32ee
movq %rax, %r13
testq %rax, %rax
je 0x598d
movq 0x28(%rsp), %rax
addq 0x8(%rsp), %rax
movq %rax, 0x28(%rsp)
movl 0x14(%r13), %ecx
movl 0x18(%rsp), %eax
movq %rax, 0x20(%rsp)
xorl %r15d, %r15d
testl %ecx, %ecx
movl $0x0, %ebp
movq %rcx, 0x38(%rsp)
cmovgl %ecx, %ebp
movq %rbp, 0x30(%rsp)
shlq $0x5, %rbp
cmpq %r15, %rbp
je 0x597a
movq 0x20(%r13), %r12
cmpw %bx, 0x1a(%r12,%r15)
jne 0x5974
movzwl 0x18(%r12,%r15), %eax
cmpl %eax, 0x18(%rsp)
jne 0x5974
leaq (%r12,%r15), %rdi
addq $0x8, %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x2260
testl %eax, %eax
je 0x5a77
addq $0x20, %r15
jmp 0x5938
movl 0x18(%r13), %eax
cmpl %eax, 0x30(%rsp)
jge 0x59e9
movq 0x20(%r13), %rax
jmp 0x5a2f
movl 0x82d8(%rip), %r15d     # 0xdc6c
cmpl $0x3fff, %r15d          # imm = 0x3FFF
jg 0x5a82
pushq $0x1
popq %rdi
pushq $0x30
popq %rsi
callq 0x21a0
testq %rax, %rax
je 0x5a82
movq %rax, %r13
movl 0x10(%rbp), %eax
movl %eax, 0x10(%r13)
movups (%rbp), %xmm0
movups %xmm0, (%r13)
movq 0x8291(%rip), %rax      # 0xdc60
movq %rax, 0x28(%r13)
movq %r13, 0x8286(%rip)      # 0xdc60
incl %r15d
movl %r15d, 0x8288(%rip)     # 0xdc6c
jmp 0x5901
cmpl $0x7ff, %eax            # imm = 0x7FF
jg 0x5a82
leal (%rax,%rax), %ecx
movl $0x800, %ebp            # imm = 0x800
cmpl %ebp, %ecx
cmovll %ecx, %ebp
testl %eax, %eax
pushq $0x2
popq %rax
cmovel %eax, %ebp
movq 0x20(%r13), %rdi
movslq %ebp, %rsi
shlq $0x5, %rsi
callq 0x2270
testq %rax, %rax
je 0x5a82
movq %rax, 0x20(%r13)
movl %ebp, 0x18(%r13)
movl 0x14(%r13), %ecx
movq %rcx, 0x38(%rsp)
movq 0x38(%rsp), %rdx
leal 0x1(%rdx), %ecx
movl %ecx, 0x14(%r13)
movslq %edx, %rcx
shlq $0x5, %rcx
movq 0x81c7(%rip), %rdx      # 0xdc10
leaq (%rax,%rcx), %r15
addq $0x8, %r15
movq %rdx, -0x8(%r15)
movl 0x18(%rsp), %eax
movw %ax, 0x10(%r15)
movq %r15, %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x2200
movw %bx, 0x12(%r15)
jmp 0x5a82
movq 0x8192(%rip), %rax      # 0xdc10
movq %rax, (%r12,%r15)
leaq 0x2bb3(%rip), %rdi      # 0x863c
xorl %eax, %eax
callq 0x3324
movzwl 0x25a(%rsp), %ebx
leaq 0x60(%rsp), %rdi
movabsq $0x3a303264693a32, %rax # imm = 0x3A303264693A32
movq %rax, -0x1b(%rdi)
movabsq $0x693a3264723a3164, %rax # imm = 0x693A3264723A3164
movq %rax, -0x20(%rdi)
jmp 0x4fbc