// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/src/redis-benchmark.c
// Function: main
int main(int argc, const char **argv) {
    int i;
    char *data, *cmd;
    int len;

    client c;

    srandom(time(NULL));
    signal(SIGHUP, SIG_IGN);
    signal(SIGPIPE, SIG_IGN);

    config.numclients = 50;
    config.requests = 100000;
    config.liveclients = 0;
    config.el = aeCreateEventLoop(1024*10);
    aeCreateTimeEvent(config.el,1,showThroughput,NULL,NULL);
    config.keepalive = 1;
    config.datasize = 3;
    config.pipeline = 1;
    config.showerrors = 0;
    config.randomkeys = 0;
    config.randomkeys_keyspacelen = 0;
    config.quiet = 0;
    config.csv = 0;
    config.loop = 0;
    config.idlemode = 0;
    config.latency = NULL;
    config.clients = listCreate();
    config.hostip = "127.0.0.1";
    config.hostport = 6379;
    config.hostsocket = NULL;
    config.tests = NULL;
    config.dbnum = 0;
    config.auth = NULL;

    i = parseOptions(argc,argv);
    argc -= i;
    argv += i;

    config.latency = zmalloc(sizeof(long long)*config.requests);

    if (config.keepalive == 0) {
        printf("WARNING: keepalive disabled, you probably need 'echo 1 > /proc/sys/net/ipv4/tcp_tw_reuse' for Linux and 'sudo sysctl -w net.inet.tcp.msl=1000' for Mac OS X in order to use a lot of clients/requests\n");
    }

    if (config.idlemode) {
        printf("Creating %d idle connections and waiting forever (Ctrl+C when done)\n", config.numclients);
        c = createClient("",0,NULL); /* will never receive a reply */
        createMissingClients(c);
        aeMain(config.el);
        /* and will wait for every */
    }

    /* Run benchmark with command in the remainder of the arguments. */
    if (argc) {
        sds title = sdsnew(argv[0]);
        for (i = 1; i < argc; i++) {
            title = sdscatlen(title, " ", 1);
            title = sdscatlen(title, (char*)argv[i], strlen(argv[i]));
        }

        do {
            len = redisFormatCommandArgv(&cmd,argc,argv,NULL);
            benchmark(title,cmd,len);
            free(cmd);
        } while(config.loop);

        return 0;
    }

    /* Run default benchmark suite. */
    data = zmalloc(config.datasize+1);
    do {
        memset(data,'x',config.datasize);
        data[config.datasize] = '\0';

        if (test_is_selected("ping_inline") || test_is_selected("ping"))
            benchmark("PING_INLINE","PING\r\n",6);

        if (test_is_selected("ping_mbulk") || test_is_selected("ping")) {
            len = redisFormatCommand(&cmd,"PING");
            benchmark("PING_BULK",cmd,len);
            free(cmd);
        }

        if (test_is_selected("set")) {
            len = redisFormatCommand(&cmd,"SET key:__rand_int__ %s",data);
            benchmark("SET",cmd,len);
            free(cmd);
        }

        if (test_is_selected("get")) {
            len = redisFormatCommand(&cmd,"GET key:__rand_int__");
            benchmark("GET",cmd,len);
            free(cmd);
        }

        if (test_is_selected("incr")) {
            len = redisFormatCommand(&cmd,"INCR counter:__rand_int__");
            benchmark("INCR",cmd,len);
            free(cmd);
        }

        if (test_is_selected("lpush")) {
            len = redisFormatCommand(&cmd,"LPUSH mylist %s",data);
            benchmark("LPUSH",cmd,len);
            free(cmd);
        }

        if (test_is_selected("rpush")) {
            len = redisFormatCommand(&cmd,"RPUSH mylist %s",data);
            benchmark("RPUSH",cmd,len);
            free(cmd);
        }

        if (test_is_selected("lpop")) {
            len = redisFormatCommand(&cmd,"LPOP mylist");
            benchmark("LPOP",cmd,len);
            free(cmd);
        }

        if (test_is_selected("rpop")) {
            len = redisFormatCommand(&cmd,"RPOP mylist");
            benchmark("RPOP",cmd,len);
            free(cmd);
        }

        if (test_is_selected("sadd")) {
            len = redisFormatCommand(&cmd,
                "SADD myset element:__rand_int__");
            benchmark("SADD",cmd,len);
            free(cmd);
        }

        if (test_is_selected("spop")) {
            len = redisFormatCommand(&cmd,"SPOP myset");
            benchmark("SPOP",cmd,len);
            free(cmd);
        }

        if (test_is_selected("lrange") ||
            test_is_selected("lrange_100") ||
            test_is_selected("lrange_300") ||
            test_is_selected("lrange_500") ||
            test_is_selected("lrange_600"))
        {
            len = redisFormatCommand(&cmd,"LPUSH mylist %s",data);
            benchmark("LPUSH (needed to benchmark LRANGE)",cmd,len);
            free(cmd);
        }

        if (test_is_selected("lrange") || test_is_selected("lrange_100")) {
            len = redisFormatCommand(&cmd,"LRANGE mylist 0 99");
            benchmark("LRANGE_100 (first 100 elements)",cmd,len);
            free(cmd);
        }

        if (test_is_selected("lrange") || test_is_selected("lrange_300")) {
            len = redisFormatCommand(&cmd,"LRANGE mylist 0 299");
            benchmark("LRANGE_300 (first 300 elements)",cmd,len);
            free(cmd);
        }

        if (test_is_selected("lrange") || test_is_selected("lrange_500")) {
            len = redisFormatCommand(&cmd,"LRANGE mylist 0 449");
            benchmark("LRANGE_500 (first 450 elements)",cmd,len);
            free(cmd);
        }

        if (test_is_selected("lrange") || test_is_selected("lrange_600")) {
            len = redisFormatCommand(&cmd,"LRANGE mylist 0 599");
            benchmark("LRANGE_600 (first 600 elements)",cmd,len);
            free(cmd);
        }

        if (test_is_selected("mset")) {
            const char *argv[21];
            argv[0] = "MSET";
            for (i = 1; i < 21; i += 2) {
                argv[i] = "key:__rand_int__";
                argv[i+1] = data;
            }
            len = redisFormatCommandArgv(&cmd,21,argv,NULL);
            benchmark("MSET (10 keys)",cmd,len);
            free(cmd);
        }

        if (!config.csv) printf("\n");
    } while(config.loop);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0xb320
movl %eax, %edi
callq 0xb070
movl $0x1, %edi
movl $0x1, %esi
callq 0xb2c0
movl $0xd, %edi
movl $0x1, %esi
callq 0xb2c0
movl $0x32, 0x948a7(%rip)    # 0xa3438
movl $0x186a0, 0x948a5(%rip) # imm = 0x186A0
movl $0x0, 0x94897(%rip)     # 0xa343c
movl $0x2800, %edi           # imm = 0x2800
callq 0xb6e0
movq %rax, 0x94862(%rip)     # 0xa3418
movq 0x9485b(%rip), %rdi     # 0xa3418
movl $0x1, %esi
leaq -0x299(%rip), %rdx      # 0xe930
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rcx
callq 0xbe90
movl $0x1, 0x9487c(%rip)     # 0xa345c
movl $0x3, 0x94866(%rip)     # 0xa3450
movl $0x1, 0x9486c(%rip)     # 0xa3460
movl $0x0, 0x94866(%rip)     # 0xa3464
movl $0x0, 0x9484c(%rip)     # 0xa3454
movl $0x0, 0x94846(%rip)     # 0xa3458
movl $0x0, 0x94874(%rip)     # 0xa3490
movl $0x0, 0x9486e(%rip)     # 0xa3494
movl $0x0, 0x94868(%rip)     # 0xa3498
movl $0x0, 0x94862(%rip)     # 0xa349c
movq $0x0, 0x94833(%rip) # 0xa3478
callq 0x10420
movq %rax, 0x94837(%rip)     # 0xa3488
leaq 0x7ff84(%rip), %rax     # 0x8ebdc
movq %rax, 0x947c1(%rip)     # 0xa3420
movl $0x18eb, 0x947bf(%rip)  # imm = 0x18EB
movq $0x0, 0x947bc(%rip) # 0xa3430
movq $0x0, 0x94831(%rip) # 0xa34b0
movl $0x0, 0x94817(%rip)     # 0xa34a0
movq $0x0, 0x94824(%rip) # 0xa34b8
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0xe320
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %ecx
movl -0x8(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x8(%rbp)
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movslq 0x94776(%rip), %rdi     # 0xa3440
shlq $0x3, %rdi
callq 0x10cc0
movq %rax, 0x9479e(%rip)     # 0xa3478
cmpl $0x0, 0x9477b(%rip)     # 0xa345c
jne 0xecf1
leaq 0x7fefc(%rip), %rdi     # 0x8ebe6
movb $0x0, %al
callq 0xb1a0
cmpl $0x0, 0x947a4(%rip)     # 0xa349c
je 0xed3a
movl 0x94738(%rip), %esi     # 0xa3438
leaq 0x7ffa6(%rip), %rdi     # 0x8ecad
movb $0x0, %al
callq 0xb1a0
leaq 0x803e8(%rip), %rdi     # 0x8f0fd
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0xf3f0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0xf8e0
movq 0x946e3(%rip), %rdi     # 0xa3418
callq 0xc830
cmpl $0x0, -0x8(%rbp)
je 0xee17
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x15010
movq %rax, -0x40(%rbp)
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0xedd0
movq -0x40(%rbp), %rdi
leaq 0x80ca3(%rip), %rsi     # 0x8fa11
movl $0x1, %edx
callq 0x15b40
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x100(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0xf8(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0xb170
movq -0x100(%rbp), %rdi
movq -0xf8(%rbp), %rsi
movq %rax, %rdx
callq 0x15b40
movq %rax, -0x40(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xed5b
jmp 0xedd2
movl -0x8(%rbp), %esi
movq -0x10(%rbp), %rdx
leaq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %ecx
callq 0x12b70
movl %eax, -0x2c(%rbp)
movq -0x40(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl -0x2c(%rbp), %edx
callq 0xf940
movq -0x28(%rbp), %rdi
callq 0xb040
cmpl $0x0, 0x9468f(%rip)     # 0xa3498
jne 0xedd2
movl $0x0, -0x4(%rbp)
jmp 0xf3d8
movl 0x94633(%rip), %eax     # 0xa3450
addl $0x1, %eax
movslq %eax, %rdi
callq 0x10cc0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movslq 0x94619(%rip), %rdx     # 0xa3450
movl $0x78, %esi
callq 0xb210
movq -0x20(%rbp), %rax
movslq 0x94604(%rip), %rcx     # 0xa3450
movb $0x0, (%rax,%rcx)
leaq 0x7fe9b(%rip), %rdi     # 0x8ecf2
callq 0xea90
cmpl $0x0, %eax
jne 0xee72
leaq 0x7fe96(%rip), %rdi     # 0x8ecfe
callq 0xea90
cmpl $0x0, %eax
je 0xee8a
leaq 0x7fe8a(%rip), %rdi     # 0x8ed03
leaq 0x7fe8f(%rip), %rsi     # 0x8ed0f
movl $0x6, %edx
callq 0xf940
leaq 0x7fe85(%rip), %rdi     # 0x8ed16
callq 0xea90
cmpl $0x0, %eax
jne 0xeeac
leaq 0x7fe5c(%rip), %rdi     # 0x8ecfe
callq 0xea90
cmpl $0x0, %eax
je 0xeedd
leaq -0x28(%rbp), %rdi
leaq 0x7fe6a(%rip), %rsi     # 0x8ed21
movb $0x0, %al
callq 0x12ad0
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rsi
movl -0x2c(%rbp), %edx
leaq 0x7fe57(%rip), %rdi     # 0x8ed26
callq 0xf940
movq -0x28(%rbp), %rdi
callq 0xb040
leaq 0x828cc(%rip), %rdi     # 0x917b0
callq 0xea90
cmpl $0x0, %eax
je 0xef23
movq -0x20(%rbp), %rdx
leaq -0x28(%rbp), %rdi
leaq 0x7fe33(%rip), %rsi     # 0x8ed30
movb $0x0, %al
callq 0x12ad0
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rsi
movl -0x2c(%rbp), %edx
leaq 0x80042(%rip), %rdi     # 0x8ef57
callq 0xf940
movq -0x28(%rbp), %rdi
callq 0xb040
leaq 0x7fe1e(%rip), %rdi     # 0x8ed48
callq 0xea90
cmpl $0x0, %eax
je 0xef65
leaq -0x28(%rbp), %rdi
leaq 0x7fe0d(%rip), %rsi     # 0x8ed4c
movb $0x0, %al
callq 0x12ad0
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rsi
movl -0x2c(%rbp), %edx
leaq 0x7fe0a(%rip), %rdi     # 0x8ed61
callq 0xf940
movq -0x28(%rbp), %rdi
callq 0xb040
leaq 0x7fdf9(%rip), %rdi     # 0x8ed65
callq 0xea90
cmpl $0x0, %eax
je 0xefa7
leaq -0x28(%rbp), %rdi
leaq 0x7fde9(%rip), %rsi     # 0x8ed6a
movb $0x0, %al
callq 0x12ad0
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rsi
movl -0x2c(%rbp), %edx
leaq 0x7fdeb(%rip), %rdi     # 0x8ed84
callq 0xf940
movq -0x28(%rbp), %rdi
callq 0xb040
leaq 0x7fddb(%rip), %rdi     # 0x8ed89
callq 0xea90
cmpl $0x0, %eax
je 0xefed
movq -0x20(%rbp), %rdx
leaq -0x28(%rbp), %rdi
leaq 0x7fdc8(%rip), %rsi     # 0x8ed8f
movb $0x0, %al
callq 0x12ad0
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rsi
movl -0x2c(%rbp), %edx
leaq 0x7fdc0(%rip), %rdi     # 0x8ed9f
callq 0xf940
movq -0x28(%rbp), %rdi
callq 0xb040
leaq 0x7fdb1(%rip), %rdi     # 0x8eda5
callq 0xea90
cmpl $0x0, %eax
je 0xf033
movq -0x20(%rbp), %rdx
leaq -0x28(%rbp), %rdi
leaq 0x7fd9e(%rip), %rsi     # 0x8edab
movb $0x0, %al
callq 0x12ad0
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rsi
movl -0x2c(%rbp), %edx
leaq 0x7fd96(%rip), %rdi     # 0x8edbb
callq 0xf940
movq -0x28(%rbp), %rdi
callq 0xb040
leaq 0x7fd87(%rip), %rdi     # 0x8edc1
callq 0xea90
cmpl $0x0, %eax
je 0xf075
leaq -0x28(%rbp), %rdi
leaq 0x7fd77(%rip), %rsi     # 0x8edc6
movb $0x0, %al
callq 0x12ad0
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rsi
movl -0x2c(%rbp), %edx
leaq 0x7fd6b(%rip), %rdi     # 0x8edd2
callq 0xf940
movq -0x28(%rbp), %rdi
callq 0xb040
leaq 0x7fd5b(%rip), %rdi     # 0x8edd7
callq 0xea90
cmpl $0x0, %eax
je 0xf0b7
leaq -0x28(%rbp), %rdi
leaq 0x7fd4b(%rip), %rsi     # 0x8eddc
movb $0x0, %al
callq 0x12ad0
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rsi
movl -0x2c(%rbp), %edx
leaq 0x7fd3f(%rip), %rdi     # 0x8ede8
callq 0xf940
movq -0x28(%rbp), %rdi
callq 0xb040
leaq 0x7fd2f(%rip), %rdi     # 0x8eded
callq 0xea90
cmpl $0x0, %eax
je 0xf0f9
leaq -0x28(%rbp), %rdi
leaq 0x7fd1f(%rip), %rsi     # 0x8edf2
movb $0x0, %al
callq 0x12ad0
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rsi
movl -0x2c(%rbp), %edx
leaq 0x7fd27(%rip), %rdi     # 0x8ee12
callq 0xf940
movq -0x28(%rbp), %rdi
callq 0xb040
leaq 0x7fd17(%rip), %rdi     # 0x8ee17
callq 0xea90
cmpl $0x0, %eax
je 0xf13b
leaq -0x28(%rbp), %rdi
leaq 0x7fd07(%rip), %rsi     # 0x8ee1c
movb $0x0, %al
callq 0x12ad0
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rsi
movl -0x2c(%rbp), %edx
leaq 0x7fcfa(%rip), %rdi     # 0x8ee27
callq 0xf940
movq -0x28(%rbp), %rdi
callq 0xb040
leaq 0x7fcea(%rip), %rdi     # 0x8ee2c
callq 0xea90
cmpl $0x0, %eax
jne 0xf190
leaq 0x7fce0(%rip), %rdi     # 0x8ee33
callq 0xea90
cmpl $0x0, %eax
jne 0xf190
leaq 0x7fcda(%rip), %rdi     # 0x8ee3e
callq 0xea90
cmpl $0x0, %eax
jne 0xf190
leaq 0x7fcd4(%rip), %rdi     # 0x8ee49
callq 0xea90
cmpl $0x0, %eax
jne 0xf190
leaq 0x7fcce(%rip), %rdi     # 0x8ee54
callq 0xea90
cmpl $0x0, %eax
je 0xf1c5
movq -0x20(%rbp), %rdx
leaq -0x28(%rbp), %rdi
leaq 0x7fbf0(%rip), %rsi     # 0x8ed8f
movb $0x0, %al
callq 0x12ad0
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rsi
movl -0x2c(%rbp), %edx
leaq 0x7fca8(%rip), %rdi     # 0x8ee5f
callq 0xf940
movq -0x28(%rbp), %rdi
callq 0xb040
leaq 0x7fc60(%rip), %rdi     # 0x8ee2c
callq 0xea90
cmpl $0x0, %eax
jne 0xf1e7
leaq 0x7fc56(%rip), %rdi     # 0x8ee33
callq 0xea90
cmpl $0x0, %eax
je 0xf218
leaq -0x28(%rbp), %rdi
leaq 0x7fc90(%rip), %rsi     # 0x8ee82
movb $0x0, %al
callq 0x12ad0
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rsi
movl -0x2c(%rbp), %edx
leaq 0x7fc8b(%rip), %rdi     # 0x8ee95
callq 0xf940
movq -0x28(%rbp), %rdi
callq 0xb040
leaq 0x7fc0d(%rip), %rdi     # 0x8ee2c
callq 0xea90
cmpl $0x0, %eax
jne 0xf23a
leaq 0x7fc0e(%rip), %rdi     # 0x8ee3e
callq 0xea90
cmpl $0x0, %eax
je 0xf26b
leaq -0x28(%rbp), %rdi
leaq 0x7fc70(%rip), %rsi     # 0x8eeb5
movb $0x0, %al
callq 0x12ad0
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rsi
movl -0x2c(%rbp), %edx
leaq 0x7fc6c(%rip), %rdi     # 0x8eec9
callq 0xf940
movq -0x28(%rbp), %rdi
callq 0xb040
leaq 0x7fbba(%rip), %rdi     # 0x8ee2c
callq 0xea90
cmpl $0x0, %eax
jne 0xf28d
leaq 0x7fbc6(%rip), %rdi     # 0x8ee49
callq 0xea90
cmpl $0x0, %eax
je 0xf2be
leaq -0x28(%rbp), %rdi
leaq 0x7fc51(%rip), %rsi     # 0x8eee9
movb $0x0, %al
callq 0x12ad0
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rsi
movl -0x2c(%rbp), %edx
leaq 0x7fc4d(%rip), %rdi     # 0x8eefd
callq 0xf940
movq -0x28(%rbp), %rdi
callq 0xb040
leaq 0x7fb67(%rip), %rdi     # 0x8ee2c
callq 0xea90
cmpl $0x0, %eax
jne 0xf2e0
leaq 0x7fb7e(%rip), %rdi     # 0x8ee54
callq 0xea90
cmpl $0x0, %eax
je 0xf311
leaq -0x28(%rbp), %rdi
leaq 0x7fc32(%rip), %rsi     # 0x8ef1d
movb $0x0, %al
callq 0x12ad0
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rsi
movl -0x2c(%rbp), %edx
leaq 0x7fc2e(%rip), %rdi     # 0x8ef31
callq 0xf940
movq -0x28(%rbp), %rdi
callq 0xb040
leaq 0x7fc39(%rip), %rdi     # 0x8ef51
callq 0xea90
cmpl $0x0, %eax
je 0xf3ab
leaq 0x7fc29(%rip), %rax     # 0x8ef56
movq %rax, -0xf0(%rbp)
movl $0x1, -0x14(%rbp)
cmpl $0x15, -0x14(%rbp)
jge 0xf373
movslq -0x14(%rbp), %rax
leaq 0x7fa04(%rip), %rcx     # 0x8ed50
movq %rcx, -0xf0(%rbp,%rax,8)
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
addl $0x1, %eax
cltq
movq %rcx, -0xf0(%rbp,%rax,8)
movl -0x14(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x14(%rbp)
jmp 0xf33b
leaq -0xf0(%rbp), %rdx
leaq -0x28(%rbp), %rdi
movl $0x15, %esi
xorl %eax, %eax
movl %eax, %ecx
callq 0x12b70
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rsi
movl -0x2c(%rbp), %edx
leaq 0x7fbbe(%rip), %rdi     # 0x8ef5b
callq 0xf940
movq -0x28(%rbp), %rdi
callq 0xb040
cmpl $0x0, 0x940e2(%rip)     # 0xa3494
jne 0xf3c2
leaq 0x7fd41(%rip), %rdi     # 0x8f0fc
movb $0x0, %al
callq 0xb1a0
jmp 0xf3c4
cmpl $0x0, 0x940cd(%rip)     # 0xa3498
jne 0xee2c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nopw %cs:(%rax,%rax)