// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/mgth/mg_compute_gene_prediction.c
// Function: genemergeprocessing
static void genemergeprocessing(ParseStruct *parsestruct_ptr,
                                RegionStruct **regionmatrix, GtError * err)
{
  unsigned short row_index;
  short check_bp;
  GtUword array_idx,
    arraysize,
    from_tmp,
    to_tmp,
    from_tmp_next,
    to_tmp_real,
    function_stop = 0;
  GtArray *tmp_from;
  GtArray *tmp_to;

  gt_error_check(err);

  tmp_from = gt_array_new(sizeof (GtUword));
  tmp_to = gt_array_new(sizeof (GtUword));

  /* Frames werden nacheinander abgearbeitet - zeilenkodiert */
  for (row_index = 0; row_index < 7; row_index++)
  {
    /* bestimmen der Anzahl kodierender Bereiche im aktuell betrachteten
       Frame */
    arraysize = gt_array_size(regionmatrix[row_index][0].from);

    gt_array_reset(tmp_from);
    gt_array_reset(tmp_to);

    if (arraysize > 1)
    {
      /* die kodierenden Bereiche werden nacheinander abgearbeitet */
      for (array_idx = 0; array_idx < arraysize - 1;)
      {
        /* ist gt_array_size des tmp-Arrays > 0 wurden bereits Aenderungen
           vorgenommen und die neuen Bereichsgrenzen-Werte muessen
           verwendet werden */
        if (gt_array_size(tmp_from) > 0)
        {
          from_tmp = *(GtUword *) gt_array_get_last(tmp_from);
          to_tmp = *(GtUword *) gt_array_get_last(tmp_to);
        }
        /* ansonsten auslesen der Bereichsgrenzen aus dem "original" */
        else
        {
          from_tmp =
            *(GtUword *) gt_array_get(regionmatrix[row_index][0].from,
                                            array_idx);
          to_tmp =
            *(GtUword *) gt_array_get(regionmatrix[row_index][0].to,
                                            array_idx);
        }

        ++array_idx;
        function_stop = 0;

        do
        {
          /* auslesen der Grenzen des nachfolgenden kodierenden Bereiches */
          from_tmp_next =
            *(GtUword *) gt_array_get(regionmatrix[row_index][0].from,
                                            array_idx);
          to_tmp_real =
            *(GtUword *) gt_array_get(regionmatrix[row_index][0].to,
                                            array_idx);

          /* zusammenlegen kodierender Bereiche nur, wenn diese innerhalb
             der per GtOption angegebenen Spanbreite liegen */
          if (to_tmp + ARGUMENTSSTRUCT(prediction_span) > from_tmp_next)
          {
            /* es wurden noch keine Eintragungen vorgenommen - der erste
               kodierende Abschnitt wird in das tmp-Array eingetragen */
            if (gt_array_size(tmp_from) == 0)
            {
              gt_array_add(tmp_from, from_tmp);
              gt_array_add(tmp_to, to_tmp);
            }

            /* Ueberpruefen, ob zwischen den kodierenden Abschnitten
               Stop-Codons liegen */
            check_bp = check_coding(parsestruct_ptr,
                                    to_tmp, from_tmp_next, row_index, err);

            /* kein Stop-Codon gefunden */
            if (!check_bp)
            {
              /* befindet sich schon ein Eintrag im temp-Array, muss der
                 letzte Eintrag wieder entfernt werden */
              if (gt_array_size(tmp_from) > 0)
              {
                (void) gt_array_pop(tmp_from);
                (void) gt_array_pop(tmp_to);
              }
              /* Speichern der neuen Bereichsgrenzen */
              gt_array_add(tmp_from, from_tmp);
              gt_array_add(tmp_to, to_tmp_real);

              ++array_idx;
            }
            /* Stop-Codon gefunden - der next-Abschnitt wird ebenfalls in
               das tmp-Array eingetragen; die Bearbeitung kann hier
               abgebrochen werden, da das Stop-Codon auch im Vergleich zu
               den anderen Abschnitten eine Vereinigung verhindert */
            else
            {
              gt_array_add(tmp_from, from_tmp_next);
              gt_array_add(tmp_to, to_tmp_real);

              function_stop = 1;
            }
          }
          /* Abstand der kodierenden Bereiche > als angegebene
             Spannbreite, auch hier kann die Bearbeitung beendet werden */
          else
          {
            gt_array_add(tmp_from, from_tmp_next);
            gt_array_add(tmp_to, to_tmp_real);

            function_stop = 1;
          }
          /* Bearbeitung solange, bis keine weiteren Abschnitte vorliegen
             oder das Stop-Flag gesetzt ist */
        } while (array_idx < arraysize && !function_stop);
      }

      /* aktualisieren der Bereichsgrenzen */
      gt_array_delete(regionmatrix[row_index][0].from);
      gt_array_delete(regionmatrix[row_index][0].to);
      regionmatrix[row_index][0].from = gt_array_clone(tmp_from);
      regionmatrix[row_index][0].to = gt_array_clone(tmp_to);
    }
  }
  gt_array_delete(tmp_from);
  gt_array_delete(tmp_to);
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq $0x0, 0x20(%rsp)
cmpq $0x0, 0x60(%rsp)
je 0x4ed44c
movq 0x60(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x4ed414
jmp 0x4ed44c
movq 0x14eb85(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x28bee(%rip), %rsi     # 0x516013
leaq 0x28d93(%rip), %rdx     # 0x5161bf
leaq 0xceadf(%rip), %rcx     # 0x5bbf12
leaq 0xcea80(%rip), %r8      # 0x5bbeba
movl $0x2c9, %r9d            # imm = 0x2C9
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4ed44e
movl $0x8, %edi
callq 0x80990
movq %rax, 0x18(%rsp)
movl $0x8, %edi
callq 0x80990
movq %rax, 0x10(%rsp)
movw $0x0, 0x5e(%rsp)
movzwl 0x5e(%rsp), %eax
cmpl $0x7, %eax
jge 0x4ed7ec
movq 0x68(%rsp), %rax
movzwl 0x5e(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq (%rax), %rdi
callq 0x81370
movq %rax, 0x48(%rsp)
movq 0x18(%rsp), %rdi
callq 0x814a0
movq 0x10(%rsp), %rdi
callq 0x814a0
cmpq $0x1, 0x48(%rsp)
jbe 0x4ed7d7
movq $0x0, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq 0x48(%rsp), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x4ed76d
movq 0x18(%rsp), %rdi
callq 0x81370
cmpq $0x0, %rax
jbe 0x4ed512
movq 0x18(%rsp), %rdi
callq 0x80c00
movq (%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x10(%rsp), %rdi
callq 0x80c00
movq (%rax), %rax
movq %rax, 0x38(%rsp)
jmp 0x4ed559
movq 0x68(%rsp), %rax
movzwl 0x5e(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq (%rax), %rdi
movq 0x50(%rsp), %rsi
callq 0x80b60
movq (%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x68(%rsp), %rax
movzwl 0x5e(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rdi
movq 0x50(%rsp), %rsi
callq 0x80b60
movq (%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x50(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x50(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x68(%rsp), %rax
movzwl 0x5e(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq (%rax), %rdi
movq 0x50(%rsp), %rsi
callq 0x80b60
movq (%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x68(%rsp), %rax
movzwl 0x5e(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rdi
movq 0x50(%rsp), %rsi
callq 0x80b60
movq (%rax), %rax
movq %rax, 0x28(%rsp)
movaps 0x2b372(%rip), %xmm3    # 0x518930
movq 0x38(%rsp), %xmm0
punpckldq %xmm3, %xmm0    # xmm0 = xmm0[0],xmm3[0],xmm0[1],xmm3[1]
movapd 0x2b370(%rip), %xmm2    # 0x518940
subpd %xmm2, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movq 0x70(%rsp), %rax
movsd 0x1b0(%rax), %xmm1
addsd %xmm1, %xmm0
movq 0x30(%rsp), %xmm1
punpckldq %xmm3, %xmm1    # xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1]
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x4ed708
movq 0x18(%rsp), %rdi
callq 0x81370
cmpq $0x0, %rax
jne 0x4ed64b
movq 0x18(%rsp), %rdi
leaq 0x40(%rsp), %rsi
movl $0x8, %edx
callq 0x81100
movq 0x10(%rsp), %rdi
leaq 0x38(%rsp), %rsi
movl $0x8, %edx
callq 0x81100
movq 0x70(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
movw 0x5e(%rsp), %ax
movq 0x60(%rsp), %r8
movswl %ax, %ecx
callq 0x4ed8f0
movw %ax, 0x5c(%rsp)
cmpw $0x0, 0x5c(%rsp)
jne 0x4ed6d5
movq 0x18(%rsp), %rdi
callq 0x81370
cmpq $0x0, %rax
jbe 0x4ed69d
movq 0x18(%rsp), %rdi
callq 0x80c70
movq 0x10(%rsp), %rdi
callq 0x80c70
movq 0x18(%rsp), %rdi
leaq 0x40(%rsp), %rsi
movl $0x8, %edx
callq 0x81100
movq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rsi
movl $0x8, %edx
callq 0x81100
movq 0x50(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x50(%rsp)
jmp 0x4ed706
movq 0x18(%rsp), %rdi
leaq 0x30(%rsp), %rsi
movl $0x8, %edx
callq 0x81100
movq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rsi
movl $0x8, %edx
callq 0x81100
movq $0x1, 0x20(%rsp)
jmp 0x4ed739
movq 0x18(%rsp), %rdi
leaq 0x30(%rsp), %rsi
movl $0x8, %edx
callq 0x81100
movq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rsi
movl $0x8, %edx
callq 0x81100
movq $0x1, 0x20(%rsp)
jmp 0x4ed73b
movq 0x50(%rsp), %rcx
xorl %eax, %eax
cmpq 0x48(%rsp), %rcx
movb %al, 0xf(%rsp)
jae 0x4ed75c
cmpq $0x0, 0x20(%rsp)
setne %al
xorb $-0x1, %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x4ed570
jmp 0x4ed4c5
movq 0x68(%rsp), %rax
movzwl 0x5e(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq (%rax), %rdi
callq 0x81f80
movq 0x68(%rsp), %rax
movzwl 0x5e(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rdi
callq 0x81f80
movq 0x18(%rsp), %rdi
callq 0x80a20
movq %rax, %rcx
movq 0x68(%rsp), %rax
movzwl 0x5e(%rsp), %edx
movq (%rax,%rdx,8), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rdi
callq 0x80a20
movq %rax, %rcx
movq 0x68(%rsp), %rax
movzwl 0x5e(%rsp), %edx
movq (%rax,%rdx,8), %rax
movq %rcx, 0x8(%rax)
jmp 0x4ed7d9
movw 0x5e(%rsp), %ax
addw $0x1, %ax
movw %ax, 0x5e(%rsp)
jmp 0x4ed473
movq 0x18(%rsp), %rdi
callq 0x81f80
movq 0x10(%rsp), %rdi
callq 0x81f80
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)