// File: /workspace/github_c_makefile_star2_O0/zuocheng-liu[P]ae-memcached/src/memcached.c
// Function: main
int main (int argc, char **argv) {
    conn *l_conn;
    /*conn *u_conn;*/
    struct passwd *pw;
    struct sigaction sa;
    struct rlimit rlim;
    
    /* set stderr non-buffering (for running under, say, daemontools) */
    setbuf(stderr, NULL);

    /* handle SIGINT */
    signal(SIGINT, sigint_handler);

    /* init settings */
    settings_init(&settings);
    /* process arguments */
    process_arguments(&settings, argc, argv);

    /* create mem_cache instance */
    mem_cache = mem_cache_create(48, 1.25, 40, DEFAULT_POWER_BLOCK, settings.maxbytes, 1);
    /* create AE event loop  */
    g_el = aeCreateEventLoop(AE_SETSIZE);

    if (settings.maxcore) {
        struct rlimit rlim_new;
        /*
         * First try raising to infinity; if that fails, try bringing
         * the soft limit to the hard.
         */
        if (getrlimit(RLIMIT_CORE, &rlim)==0) {
            rlim_new.rlim_cur = rlim_new.rlim_max = RLIM_INFINITY;
            if (setrlimit(RLIMIT_CORE, &rlim_new)!=0) {
                /* failed. try raising just to the old max */
                rlim_new.rlim_cur = rlim_new.rlim_max =
                    rlim.rlim_max;
                (void) setrlimit(RLIMIT_CORE, &rlim_new);
            }
        }
        /*
         * getrlimit again to see what we ended up with. Only fail if
         * the soft limit ends up 0, because then no core files will be
         * created at all.
         */

        if ((getrlimit(RLIMIT_CORE, &rlim)!=0) || rlim.rlim_cur==0) {
            fprintf(stderr, "failed to ensure corefile creation\n");
            exit(1);
        }
    }

    /*
     * If needed, increase rlimits to allow as many connections
     * as needed.
     */

    if (getrlimit(RLIMIT_NOFILE, &rlim) != 0) {
        fprintf(stderr, "failed to getrlimit number of files\n");
        exit(1);
    } else {
        int maxfiles = settings.maxconns;
        if ((int)rlim.rlim_cur < maxfiles)
            rlim.rlim_cur = maxfiles + 3;
        if (rlim.rlim_max < rlim.rlim_cur)
            rlim.rlim_max = rlim.rlim_cur;
        if (setrlimit(RLIMIT_NOFILE, &rlim) != 0) {
            fprintf(stderr, "failed to set rlimit for open files. Try running as root or requesting smaller maxconns value.\n");
            exit(1);
        }
    }

    /*
     * initialization order: first create the listening sockets
     * (may need root on low ports), then drop root if needed,
     * then daemonise if needed, then init libevent (in some cases
     * descriptors created by libevent wouldn't survive forking).
     */

    /* create the listening socket and bind it */
    if (!settings.socketpath) {
        l_socket = server_socket(settings.port, 0);
        if (l_socket == -1) {
            fprintf(stderr, "failed to listen\n");
            exit(1);
        }
    }

    if (settings.udpport > 0 && ! settings.socketpath) {
        /* create the UDP listening socket and bind it */
        u_socket = server_socket(settings.udpport, 1);
        if (u_socket == -1) {
            fprintf(stderr, "failed to listen on UDP port %d\n", settings.udpport);
            exit(1);
        }
    }

    /* lose root privileges if we have them */
    if (getuid()== 0 || geteuid()==0) {
        if (settings.username==0 || *(settings.username)=='\0') {
            fprintf(stderr, "can't run as root without the -u switch\n");
            return 1;
        }
        if ((pw = getpwnam(settings.username)) == 0) {
            fprintf(stderr, "can't find the user %s to switch to\n", settings.username);
            return 1;
        }
        if (setgid(pw->pw_gid)<0 || setuid(pw->pw_uid)<0) {
            fprintf(stderr, "failed to assume identity of user %s\n", settings.username);
            return 1;
        }
    }

    /* create unix mode sockets after dropping privileges */
    if (settings.socketpath) {
        l_socket = server_socket_unix(settings.socketpath);
        if (l_socket == -1) {
            fprintf(stderr, "failed to listen\n");
            exit(1);
        }
    }

    /* daemonize if requested */
    /* if we want to ensure our ability to dump core, don't chdir to / */
    if (settings.daemonize) {
        int res;
        res = daemon(settings.maxcore, settings.verbose);
        if (res == -1) {
            fprintf(stderr, "failed to daemon() in order to daemonize\n");
            return 1;
        }
    }


    /* initialize other stuff */
    item_init();
    stats_init(&stats);
    assoc_init();
    conn_init();

    /* managed instance? alloc and zero a bucket array */
    if (settings.managed) {
        buckets = malloc(sizeof(int)*MAX_BUCKETS);
        if (buckets == 0) {
            fprintf(stderr, "failed to allocate the bucket array");
            exit(1);
        }
        memset(buckets, 0, sizeof(int)*MAX_BUCKETS);
    }

    /* lock paged memory if needed */
    if (settings.lock_memory) {
        mlockall(MCL_CURRENT | MCL_FUTURE);
        fprintf(stderr, "warning: mlockall() not supported on this platform.  proceeding without.\n");
    }

    /*
     * ignore SIGPIPE signals; we can use errno==EPIPE if we
     * need that information
     */
    sa.sa_handler = SIG_IGN;
    sa.sa_flags = 0;
    if (sigemptyset(&sa.sa_mask) == -1 ||
        sigaction(SIGPIPE, &sa, 0) == -1) {
        perror("failed to ignore SIGPIPE; sigaction");
        exit(1);
    }
    /* create the initial listening connection */
    if (!(l_conn = conn_new(l_socket, conn_listening, AE_READABLE, 1, 0))) {
        fprintf(stderr, "failed to create listening connection");
        exit(1);
    }
    /* create the initial listening udp connection     
      if (u_socket > -1 &&
        !(u_conn = conn_new(u_socket, conn_read, EV_READ | EV_PERSIST, UDP_READ_BUFFER_SIZE, 1))) {
        fprintf(stderr, "failed to create udp connection");
        exit(1);
    }*/
    /* initialise clock event */
    aeCreateTimeEvent(g_el, 1000, clock_handler, NULL, NULL);
    /* initialise deletion array and timer event */
    deltotal = 200; delcurr = 0;
    todelete = malloc(sizeof(item *)*deltotal);
    aeCreateTimeEvent(g_el, 1000, timer_delete_handler, NULL, NULL);
    
    /* create command service */
    g_cmd_srv = command_service_create();
    /* register commands */
    command_service_register_handler(g_cmd_srv, "get ", 4, FIXED_PREFIX, get_handler);
    command_service_register_handler(g_cmd_srv, "bget ", 5, FIXED_PREFIX, bget_handler);

    /* writting commands */
    command_service_register_handler(g_cmd_srv, "set ", 4, FIXED_PREFIX, set_handler);
    command_service_register_handler(g_cmd_srv, "add ", 4, FIXED_PREFIX, add_handler);
    command_service_register_handler(g_cmd_srv, "replace ", 8, FIXED_PREFIX, replace_handler);
    command_service_register_handler(g_cmd_srv, "incr ", 5, FIXED_PREFIX, incr_handler);
    command_service_register_handler(g_cmd_srv, "decr ", 5, FIXED_PREFIX, decr_handler);
    command_service_register_handler(g_cmd_srv, "delete ", 7, FIXED_PREFIX, delete_handler);
    
    command_service_register_handler(g_cmd_srv, "own ", 4, FIXED_PREFIX, own_handler);
    command_service_register_handler(g_cmd_srv, "disown ", 7, FIXED_PREFIX, disown_handler);

    /* statistics commands */
    command_service_register_handler(g_cmd_srv, "stats", 5, FULL_MATCH, stats_handler);
    command_service_register_handler(g_cmd_srv, "stats reset", 11, FULL_MATCH, stats_reset_handler);
    command_service_register_handler(g_cmd_srv, "stats malloc", 12, FULL_MATCH, stats_malloc_handler);
    command_service_register_handler(g_cmd_srv, "stats maps", 10, FULL_MATCH, stats_maps_handler);
    command_service_register_handler(g_cmd_srv, "stats cachedump", 15, FULL_MATCH, stats_cachedump_handler);
    command_service_register_handler(g_cmd_srv, "stats slabs", 11, FULL_MATCH, stats_slabs_handler);
    command_service_register_handler(g_cmd_srv, "stats items", 11, FULL_MATCH, stats_items_handler);
    command_service_register_handler(g_cmd_srv, "stats sizes", 11, FULL_MATCH, stats_sizes_handler);
    
    /* other commands */
    command_service_register_handler(g_cmd_srv, "version", 7, FULL_MATCH, version_handler);
    command_service_register_handler(g_cmd_srv, "quit", 4, FULL_MATCH, quit_handler);
    command_service_register_handler(g_cmd_srv, "slabs reassign ", 15, FIXED_PREFIX, quit_handler);
    command_service_register_handler(g_cmd_srv, "flush_all", 9, FIXED_PREFIX, flush_all_handler);
    command_service_register_handler(g_cmd_srv, "bg ", 3, FIXED_PREFIX, bg_handler);

    /* save the PID in if we're a daemon */
    if (settings.daemonize && NULL != settings.pid_file) {
        FILE *fp;
        if (!(fp = fopen(settings.pid_file,"w"))) {
            fprintf(stderr,"Could not open the pid file %s for writing\n",settings.pid_file);
        } else {
            fprintf(fp,"%ld\n",(long) getpid());
            if (fclose(fp) < 0) {
                fprintf(stderr,"Could not close the pid file %s.\n",settings.pid_file);
            }
        }
    }

    /* enter the loop */
    aeMain(g_el);
    aeDeleteEventLoop(g_el);
    
    /* destory command service */
    command_service_destory(g_cmd_srv);

    /* remove the PID file if we're a daemon */
    if (settings.daemonize && NULL != settings.pid_file) {
        if (unlink(settings.pid_file) < 0) {
            fprintf(stderr,"Could not remove the pid file %s.\n",settings.pid_file);
        }
    }
    return 0;
}

// Assembly:
subq $0xf8, %rsp
movl $0x0, 0xf4(%rsp)
movl %edi, 0xf0(%rsp)
movq %rsi, 0xe8(%rsp)
movq 0x6bd0(%rip), %rax      # 0x10ff8
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2140
movl $0x2, %edi
leaq -0x60(%rip), %rsi       # 0xa3e0
callq 0x2260
leaq 0x6e4c(%rip), %rdi      # 0x11298
callq 0xafd0
movl 0xf0(%rsp), %esi
movq 0xe8(%rsp), %rdx
leaq 0x6e31(%rip), %rdi      # 0x11298
callq 0xb0a0
leaq 0x6e25(%rip), %rax      # 0x11298
movq (%rax), %rcx
movl $0x30, %edi
movsd 0x1eb5(%rip), %xmm0     # 0xc338
movl $0x28, %esi
movl $0x100000, %edx         # imm = 0x100000
movl $0x1, %r8d
callq 0x6260
movq %rax, %rcx
leaq 0x6ea6(%rip), %rax      # 0x11348
movq %rcx, (%rax)
movl $0x2800, %edi           # imm = 0x2800
callq 0x2580
movq %rax, %rcx
leaq 0x6dcf(%rip), %rax      # 0x11288
movq %rcx, (%rax)
leaq 0x6dd5(%rip), %rax      # 0x11298
cmpl $0x0, 0x44(%rax)
je 0xa567
movl $0x4, %edi
leaq 0x30(%rsp), %rsi
callq 0x2440
cmpl $0x0, %eax
jne 0xa527
movq $-0x1, 0x28(%rsp)
movq $-0x1, 0x20(%rsp)
movl $0x4, %edi
leaq 0x20(%rsp), %rsi
callq 0x2320
cmpl $0x0, %eax
je 0xa525
movq 0x38(%rsp), %rax
movq %rax, 0x28(%rsp)
movq %rax, 0x20(%rsp)
movl $0x4, %edi
leaq 0x20(%rsp), %rsi
callq 0x2320
jmp 0xa527
movl $0x4, %edi
leaq 0x30(%rsp), %rsi
callq 0x2440
cmpl $0x0, %eax
jne 0xa543
cmpq $0x0, 0x30(%rsp)
jne 0xa565
movq 0x6aae(%rip), %rax      # 0x10ff8
movq (%rax), %rdi
leaq 0x24be(%rip), %rsi      # 0xca12
movb $0x0, %al
callq 0x2280
movl $0x1, %edi
callq 0x2430
jmp 0xa567
movl $0x7, %edi
leaq 0x30(%rsp), %rsi
callq 0x2440
cmpl $0x0, %eax
je 0xa59d
movq 0x6a76(%rip), %rax      # 0x10ff8
movq (%rax), %rdi
leaq 0x24aa(%rip), %rsi      # 0xca36
movb $0x0, %al
callq 0x2280
movl $0x1, %edi
callq 0x2430
leaq 0x6cf4(%rip), %rax      # 0x11298
movl 0x8(%rax), %eax
movl %eax, 0x1c(%rsp)
movq 0x30(%rsp), %rax
cmpl 0x1c(%rsp), %eax
jge 0xa5c4
movl 0x1c(%rsp), %eax
addl $0x3, %eax
cltq
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rax
cmpq 0x30(%rsp), %rax
jae 0xa5da
movq 0x30(%rsp), %rax
movq %rax, 0x38(%rsp)
movl $0x7, %edi
leaq 0x30(%rsp), %rsi
callq 0x2320
cmpl $0x0, %eax
je 0xa610
movq 0x6a03(%rip), %rax      # 0x10ff8
movq (%rax), %rdi
leaq 0x245c(%rip), %rsi      # 0xca5b
movb $0x0, %al
callq 0x2280
movl $0x1, %edi
callq 0x2430
jmp 0xa612
leaq 0x6c7f(%rip), %rax      # 0x11298
cmpq $0x0, 0x28(%rax)
jne 0xa66c
leaq 0x6c71(%rip), %rax      # 0x11298
movl 0xc(%rax), %edi
xorl %esi, %esi
callq 0x9e60
movl %eax, %ecx
leaq 0x6c46(%rip), %rax      # 0x11280
movl %ecx, (%rax)
leaq 0x6c3d(%rip), %rax      # 0x11280
cmpl $-0x1, (%rax)
jne 0xa66a
movq 0x69a9(%rip), %rax      # 0x10ff8
movq (%rax), %rdi
leaq 0x2462(%rip), %rsi      # 0xcabb
movb $0x0, %al
callq 0x2280
movl $0x1, %edi
callq 0x2430
jmp 0xa66c
leaq 0x6c25(%rip), %rax      # 0x11298
cmpl $0x0, 0x10(%rax)
jle 0xa6e0
leaq 0x6c18(%rip), %rax      # 0x11298
cmpq $0x0, 0x28(%rax)
jne 0xa6e0
leaq 0x6c0a(%rip), %rax      # 0x11298
movl 0x10(%rax), %edi
movl $0x1, %esi
callq 0x9e60
movl %eax, %ecx
leaq 0x6bac(%rip), %rax      # 0x11250
movl %ecx, (%rax)
leaq 0x6ba3(%rip), %rax      # 0x11250
cmpl $-0x1, (%rax)
jne 0xa6de
movq 0x693f(%rip), %rax      # 0x10ff8
movq (%rax), %rdi
leaq 0x6bd5(%rip), %rax      # 0x11298
movl 0x10(%rax), %edx
leaq 0x2400(%rip), %rsi      # 0xcacd
movb $0x0, %al
callq 0x2280
movl $0x1, %edi
callq 0x2430
jmp 0xa6e0
callq 0x2130
cmpl $0x0, %eax
je 0xa6f8
callq 0x21c0
cmpl $0x0, %eax
jne 0xa7f1
leaq 0x6b99(%rip), %rax      # 0x11298
cmpq $0x0, 0x48(%rax)
je 0xa719
leaq 0x6b8b(%rip), %rax      # 0x11298
movq 0x48(%rax), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0xa741
movq 0x68d8(%rip), %rax      # 0x10ff8
movq (%rax), %rdi
leaq 0x23c4(%rip), %rsi      # 0xcaee
movb $0x0, %al
callq 0x2280
movl $0x1, 0xf4(%rsp)
jmp 0xaf29
leaq 0x6b50(%rip), %rax      # 0x11298
movq 0x48(%rax), %rdi
callq 0x2270
movq %rax, 0xd8(%rsp)
cmpq $0x0, %rax
jne 0xa792
movq 0x6892(%rip), %rax      # 0x10ff8
movq (%rax), %rdi
leaq 0x6b28(%rip), %rax      # 0x11298
movq 0x48(%rax), %rdx
leaq 0x239c(%rip), %rsi      # 0xcb17
movb $0x0, %al
callq 0x2280
movl $0x1, 0xf4(%rsp)
jmp 0xaf29
movq 0xd8(%rsp), %rax
movl 0x14(%rax), %edi
callq 0x2390
cmpl $0x0, %eax
jl 0xa7bc
movq 0xd8(%rsp), %rax
movl 0x10(%rax), %edi
callq 0x2450
cmpl $0x0, %eax
jge 0xa7ef
movq 0x6835(%rip), %rax      # 0x10ff8
movq (%rax), %rdi
leaq 0x6acb(%rip), %rax      # 0x11298
movq 0x48(%rax), %rdx
leaq 0x2364(%rip), %rsi      # 0xcb3c
movb $0x0, %al
callq 0x2280
movl $0x1, 0xf4(%rsp)
jmp 0xaf29
jmp 0xa7f1
leaq 0x6aa0(%rip), %rax      # 0x11298
cmpq $0x0, 0x28(%rax)
je 0xa84a
leaq 0x6a92(%rip), %rax      # 0x11298
movq 0x28(%rax), %rdi
callq 0xa090
movl %eax, %ecx
leaq 0x6a68(%rip), %rax      # 0x11280
movl %ecx, (%rax)
leaq 0x6a5f(%rip), %rax      # 0x11280
cmpl $-0x1, (%rax)
jne 0xa848
movq 0x67cb(%rip), %rax      # 0x10ff8
movq (%rax), %rdi
leaq 0x2284(%rip), %rsi      # 0xcabb
movb $0x0, %al
callq 0x2280
movl $0x1, %edi
callq 0x2430
jmp 0xa84a
leaq 0x6a47(%rip), %rax      # 0x11298
cmpl $0x0, 0x40(%rax)
je 0xa8a5
leaq 0x6a3a(%rip), %rax      # 0x11298
movl 0x44(%rax), %edi
leaq 0x6a30(%rip), %rax      # 0x11298
movl 0x18(%rax), %esi
callq 0x5430
movl %eax, 0x18(%rsp)
cmpl $-0x1, 0x18(%rsp)
jne 0xa8a3
movq 0x6776(%rip), %rax      # 0x10ff8
movq (%rax), %rdi
leaq 0x22d6(%rip), %rsi      # 0xcb62
movb $0x0, %al
callq 0x2280
movl $0x1, 0xf4(%rsp)
jmp 0xaf29
jmp 0xa8a5
callq 0x5520
leaq 0x6a3f(%rip), %rdi      # 0x112f0
callq 0xb840
callq 0x3f30
callq 0x45c0
leaq 0x69d1(%rip), %rax      # 0x11298
cmpl $0x0, 0x20(%rax)
je 0xa91d
movl $0x20000, %edi          # imm = 0x20000
callq 0x22e0
movq %rax, 0x7e82(%rip)      # 0x12760
cmpq $0x0, 0x7e7a(%rip)      # 0x12760
jne 0xa90a
movq 0x6709(%rip), %rax      # 0x10ff8
movq (%rax), %rdi
leaq 0x2293(%rip), %rsi      # 0xcb8c
movb $0x0, %al
callq 0x2280
movl $0x1, %edi
callq 0x2430
movq 0x7e4f(%rip), %rdi      # 0x12760
xorl %esi, %esi
movl $0x20000, %edx          # imm = 0x20000
callq 0x21b0
leaq 0x6974(%rip), %rax      # 0x11298
cmpl $0x0, 0x3c(%rax)
je 0xa94c
movl $0x3, %edi
callq 0x2340
movq 0x66bd(%rip), %rax      # 0x10ff8
movq (%rax), %rdi
leaq 0x226b(%rip), %rsi      # 0xcbb0
movb $0x0, %al
callq 0x2280
movl $0x1, %eax
movq %rax, 0x40(%rsp)
movl $0x0, 0xc8(%rsp)
leaq 0x40(%rsp), %rdi
addq $0x8, %rdi
callq 0x2290
cmpl $-0x1, %eax
je 0xa98c
movl $0xd, %edi
leaq 0x40(%rsp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x20b0
cmpl $-0x1, %eax
jne 0xa9a2
leaq 0x2267(%rip), %rdi      # 0xcbfa
callq 0x23d0
movl $0x1, %edi
callq 0x2430
leaq 0x68d7(%rip), %rax      # 0x11280
movl (%rax), %edi
xorl %r8d, %r8d
movl $0x1, %ecx
movl %r8d, %esi
movl %ecx, %edx
callq 0x45f0
movq %rax, 0xe0(%rsp)
cmpq $0x0, %rax
jne 0xa9ed
movq 0x6626(%rip), %rax      # 0x10ff8
movq (%rax), %rdi
leaq 0x2242(%rip), %rsi      # 0xcc1e
movb $0x0, %al
callq 0x2280
movl $0x1, %edi
callq 0x2430
leaq 0x6894(%rip), %rax      # 0x11288
movq (%rax), %rdi
movl $0x3e8, %esi            # imm = 0x3E8
leaq -0x713(%rip), %rdx      # 0xa2f0
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rcx
callq 0x2da0
movl $0xc8, 0x7d52(%rip)     # 0x1276c
movl $0x0, 0x7d44(%rip)      # 0x12768
movslq 0x7d41(%rip), %rdi      # 0x1276c
shlq $0x3, %rdi
callq 0x22e0
movq %rax, 0x7d35(%rip)      # 0x12770
leaq 0x6846(%rip), %rax      # 0x11288
movq (%rax), %rdi
movl $0x3e8, %esi            # imm = 0x3E8
leaq -0x731(%rip), %rdx      # 0xa320
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rcx
callq 0x2da0
movb $0x0, %al
callq 0x41c0
movq %rax, %rcx
leaq 0x6821(%rip), %rax      # 0x11290
movq %rcx, (%rax)
leaq 0x6817(%rip), %rax      # 0x11290
movq (%rax), %rdi
leaq 0x21c2(%rip), %rsi      # 0xcc45
movl $0x4, %edx
movl $0x1, %ecx
leaq -0x3914(%rip), %r8      # 0x7180
callq 0x41f0
leaq 0x67f0(%rip), %rax      # 0x11290
movq (%rax), %rdi
leaq 0x219a(%rip), %rsi      # 0xcc44
movl $0x5, %edx
movl $0x1, %ecx
leaq -0x397b(%rip), %r8      # 0x7140
callq 0x41f0
leaq 0x67c9(%rip), %rax      # 0x11290
movq (%rax), %rdi
leaq 0x2179(%rip), %rsi      # 0xcc4a
movl $0x4, %edx
movl $0x1, %ecx
leaq -0x3672(%rip), %r8      # 0x7470
callq 0x41f0
leaq 0x67a2(%rip), %rax      # 0x11290
movq (%rax), %rdi
leaq 0x2157(%rip), %rsi      # 0xcc4f
movl $0x4, %edx
movl $0x1, %ecx
leaq -0x3669(%rip), %r8      # 0x74a0
callq 0x41f0
leaq 0x677b(%rip), %rax      # 0x11290
movq (%rax), %rdi
leaq 0x2135(%rip), %rsi      # 0xcc54
movl $0x8, %edx
movl $0x1, %ecx
leaq -0x36f0(%rip), %r8      # 0x7440
callq 0x41f0
leaq 0x6754(%rip), %rax      # 0x11290
movq (%rax), %rdi
leaq 0x2117(%rip), %rsi      # 0xcc5d
movl $0x5, %edx
movl $0x1, %ecx
leaq -0x3217(%rip), %r8      # 0x7940
callq 0x41f0
leaq 0x672d(%rip), %rax      # 0x11290
movq (%rax), %rdi
leaq 0x20f6(%rip), %rsi      # 0xcc63
movl $0x5, %edx
movl $0x1, %ecx
leaq -0x320e(%rip), %r8      # 0x7970
callq 0x41f0
leaq 0x6706(%rip), %rax      # 0x11290
movq (%rax), %rdi
leaq 0x20d5(%rip), %rsi      # 0xcc69
movl $0x7, %edx
movl $0x1, %ecx
leaq -0x3205(%rip), %r8      # 0x79a0
callq 0x41f0
leaq 0x66df(%rip), %rax      # 0x11290
movq (%rax), %rdi
leaq 0x20b9(%rip), %rsi      # 0xcc74
movl $0x4, %edx
movl $0x1, %ecx
leaq -0x2fac(%rip), %r8      # 0x7c20
callq 0x41f0
leaq 0x66b8(%rip), %rax      # 0x11290
movq (%rax), %rdi
leaq 0x208f(%rip), %rsi      # 0xcc71
movl $0x7, %edx
movl $0x1, %ecx
leaq -0x2ee3(%rip), %r8      # 0x7d10
callq 0x41f0
leaq 0x6691(%rip), %rax      # 0x11290
movq (%rax), %rdi
leaq 0x2070(%rip), %rsi      # 0xcc79
movl $0x5, %edx
xorl %ecx, %ecx
leaq -0x2e17(%rip), %r8      # 0x7e00
callq 0x41f0
leaq 0x666d(%rip), %rax      # 0x11290
movq (%rax), %rdi
leaq 0x2052(%rip), %rsi      # 0xcc7f
movl $0xb, %edx
xorl %ecx, %ecx
leaq -0x292b(%rip), %r8      # 0x8310
callq 0x41f0
leaq 0x6649(%rip), %rax      # 0x11290
movq (%rax), %rdi
leaq 0x203a(%rip), %rsi      # 0xcc8b
movl $0xc, %edx
xorl %ecx, %ecx
leaq -0x290f(%rip), %r8      # 0x8350
callq 0x41f0
leaq 0x6625(%rip), %rax      # 0x11290
movq (%rax), %rdi
leaq 0x2023(%rip), %rsi      # 0xcc98
movl $0xa, %edx
xorl %ecx, %ecx
leaq -0x2723(%rip), %r8      # 0x8560
callq 0x41f0
leaq 0x6601(%rip), %rax      # 0x11290
movq (%rax), %rdi
leaq 0x200a(%rip), %rsi      # 0xcca3
movl $0xf, %edx
xorl %ecx, %ecx
leaq -0x2597(%rip), %r8      # 0x8710
callq 0x41f0
leaq 0x65dd(%rip), %rax      # 0x11290
movq (%rax), %rdi
leaq 0x1ff6(%rip), %rsi      # 0xccb3
movl $0xb, %edx
xorl %ecx, %ecx
leaq -0x24bb(%rip), %r8      # 0x8810
callq 0x41f0
leaq 0x65b9(%rip), %rax      # 0x11290
movq (%rax), %rdi
leaq 0x1fde(%rip), %rsi      # 0xccbf
movl $0xb, %edx
xorl %ecx, %ecx
leaq -0x24bf(%rip), %r8      # 0x8830
callq 0x41f0
leaq 0x6595(%rip), %rax      # 0x11290
movq (%rax), %rdi
leaq 0x1fc6(%rip), %rsi      # 0xcccb
movl $0xb, %edx
xorl %ecx, %ecx
leaq -0x2483(%rip), %r8      # 0x8890
callq 0x41f0
leaq 0x6571(%rip), %rax      # 0x11290
movq (%rax), %rdi
leaq 0x1fae(%rip), %rsi      # 0xccd7
movl $0x7, %edx
xorl %ecx, %ecx
leaq -0x23f7(%rip), %r8      # 0x8940
callq 0x41f0
leaq 0x654d(%rip), %rax      # 0x11290
movq (%rax), %rdi
leaq 0x1f92(%rip), %rsi      # 0xccdf
movl $0x4, %edx
xorl %ecx, %ecx
leaq -0x23db(%rip), %r8      # 0x8980
callq 0x41f0
leaq 0x6529(%rip), %rax      # 0x11290
movq (%rax), %rdi
leaq 0x1f73(%rip), %rsi      # 0xcce4
movl $0xf, %edx
movl $0x1, %ecx
leaq -0x2402(%rip), %r8      # 0x8980
callq 0x41f0
leaq 0x6502(%rip), %rax      # 0x11290
movq (%rax), %rdi
leaq 0x1aab(%rip), %rsi      # 0xc843
movl $0x9, %edx
movl $0x1, %ecx
leaq -0x23c9(%rip), %r8      # 0x89e0
callq 0x41f0
leaq 0x64db(%rip), %rax      # 0x11290
movq (%rax), %rdi
leaq 0x1f35(%rip), %rsi      # 0xccf4
movl $0x3, %edx
movl $0x1, %ecx
leaq -0x2300(%rip), %r8      # 0x8ad0
callq 0x41f0
leaq 0x64bc(%rip), %rax      # 0x11298
cmpl $0x0, 0x40(%rax)
je 0xae9b
xorl %eax, %eax
leaq 0x64a9(%rip), %rcx      # 0x11298
cmpq 0x50(%rcx), %rax
je 0xae9b
leaq 0x6498(%rip), %rax      # 0x11298
movq 0x50(%rax), %rdi
leaq 0x19e4(%rip), %rsi      # 0xc7ef
callq 0x23b0
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
jne 0xae40
movq 0x61d6(%rip), %rax      # 0x10ff8
movq (%rax), %rdi
leaq 0x646c(%rip), %rax      # 0x11298
movq 0x50(%rax), %rdx
leaq 0x1ec1(%rip), %rsi      # 0xccf8
movb $0x0, %al
callq 0x2280
jmp 0xae99
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x20f0
movq 0x8(%rsp), %rdi
movslq %eax, %rdx
leaq 0x1ec6(%rip), %rsi      # 0xcd24
movb $0x0, %al
callq 0x2280
movq 0x10(%rsp), %rdi
callq 0x2100
cmpl $0x0, %eax
jge 0xae97
movq 0x617d(%rip), %rax      # 0x10ff8
movq (%rax), %rdi
leaq 0x6413(%rip), %rax      # 0x11298
movq 0x50(%rax), %rdx
leaq 0x1e99(%rip), %rsi      # 0xcd29
movb $0x0, %al
callq 0x2280
jmp 0xae99
jmp 0xae9b
leaq 0x63e6(%rip), %rax      # 0x11288
movq (%rax), %rdi
callq 0x3850
leaq 0x63d7(%rip), %rax      # 0x11288
movq (%rax), %rdi
callq 0x2910
leaq 0x63d0(%rip), %rax      # 0x11290
movq (%rax), %rdi
callq 0x4560
leaq 0x63c9(%rip), %rax      # 0x11298
cmpl $0x0, 0x40(%rax)
je 0xaf1e
xorl %eax, %eax
leaq 0x63ba(%rip), %rcx      # 0x11298
cmpq 0x50(%rcx), %rax
je 0xaf1e
leaq 0x63ad(%rip), %rax      # 0x11298
movq 0x50(%rax), %rdi
callq 0x2050
cmpl $0x0, %eax
jge 0xaf1c
movq 0x60f8(%rip), %rax      # 0x10ff8
movq (%rax), %rdi
leaq 0x638e(%rip), %rax      # 0x11298
movq 0x50(%rax), %rdx
leaq 0x1e36(%rip), %rsi      # 0xcd4b
movb $0x0, %al
callq 0x2280
jmp 0xaf1e
movl $0x0, 0xf4(%rsp)
movl 0xf4(%rsp), %eax
addq $0xf8, %rsp
retq
nopl (%rax,%rax)