// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/geo.c
// Function: georadiusGeneric
void georadiusGeneric(client *c, int flags) {
    robj *key = c->argv[1];
    robj *storekey = NULL;
    int storedist = 0; /* 0 for STORE, 1 for STOREDIST. */

    /* Look up the requested zset */
    robj *zobj = NULL;
    if ((zobj = lookupKeyReadOrReply(c, key, shared.emptymultibulk)) == NULL ||
        checkType(c, zobj, OBJ_ZSET)) {
        return;
    }

    /* Find long/lat to use for radius search based on inquiry type */
    int base_args;
    double xy[2] = { 0 };
    if (flags & RADIUS_COORDS) {
        base_args = 6;
        if (extractLongLatOrReply(c, c->argv + 2, xy) == C_ERR)
            return;
    } else if (flags & RADIUS_MEMBER) {
        base_args = 5;
        robj *member = c->argv[2];
        if (longLatFromMember(zobj, member, xy) == C_ERR) {
            addReplyError(c, "could not decode requested zset member");
            return;
        }
    } else {
        addReplyError(c, "Unknown georadius search type");
        return;
    }

    /* Extract radius and units from arguments */
    double radius_meters = 0, conversion = 1;
    if ((radius_meters = extractDistanceOrReply(c, c->argv + base_args - 2,
                                                &conversion)) < 0) {
        return;
    }

    /* Discover and populate all optional parameters. */
    int withdist = 0, withhash = 0, withcoords = 0;
    int sort = SORT_NONE;
    long long count = 0;
    if (c->argc > base_args) {
        int remaining = c->argc - base_args;
        for (int i = 0; i < remaining; i++) {
            char *arg = c->argv[base_args + i]->ptr;
            if (!strcasecmp(arg, "withdist")) {
                withdist = 1;
            } else if (!strcasecmp(arg, "withhash")) {
                withhash = 1;
            } else if (!strcasecmp(arg, "withcoord")) {
                withcoords = 1;
            } else if (!strcasecmp(arg, "asc")) {
                sort = SORT_ASC;
            } else if (!strcasecmp(arg, "desc")) {
                sort = SORT_DESC;
            } else if (!strcasecmp(arg, "count") && (i+1) < remaining) {
                if (getLongLongFromObjectOrReply(c, c->argv[base_args+i+1],
                    &count, NULL) != C_OK) return;
                if (count <= 0) {
                    addReplyError(c,"COUNT must be > 0");
                    return;
                }
                i++;
            } else if (!strcasecmp(arg, "store") &&
                       (i+1) < remaining &&
                       !(flags & RADIUS_NOSTORE))
            {
                storekey = c->argv[base_args+i+1];
                storedist = 0;
                i++;
            } else if (!strcasecmp(arg, "storedist") &&
                       (i+1) < remaining &&
                       !(flags & RADIUS_NOSTORE))
            {
                storekey = c->argv[base_args+i+1];
                storedist = 1;
                i++;
            } else {
                addReply(c, shared.syntaxerr);
                return;
            }
        }
    }

    /* Trap options not compatible with STORE and STOREDIST. */
    if (storekey && (withdist || withhash || withcoords)) {
        addReplyError(c,
            "STORE option in GEORADIUS is not compatible with "
            "WITHDIST, WITHHASH and WITHCOORDS options");
        return;
    }

    /* COUNT without ordering does not make much sense, force ASC
     * ordering if COUNT was specified but no sorting was requested. */
    if (count != 0 && sort == SORT_NONE) sort = SORT_ASC;

    /* Get all neighbor geohash boxes for our radius search */
    GeoHashRadius georadius =
        geohashGetAreasByRadiusWGS84(xy[0], xy[1], radius_meters);

    /* Search the zset for all matching points */
    geoArray *ga = geoArrayCreate();
    membersOfAllNeighbors(zobj, georadius, xy[0], xy[1], radius_meters, ga);

    /* If no matching results, the user gets an empty reply. */
    if (ga->used == 0 && storekey == NULL) {
        addReply(c, shared.emptymultibulk);
        geoArrayFree(ga);
        return;
    }

    long result_length = ga->used;
    long returned_items = (count == 0 || result_length < count) ?
                          result_length : count;
    long option_length = 0;

    /* Process [optional] requested sorting */
    if (sort == SORT_ASC) {
        qsort(ga->array, result_length, sizeof(geoPoint), sort_gp_asc);
    } else if (sort == SORT_DESC) {
        qsort(ga->array, result_length, sizeof(geoPoint), sort_gp_desc);
    }

    if (storekey == NULL) {
        /* No target key, return results to user. */

        /* Our options are self-contained nested multibulk replies, so we
         * only need to track how many of those nested replies we return. */
        if (withdist)
            option_length++;

        if (withcoords)
            option_length++;

        if (withhash)
            option_length++;

        /* The multibulk len we send is exactly result_length. The result is
         * either all strings of just zset members  *or* a nested multi-bulk
         * reply containing the zset member string _and_ all the additional
         * options the user enabled for this request. */
        addReplyMultiBulkLen(c, returned_items);

        /* Finally send results back to the caller */
        int i;
        for (i = 0; i < returned_items; i++) {
            geoPoint *gp = ga->array+i;
            gp->dist /= conversion; /* Fix according to unit. */

            /* If we have options in option_length, return each sub-result
             * as a nested multi-bulk.  Add 1 to account for result value
             * itself. */
            if (option_length)
                addReplyMultiBulkLen(c, option_length + 1);

            addReplyBulkSds(c,gp->member);
            gp->member = NULL;

            if (withdist)
                addReplyDoubleDistance(c, gp->dist);

            if (withhash)
                addReplyLongLong(c, gp->score);

            if (withcoords) {
                addReplyMultiBulkLen(c, 2);
                addReplyHumanLongDouble(c, gp->longitude);
                addReplyHumanLongDouble(c, gp->latitude);
            }
        }
    } else {
        /* Target key, create a sorted set with the results. */
        robj *zobj;
        zset *zs;
        int i;
        size_t maxelelen = 0;

        if (returned_items) {
            zobj = createZsetObject();
            zs = zobj->ptr;
        }

        for (i = 0; i < returned_items; i++) {
            zskiplistNode *znode;
            geoPoint *gp = ga->array+i;
            gp->dist /= conversion; /* Fix according to unit. */
            double score = storedist ? gp->dist : gp->score;
            size_t elelen = sdslen(gp->member);
            robj *ele = createObject(OBJ_STRING,gp->member);

            if (maxelelen < elelen) maxelelen = elelen;
            incrRefCount(ele); /* Set refcount to 2 since we reference the
                                  object both in the skiplist and dict. */
            znode = zslInsert(zs->zsl,score,ele);
            serverAssert(dictAdd(zs->dict,ele,&znode->score) == DICT_OK);
            gp->member = NULL;
        }

        if (returned_items) {
            zsetConvertToZiplistIfNeeded(zobj,maxelelen);
            setKey(c->db,storekey,zobj);
            decrRefCount(zobj);
            notifyKeyspaceEvent(NOTIFY_LIST,"georadiusstore",storekey,
                                c->db->id);
            server.dirty += returned_items;
        } else if (dbDelete(c->db,storekey)) {
            signalModifiedKey(c->db,storekey);
            notifyKeyspaceEvent(NOTIFY_GENERIC,"del",storekey,c->db->id);
            server.dirty++;
        }
        addReplyLongLong(c, returned_items);
    }
    geoArrayFree(ga);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2b0, %rsp            # imm = 0x2B0
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq 0xd40e8(%rip), %rax     # 0x178c40
movq 0x68(%rax), %rdx
callq 0x4a730
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0xa4b82
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl $0x3, %edx
callq 0x490a0
cmpl $0x0, %eax
je 0xa4b87
jmp 0xa5554
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x26110
movl -0xc(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xa4bce
movl $0x6, -0x34(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rsi
addq $0x10, %rsi
leaq -0x50(%rbp), %rdx
callq 0xa3980
cmpl $-0x1, %eax
jne 0xa4bcc
jmp 0xa5554
jmp 0xa4c34
movl -0xc(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0xa4c1d
movl $0x5, -0x34(%rbp)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x30(%rbp), %rdi
movq -0x58(%rbp), %rsi
leaq -0x50(%rbp), %rdx
callq 0xa3a90
cmpl $-0x1, %eax
jne 0xa4c1b
movq -0x8(%rbp), %rdi
leaq 0xa4925(%rip), %rsi     # 0x149536
callq 0x42f90
jmp 0xa5554
jmp 0xa4c32
movq -0x8(%rbp), %rdi
leaq 0xa4935(%rip), %rsi     # 0x14955d
callq 0x42f90
jmp 0xa5554
jmp 0xa4c34
xorps %xmm0, %xmm0
movsd %xmm0, -0x60(%rbp)
movsd 0x92824(%rip), %xmm0    # 0x137468
movsd %xmm0, -0x68(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rsi
movslq -0x34(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rsi
addq $-0x10, %rsi
leaq -0x68(%rbp), %rdx
callq 0xa3be0
movaps %xmm0, %xmm1
movsd %xmm1, -0x60(%rbp)
xorps %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jbe 0xa4c83
jmp 0xa5554
movl $0x0, -0x6c(%rbp)
movl $0x0, -0x70(%rbp)
movl $0x0, -0x74(%rbp)
movl $0x0, -0x78(%rbp)
movq $0x0, -0x80(%rbp)
movq -0x8(%rbp), %rax
movl 0x38(%rax), %eax
cmpl -0x34(%rbp), %eax
jle 0xa4f64
movq -0x8(%rbp), %rax
movl 0x38(%rax), %eax
subl -0x34(%rbp), %eax
movl %eax, -0x84(%rbp)
movl $0x0, -0x88(%rbp)
movl -0x88(%rbp), %eax
cmpl -0x84(%rbp), %eax
jge 0xa4f62
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movl -0x34(%rbp), %ecx
addl -0x88(%rbp), %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %rdi
leaq 0xa4867(%rip), %rsi     # 0x14957b
callq 0x26300
cmpl $0x0, %eax
jne 0xa4d2a
movl $0x1, -0x6c(%rbp)
jmp 0xa4f4c
movq -0x90(%rbp), %rdi
leaq 0xa484c(%rip), %rsi     # 0x149584
callq 0x26300
cmpl $0x0, %eax
jne 0xa4d4e
movl $0x1, -0x70(%rbp)
jmp 0xa4f4a
movq -0x90(%rbp), %rdi
leaq 0xa4831(%rip), %rsi     # 0x14958d
callq 0x26300
cmpl $0x0, %eax
jne 0xa4d72
movl $0x1, -0x74(%rbp)
jmp 0xa4f48
movq -0x90(%rbp), %rdi
leaq 0x9c83b(%rip), %rsi     # 0x1415bb
callq 0x26300
cmpl $0x0, %eax
jne 0xa4d96
movl $0x1, -0x78(%rbp)
jmp 0xa4f46
movq -0x90(%rbp), %rdi
leaq 0x9c81b(%rip), %rsi     # 0x1415bf
callq 0x26300
cmpl $0x0, %eax
jne 0xa4dba
movl $0x2, -0x78(%rbp)
jmp 0xa4f44
movq -0x90(%rbp), %rdi
leaq 0xa1c71(%rip), %rsi     # 0x146a39
callq 0x26300
cmpl $0x0, %eax
jne 0xa4e49
movl -0x88(%rbp), %eax
addl $0x1, %eax
cmpl -0x84(%rbp), %eax
jge 0xa4e49
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movl -0x34(%rbp), %ecx
addl -0x88(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rsi
leaq -0x80(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x49ea0
cmpl $0x0, %eax
je 0xa4e19
jmp 0xa5554
cmpq $0x0, -0x80(%rbp)
jg 0xa4e35
movq -0x8(%rbp), %rdi
leaq 0xa476c(%rip), %rsi     # 0x149597
callq 0x42f90
jmp 0xa5554
movl -0x88(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x88(%rbp)
jmp 0xa4f42
movq -0x90(%rbp), %rdi
leaq 0x92a17(%rip), %rsi     # 0x13786e
callq 0x26300
cmpl $0x0, %eax
jne 0xa4eb7
movl -0x88(%rbp), %eax
addl $0x1, %eax
cmpl -0x84(%rbp), %eax
jge 0xa4eb7
movl -0xc(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
jne 0xa4eb7
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movl -0x34(%rbp), %ecx
addl -0x88(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x88(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x88(%rbp)
jmp 0xa4f40
movq -0x90(%rbp), %rdi
leaq 0x96b94(%rip), %rsi     # 0x13ba59
callq 0x26300
cmpl $0x0, %eax
jne 0xa4f22
movl -0x88(%rbp), %eax
addl $0x1, %eax
cmpl -0x84(%rbp), %eax
jge 0xa4f22
movl -0xc(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
jne 0xa4f22
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movl -0x34(%rbp), %ecx
addl -0x88(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movl $0x1, -0x24(%rbp)
movl -0x88(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x88(%rbp)
jmp 0xa4f3e
movq -0x8(%rbp), %rdi
leaq 0xd3d13(%rip), %rax     # 0x178c40
movq 0x80(%rax), %rsi
callq 0x42cc0
jmp 0xa5554
jmp 0xa4f40
jmp 0xa4f42
jmp 0xa4f44
jmp 0xa4f46
jmp 0xa4f48
jmp 0xa4f4a
jmp 0xa4f4c
jmp 0xa4f4e
movl -0x88(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x88(%rbp)
jmp 0xa4cd1
jmp 0xa4f64
cmpq $0x0, -0x20(%rbp)
je 0xa4f92
cmpl $0x0, -0x6c(%rbp)
jne 0xa4f7d
cmpl $0x0, -0x70(%rbp)
jne 0xa4f7d
cmpl $0x0, -0x74(%rbp)
je 0xa4f92
movq -0x8(%rbp), %rdi
leaq 0xa4621(%rip), %rsi     # 0x1495a9
callq 0x42f90
jmp 0xa5554
cmpq $0x0, -0x80(%rbp)
je 0xa4fa6
cmpl $0x0, -0x78(%rbp)
jne 0xa4fa6
movl $0x1, -0x78(%rbp)
movsd -0x50(%rbp), %xmm0
movsd -0x48(%rbp), %xmm1
movsd -0x60(%rbp), %xmm2
leaq -0x150(%rbp), %rdi
callq 0xd4b80
callq 0xa37c0
movq %rax, -0x158(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x1d0(%rbp)
movsd -0x50(%rbp), %xmm0
movsd -0x48(%rbp), %xmm1
movsd -0x60(%rbp), %xmm2
movq -0x158(%rbp), %rax
movq %rax, -0x1d8(%rbp)
movq %rsp, %rdi
movl $0x18, %ecx
leaq -0x150(%rbp), %rsi
rep  movsq (%rsi), %es:(%rdi)
movq -0x1d8(%rbp), %rsi
movq -0x1d0(%rbp), %rdi
callq 0xa4210
movq -0x158(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0xa5054
cmpq $0x0, -0x20(%rbp)
jne 0xa5054
movq -0x8(%rbp), %rdi
leaq 0xd3c06(%rip), %rax     # 0x178c40
movq 0x68(%rax), %rsi
callq 0x42cc0
movq -0x158(%rbp), %rdi
callq 0xa38b0
jmp 0xa5554
movq -0x158(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x160(%rbp)
cmpq $0x0, -0x80(%rbp)
je 0xa507a
movq -0x160(%rbp), %rax
cmpq -0x80(%rbp), %rax
jge 0xa508a
movq -0x160(%rbp), %rax
movq %rax, -0x1e0(%rbp)
jmp 0xa5095
movq -0x80(%rbp), %rax
movq %rax, -0x1e0(%rbp)
movq -0x1e0(%rbp), %rax
movq %rax, -0x168(%rbp)
movq $0x0, -0x170(%rbp)
cmpl $0x1, -0x78(%rbp)
jne 0xa50d8
movq -0x158(%rbp), %rax
movq (%rax), %rdi
movq -0x160(%rbp), %rsi
movl $0x28, %edx
leaq 0x48f(%rip), %rcx       # 0xa5560
callq 0x26890
jmp 0xa5102
cmpl $0x2, -0x78(%rbp)
jne 0xa5100
movq -0x158(%rbp), %rax
movq (%rax), %rdi
movq -0x160(%rbp), %rsi
movl $0x28, %edx
leaq 0x4d5(%rip), %rcx       # 0xa55d0
callq 0x26890
jmp 0xa5102
cmpq $0x0, -0x20(%rbp)
jne 0xa5292
cmpl $0x0, -0x6c(%rbp)
je 0xa5125
movq -0x170(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x170(%rbp)
cmpl $0x0, -0x74(%rbp)
je 0xa513d
movq -0x170(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x170(%rbp)
cmpl $0x0, -0x70(%rbp)
je 0xa5155
movq -0x170(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x170(%rbp)
movq -0x8(%rbp), %rdi
movq -0x168(%rbp), %rsi
callq 0x437f0
movl $0x0, -0x174(%rbp)
movslq -0x174(%rbp), %rax
cmpq -0x168(%rbp), %rax
jge 0xa528d
movq -0x158(%rbp), %rax
movq (%rax), %rax
movslq -0x174(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x180(%rbp)
movsd -0x68(%rbp), %xmm1
movq -0x180(%rbp), %rax
movsd 0x10(%rax), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rax)
cmpq $0x0, -0x170(%rbp)
je 0xa51da
movq -0x8(%rbp), %rdi
movq -0x170(%rbp), %rsi
addq $0x1, %rsi
callq 0x437f0
movq -0x8(%rbp), %rdi
movq -0x180(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x43970
movq -0x180(%rbp), %rax
movq $0x0, 0x20(%rax)
cmpl $0x0, -0x6c(%rbp)
je 0xa5218
movq -0x8(%rbp), %rdi
movq -0x180(%rbp), %rax
movsd 0x10(%rax), %xmm0
callq 0xa3cb0
cmpl $0x0, -0x70(%rbp)
je 0xa5234
movq -0x8(%rbp), %rdi
movq -0x180(%rbp), %rax
cvttsd2si 0x18(%rax), %rsi
callq 0x43780
cmpl $0x0, -0x74(%rbp)
je 0xa5277
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x437f0
movq -0x8(%rbp), %rdi
movq -0x180(%rbp), %rax
fldl (%rax)
movq %rsp, %rax
fstpt (%rax)
callq 0x435e0
movq -0x8(%rbp), %rdi
movq -0x180(%rbp), %rax
fldl 0x8(%rax)
movq %rsp, %rax
fstpt (%rax)
callq 0x435e0
jmp 0xa5279
movl -0x174(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x174(%rbp)
jmp 0xa516f
jmp 0xa5548
movq $0x0, -0x1a0(%rbp)
cmpq $0x0, -0x168(%rbp)
je 0xa52c5
callq 0x48c90
movq %rax, -0x188(%rbp)
movq -0x188(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x190(%rbp)
movl $0x0, -0x194(%rbp)
movslq -0x194(%rbp), %rax
cmpq -0x168(%rbp), %rax
jge 0xa5449
movq -0x158(%rbp), %rax
movq (%rax), %rax
movslq -0x194(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x1b0(%rbp)
movsd -0x68(%rbp), %xmm1
movq -0x1b0(%rbp), %rax
movsd 0x10(%rax), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rax)
cmpl $0x0, -0x24(%rbp)
je 0xa5338
movq -0x1b0(%rbp), %rax
movsd 0x10(%rax), %xmm0
movsd %xmm0, -0x1e8(%rbp)
jmp 0xa534c
movq -0x1b0(%rbp), %rax
movsd 0x18(%rax), %xmm0
movsd %xmm0, -0x1e8(%rbp)
movsd -0x1e8(%rbp), %xmm0
movsd %xmm0, -0x1b8(%rbp)
movq -0x1b0(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0xa5600
movq %rax, -0x1c0(%rbp)
movq -0x1b0(%rbp), %rax
movq 0x20(%rax), %rsi
xorl %edi, %edi
callq 0x48480
movq %rax, -0x1c8(%rbp)
movq -0x1a0(%rbp), %rax
cmpq -0x1c0(%rbp), %rax
jae 0xa53aa
movq -0x1c0(%rbp), %rax
movq %rax, -0x1a0(%rbp)
movq -0x1c8(%rbp), %rdi
callq 0x487b0
movq -0x190(%rbp), %rax
movq 0x8(%rax), %rdi
movsd -0x1b8(%rbp), %xmm0
movq -0x1c8(%rbp), %rsi
callq 0x5e160
movq %rax, -0x1a8(%rbp)
movq -0x190(%rbp), %rax
movq (%rax), %rdi
movq -0x1c8(%rbp), %rsi
movq -0x1a8(%rbp), %rdx
addq $0x8, %rdx
callq 0x2d8c0
cmpl $0x0, %eax
jne 0xa5404
jmp 0xa5426
leaq 0x98a18(%rip), %rdi     # 0x13de23
leaq 0xa4011(%rip), %rsi     # 0x149423
movl $0x293, %edx            # imm = 0x293
callq 0x76ce0
movl $0x1, %edi
callq 0x263c0
movq -0x1b0(%rbp), %rax
movq $0x0, 0x20(%rax)
movl -0x194(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x194(%rbp)
jmp 0xa52cf
cmpq $0x0, -0x168(%rbp)
je 0xa54cf
movq -0x188(%rbp), %rdi
movq -0x1a0(%rbp), %rsi
callq 0x614a0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x20(%rbp), %rsi
movq -0x188(%rbp), %rdx
callq 0x4a960
movq -0x188(%rbp), %rdi
callq 0x48f70
movq -0x20(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x30(%rax), %ecx
movl $0x10, %edi
leaq 0xa415f(%rip), %rsi     # 0x149604
callq 0x9ce20
movq -0x168(%rbp), %rcx
leaq 0xd2d20(%rip), %rax     # 0x1781d8
addq 0x720(%rax), %rcx
leaq 0xd2d12(%rip), %rax     # 0x1781d8
movq %rcx, 0x720(%rax)
jmp 0xa5538
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x4ac10
cmpl $0x0, %eax
je 0xa5536
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x4aa60
movq -0x20(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x30(%rax), %ecx
movl $0x4, %edi
leaq 0x93f87(%rip), %rsi     # 0x139498
callq 0x9ce20
leaq 0xd2cbb(%rip), %rax     # 0x1781d8
movq 0x720(%rax), %rcx
addq $0x1, %rcx
leaq 0xd2ca9(%rip), %rax     # 0x1781d8
movq %rcx, 0x720(%rax)
jmp 0xa5538
movq -0x8(%rbp), %rdi
movq -0x168(%rbp), %rsi
callq 0x43780
movq -0x158(%rbp), %rdi
callq 0xa38b0
addq $0x2b0, %rsp            # imm = 0x2B0
popq %rbp
retq
nopl (%rax)