LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/antonblanchard[P]will-it-scale/tests/page_fault1.c
// Function: testcase
void testcase(unsigned long long *iterations, unsigned long nr)
{
	unsigned long pgsize = getpagesize();

	while (1) {
		unsigned long i;

		char *c = mmap(NULL, MEMSIZE, PROT_READ|PROT_WRITE,
			       MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
		assert(c != MAP_FAILED);

		for (i = 0; i < MEMSIZE; i += pgsize) {
			c[i] = 0;
			(*iterations)++;
		}

		munmap(c, MEMSIZE);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x2270
movslq %eax, %r12
pushq $0x3
popq %rbp
pushq $0x22
popq %r14
pushq $-0x1
popq %r15
movl $0x8000000, %esi        # imm = 0x8000000
xorl %edi, %edi
movl %ebp, %edx
movl %r14d, %ecx
movl %r15d, %r8d
xorl %r9d, %r9d
callq 0x20e0
cmpq $-0x1, %rax
je 0x2b91
xorl %ecx, %ecx
cmpq $0x7ffffff, %rcx        # imm = 0x7FFFFFF
ja 0x2b82
movb $0x0, (%rax,%rcx)
incq (%rbx)
addq %r12, %rcx
jmp 0x2b6d
movl $0x8000000, %esi        # imm = 0x8000000
movq %rax, %rdi
callq 0x21d0
jmp 0x2b4e
leaq 0x6ec(%rip), %rdi       # 0x3284
leaq 0x6f5(%rip), %rsi       # 0x3294
leaq 0x702(%rip), %rcx       # 0x32a8
pushq $0x13
popq %rdx
callq 0x2120
// File: /workspace/github_c_makefile_star2_O2/oreparaz[P]dudect/src/dudect.h
// Function: randombytes
void randombytes(uint8_t *x, size_t how_much) {
  ssize_t i;
  static int fd = -1;

  ssize_t xlen = (ssize_t)how_much;
  assert(xlen >= 0);
  if (fd == -1) {
    for (;;) {
      fd = open("/dev/urandom", O_RDONLY);
      if (fd != -1)
        break;
      sleep(1);
    }
  }

  while (xlen > 0) {
    if (xlen < 1048576)
      i = xlen;
    else
      i = 1048576;

    i = read(fd, x, (size_t)i);
    if (i < 1) {
      sleep(1);
      continue;
    }

    x += i;
    xlen -= i;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
js 0x1272
movq %rsi, %rbx
movq %rdi, %r14
cmpl $-0x1, 0x1ee83(%rip)    # 0x20088
jne 0x1255
leaq 0x1cedd(%rip), %r15     # 0x1e0eb
pushq $0x1
popq %rbp
movq %r15, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x10c0
movl %eax, 0x1ee65(%rip)     # 0x20088
cmpl $-0x1, %eax
jne 0x1255
movl %ebp, %edi
callq 0x10e0
jmp 0x1211
pushq $0x1
popq %rdi
callq 0x10e0
movl 0x1ee49(%rip), %edi     # 0x20088
movq %r14, %rsi
movq %r15, %rdx
callq 0x10a0
testq %rax, %rax
jle 0x1231
addq %rax, %r14
subq %rax, %rbx
movl $0x100000, %r15d        # imm = 0x100000
cmpq %r15, %rbx
cmovbq %rbx, %r15
testq %rbx, %rbx
jg 0x1239
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1ce37(%rip), %rdi     # 0x1e0b0
leaq 0x1ce3a(%rip), %rsi     # 0x1e0ba
leaq 0x1ce40(%rip), %rcx     # 0x1e0c7
movl $0xec, %edx
callq 0x1080
// File: /workspace/github_c_makefile_star2_O2/oreparaz[P]dudect/examples/aesbitsliced/dut_aesbitsliced.c
// Function: prepare_inputs
void prepare_inputs(dudect_config_t *c, uint8_t *input_data, uint8_t *classes) {
  randombytes(input_data, c->number_measurements * c->chunk_size);
  for (size_t i = 0; i < c->number_measurements; i++) {
    classes[i] = randombit();
    if (classes[i] == 0) {
      memset(input_data + (size_t)i * c->chunk_size, 0x00, c->chunk_size);
    } else {
      // leave random
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rsi
imulq 0x8(%rdi), %rsi
movq %r14, %rdi
callq 0x11ec
xorl %r12d, %r12d
cmpq 0x8(%r15), %r12
jae 0x16c5
callq 0x1291
movb %al, (%rbx,%r12)
testb %al, %al
jne 0x16c0
movq (%r15), %rdx
movq %rdx, %rdi
imulq %r12, %rdi
addq %r14, %rdi
xorl %esi, %esi
callq 0x1090
incq %r12
jmp 0x1699
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/oreparaz[P]dudect/src/dudect.h
// Function: dudect_free
int dudect_free(dudect_ctx_t *ctx)
{
  for (int i = 0; i < DUDECT_TESTS; i++) {
    free(ctx->ttest_ctxs[i]);
  }
  free(ctx->percentiles);
  free(ctx->input_data);
  free(ctx->classes);
  free(ctx->exec_times);
  free(ctx->ticks);
  free(ctx->config);
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x5
popq %r14
cmpq $0x6b, %r14
je 0x18cd
movq (%rbx,%r14,8), %rdi
callq 0x1040
incq %r14
jmp 0x18b9
movq 0x358(%rbx), %rdi
callq 0x1040
movq 0x10(%rbx), %rdi
callq 0x1040
movq 0x18(%rbx), %rdi
callq 0x1040
movq 0x8(%rbx), %rdi
callq 0x1040
movq (%rbx), %rdi
callq 0x1040
movq 0x20(%rbx), %rdi
callq 0x1040
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/oreparaz[P]dudect/examples/aesbitsliced/dut_aesbitsliced.c
// Function: do_one_computation
uint8_t do_one_computation(uint8_t *data) {
  uint8_t in[16] = {0};
  uint8_t out[16] = {0};
  uint8_t key[16] = {0x01,0};
  uint8_t ret = 0;

  memcpy(in, data, 16);
  crypto_stream(out, 16, in, key);
  ret ^= out[0];
  return ret;
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rbx
movaps %xmm0, (%rbx)
movaps 0x1c76a(%rip), %xmm0    # 0x1e090
movq %rsp, %rcx
movaps %xmm0, (%rcx)
movups (%rdi), %xmm0
leaq 0x20(%rsp), %rdx
movaps %xmm0, (%rdx)
pushq $0x10
popq %rsi
movq %rbx, %rdi
callq 0x14530
movb (%rbx), %al
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/oreparaz[P]dudect/examples/aesbitsliced/dut_aesbitsliced.c
// Function: main
int main(int argc, char **argv)
{
  (void)argc;
  (void)argv;

  dudect_config_t config = {
     .chunk_size = 16,
     .number_measurements = 1e6,
  };
  dudect_ctx_t ctx;

  dudect_init(&ctx, &config);

  dudect_state_t state = DUDECT_NO_LEAKAGE_EVIDENCE_YET;
  while (state == DUDECT_NO_LEAKAGE_EVIDENCE_YET) {
    state = dudect_main(&ctx);
  }
  dudect_free(&ctx);
  return (int)state;
}

// Assembly:
pushq %rbx
subq $0x360, %rsp            # imm = 0x360
leaq 0x1c747(%rip), %rsi     # 0x1e0a0
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x16d1
pushq $0x1
popq %rax
testl %eax, %eax
je 0x1975
movq %rbx, %rdi
callq 0x12b3
jmp 0x1967
movq %rsp, %rdi
callq 0x18ae
xorl %eax, %eax
addq $0x360, %rsp            # imm = 0x360
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/oreparaz[P]dudect/src/dudect.h
// Function: t_push
static void t_push(ttest_ctx_t *ctx, double x, uint8_t clazz) {
  assert(clazz == 0 || clazz == 1);
  ctx->n[clazz]++;
  /*
   estimate variance on the fly as per the Welford method.
   this gives good numerical stability, see Knuth's TAOCP vol 2
  */
  double delta = x - ctx->mean[clazz];
  ctx->mean[clazz] = ctx->mean[clazz] + delta / ctx->n[clazz];
  ctx->m2[clazz] = ctx->m2[clazz] + delta * (x - ctx->mean[clazz]);
}

// Assembly:
cmpb $0x2, %sil
jae 0x19ee
movzbl %sil, %eax
movsd (%rdi,%rax,8), %xmm1
movsd 0x20(%rdi,%rax,8), %xmm2
addsd 0x1c67e(%rip), %xmm2    # 0x1e038
movsd %xmm2, 0x20(%rdi,%rax,8)
movapd %xmm0, %xmm3
subsd %xmm1, %xmm3
movapd %xmm3, %xmm4
divsd %xmm2, %xmm4
addsd %xmm1, %xmm4
movsd %xmm4, (%rdi,%rax,8)
subsd %xmm4, %xmm0
mulsd %xmm3, %xmm0
addsd 0x10(%rdi,%rax,8), %xmm0
movsd %xmm0, 0x10(%rdi,%rax,8)
retq
pushq %rax
leaq 0x1c7d5(%rip), %rdi     # 0x1e1cb
leaq 0x1c6bd(%rip), %rsi     # 0x1e0ba
leaq 0x1c7e0(%rip), %rcx     # 0x1e1e4
movl $0xae, %edx
callq 0x1080
// File: /workspace/github_c_makefile_star2_O2/oreparaz[P]dudect/src/dudect.h
// Function: t_compute
static double t_compute(ttest_ctx_t *ctx) {
  double var[2] = {0.0, 0.0};
  var[0] = ctx->m2[0] / (ctx->n[0] - 1);
  var[1] = ctx->m2[1] / (ctx->n[1] - 1);
  double num = (ctx->mean[0] - ctx->mean[1]);
  double den = sqrt(var[0] / ctx->n[0] + var[1] / ctx->n[1]);
  double t_value = num / den;
  return t_value;
}

// Assembly:
movsd (%rdi), %xmm3
subsd 0x8(%rdi), %xmm3
movupd 0x10(%rdi), %xmm1
movupd 0x20(%rdi), %xmm0
movapd 0x1c657(%rip), %xmm2    # 0x1e080
addpd %xmm0, %xmm2
divpd %xmm2, %xmm1
divpd %xmm0, %xmm1
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x1a51
sqrtsd %xmm0, %xmm0
jmp 0x1a65
pushq %rax
movsd %xmm3, (%rsp)
callq 0x10d0
movsd (%rsp), %xmm3
addq $0x8, %rsp
divsd %xmm0, %xmm3
movapd %xmm3, %xmm0
retq
nop
// File: /workspace/github_c_makefile_star2_O2/oreparaz[P]dudect/examples/aesbitsliced/int128_aes128ctr.c
// Function: crypto_stream_aes128ctr_portable_rshift32_littleendian
void rshift32_littleendian(int128 *r, const unsigned int n)
{
  unsigned char *rp = (unsigned char *)r;
  uint32 t;
  t = load32_littleendian(rp);
  t >>= n;
  store32_littleendian(rp, t);
  t = load32_littleendian(rp+4);
  t >>= n;
  store32_littleendian(rp+4, t);
  t = load32_littleendian(rp+8);
  t >>= n;
  store32_littleendian(rp+8, t);
  t = load32_littleendian(rp+12);
  t >>= n;
  store32_littleendian(rp+12, t);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
callq 0x142aa
movl %ebp, %ecx
shrl %cl, %eax
movq %rbx, %rdi
movl %eax, %esi
callq 0x142ad
leaq 0x4(%rbx), %r14
movq %r14, %rdi
callq 0x142aa
movl %ebp, %ecx
shrl %cl, %eax
movq %r14, %rdi
movl %eax, %esi
callq 0x142ad
leaq 0x8(%rbx), %r14
movq %r14, %rdi
callq 0x142aa
movl %ebp, %ecx
shrl %cl, %eax
movq %r14, %rdi
movl %eax, %esi
callq 0x142ad
addq $0xc, %rbx
movq %rbx, %rdi
callq 0x142aa
movl %ebp, %ecx
shrl %cl, %eax
movq %rbx, %rdi
movl %eax, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x142ad
// File: /workspace/github_c_makefile_star2_O2/oreparaz[P]dudect/examples/aesbitsliced/int128_aes128ctr.c
// Function: crypto_stream_aes128ctr_portable_rshift64_littleendian
void rshift64_littleendian(int128 *r, const unsigned int n)
{
  unsigned char *rp = (unsigned char *)r;
  uint64 t;
  t = load64_littleendian(rp);
  t >>= n;
  store64_littleendian(rp, t);
  t = load64_littleendian(rp+8);
  t >>= n;
  store64_littleendian(rp+8, t);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x142b0
movl %ebx, %ecx
shrq %cl, %rax
movq %r14, %rdi
movq %rax, %rsi
callq 0x142b4
addq $0x8, %r14
movq %r14, %rdi
callq 0x142b0
movl %ebx, %ecx
shrq %cl, %rax
movq %r14, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x142b4
// File: /workspace/github_c_makefile_star2_O2/eric-lo[P]3150/8-Synchronization/pthread_strtok_r.c
// Function: thread_func
void *thread_func(void *input)
{
	char *token;
	char *saveptr;		// the thread-specific data for reentrant
	int i = 0, thread_num;

	thread_num = ((char *) input)[strlen(input) - 1] - '0';
	printf("Thread %d: I start with the input %s\n", thread_num, (char *) input);

	token = strtok_r((char *) input, " ", &saveptr);		// initial step for strtok_r()
	do
	{
		printf("Thread %d: Token %d = %s\n", thread_num, i++, token);
		sleep(1);
	} while((token = strtok_r(NULL, " ", &saveptr)) != NULL);	// later steps for strtok_r()

	printf("Thread %d: terminated.\n", thread_num);

	pthread_exit(0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r12
callq 0x1030
movsbl -0x1(%r12,%rax), %ebx
addl $-0x30, %ebx
leaq 0xe35(%rip), %rdi       # 0x2004
movl %ebx, %esi
movq %r12, %rdx
xorl %eax, %eax
callq 0x1040
leaq 0xe48(%rip), %r14       # 0x202a
movq %rsp, %r15
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1050
leaq 0xe32(%rip), %r12       # 0x202c
pushq $0x1
popq %rbp
xorl %edx, %edx
leal 0x1(%rdx), %r13d
movq %r12, %rdi
movl %ebx, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x1040
movl %ebp, %edi
callq 0x10a0
xorl %edi, %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1050
movl %r13d, %edx
testq %rax, %rax
jne 0x11ff
leaq 0xe11(%rip), %rdi       # 0x2046
movl %ebx, %esi
xorl %eax, %eax
callq 0x1040
xorl %edi, %edi
callq 0x1060
// File: /workspace/github_c_makefile_star2_O2/eric-lo[P]3150/8-Synchronization/pthread_strtok_r.c
// Function: main
int main(void)
{
	pthread_t tid[THREAD];
	char buf[THREAD][STR_MAX];
	int i;

	for(i = 0; i < THREAD; i++)
	{
		sprintf(buf[i], "Thread %d says: Linux is a cool operating system %d", i, i);
		pthread_create(&tid[i], NULL, thread_func, buf[i]);
	}

	for(i = 0; i < THREAD; i++)
		pthread_join(tid[i], NULL);

	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x810, %rsp            # imm = 0x810
movq %rsp, %rbx
leaq 0x10(%rsp), %r14
leaq 0xdfa(%rip), %r15       # 0x205e
leaq -0xbf(%rip), %r12       # 0x11ac
xorl %r13d, %r13d
cmpq $0x2, %r13
je 0x12a7
movq %r14, %rdi
movq %r15, %rsi
movl %r13d, %edx
movl %r13d, %ecx
xorl %eax, %eax
callq 0x1080
movq %rbx, %rdi
xorl %esi, %esi
movq %r12, %rdx
movq %r14, %rcx
callq 0x1070
incq %r13
addq $0x8, %rbx
addq $0x400, %r14            # imm = 0x400
jmp 0x126e
xorl %ebx, %ebx
cmpq $0x2, %rbx
je 0x12bf
movq (%rsp,%rbx,8), %rdi
xorl %esi, %esi
callq 0x1090
incq %rbx
jmp 0x12a9
xorl %eax, %eax
addq $0x810, %rsp            # imm = 0x810
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/ranbenbasat[P]RHHH/check1.cpp
// Function: conditionedcount(std::map<unsigned int, Counter, std::less<unsigned int>, std::allocator<std::pair<unsigned int const, Counter>>>*, std::vector<std::pair<int, unsigned int>, std::allocator<std::pair<int, unsigned int>>> const&, unsigned int, int)
int conditionedcount(map<Item, Counter> * m, const vector<Pair> &p, Item item, int mask) {
	vector<Pair> descendants; //the direct descendants of item,mask
	//int countcandidates=0;
	for (vector<Pair>::const_iterator it = p.begin(); it != p.end(); ++it) {
		if ((masks[it->first] & masks[mask]) == masks[mask] && (it->second & masks[mask]) == item) {
			//it is a descendant, now eliminate non-direct descendants
			vector<Pair> newdescendants;
			for (vector<Pair>::const_iterator iter = descendants.begin(); iter != descendants.end(); ++iter) {
				if ((masks[iter->first] & masks[it->first]) != masks[it->first] || (iter->second & masks[it->first]) != it->second) {
					newdescendants.push_back(*iter);
				}
			}
			descendants = newdescendants;
			descendants.push_back(*it);
		}
	}
	
	int s = m[mask][item].get();
	for (vector<Pair>::iterator iter = descendants.begin(); iter != descendants.end(); ++iter) {
		s -= m[iter->first][iter->second].get();
	}

	return s;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, 0x28(%rsp)
movl %edx, 0xc(%rsp)
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdi
movaps %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movq (%rsi), %r12
movslq %ecx, %rbp
leaq 0x4de9(%rip), %rbx      # 0x60e0
leaq 0x30(%rsp), %r13
movl %edx, 0x8(%rsp)
cmpq 0x8(%r14), %r12
je 0x139c
movslq (%r12), %rax
movl (%rbx,%rax,4), %ecx
movl (%rbx,%rbp,4), %eax
notl %ecx
testl %ecx, %eax
jne 0x1393
andl 0x4(%r12), %eax
cmpl %edx, %eax
jne 0x1393
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
andq $0x0, 0x40(%rsp)
movq 0x10(%rsp), %r15
cmpq 0x18(%rsp), %r15
je 0x136c
movslq (%r15), %rax
movl (%rbx,%rax,4), %ecx
movslq (%r12), %rax
movl (%rbx,%rax,4), %eax
notl %ecx
testl %ecx, %eax
jne 0x135b
andl 0x4(%r15), %eax
cmpl 0x4(%r12), %eax
je 0x1366
movq %r13, %rdi
movq %r15, %rsi
callq 0x1e4c
addq $0x8, %r15
jmp 0x1336
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %r13, %rsi
callq 0x1e6a
movq %r15, %rdi
movq %r12, %rsi
callq 0x1e4c
movq %r13, %rdi
callq 0x202c
movl 0x8(%rsp), %edx
addq $0x8, %r12
jmp 0x1300
imulq $0x30, %rbp, %rdi
movq 0x28(%rsp), %rbx
addq %rbx, %rdi
leaq 0xc(%rsp), %rsi
callq 0x1f38
movl (%rax), %ebp
movq 0x10(%rsp), %r14
cmpq 0x18(%rsp), %r14
je 0x13de
movslq (%r14), %rax
imulq $0x30, %rax, %rdi
addq %rbx, %rdi
addq $0x4, %r14
movq %r14, %rsi
callq 0x1f38
subl (%rax), %ebp
addq $0x4, %r14
jmp 0x13b9
leaq 0x10(%rsp), %rdi
callq 0x202c
movl %ebp, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x13ff
jmp 0x13ff
jmp 0x1404
movq %rax, %rbx
jmp 0x1411
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x202c
leaq 0x10(%rsp), %rdi
callq 0x202c
movq %rbx, %rdi
callq 0x1170
movq %rax, %rdi
callq 0x1f2d
// File: /workspace/github_c_makefile_star2_O2/mijallen[P]SimpleHTTPServer/lib/libyaml/tests/run-parser.c
// Function: main
int
main(int argc, char *argv[])
{
    int number;

    if (argc < 2) {
        printf("Usage: %s file1.yaml ...\n", argv[0]);
        return 0;
    }

    for (number = 1; number < argc; number ++)
    {
        FILE *file;
        yaml_parser_t parser;
        yaml_event_t event;
        int done = 0;
        int count = 0;
        int error = 0;

        printf("[%d] Parsing '%s': ", number, argv[number]);
        fflush(stdout);

        file = fopen(argv[number], "rb");
        assert(file);

        assert(yaml_parser_initialize(&parser));

        yaml_parser_set_input_file(&parser, file);

        while (!done)
        {
            if (!yaml_parser_parse(&parser, &event)) {
                error = 1;
                break;
            }

            done = (event.type == YAML_STREAM_END_EVENT);

            yaml_event_delete(&event);

            count ++;
        }

        yaml_parser_delete(&parser);

        assert(!fclose(file));

        printf("%s (%d events)\n", (error ? "FAILURE" : "SUCCESS"), count);
    }

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x258, %rsp            # imm = 0x258
movq %rsi, %rbx
cmpl $0x2, %edi
jge 0x120a
movq (%rbx), %rsi
leaq 0xe15(%rip), %rdi       # 0x2004
xorl %eax, %eax
callq 0x1060
xorl %eax, %eax
addq $0x258, %rsp            # imm = 0x258
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %edi, %eax
movq %rax, 0x8(%rsp)
pushq $0x1
popq %r14
leaq 0x78(%rsp), %r13
leaq 0x10(%rsp), %rbp
movq %rbx, (%rsp)
cmpq 0x8(%rsp), %r14
je 0x11f6
movq (%rbx,%r14,8), %rdx
leaq 0xde9(%rip), %rdi       # 0x201e
movl %r14d, %esi
xorl %eax, %eax
callq 0x1060
movq 0x2d9a(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
callq 0x10a0
movq (%rbx,%r14,8), %rdi
leaq 0xdd9(%rip), %rsi       # 0x2032
callq 0x10b0
testq %rax, %rax
je 0x12f9
movq %rax, %r12
movq %r13, %rdi
callq 0x1090
testl %eax, %eax
je 0x1312
movq %r13, %rdi
movq %r12, %rsi
callq 0x1030
xorl %ebx, %ebx
xorl %r15d, %r15d
testl %ebx, %ebx
jne 0x12b4
movq %r13, %rdi
movq %rbp, %rsi
callq 0x1040
testl %eax, %eax
je 0x12b4
xorl %ebx, %ebx
cmpl $0x2, 0x10(%rsp)
sete %bl
movq %rbp, %rdi
callq 0x10c0
incl %r15d
jmp 0x128a
movq %r13, %rdi
callq 0x1080
movq %r12, %rdi
callq 0x1050
testl %eax, %eax
jne 0x132b
testl %ebx, %ebx
leaq 0xdd3(%rip), %rsi       # 0x20a4
leaq 0xdc4(%rip), %rax       # 0x209c
cmoveq %rax, %rsi
leaq 0xda9(%rip), %rdi       # 0x208c
movl %r15d, %edx
xorl %eax, %eax
callq 0x1060
incq %r14
movq (%rsp), %rbx
jmp 0x1223
leaq 0xd35(%rip), %rdi       # 0x2035
leaq 0xd33(%rip), %rsi       # 0x203a
leaq 0xd39(%rip), %rcx       # 0x2047
pushq $0x22
jmp 0x1342
leaq 0xd45(%rip), %rdi       # 0x205e
leaq 0xd1a(%rip), %rsi       # 0x203a
leaq 0xd20(%rip), %rcx       # 0x2047
pushq $0x24
jmp 0x1342
leaq 0xd4c(%rip), %rdi       # 0x207e
leaq 0xd01(%rip), %rsi       # 0x203a
leaq 0xd07(%rip), %rcx       # 0x2047
pushq $0x38
popq %rdx
callq 0x1070
// File: /workspace/github_c_makefile_star2_O2/fm4dd[P]learn-ssl/keycompare.c
// Function: RSAcmp_mod
int RSAcmp_mod(EVP_PKEY *priv, EVP_PKEY *pub) {
  int match;

#if OPENSSL_VERSION_NUMBER < 0x30000000L
  /* -------------------------------------------------------- *
   * Old code for OpenSSL versions before version 3.0         *
   * ---------------------------------------------------------*/
  const BIGNUM *privrsa_mod;
  const BIGNUM *pubrsa_mod;
  RSA *privrsa = EVP_PKEY_get1_RSA(priv);
  RSA_get0_key(privrsa, &privrsa_mod, NULL, NULL);
  RSA *pubrsa = EVP_PKEY_get1_RSA(pub);
  RSA_get0_key(pubrsa, &pubrsa_mod, NULL, NULL);
#else
  /* -------------------------------------------------------- *
   * New code for latest OpenSSL version 3.0                  *
   * ---------------------------------------------------------*/
  BIGNUM *privrsa_mod = NULL;
  BIGNUM *pubrsa_mod = NULL;
  EVP_PKEY_get_bn_param(priv, OSSL_PKEY_PARAM_RSA_N, &privrsa_mod);
  EVP_PKEY_get_bn_param(pub, OSSL_PKEY_PARAM_RSA_N, &pubrsa_mod);
#endif

  char *privrsa_mod_hex = BN_bn2hex(privrsa_mod);
  char *pubrsa_mod_hex = BN_bn2hex(pubrsa_mod);

  printf("priv: %s\n", privrsa_mod_hex);
  printf(" pub: %s\n", pubrsa_mod_hex);

  if(strcmp(privrsa_mod_hex, pubrsa_mod_hex) == 0)
    match = 0; // the keys modulus is matching
  else
    match = 1; // the keys modulus don't match

  OPENSSL_free(privrsa_mod_hex);
  OPENSSL_free(pubrsa_mod_hex);

#if OPENSSL_VERSION_NUMBER < 0x30000000L
  RSA_free(privrsa);
  RSA_free(pubrsa);
#endif
  return match;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
leaq 0x8(%rsp), %r14
andq $0x0, (%r14)
movq %rsp, %r15
andq $0x0, (%r15)
leaq 0xcc2(%rip), %r12       # 0x2004
movq %r12, %rsi
movq %r14, %rdx
callq 0x10c0
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x10c0
movq (%r14), %rdi
callq 0x1210
movq %rax, %r14
movq (%r15), %rdi
callq 0x1210
movq %rax, %rbx
leaq 0xc8e(%rip), %rdi       # 0x2006
movq %r14, %rsi
xorl %eax, %eax
callq 0x1040
leaq 0xc87(%rip), %rdi       # 0x2010
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1040
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1190
xorl %ebp, %ebp
testl %eax, %eax
setne %bpl
leaq 0xc6d(%rip), %r15       # 0x201a
pushq $0x48
popq %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x1100
pushq $0x49
popq %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1100
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/fm4dd[P]learn-ssl/keycompare.c
// Function: RSAencrypt
int RSAencrypt(EVP_PKEY *key, const unsigned char *teststring) {
  int rsa_outlen = 0;
  encdata = OPENSSL_zalloc(1024); // allocate and zero 1kb space

#if OPENSSL_VERSION_NUMBER < 0x30000000L
  RSA *pubrsa = NULL;
  pubrsa = EVP_PKEY_get1_RSA(key);
  rsa_outlen = RSA_public_encrypt(teststr_len, teststring, encdata, pubrsa, pad);
  RSA_free(pubrsa);
#else
  EVP_PKEY_CTX *ctx = NULL;
  ctx = EVP_PKEY_CTX_new_from_pkey(NULL, key, NULL);
  OSSL_PARAM params[2];
  set_optional_params(params);
  EVP_PKEY_encrypt_init_ex(ctx, params);
  EVP_PKEY_encrypt(ctx, encdata, (size_t *) &rsa_outlen, teststring, teststr_len);
  EVP_PKEY_CTX_free(ctx);
#endif
  return rsa_outlen;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %r15
leaq 0xc(%rsp), %rbx
andl $0x0, (%rbx)
leaq 0x94d(%rip), %rsi       # 0x201a
movl $0x400, %edi            # imm = 0x400
movl $0xc3, %edx
callq 0x11e0
movq %rax, 0x2a45(%rip)      # 0x4128
xorl %edi, %edi
movq %r15, %rsi
xorl %edx, %edx
callq 0x1090
movq %rax, %r15
leaq 0x10(%rsp), %r12
movq %r12, %rdi
callq 0x1881
movq %r15, %rdi
movq %r12, %rsi
callq 0x1060
movq 0x2a17(%rip), %rsi      # 0x4128
movslq 0x2a24(%rip), %r8       # 0x413c
movq %r15, %rdi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x1140
movq %r15, %rdi
callq 0x11b0
movl (%rbx), %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/fm4dd[P]learn-ssl/keycompare.c
// Function: RSAdecrypt
int RSAdecrypt(EVP_PKEY *key, int rsa_inlen) {
  int rsa_outlen = 0;
  decdata = OPENSSL_zalloc(1024); // allocate and zero 1kb space

#if OPENSSL_VERSION_NUMBER < 0x30000000L
  RSA *privrsa = NULL;
  privrsa = EVP_PKEY_get1_RSA(key);
  rsa_outlen = RSA_private_decrypt(rsa_inlen, encdata, decdata, privrsa, pad);
  RSA_free(privrsa);
#else
  EVP_PKEY_CTX *ctx = NULL;
  ctx = EVP_PKEY_CTX_new_from_pkey(NULL, key, NULL);
  OSSL_PARAM params[2];
  set_optional_params(params);
  EVP_PKEY_decrypt_init_ex(ctx, params);
  EVP_PKEY_decrypt(ctx, decdata, (size_t *) &rsa_outlen, encdata, rsa_inlen);
#endif
  return rsa_outlen;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movl %esi, %ebp
movq %rdi, %r14
leaq 0xc(%rsp), %rbx
andl $0x0, (%rbx)
leaq 0x8c0(%rip), %rsi       # 0x201a
movl $0x400, %edi            # imm = 0x400
movl $0xdb, %edx
callq 0x11e0
movq %rax, 0x29c0(%rip)      # 0x4130
xorl %edi, %edi
movq %r14, %rsi
xorl %edx, %edx
callq 0x1090
movq %rax, %r14
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x1881
movq %r14, %rdi
movq %r15, %rsi
callq 0x1030
movq 0x2992(%rip), %rsi      # 0x4130
movq 0x2983(%rip), %rcx      # 0x4128
movslq %ebp, %r8
movq %r14, %rdi
movq %rbx, %rdx
callq 0x1130
movl (%rbx), %eax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/fm4dd[P]learn-ssl/keycompare.c
// Function: ECsign
ECDSA_SIG *ECsign(EVP_PKEY *key, const unsigned char *teststring) {
  ECDSA_SIG *sig;

#if OPENSSL_VERSION_NUMBER < 0x30000000L
  EC_KEY *priveckey = NULL;
  priveckey = EVP_PKEY_get1_EC_KEY(key);
  sig = ECDSA_do_sign(teststring, teststr_len, priveckey);
  EC_KEY_free(priveckey);
#else
  EVP_MD_CTX *ctx = NULL;
  ctx = EVP_MD_CTX_new();
  unsigned char *sigstr;
  size_t *sig_len;
  EVP_DigestSign(ctx, sigstr, sig_len, teststring, teststr_len);
  sig = d2i_ECDSA_SIG(NULL, (const unsigned char **) &sigstr, (long) &sig_len);
  EVP_MD_CTX_free(ctx);
#endif
  return sig;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
callq 0x1160
movq %rax, %r14
movslq 0x2963(%rip), %r8       # 0x413c
movq %rax, %rdi
movq %rbx, %rcx
callq 0x1050
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %rdx
xorl %edi, %edi
callq 0x10e0
movq %rax, %rbx
movq %r14, %rdi
callq 0x11f0
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/fm4dd[P]learn-ssl/keycompare.c
// Function: ECverify
int ECverify(EVP_PKEY *key, const unsigned char *teststring, ECDSA_SIG *sig) {

  teststr_len = strlen( (const char *) teststring);
#if OPENSSL_VERSION_NUMBER < 0x30000000L
  EC_KEY *pubeckey = NULL;
  pubeckey = EVP_PKEY_get1_EC_KEY(key);
  ret = ECDSA_do_verify(teststring, teststr_len, sig, pubeckey);
  EC_KEY_free(pubeckey);
#else
  EVP_MD_CTX *ctx = NULL;
  ctx = EVP_MD_CTX_new();
  unsigned char *sigstr;
  i2d_ECDSA_SIG(sig, &sigstr);
  size_t sig_len = strlen( (const char *) sigstr);
  /* ---------------------------------------------------------- *
   * Successful verification returns 1                          *
   * ---------------------------------------------------------- */
    ret = EVP_DigestVerify(ctx, sigstr, sig_len, teststring, teststr_len);
   EVP_MD_CTX_free(ctx);
#endif
  return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rsi, %rdi
callq 0x10d0
movl %eax, 0x2915(%rip)      # 0x413c
callq 0x1160
movq %rax, %r15
movq %rsp, %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1170
movq (%r12), %rbx
movq %rbx, %rdi
callq 0x10d0
movslq 0x28ec(%rip), %r8       # 0x413c
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
movq %r14, %rcx
callq 0x1070
movl %eax, 0x28d1(%rip)      # 0x4138
movq %r15, %rdi
callq 0x11f0
movl 0x28c3(%rip), %eax      # 0x4138
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]bgt/import.c
// Function: main_bcfidx
int main_bcfidx(int argc, char *argv[])
{
	int c, min_shift = 14;
	while ((c = getopt(argc, argv, "s:")) >= 0)
		if (c == 's') min_shift = atoi(optarg);
	if (optind == argc) {
		fprintf(stderr, "Usage: bgt bcfidx [-s minShift] <in.bcf>\n");
		return 1;
	}
	bcf_index_build(argv[optind], min_shift);
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movl %edi, %ebp
pushq $0xe
popq %r14
leaq 0x15594(%rip), %r15     # 0x18364
movq 0x1e1d9(%rip), %r12     # 0x20fb0
movl %ebp, %edi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x23e0
testl %eax, %eax
js 0x2dfb
cmpl $0x73, %eax
jne 0x2dd7
movq (%r12), %rdi
callq 0x23f0
movl %eax, %r14d
jmp 0x2dd7
movq 0x1e196(%rip), %rax     # 0x20f98
movslq (%rax), %rax
cmpl %ebp, %eax
je 0x2e20
movq (%rbx,%rax,8), %rdi
movl %r14d, %esi
callq 0xd01a
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x1e1d1(%rip), %rax     # 0x20ff8
movq (%rax), %rcx
leaq 0x15536(%rip), %rdi     # 0x18367
pushq $0x29
popq %rsi
pushq $0x1
popq %rdx
callq 0x2410
pushq $0x1
popq %rax
jmp 0x2e17
// File: /workspace/github_c_makefile_star2_O2/lh3[P]bgt/fmf.c
// Function: fmf_destroy
void fmf_destroy(fmf_t *f)
{
	int i;
	if (f == 0) return;
	for (i = 0; i < f->n_keys; ++i) free(f->keys[i]);
	for (i = 0; i < f->n_vals; ++i) free(f->vals[i]);
	for (i = 0; i < f->n_rows; ++i) {
		fmf1_t *r = &f->rows[i];
		free(r->name); free(r->meta);
	}
	free(f->rows); free(f->keys); free(f->vals);
	free(f);
}

// Assembly:
testq %rdi, %rdi
je 0x8fa7
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movslq (%rbx), %rax
cmpq %rax, %r14
jge 0x8f2c
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x2050
incq %r14
jmp 0x8f12
xorl %r14d, %r14d
movslq 0x10(%rbx), %rax
cmpq %rax, %r14
jge 0x8f4a
movq 0x18(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x2050
incq %r14
jmp 0x8f2f
pushq $0x10
popq %r15
xorl %r12d, %r12d
movslq 0x20(%rbx), %rax
movq 0x28(%rbx), %r14
cmpq %rax, %r12
jge 0x8f7a
movq -0x10(%r14,%r15), %rdi
callq 0x2050
movq (%r14,%r15), %rdi
callq 0x2050
incq %r12
addq $0x18, %r15
jmp 0x8f51
movq %r14, %rdi
callq 0x2050
movq 0x8(%rbx), %rdi
callq 0x2050
movq 0x18(%rbx), %rdi
callq 0x2050
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2050
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]bgt/fmf.c
// Function: fmf_write
char *fmf_write(const fmf_t *f, int r)
{
	static const char *type_str = "\0ifZ";
	kstring_t s = {0,0,0};
	fmf1_t *u;
	int i;
	if (r >= f->n_rows) return 0;
	u = &f->rows[r];
	kputs(u->name, &s);
	for (i = 0; i < u->n_meta; ++i) {
		fmf_meta_t *m = &u->meta[i];
		kputc('\t', &s);
		kputs(f->keys[m->key], &s);
		if (m->type != FMF_FLAG) {
			kputc(':', &s); kputc(type_str[m->type], &s);
			kputc(':', &s);
			if (m->type == FMF_INT) ksprintf(&s, "%lld", (long long)m->v.i);
			else if (m->type == FMF_REAL) ksprintf(&s, "%g", m->v.r);
			else kputs(f->vals[m->v.s], &s);
		}
	}
	return s.s;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
andq $0x0, 0x10(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
cmpl %esi, 0x20(%rdi)
jle 0x90d6
movq %rdi, %rbx
movq 0x28(%rdi), %rax
movslq %esi, %rcx
imulq $0x18, %rcx, %rcx
leaq (%rax,%rcx), %r12
movq (%rax,%rcx), %rdi
movq %rsp, %r14
movq %r14, %rsi
callq 0x90e7
pushq $0x3a
popq %r15
xorl %r13d, %r13d
movslq 0x8(%r12), %rax
cmpq %rax, %r13
jge 0x90cf
movq 0x10(%r12), %rbp
pushq $0x9
popq %rdi
movq %r14, %rsi
callq 0x917b
movq 0x8(%rbx), %rax
movl (%rbp,%r13,8), %ecx
movl $0xfffffff, %edx        # imm = 0xFFFFFFF
andl %edx, %ecx
movq (%rax,%rcx,8), %rdi
movq %r14, %rsi
callq 0x90e7
cmpl $0x10000000, (%rbp,%r13,8) # imm = 0x10000000
jb 0x90c7
movl %r15d, %edi
movq %r14, %rsi
callq 0x917b
movl (%rbp,%r13,8), %eax
shrl $0x1c, %eax
leaq 0x100f7(%rip), %rcx     # 0x1914e
movsbl (%rax,%rcx), %edi
movq %r14, %rsi
callq 0x917b
movl %r15d, %edi
movq %r14, %rsi
callq 0x917b
movl (%rbp,%r13,8), %eax
shrl $0x1c, %eax
cmpl $0x2, %eax
je 0x9098
cmpl $0x1, %eax
jne 0x90b2
movslq 0x4(%rbp,%r13,8), %rdx
movq %r14, %rdi
leaq 0x10030(%rip), %rsi     # 0x190bf
xorl %eax, %eax
callq 0x91fe
jmp 0x90c7
cvtss2sd 0x4(%rbp,%r13,8), %xmm0
movq %r14, %rdi
leaq 0x1001b(%rip), %rsi     # 0x190c4
movb $0x1, %al
callq 0x91fe
jmp 0x90c7
movq 0x18(%rbx), %rax
movl 0x4(%rbp,%r13,8), %ecx
movq (%rax,%rcx,8), %rdi
movq %r14, %rsi
callq 0x90e7
incq %r13
jmp 0x8ff4
movq 0x10(%rsp), %rax
jmp 0x90d8
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]bgt/fmf.c
// Function: fmf_test
int fmf_test(const fmf_t *f, int r, kexpr_t *ke) // FIXME: a quadratic implementation!!! optimize later if too slow
{
	fmf1_t *u;
	int err, i, is_true;
	if (r >= f->n_rows) return 0;
	u = &f->rows[r];
	ke_unset(ke);
	for (i = 0; i < u->n_meta; ++i) {
		fmf_meta_t *m = &u->meta[i];
		ke_set_str(ke, "_ROW_", u->name);
		if (m->type == FMF_STR) ke_set_str(ke, f->keys[m->key], f->vals[m->v.s]);
		else if (m->type == FMF_INT) ke_set_int(ke, f->keys[m->key], m->v.i);
		else if (m->type == FMF_REAL) ke_set_int(ke, f->keys[m->key], m->v.r);
	}
	is_true = !!ke_eval_int(ke, &err);
	return !(err || !is_true);
}

// Assembly:
xorl %eax, %eax
cmpl %esi, 0x20(%rdi)
jle 0x9439
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movslq %esi, %rax
imulq $0x18, %rax, %r12
addq 0x28(%rdi), %r12
movq %rdx, %rdi
callq 0x1677e
xorl %r13d, %r13d
leaq 0xfd55(%rip), %r15      # 0x190c7
movslq 0x8(%r12), %rax
cmpq %rax, %r13
jge 0x9409
movq (%r12), %rdx
movq 0x10(%r12), %rbp
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1646f
movl (%rbp,%r13,8), %eax
movl %eax, %ecx
shrl $0x1c, %ecx
cmpl $0x1, %ecx
je 0x93e7
cmpl $0x2, %ecx
je 0x93d1
cmpl $0x3, %ecx
jne 0x9401
andl $0xfffffff, %eax        # imm = 0xFFFFFFF
movq 0x8(%r14), %rcx
movq 0x18(%r14), %rdx
movq (%rcx,%rax,8), %rsi
movl 0x4(%rbp,%r13,8), %eax
movq (%rdx,%rax,8), %rdx
movq %rbx, %rdi
callq 0x1646f
jmp 0x9401
movq 0x8(%r14), %rcx
andl $0xfffffff, %eax        # imm = 0xFFFFFFF
movq (%rcx,%rax,8), %rsi
cvttss2si 0x4(%rbp,%r13,8), %rdx
jmp 0x93f9
movq 0x8(%r14), %rcx
andl $0xfffffff, %eax        # imm = 0xFFFFFFF
movq (%rcx,%rax,8), %rsi
movslq 0x4(%rbp,%r13,8), %rdx
movq %rbx, %rdi
callq 0x16315
incq %r13
jmp 0x9372
leaq 0x4(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1625a
testq %rax, %rax
setne %al
cmpl $0x0, (%r14)
sete %cl
andb %al, %cl
movzbl %cl, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]bgt/fmf.c
// Function: fms_open
fms_t *fms_open(const char *fn)
{
	fms_t *f;
	gzFile fp;
	fp = fn && strcmp(fn, "-")? gzopen(fn, "r") : gzdopen(fileno(stdin), "r");
	if (fp == 0) return 0;
	f = (fms_t*)calloc(1, sizeof(fms_t));
	f->ks = ks_init(fp);
	f->fp = fp;
	return f;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x945c
cmpb $0x2d, (%rdi)
jne 0x944e
cmpb $0x0, 0x1(%rdi)
je 0x945c
leaq 0xfda3(%rip), %rsi      # 0x191f8
callq 0x2380
jmp 0x9479
movq 0x17b25(%rip), %rax     # 0x20f88
movq (%rax), %rdi
callq 0x22a0
leaq 0xfd86(%rip), %rsi      # 0x191f8
movl %eax, %edi
callq 0x2140
movq %rax, %rbx
testq %rax, %rax
je 0x94a0
pushq $0x1
popq %rdi
pushq $0x28
popq %rsi
callq 0x2220
movq %rax, %r14
movq %rbx, %rdi
callq 0x5584
movq %rax, (%r14)
movq %rbx, 0x20(%r14)
jmp 0x94a3
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]bgt/fmf.c
// Function: fms_close
void fms_close(fms_t *f)
{
	if (f == 0) return;
	free(f->s.s);
	ks_destroy(f->ks);
	gzclose(f->fp);
	free(f);
}

// Assembly:
testq %rdi, %rdi
je 0x94da
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x2050
movq (%rbx), %rdi
callq 0x55bd
movq 0x20(%rbx), %rdi
callq 0x2040
movq %rbx, %rdi
popq %rbx
jmp 0x2050
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]bgt/fmf.c
// Function: fms_read
const char *fms_read(fms_t *f, kexpr_t *ke, int name_only)
{
	int ret;
	char *end0 = 0;
	while ((ret = fms_read_and_test(f, ke, &end0)) == 0);
	if (ret < 0) return 0;
	if (name_only) *end0 = 0;
	return f->s.s;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %edx, 0x34(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
movq $0x0, 0x20(%rsp)
leaq 0x18(%rsp), %r15
andl $0x0, 0x1c(%rsp)
movq (%rbx), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x8eea
testl %eax, %eax
js 0x96cf
cmpq $0x0, (%r14)
je 0x9507
movq %r14, 0x38(%rsp)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x9546
movq 0x8(%rsp), %rdi
callq 0x1677e
movq 0x8(%rsp), %rdi
movq %rbx, 0x28(%rsp)
movq 0x18(%rbx), %r12
xorl %ecx, %ecx
movq %r12, %r15
movq %r12, %rbp
movzbl (%rbp), %r14d
cmpl $0x9, %r14d
je 0x956b
testl %r14d, %r14d
jne 0x9674
movb $0x0, (%rbp)
testl %ecx, %ecx
je 0x95ef
movq %r12, %rax
subq %r15, %rax
movq %r15, %rbx
movq %rbx, 0x40(%rsp)
movzbl (%rbx), %r13d
testl %r13d, %r13d
je 0x9598
cmpl $0x3a, %r13d
je 0x9598
incq %rbx
decq %rax
jmp 0x957c
movb $0x0, (%rbx)
cmpb $0x3a, %r13b
jne 0x9662
testq %rdi, %rdi
je 0x9662
cmpq $0x3, %rax
jl 0x9662
movzbl 0x1(%rbx), %eax
leaq 0x3(%rbx), %rdx
cmpl $0x66, %eax
movl %ecx, 0x14(%rsp)
je 0x9627
cmpl $0x69, %eax
jne 0x964c
movq %rdx, %rdi
leaq 0x40(%rsp), %rsi
xorl %edx, %edx
callq 0x2270
movq 0x8(%rsp), %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x16315
jmp 0x9659
testq %rdi, %rdi
je 0x9618
movq 0x8(%rsp), %rdi
leaq 0xfac7(%rip), %rsi      # 0x190c7
movq %r15, %rdx
movl %ecx, %ebx
callq 0x1646f
movl %ebx, %ecx
movq 0x8(%rsp), %rdi
movq %rbp, 0x20(%rsp)
jmp 0x9665
movq %rbp, 0x20(%rsp)
testb %r14b, %r14b
jne 0x966a
jmp 0x96bc
movq %rdx, %rdi
leaq 0x40(%rsp), %rsi
callq 0x2100
movq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x163bc
movl 0x14(%rsp), %ecx
movq 0x8(%rsp), %rdi
jmp 0x9662
movq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x1646f
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %ecx
movb %r13b, (%rbx)
testb %r14b, %r14b
je 0x967f
incl %ecx
leaq 0x1(%rbp), %r15
movb %r14b, (%rbp)
incq %rbp
incq %r12
jmp 0x9557
testq %rdi, %rdi
movq 0x38(%rsp), %r14
je 0x969b
leaq 0x1c(%rsp), %rsi
callq 0x1625a
testq %rax, %rax
setne %al
jmp 0x969d
movb $0x1, %al
movq 0x28(%rsp), %rbx
leaq 0x18(%rsp), %r15
cmpl $0x0, 0x1c(%rsp)
jne 0x9507
testb %al, %al
je 0x9507
jmp 0x96e0
movb $0x1, %al
movq %rbp, 0x20(%rsp)
movq 0x28(%rsp), %rbx
movq 0x38(%rsp), %r14
jmp 0x96a2
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x0, 0x34(%rsp)
je 0x96ef
movq 0x20(%rsp), %rax
movb $0x0, (%rax)
movq 0x18(%rbx), %rax
jmp 0x96d1
// File: /workspace/github_c_makefile_star2_O2/lh3[P]bgt/vcf.c
// Function: bcf_hdr_sync
int bcf_hdr_sync(bcf_hdr_t *h)
{
	int i;
	for (i = 0; i < 3; ++i) {
		khint_t k;
		vdict_t *d = (vdict_t*)h->dict[i];
		h->n[i]  = kh_size(d);
		h->id[i] = (bcf_idpair_t*)realloc(h->id[i], kh_size(d) * sizeof(bcf_idpair_t));
		for (k = kh_begin(d); k != kh_end(d); ++k) {
			if (!kh_exist(d, k)) continue;
			h->id[i][kh_val(d, k).id].key = kh_key(d, k);
			h->id[i][kh_val(d, k).id].val = &kh_val(d, k);
		}
	}
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
cmpq $0x3, %r14
je 0xa305
movq 0x30(%rbx,%r14,8), %r15
movl 0x4(%r15), %esi
movl %esi, 0x8(%rbx,%r14,4)
movq 0x18(%rbx,%r14,8), %rdi
shlq $0x4, %rsi
callq 0x2340
movq %rax, 0x18(%rbx,%r14,8)
movl (%r15), %eax
xorl %edx, %edx
xorl %esi, %esi
xorl %edi, %edi
cmpl %esi, %eax
je 0xa2fd
movq 0x10(%r15), %rcx
movl %esi, %r8d
shrl $0x4, %r8d
movl (%rcx,%r8,4), %r8d
movl %edi, %ecx
andb $0x1e, %cl
shrl %cl, %r8d
testb $0x3, %r8b
jne 0xa2f1
movq 0x18(%r15), %rcx
movq 0x20(%r15), %r8
movq (%rcx,%rsi,8), %rcx
movq 0x18(%rbx,%r14,8), %r9
movslq 0xc(%r8,%rdx), %r10
addq %rdx, %r8
shlq $0x4, %r10
movq %rcx, (%r9,%r10)
movq 0x18(%rbx,%r14,8), %rcx
movq %r8, 0x8(%rcx,%r10)
addl $0x2, %edi
incq %rsi
addq $0x10, %rdx
jmp 0xa2a5
incq %r14
jmp 0xa271
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]bgt/vcf.c
// Function: bcf_hdr_parse
int bcf_hdr_parse(bcf_hdr_t *h)
{
	char *p, *q;
	bcf_hdr_parse1(h, "##FILTER=<ID=PASS,Description=\"All filters passed\">"); // add PASS before anything else
	for (p = q = h->text; q - h->text < h->l_text; ++q) {
		int c;
		if (*q != '\n' && *q != 0) continue;
		c = *q; *q = 0;
		bcf_hdr_parse1(h, p);
		*q = c;
		if (*q == 0) break;
		p = q + 1;
	}
	bcf_hdr_sync(h);
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xefa0(%rip), %rsi      # 0x192be
callq 0x9e1f
movq 0x48(%rbx), %r14
leaq 0x1(%r14), %r15
movq %r14, %rax
movq %r14, %rsi
movq %r14, %rcx
subq %rax, %rcx
movslq (%rbx), %rdx
cmpq %rdx, %rcx
jge 0xa372
movzbl -0x1(%r15), %ebp
cmpl $0xa, %ebp
je 0xa34d
testl %ebp, %ebp
jne 0xa36a
movb $0x0, -0x1(%r15)
movq %rbx, %rdi
callq 0x9e1f
movb %bpl, -0x1(%r15)
testb %bpl, %bpl
je 0xa372
movq 0x48(%rbx), %rax
movq %r15, %rsi
incq %r15
incq %r14
jmp 0xa331
movq %rbx, %rdi
callq 0xa266
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]bgt/vcf.c
// Function: bcf_hdr_append
int bcf_hdr_append(bcf_hdr_t *h, const char *line)
{
	int len, i;
	len = strlen(line);
	if (line[len - 1] == '\n') --len;
	if (h->m_text < h->l_text + len + 1) {
		h->m_text = h->l_text + len + 1;
		kroundup32(h->m_text);
		h->text = (char*)realloc(h->text, h->m_text);
	}
	for (i = h->l_text - 1; i >= 0; --i)
		if (h->text[i] == '#' && (i == 0 || h->text[i-1] == '\n'))
			break;
	if (i < 0) return -1; // no #CHROM line
	memmove(&h->text[i+len+1], &h->text[i], h->l_text - i);
	memcpy(&h->text[i], line, len);
	h->text[i+len] = '\n';
	h->l_text += len;
	bcf_hdr_parse1(h, line);
	bcf_hdr_sync(h);
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x2170
movq %rax, %r15
decl %eax
cltq
xorl %r13d, %r13d
cmpb $0xa, (%r14,%rax)
sete %r13b
movl %r15d, %r12d
subl %r13d, %r12d
movl (%rbx), %eax
leal (%r12,%rax), %ecx
cmpl %ecx, 0x4(%rbx)
jg 0xa3fd
movl %ecx, %eax
sarl %eax
orl %ecx, %eax
movl %eax, %ecx
sarl $0x2, %ecx
orl %eax, %ecx
movl %ecx, %eax
sarl $0x4, %eax
orl %ecx, %eax
movl %eax, %ecx
sarl $0x8, %ecx
orl %eax, %ecx
movl %ecx, %eax
sarl $0x10, %eax
orl %ecx, %eax
incl %eax
movl %eax, 0x4(%rbx)
movq 0x48(%rbx), %rdi
movslq %eax, %rsi
callq 0x2340
movq %rax, 0x48(%rbx)
movl (%rbx), %eax
negl %r13d
movl %eax, %edx
xorl %ecx, %ecx
pushq $-0x1
popq %rax
leaq (%rdx,%rcx), %rsi
testl %esi, %esi
jle 0xa4a7
leaq (%rdx,%rcx), %rdi
decq %rdi
movq 0x48(%rbx), %rsi
movl %edi, %r8d
cmpb $0x23, (%rsi,%r8)
jne 0xa437
testl %edi, %edi
je 0xa43c
leaq (%rsi,%rdx), %rdi
cmpb $0xa, -0x2(%rcx,%rdi)
je 0xa43c
decq %rcx
jmp 0xa407
addl %edx, %r13d
addl %r15d, %r13d
leal (%rcx,%r13), %eax
leal (%rcx,%r13), %ebp
decl %ebp
movslq %eax, %rdi
addq %rsi, %rdi
leal (%rdx,%rcx), %r15d
decl %r15d
addq %r15, %rsi
movslq %edx, %rdx
leal -0x1(%rdx), %eax
cltq
subq %rax, %rdx
subq %rcx, %rdx
callq 0x2370
addq 0x48(%rbx), %r15
movslq %r12d, %r12
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x2280
movq 0x48(%rbx), %rax
movslq %ebp, %rcx
movb $0xa, (%rax,%rcx)
addl %r12d, (%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9e1f
movq %rbx, %rdi
callq 0xa266
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_O2/lh3[P]bgt/vcf.c
// Function: bcf_hdr_init
bcf_hdr_t *bcf_hdr_init(void)
{
	int i;
	bcf_hdr_t *h;
	h = (bcf_hdr_t*)calloc(1, sizeof(bcf_hdr_t));
	for (i = 0; i < 3; ++i)
		h->dict[i] = kh_init(vdict);
	return h;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
pushq $0x1
popq %rbx
pushq $0x68
popq %rsi
movq %rbx, %rdi
callq 0x2220
movq %rax, %r14
pushq $0x6
popq %r12
pushq $0x28
popq %r15
cmpq $0x9, %r12
je 0xa4f1
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2220
movq %rax, (%r14,%r12,8)
incq %r12
jmp 0xa4d7
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]bgt/vcf.c
// Function: bcf_hdr_destroy
void bcf_hdr_destroy(bcf_hdr_t *h)
{
	int i;
	khint_t k;
	for (i = 0; i < 3; ++i) {
		vdict_t *d = (vdict_t*)h->dict[i];
		if (d == 0) continue;
		for (k = kh_begin(d); k != kh_end(d); ++k)
			if (kh_exist(d, k)) free((char*)kh_key(d, k));
		kh_destroy(vdict, d);
		free(h->id[i]);
	}
	free(h->mem.s); free(h->text);
	free(h);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
xorl %r15d, %r15d
cmpq $0x3, %r15
je 0xa58a
movq 0x30(%rbx,%r15,8), %r14
testq %r14, %r14
je 0xa585
xorl %ebp, %ebp
xorl %r12d, %r12d
cmpl (%r14), %r12d
je 0xa558
movq 0x10(%r14), %rax
movl %r12d, %ecx
shrl $0x4, %ecx
movl (%rax,%rcx,4), %eax
movl %ebp, %ecx
andb $0x1e, %cl
shrl %cl, %eax
testb $0x3, %al
jne 0xa550
movq 0x18(%r14), %rax
movl %r12d, %ecx
movq (%rax,%rcx,8), %rdi
callq 0x2050
incl %r12d
addl $0x2, %ebp
jmp 0xa523
movq 0x18(%r14), %rdi
callq 0x2050
movq 0x10(%r14), %rdi
callq 0x2050
movq 0x20(%r14), %rdi
callq 0x2050
movq %r14, %rdi
callq 0x2050
movq 0x18(%rbx,%r15,8), %rdi
callq 0x2050
incq %r15
jmp 0xa50e
movq 0x60(%rbx), %rdi
callq 0x2050
movq 0x48(%rbx), %rdi
callq 0x2050
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2050
// File: /workspace/github_c_makefile_star2_O2/lh3[P]bgt/vcf.c
// Function: bcf_hdr_read
bcf_hdr_t *bcf_hdr_read(BGZF *fp)
{
	uint8_t magic[5];
	bcf_hdr_t *h;
	h = bcf_hdr_init();
	bgzf_read(fp, magic, 5);
	if (strncmp((char*)magic, "BCF\2\2", 5) != 0) {
		if (hts_verbose >= 2)
			fprintf(stderr, "[E::%s] invalid BCF2 magic string\n", __func__);
		bcf_hdr_destroy(h);
		return 0;
	}
	bgzf_read(fp, &h->l_text, 4);
	h->m_text = h->l_text;
	h->text = (char*)malloc(h->l_text);
	bgzf_read(fp, h->text, h->l_text);
	bcf_hdr_parse(h);
	return h;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0xa4b6
movq %rax, %rbx
leaq 0x3(%rsp), %r15
pushq $0x5
popq %r12
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x4874
leaq 0xed15(%rip), %rsi      # 0x192f2
movq %r15, %rdi
movq %r12, %rdx
callq 0x2310
testl %eax, %eax
je 0xa604
leaq 0x16c5d(%rip), %rax     # 0x21250
cmpl $0x2, (%rax)
jge 0xa64a
movq %rbx, %rdi
callq 0xa500
xorl %ebx, %ebx
jmp 0xa63b
pushq $0x4
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4874
movslq (%rbx), %r15
movl %r15d, 0x4(%rbx)
movq %r15, %rdi
callq 0x22e0
movq %rax, 0x48(%rbx)
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x4874
movq %rbx, %rdi
callq 0xa30d
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x169a7(%rip), %rax     # 0x20ff8
movq (%rax), %rdi
leaq 0xec9d(%rip), %rsi      # 0x192f8
leaq 0xecb9(%rip), %rdx      # 0x1931b
xorl %eax, %eax
callq 0x2250
jmp 0xa5f8
// File: /workspace/github_c_makefile_star2_O2/lh3[P]bgt/vcf.c
// Function: bcf_read1_core
static inline int bcf_read1_core(BGZF *fp, bcf1_t *v)
{
	uint32_t x[8];
	int ret;
	if ((ret = bgzf_read(fp, x, 32)) != 32) {
		if (ret == 0) return -1;
		return -2;
	}
	x[0] -= 24; // to exclude six 32-bit integers
	ks_resize(&v->shared, x[0]);
	ks_resize(&v->indiv, x[1]);
	memcpy(v, x + 2, 16);
	v->n_allele = x[6]>>16; v->n_info = x[6]&0xffff;
	v->n_fmt = x[7]>>24; v->n_sample = x[7]&0xffffff;
	v->shared.l = x[0], v->indiv.l = x[1];
	v->unpacked = 0;
	v->unpack_ptr = NULL;
	bgzf_read(fp, v->shared.s, v->shared.l);
	bgzf_read(fp, v->indiv.s, v->indiv.l);
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rsi
pushq $0x20
popq %rdx
callq 0x4874
testl %eax, %eax
je 0xa7cc
cmpl $0x20, %eax
jne 0xa7d0
movl (%rsp), %esi
addl $-0x18, %esi
movl %esi, (%rsp)
leaq 0x18(%r14), %rdi
callq 0xc489
leaq 0x30(%r14), %rdi
movl 0x4(%rsp), %esi
callq 0xc489
movups 0x8(%rsp), %xmm0
movups %xmm0, (%r14)
movl 0x18(%rsp), %eax
movl 0x1c(%rsp), %ecx
movl %ecx, %edx
shrl $0x18, %edx
shlq $0x20, %rdx
orq %rax, %rdx
shlq $0x28, %rcx
orq %rdx, %rcx
movq %rcx, 0x10(%r14)
movl (%rsp), %edx
movq %rdx, 0x18(%r14)
movl 0x4(%rsp), %eax
movq %rax, 0x30(%r14)
andl $0x0, 0x88(%r14)
andq $0x0, 0x90(%r14)
movq 0x28(%r14), %rsi
movq %rbx, %rdi
callq 0x4874
movq 0x30(%r14), %rdx
movq 0x40(%r14), %rsi
movq %rbx, %rdi
callq 0x4874
xorl %eax, %eax
jmp 0xa7d3
pushq $-0x1
jmp 0xa7d2
pushq $-0x2
popq %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]bgt/vcf.c
// Function: bcf_write1
int bcf_write1(BGZF *fp, const bcf1_t *v)
{
	uint32_t x[8];
	x[0] = v->shared.l + 24; // to include six 32-bit integers
	x[1] = v->indiv.l;
	memcpy(x + 2, v, 16);
	x[6] = (uint32_t)v->n_allele<<16 | v->n_info;
	x[7] = (uint32_t)v->n_fmt<<24 | v->n_sample;
	bgzf_write(fp, x, 32);
	bgzf_write(fp, v->shared.s, v->shared.l);
	bgzf_write(fp, v->indiv.s, v->indiv.l);
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x18(%rsi), %eax
addl $0x18, %eax
movq %rsp, %rsi
movl %eax, (%rsi)
movl 0x30(%r14), %eax
movl %eax, 0x4(%rsi)
movups (%r14), %xmm0
movups %xmm0, 0x8(%rsi)
movq 0x10(%r14), %rax
movl %eax, 0x18(%rsi)
movq %rax, %rcx
shrq $0x8, %rcx
andl $0xff000000, %ecx       # imm = 0xFF000000
shrq $0x28, %rax
orl %ecx, %eax
movl %eax, 0x1c(%rsi)
pushq $0x20
popq %rdx
callq 0x4cdb
movq 0x18(%r14), %rdx
movq 0x28(%r14), %rsi
movq %rbx, %rdi
callq 0x4cdb
movq 0x30(%r14), %rdx
movq 0x40(%r14), %rsi
movq %rbx, %rdi
callq 0x4cdb
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq