LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/oreparaz[P]dudect/examples/aesbitsliced/int128_aes128ctr.c
// Function: crypto_stream_aes128ctr_portable_shufd
void shufd(int128 *r, const int128 *x, const unsigned int c)
{
  int128 t;

  t.u32[0] = x->u32[c >> 0 & 3];
  t.u32[1] = x->u32[c >> 2 & 3];
  t.u32[2] = x->u32[c >> 4 & 3];
  t.u32[3] = x->u32[c >> 6 & 3];
  copy2(r, &t);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movq 0x18(%rsp), %rax
movl 0x14(%rsp), %ecx
shrl $0x0, %ecx
andl $0x3, %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %eax
movl %eax, (%rsp)
movq 0x18(%rsp), %rax
movl 0x14(%rsp), %ecx
shrl $0x2, %ecx
andl $0x3, %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %eax
movl %eax, 0x4(%rsp)
movq 0x18(%rsp), %rax
movl 0x14(%rsp), %ecx
shrl $0x4, %ecx
andl $0x3, %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %eax
movl %eax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movl 0x14(%rsp), %ecx
shrl $0x6, %ecx
andl $0x3, %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %eax
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0x1b560
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x1b280
movl %eax, 0xc(%rsp)
movl 0x1c(%rsp), %ecx
movl 0xc(%rsp), %eax
shrl %cl, %eax
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x1b2c0
movq 0x10(%rsp), %rdi
addq $0x4, %rdi
callq 0x1b280
movl %eax, 0xc(%rsp)
movl 0x1c(%rsp), %ecx
movl 0xc(%rsp), %eax
shrl %cl, %eax
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
addq $0x4, %rdi
movl 0xc(%rsp), %esi
callq 0x1b2c0
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
callq 0x1b280
movl %eax, 0xc(%rsp)
movl 0x1c(%rsp), %ecx
movl 0xc(%rsp), %eax
shrl %cl, %eax
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
movl 0xc(%rsp), %esi
callq 0x1b2c0
movq 0x10(%rsp), %rdi
addq $0xc, %rdi
callq 0x1b280
movl %eax, 0xc(%rsp)
movl 0x1c(%rsp), %ecx
movl 0xc(%rsp), %eax
shrl %cl, %eax
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
addq $0xc, %rdi
movl 0xc(%rsp), %esi
callq 0x1b2c0
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x1b330
movq %rax, 0x8(%rsp)
movl 0x1c(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, %ecx
shrq %cl, %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x1b3b0
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
callq 0x1b330
movq %rax, 0x8(%rsp)
movl 0x1c(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, %ecx
shrq %cl, %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
movq 0x8(%rsp), %rsi
callq 0x1b3b0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oreparaz[P]dudect/examples/aesbitsliced/int128_aes128ctr.c
// Function: crypto_stream_aes128ctr_portable_xor_rcon
void xor_rcon(int128 *r)
{
  unsigned char *rp = (unsigned char *)r;
  uint32 t;
  t = load32_littleendian(rp+12);
  t ^= 0xffffffff;
  store32_littleendian(rp+12, t);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
addq $0xc, %rdi
callq 0x1b280
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
xorl $-0x1, %eax
movl %eax, 0x4(%rsp)
movq 0x8(%rsp), %rdi
addq $0xc, %rdi
movl 0x4(%rsp), %esi
callq 0x1b2c0
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oreparaz[P]dudect/examples/aesbitsliced/int128_aes128ctr.c
// Function: crypto_stream_aes128ctr_portable_add_uint32_big
void add_uint32_big(int128 *r, uint32 x)
{
  unsigned char *rp = (unsigned char *)r;
  uint32 t;
  t = load32_littleendian(rp+12);
  t += x;
  store32_littleendian(rp+12, t);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
addq $0xc, %rdi
callq 0x1b280
movl %eax, 0xc(%rsp)
movl 0x1c(%rsp), %eax
addl 0xc(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
addq $0xc, %rdi
movl 0xc(%rsp), %esi
callq 0x1b2c0
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aegis128l/ref/aes.c
// Function: AESROUND
void AESROUND(unsigned char *out, unsigned char *in, unsigned char *rk)
{
      ((U32*)out)[0] = ((U32*)TE0)[*(in+0)]  ^ ((U32*)TE1)[*(in+5)]  ^ ((U32*)TE2)[*(in+10)] ^ ((U32*)TE3)[*(in+15)] ^ ((U32*)rk)[0];
      ((U32*)out)[1] = ((U32*)TE0)[*(in+4)]  ^ ((U32*)TE1)[*(in+9)]  ^ ((U32*)TE2)[*(in+14)] ^ ((U32*)TE3)[*(in+3)]  ^ ((U32*)rk)[1];
      ((U32*)out)[2] = ((U32*)TE0)[*(in+8)]  ^ ((U32*)TE1)[*(in+13)] ^ ((U32*)TE2)[*(in+2)]  ^ ((U32*)TE3)[*(in+7)]  ^ ((U32*)rk)[2];
      ((U32*)out)[3] = ((U32*)TE0)[*(in+12)] ^ ((U32*)TE1)[*(in+1)]  ^ ((U32*)TE2)[*(in+6)]  ^ ((U32*)TE3)[*(in+11)] ^ ((U32*)rk)[3];
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq -0x10(%rsp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
movq 0x3e10(%rip), %rax      # 0x4fe0
movl (%rax,%rcx,4), %ecx
movq -0x10(%rsp), %rax
movzbl 0x5(%rax), %eax
movl %eax, %edx
movq 0x3e0b(%rip), %rax      # 0x4ff0
xorl (%rax,%rdx,4), %ecx
movq -0x10(%rsp), %rax
movzbl 0xa(%rax), %eax
movl %eax, %edx
movq 0x3dfe(%rip), %rax      # 0x4ff8
xorl (%rax,%rdx,4), %ecx
movq -0x10(%rsp), %rax
movzbl 0xf(%rax), %eax
movl %eax, %edx
movq 0x3db1(%rip), %rax      # 0x4fc0
xorl (%rax,%rdx,4), %ecx
movq -0x18(%rsp), %rax
xorl (%rax), %ecx
movq -0x8(%rsp), %rax
movl %ecx, (%rax)
movq -0x10(%rsp), %rax
movzbl 0x4(%rax), %eax
movl %eax, %ecx
movq 0x3dae(%rip), %rax      # 0x4fe0
movl (%rax,%rcx,4), %ecx
movq -0x10(%rsp), %rax
movzbl 0x9(%rax), %eax
movl %eax, %edx
movq 0x3da9(%rip), %rax      # 0x4ff0
xorl (%rax,%rdx,4), %ecx
movq -0x10(%rsp), %rax
movzbl 0xe(%rax), %eax
movl %eax, %edx
movq 0x3d9c(%rip), %rax      # 0x4ff8
xorl (%rax,%rdx,4), %ecx
movq -0x10(%rsp), %rax
movzbl 0x3(%rax), %eax
movl %eax, %edx
movq 0x3d4f(%rip), %rax      # 0x4fc0
xorl (%rax,%rdx,4), %ecx
movq -0x18(%rsp), %rax
xorl 0x4(%rax), %ecx
movq -0x8(%rsp), %rax
movl %ecx, 0x4(%rax)
movq -0x10(%rsp), %rax
movzbl 0x8(%rax), %eax
movl %eax, %ecx
movq 0x3d4a(%rip), %rax      # 0x4fe0
movl (%rax,%rcx,4), %ecx
movq -0x10(%rsp), %rax
movzbl 0xd(%rax), %eax
movl %eax, %edx
movq 0x3d45(%rip), %rax      # 0x4ff0
xorl (%rax,%rdx,4), %ecx
movq -0x10(%rsp), %rax
movzbl 0x2(%rax), %eax
movl %eax, %edx
movq 0x3d38(%rip), %rax      # 0x4ff8
xorl (%rax,%rdx,4), %ecx
movq -0x10(%rsp), %rax
movzbl 0x7(%rax), %eax
movl %eax, %edx
movq 0x3ceb(%rip), %rax      # 0x4fc0
xorl (%rax,%rdx,4), %ecx
movq -0x18(%rsp), %rax
xorl 0x8(%rax), %ecx
movq -0x8(%rsp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rsp), %rax
movzbl 0xc(%rax), %eax
movl %eax, %ecx
movq 0x3ce6(%rip), %rax      # 0x4fe0
movl (%rax,%rcx,4), %ecx
movq -0x10(%rsp), %rax
movzbl 0x1(%rax), %eax
movl %eax, %edx
movq 0x3ce1(%rip), %rax      # 0x4ff0
xorl (%rax,%rdx,4), %ecx
movq -0x10(%rsp), %rax
movzbl 0x6(%rax), %eax
movl %eax, %edx
movq 0x3cd4(%rip), %rax      # 0x4ff8
xorl (%rax,%rdx,4), %ecx
movq -0x10(%rsp), %rax
movzbl 0xb(%rax), %eax
movl %eax, %edx
movq 0x3c87(%rip), %rax      # 0x4fc0
xorl (%rax,%rdx,4), %ecx
movq -0x18(%rsp), %rax
xorl 0xc(%rax), %ecx
movq -0x8(%rsp), %rax
movl %ecx, 0xc(%rax)
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/eric-lo[P]3150/4-ProcessKernel/zombie.c
// Function: main
int main(void) {
	int pid;
	if( (pid = fork()) != 0 ) {
		printf("Look at the status of the child process %d\n", pid);
		while( getchar() != '\n' );		// block stdin until a newline.
		wait(NULL);
		printf("Look again!\n");
		while( getchar() != '\n' );
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
callq 0x1060
movl %eax, -0x8(%rbp)
cmpl $0x0, %eax
je 0x11ce
movl -0x8(%rbp), %esi
leaq 0xe6e(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
callq 0x1040
cmpl $0xa, %eax
je 0x11a9
jmp 0x119d
xorl %eax, %eax
movl %eax, %edi
callq 0x1050
leaq 0xe77(%rip), %rdi       # 0x2030
movb $0x0, %al
callq 0x1030
callq 0x1040
cmpl $0xa, %eax
je 0x11cc
jmp 0x11c0
jmp 0x11ce
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1030
movq %rax, %rcx
movq -0x28(%rbp), %rax
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
subl $0x30, %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %esi
movq -0x8(%rbp), %rdx
leaq 0xe0d(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1040
movq -0x8(%rbp), %rdi
leaq 0xe21(%rip), %rsi       # 0x202a
leaq -0x18(%rbp), %rdx
callq 0x1050
movq %rax, -0x10(%rbp)
movl -0x20(%rbp), %esi
movl -0x1c(%rbp), %edx
movl %edx, %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rcx
leaq 0xdfd(%rip), %rdi       # 0x202c
movb $0x0, %al
callq 0x1040
movl $0x1, %edi
callq 0x10a0
xorl %eax, %eax
movl %eax, %edi
leaq 0xddf(%rip), %rsi       # 0x202a
leaq -0x18(%rbp), %rdx
callq 0x1050
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x1216
movl -0x20(%rbp), %esi
leaq 0xdde(%rip), %rdi       # 0x2046
movb $0x0, %al
callq 0x1040
xorl %eax, %eax
movl %eax, %edi
callq 0x1060
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x830, %rsp            # imm = 0x830
movl $0x0, -0x4(%rbp)
movl $0x0, -0x824(%rbp)
cmpl $0x2, -0x824(%rbp)
jge 0x131c
movslq -0x824(%rbp), %rax
leaq -0x820(%rbp), %rdi
shlq $0xa, %rax
addq %rax, %rdi
movl -0x824(%rbp), %edx
movl -0x824(%rbp), %ecx
leaq 0xd91(%rip), %rsi       # 0x205e
movb $0x0, %al
callq 0x1080
movslq -0x824(%rbp), %rax
leaq -0x20(%rbp), %rdi
shlq $0x3, %rax
addq %rax, %rdi
movslq -0x824(%rbp), %rax
leaq -0x820(%rbp), %rcx
shlq $0xa, %rax
addq %rax, %rcx
xorl %eax, %eax
movl %eax, %esi
leaq -0x156(%rip), %rdx      # 0x11b0
callq 0x1070
movl -0x824(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x824(%rbp)
jmp 0x129c
movl $0x0, -0x824(%rbp)
cmpl $0x2, -0x824(%rbp)
jge 0x1355
movslq -0x824(%rbp), %rax
movq -0x20(%rbp,%rax,8), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1090
movl -0x824(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x824(%rbp)
jmp 0x1326
xorl %eax, %eax
addq $0x830, %rsp            # imm = 0x830
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xcb9(%rip), %rsi       # 0x2004
leaq -0x20(%rbp), %rdx
callq 0x10c0
movq -0x10(%rbp), %rdi
leaq 0xca5(%rip), %rsi       # 0x2004
leaq -0x28(%rbp), %rdx
callq 0x10c0
movq -0x20(%rbp), %rdi
callq 0x1210
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x1210
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rsi
leaq 0xc79(%rip), %rdi       # 0x2006
movb $0x0, %al
callq 0x1040
movq -0x38(%rbp), %rsi
leaq 0xc71(%rip), %rdi       # 0x2010
movb $0x0, %al
callq 0x1040
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x11a0
cmpl $0x0, %eax
jne 0x13c1
movl $0x0, -0x14(%rbp)
jmp 0x13c8
movl $0x1, -0x14(%rbp)
movq -0x30(%rbp), %rdi
leaq 0xc47(%rip), %rsi       # 0x201a
movl $0x48, %edx
callq 0x1100
movq -0x38(%rbp), %rdi
leaq 0xc32(%rip), %rsi       # 0x201a
movl $0x49, %edx
callq 0x1100
movl -0x14(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x400, %edi            # imm = 0x400
leaq 0x7b7(%rip), %rsi       # 0x201a
movl $0xc3, %edx
callq 0x11e0
movq %rax, 0x28b4(%rip)      # 0x4128
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rdi
callq 0x1090
movq %rax, -0x20(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x1a70
movq -0x20(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x1060
movq -0x20(%rbp), %rdi
movq 0x2877(%rip), %rsi      # 0x4128
movq -0x10(%rbp), %rcx
movslq 0x2880(%rip), %r8       # 0x413c
leaq -0x14(%rbp), %rdx
callq 0x1150
movq -0x20(%rbp), %rdi
callq 0x11b0
movl -0x14(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x400, %edi            # imm = 0x400
leaq 0x718(%rip), %rsi       # 0x201a
movl $0xdb, %edx
callq 0x11e0
movq %rax, 0x281d(%rip)      # 0x4130
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rdi
callq 0x1090
movq %rax, -0x18(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x1a70
movq -0x18(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x1030
movq -0x18(%rbp), %rdi
movq 0x27e0(%rip), %rsi      # 0x4130
movq 0x27d1(%rip), %rcx      # 0x4128
movslq -0xc(%rbp), %r8
leaq -0x10(%rbp), %rdx
callq 0x1140
movl -0x10(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
callq 0x1170
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x10(%rbp), %rcx
movslq 0x2794(%rip), %r8       # 0x413c
callq 0x1050
leaq -0x30(%rbp), %rdx
xorl %eax, %eax
movl %eax, %edi
leaq -0x28(%rbp), %rsi
callq 0x10e0
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rdi
callq 0x11f0
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10d0
movl %eax, 0x2739(%rip)      # 0x413c
movq $0x0, -0x20(%rbp)
callq 0x1170
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1180
movq -0x28(%rbp), %rdi
callq 0x10d0
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x10(%rbp), %rcx
movslq 0x26f7(%rip), %r8       # 0x413c
callq 0x1070
movl %eax, 0x26e8(%rip)      # 0x4138
movq -0x20(%rbp), %rdi
callq 0x11f0
movl 0x26d9(%rip), %eax      # 0x4138
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]bgt/main.c
// Function: main
int main(int argc, char *argv[])
{
	if (argc < 2) return usage();
	if (strcmp(argv[1], "import") == 0) return main_import(argc-1, argv+1);
	else if (strcmp(argv[1], "atomize") == 0) return main_atomize(argc-1, argv+1);
	else if (strcmp(argv[1], "view") == 0 || strcmp(argv[1], "mview") == 0 ) return main_view(argc-1, argv+1);
	else if (strcmp(argv[1], "fmf") == 0 ) return main_fmf(argc-1, argv+1);
	else if (strcmp(argv[1], "getalt") == 0) return main_getalt(argc-1, argv+1);
	else if (strcmp(argv[1], "bcfidx") == 0) return main_bcfidx(argc-1, argv+1);
	else if (strcmp(argv[1], "version") == 0) {
		puts(BGT_VERSION);
		return 0;
	} else {
		fprintf(stderr, "[E::%s] unrecognized command '%s'\n", __func__, argv[1]);
		return 1;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
jge 0x25b9
callq 0x2770
movl %eax, -0x4(%rbp)
jmp 0x2763
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x24a3c(%rip), %rsi     # 0x27004
callq 0x2240
cmpl $0x0, %eax
jne 0x25ed
movl -0x8(%rbp), %edi
subl $0x1, %edi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0x2840
movl %eax, -0x4(%rbp)
jmp 0x2763
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x25d9c(%rip), %rsi     # 0x28398
callq 0x2240
cmpl $0x0, %eax
jne 0x2621
movl -0x8(%rbp), %edi
subl $0x1, %edi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0x30d0
movl %eax, -0x4(%rbp)
jmp 0x2763
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x24ed1(%rip), %rsi     # 0x27501
callq 0x2240
cmpl $0x0, %eax
je 0x2653
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x249c2(%rip), %rsi     # 0x2700b
callq 0x2240
cmpl $0x0, %eax
jne 0x266e
movl -0x8(%rbp), %edi
subl $0x1, %edi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0x33f0
movl %eax, -0x4(%rbp)
jmp 0x2763
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x24994(%rip), %rsi     # 0x27011
callq 0x2240
cmpl $0x0, %eax
jne 0x26a2
movl -0x8(%rbp), %edi
subl $0x1, %edi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0xe7c0
movl %eax, -0x4(%rbp)
jmp 0x2763
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x24964(%rip), %rsi     # 0x27015
callq 0x2240
cmpl $0x0, %eax
jne 0x26d6
movl -0x8(%rbp), %edi
subl $0x1, %edi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0x4070
movl %eax, -0x4(%rbp)
jmp 0x2763
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x24937(%rip), %rsi     # 0x2701c
callq 0x2240
cmpl $0x0, %eax
jne 0x2707
movl -0x8(%rbp), %edi
subl $0x1, %edi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0x3020
movl %eax, -0x4(%rbp)
jmp 0x2763
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x2490d(%rip), %rsi     # 0x27023
callq 0x2240
cmpl $0x0, %eax
jne 0x2735
leaq 0x24904(%rip), %rdi     # 0x2702b
callq 0x20e0
movl $0x0, -0x4(%rbp)
jmp 0x2763
movq 0x2b8bc(%rip), %rax     # 0x2dff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
leaq 0x248ec(%rip), %rsi     # 0x2703a
leaq 0x24908(%rip), %rdx     # 0x2705d
movb $0x0, %al
callq 0x2260
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]bgt/main.c
// Function: usage
static int usage()
{
	fprintf(stderr, "Usage: bgt <command> <argument>\n");
	fprintf(stderr, "Commands:\n");
	fprintf(stderr, "  import       convert VCF to BGT\n");
	fprintf(stderr, "  atomize      atomize VCF\n");
	fprintf(stderr, "  view         extract from BGT\n");
	fprintf(stderr, "  fmf          manipulate FMF files\n");
	fprintf(stderr, "  bcfidx       (re)index BCF with record number index\n");
	fprintf(stderr, "  version      show version number\n");
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x2b87d(%rip), %rax     # 0x2dff8
movq (%rax), %rdi
leaq 0x248dd(%rip), %rsi     # 0x27062
movb $0x0, %al
callq 0x2260
movq 0x2b865(%rip), %rax     # 0x2dff8
movq (%rax), %rdi
leaq 0x248e6(%rip), %rsi     # 0x27083
movb $0x0, %al
callq 0x2260
movq 0x2b84d(%rip), %rax     # 0x2dff8
movq (%rax), %rdi
leaq 0x248d9(%rip), %rsi     # 0x2708e
movb $0x0, %al
callq 0x2260
movq 0x2b835(%rip), %rax     # 0x2dff8
movq (%rax), %rdi
leaq 0x248e4(%rip), %rsi     # 0x270b1
movb $0x0, %al
callq 0x2260
movq 0x2b81d(%rip), %rax     # 0x2dff8
movq (%rax), %rdi
leaq 0x248e8(%rip), %rsi     # 0x270cd
movb $0x0, %al
callq 0x2260
movq 0x2b805(%rip), %rax     # 0x2dff8
movq (%rax), %rdi
leaq 0x248f1(%rip), %rsi     # 0x270ee
movb $0x0, %al
callq 0x2260
movq 0x2b7ed(%rip), %rax     # 0x2dff8
movq (%rax), %rdi
leaq 0x248fe(%rip), %rsi     # 0x27113
movb $0x0, %al
callq 0x2260
movq 0x2b7d5(%rip), %rax     # 0x2dff8
movq (%rax), %rdi
leaq 0x2491d(%rip), %rsi     # 0x2714a
movb $0x0, %al
callq 0x2260
movl $0x1, %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0xe, -0x18(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq 0x24320(%rip), %rdx     # 0x27364
callq 0x23e0
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
jl 0x306b
cmpl $0x73, -0x14(%rbp)
jne 0x3069
movq 0x2af52(%rip), %rax     # 0x2dfb0
movq (%rax), %rdi
callq 0x23f0
movl %eax, -0x18(%rbp)
jmp 0x3036
movq 0x2af26(%rip), %rax     # 0x2df98
movl (%rax), %eax
cmpl -0x8(%rbp), %eax
jne 0x309a
movq 0x2af78(%rip), %rax     # 0x2dff8
movq (%rax), %rdi
leaq 0x242dd(%rip), %rsi     # 0x27367
movb $0x0, %al
callq 0x2260
movl $0x1, -0x4(%rbp)
jmp 0x30bb
movq -0x10(%rbp), %rax
movq 0x2aef3(%rip), %rcx     # 0x2df98
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rdi
movl -0x18(%rbp), %esi
callq 0x14df0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]bgt/bgzf.c
// Function: load_block_from_cache
static int load_block_from_cache(BGZF *fp, int64_t block_address)
{
	khint_t k;
	cache_t *p;
	khash_t(cache) *h = (khash_t(cache)*)fp->cache;
	k = kh_get(cache, h, block_address);
	if (k == kh_end(h)) return 0;
	p = &kh_val(h, k);
	if (fp->block_length != 0) fp->block_offset = 0;
	fp->block_address = block_address;
	fp->block_length = p->size;
	memcpy(fp->uncompressed_block, p->block, BGZF_MAX_BLOCK_SIZE);
	_bgzf_seek((_bgzf_file_t)fp->fp, p->end_offset, SEEK_SET);
	return p->size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6620
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x4de0
movl $0x0, -0x4(%rbp)
jmp 0x4e5e
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x1c(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0x4e0b
movq -0x10(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rax
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rsi
movl $0x10000, %edx          # imm = 0x10000
callq 0x2290
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rsi
xorl %edx, %edx
callq 0x23b0
movq -0x28(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]bgt/bgzf.c
// Function: cache_block
static void cache_block(BGZF *fp, int size)
{
	int ret;
	khint_t k;
	cache_t *p;
	khash_t(cache) *h = (khash_t(cache)*)fp->cache;
	if (BGZF_MAX_BLOCK_SIZE >= fp->cache_size) return;
	if ((kh_size(h) + 1) * BGZF_MAX_BLOCK_SIZE > (uint32_t)fp->cache_size) {
		/* A better way would be to remove the oldest block in the
		 * cache, but here we remove a random one for simplicity. This
		 * should not have a big impact on performance. */
		for (k = kh_begin(h); k < kh_end(h); ++k)
			if (kh_exist(h, k)) break;
		if (k < kh_end(h)) {
			free(kh_val(h, k).block);
			kh_del(cache, h, k);
		}
	}
	k = kh_put(cache, h, fp->block_address, &ret);
	if (ret == 0) return; // if this happens, a bug!
	p = &kh_val(h, k);
	p->size = fp->block_length;
	p->end_offset = fp->block_address + size;
	p->block = (uint8_t*)malloc(BGZF_MAX_BLOCK_SIZE);
	memcpy(kh_val(h, k).block, fp->uncompressed_block, BGZF_MAX_BLOCK_SIZE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rcx
movl $0x10000, %eax          # imm = 0x10000
cmpl 0x4(%rcx), %eax
jl 0x50be
jmp 0x51e5
movq -0x28(%rbp), %rax
movl 0x4(%rax), %eax
addl $0x1, %eax
shll $0x10, %eax
movq -0x8(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jbe 0x514e
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x28(%rbp), %rcx
cmpl (%rcx), %eax
jae 0x511a
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x14(%rbp), %ecx
shrl $0x4, %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %eax
movl -0x14(%rbp), %ecx
andl $0xf, %ecx
shll %ecx
shrl %cl, %eax
andl $0x3, %eax
cmpl $0x0, %eax
jne 0x510d
jmp 0x511a
jmp 0x510f
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x50db
movl -0x14(%rbp), %eax
movq -0x28(%rbp), %rcx
cmpl (%rcx), %eax
jae 0x514c
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x14(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
callq 0x2040
movq -0x28(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x6780
jmp 0x514e
movq -0x28(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
leaq -0x10(%rbp), %rdx
callq 0x6800
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x10(%rbp)
jne 0x516e
jmp 0x51e5
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x14(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movslq -0xc(%rbp), %rax
addq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movl $0x10000, %edi          # imm = 0x10000
callq 0x22f0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x14(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
movl $0x10000, %edx          # imm = 0x10000
callq 0x2290
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]bgt/bgzf.c
// Function: free_cache
static void free_cache(BGZF *fp)
{
	khint_t k;
	khash_t(cache) *h = (khash_t(cache)*)fp->cache;
	if (fp->is_write) return;
	for (k = kh_begin(h); k < kh_end(h); ++k)
		if (kh_exist(h, k)) free(kh_val(h, k).block);
	kh_destroy(cache, h);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
shll $0xe, %eax
sarl $0x1e, %eax
cmpl $0x0, %eax
je 0x5f3b
jmp 0x5fa3
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jae 0x5f9a
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movl -0xc(%rbp), %ecx
shrl $0x4, %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %eax
movl -0xc(%rbp), %ecx
andl $0xf, %ecx
shll %ecx
shrl %cl, %eax
andl $0x3, %eax
cmpl $0x0, %eax
jne 0x5f8d
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movl -0xc(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
callq 0x2040
jmp 0x5f8f
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x5f42
movq -0x18(%rbp), %rdi
callq 0x74b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xdb98
jmp 0xdc7b
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0xdbca
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2040
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xdb9f
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jge 0xdbfd
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2040
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xdbd1
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jge 0xdc4b
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x2040
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2040
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xdc04
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rdi
callq 0x2040
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x21e0
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jl 0xdcc8
movq $0x0, -0x8(%rbp)
jmp 0xde2c
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rdi
leaq -0x30(%rbp), %rsi
callq 0xde40
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movq -0x38(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0xde24
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x3c(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movl $0x9, %edi
leaq -0x30(%rbp), %rsi
callq 0xde80
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x48(%rbp), %rcx
movl (%rcx), %ecx
andl $0xfffffff, %ecx        # imm = 0xFFFFFFF
movl %ecx, %ecx
movq (%rax,%rcx,8), %rdi
leaq -0x30(%rbp), %rsi
callq 0xde40
movq -0x48(%rbp), %rax
movl (%rax), %eax
shrl $0x1c, %eax
cmpl $0x0, %eax
je 0xde14
movl $0x3a, %edi
leaq -0x30(%rbp), %rsi
callq 0xde80
movq 0x2061b(%rip), %rax     # 0x2e390
movq -0x48(%rbp), %rcx
movl (%rcx), %ecx
shrl $0x1c, %ecx
movl %ecx, %ecx
movsbl (%rax,%rcx), %edi
leaq -0x30(%rbp), %rsi
callq 0xde80
movl $0x3a, %edi
leaq -0x30(%rbp), %rsi
callq 0xde80
movq -0x48(%rbp), %rax
movl (%rax), %eax
shrl $0x1c, %eax
cmpl $0x1, %eax
jne 0xddc5
movq -0x48(%rbp), %rax
movslq 0x4(%rax), %rdx
leaq -0x30(%rbp), %rdi
leaq 0x1a273(%rip), %rsi     # 0x2802f
movb $0x0, %al
callq 0xdfb0
jmp 0xde12
movq -0x48(%rbp), %rax
movl (%rax), %eax
shrl $0x1c, %eax
cmpl $0x2, %eax
jne 0xddf4
movq -0x48(%rbp), %rax
movss 0x4(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
leaq -0x30(%rbp), %rdi
leaq 0x1a249(%rip), %rsi     # 0x28034
movb $0x1, %al
callq 0xdfb0
jmp 0xde10
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x48(%rbp), %rcx
movl 0x4(%rcx), %ecx
movq (%rax,%rcx,8), %rdi
leaq -0x30(%rbp), %rsi
callq 0xde40
jmp 0xde12
jmp 0xde14
jmp 0xde16
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0xdcf6
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jl 0xe1fb
movl $0x0, -0x4(%rbp)
jmp 0xe374
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x24270
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
movq -0x28(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0xe330
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x30(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rdx
leaq 0x19ddc(%rip), %rsi     # 0x28037
callq 0x23e90
movq -0x40(%rbp), %rax
movl (%rax), %eax
shrl $0x1c, %eax
cmpl $0x3, %eax
jne 0xe2a6
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x40(%rbp), %rcx
movl (%rcx), %ecx
andl $0xfffffff, %ecx        # imm = 0xFFFFFFF
movl %ecx, %ecx
movq (%rax,%rcx,8), %rsi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x40(%rbp), %rcx
movl 0x4(%rcx), %ecx
movq (%rax,%rcx,8), %rdx
callq 0x23e90
jmp 0xe320
movq -0x40(%rbp), %rax
movl (%rax), %eax
shrl $0x1c, %eax
cmpl $0x1, %eax
jne 0xe2e1
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x40(%rbp), %rcx
movl (%rcx), %ecx
andl $0xfffffff, %ecx        # imm = 0xFFFFFFF
movl %ecx, %ecx
movq (%rax,%rcx,8), %rsi
movq -0x40(%rbp), %rax
movslq 0x4(%rax), %rdx
callq 0x23c90
jmp 0xe31e
movq -0x40(%rbp), %rax
movl (%rax), %eax
shrl $0x1c, %eax
cmpl $0x2, %eax
jne 0xe31c
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x40(%rbp), %rcx
movl (%rcx), %ecx
andl $0xfffffff, %ecx        # imm = 0xFFFFFFF
movl %ecx, %ecx
movq (%rax,%rcx,8), %rsi
movq -0x40(%rbp), %rax
cvttss2si 0x4(%rax), %rdx
callq 0x23c90
jmp 0xe31e
jmp 0xe320
jmp 0xe322
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0xe222
movq -0x20(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
callq 0x23b80
cmpq $0x0, %rax
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x34(%rbp)
movb $0x1, %al
cmpl $0x0, -0x2c(%rbp)
movb %al, -0x41(%rbp)
jne 0xe367
cmpl $0x0, -0x34(%rbp)
setne %al
xorb $-0x1, %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xe3be
movq -0x10(%rbp), %rdi
leaq 0x19116(%rip), %rsi     # 0x274b4
callq 0x2240
cmpl $0x0, %eax
je 0xe3be
movq -0x10(%rbp), %rdi
leaq 0x19d2b(%rip), %rsi     # 0x280de
callq 0x2380
movq %rax, -0x28(%rbp)
jmp 0xe3df
movq 0x1fbc3(%rip), %rax     # 0x2df88
movq (%rax), %rdi
callq 0x22b0
movl %eax, %edi
leaq 0x19d08(%rip), %rsi     # 0x280de
callq 0x2140
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xe3f8
movq $0x0, -0x8(%rbp)
jmp 0xe432
movl $0x1, %edi
movl $0x28, %esi
callq 0x2230
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rdi
callq 0x7500
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xe455
jmp 0xe484
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x7560
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rdi
callq 0x2040
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0xe500
movl %eax, -0x20(%rbp)
cmpl $0x0, %eax
jne 0xe4c6
jmp 0xe4ab
cmpl $0x0, -0x20(%rbp)
jge 0xe4d6
movq $0x0, -0x8(%rbp)
jmp 0xe4ef
cmpl $0x0, -0x1c(%rbp)
je 0xe4e3
movq -0x28(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x3, -0xc(%rbp)
jge 0xfaf7
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq 0x30(%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %edx
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl %edx, 0x8(%rax,%rcx,4)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, %esi
shlq $0x4, %rsi
callq 0x2340
movq %rax, %rdx
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq %rdx, 0x18(%rax,%rcx,8)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
je 0xfae7
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x10(%rbp), %ecx
shrl $0x4, %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %eax
movl -0x10(%rbp), %ecx
andl $0xf, %ecx
shll %ecx
shrl %cl, %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0xfa5d
jmp 0xfad9
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movl -0x10(%rbp), %ecx
movq (%rax,%rcx,8), %rcx
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rdx
movq 0x18(%rax,%rdx,8), %rax
movq -0x18(%rbp), %rdx
movq 0x20(%rdx), %rdx
movl -0x10(%rbp), %esi
shlq $0x4, %rsi
addq %rsi, %rdx
movslq 0xc(%rdx), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rcx
movl -0x10(%rbp), %eax
shlq $0x4, %rax
addq %rax, %rcx
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rdx
movq 0x18(%rax,%rdx,8), %rax
movq -0x18(%rbp), %rdx
movq 0x20(%rdx), %rdx
movl -0x10(%rbp), %esi
shlq $0x4, %rsi
addq %rsi, %rdx
movslq 0xc(%rdx), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xfa27
jmp 0xfae9
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xf9c3
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x1868d(%rip), %rsi     # 0x281a4
callq 0xf2d0
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x18(%rbp)
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x48(%rcx), %rcx
subq %rcx, %rax
movq -0x8(%rbp), %rcx
movslq (%rcx), %rcx
cmpq %rcx, %rax
jge 0xfbb5
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
je 0xfb61
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0xfb61
jmp 0xfba4
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xf2d0
movl -0x1c(%rbp), %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0xfb98
jmp 0xfbb5
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xfb2c
movq -0x8(%rbp), %rdi
callq 0xf9b0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x1, %edi
movl $0x68, %esi
callq 0x2230
movq %rax, -0x10(%rbp)
movl $0x0, -0x4(%rbp)
cmpl $0x3, -0x4(%rbp)
jge 0xfe28
callq 0x15ef0
movq %rax, %rdx
movq -0x10(%rbp), %rax
movslq -0x4(%rbp), %rcx
movq %rdx, 0x30(%rax,%rcx,8)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xfe02
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)