LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/pahihu[P]mixal/run.c
// Function: compare
static void compare(Cell cell)
{
    Flag saved = overflow;

    Cell difference = sub(field(F, r[C & 7]), field(F, cell));
    comparison_indicator = sign_of_difference(difference);
    overflow = saved;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x741f(%rip), %r15      # 0xfb40
movl (%r15), %ebp
movl 0x86c2(%rip), %edi      # 0x10dec
movl 0x86b8(%rip), %eax      # 0x10de8
andl $0x7, %eax
leaq 0x8626(%rip), %rcx      # 0x10d60
movq (%rcx,%rax,8), %rsi
callq 0x37ed
movq %rax, %r14
movl 0x86a0(%rip), %edi      # 0x10dec
movq %rbx, %rsi
callq 0x37ed
movq %r14, %rdi
movq %rax, %rsi
callq 0x3b59
xorl %ecx, %ecx
btl $0x1e, %eax
movl $0x0, %edx
sbbl %edx, %edx
orl $0x1, %edx
testl $0x3fffffff, %eax       # imm = 0x3FFFFFFF
cmovel %ecx, %edx
movl %edx, 0x85c7(%rip)      # 0x10d44
movl %ebp, (%r15)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/pahihu[P]mixal/symbol.c
// Function: string_to_symbol
Symbol string_to_symbol(const char *name)
{
    Symbol *bucket = symbol_table + hash(name);
    Symbol p = *bucket;
    for (; p; p = p->next)
	    if (stricmp(name, p->name) == 0)
	        return p;
    {                   /* Symbol doesn't exist yet. */
	    Symbol result = allot(sizeof(struct Symbol));
	    strcpy(result->name = allot(strlen(name) + 1), name);
	    result->defined = false;
	    result->references = NULL;
	    result->next = *bucket;
	    result->cell = zero;
	    *bucket = result;
	    return result;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movb (%rdi), %bpl
xorl %r12d, %r12d
testb %bpl, %bpl
movq %rdi, 0x8(%rsp)
je 0x87f2
movq %rdi, %rbx
callq 0x3030
movq (%rax), %rax
leaq 0x1(%rbx), %rcx
movl %ebp, %edx
movl %r12d, %esi
shll $0x5, %esi
subl %r12d, %esi
movsbq %dl, %rdx
movl %esi, %r12d
addl (%rax,%rdx,4), %r12d
movb (%rcx), %dl
incq %rcx
testb %dl, %dl
jne 0x87bb
movl %r12d, %eax
movl $0xf0f0f0f1, %ecx       # imm = 0xF0F0F0F1
imulq %rax, %rcx
shrq $0x24, %rcx
movl %ecx, %eax
shll $0x4, %eax
addl %ecx, %eax
subl %eax, %r12d
leaq 0x86e7(%rip), %rax      # 0x10ee0
movq (%rax,%r12,8), %r14
testq %r14, %r14
je 0x8878
movq 0x8(%rsp), %rax
incq %rax
movq %rax, 0x10(%rsp)
movb %bpl, 0x7(%rsp)
movq 0x8(%r14), %r13
testb %bpl, %bpl
je 0x884e
movq 0x10(%rsp), %r15
movsbq (%r13), %rbx
testq %rbx, %rbx
je 0x884e
callq 0x32c0
movq (%rax), %rax
movsbq %bpl, %rcx
movl (%rax,%rcx,4), %ecx
cmpl (%rax,%rbx,4), %ecx
jne 0x886b
incq %r13
movb (%r15), %bpl
incq %r15
testb %bpl, %bpl
jne 0x8822
callq 0x32c0
movq (%rax), %rax
movsbq %bpl, %rcx
movl (%rax,%rcx,4), %ecx
movsbq (%r13), %rdx
cmpl (%rax,%rdx,4), %ecx
je 0x88f7
movq (%r14), %r14
testq %r14, %r14
movb 0x7(%rsp), %bpl
jne 0x8814
movl $0x28, %edi
callq 0x31f0
movq %rax, %r14
testq %rax, %rax
jne 0x8898
leaq 0x1c62(%rip), %rdi      # 0xa4f3
xorl %eax, %eax
callq 0x5ac0
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x3100
leaq 0x1(%rax), %rdi
callq 0x31f0
movq %rax, %r15
testq %rax, %rax
jne 0x88c4
leaq 0x1c36(%rip), %rdi      # 0xa4f3
xorl %eax, %eax
callq 0x5ac0
movq %r15, 0x8(%r14)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3090
movl $0x0, 0x10(%r14)
xorl %eax, %eax
movq %rax, 0x20(%r14)
leaq 0x85f8(%rip), %rdx      # 0x10ee0
movq (%rdx,%r12,8), %rcx
movq %rcx, (%r14)
movq %rax, 0x18(%r14)
movq %r14, (%rdx,%r12,8)
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/pahihu[P]mixal/symbol.c
// Function: forward_reference
void forward_reference(Symbol symbol, Address address)
{
    assert(!symbol->defined);
    {
	    AddressList refs = allot(sizeof(struct AddressList));
	    refs->address = address;
	    refs->next = symbol->references;
	    symbol->references = refs;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
cmpl $0x0, 0x10(%rdi)
jne 0x897b
movl %esi, %ebp
movq %rdi, %rbx
movl $0x10, %edi
callq 0x31f0
movq %rax, %r14
testq %rax, %rax
jne 0x8967
leaq 0x1b93(%rip), %rdi      # 0xa4f3
xorl %eax, %eax
callq 0x5ac0
movl %ebp, 0x8(%r14)
movq 0x20(%rbx), %rax
movq %rax, (%r14)
movq %r14, 0x20(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1b01(%rip), %rdi      # 0xa483
leaq 0x1ad7(%rip), %rsi      # 0xa460
leaq 0x1b04(%rip), %rcx      # 0xa494
movl $0x78, %edx
callq 0x3130
// File: /workspace/github_c_makefile_star2_O1/pahihu[P]mixal/symbol.c
// Function: define_symbol
void define_symbol(Symbol symbol, Cell cell)
{
    {   /* handle local symbols */
	    const char *name = symbol->name;
	    if (isdigit(name[0]) && strlen(name) == 2) {
            char c = toupper(name[1]);
            if (c == 'F' || c == 'B') {
                error("Definition of local ref: %s", name);
                return;
            } else if (c == 'H') {
                char new_name[3];
                Symbol nB, nF;
                strcpy(new_name, name);
                new_name[1] = 'B'; nB = string_to_symbol(new_name);
                nB->defined = true, nB->cell = cell;
                new_name[1] = 'F'; nF = string_to_symbol(new_name);
                resolve_references(nF, cell);
                nF->defined = false, nF->references = NULL;
                return;
            } else
                ;       /* not a local; fall through */
        }
    }
    if (symbol->defined)
	    warn("'%s' multiply-defined", symbol->name);
    else
	    resolve_references(symbol, cell);
    symbol->defined = true, symbol->cell = cell;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r15
callq 0x32d0
movq (%rax), %rax
movsbq (%r15), %rcx
testb $0x8, 0x1(%rax,%rcx,2)
je 0x8a6a
movq %r15, %rdi
callq 0x3100
cmpq $0x2, %rax
jne 0x8a6a
callq 0x3030
movq (%rax), %rax
movsbq 0x1(%r15), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, %ecx
andl $0xfb, %ecx
cmpl $0x42, %ecx
jne 0x8a0d
leaq 0x1ac2(%rip), %rdi      # 0xa4bc
movq %r15, %rsi
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x5bbc
movzbl %al, %eax
cmpl $0x48, %eax
jne 0x8a6a
leaq 0xd(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x3090
movb $0x42, 0x1(%r14)
movq %r14, %rdi
callq 0x878c
movl $0x1, 0x10(%rax)
movq %rbx, 0x18(%rax)
movb $0x46, 0x1(%r14)
movq %r14, %rdi
callq 0x878c
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x8aa6
movl $0x0, 0x10(%r14)
movq $0x0, 0x20(%r14)
jmp 0x8a9c
cmpl $0x0, 0x10(%r14)
je 0x8a85
movq 0x8(%r14), %rsi
leaq 0x1a5c(%rip), %rdi      # 0xa4d8
xorl %eax, %eax
callq 0x331d
jmp 0x8a90
movq %r14, %rdi
movq %rbx, %rsi
callq 0x8aa6
movl $0x1, 0x10(%r14)
movq %rbx, 0x18(%r14)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/pahihu[P]mixal/symbol.c
// Function: resolve_references
static void resolve_references(Symbol symbol, Cell definition)
{
    AddressList refs, rest;
    assert(!symbol->defined);
    for (refs = symbol->references; refs; refs = rest) {
	    asm_store_field(refs->address, 0, 2, definition);
	    rest = refs->next;
	    free(refs);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpl $0x0, 0x10(%rdi)
jne 0x8ae9
movq 0x20(%rdi), %r14
testq %r14, %r14
je 0x8ae3
movq %rsi, %rbx
movl 0x8(%r14), %edi
xorl %esi, %esi
movl $0x2, %edx
movq %rbx, %rcx
callq 0x363d
movq (%r14), %r15
movq %r14, %rdi
callq 0x3040
movq %r15, %r14
testq %r15, %r15
jne 0x8abd
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1993(%rip), %rdi      # 0xa483
leaq 0x1969(%rip), %rsi      # 0xa460
leaq 0x1a07(%rip), %rcx      # 0xa505
movl $0x87, %edx
callq 0x3130
// File: /workspace/github_c_makefile_star2_O1/CBaquero[P]random/Random.cc
// Function: RandomDUnif_RedisCommand(RedisModuleCtx*, RedisModuleString**, int)
int RandomDUnif_RedisCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {
  if (argc != 3) return RedisModule_WrongArity(ctx);
  long long start, end;
  if (
      (RedisModule_StringToLongLong(argv[1],&start) != REDISMODULE_OK) ||
      (RedisModule_StringToLongLong(argv[2],&end) != REDISMODULE_OK) ||
      (start > end) 
      ) 
    return RedisModule_ReplyWithError(ctx,"ERR invalid range");

  std::uniform_int_distribution<long long> rdunif(start,end);
  RedisModule_ReplyWithLongLong(ctx,rdunif(gen));
  return REDISMODULE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
cmpl $0x3, %edx
jne 0x4374
movq %rsi, %r14
movq 0x5bf5(%rip), %r15      # 0x9f20
movq 0x8(%rsi), %rdi
leaq -0x28(%rbp), %rsi
callq *(%r15)
testl %eax, %eax
jne 0x4356
movq 0x10(%r14), %rdi
leaq -0x20(%rbp), %rsi
callq *(%r15)
testl %eax, %eax
jne 0x4356
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq %rcx, %rax
jle 0x438a
movq 0x5a13(%rip), %rax      # 0x9d70
leaq 0x2d08(%rip), %rsi      # 0x706c
movq %rbx, %rdi
callq *(%rax)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x5bc5(%rip), %rax      # 0x9f40
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *(%rax)
leaq -0x38(%rbp), %rdi
movq %rax, (%rdi)
movq %rcx, 0x8(%rdi)
movq 0x5bd4(%rip), %rax      # 0x9f70
movq (%rax), %r14
movq 0x5bf2(%rip), %rsi      # 0x9f98
movq %rdi, %rdx
callq 0x4140
movq %rbx, %rdi
movq %rax, %rsi
callq *%r14
xorl %eax, %eax
jmp 0x4369
// File: /workspace/github_c_makefile_star2_O1/CBaquero[P]random/Random.cc
// Function: RandomUnif_RedisCommand(RedisModuleCtx*, RedisModuleString**, int)
int RandomUnif_RedisCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {
  if (argc != 3) return RedisModule_WrongArity(ctx);
  double start, end;
  if (
      (RedisModule_StringToDouble(argv[1],&start) != REDISMODULE_OK) ||
      (RedisModule_StringToDouble(argv[2],&end) != REDISMODULE_OK) ||
      (start > end) 
      ) 
    return RedisModule_ReplyWithError(ctx,"ERR invalid range");

  std::uniform_real_distribution<double> runif(start,end);
  RedisModule_ReplyWithDouble(ctx,runif(gen));
  return REDISMODULE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
cmpl $0x3, %edx
jne 0x4426
movq %rsi, %r14
movq 0x5b06(%rip), %r15      # 0x9ee0
movq 0x8(%rsi), %rdi
leaq -0x38(%rbp), %rsi
callq *(%r15)
testl %eax, %eax
jne 0x4408
movq 0x10(%r14), %rdi
leaq -0x30(%rbp), %rsi
callq *(%r15)
testl %eax, %eax
jne 0x4408
movsd -0x38(%rbp), %xmm0
movsd -0x30(%rbp), %xmm1
ucomisd %xmm1, %xmm0
jbe 0x443c
movq 0x5961(%rip), %rax      # 0x9d70
leaq 0x2c56(%rip), %rsi      # 0x706c
movq %rbx, %rdi
callq *(%rax)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x5b13(%rip), %rax      # 0x9f40
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *(%rax)
movq 0x57cd(%rip), %rax      # 0x9c10
movq (%rax), %r14
movq 0x5b4b(%rip), %rdi      # 0x9f98
movsd %xmm0, -0x28(%rbp)
movsd %xmm1, -0x20(%rbp)
callq 0x4180
movsd -0x28(%rbp), %xmm1
movsd -0x20(%rbp), %xmm2
subsd %xmm1, %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq %rbx, %rdi
callq *%r14
xorl %eax, %eax
jmp 0x441b
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq $0x0, -0x28(%rbp)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, -0x20(%rbp)
cmpl $0x4, %edx
jl 0x44bd
movq 0x5a92(%rip), %rax      # 0x9f40
movq %rbx, %rdi
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *(%rax)
movl %edx, %r15d
movq %rsi, %r14
cmpl $0x2, %edx
jl 0x44ed
movq 0x5a11(%rip), %rax      # 0x9ee0
movq 0x8(%r14), %rdi
leaq -0x28(%rbp), %rsi
callq *(%rax)
testl %eax, %eax
je 0x44ed
movq 0x588c(%rip), %rax      # 0x9d70
leaq 0x2b93(%rip), %rsi      # 0x707e
jmp 0x4516
cmpl $0x3, %r15d
jne 0x451d
movq 0x59e6(%rip), %rax      # 0x9ee0
movq 0x10(%r14), %rdi
leaq -0x20(%rbp), %rsi
callq *(%rax)
testl %eax, %eax
je 0x451d
movq 0x5861(%rip), %rax      # 0x9d70
leaq 0x2b79(%rip), %rsi      # 0x708f
movq %rbx, %rdi
callq *(%rax)
jmp 0x4561
movsd -0x28(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
leaq -0x48(%rbp), %rdi
movsd %xmm0, (%rdi)
movsd %xmm1, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
movq 0x56c9(%rip), %rax      # 0x9c10
movq (%rax), %r14
movq 0x5a47(%rip), %rsi      # 0x9f98
movq %rdi, %rdx
callq 0x41b0
movq %rbx, %rdi
callq *%r14
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4995
movq 0x55b8(%rip), %rax      # 0x9f40
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmpq *(%rax)
cmpl $0x2, %edx
jne 0x49c4
movq 0x553f(%rip), %rax      # 0x9ee0
movq 0x8(%rsi), %rdi
leaq -0x18(%rbp), %rsi
callq *(%rax)
testl %eax, %eax
je 0x49d2
movq 0x53ba(%rip), %rax      # 0x9d70
leaq 0x276d(%rip), %rsi      # 0x712a
movq %rbx, %rdi
callq *(%rax)
jmp 0x4a1c
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movq 0x522d(%rip), %rax      # 0x9c10
movq (%rax), %r14
movq 0x55ab(%rip), %rdi      # 0x9f98
callq 0x4180
movsd 0x2606(%rip), %xmm1     # 0x7000
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
callq 0x40e0
xorpd 0x2621(%rip), %xmm0     # 0x7030
divsd -0x20(%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_O1/giometti[P]mastering_UNIX_programming/chapter_08/environ.c
// Function: main
int main(int argc, char *argv[])
{
	int n;

	for (n = 0; environ[n]; n++)
		printf("environ[%d]=\"%s\"\n", n, environ[n]);

	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x2ea0(%rip), %r15      # 0x3fe8
movq (%r15), %rax
movq (%rax), %rdx
testq %rdx, %rdx
je 0x117a
leaq 0xeaa(%rip), %rbx       # 0x2004
xorl %r14d, %r14d
movq %rbx, %rdi
movl %r14d, %esi
xorl %eax, %eax
callq 0x1030
movq (%r15), %rax
movq 0x8(%rax,%r14,8), %rdx
incq %r14
testq %rdx, %rdx
jne 0x115d
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/mjosaarinen[P]brutus/crypto_aead/aes128n12t8silcv2/aesni/encrypt.c
// Function: load_partial_block
void load_partial_block(block* dst, const unsigned char* m, int len, unsigned choice)
{
    unsigned char temp[16];
    if(choice == ZERO_APPEND){
        memcpy(temp, m, len);
        memset(temp+len, 0, 16-len);
        *dst = LOAD(temp);
    }
    else if(choice == ZERO_PREPEND){
        memcpy(temp+16-len, m, len);
        memset(temp, 0, 16-len);
        *dst = LOAD(temp);
    }
    else if(choice == PARAM_ZP){
        memcpy(temp+16-len, m, len);
        memset(temp, 0, 16-len-1);
        temp[16-len-1] = PARAM;
        *dst = LOAD(temp);
    }
    else{
        // do nothing
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movq %rdi, %rbx
cmpl $0x3, %ecx
je 0x1366
cmpl $0x1, %ecx
je 0x133b
testl %ecx, %ecx
jne 0x13a4
movslq %ebp, %r14
movq %rsp, %rdi
movq %r14, %rdx
callq 0x1080
leaq (%rsp,%r14), %rdi
movl $0x10, %eax
subl %ebp, %eax
movslq %eax, %rdx
jmp 0x135d
movslq %ebp, %rdx
movq %rsp, %r14
movq %r14, %rdi
subq %rdx, %rdi
addq $0x10, %rdi
callq 0x1080
movl $0x10, %eax
subl %ebp, %eax
movslq %eax, %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0x1030
jmp 0x139b
movslq %ebp, %r14
movq %rsp, %r15
movq %r15, %rdi
subq %r14, %rdi
addq $0x10, %rdi
movq %r14, %rdx
callq 0x1080
movl $0xf, %eax
subl %r14d, %eax
movslq %eax, %r14
movq %r15, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x1030
movb $-0x40, (%rsp,%r14)
vmovaps (%rsp), %xmm0
vmovaps %xmm0, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mjosaarinen[P]brutus/crypto_aead/aes128n12t8silcv2/aesni/encrypt.c
// Function: xor_length
void xor_length(block* st, unsigned long long len)
{
    unsigned char temp[16] = { 0 };
    int i;
    for(i = 0;i < 8;i++){
        temp[15-i] = len & 0xff;
        len >>= 8;
    }
    (*st) = XOR((*st), LOAD(temp));
}

// Assembly:
vxorps %xmm0, %xmm0, %xmm0
vmovaps %xmm0, -0x18(%rsp)
movl $0xf, %eax
movb %sil, -0x18(%rsp,%rax)
shrq $0x8, %rsi
decq %rax
cmpq $0x7, %rax
jne 0x13be
vmovaps -0x18(%rsp), %xmm0
vxorps (%rdi), %xmm0, %xmm0
vmovaps %xmm0, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/glk[P]critbit/critbit.c
// Function: critbit_buf_get
static __inline struct critbit_key *
critbit_get_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_node *node;
	struct critbit_ref *ref;
	uint8_t c;

	ref = t->ct_root;
	if (ref == NULL)
		return (0);

	while (critbit_ref_is_internal(ref)) {
		node = critbit_ref_get_node(ref);

		c = 0;
		if (node->byte < keylen)
			c = ubytes[node->byte];

		const int direction = (1 + (node->otherbits | c)) >> 8;
		ref = node->child[direction];
	}

	if (keycmp(keybuf(critbit_ref_get_key(ref)), ubytes, keylen) == 0)
		return (critbit_ref_get_key(ref));

	return (NULL);
}

// Assembly:
pushq %rbx
movq (%rdi), %rbx
testq %rbx, %rbx
je 0xd21e
movq 0x8(%rdi), %rdx
testb $0x1, %bl
je 0xd20a
movl 0xf(%rbx), %eax
cmpq %rax, %rdx
jbe 0xd1f6
movzbl (%rsi,%rax), %eax
jmp 0xd1f8
xorl %eax, %eax
movzbl 0x13(%rbx), %ecx
orl %ecx, %eax
incl %eax
shrl $0x8, %eax
movq -0x1(%rbx,%rax,8), %rbx
jmp 0xd1e3
movq %rbx, %rdi
callq 0xd0b0
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
cmoveq %rbx, %rax
jmp 0xd220
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xd3c6
movq %rdi, %r14
movq 0x8(%rdi), %rdx
testb $0x1, %bl
jne 0xd379
movl $0x1, %r13d
xorl %r15d, %r15d
xorl %r12d, %r12d
jmp 0xd3ba
movq %r14, %rax
movq %rax, %r12
movl 0xf(%rbx), %ecx
xorl %eax, %eax
cmpq %rcx, %rdx
jbe 0xd38d
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 0xd37c
xorl $0x1, %r13d
movq %rbx, %rdi
callq 0xd0b0
testl %eax, %eax
je 0xd3d5
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
testq %r12, %r12
je 0xd3ee
movq (%r15,%r13,8), %rax
movq %rax, (%r12)
movq %r14, %rdi
movq %r15, %rsi
callq *0x18(%r14)
jmp 0xd3c8
movq $0x0, (%r14)
jmp 0xd3c8
// File: /workspace/github_c_makefile_star2_O1/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 0x1238
xorl %r12d, %r12d
jmp 0x135f
leaq 0x1fec(%rip), %rsi      # 0x322b
movl $0x4, %edi
xorl %eax, %eax
callq 0x16b2
leaq 0x1dca(%rip), %rsi      # 0x301c
leaq 0x1fe9(%rip), %rdx      # 0x3242
movq $-0x1, %rdi
callq 0x1110
movq %rax, 0x3e84(%rip)      # 0x50f0
movq 0x3e7d(%rip), %r12      # 0x50f0
cmpq $0x0, 0x3e75(%rip)      # 0x50f0
je 0x12cb
movq 0x3e6c(%rip), %rcx      # 0x50f0
leaq 0x1ea1(%rip), %rsi      # 0x312c
leaq 0x1d8a(%rip), %rdx      # 0x301c
movq 0x3d2f(%rip), %r8       # 0x4fc8
movl $0x5, %edi
xorl %eax, %eax
callq 0x16b2
cmpq $0x0, 0x3e43(%rip)      # 0x50f0
je 0x12d4
movq 0x3e3a(%rip), %rax      # 0x50f0
leaq 0x1d5f(%rip), %rsi      # 0x301c
movq $-0x1, %rdi
callq *%rax
movq %rax, %r15
jmp 0x12f1
leaq 0x1f37(%rip), %rsi      # 0x3209
jmp 0x134c
leaq 0x1f73(%rip), %rsi      # 0x324e
leaq 0x1d3a(%rip), %rdx      # 0x301c
xorl %r15d, %r15d
movl $0x2, %edi
xorl %eax, %eax
callq 0x16b2
cmpq 0x3df8(%rip), %r15      # 0x50f0
je 0x135f
testq %r15, %r15
je 0x1345
leaq 0x1e47(%rip), %rdi      # 0x314d
movl $0x1, %esi
callq 0x1fa0
movq 0x3dd9(%rip), %rcx      # 0x50f0
testl %eax, %eax
je 0x13fd
leaq 0x1e42(%rip), %rsi      # 0x3168
leaq 0x1cef(%rip), %rdx      # 0x301c
movl $0x5, %edi
movq %r15, %r8
xorl %eax, %eax
callq 0x16b2
movq %r15, 0x3dad(%rip)      # 0x50f0
jmp 0x135f
leaq 0x1e83(%rip), %rsi      # 0x31cf
leaq 0x1cc9(%rip), %rdx      # 0x301c
movl $0x2, %edi
xorl %eax, %eax
callq 0x16b2
testq %r12, %r12
je 0x1386
cmpq $0x0, 0x3db4(%rip)      # 0x5120
jne 0x1386
leaq 0x1db0(%rip), %rsi      # 0x3125
movq $-0x1, %rdi
callq *%r12
movq %rax, 0x3d9a(%rip)      # 0x5120
leaq 0x3d3b(%rip), %rdi      # 0x50c8
callq 0x10c0
leaq 0x2e1(%rip), %rsi       # 0x167a
leaq 0x1c7c(%rip), %rdx      # 0x301c
movq %rbx, %rdi
callq 0x141f
testq %rax, %rax
je 0x13b9
movq %rax, %r15
leaq 0x1c81(%rip), %r9       # 0x3038
jmp 0x13d2
movq 0x3d30(%rip), %rax      # 0x50f0
movq %r14, %rdi
movq %rbx, %rsi
callq *%rax
movq %rax, %r15
leaq 0x1ffc(%rip), %r9       # 0x33ce
leaq 0x1c49(%rip), %rsi      # 0x3022
movl $0x5, %edi
movq %r14, %rdx
movq %rbx, %rcx
movq %r15, %r8
xorl %eax, %eax
callq 0x16b2
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x1d8b(%rip), %rsi      # 0x318f
leaq 0x1c11(%rip), %rdx      # 0x301c
movl $0x2, %edi
movq %r15, %r8
xorl %eax, %eax
callq 0x16b2
jmp 0x135f
// File: /workspace/github_c_makefile_star2_O1/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 0x37b8(%rip), %rdi      # 0x50c8
callq 0x1120
cmpq $0x0, 0x37db(%rip)      # 0x50f8
jne 0x1969
cmpq $0x0, 0x37c9(%rip)      # 0x50f0
je 0x1945
movq 0x37c0(%rip), %rax      # 0x50f0
leaq 0x1710(%rip), %rsi      # 0x3047
movq $-0x1, %rdi
callq *%rax
movq %rax, %r14
jmp 0x1962
leaq 0x1902(%rip), %rsi      # 0x324e
leaq 0x16f4(%rip), %rdx      # 0x3047
xorl %r14d, %r14d
movl $0x2, %edi
xorl %eax, %eax
callq 0x16b2
movq %r14, 0x378f(%rip)      # 0x50f8
leaq 0x3758(%rip), %rdi      # 0x50c8
callq 0x10c0
movq 0x377c(%rip), %rsi      # 0x50f8
leaq 0x16c4(%rip), %rdx      # 0x3047
movq %rbx, %rdi
callq 0x141f
testq %rax, %rax
je 0x199c
movq %rax, %r14
leaq 0x169e(%rip), %r8       # 0x3038
jmp 0x19b2
movq 0x3755(%rip), %rax      # 0x50f8
movq %rbx, %rdi
callq *%rax
movq %rax, %r14
leaq 0x1a1c(%rip), %r8       # 0x33ce
leaq 0x16a0(%rip), %rsi      # 0x3059
movl $0x5, %edi
movq %rbx, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x16b2
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1b10
movl %eax, %ebp
negl %eax
jno 0x1ac6
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x35fb(%rip), %rdi      # 0x50c8
callq 0x1120
cmpq $0x0, 0x362e(%rip)      # 0x5108
jne 0x1aef
leaq 0x15ca(%rip), %rdi      # 0x30ad
callq 0x1de6
movq %rax, 0x3619(%rip)      # 0x5108
leaq 0x35d2(%rip), %rdi      # 0x50c8
callq 0x10c0
movq 0x3606(%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_O1/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 0x32fc(%rip), %rax      # 0x50f0
movq $-0x1, %rdi
movq %rbx, %rsi
callq *%rax
testq %rax, %rax
je 0x1e0d
addq $0x8, %rsp
popq %rbx
popq %r14
retq
cmpb $0x0, 0x3354(%rip)      # 0x5168
jne 0x1e8c
cmpq $0x0, 0x3342(%rip)      # 0x5160
jne 0x1e8c
leaq 0x156c(%rip), %rdi      # 0x3393
callq 0x1030
testq %rax, %rax
leaq 0x156b(%rip), %r14      # 0x33a1
cmovneq %rax, %r14
cmpb $0x0, (%r14)
je 0x1e85
leaq 0x1563(%rip), %rsi      # 0x33aa
movl $0x4, %edi
movq %r14, %rdx
xorl %eax, %eax
callq 0x16b2
movq %r14, %rdi
movl $0x101, %esi            # imm = 0x101
callq 0x10a0
movq %rax, 0x32f6(%rip)      # 0x5160
testq %rax, %rax
jne 0x1e8c
leaq 0x1559(%rip), %rsi      # 0x33cf
movl $0x2, %edi
movq %r14, %rdx
xorl %eax, %eax
callq 0x16b2
movb $0x1, 0x32dc(%rip)      # 0x5168
cmpq $0x0, 0x32cc(%rip)      # 0x5160
je 0x1ec6
leaq 0x1550(%rip), %rsi      # 0x33ed
movl $0x4, %edi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x16b2
movq 0x323d(%rip), %rax      # 0x50f0
movq 0x32a6(%rip), %rdi      # 0x5160
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
xorl %eax, %eax
jmp 0x1e05
// File: /workspace/github_c_makefile_star2_O1/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 0x1b10
movl %eax, %ebx
negl %eax
jno 0x1edd
xorl %eax, %eax
popq %rbx
retq
leaq 0x31e4(%rip), %rdi      # 0x50c8
callq 0x1120
cmpq $0x0, 0x321f(%rip)      # 0x5110
jne 0x1f06
leaq 0x11c6(%rip), %rdi      # 0x30c0
callq 0x1de6
movq %rax, 0x320a(%rip)      # 0x5110
leaq 0x31bb(%rip), %rdi      # 0x50c8
callq 0x10c0
movq 0x31f7(%rip), %rax      # 0x5110
movl %ebx, %edi
popq %rbx
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/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 0x1b10
movl %eax, %ebp
negl %ebp
jno 0x1f3f
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movl %eax, %ebx
testl %eax, %eax
jns 0x1f5a
leaq 0x1187(%rip), %rsi      # 0x30d3
movl $0x2, %edi
xorl %eax, %eax
callq 0x16b2
movl %ebp, %ebx
leaq 0x3167(%rip), %rdi      # 0x50c8
callq 0x1120
cmpq $0x0, 0x31aa(%rip)      # 0x5118
jne 0x1f83
leaq 0x119a(%rip), %rdi      # 0x3111
callq 0x1de6
movq %rax, 0x3195(%rip)      # 0x5118
leaq 0x313e(%rip), %rdi      # 0x50c8
callq 0x10c0
movq 0x3182(%rip), %rax      # 0x5118
movl %ebx, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/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 0x1fbc
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_O1/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 %r14
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %rbx
leaq 0x20(%rsp), %rdx
movq %r8, 0x20(%rdx)
movq %r9, 0x28(%rdx)
testb %al, %al
je 0x2015
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movl $0xfff, %r14d           # imm = 0xFFF
subq %rsi, %r14
movq %rsp, %rax
movq %rdx, 0x10(%rax)
leaq 0xf0(%rsp), %rdx
movq %rdx, 0x8(%rax)
movabsq $0x3000000020, %rdx     # imm = 0x3000000020
movq %rdx, (%rax)
addq %rsi, %rdi
movq %r14, %rsi
movq %rcx, %rdx
movq %rax, %rcx
callq 0x1050
movl %eax, %ecx
cmpq %rcx, %r14
cmovaeq %rcx, %r14
xorl %ecx, %ecx
testl %eax, %eax
cmovgq %r14, %rcx
addq %rbx, %rcx
movq %rcx, %rax
addq $0xd8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
leaq 0x8(%rsp), %rcx
movl $0x0, (%rcx)
leaq 0xc(%rsp), %r8
movl $0x4, (%r8)
movl %esi, %edi
movl $0x1, %esi
movl $0x4, %edx
callq 0x2250
cmpl $-0x1, %eax
je 0x25cc
movl 0x8(%rsp), %ebp
testl %ebp, %ebp
je 0x25e9
callq 0x2080
movl %ebp, (%rax)
movq %r14, %rdi
xorl %esi, %esi
jmp 0x25d6
leaq 0x4a2d(%rip), %rsi      # 0x7000
movq %r14, %rdi
callq 0x25f4
movl %ebx, %edi
callq 0x21e0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x25eb
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r15d
movl %esi, %ebx
movq %rdi, %r14
xorl %ebp, %ebp
movl %esi, %edi
movl $0x3, %esi
xorl %eax, %eax
callq 0x2100
cmpl $-0x1, %eax
je 0x291b
xorl %edx, %edx
testl %r15d, %r15d
sete %dl
andl $0xfffff7ff, %eax       # imm = 0xFFFFF7FF
shll $0xb, %edx
orl %eax, %edx
movl %ebx, %edi
movl $0x4, %esi
xorl %eax, %eax
callq 0x2100
cmpl $-0x1, %eax
jne 0x2936
leaq 0x475b(%rip), %rsi      # 0x7074
jmp 0x2922
leaq 0x4743(%rip), %rsi      # 0x7065
movq %r14, %rdi
callq 0x25f4
movl %ebx, %edi
callq 0x21e0
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/winton[P]redis_parse/hiredis/net.c
// Function: redisContextWaitReady
static int redisContextWaitReady(redisContext *c, int fd, const struct timeval *timeout) {
    struct timeval to;
    struct timeval *toptr = NULL;
    fd_set wfd;

    /* Only use timeout when not NULL. */
    if (timeout != NULL) {
        to = *timeout;
        toptr = &to;
    }

    if (errno == EINPROGRESS) {
        FD_ZERO(&wfd);
        FD_SET(fd, &wfd);

        if (select(FD_SETSIZE, NULL, &wfd, NULL, toptr) == -1) {
            __redisSetErrorFromErrno(c,REDIS_ERR_IO,"select(2)");
            close(fd);
            return REDIS_ERR;
        }

        if (!FD_ISSET(fd, &wfd)) {
            errno = ETIMEDOUT;
            __redisSetErrorFromErrno(c,REDIS_ERR_IO,NULL);
            close(fd);
            return REDIS_ERR;
        }

        if (redisCheckSocketError(c, fd) != REDIS_OK)
            return REDIS_ERR;

        return REDIS_OK;
    }

    __redisSetErrorFromErrno(c,REDIS_ERR_IO,NULL);
    close(fd);
    return REDIS_ERR;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movl %esi, %ebx
movq %rdi, %r14
testq %rdx, %rdx
je 0x296b
movups (%rdx), %xmm0
movq %rsp, %r12
movaps %xmm0, (%r12)
jmp 0x296e
xorl %r12d, %r12d
callq 0x2080
cmpl $0x73, (%rax)
jne 0x2a0f
movq %rax, %r15
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdx
movaps %xmm0, 0x70(%rdx)
movaps %xmm0, 0x60(%rdx)
movaps %xmm0, 0x50(%rdx)
movaps %xmm0, 0x40(%rdx)
movaps %xmm0, 0x30(%rdx)
movaps %xmm0, 0x20(%rdx)
movaps %xmm0, 0x10(%rdx)
movaps %xmm0, (%rdx)
leal 0x3f(%rbx), %eax
testl %ebx, %ebx
cmovnsl %ebx, %eax
movl %eax, %esi
andl $-0x40, %esi
movl %ebx, %ecx
subl %esi, %ecx
movl $0x1, %r13d
shlq %cl, %r13
sarl $0x6, %eax
movslq %eax, %rbp
orq %r13, 0x10(%rsp,%rbp,8)
movl $0x400, %edi            # imm = 0x400
xorl %esi, %esi
xorl %ecx, %ecx
movq %r12, %r8
callq 0x22d0
cmpl $-0x1, %eax
je 0x29fc
testq %r13, 0x10(%rsp,%rbp,8)
je 0x2a08
movq %r14, %rdi
movl %ebx, %esi
callq 0x2150
movl %eax, %ecx
xorl %eax, %eax
negl %ecx
sbbl %eax, %eax
jmp 0x2a25
leaq 0x4680(%rip), %rsi      # 0x7083
movq %r14, %rdi
jmp 0x2a14
movl $0x6e, (%r15)
movq %r14, %rdi
xorl %esi, %esi
callq 0x25f4
movl %ebx, %edi
callq 0x21e0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl %eax, %r14d
cmpl $-0x1, %eax
jne 0x2a7e
movq %rbx, %rdi
xorl %esi, %esi
callq 0x25f4
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testl %r14d, %r14d
js 0x2b1c
movq %rbx, %rdi
movl %r14d, %esi
xorl %edx, %edx
callq 0x28c9
testl %eax, %eax
jne 0x2b1c
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
jne 0x2af2
callq 0x2080
movl (%rax), %eax
xorl $0x73, %eax
movl %r13d, %ecx
andl $0x1, %ecx
orl %eax, %ecx
je 0x2af2
movq %rbx, %rdi
movl %r14d, %esi
movq %r15, %rdx
callq 0x2943
testl %eax, %eax
jne 0x2b1c
testb $0x1, %r13b
je 0x2b0c
movq %rbx, %rdi
movl %r14d, %esi
movl $0x1, %edx
callq 0x28c9
testl %eax, %eax
jne 0x2b1c
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_O1/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 0x3ce8
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_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq %rdx, (%r15)
movq %rcx, 0x8(%r15)
callq 0x3ce8
movq %rax, %r12
orb $0x1, 0x88(%rax)
movq %rax, %rdi
movq %r14, %rsi
movl %ebx, %edx
movq %r15, %rcx
callq 0x2390
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3ce8
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_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x3ce8
movq %rax, %r14
orb $0x1, 0x88(%rax)
movq %rax, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x2290
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3ce8
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_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x3ce8
movq %rax, %r14
andb $-0x2, 0x88(%rax)
movq %rax, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x2290
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x413c
movq %rax, 0x90(%rbx)
xorl %eax, %eax
jmp 0x4167
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_O1/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 0x494c
movq %rax, %r14
movl %ebx, (%rax)
movl $0x0, 0x4(%rax)
testq %rbx, %rbx
je 0x495a
leaq 0x8(%r14), %rdi
testq %r15, %r15
je 0x4950
movq %r15, %rsi
movq %rbx, %rdx
callq 0x22c0
jmp 0x495a
xorl %eax, %eax
jmp 0x4967
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_O1/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 %rbx
movq %rdi, %rbx
callq 0x2130
movl -0x8(%rbx), %ecx
subl %eax, %ecx
addl %ecx, -0x4(%rbx)
movl %eax, -0x8(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4a8f
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 0x4a86
addq %rbx, %rbx
subl %r14d, %ebx
movl %ebx, 0x4(%rax)
addq $0x8, %rax
jmp 0x4a88
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4a44
testq %rax, %rax
je 0x4ad5
movq %rax, %r14
movq %rax, %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)
jmp 0x4ad8
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq