LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/annotationsketch/custom_track.c
// Function: gt_custom_track_class_new
const GtCustomTrackClass* gt_custom_track_class_new(size_t size,
                                          GtCustomTrackRenderFunc render,
                                          GtCustomTrackGetHeightFunc get_height,
                                          GtCustomTrackGetTitleFunc get_title,
                                          GtCustomTrackFreeFunc free)
{
  GtCustomTrackClass *c_class = gt_class_alloc(sizeof *c_class);
  c_class->size = size;
  c_class->render = render;
  c_class->get_height = get_height;
  c_class->get_title = get_title;
  c_class->free = free;
  return c_class;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movl $0x28, %edi
callq 0x7b610
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x28(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x20(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x8(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/annotationsketch/custom_track.c
// Function: gt_custom_track_create
GtCustomTrack* gt_custom_track_create(const GtCustomTrackClass *ctc)
{
  GtCustomTrack *ct;
  gt_assert(ctc && ctc->size);
  ct = gt_calloc(1, ctc->size);
  ct->c_class = ctc;
  ct->pvt = gt_calloc(1, sizeof (GtCustomTrackMembers));
  return ct;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0xb646c
movq 0x10(%rsp), %rax
cmpq $0x0, (%rax)
jne 0xb64a4
movq 0xfdb65(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0xa7be9(%rip), %rsi     # 0x15e066
leaq 0xbe38d(%rip), %rdx     # 0x174811
leaq 0xbe397(%rip), %rcx     # 0x174822
leaq 0xbe3a7(%rip), %r8      # 0x174839
movl $0x37, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xb64a6
movq 0x10(%rsp), %rax
movq (%rax), %rsi
movl $0x1, %edi
leaq 0xbe37f(%rip), %rdx     # 0x174839
movl $0x38, %ecx
callq 0xd5b0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movl $0x1, %edi
movl $0x4, %esi
leaq 0xbe352(%rip), %rdx     # 0x174839
movl $0x3a, %ecx
callq 0xd5b0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/annotationsketch/custom_track.c
// Function: gt_custom_track_delete
void gt_custom_track_delete(GtCustomTrack *ctrack)
{
  if (!ctrack) return;
  if (ctrack->pvt->reference_count) {
    ctrack->pvt->reference_count--;
    return;
  }
  gt_assert(ctrack->c_class);
  if (ctrack->c_class->free)
    ctrack->c_class->free(ctrack);
  gt_free(ctrack->pvt);
  gt_free(ctrack);
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0xb6581
jmp 0xb6635
movq (%rsp), %rax
movq 0x8(%rax), %rax
cmpl $0x0, (%rax)
je 0xb65a2
movq (%rsp), %rax
movq 0x8(%rax), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
jmp 0xb6635
jmp 0xb65a4
movq (%rsp), %rax
cmpq $0x0, (%rax)
jne 0xb65e6
movq 0xfda23(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0xa7aa7(%rip), %rsi     # 0x15e066
leaq 0xbe33a(%rip), %rdx     # 0x174900
leaq 0xbe2a4(%rip), %rcx     # 0x174871
leaq 0xbe265(%rip), %r8      # 0x174839
movl $0x4c, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xb65e8
movq (%rsp), %rax
movq (%rax), %rax
cmpq $0x0, 0x20(%rax)
je 0xb6607
movq (%rsp), %rax
movq (%rax), %rax
movq 0x20(%rax), %rax
movq (%rsp), %rdi
callq *%rax
movq (%rsp), %rax
movq 0x8(%rax), %rdi
leaq 0xbe223(%rip), %rsi     # 0x174839
movl $0x4f, %edx
callq 0xdab0
movq (%rsp), %rdi
leaq 0xbe20e(%rip), %rsi     # 0x174839
movl $0x50, %edx
callq 0xdab0
popq %rax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/annotationsketch/drawing_range.c
// Function: gt_drawing_range_compare
int gt_drawing_range_compare(GtDrawingRange range_a, GtDrawingRange range_b)
{
  gt_assert(range_a.start <= range_a.end && range_b.start <= range_b.end);

  if (gt_double_equals_double(range_a.start, range_b.start) &&
      gt_double_equals_double(range_a.end, range_b.end))
    return 0; /* range_a == range_b */

  if (gt_double_smaller_double(range_a.start, range_b.start) ||
      (gt_double_equals_double(range_a.start, range_b.start)
       && gt_double_smaller_double(range_a.end, range_b.end)))
    return -1; /* range_a < range_b */

  return 1; /* range_a > range_b */
}

// Assembly:
subq $0x18, %rsp
leaq 0x38(%rsp), %rax
movq %rax, (%rsp)
leaq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movsd (%rax), %xmm1
movsd 0x8(%rax), %xmm0
ucomisd %xmm1, %xmm0
jb 0xb691e
movq (%rsp), %rax
movsd (%rax), %xmm1
movsd 0x8(%rax), %xmm0
ucomisd %xmm1, %xmm0
jae 0xb6956
movq 0xfd6b3(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0xa7737(%rip), %rsi     # 0x15e066
leaq 0xbe044(%rip), %rdx     # 0x17497a
leaq 0xbe07a(%rip), %rcx     # 0x1749b7
leaq 0xbe08c(%rip), %r8      # 0x1749d0
movl $0x18, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xb6958
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movsd (%rcx), %xmm0
movsd (%rax), %xmm1
callq 0x8c2d0
testb $0x1, %al
jne 0xb6974
jmp 0xb699c
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movsd 0x8(%rcx), %xmm0
movsd 0x8(%rax), %xmm1
callq 0x8c2d0
testb $0x1, %al
jne 0xb6992
jmp 0xb699c
movl $0x0, 0x14(%rsp)
jmp 0xb6a02
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movsd (%rcx), %xmm0
movsd (%rax), %xmm1
callq 0x8c360
testb $0x1, %al
jne 0xb69f0
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movsd (%rcx), %xmm0
movsd (%rax), %xmm1
callq 0x8c2d0
testb $0x1, %al
jne 0xb69d2
jmp 0xb69fa
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movsd 0x8(%rcx), %xmm0
movsd 0x8(%rax), %xmm1
callq 0x8c360
testb $0x1, %al
jne 0xb69f0
jmp 0xb69fa
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
jmp 0xb6a02
movl $0x1, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/annotationsketch/element.c
// Function: gt_element_new
GtElement* gt_element_new(GtFeatureNode *node)
{
  GtElement *element;
  gt_assert(node);
  element = gt_element_new_empty();
  gt_element_set_type(element, gt_feature_node_get_type(node));
  gt_element_set_range(element, gt_genome_node_get_range((GtGenomeNode*) node));
  element->strand = gt_feature_node_get_strand(node);
  element->mark = gt_feature_node_is_marked(node);
  element->gn = (GtFeatureNode*) gt_genome_node_ref((GtGenomeNode*) node);
  return element;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0xb6b09
movq 0xfd500(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0xa7584(%rip), %rsi     # 0x15e066
leaq 0xb1029(%rip), %rdx     # 0x167b12
leaq 0xbdf05(%rip), %rcx     # 0x1749f5
leaq 0xbdf0d(%rip), %r8      # 0x174a04
movl $0x29, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xb6b0b
callq 0xb6bc0
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
callq 0x211d0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0xb6be0
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
callq 0x259f0
movq 0x10(%rsp), %rdi
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0xb6c50
movq 0x30(%rsp), %rdi
callq 0x20a10
movl %eax, %ecx
movq 0x28(%rsp), %rax
movl %ecx, 0x10(%rax)
movq 0x30(%rsp), %rdi
callq 0x23e80
movb %al, %cl
movq 0x28(%rsp), %rax
andb $0x1, %cl
movb %cl, 0x48(%rax)
movq 0x30(%rsp), %rdi
callq 0x25140
movq %rax, %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x28(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/annotationsketch/element.c
// Function: gt_element_sketch
int gt_element_sketch(GtElement *elem, GtCanvas *canvas, GtError *err)
{
  int had_err = 0;
  gt_assert(elem && canvas);
  had_err = gt_canvas_visit_element(canvas, elem, err);
  return had_err;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0xb6ebb
cmpq $0x0, 0x18(%rsp)
jne 0xb6ef3
movq 0xfd116(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0xa719a(%rip), %rsi     # 0x15e066
leaq 0xbdbdc(%rip), %rdx     # 0x174aaf
leaq 0xbdbe4(%rip), %rcx     # 0x174abe
leaq 0xbdb23(%rip), %r8      # 0x174a04
movl $0x6d, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xb6ef5
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x3ada0
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/annotationsketch/element.c
// Function: elements_are_equal
static bool elements_are_equal(const GtElement *e1, const GtElement *e2)
{
  gt_assert(e1 && e2);
  if (e1->type == e2->type && !gt_range_compare(&e1->range, &e2->range))
    return true;
  return false;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
cmpq $0x0, 0x8(%rsp)
je 0xb743c
cmpq $0x0, (%rsp)
jne 0xb7474
movq 0xfcb95(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0xa6c19(%rip), %rsi     # 0x15e066
leaq 0xbd781(%rip), %rdx     # 0x174bd5
leaq 0xbd783(%rip), %rcx     # 0x174bde
leaq 0xbd5a2(%rip), %r8      # 0x174a04
movl $0x64, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xb7476
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq (%rsp), %rcx
cmpq (%rcx), %rax
jne 0xb74a9
movq 0x8(%rsp), %rdi
addq $0x20, %rdi
movq (%rsp), %rsi
addq $0x20, %rsi
callq 0x93850
cmpl $0x0, %eax
jne 0xb74a9
movb $0x1, 0x17(%rsp)
jmp 0xb74ae
movb $0x0, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/annotationsketch/element.c
// Function: gt_element_delete
void gt_element_delete(GtElement *element)
{
  if (!element) return;
  if (element->refcount) {
    element->refcount--;
    return;
  }
  gt_genome_node_delete((GtGenomeNode*) element->gn);
  gt_free(element);
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0xb74ce
jmp 0xb750d
movq (%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0xb74eb
movq (%rsp), %rax
movq 0x8(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x8(%rax)
jmp 0xb750d
movq (%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x26eb0
movq (%rsp), %rdi
leaq 0xbd501(%rip), %rsi     # 0x174a04
movl $0xb4, %edx
callq 0xdab0
popq %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/annotationsketch/line.c
// Function: gt_line_new
GtLine* gt_line_new(void)
{
  GtLine *line;
  line = gt_calloc(1, sizeof (GtLine));
  line->blocks = gt_array_new(sizeof (GtBlock*));
  line->has_captions = false;
  return line;
}

// Assembly:
pushq %rax
movl $0x1, %edi
movl $0x10, %esi
leaq 0xbd6cf(%rip), %rdx     # 0x174bf1
movl $0x26, %ecx
callq 0xd5b0
movq %rax, (%rsp)
movl $0x8, %edi
callq 0x75ab0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movq (%rsp), %rax
movb $0x0, (%rax)
movq (%rsp), %rax
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/annotationsketch/line.c
// Function: gt_line_insert_block
void gt_line_insert_block(GtLine *line, GtBlock *block)
{
  gt_assert(line && block);
  if (!line->has_captions && gt_block_get_caption(block) != NULL)
    line->has_captions = true;
  gt_array_add(line->blocks, block);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0xb757e
cmpq $0x0, 0x8(%rsp)
jne 0xb75b6
movq 0xfca53(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0xa6ad7(%rip), %rsi     # 0x15e066
leaq 0xbd8f1(%rip), %rdx     # 0x174e87
leaq 0xbd670(%rip), %rcx     # 0x174c0d
leaq 0xbd64d(%rip), %r8      # 0x174bf1
movl $0x2e, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xb75b8
movq 0x10(%rsp), %rax
testb $0x1, (%rax)
jne 0xb75da
movq 0x8(%rsp), %rdi
callq 0xb03f0
cmpq $0x0, %rax
je 0xb75da
movq 0x10(%rsp), %rax
movb $0x1, (%rax)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
leaq 0x8(%rsp), %rsi
movl $0x8, %edx
callq 0x76220
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/annotationsketch/line.c
// Function: gt_line_sketch
int gt_line_sketch(GtLine *line, GtCanvas *canvas, GtError *err)
{
  int i = 0, had_err = 0;
  gt_assert(line && canvas);
  had_err = gt_canvas_visit_line_pre(canvas, line, err);
  if (!had_err)
  {
    for (i = 0; !had_err && i < gt_array_size(line->blocks); i++) {
      GtBlock *block;
      block = *(GtBlock**) gt_array_get(line->blocks, i);
      had_err = gt_block_sketch(block, canvas, err);
    }
  }
  if (!had_err)
    had_err = gt_canvas_visit_line_post(canvas, line, err);
  return had_err;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0xb76d3
cmpq $0x0, 0x28(%rsp)
jne 0xb770b
movq 0xfc8fe(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0xa6982(%rip), %rsi     # 0x15e066
leaq 0xbd55f(%rip), %rdx     # 0x174c4a
leaq 0xbd567(%rip), %rcx     # 0x174c59
leaq 0xbd4f8(%rip), %r8      # 0x174bf1
movl $0x43, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xb770d
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x3abc0
movl %eax, 0x18(%rsp)
cmpl $0x0, 0x18(%rsp)
jne 0xb77b9
movl $0x0, 0x1c(%rsp)
xorl %eax, %eax
cmpl $0x0, 0x18(%rsp)
movb %al, 0xf(%rsp)
jne 0xb776d
movslq 0x1c(%rsp), %rax
movq %rax, (%rsp)
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x76490
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
setb %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0xb7777
jmp 0xb77b7
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rdi
movslq 0x1c(%rsp), %rsi
callq 0x75c80
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0xb1390
movl %eax, 0x18(%rsp)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0xb7738
jmp 0xb77b9
cmpl $0x0, 0x18(%rsp)
jne 0xb77d8
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x3ac60
movl %eax, 0x18(%rsp)
movl 0x18(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/annotationsketch/line.c
// Function: gt_line_get_height
int gt_line_get_height(GtLine *line, double *height, const GtStyle *sty,
                       GtError *err)
{
  double line_height = 0;
  GtUword i;
  gt_assert(line && sty);
  for (i = 0; i < gt_array_size(line->blocks); i++) {
    GtBlock *block;
    double myheight = BAR_HEIGHT_DEFAULT;
    block = *(GtBlock**) gt_array_get(line->blocks, i);
    /* check again for caption presence, may have changed in the meantime */
    if (!line->has_captions && gt_block_get_caption(block) != NULL) {
      line->has_captions = true;
    }
    if (gt_block_get_max_height(block, &myheight, sty, err) < 0) {
      return -1;
    }
    if (gt_double_smaller_double(line_height, myheight)) {
      line_height = myheight;
    }
  }
  *height = line_height;
  return 0;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq %rcx, 0x30(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x28(%rsp)
cmpq $0x0, 0x48(%rsp)
je 0xb7821
cmpq $0x0, 0x38(%rsp)
jne 0xb7859
movq 0xfc7b0(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0xa6834(%rip), %rsi     # 0x15e066
leaq 0xbd42f(%rip), %rdx     # 0x174c68
leaq 0xbd434(%rip), %rcx     # 0x174c74
leaq 0xbd3aa(%rip), %r8      # 0x174bf1
movl $0x57, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xb785b
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x76490
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0xb7938
movsd 0xb266b(%rip), %xmm0    # 0x169f00
movsd %xmm0, 0x10(%rsp)
movq 0x48(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x20(%rsp), %rsi
callq 0x75c80
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x48(%rsp), %rax
testb $0x1, (%rax)
jne 0xb78d8
movq 0x18(%rsp), %rdi
callq 0xb03f0
cmpq $0x0, %rax
je 0xb78d8
movq 0x48(%rsp), %rax
movb $0x1, (%rax)
movq 0x18(%rsp), %rdi
movq 0x38(%rsp), %rdx
movq 0x30(%rsp), %rcx
leaq 0x10(%rsp), %rsi
callq 0xb1140
cmpl $0x0, %eax
jge 0xb7900
movl $0xffffffff, 0x54(%rsp) # imm = 0xFFFFFFFF
jmp 0xb794f
movsd 0x28(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
callq 0x8c360
testb $0x1, %al
jne 0xb7917
jmp 0xb7923
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
jmp 0xb7925
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0xb7864
movsd 0x28(%rsp), %xmm0
movq 0x40(%rsp), %rax
movsd %xmm0, (%rax)
movl $0x0, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/annotationsketch/line.c
// Function: gt_line_delete
void gt_line_delete(GtLine *line)
{
  GtUword i;
  if (!line) return;
  for (i = 0; i < gt_array_size(line->blocks); i++)
    gt_block_delete(*(GtBlock**) gt_array_get(line->blocks, i));
  gt_array_delete(line->blocks);
  gt_free(line);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0xb84a3
jmp 0xb851e
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x76490
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0xb84fa
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0x75c80
movq (%rax), %rdi
callq 0xb21b0
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0xb84ac
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x770a0
movq 0x10(%rsp), %rdi
leaq 0xbc6dd(%rip), %rsi     # 0x174bf1
movl $0xd6, %edx
callq 0xdab0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/annotationsketch/line_breaker.c
// Function: gt_line_breaker_class_new
const GtLineBreakerClass* gt_line_breaker_class_new(size_t size,
                                  GtLineBreakerIsOccupiedFunc is_occupied,
                                  GtLineBreakerRegisterBlockFunc register_block,
                                  GtLineBreakerFreeFunc free)
{
  GtLineBreakerClass *c_class = gt_class_alloc(sizeof *c_class);
  c_class->size = size;
  c_class->is_occupied = is_occupied;
  c_class->register_block = register_block;
  c_class->free = free;
  return c_class;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movl $0x20, %edi
callq 0x7b610
movq %rax, (%rsp)
movq 0x20(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x18(%rax)
movq (%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/annotationsketch/line_breaker.c
// Function: gt_line_breaker_create
GtLineBreaker* gt_line_breaker_create(const GtLineBreakerClass *lbc)
{
  GtLineBreaker *lb;
  gt_assert(lbc && lbc->size);
  lb = gt_calloc(1, lbc->size);
  lb->c_class = lbc;
  lb->pvt = gt_calloc(1, sizeof (GtLineBreakerMembers));
  return lb;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0xb85bc
movq 0x10(%rsp), %rax
cmpq $0x0, (%rax)
jne 0xb85f4
movq 0xfba15(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0xa5a99(%rip), %rsi     # 0x15e066
leaq 0xbc7cd(%rip), %rdx     # 0x174da1
leaq 0xbc7d7(%rip), %rcx     # 0x174db2
leaq 0xbc7e7(%rip), %r8      # 0x174dc9
movl $0x33, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xb85f6
movq 0x10(%rsp), %rax
movq (%rax), %rsi
movl $0x1, %edi
leaq 0xbc7bf(%rip), %rdx     # 0x174dc9
movl $0x34, %ecx
callq 0xd5b0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movl $0x1, %edi
movl $0x4, %esi
leaq 0xbc792(%rip), %rdx     # 0x174dc9
movl $0x36, %ecx
callq 0xd5b0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/annotationsketch/line_breaker.c
// Function: gt_line_breaker_delete
void gt_line_breaker_delete(GtLineBreaker *lb)
{
  if (!lb) return;
  if (lb->pvt->reference_count) {
    lb->pvt->reference_count--;
    return;
  }
  gt_assert(lb->c_class);
  if (lb->c_class->free)
    lb->c_class->free(lb);
  gt_free(lb->pvt);
  gt_free(lb);
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0xb86d1
jmp 0xb8785
movq (%rsp), %rax
movq 0x8(%rax), %rax
cmpl $0x0, (%rax)
je 0xb86f2
movq (%rsp), %rax
movq 0x8(%rax), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
jmp 0xb8785
jmp 0xb86f4
movq (%rsp), %rax
cmpq $0x0, (%rax)
jne 0xb8736
movq 0xfb8d3(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0xa5957(%rip), %rsi     # 0x15e066
leaq 0xbc6eb(%rip), %rdx     # 0x174e01
leaq 0xbc6f0(%rip), %rcx     # 0x174e0d
leaq 0xbc6a5(%rip), %r8      # 0x174dc9
movl $0x48, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xb8738
movq (%rsp), %rax
movq (%rax), %rax
cmpq $0x0, 0x18(%rax)
je 0xb8757
movq (%rsp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq (%rsp), %rdi
callq *%rax
movq (%rsp), %rax
movq 0x8(%rax), %rdi
leaq 0xbc663(%rip), %rsi     # 0x174dc9
movl $0x4b, %edx
callq 0xdab0
movq (%rsp), %rdi
leaq 0xbc64e(%rip), %rsi     # 0x174dc9
movl $0x4c, %edx
callq 0xdab0
popq %rax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/annotationsketch/line_breaker_bases.c
// Function: gt_line_breaker_bases_is_line_occupied
int gt_line_breaker_bases_is_line_occupied(GtLineBreaker* lb, bool *result,
                                           GtLine *line, GtBlock *block,
                                           GT_UNUSED GtError *err)
{
  GtLineBreakerBases *lbb;
  GtRange r;
  GtIntervalTree *t;
  gt_assert(lb && block && line);
  r = gt_block_get_range(block);
  lbb = gt_line_breaker_bases_cast(lb);
  if (!(t = gt_hashmap_get(lbb->itrees, line)))
    *result = false;
  else
    *result = (gt_interval_tree_find_first_overlapping(t, r.start, r.end));
  return 0; /* gt_line_breaker_bases_is_line_occupied() is sane */
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
cmpq $0x0, 0x50(%rsp)
je 0xb8995
cmpq $0x0, 0x38(%rsp)
je 0xb8995
cmpq $0x0, 0x40(%rsp)
jne 0xb89cd
movq 0xfb63c(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0xa56c0(%rip), %rsi     # 0x15e066
leaq 0xb0502(%rip), %rdx     # 0x168eaf
leaq 0xbc535(%rip), %rcx     # 0x174ee9
leaq 0xbc555(%rip), %r8      # 0x174f10
movl $0x28, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xb89cf
movq 0x38(%rsp), %rdi
callq 0xb0380
movq %rax, (%rsp)
movq %rdx, 0x8(%rsp)
movq (%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
callq 0xb8a60
movq %rax, %rdi
movq 0x50(%rsp), %rsi
callq 0xb88e0
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x40(%rsp), %rsi
callq 0x86470
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
jne 0xb8a34
movq 0x48(%rsp), %rax
movb $0x0, (%rax)
jmp 0xb8a59
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x89c40
cmpq $0x0, %rax
setne %cl
movq 0x48(%rsp), %rax
andb $0x1, %cl
movb %cl, (%rax)
xorl %eax, %eax
addq $0x58, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/annotationsketch/line_breaker_bases.c
// Function: gt_line_breaker_bases_class
const GtLineBreakerClass* gt_line_breaker_bases_class(void)
{
  static const GtLineBreakerClass *lbc = NULL;
  gt_class_alloc_lock_enter();
  if (!lbc)
  {
    lbc = gt_line_breaker_class_new(sizeof (GtLineBreakerBases),
                                    gt_line_breaker_bases_is_line_occupied,
                                    gt_line_breaker_bases_register_block,
                                    gt_line_breaker_bases_delete);
  }
  gt_class_alloc_lock_leave();
  return lbc;
}

// Assembly:
pushq %rax
callq 0x7b730
cmpq $0x0, 0xfdac2(%rip)     # 0x1b6530
jne 0xb8a96
movl $0x18, %edi
leaq -0x11c(%rip), %rsi      # 0xb8960
leaq 0x2d(%rip), %rdx        # 0xb8ab0
leaq 0x136(%rip), %rcx       # 0xb8bc0
callq 0xb8530
movq %rax, 0xfda9a(%rip)     # 0x1b6530
callq 0x7b790
movq 0xfda8e(%rip), %rax     # 0x1b6530
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/annotationsketch/line_breaker_bases.c
// Function: gt_line_breaker_bases_register_block
int gt_line_breaker_bases_register_block(GtLineBreaker *lb,
                                         GtLine *line,
                                         GtBlock *block,
                                         GT_UNUSED GtError *err)
{
  GtLineBreakerBases *lbb;
  GtIntervalTree *t;
  GtIntervalTreeNode *new_node;
  GtRange *rng;
  gt_assert(lb && block && line);
  lbb = gt_line_breaker_bases_cast(lb);
  rng = gt_block_get_range_ptr(block);
  new_node = gt_interval_tree_node_new(rng, rng->start, rng->end);
  if (!(t = gt_hashmap_get(lbb->itrees, line)))
  {
    t = gt_interval_tree_new(NULL);
    gt_hashmap_add(lbb->itrees, line, t);
  }
  gt_interval_tree_insert(t, new_node);
  return 0; /* gt_line_breaker_bases_register_block() is sane */
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
cmpq $0x0, 0x40(%rsp)
je 0xb8ae0
cmpq $0x0, 0x30(%rsp)
je 0xb8ae0
cmpq $0x0, 0x38(%rsp)
jne 0xb8b18
movq 0xfb4f1(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0xa5575(%rip), %rsi     # 0x15e066
leaq 0xb03b7(%rip), %rdx     # 0x168eaf
leaq 0xbc43b(%rip), %rcx     # 0x174f3a
leaq 0xbc40a(%rip), %r8      # 0x174f10
movl $0x3b, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xb8b1a
callq 0xb8a60
movq %rax, %rdi
movq 0x40(%rsp), %rsi
callq 0xb88e0
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rdi
callq 0xb0c30
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rsi
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdx
callq 0x89a50
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x38(%rsp), %rsi
callq 0x86470
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
jne 0xb8ba4
xorl %eax, %eax
movl %eax, %edi
callq 0x89ac0
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x38(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x86510
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x8a190
xorl %eax, %eax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/annotationsketch/line_breaker_bases.c
// Function: gt_line_breaker_bases_new
GtLineBreaker* gt_line_breaker_bases_new()
{
  GtLineBreakerBases *lbb;
  GtLineBreaker *lb;
  lb = gt_line_breaker_create(gt_line_breaker_bases_class());
  lbb = gt_line_breaker_bases_cast(lb);
  lbb->itrees = gt_hashmap_new(GT_HASH_DIRECT, NULL,
                               (GtFree) gt_interval_tree_delete);
  return lb;
}

// Assembly:
subq $0x18, %rsp
callq 0xb8a60
movq %rax, %rdi
callq 0xb85a0
movq %rax, 0x8(%rsp)
callq 0xb8a60
movq %rax, %rdi
movq 0x8(%rsp), %rsi
callq 0xb88e0
movq %rax, 0x10(%rsp)
xorl %edi, %edi
xorl %eax, %eax
movl %eax, %esi
leaq -0x2e76a(%rip), %rdx    # 0x8a4d0
callq 0x86190
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/tre/lib/regerror.c
// Function: tre_regerror
size_t
tre_regerror(int errcode, const regex_t *preg, char *errbuf, size_t errbuf_size)
{
  const char *err;
  size_t err_len;

  /*LINTED*/(void)&preg;
  if (errcode >= 0
      && errcode < (int)(sizeof(tre_error_messages)
			 / sizeof(*tre_error_messages)))
    err = gettext(tre_error_messages[errcode]);
  else
    err = gettext("Unknown error");

  err_len = strlen(err) + 1;
  if (errbuf_size > 0 && errbuf != NULL)
    {
      if (err_len > errbuf_size)
	{
	  strncpy(errbuf, err, errbuf_size - 1);
	  errbuf[errbuf_size - 1] = '\0';
	}
      else
	{
	  strcpy(errbuf, err);
	}
    }
  return err_len;
}

// Assembly:
subq $0x38, %rsp
movl %edi, 0x34(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
cmpl $0x0, 0x34(%rsp)
jl 0xb8d5c
cmpl $0xe, 0x34(%rsp)
jge 0xb8d5c
movslq 0x34(%rsp), %rcx
leaq 0xfbf6f(%rip), %rax     # 0x1b4cc0
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
jmp 0xb8d68
leaq 0xbc1fc(%rip), %rax     # 0x174f5f
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0xb240
addq $0x1, %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x18(%rsp)
jbe 0xb8dd4
cmpq $0x0, 0x20(%rsp)
je 0xb8dd4
movq 0x8(%rsp), %rax
cmpq 0x18(%rsp), %rax
jbe 0xb8dc3
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
subq $0x1, %rdx
callq 0xb2b0
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rcx
subq $0x1, %rcx
movb $0x0, (%rax,%rcx)
jmp 0xb8dd2
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xb5e0
jmp 0xb8dd4
movq 0x8(%rsp), %rax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/tre/lib/tre-compile.c
// Function: tre_version
char *
tre_version(void)
{
  static char str[256];
  char *version;

  if (str[0] == 0)
    {
      (void) tre_config(TRE_CONFIG_VERSION, &version);
      (void) snprintf(str, sizeof(str), "TRE %s (BSD)", version);
    }
  return str;
}

// Assembly:
pushq %rax
movsbl 0xf8c18(%rip), %eax     # 0x1b6540
cmpl $0x0, %eax
jne 0xbd958
movl $0x4, %edi
movq %rsp, %rsi
callq 0xbd970
movq (%rsp), %rcx
leaq 0xf8bfb(%rip), %rdi     # 0x1b6540
movl $0x100, %esi            # imm = 0x100
leaq 0xb787f(%rip), %rdx     # 0x1751d0
movb $0x0, %al
callq 0xb9d0
leaq 0xf8be1(%rip), %rax     # 0x1b6540
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/tre/lib/tre-compile.c
// Function: tre_add_tag_left
static reg_errcode_t
tre_add_tag_left(tre_mem_t mem, tre_ast_node_t *node, int tag_id)
{
  tre_catenation_t *c;

  DPRINT(("add_tag_left: tag %d\n", tag_id));

  c = tre_mem_alloc(mem, sizeof(*c));
  if (c == NULL)
    return REG_ESPACE;
  c->left = tre_ast_new_literal(mem, TAG, tag_id, -1);
  if (c->left == NULL)
    return REG_ESPACE;
  c->right = tre_mem_alloc(mem, sizeof(tre_ast_node_t));
  if (c->right == NULL)
    return REG_ESPACE;

  c->right->obj = node->obj;
  c->right->type = node->type;
  c->right->nullable = -1;
  c->right->submatch_id = -1;
  c->right->firstpos = NULL;
  c->right->lastpos = NULL;
  c->right->num_tags = 0;
  node->obj = c;
  node->type = CATENATION;
  return REG_OK;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
jmp 0xbda44
movq 0x18(%rsp), %rdi
xorl %ecx, %ecx
xorl %eax, %eax
movl %eax, %edx
movl $0x10, %r8d
movl %ecx, %esi
callq 0xc3270
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0xbda74
movl $0xc, 0x24(%rsp)
jmp 0xbdb7b
movq 0x18(%rsp), %rdi
movl 0xc(%rsp), %edx
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0xfc1a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movq (%rsp), %rax
cmpq $0x0, (%rax)
jne 0xbdaad
movl $0xc, 0x24(%rsp)
jmp 0xbdb7b
movq 0x18(%rsp), %rdi
xorl %ecx, %ecx
xorl %eax, %eax
movl %eax, %edx
movl $0x30, %r8d
movl %ecx, %esi
callq 0xc3270
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movq (%rsp), %rax
cmpq $0x0, 0x8(%rax)
jne 0xbdae8
movl $0xc, 0x24(%rsp)
jmp 0xbdb7b
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rcx
movq (%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
movl (%rax), %ecx
movq (%rsp), %rax
movq 0x8(%rax), %rax
movl %ecx, (%rax)
movq (%rsp), %rax
movq 0x8(%rax), %rax
movl $0xffffffff, 0x10(%rax) # imm = 0xFFFFFFFF
movq (%rsp), %rax
movq 0x8(%rax), %rax
movl $0xffffffff, 0x14(%rax) # imm = 0xFFFFFFFF
movq (%rsp), %rax
movq 0x8(%rax), %rax
movq $0x0, 0x20(%rax)
movq (%rsp), %rax
movq 0x8(%rax), %rax
movq $0x0, 0x28(%rax)
movq (%rsp), %rax
movq 0x8(%rax), %rax
movl $0x0, 0x1c(%rax)
movq (%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
movl $0x1, (%rax)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/tre/lib/tre-compile.c
// Function: tre_purge_regset
static void
tre_purge_regset(int *regset, tre_tnfa_t *tnfa, int tag)
{
  int i;

  for (i = 0; regset[i] >= 0; i++)
    {
      int id = regset[i] / 2;
      int start = !(regset[i] % 2);
      DPRINT(("  Using tag %d for %s offset of "
	      "submatch %d\n", tag,
	      start ? "start" : "end", id));
      if (start)
	tnfa->submatch_data[id].so_tag = tag;
      else
	tnfa->submatch_data[id].eo_tag = tag;
    }
  regset[0] = -1;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movl $0x0, -0x18(%rsp)
movq -0x8(%rsp), %rax
movslq -0x18(%rsp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jl 0xbdc4d
movq -0x8(%rsp), %rax
movslq -0x18(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x1c(%rsp)
movq -0x8(%rsp), %rax
movslq -0x18(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x20(%rsp)
jmp 0xbdbfb
cmpl $0x0, -0x20(%rsp)
je 0xbdc1f
movl -0x14(%rsp), %ecx
movq -0x10(%rsp), %rax
movq 0x20(%rax), %rax
movslq -0x1c(%rsp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movl %ecx, (%rax)
jmp 0xbdc3b
movl -0x14(%rsp), %ecx
movq -0x10(%rsp), %rax
movq 0x20(%rax), %rax
movslq -0x1c(%rsp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movl %ecx, 0x4(%rax)
jmp 0xbdc3d
movl -0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rsp)
jmp 0xbdba6
movq -0x8(%rsp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/tre/lib/tre-compile.c
// Function: tre_add_tag_right
static reg_errcode_t
tre_add_tag_right(tre_mem_t mem, tre_ast_node_t *node, int tag_id)
{
  tre_catenation_t *c;

  DPRINT(("tre_add_tag_right: tag %d\n", tag_id));

  c = tre_mem_alloc(mem, sizeof(*c));
  if (c == NULL)
    return REG_ESPACE;
  c->right = tre_ast_new_literal(mem, TAG, tag_id, -1);
  if (c->right == NULL)
    return REG_ESPACE;
  c->left = tre_mem_alloc(mem, sizeof(tre_ast_node_t));
  if (c->left == NULL)
    return REG_ESPACE;

  c->left->obj = node->obj;
  c->left->type = node->type;
  c->left->nullable = -1;
  c->left->submatch_id = -1;
  c->left->firstpos = NULL;
  c->left->lastpos = NULL;
  c->left->num_tags = 0;
  node->obj = c;
  node->type = CATENATION;
  return REG_OK;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
jmp 0xbdc74
movq 0x18(%rsp), %rdi
xorl %ecx, %ecx
xorl %eax, %eax
movl %eax, %edx
movl $0x10, %r8d
movl %ecx, %esi
callq 0xc3270
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0xbdca4
movl $0xc, 0x24(%rsp)
jmp 0xbdda4
movq 0x18(%rsp), %rdi
movl 0xc(%rsp), %edx
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0xfc1a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movq (%rsp), %rax
cmpq $0x0, 0x8(%rax)
jne 0xbdcdf
movl $0xc, 0x24(%rsp)
jmp 0xbdda4
movq 0x18(%rsp), %rdi
xorl %ecx, %ecx
xorl %eax, %eax
movl %eax, %edx
movl $0x30, %r8d
movl %ecx, %esi
callq 0xc3270
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movq (%rsp), %rax
cmpq $0x0, (%rax)
jne 0xbdd18
movl $0xc, 0x24(%rsp)
jmp 0xbdda4
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rcx
movq (%rsp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
movl (%rax), %ecx
movq (%rsp), %rax
movq (%rax), %rax
movl %ecx, (%rax)
movq (%rsp), %rax
movq (%rax), %rax
movl $0xffffffff, 0x10(%rax) # imm = 0xFFFFFFFF
movq (%rsp), %rax
movq (%rax), %rax
movl $0xffffffff, 0x14(%rax) # imm = 0xFFFFFFFF
movq (%rsp), %rax
movq (%rax), %rax
movq $0x0, 0x20(%rax)
movq (%rsp), %rax
movq (%rax), %rax
movq $0x0, 0x28(%rax)
movq (%rsp), %rax
movq (%rax), %rax
movl $0x0, 0x1c(%rax)
movq (%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
movl $0x1, (%rax)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/tre/lib/tre-compile.c
// Function: tre_set_one
static tre_pos_and_tags_t *
tre_set_one(tre_mem_t mem, int position, int code_min, int code_max,
	    tre_ctype_t class, tre_ctype_t *neg_classes, int backref)
{
  tre_pos_and_tags_t *new_set;

  new_set = tre_mem_calloc(mem, sizeof(*new_set) * 2);
  if (new_set == NULL)
    return NULL;

  new_set[0].position = position;
  new_set[0].code_min = code_min;
  new_set[0].code_max = code_max;
  new_set[0].class = class;
  new_set[0].neg_classes = neg_classes;
  new_set[0].backref = backref;
  new_set[1].position = -1;
  new_set[1].code_min = -1;
  new_set[1].code_max = -1;

  return new_set;
}

// Assembly:
subq $0x38, %rsp
movl 0x40(%rsp), %eax
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movl %edx, 0x20(%rsp)
movl %ecx, 0x1c(%rsp)
movq %r8, 0x10(%rsp)
movq %r9, 0x8(%rsp)
movq 0x28(%rsp), %rdi
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %edx
movl $0x1, %ecx
movl $0x80, %r8d
callq 0xc3270
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0xbe444
movq $0x0, 0x30(%rsp)
jmp 0xbe4b3
movl 0x24(%rsp), %ecx
movq (%rsp), %rax
movl %ecx, (%rax)
movl 0x20(%rsp), %ecx
movq (%rsp), %rax
movl %ecx, 0x4(%rax)
movl 0x1c(%rsp), %ecx
movq (%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x10(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x28(%rax)
movl 0x40(%rsp), %ecx
movq (%rsp), %rax
movl %ecx, 0x30(%rax)
movq (%rsp), %rax
movl $0xffffffff, 0x40(%rax) # imm = 0xFFFFFFFF
movq (%rsp), %rax
movl $0xffffffff, 0x44(%rax) # imm = 0xFFFFFFFF
movq (%rsp), %rax
movl $0xffffffff, 0x48(%rax) # imm = 0xFFFFFFFF
movq (%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/tre/lib/tre-compile.c
// Function: tre_set_empty
static tre_pos_and_tags_t *
tre_set_empty(tre_mem_t mem)
{
  tre_pos_and_tags_t *new_set;

  new_set = tre_mem_calloc(mem, sizeof(*new_set));
  if (new_set == NULL)
    return NULL;

  new_set[0].position = -1;
  new_set[0].code_min = -1;
  new_set[0].code_max = -1;

  return new_set;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %edx
movl $0x1, %ecx
movl $0x40, %r8d
callq 0xc3270
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0xbe4fa
movq $0x0, 0x10(%rsp)
jmp 0xbe523
movq (%rsp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movq (%rsp), %rax
movl $0xffffffff, 0x4(%rax)  # imm = 0xFFFFFFFF
movq (%rsp), %rax
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
movq (%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/tre/lib/tre-match-utils.h
// Function: tre_tag_order
inline static int
tre_tag_order(int num_tags, tre_tag_direction_t *tag_directions,
	      int *t1, int *t2)
{
  int i;
  for (i = 0; i < num_tags; i++)
    {
      if (tag_directions[i] == TRE_TAG_MINIMIZE)
	{
	  if (t1[i] < t2[i])
	    return 1;
	  if (t1[i] > t2[i])
	    return 0;
	}
      else
	{
	  if (t1[i] > t2[i])
	    return 1;
	  if (t1[i] < t2[i])
	    return 0;
	}
    }
  /*  assert(0);*/
  return 0;
}

// Assembly:
movl %edi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movl $0x0, -0x24(%rsp)
movl -0x24(%rsp), %eax
cmpl -0x8(%rsp), %eax
jge 0xc15da
movq -0x10(%rsp), %rax
movslq -0x24(%rsp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jne 0xc157a
movq -0x18(%rsp), %rax
movslq -0x24(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x20(%rsp), %rcx
movslq -0x24(%rsp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0xc1552
movl $0x1, -0x4(%rsp)
jmp 0xc15e2
movq -0x18(%rsp), %rax
movslq -0x24(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x20(%rsp), %rcx
movslq -0x24(%rsp), %rdx
cmpl (%rcx,%rdx,4), %eax
jle 0xc1578
movl $0x0, -0x4(%rsp)
jmp 0xc15e2
jmp 0xc15c8
movq -0x18(%rsp), %rax
movslq -0x24(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x20(%rsp), %rcx
movslq -0x24(%rsp), %rdx
cmpl (%rcx,%rdx,4), %eax
jle 0xc15a0
movl $0x1, -0x4(%rsp)
jmp 0xc15e2
movq -0x18(%rsp), %rax
movslq -0x24(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x20(%rsp), %rcx
movslq -0x24(%rsp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0xc15c6
movl $0x0, -0x4(%rsp)
jmp 0xc15e2
jmp 0xc15c8
jmp 0xc15ca
movl -0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rsp)
jmp 0xc150b
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/tre/lib/tre-match-utils.h
// Function: tre_neg_char_classes_match
inline static int
tre_neg_char_classes_match(tre_ctype_t *classes, tre_cint_t wc, int icase)
{
  DPRINT(("neg_char_classes_test: %p, %d, %d\n", classes, wc, icase));
  while (*classes != (tre_ctype_t)0)
    if ((!icase && tre_isctype(wc, *classes))
	|| (icase && (tre_isctype(tre_toupper(wc), *classes)
		      || tre_isctype(tre_tolower(wc), *classes))))
      return 1; /* Match. */
    else
      classes++;
  return 0; /* No match. */
}

// Assembly:
subq $0x28, %rsp
movw %si, %ax
movq %rdi, 0x18(%rsp)
movw %ax, 0x16(%rsp)
movl %edx, 0x10(%rsp)
jmp 0xc1607
jmp 0xc1609
movq 0x18(%rsp), %rax
cmpq $0x0, (%rax)
je 0xc16a5
cmpl $0x0, 0x10(%rsp)
jne 0xc1633
movq 0x18(%rsp), %rax
movq (%rax), %rax
movswl 0x16(%rsp), %edi
callq *%rax
cmpl $0x0, %eax
jne 0xc1688
cmpl $0x0, 0x10(%rsp)
je 0xc1692
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movswl 0x16(%rsp), %edi
callq 0xbbb0
movl %eax, %ecx
movq 0x8(%rsp), %rax
movswl %cx, %edi
callq *%rax
cmpl $0x0, %eax
jne 0xc1688
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
movswl 0x16(%rsp), %edi
callq 0xb8c0
movl %eax, %ecx
movq (%rsp), %rax
movswl %cx, %edi
callq *%rax
cmpl $0x0, %eax
je 0xc1692
movl $0x1, 0x24(%rsp)
jmp 0xc16ad
movq 0x18(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x18(%rsp)
jmp 0xc1609
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/tre/lib/tre-mem.c
// Function: tre_mem_new_impl
tre_mem_t
tre_mem_new_impl(int provided, void *provided_block)
{
  tre_mem_t mem;
  if (provided)
    {
      mem = provided_block;
      memset(mem, 0, sizeof(*mem));
    }
  else
    mem = xcalloc(1, sizeof(*mem));
  if (mem == NULL)
    return NULL;
  return mem;
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x1c(%rsp)
movq %rsi, 0x10(%rsp)
cmpl $0x0, 0x1c(%rsp)
je 0xc31d1
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0xb2d0
jmp 0xc31e5
movl $0x1, %edi
movl $0x30, %esi
callq 0xb3f0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0xc31f8
movq $0x0, 0x20(%rsp)
jmp 0xc3202
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/tre/lib/tre-mem.c
// Function: tre_mem_destroy
void
tre_mem_destroy(tre_mem_t mem)
{
  tre_list_t *tmp, *l = mem->blocks;

  while (l != NULL)
    {
      xfree(l->data);
      tmp = l->next;
      xfree(l);
      l = tmp;
    }
  xfree(mem);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0xc3259
movq (%rsp), %rax
movq (%rax), %rdi
callq 0xb760
movq (%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq (%rsp), %rdi
callq 0xb760
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
jmp 0xc3225
movq 0x10(%rsp), %rdi
callq 0xb760
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/tre/lib/tre-parse.c
// Function: tre_ctype
tre_ctype_t tre_ctype(const char *name)
{
  int i;
  for (i = 0; tre_ctype_map[i].name != NULL; i++)
    {
      if (strcmp(name, tre_ctype_map[i].name) == 0)
	return tre_ctype_map[i].func;
    }
  return (tre_ctype_t)0;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
movslq 0x4(%rsp), %rcx
leaq 0xf15c3(%rip), %rax     # 0x1b4d30
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
je 0xc37cc
movq 0x8(%rsp), %rdi
movslq 0x4(%rsp), %rcx
leaq 0xf15a5(%rip), %rax     # 0x1b4d30
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
callq 0xb850
cmpl $0x0, %eax
jne 0xc37bd
movslq 0x4(%rsp), %rcx
leaq 0xf1585(%rip), %rax     # 0x1b4d30
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0xc37d5
jmp 0xc37bf
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0xc3761
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/tre/lib/tre-parse.c
// Function: tre_expand_macro
static void
tre_expand_macro(const tre_char_t *regex, const tre_char_t *regex_end,
		 tre_char_t *buf, size_t buf_len)
{
  int i;

  buf[0] = 0;
  if (regex >= regex_end)
    return;

  for (i = 0; tre_macros[i].expansion; i++)
    {
      if (tre_macros[i].c == *regex)
	{
	  unsigned int j;
	  DPRINT(("Expanding macro '%c' => '%s'\n",
		  tre_macros[i].c, tre_macros[i].expansion));
	  for (j = 0; tre_macros[i].expansion[j] && j < buf_len; j++)
	    buf[j] = tre_macros[i].expansion[j];
	  buf[j] = 0;
	  break;
	}
    }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movq -0x18(%rsp), %rax
movb $0x0, (%rax)
movq -0x8(%rsp), %rax
cmpq -0x10(%rsp), %rax
jb 0xc6b3d
jmp 0xc6c31
movl $0x0, -0x24(%rsp)
movslq -0x24(%rsp), %rcx
leaq 0xec6df(%rip), %rax     # 0x1b3230
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, 0x8(%rax)
je 0xc6c31
movslq -0x24(%rsp), %rcx
leaq 0xec6c1(%rip), %rax     # 0x1b3230
shlq $0x4, %rcx
addq %rcx, %rax
movsbl (%rax), %eax
movq -0x8(%rsp), %rcx
movzbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0xc6c1f
jmp 0xc6b8b
jmp 0xc6b8d
movl $0x0, -0x28(%rsp)
movslq -0x24(%rsp), %rcx
leaq 0xec68f(%rip), %rax     # 0x1b3230
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movl -0x28(%rsp), %ecx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x29(%rsp)
je 0xc6bcf
movl -0x28(%rsp), %eax
cmpq -0x20(%rsp), %rax
setb %al
movb %al, -0x29(%rsp)
movb -0x29(%rsp), %al
testb $0x1, %al
jne 0xc6bd9
jmp 0xc6c10
movslq -0x24(%rsp), %rcx
leaq 0xec64b(%rip), %rax     # 0x1b3230
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movl -0x28(%rsp), %ecx
movb (%rax,%rcx), %dl
movq -0x18(%rsp), %rax
movl -0x28(%rsp), %ecx
movb %dl, (%rax,%rcx)
movl -0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rsp)
jmp 0xc6b95
movq -0x18(%rsp), %rax
movl -0x28(%rsp), %ecx
movb $0x0, (%rax,%rcx)
jmp 0xc6c31
jmp 0xc6c21
movl -0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rsp)
jmp 0xc6b45
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/tre/lib/tre-parse.c
// Function: tre_parse_int
static int
tre_parse_int(const tre_char_t **regex, const tre_char_t *regex_end)
{
  int num = -1;
  const tre_char_t *r = *regex;
  while (r < regex_end && *r >= L'0' && *r <= L'9')
    {
      if (num < 0)
	num = 0;
      num = num * 10 + *r - L'0';
      r++;
    }
  *regex = r;
  return num;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl $0xffffffff, -0x14(%rsp) # imm = 0xFFFFFFFF
movq -0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rcx
xorl %eax, %eax
cmpq -0x10(%rsp), %rcx
movb %al, -0x21(%rsp)
jae 0xc6c96
movq -0x20(%rsp), %rax
movzbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x30, %ecx
movb %al, -0x21(%rsp)
jl 0xc6c96
movq -0x20(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x39, %eax
setle %al
movb %al, -0x21(%rsp)
movb -0x21(%rsp), %al
testb $0x1, %al
jne 0xc6ca0
jmp 0xc6cd5
cmpl $0x0, -0x14(%rsp)
jge 0xc6caf
movl $0x0, -0x14(%rsp)
imull $0xa, -0x14(%rsp), %eax
movq -0x20(%rsp), %rcx
movzbl (%rcx), %ecx
addl %ecx, %eax
subl $0x30, %eax
movl %eax, -0x14(%rsp)
movq -0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rsp)
jmp 0xc6c5f
movq -0x20(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, (%rax)
movl -0x14(%rsp), %eax
retq
nopw (%rax,%rax)