// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rsi, %r14
movl %edi, %ebp
movq 0x6a5a(%rip), %r15      # 0xcff8
movq (%r15), %rdi
xorl %esi, %esi
callq 0x2150
leaq -0x42(%rip), %rsi       # 0x656d
pushq $0x2
popq %rdi
callq 0x2240
leaq 0x6cca(%rip), %rbx      # 0xd288
movq %rbx, %rdi
callq 0x6d64
movq %rbx, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x6da8
movq (%rbx), %rcx
pushq $0x30
popq %rdi
movq 0x1d47(%rip), %xmm0     # 0x8328
pushq $0x28
popq %rsi
pushq $0x1
popq %r12
movl $0x100000, %edx         # imm = 0x100000
movl %r12d, %r8d
callq 0x42c4
leaq 0x6d3c(%rip), %rcx      # 0xd338
movq %rax, (%rcx)
movl $0x2800, %edi           # imm = 0x2800
callq 0x256c
leaq 0x6c68(%rip), %r13      # 0xd278
movq %rax, (%r13)
cmpl $0x0, 0x44(%rbx)
je 0x6679
pushq $0x4
popq %rdi
movq %rsp, %rsi
callq 0x2430
testl %eax, %eax
jne 0x665b
pcmpeqd %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movdqa %xmm0, (%rsi)
pushq $0x4
popq %rdi
callq 0x2300
testl %eax, %eax
je 0x665b
movq 0x8(%rsp), %rax
leaq 0x10(%rsp), %rsi
movq %rax, 0x8(%rsi)
movq %rax, (%rsi)
pushq $0x4
popq %rdi
callq 0x2300
pushq $0x4
popq %rdi
movq %rsp, %rsi
callq 0x2430
testl %eax, %eax
jne 0x6ce8
cmpq $0x0, (%rsp)
je 0x6ce8
pushq $0x7
popq %rdi
movq %rsp, %rsi
callq 0x2430
testl %eax, %eax
jne 0x6ca9
movslq 0x8(%rbx), %rcx
movq (%rsp), %rax
cmpl %eax, %ecx
jle 0x66a3
addq $0x3, %rcx
movq %rcx, (%rsp)
movq %rcx, %rax
cmpq %rax, 0x8(%rsp)
jae 0x66af
movq %rax, 0x8(%rsp)
pushq $0x7
popq %rdi
movq %rsp, %rsi
callq 0x2300
testl %eax, %eax
jne 0x6cb7
cmpq $0x0, 0x28(%rbx)
jne 0x670d
movl 0xc(%rbx), %edi
xorl %esi, %esi
callq 0x61d5
leaq 0x6b96(%rip), %rcx      # 0xd270
movl %eax, (%rcx)
cmpl $-0x1, %eax
je 0x6cc5
movl 0x10(%rbx), %edi
testl %edi, %edi
jle 0x670d
cmpq $0x0, 0x28(%rbx)
jne 0x670d
pushq $0x1
popq %rsi
callq 0x61d5
leaq 0x6b46(%rip), %rcx      # 0xd248
movl %eax, (%rcx)
cmpl $-0x1, %eax
je 0x6d11
callq 0x2140
testl %eax, %eax
je 0x671f
callq 0x21a0
testl %eax, %eax
jne 0x6767
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x6bf0
cmpb $0x0, (%rdi)
je 0x6bf0
callq 0x2250
testq %rax, %rax
je 0x6c30
movq %rax, %r14
movl 0x14(%rax), %edi
callq 0x2370
testl %eax, %eax
js 0x6bfe
movl 0x10(%r14), %edi
callq 0x2440
testl %eax, %eax
js 0x6bfe
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x6787
callq 0x635a
leaq 0x6af4(%rip), %rcx      # 0xd270
movl %eax, (%rcx)
cmpl $-0x1, %eax
je 0x6cc5
cmpl $0x0, 0x40(%rbx)
je 0x67a1
movl 0x18(%rbx), %esi
movl 0x44(%rbx), %edi
callq 0x3b94
cmpl $-0x1, %eax
je 0x6c47
callq 0x3c2c
leaq 0x6b33(%rip), %rdi      # 0xd2e0
callq 0x7220
callq 0x2fe7
callq 0x337c
cmpl $0x0, 0x20(%rbx)
je 0x67df
pushq $0x1
popq %rdi
movl $0x20000, %esi          # imm = 0x20000
callq 0x2220
movq %rax, 0x7f7a(%rip)      # 0xe750
testq %rax, %rax
je 0x6cf4
cmpl $0x0, 0x3c(%rbx)
jne 0x6c0e
leaq 0x18(%rsp), %rdi
movq $0x1, -0x8(%rdi)
andl $0x0, 0x80(%rdi)
callq 0x2270
cmpl $-0x1, %eax
je 0x6c9b
pushq $0xd
popq %rdi
leaq 0x10(%rsp), %rsi
xorl %edx, %edx
callq 0x20c0
cmpl $-0x1, %eax
je 0x6c9b
leaq 0x6a46(%rip), %rax      # 0xd270
movl (%rax), %edi
pushq $0x1
popq %rcx
xorl %esi, %esi
movl %ecx, %edx
xorl %r8d, %r8d
callq 0x33a1
testq %rax, %rax
je 0x6cd3
movq (%r13), %rdi
leaq -0x36a(%rip), %rdx      # 0x64e5
movl $0x3e8, %esi            # imm = 0x3E8
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x2908
movl $0xc8, 0x7ef4(%rip)     # 0xe75c
andl $0x0, 0x7ee9(%rip)      # 0xe758
movl $0x640, %edi            # imm = 0x640
callq 0x22c0
movq %rax, 0x7ee0(%rip)      # 0xe760
movq (%r13), %rdi
leaq -0x392(%rip), %rdx      # 0x64f9
movl $0x3e8, %esi            # imm = 0x3E8
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x2908
xorl %eax, %eax
callq 0x311c
leaq 0x69d8(%rip), %r15      # 0xd280
movq %rax, (%r15)
leaq 0x2372(%rip), %rsi      # 0x8c24
leaq -0x1e42(%rip), %r8      # 0x4a77
pushq $0x4
popq %r14
pushq $0x1
popq %rbp
movq %rax, %rdi
movq %r14, %rdx
movl %ebp, %ecx
callq 0x3137
movq (%r15), %rdi
leaq 0x234c(%rip), %rsi      # 0x8c23
leaq -0x1e7e(%rip), %r8      # 0x4a60
pushq $0x5
popq %r13
movq %r13, %rdx
movl %ebp, %ecx
callq 0x3137
movq (%r15), %rdi
leaq 0x2333(%rip), %rsi      # 0x8c29
leaq -0x1d18(%rip), %r8      # 0x4be5
movq %r14, %rdx
movl %ebp, %ecx
callq 0x3137
movq (%r15), %rdi
leaq 0x231d(%rip), %rsi      # 0x8c2e
leaq -0x1d21(%rip), %r8      # 0x4bf7
movq %r14, %rdx
movl %ebp, %ecx
callq 0x3137
movq (%r15), %rdi
leaq 0x2307(%rip), %rsi      # 0x8c33
leaq -0x1d60(%rip), %r8      # 0x4bd3
pushq $0x8
popq %rdx
movl %ebp, %ecx
callq 0x3137
movq (%r15), %rdi
leaq 0x22f5(%rip), %rsi      # 0x8c3c
leaq -0x1b4b(%rip), %r8      # 0x4e03
movq %r13, %rdx
movl %ebp, %ecx
callq 0x3137
movq (%r15), %rdi
leaq 0x22e0(%rip), %rsi      # 0x8c42
leaq -0x1b54(%rip), %r8      # 0x4e15
movq %r13, %rdx
movl %ebp, %ecx
callq 0x3137
movq (%r15), %rdi
leaq 0x22cb(%rip), %rsi      # 0x8c48
leaq -0x1b60(%rip), %r8      # 0x4e24
pushq $0x7
popq %r12
movq %r12, %rdx
movl %ebp, %ecx
callq 0x3137
movq (%r15), %rdi
leaq 0x22b7(%rip), %rsi      # 0x8c53
leaq -0x1a1f(%rip), %r8      # 0x4f84
movq %r14, %rdx
movl %ebp, %ecx
callq 0x3137
movq (%r15), %rdi
leaq 0x2299(%rip), %rsi      # 0x8c50
leaq -0x19b8(%rip), %r8      # 0x5006
movq %r12, %rdx
movl %ebp, %ecx
callq 0x3137
movq (%r15), %rdi
leaq 0x2286(%rip), %rsi      # 0x8c58
leaq -0x1959(%rip), %r8      # 0x5080
movq %r13, %rdx
xorl %ecx, %ecx
callq 0x3137
movq (%r15), %rdi
leaq 0x2271(%rip), %rsi      # 0x8c5e
leaq -0x16d8(%rip), %r8      # 0x531c
pushq $0xb
popq %r13
movq %r13, %rdx
xorl %ecx, %ecx
callq 0x3137
movq (%r15), %rdi
leaq 0x225e(%rip), %rsi      # 0x8c6a
leaq -0x16d4(%rip), %r8      # 0x533f
pushq $0xc
popq %rdx
xorl %ecx, %ecx
callq 0x3137
movq (%r15), %rdi
leaq 0x2250(%rip), %rsi      # 0x8c77
leaq -0x1568(%rip), %r8      # 0x54c6
pushq $0xa
popq %rdx
xorl %ecx, %ecx
callq 0x3137
movq (%r15), %rdi
leaq 0x2240(%rip), %rsi      # 0x8c82
leaq -0x14a8(%rip), %r8      # 0x55a1
pushq $0xf
popq %r14
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x3137
movq (%r15), %rdi
leaq 0x2231(%rip), %rsi      # 0x8c92
leaq -0x1442(%rip), %r8      # 0x5626
movq %r13, %rdx
xorl %ecx, %ecx
callq 0x3137
movq (%r15), %rdi
leaq 0x2222(%rip), %rsi      # 0x8c9e
leaq -0x145a(%rip), %r8      # 0x5629
movq %r13, %rdx
xorl %ecx, %ecx
callq 0x3137
movq (%r15), %rdi
leaq 0x2213(%rip), %rsi      # 0x8caa
leaq -0x1440(%rip), %r8      # 0x565e
movq %r13, %rdx
xorl %ecx, %ecx
callq 0x3137
movq (%r15), %rdi
leaq 0x2204(%rip), %rsi      # 0x8cb6
leaq -0x1407(%rip), %r8      # 0x56b2
movq %r12, %rdx
xorl %ecx, %ecx
callq 0x3137
movq (%r15), %rdi
leaq 0x21f1(%rip), %rsi      # 0x8cbe
leaq -0x140e(%rip), %r12     # 0x56c6
pushq $0x4
popq %rdx
xorl %ecx, %ecx
movq %r12, %r8
callq 0x3137
movq (%r15), %rdi
leaq 0x21d8(%rip), %rsi      # 0x8cc3
movq %r14, %rdx
movl %ebp, %ecx
movq %r12, %r8
callq 0x3137
movq (%r15), %rdi
leaq 0x1d31(%rip), %rsi      # 0x8833
leaq -0x1430(%rip), %r8      # 0x56d9
pushq $0x9
popq %rdx
movl %ebp, %ecx
callq 0x3137
movq (%r15), %rdi
leaq 0x21b6(%rip), %rsi      # 0x8cd3
leaq -0x13bd(%rip), %r8      # 0x5767
pushq $0x3
popq %rdx
movl %ebp, %ecx
callq 0x3137
cmpl $0x0, 0x40(%rbx)
setne %al
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x6b87
leaq 0x1c92(%rip), %rsi      # 0x87df
callq 0x2390
testq %rax, %rax
je 0x6c71
movq %rax, %r14
callq 0x2100
movslq %eax, %rdx
leaq 0x2196(%rip), %rsi      # 0x8d03
movq %r14, %rdi
xorl %eax, %eax
callq 0x2260
movq %r14, %rdi
callq 0x2110
testl %eax, %eax
js 0x6c7a
leaq 0x66ea(%rip), %r14      # 0xd278
movq (%r14), %rdi
callq 0x2dc4
movq (%r14), %rdi
callq 0x2719
movq (%r15), %rdi
callq 0x3348
cmpl $0x0, 0x40(%rbx)
setne %al
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x6beb
callq 0x2050
testl %eax, %eax
movl $0x0, %r12d
jns 0x6c5c
movq 0x6420(%rip), %rax      # 0xcff8
movq (%rax), %rdi
movq 0x50(%rbx), %rdx
leaq 0x2144(%rip), %rsi      # 0x8d2a
xorl %r12d, %r12d
jmp 0x6c3e
xorl %r12d, %r12d
jmp 0x6c5c
movq (%r15), %rcx
leaq 0x1ed3(%rip), %rdi      # 0x8acd
pushq $0x28
jmp 0x6c53
movq (%r15), %rdi
movq 0x48(%rbx), %rdx
leaq 0x1f0f(%rip), %rsi      # 0x8b1b
jmp 0x6c3e
pushq $0x3
popq %rdi
callq 0x2320
movq (%r15), %rcx
leaq 0x1f6f(%rip), %rdi      # 0x8b8f
pushq $0x49
popq %rsi
pushq $0x1
popq %rdx
callq 0x2420
jmp 0x67e9
movq (%r15), %rdi
movq 0x48(%rbx), %rdx
leaq 0x1eb8(%rip), %rsi      # 0x8af6
xorl %eax, %eax
callq 0x2260
jmp 0x6c5c
movq (%r15), %rcx
leaq 0x1ef0(%rip), %rdi      # 0x8b41
pushq $0x29
popq %rsi
pushq $0x1
popq %rdx
callq 0x2420
movl %r12d, %eax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x205f(%rip), %rsi      # 0x8cd7
jmp 0x6c81
leaq 0x2087(%rip), %rsi      # 0x8d08
movq 0x6370(%rip), %rax      # 0xcff8
movq (%rax), %rdi
movq 0x50(%rbx), %rdx
xorl %eax, %eax
callq 0x2260
jmp 0x6b87
leaq 0x1f37(%rip), %rdi      # 0x8bd9
callq 0x23b0
jmp 0x6d09
movq (%r15), %rcx
leaq 0x1d62(%rip), %rdi      # 0x8a15
pushq $0x24
jmp 0x6d00
movq (%r15), %rcx
leaq 0x1d79(%rip), %rdi      # 0x8a3a
pushq $0x5f
jmp 0x6d00
movq (%r15), %rcx
leaq 0x1dcb(%rip), %rdi      # 0x8a9a
pushq $0x11
jmp 0x6d00
movq 0x631e(%rip), %rax      # 0xcff8
movq (%rax), %rcx
leaq 0x1f19(%rip), %rdi      # 0x8bfd
pushq $0x25
jmp 0x6d00
movq (%r15), %rcx
leaq 0x1cff(%rip), %rdi      # 0x89f1
jmp 0x6cfe
movq (%r15), %rcx
leaq 0x1e6d(%rip), %rdi      # 0x8b6b
pushq $0x23
popq %rsi
pushq $0x1
popq %rdx
callq 0x2420
pushq $0x1
popq %rdi
callq 0x2410
movq (%r15), %rdi
movl 0x10(%rbx), %edx
leaq 0x1d8e(%rip), %rsi      # 0x8aac
xorl %eax, %eax
callq 0x2260
jmp 0x6d09
nop