LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/glk[P]critbit/critbit-test.c
// Function: test_benchmark_rbtree_int
static void
test_benchmark_rbtree_int(void)
{
	struct rbinttree tree;
	struct element find, *el, *xel;
	int i, j;

	xel = malloc(sizeof(*el) * loopcnt_int_init);

	struct timeval tstart, tend;
        gettimeofday(&tstart, NULL);

	for (i = 1; i < loopcnt_int_init; ++i) {

		RB_INIT(&tree);

		for (j = 0; j < i; ++j) {
			el = &xel[j];
			el->kint = j;
			el = RB_INSERT(rbinttree, &tree, el);
			if (el != NULL)
				abort();
		}
		for (j = 0; j < i; ++j) {
			find.kint = j;
			if (RB_FIND(rbinttree, &tree, &find) == NULL)
				abort();
			find.kint = j;
			if (RB_FIND(rbinttree, &tree, &find) == NULL)
				abort();
			find.kint = j;
			if (RB_FIND(rbinttree, &tree, &find) == NULL)
				abort();
			find.kint = j;
			if (RB_FIND(rbinttree, &tree, &find) == NULL)
				abort();
		}
	}

        gettimeofday(&tend, NULL);

	benchmark_result("rbtree int", loopcnt_int_init, &tstart, &tend);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl $0x23280, %edi          # imm = 0x23280
callq 0xd0b0
movq %rax, -0x60(%rbp)
leaq -0x78(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xd070
movl $0x1, -0x64(%rbp)
cmpl $0x7d0, -0x64(%rbp)     # imm = 0x7D0
jge 0xe3bf
jmp 0xe2ac
movq $0x0, -0x8(%rbp)
movl $0x0, -0x68(%rbp)
movl -0x68(%rbp), %eax
cmpl -0x64(%rbp), %eax
jge 0xe30c
movq -0x60(%rbp), %rax
movslq -0x68(%rbp), %rcx
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x58(%rbp)
movslq -0x68(%rbp), %rcx
movq -0x58(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x58(%rbp), %rsi
leaq -0x8(%rbp), %rdi
callq 0xed40
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x58(%rbp)
je 0xe2ff
callq 0xd040
jmp 0xe301
movl -0x68(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x68(%rbp)
jmp 0xe2bb
movl $0x0, -0x68(%rbp)
movl -0x68(%rbp), %eax
cmpl -0x64(%rbp), %eax
jge 0xe3af
movslq -0x68(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xee50
cmpq $0x0, %rax
jne 0xe33f
callq 0xd040
movslq -0x68(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xee50
cmpq $0x0, %rax
jne 0xe35f
callq 0xd040
movslq -0x68(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xee50
cmpq $0x0, %rax
jne 0xe37f
callq 0xd040
movslq -0x68(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xee50
cmpq $0x0, %rax
jne 0xe39f
callq 0xd040
jmp 0xe3a1
movl -0x68(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x68(%rbp)
jmp 0xe313
jmp 0xe3b1
movl -0x64(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x64(%rbp)
jmp 0xe29d
leaq -0x88(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xd070
leaq 0x95d7(%rip), %rdi      # 0x179ad
movl $0x7d0, %esi            # imm = 0x7D0
leaq -0x78(%rbp), %rdx
leaq -0x88(%rbp), %rcx
callq 0xec30
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/glk[P]critbit/critbit-test.c
// Function: test_benchmark_nrbtree_int
static void
test_benchmark_nrbtree_int(void)
{
	nrb_tree tree;
	struct element find, *el, *xel;
	int i, j;

	xel = malloc(sizeof(*el) * loopcnt_int_init);

	struct timeval tstart, tend;
        gettimeofday(&tstart, NULL);

	for (i = 1; i < loopcnt_int_init; ++i) {

		nrb_new(&tree);

		for (j = 0; j < i; ++j) {
			el = &xel[j];
			el->kint = j;
			nrb_insert(&tree, el);
		}
		for (j = 0; j < i; ++j) {
			find.kint = j;
			if (nrb_search(&tree, &find) == NULL)
				abort();
			find.kint = j;
			if (nrb_search(&tree, &find) == NULL)
				abort();
			find.kint = j;
			if (nrb_search(&tree, &find) == NULL)
				abort();
			find.kint = j;
			if (nrb_search(&tree, &find) == NULL)
				abort();
		}
	}

        gettimeofday(&tend, NULL);

	benchmark_result("nrbtree int", loopcnt_int_init, &tstart, &tend);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movl $0x23280, %edi          # imm = 0x23280
callq 0xd0b0
movq %rax, -0xa8(%rbp)
leaq -0xc0(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xd070
movl $0x1, -0xac(%rbp)
cmpl $0x7d0, -0xac(%rbp)     # imm = 0x7D0
jge 0xe5a2
leaq -0x50(%rbp), %rdi
callq 0xf380
movl $0x0, -0xb0(%rbp)
movl -0xb0(%rbp), %eax
cmpl -0xac(%rbp), %eax
jge 0xe4b6
movq -0xa8(%rbp), %rax
movslq -0xb0(%rbp), %rcx
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0xa0(%rbp)
movslq -0xb0(%rbp), %rcx
movq -0xa0(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0xa0(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0xf400
movl -0xb0(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xb0(%rbp)
jmp 0xe459
movl $0x0, -0xb0(%rbp)
movl -0xb0(%rbp), %eax
cmpl -0xac(%rbp), %eax
jge 0xe58c
movslq -0xb0(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0xf880
cmpq $0x0, %rax
jne 0xe4fb
callq 0xd040
movslq -0xb0(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0xf880
cmpq $0x0, %rax
jne 0xe524
callq 0xd040
movslq -0xb0(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0xf880
cmpq $0x0, %rax
jne 0xe54d
callq 0xd040
movslq -0xb0(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0xf880
cmpq $0x0, %rax
jne 0xe576
callq 0xd040
jmp 0xe578
movl -0xb0(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xb0(%rbp)
jmp 0xe4c0
jmp 0xe58e
movl -0xac(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xac(%rbp)
jmp 0xe436
leaq -0xd0(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xd070
leaq 0x93f3(%rip), %rdi      # 0x179ac
movl $0x7d0, %esi            # imm = 0x7D0
leaq -0xc0(%rbp), %rdx
leaq -0xd0(%rbp), %rcx
callq 0xec30
addq $0xd0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/glk[P]critbit/critbit-test.c
// Function: benchmark_result
static void
benchmark_result(const char *name, intmax_t n, struct timeval *tstart, struct timeval *tend)
{
        double t;

        t = tend->tv_sec - tstart->tv_sec;
        t += (double)(tend->tv_usec - tstart->tv_usec) / (double)1000000;
        printf("%16s: %jd iterations in %lf seconds; %lf iterations/s\n",
            name, n, t, (double)n/t);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
subq (%rcx), %rax
cvtsi2sd %rax, %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
subq 0x8(%rcx), %rax
cvtsi2sd %rax, %xmm0
movsd 0x238b(%rip), %xmm1     # 0x11008
divsd %xmm1, %xmm0
addsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
movsd -0x28(%rbp), %xmm0
cvtsi2sdq -0x10(%rbp), %xmm1
divsd -0x28(%rbp), %xmm1
leaq 0x8cba(%rip), %rdi      # 0x17964
movb $0x2, %al
callq 0xd060
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/glk[P]critbit/critbit-test.c
// Function: hashint
static __inline uint32_t
hashint(uintptr_t h)
{
	h = (~h) + (h << 18);
	h = h ^ (h >> 31);
	h = h * 21;
	h = h ^ (h >> 11);
	h = h + (h << 6);
	h = h ^ (h >> 22);
	return (h);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
xorq $-0x1, %rax
movq -0x8(%rbp), %rcx
shlq $0x12, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
shrq $0x1f, %rcx
xorq %rcx, %rax
movq %rax, -0x8(%rbp)
imulq $0x15, -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
shrq $0xb, %rcx
xorq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
shrq $0x16, %rcx
xorq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/derhass[P]glx_hook/glx_hook.c
// Function: dlsym
extern void *
dlsym(void *handle, const char *name)
{
	void *interceptor;
	void *ptr;
	/* special case: we cannot use GH_GET_PTR as it relies on
	 * GH_dlsym() which we have to query using GH_dlsym_internal */
	pthread_mutex_lock(&GH_fptr_mutex);
	GH_dlsym_internal_dlsym();
	pthread_mutex_unlock(&GH_fptr_mutex);
	interceptor=GH_get_interceptor(name, GH_dlsym_next, "dlsym");
	ptr=(interceptor)?interceptor:GH_dlsym(handle,name);
	GH_verbose(GH_MSG_DEBUG_INTERCEPTION,"dlsym(%p, %s) = %p%s\n",handle,name,ptr,
		interceptor?" [intercepted]":"");
	return ptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x3f49(%rip), %rdi      # 0x5180
callq 0x1130
callq 0x1d40
leaq 0x3f38(%rip), %rdi      # 0x5180
callq 0x10e0
movq -0x10(%rbp), %rdi
leaq 0x408(%rip), %rsi       # 0x1660
leaq 0x1dcd(%rip), %rdx      # 0x302c
callq 0x12e0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1279
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x128e
movq 0x3f28(%rip), %rax      # 0x51a8
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq *%rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %r8
movq -0x18(%rbp), %rsi
leaq 0x2131(%rip), %r9       # 0x33de
leaq 0x1d94(%rip), %rax      # 0x3048
cmpq $0x0, %rsi
cmovneq %rax, %r9
movl $0x5, %edi
leaq 0x1d6a(%rip), %rsi      # 0x3032
movb $0x0, %al
callq 0x16c0
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/derhass[P]glx_hook/glx_hook.c
// Function: GH_dlsym_next
static void *GH_dlsym_next(const char *name)
{
	if (GH_dlsym) {
		return GH_dlsym(RTLD_NEXT, name);
	}
	GH_verbose(GH_MSG_WARNING, "failed to dynamically query '%s' because I don't have a dlsym\n", name);
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq 0x3b35(%rip), %rax      # 0x51a8
cmpq $0x0, %rax
je 0x1693
movq 0x3b28(%rip), %rax      # 0x51a8
movq -0x10(%rbp), %rsi
movq $-0x1, %rdi
callq *%rax
movq %rax, -0x8(%rbp)
jmp 0x16b2
movq -0x10(%rbp), %rdx
movl $0x2, %edi
leaq 0x1bbb(%rip), %rsi      # 0x325e
movb $0x0, %al
callq 0x16c0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/derhass[P]glx_hook/glx_hook.c
// Function: GH_verbose
static void GH_verbose(int level, const char *fmt, ...)
{
	static int verbosity=-1;
	static FILE *output_stream=NULL;
	static int stream_initialized=0;
	va_list args;

	if (verbosity < 0) {
		verbosity=get_envi("GH_VERBOSE", GH_MSG_LEVEL_DEFAULT);
	}

	if (level > verbosity) {
		return;
	}

	if (!stream_initialized) {
		const char *file=getenv("GH_VERBOSE_FILE");
		if (file) {
			char buf[PATH_MAX];
			parse_name(buf, sizeof(buf), file, 0);
			output_stream=fopen(buf,"a+t");
		}
		if (!output_stream)
			output_stream=GH_DEFAULT_OUTPUT_STREAM;
		stream_initialized=1;
	}
	fprintf(output_stream,"GH: ");
	va_start(args, fmt);
	vfprintf(output_stream, fmt, args);
	va_end(args);
	fflush(output_stream);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10f0, %rsp           # imm = 0x10F0
testb %al, %al
je 0x1707
movaps %xmm0, -0x10c0(%rbp)
movaps %xmm1, -0x10b0(%rbp)
movaps %xmm2, -0x10a0(%rbp)
movaps %xmm3, -0x1090(%rbp)
movaps %xmm4, -0x1080(%rbp)
movaps %xmm5, -0x1070(%rbp)
movaps %xmm6, -0x1060(%rbp)
movaps %xmm7, -0x1050(%rbp)
movq %r9, -0x10c8(%rbp)
movq %r8, -0x10d0(%rbp)
movq %rcx, -0x10d8(%rbp)
movq %rdx, -0x10e0(%rbp)
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x0, 0x399f(%rip)      # 0x50d0
jge 0x174a
leaq 0x1b63(%rip), %rdi      # 0x329d
movl $0x2, %esi
callq 0x1f10
movl %eax, 0x3986(%rip)      # 0x50d0
movl -0x4(%rbp), %eax
cmpl 0x397d(%rip), %eax      # 0x50d0
jle 0x175a
jmp 0x182d
cmpl $0x0, 0x3a87(%rip)      # 0x51e8
jne 0x17d0
leaq 0x1b3e(%rip), %rdi      # 0x32a8
callq 0x1030
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x17ab
leaq -0x1040(%rbp), %rdi
movq -0x38(%rbp), %rdx
movl $0x1000, %esi           # imm = 0x1000
xorl %ecx, %ecx
callq 0x1fb0
leaq -0x1040(%rbp), %rdi
leaq 0x1b19(%rip), %rsi      # 0x32b8
callq 0x1100
movq %rax, 0x3a35(%rip)      # 0x51e0
cmpq $0x0, 0x3a2d(%rip)      # 0x51e0
jne 0x17c6
movq 0x383c(%rip), %rax      # 0x4ff8
movq (%rax), %rax
movq %rax, 0x3a1a(%rip)      # 0x51e0
movl $0x1, 0x3a18(%rip)      # 0x51e8
movq 0x3a09(%rip), %rdi      # 0x51e0
leaq 0x1ade(%rip), %rsi      # 0x32bc
movb $0x0, %al
callq 0x10c0
leaq -0x30(%rbp), %rax
leaq -0x10f0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq 0x39d0(%rip), %rdi      # 0x51e0
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x1110
leaq -0x30(%rbp), %rax
movq 0x39b8(%rip), %rdi      # 0x51e0
callq 0x10f0
addq $0x10f0, %rsp           # imm = 0x10F0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/derhass[P]glx_hook/glx_hook.c
// Function: glXSwapIntervalEXT
extern void glXSwapIntervalEXT(Display *dpy, GLXDrawable drawable,
				int interval)
{
	interval=GH_swap_interval(interval);
	if (interval == GH_SWAP_DONT_SET) {
		/* ignore the call */
		return;
	}
	GH_GET_PTR_GL(glXSwapIntervalEXT);
	GH_glXSwapIntervalEXT(dpy, drawable, interval);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %edi
callq 0x1a60
movl %eax, -0x14(%rbp)
cmpl $0x80000000, -0x14(%rbp) # imm = 0x80000000
jne 0x1a09
jmp 0x1a55
leaq 0x3770(%rip), %rdi      # 0x5180
callq 0x1130
movq 0x37a4(%rip), %rax      # 0x51c0
cmpq $0x0, %rax
jne 0x1a35
leaq 0x1694(%rip), %rdi      # 0x30bd
callq 0x1ae0
movq %rax, 0x378b(%rip)      # 0x51c0
leaq 0x3744(%rip), %rdi      # 0x5180
callq 0x10e0
movq 0x3778(%rip), %rax      # 0x51c0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq *%rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/derhass[P]glx_hook/glx_hook.c
// Function: GH_swap_interval
static int GH_swap_interval(int interval)
{
	static pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;
	static volatile GH_config cfg={GH_SWAP_MODES_COUNT, GH_SWAP_TEAR_KEEP, {0,1}};

	pthread_mutex_lock(&mutex);
	if (cfg.swap_mode >= GH_SWAP_MODES_COUNT) {
		GH_swap_mode_from_str(&cfg, getenv("GH_SWAP_MODE"));
		GH_swap_tear_from_str(&cfg, getenv("GH_SWAP_TEAR"));
	}
	pthread_mutex_unlock(&mutex);
	return GH_swap_interval_base(&cfg, interval);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
leaq 0x377e(%rip), %rdi      # 0x51f0
callq 0x1130
movl 0x3657(%rip), %eax      # 0x50d4
cmpl $0x8, %eax
jb 0x1ab8
leaq 0x184b(%rip), %rdi      # 0x32d4
callq 0x1030
movq %rax, %rsi
leaq 0x363c(%rip), %rdi      # 0x50d4
callq 0x2290
leaq 0x183d(%rip), %rdi      # 0x32e1
callq 0x1030
movq %rax, %rsi
leaq 0x3621(%rip), %rdi      # 0x50d4
callq 0x2450
leaq 0x3731(%rip), %rdi      # 0x51f0
callq 0x10e0
movl -0x4(%rbp), %esi
leaq 0x3606(%rip), %rdi      # 0x50d4
callq 0x24e0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/derhass[P]glx_hook/glx_hook.c
// Function: GH_dlsym_gl
static void *GH_dlsym_gl(const char *name)
{
	static void *libgl_handle=NULL;
	static int try_load_libgl=1;

	void *ptr=GH_dlsym(RTLD_NEXT, name);
	if (!ptr) {
		if (try_load_libgl && !libgl_handle) {
			const char *libname=get_envs("GH_LIBGL_FILE", "libGL.so");
			if (libname[0]) {
				GH_verbose(GH_MSG_DEBUG, "trying to load libGL manually: '%s'\n", libname);
				libgl_handle=dlopen(libname, RTLD_GLOBAL | RTLD_LAZY);
				if (!libgl_handle) {
					GH_verbose(GH_MSG_WARNING, "failed to load '%s' manually\n", libname);
					/* give up on loading libGL */
					try_load_libgl=0;
				}
			} else {
				try_load_libgl=0;
			}
		}
		if (libgl_handle) {
			GH_verbose(GH_MSG_DEBUG, "trying to find '%s' in manually loaded libGL\n", name);
			ptr=GH_dlsym(libgl_handle, name);
		}
	}
	return ptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq 0x36b5(%rip), %rax      # 0x51a8
movq -0x8(%rbp), %rsi
movq $-0x1, %rdi
callq *%rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1bea
cmpl $0x0, 0x365a(%rip)      # 0x5170
je 0x1baf
cmpq $0x0, 0x36f4(%rip)      # 0x5218
jne 0x1baf
leaq 0x1872(%rip), %rdi      # 0x33a3
leaq 0x1879(%rip), %rsi      # 0x33b1
callq 0x2700
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
je 0x1ba3
movq -0x18(%rbp), %rdx
movl $0x4, %edi
leaq 0x1860(%rip), %rsi      # 0x33ba
movb $0x0, %al
callq 0x16c0
movq -0x18(%rbp), %rdi
movl $0x101, %esi            # imm = 0x101
callq 0x10b0
movq %rax, 0x36a2(%rip)      # 0x5218
cmpq $0x0, 0x369a(%rip)      # 0x5218
jne 0x1ba1
movq -0x18(%rbp), %rdx
movl $0x2, %edi
leaq 0x184f(%rip), %rsi      # 0x33df
movb $0x0, %al
callq 0x16c0
movl $0x0, 0x35cf(%rip)      # 0x5170
jmp 0x1bad
movl $0x0, 0x35c3(%rip)      # 0x5170
jmp 0x1baf
cmpq $0x0, 0x3661(%rip)      # 0x5218
je 0x1be8
movq -0x8(%rbp), %rdx
movl $0x4, %edi
leaq 0x1834(%rip), %rsi      # 0x33fd
movb $0x0, %al
callq 0x16c0
movq 0x35d1(%rip), %rax      # 0x51a8
movq 0x363a(%rip), %rdi      # 0x5218
movq -0x8(%rbp), %rsi
callq *%rax
movq %rax, -0x10(%rbp)
jmp 0x1bea
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/derhass[P]glx_hook/glx_hook.c
// Function: glXSwapIntervalSGI
extern int glXSwapIntervalSGI(int interval)
{
	interval=GH_swap_interval(interval);
	if (interval == GH_SWAP_DONT_SET) {
		/* ignore the call */
		return 0; /* success */
	}
	GH_GET_PTR_GL(glXSwapIntervalSGI);
	return GH_glXSwapIntervalSGI(interval);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %edi
callq 0x1a60
movl %eax, -0x8(%rbp)
cmpl $0x80000000, -0x8(%rbp) # imm = 0x80000000
jne 0x1c28
movl $0x0, -0x4(%rbp)
jmp 0x1c6f
leaq 0x3551(%rip), %rdi      # 0x5180
callq 0x1130
movq 0x358d(%rip), %rax      # 0x51c8
cmpq $0x0, %rax
jne 0x1c54
leaq 0x1488(%rip), %rdi      # 0x30d0
callq 0x1ae0
movq %rax, 0x3574(%rip)      # 0x51c8
leaq 0x3525(%rip), %rdi      # 0x5180
callq 0x10e0
movq 0x3561(%rip), %rax      # 0x51c8
movl -0x8(%rbp), %edi
callq *%rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/derhass[P]glx_hook/glx_hook.c
// Function: glXSwapIntervalMESA
extern int glXSwapIntervalMESA(unsigned int interval)
{
	int signed_interval;
	if (interval > (unsigned)INT_MAX) {
		signed_interval=INT_MAX;
	} else {
		signed_interval=(int)interval;
	}
	signed_interval=GH_swap_interval(signed_interval);
	if (signed_interval == GH_SWAP_DONT_SET) {
		/* ignore the call */
		return 0; /* success */
	}
	if (signed_interval < 0) {
		GH_verbose(GH_MSG_WARNING,"glXSwapIntervalMESA does not support negative swap intervals\n");
		interval=(unsigned)(-signed_interval);
	} else {
		interval=(unsigned)signed_interval;
	}
	GH_GET_PTR_GL(glXSwapIntervalMESA);
	return GH_glXSwapIntervalMESA(interval);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
cmpl $0x7fffffff, -0x8(%rbp) # imm = 0x7FFFFFFF
jbe 0x1c9d
movl $0x7fffffff, -0xc(%rbp) # imm = 0x7FFFFFFF
jmp 0x1ca3
movl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %edi
callq 0x1a60
movl %eax, -0xc(%rbp)
cmpl $0x80000000, -0xc(%rbp) # imm = 0x80000000
jne 0x1cc0
movl $0x0, -0x4(%rbp)
jmp 0x1d30
cmpl $0x0, -0xc(%rbp)
jge 0x1ce3
movl $0x2, %edi
leaq 0x1411(%rip), %rsi      # 0x30e3
movb $0x0, %al
callq 0x16c0
xorl %eax, %eax
subl -0xc(%rbp), %eax
movl %eax, -0x8(%rbp)
jmp 0x1ce9
movl -0xc(%rbp), %eax
movl %eax, -0x8(%rbp)
leaq 0x3490(%rip), %rdi      # 0x5180
callq 0x1130
movq 0x34d4(%rip), %rax      # 0x51d0
cmpq $0x0, %rax
jne 0x1d15
leaq 0x1418(%rip), %rdi      # 0x3121
callq 0x1ae0
movq %rax, 0x34bb(%rip)      # 0x51d0
leaq 0x3464(%rip), %rdi      # 0x5180
callq 0x10e0
movq 0x34a8(%rip), %rax      # 0x51d0
movl -0x8(%rbp), %edi
callq *%rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/derhass[P]glx_hook/glx_hook.c
// Function: get_envi
static int
get_envi(const char *name, int def)
{
	const char *s=getenv(name);
	int i;

	if (s) {
		i=(int)strtol(s,NULL,0);
	} else {
		i=def;
	}
	return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1030
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1f47
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x10d0
movl %eax, -0x1c(%rbp)
jmp 0x1f4d
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/derhass[P]glx_hook/glx_hook.c
// Function: buf_printf
static size_t
buf_printf(char *buf, size_t pos, size_t size, const char *fmt, ...)
{
	va_list args;
	size_t left=size-pos;
	int r;

	va_start(args, fmt);
	r=vsnprintf(buf+pos, left, fmt, args);
	va_end(args);

	if (r > 0) {
		size_t written=(size_t)r;
		pos += (written >= left)?left:written;
	}
	return pos;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
testb %al, %al
je 0x21d1
movaps %xmm0, -0xe0(%rbp)
movaps %xmm1, -0xd0(%rbp)
movaps %xmm2, -0xc0(%rbp)
movaps %xmm3, -0xb0(%rbp)
movaps %xmm4, -0xa0(%rbp)
movaps %xmm5, -0x90(%rbp)
movaps %xmm6, -0x80(%rbp)
movaps %xmm7, -0x70(%rbp)
movq %r9, -0xe8(%rbp)
movq %r8, -0xf0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
subq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rax
leaq -0x110(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x20, (%rax)
movq -0x8(%rbp), %rdi
addq -0x10(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x40(%rbp), %rcx
callq 0x1050
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rax
cmpl $0x0, -0x4c(%rbp)
jle 0x227e
movslq -0x4c(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
cmpq -0x48(%rbp), %rax
jb 0x2264
movq -0x48(%rbp), %rax
movq %rax, -0x118(%rbp)
jmp 0x226f
movq -0x58(%rbp), %rax
movq %rax, -0x118(%rbp)
movq -0x118(%rbp), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/derhass[P]glx_hook/glx_hook.c
// Function: GH_swap_tear_from_str
static void GH_swap_tear_from_str(GH_config volatile *cfg, const char *str)
{
	static const char *mode_str[GH_SWAP_TEAR_COUNT+1]={
		"raw",
		"keep",
		"disable",
		"enable",
		"invert",

		NULL
	};

	int idx;

	cfg->swap_tear=GH_SWAP_TEAR_KEEP;
	
	if (str == NULL)
		return;

	for (idx=0; mode_str[idx]; idx++) {
		if (!strcmp(str, mode_str[idx])) {
			break;
		}
	}

	if (idx >= 0 && idx<(int)GH_SWAP_MODES_COUNT) {
		cfg->swap_tear=(GH_swap_mode)idx;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl $0x1, 0x4(%rax)
cmpq $0x0, -0x10(%rbp)
jne 0x2474
jmp 0x24cf
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rcx
leaq 0x2cba(%rip), %rax      # 0x5140
cmpq $0x0, (%rax,%rcx,8)
je 0x24b9
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rcx
leaq 0x2ca4(%rip), %rax      # 0x5140
movq (%rax,%rcx,8), %rsi
callq 0x10a0
cmpl $0x0, %eax
jne 0x24ac
jmp 0x24b9
jmp 0x24ae
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x247b
cmpl $0x0, -0x14(%rbp)
jl 0x24cf
cmpl $0x8, -0x14(%rbp)
jge 0x24cf
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/derhass[P]glx_hook/glx_hook.c
// Function: GH_swap_interval_base
static int GH_swap_interval_base(const volatile GH_config *cfg, int interval)
{
	int sign_interval;
	int abs_interval;
	int new_interval;

	if (cfg->swap_tear == GH_SWAP_TEAR_RAW) {
		sign_interval=0;
		abs_interval=interval; /* moght be negative */
	} else 	if (interval < 0) {
		sign_interval=-1;
		abs_interval=-interval;
	} else {
		sign_interval=1;
		abs_interval=interval;
	}

	abs_interval=GH_swap_interval_absolute(cfg, abs_interval);
	if (abs_interval == GH_SWAP_DONT_SET) {
		GH_verbose(GH_MSG_INFO,"swap interval %d setting ignored\n",
					interval);
		return GH_SWAP_DONT_SET;
	}

	/* set sign based on GH_SWAP_TEAR mode */
	switch (cfg->swap_tear) {
		case GH_SWAP_TEAR_KEEP:
			new_interval=abs_interval * sign_interval;
			break;
		case GH_SWAP_TEAR_DISABLE:
			new_interval=abs_interval;
			break;
		case GH_SWAP_TEAR_ENABLE:
			new_interval=-abs_interval;
			break;
		case GH_SWAP_TEAR_INVERT:
			new_interval=abs_interval * (-sign_interval);
			break;
		default:
			new_interval=abs_interval;	
	}

	GH_verbose(GH_MSG_INFO,"swap interval %d -> %d\n", interval, new_interval);
	return new_interval;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
cmpl $0x0, %eax
jne 0x250a
movl $0x0, -0x18(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x2530
cmpl $0x0, -0x14(%rbp)
jge 0x2521
movl $0xffffffff, -0x18(%rbp) # imm = 0xFFFFFFFF
xorl %eax, %eax
subl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x252e
movl $0x1, -0x18(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x2530
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x25f0
movl %eax, -0x1c(%rbp)
cmpl $0x80000000, -0x1c(%rbp) # imm = 0x80000000
jne 0x2567
movl -0x14(%rbp), %edx
movl $0x3, %edi
leaq 0xdea(%rip), %rsi       # 0x3341
movb $0x0, %al
callq 0x16c0
movl $0x80000000, -0x4(%rbp) # imm = 0x80000000
jmp 0x25e2
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0x3, %eax
ja 0x25bd
movq -0x28(%rbp), %rax
leaq 0xa7a(%rip), %rcx       # 0x3000
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl -0x1c(%rbp), %eax
imull -0x18(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x25c3
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x25c3
xorl %eax, %eax
subl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x25c3
movl -0x1c(%rbp), %eax
xorl %ecx, %ecx
subl -0x18(%rbp), %ecx
imull %ecx, %eax
movl %eax, -0x20(%rbp)
jmp 0x25c3
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x14(%rbp), %edx
movl -0x20(%rbp), %ecx
movl $0x3, %edi
leaq 0xd8e(%rip), %rsi       # 0x3363
movb $0x0, %al
callq 0x16c0
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/derhass[P]glx_hook/glx_hook.c
// Function: GH_swap_interval_absolute
static int GH_swap_interval_absolute(const volatile GH_config *cfg, int interval)
{
	int new_interval;

	switch(cfg->swap_mode) {
		case GH_SWAP_MODE_IGNORE:
			new_interval=GH_SWAP_DONT_SET;
			break;
		case GH_SWAP_MODE_CLAMP:
			new_interval=interval;
			if (new_interval < cfg->swap_param[0])
				new_interval=cfg->swap_param[0];
			if (new_interval > cfg->swap_param[1])
				interval=cfg->swap_param[1];
			break;
		case GH_SWAP_MODE_FORCE:
			new_interval=cfg->swap_param[0];
			break;
		case GH_SWAP_MODE_DISABLE:
			new_interval=0;
			break;
		case GH_SWAP_MODE_ENABLE:
			new_interval=interval;
			if (new_interval < 1)
				new_interval=1;
			break;
		case GH_SWAP_MODE_MIN:
			new_interval=interval;
			if (new_interval < cfg->swap_param[0])
				new_interval=cfg->swap_param[0];
			break;
		case GH_SWAP_MODE_MAX:
			new_interval=interval;
			if (new_interval > cfg->swap_param[0])
				new_interval=cfg->swap_param[0];
			break;
		default:
			new_interval=interval;
	}

	GH_verbose(GH_MSG_DEBUG,"swap interval, absolute value %d -> %d\n", interval, new_interval);
	return new_interval;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x6, %eax
ja 0x26d8
movq -0x18(%rbp), %rax
leaq 0x9ef(%rip), %rcx       # 0x3010
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x80000000, -0x10(%rbp) # imm = 0x80000000
jmp 0x26de
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
movl 0x8(%rcx), %ecx
cmpl %ecx, %eax
jge 0x2654
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
movl 0xc(%rcx), %ecx
cmpl %ecx, %eax
jle 0x266c
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0xc(%rbp)
jmp 0x26de
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x10(%rbp)
jmp 0x26de
movl $0x0, -0x10(%rbp)
jmp 0x26de
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
cmpl $0x1, -0x10(%rbp)
jge 0x2696
movl $0x1, -0x10(%rbp)
jmp 0x26de
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
movl 0x8(%rcx), %ecx
cmpl %ecx, %eax
jge 0x26b6
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x10(%rbp)
jmp 0x26de
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
movl 0x8(%rcx), %ecx
cmpl %ecx, %eax
jle 0x26d6
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x10(%rbp)
jmp 0x26de
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %edx
movl -0x10(%rbp), %ecx
movl $0x4, %edi
leaq 0xc8b(%rip), %rsi       # 0x337b
movb $0x0, %al
callq 0x16c0
movl -0x10(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/winton[P]redis_parse/hiredis/net.c
// Function: redisCheckSocketError
int redisCheckSocketError(redisContext *c, int fd) {
    int err = 0;
    socklen_t errlen = sizeof(err);

    if (getsockopt(fd, SOL_SOCKET, SO_ERROR, &err, &errlen) == -1) {
        __redisSetErrorFromErrno(c,REDIS_ERR_IO,"getsockopt(SO_ERROR)");
        close(fd);
        return REDIS_ERR;
    }

    if (err) {
        errno = err;
        __redisSetErrorFromErrno(c,REDIS_ERR_IO,NULL);
        close(fd);
        return REDIS_ERR;
    }

    return REDIS_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x4, -0x1c(%rbp)
movl -0x14(%rbp), %edi
movl $0x1, %esi
movl $0x4, %edx
leaq -0x18(%rbp), %rcx
leaq -0x1c(%rbp), %r8
callq 0x2240
cmpl $-0x1, %eax
jne 0x2602
movq -0x10(%rbp), %rdi
movl $0x1, %esi
leaq 0x7a14(%rip), %rdx      # 0xa000
callq 0x2650
movl -0x14(%rbp), %edi
callq 0x21e0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2642
cmpl $0x0, -0x18(%rbp)
je 0x263b
movl -0x18(%rbp), %eax
movl %eax, -0x20(%rbp)
callq 0x2070
movl -0x20(%rbp), %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x2650
movl -0x14(%rbp), %edi
callq 0x21e0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2642
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/winton[P]redis_parse/hiredis/net.c
// Function: redisContextSetTimeout
int redisContextSetTimeout(redisContext *c, struct timeval tv) {
    if (setsockopt(c->fd,SOL_SOCKET,SO_RCVTIMEO,&tv,sizeof(tv)) == -1) {
        __redisSetErrorFromErrno(c,REDIS_ERR_IO,"setsockopt(SO_RCVTIMEO)");
        return REDIS_ERR;
    }
    if (setsockopt(c->fd,SOL_SOCKET,SO_SNDTIMEO,&tv,sizeof(tv)) == -1) {
        __redisSetErrorFromErrno(c,REDIS_ERR_IO,"setsockopt(SO_SNDTIMEO)");
        return REDIS_ERR;
    }
    return REDIS_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rsi, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x84(%rax), %edi
movl $0x1, %esi
movl $0x14, %edx
leaq -0x18(%rbp), %rcx
movl $0x10, %r8d
callq 0x20d0
cmpl $-0x1, %eax
jne 0x274a
movq -0x20(%rbp), %rdi
movl $0x1, %esi
leaq 0x78d9(%rip), %rdx      # 0xa015
callq 0x2650
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2797
movq -0x20(%rbp), %rax
movl 0x84(%rax), %edi
movl $0x1, %esi
movl $0x15, %edx
leaq -0x18(%rbp), %rcx
movl $0x10, %r8d
callq 0x20d0
cmpl $-0x1, %eax
jne 0x2790
movq -0x20(%rbp), %rdi
movl $0x1, %esi
leaq 0x78ab(%rip), %rdx      # 0xa02d
callq 0x2650
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2797
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/winton[P]redis_parse/hiredis/net.c
// Function: redisSetBlocking
static int redisSetBlocking(redisContext *c, int fd, int blocking) {
    int flags;

    /* Set the socket nonblocking.
     * Note that fcntl(2) for F_GETFL and F_SETFL can't be
     * interrupted by a signal. */
    if ((flags = fcntl(fd, F_GETFL)) == -1) {
        __redisSetErrorFromErrno(c,REDIS_ERR_IO,"fcntl(F_GETFL)");
        close(fd);
        return REDIS_ERR;
    }

    if (blocking)
        flags &= ~O_NONBLOCK;
    else
        flags |= O_NONBLOCK;

    if (fcntl(fd, F_SETFL, flags) == -1) {
        __redisSetErrorFromErrno(c,REDIS_ERR_IO,"fcntl(F_SETFL)");
        close(fd);
        return REDIS_ERR;
    }
    return REDIS_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl -0x14(%rbp), %edi
movl $0x3, %esi
movb $0x0, %al
callq 0x2100
movl %eax, -0x1c(%rbp)
cmpl $-0x1, %eax
jne 0x2a4f
movq -0x10(%rbp), %rdi
movl $0x1, %esi
leaq 0x762c(%rip), %rdx      # 0xa065
callq 0x2650
movl -0x14(%rbp), %edi
callq 0x21e0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2ab1
cmpl $0x0, -0x18(%rbp)
je 0x2a62
movl -0x1c(%rbp), %eax
andl $0xfffff7ff, %eax       # imm = 0xFFFFF7FF
movl %eax, -0x1c(%rbp)
jmp 0x2a6d
movl -0x1c(%rbp), %eax
orl $0x800, %eax            # imm = 0x800
movl %eax, -0x1c(%rbp)
movl -0x14(%rbp), %edi
movl -0x1c(%rbp), %edx
movl $0x4, %esi
movb $0x0, %al
callq 0x2100
cmpl $-0x1, %eax
jne 0x2aaa
movq -0x10(%rbp), %rdi
movl $0x1, %esi
leaq 0x75e0(%rip), %rdx      # 0xa074
callq 0x2650
movl -0x14(%rbp), %edi
callq 0x21e0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2ab1
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/winton[P]redis_parse/hiredis/net.c
// Function: redisSetTcpNoDelay
static int redisSetTcpNoDelay(redisContext *c, int fd) {
    int yes = 1;
    if (setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &yes, sizeof(yes)) == -1) {
        __redisSetErrorFromErrno(c,REDIS_ERR_IO,"setsockopt(TCP_NODELAY)");
        close(fd);
        return REDIS_ERR;
    }
    return REDIS_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x1, -0x18(%rbp)
movl -0x14(%rbp), %edi
movl $0x6, %esi
movl $0x1, %edx
leaq -0x18(%rbp), %rcx
movl $0x4, %r8d
callq 0x20d0
cmpl $-0x1, %eax
jne 0x2cfd
movq -0x10(%rbp), %rdi
movl $0x1, %esi
leaq 0x73a6(%rip), %rdx      # 0xa08d
callq 0x2650
movl -0x14(%rbp), %edi
callq 0x21e0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2d04
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/winton[P]redis_parse/hiredis/net.c
// Function: redisContextConnectUnix
int redisContextConnectUnix(redisContext *c, const char *path, struct timeval *timeout) {
    int s;
    int blocking = (c->flags & REDIS_BLOCK);
    struct sockaddr_un sa;

    if ((s = redisCreateSocket(c,AF_LOCAL)) < 0)
        return REDIS_ERR;
    if (redisSetBlocking(c,s,0) != REDIS_OK)
        return REDIS_ERR;

    sa.sun_family = AF_LOCAL;
    strncpy(sa.sun_path,path,sizeof(sa.sun_path)-1);
    if (connect(s, (struct sockaddr*)&sa, sizeof(sa)) == -1) {
        if (errno == EINPROGRESS && !blocking) {
            /* This is ok. */
        } else {
            if (redisContextWaitReady(c,s,timeout) != REDIS_OK)
                return REDIS_ERR;
        }
    }

    /* Reset socket to be blocking after connect(2). */
    if (blocking && redisSetBlocking(c,s,1) != REDIS_OK)
        return REDIS_ERR;

    c->fd = s;
    c->flags |= REDIS_CONNECTED;
    return REDIS_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x88(%rax), %eax
andl $0x1, %eax
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x2e40
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
jge 0x2d59
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2e33
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %esi
xorl %edx, %edx
callq 0x2a00
cmpl $0x0, %eax
je 0x2d78
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2e33
movw $0x1, -0x96(%rbp)
leaq -0x96(%rbp), %rdi
addq $0x2, %rdi
movq -0x18(%rbp), %rsi
movl $0x6b, %edx
callq 0x2080
movl -0x24(%rbp), %edi
leaq -0x96(%rbp), %rsi
movl $0x6e, %edx
callq 0x23e0
cmpl $-0x1, %eax
jne 0x2de7
callq 0x2070
cmpl $0x73, (%rax)
jne 0x2dc5
cmpl $0x0, -0x28(%rbp)
jne 0x2dc5
jmp 0x2de5
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %esi
movq -0x20(%rbp), %rdx
callq 0x2ac0
cmpl $0x0, %eax
je 0x2de3
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2e33
jmp 0x2de5
jmp 0x2de7
cmpl $0x0, -0x28(%rbp)
je 0x2e0c
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %esi
movl $0x1, %edx
callq 0x2a00
cmpl $0x0, %eax
je 0x2e0c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2e33
movl -0x24(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x84(%rax)
movq -0x10(%rbp), %rax
movl 0x88(%rax), %ecx
orl $0x2, %ecx
movl %ecx, 0x88(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/winton[P]redis_parse/hiredis/net.c
// Function: redisCreateSocket
static int redisCreateSocket(redisContext *c, int type) {
    int s;
    if ((s = socket(type, SOCK_STREAM, 0)) == -1) {
        __redisSetErrorFromErrno(c,REDIS_ERR_IO,NULL);
        return REDIS_ERR;
    }
    if (type == AF_INET) {
        if (redisSetReuseAddr(c,s) == REDIS_ERR) {
            return REDIS_ERR;
        }
    }
    return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x2470
movl %eax, -0x18(%rbp)
cmpl $-0x1, %eax
jne 0x2e81
movq -0x10(%rbp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x2650
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2ea9
cmpl $0x2, -0x14(%rbp)
jne 0x2ea3
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x2ec0
cmpl $-0x1, %eax
jne 0x2ea1
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2ea9
jmp 0x2ea3
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/winton[P]redis_parse/hiredis/net.c
// Function: redisSetReuseAddr
static int redisSetReuseAddr(redisContext *c, int fd) {
    int on = 1;
    if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) == -1) {
        __redisSetErrorFromErrno(c,REDIS_ERR_IO,NULL);
        close(fd);
        return REDIS_ERR;
    }
    return REDIS_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x1, -0x18(%rbp)
movl -0x14(%rbp), %edi
movl $0x1, %esi
movl $0x2, %edx
leaq -0x18(%rbp), %rcx
movl $0x4, %r8d
callq 0x20d0
cmpl $-0x1, %eax
jne 0x2f1a
movq -0x10(%rbp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x2650
movl -0x14(%rbp), %edi
callq 0x21e0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2f21
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/winton[P]redis_parse/hiredis/hiredis.c
// Function: redisConnect
redisContext *redisConnect(const char *ip, int port) {
    redisContext *c = redisContextInit();
    c->flags |= REDIS_BLOCK;
    redisContextConnectTcp(c,ip,port,NULL);
    return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
callq 0x47a0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x88(%rax), %ecx
orl $0x1, %ecx
movl %ecx, 0x88(%rax)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl -0xc(%rbp), %edx
xorl %eax, %eax
movl %eax, %ecx
callq 0x2380
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/winton[P]redis_parse/hiredis/hiredis.c
// Function: redisConnectWithTimeout
redisContext *redisConnectWithTimeout(const char *ip, int port, struct timeval tv) {
    redisContext *c = redisContextInit();
    c->flags |= REDIS_BLOCK;
    redisContextConnectTcp(c,ip,port,&tv);
    return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdx, -0x10(%rbp)
movq %rcx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
callq 0x47a0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl 0x88(%rax), %ecx
orl $0x1, %ecx
movl %ecx, 0x88(%rax)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
leaq -0x10(%rbp), %rcx
callq 0x2380
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/winton[P]redis_parse/hiredis/hiredis.c
// Function: redisConnectNonBlock
redisContext *redisConnectNonBlock(const char *ip, int port) {
    redisContext *c = redisContextInit();
    c->flags &= ~REDIS_BLOCK;
    redisContextConnectTcp(c,ip,port,NULL);
    return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
callq 0x47a0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x88(%rax), %ecx
andl $-0x2, %ecx
movl %ecx, 0x88(%rax)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl -0xc(%rbp), %edx
xorl %eax, %eax
movl %eax, %ecx
callq 0x2380
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/winton[P]redis_parse/hiredis/hiredis.c
// Function: redisConnectUnix
redisContext *redisConnectUnix(const char *path) {
    redisContext *c = redisContextInit();
    c->flags |= REDIS_BLOCK;
    redisContextConnectUnix(c,path,NULL);
    return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0x47a0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x88(%rax), %ecx
orl $0x1, %ecx
movl %ecx, 0x88(%rax)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x2280
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/winton[P]redis_parse/hiredis/hiredis.c
// Function: redisConnectUnixWithTimeout
redisContext *redisConnectUnixWithTimeout(const char *path, struct timeval tv) {
    redisContext *c = redisContextInit();
    c->flags |= REDIS_BLOCK;
    redisContextConnectUnix(c,path,&tv);
    return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
callq 0x47a0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x88(%rax), %ecx
orl $0x1, %ecx
movl %ecx, 0x88(%rax)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x10(%rbp), %rdx
callq 0x2280
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/winton[P]redis_parse/hiredis/hiredis.c
// Function: redisConnectUnixNonBlock
redisContext *redisConnectUnixNonBlock(const char *path) {
    redisContext *c = redisContextInit();
    c->flags &= ~REDIS_BLOCK;
    redisContextConnectUnix(c,path,NULL);
    return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0x47a0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x88(%rax), %ecx
andl $-0x2, %ecx
movl %ecx, 0x88(%rax)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x2280
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/winton[P]redis_parse/hiredis/hiredis.c
// Function: _redisAppendCommand
int __redisAppendCommand(redisContext *c, char *cmd, size_t len) {
    sds newbuf;

    newbuf = sdscatlen(c->obuf,cmd,len);
    if (newbuf == NULL) {
        __redisSetError(c,REDIS_ERR_OOM,"Out of memory");
        return REDIS_ERR;
    }

    c->obuf = newbuf;
    return REDIS_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x90(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x23a0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x4e65
movq -0x10(%rbp), %rdi
movl $0x5, %esi
leaq 0x545d(%rip), %rdx      # 0xa2b4
callq 0x2270
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4e7b
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x90(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/winton[P]redis_parse/hiredis/sds.c
// Function: sdsnewlen
sds sdsnewlen(const void *init, size_t initlen) {
    struct sdshdr *sh;

    sh = malloc(sizeof(struct sdshdr)+initlen+1);
#ifdef SDS_ABORT_ON_OOM
    if (sh == NULL) sdsOomAbort();
#else
    if (sh == NULL) return NULL;
#endif
    sh->len = initlen;
    sh->free = 0;
    if (initlen) {
        if (init) memcpy(sh->buf, init, initlen);
        else memset(sh->buf,0,initlen);
    }
    sh->buf[initlen] = '\0';
    return (char*)sh->buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
addq $0x1, %rdi
callq 0x2300
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x6436
movq $0x0, -0x8(%rbp)
jmp 0x64a0
movq -0x18(%rbp), %rax
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x4(%rax)
cmpq $0x0, -0x18(%rbp)
je 0x6487
cmpq $0x0, -0x10(%rbp)
je 0x6472
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x22b0
jmp 0x6485
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rdx
xorl %esi, %esi
callq 0x21d0
jmp 0x6487
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movb $0x0, 0x8(%rax,%rcx)
movq -0x20(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/winton[P]redis_parse/hiredis/sds.c
// Function: sdsupdatelen
void sdsupdatelen(sds s) {
    struct sdshdr *sh = (void*) (s-(sizeof(struct sdshdr)));
    int reallen = strlen(s);
    sh->free += (sh->len-reallen);
    sh->len = reallen;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $-0x8, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2130
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
subl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
addl 0x4(%rax), %ecx
movl %ecx, 0x4(%rax)
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/winton[P]redis_parse/hiredis/sds.c
// Function: sdsMakeRoomFor
static sds sdsMakeRoomFor(sds s, size_t addlen) {
    struct sdshdr *sh, *newsh;
    size_t free = sdsavail(s);
    size_t len, newlen;

    if (free >= addlen) return s;
    len = sdslen(s);
    sh = (void*) (s-(sizeof(struct sdshdr)));
    newlen = (len+addlen)*2;
    newsh = realloc(sh, sizeof(struct sdshdr)+newlen+1);
#ifdef SDS_ABORT_ON_OOM
    if (newsh == NULL) sdsOomAbort();
#else
    if (newsh == NULL) return NULL;
#endif

    newsh->free = newlen - len;
    return newsh->buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x63e0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
jb 0x66e1
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6750
movq -0x10(%rbp), %rdi
callq 0x63c0
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
addq $-0x8, %rax
movq %rax, -0x20(%rbp)
movq -0x38(%rbp), %rax
addq -0x18(%rbp), %rax
shlq %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
movq -0x40(%rbp), %rsi
addq $0x8, %rsi
addq $0x1, %rsi
callq 0x2340
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x6733
movq $0x0, -0x8(%rbp)
jmp 0x6750
movq -0x40(%rbp), %rax
subq -0x38(%rbp), %rax
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x28(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)