LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/sszllzss[P]webSocket_Libevent_ThreadPool/Threadpool.cpp
// Function: threadpool_add(threadpool_t*, void* (*)(void*), void*)
int threadpool_add(threadpool_t *pool, void*(*function)(void *arg), void *arg)
{
    pthread_mutex_lock(&(pool->lock));

    /* ==为真，队列已经满， 调wait阻塞 */
    while ((pool->threadpool_task_queue->max_size() == pool->threadpool_task_queue->size()) && (!pool->shutdown)) {
        pthread_cond_wait(&(pool->queue_not_full), &(pool->lock));

    }
    if (pool->shutdown) {
        pthread_mutex_unlock(&(pool->lock));

    }


    /*添加任务到任务队列里*/
    threadpool_task_t task;
    task.function = function;
    task.arg = arg;
    pool->threadpool_task_queue->push_back(task);
    /*添加完任务后，队列不为空，唤醒线程池中 等待处理任务的线程*/
    pthread_cond_signal(&(pool->queue_not_empty));
    pthread_mutex_unlock(&(pool->lock));

    return 0;

}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x3620
leaq 0x50(%rbx), %r12
movabsq $0x7ffffffffffffff, %r13 # imm = 0x7FFFFFFFFFFFFFF
movq 0xc0(%rbx), %rdi
movq 0x48(%rdi), %rax
movq %rax, %rcx
subq 0x28(%rdi), %rcx
shrq $0x3, %rcx
cmpq $0x1, %rax
adcq $-0x1, %rcx
shlq $0x5, %rcx
movq 0x20(%rdi), %rdx
movq 0x30(%rdi), %rax
movq %rax, %rsi
subq 0x38(%rdi), %rsi
sarq $0x4, %rsi
subq 0x10(%rdi), %rdx
sarq $0x4, %rdx
addq %rsi, %rdx
addq %rcx, %rdx
movl 0xd4(%rbx), %ecx
cmpq %r13, %rdx
jne 0x9201
testl %ecx, %ecx
jne 0x9205
movq %r12, %rdi
movq %rbx, %rsi
callq 0x3660
jmp 0x91a2
testl %ecx, %ecx
je 0x9218
movq %rbx, %rdi
callq 0x3310
movq 0xc0(%rbx), %rdi
movq 0x30(%rdi), %rax
movq %r15, (%rsp)
movq %r14, 0x8(%rsp)
movq 0x40(%rdi), %rcx
addq $-0x10, %rcx
cmpq %rcx, %rax
je 0x923c
movups (%rsp), %xmm0
movups %xmm0, (%rax)
addq $0x10, 0x30(%rdi)
jmp 0x9244
movq %rsp, %rsi
callq 0x9616
leaq 0x80(%rbx), %rdi
callq 0x3040
movq %rbx, %rdi
callq 0x3310
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/sszllzss[P]webSocket_Libevent_ThreadPool/Threadpool.cpp
// Function: threadpool_free(threadpool_t*)
int threadpool_free(threadpool_t *pool)
{
    if (pool == NULL) {
        return -1;

    }

    if (pool->threadpool_task_queue) {
        for(thread_pool_task_queue_t::iterator i=pool->threadpool_task_queue->begin();
            i != pool->threadpool_task_queue->end();i++)
        {
            if((*i).arg != NULL)
            {
                free((*i).arg);
            }
        }
        delete pool->threadpool_task_queue;
    }
    if (pool->threads) {
        delete pool->threads;
        pthread_mutex_lock(&(pool->lock));
        pthread_mutex_destroy(&(pool->lock));
        pthread_mutex_lock(&(pool->thread_counter));
        pthread_mutex_destroy(&(pool->thread_counter));
        pthread_cond_destroy(&(pool->queue_not_empty));
        pthread_cond_destroy(&(pool->queue_not_full));

    }
    free(pool);
    pool = NULL;

    return 0;

}

// Assembly:
testq %rdi, %rdi
je 0x9367
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0xc0(%rdi), %r14
testq %r14, %r14
je 0x92e4
movq 0x10(%r14), %r15
cmpq 0x30(%r14), %r15
je 0x92cf
movq 0x20(%r14), %r13
movq 0x28(%r14), %r12
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0x92a9
callq 0x3500
addq $0x10, %r15
cmpq %r13, %r15
jne 0x92c2
movq 0x8(%r12), %r15
addq $0x8, %r12
leaq 0x200(%r15), %r13
movq 0xc0(%rbx), %r14
cmpq 0x30(%r14), %r15
jne 0x929b
movq %r14, %rdi
callq 0x982c
movl $0x50, %esi
movq %r14, %rdi
callq 0x3460
movq 0xb8(%rbx), %r14
testq %r14, %r14
je 0x9353
movq (%r14), %rdi
cmpq %r14, %rdi
je 0x930d
movq (%rdi), %r15
movl $0x18, %esi
callq 0x3460
movq %r15, %rdi
cmpq %r14, %r15
jne 0x92f8
movl $0x18, %esi
movq %r14, %rdi
callq 0x3460
movq %rbx, %rdi
callq 0x3620
movq %rbx, %rdi
callq 0x34e0
leaq 0x28(%rbx), %r14
movq %r14, %rdi
callq 0x3620
movq %r14, %rdi
callq 0x34e0
leaq 0x80(%rbx), %rdi
callq 0x37c0
leaq 0x50(%rbx), %rdi
callq 0x37c0
movq %rbx, %rdi
callq 0x3500
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_c_makefile_star2_O3/sszllzss[P]webSocket_Libevent_ThreadPool/ev_httpd_test.c
// Function: getFileSize(char const*)
int getFileSize(const char * filename)
{
    int fileSize = 0;
    FILE *fp = NULL;
    if (filename == NULL)
        return 0;
    //以二进制的形式读取
    fp = fopen(filename, "rb");
    if (fp == NULL)
        return 0;
    fseek(fp, 0, SEEK_END);
    fileSize = ftell(fp);
    rewind(fp);
    fclose(fp);
    return fileSize;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x9b5c
leaq 0x34a1(%rip), %rsi      # 0xcfc6
callq 0x34f0
testq %rax, %rax
je 0x9b5c
movq %rax, %r14
movq %rax, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x34c0
movq %r14, %rdi
callq 0x3030
movq %rax, %rbx
movq %r14, %rdi
callq 0x30b0
movq %r14, %rdi
callq 0x3430
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/sszllzss[P]webSocket_Libevent_ThreadPool/ev_httpd_test.c
// Function: ws_read_cb(httpChilent_t*)
void ws_read_cb(struct httpChilent_t * httpChilent)
{
    char buff[1024];
    char ip[INET_ADDRSTRLEN];
    struct sockaddr_in *address = (struct sockaddr_in *)&(httpChilent->addr);
    inet_ntop(AF_INET, &address->sin_addr,ip, INET_ADDRSTRLEN);
    evbuffer_remove(httpChilent->receive_evbuff, buff, evbuffer_get_length(httpChilent->receive_evbuff));
    printf("%s:%d ] %s\r\n",ip, ntohs(address->sin_port) ,  buff);
    ev_webSocket_send(httpChilent->bev, (unsigned char *)"hello!", (unsigned)6,false,WCT_TXTDATA);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x410, %rsp            # imm = 0x410
movq %rdi, %rbx
leaq 0xa8(%rdi), %rsi
leaq -0x30(%rbp), %r14
movl $0x2, %edi
movq %r14, %rdx
movl $0x10, %ecx
callq 0x3480
movq 0x98(%rbx), %r15
movq %r15, %rdi
callq 0x3490
leaq -0x430(%rbp), %r12
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x3540
movzwl 0xa6(%rbx), %eax
rolw $0x8, %ax
movzwl %ax, %edx
leaq 0x30ab(%rip), %rdi      # 0xd02e
movq %r14, %rsi
movq %r12, %rcx
xorl %eax, %eax
callq 0x3080
movq 0x30(%rbx), %rdi
leaq 0x30a0(%rip), %rsi      # 0xd03b
movl $0x6, %edx
xorl %ecx, %ecx
movl $0xffffffed, %r8d       # imm = 0xFFFFFFED
callq 0x533d
addq $0x410, %rsp            # imm = 0x410
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/sszllzss[P]webSocket_Libevent_ThreadPool/ev_httpd_test.c
// Function: close_signal_cb(int, short, void*)
void close_signal_cb(evutil_socket_t sig,short events, void *user_data)
{
    struct event_base *base = (struct event_base *)user_data;
    struct timeval delay = {2, 0};
    if(sig == SIGINT)
    {
        De_printf("2s后程序关闭\r\n");
        event_base_loopexit(base, &delay);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movups 0x30d3(%rip), %xmm0     # 0xd0a0
movaps %xmm0, -0x20(%rbp)
cmpl $0x2, %edi
jne 0xa01e
movq %rdx, %rbx
leaq 0x11cb(%rip), %rdi      # 0xb1ab
leaq 0x305b(%rip), %rsi      # 0xd042
leaq 0x3064(%rip), %rdx      # 0xd052
movl $0xef, %ecx
xorl %eax, %eax
callq 0x3080
leaq 0x308c(%rip), %rdi      # 0xd08d
callq 0x3680
leaq 0x14d1(%rip), %rdi      # 0xb4de
callq 0x3680
leaq -0x20(%rbp), %rsi
movq %rbx, %rdi
callq 0x3330
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/sszllzss[P]webSocket_Libevent_ThreadPool/ev_httpd_test.c
// Function: main
int main(void)
{
    u_short port = 8088;
    struct event_base *base;
    struct event * close_signal; 
    httpServer_t * httpServer;
    base = event_base_new();
    set_SERVER_STRING(NULL);
    httpServer = startHttpServe(base ,&port);
    httpServer_setHttpHandler(httpServer, httpd_handler);
    httpServer_setWebSocket_read_cb(httpServer, ws_read_cb, "/");
    close_signal =  evsignal_new(base,SIGINT,close_signal_cb, base); 
    if(!close_signal || event_add(close_signal, NULL) < 0)
    {
        De_fprintf(stderr, "Could not create/add a signal event!\n");
        exit(1);
    }
    event_base_dispatch(base);
    httpServer_free(httpServer);

    event_base_free(base);

    return(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
leaq -0x12(%rbp), %r14
movw $0x1f98, (%r14)         # imm = 0x1F98
callq 0x36f0
movq %rax, %rbx
xorl %edi, %edi
callq 0xa1c4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x78ed
movq %rax, %r14
leaq -0x2ec(%rip), %rsi      # 0x9d72
movq %rax, %rdi
callq 0x76a1
leaq -0x155(%rip), %rsi      # 0x9f18
leaq 0x2f75(%rip), %rdx      # 0xcfe9
movq %r14, %rdi
callq 0x7765
leaq -0xc6(%rip), %rcx       # 0x9fbd
movq %rbx, %rdi
movl $0x2, %esi
movl $0x18, %edx
movq %rbx, %r8
callq 0x3380
testq %rax, %rax
je 0xa0ce
movq %rax, %rdi
xorl %esi, %esi
callq 0x31e0
testl %eax, %eax
js 0xa0ce
movq %rbx, %rdi
callq 0x3640
movq %r14, %rdi
callq 0x77c9
movq %rbx, %rdi
callq 0x35b0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x4185
nop
// File: /workspace/github_c_makefile_star2_O3/sszllzss[P]webSocket_Libevent_ThreadPool/config.c
// Function: set_SERVER_STRING(char*)
void set_SERVER_STRING(char * name)
{
    if(SERVER_STRING_VARIALE == NULL)
    {
        if(name == NULL)
            SERVER_STRING_VARIALE = (char *)malloc(strlen("WebSocket-HttpServer/1.0.0"));
        else
            SERVER_STRING_VARIALE = (char *)malloc(strlen(name));

    }
    else
    {
        SERVER_STRING_VARIALE = (char *) realloc(SERVER_STRING_VARIALE, strlen(name));
    }
    if(name == NULL)
        strcpy(SERVER_STRING_VARIALE,"WebSocket-HttpServer/1.0.0");
    else
        strcpy(SERVER_STRING_VARIALE, name);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x728b(%rip), %r14      # 0x11460
testq %r14, %r14
je 0xa1fb
movq %rbx, %rdi
callq 0x31f0
movq %r14, %rdi
movq %rax, %rsi
callq 0x36c0
movq %rax, 0x726c(%rip)      # 0x11460
testq %rbx, %rbx
jne 0xa217
jmp 0xa237
testq %rbx, %rbx
je 0xa226
movq %rbx, %rdi
callq 0x31f0
movq %rax, %rdi
callq 0x35a0
movq %rax, 0x7249(%rip)      # 0x11460
movq %rax, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x33e0
movl $0x1a, %edi
callq 0x35a0
movq %rax, 0x7229(%rip)      # 0x11460
movups 0x2e7d(%rip), %xmm0     # 0xd0bb
movups %xmm0, 0xb(%rax)
movups 0x2e67(%rip), %xmm0     # 0xd0b0
movups %xmm0, (%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/antonblanchard[P]will-it-scale/tests/pwrite3.c
// Function: testcase
void testcase(unsigned long long *iterations, unsigned long nr)
{
	char buf[BUFLEN];
	int fd = open(tmpfile, O_RDWR);
	unsigned long offset = getpagesize() * nr;

	assert(fd >= 0);

	while (1) {
		assert(pwrite(fd, buf, BUFLEN, offset) == BUFLEN);

		(*iterations)++;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1008, %rsp           # imm = 0x1008
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x2394(%rip), %rdi      # 0x5180
movl $0x2, %esi
xorl %eax, %eax
callq 0x2230
movl %eax, %ebp
callq 0x2280
testl %ebp, %ebp
js 0x2e63
movslq %eax, %r14
imulq %r15, %r14
movq %rsp, %rsi
movl $0x1000, %edx           # imm = 0x1000
movl %ebp, %edi
movq %r14, %rcx
callq 0x2200
cmpq $0x1000, %rax           # imm = 0x1000
jne 0x2e44
movq %rsp, %r15
incq (%rbx)
movl $0x1000, %edx           # imm = 0x1000
movl %ebp, %edi
movq %r15, %rsi
movq %r14, %rcx
callq 0x2200
cmpq $0x1000, %rax           # imm = 0x1000
je 0x2e27
leaq 0x4d9(%rip), %rdi       # 0x3324
leaq 0x464(%rip), %rsi       # 0x32b6
leaq 0x498(%rip), %rcx       # 0x32f1
movl $0x28, %edx
callq 0x2130
leaq 0x444(%rip), %rdi       # 0x32ae
leaq 0x445(%rip), %rsi       # 0x32b6
leaq 0x479(%rip), %rcx       # 0x32f1
movl $0x25, %edx
callq 0x2130
// File: /workspace/github_c_makefile_star2_O3/salextpuru[P]speccy-toochain/src/spgbld/func.cxx
// Function: num(char*)
u32 num(char *ns)
{
	int n;

	if ((ns[0] == '0') && ns[1] == 'x') {
		sscanf(ns, "%x", &n);
		return n;
	}

	if ((ns[0] == '#') || (ns[0] == '$')) {
		sscanf(ns + 1, "%x", &n);
		return n;

	} else {
		sscanf(ns, "%d", &n);
		return n;
	}
}

// Assembly:
pushq %rax
movb (%rdi), %al
cmpb $0x30, %al
jne 0x25d5
cmpb $0x78, 0x1(%rdi)
je 0x25de
jmp 0x25e7
addb $-0x23, %al
cmpb $0x1, %al
ja 0x25e7
incq %rdi
leaq 0x1a88(%rip), %rsi      # 0x406d
jmp 0x25ee
leaq 0x1a82(%rip), %rsi      # 0x4070
leaq 0x4(%rsp), %rdx
xorl %eax, %eax
callq 0x20f0
movslq 0x4(%rsp), %rax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/salextpuru[P]speccy-toochain/src/spgbld/func.cxx
// Function: save_spg(char*)
void save_spg(char* name)
{
	FILE* f = fopen(name, "w+");
	// save header
	fwrite(&hdr, 1, sizeof(hdr), f);

	// save blocks
	for (int i = 0; i < conf.n_blocks; i++) {
		fwrite(&blk[i].data, 1, (hdr.blk[i].size + 1) << 9, f);
	}

	fclose(f);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
leaq 0xea2(%rip), %rsi       # 0x423b
callq 0x2130
movq %rax, %rbx
leaq 0x2db8(%rip), %rdi      # 0x6160
movl $0x1, %esi
movl $0x400, %edx            # imm = 0x400
movq %rax, %rcx
callq 0x2250
leaq 0x44399f(%rip), %r15    # 0x446d60
cmpl $0x0, 0x18(%r15)
jle 0x341e
movl $0x100, %r12d           # imm = 0x100
addq 0x2bfb(%rip), %r12      # 0x5fd0
movl $0x408, %r14d           # imm = 0x408
addq 0x2bfe(%rip), %r14      # 0x5fe0
xorl %r13d, %r13d
movzwl (%r12), %eax
andl $0x1f00, %eax           # imm = 0x1F00
leaq 0x200(,%rax,2), %rdx
movl $0x1, %esi
movq %r14, %rdi
movq %rbx, %rcx
callq 0x2250
incq %r13
movslq 0x18(%r15), %rax
addq $0x3, %r12
addq $0x4408, %r14           # imm = 0x4408
cmpq %rax, %r13
jl 0x33e5
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2100
// File: /workspace/github_c_makefile_star2_O3/salextpuru[P]speccy-toochain/src/spgbld/func.cxx
// Function: load_files()
void load_files()
{
	for (int i = 0; i < conf.n_blocks; i++) {
		FILE* f = fopen(blk[i].fname, "r");

		if (!f) error(FNFD);

		hdr.blk[i].size = sz(blk[i].size);
		fseek(f, blk[i].offset, SEEK_SET);
		fread(blk[i].data, 1, blk[i].size, f);
		fclose(f);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x44391f(%rip), %r12    # 0x446d60
cmpl $0x0, 0x18(%r12)
jle 0x34e6
movl $0x100, %r13d           # imm = 0x100
addq 0x2b76(%rip), %r13      # 0x5fd0
movl $0x408, %ebx            # imm = 0x408
addq 0x2b7a(%rip), %rbx      # 0x5fe0
xorl %ebp, %ebp
leaq 0xc78(%rip), %r14       # 0x40e7
leaq -0x408(%rbx), %rdi
movq %r14, %rsi
callq 0x2130
testq %rax, %rax
je 0x34f5
movq %rax, %r15
movl -0x4(%rbx), %eax
decl %eax
movzwl (%r13), %ecx
shrl %eax
andl $0x1f00, %eax           # imm = 0x1F00
andl $0xffffe0ff, %ecx       # imm = 0xFFFFE0FF
orl %eax, %ecx
movw %cx, (%r13)
movslq -0x8(%rbx), %rsi
movq %r15, %rdi
xorl %edx, %edx
callq 0x2120
movslq -0x4(%rbx), %rdx
movl $0x1, %esi
movq %rbx, %rdi
movq %r15, %rcx
callq 0x21c0
movq %r15, %rdi
callq 0x2100
incq %rbp
movslq 0x18(%r12), %rax
addq $0x3, %r13
addq $0x4408, %rbx           # imm = 0x4408
cmpq %rax, %rbp
jl 0x346f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xcf9(%rip), %rdi       # 0x41f5
xorl %eax, %eax
callq 0x2030
leaq 0xdc6(%rip), %rdi       # 0x42d0
callq 0x21d0
movl $0x5, %edi
callq 0x2150
// File: /workspace/github_c_makefile_star2_O3/salextpuru[P]speccy-toochain/src/spgbld/main.cxx
// Function: main
int main(int argc, char* argv[])
{
	init_hdr();
	parse_args(argc, argv);

	switch (conf.mode) {
	case M_BLD:
		load_ini(conf.in_fname);
		load_files();

		if (conf.packer != PM_NONE)
			pack_blocks();

		save_spg(conf.out_fname);
		break;

	case M_UNP:
		unpack_spg(conf.in_fname);
		break;
	}

	error(OK);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
callq 0x252a
movl %ebp, %edi
movq %rbx, %rsi
callq 0x23e4
movl 0x442fcf(%rip), %eax    # 0x446d64
cmpl $0x3, %eax
je 0x3dcc
cmpl $0x1, %eax
jne 0x3dd8
movq 0x442fc2(%rip), %rdi    # 0x446d68
callq 0x2601
callq 0x342f
cmpl $0x0, 0x442fa9(%rip)    # 0x446d60
je 0x3dbe
callq 0x2d77
movq 0x442fab(%rip), %rdi    # 0x446d70
callq 0x3389
jmp 0x3dd8
movq 0x442f95(%rip), %rdi    # 0x446d68
callq 0x3519
leaq 0x5be(%rip), %rdi       # 0x439d
xorl %eax, %eax
callq 0x2030
leaq 0x4e3(%rip), %rdi       # 0x42d0
callq 0x21d0
xorl %edi, %edi
callq 0x2150
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/salextpuru[P]speccy-toochain/src/spgbld/msg.cxx
// Function: print_help()
void print_help()
{
	printf(STR(SB_VER));
	printf("\n\n");
	printf("Build:	  spgbld -b <input.ini> <output.spg> [-c <pack method>]\n");
	printf("Unpack:	  spgbld -u <input.spg>\n");
	printf("Pack method is:	 auto/-1(default) none/0 mlz/1 hst/2\n");
	printf("\n\n");
}

// Assembly:
pushq %rbx
leaq 0x59f(%rip), %rdi       # 0x43a3
xorl %eax, %eax
callq 0x2030
leaq 0x4be(%rip), %rbx       # 0x42d0
movq %rbx, %rdi
callq 0x21d0
leaq 0x5a1(%rip), %rdi       # 0x43c2
callq 0x21d0
leaq 0x5d4(%rip), %rdi       # 0x4401
callq 0x21d0
leaq 0x5e8(%rip), %rdi       # 0x4421
callq 0x21d0
movq %rbx, %rdi
popq %rbx
jmp 0x21d0
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/ch6/limit_memory.c
// Function: alloc
void *alloc(void *ud,
            void *ptr,
            size_t osize,
            size_t nsize) {

  // Compute the byte change requested. May be negative.
  long num_bytes_to_add = nsize - (ptr ? osize : 0);

  // Reject the change if it would exceed our limit.
  if (bytes_alloced + num_bytes_to_add > max_bytes) {
    errno = ENOMEM;
    return NULL;
  }

  // Otherwise, free or allocate memory as requested.
  bytes_alloced += num_bytes_to_add;
  if (nsize) return realloc(ptr, nsize);
  free(ptr);
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rsi, %rsi
cmoveq %rsi, %rdx
movq %rcx, %rax
subq %rdx, %rax
addq 0x29ac4(%rip), %rax     # 0x2e2c8
cmpq 0x29a95(%rip), %rax     # 0x2e2a0
jle 0x481a
callq 0x40a0
movl $0xc, (%rax)
jmp 0x4837
movq %rax, 0x29aa7(%rip)     # 0x2e2c8
movq %rsi, %rdi
testq %rcx, %rcx
je 0x4832
movq %rcx, %rsi
popq %rbp
jmp 0x43c0
callq 0x4050
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/ch6/limit_memory.c
// Function: main
int main() {
  lua_State *L = lua_newstate(alloc, NULL);
  luaL_openlibs(L);

  print_status();
  while (accept_and_run_a_line(L)) print_status();

  lua_close(L);
  print_status();
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
leaq -0x77(%rip), %rdi       # 0x47ec
xorl %esi, %esi
callq 0x4bb9
movq %rax, %rbx
movq %rax, %rdi
callq 0x94a0
movq 0x29a4c(%rip), %rsi     # 0x2e2c8
leaq 0x1c781(%rip), %rdi     # 0x21004
xorl %eax, %eax
callq 0x4170
movq %rbx, %rdi
callq 0x203cc
testl %eax, %eax
je 0x48ba
leaq 0x1c767(%rip), %r14     # 0x21004
movq 0x29a24(%rip), %rsi     # 0x2e2c8
movq %r14, %rdi
xorl %eax, %eax
callq 0x4170
movq %rbx, %rdi
callq 0x203cc
testl %eax, %eax
jne 0x489d
movq %rbx, %rdi
callq 0x4ebf
movq 0x299ff(%rip), %rsi     # 0x2e2c8
leaq 0x1c734(%rip), %rdi     # 0x21004
xorl %eax, %eax
callq 0x4170
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/ch6/interpreter.c
// Function: accept_and_run_a_line
int accept_and_run_a_line(lua_State *L) {

  char buff[2048];

  // Read input and exit early if there is an end of stream.
  printf("> ");
  if (!fgets(buff, sizeof(buff), stdin)) {
    printf("\n");
    return 0;
  }

  // Try to run the line, printing errors if there are any.
  int error = luaL_loadstring(L, buff);
  if (!error) error = lua_pcall(L, 0, 0, 0);
  if (error) {
    fprintf(stderr, "%s\n", lua_tostring(L, -1));
    lua_pop(L, 1);
  }

  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x800, %rsp            # imm = 0x800
movq %rdi, %rbx
leaq 0x26c6(%rip), %rdi      # 0x22aaa
xorl %r14d, %r14d
xorl %eax, %eax
callq 0x4170
movq 0xdbdb(%rip), %rax      # 0x2dfd0
movq (%rax), %rdx
leaq -0x810(%rbp), %rdi
movl $0x800, %esi            # imm = 0x800
callq 0x4240
testq %rax, %rax
je 0x2044f
leaq -0x810(%rbp), %rsi
movq %rbx, %rdi
callq 0x157d1
testl %eax, %eax
jne 0x2043f
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0xa8a3
movl $0x1, %r14d
testl %eax, %eax
je 0x20459
movq %rbx, %rdi
callq 0x46b5
movl $0x1, %r14d
jmp 0x20459
movl $0xa, %edi
callq 0x4070
movl %r14d, %eax
addq $0x800, %rsp            # imm = 0x800
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/amanelis[P]uici/uiciname.c
// Function: addr2name
void addr2name(struct in_addr addr, char *name, int namelen) {
   struct hostent *hostptr;

   if (pthread_mutex_lock(&mutex) == -1) {
      strncpy(name, inet_ntoa(addr), namelen-1); 
      name[namelen-1] = 0;
      return;
   }
   hostptr = gethostbyaddr((char *)&addr, 4, AF_INET);
   if (hostptr == NULL)
      strncpy(name, inet_ntoa(addr), namelen-1); 
   else  
      strncpy(name, hostptr->h_name, namelen-1);
   pthread_mutex_unlock(&mutex);
   name[namelen-1] = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rsi, %rbx
movl %edi, %r15d
movl %edi, -0x1c(%rbp)
leaq 0x266b(%rip), %rdi      # 0x4120
callq 0x11e0
cmpl $-0x1, %eax
je 0x1adc
leaq -0x1c(%rbp), %rdi
movl $0x4, %esi
movl $0x2, %edx
callq 0x11b0
testq %rax, %rax
je 0x1aff
movq (%rax), %rsi
jmp 0x1b0a
movl %r15d, %edi
callq 0x1090
movslq %r14d, %r14
leaq -0x1(%r14), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1040
leaq (%rbx,%r14), %rax
decq %rax
jmp 0x1b2e
movl -0x1c(%rbp), %edi
callq 0x1090
movq %rax, %rsi
leal -0x1(%r14), %eax
movslq %eax, %rdx
movq %rbx, %rdi
callq 0x1040
leaq 0x2600(%rip), %rdi      # 0x4120
callq 0x1130
movslq %r14d, %rax
addq %rbx, %rax
decq %rax
movb $0x0, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/amanelis[P]uici/uiciname.c
// Function: name2addr
int name2addr(char *name, in_addr_t *addrp) {
   struct hostent *hp;
 
   if (isdigit((int)(*name)))
      *addrp = inet_addr(name);
   else {
      if (pthread_mutex_lock(&mutex) == -1)
         return -1;
      hp = gethostbyname(name);
      if (hp == NULL) {
         pthread_mutex_unlock(&mutex);
         return -1;
      }
      memcpy((char *)addrp, hp->h_addr_list[0], hp->h_length);
      pthread_mutex_unlock(&mutex);
   }
   return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
callq 0x11f0
movq (%rax), %rax
movsbq (%r15), %rcx
testb $0x8, 0x1(%rax,%rcx,2)
jne 0x1ba4
leaq 0x25ba(%rip), %rdi      # 0x4120
callq 0x11e0
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
cmpl $-0x1, %eax
je 0x1bb1
movq %r15, %rdi
callq 0x10f0
testq %rax, %rax
je 0x1bbf
movq 0x18(%rax), %rcx
movq (%rcx), %rsi
movslq 0x14(%rax), %rdx
movq %rbx, %rdi
callq 0x1110
leaq 0x2583(%rip), %rdi      # 0x4120
callq 0x1130
jmp 0x1bae
movq %r15, %rdi
callq 0x10e0
movl %eax, (%rbx)
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x255a(%rip), %rdi      # 0x4120
callq 0x1130
jmp 0x1bb1
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/openshmem-org[P]openshmem-examples/c/iip.c
// Function: main
int
main(void)
{
    int me;

    shmem_init();
    me = shmem_my_pe();

    n = 3;

    shmem_barrier_all();

    if (me == 0) {
        shmem_int_p(&n, 42, 1);
    }

    shmem_barrier_all();

    /* now check */

    if (me == 1) {
        printf("PE %d: n = %d, %s\n", me, n, (n == 42) ? "OK" : "FAIL");
    }

    shmem_finalize();

    return 0;
}

// Assembly:
pushq %rbx
callq 0x1080
callq 0x1060
movl %eax, %ebx
movl $0x3, 0x2eb9(%rip)      # 0x405c
callq 0x1070
testl %ebx, %ebx
je 0x11e6
callq 0x1070
cmpl $0x1, %ebx
jne 0x1201
movl 0x2ea0(%rip), %edx      # 0x405c
cmpl $0x2a, %edx
leaq 0xe51(%rip), %rax       # 0x2017
leaq 0xe4d(%rip), %rcx       # 0x201a
cmoveq %rax, %rcx
leaq 0xe2c(%rip), %rdi       # 0x2004
movl $0x1, %esi
xorl %eax, %eax
callq 0x1030
jmp 0x1201
leaq 0x2e6f(%rip), %rdi      # 0x405c
movl $0x2a, %esi
movl $0x1, %edx
callq 0x1040
callq 0x1070
callq 0x1050
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/richarddurbin[P]hash10x/fq2b.c
// Function: read10xWhitelist
void read10xWhitelist (char *fileName)
{ FILE *f = fopen (fileName, "r") ;
  if (!f) die ("failed to open 10x whitelist file %s\n", fileName) ;
  char s[32] ;
  U32 u ; 
  int i,j,n = 0 ;

  if (!(table = calloc ((size_t)1<<32, 1))) die ("can't allocate barcode table") ;
  for (i = 0 ; i < 16 ; ++i)
    for (j = 0 ; j < 4 ; ++j)
      { mask[i*4 + j] = ~(3 << (2*i)) ; bits[i*4 + j] = j << (2*i) ; }
  
  while (!feof (f) && fscanf (f, "%s\n", s))
    { ++n ;
      if (strlen(s) != 16) die ("bad barcode line % in %s: %s", n, fileName, s) ;
      seqPack (s, &u, 16) ;
      for (i = 0 ; i < 16 ; ++i)
	{ U8 ui = 1 + i*4 + ((u >> (2*i)) & 0x3) ; /* code to reset i'th base to u[i] */
	  for (j = 0 ; j < 4 ; ++j) table[switchBase(u,1+i*4+j)] = ui ;
	}
    }
  fclose (f) ;
  fprintf (stderr, "read %d barcodes from file %s\n", n, fileName) ;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
leaq 0x2e87(%rip), %rsi      # 0x40bc
movq %rdi, (%rsp)
callq 0x1190
movq %rax, %r14
testq %rax, %rax
jne 0x1258
leaq 0x2e71(%rip), %rdi      # 0x40be
movq (%rsp), %rsi
xorl %eax, %eax
callq 0x3244
movabsq $0x100000000, %rdi      # imm = 0x100000000
pushq $0x1
popq %rsi
callq 0x10f0
movq %rax, 0x66e7(%rip)      # 0x7958
testq %rax, %rax
jne 0x1284
leaq 0x2e67(%rip), %rdi      # 0x40e4
xorl %eax, %eax
callq 0x3244
xorl %eax, %eax
pushq $0x3
popq %rdx
leaq 0x66d0(%rip), %r15      # 0x7960
movdqa 0x2d88(%rip), %xmm0     # 0x4020
leaq 0x67c1(%rip), %r13      # 0x7a60
xorl %ecx, %ecx
movl %edx, %esi
shll %cl, %esi
notl %esi
movd %esi, %xmm1
pshufd $0x0, %xmm1, %xmm1      # xmm1 = xmm1[0,0,0,0]
movdqa %xmm1, (%rax,%r15)
movd %ecx, %xmm1
movdqa %xmm0, %xmm2
pslld %xmm1, %xmm2
movdqa %xmm2, (%rax,%r13)
addq $0x2, %rcx
addq $0x10, %rax
cmpq $0x20, %rcx
jne 0x12a1
movq %r14, %rdi
callq 0x1130
xorl %ebp, %ebp
testl %eax, %eax
jne 0x139f
leaq 0x10(%rsp), %r12
pushq $0x10
popq %rbx
xorl %ebp, %ebp
movq %r14, %rdi
leaq 0x2e3d(%rip), %rsi      # 0x4139
movq %r12, %rdx
xorl %eax, %eax
callq 0x1050
testl %eax, %eax
je 0x139f
incl %ebp
movq %r12, %rdi
callq 0x1090
cmpq $0x10, %rax
je 0x1335
leaq 0x2ddc(%rip), %rdi      # 0x4101
movl %ebp, %esi
movq (%rsp), %rdx
movq %r12, %rcx
xorl %eax, %eax
callq 0x3244
movq %r12, %rdi
leaq 0xc(%rsp), %rsi
movl %ebx, %edx
callq 0x16a8
movl 0xc(%rsp), %eax
xorl %edx, %edx
xorl %esi, %esi
leal (%rsi,%rsi), %ecx
movl %eax, %edi
shrl %cl, %edi
andl $0x3, %edi
leal (%rdi,%rsi,4), %ecx
incb %cl
xorl %edi, %edi
leaq (%rdx,%rdi), %r8
movl (%r15,%r8), %r9d
andl %eax, %r9d
orl (%r13,%r8), %r9d
movq 0x65e4(%rip), %r8       # 0x7958
movb %cl, (%r8,%r9)
addq $0x4, %rdi
cmpq $0x10, %rdi
jne 0x135d
incq %rsi
addq $0x10, %rdx
cmpq $0x10, %rsi
jne 0x134c
movq %r14, %rdi
callq 0x1130
testl %eax, %eax
je 0x12f2
movq %r14, %rdi
callq 0x1080
movq 0x5c4a(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
leaq 0x2d66(%rip), %rsi      # 0x411e
movl %ebp, %edx
movq (%rsp), %rcx
xorl %eax, %eax
callq 0x1120
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/richarddurbin[P]hash10x/fq2b.c
// Function: packInit
void packInit (void)
{
  if (isPackInitialised) return ;
  int i ;
  static int sIndex[] = {'a','c','g','t','A','C','G','T'} ;
  for (i = 0 ; i < 8 ; ++i) sPack[sIndex[i]] = i%4 ;
  for (i = '$' + 20 ; i < 256 ; ++i) qPack[i] = 1 ;
  isPackInitialised = TRUE ;
}

// Assembly:
cmpb $0x0, 0x5add(%rip)      # 0x7130
jne 0x16a7
leaq 0x29e4(%rip), %rax      # 0x4040
xorl %ecx, %ecx
leaq 0x5adb(%rip), %rdx      # 0x7140
movl %ecx, %esi
andl $0x3, %esi
movslq (%rax), %rdi
movl %esi, (%rdx,%rdi,4)
incq %rcx
addq $0x4, %rax
cmpq $0x8, %rcx
jne 0x1665
movl $0x38, %eax
leaq 0x5eb7(%rip), %rcx      # 0x7540
movaps 0x2980(%rip), %xmm0     # 0x4010
movaps %xmm0, (%rcx,%rax,4)
addq $0x4, %rax
cmpq $0x100, %rax            # imm = 0x100
jne 0x1690
movb $0x1, 0x5a89(%rip)      # 0x7130
retq
// File: /workspace/github_c_makefile_star2_O3/richarddurbin[P]hash10x/fq2b.c
// Function: seqPack
void seqPack (char *s, U32 *u, int len) /* compress s into (len+)/4 U32  */
{
  assert (isPackInitialised) ;
  int i ;
  while (len > 16)
    { *u = 0 ; for (i = 0 ; i < 16 ; ++i) *u = (*u << 2) | sPack[*s++] ;
      len -= 16 ; ++u ;
    }
  *u = 0 ; for (i = 0 ; i < len ; ++i) *u = (*u << 2) | sPack[*s++] ;
}

// Assembly:
pushq %rax
cmpb $0x1, 0x5a80(%rip)      # 0x7130
jne 0x1739
cmpl $0x11, %edx
jl 0x1703
leaq 0x5a7e(%rip), %rax      # 0x7140
movq %rdi, %rcx
movl $0x0, (%rsi)
xorl %r8d, %r8d
xorl %edi, %edi
shll $0x2, %edi
movsbq (%rcx,%r8), %r9
orl (%rax,%r9,4), %edi
movl %edi, (%rsi)
incq %r8
cmpl $0x10, %r8d
jne 0x16d0
leal -0x10(%rdx), %r9d
addq $0x4, %rsi
leaq (%rcx,%r8), %rdi
cmpl $0x20, %edx
movl %r9d, %edx
jg 0x16c2
addq %r8, %rcx
movq %rcx, %rdi
jmp 0x1706
movl %edx, %r9d
movl $0x0, (%rsi)
testl %r9d, %r9d
jle 0x1737
movl %r9d, %eax
xorl %ecx, %ecx
leaq 0x5a23(%rip), %rdx      # 0x7140
xorl %r8d, %r8d
shll $0x2, %r8d
movsbq (%rdi,%rcx), %r9
orl (%rdx,%r9,4), %r8d
movl %r8d, (%rsi)
incq %rcx
cmpl %ecx, %eax
jne 0x1720
popq %rax
retq
leaq 0x2920(%rip), %rdi      # 0x4060
leaq 0x292b(%rip), %rsi      # 0x4072
leaq 0x292b(%rip), %rcx      # 0x4079
movl $0x23, %edx
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O3/richarddurbin[P]hash10x/fq2b.c
// Function: qualPack
void qualPack (char *q, U32 *u, int len)
{
  assert (isPackInitialised) ;
  int i ;
  while (len > 32)
    { *u = 0 ; for (i = 0 ; i < 32 ; ++i) *u = (*u << 1) | qPack[*q++] ;
      len -= 32 ; ++u ;
    }
  *u = 0 ; for (i = 0 ; i < len ; ++i) *u = (*u << 1) | qPack[*q++] ;
}

// Assembly:
pushq %rax
cmpb $0x1, 0x598a(%rip)      # 0x7130
jne 0x182d
cmpl $0x21, %edx
jl 0x17f8
leaq 0x5d88(%rip), %rax      # 0x7540
movq %rdi, %rcx
movl $0x0, (%rsi)
xorl %r8d, %r8d
xorl %edi, %edi
addl %edi, %edi
movsbq (%rcx,%r8), %r9
orl (%rax,%r9,4), %edi
movl %edi, (%rsi)
incq %r8
cmpl $0x20, %r8d
jne 0x17c6
leal -0x20(%rdx), %r9d
addq $0x4, %rsi
leaq (%rcx,%r8), %rdi
cmpl $0x40, %edx
movl %r9d, %edx
jg 0x17b8
addq %r8, %rcx
movq %rcx, %rdi
jmp 0x17fb
movl %edx, %r9d
movl $0x0, (%rsi)
testl %r9d, %r9d
jle 0x182b
movl %r9d, %eax
xorl %ecx, %ecx
leaq 0x5d2e(%rip), %rdx      # 0x7540
xorl %r8d, %r8d
addl %r8d, %r8d
movsbq (%rdi,%rcx), %r9
orl (%rdx,%r9,4), %r8d
movl %r8d, (%rsi)
incq %rcx
cmpl %ecx, %eax
jne 0x1815
popq %rax
retq
leaq 0x282c(%rip), %rdi      # 0x4060
leaq 0x2837(%rip), %rsi      # 0x4072
leaq 0x2858(%rip), %rcx      # 0x409a
movl $0x36, %edx
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O3/richarddurbin[P]hash10x/fq2b.c
// Function: find10xBarcode
BOOL find10xBarcode (U32* u)
{
  if (!table[*u]) { ++nBad ; return FALSE ; }
  U32 v = switchBase (*u, table[*u]) ;
  if (v != *u) { ++nFixed ; ++nFixBase[15 - (table[*u]-1)/4] ; *u = v ; }
  return TRUE ;
}

// Assembly:
movq 0x6105(%rip), %rax      # 0x7958
movl (%rdi), %esi
movzbl (%rax,%rsi), %ecx
testl %ecx, %ecx
je 0x189b
decl %ecx
leaq 0x60fa(%rip), %rax      # 0x7960
movl (%rax,%rcx,4), %edx
andl %esi, %edx
leaq 0x61ee(%rip), %rax      # 0x7a60
orl (%rax,%rcx,4), %edx
movb $0x1, %al
cmpl %esi, %edx
je 0x189a
incl 0x62e3(%rip)            # 0x7b64
shrl $0x2, %ecx
movl $0xf, %esi
subl %ecx, %esi
movslq %esi, %rcx
leaq 0x62db(%rip), %rsi      # 0x7b70
incl (%rsi,%rcx,4)
movl %edx, (%rdi)
retq
incl 0x62bf(%rip)            # 0x7b60
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/TimeToogo[P]ff-proxy/client/c/client.c
// Function: ff_client_read_payload_from_file
void ff_client_read_payload_from_file(struct ff_request *request, FILE *fd)
{
    uint8_t buffer[1024];
    uint16_t payload_length = 0;
    uint16_t chunk_length = 0;

    struct ff_request_payload_node *payload = ff_request_payload_node_alloc();
    payload->value = malloc(sizeof(buffer));

    while ((chunk_length = fread(buffer, 1, sizeof(buffer), fd)) != 0)
    {
        payload_length += chunk_length;
        payload->value = realloc(payload->value, payload_length);

        if (payload->value == NULL)
        {
            ff_log(FF_FATAL, "Could not reallocate payload buffer");
            exit(1);
        }

        memcpy(payload->value, buffer, chunk_length);
    }

    ff_log(FF_DEBUG, "Read %u bytes from STDIN", payload_length);

    payload->length = payload_length;
    ff_client_request_add_payload(request, payload);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movq %rsi, %r15
movq %rdi, -0x30(%rbp)
callq 0x3bc9
movq %rax, %r14
movl $0x400, %edi            # imm = 0x400
callq 0x2220
movq %rax, 0x8(%r14)
leaq -0x430(%rbp), %rdi
movl $0x1, %esi
movl $0x400, %edx            # imm = 0x400
movq %r15, %rcx
callq 0x2260
movq %rax, %r13
xorl %ebx, %ebx
testw %r13w, %r13w
je 0x2811
leaq -0x430(%rbp), %r12
addl %r13d, %ebx
movq 0x8(%r14), %rdi
movzwl %bx, %esi
callq 0x22a0
movq %rax, 0x8(%r14)
testq %rax, %rax
je 0x2868
movzwl %r13w, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x2150
movl $0x1, %esi
movl $0x400, %edx            # imm = 0x400
movq %r12, %rdi
movq %r15, %rcx
callq 0x2260
movq %rax, %r13
testw %r13w, %r13w
jne 0x27c8
movzwl %bx, %r15d
leaq 0x288e(%rip), %rsi      # 0x50aa
movl $0x1, %edi
movl %r15d, %edx
xorl %eax, %eax
callq 0x3a20
movw %r15w, 0x2(%r14)
movq -0x30(%rbp), %rdx
movq 0x50(%rdx), %rax
testq %rax, %rax
je 0x284e
movq %r14, 0x10(%rax)
movzwl 0x2(%rax), %ecx
addw (%rax), %cx
movw %cx, (%r14)
jmp 0x2852
movq %r14, 0x50(%rdx)
addq %r15, 0x40(%rdx)
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2817(%rip), %rsi      # 0x5086
movl $0x5, %edi
xorl %eax, %eax
callq 0x3a20
movl $0x1, %edi
callq 0x21e0
// File: /workspace/github_c_makefile_star2_O3/TimeToogo[P]ff-proxy/client/c/client.c
// Function: ff_client_write_options
uint32_t ff_client_write_options(void *buffer, struct ff_request_option_node **options, uint8_t amount)
{
    uint32_t buff_i = 0;

    for (uint8_t i = 0; i < amount; i++)
    {
        struct __raw_ff_request_option_header *option_header = (struct __raw_ff_request_option_header *)(buffer + buff_i);
        option_header->type = options[i]->type;
        option_header->length = htons(options[i]->length);
        buff_i += sizeof(struct __raw_ff_request_option_header);
        memcpy(buffer + buff_i, options[i]->value, options[i]->length);
        buff_i += options[i]->length;
    }

    return buff_i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testl %edx, %edx
je 0x2d5f
movq %rsi, %rbx
movq %rdi, %r14
movzbl %dl, %r12d
xorl %r13d, %r13d
xorl %r15d, %r15d
movl %r15d, %eax
movq (%rbx,%r13,8), %rcx
movb (%rcx), %dl
movb %dl, (%r14,%rax)
movzwl 0x4(%rcx), %edx
movl %edx, %esi
rolw $0x8, %si
movw %si, 0x1(%r14,%rax)
leal 0x3(%r15), %edi
addq %r14, %rdi
movq 0x8(%rcx), %rsi
callq 0x2150
movq (%rbx,%r13,8), %rax
movzwl 0x4(%rax), %eax
addl %eax, %r15d
addl $0x3, %r15d
incq %r13
cmpq %r13, %r12
jne 0x2d19
jmp 0x2d62
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/TimeToogo[P]ff-proxy/client/c/client.c
// Function: ff_client_calculate_request_size
uint32_t ff_client_calculate_request_size(struct ff_request *request)
{
    uint32_t length = 0;

    length += sizeof(struct __raw_ff_request_header);

    for (int i = 0; i < request->options_length; i++)
    {
        length += sizeof(struct __raw_ff_request_option_header);
        length += request->options[i]->length;
    }

    length += request->payload_length;

    return length;
}

// Assembly:
movzbl 0x28(%rdi), %ecx
testq %rcx, %rcx
je 0x2dd1
pushq %rbp
movq %rsp, %rbp
movq 0x30(%rdi), %rdx
movl $0x14, %eax
xorl %esi, %esi
movq (%rdx,%rsi,8), %r8
movzwl 0x4(%r8), %r8d
addl %r8d, %eax
addl $0x3, %eax
incq %rsi
cmpq %rsi, %rcx
jne 0x2db7
popq %rbp
jmp 0x2dd6
movl $0x14, %eax
addl 0x40(%rdi), %eax
retq
// File: /workspace/github_c_makefile_star2_O3/TimeToogo[P]ff-proxy/client/c/client.c
// Function: ff_client_generate_request_id
uint64_t ff_client_generate_request_id()
{
    uint8_t buffer[8];

    if (!RAND_bytes(buffer, sizeof(buffer)))
    {
        ff_log(FF_FATAL, "Failed to generate request ID");
        exit(EXIT_FAILURE);
    }

    return (uint64_t)(
        (uint64_t)buffer[0] | ((uint64_t)buffer[1] << 8) | ((uint64_t)buffer[2] << 16) | ((uint64_t)buffer[3] << 24) | ((uint64_t)buffer[4] << 32) | ((uint64_t)buffer[5] << 40) | ((uint64_t)buffer[6] << 48) | ((uint64_t)buffer[7] << 56));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq -0x8(%rbp), %rdi
movl $0x8, %esi
callq 0x2240
testl %eax, %eax
je 0x2dfe
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
leaq 0x22e1(%rip), %rsi      # 0x50e6
movl $0x5, %edi
xorl %eax, %eax
callq 0x3a20
movl $0x1, %edi
callq 0x21e0
nop
// File: /workspace/github_c_makefile_star2_O3/TimeToogo[P]ff-proxy/client/c/main.c
// Function: main
int main(int argc, char **argv)
{
    enum ff_client_action action = ff_client_parse_arguments(&ff_global_config, argc, argv);
    int ret = EXIT_SUCCESS;

    switch (action)
    {
    case FF_CLIENT_ACTION_MAKE_REQUEST:
        ret = ff_client_make_request(&ff_global_config, stdin);
        break;

    case FF_CLIENT_ACTION_PRINT_VERSION:
        ff_print_version(stdout);
        ret = 0;
        break;

    case FF_CLIENT_ACTION_PRINT_USAGE:
        ff_client_print_usage(stdout);
        ret = 0;
        break;

    case FF_CLIENT_ACTION_INVALID_ARGS:
        ff_client_print_usage(stderr);
        ret = EXIT_FAILURE;
        break;
    }

    ff_log(FF_INFO, "Exiting...");
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, %rdx
movl %edi, %esi
leaq 0x4bde(%rip), %rdi      # 0x81a8
callq 0x2e1c
xorl %ebx, %ebx
decl %eax
cmpl $0x3, %eax
ja 0x3638
leaq 0x2089(%rip), %rcx      # 0x5668
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x49e9(%rip), %rax      # 0x7fd8
movq (%rax), %rsi
leaq 0x4baf(%rip), %rdi      # 0x81a8
callq 0x244c
movl %eax, %ebx
jmp 0x3638
movq 0x49b7(%rip), %rax      # 0x7fc0
movq (%rax), %rdi
callq 0x30ad
jmp 0x3638
movq 0x49c6(%rip), %rax      # 0x7fe0
movq (%rax), %rdi
callq 0x30ad
movl $0x1, %ebx
jmp 0x3638
movq 0x4990(%rip), %rax      # 0x7fc0
movq (%rax), %rdi
callq 0x39d7
leaq 0x2039(%rip), %rsi      # 0x5678
movl $0x2, %edi
xorl %eax, %eax
callq 0x3a20
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/albinoloverats[P]hide/common/src/cli.c
// Function: cli_display
extern void cli_display(cli_s *p)
{
	CLI_DO_INIT;

#ifndef _WIN32
	cli_sigwinch(SIGWINCH);
#endif
	cli_size_width = 0;

	cli_bps_s bps[BPS];
	memset(bps, 0x00, BPS * sizeof( cli_bps_s ));
	int b = 0;

	fprintf(stderr, "\e[?25l\n"); /* hide cursor */
	while (*p->status == CLI_INIT || *p->status == CLI_RUN)
	{
		struct timespec s = { 0, 10 * MILLION }; /* 10 milliseconds */
		nanosleep(&s, NULL);
		if (*p->status == CLI_INIT)
			continue;
		struct timeval tv;
		gettimeofday(&tv, NULL);
		bps[b].time = tv.tv_sec * MILLION + tv.tv_usec;
		bps[b].bytes = p->current->offset;
		b++;
		if (b >= BPS)
			b = 0;
		cli_display_bars(p->total, p->current, bps);
	}
	if (*p->status == CLI_DONE)
	{
		p->total->offset = p->total->size;
		p->current->offset = p->current->size;
		cli_display_bars(p->total, p->current, bps);
	}
	fprintf(stderr, "\e[?25h\n"); /* restore cursor */

	return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x828, %rsp            # imm = 0x828
movq %rdi, %rbx
cmpb $0x0, 0x5d05(%rip)      # 0x8248
jne 0x254a
callq 0x3a8d
xorl %r13d, %r13d
pushq $0x1
popq %rdi
leaq 0x20(%rsp), %r14
movl $0x5413, %esi           # imm = 0x5413
movq %r14, %rdx
xorl %eax, %eax
callq 0x2190
movzwl 0x2(%r14), %eax
movl %eax, 0x5c89(%rip)      # 0x81f8
leaq 0x1bf2(%rip), %rsi      # 0x4168
pushq $0x1c
popq %rdi
callq 0x21f0
leaq 0x20(%rsp), %rdi
movl $0x800, %edx            # imm = 0x800
xorl %esi, %esi
callq 0x2180
movq 0x5a62(%rip), %rax      # 0x7ff8
movq (%rax), %rcx
leaq 0x2dc3(%rip), %rdi      # 0x5363
pushq $0x7
popq %rsi
pushq $0x1
popq %rdx
callq 0x2350
leaq 0x10(%rsp), %r15
movq %rsp, %r12
xorl %ebp, %ebp
movq (%rbx), %rax
movl (%rax), %eax
leal -0x1(%rax), %ecx
cmpl $0x2, %ecx
jae 0x262a
movups 0x2ce7(%rip), %xmm0     # 0x52b0
movaps %xmm0, 0x10(%rsp)
movq %r15, %rdi
xorl %esi, %esi
callq 0x2150
movq (%rbx), %rax
cmpl $0x1, (%rax)
je 0x25b5
movq %r12, %rdi
xorl %esi, %esi
callq 0x2160
imulq $0xf4240, (%rsp), %rax  # imm = 0xF4240
addq 0x8(%rsp), %rax
movslq %ebp, %rcx
movq %rcx, %rdx
shlq $0x4, %rdx
movq %rax, 0x20(%rsp,%rdx)
movq 0x8(%rbx), %rsi
movq (%rsi), %rax
movq %rax, 0x28(%rsp,%rdx)
leal 0x1(%rcx), %ebp
cmpl $0x7f, %ecx
cmovgel %r13d, %ebp
movq 0x10(%rbx), %rdi
movq %r14, %rdx
callq 0x41a7
jmp 0x25b5
testl %eax, %eax
jne 0x264e
movq 0x10(%rbx), %rdi
movq 0x8(%rdi), %rax
movq %rax, (%rdi)
movq 0x8(%rbx), %rsi
movq 0x8(%rsi), %rax
movq %rax, (%rsi)
leaq 0x20(%rsp), %rdx
callq 0x41a7
movq 0x59a3(%rip), %rax      # 0x7ff8
movq (%rax), %rcx
leaq 0x2be1(%rip), %rdi      # 0x5240
pushq $0x7
popq %rsi
pushq $0x1
popq %rdx
callq 0x2350
addq $0x828, %rsp            # imm = 0x828
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/albinoloverats[P]hide/common/src/cli.c
// Function: cli_display_bar
static void cli_display_bar(char *name, cli_progress_s *p, double percent)
{
	int name_width = CLI_TRUNCATED_DISPLAY_SHORT + strlen(CLI_TRUNCATED_ELLIPSE) + (cli_width > CLI_DEFAULT ? CLI_TRUNCATED_DISPLAY_SHORT : 0);
	fprintf(stderr, "\r%-*s : ", name_width, name);
	if (cli_width > CLI_SMALL)
		fprintf(stderr, "%'13" PRIu64 "/%-'13" PRIu64 " (", p->offset, p->size);
	fprintf(stderr, "%3.0f%%", isnan(percent) ? 0.0f : (percent > PERCENT ? PERCENT : percent));
	if (cli_width > CLI_SMALL)
		fprintf(stderr, ")");

	if (cli_width > CLI_DEFAULT)
	{
		int progress_bar_width = cli_width - CLI_LARGE;
		fprintf(stderr, " [");
		/*
		 * display overall progress bar
		 */
		for (int i = 0; i < progress_bar_width; i++)
			fprintf(stderr, "%c", i < progress_bar_width * percent  / PERCENT ? '=' : ' ');
		fprintf(stderr, "]");
	}
	return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rsi, %rbx
movq %rdi, %rcx
cmpl $0x51, 0x5b5f(%rip)     # 0x81f8
pushq $0x18
popq %rax
pushq $0xe
popq %rdx
cmovgel %eax, %edx
movq 0x594f(%rip), %r14      # 0x7ff8
movq (%r14), %rdi
leaq 0x2cd2(%rip), %rsi      # 0x5385
xorl %eax, %eax
callq 0x2210
cmpl $0x3f, 0x5b37(%rip)     # 0x81f8
jl 0x26db
movq (%r14), %rdi
movq (%rbx), %rdx
movq 0x8(%rbx), %rcx
leaq 0x2cba(%rip), %rsi      # 0x538e
xorl %eax, %eax
callq 0x2210
movq (%r14), %rdi
movsd 0x2bea(%rip), %xmm1     # 0x52d0
movsd 0x8(%rsp), %xmm0
minsd %xmm0, %xmm1
cmpunordsd %xmm0, %xmm0
andnpd %xmm1, %xmm0
leaq 0x2c9f(%rip), %rsi      # 0x539f
movb $0x1, %al
callq 0x2210
cmpl $0x3f, 0x5aea(%rip)     # 0x81f8
jl 0x2726
movq (%r14), %rsi
pushq $0x29
popq %rdi
callq 0x21b0
movl 0x5ad7(%rip), %ebx      # 0x81f8
cmpl $0x51, %ebx
jge 0x2731
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
addl $-0x4b, %ebx
movq (%r14), %rcx
leaq 0x2b4e(%rip), %rdi      # 0x528c
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
callq 0x2350
cvtsi2sd %ebx, %xmm0
mulsd 0x8(%rsp), %xmm0
divsd 0x2b75(%rip), %xmm0     # 0x52d0
movsd %xmm0, 0x10(%rsp)
xorpd %xmm1, %xmm1
pushq $0x3d
popq %rbp
pushq $0x20
popq %r15
movsd %xmm1, 0x8(%rsp)
movq (%r14), %rsi
movsd 0x10(%rsp), %xmm0
ucomisd %xmm1, %xmm0
movl %r15d, %edi
cmoval %ebp, %edi
callq 0x21b0
movsd 0x8(%rsp), %xmm1
addsd 0x2b40(%rip), %xmm1     # 0x52d8
decl %ebx
jne 0x276c
movq (%r14), %rsi
pushq $0x5d
popq %rdi
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x21b0
// File: /workspace/github_c_makefile_star2_O3/albinoloverats[P]hide/src/hide.c
// Function: progress_current_update
static void progress_current_update(uint64_t i, uint64_t j)
{
	if (i < j && i > 0)
	{
		ui.current->offset = i;
		ui.current->size = j;
	}
	return;
}

// Assembly:
cmpq %rsi, %rdi
setae %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x2f65
movq 0x52b2(%rip), %rax      # 0x8210
movq %rdi, (%rax)
movq %rsi, 0x8(%rax)
retq
// File: /workspace/github_c_makefile_star2_O3/albinoloverats[P]hide/src/hide.c
// Function: will_fit
static bool will_fit(data_info_t *data_info, image_info_t image_info)
{
	/*
	 * figure out how much data we can hide
	 */
	struct stat s;
	stat(data_info->file, &s);
	if ((uint64_t)s.st_size > HIDE_CAPACITY)
	{
		errno = ENOSPC;
		return false;
	}
	data_info->size = htonll(s.st_size);
	data_info->hide = true;
	return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
leaq 0x8(%rsp), %r12
movq %r12, %rsi
callq 0x2120
movq 0x30(%r12), %r12
imulq %r15, %rbx
addq $-0x8, %rbx
cmpq %rbx, %r12
ja 0x2fb0
movq %r12, %rax
bswapq %rax
movq %rax, 0x8(%r14)
movb $0x1, 0x10(%r14)
jmp 0x2fbb
callq 0x2060
movl $0x1c, (%rax)
cmpq %rbx, %r12
setbe %al
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/albinoloverats[P]hide/common/src/error.c
// Function: error_init
extern void error_init(void)
{
	if (error_inited)
		return;

	signal(SIGILL,  on_error);
	signal(SIGSEGV, on_error);
	signal(SIGBUS,  on_error);
	signal(SIGABRT, on_error);
	signal(SIGSYS,  on_error);
	//signal(SIGPROF, on_error);

	error_inited = 1;

	return;
}

// Assembly:
cmpl $0x0, 0x4a78(%rip)      # 0x8224
je 0x37af
retq
pushq %rbx
leaq -0x1c7(%rip), %rbx      # 0x35f0
movl $0x4, %edi
movq %rbx, %rsi
callq 0x21f0
movl $0xb, %edi
movq %rbx, %rsi
callq 0x21f0
movl $0x7, %edi
movq %rbx, %rsi
callq 0x21f0
movl $0x6, %edi
movq %rbx, %rsi
callq 0x21f0
movl $0x1f, %edi
movq %rbx, %rsi
callq 0x21f0
movl $0x1, 0x4a22(%rip)      # 0x8224
popq %rbx
retq