// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq %rcx, 0x68(%rsp)
movq %r8, 0x60(%rsp)
movq %r9, 0x58(%rsp)
movl $0x0, 0x54(%rsp)
movw $0x0, 0x46(%rsp)
movw $0x0, 0x44(%rsp)
movw $0x0, 0x42(%rsp)
movw $0x0, 0x40(%rsp)
movq $0x0, 0x38(%rsp)
movw $0x0, 0x36(%rsp)
movw $0x0, 0x34(%rsp)
movq 0x60(%rsp), %rax
movsd 0x1b8(%rax), %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x28c52(%rip), %xmm0    # 0x517240
movsd %xmm0, 0x18(%rsp)
movsd 0x28c44(%rip), %xmm0    # 0x517240
movsd %xmm0, 0x10(%rsp)
movl $0x38, %edi
leaq 0xcd918(%rip), %rsi     # 0x5bbf26
movl $0x44, %edx
callq 0xe80f0
movq %rax, 0x48(%rsp)
imulq $0x7, 0x68(%rsp), %rdi
movl $0x10, %esi
leaq 0xcd8f7(%rip), %rdx     # 0x5bbf26
movl $0x44, %ecx
callq 0xe83c0
movq %rax, %rcx
movq 0x48(%rsp), %rax
movq %rcx, (%rax)
movq $0x1, 0x8(%rsp)
cmpq $0x7, 0x8(%rsp)
jae 0x4ee691
movq 0x48(%rsp), %rax
movq 0x8(%rsp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rdx
movq 0x68(%rsp), %rax
shlq $0x4, %rax
addq %rax, %rdx
movq 0x48(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x4ee64d
jmp 0x4ee693
cmpq $0x0, 0x58(%rsp)
je 0x4ee6e3
movq 0x58(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x4ee6ab
jmp 0x4ee6e3
movq 0x14d8ee(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x27957(%rip), %rsi     # 0x516013
leaq 0x27afc(%rip), %rdx     # 0x5161bf
leaq 0xcd876(%rip), %rcx     # 0x5bbf40
leaq 0xcd855(%rip), %r8      # 0x5bbf26
movl $0x46, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4ee6e5
movw $0x0, 0x46(%rsp)
movzwl 0x46(%rsp), %eax
cmpq 0x70(%rsp), %rax
jae 0x4ee746
movq 0x80(%rsp), %rax
movzwl 0x46(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movsd (%rax), %xmm0
movq 0x48(%rsp), %rax
movzwl 0x46(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movsd %xmm0, (%rax)
movw 0x46(%rsp), %cx
movq 0x48(%rsp), %rax
movzwl 0x46(%rsp), %edx
movq (%rax,%rdx,8), %rax
movw %cx, 0x8(%rax)
movw 0x46(%rsp), %ax
addw $0x1, %ax
movw %ax, 0x46(%rsp)
jmp 0x4ee6ec
movq $0x1, 0x38(%rsp)
movq 0x38(%rsp), %rax
cmpq 0x68(%rsp), %rax
jae 0x4ee9f7
movw $0x0, 0x46(%rsp)
movzwl 0x46(%rsp), %eax
cmpq 0x70(%rsp), %rax
jae 0x4ee9e2
movzwl 0x46(%rsp), %eax
movl %eax, %edi
callq 0x4eb870
movw %ax, 0x36(%rsp)
movw 0x36(%rsp), %ax
movq 0x38(%rsp), %rsi
leaq 0x2e(%rsp), %rdx
movswl %ax, %edi
callq 0x4eea60
movw $0x0, 0x44(%rsp)
movzwl 0x44(%rsp), %ecx
xorl %eax, %eax
cmpl $0x3, %ecx
movb %al, 0x7(%rsp)
jge 0x4ee7c9
movzwl 0x44(%rsp), %eax
movswl 0x2e(%rsp,%rax,2), %eax
cmpl $0x9, %eax
setne %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x4ee7d6
jmp 0x4ee965
movzwl 0x44(%rsp), %eax
movw 0x2e(%rsp,%rax,2), %ax
movw %ax, 0x34(%rsp)
movswq 0x34(%rsp), %rdi
callq 0x4eae90
movw %ax, 0x42(%rsp)
movswl 0x36(%rsp), %eax
cmpl $0x0, %eax
jge 0x4ee809
movswl 0x34(%rsp), %eax
cmpl $0x0, %eax
jg 0x4ee81d
movswl 0x36(%rsp), %eax
cmpl $0x0, %eax
jle 0x4ee876
movswl 0x34(%rsp), %eax
cmpl $0x0, %eax
jge 0x4ee876
movq 0x48(%rsp), %rax
movzwl 0x42(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq 0x38(%rsp), %rcx
subq $0x1, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movsd (%rax), %xmm1
movq 0x80(%rsp), %rax
movzwl 0x46(%rsp), %ecx
movq (%rax,%rcx,8), %rax
imulq $0x18, 0x38(%rsp), %rcx
addq %rcx, %rax
addsd (%rax), %xmm1
movsd 0x20(%rsp), %xmm0
addsd %xmm0, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
jmp 0x4ee924
movswl 0x36(%rsp), %eax
cmpl $0x0, %eax
je 0x4ee8dc
movswl 0x34(%rsp), %eax
movswl 0x36(%rsp), %ecx
cmpl %ecx, %eax
je 0x4ee8dc
movq 0x48(%rsp), %rax
movzwl 0x42(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq 0x38(%rsp), %rcx
subq $0x1, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movsd (%rax), %xmm0
movq 0x80(%rsp), %rax
movzwl 0x46(%rsp), %ecx
movq (%rax,%rcx,8), %rax
imulq $0x18, 0x38(%rsp), %rcx
addq %rcx, %rax
addsd (%rax), %xmm0
addsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
jmp 0x4ee922
movq 0x48(%rsp), %rax
movzwl 0x42(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq 0x38(%rsp), %rcx
subq $0x1, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movsd (%rax), %xmm0
movq 0x80(%rsp), %rax
movzwl 0x46(%rsp), %ecx
movq (%rax,%rcx,8), %rax
imulq $0x18, 0x38(%rsp), %rcx
addq %rcx, %rax
addsd (%rax), %xmm0
movsd %xmm0, 0x18(%rsp)
jmp 0x4ee924
movsd 0x18(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
callq 0xec290
cmpl $0x0, %eax
jle 0x4ee950
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movw 0x42(%rsp), %ax
movw %ax, 0x40(%rsp)
jmp 0x4ee952
movw 0x44(%rsp), %ax
addw $0x1, %ax
movw %ax, 0x44(%rsp)
jmp 0x4ee7a5
movsd 0x10(%rsp), %xmm0
movq 0x48(%rsp), %rax
movzwl 0x46(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq 0x38(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movsd %xmm0, (%rax)
movw 0x40(%rsp), %cx
movq 0x48(%rsp), %rax
movzwl 0x46(%rsp), %edx
movq (%rax,%rdx,8), %rax
movq 0x38(%rsp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movw %cx, 0x8(%rax)
movsd 0x2f894(%rip), %xmm0    # 0x51e248
movsd %xmm0, 0x18(%rsp)
movsd 0x2f886(%rip), %xmm0    # 0x51e248
movsd %xmm0, 0x10(%rsp)
movw $0x0, 0x40(%rsp)
movw 0x46(%rsp), %ax
addw $0x1, %ax
movw %ax, 0x46(%rsp)
jmp 0x4ee766
jmp 0x4ee9e4
movq 0x38(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x38(%rsp)
jmp 0x4ee74f
movq 0x80(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x68(%rsp), %rdx
movq 0x78(%rsp), %rcx
movq 0x60(%rsp), %r8
movq 0x58(%rsp), %r9
callq 0x4eba70
movl %eax, 0x54(%rsp)
movq 0x48(%rsp), %rax
movq (%rax), %rdi
leaq 0xcd4f6(%rip), %rsi     # 0x5bbf26
movl $0xa2, %edx
callq 0xe88c0
movq 0x48(%rsp), %rdi
leaq 0xcd4e0(%rip), %rsi     # 0x5bbf26
movl $0xa2, %edx
callq 0xe88c0
movl 0x54(%rsp), %eax
addq $0x88, %rsp
retq
nopl (%rax)