LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/CBaquero[P]random/Random.cc
// Function: RandomNorm_RedisCommand(RedisModuleCtx*, RedisModuleString**, int)
int RandomNorm_RedisCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {
  double mean=0.0, sd=1.0;
  if (argc > 3) return RedisModule_WrongArity(ctx);
  if (argc >= 2) /* Get mean */
  {
    if (RedisModule_StringToDouble(argv[1],&mean) != REDISMODULE_OK)
      return RedisModule_ReplyWithError(ctx,"ERR invalid mean");
  }
  if (argc == 3) /* get stddev */
  {
    if (RedisModule_StringToDouble(argv[2],&sd) != REDISMODULE_OK)
      return RedisModule_ReplyWithError(ctx,"ERR invalid standard deviation");
  }

  std::normal_distribution<double> rnorm(mean,sd);
  RedisModule_ReplyWithDouble(ctx, rnorm(gen));
  return REDISMODULE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq $0x0, -0x30(%rbp)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, -0x28(%rbp)
cmpl $0x4, %edx
jl 0x44c1
movq 0x5a90(%rip), %rax      # 0x9f40
movq %rbx, %rdi
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *(%rax)
movl %edx, %r15d
movsd 0x2b34(%rip), %xmm1     # 0x7000
cmpl $0x2, %edx
jl 0x4533
movq %rsi, %r14
movq 0x5a05(%rip), %r12      # 0x9ee0
movq 0x8(%rsi), %rdi
leaq -0x30(%rbp), %rsi
callq *(%r12)
testl %eax, %eax
je 0x4500
movq 0x587e(%rip), %rax      # 0x9d70
leaq 0x2b85(%rip), %rsi      # 0x707e
movq %rbx, %rdi
callq *(%rax)
jmp 0x4572
cmpl $0x3, %r15d
movsd 0x2af4(%rip), %xmm1     # 0x7000
jne 0x4533
movq 0x10(%r14), %rdi
leaq -0x28(%rbp), %rsi
callq *(%r12)
testl %eax, %eax
je 0x452e
movq 0x584b(%rip), %rax      # 0x9d70
leaq 0x2b63(%rip), %rsi      # 0x708f
jmp 0x44f9
movsd -0x28(%rbp), %xmm1
movsd -0x30(%rbp), %xmm0
leaq -0x50(%rbp), %rdi
movsd %xmm0, (%rdi)
movsd %xmm1, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
movq 0x56b8(%rip), %rax      # 0x9c10
movq (%rax), %r14
movq 0x5a36(%rip), %rsi      # 0x9f98
movq %rdi, %rdx
callq 0x41b0
movq %rbx, %rdi
callq *%r14
xorl %eax, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/CBaquero[P]random/Random.cc
// Function: RandomExp_RedisCommand(RedisModuleCtx*, RedisModuleString**, int)
int RandomExp_RedisCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {
  double lambda;
  if (argc > 2) return RedisModule_WrongArity(ctx);
  if (argc == 2)
  {
    if (RedisModule_StringToDouble(argv[1],&lambda) != REDISMODULE_OK)
      return RedisModule_ReplyWithError(ctx,"ERR invalid lambda");
  }
  else // If no parameter, use default lambda of 1
    lambda=1.0;
  std::exponential_distribution<double> rexp(lambda);
  RedisModule_ReplyWithDouble(ctx, rexp(gen));
  return REDISMODULE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpl $0x3, %edx
jl 0x49a1
movq 0x55ac(%rip), %rax      # 0x9f40
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmpq *(%rax)
cmpl $0x2, %edx
jne 0x49d0
movq 0x5533(%rip), %rax      # 0x9ee0
movq 0x8(%rsi), %rdi
leaq -0x20(%rbp), %rsi
callq *(%rax)
testl %eax, %eax
je 0x49e8
movq 0x53ae(%rip), %rax      # 0x9d70
leaq 0x2761(%rip), %rsi      # 0x712a
movq %rbx, %rdi
callq *(%rax)
jmp 0x4a32
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, -0x20(%rbp)
movsd 0x261a(%rip), %xmm0     # 0x7000
jmp 0x49ed
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movq 0x5217(%rip), %rax      # 0x9c10
movq (%rax), %r14
movq 0x5595(%rip), %rdi      # 0x9f98
callq 0x4180
movsd 0x25f0(%rip), %xmm1     # 0x7000
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
callq 0x40e0
xorpd 0x260b(%rip), %xmm0     # 0x7030
divsd -0x18(%rbp), %xmm0
movq %rbx, %rdi
callq *%r14
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/glk[P]critbit/critbit.c
// Function: critbit_buf_remove
static __inline struct critbit_key *
critbit_remove_impl(struct critbit_tree *t, const void *key, size_t keylen,
    critbit_keycmp_t *keycmp, critbit_keybuf_t *keybuf)
{
	const uint8_t *ubytes = key;
	struct critbit_ref *p = t->ct_root;
	struct critbit_node *q = NULL;
	struct critbit_ref **wherep = &t->ct_root;
	struct critbit_ref **whereq = NULL;
	int direction = 0;

	if (p == NULL)
		return (NULL);

	while (critbit_ref_is_internal(p)) {
		whereq = wherep;
		q = critbit_ref_get_node(p);
		uint8_t c = 0;
		if (q->byte < keylen)
			c = ubytes[q->byte];
		direction = (1 + (q->otherbits | c)) >> 8;
		wherep = q->child + direction;
		p = *wherep;
	}

	if (keycmp(keybuf(critbit_ref_get_key(p)), ubytes, keylen) != 0)
		return (NULL);

	/* Remove p */

	if (whereq == NULL) {
		t->ct_root = NULL;
		return (critbit_ref_get_key(p));
	}

	*whereq = q->child[1 - direction];
	critbit_node_free(t, q);

	return (critbit_ref_get_key(p));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq (%rdi), %rbx
testq %rbx, %rbx
je 0xd3b4
movq %rdi, %r14
movq 0x8(%rdi), %rdx
testb $0x1, %bl
jne 0xd36b
movq %rbx, %rdi
callq 0xd0b0
testl %eax, %eax
jne 0xd3b4
movq $0x0, (%r14)
jmp 0xd3b6
movq %r14, %rax
movq %rax, %r12
movl 0xf(%rbx), %ecx
xorl %eax, %eax
cmpq %rcx, %rdx
jbe 0xd37f
movzbl (%rsi,%rcx), %eax
leaq -0x1(%rbx), %r15
movzbl 0x13(%rbx), %r13d
orl %eax, %r13d
incl %r13d
shrl $0x8, %r13d
leal (,%r13,8), %ecx
leaq (%r15,%rcx), %rax
movq -0x1(%rbx,%rcx), %rbx
testb $0x1, %bl
jne 0xd36e
movq %rbx, %rdi
callq 0xd0b0
testl %eax, %eax
je 0xd3c3
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
xorl $0x1, %r13d
movq (%r15,%r13,8), %rax
movq %rax, (%r12)
movq %r14, %rdi
movq %r15, %rsi
callq *0x18(%r14)
jmp 0xd3b6
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x3ea7(%rip), %rdi      # 0x50c8
callq 0x1120
cmpq $0x0, 0x3ec2(%rip)      # 0x50f0
je 0x126a
leaq 0x3e91(%rip), %rdi      # 0x50c8
callq 0x10c0
leaq 0x45b(%rip), %rsi       # 0x169e
leaq 0x1dd2(%rip), %rdx      # 0x301c
movq %rbx, %rdi
callq 0x1440
testq %rax, %rax
je 0x1362
movq %rax, %r15
leaq 0x1dd3(%rip), %r9       # 0x3038
jmp 0x137b
leaq 0x1fba(%rip), %rsi      # 0x322b
movl $0x4, %edi
xorl %eax, %eax
callq 0x16d6
leaq 0x1d98(%rip), %rsi      # 0x301c
leaq 0x1fb7(%rip), %rdx      # 0x3242
movq $-0x1, %rdi
callq 0x1110
movq %rax, 0x3e52(%rip)      # 0x50f0
movq 0x3e4b(%rip), %r12      # 0x50f0
cmpq $0x0, 0x3e43(%rip)      # 0x50f0
je 0x13a6
movq 0x3e36(%rip), %rcx      # 0x50f0
leaq 0x1e6b(%rip), %rsi      # 0x312c
leaq 0x1d54(%rip), %rdx      # 0x301c
movq 0x3cf9(%rip), %r8       # 0x4fc8
movl $0x5, %edi
xorl %eax, %eax
callq 0x16d6
cmpq $0x0, 0x3e0d(%rip)      # 0x50f0
je 0x13af
movq 0x3e00(%rip), %rax      # 0x50f0
leaq 0x1d25(%rip), %rsi      # 0x301c
movq $-0x1, %rdi
callq *%rax
cmpq 0x3de9(%rip), %rax      # 0x50f0
je 0x13ed
movq %rax, %r15
testq %rax, %rax
je 0x13d3
leaq 0x1e2d(%rip), %rdi      # 0x314d
movl $0x1, %esi
callq 0x2003
movq 0x3dbf(%rip), %rcx      # 0x50f0
testl %eax, %eax
je 0x1421
leaq 0x1e28(%rip), %rsi      # 0x3168
leaq 0x1cd5(%rip), %rdx      # 0x301c
movl $0x5, %edi
movq %r15, %r8
xorl %eax, %eax
callq 0x16d6
movq %r15, 0x3d93(%rip)      # 0x50f0
jmp 0x13ed
movq 0x3d87(%rip), %rax      # 0x50f0
movq %r14, %rdi
movq %rbx, %rsi
callq *%rax
movq %rax, %r15
leaq 0x2053(%rip), %r9       # 0x33ce
leaq 0x1ca0(%rip), %rsi      # 0x3022
movl $0x5, %edi
movq %r14, %rdx
movq %rbx, %rcx
movq %r15, %r8
xorl %eax, %eax
callq 0x16d6
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x1e5c(%rip), %rsi      # 0x3209
jmp 0x13da
leaq 0x1e98(%rip), %rsi      # 0x324e
leaq 0x1c5f(%rip), %rdx      # 0x301c
movl $0x2, %edi
xorl %eax, %eax
callq 0x16d6
cmpq $0x0, 0x3d1f(%rip)      # 0x50f0
je 0x13ed
leaq 0x1df5(%rip), %rsi      # 0x31cf
leaq 0x1c3b(%rip), %rdx      # 0x301c
movl $0x2, %edi
xorl %eax, %eax
callq 0x16d6
testq %r12, %r12
je 0x1230
cmpq $0x0, 0x3d22(%rip)      # 0x5120
jne 0x1230
leaq 0x1d1a(%rip), %rsi      # 0x3125
movq $-0x1, %rdi
callq *%r12
movq %rax, 0x3d04(%rip)      # 0x5120
jmp 0x1230
leaq 0x1d67(%rip), %rsi      # 0x318f
leaq 0x1bed(%rip), %rdx      # 0x301c
movl $0x2, %edi
movq %r15, %r8
xorl %eax, %eax
callq 0x16d6
jmp 0x13ed
// File: /workspace/github_c_makefile_star2_O3/derhass[P]glx_hook/glx_hook.c
// Function: glXGetProcAddress
GH_GLXGETPROCADDRESS_GENERIC(glXGetProcAddress)
GH_GLXGETPROCADDRESS_GENERIC(glXGetProcAddressARB)

#ifdef GH_CONTEXT_TRACKING

/* ---------- Context Creation ---------- */

extern GLXContext glXCreateContext(Display *dpy, XVisualInfo *vis, GLXContext shareList, Bool direct )
{
	GLXContext ctx;

	ctx = override_create_context(dpy, vis, NULL, shareList, direct, NULL);
	if (ctx == NULL) {
		GH_GET_PTR_GL(glXCreateContext);
		ctx=GH_glXCreateContext(dpy, vis, shareList, direct);
	}
	create_context(ctx);
	return ctx;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x3782(%rip), %rdi      # 0x50c8
callq 0x1120
cmpq $0x0, 0x37a5(%rip)      # 0x50f8
jne 0x199f
cmpq $0x0, 0x3793(%rip)      # 0x50f0
je 0x197b
movq 0x378a(%rip), %rax      # 0x50f0
leaq 0x16da(%rip), %rsi      # 0x3047
movq $-0x1, %rdi
callq *%rax
movq %rax, %r14
jmp 0x1998
leaq 0x18cc(%rip), %rsi      # 0x324e
leaq 0x16be(%rip), %rdx      # 0x3047
xorl %r14d, %r14d
movl $0x2, %edi
xorl %eax, %eax
callq 0x16d6
movq %r14, 0x3759(%rip)      # 0x50f8
leaq 0x3722(%rip), %rdi      # 0x50c8
callq 0x10c0
movq 0x3746(%rip), %rsi      # 0x50f8
leaq 0x168e(%rip), %rdx      # 0x3047
movq %rbx, %rdi
callq 0x1440
testq %rax, %rax
je 0x19d2
movq %rax, %r14
leaq 0x1668(%rip), %r8       # 0x3038
jmp 0x19e8
movq 0x371f(%rip), %rax      # 0x50f8
movq %rbx, %rdi
callq *%rax
movq %rax, %r14
leaq 0x19e6(%rip), %r8       # 0x33ce
leaq 0x166a(%rip), %rsi      # 0x3059
movl $0x5, %edi
movq %rbx, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x16d6
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl %edx, %edi
callq 0x1b46
movl %eax, %ebp
negl %eax
jno 0x1afc
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x35c5(%rip), %rdi      # 0x50c8
callq 0x1120
cmpq $0x0, 0x35f8(%rip)      # 0x5108
jne 0x1b25
leaq 0x1594(%rip), %rdi      # 0x30ad
callq 0x1e3e
movq %rax, 0x35e3(%rip)      # 0x5108
leaq 0x359c(%rip), %rdi      # 0x50c8
callq 0x10c0
movq 0x35d0(%rip), %rax      # 0x5108
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
popq %rbx
popq %r14
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x32a4(%rip), %rax      # 0x50f0
movq $-0x1, %rdi
movq %rbx, %rsi
callq *%rax
testq %rax, %rax
je 0x1e65
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x32f4(%rip), %rax      # 0x5160
testq %rax, %rax
setne %cl
orb 0x32f0(%rip), %cl       # 0x5168
testb $0x1, %cl
jne 0x1ef4
leaq 0x150f(%rip), %rdi      # 0x3393
callq 0x1030
testq %rax, %rax
leaq 0x150e(%rip), %r14      # 0x33a1
cmovneq %rax, %r14
cmpb $0x0, (%r14)
je 0x1eeb
leaq 0x1506(%rip), %rsi      # 0x33aa
movl $0x4, %edi
movq %r14, %rdx
xorl %eax, %eax
callq 0x16d6
movq %r14, %rdi
movl $0x101, %esi            # imm = 0x101
callq 0x10a0
movq %rax, 0x3299(%rip)      # 0x5160
testq %rax, %rax
jne 0x1ef9
leaq 0x14fc(%rip), %rsi      # 0x33cf
movl $0x2, %edi
movq %r14, %rdx
xorl %eax, %eax
callq 0x16d6
movq 0x3277(%rip), %rax      # 0x5160
jmp 0x1eed
xorl %eax, %eax
movb $0x1, 0x3274(%rip)      # 0x5168
testq %rax, %rax
je 0x1f29
leaq 0x14ed(%rip), %rsi      # 0x33ed
movl $0x4, %edi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x16d6
movq 0x31da(%rip), %rax      # 0x50f0
movq 0x3243(%rip), %rdi      # 0x5160
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
xorl %eax, %eax
jmp 0x1e5d
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
callq 0x1b46
movl %eax, %ebx
negl %eax
jno 0x1f40
xorl %eax, %eax
popq %rbx
retq
leaq 0x3181(%rip), %rdi      # 0x50c8
callq 0x1120
cmpq $0x0, 0x31bc(%rip)      # 0x5110
jne 0x1f69
leaq 0x1163(%rip), %rdi      # 0x30c0
callq 0x1e3e
movq %rax, 0x31a7(%rip)      # 0x5110
leaq 0x3158(%rip), %rdi      # 0x50c8
callq 0x10c0
movq 0x3194(%rip), %rax      # 0x5110
movl %ebx, %edi
popq %rbx
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/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
pushq %rbx
pushq %rax
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
cmpl %eax, %edi
cmovael %eax, %edi
callq 0x1b46
movl %eax, %ebp
negl %ebp
jno 0x1fa2
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movl %eax, %ebx
testl %eax, %eax
jns 0x1fbd
leaq 0x1124(%rip), %rsi      # 0x30d3
movl $0x2, %edi
xorl %eax, %eax
callq 0x16d6
movl %ebp, %ebx
leaq 0x3104(%rip), %rdi      # 0x50c8
callq 0x1120
cmpq $0x0, 0x3147(%rip)      # 0x5118
jne 0x1fe6
leaq 0x1137(%rip), %rdi      # 0x3111
callq 0x1e3e
movq %rax, 0x3132(%rip)      # 0x5118
leaq 0x30db(%rip), %rdi      # 0x50c8
callq 0x10c0
movq 0x311f(%rip), %rax      # 0x5118
movl %ebx, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movl %esi, %ebx
callq 0x1030
testq %rax, %rax
je 0x201f
movq %rax, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x10b0
movq %rax, %rbx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movl 0x88(%rdi), %r13d
movl $0x1, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x2490
cmpl $-0x1, %eax
je 0x2adb
movl %eax, %r14d
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testl %eax, %eax
js 0x2b24
movq %rbx, %rdi
movl %r14d, %esi
xorl %edx, %edx
callq 0x28c9
testl %eax, %eax
jne 0x2b24
leaq 0xc(%rsp), %rdi
movw $0x1, -0x2(%rdi)
movl $0x6b, %edx
movq %r12, %rsi
callq 0x2090
leaq 0xa(%rsp), %rsi
movl %r14d, %edi
movl $0x6e, %edx
callq 0x23f0
cmpl $-0x1, %eax
je 0x2aec
testb $0x1, %r13b
je 0x2b14
movq %rbx, %rdi
movl %r14d, %esi
movl $0x1, %edx
callq 0x28c9
testl %eax, %eax
jne 0x2b24
jmp 0x2b14
movq %rbx, %rdi
xorl %esi, %esi
callq 0x25f4
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
jmp 0x2b24
callq 0x2080
movl (%rax), %eax
xorl $0x73, %eax
movl %r13d, %ecx
andl $0x1, %ecx
orl %eax, %ecx
je 0x2b14
movq %rbx, %rdi
movl %r14d, %esi
movq %r15, %rdx
callq 0x2943
testl %eax, %eax
jne 0x2b24
jmp 0x2abf
movl %r14d, 0x84(%rbx)
orb $0x2, 0x88(%rbx)
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
callq 0x3c69
movq %rax, %r15
orb $0x1, 0x88(%rax)
movq %rax, %rdi
movq %r14, %rsi
movl %ebx, %edx
xorl %ecx, %ecx
callq 0x2390
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
callq 0x3c69
movq %rax, %r15
andb $-0x2, 0x88(%rax)
movq %rax, %rdi
movq %r14, %rsi
movl %ebx, %edx
xorl %ecx, %ecx
callq 0x2390
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq %rsi, (%r14)
movq %rdx, 0x8(%r14)
callq 0x3c69
movq %rax, %r15
orb $0x1, 0x88(%rax)
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2290
movq %r15, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
movq 0x90(%rdi), %rdi
callq 0x23b0
testq %rax, %rax
je 0x40b0
movq %rax, 0x90(%rbx)
xorl %eax, %eax
jmp 0x40db
movl $0x5, (%rbx)
movabsq $0x6d20666f2074754f, %rax # imm = 0x6D20666F2074754F
movq %rax, 0x4(%rbx)
movabsq $0x79726f6d656d2066, %rax # imm = 0x79726F6D656D2066
movq %rax, 0x9(%rbx)
movb $0x0, 0x11(%rbx)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x9(%rsi), %rdi
callq 0x2300
testq %rax, %rax
je 0x48ac
movq %rax, %r14
movl %ebx, (%rax)
movl $0x0, 0x4(%rax)
testq %rbx, %rbx
je 0x48ba
leaq 0x8(%r14), %rdi
testq %r15, %r15
je 0x48b0
movq %r15, %rsi
movq %rbx, %rdx
callq 0x22c0
jmp 0x48ba
xorl %eax, %eax
jmp 0x48c7
xorl %esi, %esi
movq %rbx, %rdx
callq 0x21d0
movq %r14, %rax
addq $0x8, %rax
movb $0x0, 0x8(%r14,%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movq %rdi, %rax
movslq -0x4(%rdi), %rcx
cmpq %rsi, %rcx
jae 0x4a3d
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movslq -0x8(%rax), %r14
addq $-0x8, %rax
addq %r14, %rbx
leaq 0x9(,%rbx,2), %rsi
movq %rax, %rdi
callq 0x2350
testq %rax, %rax
je 0x4a34
addq %rbx, %rbx
subl %r14d, %ebx
movl %ebx, 0x4(%rax)
addq $0x8, %rax
jmp 0x4a36
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/winton[P]redis_parse/hiredis/sds.c
// Function: sdscatlen
sds sdscatlen(sds s, const void *t, size_t len) {
    struct sdshdr *sh;
    size_t curlen = sdslen(s);

    s = sdsMakeRoomFor(s,len);
    if (s == NULL) return NULL;
    sh = (void*) (s-(sizeof(struct sdshdr)));
    memcpy(s+curlen, t, len);
    sh->len = curlen+len;
    sh->free = sh->free-len;
    s[curlen+len] = '\0';
    return s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movslq -0x8(%rdi), %r12
movq %rdx, %rsi
callq 0x49f2
movq %rax, %r14
testq %rax, %rax
je 0x4a81
movq %r14, %rdi
addq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x22c0
addq %rbx, %r12
movl %r12d, -0x8(%r14)
subl %ebx, -0x4(%r14)
movb $0x0, (%r14,%r12)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/winton[P]redis_parse/hiredis/sds.c
// Function: sdscatvprintf
sds sdscatvprintf(sds s, const char *fmt, va_list ap) {
    va_list cpy;
    char *buf, *t;
    size_t buflen = 16;

    while(1) {
        buf = malloc(buflen);
#ifdef SDS_ABORT_ON_OOM
        if (buf == NULL) sdsOomAbort();
#else
        if (buf == NULL) return NULL;
#endif
        buf[buflen-2] = '\0';
        va_copy(cpy,ap);
        vsnprintf(buf, buflen, fmt, cpy);
        if (buf[buflen-2] != '\0') {
            free(buf);
            buflen *= 2;
            continue;
        }
        break;
    }
    t = sdscat(s, buf);
    free(buf);
    return t;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movl $0x10, %r13d
movl $0x10, %edi
callq 0x2300
testq %rax, %rax
je 0x4c1f
movq %rax, %rbp
movq %rbx, 0x8(%rsp)
leaq 0x10(%rsp), %r14
xorl %ebx, %ebx
movb $0x0, -0x2(%rbp,%r13)
movq 0x10(%r15), %rax
movq %rax, 0x20(%rsp)
movups (%r15), %xmm0
movaps %xmm0, 0x10(%rsp)
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r14, %rcx
callq 0x20c0
cmpb $0x0, -0x2(%rbp,%r13)
je 0x4c23
movq %rbp, %rdi
callq 0x2060
addq %r13, %r13
movq %r13, %rdi
callq 0x2300
movq %rax, %rbp
testq %rax, %rax
jne 0x4bd1
jmp 0x4c3b
xorl %ebx, %ebx
jmp 0x4c3b
movq 0x8(%rsp), %rdi
movq %rbp, %rsi
callq 0x2330
movq %rax, %rbx
movq %rbp, %rdi
callq 0x2060
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/winton[P]redis_parse/hiredis/sds.c
// Function: sdstrim
sds sdstrim(sds s, const char *cset) {
    struct sdshdr *sh = (void*) (s-(sizeof(struct sdshdr)));
    char *start, *end, *sp, *ep;
    size_t len;

    sp = start = s;
    ep = end = s+sdslen(s)-1;
    while(sp <= end && strchr(cset, *sp)) sp++;
    while(ep > start && strchr(cset, *ep)) ep--;
    len = (sp > ep) ? 0 : ((ep-sp)+1);
    if (sh->buf != sp) memmove(sh->buf, sp, len);
    sh->buf[len] = '\0';
    sh->free = sh->free+(sh->len-len);
    sh->len = len;
    return s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movslq -0x8(%rdi), %rax
leaq (%rdi,%rax), %r12
decq %r12
movq %rdi, %r14
cmpq %rdi, %r12
jb 0x4d0e
movq %rbx, %r14
movsbl (%r14), %esi
movq %r15, %rdi
callq 0x2170
testq %rax, %rax
je 0x4d0e
incq %r14
cmpq %r12, %r14
jbe 0x4cf5
cmpq %rbx, %r12
jbe 0x4d30
movsbl (%r12), %esi
movq %r15, %rdi
callq 0x2170
testq %rax, %rax
je 0x4d30
decq %r12
cmpq %rbx, %r12
ja 0x4d13
movq %rbx, %r12
xorl %r15d, %r15d
subq %r14, %r12
leaq 0x1(%r12), %rax
cmovaeq %rax, %r15
cmpq %rbx, %r14
je 0x4d52
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x23a0
movb $0x0, (%rbx,%r15)
movl -0x4(%rbx), %eax
subl %r15d, %eax
addl -0x8(%rbx), %eax
movl %eax, -0x4(%rbx)
movl %r15d, -0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/winton[P]redis_parse/hiredis/sds.c
// Function: sdsrange
sds sdsrange(sds s, int start, int end) {
    struct sdshdr *sh = (void*) (s-(sizeof(struct sdshdr)));
    size_t newlen, len = sdslen(s);

    if (len == 0) return s;
    if (start < 0) {
        start = len+start;
        if (start < 0) start = 0;
    }
    if (end < 0) {
        end = len+end;
        if (end < 0) end = 0;
    }
    newlen = (start > end) ? 0 : (end-start)+1;
    if (newlen != 0) {
        if (start >= (signed)len) {
            newlen = 0;
        } else if (end >= (signed)len) {
            end = len-1;
            newlen = (start > end) ? 0 : (end-start)+1;
        }
    } else {
        start = 0;
    }
    if (start && newlen) memmove(sh->buf, sh->buf+start, newlen);
    sh->buf[newlen] = 0;
    sh->free = sh->free+(sh->len-newlen);
    sh->len = newlen;
    return s;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl -0x8(%rdi), %ecx
testl %ecx, %ecx
je 0x4dfb
leal (%rcx,%rsi), %eax
xorl %r14d, %r14d
testl %eax, %eax
cmovlel %r14d, %eax
testl %esi, %esi
cmovnsl %esi, %eax
leal (%rcx,%rdx), %esi
testl %esi, %esi
cmovlel %r14d, %esi
testl %edx, %edx
cmovnsl %edx, %esi
movl %esi, %edx
subl %eax, %edx
leal 0x1(%rdx), %edi
cmovbl %r14d, %edi
movl %ecx, %edx
subl %eax, %edx
jle 0x4de6
testl %edi, %edi
je 0x4de6
leal -0x1(%rcx), %r8d
xorl %r9d, %r9d
cmpl %r8d, %eax
cmoval %r9d, %edx
cmpl %ecx, %esi
cmovbl %edi, %edx
movslq %edx, %r14
testl %eax, %eax
je 0x4de6
testl %edx, %edx
je 0x4de6
movl %eax, %esi
addq %rbx, %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x23a0
movb $0x0, (%rbx,%r14)
movl -0x4(%rbx), %eax
subl %r14d, %eax
addl -0x8(%rbx), %eax
movl %eax, -0x4(%rbx)
movl %r14d, -0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/winton[P]redis_parse/hiredis/sds.c
// Function: sdscatrepr
sds sdscatrepr(sds s, char *p, size_t len) {
    s = sdscatlen(s,"\"",1);
    if (s == NULL) return NULL;

    while(len--) {
        switch(*p) {
        case '\\':
        case '"':
            s = sdscatprintf(s,"\\%c",*p);
            break;
        case '\n': s = sdscatlen(s,"\\n",2); break;
        case '\r': s = sdscatlen(s,"\\r",2); break;
        case '\t': s = sdscatlen(s,"\\t",2); break;
        case '\a': s = sdscatlen(s,"\\a",2); break;
        case '\b': s = sdscatlen(s,"\\b",2); break;
        default:
            if (isprint(*p))
                s = sdscatprintf(s,"%c",*p);
            else
                s = sdscatprintf(s,"\\x%02x",(unsigned char)*p);
            break;
        }
        p++;
        if (s == NULL) return NULL;
    }
    return sdscatlen(s,"\"",1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movslq -0x8(%rdi), %rbx
movl $0x1, %esi
callq 0x49f2
testq %rax, %rax
je 0x5327
movq %rax, %r13
movb $0x22, (%rax,%rbx)
leaq 0x1(%rbx), %rax
movl %eax, -0x8(%r13)
decl -0x4(%r13)
movb $0x0, 0x1(%r13,%rbx)
xorl %ebx, %ebx
cmpq %rbx, %r14
je 0x52fc
movsbl (%r15,%rbx), %ebp
movzbl %bpl, %r12d
leal -0x7(%r12), %eax
cmpl $0x6, %eax
ja 0x51ed
leaq 0x2349(%rip), %rcx      # 0x7504
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movslq -0x8(%r13), %r12
movl $0x2, %esi
movq %r13, %rdi
callq 0x49f2
testq %rax, %rax
je 0x5327
movq %rax, %r13
movw $0x615c, (%rax,%r12)    # imm = 0x615C
jmp 0x52c2
cmpl $0x5c, %r12d
je 0x51f9
cmpl $0x22, %r12d
jne 0x5208
movq %r13, %rdi
leaq 0x231d(%rip), %rsi      # 0x7520
jmp 0x52e2
callq 0x2470
movq (%rax), %rax
movslq %ebp, %rcx
testb $0x40, 0x1(%rax,%rcx,2)
jne 0x52d8
movq %r13, %rdi
leaq 0x22fc(%rip), %rsi      # 0x7524
movl %r12d, %edx
jmp 0x52e4
movslq -0x8(%r13), %r12
movl $0x2, %esi
movq %r13, %rdi
callq 0x49f2
testq %rax, %rax
je 0x5327
movq %rax, %r13
movw $0x625c, (%rax,%r12)    # imm = 0x625C
jmp 0x52c2
movslq -0x8(%r13), %r12
movl $0x2, %esi
movq %r13, %rdi
callq 0x49f2
testq %rax, %rax
je 0x5327
movq %rax, %r13
movw $0x745c, (%rax,%r12)    # imm = 0x745C
jmp 0x52c2
movslq -0x8(%r13), %r12
movl $0x2, %esi
movq %r13, %rdi
callq 0x49f2
testq %rax, %rax
je 0x5327
movq %rax, %r13
movw $0x6e5c, (%rax,%r12)    # imm = 0x6E5C
jmp 0x52c2
movslq -0x8(%r13), %r12
movl $0x2, %esi
movq %r13, %rdi
callq 0x49f2
testq %rax, %rax
je 0x5327
movq %rax, %r13
movw $0x725c, (%rax,%r12)    # imm = 0x725C
leaq 0x2(%r12), %rax
movl %eax, -0x8(%r13)
addl $-0x2, -0x4(%r13)
movb $0x0, 0x2(%r13,%r12)
jmp 0x52ee
movq %r13, %rdi
leaq 0x223f(%rip), %rsi      # 0x7521
movl %ebp, %edx
xorl %eax, %eax
callq 0x2140
movq %rax, %r13
incq %rbx
testq %r13, %r13
jne 0x5198
jmp 0x5327
movslq -0x8(%r13), %rbx
movl $0x1, %esi
movq %r13, %rdi
callq 0x49f2
testq %rax, %rax
je 0x5327
movb $0x22, (%rax,%rbx)
leaq 0x1(%rbx), %rcx
movl %ecx, -0x8(%rax)
decl -0x4(%rax)
movb $0x0, 0x1(%rax,%rbx)
jmp 0x5329
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/winton[P]redis_parse/hiredis/async.c
// Function: redisAsyncConnect
redisAsyncContext *redisAsyncConnect(const char *ip, int port) {
    redisContext *c = redisConnectNonBlock(ip,port);
    redisAsyncContext *ac = redisAsyncInitialize(c);
    __redisAsyncCopyError(ac);
    return ac;
}

// Assembly:
pushq %rax
callq 0x2340
movq %rax, %rdi
callq 0x55df
movl (%rax), %ecx
movl %ecx, 0xa0(%rax)
leaq 0x4(%rax), %rcx
movq %rcx, 0xa8(%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/winton[P]redis_parse/hiredis/async.c
// Function: redisAsyncConnectUnix
redisAsyncContext *redisAsyncConnectUnix(const char *path) {
    redisContext *c = redisConnectUnixNonBlock(path);
    redisAsyncContext *ac = redisAsyncInitialize(c);
    __redisAsyncCopyError(ac);
    return ac;
}

// Assembly:
pushq %rax
callq 0x2360
movq %rax, %rdi
callq 0x55df
movl (%rax), %ecx
movl %ecx, 0xa0(%rax)
leaq 0x4(%rax), %rcx
movq %rcx, 0xa8(%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/winton[P]redis_parse/hiredis/async.c
// Function: _redisAsyncHandleConnect
static int __redisAsyncHandleConnect(redisAsyncContext *ac) {
    redisContext *c = &(ac->c);

    if (redisCheckSocketError(c,c->fd) == REDIS_ERR) {
        /* Try again later when connect(2) is still in progress. */
        if (errno == EINPROGRESS)
            return REDIS_OK;

        if (ac->onConnect) ac->onConnect(ac,REDIS_ERR);
        __redisAsyncDisconnect(ac);
        return REDIS_ERR;
    }

    /* Mark context as connected. */
    c->flags |= REDIS_CONNECTED;
    if (ac->onConnect) ac->onConnect(ac,REDIS_OK);
    return REDIS_OK;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x84(%rdi), %esi
callq 0x2150
cmpl $-0x1, %eax
je 0x5e3a
orb $0x2, 0x88(%rbx)
movq 0xf0(%rbx), %rax
testq %rax, %rax
je 0x5e44
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %esi, %esi
callq *%rax
jmp 0x5e6b
callq 0x2080
cmpl $0x73, (%rax)
jne 0x5e48
xorl %ebp, %ebp
jmp 0x5e6b
movq 0xf0(%rbx), %rax
testq %rax, %rax
je 0x5e5e
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq *%rax
movq %rbx, %rdi
callq 0x5937
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ranbenbasat[P]RHHH/randhhh1D.c
// Function: update
void update(LCLitem_t item, int count) {
#ifdef  PROB
	if (nrIgnore--) return;
	short i = rand() % NUM_COUNTERS;
	LCU_Update(counters[i], item & masks[i]);
	nrIgnore = log((float)rand()) / logIgnoreProb - minusQuantity;
#else
	short i = rand() % NUM_COUNTERS;
	LCU_Update(counters[i], item & masks[i]);
#endif
}

// Assembly:
subl $0x1, 0x3dde(%rip)      # 0x5260
jae 0x14f8
pushq %rbx
movl %edi, %ebx
callq 0x11e0
cltq
imulq $0x3e0f83e1, %rax, %rcx # imm = 0x3E0F83E1
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x23, %rcx
addl %edx, %ecx
movl %ecx, %edx
shll $0x5, %edx
addl %ecx, %edx
subl %edx, %eax
movswq %ax, %rax
leaq 0x3dba(%rip), %rcx      # 0x5270
movq (%rcx,%rax,8), %rdi
leaq 0x3c4f(%rip), %rcx      # 0x5110
andl (%rcx,%rax,4), %ebx
movl %ebx, %esi
callq 0x20a0
callq 0x11e0
cvtsi2ss %eax, %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x10d0
divsd 0x3d6b(%rip), %xmm0     # 0x5250
subsd 0x3d6b(%rip), %xmm0     # 0x5258
cvttsd2si %xmm0, %eax
movl %eax, 0x3d69(%rip)      # 0x5260
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/cirocosta[P]stress/src/pid.c
// Function: fork_so_much
void
fork_so_much(int n)
{
	int pid;

	printf("Starting to spawn %d blocking children\n", n);
	while (--n) {
		switch (pid = fork()) {
			case -1:
				_STRESS_MUST(0, "Fork returned -1.");
				break;
			case 0:
				printf("[%d] - blocking\n", n);
				stress_wait_until_signalized();
				return;
		}
	}
}

// Assembly:
pushq %rbx
movl %edi, %ebx
leaq 0x930(%rip), %rdi       # 0x2108
movl %ebx, %esi
xorl %eax, %eax
callq 0x1090
cmpl $0x1, %ebx
je 0x17fb
callq 0x1130
decl %ebx
testl %eax, %eax
je 0x17fd
cmpl $-0x1, %eax
jne 0x17e1
callq 0x138c
popq %rbx
retq
leaq 0x948(%rip), %rdi       # 0x214c
movl %ebx, %esi
xorl %eax, %eax
callq 0x1090
popq %rbx
jmp 0x16c2
// File: /workspace/github_c_makefile_star2_O3/simh[P]simtools/converters/fsio/fsio.c
// Function: doUmount
static void doUmount(void)
{
  struct mountedFS *mount, **ptr = &mounts;

  if (checkDev(words[0]) != 0) {
    if ((mount = lookupDev(words[0])) != NULL) {
      if (mount->filesys->umount == NULL) {
        fprintf(stderr, "umount: \"%s\" may not be unmounted\n", words[0]);
        return;
      }

      for (ptr = &mounts; *ptr != NULL; ptr = &((*ptr)->next))
        if (*ptr == mount) {
          *ptr = mount->next;
          (*mount->filesys->umount)(mount);
          fclose(mount->container);
          free(mount);
          return;
        }
      fprintf(stderr, "Mounted file system list corrupted\n");
      exit(10);
    } else fprintf(stderr, "umount: \"%s\" is not mounted\n", words[0]);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x1432b(%rip), %rax     # 0x190b8
movq (%rax), %rdi
callq 0x62fc
testl %eax, %eax
je 0x4e0c
movq 0x14318(%rip), %rax     # 0x190b8
movq (%rax), %r14
leaq 0x15316(%rip), %rbx     # 0x1a0c0
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x4e14
leaq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x31d0
testl %eax, %eax
jne 0x4daa
movq 0x20(%rbx), %rax
cmpq $0x0, 0x30(%rax)
je 0x4e27
leaq 0x152ec(%rip), %rax     # 0x1a0c0
movq %rax, %rcx
movq (%rax), %rax
testq %rax, %rax
je 0x4e49
cmpq %rbx, %rax
jne 0x4dd4
movq (%rbx), %rax
movq %rax, (%rcx)
movq 0x20(%rbx), %rax
movq %rbx, %rdi
callq *0x30(%rax)
movq 0x38(%rbx), %rdi
callq 0x3110
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3050
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x131d5(%rip), %rax     # 0x17ff0
movq (%rax), %rdi
leaq 0xb433(%rip), %rsi      # 0x10258
jmp 0x4e38
movq 0x131c2(%rip), %rax     # 0x17ff0
movq (%rax), %rdi
leaq 0xb3d9(%rip), %rsi      # 0x10211
movq %r14, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x31e0
callq 0x3382
// File: /workspace/github_c_makefile_star2_O3/simh[P]simtools/converters/fsio/fsio.c
// Function: doSet
static void doSet(void)
{
  struct mountedFS *mount;
  char *fname;
  uint8_t unit, present;

  if ((mount = findMount("set", words[0], &unit, &present, &fname)) != NULL) {
    if (*fname == '\0') {
      if (mount->filesys->set != NULL)
        (*mount->filesys->set)(mount, unit, present);
      else fprintf(stderr, "set: \"%s\" does not support \"set\" command\n",
                   mount->filesys->fstype);
    } else fprintf(stderr, "set: Does not expect a file name\n");
  }
}

// Assembly:
subq $0x18, %rsp
movq 0x140d9(%rip), %rax     # 0x190b8
movq (%rax), %rsi
leaq 0xb056(%rip), %rdi      # 0x1003f
leaq 0xf(%rsp), %rdx
leaq 0xe(%rsp), %rcx
leaq 0x10(%rsp), %r8
callq 0x636e
testq %rax, %rax
je 0x5038
movq 0x10(%rsp), %rcx
cmpb $0x0, (%rcx)
jne 0x502c
movq 0x20(%rax), %rdi
movq 0x48(%rdi), %rcx
testq %rcx, %rcx
je 0x5033
movzbl 0xf(%rsp), %esi
movzbl 0xe(%rsp), %edx
movq %rax, %rdi
addq $0x18, %rsp
jmpq *%rcx
callq 0x3429
jmp 0x5038
callq 0x3445
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/simh[P]simtools/converters/fsio/fsio.c
// Function: doInfo
static void doInfo(void)
{
  struct mountedFS *mount;
  char *fname;
  uint8_t unit, present;

  if ((mount = findMount("info", words[0], &unit, &present, &fname)) != NULL) {
    if (*fname == '\0')
      (*mount->filesys->info)(mount, unit, present);
    else fprintf(stderr, "info: Does not expect a file name\n");
  }
}

// Assembly:
subq $0x18, %rsp
movq 0x14070(%rip), %rax     # 0x190b8
movq (%rax), %rsi
leaq 0xaff1(%rip), %rdi      # 0x10043
leaq 0xf(%rsp), %rdx
leaq 0xe(%rsp), %rcx
leaq 0x10(%rsp), %r8
callq 0x636e
testq %rax, %rax
je 0x5095
movq 0x10(%rsp), %rcx
cmpb $0x0, (%rcx)
jne 0x5090
movq 0x20(%rax), %rcx
movq 0x50(%rcx), %rcx
movzbl 0xf(%rsp), %esi
movzbl 0xe(%rsp), %edx
movq %rax, %rdi
addq $0x18, %rsp
jmpq *%rcx
callq 0x3464
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/simh[P]simtools/converters/fsio/fsio.c
// Function: doType
static void doType(void)
{
  struct mountedFS *mount;
  char *fname;
  void *file;
  uint8_t unit, present;

  /*
   * Force ASCII mode
   */
  SWSET('a');

  if ((mount = findMount("type", words[0], &unit, &present, &fname)) != NULL) {
    if ((file = (*mount->filesys->openFileR)(mount, unit, fname)) != NULL) {
      char buf[BFRSIZ];
      size_t len, i;

      while ((len = (*mount->filesys->readFile)(file, buf, BFRSIZ)) != 0) {
        for (i = 0; i < len; i++)
          if (buf[i] != '\0')
            putchar(buf[i]);
      }

      /*
       * Close the file
       */
      (*mount->filesys->closeFile)(file);
    } else fprintf(stderr, "type: \"%s\" no such file\n", fname);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x210, %rsp            # imm = 0x210
orb $0x1, 0x138b2(%rip)     # 0x18fd8
movq 0x1398b(%rip), %rax     # 0x190b8
movq (%rax), %rsi
leaq 0xa932(%rip), %rdi      # 0x10069
leaq 0x6(%rsp), %rdx
leaq 0x7(%rsp), %rcx
leaq 0x8(%rsp), %r8
callq 0x636e
testq %rax, %rax
je 0x57db
movq %rax, %rbx
movq 0x20(%rax), %rax
movzbl 0x6(%rsp), %esi
movq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rdx
callq *0x60(%rax)
testq %rax, %rax
je 0x57ec
movq %rax, %r14
movq 0x20(%rbx), %rax
leaq 0x10(%rsp), %rsi
movl $0x200, %edx            # imm = 0x200
movq %r14, %rdi
callq *0x80(%rax)
testq %rax, %rax
je 0x57d1
movq %rax, %r12
leaq 0x10(%rsp), %r15
xorl %r13d, %r13d
movsbl 0x10(%rsp,%r13), %edi
testl %edi, %edi
je 0x57ac
callq 0x3060
incq %r13
cmpq %r13, %r12
jne 0x579d
movq 0x20(%rbx), %rax
movl $0x200, %edx            # imm = 0x200
movq %r14, %rdi
movq %r15, %rsi
callq *0x80(%rax)
movq %rax, %r12
testq %rax, %rax
jne 0x579a
movq 0x20(%rbx), %rax
movq %r14, %rdi
callq *0x78(%rax)
addq $0x210, %rsp            # imm = 0x210
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x127fd(%rip), %rax     # 0x17ff0
movq (%rax), %rdi
leaq 0xade2(%rip), %rsi      # 0x105df
movq %r15, %rdx
xorl %eax, %eax
addq $0x210, %rsp            # imm = 0x210
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x31e0
// File: /workspace/github_c_makefile_star2_O3/simh[P]simtools/converters/fsio/fsio.c
// Function: doDelete
static void doDelete(void)
{
  struct mountedFS *mount;
  char *fname;
  void *file;
  uint8_t unit, present;

  if ((mount = findMount("delete", words[0], &unit, &present, &fname)) != NULL) {
    if (mount->filesys->deleteFile != NULL) {
      if ((mount->flags & FS_READONLY) == 0) {
        if ((file = (*mount->filesys->openFileR)(mount, unit, fname)) != NULL)
          (*mount->filesys->deleteFile)(file, fname);
        else fprintf(stderr, "delete: \"%s\" no such file\n", fname);
      } else fprintf(stderr, "delete: \"%s\" is mounted read-only\n", mount->name);
    } else fprintf(stderr, "delete: Function not supported\n");
  }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq 0x13893(%rip), %rax     # 0x190b8
movq (%rax), %rsi
leaq 0xa842(%rip), %rdi      # 0x10071
leaq 0xe(%rsp), %rdx
leaq 0xf(%rsp), %rcx
leaq 0x10(%rsp), %r8
callq 0x636e
testq %rax, %rax
je 0x5896
movq %rax, %rbx
movq 0x20(%rax), %rax
cmpq $0x0, 0x90(%rax)
je 0x5891
testb $0x1, 0x30(%rbx)
jne 0x589e
movzbl 0xe(%rsp), %esi
movq 0x10(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rdx
callq *0x60(%rax)
testq %rax, %rax
je 0x58b8
movq 0x20(%rbx), %rcx
movq 0x90(%rcx), %rcx
movq %rax, %rdi
movq %r14, %rsi
addq $0x18, %rsp
popq %rbx
popq %r14
jmpq *%rcx
callq 0x34b6
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq 0x1274b(%rip), %rax     # 0x17ff0
movq (%rax), %rdi
addq $0x8, %rbx
leaq 0xad60(%rip), %rsi      # 0x10613
movq %rbx, %rdx
jmp 0x58cc
movq 0x12731(%rip), %rax     # 0x17ff0
movq (%rax), %rdi
leaq 0xad2f(%rip), %rsi      # 0x105f8
movq %r14, %rdx
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x31e0
// File: /workspace/github_c_makefile_star2_O3/simh[P]simtools/converters/fsio/fsio.c
// Function: doDo
static void doDo(void)
{
  uint8_t noecho = SWISSET('q');
  FILE *cmdFile;
  char buf[MAX_CMDLEN];

  if ((cmdFile = fopen(words[0], "r")) != NULL) {
    for (;;) {
      int len;

      if (fgets(buf, sizeof(buf), cmdFile) == NULL) {
        fclose(cmdFile);
        return;
      }

      if (!noecho)
        printf("fsio> %s", buf);

      /*
       * Remove any trailing newline
       */
      len = strlen(buf);
      if (buf[len - 1] == '\n')
        buf[len - 1] = '\0';

      /*
       * Parse the command line and execute any command found
       */
      FSioExecute(buf);
    }
  } else fprintf(stderr, "do: failed to open \"%s\"\n", words[0]);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movl 0x136ae(%rip), %ebp     # 0x18fd8
movq 0x13787(%rip), %rax     # 0x190b8
movq (%rax), %rdi
leaq 0xbcb8(%rip), %rsi      # 0x115f3
callq 0x3280
testq %rax, %rax
je 0x59c3
movq %rax, %rbx
movq %rsp, %rdi
movl $0x200, %esi            # imm = 0x200
movq %rax, %rdx
callq 0x31b0
testq %rax, %rax
je 0x59ad
leaq 0xa781(%rip), %r14      # 0x100e5
movq %rsp, %r15
btl $0x10, %ebp
jb 0x597a
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x3160
movq %r15, %rdi
callq 0x3130
decl %eax
cltq
cmpb $0xa, (%rsp,%rax)
jne 0x5990
movb $0x0, (%rsp,%rax)
movq %r15, %rdi
callq 0x5e78
movq %r15, %rdi
movl $0x200, %esi            # imm = 0x200
movq %rbx, %rdx
callq 0x31b0
testq %rax, %rax
jne 0x5967
movq %rbx, %rdi
callq 0x3110
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x34d2
jmp 0x59b5
// File: /workspace/github_c_makefile_star2_O3/simh[P]simtools/converters/fsio/fsio.c
// Function: doExit
static void doExit(void)
{
  struct mountedFS *mount;

  for (mount = mounts; mount != NULL; mount = mount->next)
    if (mount != &localMount)
      fclose(mount->container);

#ifdef DEBUG
  if ((DEBUGout != NULL) && (DEBUGout != stdout))
    fclose(DEBUGout);
#endif

  exit(0);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x146aa(%rip), %rbx     # 0x1a0c0
testq %rbx, %rbx
je 0x5a38
leaq 0x146a6(%rip), %r14     # 0x1a0c8
cmpq %r14, %rbx
je 0x5a30
movq 0x38(%rbx), %rdi
callq 0x3110
movq (%rbx), %rbx
testq %rbx, %rbx
jne 0x5a22
movq 0x13589(%rip), %rdi     # 0x18fc8
testq %rdi, %rdi
je 0x5a55
movq 0x1256d(%rip), %rax     # 0x17fb8
cmpq (%rax), %rdi
je 0x5a55
callq 0x3110
xorl %edi, %edi
callq 0x32c0
// File: /workspace/github_c_makefile_star2_O3/simh[P]simtools/converters/fsio/fsio.c
// Function: doRewind
static void doRewind(void)
{
  struct mountedFS *mount;
  char *fname;
  uint8_t unit, present;

  if ((mount = findMount("rewind", words[0], &unit, &present, &fname)) != NULL) {
    if ((mount->filesys->flags & FS_TAPE) == 0) {
      fprintf(stderr, "rewind: Command only valid on magtapes\n");
      return;
    }

    if (*fname == '\0')
      (*mount->filesys->rewind)(mount);
    else fprintf(stderr, "rewind: Does not expect a file name\n");
  }
}

// Assembly:
subq $0x18, %rsp
movq 0x13651(%rip), %rax     # 0x190b8
movq (%rax), %rsi
leaq 0xa623(%rip), %rdi      # 0x10094
leaq 0xf(%rsp), %rdx
leaq 0xe(%rsp), %rcx
leaq 0x10(%rsp), %r8
callq 0x636e
testq %rax, %rax
je 0x5ab7
movq 0x20(%rax), %rcx
testb $0x2, 0x18(%rcx)
je 0x5aab
movq 0x10(%rsp), %rdx
cmpb $0x0, (%rdx)
jne 0x5ab2
movq %rax, %rdi
addq $0x18, %rsp
jmpq *0x98(%rcx)
callq 0x3510
jmp 0x5ab7
callq 0x34f4
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/simh[P]simtools/converters/fsio/fsio.c
// Function: doEOM
static void doEOM(void)
{
  struct mountedFS *mount;
  char *fname;
  uint8_t unit, present;

  if ((mount = findMount("eom", words[0], &unit, &present, &fname)) != NULL) {
    if ((mount->filesys->flags & FS_TAPE) == 0) {
      fprintf(stderr, "eom: Command only valid on magtapes\n");
      return;
    }

    if (*fname == '\0')
      (*mount->filesys->eom)(mount);
    else fprintf(stderr, "eom: Does not expect a file name\n");
  }
}

// Assembly:
subq $0x18, %rsp
movq 0x135f1(%rip), %rax     # 0x190b8
movq (%rax), %rsi
leaq 0xa5ca(%rip), %rdi      # 0x1009b
leaq 0xf(%rsp), %rdx
leaq 0xe(%rsp), %rcx
leaq 0x10(%rsp), %r8
callq 0x636e
testq %rax, %rax
je 0x5b17
movq 0x20(%rax), %rcx
testb $0x2, 0x18(%rcx)
je 0x5b0b
movq 0x10(%rsp), %rdx
cmpb $0x0, (%rdx)
jne 0x5b12
movq %rax, %rdi
addq $0x18, %rsp
jmpq *0xa0(%rcx)
callq 0x3548
jmp 0x5b17
callq 0x352c
addq $0x18, %rsp
retq