LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aes128poetv1aes4/ni/encrypt.c
// Function: crypto_aead_decrypt
int crypto_aead_decrypt(unsigned char *m,unsigned long long *mlen,
			unsigned char *nsec,
			const unsigned char *c,unsigned long long clen,
			const unsigned char *ad,unsigned long long adlen,
			const unsigned char *npub,
			const unsigned char *k)
{
  struct poet_ctx ctx;
  unsigned char *header =  malloc((size_t) (adlen+CRYPTO_NPUBBYTES));
  unsigned char tag[CRYPTO_NPUBBYTES];
  int result;

  errno = 0;

  if(clen < CRYPTO_NPUBBYTES) return -1;
  *mlen = clen - CRYPTO_NPUBBYTES;

  keysetup(&ctx, k);
  memcpy(tag,c+(clen-CRYPTO_NPUBBYTES), CRYPTO_NPUBBYTES);

  memcpy(header,ad, adlen);
  memcpy(header+adlen, npub, CRYPTO_NPUBBYTES);
  process_header(&ctx, header, adlen+CRYPTO_NPUBBYTES);

  result = decrypt_final(&ctx, c, *mlen, tag,m);

  if (errno|result) return -1;
  else return 0;
}

// Assembly:
subq $0x2f8, %rsp            # imm = 0x2F8
movq 0x310(%rsp), %rax
movq 0x308(%rsp), %rax
movq 0x300(%rsp), %rax
movq %rdi, 0x2e8(%rsp)
movq %rsi, 0x2e0(%rsp)
movq %rdx, 0x2d8(%rsp)
movq %rcx, 0x2d0(%rsp)
movq %r8, 0x2c8(%rsp)
movq %r9, 0x2c0(%rsp)
movq 0x300(%rsp), %rdi
addq $0x10, %rdi
callq 0x1050
movq %rax, 0x28(%rsp)
callq 0x1100
movl $0x0, (%rax)
cmpq $0x10, 0x2c8(%rsp)
jae 0x23db
movl $0xffffffff, 0x2f4(%rsp) # imm = 0xFFFFFFFF
jmp 0x24db
movq 0x2c8(%rsp), %rcx
subq $0x10, %rcx
movq 0x2e0(%rsp), %rax
movq %rcx, (%rax)
movq 0x310(%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0x1170
movq 0x2d0(%rsp), %rax
movq 0x2c8(%rsp), %rcx
subq $0x10, %rcx
movq (%rax,%rcx), %rdx
movq %rdx, 0x10(%rsp)
movq 0x8(%rax,%rcx), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movq 0x2c0(%rsp), %rsi
movq 0x300(%rsp), %rdx
callq 0x1160
movq 0x28(%rsp), %rax
movq 0x300(%rsp), %rcx
movq 0x308(%rsp), %rdx
movq (%rdx), %rsi
movq %rsi, (%rax,%rcx)
movq 0x8(%rdx), %rdx
movq %rdx, 0x8(%rax,%rcx)
movq 0x28(%rsp), %rsi
movq 0x300(%rsp), %rdx
addq $0x10, %rdx
leaq 0x30(%rsp), %rdi
callq 0x1120
movq 0x2d0(%rsp), %rsi
movq 0x2e0(%rsp), %rax
movq (%rax), %rdx
leaq 0x10(%rsp), %rcx
movq 0x2e8(%rsp), %r8
leaq 0x30(%rsp), %rdi
callq 0x1090
movl %eax, 0xc(%rsp)
callq 0x1100
movl (%rax), %eax
orl 0xc(%rsp), %eax
cmpl $0x0, %eax
je 0x24d0
movl $0xffffffff, 0x2f4(%rsp) # imm = 0xFFFFFFFF
jmp 0x24db
movl $0x0, 0x2f4(%rsp)
movl 0x2f4(%rsp), %eax
addq $0x2f8, %rsp            # imm = 0x2F8
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aes128poetv1aes4/ni/poet.c
// Function: keysetup
void keysetup(struct poet_ctx *ctx, const uint8_t key[KEYLEN_BITS])
{
  uint8_t ctr[BLOCKLEN];
  AES_KEY aes_key;

  memset(ctx->tau,0,BLOCKLEN);
  memset(ctr,0, BLOCKLEN);

  /* Generate block cipher key */
  AESNI_Key_Expansion(key, aes_key);
  AESNI_encrypt(ctr, ctx->k,aes_key);

  AESNI_Key_Expansion(ctx->k, ctx->aes_enc);
  AES_Key_Dec(ctx->aes_enc, ctx->aes_dec);

  /* Generate header key */
  ctr[BLOCKLEN-1]+=1; AESNI_encrypt(ctr, ctx->l, aes_key);

  /* Generate almost XOR universal hash function keys */
  ctr[BLOCKLEN-1]+=1; AESNI_encrypt(ctr, ctx->lt, aes_key);
  AESNI_Key_Expansion4(ctx->lt, ctx->aes_lt);
  ctr[BLOCKLEN-1]+=1; AESNI_encrypt(ctr, ctx->lb, aes_key);
  AESNI_Key_Expansion4(ctx->lb,ctx->aes_lb);

  /* Generate tag masking keys */
  ctr[BLOCKLEN-1]+=1; AESNI_encrypt(ctr, ctx->tm, aes_key);

}

// Assembly:
subq $0xd8, %rsp
movq %rdi, 0xd0(%rsp)
movq %rsi, 0xc8(%rsp)
movq 0xd0(%rsp), %rdi
addq $0x270, %rdi            # imm = 0x270
xorl %esi, %esi
movl $0x10, %edx
callq 0x1030
leaq 0xb0(%rsp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x1030
movq 0xc8(%rsp), %rdi
movq %rsp, %rsi
callq 0x10b0
leaq 0xb0(%rsp), %rdi
movq 0xd0(%rsp), %rsi
addq $0x200, %rsi            # imm = 0x200
movq %rsp, %rdx
callq 0x1130
movq 0xd0(%rsp), %rdi
addq $0x200, %rdi            # imm = 0x200
movq 0xd0(%rsp), %rsi
callq 0x10b0
movq 0xd0(%rsp), %rdi
movq 0xd0(%rsp), %rsi
addq $0xb0, %rsi
callq 0x10c0
movzbl 0xbf(%rsp), %eax
addl $0x1, %eax
movb %al, 0xbf(%rsp)
leaq 0xb0(%rsp), %rdi
movq 0xd0(%rsp), %rsi
addq $0x220, %rsi            # imm = 0x220
movq %rsp, %rdx
callq 0x1130
movzbl 0xbf(%rsp), %eax
addl $0x1, %eax
movb %al, 0xbf(%rsp)
leaq 0xb0(%rsp), %rdi
movq 0xd0(%rsp), %rsi
addq $0x230, %rsi            # imm = 0x230
movq %rsp, %rdx
callq 0x1130
movq 0xd0(%rsp), %rdi
addq $0x230, %rdi            # imm = 0x230
movq 0xd0(%rsp), %rsi
addq $0x160, %rsi            # imm = 0x160
callq 0x1110
movzbl 0xbf(%rsp), %eax
addl $0x1, %eax
movb %al, 0xbf(%rsp)
leaq 0xb0(%rsp), %rdi
movq 0xd0(%rsp), %rsi
addq $0x240, %rsi            # imm = 0x240
movq %rsp, %rdx
callq 0x1130
movq 0xd0(%rsp), %rdi
addq $0x240, %rdi            # imm = 0x240
movq 0xd0(%rsp), %rsi
addq $0x1b0, %rsi            # imm = 0x1B0
callq 0x1110
movzbl 0xbf(%rsp), %eax
addl $0x1, %eax
movb %al, 0xbf(%rsp)
leaq 0xb0(%rsp), %rdi
movq 0xd0(%rsp), %rsi
addq $0x210, %rsi            # imm = 0x210
movq %rsp, %rdx
callq 0x1130
addq $0xd8, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aes128poetv1aes4/ni/gf_mul.h
// Function: GF128_quintuple
static void GF128_quintuple(uint64_t  *h)
{
  uint64_t tmp[2];

  memcpy(tmp,h, BLOCKLEN);

  GF128_double(h);
  GF128_double(h);
  h[0]^=tmp[0];
  h[1]^=tmp[1];
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x2a60
movq 0x10(%rsp), %rdi
callq 0x2a60
movq (%rsp), %rcx
movq 0x10(%rsp), %rax
xorq (%rax), %rcx
movq %rcx, (%rax)
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
xorq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aes128poetv1aes4/ni/poet.c
// Function: encrypt_block
void encrypt_block(struct poet_ctx *ctx, const uint8_t plaintext[16],
		   uint8_t ciphertext[16])
{
  block tmp;
  TOP_HASH;
  xor_block(ctx->x, plaintext,ctx->x);

  AESNI_encrypt(ctx->x, tmp, ctx->aes_enc);

  BOTTOM_HASH;
  xor_block(ciphertext, tmp,ctx->y);

  memcpy(ctx->y, tmp, BLOCKLEN);
  ctx->mlen+=BLOCKLEN_BITS;

}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
addq $0x250, %rdi            # imm = 0x250
movq 0x20(%rsp), %rsi
addq $0x250, %rsi            # imm = 0x250
movq 0x20(%rsp), %rdx
addq $0x160, %rdx            # imm = 0x160
callq 0x1040
movq 0x20(%rsp), %rdi
addq $0x250, %rdi            # imm = 0x250
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
addq $0x250, %rdx            # imm = 0x250
callq 0x1150
movq 0x20(%rsp), %rdi
addq $0x250, %rdi            # imm = 0x250
movq %rsp, %rsi
movq 0x20(%rsp), %rdx
callq 0x1130
movq 0x20(%rsp), %rdi
addq $0x260, %rdi            # imm = 0x260
movq 0x20(%rsp), %rsi
addq $0x260, %rsi            # imm = 0x260
movq 0x20(%rsp), %rdx
addq $0x1b0, %rdx            # imm = 0x1B0
callq 0x1040
movq 0x10(%rsp), %rdi
movq %rsp, %rsi
movq 0x20(%rsp), %rdx
addq $0x260, %rdx            # imm = 0x260
callq 0x1150
movq 0x20(%rsp), %rax
movq (%rsp), %rcx
movq %rcx, 0x260(%rax)
movq 0x8(%rsp), %rcx
movq %rcx, 0x268(%rax)
movq 0x20(%rsp), %rax
movq 0x280(%rax), %rcx
addq $0x80, %rcx
movq %rcx, 0x280(%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aes128poetv1aes4/ni/poet.c
// Function: decrypt_block
void decrypt_block(struct poet_ctx *ctx, const uint8_t ciphertext[16],
		   uint8_t plaintext[16])
{
  block tmp;
  BOTTOM_HASH;
  xor_block(ctx->y, ciphertext,ctx->y);

  AESNI_decrypt(ctx->y, tmp, ctx->aes_dec);

  TOP_HASH;
  xor_block(plaintext, tmp,ctx->x);

  memcpy(ctx->x, tmp, BLOCKLEN);
  ctx->mlen+=BLOCKLEN_BITS;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
addq $0x260, %rdi            # imm = 0x260
movq 0x20(%rsp), %rsi
addq $0x260, %rsi            # imm = 0x260
movq 0x20(%rsp), %rdx
addq $0x1b0, %rdx            # imm = 0x1B0
callq 0x1040
movq 0x20(%rsp), %rdi
addq $0x260, %rdi            # imm = 0x260
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
addq $0x260, %rdx            # imm = 0x260
callq 0x1150
movq 0x20(%rsp), %rdi
addq $0x260, %rdi            # imm = 0x260
movq %rsp, %rsi
movq 0x20(%rsp), %rdx
addq $0xb0, %rdx
callq 0x1080
movq 0x20(%rsp), %rdi
addq $0x250, %rdi            # imm = 0x250
movq 0x20(%rsp), %rsi
addq $0x250, %rsi            # imm = 0x250
movq 0x20(%rsp), %rdx
addq $0x160, %rdx            # imm = 0x160
callq 0x1040
movq 0x10(%rsp), %rdi
movq %rsp, %rsi
movq 0x20(%rsp), %rdx
addq $0x250, %rdx            # imm = 0x250
callq 0x1150
movq 0x20(%rsp), %rax
movq (%rsp), %rcx
movq %rcx, 0x250(%rax)
movq 0x8(%rsp), %rcx
movq %rcx, 0x258(%rax)
movq 0x20(%rsp), %rax
movq 0x280(%rax), %rcx
addq $0x80, %rcx
movq %rcx, 0x280(%rax)
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gmcvicker[P]check_fastq/util.c
// Function: util_has_gz_ext
int util_has_gz_ext(const char *filename) {
  size_t len;

  len = strlen(filename);

  if((len > 3) && (strncmp(&filename[len-3], ".gz",3)==0)) {
    return TRUE;
  }
  return FALSE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2150
movq %rax, -0x18(%rbp)
cmpq $0x3, -0x18(%rbp)
jbe 0x264e
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
subq $0x3, %rax
addq %rax, %rdi
leaq 0x2a2a(%rip), %rsi      # 0x5060
movl $0x3, %edx
callq 0x20f0
cmpl $0x0, %eax
jne 0x264e
movl $0x1, -0x4(%rbp)
jmp 0x2655
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gmcvicker[P]check_fastq/util.c
// Function: util_read_entire_file
char *util_read_entire_file(char *filename) {
  FILE *fh;
  struct stat fs;
  char *buf;

  fh = fopen(filename, "r");

  if(fh == NULL) {
    my_err("%s:%d: Could not open tree file '%s'", __FILE__, 
	    __LINE__, filename);
  }

  /* determine file size */
  fstat(fileno(fh), &fs);

  /* read entire file at once */
  buf = my_new(char, fs.st_size + 1);
  if(fread(buf, fs.st_size, 1, fh) == 0) {
    my_err("%s:%d: Could not read entire file '%s'", __FILE__,
	    __LINE__, filename);
  }

  buf[fs.st_size] = '\0';

  return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x29ea(%rip), %rsi      # 0x5064
callq 0x2110
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x26a8
movq -0x8(%rbp), %rcx
leaq 0x29d1(%rip), %rdi      # 0x5066
leaq 0x2cb0(%rip), %rsi      # 0x534c
movl $0x31, %edx
movb $0x0, %al
callq 0x4010
movq -0x10(%rbp), %rdi
callq 0x2030
movl %eax, %edi
leaq -0xa0(%rbp), %rsi
callq 0x20c0
movq -0x70(%rbp), %rdi
shlq $0x0, %rdi
addq $0x1, %rdi
callq 0x4220
movq %rax, -0xa8(%rbp)
movq -0xa8(%rbp), %rdi
movq -0x70(%rbp), %rsi
movq -0x10(%rbp), %rcx
movl $0x1, %edx
callq 0x21c0
cmpq $0x0, %rax
jne 0x2714
movq -0x8(%rbp), %rcx
leaq 0x298a(%rip), %rdi      # 0x508b
leaq 0x2c44(%rip), %rsi      # 0x534c
movl $0x3b, %edx
movb $0x0, %al
callq 0x4010
movq -0xa8(%rbp), %rax
movq -0x70(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0xa8(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gmcvicker[P]check_fastq/util.c
// Function: util_fcount_lines
long util_fcount_lines(FILE *fh) {
  char buf[UTIL_FGETS_BUF_SZ];
  long line_count;
  int len;

  if(fseek(fh, 0L, SEEK_SET) != 0) {
    my_err("%s:%d: could not rewind filehandle", __FILE__, __LINE__);
  }

  line_count = 0;
  while(fgets(buf, UTIL_FGETS_BUF_SZ, fh) != NULL) {
    len = strlen(buf);
    if(buf[len-1] == '\n') {
      line_count++;
    }
  }

  if(fseek(fh, 0L, SEEK_SET) != 0) {
    my_err("%s:%d: could not rewind filehandle", __FILE__, __LINE__);
  }

  return line_count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x4000, %rsp           # imm = 0x4000
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x2080
cmpl $0x0, %eax
je 0x277d
leaq 0x2948(%rip), %rdi      # 0x50b2
leaq 0x2bdb(%rip), %rsi      # 0x534c
movl $0x50, %edx
movb $0x0, %al
callq 0x4010
movq $0x0, -0x3ff8(%rbp)
leaq -0x3ff0(%rbp), %rdi
movq -0x8(%rbp), %rdx
movl $0x3fdc, %esi           # imm = 0x3FDC
callq 0x2130
cmpq $0x0, %rax
je 0x27e1
leaq -0x3ff0(%rbp), %rdi
callq 0x2150
movl %eax, -0x3ffc(%rbp)
movl -0x3ffc(%rbp), %eax
subl $0x1, %eax
cltq
movsbl -0x3ff0(%rbp,%rax), %eax
cmpl $0xa, %eax
jne 0x27df
movq -0x3ff8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x3ff8(%rbp)
jmp 0x2788
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x2080
cmpl $0x0, %eax
je 0x280f
leaq 0x28b6(%rip), %rdi      # 0x50b2
leaq 0x2b49(%rip), %rsi      # 0x534c
movl $0x5c, %edx
movb $0x0, %al
callq 0x4010
movq -0x3ff8(%rbp), %rax
addq $0x4000, %rsp           # imm = 0x4000
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gmcvicker[P]check_fastq/util.c
// Function: util_gzcount_lines
long util_gzcount_lines(gzFile gzf) {
  char buf[UTIL_FGETS_BUF_SZ];
  long line_count;
  size_t len;

  if(gzseek(gzf, 0L, SEEK_SET) != 0) {
    my_err("%s:%d: could not rewind filehandle", __FILE__, __LINE__);
  }

  line_count = 0;

  while(gzgets(gzf, buf, UTIL_FGETS_BUF_SZ) != NULL) {
    len = strlen(buf);
    if(buf[len-1] == '\n') {
      line_count++;
    }
  }

  if(gzseek(gzf, 0L, SEEK_SET) != 0) {
    my_err("%s:%d: could not rewind filehandle", __FILE__, __LINE__);
  }

  return line_count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x4000, %rsp           # imm = 0x4000
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x2120
cmpq $0x0, %rax
je 0x285e
leaq 0x2867(%rip), %rdi      # 0x50b2
leaq 0x2afa(%rip), %rsi      # 0x534c
movl $0x6f, %edx
movb $0x0, %al
callq 0x4010
movq $0x0, -0x3ff8(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x3ff0(%rbp), %rsi
movl $0x3fdc, %edx           # imm = 0x3FDC
callq 0x2230
cmpq $0x0, %rax
je 0x28c3
leaq -0x3ff0(%rbp), %rdi
callq 0x2150
movq %rax, -0x4000(%rbp)
movq -0x4000(%rbp), %rax
subq $0x1, %rax
movsbl -0x3ff0(%rbp,%rax), %eax
cmpl $0xa, %eax
jne 0x28c1
movq -0x3ff8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x3ff8(%rbp)
jmp 0x2869
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x2120
cmpq $0x0, %rax
je 0x28f2
leaq 0x27d3(%rip), %rdi      # 0x50b2
leaq 0x2a66(%rip), %rsi      # 0x534c
movl $0x7c, %edx
movb $0x0, %al
callq 0x4010
movq -0x3ff8(%rbp), %rax
addq $0x4000, %rsp           # imm = 0x4000
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gmcvicker[P]check_fastq/util.c
// Function: util_fcount_lines_match
long util_fcount_lines_match(FILE *fh, const char *starts_with) {
  char buf[UTIL_FGETS_BUF_SZ];
  long line_count;
  int started_with, at_line_start;
  int match_len, len;

  if(fseek(fh, 0L, SEEK_SET) != 0) {
    my_err("%s:%d: could not rewind filehandle", __FILE__, __LINE__);
  }

  match_len = strlen(starts_with);
  if(match_len == 0) {
    return 0;
  }

  if(match_len > UTIL_FGETS_BUF_SZ) {
    my_err("%s:%d: length of string to match must be"
	    "<= %d bytes", __FILE__, __LINE__, UTIL_FGETS_BUF_SZ);
  }

  line_count = 0;
  started_with  = FALSE;
  at_line_start = TRUE;

  while(fgets(buf, UTIL_FGETS_BUF_SZ, fh) != NULL) {
    if(at_line_start) {
      /* we are at the beginning of a line, does it match the string? */
      if(strncmp(starts_with, buf, match_len) == 0) {
	started_with = TRUE;
      }
    }

    len = strlen(buf);
    if(buf[len-1] == '\n') {
      /* we are at the end of the line, did the beginning match? */
      if(started_with) {
	line_count++;
	started_with = FALSE;
      }
      at_line_start = TRUE;
    } else {
      at_line_start = FALSE;
    }
  }

  if(fseek(fh, 0L, SEEK_SET) != 0) {
    my_err("%s:%d: could not rewind filehandle", __FILE__, __LINE__);
  }

  return line_count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x4020, %rsp           # imm = 0x4020
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x2080
cmpl $0x0, %eax
je 0x2951
leaq 0x2774(%rip), %rdi      # 0x50b2
leaq 0x2a07(%rip), %rsi      # 0x534c
movl $0x91, %edx
movb $0x0, %al
callq 0x4010
movq -0x18(%rbp), %rdi
callq 0x2150
movl %eax, -0x4014(%rbp)
cmpl $0x0, -0x4014(%rbp)
jne 0x2976
movq $0x0, -0x8(%rbp)
jmp 0x2ab3
cmpl $0x3fdc, -0x4014(%rbp)  # imm = 0x3FDC
jle 0x29a1
leaq 0x274c(%rip), %rdi      # 0x50d5
leaq 0x29bc(%rip), %rsi      # 0x534c
movl $0x9b, %edx
movl $0x3fdc, %ecx           # imm = 0x3FDC
movb $0x0, %al
callq 0x4010
movq $0x0, -0x4008(%rbp)
movl $0x0, -0x400c(%rbp)
movl $0x1, -0x4010(%rbp)
leaq -0x4000(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl $0x3fdc, %esi           # imm = 0x3FDC
callq 0x2130
cmpq $0x0, %rax
je 0x2a7a
cmpl $0x0, -0x4010(%rbp)
je 0x2a10
movq -0x18(%rbp), %rdi
leaq -0x4000(%rbp), %rsi
movslq -0x4014(%rbp), %rdx
callq 0x20f0
cmpl $0x0, %eax
jne 0x2a0e
movl $0x1, -0x400c(%rbp)
jmp 0x2a10
leaq -0x4000(%rbp), %rdi
callq 0x2150
movl %eax, -0x4018(%rbp)
movl -0x4018(%rbp), %eax
subl $0x1, %eax
cltq
movsbl -0x4000(%rbp,%rax), %eax
cmpl $0xa, %eax
jne 0x2a6b
cmpl $0x0, -0x400c(%rbp)
je 0x2a5f
movq -0x4008(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x4008(%rbp)
movl $0x0, -0x400c(%rbp)
movl $0x1, -0x4010(%rbp)
jmp 0x2a75
movl $0x0, -0x4010(%rbp)
jmp 0x29c0
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x2080
cmpl $0x0, %eax
je 0x2aa8
leaq 0x261d(%rip), %rdi      # 0x50b2
leaq 0x28b0(%rip), %rsi      # 0x534c
movl $0xb8, %edx
movb $0x0, %al
callq 0x4010
movq -0x4008(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x4020, %rsp           # imm = 0x4020
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/gmcvicker[P]check_fastq/util.c
// Function: util_gzgets_line
char *util_gzgets_line(gzFile gzf) {
  char buf[UTIL_FGETS_BUF_SZ];
  char *line, *old_line;;
  long len, ttl_len;

  if(gzgets(gzf, buf, UTIL_FGETS_BUF_SZ) == NULL) {
    return NULL;
  }

  len = strlen(buf);
  ttl_len = len;
  line = my_new(char, len+1);
  strcpy(line, buf);

  /* keep extending the line until a newline or EOF is reached */
  while(buf[len-1] != '\n') {
    if(gzgets(gzf, buf, UTIL_FGETS_BUF_SZ) == NULL) {
      return line;
    }

    /* extend the line */
    len = strlen(buf);
    old_line = line;

    line = util_str_concat(old_line, buf, NULL);
    ttl_len += len;

    my_free(old_line);
  }

  /* remove trailing newline char */
  if(line[ttl_len-1] == '\n') {
    line[ttl_len-1] = '\0';
  }

  return line;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x4010, %rsp           # imm = 0x4010
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x3ff0(%rbp), %rsi
movl $0x3fdc, %edx           # imm = 0x3FDC
callq 0x2230
cmpq $0x0, %rax
jne 0x2f37
movq $0x0, -0x8(%rbp)
jmp 0x3087
leaq -0x3ff0(%rbp), %rdi
callq 0x2150
movq %rax, -0x4008(%rbp)
movq -0x4008(%rbp), %rax
movq %rax, -0x4010(%rbp)
movq -0x4008(%rbp), %rdi
shlq $0x0, %rdi
addq $0x1, %rdi
callq 0x4220
movq %rax, -0x3ff8(%rbp)
movq -0x3ff8(%rbp), %rdi
leaq -0x3ff0(%rbp), %rsi
callq 0x2200
movq -0x4008(%rbp), %rax
subq $0x1, %rax
movsbl -0x3ff0(%rbp,%rax), %eax
cmpl $0xa, %eax
je 0x304b
movq -0x10(%rbp), %rdi
leaq -0x3ff0(%rbp), %rsi
movl $0x3fdc, %edx           # imm = 0x3FDC
callq 0x2230
cmpq $0x0, %rax
jne 0x2fcd
movq -0x3ff8(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3087
leaq -0x3ff0(%rbp), %rdi
callq 0x2150
movq %rax, -0x4008(%rbp)
movq -0x3ff8(%rbp), %rax
movq %rax, -0x4000(%rbp)
movq -0x4000(%rbp), %rdi
leaq -0x3ff0(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movb $0x0, %al
callq 0x2cc0
movq %rax, -0x3ff8(%rbp)
movq -0x4008(%rbp), %rax
addq -0x4010(%rbp), %rax
movq %rax, -0x4010(%rbp)
movq -0x4000(%rbp), %rdi
leaq 0x231b(%rip), %rsi      # 0x534c
movl $0x163, %edx            # imm = 0x163
callq 0x42b0
movq $0x0, -0x4000(%rbp)
jmp 0x2f86
movq -0x3ff8(%rbp), %rax
movq -0x4010(%rbp), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
jne 0x307c
movq -0x3ff8(%rbp), %rax
movq -0x4010(%rbp), %rcx
subq $0x1, %rcx
movb $0x0, (%rax,%rcx)
movq -0x3ff8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x4010, %rsp           # imm = 0x4010
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gmcvicker[P]check_fastq/util.c
// Function: util_fgets_line
char *util_fgets_line(FILE *fh) {
  char buf[UTIL_FGETS_BUF_SZ];
  char *line, *old_line;;
  long len, ttl_len;

  if(fgets(buf, UTIL_FGETS_BUF_SZ, fh) == NULL) {
    return NULL;
  }

  len = strlen(buf);
  ttl_len = len;
  line = my_new(char, len+1);
  strcpy(line, buf);

  /* keep extending the line until a newline or EOF is reached */
  while(buf[len-1] != '\n') {
    if(fgets(buf, UTIL_FGETS_BUF_SZ, fh) == NULL) {
      return line;
    }

    /* extend the line */
    len = strlen(buf);
    old_line = line;

    line = util_str_concat(old_line, buf, NULL);
    ttl_len += len;

    my_free(old_line);
  }

  /* remove trailing newline char */
  if(line[ttl_len-1] == '\n') {
    line[ttl_len-1] = '\0';
  }

  return line;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x4010, %rsp           # imm = 0x4010
movq %rdi, -0x10(%rbp)
leaq -0x3ff0(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl $0x3fdc, %esi           # imm = 0x3FDC
callq 0x2130
cmpq $0x0, %rax
jne 0x30d7
movq $0x0, -0x8(%rbp)
jmp 0x3227
leaq -0x3ff0(%rbp), %rdi
callq 0x2150
movq %rax, -0x4008(%rbp)
movq -0x4008(%rbp), %rax
movq %rax, -0x4010(%rbp)
movq -0x4008(%rbp), %rdi
shlq $0x0, %rdi
addq $0x1, %rdi
callq 0x4220
movq %rax, -0x3ff8(%rbp)
movq -0x3ff8(%rbp), %rdi
leaq -0x3ff0(%rbp), %rsi
callq 0x2200
movq -0x4008(%rbp), %rax
subq $0x1, %rax
movsbl -0x3ff0(%rbp,%rax), %eax
cmpl $0xa, %eax
je 0x31eb
leaq -0x3ff0(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl $0x3fdc, %esi           # imm = 0x3FDC
callq 0x2130
cmpq $0x0, %rax
jne 0x316d
movq -0x3ff8(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3227
leaq -0x3ff0(%rbp), %rdi
callq 0x2150
movq %rax, -0x4008(%rbp)
movq -0x3ff8(%rbp), %rax
movq %rax, -0x4000(%rbp)
movq -0x4000(%rbp), %rdi
leaq -0x3ff0(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movb $0x0, %al
callq 0x2cc0
movq %rax, -0x3ff8(%rbp)
movq -0x4008(%rbp), %rax
addq -0x4010(%rbp), %rax
movq %rax, -0x4010(%rbp)
movq -0x4000(%rbp), %rdi
leaq 0x217b(%rip), %rsi      # 0x534c
movl $0x191, %edx            # imm = 0x191
callq 0x42b0
movq $0x0, -0x4000(%rbp)
jmp 0x3126
movq -0x3ff8(%rbp), %rax
movq -0x4010(%rbp), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
jne 0x321c
movq -0x3ff8(%rbp), %rax
movq -0x4010(%rbp), %rcx
subq $0x1, %rcx
movb $0x0, (%rax,%rcx)
movq -0x3ff8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x4010, %rsp           # imm = 0x4010
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gmcvicker[P]check_fastq/util.c
// Function: util_str_dup
char *util_str_dup(const char *str) {
  char *new_str;
  new_str = my_new(char, strlen(str)+1);
  strcpy(new_str, str);

  return new_str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2150
movq %rax, %rdi
shlq $0x0, %rdi
addq $0x1, %rdi
callq 0x4220
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x2200
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/gmcvicker[P]check_fastq/util.c
// Function: util_str_ndup
char *util_str_ndup(const char *str, size_t n) {
  char *new_str;
  size_t len;

  len = 0;
  while(len < n && str[len] != '\0') {
    len++;
  }

  new_str = my_new(char, len+1);
  strncpy(new_str, str, len);
  new_str[len] = '\0';

  return new_str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpq -0x10(%rbp), %rcx
movb %al, -0x21(%rbp)
jae 0x32bc
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x32c5
jmp 0x32d3
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x3298
movq -0x20(%rbp), %rdi
shlq $0x0, %rdi
addq $0x1, %rdi
callq 0x4220
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x2220
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gmcvicker[P]check_fastq/util.c
// Function: util_str_uc
void util_str_uc(char *str) {
  size_t i;

  i = 0;
  while(str[i] != '\0') {
    str[i] = toupper(str[i]);
    i++;
  }

  return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x3361
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x2090
movb %al, %dl
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x3324
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gmcvicker[P]check_fastq/util.c
// Function: util_str_lc
void util_str_lc(char *str) {
  size_t i;

  i = 0;
  while(str[i] != '\0') {
    str[i] = tolower(str[i]);
    i++;
  }

  return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x33c1
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x21f0
movb %al, %dl
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x3384
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gmcvicker[P]check_fastq/util.c
// Function: util_str_replace
void util_str_replace(char *str, char from, char to) {
  size_t i;

  i = 0;
  while(str[i] != '\0') {
    if(str[i] == from) {
      str[i] = to;
    }
    i++;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dl, %al
movb %sil, %cl
movq %rdi, -0x8(%rbp)
movb %cl, -0x9(%rbp)
movb %al, -0xa(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x342c
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movsbl -0x9(%rbp), %ecx
cmpl %ecx, %eax
jne 0x341e
movb -0xa(%rbp), %dl
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x33eb
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gmcvicker[P]check_fastq/util.c
// Function: util_str_remove_char
void util_str_remove_char(char *str, const char c) {
  size_t i,j;

  i = j = 0;
  while(str[i] != '\0') {
    if(str[i] != c) {
      str[j] = str[i];
      j++;
    }
    i++;
  }
  str[j] = '\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x34a3
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movsbl -0x9(%rbp), %ecx
cmpl %ecx, %eax
je 0x3495
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x344e
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movb $0x0, (%rax,%rcx)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gmcvicker[P]check_fastq/util.c
// Function: util_long_to_comma_str
char *util_long_to_comma_str(const long x) {
  char *str, *comma_str;
  int len,i,j,k;
  int max_commas;

  str = my_new(char, UTIL_STR_BUF_SZ);
  max_commas = (UTIL_STR_BUF_SZ / 3);
  
  len = snprintf(str, UTIL_STR_BUF_SZ-max_commas, "%lu", x);

  if(len == 0) {
    my_err("%s:%d: could not write number %lu to string", 
	    __FILE__, __LINE__, x);
  }
  
  max_commas = len / 3;
  comma_str = my_new(char, len + max_commas + 1);

  /* copy the string in reverse, adding commas every three */
  j = 0;
  k = 0;
  for(i = len-1; i >= 0; i--) {
    comma_str[j] = str[i];
    k++;
    
    if(i > 0 && ((k %3) == 0)) {
      /* insert comma */
      j++;
      comma_str[j] = ',';
    }
    j++;
  }

  comma_str[j] = '\0';
  my_free(str);

  util_breverse(comma_str, j);

  return comma_str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl $0x14, %edi
callq 0x4220
movq %rax, -0x10(%rbp)
movl $0x6, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
movl $0x14, %eax
subl -0x2c(%rbp), %eax
movslq %eax, %rsi
movq -0x8(%rbp), %rcx
leaq 0x1c0e(%rip), %rdx      # 0x5109
movb $0x0, %al
callq 0x2050
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x3529
movq -0x8(%rbp), %rcx
leaq 0x1bf7(%rip), %rdi      # 0x510d
leaq 0x1e2f(%rip), %rsi      # 0x534c
movl $0x21e, %edx            # imm = 0x21E
movb $0x0, %al
callq 0x4010
movl -0x1c(%rbp), %eax
movl $0x3, %ecx
cltd
idivl %ecx
movl %eax, -0x2c(%rbp)
movslq -0x1c(%rbp), %rdi
shlq $0x0, %rdi
movslq -0x2c(%rbp), %rax
addq %rax, %rdi
addq $0x1, %rdi
callq 0x4220
movq %rax, -0x18(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x1c(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jl 0x35ce
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x20(%rbp)
jle 0x35ba
movl -0x28(%rbp), %eax
movl $0x3, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x35ba
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb $0x2c, (%rax,%rcx)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movl -0x20(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x356a
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rdi
leaq 0x1d67(%rip), %rsi      # 0x534c
movl $0x234, %edx            # imm = 0x234
callq 0x42b0
movq $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq 0x3610
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gmcvicker[P]check_fastq/util.c
// Function: util_reverse
void util_reverse(void *base, const size_t nmemb, const size_t size) {
  void *tmp;
  unsigned char *fwd_ptr, *rev_ptr;

  /* allocate mem for holding swap */
  tmp = malloc(size);
  if(tmp == NULL) {
    my_err("%s:%d: could not allocate mem", __FILE__, __LINE__);
  }
  
  /* initiailize pointers so that they point to beginning and end of array */
  fwd_ptr = (unsigned char *)base;
  rev_ptr = &((unsigned char *)base)[nmemb*size - size];

  /* move ptrs towards each other from either end of array */
  while(fwd_ptr < rev_ptr) {
    /* swap memory at each pointer */
    tmp = memcpy(tmp, fwd_ptr, size);
    memcpy(fwd_ptr, rev_ptr, size);
    memcpy(rev_ptr, tmp, size);

    /* advance ptrs */
    fwd_ptr += size;
    rev_ptr -= size;
  }

  free(tmp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2100
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x3682
leaq 0x1aca(%rip), %rdi      # 0x5139
leaq 0x1cd6(%rip), %rsi      # 0x534c
movl $0x24b, %edx            # imm = 0x24B
movb $0x0, %al
callq 0x4010
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
imulq -0x18(%rbp), %rcx
subq -0x18(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x370d
movq -0x20(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x2290
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x2290
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x2290
movq -0x18(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdx
movq -0x30(%rbp), %rax
xorl %ecx, %ecx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
jmp 0x36a2
movq -0x20(%rbp), %rdi
callq 0x22b0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gmcvicker[P]check_fastq/util.c
// Function: util_str_remove_whitespace
void util_str_remove_whitespace(char *str) {
  long i,j;

  i = j = 0;
  while(str[i] != '\0') {
    if(!isspace((unsigned char)str[i])) {
      str[j] = str[i];
      j++;
    }
    i++;
  }

  str[j] = '\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x37d2
callq 0x2170
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
jne 0x37c4
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x376c
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movb $0x0, (%rax,%rcx)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gmcvicker[P]check_fastq/util.c
// Function: util_str_lstrip
void util_str_lstrip(char *str) {
  long leading_ws, len;
  
  leading_ws = 0;
  while(str[leading_ws] != '\0' && isspace((unsigned char)str[leading_ws])) {
    leading_ws++;
  }

  if(leading_ws > 0) {
    len = strlen(str);
    memmove(str, &str[leading_ws], len-leading_ws+1);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x19(%rbp)
je 0x3843
callq 0x2170
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x384c
jmp 0x385a
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x3804
cmpq $0x0, -0x10(%rbp)
jle 0x388b
movq -0x8(%rbp), %rdi
callq 0x2150
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
subq -0x10(%rbp), %rdx
addq $0x1, %rdx
callq 0x21b0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gmcvicker[P]check_fastq/util.c
// Function: util_str_rstrip
void util_str_rstrip(char *str) {
  long len,i;

  len = strlen(str);
  
  i = len-1;
  while(i >= 0 && isspace((unsigned char)str[i])) {
    str[i] = '\0';
    i--;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2150
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x19(%rbp)
jl 0x38fa
callq 0x2170
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x3903
jmp 0x391d
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x38c5
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gmcvicker[P]check_fastq/util.c
// Function: util_str_starts_with
int util_str_starts_with(const char *str, const char *start) {
  size_t i;

  i = 0;

  while(start[i] != '\0') {
    if(str[i] != start[i]) {
      return FALSE;
    }
    i++;
  }

  return TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x39b8
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x39aa
movl $0x0, -0x4(%rbp)
jmp 0x39bf
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x3974
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gmcvicker[P]check_fastq/util.c
// Function: util_str_ends_with
int util_str_ends_with(const char *str, const char *end) {
  size_t i, j;

  i = strlen(str);
  j = strlen(end);

  if(j > i) {
    /* string to match is longer than provided string */
    return FALSE;
  }

  while(j > 0) {
    if(str[i-1] != end[j-1]) {
      /* character does not match */
      return FALSE;
    }
    i--;
    j--;
  }

  return TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2150
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2150
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jbe 0x3a0d
movl $0x0, -0x4(%rbp)
jmp 0x3a64
jmp 0x3a0f
cmpq $0x0, -0x28(%rbp)
jbe 0x3a5d
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rdx
subq $0x1, %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x3a43
movl $0x0, -0x4(%rbp)
jmp 0x3a64
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x3a0f
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gmcvicker[P]check_fastq/util.c
// Function: util_str_split
int util_str_split(char *str, char **tokens, const size_t n_tok) {  
  size_t i = 0;

  if(n_tok < 1) {
    my_err("%s:%d: number of tokens must be at least 1\n",
	   __FILE__, __LINE__);
  }

  while(((tokens[i] = strsep(&str, " \t")) != NULL)) {
    if(tokens[i][0] != '\0') {
      i++;

      if(i == n_tok) {
	break;
      }
    }
  }
  
  return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x1, -0x18(%rbp)
jae 0x3aad
leaq 0x16bd(%rip), %rdi      # 0x5157
leaq 0x18ab(%rip), %rsi      # 0x534c
movl $0x2f5, %edx            # imm = 0x2F5
movb $0x0, %al
callq 0x4010
jmp 0x3aaf
leaq -0x8(%rbp), %rdi
leaq 0x16c9(%rip), %rsi      # 0x5183
callq 0x2240
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rdx
movq %rax, (%rcx,%rdx,8)
cmpq $0x0, %rax
je 0x3b01
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x3aff
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x3afd
jmp 0x3b01
jmp 0x3aff
jmp 0x3aaf
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gmcvicker[P]check_fastq/util.c
// Function: util_dbl_cmp
int util_dbl_cmp(const void *x, const void *y) {
  if(*(double *)x < *(double *)y) {
    return -1;
  }
  if(*(double *)x > *(double *)y) {
    return 1;
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsd (%rax), %xmm1
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x3b3b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3b5d
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movq -0x18(%rbp), %rax
ucomisd (%rax), %xmm0
jbe 0x3b56
movl $0x1, -0x4(%rbp)
jmp 0x3b5d
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gmcvicker[P]check_fastq/util.c
// Function: util_must_fread
void util_must_fread(FILE *file, void *buf, size_t size) {
  if(size != 0 && fread(buf, size, 1, file) != 1) {
    if(ferror(file)) {
      my_err("error reading %lld bytes: %s", (long long)size, 
	     strerror(ferror(file)));
    } else {
      my_err("end of file reading %lld bytes", (long long)size);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x3bf8
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rcx
movl $0x1, %edx
callq 0x21c0
cmpq $0x1, %rax
je 0x3bf8
movq -0x8(%rbp), %rdi
callq 0x2160
cmpl $0x0, %eax
je 0x3be4
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2160
movl %eax, %edi
callq 0x2190
movq -0x20(%rbp), %rsi
movq %rax, %rdx
leaq 0x15ab(%rip), %rdi      # 0x5186
movb $0x0, %al
callq 0x4010
jmp 0x3bf6
movq -0x18(%rbp), %rsi
leaq 0x15b4(%rip), %rdi      # 0x51a3
movb $0x0, %al
callq 0x4010
jmp 0x3bf8
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gmcvicker[P]check_fastq/util.c
// Function: util_must_fopen
FILE *util_must_fopen(const char *path, const char *mode) {
  FILE *f;

  errno = 0;
  f = fopen(path, mode);
  if(f == NULL) {
    my_err("%s:%d: error opening file '%s' in mode '%s': %s", 
	   __FILE__, __LINE__, path, mode, strerror(errno));
  }

  return f;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x21d0
movl $0x0, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2110
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x3c74
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x21d0
movl (%rax), %edi
callq 0x2190
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %r8
movq %rax, %r9
leaq 0x1561(%rip), %rdi      # 0x51c2
leaq 0x16e4(%rip), %rsi      # 0x534c
movl $0x331, %edx            # imm = 0x331
movb $0x0, %al
callq 0x4010
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gmcvicker[P]check_fastq/util.c
// Function: util_must_gzopen
gzFile util_must_gzopen(const char *path, const char *mode) {
  gzFile f;

  if((strcmp(mode, "wb") == 0) && !util_str_ends_with(path, ".gz")) {
    my_warn("%s:%d: file '%s' does not end with '.gz' but "
	    "opening with gzopen anyway\n", __FILE__, __LINE__,
	    path);
  }

  errno = 0;
  f = gzopen(path, mode);
  if(f == NULL) {
    if(errno) {
      my_err("%s:%d: error opening file '%s' in mode '%s': %s", 
	     __FILE__, __LINE__, path, mode, strerror(errno));
    } else {
      my_err("%s:%d: error opening file '%s' in mode '%s'", 
	     __FILE__, __LINE__, path, mode);
    }
  }

  return f;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x1557(%rip), %rsi      # 0x51f2
callq 0x21e0
cmpl $0x0, %eax
jne 0x3cd8
movq -0x8(%rbp), %rdi
leaq 0x13b0(%rip), %rsi      # 0x5060
callq 0x39d0
cmpl $0x0, %eax
jne 0x3cd8
movq -0x8(%rbp), %rcx
leaq 0x1530(%rip), %rdi      # 0x51f5
leaq 0x1680(%rip), %rsi      # 0x534c
movl $0x342, %edx            # imm = 0x342
movb $0x0, %al
callq 0x4110
callq 0x21d0
movl $0x0, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x20a0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x3d6c
callq 0x21d0
cmpl $0x0, (%rax)
je 0x3d48
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x21d0
movl (%rax), %edi
callq 0x2190
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %r8
movq %rax, %r9
leaq 0x148f(%rip), %rdi      # 0x51c2
leaq 0x1612(%rip), %rsi      # 0x534c
movl $0x34b, %edx            # imm = 0x34B
movb $0x0, %al
callq 0x4010
jmp 0x3d6a
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %r8
leaq 0x14e7(%rip), %rdi      # 0x523e
leaq 0x15ee(%rip), %rsi      # 0x534c
movl $0x34e, %edx            # imm = 0x34E
movb $0x0, %al
callq 0x4010
jmp 0x3d6c
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gmcvicker[P]check_fastq/util.c
// Function: util_must_fwrite
void util_must_fwrite(FILE *file, void *buf, size_t size) {
  if(size != 0 && fwrite(buf, size, 1, file) != 1) {
    if(ferror(file)) {
      my_err("error writing %lld bytes: %s", (long long)size, 
	     strerror(ferror(file)));
    } else {
      my_err("error writing %lld bytes\n", (long long)size);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x3e08
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rcx
movl $0x1, %edx
callq 0x2250
cmpq $0x1, %rax
je 0x3e08
movq -0x8(%rbp), %rdi
callq 0x2160
cmpl $0x0, %eax
je 0x3df4
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2160
movl %eax, %edi
callq 0x2190
movq -0x20(%rbp), %rsi
movq %rax, %rdx
leaq 0x147f(%rip), %rdi      # 0x526a
movb $0x0, %al
callq 0x4010
jmp 0x3e06
movq -0x18(%rbp), %rsi
leaq 0x1488(%rip), %rdi      # 0x5287
movb $0x0, %al
callq 0x4010
jmp 0x3e08
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gmcvicker[P]check_fastq/util.c
// Function: util_parse_long
long util_parse_long(const char *str) {
  long val;

  errno = 0;
  val = strtol(str, NULL, 10);
  if(val == 0 && errno) {
    perror("strtol");
    my_err("%s:%d: failed to parse long string '%s'", __FILE__, __LINE__, str);
  }

  return val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0x21d0
movl $0x0, (%rax)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x21a0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3e78
callq 0x21d0
cmpl $0x0, (%rax)
je 0x3e78
leaq 0x144c(%rip), %rdi      # 0x52a1
callq 0x2260
movq -0x8(%rbp), %rcx
leaq 0x1443(%rip), %rdi      # 0x52a8
leaq 0x14e0(%rip), %rsi      # 0x534c
movl $0x371, %edx            # imm = 0x371
movb $0x0, %al
callq 0x4010
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gmcvicker[P]check_fastq/util.c
// Function: util_parse_double
double util_parse_double(const char *str) {
  double val;

  if(is_nan_str(str)) {
    return NAN;
  }

  errno = 0;
  val = strtod(str, NULL);
  if(errno) {
    perror("strtod");
    my_err("%s:%d: failed to parse double string '%s'", __FILE__, __LINE__,
	   str);
  }

  return val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3f20
cmpl $0x0, %eax
je 0x3eb9
movsd 0x11a6(%rip), %xmm0     # 0x5058
movsd %xmm0, -0x8(%rbp)
jmp 0x3f14
callq 0x21d0
movl $0x0, (%rax)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x22a0
movsd %xmm0, -0x18(%rbp)
callq 0x21d0
cmpl $0x0, (%rax)
je 0x3f0a
leaq 0x13e9(%rip), %rdi      # 0x52d0
callq 0x2260
movq -0x10(%rbp), %rcx
leaq 0x13e0(%rip), %rdi      # 0x52d7
leaq 0x144e(%rip), %rsi      # 0x534c
movl $0x39f, %edx            # imm = 0x39F
movb $0x0, %al
callq 0x4010
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nop