// File: /workspace/github_c_makefile_star2_O2/jech[P]dht/dht-example.c
// Function: main
int
main(int argc, char **argv)
{
    int i, rc, fd;
    int s = -1, s6 = -1, port;
    int have_id = 0;
    unsigned char myid[20];
    time_t tosleep = 0;
    char *id_file = "dht-example.id";
    int opt;
    int quiet = 0, ipv4 = 1, ipv6 = 1;
    struct sockaddr_in sin;
    struct sockaddr_in6 sin6;
    struct sockaddr_storage from;
    socklen_t fromlen;

    memset(&sin, 0, sizeof(sin));
    sin.sin_family = AF_INET;

    memset(&sin6, 0, sizeof(sin6));
    sin6.sin6_family = AF_INET6;

    while(1) {
        opt = getopt(argc, argv, "q46b:i:");
        if(opt < 0)
            break;

        switch(opt) {
        case 'q': quiet = 1; break;
        case '4': ipv6 = 0; break;
        case '6': ipv4 = 0; break;
        case 'b': {
            char buf[16];
            int rc;
            rc = inet_pton(AF_INET, optarg, buf);
            if(rc == 1) {
                memcpy(&sin.sin_addr, buf, 4);
                break;
            }
            rc = inet_pton(AF_INET6, optarg, buf);
            if(rc == 1) {
                memcpy(&sin6.sin6_addr, buf, 16);
                break;
            }
            goto usage;
        }
            break;
        case 'i':
            id_file = optarg;
            break;
        default:
            goto usage;
        }
    }

    /* Ids need to be distributed evenly, so you cannot just use your
       bittorrent id.  Either generate it randomly, or take the SHA-1 of
       something. */
    fd = open(id_file, O_RDONLY);
    if(fd >= 0) {
        rc = read(fd, myid, 20);
        if(rc == 20)
            have_id = 1;
        close(fd);
    }

    fd = open("/dev/urandom", O_RDONLY);
    if(fd < 0) {
        perror("open(random)");
        exit(1);
    }

    if(!have_id) {
        int ofd;

        rc = read(fd, myid, 20);
        if(rc < 0) {
            perror("read(random)");
            exit(1);
        }
        have_id = 1;
        close(fd);

        ofd = open(id_file, O_WRONLY | O_CREAT | O_TRUNC, 0666);
        if(ofd >= 0) {
            rc = write(ofd, myid, 20);
            if(rc < 20)
                unlink(id_file);
            close(ofd);
        }
    }

    {
        unsigned seed;
        read(fd, &seed, sizeof(seed));
        srandom(seed);
    }

    close(fd);

    if(argc < 2)
        goto usage;

    i = optind;

    if(argc < i + 1)
        goto usage;

    port = atoi(argv[i++]);
    if(port <= 0 || port >= 0x10000)
        goto usage;

    while(i < argc) {
        struct addrinfo hints, *info, *infop;
        memset(&hints, 0, sizeof(hints));
        hints.ai_socktype = SOCK_DGRAM;
        if(!ipv6)
            hints.ai_family = AF_INET;
        else if(!ipv4)
            hints.ai_family = AF_INET6;
        else
            hints.ai_family = 0;
        rc = getaddrinfo(argv[i], argv[i + 1], &hints, &info);
        if(rc != 0) {
            fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(rc));
            exit(1);
        }

        i++;
        if(i >= argc)
            goto usage;

        infop = info;
        while(infop) {
            memcpy(&bootstrap_nodes[num_bootstrap_nodes],
                   infop->ai_addr, infop->ai_addrlen);
            infop = infop->ai_next;
            num_bootstrap_nodes++;
        }
        freeaddrinfo(info);

        i++;
    }

    /* If you set dht_debug to a stream, every action taken by the DHT will
       be logged. */
    if(!quiet)
        dht_debug = stdout;

    /* We need an IPv4 and an IPv6 socket, bound to a stable port.  Rumour
       has it that uTorrent likes you better when it is the same as your
       Bittorrent port. */
    if(ipv4) {
        s = socket(PF_INET, SOCK_DGRAM, 0);
        if(s < 0) {
            perror("socket(IPv4)");
        }
        rc = set_nonblocking(s, 1);
        if(rc < 0) {
            perror("set_nonblocking(IPv4)");
            exit(1);
        }
    }

    if(ipv6) {
        s6 = socket(PF_INET6, SOCK_DGRAM, 0);
        if(s6 < 0) {
            perror("socket(IPv6)");
        }
        rc = set_nonblocking(s6, 1);
        if(rc < 0) {
            perror("set_nonblocking(IPv6)");
            exit(1);
        }
    }

    if(s < 0 && s6 < 0) {
        fprintf(stderr, "Eek!");
        exit(1);
    }


    if(s >= 0) {
        sin.sin_port = htons(port);
        rc = bind(s, (struct sockaddr*)&sin, sizeof(sin));
        if(rc < 0) {
            perror("bind(IPv4)");
            exit(1);
        }
    }

    if(s6 >= 0) {
        int rc;
        int val = 1;

        rc = setsockopt(s6, IPPROTO_IPV6, IPV6_V6ONLY,
                        (char *)&val, sizeof(val));
        if(rc < 0) {
            perror("setsockopt(IPV6_V6ONLY)");
            exit(1);
        }

        /* BEP-32 mandates that we should bind this socket to one of our
           global IPv6 addresses.  In this simple example, this only
           happens if the user used the -b flag. */

        sin6.sin6_port = htons(port);
        rc = bind(s6, (struct sockaddr*)&sin6, sizeof(sin6));
        if(rc < 0) {
            perror("bind(IPv6)");
            exit(1);
        }
    }

    /* Init the dht. */
    rc = dht_init(s, s6, myid, (unsigned char*)"JC\0\0");
    if(rc < 0) {
        perror("dht_init");
        exit(1);
    }

    init_signals();

    /* For bootstrapping, we need an initial list of nodes.  This could be
       hard-wired, but can also be obtained from the nodes key of a torrent
       file, or from the PORT bittorrent message.

       Dht_ping_node is the brutal way of bootstrapping -- it actually
       sends a message to the peer.  If you know the nodes' ids, it is
       better to use dht_insert_node. */
    for(i = 0; i < num_bootstrap_nodes; i++) {
        socklen_t salen;
        if(bootstrap_nodes[i].ss_family == AF_INET)
            salen = sizeof(struct sockaddr_in);
        else
            salen = sizeof(struct sockaddr_in6);
        dht_ping_node((struct sockaddr*)&bootstrap_nodes[i], salen);
        /* Don't overload the DHT, or it will drop your nodes. */
        if(i <= 128)
            usleep(random() % 10000);
        else
            usleep(500000 + random() % 400000);
    }

    while(1) {
        struct timeval tv;
        fd_set readfds;
        tv.tv_sec = tosleep;
        tv.tv_usec = random() % 1000000;

        FD_ZERO(&readfds);
        if(s >= 0)
            FD_SET(s, &readfds);
        if(s6 >= 0)
            FD_SET(s6, &readfds);
        rc = select(s > s6 ? s + 1 : s6 + 1, &readfds, NULL, NULL, &tv);
        if(rc < 0) {
            if(errno != EINTR) {
                perror("select");
                sleep(1);
            }
        }

        if(exiting)
            break;

        if(rc > 0) {
            fromlen = sizeof(from);
            if(s >= 0 && FD_ISSET(s, &readfds))
                rc = recvfrom(s, buf, sizeof(buf) - 1, 0,
                              (struct sockaddr*)&from, &fromlen);
            else if(s6 >= 0 && FD_ISSET(s6, &readfds))
                rc = recvfrom(s6, buf, sizeof(buf) - 1, 0,
                              (struct sockaddr*)&from, &fromlen);
            else
                abort();
        }

        if(rc > 0) {
            buf[rc] = '\0';
            rc = dht_periodic(buf, rc, (struct sockaddr*)&from, fromlen,
                              &tosleep, callback, NULL);
        } else {
            rc = dht_periodic(NULL, 0, NULL, 0, &tosleep, callback, NULL);
        }
        if(rc < 0) {
            if(errno == EINTR) {
                continue;
            } else {
                perror("dht_periodic");
                if(rc == EINVAL || rc == EFAULT)
                    abort();
                tosleep = 1;
            }
        }

        /* This is how you trigger a search for a torrent hash.  If port
           (the second argument) is non-zero, it also performs an announce.
           Since peers expire announced data after 30 minutes, it is a good
           idea to reannounce every 28 minutes or so. */
        if(searching) {
            if(s >= 0)
                dht_search(hash, 0, AF_INET, callback, NULL);
            if(s6 >= 0)
                dht_search(hash, 0, AF_INET6, callback, NULL);
            searching = 0;
        }

        /* For debugging, or idle curiosity. */
        if(dumping) {
            dht_dump_tables(stdout);
            dumping = 0;
        }
    }

    {
        struct sockaddr_in sin[500];
        struct sockaddr_in6 sin6[500];
        int num = 500, num6 = 500;
        int i;
        i = dht_get_nodes(sin, &num, sin6, &num6);
        printf("Found %d (%d + %d) good nodes.\n", i, num, num6);
    }

    dht_uninit();
    return 0;

 usage:
    printf("Usage: dht-example [-q] [-4] [-6] [-i filename] [-b address]...\n"
           "                   port [address port]...\n");
    exit(1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x5718, %rsp           # imm = 0x5718
movq %rsi, 0x20(%rsp)
movl %edi, %ebp
andq $0x0, 0x30(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp)
movw $0x2, 0x40(%rsp)
leaq 0x88(%rsp), %rax
movaps %xmm0, -0x8(%rax)
movups %xmm0, 0x4(%rax)
movq %rax, %rbx
movw $0xa, -0x8(%rax)
pushq $0x1
popq %rcx
movl $0x0, 0x28(%rsp)
leaq 0x5b75(%rip), %rax      # 0x8039
movq %rax, 0x10(%rsp)
leaq 0x5b78(%rip), %r15      # 0x8048
movq 0x9b01(%rip), %r14      # 0xbfd8
pushq $0x2
popq %r12
leaq 0x120(%rsp), %r13
movl %ecx, 0x1c(%rsp)
movl %ecx, 0x18(%rsp)
movl %ebp, %edi
movq 0x20(%rsp), %rsi
movq %r15, %rdx
callq 0x22c0
testl %eax, %eax
js 0x2596
cmpl $0x62, %eax
jne 0x254b
movq (%r14), %rsi
movl %r12d, %edi
movq %r13, %rdx
callq 0x2210
cmpl $0x1, %eax
jne 0x2527
movl 0x120(%rsp), %eax
movl %eax, 0x44(%rsp)
jmp 0x24eb
movq (%r14), %rsi
pushq $0xa
popq %rdi
movq %r13, %rdx
callq 0x2210
cmpl $0x1, %eax
jne 0x2cb5
movaps 0x120(%rsp), %xmm0
movups %xmm0, (%rbx)
jmp 0x24eb
cmpl $0x71, %eax
je 0x2570
cmpl $0x36, %eax
je 0x257c
cmpl $0x69, %eax
je 0x2589
cmpl $0x34, %eax
jne 0x2cb5
movl $0x0, 0x18(%rsp)
jmp 0x24eb
pushq $0x1
popq %rax
movl %eax, 0x28(%rsp)
jmp 0x24eb
movl $0x0, 0x1c(%rsp)
jmp 0x24eb
movq (%r14), %rax
movq %rax, 0x10(%rsp)
jmp 0x24eb
movq 0x10(%rsp), %rdi
movq %rdi, %r15
xorl %esi, %esi
xorl %eax, %eax
callq 0x22a0
testl %eax, %eax
js 0x25cd
movl %eax, %r14d
leaq 0x60(%rsp), %rsi
pushq $0x14
popq %rdx
movl %eax, %edi
callq 0x2180
cmpl $0x14, %eax
setne %bl
movl %r14d, %edi
callq 0x2160
jmp 0x25cf
movb $0x1, %bl
leaq 0x5a7a(%rip), %rdi      # 0x8050
xorl %esi, %esi
xorl %eax, %eax
callq 0x22a0
testl %eax, %eax
js 0x2cf5
movl %eax, %r14d
testb %bl, %bl
je 0x2650
movq %r15, %rbx
leaq 0x60(%rsp), %rsi
pushq $0x14
popq %rdx
movl %r14d, %edi
callq 0x2180
testl %eax, %eax
js 0x2d52
movl %r14d, %edi
callq 0x2160
movq %rbx, %rdi
movl $0x241, %esi            # imm = 0x241
movl $0x1b6, %edx            # imm = 0x1B6
xorl %eax, %eax
callq 0x22a0
testl %eax, %eax
js 0x2650
movl %eax, %r15d
leaq 0x60(%rsp), %rsi
pushq $0x14
popq %rdx
movl %eax, %edi
callq 0x20e0
cmpl $0x13, %eax
jg 0x2648
movq %rbx, %rdi
callq 0x2080
movl %r15d, %edi
callq 0x2160
leaq 0x120(%rsp), %r15
pushq $0x4
popq %rdx
movl %r14d, %edi
movq %r15, %rsi
callq 0x2180
movl (%r15), %edi
callq 0x2070
movl %r14d, %edi
callq 0x2160
cmpl $0x2, %ebp
jl 0x2cb5
movq 0x994a(%rip), %rax      # 0xbfd0
movslq (%rax), %rbx
cmpl %ebp, %ebx
jge 0x2cb5
movq 0x20(%rsp), %rax
movq (%rax,%rbx,8), %rdi
callq 0x22e0
movq %rax, 0x50(%rsp)
addl $0xffff0000, %eax       # imm = 0xFFFF0000
cmpl $0xffff0001, %eax       # imm = 0xFFFF0001
jb 0x2cb5
incl %ebx
xorl %eax, %eax
cmpl $0x0, 0x18(%rsp)
setne %al
sete %cl
cmpl $0x0, 0x1c(%rsp)
sete %dl
movslq %ebx, %r13
movl %ebp, %ebx
orb %cl, %dl
movb %dl, 0xf(%rsp)
leal 0x2(,%rax,8), %eax
movl %eax, 0x3c(%rsp)
leaq 0x9af8(%rip), %rax      # 0xc1e0
movq %rax, 0x10(%rsp)
cmpq %rbx, %r13
jge 0x27c3
xorps %xmm0, %xmm0
movaps %xmm0, 0x120(%rsp)
movaps %xmm0, 0x130(%rsp)
movaps %xmm0, 0x140(%rsp)
movl $0x2, 0x128(%rsp)
cmpb $0x0, 0xf(%rsp)
je 0x272e
movl 0x3c(%rsp), %eax
movl %eax, 0x124(%rsp)
movq 0x20(%rsp), %rax
movq (%rax,%r13,8), %rdi
movq 0x8(%rax,%r13,8), %rsi
leaq 0x120(%rsp), %rdx
leaq 0x37d0(%rsp), %rcx
callq 0x2310
testl %eax, %eax
jne 0x2cc3
leaq 0x1(%r13), %rax
cmpq %rbx, %rax
jge 0x2cb5
movq 0x37d0(%rsp), %r14
movslq 0xa46b(%rip), %r15      # 0xcbe0
leal 0x1(%r15), %r12d
shlq $0x7, %r15
leaq 0x9a5c(%rip), %rax      # 0xc1e0
addq %rax, %r15
movq %r14, %rbp
testq %rbp, %rbp
je 0x27b2
movq 0x18(%rbp), %rsi
movl 0x10(%rbp), %edx
movq %r15, %rdi
callq 0x2200
movq 0x28(%rbp), %rbp
movl %r12d, 0xa437(%rip)     # 0xcbe0
subq $-0x80, %r15
incl %r12d
jmp 0x278a
movq %r14, %rdi
callq 0x2350
addq $0x2, %r13
jmp 0x26ed
cmpl $0x0, 0x28(%rsp)
jne 0x27de
movq 0x97f7(%rip), %rax      # 0xbfc8
movq (%rax), %rax
leaq 0xb425(%rip), %rcx      # 0xdc00
movq %rax, (%rcx)
pushq $-0x1
popq %rbx
movl %ebx, %ebp
cmpl $0x0, 0x1c(%rsp)
movq 0x50(%rsp), %r14
je 0x2814
pushq $0x2
popq %rdi
movl %edi, %esi
xorl %edx, %edx
callq 0x2360
movl %eax, %ebp
testl %eax, %eax
js 0x2c93
movl %ebp, %edi
callq 0x2d60
testl %eax, %eax
js 0x2d25
cmpl $0x0, 0x18(%rsp)
je 0x2841
pushq $0xa
popq %rdi
pushq $0x2
popq %rsi
xorl %edx, %edx
callq 0x2360
movl %eax, %ebx
testl %eax, %eax
js 0x2ca4
movl %ebx, %edi
callq 0x2d60
testl %eax, %eax
js 0x2d2e
testl %ebp, %ebx
js 0x2cfe
testl %ebp, %ebp
js 0x286f
movl %r14d, %eax
rolw $0x8, %ax
leaq 0x40(%rsp), %rsi
movw %ax, 0x2(%rsi)
pushq $0x10
popq %rdx
movl %ebp, %edi
callq 0x2280
testl %eax, %eax
js 0x2d37
testl %ebx, %ebx
js 0x28be
leaq 0x120(%rsp), %rcx
movl $0x1, (%rcx)
pushq $0x29
popq %rsi
pushq $0x1a
popq %rdx
pushq $0x4
popq %r8
movl %ebx, %edi
callq 0x20c0
testl %eax, %eax
js 0x2d40
rolw $0x8, %r14w
leaq 0x80(%rsp), %rsi
movw %r14w, 0x2(%rsi)
pushq $0x1c
popq %rdx
movl %ebx, %edi
callq 0x2280
testl %eax, %eax
js 0x2d49
leaq 0x576f(%rip), %rcx      # 0x8034
leaq 0x60(%rsp), %rdx
movl %ebp, %edi
movl %ebx, %esi
callq 0x3fb5
testl %eax, %eax
js 0x2d1c
leaq 0x37d0(%rsp), %r15
movq %r15, %rdi
callq 0x21d0
leaq 0x61f(%rip), %rax       # 0x2f11
leaq 0x128(%rsp), %r14
movq %rax, -0x8(%r14)
pushq $0x10
popq %rcx
movq %r14, %rdi
movq %r15, %rsi
rep  movsq (%rsi), %es:(%rdi)
andl $0x0, 0x80(%r14)
xorl %r13d, %r13d
pushq $0xa
popq %rdi
leaq 0x120(%rsp), %r12
movq %r12, %rsi
xorl %edx, %edx
callq 0x20b0
movq %r15, %rdi
callq 0x21d0
leaq 0x5e3(%rip), %rax       # 0x2f1c
movq %rax, (%r12)
pushq $0x10
popq %rcx
movq %r14, %rdi
movq %r15, %rsi
rep  movsq (%rsi), %es:(%rdi)
andl $0x0, 0x88(%r12)
pushq $0xc
popq %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x20b0
movq %r15, %rdi
callq 0x21d0
leaq 0x5b9(%rip), %rax       # 0x2f27
movq %rax, (%r12)
pushq $0x10
popq %rcx
movq %r14, %rdi
movq %r15, %rsi
rep  movsq (%rsi), %es:(%rdi)
andl $0x0, 0x88(%r12)
pushq $0x2
popq %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x20b0
pushq $0x10
popq %r15
pushq $0x1c
popq %r12
movslq 0xa23d(%rip), %rax      # 0xcbe0
cmpq %rax, %r13
jge 0x29fb
movq 0x10(%rsp), %rdi
cmpw $0x2, (%rdi)
movl %r12d, %esi
cmovel %r15d, %esi
callq 0x73a3
callq 0x2230
cqto
cmpq $0x80, %r13
ja 0x29da
movl $0x2710, %ecx           # imm = 0x2710
idivq %rcx
movq %rdx, %rdi
jmp 0x29eb
movl $0x61a80, %ecx          # imm = 0x61A80
idivq %rcx
movq %rdx, %rdi
addl $0x7a120, %edi          # imm = 0x7A120
callq 0x2340
incq %r13
subq $-0x80, 0x10(%rsp)
jmp 0x299c
pushq $0x1
popq %r14
movq %r14, %rax
movl %ebp, %ecx
shlq %cl, %rax
movq %rax, 0x20(%rsp)
movl %ebx, %ecx
shlq %cl, %r14
movq %r14, 0x10(%rsp)
movl %ebp, %r12d
shrl $0x6, %r12d
movl %ebx, %r13d
shrl $0x6, %r13d
cmpl %ebx, %ebp
movl %ebx, %r14d
cmovgl %ebp, %r14d
incl %r14d
movq 0x30(%rsp), %rax
movq %rax, 0x37d0(%rsp)
callq 0x2230
cqto
movl $0xf4240, %ecx          # imm = 0xF4240
idivq %rcx
movq %rdx, 0x37d8(%rsp)
xorl %eax, %eax
cmpq $0x10, %rax
je 0x2a6a
andq $0x0, 0x120(%rsp,%rax,8)
incq %rax
jmp 0x2a56
testl %ebp, %ebp
js 0x2a7b
movq 0x20(%rsp), %rax
orq %rax, 0x120(%rsp,%r12,8)
testl %ebx, %ebx
js 0x2a8c
movq 0x10(%rsp), %rax
orq %rax, 0x120(%rsp,%r13,8)
movl %r14d, %edi
leaq 0x120(%rsp), %rsi
xorl %edx, %edx
xorl %ecx, %ecx
leaq 0x37d0(%rsp), %r8
callq 0x2220
movl %eax, %r15d
testl %eax, %eax
jns 0x2abd
callq 0x2060
cmpl $0x4, (%rax)
jne 0x2c1d
cmpl $0x0, 0xa120(%rip)      # 0xcbe4
jne 0x2c36
testl %r15d, %r15d
jle 0x2b57
movl $0x80, 0x2c(%rsp)
testl %ebp, %ebp
js 0x2af0
movl %ebp, %edi
movq 0x20(%rsp), %rax
testq %rax, 0x120(%rsp,%r12,8)
jne 0x2b0d
testl %ebx, %ebx
js 0x2cf0
movl %ebx, %edi
movq 0x10(%rsp), %rax
testq %rax, 0x120(%rsp,%r13,8)
je 0x2cf0
movl $0xfff, %edx            # imm = 0xFFF
leaq 0xa0d7(%rip), %rsi      # 0xcbf0
xorl %ecx, %ecx
leaq 0xa0(%rsp), %r8
leaq 0x2c(%rsp), %r9
callq 0x2250
testl %eax, %eax
jle 0x2b57
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
leaq 0xa0b3(%rip), %rdi      # 0xcbf0
movb $0x0, (%rax,%rdi)
movl 0x2c(%rsp), %ecx
andq $0x0, (%rsp)
movq %rax, %rsi
leaq 0xa0(%rsp), %rdx
jmp 0x2b64
andq $0x0, (%rsp)
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
leaq 0x30(%rsp), %r8
leaq 0x220(%rip), %r9        # 0x2d90
callq 0x43a7
testl %eax, %eax
js 0x2bf5
cmpl $0x0, 0xb070(%rip)      # 0xdbf0
je 0x2bca
testl %ebp, %ebp
js 0x2ba1
leaq 0x5493(%rip), %rdi      # 0x8020
xorl %esi, %esi
pushq $0x2
popq %rdx
leaq 0x1f7(%rip), %rcx       # 0x2d90
xorl %r8d, %r8d
callq 0x2f34
testl %ebx, %ebx
js 0x2bc0
leaq 0x5474(%rip), %rdi      # 0x8020
xorl %esi, %esi
pushq $0xa
popq %rdx
leaq 0x1d8(%rip), %rcx       # 0x2d90
xorl %r8d, %r8d
callq 0x2f34
movl $0x0, 0xb026(%rip)      # 0xdbf0
cmpl $0x0, 0xb023(%rip)      # 0xdbf4
je 0x2a30
movq 0x93ea(%rip), %rax      # 0xbfc8
movq (%rax), %rdi
callq 0x398c
movl $0x0, 0xb004(%rip)      # 0xdbf4
jmp 0x2a30
callq 0x2060
cmpl $0x4, (%rax)
je 0x2a30
leaq 0x5507(%rip), %rdi      # 0x8111
callq 0x22b0
movq $0x1, 0x30(%rsp)
jmp 0x2b79
leaq 0x54e6(%rip), %rdi      # 0x810a
callq 0x22b0
pushq $0x1
popq %rdi
callq 0x2330
jmp 0x2abd
movl $0x1f4, %eax            # imm = 0x1F4
leaq 0x5c(%rsp), %rbx
movl %eax, (%rbx)
leaq 0x58(%rsp), %r14
movl %eax, (%r14)
leaq 0x37d0(%rsp), %rdi
leaq 0x120(%rsp), %rdx
movq %rbx, %rsi
movq %r14, %rcx
callq 0x7149
movl (%rbx), %edx
movl (%r14), %ecx
leaq 0x54ad(%rip), %rdi      # 0x811e
movl %eax, %esi
xorl %eax, %eax
callq 0x2100
callq 0x42a6
xorl %eax, %eax
addq $0x5718, %rsp           # imm = 0x5718
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x53ee(%rip), %rdi      # 0x8088
callq 0x22b0
jmp 0x2805
leaq 0x5400(%rip), %rdi      # 0x80ab
callq 0x22b0
jmp 0x2832
leaq 0x54cb(%rip), %rdi      # 0x8187
callq 0x20a0
jmp 0x2ce8
movq 0x932e(%rip), %rcx      # 0xbff8
movq (%rcx), %rbx
movl %eax, %edi
callq 0x2120
leaq 0x539c(%rip), %rsi      # 0x8077
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x21c0
pushq $0x1
popq %rdi
callq 0x22f0
callq 0x2050
leaq 0x5361(%rip), %rdi      # 0x805d
jmp 0x2d59
movq 0x92f3(%rip), %rax      # 0xbff8
movq (%rax), %rcx
leaq 0x53bf(%rip), %rdi      # 0x80ce
pushq $0x4
popq %rsi
pushq $0x1
popq %rdx
callq 0x2300
jmp 0x2ce8
leaq 0x53de(%rip), %rdi      # 0x8101
jmp 0x2d59
leaq 0x5369(%rip), %rdi      # 0x8095
jmp 0x2d59
leaq 0x5383(%rip), %rdi      # 0x80b8
jmp 0x2d59
leaq 0x5395(%rip), %rdi      # 0x80d3
jmp 0x2d59
leaq 0x5397(%rip), %rdi      # 0x80de
jmp 0x2d59
leaq 0x53a6(%rip), %rdi      # 0x80f6
jmp 0x2d59
leaq 0x5311(%rip), %rdi      # 0x806a
callq 0x22b0
jmp 0x2ce8