changed 
void get_gauss_param_all_classes2(char sc_filenames[MAX_CLASS_NUMBER][MAXLINE],
      int number_score_dim, double means[MAX_CLASS_NUMBER][MAX_NUM_SCORE_DIM],
      double covars[MAX_CLASS_NUMBER][MAX_NUM_SCORE_DIM][MAX_NUM_SCORE_DIM],
      int number_of_classifications, char gauss_param[MAXLINE])
to
void get_gauss_param_all_classes2(char sc_filenames[MAX_CLASS_NUMBER][MAXLINE],
      int number_score_dim, double means[MAX_CLASS_NUMBER][MAX_NUM_SCORE_DIM],
      double covars[MAX_CLASS_NUMBER][MAX_NUM_SCORE_DIM][MAX_NUM_SCORE_DIM],
     char gauss_param[MAXLINE])

by changing

    for (class=0; class<number_of_classifications; class++) {

to
    for (class=0; class<NUMBER_CLASSES; class++) {




changed
void compute_submatrices2(
	double means[MAX_CLASS_NUMBER][MAX_NUM_SCORE_DIM],
	double means_submatrix[MAX_CLASS_NUMBER][MAX_NUM_SCORE_DIM],
        double covars[MAX_CLASS_NUMBER][MAX_NUM_SCORE_DIM][MAX_NUM_SCORE_DIM],
        int number_classes, 
        double inv[MAX_CLASS_NUMBER][MAX_NUM_SCORE_DIM][MAX_NUM_SCORE_DIM],
        double det[MAX_CLASS_NUMBER],
	char multi_lib[MAX_TABLE_NUMBER][MAXFUNCTNUM],
	int old_num_dim_table0, int old_num_dim_table1,
	int new_num_dim_table0, int new_num_dim_table1, int multi_trimer_pairs
        )
to
void compute_submatrices2(
	double means[MAX_CLASS_NUMBER][MAX_NUM_SCORE_DIM],
	double means_submatrix[MAX_CLASS_NUMBER][MAX_NUM_SCORE_DIM],
        double covars[MAX_CLASS_NUMBER][MAX_NUM_SCORE_DIM][MAX_NUM_SCORE_DIM],
        double inv[MAX_CLASS_NUMBER][MAX_NUM_SCORE_DIM][MAX_NUM_SCORE_DIM],
        double det[MAX_CLASS_NUMBER],
	char multi_lib[MAX_TABLE_NUMBER][MAXFUNCTNUM],
	int old_num_dim_table0, int old_num_dim_table1,
	int new_num_dim_table0, int new_num_dim_table1
        )
changed
  for (class=0; class<number_classes; class++) 
to
  for (class=0; class<NUMBER_CLASSES; class++) 

everywhere changed
      means_submatrix[class][dim1] = means[class]
	    [old_dimension(old_num_dim_table0, old_num_dim_table1,
	                   new_num_dim_table0, new_num_dim_table1,
		           multi_lib, multi_trimer_pairs,dim1)];
to
      means_submatrix[class][dim1] = means[class]
	    [old_dimension(old_num_dim_table0, old_num_dim_table1,
	                   new_num_dim_table0, new_num_dim_table1,
		           multi_lib, dim1)]; 



changed
int old_dimension(int old_num_dim_table0, int old_num_dim_table1,
		  int new_num_dim_table0, int new_num_dim_table1,
		  char multi_lib[MAX_TABLE_NUMBER][MAXFUNCTNUM], 
		  int multi_trimer_pairs,
		  int new_dim_number)
to
int old_dimension(int old_num_dim_table0, int old_num_dim_table1,
		  int new_num_dim_table0, int new_num_dim_table1,
		  char multi_lib[MAX_TABLE_NUMBER][MAXFUNCTNUM], 
		  int new_dim_number)

changed

type_class_score_convert(Sequence sequence,
                     double all_like[MAX_NUM_SCORE_DIM][MAXSEQLEN][POSNUM+1],
                     double bound, int new_only_coiled_classes,
                        int number_tables, int number_classes)
to
type_class_score_convert(Sequence sequence,
                     double all_like[MAX_NUM_SCORE_DIM][MAXSEQLEN][POSNUM+1],
                     double bound, int new_only_coiled_classes)


 Replaced:

int compute_dimension(int tablenum, int number_tables, int libnumber,
		      int number_score_dim, 
		      int number_multi_lib[MAX_TABLE_NUMBER],
		      int multi_trimer_pairs)
{
  int prev_table;
  int dimension=0;

  if (!number_score_dim)   /*  old version of numbering. */
    return (libnumber*number_tables + tablenum);
  else { /* new version, works when use single freq score instead of paircoil*/
    for (prev_table =0; prev_table<tablenum; prev_table++)
      dimension+= compute_num_multilib(prev_table, number_multi_lib, 
				       multi_trimer_pairs);

    return (dimension + libnumber);
  }
}

by


int compute_dimension2(int tablenum, int libnumber, 
		       int num_dist[MAX_TABLE_NUMBER], 
		       int combine_dist[MAX_TABLE_NUMBER])
{
  int prev_table;
  int dimension=0;

  for (prev_table =0; prev_table<tablenum; prev_table++)
    dimension+= num_table_dimensions(num_dist[prev_table], 
				     combine_dist[prev_table]);

  return (dimension + libnumber);
}



added

int num_table_dimensions(int num_dist_table, 
			 int combine_dist_table)
{

  return ((1-combine_dist_table)*num_dist_table +
	  combine_dist_table);
}




/**********************************************************/


Changed



void convert_raw_scores_to_gauss_prob_like2(
   double all_raw_scores[MAX_NUM_SCORE_DIM][MAXSEQLEN][POSNUM+1],int seq_len,
   int number_tables, double class_means[MAX_CLASS_NUMBER][MAX_NUM_SCORE_DIM],
 double inverse_covars[MAX_CLASS_NUMBER][MAX_NUM_SCORE_DIM][MAX_NUM_SCORE_DIM],
   double determinants[MAX_CLASS_NUMBER],
   int number_classes, double init_class_prob[MAX_CLASS_NUMBER],
   int number_score_dim, int consider_only_positive_classes, double bound,
   int Offset_to_Use, int last_class_gets_sum_prev)

to

void convert_raw_scores_to_gauss_prob_like2(
   double all_raw_scores[MAX_NUM_SCORE_DIM][MAXSEQLEN][POSNUM+1],int seq_len,
   int number_tables, double class_means[MAX_CLASS_NUMBER][MAX_NUM_SCORE_DIM],
 double inverse_covars[MAX_CLASS_NUMBER][MAX_NUM_SCORE_DIM][MAX_NUM_SCORE_DIM],
   double determinants[MAX_CLASS_NUMBER],
   int number_classes, double init_class_prob[MAX_CLASS_NUMBER],
   int number_score_dim, int consider_only_positive_classes, double bound,
   int Offset_to_Use)

In that function:

Cut
 if (all_one || !last_class_gets_sum_prev) 
    last_class_for_scores = number_classes;
  else  last_class_for_scores = number_classes-1;  /* Last class will be sum */
                                                   /* of prob for prev. class*/


Cut
  int last_class_for_scores, number_tables_to_write;

cut
  if (number_classes > number_tables) number_tables_to_write = number_classes;
  else number_tables_to_write = number_tables;

Changed
	if (Offset_to_Use == -1)  /*  Want reg 7 to have max of other reg */
	  for (tablenum =0; tablenum<last_class_for_scores; tablenum++)

to
	if (Offset_to_Use == -1)  /*  Want reg 7 to have max of other reg */
	  for (tablenum =0; tablenum<number_classes; tablenum++)


Changed
      else    /** Compute reg 7 as max of previous registers for offset -1 **/
	for (tablenum=0; tablenum < last_class_for_scores; tablenum++)
	  like_in_class[tablenum] = max_class_like[tablenum];

to


      else    /** Compute reg 7 as max of previous registers for offset -1 **/
	for (tablenum=0; tablenum < number_classes; tablenum++)
	  like_in_class[tablenum] = max_class_like[tablenum];



Changed

    /** Temporary hack to set the class we are interested to the table. **/
    /** So make class 1 =cctb, class 2 = trimer-, class 3 = pdb- in .paircoil*/
    /** Lets ASSUME that class= number_classes-1 is always pdb- */
    /** so for table>=number_classes-1 output sum of other classes prob. **/
    /** (which is the positive prob (prob of being coiled)).             **/
      for (tablenum=0; tablenum < number_tables_to_write; tablenum++)  { 
	if (tablenum < last_class_for_scores) {  
	  all_raw_scores[tablenum][i][reg] = like_in_class[tablenum];
	}
	else {
	  all_raw_scores[tablenum][i][reg]=
	    calc_total_coil_likelihood(like_in_class, number_classes,reg,
				       Offset_to_Use, 
				       &max_class_like[tablenum],
				       init_class_prob);
	}

to

      for (tablenum=0; tablenum < number_classes; tablenum++)  { 
	all_raw_scores[tablenum][i][reg] = like_in_class[tablenum];
	}



/********************************************************************/


Cut



int compute_num_multilib(int tablenum, int number_multi_lib[MAX_TABLE_NUMBER],
			 int multi_trimer_pairs)
{
  int use_pairs;

  if (tablenum <0) return 0;
  else if (tablenum ==0) use_pairs =1;  /*  Use pairs for cctb */
  else if (tablenum ==1) use_pairs = multi_trimer_pairs;  
  
  if (!use_pairs)  return 1;
  else return number_multi_lib[tablenum];
}



changed

void get_gauss_param_all_classes2(char sc_filenames[MAX_CLASS_NUMBER][MAXLINE],
      int number_score_dim, double means[MAX_CLASS_NUMBER][MAX_NUM_SCORE_DIM],
      double covars[MAX_CLASS_NUMBER][MAX_NUM_SCORE_DIM][MAX_NUM_SCORE_DIM],
      char gauss_param[MAXLINE])
to

void get_gauss_param_all_classes2(char sc_filenames[MAX_CLASS_NUMBER][MAXLINE],
      int number_score_dim, 
      double means[MAX_CLASS_NUMBER][NUM_DIM_IN_ORIG_MATRIX],
      double covars[MAX_CLASS_NUMBER]
			[NUM_DIM_IN_ORIG_MATRIX][NUM_DIM_IN_ORIG_MATRIX],
      char gauss_param[MAXLINE])



Changed

void compute_submatrices2(
	double means[MAX_CLASS_NUMBER][MAX_NUM_SCORE_DIM],
	double means_submatrix[MAX_CLASS_NUMBER][MAX_NUM_SCORE_DIM],
        double covars[MAX_CLASS_NUMBER][MAX_NUM_SCORE_DIM][MAX_NUM_SCORE_DIM],
        double inv[MAX_CLASS_NUMBER][MAX_NUM_SCORE_DIM][MAX_NUM_SCORE_DIM],
        double det[MAX_CLASS_NUMBER],
	char multi_lib[MAX_TABLE_NUMBER][MAXFUNCTNUM],
	int old_num_dim_table0, int old_num_dim_table1,
	int new_num_dim_table0, int new_num_dim_table1
        )

to
void compute_submatrices2(
	double means[MAX_CLASS_NUMBER][NUM_DIM_IN_ORIG_MATRIX],
	double means_submatrix[MAX_CLASS_NUMBER][MAX_NUM_SCORE_DIM],
        double covars[MAX_CLASS_NUMBER]
			  [NUM_DIM_IN_ORIG_MATRIX][NUM_DIM_IN_ORIG_MATRIX],
        double inv[MAX_CLASS_NUMBER][MAX_NUM_SCORE_DIM][MAX_NUM_SCORE_DIM],
        double det[MAX_CLASS_NUMBER],
	char multi_lib[MAX_TABLE_NUMBER][MAXFUNCTNUM],
	int old_num_dim_table0, int old_num_dim_table1,
	int new_num_dim_table0, int new_num_dim_table1
        )

Changed

void multivariate_gauss_from_scfile2(char *sc_filename, int number_score_dim,
		  double  mean[MAX_NUM_SCORE_DIM], 
		  double  covar[MAX_NUM_SCORE_DIM][MAX_NUM_SCORE_DIM])

to
void multivariate_gauss_from_scfile2(char *sc_filename, int number_score_dim,
		  double  mean[NUM_DIM_IN_ORIG_MATRIX], 
		  double covar[NUM_DIM_IN_ORIG_MATRIX][NUM_DIM_IN_ORIG_MATRIX])
and in that function changed

  long  n_below_mean[MAX_NUM_SCORE_DIM];
  long _counts[MAX_NUM_SCORE_DIM][-4*MINSCORE +1];
  long *counts[MAX_NUM_SCORE_DIM];
  int table,table2;
  int all_places_good,  place[MAX_NUM_SCORE_DIM];
  int number_high=0, number_low=0;
  int maxplaces[MAX_NUM_SCORE_DIM], minplaces[MAX_NUM_SCORE_DIM];
  
  double score[MAX_NUM_SCORE_DIM];

to
  long  n_below_mean[NUM_DIM_IN_ORIG_MATRIX];
  long _counts[NUM_DIM_IN_ORIG_MATRIX][-4*MINSCORE +1];
  long *counts[NUM_DIM_IN_ORIG_MATRIX];
  int table,table2;
  int all_places_good,  place[NUM_DIM_IN_ORIG_MATRIX];
  int number_high=0, number_low=0;
  int maxplaces[NUM_DIM_IN_ORIG_MATRIX], minplaces[NUM_DIM_IN_ORIG_MATRIX];
  
  double score[NUM_DIM_IN_ORIG_MATRIX];