// File: /workspace/github_c_makefile_star2_O1/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 $0x1538, %rsp           # imm = 0x1538
movq %r9, 0x48(%rsp)
movq %r8, %r14
movl %ecx, %ebx
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
leaq 0x93a2(%rip), %rdi      # 0xdc10
xorl %esi, %esi
callq 0x2130
testq %r13, %r13
je 0x48a6
movq %r12, %rdi
callq 0x5de1
testl %eax, %eax
jne 0x48a6
movq %r12, %rdi
movl %ebx, %esi
callq 0x5e5d
testl %eax, %eax
je 0x4c52
leaq 0x4a90(%rip), %rdi      # 0x932f
xorl %eax, %eax
callq 0x366b
movq 0x9363(%rip), %rax      # 0xdc10
cmpq 0x9404(%rip), %rax      # 0xdcb8
jl 0x48bb
callq 0x45b1
movq %r14, 0x8(%rsp)
movq 0x9349(%rip), %rax      # 0xdc10
cmpq 0x93f2(%rip), %rax      # 0xdcc0
jl 0x4a6d
movq 0x9375(%rip), %rdi      # 0xdc50
callq 0x461e
movq 0x9371(%rip), %rdi      # 0xdc58
callq 0x461e
movq 0x936d(%rip), %r13      # 0xdc60
testq %r13, %r13
je 0x49d3
movq $-0x780, %rbp           # imm = 0xF880
leaq 0x9356(%rip), %rbx      # 0xdc60
leaq 0x4fe0(%rip), %r12      # 0x98f1
xorl %r15d, %r15d
movl 0x14(%r13), %edx
testl %edx, %edx
jle 0x496d
movq 0x92ed(%rip), %rax      # 0xdc10
addq %rbp, %rax
xorl %ecx, %ecx
movq 0x20(%r13), %rdi
movslq %ecx, %rsi
shlq $0x5, %rsi
cmpq %rax, (%rdi,%rsi)
jge 0x4963
decl %edx
cmpl %edx, %ecx
je 0x495d
addq %rdi, %rsi
movslq %edx, %rdx
shlq $0x5, %rdx
movdqu (%rdi,%rdx), %xmm0
movdqu 0x10(%rdi,%rdx), %xmm1
movdqu %xmm1, 0x10(%rsi)
movdqu %xmm0, (%rsi)
decl 0x14(%r13)
jmp 0x4965
incl %ecx
movl 0x14(%r13), %edx
cmpl %edx, %ecx
jl 0x4928
testl %edx, %edx
je 0x497a
movq 0x28(%r13), %r14
movq %r13, %r15
jmp 0x49c7
movq 0x20(%r13), %rdi
callq 0x2040
leaq 0x28(%r15), %r14
testq %r15, %r15
movq 0x28(%r13), %rax
cmoveq %rbx, %r14
movq %rax, (%r14)
movq %r13, %rdi
callq 0x2040
movq (%r14), %r14
movl 0x92c6(%rip), %eax      # 0xdc6c
leal -0x1(%rax), %ecx
movl %ecx, 0x92bd(%rip)      # 0xdc6c
testl %eax, %eax
jg 0x49c7
movq %r12, %rdi
xorl %eax, %eax
callq 0x366b
movl $0x0, 0x92a5(%rip)      # 0xdc6c
movq %r14, %r13
testq %r14, %r14
jne 0x4914
movq 0x922e(%rip), %r12      # 0xdc08
testq %r12, %r12
je 0x4a6d
xorl %ebx, %ebx
movq $-0xe88, %r15           # imm = 0xF178
leaq 0x9215(%rip), %r13      # 0xdc08
movq 0xce8(%r12), %rbp
movq 0x920e(%rip), %rax      # 0xdc10
addq %r15, %rax
cmpq %rax, 0x8(%r12)
jge 0x4a62
leaq 0xce8(%rbx), %rax
testq %rbx, %rbx
cmoveq %r13, %rax
movq %rbp, (%rax)
decl 0x9245(%rip)            # 0xdc68
cmpq $0x0, 0x48(%rsp)
je 0x4a58
cmpl $0x0, 0x28(%r12)
jne 0x4a58
xorl %esi, %esi
cmpl $0x2, 0x4(%r12)
setne %sil
addl $0x3, %esi
leaq 0x10(%r12), %rdx
movq 0x1570(%rsp), %rdi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq *0x48(%rsp)
movq %r12, %rdi
callq 0x2040
jmp 0x4a65
movq %r12, %rbx
movq %rbp, %r12
testq %rbp, %rbp
jne 0x49f3
movq 0x91d4(%rip), %rax      # 0xdc48
testq %rax, %rax
jle 0x4b49
cmpq %rax, 0x918c(%rip)      # 0xdc10
jl 0x4b49
movq 0x9177(%rip), %r12      # 0xdc08
testq %r12, %r12
je 0x4acf
cmpl $0x0, 0x28(%r12)
jne 0x4ac5
movq 0x8(%r12), %rax
addq $0x6, %rax
cmpq 0x9162(%rip), %rax      # 0xdc10
jg 0x4ac5
movq %r12, %rdi
movq 0x48(%rsp), %rsi
movq 0x1570(%rsp), %rdx
callq 0x37db
movq 0xce8(%r12), %r12
jmp 0x4a91
movq $0x0, 0x916e(%rip) # 0xdc48
movq 0x9127(%rip), %rbx      # 0xdc08
testq %rbx, %rbx
je 0x4b49
movabsq $0x6666666666666667, %r14 # imm = 0x6666666666666667
cmpl $0x0, 0x28(%rbx)
jne 0x4b3d
movq 0x8(%rbx), %r15
callq 0x2230
movq %rax, %rcx
imulq %r14
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x2, %rdx
addq %rax, %rdx
addq %rdx, %rdx
leaq (%rdx,%rdx,4), %rax
subq %rax, %rcx
leaq (%r15,%rcx), %rax
addq $0xa, %rax
movq 0x911c(%rip), %rcx      # 0xdc48
testq %rcx, %rcx
je 0x4b36
cmpq %rax, %rcx
jle 0x4b3d
movq %rax, 0x910b(%rip)      # 0xdc48
movq 0xce8(%rbx), %rbx
testq %rbx, %rbx
jne 0x4af0
movq 0x90c0(%rip), %rax      # 0xdc10
cmpq 0x9139(%rip), %rax      # 0xdc90
jl 0x4bf9
movl $0x2, %edi
callq 0x7724
movl %eax, %r14d
movl $0xa, %edi
callq 0x7724
movl %eax, %ebp
orl %r14d, %ebp
jne 0x4bbf
movq $-0x96, %rbx
movq 0x9087(%rip), %rax      # 0xdc10
addq %rbx, %rax
xorl %ebp, %ebp
cmpq %rax, 0x90eb(%rip)      # 0xdc80
jl 0x4ba3
movl $0x2, %edi
callq 0x7a5a
movl %eax, %ebp
addq 0x9066(%rip), %rbx      # 0xdc10
cmpq %rbx, 0x90d7(%rip)      # 0xdc88
jl 0x4bbf
movl $0xa, %edi
callq 0x7a5a
orl %eax, %ebp
testl %ebp, %ebp
movl $0x3c, %eax
movl $0x5, %ebx
cmoveq %rax, %rbx
movl $0x78, %eax
movl $0xa, %r14d
cmoveq %rax, %r14
addq 0x902b(%rip), %rbx      # 0xdc10
callq 0x2230
cqto
idivq %r14
addq %rbx, %rdx
movq %rdx, 0x9097(%rip)      # 0xdc90
movq 0x9090(%rip), %rax      # 0xdc90
xorl %ecx, %ecx
subq 0x9007(%rip), %rax      # 0xdc10
cmovgq %rax, %rcx
movq 0x8(%rsp), %rsi
movq %rcx, (%rsi)
movq 0x902c(%rip), %rdx      # 0xdc48
movl $0x1, %eax
testq %rdx, %rdx
jle 0x4c40
subq 0x8fe3(%rip), %rdx      # 0xdc10
jle 0x4c39
cmpq %rdx, %rcx
jle 0x4c40
movq %rdx, (%rsi)
jmp 0x4c40
movq $0x0, (%rsi)
addq $0x1538, %rsp           # imm = 0x1538
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpb $0x0, (%rbp,%r13)
je 0x4c7a
leaq 0x46f6(%rip), %rdi      # 0x9357
xorl %eax, %eax
callq 0x366b
callq 0x2060
movl $0x16, (%rax)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x4c40
leaq 0x5a(%rsp), %rdi
movl $0x14de, %edx           # imm = 0x14DE
xorl %esi, %esi
callq 0x2140
movslq %r13d, %r15
cmpb $0x0, (%rbp,%r15)
je 0x4caf
leaq 0x4d68(%rip), %rdi      # 0x9a05
xorl %eax, %eax
callq 0x366b
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
jmp 0x5424
leaq (%r15,%rbp), %rax
movq %rax, 0x10(%rsp)
leaq 0x4d75(%rip), %rdx      # 0x9a34
movl $0x3, %ecx
movq %rbp, %rdi
movq %r15, %rsi
callq 0x21f0
testq %rax, %rax
movl %ebx, 0x4(%rsp)
je 0x4d3f
addq $0x3, %rax
leaq 0x20(%rsp), %rsi
movq %rax, %rdi
movl $0xa, %edx
callq 0x21e0
leaq 0x20(%rsp), %rcx
movq (%rcx), %rsi
testq %rsi, %rsi
je 0x4d3f
cmpb $0x3a, (%rsi)
jne 0x4d3f
leaq -0x1(%rax), %rcx
cmpq $0xe, %rcx
ja 0x4d3f
leaq (%rsi,%rax), %rcx
incq %rcx
cmpq 0x10(%rsp), %rcx
ja 0x540c
incq %rsi
leaq 0x5a(%rsp), %rdi
movq %rax, %rdx
movq %rax, 0x8(%rsp)
callq 0x2200
leaq 0x5a(%rsp), %rax
movq 0x8(%rsp), %rcx
movw %cx, 0x10(%rax)
leaq 0x494b(%rip), %rdx      # 0x9691
movl $0x7, %ecx
movq %rbp, %rdi
movq %r15, %rsi
callq 0x21f0
testq %rax, %rax
je 0x4d80
leaq 0x1b(%rax), %rcx
cmpq 0x10(%rsp), %rcx
ja 0x540c
movl 0x17(%rax), %ecx
movl %ecx, 0x7c(%rsp)
movdqu 0x7(%rax), %xmm0
movdqu %xmm0, 0x6c(%rsp)
movl 0x4(%rsp), %ebx
leaq 0x4912(%rip), %rdx      # 0x9699
movl $0xe, %ecx
movq %rbp, %rdi
movq %r15, %rsi
callq 0x21f0
testq %rax, %rax
je 0x4dc7
leaq 0x22(%rax), %rcx
cmpq 0x10(%rsp), %rcx
ja 0x540c
movl 0x1e(%rax), %ecx
movl %ecx, 0x90(%rsp)
movdqu 0xe(%rax), %xmm0
movdqu %xmm0, 0x80(%rsp)
movl 0x4(%rsp), %ebx
leaq 0x4c6a(%rip), %rdx      # 0x9a38
movl $0x7, %ecx
movq %rbp, %rdi
movq %r15, %rsi
callq 0x21f0
testq %rax, %rax
je 0x4e20
addq $0x7, %rax
leaq 0x20(%rsp), %rsi
movq %rax, %rdi
movl $0xa, %edx
callq 0x21e0
leaq 0x20(%rsp), %rcx
movq (%rcx), %rcx
testq %rcx, %rcx
je 0x4e20
cmpb $0x65, (%rcx)
jne 0x4e20
leaq -0x1(%rax), %rcx
cmpq $0xfffe, %rcx           # imm = 0xFFFE
ja 0x4e20
movw %ax, 0xa8(%rsp)
leaq 0x4c19(%rip), %rdx      # 0x9a40
movl $0x10, %ecx
movq %rbp, %rdi
movq %r15, %rsi
callq 0x21f0
testq %rax, %rax
je 0x4e79
addq $0x10, %rax
leaq 0x20(%rsp), %rsi
movq %rax, %rdi
movl $0xa, %edx
callq 0x21e0
leaq 0x20(%rsp), %rcx
movq (%rcx), %rcx
testq %rcx, %rcx
je 0x4e79
cmpb $0x65, (%rcx)
jne 0x4e79
leaq -0x1(%rax), %rcx
cmpq $0xfffe, %rcx           # imm = 0xFFFE
ja 0x4e79
movw %ax, 0xaa(%rsp)
leaq 0x4ac2(%rip), %rdx      # 0x9942
movl $0xb, %ecx
movq %rbp, %rdi
movq %r15, %rsi
callq 0x21f0
testq %rax, %rax
je 0x4ec0
leaq 0x1f(%rax), %rcx
cmpq 0x10(%rsp), %rcx
ja 0x540c
movl 0x1b(%rax), %ecx
movl %ecx, 0xa4(%rsp)
movdqu 0xb(%rax), %xmm0
movdqu %xmm0, 0x94(%rsp)
movl 0x4(%rsp), %ebx
leaq 0x4b8a(%rip), %rdx      # 0x9a51
movl $0x7, %ecx
movq %rbp, %rdi
movq %r15, %rsi
callq 0x21f0
testq %rax, %rax
je 0x4f4c
addq $0x7, %rax
leaq 0x20(%rsp), %rsi
movq %rax, %rdi
movl $0xa, %edx
callq 0x21e0
leaq 0x20(%rsp), %rcx
movq (%rcx), %rsi
testq %rsi, %rsi
je 0x4f4c
cmpb $0x3a, (%rsi)
jne 0x4f4c
leaq -0x1(%rax), %rcx
cmpq $0x7e, %rcx
ja 0x4f4c
leaq (%rsi,%rax), %rcx
incq %rcx
cmpq 0x10(%rsp), %rcx
ja 0x540c
incq %rsi
leaq 0xac(%rsp), %rdi
movq %rax, %rdx
movq %rax, 0x8(%rsp)
callq 0x2200
leaq 0xac(%rsp), %rax
movq 0x8(%rsp), %rcx
movw %cx, 0x80(%rax)
leaq 0x4b06(%rip), %rdx      # 0x9a59
movl $0x7, %ecx
movq %rbp, %rdi
movq %r15, %rsi
callq 0x21f0
testq %rax, %rax
je 0x4fdb
addq $0x7, %rax
leaq 0x20(%rsp), %rsi
movq %rax, %rdi
movl $0xa, %edx
callq 0x21e0
leaq 0x20(%rsp), %rcx
movq (%rcx), %rsi
testq %rsi, %rsi
je 0x4fdb
cmpb $0x3a, (%rsi)
jne 0x4fdb
leaq -0x1(%rax), %rcx
cmpq $0x19f, %rcx            # imm = 0x19F
ja 0x4fdb
leaq (%rsi,%rax), %rcx
incq %rcx
cmpq 0x10(%rsp), %rcx
ja 0x540c
incq %rsi
leaq 0x12e(%rsp), %rdi
movq %rax, %rdx
movq %rax, 0x8(%rsp)
callq 0x2200
leaq 0x12e(%rsp), %rax
movq 0x8(%rsp), %rcx
movw %cx, 0x1a0(%rax)
leaq 0x4a7f(%rip), %rdx      # 0x9a61
movl $0x8, %ecx
movq %rbp, %rdi
movq %r15, %rsi
callq 0x21f0
testq %rax, %rax
je 0x506a
addq $0x8, %rax
leaq 0x20(%rsp), %rsi
movq %rax, %rdi
movl $0xa, %edx
callq 0x21e0
leaq 0x20(%rsp), %rcx
movq (%rcx), %rsi
testq %rsi, %rsi
je 0x506a
cmpb $0x3a, (%rsi)
jne 0x506a
leaq -0x1(%rax), %rcx
cmpq $0x25f, %rcx            # imm = 0x25F
ja 0x506a
leaq (%rsi,%rax), %rcx
incq %rcx
cmpq 0x10(%rsp), %rcx
ja 0x540c
incq %rsi
leaq 0x2d0(%rsp), %rdi
movq %rax, %rdx
movq %rax, 0x8(%rsp)
callq 0x2200
leaq 0x2d0(%rsp), %rax
movq 0x8(%rsp), %rcx
movw %cx, 0x260(%rax)
leaq 0x4975(%rip), %rdx      # 0x99e6
movl $0x9, %ecx
movq %rbp, %rdi
movq %r15, %rsi
callq 0x21f0
testq %rax, %rax
movq %r15, %rsi
movq %r15, 0x50(%rsp)
je 0x5220
movq %rax, %r8
subl %ebp, %r8d
addl $0x9, %r8d
xorl %eax, %eax
movl $0x0, 0x1c(%rsp)
movl %eax, 0x8(%rsp)
movq %r8, %r15
movslq %r8d, %rdi
addq %rbp, %rdi
leaq 0x20(%rsp), %rsi
movl $0xa, %edx
callq 0x21e0
movq 0x20(%rsp), %rcx
movl $0x4, %ebx
testq %rcx, %rcx
je 0x515d
cmpb $0x3a, (%rcx)
movq %r15, %r8
jne 0x51b7
testq %rax, %rax
jle 0x51b7
leaq (%rcx,%rax), %rdx
incq %rdx
movl $0x2, %ebx
cmpq 0x10(%rsp), %rdx
ja 0x51b7
incq %rcx
movl %edx, %r8d
subl %ebp, %r8d
cmpq $0x12, %rax
je 0x5166
cmpq $0x6, %rax
jne 0x519f
movl $0x3, %ebx
movl 0x8(%rsp), %eax
cmpl $0x7fa, %eax            # imm = 0x7FA
jg 0x51bb
movslq 0x8(%rsp), %rax
addl $0x6, 0x8(%rsp)
movzwl 0x4(%rcx), %edx
leaq 0xd34(%rsp), %rdi
movw %dx, -0x7fe(%rdi,%rax)
movl (%rcx), %ecx
movl %ecx, -0x802(%rdi,%rax)
movl 0x8(%rsp), %eax
xorl %ebx, %ebx
jmp 0x51bb
movl 0x8(%rsp), %eax
movq %r15, %r8
jmp 0x51bb
movl $0x3, %ebx
movl 0x1c(%rsp), %eax
cmpl $0x7ee, %eax            # imm = 0x7EE
jg 0x51b7
movl %eax, %edx
cltq
addl $0x12, %edx
movl %edx, 0x1c(%rsp)
movzwl 0x10(%rcx), %edx
leaq 0xd34(%rsp), %rdi
movw %dx, 0x10(%rdi,%rax)
movdqu (%rcx), %xmm0
movdqu %xmm0, (%rdi,%rax)
xorl %ebx, %ebx
jmp 0x51b7
xorl %ebx, %ebx
leaq 0x48c2(%rip), %rdi      # 0x9a6a
movq %r8, %r15
movl %eax, %esi
xorl %eax, %eax
callq 0x366b
movq %r15, %r8
movl 0x8(%rsp), %eax
testl %ebx, %ebx
je 0x50a6
cmpl $0x3, %ebx
je 0x50a6
cmpl $0x4, %ebx
jne 0x5206
movl %eax, %ebx
cmpl %r13d, %r8d
jge 0x51e2
movslq %r8d, %rax
cmpb $0x65, (%rbp,%rax)
je 0x51f0
leaq 0x48a4(%rip), %rdi      # 0x9a8d
xorl %eax, %eax
callq 0x366b
movw %bx, 0xd32(%rsp)
movl 0x1c(%rsp), %eax
movw %ax, 0x1534(%rsp)
xorl %ebx, %ebx
cmpl $0x2, %ebx
je 0x540c
movq 0x50(%rsp), %rsi
testl %ebx, %ebx
movl 0x4(%rsp), %ebx
jne 0x5424
leaq 0x4889(%rip), %rdx      # 0x9ab0
movl $0x7, %ecx
movq %rbp, %rdi
callq 0x21f0
testq %rax, %rax
je 0x5301
movq %rax, %r15
subl %ebp, %r15d
addl $0x7, %r15d
movw $0x0, 0x1536(%rsp)
movslq %r15d, %rbx
movb (%rbp,%rbx), %dl
leal -0x31(%rdx), %ecx
cmpb $0x8, %cl
ja 0x52e5
addq %rbp, %rbx
cmpb $0x3a, 0x1(%rbx)
jne 0x52e5
movzbl %dl, %esi
leal (%r15,%rsi), %ecx
addl $-0x2e, %ecx
cmpl %r13d, %ecx
jge 0x52e5
leaq (%rbx,%rsi), %rcx
addq $-0x2e, %rcx
cmpq 0x10(%rsp), %rcx
ja 0x540c
cmpb $0x32, %dl
jne 0x52a6
leaq 0x2(%rbx), %rax
cmpw $0x346e, (%rax)         # imm = 0x346E
je 0x52b6
cmpw $0x366e, (%rax)         # imm = 0x366E
je 0x52c0
leaq 0x480b(%rip), %rdi      # 0x9ab8
xorl %eax, %eax
callq 0x366b
jmp 0x52c8
orb $0x1, 0x1536(%rsp)
jmp 0x52c8
orb $0x2, 0x1536(%rsp)
addl $-0x2e, %r15d
movzbl (%rbx), %ecx
addl %ecx, %r15d
movslq %r15d, %rcx
leaq (%rcx,%rbp), %rbx
movb (%rbp,%rcx), %dl
leal -0x31(%rdx), %ecx
cmpb $0x9, %cl
jb 0x5267
cmpl %r13d, %r15d
movl 0x4(%rsp), %ebx
jge 0x52f3
cmpb $0x65, %dl
je 0x5301
leaq 0x47e0(%rip), %rdi      # 0x9ada
xorl %eax, %eax
callq 0x366b
leaq 0x47f3(%rip), %rdx      # 0x9afb
movl $0x6, %ecx
movq %rbp, %rdi
movq 0x50(%rsp), %r15
movq %r15, %rsi
callq 0x21f0
movq %r15, %rsi
movl $0x1, %r15d
testq %rax, %rax
jne 0x5424
leaq 0x47cc(%rip), %rdx      # 0x9b02
movl $0x6, %ecx
movq %rbp, %rdi
movq %rsi, %r15
callq 0x21f0
movq %r15, %rsi
xorl %r15d, %r15d
testq %rax, %rax
jne 0x5424
leaq 0x47ad(%rip), %rdx      # 0x9b09
movl $0x6, %ecx
movq %rbp, %rdi
movq %rsi, %r15
callq 0x21f0
testq %rax, %rax
je 0x4ca4
leaq 0x4794(%rip), %rdx      # 0x9b10
movl $0x9, %ecx
movq %rbp, %rdi
movq %r15, %rsi
callq 0x21f0
movl $0x2, %r15d
testq %rax, %rax
jne 0x5424
leaq 0x4778(%rip), %rdx      # 0x9b1a
movl $0xe, %ecx
movq %rbp, %rdi
movq 0x50(%rsp), %rsi
callq 0x21f0
movl $0x3, %r15d
testq %rax, %rax
jne 0x5424
leaq 0x4763(%rip), %rdx      # 0x9b29
movl $0xe, %ecx
movq %rbp, %rdi
movq 0x50(%rsp), %rsi
callq 0x21f0
movq 0x50(%rsp), %rsi
movl $0x4, %r15d
testq %rax, %rax
jne 0x5424
leaq 0x4749(%rip), %rdx      # 0x9b38
movl $0x13, %ecx
movq %rbp, %rdi
callq 0x21f0
xorl %r15d, %r15d
cmpq $0x1, %rax
sbbl %r15d, %r15d
orl $0x5, %r15d
jmp 0x5424
leaq 0x4739(%rip), %rdi      # 0x9b4c
xorl %eax, %eax
callq 0x366b
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
movl 0x4(%rsp), %ebx
testl %r15d, %r15d
jle 0x54bc
movl 0x7c(%rsp), %eax
orq 0x6c(%rsp), %rax
orq 0x74(%rsp), %rax
je 0x54bc
movdqu 0x6c(%rsp), %xmm0
movd 0x7c(%rsp), %xmm1
movd 0x87ef(%rip), %xmm2     # 0xdc40
pcmpeqb 0x87d7(%rip), %xmm0     # 0xdc30
pcmpeqb %xmm1, %xmm2
pand %xmm2, %xmm0
pmovmskb %xmm0, %eax
cmpl $0xffff, %eax           # imm = 0xFFFF
je 0x54e1
cmpl $0x1, %r15d
jne 0x54ed
cmpw $0x4, 0x6a(%rsp)
jne 0x5568
movb 0x5a(%rsp), %al
cmpb $0x70, %al
jne 0x55af
cmpb $0x6e, 0x5b(%rsp)
jne 0x55af
leaq 0x3f55(%rip), %rdi      # 0x93f1
xorl %eax, %eax
callq 0x366b
leaq 0x6c(%rsp), %rdi
movq %r12, %rsi
movl %ebx, %edx
movl $0x2, %ecx
callq 0x607f
jmp 0x48a6
leaq 0x3eab(%rip), %rdi      # 0x936e
xorl %eax, %eax
callq 0x366b
movq %rbp, %rdi
movl %r13d, %esi
callq 0x5ec0
leaq 0x3e4b(%rip), %rdi      # 0x9327
jmp 0x489f
leaq 0x3e9c(%rip), %rdi      # 0x9384
jmp 0x489f
callq 0x5f11
testl %eax, %eax
je 0x55a3
decl %r15d
cmpl $0x4, %r15d
ja 0x48a6
leaq 0x3d12(%rip), %rax      # 0x9220
movslq (%rax,%r15,4), %rcx
addq %rax, %rcx
jmpq *%rcx
leaq 0x5a(%rsp), %r13
movzwl 0x10(%r13), %esi
leaq 0x3f6f(%rip), %rdi      # 0x9497
xorl %eax, %eax
callq 0x366b
leaq 0x6c(%rsp), %rdi
movq %r12, %rsi
movl %ebx, %edx
movl $0x1, %ecx
callq 0x607f
leaq 0x3f59(%rip), %rdi      # 0x94a3
xorl %eax, %eax
callq 0x366b
movzwl 0x10(%r13), %ecx
movq %r12, %rdi
movl %ebx, %esi
movq %r13, %rdx
callq 0x6aa5
jmp 0x48a6
leaq 0x3e5a(%rip), %rdi      # 0x93c9
xorl %eax, %eax
callq 0x366b
movq %rbp, %rdi
movl %r13d, %esi
callq 0x5ec0
leaq 0x3d9f(%rip), %rdi      # 0x9327
xorl %eax, %eax
callq 0x366b
leaq 0x6c(%rsp), %rdi
movq %r12, %rsi
movl %ebx, %edx
callq 0x5f62
jmp 0x48a6
leaq 0x3df7(%rip), %rdi      # 0x93a1
jmp 0x489f
cmpb $0x66, %al
jne 0x55ba
cmpb $0x6e, 0x5b(%rsp)
je 0x55cd
cmpb $0x67, %al
jne 0x59bb
cmpb $0x70, 0x5b(%rsp)
jne 0x59bb
movl %ebx, 0x4(%rsp)
xorb $0x67, %al
movb 0x5b(%rsp), %cl
xorb $0x70, %cl
orb %al, %cl
sete %bl
jne 0x583d
movq 0x861c(%rip), %r13      # 0xdc08
leaq 0x3e1d(%rip), %rcx      # 0x9410
testq %r13, %r13
je 0x561f
movzwl 0x5c(%rsp), %eax
movzwl (%r12), %edx
cmpw (%r13), %ax
jne 0x5613
cmpl %edx, 0x4(%r13)
je 0x5847
movq 0xce8(%r13), %r13
testq %r13, %r13
jne 0x5602
xorl %r13d, %r13d
jmp 0x5847
leaq 0x3f39(%rip), %rdi      # 0x9567
xorl %eax, %eax
callq 0x366b
leaq 0x6c(%rsp), %rdi
movq %r12, %rsi
movl %ebx, %edx
movl $0x1, %ecx
callq 0x607f
movl 0x90(%rsp), %eax
orq 0x80(%rsp), %rax
orq 0x88(%rsp), %rax
je 0x5a15
leaq 0xac(%rsp), %rdi
movzwl 0x80(%rdi), %esi
movq %r12, %rdx
callq 0x73bd
testl %eax, %eax
je 0x5b53
cmpw $0x0, 0xaa(%rsp)
je 0x56af
movzwl (%r12), %eax
orl $0x8, %eax
cmpl $0xa, %eax
jne 0x56af
movzwl 0x2(%r12), %eax
rolw $0x8, %ax
movw %ax, 0xa8(%rsp)
movzwl 0xa8(%rsp), %eax
testw %ax, %ax
je 0x5b73
leaq 0x80(%rsp), %r13
movzwl %ax, %edx
movq %r13, %rdi
movq %r12, %rsi
callq 0x741e
leaq 0x3f6f(%rip), %rdi      # 0x964c
xorl %eax, %eax
callq 0x366b
movzwl -0x16(%r13), %ecx
leaq 0x5a(%rsp), %rdx
movq %r12, %rdi
movl %ebx, %esi
callq 0x7615
jmp 0x48a6
leaq 0x3dae(%rip), %rdi      # 0x94b2
movl %ebx, %ebp
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x366b
leaq 0x6c(%rsp), %rdi
movq %r12, %rsi
movl %ebp, %edx
movl $0x1, %ecx
callq 0x607f
leaq 0x94(%rsp), %r13
movzwl 0x14a2(%r13), %esi
leaq 0x3d84(%rip), %rdi      # 0x94be
xorl %eax, %eax
callq 0x366b
movzwl -0x2a(%r13), %ecx
movzwl 0x14a2(%r13), %r9d
subq $0x20, %rsp
movl %ebx, 0x18(%rsp)
pxor %xmm0, %xmm0
movdqu %xmm0, 0x8(%rsp)
movl %ebx, (%rsp)
leaq 0x7a(%rsp), %rdx
movq %r12, %rdi
movl %ebp, %esi
movq %r13, %r8
jmp 0x5a07
leaq 0x3d5f(%rip), %rdi      # 0x94db
xorl %eax, %eax
callq 0x366b
leaq 0x6c(%rsp), %rdi
movq %r12, %rsi
movl %ebx, %edx
movl $0x1, %ecx
callq 0x607f
movl 0x90(%rsp), %eax
orq 0x80(%rsp), %rax
orq 0x88(%rsp), %rax
je 0x5a38
leaq 0x80(%rsp), %rbp
movq %rbp, %rdi
callq 0x362b
movq %rax, %r13
leaq 0x20(%rsp), %r15
movq %r12, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x7349
testq %r13, %r13
je 0x59d8
cmpl $0x0, 0x14(%r13)
jle 0x59d8
cmpw $0xa, (%r12)
leaq 0x3d49(%rip), %rax      # 0x9543
leaq 0x3b27(%rip), %rsi      # 0x9328
cmoveq %rax, %rsi
leaq 0x3d1f(%rip), %rdi      # 0x952b
xorl %eax, %eax
callq 0x366b
leaq 0x5a(%rsp), %rdx
movzwl 0x10(%rdx), %ecx
movzwl 0x14dc(%rdx), %r9d
movzwl (%r12), %eax
movq %r12, %rdi
movl %ebx, %esi
movq %rbp, %r8
pushq $0x8
pushq %r15
pushq %r13
pushq %rax
jmp 0x5a07
xorl %r13d, %r13d
leaq 0x3ae1(%rip), %rcx      # 0x9328
movzwl 0x2ce(%rsp), %eax
imull $0x4ec5, %eax, %esi     # imm = 0x4EC5
shrl $0x13, %esi
movzwl 0x530(%rsp), %eax
imull $0xd795, %eax, %edx     # imm = 0xD795
shrl $0x15, %edx
leaq 0x3b88(%rip), %rdi      # 0x93f8
xorl %eax, %eax
callq 0x366b
movzwl 0x2ce(%rsp), %eax
imull $0x4ec5, %eax, %eax     # imm = 0x4EC5
rorw %ax
movzwl %ax, %eax
cmpl $0x9d8, %eax            # imm = 0x9D8
ja 0x58b1
movzwl 0x530(%rsp), %eax
imull $0xffffca1b, %eax, %eax # imm = 0xFFFFCA1B
rorw %ax
movzwl %ax, %eax
cmpl $0x6bd, %eax            # imm = 0x6BD
jb 0x5b1b
leaq 0x3b67(%rip), %rdi      # 0x941f
xorl %eax, %eax
callq 0x366b
leaq 0x6c(%rsp), %rdi
movq %r12, %rsi
movl 0x4(%rsp), %ebx
movl %ebx, %edx
callq 0x5f62
testq %r13, %r13
je 0x48a6
leaq 0xac(%rsp), %rbp
movzwl 0x80(%rbp), %eax
subq $0x8, %rsp
leaq 0x74(%rsp), %rdi
movq %r12, %rsi
movl %ebx, %edx
movq %r13, %rcx
movl $0x1, %r8d
movq %rbp, %r9
pushq %rax
callq 0x661c
addq $0x10, %rsp
movzwl 0xc86(%rbp), %ecx
movzwl 0x1488(%rbp), %eax
movl %ecx, %edx
orw %ax, %dx
je 0x48a6
movzwl %cx, %ecx
imull $0xaaab, %ecx, %esi     # imm = 0xAAAB
shrl $0x12, %esi
movzwl %ax, %eax
imull $0xe38f, %eax, %edx     # imm = 0xE38F
shrl $0x14, %edx
leaq 0x3b0c(%rip), %rdi      # 0x9452
xorl %eax, %eax
callq 0x366b
cmpq $0x0, 0x48(%rsp)
je 0x48a6
movzwl 0xd32(%rsp), %r8d
testq %r8, %r8
je 0x5984
leaq 0x10(%r13), %rdx
leaq 0x532(%rsp), %rcx
movq 0x1570(%rsp), %rdi
movl $0x1, %esi
callq *0x48(%rsp)
movzwl 0x1534(%rsp), %r8d
testq %r8, %r8
je 0x48a6
addq $0x10, %r13
leaq 0xd34(%rsp), %rcx
movq 0x1570(%rsp), %rdi
movl $0x2, %esi
movq %r13, %rdx
callq *0x48(%rsp)
jmp 0x48a6
xorb $0x61, %al
movb 0x5b(%rsp), %cl
xorb $0x70, %cl
orb %al, %cl
je 0x5a5b
leaq 0x3ab1(%rip), %rdi      # 0x9484
jmp 0x54c3
leaq 0x3b6a(%rip), %rdi      # 0x9549
xorl %eax, %eax
callq 0x366b
leaq 0x5a(%rsp), %rdx
movzwl 0x10(%rdx), %ecx
movzwl 0x14dc(%rdx), %r9d
movq %r12, %rdi
movl %ebx, %esi
movq %rbp, %r8
pushq $0x8
pushq %r15
pushq $0x0
pushq $0x0
callq 0x6bb4
addq $0x20, %rsp
jmp 0x48a6
leaq 0x3b5b(%rip), %rdi      # 0x9577
xorl %eax, %eax
callq 0x366b
leaq 0x5a(%rsp), %rdx
movzwl 0x10(%rdx), %ecx
leaq 0x3b66(%rip), %r8       # 0x9599
jmp 0x5b93
leaq 0x3aa8(%rip), %rdi      # 0x94e7
xorl %eax, %eax
callq 0x366b
leaq 0x5a(%rsp), %rdx
movzwl 0x10(%rdx), %ecx
leaq 0x3ab9(%rip), %r8       # 0x950f
jmp 0x5b93
movl %ebx, %ebp
movzwl 0x5c(%rsp), %ebx
leaq 0x39fe(%rip), %rdi      # 0x9467
xorl %eax, %eax
callq 0x366b
movq 0x8191(%rip), %r13      # 0xdc08
testq %r13, %r13
je 0x5a9a
movzwl (%r12), %eax
cmpw (%r13), %bx
jne 0x5a8e
cmpl %eax, 0x4(%r13)
je 0x5a9d
movq 0xce8(%r13), %r13
testq %r13, %r13
jne 0x5a81
xorl %r13d, %r13d
movl %ebp, %ebx
testq %r13, %r13
je 0x5d7d
leaq 0x6c(%rsp), %rdi
movq %r12, %rsi
movl %ebx, %edx
movl $0x2, %ecx
callq 0x607f
movslq 0xce0(%r13), %rax
testq %rax, %rax
jle 0x5dd2
imulq $0xe8, %rax, %rcx
xorl %eax, %eax
movdqu 0x6c(%rsp), %xmm0
movd 0x7c(%rsp), %xmm1
movdqu 0x30(%r13,%rax), %xmm2
pcmpeqb %xmm0, %xmm2
movd 0x40(%r13,%rax), %xmm3
pcmpeqb %xmm1, %xmm3
pand %xmm2, %xmm3
pmovmskb %xmm3, %edx
cmpl $0xffff, %edx           # imm = 0xFFFF
je 0x5d9f
addq $0xe8, %rax
cmpq %rax, %rcx
jne 0x5ae1
jmp 0x5dd2
testq %r13, %r13
setne %al
xorb $0x1, %bl
orb %al, %bl
jne 0x5ba2
leaq 0x3912(%rip), %rdi      # 0x9441
xorl %eax, %eax
callq 0x366b
leaq 0x6c(%rsp), %rdi
movq %r12, %rsi
movl 0x4(%rsp), %ebx
movl %ebx, %edx
movl $0x1, %ecx
callq 0x607f
jmp 0x58d2
leaq 0x3a5f(%rip), %rdi      # 0x95b9
xorl %eax, %eax
callq 0x366b
leaq 0x5a(%rsp), %rdx
movzwl 0x10(%rdx), %ecx
leaq 0x3a6c(%rip), %r8       # 0x95dd
jmp 0x5b93
leaq 0x3a82(%rip), %rdi      # 0x95fc
xorl %esi, %esi
xorl %eax, %eax
callq 0x366b
leaq 0x5a(%rsp), %rdx
movzwl 0x10(%rdx), %ecx
leaq 0x3a90(%rip), %r8       # 0x9623
movq %r12, %rdi
movl %ebx, %esi
callq 0x71dd
jmp 0x48a6
leaq 0x6c(%rsp), %rdi
movq %r12, %rsi
movl 0x4(%rsp), %edx
movl $0x2, %ecx
callq 0x607f
cmpw $0x1a, 0x2ce(%rsp)
jb 0x5c86
leaq 0x12e(%rsp), %rbp
xorl %ebx, %ebx
leaq 0x20(%rsp), %r15
movdqu (%rbp), %xmm0
movd 0x10(%rbp), %xmm1
movd 0x8058(%rip), %xmm2     # 0xdc40
pcmpeqb 0x8040(%rip), %xmm0     # 0xdc30
pcmpeqb %xmm1, %xmm2
pand %xmm2, %xmm0
pmovmskb %xmm0, %eax
cmpl $0xffff, %eax           # imm = 0xFFFF
je 0x5c65
pxor %xmm0, %xmm0
movdqa %xmm0, 0x20(%rsp)
movw $0x2, 0x20(%rsp)
movl 0x14(%rbp), %eax
movl %eax, 0x24(%rsp)
movzwl 0x18(%rbp), %eax
movw %ax, 0x22(%rsp)
movq %rbp, %rdi
movq %r15, %rsi
movl $0x10, %edx
xorl %ecx, %ecx
callq 0x607f
testq %r13, %r13
je 0x5c65
cmpl $0x2, 0x4(%r13)
jne 0x5c65
subq $0x8, %rsp
movq %rbp, %rdi
movq %r15, %rsi
movl $0x10, %edx
movq %r13, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq $0x0
callq 0x661c
addq $0x10, %rsp
incq %rbx
movzwl 0x2ce(%rsp), %eax
imull $0x4ec5, %eax, %eax     # imm = 0x4EC5
shrl $0x13, %eax
addq $0x1a, %rbp
cmpq %rax, %rbx
jb 0x5bd6
cmpw $0x26, 0x530(%rsp)
jb 0x5d61
leaq 0x2d0(%rsp), %rbp
leaq 0x28(%rsp), %rbx
xorl %r15d, %r15d
movdqu (%rbp), %xmm0
movd 0x10(%rbp), %xmm1
movd 0x7f89(%rip), %xmm2     # 0xdc40
pcmpeqb 0x7f71(%rip), %xmm0     # 0xdc30
pcmpeqb %xmm1, %xmm2
pand %xmm2, %xmm0
pmovmskb %xmm0, %eax
cmpl $0xffff, %eax           # imm = 0xFFFF
je 0x5d40
pxor %xmm0, %xmm0
movdqa %xmm0, 0x20(%rsp)
movdqu %xmm0, 0x2c(%rsp)
movw $0xa, 0x20(%rsp)
movdqu 0x14(%rbp), %xmm0
movdqu %xmm0, (%rbx)
movzwl 0x24(%rbp), %eax
movw %ax, 0x22(%rsp)
movq %rbp, %rdi
leaq 0x20(%rsp), %rsi
movl $0x1c, %edx
xorl %ecx, %ecx
callq 0x607f
testq %r13, %r13
je 0x5d40
cmpl $0xa, 0x4(%r13)
jne 0x5d40
subq $0x8, %rsp
movq %rbp, %rdi
leaq 0x28(%rsp), %rsi
movl $0x1c, %edx
movq %r13, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq $0x0
callq 0x661c
addq $0x10, %rsp
incq %r15
movzwl 0x530(%rsp), %eax
imull $0xd795, %eax, %eax     # imm = 0xD795
shrl $0x15, %eax
addq $0x26, %rbp
cmpq %rax, %r15
jb 0x5ca5
testq %r13, %r13
movl 0x4(%rsp), %ebx
je 0x48a6
movq %r13, %rdi
xorl %esi, %esi
callq 0x685f
jmp 0x58d2
leaq 0x36bd(%rip), %rdi      # 0x9441
xorl %eax, %eax
callq 0x366b
leaq 0x6c(%rsp), %rdi
movq %r12, %rsi
movl %ebx, %edx
movl $0x1, %ecx
jmp 0x54b2
movq $0x0, 0xd0(%r13,%rax)
movq 0x7e5e(%rip), %rcx      # 0xdc10
movq %rcx, 0xd8(%r13,%rax)
movl $0x1, 0x114(%r13,%rax)
movl $0x0, 0xe0(%r13,%rax)
movq %r13, %rdi
xorl %esi, %esi
callq 0x685f
jmp 0x48a6