// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/mgth/mg_computepath.c
// Function: mg_computepath
int mg_computepath(CombinedScoreMatrixEntry **combinedscore_matrix,
                   HitInformation *hit_information,
                   GtUword rows,
                   GtUword contig_len,
                   ParseStruct *parsestruct_ptr, GtError * err)
{
  int had_err = 0;

  /* Initialisieren der Matrix fuer die Pfadberechnung */
  PathMatrixEntry **path_matrix;

  /* i: Zaehlvariable fuer die Matrix-Zeilen; k: Zaehlvariable Precursors
     (von 0 bis max 2) maxpath_frame: Speichern des vorherigen Frames von
     dem der max-Wert berechnet wird */
  unsigned short row_index = 0,
    precursor_index = 0,
    precursors_row = 0,
    maxpath_frame = 0;

  /* Position in der Query-DNA */
  GtUword column_index = 0;

  /* Variablen fuer den aktuellen Frame, den vorherigen Frame(speichert
     einen Wert aus precursors[], die Zeile des vorherigen Frames, GtArray
     mit den Precursors-Frames */
  short current_frame = 0,
    precursors_frame = 0,
    precursors[NUM_PRECURSORS];

  /* q ist der Wert, der bei Aus- oder Eintreten in ein Gen auf dem
     Forward- bzw. Reverse-Strang berechnet wird */
  double q = ARGUMENTSSTRUCT(leavegene_value),
    max_new = 1,
    max_old = 1;

  /* Speicherreservierung fuer die Path-Matrix - Groesse entsprechend der
     CombinedScore-Matrix */
  gt_array2dim_calloc(path_matrix, 7, contig_len);

  gt_error_check(err);

  /* fuer die erste Spalte der Path-Matrix wird die erste Spalte der
     CombinedScore-Matrix uebernommen */
  for (row_index = 0; row_index < rows; row_index++)
  {
    path_matrix[row_index][0].score =
      combinedscore_matrix[row_index][0].matrix_score;
    path_matrix[row_index][0].path_frame = row_index;
  }

  /* Spaltenweise Berechnung des opt. Pfades */
  for (column_index = 1; column_index < contig_len; column_index++)
  {
    for (row_index = 0; row_index < rows; row_index++)
    {
      /* Zaehlvariable fuer die Zeile wird umgerechnet in den entsprechenden
         Leserahmen */
      current_frame = get_current_frame(row_index);
      /* Aufruf der Methode zum Berechnen der moeglichen Leserahmen anhand von
         aktuellem Leserahmen und der Query-DNA-Sequenz */
      compute_precursors(current_frame,
                         column_index,
                         precursors);

      /* der max-Wert der moeglichen Vorgaenger wird berechnet */
      for (precursor_index = 0;
           precursor_index < NUM_PRECURSORS
             && (precursors[precursor_index] != UNDEFINED);
           ++precursor_index)
      {
        /* aktueller Vorgaengerleserahmen - es gibt max. 3 moegliche
           Vorgaenger */
        precursors_frame = precursors[precursor_index];
        /* Vorgaengerleserahmen wird umgerechnet in die entsprechende
           Matrix-Zeile */
        precursors_row = get_matrix_row(precursors_frame);

        /* der DP-Algo umfasst 3 moegliche Faelle
           1. Fall: Wechsel vom Reversen- auf den Forward-Strang bzw.
           umgekehrt */
        if ((current_frame < 0 && precursors_frame > 0) ||
            (current_frame > 0 && precursors_frame < 0))
        {
            max_new = path_matrix[precursors_row][column_index-1].score +
                      combinedscore_matrix[row_index][column_index].matrix_score
                      + 2*q;
        }
        /* 2. Fall: Einfacher Wechsel des Leserahmens, also von + zu +
           bzw.- zu - */
        else if (current_frame != 0 && precursors_frame != current_frame)
        {
            max_new = path_matrix[precursors_row][column_index-1].score +
                      combinedscore_matrix[row_index][column_index].matrix_score
                      + q;
        }
        /* 3. Fall: Leserahmen wird beibehalten bzw. Wechsel von kodierend zu
           nicht-kodierend oder umgekehrt */
        else
        {
            max_new = path_matrix[precursors_row][column_index-1].score +
                      combinedscore_matrix[row_index][column_index]
                      .matrix_score;
        }

        /* Bestimmen des Max-Wertes der max. 3 Moeglichkeiten und Speichern der
           Zeile, von der der Max-Wert stammt */
        if (gt_double_compare(max_new, max_old) > 0)
        {
            max_old = max_new;
            maxpath_frame = precursors_row;
        }
      }

      /* Speichern des Max-Wertes und der "Vorgaenger"-Zeile;
         zuruecksetzen der Variablen */
      path_matrix[row_index][column_index].score      = max_old;
      path_matrix[row_index][column_index].path_frame = maxpath_frame;

      max_new = DBL_MIN;
      max_old = DBL_MIN;
      maxpath_frame = 0;
    }
  }

  /* Aufruf der Methode zur Genvorhersage */
  had_err = mg_compute_gene_prediction(combinedscore_matrix,
                                       path_matrix,
                                       contig_len,
                                       hit_information,
                                       parsestruct_ptr, err);

  gt_array2dim_delete(path_matrix);

  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %r9, 0x20(%rsp)
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, 0x60(%rsp)
movq %rdi, 0x30(%rsp)
movq %r8, 0x68(%rsp)
movsd 0x1b8(%r8), %xmm0
movsd %xmm0, 0x50(%rsp)
leaq 0xb720f(%rip), %rbx     # 0x3e6284
movl $0x38, %edi
movq %rbx, %rsi
movl $0x44, %edx
callq 0x104226
movq %rax, %r12
leaq (,%r14,8), %rdi
subq %r14, %rdi
movl $0x10, %esi
movq %rbx, %rdx
movl $0x44, %ecx
callq 0x10436a
movq %rax, (%r12)
movq %r14, 0x28(%rsp)
shlq $0x4, %r14
addq %r14, %rax
movl $0x1, %edx
movq %rax, (%r12,%rdx,8)
incq %rdx
addq %r14, %rax
cmpq $0x7, %rdx
jne 0x32f0bc
cmpq $0x0, 0x20(%rsp)
je 0x32f0e6
movq 0x20(%rsp), %rdi
callq 0xfcc32
testb %al, %al
jne 0x32f3bc
testq %r15, %r15
movq 0x30(%rsp), %rbx
je 0x32f111
xorl %eax, %eax
movq (%rbx,%rax,8), %rcx
movsd (%rcx), %xmm0
movq (%r12,%rax,8), %rcx
movsd %xmm0, (%rcx)
movw %ax, 0x8(%rcx)
incq %rax
movzwl %ax, %ecx
cmpq %r15, %rcx
jb 0x32f0f2
cmpq $0x2, 0x28(%rsp)
jb 0x32f35f
movl $0x1, %ecx
movsd 0x170fe(%rip), %xmm1    # 0x346228
movsd 0x50(%rsp), %xmm0
addsd %xmm0, %xmm0
movsd %xmm0, 0x88(%rsp)
movq %r15, 0x80(%rsp)
testq %r15, %r15
je 0x32f351
movq %rcx, %rax
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
mulq %rdx
shrl %edx
leal (%rdx,%rdx,2), %eax
movl %ecx, %edx
subl %eax, %edx
leal 0x1(%rdx), %eax
movl %eax, 0x18(%rsp)
notl %edx
movq %rdx, 0x78(%rsp)
xorl %r14d, %r14d
movq %rcx, %rax
shlq $0x4, %rax
movq %rax, 0x38(%rsp)
movq %rcx, 0x70(%rsp)
leaq (%rcx,%rcx,2), %rax
movq %rax, 0x58(%rsp)
xorl %eax, %eax
movl %eax, 0x44(%rsp)
movsd %xmm1, 0x8(%rsp)
movq %r14, %rdi
callq 0x32d655
movl %eax, %edx
testw %ax, %ax
je 0x32f1ca
movl %edx, %eax
negw %ax
cmovsw %dx, %ax
cmpw 0x18(%rsp), %ax
jne 0x32f1dc
movl %edx, %eax
negl %eax
movw %dx, 0x12(%rsp)
xorl %ecx, %ecx
jmp 0x32f1e9
movl 0x18(%rsp), %eax
movw %ax, 0x12(%rsp)
xorl %ecx, %ecx
movq 0x78(%rsp), %rax
jmp 0x32f1e9
movw %dx, 0x12(%rsp)
movw $0x9, %cx
movw $0x9, %ax
movsd 0x8(%rsp), %xmm0
movw %cx, 0x14(%rsp)
movw %ax, 0x16(%rsp)
xorl %ebp, %ebp
xorl %esi, %esi
movl %edx, 0x1c(%rsp)
movswq 0x12(%rsp,%rbp,2), %r13
cmpq $0x9, %r13
je 0x32f30a
movl %esi, 0x4c(%rsp)
movq %r14, %r15
movsd %xmm0, 0x8(%rsp)
movq %r12, %r14
testw %dx, %dx
setg %bl
sets %r12b
movq %r13, %rdi
callq 0x32d63d
testw %r13w, %r13w
setg %dl
sets %cl
movl %eax, 0x48(%rsp)
movzwl %ax, %eax
testb %dl, %r12b
jne 0x32f292
andb %cl, %bl
jne 0x32f292
movq %r14, %r12
movq (%r14,%rax,8), %rax
movq 0x38(%rsp), %rcx
movsd -0x10(%rax,%rcx), %xmm0
movq 0x30(%rsp), %rbx
movq %r15, %r14
movq (%rbx,%r15,8), %rax
movq 0x58(%rsp), %rcx
addsd (%rax,%rcx,8), %xmm0
movl 0x1c(%rsp), %eax
testw %ax, %ax
je 0x32f2c3
cmpw %ax, %r13w
movsd 0x8(%rsp), %xmm1
je 0x32f2c9
addsd 0x50(%rsp), %xmm0
jmp 0x32f2c9
movq %r14, %r12
movq (%r14,%rax,8), %rax
movq 0x38(%rsp), %rcx
movsd -0x10(%rax,%rcx), %xmm0
movq 0x30(%rsp), %rbx
movq %r15, %r14
movq (%rbx,%r15,8), %rax
movq 0x58(%rsp), %rcx
addsd (%rax,%rcx,8), %xmm0
addsd 0x88(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movsd %xmm0, 0x90(%rsp)
callq 0x105c1c
movsd 0x90(%rsp), %xmm1
testl %eax, %eax
movl 0x4c(%rsp), %esi
cmovgl 0x48(%rsp), %esi
jg 0x32f2f3
movsd 0x8(%rsp), %xmm1
incq %rbp
movapd %xmm1, %xmm0
cmpq $0x3, %rbp
movl 0x1c(%rsp), %edx
jne 0x32f201
jmp 0x32f30e
movapd %xmm0, %xmm1
movq (%r12,%r14,8), %rax
movq 0x38(%rsp), %rcx
movsd %xmm1, (%rax,%rcx)
movw %si, 0x8(%rax,%rcx)
movl 0x44(%rsp), %eax
incl %eax
movzwl %ax, %r14d
movsd 0x1de8d(%rip), %xmm1    # 0x34d1c0
movq 0x80(%rsp), %r15
cmpq %r15, %r14
jb 0x32f194
movsd 0x1de74(%rip), %xmm1    # 0x34d1c0
movq 0x70(%rsp), %rcx
incq %rcx
cmpq 0x28(%rsp), %rcx
jne 0x32f145
movq %rbx, %rdi
movq %r12, %rsi
movq 0x28(%rsp), %rdx
movq 0x60(%rsp), %rcx
movq 0x68(%rsp), %r8
movq 0x20(%rsp), %r9
callq 0x32d750
movl %eax, %ebx
movq (%r12), %rdi
leaq 0xb6ef9(%rip), %r15     # 0x3e6284
movq %r15, %rsi
movl $0xa2, %edx
callq 0x1045eb
movq %r12, %rdi
movq %r15, %rsi
movl $0xa2, %edx
callq 0x1045eb
movl %ebx, %eax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x95ead
nopl (%rax)