LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/mgth/mg_combinedscore.c
// Function: add_scores
static void add_scores(ParseStruct *parsestruct_ptr,
                       double *matrix_row,
                       GtUword *count_row_fct,
                       short current_row_fct,
                       GtUword hit_number,
                       GtUword position,
                       unsigned short k, double score)
{
  /* Wenn der Query-Leserahmen negativ ist, muessen die Combined-Scores
     von Rechts nach Links in die Combined-Score Matrix eingetragen werden
     - also ausgehend vom Query-to Wert */
  if (current_row_fct > 3)
  {
    matrix_row[POSITION(MATRIXSTRUCT(query_to), hit_number, -position, -k)]
      += score;
    count_row_fct[POSITION
                  (MATRIXSTRUCT(query_to), hit_number, -position, -k)] +=
      1;
  }
  else
  {
    matrix_row[POSITION(MATRIXSTRUCT(query_from), hit_number, position, k)]
      += score;
    count_row_fct[POSITION
                  (MATRIXSTRUCT(query_from), hit_number, position, k)] +=
      1;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movsd %xmm0, (%rsp)
movq %r9, %r15
movq %r8, %r14
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, %r12
movzwl 0x40(%rsp), %ebp
cmpw $0x4, %cx
jb 0x32d6e3
movq 0x118(%r12), %rdi
movq %r14, %rsi
callq 0xd2207
movq (%rax), %rax
addq %r15, %rbp
notq %rbp
leaq (,%rax,8), %rax
addq %r13, %rax
movsd (%rsp), %xmm0
addsd (%rax,%rbp,8), %xmm0
movsd %xmm0, (%rax,%rbp,8)
movq 0x118(%r12), %rdi
movq %r14, %rsi
callq 0xd2207
movq (%rax), %rax
leaq (%rbx,%rax,8), %rax
leaq (%rax,%rbp,8), %rax
jmp 0x32d73b
movq 0x110(%r12), %rdi
movq %r14, %rsi
callq 0xd2207
movq (%rax), %rax
leaq (,%rax,8), %rax
addq %r13, %rax
leaq (%rax,%r15,8), %rax
shll $0x3, %ebp
movsd (%rsp), %xmm0
addsd -0x8(%rbp,%rax), %xmm0
movsd %xmm0, -0x8(%rbp,%rax)
movq 0x110(%r12), %rdi
movq %r14, %rsi
callq 0xd2207
movq (%rax), %rax
leaq (%rbx,%rax,8), %rax
leaq (%rax,%r15,8), %rax
addq %rbp, %rax
addq $-0x8, %rax
incq (%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/mgth/mg_compute_gene_prediction.c
// Function: gt_check_stopcodon
short gt_check_stopcodon(char *contig_seq_ptrfct)
{
  unsigned short codon_status = 0;

  /* jeder if-Zweig ueberprueft entsprechend des
     Metagenomethreader-Arguments zur Verwendung alternativer Start-Codons
     auf Start-Codons */
  if (!strcmp(contig_seq_ptrfct, "tga")
      || !strcmp(contig_seq_ptrfct, "taa")
      || !strcmp(contig_seq_ptrfct, "tag")
      || !strcmp(contig_seq_ptrfct, "tar")
      || !strcmp(contig_seq_ptrfct, "uga")
      || !strcmp(contig_seq_ptrfct, "uaa")
      || !strcmp(contig_seq_ptrfct, "uag")
      || !strcmp(contig_seq_ptrfct, "uar"))
  {
    codon_status = 1;
  }

  return codon_status;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x65b2a(%rip), %rsi     # 0x394509
callq 0x17a40
testl %eax, %eax
je 0x32ea75
leaq 0xb671b(%rip), %rsi     # 0x3e510e
movq %rbx, %rdi
callq 0x17a40
testl %eax, %eax
je 0x32ea75
leaq 0xbb65c(%rip), %rsi     # 0x3ea062
movq %rbx, %rdi
callq 0x17a40
testl %eax, %eax
je 0x32ea75
leaq 0x8ab2d(%rip), %rsi     # 0x3b9546
movq %rbx, %rdi
callq 0x17a40
testl %eax, %eax
je 0x32ea75
leaq 0xb7812(%rip), %rsi     # 0x3e623e
movq %rbx, %rdi
callq 0x17a40
testl %eax, %eax
je 0x32ea75
leaq 0xb7803(%rip), %rsi     # 0x3e6242
movq %rbx, %rdi
callq 0x17a40
testl %eax, %eax
je 0x32ea75
leaq 0xb77f4(%rip), %rsi     # 0x3e6246
movq %rbx, %rdi
callq 0x17a40
testl %eax, %eax
je 0x32ea75
leaq 0xb77e5(%rip), %rsi     # 0x3e624a
movq %rbx, %rdi
callq 0x17a40
testl %eax, %eax
je 0x32ea75
xorl %eax, %eax
jmp 0x32ea79
movw $0x1, %ax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/annotationsketch/canvas_cairo_context.c
// Function: gt_canvas_cairo_context_class
const GtCanvasClass* gt_canvas_cairo_context_class(void)
{
  static const GtCanvasClass *canvas_class = NULL;
  gt_class_alloc_lock_enter();
  if (!canvas_class) {
    canvas_class = gt_canvas_class_new(sizeof (GtCanvasCairoContext),
                                       gt_canvas_cairo_visit_layout_pre,
                                       gt_canvas_cairo_visit_layout_post,
                                       gt_canvas_cairo_visit_track_pre,
                                       gt_canvas_cairo_visit_track_post,
                                       gt_canvas_cairo_visit_line_pre,
                                       gt_canvas_cairo_visit_line_post,
                                       gt_canvas_cairo_visit_block,
                                       gt_canvas_cairo_visit_element,
                                       gt_canvas_cairo_visit_custom_track,
                                       gt_canvas_cairo_draw_ruler,
                                       NULL);
  }
  gt_class_alloc_lock_leave();
  return canvas_class;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0xe252f
cmpq $0x0, 0x18fc3b(%rip)    # 0x4bf010
jne 0x32f43c
leaq 0x131af(%rip), %rax     # 0x34258d
leaq 0x12ef2(%rip), %r10     # 0x3422d7
leaq 0x1247f(%rip), %r11     # 0x34186b
leaq 0x11c8b(%rip), %rbx     # 0x34107e
leaq 0x11bba(%rip), %r14     # 0x340fb4
leaq 0x115e3(%rip), %rsi     # 0x3409e4
leaq 0x1167c(%rip), %rdx     # 0x340a84
leaq 0x11678(%rip), %rcx     # 0x340a87
leaq 0x1197a(%rip), %r8      # 0x340d90
leaq 0x119e7(%rip), %r9      # 0x340e04
movl $0x18, %edi
pushq $0x0
pushq %rax
pushq %r10
pushq %r11
pushq %rbx
pushq %r14
callq 0x218414
addq $0x30, %rsp
movq %rax, 0x18fbd4(%rip)    # 0x4bf010
callq 0xe2545
movq 0x18fbc8(%rip), %rax    # 0x4bf010
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/annotationsketch/custom_track_gc_content.c
// Function: gt_custom_track_gc_content_class
const GtCustomTrackClass* gt_custom_track_gc_content_class(void)
{
  static const GtCustomTrackClass *ctc = NULL;
  gt_class_alloc_lock_enter();
  if (!ctc)
  {
    ctc = gt_custom_track_class_new(sizeof (GtCustomTrackGcContent),
                                    gt_custom_track_gc_content_sketch,
                                    gt_custom_track_gc_content_get_height,
                                    gt_custom_track_gc_content_get_title,
                                    gt_custom_track_gc_content_delete);
  }
  gt_class_alloc_lock_leave();
  return ctc;
}

// Assembly:
pushq %rax
callq 0xe252f
cmpq $0x0, 0x18ed3a(%rip)    # 0x4bf020
jne 0x330315
leaq -0x69f(%rip), %rsi      # 0x32fc50
leaq 0xd1(%rip), %rdx        # 0x3303c7
leaq 0xe4(%rip), %rcx        # 0x3303e1
leaq 0xfb(%rip), %r8         # 0x3303ff
movl $0x48, %edi
callq 0x32faac
movq %rax, 0x18ed0b(%rip)    # 0x4bf020
callq 0xe2545
movq 0x18ecff(%rip), %rax    # 0x4bf020
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/annotationsketch/custom_track_gc_content.c
// Function: get_val_for_pos
static double get_val_for_pos(GtCustomTrackGcContent *ctgc, GtUword pos)
{
  GtUword i,
                gc_count = 0,
                bases = 0;
  for (i=0;i<ctgc->windowsize;i++)
  {
    if (pos + i > ctgc->seqlen)
      return -1;
    if (ctgc->seq[pos+i] == 'g' || ctgc->seq[pos+i] == 'c'
         || ctgc->seq[pos+i] == 'G' || ctgc->seq[pos+i] == 'C')
    {
      gc_count++;
    }
    bases++;
  }
  return ((double) gc_count)/((double) GT_MIN(ctgc->windowsize, bases));
}

// Assembly:
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x3303be
movq 0x40(%rdi), %rdx
xorl %ecx, %ecx
movsd 0x3ba2a(%rip), %xmm0    # 0x36bd68
movl $0x303, %r8d            # imm = 0x303
movq %rax, %r9
cmpq %rdx, %rsi
ja 0x3303bd
movq 0x38(%rdi), %r10
movb (%r10,%rsi), %r10b
addb $-0x43, %r10b
rolb $0x6, %r10b
cmpb $0x9, %r10b
ja 0x33036f
movzbl %r10b, %r10d
btl %r10d, %r8d
jae 0x33036f
incq %rcx
incq %rsi
decq %r9
jne 0x330347
movq %rcx, %xmm1
movq 0x1755c(%rip), %xmm2    # 0x3478e0
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x17560(%rip), %xmm3    # 0x3478f0
subpd %xmm3, %xmm1
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movq %rax, %xmm1
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
subpd %xmm3, %xmm1
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
divsd %xmm2, %xmm0
retq
movsd 0xb622a(%rip), %xmm0    # 0x3e65f0
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/annotationsketch/custom_track_gc_content.c
// Function: gt_custom_track_gc_content_new
GtCustomTrack* gt_custom_track_gc_content_new(const char *seq,
                                              GtUword seqlen,
                                              GtUword windowsize,
                                              GtUword height,
                                              double avg,
                                              bool show_scale)
{
  GtCustomTrackGcContent *ctgc;
  GtCustomTrack *ct;
  char buf[BUFSIZ];
  ct = gt_custom_track_create(gt_custom_track_gc_content_class());
  ctgc = gt_custom_track_gc_content_cast(ct);
  ctgc->windowsize = windowsize;
  ctgc->height = height;
  ctgc->seq = seq;
  ctgc->seqlen = seqlen;
  ctgc->avg = avg;
  ctgc->show_scale = show_scale;
  ctgc->title = gt_str_new_cstr("GC content (window size ");
  gt_str_append_uword(ctgc->title, ctgc->windowsize);
  if (gt_double_smaller_double(0, avg))
  {
    (void) snprintf(buf, BUFSIZ, ", average: %.1f%%", avg*100);
    gt_str_append_cstr(ctgc->title, buf);
  }
  gt_str_append_cstr(ctgc->title, ")");
  return ct;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2018, %rsp           # imm = 0x2018
movl %r8d, %ebp
movsd %xmm0, (%rsp)
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
callq 0x3302d8
movq %rax, %rdi
callq 0x32faeb
movq %rax, %r14
callq 0x3302d8
movq %rax, %rdi
movq %r14, 0x8(%rsp)
movq %r14, %rsi
callq 0x32fc36
movq %rax, %r14
movq %r12, 0x10(%rax)
movq %r15, 0x18(%rax)
movq %rbx, 0x38(%rax)
movq %r13, 0x40(%rax)
movsd (%rsp), %xmm0
movsd %xmm0, 0x20(%rax)
movb %bpl, 0x28(%rax)
leaq 0xb62b1(%rip), %rdi     # 0x3e6746
callq 0x11acc9
movq %rax, 0x30(%r14)
movq 0x10(%r14), %rsi
movq %rax, %rdi
callq 0x11ae72
xorpd %xmm0, %xmm0
movsd (%rsp), %xmm1
callq 0x105c97
testb %al, %al
je 0x3304f0
movsd (%rsp), %xmm0
mulsd 0x19317(%rip), %xmm0    # 0x3497e0
leaq 0xb628f(%rip), %rdx     # 0x3e675f
leaq 0x10(%rsp), %rbx
movl $0x2000, %esi           # imm = 0x2000
movq %rbx, %rdi
movb $0x1, %al
callq 0x17c60
movq 0x30(%r14), %rdi
movq %rbx, %rsi
callq 0x11acf3
movq 0x30(%r14), %rdi
leaq 0xa7be5(%rip), %rsi     # 0x3d80e0
callq 0x11acf3
movq 0x8(%rsp), %rax
addq $0x2018, %rsp           # imm = 0x2018
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/samtools-0.1.18/bgzf.c
// Function: bgzf_check_bgzf
int bgzf_check_bgzf(const char *fn)
{
    BGZF *fp;
    uint8_t buf[10],magic[10]="\037\213\010\4\0\0\0\0\0\377";
    int n;

    if ((fp = bgzf_open(fn, "r")) == 0) 
    {
        fprintf(stderr, "[bgzf_check_bgzf] failed to open the file: %s\n",fn);
        return -1;
    }

#ifdef _USE_KNETFILE
    n = knet_read(fp->x.fpr, buf, 10);
#else
    n = fread(buf, 1, 10, fp->file);
#endif
    bgzf_close(fp);

    if ( n!=10 ) 
        return -1;

    if ( !memcmp(magic, buf, 10) ) return 1;
    return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x275f4(%rip), %rsi     # 0x35ae55
callq 0x3338e3
testq %rax, %rax
je 0x3338c1
movq %rax, %r14
movq 0x10(%rax), %rcx
leaq 0xe(%rsp), %rdi
movl $0x1, %esi
movl $0xa, %edx
callq 0x17b40
movq %rax, %rbx
movq %r14, %rdi
callq 0x3339eb
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0xa, %ebx
jne 0x3338b9
movl $0x4088b1f, %ecx        # imm = 0x4088B1F
xorq 0xe(%rsp), %rcx
movzwl 0x16(%rsp), %edx
xorq $0xff00, %rdx           # imm = 0xFF00
xorl %eax, %eax
orq %rcx, %rdx
sete %al
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq 0x1856b8(%rip), %rax    # 0x4b8f80
movq (%rax), %rdi
leaq 0xb3afe(%rip), %rsi     # 0x3e73d0
movq %rbx, %rdx
xorl %eax, %eax
callq 0x17ab0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x3338b9
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/samtools-0.1.18/bgzf.c
// Function: bgzf_open
BGZF*
bgzf_open(const char* __restrict path, const char* __restrict mode)
{
    BGZF* fp = NULL;
    if (strchr(mode, 'r') || strchr(mode, 'R')) { /* The reading mode is preferred. */
#ifdef _USE_KNETFILE
		knetFile *file = knet_open(path, mode);
		if (file == 0) return 0;
		fp = bgzf_read_init();
		fp->file_descriptor = -1;
		fp->open_mode = 'r';
		fp->x.fpr = file;
#else
		int fd, oflag = O_RDONLY;
#ifdef _WIN32
		oflag |= O_BINARY;
#endif
		fd = open(path, oflag);
		if (fd == -1) return 0;
        fp = open_read(fd);
#endif
    } else if (strchr(mode, 'w') || strchr(mode, 'W')) {
		int fd, compress_level = -1, oflag = O_WRONLY | O_CREAT | O_TRUNC;
#ifdef _WIN32
		oflag |= O_BINARY;
#endif
		fd = open(path, oflag, 0666);
		if (fd == -1) return 0;
		{ // set compress_level
			int i;
			for (i = 0; mode[i]; ++i)
				if (mode[i] >= '0' && mode[i] <= '9') break;
			if (mode[i]) compress_level = (int)mode[i] - '0';
			if (strchr(mode, 'u')) compress_level = 0;
		}
        fp = open_write(fd, compress_level);
    }
    if (fp != NULL) fp->owned_file = 1;
    return fp;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movq %rsi, %rdi
movl $0x72, %esi
callq 0x17280
testq %rax, %rax
jne 0x333914
movq %rbx, %rdi
movl $0x52, %esi
callq 0x17280
testq %rax, %rax
je 0x33394b
xorl %r14d, %r14d
movq %r15, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x17d60
cmpl $-0x1, %eax
je 0x3339dd
movl %eax, %edi
callq 0x333b17
movq %rax, %r14
testq %rax, %rax
je 0x3339da
movw $0x1, 0x6(%r14)
jmp 0x3339dd
movq %rbx, %rdi
movl $0x77, %esi
callq 0x17280
testq %rax, %rax
jne 0x33396f
movq %rbx, %rdi
movl $0x57, %esi
callq 0x17280
testq %rax, %rax
je 0x3339da
xorl %r14d, %r14d
movq %r15, %rdi
movl $0x241, %esi            # imm = 0x241
movl $0x1b6, %edx            # imm = 0x1B6
xorl %eax, %eax
callq 0x17d60
cmpl $-0x1, %eax
je 0x3339dd
movl %eax, %ebp
movq %rbx, %rcx
movzbl (%rcx), %eax
testl %eax, %eax
je 0x3339a2
leal -0x30(%rax), %edx
incq %rcx
cmpb $0x9, %dl
ja 0x333990
leal -0x30(%rax), %ecx
xorl %r15d, %r15d
cmpl $0x1, %eax
movl $0x0, %r14d
sbbl %r14d, %r14d
orl %ecx, %r14d
movq %rbx, %rdi
movl $0x75, %esi
callq 0x17280
testq %rax, %rax
cmovnel %r15d, %r14d
movl %ebp, %edi
movl %r14d, %esi
callq 0x333ba0
jmp 0x333933
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/samtools-0.1.18/bgzf.c
// Function: open_read
static
BGZF*
open_read(int fd)
{
#ifdef _USE_KNETFILE
    knetFile *file = knet_dopen(fd, "r");
#else
    FILE* file = fdopen(fd, "r");
#endif
    BGZF* fp;
	if (file == 0) return 0;
	fp = bgzf_read_init();
    fp->file_descriptor = fd;
    fp->open_mode = 'r';
#ifdef _USE_KNETFILE
    fp->x.fpr = file;
#else
    fp->file = file;
#endif
    return fp;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0x2732e(%rip), %rsi     # 0x35ae55
callq 0x17860
testq %rax, %rax
je 0x333b8f
movq %rax, %r14
movl $0x1, %edi
movl $0x58, %esi
callq 0x174e0
movq %rax, %r15
movl $0x10000, %ebp          # imm = 0x10000
movl %ebp, 0x18(%rax)
movl $0x10000, %edi          # imm = 0x10000
callq 0x17ff0
movq %rax, 0x20(%r15)
movl %ebp, 0x1c(%r15)
movl $0x10000, %edi          # imm = 0x10000
callq 0x17ff0
movq %rax, 0x28(%r15)
movl $0x1, %edi
movl $0x28, %esi
callq 0x174e0
movq %rax, 0x50(%r15)
movl %ebx, (%r15)
movb $0x72, 0x4(%r15)
movq %r14, 0x10(%r15)
jmp 0x333b92
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/samtools-0.1.18/bgzf.c
// Function: open_write
static
BGZF*
open_write(int fd, int compress_level) // compress_level==-1 for the default level
{
    FILE* file = fdopen(fd, "w");
    BGZF* fp;
	if (file == 0) return 0;
	fp = malloc(sizeof(BGZF));
    fp->file_descriptor = fd;
    fp->open_mode = 'w';
    fp->owned_file = 0;
	fp->compress_level = compress_level < 0? Z_DEFAULT_COMPRESSION : compress_level; // Z_DEFAULT_COMPRESSION==-1
	if (fp->compress_level > 9) fp->compress_level = Z_DEFAULT_COMPRESSION;
#ifdef _USE_KNETFILE
    fp->x.fpw = file;
#else
    fp->file = file;
#endif
    fp->uncompressed_block_size = DEFAULT_BLOCK_SIZE;
    fp->uncompressed_block = NULL;
    fp->compressed_block_size = MAX_BLOCK_SIZE;
    fp->compressed_block = malloc(MAX_BLOCK_SIZE);
    fp->block_address = 0;
    fp->block_offset = 0;
    fp->block_length = 0;
    fp->error = NULL;
    return fp;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movl %edi, %r15d
leaq 0x5fa02(%rip), %rsi     # 0x3935b5
callq 0x17860
testq %rax, %rax
je 0x333c28
movq %rax, %r14
movl $0x58, %edi
callq 0x17ff0
movq %rax, %rbx
movl %r15d, (%rax)
movb $0x77, 0x4(%rax)
movw $0x0, 0x6(%rax)
testl %ebp, %ebp
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmovnsl %ebp, %eax
cmpw $0xa, %ax
movl $0xffff, %ecx           # imm = 0xFFFF
cmovll %eax, %ecx
movw %cx, 0x8(%rbx)
movq %r14, 0x10(%rbx)
movabsq $0x1000000010000, %rax  # imm = 0x1000000010000
movq %rax, 0x18(%rbx)
xorl %r14d, %r14d
movq %r14, 0x20(%rbx)
movl $0x10000, %edi          # imm = 0x10000
callq 0x17ff0
movq %rax, 0x28(%rbx)
movq %r14, 0x48(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rbx)
jmp 0x333c2a
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/samtools-0.1.18/bgzf.c
// Function: bgzf_fdopen
BGZF*
bgzf_fdopen(int fd, const char * __restrict mode)
{
	if (fd == -1) return 0;
    if (mode[0] == 'r' || mode[0] == 'R') {
        return open_read(fd);
    } else if (mode[0] == 'w' || mode[0] == 'W') {
		int i, compress_level = -1;
		for (i = 0; mode[i]; ++i)
			if (mode[i] >= '0' && mode[i] <= '9') break;
		if (mode[i]) compress_level = (int)mode[i] - '0';
		if (strchr(mode, 'u')) compress_level = 0;
        return open_write(fd, compress_level);
    } else {
        return NULL;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
cmpl $-0x1, %edi
je 0x333c58
movl %edi, %ebx
movzbl (%rsi), %ecx
cmpl $0x71, %ecx
jg 0x333c5f
cmpl $0x52, %ecx
je 0x333cb1
movq %rsi, %rax
cmpl $0x57, %ecx
je 0x333c6c
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
cmpl $0x72, %ecx
je 0x333cb1
movq %rsi, %rax
cmpl $0x77, %ecx
jne 0x333c58
movzbl (%rax), %ecx
testl %ecx, %ecx
je 0x333c7e
leal -0x30(%rcx), %edx
incq %rax
cmpb $0x9, %dl
ja 0x333c6c
leal -0x30(%rcx), %eax
xorl %r14d, %r14d
cmpl $0x1, %ecx
movl $0x0, %ebp
sbbl %ebp, %ebp
orl %eax, %ebp
movq %rsi, %rdi
movl $0x75, %esi
callq 0x17280
testq %rax, %rax
cmovnel %r14d, %ebp
movl %ebx, %edi
movl %ebp, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x333ba0
movl %ebx, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x333b17
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/samtools-0.1.18/bgzf.c
// Function: bgzf_read
int
bgzf_read(BGZF* fp, void* data, int length)
{
    if (length <= 0) {
        return 0;
    }
    if (fp->open_mode != 'r') {
        report_error(fp, "file not open for reading");
        return -1;
    }

    int bytes_read = 0;
    bgzf_byte_t* output = data;
    while (bytes_read < length) {
        int copy_length, available = fp->block_length - fp->block_offset;
		bgzf_byte_t *buffer;
        if (available <= 0) {
            if (bgzf_read_block(fp) != 0) {
                return -1;
            }
            available = fp->block_length - fp->block_offset;
            if (available <= 0) {
                break;
            }
        }
        copy_length = bgzf_min(length-bytes_read, available);
        buffer = fp->uncompressed_block;
        memcpy(output, buffer + fp->block_offset, copy_length);
        fp->block_offset += copy_length;
        output += copy_length;
        bytes_read += copy_length;
    }
    if (fp->block_offset == fp->block_length) {
#ifdef _USE_KNETFILE
        fp->block_address = knet_tell(fp->x.fpr);
#else
        fp->block_address = ftello(fp->file);
#endif
        fp->block_offset = 0;
        fp->block_length = 0;
    }
    return bytes_read;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testl %edx, %edx
jle 0x3344a9
movq %rdi, %r14
cmpb $0x72, 0x4(%rdi)
jne 0x3344ad
movl %edx, %ebp
movq %rsi, %r15
movl 0x3c(%r14), %eax
xorl %ebx, %ebx
movl 0x38(%r14), %ecx
subl %eax, %ecx
jg 0x334459
movq %r14, %rdi
callq 0x333cbc
testl %eax, %eax
jne 0x3344b8
movl 0x38(%r14), %ecx
movl 0x3c(%r14), %eax
subl %eax, %ecx
jle 0x33448c
movl %ebp, %edx
subl %ebx, %edx
cmpl %ecx, %edx
cmovgel %ecx, %edx
movslq %eax, %rsi
addq 0x20(%r14), %rsi
movslq %edx, %r12
movq %r15, %rdi
movq %r12, %rdx
callq 0x17660
movl 0x3c(%r14), %eax
addl %r12d, %eax
movl %eax, 0x3c(%r14)
addq %r12, %r15
addl %r12d, %ebx
cmpl %ebp, %ebx
jl 0x334439
cmpl 0x38(%r14), %eax
jne 0x3344bd
movq 0x10(%r14), %rdi
callq 0x17bc0
movq %rax, 0x30(%r14)
movq $0x0, 0x38(%r14)
jmp 0x3344bd
xorl %ebx, %ebx
jmp 0x3344bd
leaq 0xb2f6c(%rip), %rax     # 0x3e7420
movq %rax, 0x48(%r14)
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/samtools-0.1.18/bgzf.c
// Function: bgzf_flush
int bgzf_flush(BGZF* fp)
{
    while (fp->block_offset > 0) {
        int count, block_length;
		block_length = deflate_block(fp, fp->block_offset);
        if (block_length < 0) return -1;
#ifdef _USE_KNETFILE
        count = fwrite(fp->compressed_block, 1, block_length, fp->x.fpw);
#else
        count = fwrite(fp->compressed_block, 1, block_length, fp->file);
#endif
        if (count != block_length) {
            report_error(fp, "write failed");
            return -1;
        }
        fp->block_address += block_length;
    }
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl 0x3c(%rdi), %esi
testl %esi, %esi
jle 0x334515
movq %rdi, %rbx
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movq %rbx, %rdi
callq 0x334531
testl %eax, %eax
js 0x334524
movl %eax, %r14d
movq 0x10(%rbx), %rcx
movq 0x28(%rbx), %rdi
movl %eax, %r15d
movl $0x1, %esi
movq %r15, %rdx
callq 0x17fa0
cmpl %eax, %r14d
jne 0x334519
addq %r15, 0x30(%rbx)
movl 0x3c(%rbx), %esi
testl %esi, %esi
jg 0x3344de
xorl %ebp, %ebp
jmp 0x334524
leaq 0xb2f1a(%rip), %rax     # 0x3e743a
movq %rax, 0x48(%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/samtools-0.1.18/bgzf.c
// Function: bgzf_write
int bgzf_write(BGZF* fp, const void* data, int length)
{
	const bgzf_byte_t *input = data;
	int block_length, bytes_written;
    if (fp->open_mode != 'w') {
        report_error(fp, "file not open for writing");
        return -1;
    }

    if (fp->uncompressed_block == NULL)
        fp->uncompressed_block = malloc(fp->uncompressed_block_size);

    input = data;
    block_length = fp->uncompressed_block_size;
    bytes_written = 0;
    while (bytes_written < length) {
        int copy_length = bgzf_min(block_length - fp->block_offset, length - bytes_written);
        bgzf_byte_t* buffer = fp->uncompressed_block;
        memcpy(buffer + fp->block_offset, input, copy_length);
        fp->block_offset += copy_length;
        input += copy_length;
        bytes_written += copy_length;
        if (fp->block_offset == block_length) {
            if (bgzf_flush(fp) != 0) {
                break;
            }
        }
    }
    return bytes_written;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x77, 0x4(%rdi)
jne 0x3347a9
movl %edx, %ebp
movq %rsi, %r14
movq 0x20(%rbx), %rdi
movslq 0x18(%rbx), %r15
testq %rdi, %rdi
jne 0x334753
movq %r15, %rdi
callq 0x17ff0
movq %rax, %rdi
movq %rax, 0x20(%rbx)
xorl %r12d, %r12d
testl %ebp, %ebp
jle 0x3347ba
movslq 0x3c(%rbx), %rax
movl %r15d, %ecx
subl %eax, %ecx
movl %ebp, %edx
subl %r12d, %edx
cmpl %edx, %ecx
cmovll %ecx, %edx
addq %rax, %rdi
movslq %edx, %r13
movq %r14, %rsi
movq %r13, %rdx
callq 0x17660
movl 0x3c(%rbx), %eax
addl %r13d, %eax
movl %eax, 0x3c(%rbx)
addl %r13d, %r12d
cmpl %r15d, %eax
jne 0x33479b
movq %rbx, %rdi
callq 0x3344c8
testl %eax, %eax
jne 0x3347ba
cmpl %ebp, %r12d
jge 0x3347ba
addq %r13, %r14
movq 0x20(%rbx), %rdi
jmp 0x33475a
leaq 0xb2c97(%rip), %rax     # 0x3e7447
movq %rax, 0x48(%rbx)
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/samtools-0.1.18/bgzf.c
// Function: bgzf_check_EOF
int bgzf_check_EOF(BGZF *fp)
{
	static uint8_t magic[28] = "\037\213\010\4\0\0\0\0\0\377\6\0\102\103\2\0\033\0\3\0\0\0\0\0\0\0\0\0";
	uint8_t buf[28];
	off_t offset;
#ifdef _USE_KNETFILE
	offset = knet_tell(fp->x.fpr);
	if (knet_seek(fp->x.fpr, -28, SEEK_END) != 0) return -1;
	knet_read(fp->x.fpr, buf, 28);
	knet_seek(fp->x.fpr, offset, SEEK_SET);
#else
	offset = ftello(fp->file);
	if (fseeko(fp->file, -28, SEEK_END) != 0) return -1;
	fread(buf, 1, 28, fp->file);
	fseeko(fp->file, offset, SEEK_SET);
#endif
	return (memcmp(magic, buf, 28) == 0)? 1 : 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x17bc0
movq %rax, %r14
movq 0x10(%rbx), %rdi
movq $-0x1c, %rsi
movl $0x2, %edx
callq 0x17cf0
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %ecx, %ecx
jne 0x334866
movq 0x10(%rbx), %rcx
movq %rsp, %r15
movl $0x1, %esi
movl $0x1c, %edx
movq %r15, %rdi
callq 0x17b40
movq 0x10(%rbx), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x17cf0
movdqa 0x189004(%rip), %xmm0   # 0x4bd840
movdqu 0x189008(%rip), %xmm1   # 0x4bd84c
movdqu 0xc(%r15), %xmm2
pcmpeqb %xmm1, %xmm2
pcmpeqb (%r15), %xmm0
pand %xmm2, %xmm0
pmovmskb %xmm0, %ecx
xorl %eax, %eax
cmpl $0xffff, %ecx           # imm = 0xFFFF
sete %al
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/bool_matrix.c
// Function: gt_bool_matrix_get
bool gt_bool_matrix_get(GtBoolMatrix *bm, GtUword firstdim,
                        GtUword seconddim)
{
  GtDynBittab *bt;
  gt_assert(bm);
  if (firstdim < gt_array_size(bm->dyn_bittabs)) {
    bt = *(GtDynBittab**) gt_array_get(bm->dyn_bittabs, firstdim);
    if (bt && gt_dyn_bittab_bit_is_set(bt, seconddim))
      return true;
  }
  return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x33f74f
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rdi
callq 0xd24e0
cmpq %r14, %rax
jbe 0x33f747
movq (%r15), %rdi
movq %r14, %rsi
callq 0xd2207
movq (%rax), %rdi
testq %rdi, %rdi
je 0x33f747
movq %rbx, %rsi
callq 0xe6e7b
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x33f749
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x96d6f
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/bool_matrix.c
// Function: gt_bool_matrix_set
void gt_bool_matrix_set(GtBoolMatrix *bm, GtUword firstdim,
                        GtUword seconddim, bool b)
{
  GtDynBittab *bt;
  GtUword i, elems_to_add;

  gt_assert(bm);
  /* make sure first dimension is large enough */
  if (firstdim >= gt_array_size(bm->dyn_bittabs)) {
    elems_to_add = firstdim - gt_array_size(bm->dyn_bittabs) + 1;
    for (i = 0; i < elems_to_add; i++) {
      bt = gt_dyn_bittab_new();
      gt_array_add(bm->dyn_bittabs, bt);
    }
  }

  /* set bit, if necessary */
  bt = *(GtDynBittab**) gt_array_get(bm->dyn_bittabs, firstdim);
  gt_assert(bt);
  if (b)
    gt_dyn_bittab_set_bit(bt, seconddim);
  else
    gt_dyn_bittab_unset_bit(bt, seconddim);

  /* value has been set */
  gt_assert(gt_bool_matrix_get(bm, firstdim, seconddim) == b);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x33f808
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq (%rdi), %rdi
callq 0xd24e0
cmpq %r15, %rax
ja 0x33f7bc
movq (%r12), %rdi
callq 0xd24e0
leaq 0x1(%r15), %rbp
subq %rax, %rbp
je 0x33f7bc
cmpq $0x1, %rbp
adcq $0x0, %rbp
movq %rsp, %r13
callq 0xe6d8c
movq %rax, (%rsp)
movq (%r12), %rdi
movl $0x8, %edx
movq %r13, %rsi
callq 0xd2410
decq %rbp
jne 0x33f79d
movq (%r12), %rdi
movq %r15, %rsi
callq 0xd2207
movq (%rax), %rdi
movq %rdi, (%rsp)
testq %rdi, %rdi
je 0x33f80d
movq %r14, %rsi
testb %bl, %bl
je 0x33f7e2
callq 0xe6da7
jmp 0x33f7e7
callq 0xe6e52
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x33f704
cmpb %bl, %al
jne 0x33f812
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x96e14
callq 0x96ddd
callq 0x96da6
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/bool_matrix.c
// Function: gt_bool_matrix_get_first_column
GtUword gt_bool_matrix_get_first_column(const GtBoolMatrix *bm,
                                              GtUword firstdim)
{
  GtDynBittab *bt;
  gt_assert(bm);
  if (firstdim < gt_array_size(bm->dyn_bittabs)) {
    if ((bt = *(GtDynBittab**) gt_array_get(bm->dyn_bittabs, firstdim)))
      return gt_dyn_bittab_get_first_bitnum(bt);
  }
  return GT_UNDEF_UWORD;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x33f861
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
callq 0xd24e0
cmpq %rbx, %rax
jbe 0x33f852
movq (%r14), %rdi
movq %rbx, %rsi
callq 0xd2207
movq (%rax), %rdi
testq %rdi, %rdi
je 0x33f852
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xe6ea6
movq $-0x1, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x96e4b
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/bool_matrix.c
// Function: gt_bool_matrix_get_last_column
GtUword gt_bool_matrix_get_last_column(const GtBoolMatrix *bm,
                                             GtUword firstdim)
{
  GtDynBittab *bt;
  gt_assert(bm);
  if (firstdim < gt_array_size(bm->dyn_bittabs)) {
    if ((bt = *(GtDynBittab**) gt_array_get(bm->dyn_bittabs, firstdim)))
      return gt_dyn_bittab_get_last_bitnum(bt);
  }
  return GT_UNDEF_UWORD;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x33f8b0
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
callq 0xd24e0
cmpq %rbx, %rax
jbe 0x33f8a1
movq (%r14), %rdi
movq %rbx, %rsi
callq 0xd2207
movq (%rax), %rdi
testq %rdi, %rdi
je 0x33f8a1
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xe6ee1
movq $-0x1, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x96e82
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/bool_matrix.c
// Function: gt_bool_matrix_get_next_column
GtUword gt_bool_matrix_get_next_column(const GtBoolMatrix *bm,
                                             GtUword firstdim,
                                             GtUword i)
{
  GtDynBittab *bt;
  gt_assert(bm);
  if (firstdim < gt_array_size(bm->dyn_bittabs)) {
    if ((bt = *(GtDynBittab**) gt_array_get(bm->dyn_bittabs, firstdim)))
      return gt_dyn_bittab_get_next_bitnum(bt, i);
  }
  return GT_UNDEF_UWORD;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x33f902
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rdi
callq 0xd24e0
cmpq %r14, %rax
jbe 0x33f8f5
movq (%r15), %rdi
movq %r14, %rsi
callq 0xd2207
movq (%rax), %rdi
testq %rdi, %rdi
je 0x33f8f5
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xe6ef1
movq $-0x1, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x96eb9
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/bool_matrix.c
// Function: gt_bool_matrix_delete
void gt_bool_matrix_delete(GtBoolMatrix *bm)
{
  GtUword i;
  if (!bm) return;
  for (i = 0; i < gt_array_size(bm->dyn_bittabs); i++)
    gt_dyn_bittab_delete(*(GtDynBittab**) gt_array_get(bm->dyn_bittabs, i));
  gt_array_delete(bm->dyn_bittabs);
  gt_free(bm);
}

// Assembly:
testq %rdi, %rdi
je 0x33f969
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0xd24e0
testq %rax, %rax
je 0x33f946
xorl %r14d, %r14d
movq (%rbx), %rdi
movq %r14, %rsi
callq 0xd2207
movq (%rax), %rdi
callq 0xe74a1
incq %r14
movq (%rbx), %rdi
callq 0xd24e0
cmpq %rax, %r14
jb 0x33f923
movq (%rbx), %rdi
callq 0xd2938
leaq 0xaa47b(%rip), %rsi     # 0x3e9dd0
movq %rbx, %rdi
movl $0x79, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1045eb
retq
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/obo_parse_tree.c
// Function: gt_obo_parse_tree_delete
void gt_obo_parse_tree_delete(GtOBOParseTree *obo_parse_tree)
{
  GtUword i;
  if (!obo_parse_tree) return;
  for (i = 0; i < gt_array_size(obo_parse_tree->stanzas); i++) {
    gt_obo_stanza_delete(*(GtOBOStanza**)
                         gt_array_get(obo_parse_tree->stanzas, i));
  }
  gt_array_delete(obo_parse_tree->stanzas);
  obo_header_delete(obo_parse_tree->obo_header);
  gt_free(obo_parse_tree);
}

// Assembly:
testq %rdi, %rdi
je 0x340186
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0xd24e0
testq %rax, %rax
je 0x3400d1
xorl %r14d, %r14d
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0xd2207
movq (%rax), %rdi
callq 0x34068c
incq %r14
movq 0x8(%rbx), %rdi
callq 0xd24e0
cmpq %rax, %r14
jb 0x3400ac
movq 0x8(%rbx), %rdi
callq 0xd2938
movq (%rbx), %r14
testq %r14, %r14
je 0x340169
movq (%r14), %rdi
callq 0xd24e0
testq %rax, %rax
je 0x34014d
xorl %r15d, %r15d
leaq 0xa9db8(%rip), %r12     # 0x3e9eb5
movq (%r14), %rdi
movq %r15, %rsi
callq 0xd2207
movq (%rax), %r13
movq 0x8(%r13), %rdi
movq %r12, %rsi
movl $0x38, %edx
callq 0x1045eb
movq (%r13), %rdi
movq %r12, %rsi
movl $0x39, %edx
callq 0x1045eb
movq %r13, %rdi
movq %r12, %rsi
movl $0x3a, %edx
callq 0x1045eb
incq %r15
movq (%r14), %rdi
callq 0xd24e0
cmpq %rax, %r15
jb 0x3400fd
movq (%r14), %rdi
callq 0xd2938
leaq 0xa9d59(%rip), %rsi     # 0x3e9eb5
movq %r14, %rdi
movl $0x3d, %edx
callq 0x1045eb
leaq 0xa9d45(%rip), %rsi     # 0x3e9eb5
movq %rbx, %rdi
movl $0x1bf, %edx            # imm = 0x1BF
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/obo_parse_tree.c
// Function: gt_obo_parse_tree_get_stanza_type
const char* gt_obo_parse_tree_get_stanza_type(const GtOBOParseTree
                                              *obo_parse_tree,
                                              GtUword stanza_num)
{
  gt_assert(obo_parse_tree);
  return gt_obo_stanza_get_type(*(GtOBOStanza**)
                                gt_array_get(obo_parse_tree->stanzas,
                                             stanza_num));
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x34019f
movq 0x8(%rdi), %rdi
callq 0xd2207
movq (%rax), %rdi
popq %rax
jmp 0x34075d
callq 0x97206
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/obo_parse_tree.c
// Function: gt_obo_parse_tree_get_stanza_value
const char* gt_obo_parse_tree_get_stanza_value(const GtOBOParseTree
                                               *obo_parse_tree,
                                               GtUword stanza_num,
                                               const char *stanza_key)
{
  gt_assert(obo_parse_tree);
  return gt_obo_stanza_get_value(*(GtOBOStanza**)
                                 gt_array_get(obo_parse_tree->stanzas,
                                              stanza_num), stanza_key, 0);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x3401c4
movq %rdx, %rbx
movq 0x8(%rdi), %rdi
callq 0xd2207
movq (%rax), %rdi
movq %rbx, %rsi
xorl %edx, %edx
popq %rbx
jmp 0x34076c
callq 0x9723f
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/obo_parse_tree.c
// Function: blank_line
static int blank_line(GtIO *obo_file, GtError *err)
{
  int had_err;
  gt_error_check(err);
  had_err = gt_io_expect(obo_file, OBO_BLANK_CHAR, err);
  while (!had_err) {
    char cc = gt_io_peek(obo_file);
    if (cc == OBO_COMMENT_CHAR)
      return comment_line(obo_file, err);
    else if (cc == GT_CARRIAGE_RETURN) {
      gt_io_next(obo_file);
      if (gt_io_peek(obo_file) == GT_END_OF_LINE)
        gt_io_next(obo_file);
      break;
    }
    else if ((cc == GT_END_OF_LINE) || (cc == GT_END_OF_FILE)) {
      gt_io_next(obo_file);
      break;
    }
    else
      had_err = gt_io_expect(obo_file, OBO_BLANK_CHAR, err);
  }
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
testq %rsi, %rsi
je 0x340211
movq %r14, %rdi
callq 0xfcc32
testb %al, %al
jne 0x34028e
movq %rbx, %rdi
movl $0x20, %esi
movq %r14, %rdx
callq 0x103c1b
testl %eax, %eax
jne 0x340259
movq %rbx, %rdi
callq 0x103b7b
movzbl %al, %eax
cmpl $0x20, %eax
jg 0x340241
cmpl $0xa, %eax
je 0x340262
cmpl $0xd, %eax
jne 0x340211
jmp 0x34026e
cmpl $0xff, %eax
je 0x340262
cmpl $0x21, %eax
jne 0x340211
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x340293
movl %eax, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
callq 0x103bb4
xorl %ebp, %ebp
jmp 0x34025b
movq %rbx, %rdi
callq 0x103bb4
movq %rbx, %rdi
callq 0x103b7b
xorl %ebp, %ebp
cmpb $0xa, %al
jne 0x34025b
movq %rbx, %rdi
callq 0x103bb4
jmp 0x34025b
callq 0x972ea
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/obo_parse_tree.c
// Function: comment_line
static int comment_line(GtIO *obo_file, GtError *err)
{
  int had_err;
  gt_error_check(err);
  had_err = gt_io_expect(obo_file, OBO_COMMENT_CHAR, err);
  while (!had_err) {
    switch (gt_io_peek(obo_file)) {
      case GT_CARRIAGE_RETURN:
        gt_io_next(obo_file);
        if (gt_io_peek(obo_file) == GT_END_OF_LINE)
          gt_io_next(obo_file);
        return had_err;
      case GT_END_OF_LINE:
        gt_io_next(obo_file);
        /*@fallthrough@*/
      case GT_END_OF_FILE:
        return had_err;
      default:
        gt_io_next(obo_file);
    }
  }
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
testq %rsi, %rsi
je 0x3402ae
movq %r14, %rdi
callq 0xfcc32
testb %al, %al
jne 0x34030b
movq %rbx, %rdi
movl $0x21, %esi
movq %r14, %rdx
callq 0x103c1b
movl %eax, %ebp
testl %eax, %eax
jne 0x340304
jmp 0x3402dd
movzbl %al, %eax
cmpl $0xff, %eax
je 0x340304
movq %rbx, %rdi
cmpl $0xd, %eax
je 0x3402eb
callq 0x103bb4
movq %rbx, %rdi
callq 0x103b7b
cmpb $0xa, %al
jne 0x3402c6
jmp 0x3402fc
callq 0x103bb4
movq %rbx, %rdi
callq 0x103b7b
cmpb $0xa, %al
jne 0x340304
movq %rbx, %rdi
callq 0x103bb4
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
callq 0x97323
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/obo_parse_tree.c
// Function: tag_line
static int tag_line(GtIO *obo_file, GtStr *tag, GtStr *value, GtError *err)
{
  int had_err;
  gt_error_check(err);
  gt_assert(obo_file && tag && value);
  do {
    had_err = proc_any_char(obo_file, tag, false, err);
  } while (!had_err && any_char(obo_file, false));
  if (!had_err)
    had_err = gt_io_expect(obo_file, OBO_SEPARATOR_CHAR, err);
  while (!had_err && gt_io_peek(obo_file) == OBO_BLANK_CHAR)
    gt_io_next(obo_file);
  if (!had_err) {
    do {
      had_err = proc_any_char(obo_file, value, true, err);
    } while (!had_err && any_char(obo_file, true));
  }
  if (!had_err) {
    if (gt_io_peek(obo_file) == OBO_COMMENT_CHAR)
      had_err = comment_line(obo_file, err);
    else
      had_err = gt_io_expect(obo_file, GT_END_OF_LINE, err);
  }
  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
testq %rcx, %rcx
je 0x340339
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0x340411
testq %r12, %r12
je 0x34040c
testq %r15, %r15
je 0x34040c
movq %r14, %rdi
movq %r12, %rsi
xorl %edx, %edx
movq %rbx, %rcx
callq 0x34046b
testl %eax, %eax
jne 0x3403c1
movq %r14, %rdi
xorl %esi, %esi
callq 0x340416
testb %al, %al
jne 0x34034b
movq %r14, %rdi
movl $0x3a, %esi
movq %rbx, %rdx
callq 0x103c1b
testl %eax, %eax
jne 0x3403c6
jmp 0x34038b
movq %r14, %rdi
callq 0x103bb4
movq %r14, %rdi
callq 0x103b7b
cmpb $0x20, %al
je 0x340383
jmp 0x3403aa
movq %r14, %rdi
movl $0x1, %esi
callq 0x340416
testb %al, %al
je 0x3403d2
movq %r14, %rdi
movq %r15, %rsi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x34046b
testl %eax, %eax
je 0x340399
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r14, %rdi
callq 0x103b7b
movq %r14, %rdi
cmpb $0x21, %al
jne 0x3403f4
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x340293
movl $0xa, %esi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x103c1b
callq 0x97395
callq 0x9735c
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/obo_parse_tree.c
// Function: proc_any_char
static int proc_any_char(GtIO *obo_file, GtStr *capture, bool be_permissive,
                         GtError *err)
{
  gt_error_check(err);
  gt_assert(obo_file && capture);
  if (!any_char(obo_file, be_permissive)) {
    if (gt_io_peek(obo_file) == GT_END_OF_FILE) {
      gt_error_set(err, "file \"%s\": line "GT_WU": unexpected end-of-file",
                gt_io_get_filename(obo_file), gt_io_get_line_number(obo_file));
    }
    else if ((gt_io_peek(obo_file) == GT_CARRIAGE_RETURN) ||
             (gt_io_peek(obo_file) == GT_END_OF_LINE)) {
      gt_error_set(err, "file \"%s\": line "GT_WU": unexpected newline",
                gt_io_get_filename(obo_file), gt_io_get_line_number(obo_file));
    }
    else {
      gt_error_set(err, "file \"%s\": line "GT_WU": unexpected character '%c'",
                gt_io_get_filename(obo_file), gt_io_get_line_number(obo_file),
                gt_io_peek(obo_file));
    }
    return -1;
  }
  gt_str_append_char(capture, gt_io_next(obo_file));
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
testq %rcx, %rcx
je 0x340493
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0x340578
testq %r15, %r15
je 0x340573
movzbl %bpl, %esi
movq %r14, %rdi
callq 0x340416
testb %al, %al
je 0x3404c3
movq %r14, %rdi
callq 0x103bb4
movsbl %al, %esi
movq %r15, %rdi
callq 0x11af23
xorl %eax, %eax
jmp 0x34052f
movq %r14, %rdi
callq 0x103b7b
movq %r14, %rdi
cmpb $-0x1, %al
je 0x340503
callq 0x103b7b
cmpb $0xd, %al
je 0x3404e7
movq %r14, %rdi
callq 0x103b7b
cmpb $0xa, %al
jne 0x340538
movq %r14, %rdi
callq 0x103bee
movq %rax, %r15
movq %r14, %rdi
callq 0x103bde
leaq 0x5c98a(%rip), %rsi     # 0x39ce8b
jmp 0x34051a
callq 0x103bee
movq %rax, %r15
movq %r14, %rdi
callq 0x103bde
leaq 0x5c945(%rip), %rsi     # 0x39ce5f
movq %rbx, %rdi
movq %r15, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0xfcb67
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0x103bee
movq %rax, %r15
movq %r14, %rdi
callq 0x103bde
movq %rax, %r12
movq %r14, %rdi
callq 0x103b7b
movsbl %al, %r8d
leaq 0x5c952(%rip), %rsi     # 0x39ceb3
movq %rbx, %rdi
movq %r15, %rdx
movq %r12, %rcx
xorl %eax, %eax
callq 0xfcb67
jmp 0x34052a
callq 0x97407
callq 0x973ce
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/obo_parse_tree.c
// Function: validate_value
static int validate_value(const GtOBOStanza *obo_stanza, const char *value,
                          GtError *err)
{
  gt_error_check(err);
  gt_assert(obo_stanza && value);
  if (!gt_obo_stanza_get_value(obo_stanza, value, 0)) {
    gt_error_set(err, "%s stanza starting on line "GT_WU" in file \"%s\" lacks "
                 "required \"%s\" tag", gt_obo_stanza_get_type(obo_stanza),
                 gt_obo_stanza_line(obo_stanza),
                 gt_obo_stanza_filename(obo_stanza), value);
    return -1;
  }
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
testq %rdx, %rdx
je 0x3405a0
movq %r14, %rdi
callq 0xfcc32
testb %al, %al
jne 0x340612
testq %r15, %r15
je 0x34060d
testq %rbx, %rbx
je 0x34060d
xorl %r12d, %r12d
movq %r15, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x34076c
testq %rax, %rax
jne 0x340600
movq %r15, %rdi
callq 0x34075d
movq %rax, %r12
movq %r15, %rdi
callq 0x3407d2
movq %rax, %r13
movq %r15, %rdi
callq 0x3407be
leaq 0xa9b30(%rip), %rsi     # 0x3ea114
movq %r14, %rdi
movq %r12, %rdx
movq %r13, %rcx
movq %rax, %r8
movq %rbx, %r9
xorl %eax, %eax
callq 0xfcb67
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
movl %r12d, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x97477
callq 0x97440
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/obo_stanza.c
// Function: gt_obo_stanza_new
GtOBOStanza* gt_obo_stanza_new(const char *type, GtUword line,
                               GtStr *filename)
{
  GtOBOStanza *obo_stanza = gt_malloc(sizeof *obo_stanza);
  obo_stanza->type = gt_cstr_dup(type);
  obo_stanza->content = gt_hashmap_new(GT_HASH_STRING, gt_free_func,
                                       (GtFree) gt_str_array_delete);
  obo_stanza->line = line;
  obo_stanza->filename = gt_str_ref(filename);
  return obo_stanza;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0xa9b28(%rip), %rsi     # 0x3ea158
movl $0x20, %edi
movl $0x23, %edx
callq 0x104226
movq %rax, %r12
movq %r15, %rdi
callq 0xe4290
movq %rax, (%r12)
leaq -0x23bfab(%rip), %rsi   # 0x1046aa
leaq -0x224518(%rip), %rdx   # 0x11c144
movl $0x1, %edi
callq 0x1008fc
movq %rax, 0x8(%r12)
movq %r14, 0x10(%r12)
movq %rbx, %rdi
callq 0x11b1f3
movq %rax, 0x18(%r12)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/obo_stanza.c
// Function: gt_obo_stanza_delete
void gt_obo_stanza_delete(GtOBOStanza *obo_stanza)
{
  if (!obo_stanza) return;
  gt_str_delete(obo_stanza->filename);
  gt_hashmap_delete(obo_stanza->content);
  gt_free(obo_stanza->type);
  gt_free(obo_stanza);
}

// Assembly:
testq %rdi, %rdi
je 0x3406d8
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x11bdbf
movq 0x8(%rbx), %rdi
callq 0x10109b
movq (%rbx), %rdi
leaq 0xa9aa4(%rip), %r14     # 0x3ea158
movq %r14, %rsi
movl $0x31, %edx
callq 0x1045eb
movq %rbx, %rdi
movq %r14, %rsi
movl $0x32, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/obo_stanza.c
// Function: gt_obo_stanza_add
void gt_obo_stanza_add(GtOBOStanza *obo_stanza, const char *tag,
                       const char *value)
{
  GtStrArray *sa;
  gt_assert(obo_stanza && tag && value);
  if (!(sa = gt_hashmap_get(obo_stanza->content, tag))) {
    sa = gt_str_array_new();
    gt_str_array_add_cstr(sa, value);
    gt_hashmap_add(obo_stanza->content, gt_cstr_dup(tag), sa);
  }
  else
    gt_str_array_add_cstr(sa, value);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x340758
movq %rsi, %rbx
testq %rsi, %rsi
je 0x340758
movq %rdx, %r14
testq %rdx, %rdx
je 0x340758
movq %rdi, %r15
movq 0x8(%rdi), %rdi
movq %rbx, %rsi
callq 0x100add
testq %rax, %rax
je 0x340720
movq %rax, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x11bee9
callq 0x11be10
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
callq 0x11bee9
movq 0x8(%r15), %r14
movq %rbx, %rdi
callq 0xe4290
movq %r14, %rdi
movq %rax, %rsi
movq %r12, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x100b18
callq 0x974ae