// File: /workspace/github_c_makefile_star2_O0/jech[P]shncpd/receive.c
// Function: parse_packet
int
parse_packet(const unsigned char *buf, int buflen,
             struct sockaddr_in6 *from, int unicast,
             struct interface *interface)
{
    unsigned char id[4];
    unsigned int eid = 42;      /* silence gcc */
    int have_id = 0;
    int i = 0, rc;
    int recompute = 0;

    if(debug_level >= 3)
        debugf("Received %d bytes.\n", buflen);

    while(i < buflen) {
        unsigned const char *tlv = buf + i;
        int type, bodylen;

        if(buflen - i < 4) {
            fprintf(stderr, "Received truncated TLV.\n");
            goto fail;
        }

        DO_NTOHS(type, tlv);
        DO_NTOHS(bodylen, tlv + 2);
        if(buflen - i < 4 + bodylen) {
            fprintf(stderr, "Received truncated TLV.\n");
            goto fail;
        }

        switch(type) {
        case 1: {
            debugf("   REQ-NETWORK-STATE\n");
            int i;
            buffer_network_state(from, NULL);
            for(i = 0; i < numnodes; i++)
                buffer_node_state(&nodes[i], 0, from, NULL);
            break;
        }
        case 2: {
            struct node *node;
            if(bodylen < 4) {
                fprintf(stderr, "Truncated REQ-NODE-STATE\n");
                goto fail;
            }
            debugf("   REQ-NODE-STATE %s\n", format_32(tlv + 4));
            node = find_node(tlv + 4, 0);
            if(node)
                buffer_node_state(node, 1, from, NULL);
            break;
        }
        case 3: {
            struct neighbour *neigh;
            if(bodylen < 8) {
                fprintf(stderr, "Truncated NODE-ENDPOINT.\n");
                break;
            }
            if(have_id) {
                fprintf(stderr, "Duplicate NODE-ENDPOINT.\n");
                break;
            }
            memcpy(id, tlv + 4, 4);
            DO_NTOHL(eid, tlv + 8);
            debugf("   NODE-ENDPOINT %s %u\n", format_32(id), eid);
            if(id_eq(id, myid)) {
                fprintf(stderr, "Node id collision.\n");
                goto fail;
            }
            have_id = 1;
            if(unicast) {
                neigh = find_neighbour(interface, id, eid, from);
                if(neigh && unicast)
                    neigh->last_contact = now;
            }
            break;
        }
        case 4: {
            int rc;
            unsigned char h[8];
            struct neighbour *neigh = NULL;
            struct timespec t;

            if(have_id)
                neigh = find_neighbour(interface, id, eid, NULL);

            if(bodylen < 8) {
                fprintf(stderr, "Truncated NETWORK-STATE.\n");
                goto fail;
            }

            rc = network_hash(h);
            if(rc < 0) {
                fprintf(stderr, "Eek!\n");
                goto fail;
            }

            if(memcmp(h, tlv + 4, 8) == 0) {
                debugf("   NETWORK-STATE %s (consistent)\n",
                       format_64(tlv + 4));
                if(neigh)
                    neigh->last_contact = now;
                trickle_reset(&interface->trickle, 1);
                break;
            }

            debugf("   NETWORK-STATE %s (inconsistent, %s)\n",
                   format_64(tlv + 4), format_64(h));
            /* But don't reset Trickle. */

            ts_add_msec(&t, &interface->last_request_sent, HNCP_I_min);
            if(ts_compare(&now, &t) >= 0) {
                interface->last_request_sent = now;
                debugf("-> REQ-NETWORK-STATE\n");
                buffer_tlv(1, NULL, 0, from, NULL);
            }
            break;
        }
        case 5: {
            struct node *node;
            unsigned int seqno;
            int msecs, mine;
            int datalen = bodylen - 20;

            if(bodylen < 20) {
                fprintf(stderr, "Truncated NODE-STATE.\n");
                goto fail;
            }

            if(!have_id) {
                fprintf(stderr, "NODE-STATE with no NODE-ENDPOINT.\n");
            }

            DO_NTOHL(seqno, tlv + 8);
            DO_NTOHL(msecs, tlv + 12);

            debugf("   NODE-STATE %s %d %d", format_32(tlv + 4), seqno, msecs);

            mine = id_eq(tlv + 4, myid);
            if(mine)
                debugf(" (mine)");

            node = find_node(tlv + 4, 0);

            if(node && (seqno - node->seqno) & 0x80000000) {
                debugf(" (older)\n");
            } else if(!node || seqno != node->seqno ||
                      memcmp(tlv + 16, node->datahash, 8) != 0) {
                debugf(" (newer%s, %s)\n",
                       datalen ? ", data" : "", format_64(tlv + 16));

                if(mine) {
                    fprintf(stderr,
                            "Duplicate node identifier -- reclaiming.\n");
                    node->seqno = seqno + 42;
                    break;
                }

                if(datalen) {
                    unsigned char *new_data;
                    unsigned char h[8];
                    int rc;

                    node_hash(h, tlv + 24, datalen);
                    if(memcmp(h, tlv + 16, 8) != 0) {
                        fprintf(stderr, "Corrupt hash.\n");
                        goto fail;
                    }

                    if(!node)
                        node = find_node(tlv + 4, 1);
                    if(!node) {
                        fprintf(stderr, "Couldn't create node.\n");
                        goto fail;
                    }

                    new_data = realloc(node->data, datalen);
                    if(new_data == NULL) {
                        fprintf(stderr, "Eek!\n");
                        goto fail;
                    }
                    node->interface = interface;
                    node->seqno = seqno;
                    ts_add_msec(&node->orig_time, &now, msecs + 1);
                    node->data = new_data;
                    memcpy(node->data, tlv + 24, datalen);
                    node->datalen = datalen;
                    memcpy(node->datahash, tlv + 16, 8);
                    rc = parse_node_state(node);
                    if(rc < 0)
                        fprintf(stderr, "Couldn't parse node state.\n");
                    else
                        trickle_reset_all();
                    recompute = 1;
                } else {
                    struct neighbour *neigh = NULL;
                    if(have_id)
                        neigh = find_neighbour(interface, id, eid, from);
                    if(neigh) {
                        debugf("-> REQ-NODE-STATE %s\n", format_32(tlv + 4));
                        buffer_tlv(2, tlv + 4, 4, from, NULL);
                    } else
                        fprintf(stderr, "No neighbour to send request to.\n");
                }
            } else {
                debugf(" (consistent)\n");
            }
            break;
        }
        default:
            if(debug_level >= 3)
                debugf("   %d: %d\n", type, bodylen);
            break;
            break;
        }
        i += 4 + bodylen;
        i += -i & 3;
    }

    rc = 1;
    goto done;

 fail:
    rc = -1;

 done:
    if(recompute) {
        int r;
        silly_walk(find_node(myid, 0));
        r = prefix_assignment(1);
        if(r > 0)
            republish(0, 1);
    }
    return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movl $0x2a, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl $0x0, -0x38(%rbp)
movl $0x0, -0x40(%rbp)
leaq 0xf748(%rip), %rax      # 0x16268
cmpl $0x3, (%rax)
jl 0x6b4d
jmp 0x6b27
leaq 0xf73a(%rip), %rax      # 0x16268
cmpl $0x2, (%rax)
jl 0x6b49
movl -0xc(%rbp), %edx
movl $0x2, %edi
leaq 0xbdb2(%rip), %rsi      # 0x128f4
movb $0x0, %al
callq 0xfda0
jmp 0x6b4b
jmp 0x6b4d
jmp 0x6b4f
movl -0x38(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x7562
movq -0x8(%rbp), %rax
movslq -0x38(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movl -0xc(%rbp), %eax
subl -0x38(%rbp), %eax
cmpl $0x4, %eax
jge 0x6b92
movq 0xf47c(%rip), %rax      # 0x15ff8
movq (%rax), %rdi
leaq 0xbd82(%rip), %rsi      # 0x12908
movb $0x0, %al
callq 0x21f0
jmp 0x756b
jmp 0x6b94
movq -0x48(%rbp), %rax
movw (%rax), %ax
movw %ax, -0x52(%rbp)
movzwl -0x52(%rbp), %edi
callq 0x22b0
movzwl %ax, %eax
movl %eax, -0x4c(%rbp)
jmp 0x6bb0
movq -0x48(%rbp), %rax
movw 0x2(%rax), %ax
movw %ax, -0x54(%rbp)
movzwl -0x54(%rbp), %edi
callq 0x22b0
movzwl %ax, %eax
movl %eax, -0x50(%rbp)
movl -0xc(%rbp), %eax
subl -0x38(%rbp), %eax
movl -0x50(%rbp), %ecx
addl $0x4, %ecx
cmpl %ecx, %eax
jge 0x6bf8
movq 0xf416(%rip), %rax      # 0x15ff8
movq (%rax), %rdi
leaq 0xbd1c(%rip), %rsi      # 0x12908
movb $0x0, %al
callq 0x21f0
jmp 0x756b
movl -0x4c(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0xe0(%rbp)
subl $0x4, %eax
ja 0x750a
movq -0xe0(%rbp), %rax
leaq 0xbc4b(%rip), %rcx      # 0x12868
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x6c28
leaq 0xf639(%rip), %rax      # 0x16268
cmpl $0x2, (%rax)
jl 0x6c47
movl $0x2, %edi
leaq 0xbce1(%rip), %rsi      # 0x12921
movb $0x0, %al
callq 0xfda0
jmp 0x6c49
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5a60
movl $0x0, -0x58(%rbp)
movl -0x58(%rbp), %eax
leaq 0xf64d(%rip), %rcx      # 0x162b4
cmpl (%rcx), %eax
jge 0x6c97
movslq -0x58(%rbp), %rax
leaq 0x10c2a(%rip), %rdi     # 0x178a0
imulq $0x70, %rax, %rax
addq %rax, %rdi
movq -0x18(%rbp), %rdx
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %ecx
callq 0x5b00
movl -0x58(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x58(%rbp)
jmp 0x6c5d
jmp 0x7543
cmpl $0x4, -0x50(%rbp)
jge 0x6cbf
movq 0xf34f(%rip), %rax      # 0x15ff8
movq (%rax), %rdi
leaq 0xbc84(%rip), %rsi      # 0x12937
movb $0x0, %al
callq 0x21f0
jmp 0x756b
jmp 0x6cc1
leaq 0xf5a0(%rip), %rax      # 0x16268
cmpl $0x2, (%rax)
jl 0x6cf0
movq -0x48(%rbp), %rdi
addq $0x4, %rdi
callq 0xfc40
movq %rax, %rdx
movl $0x2, %edi
leaq 0xbc68(%rip), %rsi      # 0x12951
movb $0x0, %al
callq 0xfda0
jmp 0x6cf2
movq -0x48(%rbp), %rdi
addq $0x4, %rdi
xorl %esi, %esi
callq 0x4c80
movq %rax, -0x60(%rbp)
cmpq $0x0, -0x60(%rbp)
je 0x6d22
movq -0x60(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %ecx
callq 0x5b00
jmp 0x7543
cmpl $0x8, -0x50(%rbp)
jge 0x6d4a
movq 0xf2c4(%rip), %rax      # 0x15ff8
movq (%rax), %rdi
leaq 0xbc29(%rip), %rsi      # 0x12967
movb $0x0, %al
callq 0x21f0
jmp 0x7543
cmpl $0x0, -0x34(%rbp)
je 0x6d6d
movq 0xf2a1(%rip), %rax      # 0x15ff8
movq (%rax), %rdi
leaq 0xbc20(%rip), %rsi      # 0x12981
movb $0x0, %al
callq 0x21f0
jmp 0x7543
movq -0x48(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x48(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x6c(%rbp)
movl -0x6c(%rbp), %edi
callq 0x2350
movl %eax, -0x30(%rbp)
jmp 0x6d8e
leaq 0xf4d3(%rip), %rax      # 0x16268
cmpl $0x2, (%rax)
jl 0x6dbc
leaq -0x2c(%rbp), %rdi
callq 0xfc40
movq %rax, %rdx
movl -0x30(%rbp), %ecx
movl $0x2, %edi
leaq 0xbbe6(%rip), %rsi      # 0x1299b
movb $0x0, %al
callq 0xfda0
jmp 0x6dbe
leaq -0x2c(%rbp), %rdi
leaq 0xf4c7(%rip), %rsi      # 0x16290
callq 0x75d0
cmpl $0x0, %eax
je 0x6df0
movq 0xf21e(%rip), %rax      # 0x15ff8
movq (%rax), %rdi
leaq 0xbbcf(%rip), %rsi      # 0x129b3
movb $0x0, %al
callq 0x21f0
jmp 0x756b
movl $0x1, -0x34(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x6e3e
movq -0x28(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
movl -0x30(%rbp), %edx
movq -0x18(%rbp), %rcx
callq 0x4580
movq %rax, -0x68(%rbp)
cmpq $0x0, -0x68(%rbp)
je 0x6e3c
cmpl $0x0, -0x1c(%rbp)
je 0x6e3c
movq -0x68(%rbp), %rax
leaq 0xf453(%rip), %rcx      # 0x16280
movq (%rcx), %rdx
movq %rdx, 0x28(%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x30(%rax)
jmp 0x6e3e
jmp 0x7543
movq $0x0, -0x80(%rbp)
cmpl $0x0, -0x34(%rbp)
je 0x6e69
movq -0x28(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
movl -0x30(%rbp), %edx
xorl %eax, %eax
movl %eax, %ecx
callq 0x4580
movq %rax, -0x80(%rbp)
cmpl $0x8, -0x50(%rbp)
jge 0x6e8c
movq 0xf182(%rip), %rax      # 0x15ff8
movq (%rax), %rdi
leaq 0xbb47(%rip), %rsi      # 0x129c7
movb $0x0, %al
callq 0x21f0
jmp 0x756b
leaq -0x78(%rbp), %rdi
callq 0x5410
movl %eax, -0x70(%rbp)
cmpl $0x0, -0x70(%rbp)
jge 0x6ebb
movq 0xf153(%rip), %rax      # 0x15ff8
movq (%rax), %rdi
leaq 0xbb32(%rip), %rsi      # 0x129e1
movb $0x0, %al
callq 0x21f0
jmp 0x756b
leaq -0x78(%rbp), %rax
movq -0x48(%rbp), %rcx
addq $0x4, %rcx
movq (%rcx), %rcx
movq (%rax), %rax
subq %rcx, %rax
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x6f46
jmp 0x6edd
leaq 0xf384(%rip), %rax      # 0x16268
cmpl $0x2, (%rax)
jl 0x6f0c
movq -0x48(%rbp), %rdi
addq $0x4, %rdi
callq 0xfcd0
movq %rax, %rdx
movl $0x2, %edi
leaq 0xbae2(%rip), %rsi      # 0x129e7
movb $0x0, %al
callq 0xfda0
jmp 0x6f0e
cmpq $0x0, -0x80(%rbp)
je 0x6f2f
movq -0x80(%rbp), %rax
leaq 0xf360(%rip), %rcx      # 0x16280
movq (%rcx), %rdx
movq %rdx, 0x28(%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x30(%rax)
movq -0x28(%rbp), %rdi
addq $0x30, %rdi
movl $0x1, %esi
callq 0xf2f0
jmp 0x7543
jmp 0x6f48
leaq 0xf319(%rip), %rax      # 0x16268
cmpl $0x2, (%rax)
jl 0x6f8e
movq -0x48(%rbp), %rdi
addq $0x4, %rdi
callq 0xfcd0
movq %rax, -0xe8(%rbp)
leaq -0x78(%rbp), %rdi
callq 0xfcd0
movq -0xe8(%rbp), %rdx
movq %rax, %rcx
movl $0x2, %edi
leaq 0xba82(%rip), %rsi      # 0x12a09
movb $0x0, %al
callq 0xfda0
jmp 0x6f90
movq -0x28(%rbp), %rsi
addq $0x10, %rsi
leaq -0x90(%rbp), %rdi
movl $0xc8, %edx
callq 0xfac0
leaq 0xf2d0(%rip), %rdi      # 0x16280
leaq -0x90(%rbp), %rsi
callq 0xf900
cmpl $0x0, %eax
jl 0x7014
movq -0x28(%rbp), %rax
leaq 0xf2b4(%rip), %rcx      # 0x16280
movq (%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x18(%rax)
leaq 0xf286(%rip), %rax      # 0x16268
cmpl $0x2, (%rax)
jl 0x6ffa
movl $0x2, %edi
leaq 0xba3e(%rip), %rsi      # 0x12a31
movb $0x0, %al
callq 0xfda0
jmp 0x6ffc
movq -0x18(%rbp), %rcx
movl $0x1, %edi
xorl %eax, %eax
movl %eax, %r8d
xorl %edx, %edx
movq %r8, %rsi
callq 0x5790
jmp 0x7543
movl -0x50(%rbp), %eax
subl $0x14, %eax
movl %eax, -0xa8(%rbp)
cmpl $0x14, -0x50(%rbp)
jge 0x7048
movq 0xefc6(%rip), %rax      # 0x15ff8
movq (%rax), %rdi
leaq 0xba0b(%rip), %rsi      # 0x12a47
movb $0x0, %al
callq 0x21f0
jmp 0x756b
cmpl $0x0, -0x34(%rbp)
jne 0x7066
movq 0xefa3(%rip), %rax      # 0x15ff8
movq (%rax), %rdi
leaq 0xb9ff(%rip), %rsi      # 0x12a5e
movb $0x0, %al
callq 0x21f0
jmp 0x7068
movq -0x48(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0xac(%rbp)
movl -0xac(%rbp), %edi
callq 0x2350
movl %eax, -0x9c(%rbp)
jmp 0x7088
movq -0x48(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0xb0(%rbp)
movl -0xb0(%rbp), %edi
callq 0x2350
movl %eax, -0xa0(%rbp)
jmp 0x70a8
leaq 0xf1b9(%rip), %rax      # 0x16268
cmpl $0x2, (%rax)
jl 0x70e4
movq -0x48(%rbp), %rdi
addq $0x4, %rdi
callq 0xfc40
movq %rax, %rdx
movl -0x9c(%rbp), %ecx
movl -0xa0(%rbp), %r8d
movl $0x2, %edi
leaq 0xb9a4(%rip), %rsi      # 0x12a81
movb $0x0, %al
callq 0xfda0
jmp 0x70e6
movq -0x48(%rbp), %rdi
addq $0x4, %rdi
leaq 0xf19b(%rip), %rsi      # 0x16290
callq 0x75d0
movl %eax, -0xa4(%rbp)
cmpl $0x0, -0xa4(%rbp)
je 0x712e
jmp 0x710b
leaq 0xf156(%rip), %rax      # 0x16268
cmpl $0x2, (%rax)
jl 0x712a
movl $0x2, %edi
leaq 0xb975(%rip), %rsi      # 0x12a98
movb $0x0, %al
callq 0xfda0
jmp 0x712c
jmp 0x712e
movq -0x48(%rbp), %rdi
addq $0x4, %rdi
xorl %esi, %esi
callq 0x4c80
movq %rax, -0x98(%rbp)
cmpq $0x0, -0x98(%rbp)
je 0x7190
movl -0x9c(%rbp), %eax
movq -0x98(%rbp), %rcx
subl 0x24(%rcx), %eax
andl $0x80000000, %eax       # imm = 0x80000000
cmpl $0x0, %eax
je 0x7190
jmp 0x716a
leaq 0xf0f7(%rip), %rax      # 0x16268
cmpl $0x2, (%rax)
jl 0x7189
movl $0x2, %edi
leaq 0xb91e(%rip), %rsi      # 0x12aa0
movb $0x0, %al
callq 0xfda0
jmp 0x718b
jmp 0x7508
cmpq $0x0, -0x98(%rbp)
je 0x71d7
movl -0x9c(%rbp), %eax
movq -0x98(%rbp), %rcx
cmpl 0x24(%rcx), %eax
jne 0x71d7
movq -0x48(%rbp), %rax
addq $0x10, %rax
movq -0x98(%rbp), %rcx
addq $0x1c, %rcx
movq (%rcx), %rcx
movq (%rax), %rax
subq %rcx, %rax
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x74e1
jmp 0x71d9
leaq 0xf088(%rip), %rax      # 0x16268
cmpl $0x2, (%rax)
jl 0x7231
movl -0xa8(%rbp), %edx
leaq 0xb7f4(%rip), %rax      # 0x129e6
leaq 0xb8c1(%rip), %rcx      # 0x12aba
cmpl $0x0, %edx
cmovneq %rcx, %rax
movq %rax, -0xf0(%rbp)
movq -0x48(%rbp), %rdi
addq $0x10, %rdi
callq 0xfcd0
movq -0xf0(%rbp), %rdx
movq %rax, %rcx
movl $0x2, %edi
leaq 0xb880(%rip), %rsi      # 0x12aaa
movb $0x0, %al
callq 0xfda0
jmp 0x7233
cmpl $0x0, -0xa4(%rbp)
je 0x726c
movq 0xedb5(%rip), %rax      # 0x15ff8
movq (%rax), %rdi
leaq 0xb874(%rip), %rsi      # 0x12ac1
movb $0x0, %al
callq 0x21f0
movl -0x9c(%rbp), %ecx
addl $0x2a, %ecx
movq -0x98(%rbp), %rax
movl %ecx, 0x24(%rax)
jmp 0x7543
cmpl $0x0, -0xa8(%rbp)
je 0x743a
leaq -0xc0(%rbp), %rdi
movq -0x48(%rbp), %rsi
addq $0x18, %rsi
movl -0xa8(%rbp), %edx
callq 0x53c0
leaq -0xc0(%rbp), %rax
movq -0x48(%rbp), %rcx
addq $0x10, %rcx
movq (%rcx), %rcx
movq (%rax), %rax
subq %rcx, %rax
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x72d3
movq 0xed3b(%rip), %rax      # 0x15ff8
movq (%rax), %rdi
leaq 0xb824(%rip), %rsi      # 0x12aeb
movb $0x0, %al
callq 0x21f0
jmp 0x756b
cmpq $0x0, -0x98(%rbp)
jne 0x72f6
movq -0x48(%rbp), %rdi
addq $0x4, %rdi
movl $0x1, %esi
callq 0x4c80
movq %rax, -0x98(%rbp)
cmpq $0x0, -0x98(%rbp)
jne 0x731d
movq 0xecf1(%rip), %rax      # 0x15ff8
movq (%rax), %rdi
leaq 0xb7e9(%rip), %rsi      # 0x12afa
movb $0x0, %al
callq 0x21f0
jmp 0x756b
movq -0x98(%rbp), %rax
movq 0x10(%rax), %rdi
movslq -0xa8(%rbp), %rsi
callq 0x2290
movq %rax, -0xb8(%rbp)
cmpq $0x0, -0xb8(%rbp)
jne 0x7362
movq 0xecac(%rip), %rax      # 0x15ff8
movq (%rax), %rdi
leaq 0xb68b(%rip), %rsi      # 0x129e1
movb $0x0, %al
callq 0x21f0
jmp 0x756b
movq -0x28(%rbp), %rcx
movq -0x98(%rbp), %rax
movq %rcx, (%rax)
movl -0x9c(%rbp), %ecx
movq -0x98(%rbp), %rax
movl %ecx, 0x24(%rax)
movq -0x98(%rbp), %rdi
addq $0x28, %rdi
movl -0xa0(%rbp), %edx
addl $0x1, %edx
leaq 0xeee5(%rip), %rsi      # 0x16280
callq 0xfac0
movq -0xb8(%rbp), %rcx
movq -0x98(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x98(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x48(%rbp), %rsi
addq $0x18, %rsi
movslq -0xa8(%rbp), %rdx
callq 0x2230
movl -0xa8(%rbp), %ecx
movq -0x98(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x98(%rbp), %rax
movq -0x48(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, 0x1c(%rax)
movq -0x98(%rbp), %rdi
callq 0x7600
movl %eax, -0xc4(%rbp)
cmpl $0x0, -0xc4(%rbp)
jge 0x7429
movq 0xebe2(%rip), %rax      # 0x15ff8
movq (%rax), %rdi
leaq 0xb6f1(%rip), %rsi      # 0x12b11
movb $0x0, %al
callq 0x21f0
jmp 0x742e
callq 0x4420
movl $0x1, -0x40(%rbp)
jmp 0x74df
movq $0x0, -0xd0(%rbp)
cmpl $0x0, -0x34(%rbp)
je 0x7466
movq -0x28(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
movl -0x30(%rbp), %edx
movq -0x18(%rbp), %rcx
callq 0x4580
movq %rax, -0xd0(%rbp)
cmpq $0x0, -0xd0(%rbp)
je 0x74c5
jmp 0x7472
leaq 0xedef(%rip), %rax      # 0x16268
cmpl $0x2, (%rax)
jl 0x74a1
movq -0x48(%rbp), %rdi
addq $0x4, %rdi
callq 0xfc40
movq %rax, %rdx
movl $0x2, %edi
leaq 0xb693(%rip), %rsi      # 0x12b2d
movb $0x0, %al
callq 0xfda0
jmp 0x74a3
movq -0x48(%rbp), %rsi
addq $0x4, %rsi
movq -0x18(%rbp), %rcx
movl $0x2, %edi
movl $0x4, %edx
xorl %eax, %eax
movl %eax, %r8d
callq 0x5790
jmp 0x74dd
movq 0xeb2c(%rip), %rax      # 0x15ff8
movq (%rax), %rdi
leaq 0xb66d(%rip), %rsi      # 0x12b43
movb $0x0, %al
callq 0x21f0
jmp 0x74df
jmp 0x7506
jmp 0x74e3
leaq 0xed7e(%rip), %rax      # 0x16268
cmpl $0x2, (%rax)
jl 0x7502
movl $0x2, %edi
leaq 0xb4ff(%rip), %rsi      # 0x129fa
movb $0x0, %al
callq 0xfda0
jmp 0x7504
jmp 0x7506
jmp 0x7508
jmp 0x7543
leaq 0xed57(%rip), %rax      # 0x16268
cmpl $0x3, (%rax)
jl 0x7541
jmp 0x7518
leaq 0xed49(%rip), %rax      # 0x16268
cmpl $0x2, (%rax)
jl 0x753d
movl -0x4c(%rbp), %edx
movl -0x50(%rbp), %ecx
movl $0x2, %edi
leaq 0xb82e(%rip), %rsi      # 0x12d64
movb $0x0, %al
callq 0xfda0
jmp 0x753f
jmp 0x7541
jmp 0x7543
movl -0x50(%rbp), %eax
addl $0x4, %eax
addl -0x38(%rbp), %eax
movl %eax, -0x38(%rbp)
xorl %eax, %eax
subl -0x38(%rbp), %eax
andl $0x3, %eax
addl -0x38(%rbp), %eax
movl %eax, -0x38(%rbp)
jmp 0x6b4f
movl $0x1, -0x3c(%rbp)
jmp 0x7572
movl $0xffffffff, -0x3c(%rbp) # imm = 0xFFFFFFFF
cmpl $0x0, -0x40(%rbp)
je 0x75b5
leaq 0xed11(%rip), %rdi      # 0x16290
xorl %esi, %esi
callq 0x4c80
movq %rax, %rdi
callq 0x4f80
movl $0x1, %edi
callq 0xe690
movl %eax, -0xd4(%rbp)
cmpl $0x0, -0xd4(%rbp)
jle 0x75b3
xorl %edi, %edi
movl $0x1, %esi
callq 0x48e0
jmp 0x75b5
movl -0x3c(%rbp), %eax
addq $0xf0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)