Mac binaries

[jabaws.git] / website / archive / binaries / mac / src / tcoffee / t_coffee_source / reformat.c

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <stdarg.h>
#include <string.h>
#include <ctype.h>
#include <time.h>
#include "io_lib_header.h"
#include "util_lib_header.h"
#include "dp_lib_header.h" 
#include "define_header.h"
#include "dev1_lib_header.h"  //JM_STRAT

#define ACTION(x) ((n_actions>=(x+1))?action_list[x]:NULL)
#define ACTION2(x,y) ((n_actions>=(x+1))?action_list[x]:y)
#define ATOI_ACTION(x) ((ACTION(x)!=NULL)?(atoi(ACTION(x))):0)

/**************************************************************************************************/
/*****************************    SEQ_REFORMAT     ******************************************/
/**************************************************************************************************/
int output_transitions(char *outfile, Alignment *A);
static int output_age_matrix ( char *outfile, int val);
int SeqGCGCheckSum(char *seq, int len);
static Sequence *seq2year ( Sequence *S, int modulo);
static Sequence* output_n_pavie_age_channel (Sequence *S, char *name, int n);
static Sequence* output_pavie_age_channel (Sequence *S, char *name, int modulo);

static int output_seq2struc(char *outfile, Alignment *A);
void output_conservation_statistics ( char *file, Alignment *A);
/**************************************************************************************************/
/*****************************    SEQ_REFORMAT     ******************************************/
/**************************************************************************************************/
int seq_reformat ( int argc, char **in_argv) 
        {
        
        Sequence_data_struc *D1=NULL;
        Sequence_data_struc *D2=NULL;
        Sequence_data_struc *D_ST=NULL;
        Action_data_struc  *RAD;
        
        
        
        int a, b;
        
        char *in_format;
        char *in2_format;
        char *out_format;
        char *in_file;
        char *in2_file;
        char *out_file;
        char *out2_file;
        char *struc_in_format;
        char *struc_out_format;
        char *struc_in_file;
        char *struc_out_file;
        char**action_list;
        char **action;
        char *rename_file;
        char *cache;
        char ***rename_list=NULL;
        int code=CODE;
        char **argv;
        
        int n_actions=0;
        int print_format=0;
        /*INITIALIZATIONS*/
        
        RAD=vcalloc ( 1, sizeof ( Action_data_struc));
        RAD->keep_case=1;
        declare_name (cache);sprintf ( cache, "use");
        declare_name(in_file);
        declare_name(in2_file);
        declare_name(out_file);
        declare_name(out2_file);
        declare_name(struc_in_format);
        declare_name(struc_out_format);
        declare_name(RAD->coor_file);
        
        declare_name(struc_in_file);
        declare_name(struc_out_file);
        declare_name(in_format);
        declare_name(in2_format);
        declare_name(out_format);
        declare_name(rename_file);
        
        
        argv=break_list ( in_argv, &argc, "=;, \n");
                
        action_list=declare_char ( 100, 100);

/*END INITIALIZATION*/

        addrandinit ( (unsigned long) 500);
        
        if ( argc==1 || strm6 ( argv[1], "h", "-h", "help", "-help", "-man", "?"))
                {
                
                  fprintf ( stdout, "\n%s (%s,%s,%s [%s])\n",PROGRAM, VERSION,AUTHOR, DATE, URL);
                fprintf ( stdout, "\n***********     MINIMUM SYNTAX        *****************");
                fprintf ( stdout, "\nseq_reformat -in <in_file> -output <out_format>");
                fprintf ( stdout, "\nSome File formats are automatically recognised");
                fprintf ( stdout, "\nSee Format section");
                fprintf ( stdout, "\n");
                fprintf ( stdout, "\n***********        MAIN FLAGS              ******************");
                fprintf ( stdout, "\n-in     name........Name of the file read");
                

                fprintf ( stdout, "\n-input  format......Name of the format read, see Input Format Section");
                fprintf ( stdout, "\n...................Automatic detection, except for seqs of numbers");
                fprintf ( stdout, "\n...................-input number_aln | number_fasta");
                fprintf ( stdout, "\n-in2    fname......Second alignment");
                fprintf ( stdout, "\n-input2 format.....See -input");
                fprintf ( stdout, "\n-exon_boundaries   obj file");
                fprintf ( stdout, "\n-out    fname......Output file (defualt is STDOUT");
                fprintf ( stdout, "\n-output format.....Output Format, default is fasta_aln");
                fprintf ( stdout, "\n-struc_in   name...File containing a coded aln");
                fprintf ( stdout, "\n-struc_in_f format.See -input and output format section");
                fprintf ( stdout, "\n-struc_out  fname..Name of the output structure");
                fprintf ( stdout, "\n-struc_out_f symbol");
                fprintf ( stdout, "\n-keep_case=on|off..keep case, On by default");
                fprintf ( stdout, "\n-action +ac1 +ac2..See the action section");
                fprintf ( stdout, "\n-rename <file>.....Rename the sequences following <file> indications");
                fprintf ( stdout, "\n...................File Format: One couple <name1><space><name2>/line");
                fprintf ( stdout, "\n...................Rename order <name1> into <name2>");
                fprintf ( stdout, "\n...................code file: -output code_name");
                fprintf ( stdout, "\n-code   <file>     Rename file <name1> to <name2>");
                fprintf ( stdout, "\n-decode <file>     Rename file <name2> to <name1>");
                fprintf ( stdout, "\n-no_warning........Suppresses all warnings");
                fprintf ( stdout, "\n-cache.............use,ignore,update,local, DirectoryName");
                
                
                fprintf ( stdout, "\n");

                fprintf ( stdout, "\n***********     REFORMAT ACTIONS               *****************");
                fprintf ( stdout, "\n     +Xaction.............Specifies which file undergoes the action");
                fprintf ( stdout, "\n     +Xaction.............X=1: -in");
                fprintf ( stdout, "\n     +Xaction.............X=2: -in2");
                fprintf ( stdout, "\n     +Xaction.............X=3: -struc_in");
                fprintf ( stdout, "\n     +name2unique_name....replace duplicated name with name_#");
                fprintf ( stdout, "\n     +swap_header........,swapp comments: replace comments/name in 1 by in 2");
                fprintf ( stdout, "\n     +swap_lib_header.F...Replace the sequences in the tc_lib (-in) with those in F");
                fprintf ( stdout, "\n     .....................F is a legal FASTA file");
                
                
                fprintf ( stdout, "\n     +translate[0-2]......Translate on Frame 0, 1, 2 ");
                fprintf ( stdout, "\n     +translate[3]........longuest ORF on direct strand");
                fprintf ( stdout, "\n     +translate[4]........longuest ORF on direct+complementary strand");
                
                
                fprintf ( stdout, "\n     +add_scale..<offset>.addscale below aln"); 
                
                fprintf ( stdout, "\n     +rm_gap n ...........Removes col with n%% gap [n=100]");
                fprintf ( stdout, "\n     +rmgap_col SEQ1:SEQ2.Removes column with a gap in SEQ [#] ");
        
                fprintf ( stdout, "\n     +backtranslate.......Random Backtranslation");
                fprintf ( stdout, "\n     +complement..........Produces the reverse complement");
                
                fprintf ( stdout, "\n     +reorder.............Reorders sequences of <in> according to <in2>");
                fprintf ( stdout, "\n     .........random......Random_order");
                fprintf ( stdout, "\n     .........tree........Tree Order (in2)");
                fprintf ( stdout, "\n     +reorder_column.....Reorders sequences of <in> according to <in2>");
                fprintf ( stdout, "\n     .........random......Random_order");
                fprintf ( stdout, "\n     .........tree..mode..Tree Order (comuted with mode: sarmat, idmat, blosum62mt...");
                fprintf ( stdout, "\n     +aln2random_aln SCR..Randomize the aln, S: swap sequences names");
                fprintf ( stdout, "\n     .....................Swap residues within colums");
                fprintf ( stdout, "\n     .....................Swap residues across the aln");
                fprintf ( stdout, "\n     +aln2sample......N......");
                fprintf ( stdout, "\n     +aln2bootstrap...N......");
                

                fprintf ( stdout, "\n     +chain...............Identifies all the intermediate sequences from <-in>");
                fprintf ( stdout, "\n     .....................needed to join every sequence pair in <-in2>");
        
                fprintf ( stdout, "\n     +aln2cons  mat_name..Ouputs a consensus sequence");
                fprintf ( stdout, "\n     .....................The consensus is determined using mat");
                fprintf ( stdout, "\n     .....................By Default, mat=blosum62mt, name=Cons");
                fprintf ( stdout, "\n     +aln2resindex........Prints the sequence index of each residue in -in for each -in2 sequence");
                fprintf ( stdout, "\n     +collapse_aln <new name> <seq1> <seq2...> | file name");
                fprintf ( stdout, "\n     .....................Replaces a group of sequences with its consensus");
                fprintf ( stdout, "\n     .....................The replacement sequence is named <new_seq>");
                fprintf ( stdout, "\n     .....................List of sequences can be provided via a file");          
                fprintf ( stdout, "\n     .....................File:>new_name seq1 seq2 seq3....");
                fprintf ( stdout, "\n     +original_seqnos.....Keep original seqnos [SWITCH]");
                fprintf ( stdout, "\n     +seqnos..............Print Seqnos [SWITCH]");
                fprintf ( stdout, "\n     +code_dna_aln........Undocumented")  ;
                fprintf ( stdout, "\n     +grep..[NAME|SEQ|COMMENT]..[KEEP|REMOVE]..[string]......");
                fprintf ( stdout, "\n     .....................Keeps or Removes Sequences matching string");
                fprintf ( stdout, "\n     +extract_block <seq> <start> <end> | <seq> <pos> |<filename>");
                fprintf ( stdout, "\n     .....................Extract column pos OR [start to end[");
                fprintf ( stdout, "\n     .....................<filename> Format");
                fprintf ( stdout, "\n     .......................seq start end | seq pos");
                fprintf ( stdout, "\n     .......................# for comments");
                fprintf ( stdout, "\n     .......................! seq offset_value (0 by default)");
                fprintf ( stdout, "\n     .....................Can extract as many positions as needed");
                fprintf ( stdout, "\n     .....................seq=cons: measure positions on the full aln");
                fprintf ( stdout, "\n     +cat_aln.............Concatenates the alignments input via -in and -in2");
                fprintf ( stdout, "\n     +cat_aln.............-if no -in2, -in is expected to be a list of alignments to concatenate");
                fprintf ( stdout, "\n     +orthologous_cat..<mode>: mode=voronoi or nothing");
                fprintf ( stdout, "\n     ......................-in: sequences from different species");
                fprintf ( stdout, "\n     ..................... -in2: list of species in fasta");
                fprintf ( stdout, "\n     ..................... sequence must be named: <species>_<genename>");
                fprintf ( stdout, "\n     ..................... all paralogues will be concatenated");
                
                fprintf ( stdout, "\n     +aln2replicate N name");
                fprintf ( stdout, "\n     ..................... Generates N replicates in Fasta");
                fprintf ( stdout, "\n     ..................... Voronoi weights can be used");
                                
                fprintf ( stdout, "\n     +msalist2cat_pwaln.min..max");
                fprintf ( stdout, "\n     .....................extract all pw projections and conctaenates those\n");
                fprintf ( stdout, "\n     .....................where id>=min and id<=max\n");
                fprintf ( stdout, "\n     .....................min and max can be omitted (min=0, max=100)\n");
                
                fprintf ( stdout, "\n     +seq2blast <matrix>..gather all possible homologues from NR (EBI BLAST)");
                fprintf ( stdout, "\n     +seq2msa <matrix>....makes a standard progressive alignment using matrix");
                fprintf ( stdout, "\n     +realign_block <c1> <c2> <pg>");
                fprintf ( stdout, "\n     .....................Realign column c1 to c2 (non inc.) with pg)");
                fprintf ( stdout, "\n     .....................pg reads fasta and outputs fasta");
                fprintf ( stdout, "\n     .....................pg -infile=<infile> -outfile=<outfile>");
                fprintf ( stdout, "\n     +extract_seq seq_name (start end seq_name start end...) | filename");
                fprintf ( stdout, "\n     .....................seq_name='*': every seq");
                fprintf ( stdout, "\n     .....................start='*'   : real start");
                fprintf ( stdout, "\n     .....................end='*'     : real end");
                fprintf ( stdout, "\n     .....................filename: fasta format");
                fprintf ( stdout, "\n     +extract_seq_list name1 name2");
                fprintf ( stdout, "\n     .....................Extracts entire sequences");
                fprintf ( stdout, "\n     +remove_seq sn1 sn2..Removes sequences sn1, sn2...");
                fprintf ( stdout, "\n     +remove_seq empty....Removes empty sequences (gap only)");
                fprintf ( stdout, "\n     +remove_seq unique...Remove all multiple occurences except the first");
                fprintf ( stdout, "\n     +thread_profile_on_msa <file>");
                fprintf ( stdout, "\n     .....................Threads a list of profiles on corresponding seq");
                fprintf ( stdout, "\n     .....................File: >seqname _R_ <msa file> [nlines]");
                
                fprintf ( stdout, "\n     +thread_dna_on_prot_aln");
                fprintf ( stdout, "\n     .....................-in DNA.seq and -in2 AA.aln"); 
                fprintf ( stdout, "\n     +thread_struc_on_aln");
                fprintf ( stdout, "\n     .....................-in structure and -in2 aln"); 
                fprintf ( stdout, "\n     +use_cons............Use the consensus for n[SWITCH]");
                fprintf ( stdout, "\n     +upper.n|[n1-n2].....n omitted sets everything to upper case");
                fprintf ( stdout, "\n     .....................To use n: provide a number_aln via:");
                fprintf ( stdout, "\n     .....................-struc_in <number_file> -struc_in_f number_aln");
                fprintf ( stdout, "\n     .....................if use_cons is set n, is read on the cons");
                fprintf ( stdout, "\n     .....................n: will upper every residue with a value of n in struc_in");
                fprintf ( stdout, "\n     .....................[n1-n2]: upper residues between n1 and n2");
                fprintf ( stdout, "\n     +lower  n|[n1-n2]....See +upper");
                fprintf ( stdout, "\n     +switchcase  n|[n1-n2]See +upper");
                fprintf ( stdout, "\n     +color_residue <seq> <pos> <color> | file");
                fprintf ( stdout, "\n     .....................File: seq_name pos color");
                fprintf ( stdout, "\n     .....................color: 0-9");
                fprintf ( stdout, "\n     +edit_residue <seq> <pos> <edit> | file");
                fprintf ( stdout, "\n     .....................File: seq_name pos color");
                fprintf ( stdout, "\n     .....................edit: upper|lower|symbol");        
                
                
                
                fprintf ( stdout, "\n     +keep   n|[n1-n2]....Only keep residues that have a score between n1 and n2");
                
                fprintf ( stdout, "\n     +invert..............Inverts the sequences: CAT => TAC");
                fprintf ( stdout, "\n     +rotate name         Rotate an MSA, names each sequence name_col#");
                fprintf ( stdout, "\n     +convert n|[n1-n2] s1 s2 ....");
                fprintf ( stdout, "\n     +merge_annotation.... ");
                
                fprintf ( stdout, "\n     .....................Converts residues with your alignment");
                fprintf ( stdout, "\n     .....................similar to upper");
                fprintf ( stdout, "\n     .....................s1: ABCDe turns every ABCD into e");
                fprintf ( stdout, "\n     .....................s1: #e turns any residue into e");
                fprintf ( stdout, "\n     aln2short_aln L C S..Turns sequences into shorter sequences");
                fprintf ( stdout, "\n     .....................L: list of residues to keep");
                fprintf ( stdout, "\n     .....................S: Size of Streches replaced by symbol C");

                                
                fprintf ( stdout, "\n     +random n l..........Generates N random sequences of len l");
                fprintf ( stdout, "\n     .....................You must provide a file with -in");
                fprintf ( stdout, "\n     +count n|[n1-n2] s1 s2....");
                fprintf ( stdout, "\n     .....................Counts residues with your alignment");
                fprintf ( stdout, "\n     .....................similar to convert");
                fprintf ( stdout, "\n     +print_format........prints the format name");
                fprintf ( stdout, "\n     +keep_name...........Keep the original sequence name on extraction");
                
                fprintf ( stdout, "\n     +remove_aa pos Ml Ncycle Random_len");
                fprintf ( stdout, "\n     .....................Randomly modifies an alignment");
                fprintf ( stdout, "\n     .....................pos=0: chosen randomly");
                fprintf ( stdout, "\n     .....................MaxLen of the deletions, Ncycle: number of cycles");
                fprintf ( stdout, "\n     .....................Random_len: 0 sets the len to maxlen, 1 to a random value");
                fprintf ( stdout, "\n     +remove_nuc.x........Remove Position 1, 2 or 3 of every codon"); 
                fprintf ( stdout, "\n     +evaluate matrix..gop..gep");
                fprintf ( stdout, "\n     .....................Make a similarity evaluation with matrix");
                fprintf ( stdout, "\n     .....................use -output=score_ascii, or score_html.");
                fprintf ( stdout, "\n     .....................You can filter on the values");
                fprintf ( stdout, "\n     +evaluate matrix..gop..gep");
                fprintf ( stdout, "\n     .....................Make an SP evaluation with matrix");
                fprintf ( stdout, "\n     .....................Uses Natural Gap penalties");
                fprintf ( stdout, "\n     .....................gop and gep must be negative");
                fprintf ( stdout, "\n     .....................use -output=color_ascii, color_html to get a color display");

                fprintf ( stdout, "\n.....+evaluate_lat........Make a lateral evaluation with matrix");
                fprintf ( stdout, "\n     +msa_weight proc.....Computes weights using the procedure");
                fprintf ( stdout, "\nRNA analysis Post Processing___________________________________________________");
                fprintf ( stdout, "\n     +aln2alifold.........Turns the MSA into a consensus structure");
                fprintf ( stdout, "\n     +add_alifold.........adds an alifold consensus structure");

                fprintf ( stdout, "\n     +alifold2analyze.mode..mode=stat_cache_list_aln_color_html_ps_usegap");
                fprintf ( stdout, "\n     .......................stat: compile Number of compensated mutations");
                fprintf ( stdout, "\n     .......................cache: ascii-code compensated mutations on aln");
                fprintf ( stdout, "\n     .......................html: color-code compensated mutations on aln");
                fprintf ( stdout, "\n     .......................aln: mark compensated mutations on stockholm aln");
                fprintf ( stdout, "\n     .......................usegap: do not ignore positions with gaps");
                
                fprintf ( stdout, "\n     +RNAfold_cmp.........compares the sec struc of in1 and in2 (computes them with alifold if missing)");
                                
                fprintf ( stdout, "\nMSA Post Processing___________________________________________________");
                        fprintf ( stdout, "\n     +force_aln filename|seq1 res1 seq2 res2");
                fprintf ( stdout, "\n     .....................Forces residue 1 of seq1 to be aligned with res2 of seq 2");
                fprintf ( stdout, "\n     .....................In a file, there must be one pair of interaction/line");
                fprintf ( stdout, "\n     +sim_filter[_aln_Ix_iy_Cz_cw <seq>");
                fprintf ( stdout, "\n     ....................._<unaln or aln>, aln is assumed");
                fprintf ( stdout, "\n     ....................._I max identity to seq");
                fprintf ( stdout, "\n     ....................._i min identity to seq");
                fprintf ( stdout, "\n     ....................._C max cov on seq");
                fprintf ( stdout, "\n     ....................._c min cov on seq");
                fprintf ( stdout, "\n     +trim[_aln_%%%%50_n111_N50_T_Fn_fS_pS_max_sim_P0_K0] [string2]");
                fprintf ( stdout, "\n     ....................._<seq or aln>, aln is assumed");
                fprintf ( stdout, "\n     ....................._%%%%<max/min_percent_similarity>");
                fprintf ( stdout, "\n     ....................._max Or _min <keep sequences for which sim is the max or the min [Def: _max>");
                fprintf ( stdout, "\n     ....................._cov Or _sim Filter according to the coverage [Def: _sim]");
                fprintf ( stdout, "\n     ....................._n<max_number_of_sequence>       ");
                fprintf ( stdout, "\n     ....................._N<percent_of_sequences_to_keep>");
                fprintf ( stdout, "\n     ....................._T Reorder the sequences according to a tree BEFORE triming");
                fprintf ( stdout, "\n     ....................._Fn Keep only sequences that have AT LEAST ONE residue aligned");
                fprintf ( stdout, "\n     ......................in the n first and n last columns. ");
                fprintf ( stdout, "\n     ....................._O<min sim> Remove outlayers that have less than min average sim with other sequences"); 
                fprintf ( stdout, "\n     ....................._Kn Forces the n top sequences to be kept");
                fprintf ( stdout, "\n     ....................._P_ Print a summary in stderr");
                
                
                fprintf ( stdout, "\n     .....................Keeping Sequences: Sequences provided via -in2 will be kept");
                
                fprintf ( stdout, "\n     .....................Keeping Sequences: Sequences whose name contains <string> in field fS will be kept");
                fprintf ( stdout, "\n     ....................._f<NAME|SEQ|COMMENT> designates a field"); 
                fprintf ( stdout, "\n     .....................<string> is a Perl regular expression");
                fprintf ( stdout, "\n     +aln2unalign Mode Penalty Threshold");
                fprintf ( stdout, "\n     .....................Identifies all the streches less conserved than than the average");
                fprintf ( stdout, "\n     .....................Mode: lower|number|unalign Act on all the resiues withs score<Thres");
                fprintf ( stdout, "\n     .....................Penalty: FSA penalty align2unalign, Def=90");
                fprintf ( stdout, "\n     .....................Threshold: Fraction of unaligned residues(0-9) Def=2");
                
                fprintf ( stdout, "\n     +clean_cdna..........Undocumented"); 
                fprintf ( stdout, "\n     +clean_maln..........Undocumented"); 
                fprintf ( stdout, "\nTree Analysis___________________________________________________");
                
        
                fprintf ( stdout, "\n     +tree_prune..........Prune the tree -in using the sequences provided via -in2");
                fprintf ( stdout, "\n     +tree_cmp............Compares the tree -in and the tree -in2");
                fprintf ( stdout, "\n     +tree_cmp_list......Compares the tree -in and the tree_list -in2");
                fprintf ( stdout, "\n     .....................Sets the support as boostrap value in the -in tree");
                
                fprintf ( stdout, "\n     .....................-in and -in2 can contain different taxons");
                fprintf ( stdout, "\n     +tree_scan.P1..P2.....scans alignment <-in> with tree <-in2>)");
                fprintf ( stdout, "\n     ......................+tree_scan help to get P1 information");
                fprintf ( stdout, "\n     ......................+aln2tree help to get P2 information");
                
                fprintf ( stdout, "\n     .....................-in and -in2 can contain different taxons");
                fprintf ( stdout, "\n     +tree2node.......... Reports the node list along with the split");
                fprintf ( stdout, "\n     ..................... splits can be described with the seq order ");
                fprintf ( stdout, "\n     ..................... provided via -in3=<sequence> ");
                
                fprintf ( stdout, "\n     +treelist2groups.N....count all topologies within a list of trees");
                fprintf ( stdout, "\n     .....................-in is in fasta format with each name being a newick file");
                fprintf ( stdout, "\n     .....................-in2 can be a list of sequences used to trim the trees");
                fprintf ( stdout, "\n     ......................N can be used to unresolve the trees with Depth N");
                fprintf ( stdout, "\n     +treelist2lti.N.C.....Reports the average stability of each sequence neighborhood");
                fprintf ( stdout, "\n     ......................Species can be selected via -in2 [Fasta file with Taxon names]");
                fprintf ( stdout, "\n     ......................OR the sequences observed in C%% of the files are kept [Def: C=100]");
                
                
                fprintf ( stdout, "\n     +treelist2seq.C.......Reports the species observed in C%% of the trees");
                fprintf ( stdout, "\n     +treelist2splits......List and counts all the splits in a list of trees");
                fprintf ( stdout, "\n     ......................splits can be restricted to a list of sequences provided via -in2");
                fprintf ( stdout, "\n     +treelist2dmat.......outputs a distance matrix for a list of trees");

                fprintf ( stdout, "\n     +tree_compute n s....Computes a tree using the MSA provided with -in");
                fprintf ( stdout, "\n     ....................n:0-9, controls the way the MSA is filtered");
                fprintf ( stdout, "\n     ....................s:pam250mt|blosum62mt|categories|enthropy");
                fprintf ( stdout, "\n     ....................s:controls the column evaluation in MSA");
                fprintf ( stdout, "\n     +change_distances.f.f:float, sets all the distances to f in the tree");
                fprintf ( stdout, "\n     +change_bootstrap n..:n=0 removes all the bootstrap values");
                fprintf ( stdout, "\n     .....................:n!=0 adds a the value n to every node");
                fprintf ( stdout, "\n     +tree2dpatree........Replaces tree distances with the minimum %%ID in");
                fprintf ( stdout, "\n     .....................the depending subgroup. The ID is measured on an");
                fprintf ( stdout, "\n     .....................-in=TREE -in2=ALN");
                fprintf ( stdout, "\n     +unroot..............Removes the root in the input tree");
                fprintf ( stdout, "\n     +tree2group.N.I.P....Reports all the tree subgroup with at most Nseq");
                fprintf ( stdout, "\n     .....................and at min I%% identity. Output format can be read by");
                fprintf ( stdout, "\n     .....................collapse_tree. New groups are named P_1, P_2...");               
                fprintf ( stdout, "\n     +collapse_tree.F.....Collapses trees. F is either a file or a list");
                fprintf ( stdout, "\n     .....................<new name> <seq1> <seq2>...");
                fprintf ( stdout, "\n     +aln2tree............Computes a tree");
                fprintf ( stdout, "\n     ..ktupN|aln|sarmat   ktupN: match size N to estimate distances");
                fprintf ( stdout, "\n     .....................aln: Measures distances on aln");
                fprintf ( stdout, "\n     .....................sarmat: expects in to be a SAR matrix of O and I");
                fprintf ( stdout, "\n     ..nj | cw............Runs Neighbor Joining OR Cw to compute Tree");
                fprintf ( stdout, "\n     ..dpa................Turns the tree into a daptree (+tree2dpatree)");
                fprintf ( stdout, "\n     +node_sort..<name>...Sort leafs of tree n1, by node distance");
                          
                
                fprintf ( stdout, "\nMatrix Analysis___________________________________________________");
                fprintf ( stdout, "\n     +aln2mat_diaa........computes a dinucleotide matrix on a list of aln");
                fprintf ( stdout, "\n     +aln2mat.............computes a log odd matrix");
                
                fprintf ( stdout, "\n     +seq2lat_mat.........computes a transition matrix on seq provided via -in");
                
                fprintf ( stdout, "\nStructure Analysis___________________________________________________");
                fprintf ( stdout, "\n     +struc2contacts.A.B D.Displays in capitals all the residues of A");
                fprintf ( stdout, "\n     ......................Less than D Angs from a residue of B");
                fprintf ( stdout, "\n     ......................A and B are pdb file, D is a distance in Angs");
                fprintf ( stdout, "\n     +seq2contacts.A.D.....Identifies all the residues in contact with ligands");
                fprintf ( stdout, "\n     ......................Ligands are in the FASTA header of struc in");
                fprintf ( stdout, "\n     ......................>Name _S_ [Target Struc] [Ligand1] [Chain] ...");
                fprintf ( stdout, "\n     ......................Output: number_fasta: 0=no contact, 1=ligand 1...");
                fprintf ( stdout, "\n     ......................9: residues in contact with more than 1 ligand");
                fprintf ( stdout, "\n     ......................Use -output=color_html/ascii to display result");
                fprintf ( stdout, "\n     +struc2nb...D.........Display a list of all the residues D appart");
                fprintf ( stdout, "\n     +rm_template...V......Removes _[S|G|R]_[template] to sequence names");
                fprintf ( stdout, "\n     ......................V: omitted | sequences <=> Output sequences");
                fprintf ( stdout, "\n     ......................V: template <=> Output templates");
                        
                fprintf ( stdout, "\n     +add_template.F.......Add _[S|G|R]_[template] to sequence names");
                fprintf ( stdout, "\n     ......................F can either be a fasta file or an executable");
                fprintf ( stdout, "\n     ......................F: File: >name _S_ template");
                fprintf ( stdout, "\n     ......................F: executable: pg -infile=<seq> -outfile=<tagged>");
                fprintf ( stdout, "\nMatrix Comparison___________________________________________________");
                fprintf ( stdout, "\n    +mat2cmp...............Returns the correlation coefficient between two matrices");
                fprintf ( stdout, "\n    .......................-in mat1 -input matrix, -in2 mat2 -input2 matrix");
                fprintf ( stdout, "\n***********  INPUT FORMATS: Alignments *****************");
                fprintf ( stdout, "\n     AUTOMATIC RECOGNITION");
                fprintf ( stdout, "\n     perl_xxx:............. runs xxx onto the input file");
                fprintf ( stdout, "\n     xxxx <file> > outfile..xxx reads any formats, outputs fasta");
                fprintf ( stdout, "\n     amps_aln       saga_aln      ");
                fprintf ( stdout, "\n     clustal_aln    fasta_aln     msf_aln  ");
                fprintf ( stdout, "\n     dali_aln       gotoh_aln     pima_aln");
                fprintf ( stdout, "\n     dialign_aln    matrix        conc_aln");    
                fprintf ( stdout, "\n     NON AUTOMATIC RECOGNITION (use the -input file to specify the format");
                fprintf ( stdout, "\n     number_aln     newick_tree");
                fprintf ( stdout, "\n");
                fprintf ( stdout, "\n***********  INPUT FORMATS: Sequences *****************");
                fprintf ( stdout, "\n     fasta_seq      dali_seq       pir_seq");
                fprintf ( stdout, "\n     barton_list_tc amps_sd_scores EST_fasta");
                fprintf ( stdout, "\n     gor_seq        gor_struc      number_fasta[*]");
                fprintf ( stdout, "\n     swissprot      tc_lib         pdb_struc");
                fprintf ( stdout, "\n");
                fprintf ( stdout, "\n***********  INPUT FORMATS: Structures   *****************");
                fprintf ( stdout, "\n    rna_number");
                fprintf ( stdout, "\n    alifold");
                fprintf ( stdout, "\n***********  OUTPUT FORMATS: Alignments ******************");
                fprintf ( stdout, "\n     compressed_aln saga_aln        clustal_aln");
                fprintf ( stdout, "\n     phylip_aln     msf_aln         fasta_aln ");
                fprintf ( stdout, "\n     pir_aln        ");
                fprintf ( stdout, "\n     color_html,color_ps......colored using the struc_in file  ");
                fprintf ( stdout, "\n     color_protogene..........colors codons");
                fprintf ( stdout, "\n     color_exoset.............mixes conservation (gray) and introns (RGB)");
                fprintf ( stdout, "\n     color_pdf      pw_lib_saga_aln tdna_aln");
                fprintf ( stdout, "\n     thread_dna_on_prot_aln");
                fprintf ( stdout, "\n");
                fprintf ( stdout, "\n*********** OUTPUT FORMATS: sequence  ******************");
                fprintf ( stdout, "\n     fasta_seq      fasta_seq1     gotoh_seq");
                fprintf ( stdout, "\n     gor_seq        cache_id");
                fprintf ( stdout, "\n     tblastx_db1     tblastx_db2    tblastx_db3");
                fprintf ( stdout, "\n*********** OUTPUT FORMATS: weights ******************");
                fprintf ( stdout, "\n     constraints    saga_pw_sd_weights  nseq\n");
                fprintf ( stdout, "\n");
                fprintf ( stdout, "\n*********** OUTPUT Formats: special  ****************");
                fprintf ( stdout, "\n     len             name               statistics<_hnrglNL>");
                fprintf ( stdout, "\n      sim............outputs a similarity matrix based on an id comparison of -in");
                fprintf ( stdout, "\n      sim_sarmat.....in is sar matrix");
                fprintf ( stdout, "\n      sim_idscore....makes dp alignment of the sequences using Blosum62mt");
                fprintf ( stdout, "\n      sim_idscoreDNA.makes dp alignment of the sequences using idmat");
                fprintf ( stdout, "\n      sim............if -in2 is set: in1 vs in2, idscore");
                
                fprintf ( stdout, "\n     code_name......Outputs a compact list of names for code/decode");

                
                
                fprintf ( stdout, "\n");
        
                
                fprintf ( stdout, "\n");
                return EXIT_SUCCESS;
                }
        
        argv=standard_initialisation (argv, &argc);
        
                
        for ( a=1; a< argc; a++)
                {
                  if (a==1 && argv[1][0]!='-')
                    {
                      sprintf( in_file, "%s", argv[a]);
                    }
                  else if ( strcmp ( argv[a], "-in_f")==0 ||strm(argv[a],"-input") )
                        {
                        if ( strcmp ( argv[a], "-in_f")==0) fprintf ( stdout,"\nWARNING: %s deprecated, use -input instead", argv[a]);
                
                        sprintf ( in_format, "%s", argv[a+1]);
                        a++;
                        }
                
                else if ( strcmp ( argv[a], "-cache")==0 )
                        {
                        sprintf (cache, "%s", argv[a+1]);
                
                        a++;
                        }
                  
                
                else if ( strcmp ( argv[a], "-exon_boundaries")==0 )
                        {
                
                          set_string_variable ("exon_boundaries", argv[a+1]);
                          a++;
                        }
                else if ( strcmp ( argv[a], "-overaln_threshold")==0 )
                        {
                
                          set_int_variable ("overaln_threshold", atoi(argv[a+1]));
                          a++;
                        }
                else if ( strcmp ( argv[a], "-overaln_target")==0 )
                        {
                
                          set_int_variable ("overaln_target", atoi(argv[a+1]));
                          a++;
                        }
                else if ( strcmp ( argv[a], "-overaln_P1")==0 )
                        {
                          
                          set_int_variable ("overaln_P1", atoi(argv[a+1]));
                          a++;
                        }
                else if ( strcmp ( argv[a], "-overaln_P2")==0 )
                        {
                
                          set_int_variable ("overaln_P2", atoi(argv[a+1]));
                          a++;
                        }
                else if ( strcmp ( argv[a], "-overaln_P3")==0 )
                        {
                
                          set_int_variable ("overaln_P3", atoi(argv[a+1]));
                          a++;
                        }
                else if ( strcmp ( argv[a], "-overaln_P4")==0 )
                        {
                
                          set_int_variable ("overaln_P4", atoi(argv[a+1]));
                          a++;
                        }
                  
                else if ( strcmp ( argv[a], "-in2_f")==0||strm(argv[a],"-input2") )
                        {
                          if ( strcmp ( argv[a], "-in_f")==0) fprintf ( stdout,"\nWARNING: %s deprecated, use -input2 instead", argv[a]);
                
                        sprintf ( in2_format, "%s", argv[a+1]);
                        a++;
                        }
                else if ( strcmp ( argv[a], "-seqnos")==0)
                        {
                        sprintf (action_list[n_actions++], "seqnos");
                        }
                
                else if ( strcmp( argv[a], "-action")==0)
                        {
                        while ((a+1)<argc && argv[a+1][0]!='-')
                          {
                            sprintf (action_list[n_actions++], "%s", argv[a+1]);
                            a++;
                          }
                        }
                else if ( strcmp ( argv[a], "-keep_case")==0)
                        {
                          if(!NEXT_ARG_IS_FLAG)RAD->keep_case=1;
                          else RAD->keep_case=(strm3(argv[a], "on","ON","On"))?1:0;
                          
                        }
                
                else if ( strcmp ( argv[a], "-conv")==0)
                        {
                        if ( strncmp ( argv[a+1],"set",3)==0)RAD->symbol_list=make_symbols (argv[++a],&(RAD->n_symbol));
                        else
                            {
                            RAD->symbol_list=declare_char (STRING, STRING);
                            while(!NEXT_ARG_IS_FLAG)
                                  { 
                                  sprintf ( RAD->symbol_list[RAD->n_symbol], "%s", argv[++a]);
                                  RAD->n_symbol++; 
                                  }
                            }
                        }
                else if ( strcmp ( argv[a], "-struc_in_f")==0 ||strcmp ( argv[a], "-input3")==0 )
                        {
                        sprintf ( struc_in_format, "%s", argv[a+1]);
                        a++;
                        }
                else if ( strcmp ( argv[a], "-out_f")==0 ||strm(argv[a],"-output") )
                        {
                        if ( strcmp ( argv[a], "-out_f")==0) fprintf (stdout, "\nWARNING: %s deprecated, use -output instead", argv[a]);
                        sprintf ( out_format, "%s", argv[a+1]);
                        a++;
                        }
                else if ( strm ( argv[a], "-struc_out_f") || strm ( argv[a], "-output_struc") )
                        {
                        sprintf ( struc_out_format, "%s", argv[a+1]);
                        a++;
                        }
                else if ( strcmp (argv[a],"-in")==0)
                        {
                        sprintf( in_file, "%s", argv[a+1]);
                        a++;
                        }
                else if ( strcmp (argv[a],"-rename")==0)
                        {
                        sprintf( rename_file, "%s", argv[a+1]);
                        a++;
                        }
                else if ( strcmp (argv[a],"-code")==0)
                        {
                        code=CODE;
                        sprintf( rename_file, "%s", argv[a+1]);
                        a++;
                        }
                else if ( strcmp (argv[a],"-decode")==0)
                        {
                          code=DECODE;
                          sprintf( rename_file, "%s", argv[a+1]);
                          a++;
                        }
                else if ( strcmp (argv[a],"-in2")==0)
                        {
                        sprintf( in2_file, "%s", argv[a+1]);
                        a++;
                        }
                else if ( strcmp (argv[a],"-coor")==0)
                        {                       
                        sprintf( RAD->coor_file, "%s", argv[a+1]);
                        a++;
                        }
                else if (strcmp (argv[a],"-out")==0) 
                        {
                        sprintf (out_file, "%s", argv[a+1]);
                        a++;
                        }
                else if (strcmp (argv[a],"-out2")==0) 
                        {
                        sprintf (out2_file, "%s", argv[a+1]);
                        a++;
                        }
                else if ( strcmp (argv[a],"-struc_in")==0 || strcmp (argv[a],"-in3")==0 )
                        {
                        sprintf( struc_in_file, "%s", argv[a+1]);
                        a++;
                        }
                else if (strcmp (argv[a],"-struc_out")==0) 
                        {
                        sprintf (struc_out_file, "%s", argv[a+1]);
                        a++;
                        }
                else if ( strcmp ( argv[a], "-rm_gap")==0)
                        {
                        RAD->rm_gap=1;
                        }
                else if ( strcmp ( argv[a], "-print_format")==0)
                        {
                        print_format=1;
                        }
                else if ( strcmp ( argv[a], "-no_warning")==0)
                        {
                        set_warning_mode (NO);
                        }
                
                else    
                        {
                        fprintf ( stdout, "\nUNKNOWN OPTION: %s", argv[a]);
                        myexit(EXIT_FAILURE);
                        }
                }
/****************************************************************/
/*                                                              */
/*                          Data Preparation                    */
/*                                                              */
/*                                                              */
/****************************************************************/
        
        prepare_cache (cache);    
/****************************************************************/
/*                                                              */
/*                          INPUT SEQ/ALN                       */
/*                                                              */
/*                                                              */
/****************************************************************/
        

        if ( strm (out_format, "hasch"))
          {
            fprintf ( stdout, "%d\n", (int)hash_file(in_file));
            return EXIT_SUCCESS;
          }

        if ( rename_file[0])
          {
            rename_list=read_rename_file ( rename_file,code);
          }


        if ((D1=read_data_structure (in_format, in_file,RAD))!=NULL)
          {
            in_format=(in_format && in_format[0])?in_format:identify_seq_format(in_file);
            
            if (print_format)fprintf ( stdout, "\nFILE:%s FORMAT:%s\n", in_file, in_format);
          }
        else if ( in_file[0])
                {
                  fprintf ( stdout, "\nFORMAT of file %s Not Supported[FATAL:%s]\n", in_file, PROGRAM);
                myexit(EXIT_FAILURE);
                }
        
        if ((D2=read_data_structure (in2_format, in2_file,RAD))!=NULL){if (print_format)fprintf ( stderr, "\nFILE:%s FORMAT:%s\n", in2_file, (in2_format&&in2_format[0])?in2_format:identify_seq_format(in2_file));}

        else if (!D2 && in2_file[0])
                {
                  fprintf ( stderr, "\nFORMAT of file %s Not Supported [FATAL:%s]\n", in2_file, PROGRAM);
                myexit(EXIT_FAILURE);
                }
        
/*STRUCTURE INPUT*/     
        
        
        if ((D_ST=read_data_structure (struc_in_format, struc_in_file,RAD)))
            {

              if ( D_ST->CL)
                {
                  Constraint_list *CL;
                  int *entry;

                  CL=D_ST->CL;
                  
                  while ((entry=extract_entry (CL)))
                    {
                      if ( D_ST->S)(D_ST->S)->seq[entry[SEQ1]][entry[R1]-1]=entry[WE];
                    }
                  thread_seq_struc2aln (D_ST->A, D_ST->S);
                }
              else if ( name_is_in_list ("cons", ((D_ST)->A)->name, ((D_ST)->A)->nseq, 100));
              else
                {
                  D_ST->A=copy_aln ( D1->A, D_ST->A);
                  
                  thread_seq_struc2aln (D_ST->A, D_ST->S);
                }
            }
        else if ((strcmp (struc_in_format, "rna_number")==0) && in_file[0])
                {
                D_ST->RNA_ST=read_rna_struc_number((D1->A),struc_in_file);
                }
        else if ( struc_in_format[0] && struc_in_file[0])
                {
                    
                fprintf ( stderr, "\nSTRUC %s UNKNOWN[FATAL]", struc_in_format);
                myexit(EXIT_FAILURE);
                }
        else
          {
            D_ST=vcalloc ( 1, sizeof (Sequence_data_struc));
          }

        action=declare_char(100, 100);
        for ( a=0; a< n_actions;)
          {
           if (action_list[a][0]!='+')
              {
                fprintf ( stderr, "\nWARNING: Action %s Unknown. Actions start with a +", action_list[a]);
                myexit (EXIT_FAILURE);
              }
           else
             {
             b=0;
             sprintf ( action[b++], "%s", action_list[a++]+1);
             while ( a<n_actions && action_list[a][0]!='+')sprintf ( action[b++], "%s", action_list[a++]);
             modify_data( D1, D2, D_ST, action,b, RAD);
             }
          }

        if (rename_list)
          {
            if (D1)D1->A= rename_seq_in_aln(D1->A, rename_list);
            if (D2)D2->A=rename_seq_in_aln (D2->A, rename_list);
            if (D_ST)D_ST->A=rename_seq_in_aln (D_ST->A,rename_list);
            
            if (D1)D1->T  =rename_seq_in_tree (D1->T, rename_list);
            if (D2)D2->T  =rename_seq_in_tree (D2->T, rename_list);
            if (D_ST)D_ST->T=rename_seq_in_tree (D_ST->T,rename_list);
          }


        if ( !out_format[0] && ! struc_out_format[0])sprintf ( out_format, "%s", (in_format && in_format[0])?in_format:"fasta_aln");
        main_output  ( D1, D2, D_ST, out_format, out_file);
        main_output  ( D1, D2, D_ST, struc_out_format, struc_out_file);
        return EXIT_SUCCESS;
        }
        



/**************************************************************************************************/
/*****************************    FORMAT GUESSING     ******************************************/
/**************************************************************************************************/
Sequence_data_struc *read_data_structure ( char *in_format, char *in_file,      Action_data_struc  *RAD) 
         
        {
        Sequence_data_struc *D;
        char **seq_name=NULL, **sequences=NULL;
        int nseq=0, a;

        
        D=vcalloc ( 1, sizeof (Sequence_data_struc));
        

        if (!in_file[0])return NULL; 
        if (!in_format[0])
          {
            in_format=identify_seq_format(in_file);
          }
        if (!in_format[0])return NULL;
        


        D->A=declare_Alignment(NULL);                 
        if ( RAD->keep_case)(D->A)->residue_case=KEEP_CASE;
        
        D->rm_gap=RAD->rm_gap;
        sprintf ( D->format, "%s", in_format);
        sprintf ( D->file, "%s", in_file);
        

       

        if ( strm2(in_format,"saga_aln","clustal_aln"))
                {
                read_aln (in_file, D->A);
                D->S=aln2seq(D->A);
                
                }
                
        else if ( strm (in_format, "treefile_list"))
          {

            D->S=get_tree_file_list(in_file);
            D->A=seq2aln(D->S, D->A,NO_PAD);
          }
        else if ( strm (in_format, "file_list") || strm (in_format, "list"))
          {
            D->S=get_file_list(in_file);
            D->A=seq2aln(D->S, D->A,KEEP_GAP);
          }
        else if ( strm (in_format, "fasta_tree"))
          {

            D->S=get_fasta_tree (in_file, NULL);
            D->A=seq2aln(D->S, D->A,NO_PAD);
           
          }
        else if ( strm (in_format, "tree_list") || strm (in_format, "treelist"))
          {
            char **line;
            FILE *seq;
            int n=0;
            char *seq_file;
            FILE *fp;

            seq_file=vtmpnam(NULL);
            seq=vfopen (seq_file, "w");
            line=file2lines (in_file);
            fp=vfopen (seq_file, "w");
            for ( n=1; n<atoi(line[0]); n++)
              {
                fprintf ( fp, ">Tree_%d\n%s\n", n,line[n]);
              }
            vfclose (fp);
            
            free_char (line, -1);
            return read_data_structure ( "fasta_tree",seq_file,RAD); 
          }
        
        else if (strm (in_format, "matrix"))
          {
            D->M=read_matrice (in_file);
          }
        else if (strm4 (in_format, "newick_tree", "newick", "nh", "new_hampshire"))
          {
            D->T=main_read_tree (in_file);
            D->S=tree2seq(D->T, NULL);
            D->A=seq2aln (D->S,D->A, 0); 
          }
        else if (strm (in_format, "blast_aln"))
                {
                  if (read_blast_aln (in_file, D->A))
                  {
                    D->S=aln2seq(D->A);
                  }
                else
                  {
                    return NULL;
                  }
                }
        else if ( strm( in_format,"number_aln"))
                {               
                read_number_aln (in_file, D->A);
                D->S=aln2seq(D->A);
                }
        else if ( strm( in_format,"stockholm_aln"))
                {               
                read_stockholm_aln (in_file, D->A);
                D->S=aln2seq(D->A);
                }
        else if ( strm( in_format,"gotoh_aln"))
                {               
                read_gotoh_aln (in_file, D->A);
                D->S=aln2seq(D->A);
                }
        
        else if ( strm ( in_format, "msf_aln"))
                {
                read_msf_aln (in_file, D->A);
                D->S=aln2seq(D->A);
                }
        else if ( strm ( in_format, "amps_aln"))
                {
                read_amps_aln (in_file, D->A);
                D->S=aln2seq(D->A);
                }
        else if ( strm (in_format, "excel_seq"))
                {               
                  D->S=perl_reformat2fasta ("excel2fasta.pl",in_file);
                  (D->S)->contains_gap=0;
                  D->A=seq2aln(D->S, D->A,RAD->rm_gap);
                }
        else if ( strm (in_format, "pavie_seq"))
                {               
                  D->S=perl_reformat2fasta ("pavie2fasta.pl",in_file);
                  (D->S)->contains_gap=0;
                  D->A=seq2aln(D->S, D->A,RAD->rm_gap);
                }
        else if ( strncmp (in_format, "perl_",5 )==0)
                {               
                  D->S=perl_reformat2fasta (in_format+5,in_file);
                  (D->S)->contains_gap=0;
                  D->A=seq2aln(D->S, D->A,RAD->rm_gap);
                }
        else if ( strm (in_format, "number_fasta"))
                {               
                D->S=get_fasta_sequence_num (in_file, NULL);
                (D->S)->contains_gap=0;
                D->A=seq2aln(D->S, D->A,RAD->rm_gap);
                }       
        else if ( strm (in_format, "raw_fasta"))
                {               
                D->S=get_fasta_sequence_raw (in_file, NULL);
                (D->S)->contains_gap=0;
                D->A=seq2aln(D->S, D->A,RAD->rm_gap);
                }       

        else if ( strm2 (in_format, "fasta_aln", "fasta_seq"))
                {
                
                D->S=get_fasta_sequence (in_file, NULL);
                if ( strcmp (in_format, "fasta_aln")==0)(D->S)->contains_gap=0;
                D->A=seq2aln(D->S, D->A,RAD->rm_gap);
                }       
        else if ( strm (in_format, "fasta_tree"))
                {
                
                D->S=get_fasta_tree (in_file, NULL);
                D->A=seq2aln(D->S, D->A, NO_PAD);
                }       
        
        else if ( strm (in_format, "pdb") || strm (in_format, "pdb_struc"))
                {
                    D->S=get_pdb_sequence (in_file);
                    if ( D->S==NULL)
                      {
                        add_warning (stderr, "FAILED TO find PDB File %s", in_file);
                        myexit (EXIT_FAILURE);
                      }
                    D->A=seq2aln(D->S, D->A,RAD->rm_gap);
                }
        else if ( strm2(in_format, "pir_seq", "pir_aln"))
                {
                D->S=get_pir_sequence ( in_file,NULL );
                seq2aln(D->S, D->A, RAD->rm_gap);
                }
        else if ( strm(in_format, "gor_seq") )
                {
                D->S=get_gor_sequence ( in_file,NULL );
                seq2aln(D->S, D->A, RAD->rm_gap);
                }
        else if ( strm2 ( in_format, "dali_aln", "dali_seq"))
                {
                D->S=get_sequence_dali ( in_file);
                seq2aln(D->S, D->A, RAD->rm_gap);
                }
        else if ( strm (in_format, "barton_list_tc"))
                {
                get_barton_list_tc_seq ( in_file);
                }
        else if ( strm (in_format, "amps_sd_scores"))
                {
                D->W=get_amps_sd_scores ( in_file);
                }
        
        else if ( strm ( in_format, "pima_aln"))
                {
                D->S=get_pima_sequence ( in_file);
                seq2aln (D->S, D->A, RAD->rm_gap);
                }
        else if ( strm( in_format, "gor_struc"))
                {
                D->S=get_struc_gor ( in_file);
                seq2aln(D->S, D->A, RAD->rm_gap);
                }
        else if ( strm( in_format, "dialign_aln"))
                {
                D->S=get_dialign_sequence ( in_file);
                seq2aln (D->S, D->A, RAD->rm_gap);
                }
        else if ( strm( in_format, "tc_lib") ||  strm( in_format, "mocca_lib") ||  strm( in_format, "lib"))
                {
                  read_seq_in_list (in_file,&nseq,&sequences,&seq_name); 
                  D->S=fill_sequence_struc ( nseq, sequences, seq_name);
                  D->CL=declare_constraint_list ( D->S,NULL, NULL, 0,NULL, NULL); 
                  D->CL=read_constraint_list_file(D->CL,in_file);
                  seq2aln (D->S, D->A, RAD->rm_gap);
                  free_char (sequences,-1);
                  free_char (seq_name, -1);
                }
        else if ( strm( in_format,"swissprot_seq"))
                {
                  D->S=get_swissprot_sequence ( in_file,NULL);
                  seq2aln (D->S, D->A, RAD->rm_gap);
                }
        else if  (strm (in_format, "alifold"))
          {
            D->S=read_alifold ( in_file);
            seq2aln (D->S, D->A,0);
          }
        else
                {
                return NULL; 
                }

        if ( D->A)
          {
            for ( a=0; a<(D->A)->nseq; a++)sprintf ( (D->A)->file[a], "%s", in_file);
          }
        if ( D->S)
          {
            for ( a=0; a<(D->A)->nseq; a++)sprintf ( (D->S)->file[a], "%s", in_file);
          }
        
        return D;
        }
Sequence *read_sequences (char *name)
{
  return main_read_seq (name);
}
Alignment * alifold2aln  (char *file)
{
  Sequence *S;
  S=read_alifold(file);
  sprintf ( S->seq[0],"%s", S->seq[1]);
  return seq2aln (S, NULL, 0);
}
Sequence  * read_alifold (char *file)
{
  Sequence *S;
  char **list;
  int l;
  S=declare_sequence (1,count_n_char_in_file (file),2);
  list=file2lines (file);
  
  S->seq[0]=list[1];
  S->seq[1]=list[2];
  substitute (S->seq[0], "\n", "\0");
  substitute (S->seq[0], " ", "\0");
  substitute (S->seq[0], "_", STOCKHOLM_STRING);
  l=strlen (S->seq[0]);
  substitute (S->seq[1], "\n", "\0");
  substitute (S->seq[1], " ", "\0");
  substitute (S->seq[1], ".", STOCKHOLM_STRING);
  S->seq[1][l]='\0';
  sprintf (S->name[0], "cons");
  sprintf (S->name[1], "#=GC SS_cons");
  return S;
}

  
  

  
  
Sequence  * main_read_seq ( char *name)
       {
       char *format=NULL;
       Sequence *S=NULL;
       Alignment *A=NULL;
       int a;


       format=identify_seq_format (name);
       

       if ( getenv4debug ("DEBUG_REFORMAT"))fprintf ( stderr, "\n\nFormat %s\n", format); 

       
       if (format &&strm(format, "fasta_seq"))        
         {
           S= get_fasta_sequence ( name, NULL);
         }
       else if (format &&strm(format, "pir_seq"))     S= get_pir_sequence ( name, NULL);
       else if (format &&strm(format,"swissprot_seq"))S= get_swissprot_sequence (name, NULL); 
       else if (format && strstr (format, "aln")) 
         {
           A=main_read_aln ( name, NULL);
           S=aln2seq(A);
           ungap_seq(S);
           free_aln(A);
         }
       else if ( format && strstr (format, "tc_lib"))
         {
           int nseq,b;
           char **sequences=NULL, **seq_name=NULL;
           
           read_seq_in_list (name,&nseq,&sequences,&seq_name);             
           S=fill_sequence_struc ( nseq, sequences, seq_name);
           for ( b=0; b< S->nseq; b++)sprintf ( S->file[b], "%s",name);
           free_char (seq_name, -1);free_char (sequences, -1);
         }
       else
          {
          /*Use The ClustalW routine*/
            S=cw_read_sequences (name);
          }
       
       for ( a=0; a<S->nseq; a++)sprintf ( S->file[a], "%s", name);
       vfree(format);
       ungap_seq(S);
       S=clean_sequence ( S);
       return S;
       }

Alignment * main_read_aln ( char *name, Alignment *A)
       {
       int a;

       static char *format;
       Sequence *S=NULL;
       Sequence *IN_SEQ;
 
      
       if ( !name)return NULL;
       else if (!check_file_exists(name))
         {
           if ( !check_file_exists (name+1))return NULL;
           else if ( name[0]=='A') name++;
           else if ( name[0]=='S') name++;/*Line Added for the -convert flag of T-Coffee*/
         }
       

       if (!A)A=declare_aln(NULL);
       format=identify_seq_format (name);
       
       IN_SEQ=A->S;
       
       if      ((format && strm(format, "saga_aln" )) ||strm(format, "clustal_aln")||strm(format, "t_coffee_aln" ) )
         {
        
           read_aln ( name, A);
        
         }
       else if (format && strm (format, "conc_aln"))A=input_conc_aln (name,NULL);
       else if (format &&strm(format, "msf_aln"  ))read_msf_aln ( name, A);
       else if (format &&strm(format, "blast_aln"))read_blast_aln (name, A);
       else if (format &&(strm(format, "fasta_aln")))
                {
                  
                  
                S=get_fasta_sequence ( name, NULL);
                
                S->contains_gap=0;
                seq2aln (S, A, 0);              
                }
       else if (format &&strm(format, "pir_aln"))
                {
                S=get_pir_sequence ( name, NULL);
                S->contains_gap=0;
                seq2aln (S, A, 0);
                } 
       else if (format && strm(format, "fasta_seq") && A)
           {
           S=get_fasta_sequence ( name, NULL);
           
           for ( a=1; a<S->nseq; a++)if ( strlen (S->seq[a-1])!=strlen (S->seq[a])){free_sequence (S, S->nseq); free_aln (A); return NULL;}
           S->contains_gap=0;
           seq2aln (S, A, 0);
           }

       else if (format && strm(format, "pir_seq") && A)
           {
           S=get_pir_sequence ( name, NULL);
          
           for ( a=1; a<S->nseq; a++)if ( strlen (S->seq[a-1])!=strlen (S->seq[a])){free_sequence (S, S->nseq); free_aln (A); return NULL;}
           S->contains_gap=0;
           seq2aln (S, A, 0);
           }
       else
          {
              free_aln(A);
              return NULL;        
          }

     
         if ( check_list_for_dup( A->name, A->nseq))
          {
              fprintf ( stderr, "\nWARNING (main_read_aln): %s is duplicated in File %s ", check_list_for_dup( A->name, A->nseq), A->file[0]);
              A=aln2unique_name_aln(A);
          }
     
       if (IN_SEQ)A->S=IN_SEQ;
       else if (!A->S){A->S=aln2seq(A);}
       
       A->S=ungap_seq(A->S);
       A=fix_aln_seq(A, A->S);     
       compress_aln (A);
       for ( a=0; a< A->nseq; a++) sprintf ( A->file[a], "%s", name);
       
       A=clean_aln (A);
       return A;
       }


char * identify_aln_format ( char *file)
       {
        /*This function identify known sequence and alignmnent formats*/
         return identify_seq_format (file);
       }
char * identify_seq_format ( char *file)
       {
       char *format=NULL;
       /*This function identify known sequence and alignmnent formats*/
    
       if ( format==NULL)format=vcalloc ( 100, sizeof (char));
       else format[0]='\0';
       

       
       if ( !check_file_exists(file))
         {
           fprintf (stderr, "ERROR: %s Does Not Exist [FATAL:%s]\n",file, PROGRAM);
           myexit (EXIT_FAILURE);
         }
       else if ( is_stockholm_aln (file))sprintf (format, "stockholm_aln");
       else if ( is_blast_file (file))sprintf ( format, "blast_aln");      
       else if ( is_pdb_file(file))sprintf ( format, "pdb_struc");  
       else if ( format_is_msf      (file))sprintf ( format, "msf_aln");
       else if ( format_is_fasta_seq(file))sprintf ( format, "fasta_seq");
       else if ( format_is_fasta_aln(file))sprintf ( format, "fasta_aln");       
       else if ( format_is_pir_aln  (file))sprintf ( format, "pir_aln");
       else if ( format_is_pir_seq  (file))sprintf ( format, "pir_seq");
       else if ( format_is_oligo    (file))sprintf ( format, "oligo_aln");
       else if ( format_is_swissprot     (file))sprintf ( format, "swissprot_seq");
       else if ( format_is_saga     (file))sprintf ( format, "clustal_aln");
       else if ( format_is_conc_aln (file))sprintf ( format, "conc_aln");
       else if ( is_lib (file))sprintf ( format, "tc_lib");
       else if ( is_lib_02 (file))sprintf ( format, "tc_lib_02");
       else if ( is_newick(file))sprintf ( format, "newick_tree");
 
       else 
         {
           //add_warning ( stderr, "\nThe Format of File: %s was not recognized [SERIOUS:%s]",file, PROGRAM);
           ;
         }
       return format;
       }
char **identify_list_format ( char **list, int n)
       {
           int a;
           char *name;
           char *string;
           char mode;
        

           
           declare_name (name);
           for ( a=0; a< n; a++)
               {
                 
                 sprintf (name, "%s", list[a]);
                 string=list[a];
                 if ((mode=identify_format ( &string))!='?')
                   {
                       sprintf ( name, "%s", string);
                       sprintf ( list[a], "%c%s", mode,name);
                   }
               else
                   {
                       fprintf ( stderr, "\nERROR: %s not recognised [FATAL:%s]", name, PROGRAM);
                   }
             
               }
           
           vfree(name);
           return list;
       }
               
char * name2type_name ( char *name)
{
  /*turns <file> into <Sfile>, <Afile>...*/
  char *new_name;
  char mode;
  
  new_name=vcalloc ( strlen (name)+2, sizeof (char));
  sprintf ( new_name, "%s", name);
  if (is_in_set (name[0], "ALSMXPRW") && !check_file_exists(name))
    {
      sprintf ( new_name, "%s", name);
    }
  else
    {
      mode=identify_format (&new_name);
      sprintf ( new_name, "%c%s", mode,name);
    }
  return new_name;
}          

char identify_format (char **fname)
       {
           char mode='?';
           mode=fname[0][0];
           
           if ((is_in_set (mode, "ALMSPR") && check_file_exists(fname[0]+1)) ||(mode=='X' && is_matrix ( fname[0]+1)) ||(mode=='M' && is_method(fname[0]+1)) )
             {
               
               fname[0]++;
             }
           else if (mode=='W' && !check_file_exists(fname[0])){fname[0]++;}
           else
               {
                   
                 /*WARNING: Order matters => internal methods can be confused with files, must be checked last*/
                      if (is_lib(fname[0]))mode='L';
                      else if (is_pdb_file(fname[0]))mode='P';
                      else if (is_seq(fname[0]))mode='S';
                      else if (is_aln(fname[0]))mode='A';
                      else if (is_matrix(fname[0]))mode='X';
                      else if (is_method(fname[0]))mode='M';                  
                      else mode='?';
                  }
           return mode;
       }



int is_pdb_name ( char *name)
    {
      char command[1000];
      int result;
      char *result_file;
      static char **buf_names;
      static int   *buf_result;
      static int   nbuf;
      FILE *fp;

      
      /*Use the look up*/
      if ( !buf_names)
        {
          buf_names=declare_char (1000, 100);
          buf_result=vcalloc (1000, sizeof (int));
        }
      if ( (result=name_is_in_list ( name, buf_names,nbuf,100))!=-1)return buf_result[result];
      
      

      result_file=vtmpnam (NULL);
   
      sprintf ( command, "extract_from_pdb -is_pdb_name \'%s\' > %s", name, result_file);
      if ( getenv4debug ("DEBUG_EXTRACT_FROM_PDB"))fprintf ( stderr, "\n[DEBUG_EXTRACT_FROM_PDB:is_pdb_name] %s\n", command);
      my_system ( command);
      
      fp=vfopen ( result_file, "r");
      fscanf ( fp, "%d", &result);
      vfclose (fp);
      vremove ( result_file);
      
      sprintf ( buf_names[nbuf], "%s", name);
      result=buf_result[nbuf++]=(result==1)?1:0;

      return result;
      
    }

char*  get_pdb_id ( char *file)
{
  /*receives the name of a pdb file*/
  /*reads the structure id in the header*/
  /*returns the pdb_id*/
  char *tmp_name;
  char command[10000];
  char cached [1000];
  char fname[1000];
  FILE *fp;
  char *id;
  char buf[1000];


  tmp_name=vtmpnam(NULL);
  
  sprintf ( cached, "%s/%s", get_cache_dir(),file);
  if ( check_file_exists(cached))sprintf ( fname, "%s", cached);
  else sprintf ( fname, "%s", file);

  sprintf ( command, "extract_from_pdb -get_pdb_id %s > %s",fname, tmp_name);
  
  if ( getenv4debug ("DEBUG_EXTRACT_FROM_PDB"))fprintf ( stderr, "\n[DEBUG_EXTRACT_FROM_PDB:get_pdb_id] %s\n", command);
  my_system ( command);
  
  buf[0]='\0';
  fp=vfopen (tmp_name, "r");
  fscanf ( fp, "\n%s\n", buf);  
  vfclose (fp);

  if ( getenv4debug ("DEBUG_EXTRACT_FROM_PDB"))fprintf ( stderr, "\n[DEBUG_EXTRACT_FROM_PDB:get_pdb_id]DONE\n");
  
  id=vcalloc ( strlen (buf)+1, sizeof (char));
  sprintf ( id, "%s", buf);
  
  

  return id;  
}
    
  
char*  get_pdb_struc(char *in_name, int start, int end)
    {
      char *name1,*name2;
      char command[LONG_STRING];
      char *name;

      
      

      name=vcalloc ( STRING, sizeof (char));
      sprintf ( name, "%s", in_name);
     
      if ( (name1=is_pdb_struc(name))==NULL && (name[0]=='P' && ((name1=is_pdb_struc (name+1))==NULL)))
        {
          fprintf ( stderr, "\nERROR Could not download structure %s [FATAL:%s]\n", name, PROGRAM);crash("");
        }
      else if ( (start==0) && (end==0))return name1;
      else
        {
          declare_name(name2);
          sprintf ( name2, "%s_%d_%d.pdb", name, start, end);
          sprintf ( command, "extract_from_pdb -infile \'%s\' -chain FIRST -coor %d %d > %s%s",check_file_exists(name1),start, end, get_cache_dir(),name2);
          if ( getenv4debug ("DEBUG_EXTRACT_FROM_PDB"))fprintf ( stderr, "\n[DEBUG_EXTRACT_FROM_PDB:get_pdb_struc] %s\n", command);
          my_system (command);

          if ( is_pdb_file(name2))return name2;
          else
            {
              fprintf ( stderr, "\nERROR Could not extract segment [%d %d] from structure %s [FATAL:%s]\n",start, end, name, PROGRAM);crash("");
            }
          myexit (EXIT_FAILURE);
        }

      return NULL;
    }

char*  seq_is_pdb_struc ( Sequence *S, int i)
{
  
  if (!S){return NULL;}
  else if ( !S->T[i]){return NULL;}
  else if ( !((S->T[i])->P)){return NULL;}
  else return ((S->T[i])->P)->template_file;
}
char*  is_pdb_struc ( char *name)
   {
     /*Receives a name
       checks if this is the name of a local file that contains PDB data
       checks if this is the name of a file from a local db
                                            put the file in the cache
       checks if this is a file from a remote db (extract_from_pdb
       return NULL if everything fails
     */

     static char *file_name1;
     static char *file_name2;
          
     static char **buf_names;
     static char **buf_result;
     static int   nbuf, s;
    
     
     char *r=NULL;
     char command[1000];
     

     if ( !name || name[0]=='\0')return NULL;
       

     /*Use the look up*/
     if ( !buf_names)
        {

          buf_names=vcalloc ( 1000, sizeof (char*));
          buf_result=vcalloc ( 1000, sizeof (char*));
          file_name1=vcalloc ( 1000, sizeof (char));
          file_name2=vcalloc ( 1000, sizeof (char));
        }
     if ( (s=name_is_in_list ( name, buf_names,nbuf,-1))!=-1)return buf_result[s];
      

     r=NULL;
     sprintf ( file_name1, "%s", name);
     sprintf ( file_name2, "%s.pdb", name);
     
     
     if (is_pdb_file(file_name1)){r=file_name1;}
     else if (is_pdb_file(file_name2)){r=file_name2;}
     else if (is_pdb_name (name))
       {
         printf_system ("extract_from_pdb -netfile \'%s\' > %s/%s 2>/dev/null",name, get_cache_dir(), file_name2);
         if ( is_pdb_file(file_name2))r=file_name2; 
         else r=NULL;    
         
       }
     

      /*Fill the buffer*/
     buf_names[nbuf]=vcalloc ( strlen (name)+1, sizeof (char)); 
     sprintf ( buf_names[nbuf], "%s", name);
     if ( r)
       {
         buf_result[nbuf]=vcalloc ( strlen (r)+1, sizeof (char));
         sprintf (buf_result[nbuf], "%s", r);
       }
     else buf_result[nbuf]=NULL;      
     nbuf++;

     return r;
   }

char *fix_pdb_file ( char *in)
{
  char *empty;
  
  empty=vcalloc(1, sizeof(char));

  if ( !in || !check_file_exists (in))return empty;
  else if ( is_pdb_file(in))return in;
  else
    {
      char command[10000];
      char *tmp;
      char *tmp2;
      tmp=vtmpnam (NULL);
      tmp2=vcalloc (strlen (tmp)+1, sizeof (char));
      sprintf (tmp2, "%s", tmp);
      sprintf ( command, "extract_from_pdb %s > %s", check_file_exists(in), tmp2);
      my_system (command);
      if ( is_pdb_file (tmp))return tmp2;
      else return empty;

    }
}

int is_sap_file ( char *name)
        {
        FILE *fp;
        if (!name);
        if (!check_file_exists(name))return 0;
        
        if ((fp=find_token_in_file (name, NULL, "Percent"))!=NULL)
          {
            if ((fp=find_token_in_file (name,fp, "Percent"))!=NULL)
              {
                vfclose (fp);
                return 1;
              }
            else
              { 
                return 0;
              }
          }
        else
          {
            return 0;
          }
        }


int is_blast_file ( char *name)
       {
         if ( !check_file_exists(name) ) return 0;
         else if (token_is_in_file (name, "<SequenceSimilaritySearchResult>"))
           {
             return BLAST_XML;
           }
         else
           {
             if (token_is_in_file (name, "Lambda") && token_is_in_file (name, "Altschul,"))
               {
                 return BLAST_TXT;
               }
             else
               {
                 return 0;
               }
           }
         return 0;
       }
int is_simple_pdb_file ( char *name)
{
  FILE *fp;
  if ((fp=find_token_in_file (name, NULL, "SIMPLE_PDB_FORMAT"))!=NULL){vfclose (fp);return 1;}
  return 0;
}


int is_pdb_file ( char *name)
       {
         FILE *fp;
         int ispdb=0;
         
         if ( name==NULL) return 0;
         if (!check_file_exists (name))return 0;
         
         if ((fp=find_token_in_file (name, NULL, "\nHEADER"))!=NULL)
           {vfclose (fp);
             ispdb++; 
           }
         if ((fp=find_token_in_file (name, NULL, "\nSEQRES"))!=NULL)
           {
             vfclose (fp);
             ispdb++;
           }
         
         if ((fp=find_token_in_file (name, NULL, "\nATOM"))!=NULL)
           {
             vfclose (fp);
             ispdb++;
           }
         else
           {
             ispdb=0;
           }
         
         
         if ( ispdb>=2)return 1;
         else return 0;
       }
int is_seq ( char *name)
       {
         char *format;

         if ( !check_file_exists(name))return 0;
         
         format= identify_seq_format(name);
         if(!format || format[0]=='\0'){vfree (format);return 0;}
         else if (strstr(format, "seq")){vfree (format);return 1;}
         else return 0;
       }
int is_aln ( char *name)
       {
       char *format;     
       if ( !check_file_exists       (name))return 0;   
        
       format= identify_seq_format(name);
       if ( !format || format[0]=='\0'){vfree (format);return 0;}
       else if (strstr(format, "aln")){vfree (format); return 1;}
       else return 0;
       }   

int is_matrix (char *name)
       {
       int **m;
       
       if ((m=read_matrice (name))!=NULL){free_int (m, -1); return 1;}
       return 0;              
       }
int is_newick (char *name)
   {
     int c;
     FILE *fp;
     

     fp=vfopen (name, "r");
     if ( (c=fgetc(fp))!='('){vfclose (fp); return 0;}


     while ( (c=fgetc(fp))!=EOF)
       {
         if ( c==';'){vfclose (fp); return 1;}
       }
     vfclose (fp);
     return 0;
   }

int is_clustalw_matrix ( char *name)
{
       
  FILE *fp;


       if ( (fp=find_token_in_file (name, NULL, "CLUSTALW_MATRIX"))!=NULL){vfclose(fp);return 1;}
       else return 0;
}
int is_pavie_matrix ( char *name)
{
       
  FILE *fp;


       if ( (fp=find_token_in_file (name, NULL, "PAVIE_MATRIX"))!=NULL){vfclose(fp);return 1;}
       else return 0;
}
int is_distance_matrix_file (char *name)
{
  FILE *fp;
  if ( (fp=find_token_in_file (name, NULL, "TC_DISTANCE_MATRIX_FORMAT_01"))!=NULL){vfclose(fp);return 1;}
  else return 0;
}  
int is_similarity_matrix_file (char *name)
{
  FILE *fp;
  if ( (fp=find_token_in_file (name, NULL, "TC_SIMILARITY_MATRIX_FORMAT_01"))!=NULL){vfclose(fp);return 1;}
  else return 0;
}  
int is_blast_matrix ( char *name)
{
       
  FILE *fp;


  if ( (fp=find_token_in_file (name, NULL, "BLAST_MATRIX"))!=NULL){vfclose(fp);return 1;}
       else return 0;
}

int is_single_seq_weight_file ( char *name)
{
 
  
  return token_is_in_file ( name, "SINGLE_SEQ_WEIGHT_FORMAT_01");
  
}
int is_stockholm_aln (char *file)
{
  FILE *fp;
  
  if ((fp=find_token_in_file_nlines (file, NULL, "STOCKHOLM",2)))
    {
      vfclose (fp);
      return 1;
    }
  return 0;
}

int is_lib ( char *name)
{
  return is_lib_01(name);
}

int is_lib_02 ( char *name)
{
  
  return token_is_in_file ( name, "TC_LIB_FORMAT_02");
  
}

int is_lib_01 (char *name)
       {

         
         if ( token_is_in_file ( name, "TC_LIB_FORMAT_01")) return 1;
         else if (token_is_in_file ( name, "T-COFFEE_LIB_FORMAT_01"))return 1;
         else if (token_is_in_file (name, "SEQ_1_TO_N"))return 1;
         else return 0;
       }
int is_lib_list ( char *name)
{
  if ( !check_file_exists (name))return 0;
  if ( token_is_in_file ( name, "TC_LIB_LIST_FORMAT_01")) return 1;
  return 0;
}
int is_method ( char *file)
    {
        char new_file[200];

        
        sprintf ( new_file, "%s", file);
        if ( (token_is_in_file(new_file, "TC_METHOD_FORMAT_01"))){return 1;}
        if ( is_in_pre_set_method_list(new_file)) 
            {
        
                vremove ( new_file);
                return 1;
            }
        else
          {
        
            return 0;
          }
    }

/*******************************************************************************************/
/*                                                                                         */
/*                                                                                         */
/*                              SEQUENCE FORMAT IDENTIFIERS                                */
/*                                                                                         */
/***************************************************************************************** */
int type_is_exon_boundaries(char **seq, int n)
{
  int a, l, b;
  for (a=0; a<n; a++)
    {
      l=strlen (seq[a]);
      for (b=0; b<l; b++)
        if ( strchr ("bojBOJ", seq[a][b]))return 1;
    }
  return 0;
}

int format_is_oligo(char *file)
    { 
    char *buf=NULL;
    FILE *fp;
    int r=0;
    
    fp=vfopen ( file, "r");
    buf=vfgets(buf,fp);
    vfclose ( fp);
    

    if ( strm (buf, "ALPHABET"))r=1;
    
    vfree (buf);
    
    return r;
    }
int format_is_msf ( char *file)
    {
    char buf[1000];
    FILE *fp;

   
    
    if ( (fp=find_token_in_file_nlines (file,NULL,"MSF:", 30))!=NULL){vfclose (fp);return 1;}
    else
      {
       return 0;
      }
    
    fp=vfopen ( file, "r");
    fscanf (fp , "%s", buf);
    vfclose ( fp);

    if ( strm (buf, "MSF:"))return 1;
    return 0;
    }

//Fasta and PIR
int format_is_fasta_aln ( char *file)

    {
      if ( format_is_fasta(file) && !format_is_fasta_seq(file))return 1;
      else return 0;
    }


int format_is_fasta_seq  ( char *file)
    {
      int a, l1, l2,l;
      Sequence *S;

      if ( format_is_fasta (file))
        {       
        S=get_fasta_sequence (file, NULL);
        if (!S) return 0;
        else if ( !S->seq[0]){free_sequence (S, S->nseq); return 1;}
        l=strlen ( S->seq[0]);
        for ( a=0; a< S->nseq; a++)if(strlen(S->seq[a])!=l){free_sequence (S, S->nseq);return 1;}
        for ( a=0; a< S->nseq; a++)
          {
            l1=strlen ( S->seq[a]);
            ungap (S->seq[a]);
            l2=strlen ( S->seq[a]);
            if ( l1!=l2)
              {
                free_sequence (S, S->nseq);
                return 0;
              }
          }
        free_sequence (S, S->nseq);
        return 1;
      }
    else
      {
        return 0;
      }
    }

int format_is_fasta ( char *file)
    {
      Sequence *S;
      
      if ( !check_file_exists(file))return 0;

      if ( get_first_non_white_char (file)!='>')return 0;
      if ( !(S=get_fasta_sequence (file, NULL)))return 0;
      free_sequence (S, -1);
      if ( format_is_pir(file)) return 0;
      return 1;
    }

int format_is_pir_aln ( char *file)

    {
      if ( format_is_pir(file) && !format_is_pir_seq(file))return 1;
      else return 0;
    }

int format_is_pir_seq ( char *file)
    {
      int a, l1, l2;
      Sequence *S;

      
    if ( format_is_pir (file))
      {
        S=get_pir_sequence (file, NULL);
        for ( a=0; a< S->nseq; a++)
          {
            l1=strlen ( S->seq[a]);
            ungap (S->seq[a]);
            l2=strlen ( S->seq[a]);
            if ( l1!=l2)
              {
                free_sequence (S, S->nseq);
                return 0;
              }
          }
        return 1;
      }
    else
      {
        return 0;
      }
    }
    

int format_is_pir ( char *file)
    {
      Sequence *S;
      int pir_name=1, star_end=1, a;
      
      S=get_fasta_sequence (file, NULL);
      if (!S)return 0;
      else if (!S->seq[0])return 0;
      
      pir_name=1; star_end=1;
      for (a=0; a< S->nseq; a++)
        {
          int l;
          if (!is_pir_name(S->name[a]))pir_name=0;
          l=strlen (S->seq[a]);
          if (!l || (l && S->seq[a][l-1]!='*'))
            star_end=0;
        }
      free_sequence(S,-1);
      if ( pir_name && star_end) return 1;
      else return 0;
    }
int is_pir_name (char *name)
{
  if ( strstr (name, "P1;"))return 1;
  if ( strstr (name, "F1;"))return 1;
  if ( strstr (name, "DL;"))return 1;
  if ( strstr (name, "DC;"))return 1;
  if ( strstr (name, "RL;"))return 1;
  if ( strstr (name, "RC;"))return 1;
  if ( strstr (name, "XX;"))return 1;
  return 0;
}
  
  
int format_is_conc_aln (char *file)
{
  FILE *fp;
  if ( (fp=find_token_in_file (file, NULL, "CONC_MSF_FORMAT_01"))){vfclose (fp); return 1;}
  return 0;
}
int format_is_saga ( char *file) 
    {
    FILE *fp;
    int **list;
    int n_blocks;
    int n_seq;
    int a, b;
    
    if ( (fp=find_token_in_file (file, NULL, "SAGA"))){vfclose (fp); return 1;}
    else if  ((fp=find_token_in_file (file, NULL, "CLUSTAL"))){vfclose (fp); return 1;}
    else if  ((fp=find_token_in_file (file, NULL, "ClustalW"))){vfclose (fp); return 1;}
    else if  ((fp=find_token_in_file (file, NULL, "clustalw"))){vfclose (fp); return 1;}
    else if  ((fp=find_token_in_file (file, NULL, "clustal"))){vfclose (fp); return 1;}
    else if  ((fp=find_token_in_file (file, NULL, "T-COFFEE_MSA"))){vfclose (fp); return 1;}
    else if  ((fp=find_token_in_file (file, NULL, "INTERLEAVED_MSA"))){vfclose (fp); return 1;}
    
    else return 0;
    
    if (1==1);
    else if  ((fp=find_token_in_file (file, NULL, "T-COFFEE"))){vfclose (fp); return 1;}
    else if  ((fp=find_token_in_file (file, NULL, "SAGA_FORMAT"))){vfclose (fp); return 1;}
    else if  ((fp=find_token_in_file (file, NULL, "GARP"))){vfclose (fp); return 1;}
    else if  ((fp=find_token_in_file (file, NULL, "INTERLEAVED"))){vfclose (fp); return 1;}
    
    else 
       {
           list=get_file_block_pattern (file,&n_blocks,100); 
           if (n_blocks<=2){free_int (list, -1);return 0;}
           else 
               {                  
               n_seq=list[1][0];
               for ( a=1; a< n_blocks-1; a++)
                   {
                       if ( list[a][0]!=n_seq){free_int (list, -1);return 0;}
                       else
                       {
                           for ( b=1; b<=list[a][0]; b++)
                               if ( list[a][b]!=2){free_int (list, -1);return 0;}
                       }
                   }
               }
           return 1;
       }
    
    return 0;
    }


int format_is_swissprot (char *name)
    {
      FILE *fp;
      
      if ( !check_file_exists(name))return 0;
         
         
   
    
      if (   (fp=find_token_in_file_nlines (name,NULL,"\nID ",10))!=NULL\
           &&(fp=find_token_in_file (name,NULL,"\nSQ "))!=NULL  )
        {
          
          vfclose (fp);return 1;
        }
      else
        {
          return 0;
        }
    } 

/*******************************************************************************************/
/*                                                                                         */
/*                                                                                         */
/*                               OUTPUT STUFF                                              */
/*                                                                                         */
/***************************************************************************************** */               
int output_format_aln ( char *format, Alignment *inA, Alignment *inEA,char *name)
        {
        Sequence_data_struc *D1=NULL;
        Sequence_data_struc *D2=NULL;
        Alignment *A=NULL;
        Alignment *EA=NULL;
        
        
        A =copy_aln (inA, NULL);
        A->CL=inA->CL;
        EA=copy_aln (inEA,NULL);
        A =expand_aln(A);
        EA=expand_number_aln(inA,EA);   
        
        
        if (A && A->expanded_order  )A=reorder_aln ( A, A->expanded_order,A->nseq);  
        if (EA && EA->expanded_order)EA=reorder_aln ( EA, EA->expanded_order,EA->nseq);  

          
        D1=vcalloc ( 1, sizeof (Sequence_data_struc));
        D1->A=A;
        if (EA)
           {
           D2=vcalloc ( 1, sizeof (Sequence_data_struc));
           D2->A=EA;
           }
        
        main_output ( D1, NULL,D2, format, name);
        
        vfree(D1);
        vfree(D2);
        free_aln (A);
        free_aln (EA);
        return 1;
        }
int main_output  (Sequence_data_struc *D1, Sequence_data_struc *D2, Sequence_data_struc *DST, char *out_format, char *out_file)

        {  
        FILE *fp;
        int value;
        Alignment *BUF_A;
        int expanded=0;
        
        if ( !out_format[0])return 0;
        if ( D1 && D1->rm_gap)ungap_aln ((D1->A));
        
        if ( (strstr (out_format, "expanded_")))
          {
            if (!D1) return 1;
            out_format+=strlen ("expanded_");
            BUF_A=copy_aln (D1->A, NULL);
            (D1->A)=thread_profile_files2aln ((D1->A), NULL, NULL);
            expanded=1;
          }
        
        if ( strm (out_format, ""))return 0;
        else if (    ( strm (out_format, "aln2lib")))
          {
            int a, b, c;
            int r1,r2,s1, s2,s;
            Constraint_list *CL;
            FILE *fp;
            Alignment *IN;
            int **pos;
            
            if (!D1)return 1;
            IN=D1->A;
            CL=(D1->A)->CL;
            pos=aln2pos_simple(IN, IN->nseq);
            fp=vfopen (out_file, "w");
            fp=save_list_header (fp,CL);
            
          
            for ( b=0; b< IN->nseq-1; b++)
              {
                for ( c=b+1; c< IN->nseq; c++)
                  {
                    s1=IN->order[b][0];
                    s2=IN->order[c][0];
                    fprintf ( fp, "#%d %d\n", s1+1, s2+1);
                    for ( a=0; a< IN->len_aln; a++)
                      {
                        r1=pos[b][a];
                        r2=pos[c][a];

                        if ( s1==s2 && !CL->do_self)continue;
                        
                        if ( s1< s2)s=(CL->evaluate_residue_pair)( CL, s1, r1, s2, r2);
                        else        s=(CL->evaluate_residue_pair)( CL, s2, r2, s1, r1);
                        
                        s=(s!=UNDEFINED)?s:0;
                        if ( r1>0 && r2>0)
                          {
                            fprintf (fp, "\t%5d %5d %5d \n", r1, r2, s);
                          }
                      }
                  }
              }
             vfclose (save_list_footer (fp, CL));
          }
        else if      ( strncmp (out_format, "score",5)==0 || strm (out_format, "html"))
                {
                  Alignment *BUF;

                  if (!D1)return 1;
                  if ( !DST) 
                    {
                      fprintf ( stderr,"\n[You Need an evaluation File: Change the output format or use +evaluate][FATAL:%s]\n", PROGRAM);      
                      myexit(EXIT_FAILURE);
                    }
                  if ( !strm ("html", out_format))while ( out_format[0]!='_' && out_format[0]!='\0' )out_format++;
                  
                  D1->S=aln2seq(D1->A);
                  BUF=copy_aln (DST->A, NULL);
                  DST->A=aln2number (DST->A);
                  
                  if     ( strstr ( out_format, "html"  ))output_reliability_html  ( D1->A,  DST->A, out_file);
                  else if( strm ( out_format, "_ps"    ))output_reliability_ps    ( D1->A,  DST->A, out_file);
                  else if( strm ( out_format, "_pdf"   ))output_reliability_pdf   ( D1->A,  DST->A, out_file);  
                  else if( strm ( out_format, "_ascii" ))output_reliability_ascii ( D1->A,  DST->A, out_file);  
                  else if( strm ( out_format, "_seq"   ))output_seq_reliability_ascii ( D1->A,  DST->A, out_file);
                  else
                    {
                      DST->A=BUF;
                      main_output (DST, NULL, NULL, out_format+1, out_file);
                    }
                }
        else if (strm (out_format, "sec_html") || strm (out_format, "_E_html"))
          {
            Alignment *ST, *A;
            Sequence *S;
            
            int a, b,c,i, ns=0;
            char *buf;
            if (!D1)return 1;
            A=D1->A;
            
            
            S=A->S;
            ST=copy_aln (A, NULL);
            for (a=0; a<ST->nseq; a++)
              {
                i=name_is_in_list (ST->name[a],S->name, S->nseq, 100);
                if ( i!=-1)
                  {
                    buf=seq2E_template_string(S, i);
                    if ( buf==NULL)continue;
                    else ns++;
                    for (c=0,b=0; b<ST->len_aln; b++)
                      {
                        int r1, s;
                        r1=ST->seq_al[a][b];
                        if ( r1!='-')
                          {
                            s=tolower (buf[c]);
                            if (s=='e')r1='0';
                            else if (s=='h')r1='9';
                            else if (s=='c')r1='5';
                            c++;
                          }
                        ST->seq_al[a][b]=r1;
                      }
                  }
              }
            
            if (!ns)
              {
                add_warning ( stderr, "Cannot output tm_html:_E_ template file (sec. struc.) is required for this output ", PROGRAM);
              }
            output_color_html  ( A, ST, out_file);
          }
        else if (strm (out_format, "tm_html") || strm (out_format, "_T_html"))
          {
            Alignment *ST, *A;
            Sequence *S;
            
            int a, b,c,i, ns=0;
            char *buf;
            if (!D1)return 1;
            A=D1->A;
            A->output_tm = 1;
            
            S=A->S;
            ST=copy_aln (A, NULL);
            for (a=0; a<ST->nseq; a++)
              {
                i=name_is_in_list (ST->name[a],S->name, S->nseq, 100);
                if ( i!=-1)
                  {
                    buf=seq2T_template_string(S, i);
                    if ( buf==NULL)continue;
                    else ns++;
                    for (c=0,b=0; b<ST->len_aln; b++)
                      {
                        int r1, s;
                        r1=ST->seq_al[a][b];
                        if ( r1!='-')
                          {
                            s=tolower (buf[c]);
                            if (s=='o')r1='0';
                            else if (s=='h')r1='9';
                            else if (s=='i')r1='5';
                            c++;
                          }
                        ST->seq_al[a][b]=r1;
                      }
                  }
              }
            
            if (!ns)
              {
                add_warning ( stderr, "Cannot output tm_html:_T_ template file (trans. Memb. ) is required for this output ", PROGRAM);
              }
            output_color_html  ( A, ST, out_file);
          }
        
        else if (strm (out_format, "color_exoset"))
          {
            Alignment *ST, *EX, *A;
            Constraint_list *CL;
            int a, b, n;
            char *buf;
            
            if ( !DST->A)
              {
                printf_exit ( EXIT_FAILURE, stderr, "\nYou must provide an obj file via the -struc_in flag [FATAL:%s]", PROGRAM);
              }
            EX=DST->A;
            A=D1->A;
            
            CL=declare_constraint_list ( DST->S,NULL, NULL, 0,NULL, read_matrice("pam250mt"));
            
            ST=copy_aln (A, NULL);
            buf=vcalloc ( EX->len_aln+1, sizeof (int));
            
            for ( a=0; a< A->nseq; a++)
              {
                int i;
                                
                i=name_is_in_list (A->name[a],EX->name, EX->nseq, -1);
                if ( i==-1)continue;
                                
                sprintf ( buf, "%s", EX->seq_al[i]);
                ungap (buf);
                
                for (n=0,b=0; b<A->len_aln; b++)
                  {
                    if (!is_gap(A->seq_al[a][b]))
                      {
                        if ( buf[n]=='o')
                          ST->seq_al[a][b]='0';
                        else if ( buf[n]=='j')
                          ST->seq_al[a][b]='1';
                        else if ( buf[n]=='b')
                          ST->seq_al[a][b]='2';
                        n++;
                      }
                  }
              }
            vfree (buf);
        
            output_color_html  ( A, ST, out_file);
            return EXIT_SUCCESS;
          }
        
        else if (strm (out_format, "color_protogene"))
          {
            int n, a, b;
            DST->A=copy_aln (D1->A, NULL);
            for (n=1,a=0; a< (D1->A)->len_aln; a++, n++)
              {
                for ( b=0; b<(D1->A)->nseq; b++)
                  {
                    if (is_gap((D1->A)->seq_al[b][a]));
                    else if ( n<=3)(DST->A)->seq_al[b][a]=2;
                    else if ( n>3)(DST->A)->seq_al[b][a]=9;
                  }

                if ( n==6)n=0;
              }
            output_color_html  ( D1->A,  DST->A, out_file);
            return EXIT_SUCCESS;
            
          }
        else if      ( strncmp (out_format, "color",5)==0)
         {
           Alignment *BUF;
          
           if (!D1)return 1;
           
           if ( !DST) 
             {
               fprintf ( stderr,"\n[You Need an evaluation File: Change the output format or use +evaluate][FATAL:%s]\n", PROGRAM);     
               myexit(EXIT_FAILURE);
             }
           while ( out_format[0]!='_' && out_format[0]!='\0' )out_format++;
           
           BUF=copy_aln (DST->A, NULL);

        
        

           if     ( strm ( out_format, "_html"  ))output_color_html  ( D1->A,  DST->A, out_file);
           else if( strm ( out_format, "_ps"    ))output_color_ps    ( D1->A,  DST->A, out_file);
           else if( strm ( out_format, "_pdf"   ))output_color_pdf   ( D1->A,  DST->A, out_file);       
           else if( strm ( out_format, "_ascii"   ))output_color_ascii   ( D1->A,  DST->A, out_file);   
           else
             {
               DST->A=BUF;
               return main_output (DST, NULL, NULL, out_format+1, out_file);
             }
           return EXIT_SUCCESS;
         }
        else if ( strm4  ( out_format, "tc_aln","t_coffee_aln", "t_coffee", "tcoffee"))
          {
            if (!D1)return 1;
            vfclose (output_aln ( D1->A, vfopen (out_file, "w")));
          }
        else if ( strm  ( out_format, "analyse_pdb"))
          {
            if (!D1)return 1;
            if ( !DST) 
              {
                fprintf ( stderr,"\n[You Need an evaluation File: Change the output format][FATAL:%s]\n", PROGRAM);     
                myexit(EXIT_FAILURE);
              }
            analyse_pdb ( D1->A,DST->A, "stdout");
            (DST->A)=aln2number (DST->A);
            output_reliability_ps    ( D1->A,  DST->A, out_file);
          }
        else if ( strm4 ( out_format, "lower0", "lower1", "lower2", "lower3") || strm4(out_format, "lower4", "lower5", "lower6", "lower7") || strm4 (out_format,"lower8", "lower9", "align_pdb", "malign_pdb") )
          {
            if (!D1)return 1;
            if ( !DST) 
              {
                fprintf ( stderr,"\n[You Need an evaluation File: Change the output format][FATAL:%s]\n", PROGRAM);     
                myexit(EXIT_FAILURE);
              }
            
            
            
            (DST->A)=aln2number (DST->A);
            if ( strm (out_format, "align_pdb"))value=0;
            else if (  strm (out_format, "malign_pdb"))value=5;
            else value=atoi(out_format+5);
            
            D1->A=filter_aln_upper_lower (D1->A, DST->A,0, value);
            output_clustal_aln ( out_file, D1->A);
          }
        else if ( strnm (out_format, "repeat", 6))
          {
            int size;
            int a, b, c;
            Alignment *CONC;
            
            if ( !D1)return 1;
            size=atoi (out_format+6);
            print_aln (D1->A);
            CONC=declare_aln2 ( (D1->A)->nseq, ((D1->A)->len_aln+1)*size+1);

            for ( a=0; a< (D1->A)->nseq; a++)(D1->A)->seq_al[a][(D1->A)->len_aln]='\0';
            for ( c=0,a=0; a< (D1->A)->nseq;c++)
              {
                
                sprintf ( CONC->name[c], "%s", (D1->A)->name[a]);
                for ( b=0; b<size; b++, a++)
                  {
                    strcat (CONC->seq_al[c], (D1->A)->seq_al[a]);
                    strcat (CONC->seq_al[c], "O");
                  }
              }
            CONC->nseq=c;CONC->len_aln=strlen (CONC->seq_al[0]);
            output_clustal_aln ( out_file, CONC);
            free_aln (CONC);
          }
        
        else if ( strnm (out_format, "upper", 5))
              {
                
                if (!D1)return 1;
                if ( !DST) 
                   {
                   fprintf ( stderr,"\n[You Need an evaluation File: Change the output format][FATAL:%s]\n", PROGRAM);  
                   myexit(EXIT_FAILURE);
                   }
                
                
                (DST->A)=aln2number (DST->A);

                value=atoi(out_format+5);

                D1->A=filter_aln_lower_upper (D1->A, DST->A,0, value);
                output_clustal_aln ( out_file, D1->A);
              }
        
        else if ( strm4 ( out_format, "filter0", "filter1", "filter2", "filter3"))
               {
               if (!D1)return 1;
               if ( !DST) 
                   {
                   fprintf ( stderr,"\n[You Need an evaluation File: Change the output format][FATAL:%s]\n", PROGRAM);  
                   myexit(EXIT_FAILURE);
                   }
                
               (DST->A)=aln2number (DST->A);
               
               D1->A=filter_aln (D1->A, DST->A, atoi(out_format+6));
               output_clustal_aln ( out_file, D1->A);
               }
        
        else if ( strm3 ( out_format, "phylip_aln", "phylip", "phy"))
                {
                if (!D1)return 1;
                output_phylip_aln ( out_file, D1->A);
                }
        else if ( strm ( out_format, "mocca_aln"))
                {
                if (!D1)return 1;
                output_mocca_aln ( out_file, D1->A, DST->A);
                }       
        else if ( strm ( out_format, "saga_pw_sd_weights") )
                {
                if (!D1)return 1;
                output_pw_weights4saga ((D1->W),(D1->W)->PW_SD, out_file);
                }
        else if ( strm ( out_format, "saga_aln"))
                {
                if (!D1)return 1;
                output_saga_aln (out_file, D1->A);
                }
        else if (strm2 ( out_format, "aln","clustal_tc")|| strm (out_format, "msa"))
          {              
           
            if (!D1)return 1;
            output_clustal_aln (out_file, D1->A);
          }
        else if (strm5 ( out_format, "strict_clustal","clustal_aln", "clustalw","clustal", "clustalw_aln") || strm (out_format,"number_aln"))
          {              
            if (!D1)return 1;
            output_strict_clustal_aln (out_file, D1->A);
          }
        else if ( strm ( out_format, "conc_aln"))
              {
                if (!D1)return 1;
                output_conc_aln (out_file, D1->A);
                }
        else if ( strm2 ( out_format, "lalign_aln","lalign"))
                {
                if (!D1)return 1;
                output_lalign (out_file, D1->A);
                }
        else if ( strm2 ( out_format, "glalign_aln","glalign"))
                {
                if (!D1)return 1;
                output_glalign (out_file, D1->A, DST->A);
                }
        
        else if ( strm2 ( out_format, "fasta_aln","fasta" ) || strm (out_format, "blast_aln"))
                {
                if (!D1)return 1;
                output_fasta_aln( out_file, D1->A);
                }
        else if ( strstr (out_format, "overaln"))
                {
                
                  char *s, mode[100];
                  OveralnP *F;
                  int eb=0;
                  if (!D1) return 1;
                  F=vcalloc (1, sizeof (OveralnP));
                  ungap_aln (D1->A);
                  string_array_upper ((D1->A)->seq_al, (D1->A)->nseq);
                  if ( D2 && D2->A)
                    {
                      D1->A=mark_exon_boundaries (D1->A, D2->A);
                      eb=1;
                    }
                  else if ( (s=get_string_variable ("exon_boundaries")))
                    {
                      Sequence *S;
                      Alignment *EB;
                      EB=seq2aln(S=main_read_seq(s),NULL, 0);
                      D1->A=mark_exon_boundaries (D1->A, EB);
                      free_sequence (S, S->nseq); free_aln (EB);
                      eb=1;
                    }
                  if ( strstr (out_format, "lower")) sprintf (F->mode,"lower");
                  else if (strstr (out_format, "unalign2"))sprintf (F->mode, "unalign2");
                  else if (strstr (out_format, "unalign"))sprintf (F->mode, "unalign");
                  else sprintf (F->mode, "%s", ((s=get_string_variable ("overaln_mode")))?s:"lower");
                  if (!strm (F->mode, "lower") && !strm (F->mode, "unalign") && !strm (F->mode, "unalign2"))printf_exit (EXIT_FAILURE,stderr,"\nERROR: unknown overaln_mode in overaln output [%s] [FATAL:%s]", mode, PROGRAM);
                  
                  if (int_variable_isset ("overaln_threshold"))F->t=get_int_variable ("overaln_threshold");
                  if (int_variable_isset ("overaln_target"))F->f=get_int_variable ("overaln_target");
                  if (int_variable_isset ("overaln_P1"))F->p1=get_int_variable ("overaln_P1");
                  if (int_variable_isset ("overaln_P2"))F->p2=get_int_variable ("overaln_P2");
                  if (int_variable_isset ("overaln_P3"))F->p3=get_int_variable ("overaln_P3");
                  if (int_variable_isset ("overaln_P4"))F->p4=get_int_variable ("overaln_P4");
                  
                  if (eb)sprintf (F->model, "fsa2");
                  else   sprintf (F->model, "fsa1");
                  D1->A=aln2clean_pw_aln (D1->A, F);
                  
                  //if (eb)D1->A=aln2clean_pw_aln (D1->A, mode,t, f,p1,p2,p3, "fsa2");
                  //else   D1->A=aln2clean_pw_aln (D1->A, mode,t, f,p1,p2,p3, "fsa1");
        
                  D1->S=aln2seq(D1->A);
                  output_clustal_aln (out_file, D1->A);
                } 
        else if ( strm ( out_format, "est_prf" ))
                {
                if (!D1)return 1;
                output_est_prf( out_file, D1->A);
                }
        else if ( strm ( out_format, "clean_est_fasta_seq" ))
                {
                if (!D1)return 1;
                D1->A=clean_est(D1->A);
                output_fasta_seq(out_file, D1->A);
                
                }
        
        else if ( strm3 ( out_format, "msf_aln", "gcg", "msf"))
                {
                if (!D1)return 1;
                output_msf_aln( out_file, D1->A);
                }
        else if ( strm ( out_format, "rnalign"))
                {
                if (!D1)return 1;
                output_rnalign (out_file, D1->A, DST->S);
                }
        else if ( strm ( out_format, "tblastx_db1"))
          {
            seq2tblastx_db (out_file,D1->S,1);
          }
        else if ( strm ( out_format, "tblastx_db") || strm (out_format, "tblastx_db3"))
          {
            seq2tblastx_db (out_file,D1->S,3);
          }
        else if ( strm ( out_format, "tblastx_db2"))
          {
            seq2tblastx_db (out_file,D1->S,2);
          }
        else if ( strm ( out_format, "fasta_seq") ||strm ( out_format, "list")||strm ( out_format, "file_list"))
          {

                if (!D1)return 1;
                output_fasta_seq (out_file,D1->A);
                }
        else if (strm (out_format, "fasta_tree") )
                {
                if (!D1)return 1;
                output_fasta_tree (out_file,D1->A);
                }
        
        else if ( strm ( out_format, "gotoh_seq"))
                {
                if (!D1)return 1;
                output_gotoh_seq (out_file,D1->A);
                }
        else if ( strm (out_format, "fasta_seq1"))
                {
                if (!D1)return 1;
                output_fasta_seq1 (out_file, D1->A);
                }
        else if ( strm2 (out_format, "pir_aln", "pir"))
                {
                if (!D1)return 1;
                output_pir_aln (out_file, D1->A);
                }
        else if ( strm (out_format, "pir_seq"))
                {
                if (!D1)return 1;
                output_pir_seq (out_file, D1->A);
                }
        else if ( strm (out_format, "gor_seq"))
                {
                if (!D1)return 1;
                output_gor_seq (out_file, D1->A);
                }
        else if ( strm (out_format, "pir_seq1"))
                {
                  if (!D1)return 1;
                output_pir_seq1 (out_file, D1->A);
                }
        else if ( strm (out_format, "pw_lib_saga_aln"))
                {
                  if (!D1)return 1;
                output_pw_lib_saga_aln (out_file, D1->A);
                }
        else if ( strm (out_format, "lib"))
                {
                  if (!D1)return 1;
                output_lib (out_file, D1->A);
                }
        else if ( strm (out_format, "pdb_constraint_list"))
                {
                  if (!D1)return 1;
                output_constraints (out_file, "pdb",D1->A);
                }
        else if ( strm2 (out_format, "constraint_list","tc_lib"))
                {
                  
                  if (!D1)return 1;
                  else if (!D1->CL)output_constraints (out_file,"sim", D1->A);
                  else if (D1->CL) vfclose ( save_constraint_list ( D1->CL, 0, (D1->CL)->ne, out_file, NULL, "ascii",(D1->CL)->S)); 
                }
        else if (  strm2 (out_format, "extended_lib","extended_cosmetic"))
                {
                  if (!D1)return 1;
                  output_constraints (out_file,out_format, D1->A);
                }
        else if ( strncmp (out_format, "extended_pair", 13)==0)
                {
                  if (!D1)return 1;
                  output_constraints (out_file,out_format, D1->A);
                }
        else if ( strm (out_format, "cache_id"))
                {
                  if (!D1)return 1;
                  cache_id (D1->A);
                output_saga_aln (out_file, D1->A);
                }
        else if ( strm (out_format, "compress_aln"))
                {
                  if (!D1)return 1;
                compress_aln (D1->A);
                output_saga_aln (out_file, D1->A);
                } 
        else if (strm (out_format, "n_seq") ||strm (out_format, "nseq") )
                {
                  if (!D1)return 1;
                fp=vfopen ( out_file, "w");
                fprintf ( fp, "%d\n", (D1->A)->nseq);
                vfclose (fp);
                }
        
        else if ( strm ( out_format, "thread_dna_on_prot_aln"))
                {
                  if (!D1)return 1;
                D1->A=thread_dnaseq_on_prot_aln (D1->S, D2->A);
                output_saga_aln ( out_file, D1->A);
                }
        else if ( strm ( out_format, "tdna_fasta_seq1"))
                {if (!D1)return 1;
                D1->A=translate_dna_aln (D1->A,0);
                output_fasta_seq1 (out_file, D1->A);
                }
        else if (strm (out_format, "exons"))
          {
            Alignment *A;
            //exons come in upper case
            //output alternates them upper/lower
            if (!D1)return 1;
            A=copy_aln (D1->A, NULL);
            A->seq_al=gene2exons(A->seq_al,A->nseq);
            output_fasta_seq (out_file,A);
            free_aln (A);
          }
        else if ( strm (out_format, "wexons"))
          {
            if (!D1)return 1;
            output_wexons (out_file,D1->A);
        
          }
        else if ( strm (out_format, "texons"))
          {
            Alignment *A;
            Sequence *S;
            //exons come in upper case
            //output alternate amino acids in upper/lower case
            //amino acid has the case of its first nucleotide
            if (!D1)return 1;
            A=copy_aln (D1->A, NULL);
            A->seq_al=gene2exons(A->seq_al,A->nseq);
            S=aln2seq(A);
            output_fasta_seqS (out_file,S=translate_dna_seqS(S,1,'X'));
          }
        else if ( strm (out_format, "sexons"))
          {
            Alignment *A;

            //exons come in upper case
            //output alternate amino acids in upper/lower case
            //amino acid has the case of its first nucleotide
            if (!D1)return 1;
            A=copy_aln (D1->A, NULL);
            output_fasta_seq ( out_file, D1->A);
          }
        
        else if ( strm ( out_format, "tdna_aln"))
                {if (!D1)return 1;              
                D1->A=translate_dna_aln (D1->A,0);
                output_saga_aln ( out_file, D1->A);
                }
        else if ( strm ( out_format, "cdna_fasta_seq1"))
                {if (!D1)return 1;              
                D1->A= gene2prot(D1->A);
                output_fasta_seq1 ( out_file, D1->A);
                }
        else if ( strm ( out_format, "mutate_cdna_aln"))
                {if (!D1)return 1;
                    D1->A= mutate_cdna_aln ( D1->A);
                    output_clustal_aln ( out_file, D1->A);
                }
        else if ( strm ( out_format, "tdna_sp_aln"))
                { if (!D1)return 1;
                if ( !DST) 
                   {
                   fprintf ( stderr,"\n[You Need an evaluation File: Change the output format][FATAL:%s]\n", PROGRAM);  
                   myexit(EXIT_FAILURE);
                   }            
               (DST->A)=aln2number (DST->A);
                D1->A=translate_splice_dna_aln (D1->A, DST->A);
                output_saga_aln ( out_file, D1->A);
                }
        else if (out_format && out_format[0] && (strcmp ( out_format,"rna_graph_fasta")==0))
                {
                  if (!D1)return 1;
                sprintf ( (D1->A)->seq_al[0], "%s",(DST->S)->seq[0]);
                (D1->A)->nseq=0;
                output_fasta_seq (out_file, DST->A);
                }
        else if (strm ( out_format, "freq_mat"))
                {
                  if (!D1)return 1;
                output_freq_mat (out_file, D1->A);  
                }
        else if (strm ( out_format, "maln_pval"))
                {if (!D1)return 1;
                output_maln_pval ( out_file, D1->A);
                }
        else if ( strm ( out_format, "model_aln"))
                {
                  if (!D1)return 1;
                output_model_aln ( out_file, D1->A);
                }
        else if (strncmp (out_format, "mult",4)==0)
                {
                  if (!D1)return 1;
                output_mult_fasta_seq ( out_file, D1->A, atoi(out_format+4));
                }
        else if (strm (out_format, "conservation"))
          {
            output_conservation_statistics (out_file, D1->A);
          }
        else if (strm (out_format, "len"))
                {
                  if (!D1)return 1;
                  output_statistics (out_file, D1->A, "nrl");
                }
        else if ( strm (out_format, "name"))
                {
                  if (!D1)return 1;
                  if ( D1->A)output_statistics (out_file, D1->A, "n");
                  if ( D1->T)
                    {
                      Sequence *TS;
                      TS=tree2seq(D1->T, NULL);print_array_char (vfopen(out_file, "w"), TS->name, TS->nseq, "\n");
                    }
                }
        else if ( strm (out_format, "code_name"))
                {
                  char **nl=NULL;
                  int num, n=0;
                  Sequence *TS;
                  FILE *lfp;
                  if ( D1->A){n=(D1->A)->nseq, nl=(D1->A)->name;}
                  if ( D1->T){TS=tree2seq(D1->T, NULL);nl=TS->name;n=TS->nseq;}
                  
                  lfp=vfopen (out_file, "w");
                  for ( num=0; num<n; num++)
                    fprintf (lfp, "\n%s C%d", nl[num], num+1);
                  fprintf (lfp, "\n");
                  vfclose (lfp);
                }
        else if ( strm ( out_format, "seq2struc"))
                  {
                    output_seq2struc (out_file, D1->A);
                  }
        else if ( strstr  ( out_format, "pavie_age_channel"))
          {
            output_n_pavie_age_channel ( D1->S,out_file, atoi((out_format+strlen ("pavie_age_channel"))));
            return EXIT_SUCCESS;
          }
        else if ( strstr ( out_format, "age_matrix"))
                  {
                    output_age_matrix (out_file, atoi((out_format+10)));
                  }
        else if ( strm ( out_format, "transitions"))
                  {
                    output_transitions (out_file, D1->A);
                  }
        
        else if ( strncmp (out_format, "statistics",10)==0)
                {
                  if (!D1)return 1;
                  
                  output_statistics (out_file, D1->A,out_format+10);
                }




        else if ( strm4 (out_format, "newick_tree","newick","binary","nh"))
                {
                  if (!D1)return 1;
                  
                  /*D1->T=unroot_tree(D1->T);*/
                  vfclose (print_tree ((D1->T), out_format, vfopen ( out_file, "w")));
                }
        else if ( strncmp (out_format, "sarsim", 6)==0)
                {
                  if (!D1)return 1;
                  compare_sar_sequence (D1->S, (D2 &&D2->S)?D2->S:D1->S, atoi(out_format+6));
                  return EXIT_SUCCESS;
                }
        else if ( strncmp (out_format, "sim",3)==0)
                {
                  if (!D1)return 1;
                  output_similarities (out_file, D1->A,out_format);
                }

        else if ( strncmp (out_format, "cov",3)==0)
                {
                  if (!D1)return 1;
                  output_similarities (out_file, D1->A,out_format);
                }
        else if ( strm (out_format, "stockholm_aln"))
          {
            output_stockholm_aln (out_file,D1->A, (D2)?D2->A:NULL);
          }
        else if ( strm (out_format, "pair_sim"))
          {
            if ( !D2)
              {
                fprintf ( stderr, "\n-output=pair_sim: provide aln1 via -in and aln2 via -in2 [FATAL:%s]\n", PROGRAM);
                myexit (EXIT_FAILURE);
              }
            output_similarities_pw (out_file, D1->A,D2->A,out_format);
          }
        else if ( strm (out_format, "matrix") || strm (out_format, "blast_matrix"))
          {
            output_blast_mat (D1->M, out_file);
          }
        else if ( strm (out_format, "header_matrix"))
          {
            output_header_mat(D1->M, out_file);
          }
                  
        else 
                {

                    fprintf ( stderr, "\n%s is an UNKNOWN OUTPUT FORMAT [FATAL:%s]\n",out_format, PROGRAM); 
                    myexit (EXIT_FAILURE);
                    
                }
        
        //Remove the expansion
        if ( expanded)
          {
            free_aln (D1->A);
            D1->A=BUF_A;
          }
        return 0;
        }
int is_in_format_list ( char *name)
        {
        if ( strcmp ( name, "saga_aln")==0)return 1;
        if ( strcmp ( name, "number_aln")==0)return 1;
        if ( strcmp ( name, "clustal_aln")==0)return 1; 
        if ( strcmp ( name, "fasta_aln")==0)return 1;
        if ( strcmp ( name, "number_fasta")==0)return 1;
        if ( strcmp ( name, "fasta_seq")==0)return 1;
        if ( strcmp ( name, "pdb")==0)return 1;
        if ( strcmp ( name, "msf_aln")==0)return 1;
        if ( strcmp ( name, "dali_aln")==0)return 1;
        if ( strcmp ( name, "dali_seq")==0)return 1;
        if ( strcmp ( name, "barton_list_tc")==0)return 1;
        if ( strcmp ( name, "est_prf")==0)return 1;
        
        if ( strcmp ( name, "gotoh_aln")==0)return 1;
        if ( strcmp ( name, "amps_aln")==0)return 1;
        if ( strcmp ( name, "pir_aln")==0)return 1;
        if ( strcmp ( name, "pir_seq")==0)return 1;
        if ( strcmp ( name, "est_fasta")==0)return 1;
        if ( strcmp ( name, "amps_sd_scores")==0)return 1;
        if ( strcmp ( name, "pima_aln")==0)return 1;
        if ( strcmp ( name, "dialign_aln")==0)return 1;
        if ( strcmp ( name, "gor_seq")==0)return 1;
        if ( strcmp ( name, "gor_struc")==0)return 1;
        if ( strcmp ( name, "stockholm_aln")==0)return 1;
        
        return 0;
        }
int is_struc_in_format_list ( char *name)
        {
        if ( strcmp ( name, "rna_number")==0)return 1;
        if ( strcmp ( name, "fasta_seq")==0)return 1;
        return 0;
        }
char *format_name2aln_format_name (char *name)
        {
          if ( strm (name, "gcg"))sprintf (name, "msf");
          else if ( strm (name, "fasta"))sprintf (name, "fasta_aln");
          return name;
        }
int is_out_format_list ( char *name)
        {
          return main_output (NULL, NULL, NULL, name, NULL);    
        }
        
int is_struc_out_format_list ( char *name)
        {
          return main_output (NULL, NULL, NULL, name, NULL);    
        }       

/**************************************************************************************************/
/*************************************REFORMAT UTIL*************************************************/
/**************************************************************************************************/

/*************************************REFORMAT IN**************************************************/
/**************************************************************************************************/
/*******************************************************************************************/
/*                                                                                         */
/*                                                                                         */
/*                               READ COG FILE                                             */
/*                                                                                         */
/***************************************************************************************** */
         
/*******************************************************************************************/
/*                                                                                         */
/*                                                                                         */
/*                               INPUT WEIGHTS                                            */
/*                                                                                         */
/***************************************************************************************** */
        
Weights* get_amps_sd_scores ( char *fname)
        {
        FILE *fp;
        char *buf;
        char *buf2;
        int nseq;
        Weights *W;
        int a, b,e;
        int c;
        float array[20];
        
        buf=vcalloc ( 1001, sizeof (char));
        buf2=vcalloc ( 1001, sizeof (char));
        
        fp=vfopen ( fname, "r");
        set_fp_id ( fp, "Index");
        buf=fgets ( buf, 1000, fp);
        fscanf ( fp, "%s", buf2);       
        
        nseq=0;
        while ( isalnum(buf2[0]) && !isalpha(buf2[0]))
                {
                nseq++;
                buf=fgets ( buf, 1000, fp);
                fscanf ( fp, "%s", buf2);
                }
        vfclose ( fp);
        
        W=declare_weights (nseq);
        
        fp=vfopen ( fname, "r");
        set_fp_id ( fp, "Index");
        buf=fgets ( buf, 1000, fp);
        fscanf ( fp, "%s", buf2);       
        
        a=0;
        while ( isalnum(buf2[0]) && !isalpha(buf2[0]))
                {
                fp=set_fp_after_char (fp, '>');
                fscanf ( fp, "%s",W->seq_name[a]);
                buf=fgets ( buf, 1000, fp);
                fscanf ( fp, "%s", buf2);
                a++;
                }
        buf=fgets ( buf, 1000, fp);
        c=1;
        while ( c!=0)
                {
                for ( e=0; e< 16; e++)
                        {
                        c=fscanf ( fp, "%f", &array[e]);
                        }
                fscanf ( fp, "\n");
                if ( c!=0)
                        {
                        
                        a=(int)array[0]-1;
                        b=(int)array[1]-1;
                        W->PW_ID[b][a]=W->PW_ID[a][b]=array[9];
                        W->PW_SD[b][a]=W->PW_SD[a][b]=array[14];
                        }
                
                }
        vfclose ( fp);
        sprintf ( W->comments, "SD WEIGHTS GENERATED WITH THE PROGRAM AMPS IN PAIRWISE MODE");
        vfree ( buf);
        return W;
        }

Weights *read_seq_weight (char **name, int nseq, char* seq_weight)
       {
       int a, p;
       Weights *W;
       float w;
       
       FILE *fp;
       char line[LONG_STRING];
       char sname[MAXNAMES];
       
       
       /*Read sequence weights:
        * comment
        name1 weight1
        .....


        NOTE:
        weights must be between 0 and 1;
        
        sequences not in S do not get any weight
        sequences in S but not in file get a weight of 1
       */
       if ( !is_single_seq_weight_file (seq_weight))
         {
           fprintf ( stderr, "\nERROR: File %s is not in Format SINGLE_SEQ_WEIGHT_FORMAT_01 [FATA:%s]", seq_weight,PROGRAM);
           myexit (EXIT_FAILURE);
           return NULL;
         }
       else
         {
           W=declare_weights(nseq);
           for ( a=0; a< nseq; a++)
             {
               sprintf ( W->seq_name[a], "%s", name[a]);
               W->SEQ_W[a]=1;
             }
           sprintf ( W->mode, "%s", seq_weight);
           fp=vfopen (seq_weight, "r");
           
           
           while ( fgets( line,LONG_STRING-1, fp))
             {
               if ( line[0]=='*' ||line[0]=='#' || isblanc(line));
               else
                 {
                   if (sscanf(line, "%s %f", sname, &w)!=2)continue;
                   if ( (p=name_is_in_list ( sname, W->seq_name, nseq, MAXNAMES-1))!=-1)
                     {
                       W->SEQ_W[p]=w;
                     }
                 }
             }
           vfclose (fp);
           return W;
         }
       }
       
  
/*******************************************************************************************/
/*                                                                                         */
/*                                                                                         */
/*                               INPUT MISC                                               */
/*                                                                                         */
/***************************************************************************************** */

char *** read_rename_file ( char *fname, int code)
{
  int n;
  FILE *fp;
  char ***convert=NULL;
  
  convert=declare_arrayN(3, sizeof (char),count_n_line_in_file(fname) +1,2,MAXNAMES+1);
  fp=vfopen (fname, "r");
  n=0;
  if ( code==CODE)      while ( fscanf ( fp, "%s %s\n", convert[n][0], convert[n][1])==2)n++;
  else if (code==DECODE)while ( fscanf ( fp, "%s %s\n", convert[n][1], convert[n][0])==2)n++;
  vfclose (fp);
  return convert;
}

void get_barton_list_tc_seq ( char *in_file)
        {
        FILE *fp, *fp_make, *fp_length, *fp_long;
        FILE *fp_small[9];
        
        static char *buf;
        int len_buf=10000;
        char name[100];
        
        char pwd[100];
        int a,c,nseq;
        int k=0;
        int *length;
        int longest=0;
        
        c=0;
        length=vcalloc ( 1000, sizeof(int));
        if ( buf==NULL)buf=vcalloc ( len_buf, sizeof (char));
        fp=vfopen (in_file, "r");
        fp_long=vfopen ( "barton_seq_list_large", "w");
        fp_make=vfopen ( "make_dir", "w");
        fp_length=vfopen ( "barton_length", "w");
        for ( a=0; a< 9; a++)
                {
                sprintf ( name, "barton_nseq%d",a);
                fp_small[a]=vfopen ( name, "w");
                }
        get_pwd (pwd);
        
        
        while ( c!=EOF)
                {a=0;
                while ( (c=fgetc(fp))!='#');
                while ( (c=fgetc(fp))=='#');
                ungetc ( c, fp);
                while ( (c=fgetc(fp))!='#')buf[a++]=c;
                buf[a]='\0';
                
                sprintf ( name, "%s", buf);
        
                while ( (c=fgetc(fp))=='#');
                
                if ( c!=EOF)
                        {
                        a=0;
                        while ( (c=fgetc(fp))!='#' && c!=EOF)
                                {
                                buf[a++]=c;
                                if (a==len_buf)
                                        {
                                        len_buf+=10000;
                                        buf=vrealloc ( buf, len_buf*sizeof (char));
                                        }
                                } 
                        buf[a]='\0';
                        if (c!=EOF)
                                {
                                
                                nseq=process_barton_entry ( buf,name);
                                length[nseq]++;
                                longest=(longest<nseq)?nseq:longest;
                                
                                if ( nseq<=8) fprintf ( fp_small[nseq], "%s.pep\n", name);
                                else fprintf ( fp_long, "%s.pep\n",name);
                                fprintf ( fp_make, "mkdir %s\nmv %s.pep %s\nmv %s.check %s\n", name, name, name, name, name);
                                k++;
                                }
                        
                                
                        }
                }
        
        vfclose (fp);
        vfclose (fp_long);
        for ( a=0; a< 9; a++)vfclose (fp_small[a]);
        vfclose (fp_make);
        for ( a=0; a<= longest; a++)fprintf ( fp_length, "%d: %d\n", a, length[a]);
        vfclose ( fp_length);
        
        }
        
int process_barton_entry (char *buf, char *name)                        
    {       
    Alignment *LA;
    Sequence *LS;
    int a,c;
    static char *buf2;
    int clen=0;
    int current=0;
    int p=0;
    int max_len_seq=0;
    int min_len_seq=999999;
    int nseq=0;
    int l;
    char fname[100];
    char com_name[100];
    int rm_gap=1;

    sprintf ( fname, "%s.pep", name);
    sprintf ( com_name, "%s.check",name);
    
    if ( buf2==NULL)buf2=vcalloc ( 10000, sizeof (char));
    a=0;                
    while (buf[a]!='\0')
                {
                 if (buf[a]=='>')
                        {
                        a=get_string_line (a,2, buf, buf2); 
                        while ((c=buf[a++])!='*')
                                if (isalnum (c)|| c=='.' || c=='-')
                                        clen++;
                         max_len_seq=(clen> max_len_seq)?clen: max_len_seq;
                         min_len_seq=(clen< min_len_seq)?clen: min_len_seq;
                         nseq++;
                         clen=0;
                        }
                if ( buf[a]!='\0')a++;
                }
    
    
    LS=declare_sequence (  min_len_seq,  max_len_seq,  nseq); 
    LS->nseq=nseq;
    
    
    for (a=0, current=0; current< nseq; current++) 
        {
        a=get_string_line ( a, 1, buf, buf2);
        sscanf ( buf2, ">P1;%s", LS->name[current]);
        a=get_string_line ( a, 1, buf, buf2);
        l=strlen ( buf2);
        buf2[l-1]='\0';
        sprintf ( LS->seq_comment[current],"%s", buf2);
        
        p=0;
        while ( (c=buf[a++])!='*')
                {
                if (isalpha (c))
                        LS->seq[current][p++]=tolower (c);
                else if ( isgraph(c))
                        LS->seq[current][p++]=(c);
                }       
        a++;
        }
    
    LA=declare_Alignment(LS);
    seq2aln ( LS, LA,rm_gap);
    output_fasta_seq (fname,LA);
    output_pir_check (com_name,LA->nseq, LA->seq_comment);
    free_Alignment ( LA);
    free_sequence ( LS, nseq);   
    
    return nseq;
    }

        
        

Structure *read_rna_struc_number (Alignment *A,char *fname)
        {
        FILE *fp;
        int a;
        char x,y;
        float f;
        Sequence *SA;
        Structure *ST;
        int first, last;
        
        SA=declare_sequence ( A->len_aln, A->len_aln, 1);
        SA->len[0]=A->len[0];
        for ( a=0; a< SA->len[0]; a++)
                SA->seq[0][a]='.';
        ST=declare_rna_structure_num (SA);
        ST->S=SA;
        
        fp=vfopen ( fname, "r");
        fscanf ( fp, "%c\n%d\n",&x, &(ST)->tot_list);
        for ( a=0; a<(ST)->tot_list; a++)
                {
                fscanf ( fp, "%d %d %d %c %c %f\n", &(ST)->list[a][0],&(ST)->list[a][1],&(ST)->list[a][2], &x, &y, &f);
                (ST)->list[a][0]--;
                (ST)->list[a][1]--;
                (ST)->list[a][2]--;
                if ( a==0)
                        {
                        (ST)->stem[0][0]=(ST)->list[a][0];
                        (ST)->stem[0][1]=a;
                        }
                else if ( (ST)->stem[(ST)->tot_stem][0]==(ST)->list[a][0]);
                else if ( (ST)->stem[(ST)->tot_stem][0]!=(ST)->list[a][0])
                        {
                        (ST)->stem[(ST)->tot_stem][2]=a-1;
                        (ST)->tot_stem++;
                        (ST)->stem[(ST)->tot_stem][0]=(ST)->list[a][0];
                        (ST)->stem[(ST)->tot_stem][1]=a;
                        }
                        
                SA->seq[0][(ST)->list[a][1]]='-';
                SA->seq[0][(ST)->list[a][2]]='-';
                }
        (ST)->stem[(ST)->tot_stem][2]=a-1;      
        (ST)->tot_stem++;
        for ( a=0; a< (ST)->tot_stem; a++)
                {
        
                first=(ST)->stem[a][1];
                last=(ST)->stem[a][2];
                SA->seq[0][(ST)->list[first][1]]='>';
                SA->seq[0][(ST)->list[first][2]]='<';
                SA->seq[0][(ST)->list[last][1]]='>';
                SA->seq[0][(ST)->list[last][2]]='<';    
                }
        
        return ST;      
        }
                  
Structure * declare_rna_structure_num (Sequence *SA)
        {
        Structure *ST;
        ST=vcalloc ( 1, sizeof ( Structure));
        ST->list=declare_int ( SA->len[0], 3);
        ST->stem=declare_int ( SA->len[0], 3);
        return ST;
        }
char ** read_lib_list (char *name, int *n)
{

  char **lines;
  char **list;
  int a, b, l;
  
  lines=file2lines (name);
  l=atoi (lines[0]);
  
  list=vcalloc (l, sizeof (char*));
  for ( n[0]=0,a=1; a<l; a++,b++)
    if ( !strstr (lines[a], "TC_LIB_LIST_FORMAT_01"))list[n[0]++]=lines[a];
  vfree (lines);
  return list;
}
  
/*******************************************************************************************/
/*                                                                                         */
/*                                                                                         */
/*                               INPUT SEQ                                                */
/*                                                                                         */
/***************************************************************************************** */
char ***read_group ( char *file)
{
  /*Format: Fasta like, the name fo the group followed with the name of the sequences
    ><Group name> <First Seq> <second seq> ....
    Groups must NOT be overlaping
    list[group_index][0]="number of sequences"
    list[group_index][1]="group name"
    list[group_index][2...N]="sequence"
  */ 

  FILE *fp;
  char *buf;
  char ***list;
  int a, c, l;


  
  l=measure_longest_line_in_file (file)+1;
  buf=vcalloc (l, sizeof (char)); 
  list=vcalloc ( count_n_line_in_file (file )+1, sizeof (char**));
  
  fp=vfopen (file, "r");
  
  a=0;
  while ((c=fgetc(fp))!=EOF)
    {
      buf=fgets (buf,l-1, fp);
      if ( c=='>')list[a++]=string2list (buf);
    }
  vfclose (fp);
  vfree (buf);
  return list;
}


static Sequence* get_pdb_sequence_from_field   (char *fname, char *field);

Sequence* get_pdb_sequence   (char *fname)
{
  Sequence *S;

  if ( (S=get_pdb_sequence_from_field(fname, "SEQRES"))!=NULL);
  else if ( (S=get_pdb_sequence_from_field(fname, "ATOM"))!=NULL)
    {
      add_warning (stderr,"Warning: Read Sequence from ATOM field in %s [%s:WARNING]", fname, PROGRAM);
    }
  else
    {
      add_warning ( stderr, "\nWARNING: failed to extract sequence from %s [%s:WARNING]\n", fname, PROGRAM);
      S=NULL;
    }
  return S;
}


static Sequence* get_pdb_sequence_from_field   (char *fname, char *field)
{
        char *tp_name;
        char *command;
        char *pdbid;
        Sequence *S;


        command=vcalloc ( LONG_STRING, sizeof (char));
        tp_name=vtmpnam (NULL);
        sprintf ( command, "extract_from_pdb -seq_field %s -chain FIRST -infile \'%s\' -mode fasta > %s", field, check_file_exists(fname), tp_name);
//      printf("CO: %s\n", command);
//      char *x = vcalloc ( LONG_STRING, sizeof (char));
//      sprintf(x, "cp %s ~/Desktop/erg.txt", tp_name);
//      my_system(x);
        if ( getenv4debug ("DEBUG_EXTRACT_FROM_PDB"))fprintf ( stderr, "\n[DEBUG_EXTRACT_FROM_PDB:get_pdb_seq] %s\n", command);
        my_system ( command);


        S=get_fasta_sequence ( tp_name, NULL);
        if (S==NULL)return NULL;
        
        if ( (pdbid=get_pdb_id (fname))){sprintf ( S->name[0], "%s",pdbid);vfree (pdbid);} 
        S->nseq=1;

        sprintf ( S->file[0], "%s", fname);
        S->max_len=S->min_len=S->len[0];
        if ( S->len[0]==0)
        {
                free_sequence (S, -1);
                S=NULL;
        }

        vremove ( tp_name);
        vfree ( command);
        
        return S;
}

char * get_pdb_file   ( char *fname)
     {
         char *file;
         int a, c;
         FILE *fp;
         

         a=0;
         file=vcalloc ( sizeof (char),count_n_char_in_file ( fname)+1);
         fp=vfopen ( fname, "r");
         while ( (c=fgetc(fp))!=EOF)file[a++]=c;
         file[a]='\0'; 
         return file;
     }
         
Sequence* get_struc_gor ( char *fname)
    {
    int nseq, min_len, max_len;
    int a, c;
    int len;
    char name[STRING];
    

    FILE *fp;
    Sequence *S;

    min_len=max_len=-1;
    fp=vfopen ( fname, "r");
    nseq=0;
    while ( (c=fgetc(fp))!=EOF)
            {
            if ( c!='!');
            else
                {
                nseq++;
                fscanf ( fp, "%s %d", name, &len);
                if (min_len==-1)min_len=max_len=len;
                else
                    {
                    min_len=(len>min_len)?min_len:len;
                    max_len=(len>max_len)?len:max_len;
                    }
                }
            
            }
    vfclose (fp);
   
    S=declare_sequence (  min_len,  max_len+1,nseq); 
    S->nseq=0;
    
    fp=vfopen (fname,"r");      
     while ( (c=fgetc(fp))!=EOF)
             {
             if ( c!='!');
             else
                {
                fscanf ( fp, "%s %d\n",S->name[S->nseq], &(S->len[S->nseq]));
                
                while ( (c=fgetc(fp))!='\n');
        
                for ( a=0; a<S->len[S->nseq]; a++)
                    fscanf ( fp, " %*c %c %*f %*f %*f\n",&(S->seq[S->nseq][a]));
                
                S->seq[S->nseq][a]='\0';
                while ( (c=fgetc(fp))!='!' && c!=EOF);
                ungetc (c, fp);
                S->nseq++;
                }
             
             }
    vfclose (fp);
    return S;           
    }
                
Sequence* get_sequence_dali (char *fname)
    {
    Sequence *LS;
    FILE *fp;
    int c;

    char name[100];
    int clen=0;
    int current=0;
    int p=0;
    int max_len_seq=0;
    int min_len_seq=999999;
    int nseq=0;
    
    if ((fp=vfopen (fname,"r"))==NULL)
         {printf ( "\nCOULDN'T OPEN %s",fname);
          myexit(EXIT_FAILURE);
         }  
    c=fgetc(fp);
    while (c!=EOF)
                {
                 if (isdigit(c))
                        {
                        ungetc(c, fp);
                        fscanf (fp, "%s",name);
                        while (!isdigit(c=fgetc(fp)) && c!=EOF)
                                if (isalnum (c) || c=='.' || c=='-')
                                        clen++;
                         max_len_seq=(clen> max_len_seq)?clen: max_len_seq;
                         min_len_seq=(clen< min_len_seq)?clen: min_len_seq;
                         nseq++;
                        clen=0;
                        }
                else
                    c=fgetc (fp);
                }
    vfclose (fp);
                
    LS=declare_sequence (  min_len_seq,  max_len_seq+1,nseq); 
    LS->nseq=nseq;
    
    fp=vfopen (fname,"r");
    
    current=0;
    c=fgetc(fp);
        while (c!=EOF)
                {
                if (isdigit(c))
                        {
                        ungetc(c, fp);
                        fscanf_seq_name (fp, LS->name[current]);
                        p=0;
                        while (!isdigit(c=fgetc(fp)) && c!=EOF)
                                {
                                if (isalpha (c))
                                    LS->seq[current][p++]=tolower (c);
                                else if ( c=='.')
                                    LS->seq[current][p++]='-';
                                else if ( c=='-')
                                    LS->seq[current][p++]='-';
                                }           
                        LS->seq[current][p]='\0';
                        LS->len[current]=strlen ( LS->seq[current]);
                        current++;
                        }
                else
                    c=fgetc ( fp);
                }

    vfclose (fp);
    
    
    return LS;
    }   

Sequence* get_dialign_sequence (char *fname)
    {
    Sequence *LS;
    FILE *fp;
    int c;

    char name[10000];
    int clen=0;
    int current=0;
    int p=0;
    int max_len_seq=0;
    int min_len_seq=999999;
    int nseq=0, l=0;
    char *buf;
    
    buf=vcalloc ( 1000, sizeof (char));
    if ((fp=vfopen (fname,"r"))==NULL)
         {printf ( "\nCOULDN'T OPEN %s",fname);
          myexit(EXIT_FAILURE);
         }  
    c=fgetc(fp);
    while (c!=EOF)
                {
                 if (c=='>')
                        {fscanf (fp, "%s",name);
                        
                        buf=fgets ( buf, 1000, fp);
                        while ((c=fgetc(fp))!='>' && c!=EOF && c!=' ' && c!='\t')
                                if (isalnum (c)|| is_gap(c))
                                        clen++;
                         max_len_seq=(clen> max_len_seq)?clen: max_len_seq;
                         min_len_seq=(clen< min_len_seq)?clen: min_len_seq;
                         nseq++;
                        clen=0;
                        }
                else
                    c=fgetc (fp);
                }
    vfclose (fp);
                
    LS=declare_sequence (  min_len_seq,  max_len_seq, nseq); 
    LS->nseq=nseq;
    
    fp=vfopen (fname,"r");
    
    current=0;
    c=fgetc(fp);
        while (c!=EOF)
                {
                if (c=='>')
                        {
                          
                        fscanf_seq_name (fp, LS->name[current]);
                        l=strlen ( LS->name[current]);
                        if ( LS->name[current][l-1]==','||LS->name[current][l-1]==',')LS->name[current][l-1]='\0';
                        buf=fgets ( buf, 1000, fp);
                        p=0;
                        while ((c=fgetc(fp))!='>' && c!=EOF && c!=EOF && c!=' ' && c!='\t')
                                if (isalpha (c))
                                    LS->seq[current][p++]=tolower (c);
                                else if ( isgraph(c))
                                    LS->seq[current][p++]=(c);
                        LS->seq[current][p]='\0';
                        LS->len[current]=strlen ( LS->seq[current]);
                        current++;
                        }
                else
                    c=fgetc ( fp);
                }

    vfclose (fp);
    return LS;
    }

Sequence* get_pima_sequence (char *fname)
    {
    Sequence *LS;

    FILE *fp;
    int c;

    char name[10000];
    int clen=0;
    int current=0;
    int p=0;
    int max_len_seq=0;
    int min_len_seq=999999;
    int nseq=0, l=0, len=0;
    char *buf, *buf2;
    char prefix[1000];
    
    sprintf (  prefix, "%s",fname);
    
    buf=strstr(prefix, "-");
    buf[0]='\0';
    len=strlen (prefix);
        
   
    
    buf=vcalloc ( 1000, sizeof (char));
    if ((fp=vfopen (fname,"r"))==NULL)
         {printf ( "\nCOULDN'T OPEN %s",fname);
          myexit(EXIT_FAILURE);
         }  
    c=fgetc(fp);
    while (c!=EOF)
                {
                 if (c=='>')
                        {
                          fscanf_seq_name (fp,name);
                          if ( strlen(name)>=len && strncmp ( name, prefix, len)==0)
                                {
                                  c=fgetc(fp);
                                }
                          else
                                {
                                
                                buf=fgets ( buf, 1000, fp);
                                while ((c=fgetc(fp))!='>' && c!=EOF)
                                        if (isalnum (c)|| is_gap(c))
                                                clen++;
                                 max_len_seq=(clen> max_len_seq)?clen: max_len_seq;
                                 min_len_seq=(clen< min_len_seq)?clen: min_len_seq;
                                nseq++;
                                clen=0;
                                }
                        }
                else
                        c=fgetc (fp);
                }
    vfclose (fp);
                
    LS=declare_sequence (  min_len_seq,  max_len_seq, nseq); 
    LS->nseq=nseq;
    
    fp=vfopen (fname,"r");
    
    current=0;
    c=fgetc(fp);
        while (c!=EOF)
                {
                if (c=='>')
                        {
                        fscanf_seq_name (fp,LS->name[current]);
                        if ( strlen(LS->name[current])>=len && strncmp ( LS->name[current], prefix, len)==0)
                                c=fgetc (fp);
                        else
                                {
                                buf2=strstr (LS->name[current], ".");
                                if ( buf2!=NULL) buf2[0]='\0';
                                 
                                l=strlen ( LS->name[current]);
                                if ( LS->name[current][l-1]==','||LS->name[current][l-1]==',')LS->name[current][l-1]='\0';
                                buf=fgets ( buf, 1000, fp);
                                p=0;
                                while ((c=fgetc(fp))!='>' && c!=EOF)
                                        if (isalpha (c))
                                            LS->seq[current][p++]=tolower (c);
                                        else if ( isgraph(c))
                                            LS->seq[current][p++]=(c);
                                LS->seq[current][p]='\0';
                                LS->len[current]=strlen ( LS->seq[current]);
                                current++;
                                }
                        }
                else
                    c=fgetc ( fp);
                }

    vfclose (fp);
    return LS;
    }

Sequence* perl_reformat2fasta (char *perl_command, char *fname)
    {
      char command[1000];
      char *file;

      file=vtmpnam (NULL);
      
      check_program_is_installed ( perl_command,"", perl_command,EMAIL,IS_FATAL);
      sprintf ( command, "%s %s > %s", perl_command, fname, file);
      my_system ( command);
      return get_fasta_sequence (file, NULL);
    }
Sequence* get_fasta_sequence_num (char *fname, char *comment_out)
    {
    Sequence *LS;
    char *buffer;
    FILE *fp;
    int a;

    int   c;
    char *name;
    int clen=0;
    int current=0;
    int p=0;
    int max;
    int max_len_seq=0;
    int min_len_seq=0;
    int nseq=0, l=0;
 
    
    
    
    int *sub;
    
    buffer=vcalloc (1000, sizeof (char)); 
    name=vcalloc ( 100, sizeof (char));

    nseq=count_n_char_x_in_file(fname, '>');
    min_len_seq=max=count_n_char_in_file(fname);
    sub=vcalloc (max+1, sizeof (int));

    fp=vfopen (fname,"r");

    
    c=fgetc(fp);
    while (c!=EOF)
                {
                 if (c=='>')
                        {
                        fscanf_seq_name (fp,name);
                        while ((c=fgetc(fp))!='\n' && c!=EOF);
                        while ((c=fgetc(fp))!='>' && c!=EOF)
                                if (isalnum (c)|| is_gap(c))
                                        clen++;
                         max_len_seq=(clen> max_len_seq)?clen: max_len_seq;
                         min_len_seq=(clen< min_len_seq)?clen: min_len_seq;
                         clen=0;
                        }
                else
                    c=fgetc (fp);
                 
                }  

    vfclose (fp);               
    LS=declare_sequence (  min_len_seq,  max_len_seq,nseq); 
    
    LS->nseq=nseq;
    
    fp=vfopen (fname,"r");
    current=0;
    c=fgetc(fp);
    while (c!=EOF)
                {
                if (c=='>')
                        {
                        
                        fscanf_seq_name (fp,LS->name[current]);
                        l=strlen ( LS->name[current]);
                        if ( LS->name[current][l-1]==','||LS->name[current][l-1]==';')LS->name[current][l-1]='\0';
                        LS->name[current]=translate_name ( LS->name[current]);
                        a=0;
                        while ((c=fgetc(fp))!='\n' && c!=EOF && a<(COMMENT_SIZE-1))LS->seq_comment[current][a++]=c;
                        LS->seq_comment[current][a]='\0';


                        p=0;
                        while ((c=fgetc(fp))!='>' && c!=EOF)
                                {
                                if (isalnum (c))
                                    LS->seq[current][p++]=c;
                                else if (is_gap(c))
                                    LS->seq[current][p++]=c;
                                }
                        LS->seq[current][p]='\0';
                        LS->len[current]=strlen ( LS->seq[current]);

                        current++;
                        }
                else
                    c=fgetc ( fp);
                }
                        
    
    vfclose (fp);
    

    vfree (sub);
    vfree (name);
    vfree (buffer);
    return LS;
    }

Sequence *get_tree_file_list ( char *fname)
{

  char ***list;
  char *tmp;
  int a;
  FILE *fp;
  
  tmp=vtmpnam (NULL);
  list=file2list (fname, "\n");
  fp=vfopen (tmp, "w");
  a=0;
  while (list[a] && !isspace(list[a][1][0]))
    {
      char *s;
      s=file2string (list[a][1]);
      fprintf ( fp, ">%s\n%s\n", list[a][1], (s)?s:"");
      a++;
    }
  vfclose (fp);
  free_arrayN((void ***)list, 3);
  return get_fasta_tree (tmp, NULL);
}
Sequence *get_file_list ( char *fname)
{

  char ***list;
  char *tmp;
  int a;
  FILE *fp;
  
  tmp=vtmpnam (NULL);
  list=file2list (fname, "\n");
  fp=vfopen (tmp, "w");
  a=0;
  while (list[a] && !isspace(list[a][1][0]))
    {

      fprintf ( fp, ">%s\n", list[a][1]);
      a++;
    }
  vfclose (fp);
  free_arrayN((void ***)list, 3);
  return get_fasta_sequence (tmp, NULL);
}
Sequence*get_fasta_tree (char *fname, char *comment_out)
{
  Sequence *LS;
    char *buffer;
    FILE *fp;
    int a;

    int   c;
    char *name;
    int clen=0;
    int current=0;
    int p=0;
    int max;
    int max_len_seq=0;
    int min_len_seq=0;
    int nseq=0, l=0;
 
    
    
    
    int *sub;
    
    buffer=vcalloc (1000, sizeof (char)); 
    name=vcalloc ( 100, sizeof (char));

    nseq=count_n_char_x_in_file(fname, '>');
    min_len_seq=max=count_n_char_in_file(fname);
    sub=vcalloc (max+1, sizeof (int));

    fp=vfopen (fname,"r");

    
    c=fgetc(fp);
    while (c!=EOF)
                {
                 if (c=='>')
                        {
                        fscanf_seq_name (fp,name);
                        while ((c=fgetc(fp))!='\n' && c!=EOF);
                        while ((c=fgetc(fp))!='>' && c!=EOF)
                          if (isgraph(c))
                            clen++;
                         max_len_seq=(clen> max_len_seq)?clen: max_len_seq;
                         min_len_seq=(clen< min_len_seq)?clen: min_len_seq;
                         clen=0;
                        }
                else
                    c=fgetc (fp);
                 
                }  

    vfclose (fp);               
    LS=declare_sequence (  min_len_seq,  max_len_seq,nseq); 
    
    LS->nseq=nseq;
    
    fp=vfopen (fname,"r");
    current=0;
    c=fgetc(fp);
    while (c!=EOF)
                {
                if (c=='>')
                        {
                        
                        fscanf_seq_name (fp,LS->name[current]);
                        l=strlen ( LS->name[current]);
                        if ( LS->name[current][l-1]==','||LS->name[current][l-1]==';')LS->name[current][l-1]='\0';
                        LS->name[current]=translate_name ( LS->name[current]);
                        a=0;
                        while ((c=fgetc(fp))!='\n' && c!=EOF && a<(COMMENT_SIZE-1))LS->seq_comment[current][a++]=c;
                        LS->seq_comment[current][a]='\0';

                        
                        p=0;
                        while ((c=fgetc(fp))!='>' && c!=EOF)
                                {
                                  LS->seq[current][p++]=c;
                                }

                        LS->seq[current][p]='\0';
                        LS->len[current]=strlen ( LS->seq[current]);

                        current++;
                
                        }
                        
                else
                    c=fgetc ( fp);
                }
                        
    
    vfclose (fp);
    

    vfree (sub);
    vfree (name);
    vfree (buffer);
    
    return LS;
}
Sequence* get_fasta_sequence_raw (char *fname, char *comment_out)
    {
    Sequence *LS;
    char *buffer;
    FILE *fp;
    int a;

    int   c;
    char *name;
    int clen=0;
    int current=0;
    int p=0;
    int max;
    int max_len_seq=0;
    int min_len_seq=0;
    int nseq=0, l=0;
 
    
    
    
    int *sub;
    
    buffer=vcalloc (1000, sizeof (char)); 
    name=vcalloc ( 100, sizeof (char));

    nseq=count_n_char_x_in_file(fname, '>');
    min_len_seq=max=count_n_char_in_file(fname);
    sub=vcalloc (max+1, sizeof (int));

    fp=vfopen (fname,"r");

    
    c=fgetc(fp);
    while (c!=EOF)
                {
                 if (c=='>')
                        {
                        fscanf_seq_name (fp,name);
                        while ((c=fgetc(fp))!='\n' && c!=EOF);
                        while ((c=fgetc(fp))!='>' && c!=EOF)
                          if (isgraph(c))
                            clen++;
                         max_len_seq=(clen> max_len_seq)?clen: max_len_seq;
                         min_len_seq=(clen< min_len_seq)?clen: min_len_seq;
                         clen=0;
                        }
                else
                    c=fgetc (fp);
                 
                }  

    vfclose (fp);               
    LS=declare_sequence (  min_len_seq,  max_len_seq,nseq); 
    
    LS->nseq=nseq;
   
    fp=vfopen (fname,"r");
    current=0;
    c=fgetc(fp);
    while (c!=EOF)
                {
                if (c=='>')
                        {
                        
                        fscanf_seq_name (fp,LS->name[current]);
                        l=strlen ( LS->name[current]);
                        if ( LS->name[current][l-1]==','||LS->name[current][l-1]==';')LS->name[current][l-1]='\0';
                        LS->name[current]=translate_name ( LS->name[current]);
                        a=0;
                        while ((c=fgetc(fp))!='\n' && c!=EOF && a<(COMMENT_SIZE-1))LS->seq_comment[current][a++]=c;
                        LS->seq_comment[current][a]='\0';

                        
                        p=0;
                        while ((c=fgetc(fp))!='>' && c!=EOF)
                                {
                                  //if (c<'A')c+='z';
                                  if (c!='\n')LS->seq[current][p++]=c;
                                }

                        LS->seq[current][p]='\0';
                        LS->len[current]=strlen ( LS->seq[current]);

                        current++;
                
                        }
                        
                else
                    c=fgetc ( fp);
                }
                        
    
    vfclose (fp);
    

    vfree (sub);
    vfree (name);
    vfree (buffer);
    return LS;
    }
Sequence* get_fasta_sequence (char *fname, char *comment_out)
    {
    Sequence *LS;
    Sequence *pdb_S;
    int a;

    char *pdb_name;
    
    char *buffer;
    FILE *fp;

    int   c;
    char *name;
    int clen=0;
    int current=0;
    int p=0;
    int max;
    int max_len_seq=0;
    int min_len_seq=0;
    int nseq=0, l=0;
    char *sub;
    int disk=0;
    int coor=0;

    
       
    buffer=vcalloc (1000, sizeof (char)); 
    name=vcalloc ( 10000, sizeof (char));

    nseq=count_n_char_x_in_file(fname, '>');
    if (disk==1 || get_int_variable ("use_disk") || getenv ("SEQ_ON_DISK_4_TCOFFEE")){disk=1;}
    if ( nseq==0)
      {
        vfree (buffer); vfree (name);
        return NULL;
      }
    
    min_len_seq=max=count_n_char_in_file(fname);
    sub=vcalloc (max+1, sizeof (char));

    fp=vfopen (fname,"r");

    nseq=0;
    c=fgetc(fp);
    while (c!=EOF)
                {
                 if (c=='>')
                        {
                          nseq++;
                          fscanf_seq_name (fp,name);
                          while ((c=fgetc(fp))!='\n' && c!=EOF);
                          while ((c=fgetc(fp))!='>' && c!=EOF)
                            {
                              if (isalnum (c)|| is_gap(c))
                                sub[clen++]=c;
                            }
                          
                          if (strm (sub, "PDB"))
                            {
                              pdb_name=get_pdb_struc(name,0, 0);
                              pdb_S=get_pdb_sequence (pdb_name);
                              if (pdb_S)
                                {
                                  clen=strlen( pdb_S->seq[0]);
                                  free_sequence ( pdb_S,1);
                                }
                              else
                                clen=0;
                              
                            }
                                                  
                          max_len_seq=(clen> max_len_seq)?clen: max_len_seq;
                          min_len_seq=(clen< min_len_seq)?clen: min_len_seq;
                          clen=0;
                        }
                 else
                   c=fgetc (fp);
                 
                }  
    
    vfclose (fp);       
    
    
    if ( disk==0)
      LS=declare_sequence (  min_len_seq,  max_len_seq,nseq); 
    else
      {
        LS=declare_sequence (0,0,nseq);
        for (a=0; a<nseq; a++)LS->seq[a]=NULL;
      }
    LS->nseq=nseq;
    
    fp=vfopen (fname,"r");
    current=0;
    c=fgetc(fp);coor++;
    
    while (c!=EOF)
                {
                if (c=='>')
                        {
                          coor+=fscanf_seq_name (fp, LS->name[current]);

                          
                          l=strlen ( LS->name[current]);
                          if ( LS->name[current][l-1]==','||LS->name[current][l-1]==';')LS->name[current][l-1]='\0';
                          LS->name[current]=translate_name ( LS->name[current]);                        
                          a=0;
                          while ((c=fgetc(fp))!='\n' && c!=EOF && a<(COMMENT_SIZE-1)){LS->seq_comment[current][a++]=c;coor++;}
                          coor++;
                          
                          LS->seq_comment[current][a]='\0';
                          
                          p=0;
                          while ((c=fgetc(fp))!='>' && c!=EOF)
                            {
                              coor++;
                              
                              if (!isspace(c))
                                {
                                  if (p==0)LS->dc[current][0]=coor;
                                  
                                  if (disk==0)LS->seq[current][p++]=c;
                                  else p++;
                                }
                              
                              LS->dc[current][1]=coor;
                            }
                          coor++;
                          
                          if ( disk==0)LS->seq[current][p]='\0';
                          
                          if (LS->seq[current] && strm (LS->seq[current], "PDB"))
                            {
                              
                              pdb_name=get_pdb_struc(LS->name[current],0, 0);
                              pdb_S=get_pdb_sequence (pdb_name);
                              if (pdb_S)
                                {
                                  sprintf ( LS->seq[current], "%s", pdb_S->seq[0]);
                                  clen=strlen( pdb_S->seq[0]);
                                  free_sequence ( pdb_S, 1);
                                }
                              else
                                {
                                  add_warning (stderr, "WARNING: Could not fetch PDB file: %s", pdb_name);
                                }
                            }
                        
                        
                          LS->len[current]=p;
                          current++;            
                        }
                        
                else
                  {
                    c=fgetc ( fp);
                    coor++;
                  }
                }
     
    vfclose (fp);
    vfree (sub);
    vfree (name);
    vfree (buffer);
    //LS=clean_sequence (LS);
   
    return LS;
    }

Sequence* get_sub_fasta_sequence (char *fname, char *comment_out)
    {
    Sequence *LS;
    
    FILE *fp;

    int c;
    char name[100];
    int clen=0;
    int current=0;
    int p=0;
    int max;
    int max_len_seq=0;
    int min_len_seq=0;
    int nseq=0, l=0;
    char *buf;
    
    
    
    int *sub;

    nseq=count_n_char_x_in_file(fname, '>');
    min_len_seq=max=count_n_char_in_file(fname);
    sub=vcalloc (max+1, sizeof (int));
    buf=vcalloc ( max+1, sizeof (char));
    fp=vfopen (fname,"r");

    
    c=fgetc(fp);
    while (c!=EOF)
                {
                 if (c=='>')
                        {
                        fscanf_seq_name (fp,name);
                        while ((c=fgetc(fp))!='\n' && c!=EOF);
                        buf=fgets ( buf,max, fp);
                        while ((c=fgetc(fp))!='>' && c!=EOF)
                                if (isalnum (c)|| is_gap(c))
                                        clen++;
                         max_len_seq=(clen> max_len_seq)?clen: max_len_seq;
                         min_len_seq=(clen< min_len_seq)?clen: min_len_seq;
                         clen=0;
                        }
                else
                    c=fgetc (fp);
                 
                }  

    vfclose (fp);               
    LS=declare_sequence (  min_len_seq,  max_len_seq,nseq); 
    LS->nseq=nseq;
    
    fp=vfopen (fname,"r");
    current=0;
    c=fgetc(fp);
    while (c!=EOF)
                {
                if (c=='>')
                        {
                        
                        fscanf_seq_name (fp,LS->name[current]);
                        l=strlen ( LS->name[current]);
                        if ( LS->name[current][l-1]==','||LS->name[current][l-1]==';')LS->name[current][l-1]='\0';
                        LS->name[current]=translate_name ( LS->name[current]);
                        while ((c=fgetc(fp))!='\n' && c!=EOF);
                
                        p=0;
                        while ((c=fgetc(fp))!='>' && c!=EOF)
                                {
                                if (isalpha (c))
                                    LS->seq[current][p++]=tolower (c);
                                else if (is_gap(c))
                                    LS->seq[current][p++]=(c);                          
                                }

                        LS->seq[current][p]='\0';
                        LS->len[current]=strlen ( LS->seq[current]);

                        current++;
                
                        }
                        
                else
                    c=fgetc ( fp);
                }
                        
    
    vfclose (fp);
    

    vfree (sub);
    return LS;
    }
Sequence* get_pir_sequence (char *fname, char *comment_out)
    {
    Sequence *LS;

    FILE *fp;
    int c;

    char name[100];
    int clen=0;
    int current=0;
    int p=0;
    int max_len_seq=0;
    int min_len_seq=999999;
    int nseq=0, l=0;
    char *buf;
    
    buf=vcalloc ( 1000, sizeof (char));
    if ((fp=vfopen (fname,"r"))==NULL)
         {printf ( "\nCOULDN'T OPEN %s",fname);
          myexit(EXIT_FAILURE);
         }  
    c=fgetc(fp);
    while (c!=EOF)
                {
                 if (c=='>')
                        {
                        if ( (c=fgetc(fp))=='P')while ( (c=fgetc(fp))!=';');
                        else ungetc ( c, fp);
                        fscanf_seq_name (fp,name);
                        
                        buf=fgets ( buf, 1000, fp);
                        while ((c=fgetc(fp))!='>' && c!=EOF)
                                if (isalnum (c)|| is_gap(c))
                                        clen++;
                         max_len_seq=(clen> max_len_seq)?clen: max_len_seq;
                         min_len_seq=(clen< min_len_seq)?clen: min_len_seq;
                         nseq++;
                        clen=0;
                        }
                else
                    c=fgetc (fp);
                }
    vfclose (fp);


   
    LS=declare_sequence (  min_len_seq,  max_len_seq,nseq); 
    LS->nseq=nseq;
    
    fp=vfopen (fname,"r");
    
    current=0;
    c=fgetc(fp);
        while (c!=EOF)
                {
                if (c=='>')
                        {
                        if ( (c=fgetc(fp))=='P')while ( (c=fgetc(fp))!=';');
                        else ungetc ( c, fp);

                        fscanf_seq_name (fp,LS->name[current]);
                
                        l=strlen ( LS->name[current]);
                        if ( LS->name[current][l-1]==','||LS->name[current][l-1]==',')LS->name[current][l-1]='\0';
                        LS->name[current]=translate_name ( LS->name[current]);
                        buf=fgets ( buf, 1000, fp);
                        
                        LS->seq_comment[current]=fgets ( LS->seq_comment[current],COMMENT_SIZE-1, fp);
                        LS->seq_comment[current][strlen(LS->seq_comment[current])-1]='\0';
                        p=0;
                        while ((c=fgetc(fp))!='>' && c!=EOF)
                                if (isalpha (c))
                                    LS->seq[current][p++]=tolower (c);
                                else if ( !isspace(c) && c!='*')
                                    LS->seq[current][p++]=(c);
                        LS->seq[current][p]='\0';
                        LS->len[current]=strlen ( LS->seq[current]);
                        current++;
                        }
                else
                    c=fgetc ( fp);
                }

    vfclose (fp);
    if (comment_out!=NULL) output_pir_check ( comment_out,LS->nseq, LS->seq_comment);
    return LS;
    }

Sequence* get_gor_sequence (char *fname, char *comment_out)
    {
    Sequence *LS;

    FILE *fp;
    int c;

    char name[100];
    int clen=0;
    int current=0;
    int p=0;
    int max_len_seq=0;
    int min_len_seq=99999;
    int nseq=0;
    char *buf;
    
    buf=vcalloc ( 1000, sizeof (char));
    if ((fp=vfopen (fname,"r"))==NULL)
         {printf ( "\nCOULDN'T OPEN %s",fname);
          myexit(EXIT_FAILURE);
         }  
    c=fgetc(fp);
    while (c!=EOF)
                {
                 if (c=='!')
                        {
                        fscanf_seq_name (fp,name);
                        
                        buf=fgets ( buf, 1000, fp);
                        while ((c=fgetc(fp))!='!' && c!=EOF)
                                if (isalnum (c)|| is_gap(c))
                                        clen++;
                         max_len_seq=(clen> max_len_seq)?clen: max_len_seq;
                         min_len_seq=(clen< min_len_seq)?clen: min_len_seq;
                         nseq++;
                        clen=0;
                        }
                else
                    c=fgetc (fp);
                }
    vfclose (fp);
                
    LS=declare_sequence (  min_len_seq,  max_len_seq,nseq); 
    LS->nseq=nseq;
    
    fp=vfopen (fname,"r");
    
    current=0;
    c=fgetc(fp);
        while (c!=EOF)
                {
                if (c=='!')
                        {
                        
                       
                        fscanf_seq_name (fp,LS->name[current]);
                        LS->name[current]=translate_name ( LS->name[current]);
                        buf=fgets ( buf, 1000, fp);
                        
                        p=0;
                        while ((c=fgetc(fp))!='!' && c!=EOF)
                                if (isalnum (c)|| is_gap(c))
                                    LS->seq[current][p++]=tolower (c);
                                
                        LS->seq[current][p]='\0';
                        LS->len[current]=strlen ( LS->seq[current]);
                        current++;
                        }
                else
                    c=fgetc ( fp);
                }

    vfclose (fp);

    return LS;
    }
Sequence* get_swissprot_sequence (char *fname, char *comment_out)
    {
    Sequence *LS;
    FILE *fp;
    int c;
    char *buf;    
    int nseq=0;
    int len, max_len_seq=0, min_len_seq=0;
    
    if ( !check_file_exists(fname))
      {printf ( "\nCOULDN'T OPEN %s",fname);
          myexit(EXIT_FAILURE);
      }  

    buf=vcalloc (LONG_STRING+1, sizeof (char));
    fp=NULL;   
    while ( (fp=find_token_in_file(fname,fp,"\nSQ")))
      {
        nseq++;
        fgets (buf, LONG_STRING, fp);
        len=0;
        while ((c=fgetc(fp))!='/')if(isalpha(c))len++;
        if ( max_len_seq==0)max_len_seq=min_len_seq=len;
        else
          {
            max_len_seq=MAX(len, max_len_seq);
            min_len_seq=MIN(len, min_len_seq);
          }
      }

    LS=declare_sequence (  min_len_seq,  max_len_seq,nseq);     
    LS->nseq=0;
    
    fp=NULL;
    while ( (fp=find_token_in_file(fname,fp,"\nID")))
      {
        fscanf_seq_name (fp, LS->name[LS->nseq]);
        fp=find_token_in_file(fname,fp,"\nSQ");
        fgets (buf, LONG_STRING, fp);
        while ((c=fgetc(fp))!='/')if (isalpha(c))LS->seq[LS->nseq][LS->len[LS->nseq]++]=c;
        LS->seq[LS->nseq][LS->len[LS->nseq]]='\0';
        LS->nseq++;
      }

   
    return LS;
    }
int fscanf_seq_name ( FILE *fp, char *sname)
{
  static char *name;
  int r;
  if ( !sname) return 0;
  
  if ( !name)name=vcalloc ( 10000, sizeof (char));
  fscanf (fp, "%s", name);
  r=strlen (name);
  if ( strlen (name)>MAXNAMES)
    add_warning (stderr, "\nWARNING: Seq Name Too long: [%s]. Truncated to %d", name, MAXNAMES);
  name[MAXNAMES]='\0';
  sprintf ( sname, "%s", name);
  return r;
}

/*******************************************************************************************/
/*                                                                                         */
/*                                                                                         */
/*                               INPUT ALN                                                 */
/*                                                                                         */
/***************************************************************************************** */
void undump_msa ( Alignment *A, char *tmp)
{
  FILE *fp;
  int m;
  char *buf;
  int index;
  
  if ( !A || !tmp || !check_file_exists (tmp))return;
  m=measure_longest_line_in_file (tmp );
  A=realloc_aln2 ( A,A->max_n_seq,m+1);

  buf=vcalloc (m+1, sizeof (char));
  fp=vfopen (tmp, "r");
  while (fscanf (fp, "%d %s\n", &index, buf)==2)
    {
      sprintf ( A->seq_al[index], "%s", buf);
    }
  vfclose (fp);
  vfree (buf);
}
void dump_msa ( char *file,Alignment *A, int nseq, int *lseq)
{
  FILE *fp;
  int a;
  fp=vfopen (file, "w");
  for (a=0; a<nseq; a++)
    fprintf ( fp, "%d %s\n", lseq[a], A->seq_al[lseq[a]]);
  vfclose (fp);
}

void read_aln (char *file_name, Alignment *A)
{
  char *tmp_name;
  Sequence *S;
  

  tmp_name=vtmpnam (NULL);
  
  if (printf_system ( "clustalw_aln2fasta_aln.pl %s > %s",file_name, tmp_name)!=EXIT_SUCCESS)
    {
      printf_exit ( EXIT_FAILURE, stderr, "Could Not Read File %s [FATAL:%s]\n", file_name, PROGRAM);
    }
  else
    {
      S=get_fasta_sequence ( tmp_name,NULL);
      A=seq2aln (S, A, 0);  
    }
  return;
}
void read_stockholm_aln (char *file_name, Alignment *A)
{
  char *tmp_name;
  Sequence *S;
  

  tmp_name=vtmpnam (NULL);
  if (printf_system ( "clustalw_aln2fasta_aln.pl %s > %s",file_name, tmp_name)!=EXIT_SUCCESS)
    {
      printf_exit ( EXIT_FAILURE, stderr, "Could Not Read File %s [FATAL:%s]\n", file_name, PROGRAM);
    }
  else
    {
      int a;
      S=get_fasta_sequence ( tmp_name,NULL);
      for (a=0; a<S->nseq; a++)
        {
          if (strstr (S->name[a], "_stockholm"))
            {
              substitute ( S->name[a], "_stockholmspace_", " ");
              substitute ( S->name[a], "_stockholmhasch_", "#");
            }
        }
      A=seq2aln (S, A, 0);  
    }
  return;
}
Alignment* read_blast_aln ( char *file_name, Alignment *A)
{
  char *tmp_name;

  int type;

  
  if ( !(type=is_blast_file (file_name)))
    {
      myexit (EXIT_FAILURE);
    }
  tmp_name=vtmpnam ( NULL);
  if (type==BLAST_TXT)
    {
      printf_system("cat %s | blast_aln2fasta_aln.pl | fasta_aln2fasta_aln_unique_name.pl >%s", file_name, tmp_name);
    }
  else if (type==BLAST_XML)
    {
      
      printf_system("blast_xml2fasta_aln.pl %s >%s", file_name, tmp_name);
    }

  main_read_aln (tmp_name, A);
  return A;
}


void read_number_aln ( char *file_name, Alignment *A)
   {
    FILE *fp, *fp2;
    int * ptr_aln;
    int a,b,d;
    int c;
    char *buf=NULL;

    int tot=0;
    int flag=0;
    char *fname;   
    int n_comment=0;

    int nseq=0;
    int max_len=0;

    
    fp=vfopen ( file_name, "r");
    
    fname=vtmpnam(NULL);
    fp2=vfopen ( fname, "w");
    while ( (c=fgetc(fp))!=EOF)
        {
            fprintf ( fp2, "%c", c);
        }
    vfclose (fp);
    vfclose (fp2);

  
    /*1 Count The number of sequences*/ 
    fp=vfopen ( fname, "r");
    buf=vfgets ( buf,fp);
    if ( !isblanc (buf));
    while ( isblanc (buf))
        {
          buf=vfgets ( buf, fp);
        }
    while (!isblanc (buf))
        {
        buf=vfgets ( buf,fp);
        }
    while ( !isalnum ((c=fgetc(fp))))
        {       
        ungetc(c,fp);
        buf=vfgets ( buf,fp);           
        }
    
    if ( c!='\n')ungetc(c,fp);
    
    while ( isalnum ((c=fgetc(fp))))
        {
        ungetc(c,fp);           
        a=0;
        while ( isgraph ((c=fgetc(fp))));                       
        nseq++;
        buf=vfgets ( buf, fp);
        }    
    vfclose (fp);

    /*DONE*/
    /*2 get_max_len*/
    max_len=count_n_char_in_file(fname)/nseq;
    A=realloc_alignment2( A, nseq+1, max_len+1);

    /*DONE*/
        
   
    fp=vfopen ( fname, "r");
    buf=vfgets ( buf, fp);
    if ( !isblanc (buf))sprintf (A->aln_comment[n_comment++], "%s", buf);
    while ( isblanc (buf))
        {
        buf=vfgets ( buf,fp);           
        }
    while (!isblanc (buf))
        {
        buf=vfgets ( buf, fp);
        sprintf ( A->aln_comment[n_comment++], "%s", buf);
        
        }
    while ( !isalnum ((c=fgetc(fp))))
        {       
        ungetc(c,fp);
        buf=vfgets ( buf, fp);
        
        }
    
    if ( c!='\n')ungetc(c,fp);
    
    while ( isalnum ((c=fgetc(fp))))
        {
        ungetc(c,fp);
        
        fscanf_seq_name (fp, A->name[A->nseq]); 

        if ( name_is_in_list (A->name[A->nseq], A->name, A->nseq, 100)!=-1)
          {
            fprintf ( stderr, "\nWARNING (read_number_aln): Sequence %s Duplicated in File %s ", A->name[A->nseq], A->file[A->nseq]);
            if (!getenv("ALLOW_DUPLICATE"))
              {
                fprintf ( stderr, " [FATAL:%s]\n", PROGRAM);
                myexit (EXIT_FAILURE);
              }
          }      
        A->nseq++;
        buf=vfgets ( buf,fp);
        }
    
    vfclose (fp);
  
    
     
    if ((fp=vfopen ( fname, "r"))==NULL)
        printf ( "\nCOULDN'T READ %s", fname);
   
    ptr_aln=vcalloc ( A->nseq, sizeof(int));
    while ( flag==0)
        {
        while (  (c=fgetc(fp))!='\n');
        if ( (c=fgetc(fp))=='\n')
            flag=1;
        }
    while ( !isalnum(c=fgetc(fp)));
    ungetc ( c, fp);
    while ( c!=EOF)
        {
        tot=0;
        while(tot< A->nseq && c!=EOF)
            {
             b=0;
             while ( !isgraph (c=fgetc(fp)) && c!=EOF);
             if ( c!=EOF)ungetc(c, fp);
             while ( isgraph((buf[b++]=fgetc(fp))));
             buf[b-1]='\0';
             for ( a=-1,d=0; d< A->nseq; d++)
                if ( strcmp (A->name[d], buf)==0)
                    {a=d;
                     tot++;
                    }

             if ( a==-1) while ( (c=fgetc(fp))!='\n' && c!=EOF);
             else
               {
                 while ( (c=fgetc(fp))!='\n')
                   {
                     if ( isgraph(c) || is_gap(c))
                       {if ( isalpha(c))
                         c=(A->residue_case==2)?c:tolower(c);
                       
                       if (!isspace(c))A->seq_al[a][ptr_aln[a]++]=c;
                       }
                   }
               }
             }
         while ( !isalnum(c=getc(fp)) && c!=EOF);
         if ( c!=EOF)
            ungetc (c, fp);
         }
         
    vfclose (fp);
    
   
    for ( a=0; a< A->nseq; a++)
        {A->seq_al[a][ptr_aln[a]]='\0';
         A->order[a][0]=a;
         A->order[a][1]=0;
        }
    
    A->len_aln= strlen(A->seq_al[0]);  
    
    vfree (buf);
    vfree(ptr_aln);
    vremove (fname);
    
    }           
void read_amps_aln ( char *in_file, Alignment *A)
        {
        FILE *fp;
        int a, b, c, cont=1;
        A->nseq=get_amps_seq_name ( A->name, in_file);
        
        fp=vfopen ( in_file, "r");
        fp=set_fp_id(fp, "1*");
        while ( (c=fgetc(fp))!='\n');
        b=0;
        while ( cont==1)
                {
                c=fgetc ( fp);
                c=fgetc(fp);
                if ( c=='*')
                        {
                        cont=0;
                        for ( a=0; a<A->nseq; a++)
                                A->seq_al[a][b]='\0';
                        A->len_aln=b;
                        }
                         
                else
                        {
                        ungetc (c, fp);
                        for ( a=0; a< A->nseq; a++)
                                {
                                c=fgetc(fp);
                                if ( c==' ')A->seq_al[a][b]='-';
                                else
                                        {
                                        A->seq_al[a][b]=c;
                                        A->len[a]++;
                                        }
                                }
                        while ((c=fgetc(fp))!='\n');
                        b++;
                        }
                }
        }






int get_amps_seq_name ( char **name, char* fname)
        {
        FILE *fp;
        int nseq=0;
        
        fp=vfopen ( fname, "r");
        fp=set_fp_id ( fp, "Index");
        while ( (fgetc(fp))!='\n');
        while ( isspace(fgetc(fp)))
                {fscanf (fp, "%*d >%s", name[nseq++]);
                 while ( (fgetc(fp))!='\n');
                }
        vfclose ( fp);
        return nseq;
        }
Alignment * read_gotoh_aln ( char *fname, Alignment *A)
   {
    FILE *fp;
    int * ptr_aln;
    int a,b,d,e;


    char *buf;
    char buf2[VERY_LONG_STRING+1];
    char buf3[VERY_LONG_STRING+1];
    char buf4[VERY_LONG_STRING+1];

    int tot=0;

    int l;
    int nseq, max_len;
    
   
    if ( !check_file_exists (fname))return NULL;
    fp=vfopen ( fname, "r");

/*1 GET THE NUMBER OF SEQUENCES*/
    nseq=0;
    buf=vcalloc ( VERY_LONG_STRING+1, sizeof (char));    
    while ( isblanc (buf=fgets ( buf, VERY_LONG_STRING, fp)));
    while (!isblanc (buf=fgets ( buf, VERY_LONG_STRING, fp)));
    while ( isblanc (buf=fgets ( buf, VERY_LONG_STRING, fp)));
    while ( !isblanc ( buf) && buf!=NULL)
        {
        a=-1;
        d=sscanf ( buf, "%d %s %s %s", &a, buf2, A->name[A->nseq],buf3);
        if ( a!=-1)
                {
                if ( name_is_in_list (A->name[A->nseq], A->name, A->nseq, 100)!=-1)
                  {
                    fprintf ( stderr, "\nWARNING (get_amps_seq_name): Sequence %s Duplicated in File %s ", A->name[A->nseq], A->file[A->nseq]);
                    if (!getenv("ALLOW_DUPLICATE"))
                      {
                        fprintf ( stderr, " [FATAL:%s]\n", PROGRAM);
                        myexit (EXIT_FAILURE);
                      }
                  }                 
                nseq++;
                fgets(buf, VERY_LONG_STRING, fp);
                }
        else ( buf=NULL);
        }
    vfclose (fp);
/*2 Get the MAX Len and Reallocate*/
    max_len=count_n_char_in_file(fname)/nseq;
    A=realloc_aln2( A, nseq+1, max_len+1);
/*3 Get The Sequences Names*/
    A->nseq=0;
    fp=vfopen ( fname, "r");
    while ( isblanc (buf=fgets ( buf, VERY_LONG_STRING, fp)));
    while (!isblanc (buf=fgets ( buf, VERY_LONG_STRING, fp)));
    while ( isblanc (buf=fgets ( buf, VERY_LONG_STRING, fp)));
    while ( !isblanc ( buf) && buf!=NULL)
        {
        a=-1;
        d=sscanf ( buf, "%d %s %s %s", &a, buf2, A->name[A->nseq],buf3);
        if ( a!=-1)
                {
                if ( d==4)sprintf (A->name[A->nseq],"%s", buf3);        
                A->nseq++;
                fgets(buf, VERY_LONG_STRING, fp);
                }
        else ( buf=NULL);
        }
    vfclose (fp);   

/*READ THE ALN*/     
    fp=vfopen ( fname, "r");

    buf=vcalloc ( VERY_LONG_STRING+1, sizeof (char));;  
    ptr_aln=vcalloc ( A->nseq, sizeof(int));
    
    while ( isblanc (buf=fgets ( buf, VERY_LONG_STRING, fp)));
    while (!isblanc (buf=fgets ( buf, VERY_LONG_STRING, fp)));
    
    
    while ( isblanc (buf=fgets ( buf, VERY_LONG_STRING, fp)));
    
    while (buf!=NULL)
        {
        tot=0;
        while(tot< A->nseq)
            {
            
            e=sscanf (buf, "%d %s %s %s", &e, buf2, buf3, buf4);
            if ( e==4)sprintf( buf3, "%s", buf4);
            
            
            for ( d=0; d< A->nseq; d++)
                {
                
                if ( strcmp (A->name[d], buf3)==0)
                    {a=d;
                     tot++;
                    }
                }
             l=strlen (buf2);
             if ( buf2[l-1]=='|')l--;
             buf2[l]='\0';
            
             for (b=0; b<l; b++)
                {
                if ( isgraph (buf2[b]))
                        A->seq_al[a][ptr_aln[a]++]=(A->residue_case==2)?buf2[b]:tolower (buf2[b]);
                 }
             buf=fgets(buf, VERY_LONG_STRING, fp);      
             }
         if ( buf!=NULL)
                {
                buf=fgets(buf, VERY_LONG_STRING, fp);
                while ( isblanc (buf) && buf!=NULL)
                        {
                        buf=fgets ( buf, VERY_LONG_STRING, fp);
                        }
                }
         
         }
         
    vfclose (fp);
    
   
    for ( a=0; a< A->nseq; a++)
        {A->seq_al[a][ptr_aln[a]]='\0';
        }
    
    A->len_aln= strlen(A->seq_al[0]);  
    
   
    
    for ( a=0; a< A->nseq; a++)
        {
        for ( b=0; b< A->len_aln; b++)
                A->len[a]+=1-is_gap(A->seq_al[a][b]);
        }
    for ( a=0, b=0; a< A->len_aln; a++)
        {
        if ( !is_gap(A->seq_al[0][a]) &&!is_gap(A->seq_al[1][a]))b++;
        }
    return A;
    }
    




void read_msf_aln ( char *fname, Alignment *A)
   {
    char command[1000];
    char *tmp_name;
    Sequence *S;
    
    tmp_name=vtmpnam(NULL);
    sprintf ( command, "msf_aln2fasta_aln.pl %s > %s", fname, tmp_name);

    if ( my_system (command)!=EXIT_SUCCESS)
      {
        fprintf ( stderr, "\nERROR: file %s does not have a legal msf format [FATAL:%s]", fname,PROGRAM);
        myexit (EXIT_FAILURE);
      }

    S=get_fasta_sequence ( tmp_name,NULL);
    A=seq2aln (S, A, 0);  
    vremove (tmp_name);
    return;
    }           

/**************************************************************************************************/
/*************************************REFORMAT OUT*************************************************/
/**************************************************************************************************/
/*******************************************************************************************/
/*                                                                                         */
/*                                                                                         */
/*                               OUTPUT MATRICES                                           */
/*                                                                                         */
/***************************************************************************************** */



int output_freq_mat ( char *outfile, Alignment *A)
    { /*
        function documentation: start
        
        int output_freq_mat ( char *outfile, Aligmnent *A)

        This function counts the number of residues in each column of an alignment (Prot)
        It outputs these values in the following format

        A | 0 0 0 1 0
        B | 1 0 0 0 1
        - | 0 1 1 0 0

        This format can be piped into:
        The routine used for computing the p-value  gmat-inf-gc-v2c
        
        function documentation: end
      */
      
    int a, b;
    int **freq_mat;
    FILE *fp;
    
    
    freq_mat=aln2count_mat (A);
            
    fp=vfopen ( outfile, "w");
    for ( b=0; b< 26; b++)
      {
        fprintf (fp, "%c |", 'A'+b);
        for ( a=0; a< A->len_aln; a++)fprintf (fp,"%d ", freq_mat[b][a]);
        fprintf (fp, "\n");
      }
    fprintf (fp, "- |");
    for ( a=0; a< A->len_aln; a++)fprintf (fp,"%d ", freq_mat[26][a]);
    
    free_int (freq_mat, -1);
    vfclose ( fp);
    return 1;
    }
/*******************************************************************************************/
/*                                                                                         */
/*                                                                                         */
/*                               OUTPUT P-Values                                           */
/*                                                                                         */
/***************************************************************************************** */   
float output_maln_pval ( char *outfile, Alignment *A)
    {
      /*
        function documentation: start
        float output_maln_pval ( char *outfile, Aligmnent *A)

        This function outputs the p-value of a multiple alignmnet as described 
        in Hertz, Stormo, Bioinformatics, 15-7/8, 563/577
            ftp beagle.colorado.edu /pub/cosensus
        Locally
            packages/consensus/gmat-inf-gc-v2c
        
        
        The routine used for computing the p-value is the program gmat-inf-gc-v2c
        function documentation: end
      */

  
    char *mat;
    char *result;
    FILE *fp;
    float value;
    char command[LONG_STRING];
    char string[STRING];
    mat=vtmpnam (NULL);
    result=vtmpnam (NULL);
    
    output_freq_mat (mat,A);
    sprintf ( command, "more %s | gmat-inf-gc-v2c -A abcdefghijklmnopqrstuvwxyz> %s",mat, result);
    my_system ( command);
    
    if ( !check_file_exists(result))return 0;
    fp=find_token_in_file ( result, NULL, "ln(p-value):");
    
    fscanf ( fp, "%s",string);
    value=atof ( string);
    vfclose ( fp);
    
    vremove ( mat);
    vremove ( result);
    
    fp=vfopen ( outfile, "w");
    fprintf ( fp, "%.6f\n", value);
    vfclose ( fp);
    
    return value;
    }
              
    
/*******************************************************************************************/
/*                                                                                         */
/*                                                                                         */
/*                               OUTPUT WEIGHTS                                            */
/*                                                                                         */
/***************************************************************************************** */
int output_seq_weights ( Weights *W, char *wfile)
        {
        FILE*fp;
        int a;
        
        if ( W==NULL)return 0;
        
        fp=vfopen (wfile, "w");
        if ( fp==NULL)return 0;
        
        
        for ( a=0; a< W->nseq; a++)
                {
                
                  fprintf ( fp, "%s %.2f\n", W->seq_name[a],W->SEQ_W[a]);
                }
        vfclose ( fp);
        return 1;
        }  
void output_pw_weights4saga ( Weights *W, float **w_list, char *wfile)
        {
        FILE*fp;
        int a, b;
        fp=vfopen (wfile, "w");
        
        fprintf ( fp, "%s\n$\n", W->comments); 
        for ( a=0; a< W->nseq-1; a++)
                {
                for (b=a+1; b< W->nseq; b++)
                        {
                        fprintf ( fp, "%s %s %f\n", W->seq_name[a], W->seq_name[b],w_list[a][b]);
                        }
                }
        fprintf ( fp, "$\n");
        vfclose ( fp);
        }

FILE * display_weights (Weights *W, FILE *fp)
{
  int a;
  int max_len;
  
  if ( W==NULL)
    {
      fprintf ( fp, "\n\nUN-WEIGHTED MODE: EVERY SEQUENCE WEIGHTS 1\n");
      return fp;
    }
  fprintf ( fp, "\n\nWEIGHTED MODE:%s\n\n", (W)->mode);
  for ( a=0, max_len=0; a< W->nseq; a++)max_len=MAX(max_len, strlen (W->seq_name[a]));
  for ( a=0; a< (W->nseq); a++)
    {
      fprintf ( fp, "\t%*s %.2f\n", max_len,(W)->seq_name[a],W->SEQ_W[a]);
    }
  fprintf ( fp, "\n");
  return fp;
}

/*******************************************************************************************/
/*                                                                                         */
/*                                                                                         */
/*                               OUTPUT SEQ                                                */
/*                                                                                         */
/***************************************************************************************** */
int ** input_similarities (char *file, Alignment *A, char *mode)
{
  int a, b, i, n;
  int **sim;
  float score;
  char name[1000];
  FILE *fp=NULL;
  char *buf1=NULL, *buf2=NULL;
  int new_aln=0;
  

  
  if ( !check_file_exists (file) || !is_distance_matrix_file (file) ||!is_similarity_matrix_file (file) )
    {
      return NULL;
    }
  
  if ( A)
    {
      fp=vfopen (file, "r");
      while ((buf2=vfgets (buf1,fp))!=NULL )
        {
          if (strstr (buf2, "SEQ_INDEX"))
            {
              buf1=buf2;
              sscanf (buf1, "# SEQ_INDEX %s %d",name, &i);
              if ( !strm (A->name[i], name))
                {
                  return NULL;
                }
            }
        }
      vfclose (fp);
    }
  else
    {
  
      A=similarities_file2aln(file);
      new_aln=1;
    }
  
  sim=declare_int ( A->nseq, A->nseq);
  for ( a=0; a<A->nseq; a++)sim[a][a]=100;
  
  
  fp=find_token_in_file (file, NULL, "PW_SEQ_DISTANCES");
  fp=find_token_in_file (file, fp, "BOT");
  while ((buf2=vfgets (buf1,fp))!=NULL )
    {
      if ( !(strstr (buf2, "BOT\t") || strstr (buf2, "TOP\t")))continue;
      buf1=buf2;
      n=sscanf (buf1, "%*s %d %d %f", &a, &b, &score);
      if ( n!=3)
        {
          free_int (sim, -1);
          return NULL;
        }
      else sim[a][b]=sim[b][a]=(int)score;
    }
  vfclose (fp);
  vfree (buf1);
  if (new_aln)free_aln(A);
  return sim;
}

Alignment * similarities_file2aln ( char *file)
{
  int nseq=0, i;
  FILE *fp;
  char name[1000];
  Alignment *A;
  

  fp=vfopen (file, "r");
  while ((fp=find_token_in_file (file,fp, "SEQ_INDEX")))nseq++;
  A=declare_aln2 (nseq+1, 10);
  
  while ((fp=find_token_in_file (file,fp, "SEQ_INDEX")))
    {
      fscanf (fp, "%s %d", name,&i);
      sprintf ( A->name[i], "%s", name);
    }
  A->nseq=nseq;

  return A;
}
  
void output_similarities (char *file, Alignment *A, char *mode)
{
  float s;
  float *tot;
  float bigtot=0;
  int n, max;
  FILE *fp;
  int a, b;
  char *p;
  int **M=NULL;
  for (max=0, a=0; a< A->nseq; a++)max=MAX(max,(strlen (A->name[a])));
  

  tot=vcalloc ( A->nseq, sizeof (float));
  fp=vfopen (file, "w");
  fprintf (fp, "# TC_SIMILARITY_MATRIX_FORMAT_01\n");
  for ( a=0; a<A->nseq; a++)
    fprintf ( fp, "# SEQ_INDEX %s %d\n",A->name[a],a);
  fprintf ( fp, "# PW_SEQ_DISTANCES \n");
  for (n=0,a=0;a< A->nseq-1; a++)
    {
      for ( b=a+1; b<A->nseq; b++, n++)
        {
           if (strstr (mode, "_sarmat2"))
            {
              s=get_sar_sim (A->seq_al[a], A->seq_al[b]);
            }
          else if (strstr (mode, "_sar"))
            {
              s=get_sar_sim (A->seq_al[a], A->seq_al[b]);
            }
          else if ( (p=strstr (mode, "_memory_")))
            {
              int **sim;
              sscanf ( p, "_memory_%ld", (long int*)&sim);
              s=sim[a][b];
            }
          else if ( strstr (mode, "_idscore") || strstr ( mode, "_covscore"))
            {
              static Sequence *S;
              if (a==0 && b==1)
                {
                  free_sequence (S, -1);
                  if ( strstr (mode, "idscoreDNA"))
                    M=read_matrice ("idmat");
                  else
                    M=read_matrice("blosum62mt");
              
                  S=aln2seq(A);
                }
              if ( strstr (mode, "_idscore"))s=idscore_pairseq(S->seq[a], S->seq[b], -10,-1, M, "sim");
              else            s=idscore_pairseq(S->seq[a], S->seq[b], -10,-1, M, "cov");
            }
          else if ( strstr (mode, "cov"))
            {
              s=get_seq_sim ( A->seq_al[a], A->seq_al[b],GAP_LIST, "cov");
            }
          else
            {
              s=get_seq_fsim2 (A->seq_al[a], A->seq_al[b],GAP_LIST, mode);
            }
          fprintf (fp, "BOT\t %4d %4d\t %5.2f %*s\t %*s\t %5.2f\n", a,b,s,max,A->name[a], max, A->name[b], s);
          fprintf (fp, "TOP\t %4d %4d\t %5.2f %*s\t %*s\t %5.2f\n", b,a,s,max,A->name[b], max, A->name[a], s);
          tot[a]+=s;
          tot[b]+=s;
          bigtot+=s;
        }
    }
  for ( a=0; a< A->nseq; a++)
    {
      fprintf (fp, "AVG\t %d\t %*s\t %*s\t %5.2f\n", a,max,A->name[a], max, "*", tot[a]/(A->nseq-1));
      
    }
  vfree (tot);free_int (M, -1);
  fprintf (fp, "TOT\t %*s\t %*s\t %5.2f\n", max,"TOT", max, "*", bigtot/n);
  vfclose (fp);
}

void output_similarities_pw (char *file, Alignment *A, Alignment *B,char *mode)
{
  float s;
  float *tot;
  float bigtot=0;
  int n, max;
  FILE *fp;
  int a, b;

  int **M=NULL;
  Sequence *SA, *SB;
  
  if ( strstr (mode, "idscoreDNA"))
    M=read_matrice ("idmat");
  else
    M=read_matrice("blosum62mt");
  
  SA=aln2seq(A);
  SB=aln2seq(B);
   
  for (max=0, a=0; a< A->nseq; a++)max=MAX(max,(strlen (A->name[a])));
  for (a=0; a< B->nseq; a++)max=MAX(max,(strlen (B->name[a])));
  

  tot=vcalloc ( A->nseq, sizeof (float));
  fp=vfopen (file, "w");
  fprintf (fp, "# TC_SIMILARITY_MATRIX_FORMAT_01\n");
  for ( a=0; a<A->nseq; a++)
    fprintf ( fp, "# SEQ_INDEX %s %d\n",A->name[a],a);
  fprintf ( fp, "# PW_SEQ_DISTANCES \n");
  for (n=0,a=0;a< A->nseq; a++)
    {
      for ( b=0; b<B->nseq; b++, n++)
        {
          s=idscore_pairseq(SA->seq[a], SB->seq[b], -10,-1, M, "sim");
          fprintf (fp, "BOT\t %4d %4d\t %5.2f %*s\t %*s\t %5.2f\n", a,b,s,max,A->name[a], max, B->name[b], s);
          fprintf (fp, "TOP\t %4d %4d\t %5.2f %*s\t %*s\t %5.2f\n", b,a,s,max,B->name[b], max, A->name[a], s);
          tot[a]+=s;
          tot[b]+=s;
          bigtot+=s;
        }
    }
  
  for ( a=0; a< A->nseq; a++)
    {
      fprintf (fp, "AVG\t %d\t %*s\t %*s\t %5.2f\n", a,max,A->name[a], max, "*", tot[a]/(A->nseq-1));
    }
  vfree (tot);free_int (M, -1);
  fprintf (fp, "TOT\t %*s\t %*s\t %5.2f\n", max,"TOT", max, "*", bigtot/n);
  vfclose (fp);
}
void output_conservation_statistics ( char *file, Alignment *A)
{
  int a, b, c,c1, c2;
  double **tot;
  char aa[1000];
  int naa;
  
  sprintf (aa, "%s", BLAST_AA_ALPHABET);
  naa=strlen (aa);
  
  tot=declare_double (256, 256);
  
  
  for ( a=0; a<A->nseq; a+=2)
    {
      b=a+1;
      for ( c=0; c<A->len_aln; c++)
        {
          c1=tolower (A->seq_al[a][c]);
          c2=tolower (A->seq_al[b][c]);
          if ( !is_gap(c1) && !is_gap(c2))
            {
              tot[c1][c2]++;
              tot[c2][c1]++;
              tot[c1][0]++;
              tot[c2][0]++;
              tot[0][0]++;
            }
        }
    }
  
  fprintf ( stdout, "# BLAST_MATRIX FORMAT\n#ALPHABET=%s\n",aa);
  for (a=0; a<naa; a++)fprintf ( stdout, "%3c ", toupper(aa[a]));
  fprintf ( stdout, "\n");
  for (a=0; a< naa; a++)
    {
      fprintf (stdout, "%c", toupper(aa[a]));
      for ( b=0; b< naa; b++)
        {
          float f1, f2, f3, r, v;
          c1=tolower(aa[a]);c2=tolower(aa[b]);
          f1=(float)((tot[c1][c2]*2)/tot[0][0]);
          f2=(float)((tot[c1][0])/tot[0][0]);
          f3=(float)((tot[c2][0])/tot[0][0]);
          r=(float)(f2==0 || f3==0)?0:(f1/(f2*f3));
          v=(r==0)?0:((float)10*log((double)r));
          fprintf (stdout, " %5d",(int)v);
        }
      fprintf ( stdout, "\n");
    }
}
void output_statistics (char *file, Alignment *A, char *mode)
    {
      FILE *fp;
      int a, b, c, d=0, n;
      int maxname=0;

      
      if (!mode || !mode[0])
        mode="hnrglNL";
      else if ( mode[0]=='_')
        mode++;
      for ( a=0; a<A->nseq; a++)maxname=MAX(strlen(A->name[a]), maxname);
      maxname++;
      
      
      fp=vfopen (file, "w");
      
      if (mode[0]=='h')
        {
          b=0;
          while ((c=mode[b++])!='\0')
            {
              if ( c=='n') fprintf (fp, "%-*s ",maxname,"name");
              if ( c=='l') fprintf (fp, "%-*s ",5,"nres");
              if ( c=='g') fprintf (fp, "%-*s ",5,"ngap");
              if ( c=='t') fprintf (fp, "%-*s ",5,"len");
            }
          if (is_in_set ( c, "nlgt"))     fprintf (fp, "\n");
          mode++;
        }
      b=0;
      while ((c=mode[b++])!='\0')
        {
          if ( c=='n')break;
          if ( c=='N'){d=1;fprintf (fp, "NSEQ %d ", A->nseq);}
          if ( c=='L'){d=1;fprintf (fp, "LEN  %d ", A->len_aln);}         
        }
      if ( d) fprintf (fp, "\n");
      
      for (a=0; a<A->nseq; a++)
        {
          b=0;
          d=0;
          while ((c=mode[b++])!='\0')
            {
              if (is_in_set ( c, "nlgt"))d=1;

              if (c=='n'){d=1;fprintf ( fp, "%-*s ", maxname,A->name[a]);}
              if (c=='l')
                {
                  for (n=0,d=0; d<A->len_aln; d++)n+=!is_gap(A->seq_al[a][d]);
                  fprintf ( fp, "%-5d ",n);
                }
              if (c=='g')
                {
                  for (n=0,d=0; d<A->len_aln; d++)n+=((is_gap(A->seq_al[a][d]) && !is_gap(A->seq_al[a][d+1]))||(is_gap(A->seq_al[a][d])&& A->seq_al[a][d+1]=='\0')) ;
                  fprintf ( fp, "%-5d ",n); 
                }
              if (c=='t')
                {
                  fprintf ( fp, "%-5d ",(int)strlen (A->seq_al[a]));             
                }
               if (c=='N' && d)
                {
                 fprintf ( fp, "%-5d ",A->nseq);                 
                }
              if (c=='L'&& d)
                {
                 fprintf ( fp, "%-5d ",A->len_aln);              
                }
            }
          if (d)fprintf ( fp, "\n"); 
        }
      vfclose (fp);
    }

int output_age_matrix ( char *outfile, int val)
{
  int **mat;
  int a, b;
  char alp[]="abcdefghij-";
  int naa;
  
  mat=declare_int ( 256, 256);
  naa=strlen (alp);
  for ( a=0; a<naa; a++)
    for ( b=0; b<naa; b++)
      {
        if (is_gap(alp[a]) ||is_gap(alp[b] ))mat[(int)alp[a]][(int)alp[b]]=((val==0)?1:val)*-1;
        else mat[(int)alp[a]][(int)alp[b]]=(FABS((a-b))*-1)*((val==0)?1:val);
        
      }
  output_mat ( mat,outfile, alp, 0);
  free_arrayN((void**)mat, 2);
  return 1;
}
     



int output_transitions(char *outfile, Alignment *A)
{
  double table[256][256];
  double symbols[256];
  double tot, l, freq, expected, log_odd;
  int a, b;
  char *s;
  char *alp;
  int naa=0;
  int **mat;
  float **fmat;
  
  FILE *fp;
  
  for ( a=0; a< 256; a++)
    for (b=0; b<256; b++) 
      {
        symbols[b]=0;
        table[a][b]=0;
      }
  alp=vcalloc ( 256, sizeof (char));
  mat=declare_int ( 256,256);
  fmat=declare_float ( 256,256);
  
  for (tot=0,a=0; a< A->nseq; a++)
    {
      ungap (A->seq_al[a]);
      lower_string (A->seq_al[a]);
      s=A->seq_al[a];
      l=strlen (s);
      if ( s[0]=='\0') continue;
      symbols[(int)s[0]]++;
      for ( b=1; b< l; b++)
        {
          symbols[(int)s[b]]++;
          table[(int)s[b-1]][(int)s[b]]++;
          tot++;
        }
    }
  for (naa=0, a=0; a< 256; a++)
    {
      if (symbols[a])alp[naa++]=a;
    }
  
      
  for ( a=0; a< 256; a++)
    for (b=0; b<256; b++) 
      {
        if (symbols[a]&& symbols[b] && table[a][b] && tot>0)
          {
            freq=(table[a][b])/tot;
            expected=(symbols[a]*symbols[b])/(tot*tot);
            log_odd=log (freq/expected);
            mat[a-'A'][b-'A']=log_odd*10;
            fmat[a-'A'][b-'A']=log_odd;
          }
        else if ( symbols[a]&& symbols[b])
          {
            mat[a-'A'][b-'A']=-999;
            fmat[a-'A'][b-'A']=-999;
          }
      }
  output_mat ( mat,outfile, alp, 'A');
  
  fp=vfopen (outfile, "a");
  for ( a=0; a<256; a++)
    if ( symbols[a])
      {
        fprintf (fp, "# %c tot: %6d freq: %7.5f\n", a, (int)symbols[a],(float)symbols[a]/tot);
      }
  
  for ( a=0; a< 256; a++)
    for (b=0; b<256; b++) 
      {
        if (symbols[a]&& symbols[b])
          {
            freq=(table[a][b])/tot;
            fprintf (fp, "# %c%c tot: %6d freq: %7.5f log_odd: %9.3f\n", a, b, (int)table[a][b],(float)freq,fmat[a-'A'][b-'A']);                    
          }
      }
  vfclose (fp);
  vfree(alp);
  free_arrayN ((void **)mat, 2);
  free_arrayN ((void **)fmat, 2);
  
  return 1;
}



void output_est_prf   (char *fname, Alignment *A)
        {
        int a;
        FILE *fp;

        if ( !A->P)
          {
            fprintf ( stderr, "\nFormat output_est_prf Impossible: No profile\n");
            myexit(EXIT_FAILURE);
          }
        

        fp=vfopen ( fname, "w");
        fprintf ( fp, "Consensus Sequence\nReconstructed with %s (%s,%s)\n",PROGRAM,AUTHOR,DATE);
        fprintf ( fp, "%4c %4c %4c %4c %15s    Consensus\n",  'A','G','C','T', "Internal Gaps");

        for ( a=0; a< A->len_aln; a++)
          {
            fprintf (fp, "%4d %4d %4d %4d %15d %c\n", (A->P)->count[0][a],(A->P)->count[1][a],(A->P)->count[2][a], (A->P)->count[3][a], (A->P)->count[4][a],A->seq_al[0][a]);
          }
        return;
        }

          
void output_gotoh_seq (char *fname, Alignment*A )
        {
        int a;
        FILE *fp;
                
        fp=vfopen ( fname, "w");
        fprintf ( fp, "%d %d\n",A->nseq, A->max_len);
        for ( a=0; a< A->nseq; a++)
                {
                ungap ( A->seq_al[a]);
                fprintf ( fp, ">%s\n", A->name[a]);
                fp=output_string_wrap ( 50,A->seq_al[a] , fp);
                fprintf ( fp, "//\n");
                }
                
        vfclose (fp);
        }           

void output_mult_fasta_seq (char *fname, Alignment*A, int n )
        {
        int a;
        FILE *fp;
        
        fp=vfopen (fname, "w");
        ungap(A->seq_al[0]);
        for (a=0; a<n; a++)
          {
            fprintf (fp, ">%s_%d\n%s\n", A->name[0],a+1, A->seq_al[0]);
          }
        vfclose (fp);
        }
int output_wexons (char *name, Alignment *A)
{
  int a,b,c;
  FILE *fp;
  int **w;
  fp=vfopen (name, "w");
  if (!fp) return 0;
  if (!A) {vfclose(fp);return 0;}
  w=A->score_res;
  if (!w) {vfclose (fp);return 0; }
  
  for (a=0; a<A->nseq; a++)
    {
      fprintf (fp, ">%s\n", A->name[a]);
      for (c=0,b=0; b<A->len_aln; b++)
        {
          int r;
          r=A->seq_al[a][b];
          if (!is_gap(r) && r!='f' && r!='F')
            {
              fprintf (fp, " %c %d ", r,w[a][c++]);
            }
          else if (!is_gap(r))fprintf (fp,"%c -1 ",r);
        }
      fprintf (fp, "\n");
    }
  return 1;
}
char * output_fasta_seqX (char *name, char *mode, Sequence *S, Alignment *A, int i)
{
  FILE *fp;
  
  if (!name)name=vtmpnam (NULL);
  fp=vfopen (name, mode);
  if ( (S && S->nseq<=i) || (A && S->nseq<=i) || (!A && !S))
    {
      fprintf ( stderr, "\nERROR in function reformat:output_fasta_seqX[FATAL:%s]", PROGRAM);
      myexit (EXIT_FAILURE);
    }

  else if ( S) 
    fprintf ( fp, ">%s %s\n%s\n", S->name[i], S->seq_comment[i], S->seq[i]);
  else if ( A)
    {
      ungap (A->seq_al[i]);
      fprintf ( fp, ">%s %s\n%s\n", A->name[i], A->seq_comment[i], A->seq_al[i]);
    }
  vfclose (fp);
  return name;
}

void output_fasta_seq1 (char *fname, Alignment*A )
        {
        char seq_name[VERY_LONG_STRING];
        int a;
        FILE *fp;
        char *extension;
        
        for ( a=0; a< A->nseq; a++)
                {
                if ( strncmp( fname, "name",4)==0)
                  {
                    if ( (fname+4)[0]!='\0')extension=fname+5;
                    else
                      extension=NULL;
                    
                     sprintf ( seq_name,"%s.%s", A->name[a],(extension==NULL)?"seq":extension);
                  }
                else
                   sprintf ( seq_name,"%s.seq",A->name[a]);
                
                ungap ( A->seq_al[a]);
                fp=vfopen (seq_name, "w");
                fprintf (fp, ">%s %s\n", A->name[a], A->seq_comment[a]);
                fp=output_string_wrap ( 50, A->seq_al[a],fp);
                fprintf ( fp, "\n");
                vfclose (fp);
                }
        }
void output_pir_check (char *fname,int nseq, char **comment )
        {
        int a;
        FILE *fp;
        
        if ( fname==NULL)return;
        fp=vfopen ( fname, "w");
        
        for ( a=0; a< nseq; a++)fprintf (fp, "%s\n", comment[a]);
        vfclose (fp);
        }
void output_fasta_seqS (char *fname, Sequence *S)
{
  Alignment *A;
  A=seq2aln (S,NULL,RM_GAP);
  output_fasta_seq (fname, A);
  free_aln (A);
}

void output_fasta_seq (char *fname, Alignment*A)
{
  main_output_fasta_seq (fname, A, HEADER);
}
void output_fasta_tree (char *fname, Alignment*A)
        {
        int a;
        FILE *fp;
        if ( !A || !A->nseq) return;
        
        fp=vfopen ( fname, "w");
        
        for ( a=0; a< A->nseq; a++)
                {
                  fprintf ( fp, ">%s %s\n%s\n", A->name[a], A->seq_comment[a], A->seq_al[a]);
                }
        vfclose (fp);
        }
void main_output_fasta_seq (char *fname, Alignment*A,int header )
        {
        int a;
        FILE *fp;
        
        fp=vfopen ( fname, "w");

        for ( a=0; a< A->nseq; a++)
                {
                ungap(A->seq_al[a]);
                fprintf ( fp, ">%s", A->name[a]);
                if (header==HEADER && A->seq_comment[a][0] && !isblanc(A->seq_comment[a]))fprintf (fp," %s\n",A->seq_comment[a]);
                else fprintf ( fp, "\n");
                fp=output_string_wrap ( 50, A->seq_al[a],fp);
                fprintf ( fp, "\n");
                }
        vfclose (fp);
        }    
void output_gor_seq (char *fname, Alignment*A )
        {
        int a;
        FILE *fp;
        
        fp=vfopen ( fname, "w");
        
        for ( a=0; a< A->nseq; a++)
                {
                ungap(A->seq_al[a]);
                fprintf ( fp, "!%s %d \n", A->name[a], (int)strlen(A->seq_al[a]));
                upper_string ( A->seq_al[a]);
                fp=output_string_wrap ( 50, A->seq_al[a],fp);
                fprintf ( fp, "@\n");
                }
        vfclose (fp);
        }    
void output_pir_seq (char *fname, Alignment*A )
        {
        int a;
        for ( a=0; a< A->nseq; a++)ungap(A->seq_al[a]);
        output_pir_aln (fname, A);
        } 
void output_pir_seq1 (char *fname, Alignment*A )
        {
        char seq_name[VERY_LONG_STRING];
        int a;
        FILE *fp;
        char type[20];

        
        for ( a=0; a< A->nseq; a++)
                {
                if      ( strm ( get_string_type (A->seq_al[a]),"DNA") || strm ( get_string_type (A->seq_al[a]),"RNA"))sprintf(type, "DL");
                else if ( strm ( get_string_type (A->seq_al[a]),"PROTEIN"))sprintf(type, "P1"); 
                sprintf ( seq_name,"%s;%s_%s.seq",type, fname,A->name[a]);
                ungap ( A->seq_al[a]);
                fp=vfopen (seq_name, "w");
                fprintf (fp, ">%s\n\n", A->name[a]);
                fp=output_string_wrap ( 50, A->seq_al[a],fp);
                fprintf ( fp, "\n*\n");
                vfclose (fp);
                }
        } 
/*******************************************************************************************/
/*                                                                                         */
/*                                                                                         */
/*                               OUTPUT ALN                                                */
/*                                                                                         */
/***************************************************************************************** */
void output_mocca_aln (char *outfile, Alignment *A, Alignment *S)
    {
    FILE *fp;
    int **score;
    char **new_name_order;
    int a, maxl;

    score=declare_int (S->nseq, 2);
    new_name_order=declare_char ( S->nseq,MAXNAMES+1); 
    for ( a=0; a<A->nseq; a++)
      {
        score[a][0]=a;
        score[a][1]=S->score_seq[a];
      }
    sort_int_inv (score+1,2,1,0,S->nseq-2);
    for ( a=0; a<A->nseq; a++)
      {
        sprintf ( new_name_order[a], "%s", A->name[score[a][0]]);
      }
    A=reorder_aln (A, new_name_order, A->nseq);

    fp=vfopen (outfile, "w");
    fprintf ( fp, "MOCCA,(%s,%s, C. Notredame)\nSCORE %d\nNSEQ  %d\nLEN   %d\n",VERSION,DATE, A->score_aln, A->nseq, A->len_aln);     
    
    maxl=return_maxlen ( new_name_order, A->nseq); 
    
   
    for (a=0; a< A->nseq; a++)
      {
        fprintf (fp, "%-*s: %3d\n", maxl, A->name[a], score[a][1]);
      }
    
    fprintf ( fp, "\n");
    
    fp=output_Alignment_without_header ( A, fp);
    vfclose (fp);
    free_int  (score, -1);
    free_char (new_name_order, -1);
    return ;
    }
  
void print_sub_aln ( Alignment *B, int *ns, int **ls)
{
  Alignment *X;
  int a, b;
 

  X=copy_aln (B, NULL);
  X->nseq=0;
  X->len_aln=strlen ( B->seq_al[ls[0][0]]);


  for (a=0; a< 2; a++)
    for ( b=0; b<ns[a]; b++, X->nseq++)
      {
        sprintf ( X->seq_al[X->nseq], "%s", B->seq_al[ls[a][b]]);
        sprintf ( X->name[X->nseq], "%s", B->name[ls[a][b]]);
      }
  X->name[X->nseq][0]='\0';
  
  print_aln (X);
  free_aln (X);
}
void print_aln ( Alignment *B)
    {
      
    while(B)
      {
        output_Alignment_without_header ( B, stderr);
        B=B->A;
      }
    }


FILE * output_aln ( Alignment *B, FILE *fp){return output_Alignment(B, fp);}
FILE * output_Alignment ( Alignment *B, FILE *fp)
    {
      fprintf ( fp, "%s, %s (%s) [%s] [MODE: %s]\n%s\nCPU   %d sec\nSCORE %d\nNSEQ  %d\nLEN   %d\n",PROGRAM,VERSION,DATE,retrieve_mode(),URL,AUTHOR,  (B->cpu+get_time())/1000, B->score_aln, B->nseq, B->len_aln);     
     
      return output_Alignment_without_header ( B, fp);
    }
  
FILE * output_Alignment_without_header ( Alignment *B, FILE *fp)
    {
    int a,b, c;
    int max_len=0;
    int line;       
    int *n_residues;
    char s;

    
    if (fp==NULL)return fp;
    for ( a=0; a< B->nseq; a++)
            {if ( strlen (B->name[a])>max_len)
                max_len= strlen ( (B->name[a]));
            }
    max_len=MAX(max_len+2, 16);
    line=get_msa_line_length (0, 0);
    n_residues=vcalloc ( B->nseq+1, sizeof (int));
    for ( a=0; a<B->nseq; a++)n_residues[a]=(B->output_res_num==2)?B->order[a][1]:0;
    
    
    
    
  fprintf ( fp, "\n"); 
    for (a=0; a<B->len_aln; a+=line)
           {for (b=0; b<=B->nseq; b++)
             {
               fprintf (fp,"%-*s",max_len,B->name[b]);
               if (B->output_res_num)fprintf (fp, " %4d ", n_residues[b]+1);
               for (c=a;c<a+line && c<B->len_aln;c++)
                 {
                   if (b==B->nseq){n_residues[b]++;s=analyse_aln_column ( B, c);}
                   else 
                     {n_residues[b]+=!is_gap(B->seq_al[b][c]);
                       s=GET_CASE(B->residue_case, B->seq_al[b][c]);
                     }
                   
                   fprintf (fp,"%c",s );
                                }
               if (B->output_res_num)fprintf (fp, " %4d", n_residues[b]);
               fprintf (fp,"\n");
             }
             
             fprintf (fp,"\n");
           }
    
     fprintf (fp,"\n\n");
     vfree (n_residues);
     
     return fp;
    }
FILE * output_aln_score ( Alignment *B, FILE *fp){return output_Alignment_score(B, fp);}
FILE * output_Alignment_score ( Alignment *B, FILE *fp)
    {
    int a, b, c;
    static int max_len=0;
    static int line;        
    int ch;
    
    if (fp==NULL)return fp;
    if ( max_len==0)
        {
        for ( a=0; a< B->nseq; a++)
            {if ( strlen (B->name[a])>max_len)
                max_len= strlen ( (B->name[a]));
            }
        max_len+=4;

        }       
   line=get_msa_line_length(0, 0);
   sprintf (B->name[B->nseq], "CONS"); 
   fprintf ( fp, "T_COFFEE ALIGNMENT\nCPU TIME:%d sec.\n", (B->cpu+get_time())/1000);  
   fprintf ( fp, "SCORE=%d\n", B->score_aln);
   for ( a=0;a<B->nseq; a++)fprintf ( fp, "%s: %d\n", B->name[a], B->score_seq[a]);
   fprintf ( fp, "\n"); 
    for (a=0; a<B->len_aln; a+=line)
           {for (b=0; b<B->nseq; b++)
              {
              fprintf (fp,"%-*s",max_len,B->name[b]);
              for (c=a;c<a+line && c<B->len_aln;c++)
                {
                ch=B->seq_al[b][c];
                if (ch==NO_COLOR_RESIDUE)fprintf (fp,"-");
                else if ( ch==NO_COLOR_GAP)fprintf (fp,"*");
                else if ( ch<10 && ch>=0)fprintf (fp,"%d",ch);
                else if ( ch>10)fprintf (fp,"#");
                else if ( ch<0)fprintf  (fp,".");
                else fprintf (fp,"9");          
                }             
              fprintf (fp,"\n");              
              }
            fprintf (fp,"\n");
            fprintf (fp,"%-*s",max_len,B->name[b]);
            for (c=a;c<a+line && c<B->len_aln;c++)
              {
              ch=B->seq_al[b][c];
              if (ch==NO_COLOR_RESIDUE)fprintf (fp,"-");
              else if ( ch==NO_COLOR_GAP)fprintf ( fp, "*");
              else if ( ch<10 && ch>=0)fprintf (fp,"%d",ch);
              else if ( ch>10)fprintf (fp,"#");
              else if ( ch<0)fprintf (fp,".");
              else fprintf (fp,"9");            
              }       
            fprintf (fp,"\n\n\n");
           }
    fprintf (fp,"\n\n");
    return fp;
    }
FILE * output_aln_with_res_number ( Alignment *B, FILE *fp){return  output_Alignment_with_res_number(B, fp);}
FILE * output_Alignment_with_res_number ( Alignment *B, FILE *fp)
    {
    int a, b, c;
    static int max_len=0;
    static int line;        
    int**order;

    if (fp==NULL)return fp;
    if ( max_len==0)
        {
        for ( a=0; a< B->nseq; a++)
            {if ( strlen (B->name[a])>max_len)
                max_len= strlen ( (B->name[a]));
            }
        max_len+=4;
        line=60;
        }       
   order=copy_int ( B->order,declare_int ( B->nseq, 2), B->nseq, 2);
    
   fprintf ( fp, "T_COFFEE ALIGNMENT\nCPU TIME:%d sec.\n", (B->cpu+get_time())/1000);     
   fprintf ( fp, "\n"); 
    for (a=0; a<B->len_aln; a+=line)
           {for (b=0; b<B->nseq; b++)
             {
              fprintf (fp,"%-*s %3d %4d ",max_len,B->name[b], order[b][0], order[b][1] );
              for (c=a;c<a+line && c<B->len_aln;c++)
                {
                order[b][1]+=1-is_gap(B->seq_al[b][c]);
                fprintf (fp,"%c",toupper(B->seq_al[b][c]) );
                }
              fprintf (fp," %4d\n", order[b][1] );
              }
            fprintf (fp,"\n");
            }
    fprintf (fp,"\n\n");

    free_int (order, -1);
    return fp;
    }

void output_constraints ( char *fname, char *mode,Alignment *A)
        {
        FILE *fp;
        Constraint_list *CL;
        char *buf;
        char **name_list;
        
        if ( !A->CL || strm ( mode, "pdb"))
           {
               if (!A->S)
                  {
                      A->S=aln2seq(A);
                  }
               
               CL=declare_constraint_list ( A->S, NULL, NULL, 0, NULL, NULL);
               CL=aln2constraint_list (A,CL, mode);
               fp=save_constraint_list ( CL, 0, CL->ne,fname, NULL, "lib",A->S);
               vfclose (fp);
               free_constraint_list (CL);
               return;
           }
        else if ( strncmp ( mode, "extended_pair", 13)==0)
          {
            buf=duplicate_string (mode+14);
            
            name_list=vcalloc(2, sizeof(char*));
            name_list[0]=strtok (buf,"_");
            name_list[1]=strtok (NULL,"_");
            mode[13]='\0';
            
        
            CL=A->CL;
            fp=save_sub_list_header (vfopen(fname, "w"),2, name_list,CL);
            fp=save_extended_constraint_list_pair (CL, "pair",name_list[0],name_list[1],fp);
            fp=save_list_footer (fp, CL);
            vfree (buf);
          }
        else if ( strm2 (mode, "extended_lib","extended_cosmetic"))
          {
            CL=A->CL;
            fp=save_extended_constraint_list ( CL,mode+9, vfopen(fname, "w"));
          }
        else 
           {
               CL=(Constraint_list *)A->CL;
               fp=save_constraint_list ( CL, 0, CL->ne,fname, NULL, "lib",A->S);
           }
        vfclose ( fp);
        
        if ( (Constraint_list *)A->CL !=CL)free_constraint_list (CL);

        return;

        }
void output_model_aln (char *fname, Alignment*A )
        {
          FILE *fp;
          int a;
          Dp_Model *M;
          Dp_Result *R;
          char *string;
          
          if ( A->Dp_result==NULL)
            {
              fprintf ( stderr, "\nWARNING Could Not Output Model %s [%s]", fname, PROGRAM);
            }
          R=A->Dp_result;
          M=R->Dp_model;

          fp=vfopen ( fname, "w");
          for (a=0; a<M->nstate; a++)
            {
              if (M->model_comments[a][0])fprintf ( fp, "#STATE %c: %s\n", 'a'+a, M->model_comments[a]);
            }
          string=vcalloc ( R->len+1, sizeof (char));
          for (a=0; a<R->len; a++)string[a]=R->traceback[a]+'a';
          fprintf ( fp, ">%s\n",fname);
          fp=output_string_wrap ( 50,string, fp);
          vfree(string);
          fprintf ( fp, "\n");
        
          vfclose (fp);
          return;
        }
char * output_fasta_sub_aln (char *fname, Alignment*A, int ns, int *ls  )
{
  int a,s;
  FILE *fp;
  if (fname==NULL)fname=vtmpnam (NULL);
  fp=vfopen (fname, "w");
  for (a=0; a<ns; a++)
    {
      s=ls[a];
      fprintf (fp, ">%s %s\n%s\n", A->name[s],A->seq_comment[s],A->seq_al[s]);
    }
  vfclose (fp);
  return fname;
}
char * output_fasta_sub_aln2 (char *fname, Alignment*A, int *ns, int **ls  )
{
  int a,g,s;
  FILE *fp;
  if (fname==NULL)fname=vtmpnam (NULL);
  fp=vfopen (fname, "w");
  for ( g=0; g<2; g++)
    for (a=0; a<ns[g]; a++)
      {
        s=ls[g][a];
        fprintf (fp, ">%s %s\n%s\n", A->name[s],A->seq_comment[s],A->seq_al[s]);
      }
  vfclose (fp);
  return fname;
}

int output_suchard_aln (char *out_file, Alignment *A)
{
  int a, b, c, d;
  FILE *fp;
  
  A=back_translate_dna_aln (A);
  
  for ( c=0,a=0; a<A->len_aln; a++, c++)
             {
               if (c==3)c=0;
               for (b=0; b<A->nseq; b++)
                 {
                 if (c==2)
                   {
                     A->seq_al[b][a]='-';
                   }
                 }
             }
  A=ungap_aln_n (A, 1);    
  fp=vfopen (out_file, "w");
  for ( a=0; a< A->nseq; a++)
    {
      for (b=0; b< A->len_aln; b++)
        {
          c=tolower(A->seq_al[a][b]);
          if ( c=='a')d=1;
          else if ( c=='g')d=2;
          else if ( c=='c')d=3;
          else if ( c=='t')d=4;
          else if ( c=='u')d=5;
          else d=6;

          fprintf ( fp, "%d", d);
        }
      fprintf ( fp, "\n");
    }
  vfclose (fp);
  myexit (EXIT_SUCCESS);
}
  
void output_fasta_aln (char *fname, Alignment*A )
        {
        FILE *fp;
        int a;
        int line=0;

        line=get_msa_line_length (line, A->len_aln+1);
        fp=vfopen ( fname, "w");

        for ( a=0; a< A->nseq; a++)
                {
                  fprintf ( fp, ">%s", A->name[a]);
                  
                  if ( A->seq_comment[a][0] && !isblanc (A->seq_comment[a]))fprintf ( fp, " %s", A->seq_comment[a]);
                  fprintf ( fp, "\n");
                  fp=output_string_wrap ( line,A->seq_al[a] , fp);
                  fprintf ( fp, "\n");
                }
        vfclose (fp);
        }
        
void output_pir_aln (char *fname, Alignment*A )
        {
        int a;
        FILE *fp;
        char type[20];
        
        

        
        
        fp=vfopen ( fname, "w");
        for ( a=0; a< A->nseq; a++)
                {
                if      ( strm ( get_string_type (A->seq_al[a]),"DNA") || strm ( get_string_type (A->seq_al[a]),"RNA"))sprintf(type, "DL");
                else if ( strm ( get_string_type (A->seq_al[a]),"PROTEIN"))sprintf(type, "P1");
                fprintf ( fp, ">%s;%s\n%s\n",type, A->name[a], A->seq_comment[a]);
                fp=output_string_wrap ( 50,A->seq_al[a] , fp);
                fprintf ( fp, "\n*\n");
                }
                
        vfclose (fp);
        }           

int landscape_msa;
int  set_landscape_msa (int len)
{
  if ( len==0)landscape_msa=-1;
  else
    {
      landscape_msa=len;
    }
  return landscape_msa;
}
int get_msa_line_length (int line, int aln_len)
{
  if (landscape_msa==-1) return aln_len;
  else if ( landscape_msa)return landscape_msa;
  else if (line) return line;
  else 
    {
      return (getenv ("ALN_LINE_LENGTH"))?atoi(getenv("ALN_LINE_LENGTH")):ALN_LINE_LENGTH;
    }
}

void output_msf_aln (char *fname,Alignment *B)
        {
        int a, b, c;    
        char *seq;
        int *all_checks;
        int i,j;
        long grand_checksum;
        FILE *fp;
        int max_len;
        int line=0;
        int block=10;
        int c_block;
        char aa;
        

        line=get_msa_line_length (line, B->len_aln+1);
        

        for ( max_len=0,a=0; a< B->nseq; a++)max_len= MAX(strlen ( B->name[a]),max_len);


        max_len+=5;
        
        fp=vfopen (fname, "w");
        
        seq =vcalloc(B->len_aln,  sizeof(char));
        all_checks =vcalloc(B->nseq, sizeof(int));
        for ( i=0; i< B->nseq; i++)
          {
            for ( j=0; j<B->len_aln; j++)
              {
                if ( is_gap(B->seq_al[i][j]))seq[j]='.';
                else seq[j]=B->seq_al[i][j]=toupper(B->seq_al[i][j]);
                
              }
            all_checks[i] = SeqGCGCheckSum(seq, (int)B->len_aln);
          }
        grand_checksum = 0;
        for(i=0; i<B->nseq; i++) grand_checksum += all_checks[i];
        grand_checksum = grand_checksum % 10000;
        fprintf(fp,"PileUp\n\n");
        B=get_aln_type(B);
        fprintf(fp,"\n\n   MSF:%5d  Type: ",B->len_aln);
        if(strm ( (B->S)->type, "DNA") || strm ( (B->S)->type, "RNA"))
                fprintf(fp,"N");
        else
                fprintf(fp,"P");
        fprintf(fp,"    Check:%6ld   .. \n\n", (long)grand_checksum);
        for (i=0; i< B->nseq; i++)
          {
            fprintf ( fp, " Name: %s oo  Len:%5d  Check:%6ld  Weight:  %.3f\n", B->name[i], B->len_aln,(long)all_checks[i],(B->S)->W?((B->S)->W)->SEQ_W[i]:1.00);
          }
        fprintf(fp,"\n//\n\n");
        
        for (a=0; a<B->len_aln; a+=line)
           {
             fprintf ( fp,"\n\n"); 
             for (b=0; b<B->nseq; b++)
               {
                 fprintf (fp,"%-*s ",max_len,B->name[b]);
                 for (c_block=0,c=a;c<a+line && c<B->len_aln;c++)
                   {
                     if ( c_block==block)
                            {
                              fprintf (fp, " ");
                              c_block=0;
                            }
                        c_block++;
                     aa=(is_gap(B->seq_al[b][c]))?'.': toupper(B->seq_al[b][c]);
                     fprintf (fp,"%c",aa );
                   }
                 if ( c_block==block)
                            {
                              fprintf (fp, " ");
                              c_block=0;
                            }
                 fprintf (fp,"\n");
                 
               }
           }
        fprintf ( fp,"\n");              
        vfclose ( fp);
        
        
        vfree(seq);
        vfree(all_checks);
        

        return;
} 
int SeqGCGCheckSum(char *seq, int len)
{
        int  i;
        long check;
        
        for( i=0, check=0; i< len; i++,seq++)
                check += ((i % 57)+1) * toupper(*seq);

        return(check % 10000);
}  
void old_output_msf_aln (char *fname,Alignment *B)
        {
        FILE *fp;
        static int *put_seq;
        int a, b, c;
        int line=0;
        char aa;
        char *buf;
        int max_len;
        int seq_max_len;
        
        line=get_msa_line_length (line, B->len_aln+1);
        
        
        for ( max_len=0,a=0; a< B->nseq; a++)max_len= MAX(strlen ( B->name[a]),max_len);
        for ( seq_max_len=0,a=0; a< B->nseq; a++)seq_max_len= MAX(strlen ( B->seq_al[a]),max_len);
        

        buf=vcalloc(seq_max_len+1, sizeof (int)); 
        
        if ( put_seq==NULL)
                put_seq= vcalloc ( B->nseq, sizeof (int));
        put_seq[0]=1;
        
        
        for ( b=1; b< B->nseq; b++)
                {
                sprintf ( buf, "%s", B->seq_al[b]);
                ungap(buf);
                put_seq[b]=( strlen (buf)>0)?1:0;
                }       
        
        fp=vfopen ( fname, "w");
        fprintf ( fp, "MSF: %d Type P Check: 5083 ..\n", B->len_aln);
        for ( a=0; a< B->nseq; a++)
                {
                if ( put_seq[a]==1)
                        fprintf ( fp,"Name: %s\n",B->name[a]);
                }
         fprintf ( fp, "//\n");
         for (a=0; a<B->len_aln; a+=line)
           {for (b=0; b<B->nseq; b++)
             {
             if ( put_seq[b]==1)
                {
                fprintf (fp,"%-*s ",max_len,B->name[b]);
                for (c=a;c<a+line && c<B->len_aln;c++)
                        {
                        
                          
                            
                        aa=(B->seq_al[b][c]=='-')?'.': toupper(B->seq_al[b][c]);
                        fprintf (fp,"%c",aa );
                        }
                fprintf (fp,"\n");
                }
              }
            fprintf (fp,"\n");
            }
        fprintf ( fp,"\n\n");            
        vfclose ( fp);

        vfree (buf);
        vfree(put_seq);
        }
        
void output_saga_aln ( char *name, Alignment *B)
    {
    int a, b, c;
    FILE *fp;



    int max_len;
    int line=0;
    
    line=get_msa_line_length (line, B->len_aln+1);
    
    
    
    for ( max_len=0,a=0; a< B->nseq; a++)max_len= (strlen ( B->name[a])>max_len)?(strlen ( B->name[a])):max_len;
            
        


    fp= vfopen ( name, "w");
    
    fprintf (fp, "\nSAGA FORMAT\nalignement  %s nseq=%d len=%d\n", name, B->nseq, B->len_aln);
       
    fprintf (fp, "\n\n");
    for (a=0; a<B->len_aln; a+=line)
           {for (b=0; b<B->nseq; b++)
             {fprintf (fp,"%-*s ",max_len,B->name[b]);
              for (c=a;c<a+line && c<B->len_aln;c++)
                {
                  fprintf (fp,"%c",(B->seq_al[b][c]) );
                }
              fprintf (fp,"\n");
              }
            fprintf (fp,"\n");
            }
    fprintf (fp,"\n\n");
    vfclose ( fp);
    }
void output_compact_aln ( char *name, Alignment *B)
    {
    int a, b, c;
    FILE *fp;
    int do_print=0;


    int max_len;
    int line=0;

    line=get_msa_line_length (line, B->len_aln+1);
    
    
    for ( max_len=0,a=0; a< B->nseq; a++)max_len= (strlen ( B->name[a])>max_len)?(strlen ( B->name[a])):max_len;
            
        


    fp= vfopen ( name, "w");
    
    fprintf (fp, "\nSAGA FORMAT\nalignement  %s nseq=%d len=%d", name, B->nseq, B->len_aln);
    fprintf (fp, "\n\n");
    for (a=0; a<B->len_aln; a+=line)
           {for (b=0; b<B->nseq; b++)
             {
             
             for ( do_print=0, c=a;c<a+line && c<B->len_aln;c++)
               do_print+=1-is_gap(B->seq_al[b][c]);
             if ( do_print>0)
                   {
                     fprintf (fp,"%-*s ",max_len,B->name[b]);
             
             
             
                     for (c=a;c<a+line && c<B->len_aln;c++)
                       {
                         if ( is_gap(B->seq_al[b][c])&& B->seq_al[b][c]!='-' )fprintf (fp,"%c", '-');
                         else fprintf (fp,"%c",(B->seq_al[b][c]) );
                       }
                     fprintf (fp,"\n");
                   }
              }
            fprintf (fp,"\n");
            }
    fprintf (fp,"\n\n");
    vfclose ( fp);
    }

void output_clustal_aln ( char *name, Alignment *B)
{
  return output_generic_clustal_aln (name, B, "tc_clustal");
}
void output_strict_clustal_aln ( char *name, Alignment *B)
{
  return output_generic_clustal_aln (name, B, "strict_clustal");
}

void output_generic_clustal_aln ( char *name, Alignment *B, char *mode)
    {
    int a, b, c;
    FILE *fp;
    int max_len=0;
    int line=0; 
    int *n_residues;
    
    if ( getenv ("SEP_4_TCOFFEE"))
      {
        while ( line<B->len_aln && B->seq_al[0][line]!='o' && B->seq_al[0][line]!='O')line++;
        if ( B->seq_al[0][line]=='O' || B->seq_al[0][line]=='o')line++;
      }
    else
      {
        while ( line<B->len_aln)line++;
      }
    
    if ( line==B->len_aln)line=get_msa_line_length (0, B->len_aln+1);
    
    n_residues=vcalloc ( B->nseq+1, sizeof (int));
    for ( a=0; a< B->nseq; a++)
            {if ( strlen (B->name[a])>max_len)
                max_len= strlen ( (B->name[a]));
            n_residues[a]=B->order[a][1];
            }
    max_len=MAX(max_len+2, 16);
        

    fp= vfopen ( name, "w");

    if ( strm (mode, "strict_clustal"))
      fprintf ( fp, "CLUSTAL W (1.83) multiple sequence alignment");
    else
      {
        fprintf (fp, "CLUSTAL FORMAT for %s %s [%s] [MODE: %s ], CPU=%.2f sec, SCORE=%d, Nseq=%d, Len=%d ", PROGRAM, VERSION,URL, retrieve_mode (),(float)(B->cpu+get_time())/1000, B->score_aln, B->nseq, B->len_aln);
        if (B->ibit>0)
          {
            float ibit=(float)log ((double)B->ibit)/log ((double)2);
            float nibit=(float)log(ibit/(B->len_aln*B->nseq));
            fprintf ( fp, "\nTies: %.1f bits (%d alternative)\n",ibit, B->ibit-1);
          
          }
      }
    fprintf (fp, "\n\n");


    if ( B->len_aln==0)
      {
        for (b=0; b<=B->nseq; b++)
          fprintf (fp,"%-*s -\n",max_len, B->name[b]);
      }
    
    else
      {
        for (a=0; a<B->len_aln; a+=line)
          {for (b=0; b<=B->nseq; b++)
            {
              if (b!=B->nseq)
                {
                  fprintf (fp,"%-*s",max_len, B->name[b]);
                  for (c=a;c<a+line && c<B->len_aln;c++)
                    {
                      if ( is_gap(B->seq_al[b][c]))fprintf (fp,"%c", '-');
                      else 
                        {
                          n_residues[b]++;
                          fprintf (fp, "%c", GET_CASE(B->residue_case, B->seq_al[b][c]));
                          
                        }
                      
                    }
                  if (B->output_res_num)fprintf (fp, " %d", n_residues[b]);
                  fprintf (fp,"\n");
                }
              else if ( b==B->nseq)
                {
                  fprintf (fp,"%-*s",max_len," ");                  
                  for (c=a;c<a+line && c<B->len_aln;c++)
                    {
                      fprintf ( fp, "%c", analyse_aln_column (B, c));
                    }
                  fprintf (fp,"\n");
                }
            }
          fprintf (fp,"\n"); 
          }
      }
    fprintf (fp,"\n\n");
    vfree (n_residues);
    vfclose ( fp);
    }    
FILE * output_generic_interleaved_aln (FILE *fp, Alignment *B, int line, char gap, char *mode)
    {
    int a, b, c;
    int max_len=0;
    int *n_residues;
    
    
    n_residues=vcalloc ( B->nseq+1, sizeof (int));
    for ( a=0; a< B->nseq; a++)
            {if ( strlen (B->name[a])>max_len)
                max_len= strlen ( (B->name[a]));
            n_residues[a]=B->order[a][1];
            }
    max_len=MAX(max_len+2, 16);
        

    
    
    if ( B->len_aln==0)
      {
        for (b=0; b<=B->nseq; b++)
          fprintf (fp,"%-*s -\n",max_len, B->name[b]);
      }
    
    else
      {
        for (a=0; a<B->len_aln; a+=line)
          {for (b=0; b<=B->nseq; b++)
            {
              if (b!=B->nseq)
                {
                  fprintf (fp,"%-*s",max_len, B->name[b]);
                  for (c=a;c<a+line && c<B->len_aln;c++)
                    {
                      if ( is_gap(B->seq_al[b][c]))fprintf (fp,"%c", gap);
                      else 
                        {
                          n_residues[b]++;
                          fprintf (fp, "%c", GET_CASE(B->residue_case, B->seq_al[b][c]));
                          
                        }
                      
                    }
                  if (B->output_res_num)fprintf (fp, " %d", n_residues[b]);
                  fprintf (fp,"\n");
                }
            }
          fprintf (fp,"\n"); 
          }
      }
    vfree (n_residues);
    return fp;
    }    
void output_phylip_aln ( char *name, Alignment *B)
    {
      int a, b, c, d;
    FILE *fp;

    int *print_name;
    static int line=0;      
    line=get_msa_line_length(0, 0);
    
    print_name=vcalloc ( B->nseq, sizeof (int));
    fp= vfopen ( name, "w");
    
    fprintf (fp, "%3d %d\n", B->nseq, B->len_aln);
    for (a=0; a<B->len_aln; a+=line)
           {for (b=0; b<B->nseq; b++)
             {if ( print_name[b]==0)
                {
                  
                  fprintf (fp,"%-10.10s  ",B->name[b]);
                  print_name[b]=1;
                }
               else
                 {
                   fprintf (fp, "%10.10s ", " ");
                 }


               for (d=0,c=a;c<a+line && c<B->len_aln;c++, d++)
                 {
                   if ( d==10)
                     {
                       fprintf ( fp, " ");
                       d=0;
                     }
                   if ( is_gap(B->seq_al[b][c])&& B->seq_al[b][c]!='-' )fprintf (fp,"%c", '-');
                   else fprintf (fp,"%c",(B->seq_al[b][c]) );
                 }
              fprintf (fp,"\n");
              }
            fprintf (fp,"\n");
            }
    fprintf (fp,"\n\n");
    vfclose ( fp);
    }

void output_rnalign (char *out_file, Alignment *A, Sequence *STRUC)
    {
    int a, b;
    FILE *fp;
    char bank_file[100];
    char pep_file[100];
    char *buf;
    
    sprintf ( bank_file, "%s.mss", out_file);
    sprintf ( pep_file, "%s.one_rna", out_file);
    
   
    buf=vcalloc ( strlen ( A->seq_al[0]+1), sizeof (char));
    
    for ( b=0,a=0; a< strlen(A->seq_al[0]); a++) 
        {
        if ( is_gap(A->seq_al[0][a]))
                buf[a]='.';
        else
                buf[a]=STRUC->seq[0][b++];
        }
    buf[a]='\0';
    
    fp=vfopen ( bank_file, "w");
    
    fprintf ( fp, "ST\n");
    fp=output_string_wrap ( 50, buf, fp);
    fprintf ( fp, "\n\n");
    
    for ( a=0; a<A->nseq-1; a++)
        {
        fprintf ( fp, "AS %s\n ", A->name[a]);
        fp=output_string_wrap ( 50, A->seq_al[a], fp); 
        fprintf ( fp, "\n\n");
        }
    vfclose ( fp);
    fp=vfopen ( pep_file, "w");
    fprintf ( fp, ">%s\n", A->name[A->nseq-1]); 
    fp=output_string_wrap ( 50, A->seq_al[A->nseq-1], fp);
    fprintf ( fp, "\n");
    vfclose (fp);
    }

void output_lib (char *pw_lib_saga_aln_name, Alignment *A )
    {
    Alignment *B;
    char fname[VERY_LONG_STRING];
    int a,b;
    
    B=declare_Alignment (NULL);
    
    B->nseq=2;
    
    for ( a=0; a< A->nseq-1; a++)
        {
        for ( b=a+1; b<A->nseq; b++)
                {
                sprintf ( B->seq_al[0], "%s", A->seq_al[a]);
                sprintf ( B->name[0], "%s", A->name[a]);
                sprintf(B->name[1], "%s", A->name[b]);
                sprintf ( B->seq_al[1], "%s",A->seq_al[b]);
                B->nseq=2;
                sprintf ( fname, "%s_%s_%s.lib",pw_lib_saga_aln_name, A->name[a], A->name[b]);
        
                B->len_aln=strlen ( B->seq_al[0]);
                ungap_aln (B);
                output_clustal_aln (fname,B);  
                }
        }
    } 
void output_pw_lib_saga_aln (char *pw_lib_saga_aln_name, Alignment *A )
    {
    Alignment *B;
    char fname[VERY_LONG_STRING];
    int a,b;
    
    B=declare_Alignment (NULL);
    
    B->nseq=2;
    
    for ( a=0; a< A->nseq-1; a++)
        {
        for ( b=a+1; b<A->nseq; b++)
                {
                sprintf ( B->seq_al[0], "%s", A->seq_al[a]);
                sprintf ( B->name[0], "%s", A->name[a]);
                sprintf(B->name[1], "%s", A->name[b]);
                sprintf ( B->seq_al[1], "%s",A->seq_al[b]);
                B->nseq=2;
                sprintf ( fname, "%s_%s_%s.pw_lib_saga_aln",pw_lib_saga_aln_name, A->name[a], A->name[b]);
        
                B->len_aln=strlen ( B->seq_al[0]);
                ungap_aln (B);
                output_clustal_aln (fname,B);  
                }
        }
    }   
void output_lalign_header( char *name, Alignment *A)
    {
    FILE *fp;
    
    fp=vfopen ( name, "w");
    fprintf ( fp, " Lalign mode: best local alignments between two sequences\n");
    fprintf ( fp, " %s(%s) [%s]\n\n", VERSION, DATE, URL);
    fprintf ( fp, " Comparison of:\n(A) %s\t%s\t-%d aa\n", (A->S)->file[A->order[0][0]],(A->S)->name[A->order[0][0]], (A->S)->len[A->order[0][0]]);
    fprintf ( fp, "(B) %s\t%s\t-%d aa\n", (A->S)->file[A->order[1][0]],(A->S)->name[A->order[1][0]], (A->S)->len[A->order[1][0]]);
    
    
    vfclose ( fp);
    return;
    }
void output_stockholm_aln (char *file, Alignment *A, Alignment *ST)
{
  FILE *fp;
  int a,b;
    
  for (a=0; a<A->nseq; a++)
    for (b=0; b<A->len_aln; b++)
      if (A->seq_al[a][b]==STOCKHOLM_CHAR)A->seq_al[a][b]='.';
  
  fp=vfopen (file, "w");
  fprintf ( fp, "# STOCKHOLM 1.0\n\n");
  output_generic_interleaved_aln (fp,A, 50, '.', NULL);
  fprintf ( fp, "//\n");
  vfclose (fp);
}
                           
void output_glalign ( char *name, Alignment *B, Alignment *S)
{
  int a, b, g, s;
  int naln=0;
  FILE *fp;
  int **nr;
  B=B->A;
  if ( B==NULL){return;}
  
  fp=vfopen (name, "w");
  fprintf (fp, "Format: GLALIGN_01 [Generated with %s ]\n", PROGRAM);
  fprintf (fp, "#Each Line corresponds to a column\n");
  fprintf (fp, "#First column coresponds to first genome\n");
  fprintf (fp, "#Last Column gives the column reliability on a 0-9 scale\n");
  fprintf (fp, "#[-1] Indicates that the reliability was not evaluated\n");
  
  fprintf (fp, "Genome List\n");
  for ( a=0; a< B->nseq; a++)
    fprintf (fp, "\tGenome %s\n", B->name[a]);
  fprintf (fp, "Alignment List\n");
  while (B)
    {
      fprintf (fp, "Alignment %d Len %d Score %d\n", ++naln, B->len_aln, S->score_aln);
      nr=duplicate_int (B->order, -1, -1);
      for ( a=0; a< B->len_aln; a++)
        {
          fprintf ( fp, "\t");
          for ( b=0; b< B->nseq; b++)
            {
              g=is_gap (B->seq_al[b][a]);
              nr[b][1]+=1-g;

              if (g)fprintf (fp, "---- ");
              else fprintf ( fp, "%4d ",nr[b][1]);
            }
          s=((S)?S->seq_al[S->nseq][a]:-1);
          if (s==NO_COLOR_RESIDUE)s=-1;
          fprintf ( fp,"[ %d ]",s);
          fprintf ( fp, "\n");  
          
        } 
      free_int (nr, -1);
      B=B->A;
      S=S->A;
    }
  vfclose ( fp);
}
Alignment *input_conc_aln ( char *name, Alignment *IN)
{
  FILE *fp;
  char *string, *p, *file;
  Alignment *F=NULL,*A=NULL, *B=NULL;
  
  file=vtmpnam (NULL);
 
  string=file2string(name);
  string=substitute ( string, "@", "!Protected!");
  string=substitute ( string, TC_REC_SEPARATOR, "@");
  strtok (string,"@");
  

  while ( (p=strtok (NULL,"@"))!=NULL)
    {
      char *buf;
      buf=vcalloc ( strlen (p)+1, sizeof (char));
      sprintf (buf,"%s", p);
      buf=substitute (buf,"!protected!", "@");
      
      fp=vfopen (file, "w");
      fprintf ( fp, "%s",buf);
      vfclose (fp);
      vfree (buf);
            
      if ( is_aln (file))
        {
          B=main_read_aln (file,NULL);
          
          if ( !A)
            {
              if (IN){copy_aln (B, IN);F=A=IN;}
              else F=A=B;
            }
          else
            {
              A->A=B;
              A=A->A;
            }
        }
    }
  
  vfree (string);
  return F;
}

void output_conc_aln ( char *name, Alignment *B)
{
  FILE *fp;
  int a;
  
  fp=vfopen (name, "w");
  fprintf (fp, "# CONC_MSF_FORMAT_01\n");
  while (B)
    {
      fprintf (fp, "%s\n", TC_REC_SEPARATOR);
      for ( a=0; a< B->nseq; a++)
        {
          fprintf ( fp, ">%s\n%s\n", B->name[a], B->seq_al[a]);
        }
      B=B->A;
      
    }
  vfclose (fp);
}

void output_lalign ( char *name, Alignment *B)
{
  static int output_header;
 
  B=B->A;
  if ( B==NULL){output_header=0;return;}
    else if ( output_header==0)
      {
        output_lalign_header(name, B);
        output_header=1;
      }
  while (B)
    {
      output_lalign_aln   ( name, B);
      B=B->A;
    }
}
void output_lalign_aln   ( char *name, Alignment *B)
    {
    int a, b, c,d=0, s=0;
    char col;

    float tot=0;
    float id=0;

    FILE *fp;
    int max_len=0;
    int line;   
    int *n_residues;
    int res;

        
    n_residues=vcalloc ( B->nseq+1, sizeof (int));
    for ( a=0; a< B->nseq; a++)
            {if ( strlen (B->name[a])>max_len)
                max_len= strlen ( (B->name[a]));
            n_residues[a]=B->order[a][1];
            }
    max_len=MAX(max_len+2, 16);
    line=60;
    
    

    fp= vfopen ( name, "a");
    
    for (a=0; a< B->len_aln; a++)
      {
        if ( !is_gap(B->seq_al[0][a]) && !is_gap(B->seq_al[1][a]))
             {
               tot++;
               id+=(B->seq_al[0][a]==B->seq_al[1][a]);
             }
      }
    
    id=(id*100)/tot;
    fprintf (fp, " %.1f%% identity in %d aa overlap; score: %d\n\n", id,(int)tot, B->score_aln);
    
    
    for (a=0; a<B->len_aln; a+=line)
           {for (b=0; b<5; b++)
             {
                 if ( b==0 || b==4)
                   {
                     if ( b==0)s=0;
                     if ( b==4)s=1;
                     fprintf (fp,"%-*s",max_len," ");
                     for (d=0,c=a;c<a+line && c<B->len_aln;c++)
                       {
                         res=!is_gap ( B->seq_al[s][c]);
                         n_residues[s]+=res;
                         if ( (n_residues[s]%10)==0 && res && (c-a+4)<line){fprintf (fp, "%-4d", n_residues[s]);d=-3;}  
                         else
                           {
                             if ( d==0)fprintf (fp, " ");
                             else d++;
                           }
                       }
                     fprintf (fp,"\n");
                   }
                 else if (b==1 || b==3)
                    {
                      if ( b==1)s=0;
                      if ( b==3)s=1;
                        fprintf (fp,"%-*s",max_len, B->name[s]);
                        for (c=a;c<a+line && c<B->len_aln;c++)
                            {
                                if ( is_gap(B->seq_al[s][c]))fprintf (fp,"%c", '-');
                                else 
                                    {
                                        fprintf (fp, "%c", GET_CASE(B->residue_case, B->seq_al[s][c]));
                                    }
                            }
                        fprintf (fp,"\n");
                    }
                 else if ( b==2)
                    {
                    fprintf (fp,"%-*s",max_len," ");                
                    for (c=a;c<a+line && c<B->len_aln;c++)
                            {
                            col=analyse_aln_column (B, c);
                            if ( col=='*')col=':';
                            else if ( col==':')col='.';
                            else if ( col=='.')col=' ';
                            fprintf ( fp, "%c", col);
                            }
                    fprintf (fp,"\n");
                    }
             }
           fprintf (fp,"\n"); 
           }
    
    fprintf (fp,"\n\n----------\n\n");
    vfree (n_residues);
    vfclose ( fp);
    }   


/****************************************************************************************************/
/*************************************UTIL *********************************************************/
/**************************************************************************************************/


/****************************************************************************************************/
/***************************                                    *************************************/
/***************************             PROCESSING             *************************************/
/***************************                                    *************************************/
/*******************************************************************************************/
/*                                                                                         */
/*                                                                                         */
/*                              THREADING                                                  */
/***************************************************************************************** */

char *thread_aa_seq_on_dna_seq( char *s)
     {
         int l, b, c;
         char *array;
         

         l=strlen ( s);
         array=vcalloc ( l*3 +1, sizeof (char));
         for ( b=0, c=0; b< l; b++, c+=3)
             {
                 array[c]=s[b];
                 array[c+1]='o';
                 array[c+2]='o';
             }
         array[c]='\0';
         return array;
     }

Alignment *thread_dnaseq_on_prot_aln (Sequence *S, Alignment *A)
        {
            Alignment *B=NULL;
            int a, b, c, n, la, ls, ln, m;

            B=copy_aln ( A, B);
            B=realloc_aln2 ( B, B->nseq, B->len_aln*3 +1);

            for ( n=0,a=0; a< A->nseq; a++)
                {
                for ( m=0,b=0; b< S->nseq; b++)
                    {
                    if (strm (A->name[a], S->name[b]) )
                       {
                           m=1;
                           n++;
                           ungap ( S->seq[b]);
                           B->seq_al[a][0]='\0';
                           for (la=0, ls=0, ln=0; la< A->len_aln; la++)
                               {
                                   for (c=0; c< 3; c++)
                                       B->seq_al[a][ls++]=(is_gap(A->seq_al[a][la]))?'-':S->seq[b][ln++];
                               }
                       B->seq_al[a][ls]='\0';
                       }
                    }
                if ( m==0)
                       {
                       for (la=0, ls=0, ln=0; la< A->len_aln; la++)
                               {
                                
                                   B->seq_al[a][ls++]=A->seq_al[a][la];
                                   B->seq_al[a][ls++]='-';
                                   B->seq_al[a][ls++]='-';
                               }
                       }
                }
            
            B->len_aln=strlen ( B->seq_al[0]);
            return B;
        }
void thread_seq_struc2aln ( Alignment *A, Sequence *ST)
        {
        int a, b, c,d;
        int len, cons;
        
        for ( a=0; a< A->nseq; a++)
                for ( b=0; b< ST->nseq; b++)
                        {
                        if ( strcmp ( A->name[a], ST->name[b])==0)
                                {
                                ungap (ST->seq[b]);
                                len=strlen(A->seq_al[a]);
                                for ( c=0, d=0; c<len; c++)
                                        {
                                        if ( !is_gap(A->seq_al[a][c]))A->seq_al[a][c]=ST->seq[b][d++];
                                        }
                                }
                        }
        cons=name_is_in_list ("Cons", ST->name, ST->nseq, 100);
        if ( cons!=-1 && A->len_aln==strlen ( ST->seq[cons]))
          {
            sprintf (A->name[A->nseq], "Cons");
            sprintf (A->seq_al[A->nseq],"%s", ST->seq[cons]);
            A->nseq++;
          }
        }
void cache_id ( Alignment *A)
        {
        int a, b,n;
        char r1, r2, r3;
        
        for ( a=0; a< A->len_aln; a++)
                {
                for ( b=0, n=0; b< A->nseq; b++)if ( !is_gap(A->seq_al[b][a]))n++;
                for ( b=0; b< A->nseq; b++)
                        if ( !is_gap(A->seq_al[b][a]) && n==A->nseq)A->seq_al[b][a]='h';
                        else if( !is_gap(A->seq_al[b][a]))A->seq_al[b][a]='x';
                }
        for ( a=0; a< A->nseq; a++)
                {
                for ( b=1; b< A->len_aln-1; b++)
                        {
                        r1=A->seq_al[a][b-1];
                        r2=A->seq_al[a][b];
                        r3=A->seq_al[a][b+1];
                        if (r2=='h')
                                {
                                if ( (r1=='h' || r1=='b') && (r3=='h' || r3=='b'))A->seq_al[a][b]='h';
                                else A->seq_al[a][b]='b';
                                }
                        }
                for ( b=1; b< A->len_aln-1; b++)if ( A->seq_al[a][b]=='b')A->seq_al[a][b]='x';
                }
                        
        }
                        
                                                                         
/*******************************************************************************************/
/*                                                                                         */
/*                                                                                         */
/*                               PROCESING OF EST                                          */
/*                                                                                         */
/***************************************************************************************** */
int process_est_sequence ( Sequence *S, int *cluster_list)
        {
        char **inverted_seq;
        int T=20;
        int a, b;
        int V1, V2;
        int **sens;
        int **a_sens;
        int **best;
        int *solution;
        char buf [VERY_LONG_STRING];
        int n_clusters=0;
        int n;
        
        sens=declare_int ( S->nseq,S->nseq);
        a_sens=declare_int ( S->nseq,S->nseq);
        best=declare_int ( S->nseq,S->nseq);
        
        
        inverted_seq=vcalloc ( S->nseq, sizeof (char*));
        for ( a=0; a<S->nseq; a++)
                inverted_seq[a]=invert_seq ( S->seq[a]);
                
        for ( a=0; a< S->nseq-1; a++)
                {
                
                for ( b=a+1; b<S->nseq; b++)
                                     {
                                     
                                     V1=sens[a][b]=sens[b][a]=get_best_match ( S->seq[a], S->seq[b]);
                                     V2=a_sens[a][b]=a_sens[b][a]=get_best_match ( S->seq[a],inverted_seq[b]);
                                     best[a][b]=best[b][a]=(V1>V2)?V1:V2;
                                     }
                }
        solution=SHC ( S->nseq, a_sens, sens);
        
        
        for ( a=0; a<S->nseq; a++)cluster_list[a]=-1;
        for ( a=0; a<S->nseq; a++)
                {
                n=search_for_cluster (a, n_clusters, cluster_list, T, S->nseq, best);
                if ( n>0)n_clusters++;
                }
        fprintf ( stderr, "\nTHERE %s %d Independant Cluster(s) in your sequences",(n_clusters>1)?"are":"is",(n_clusters));
        for (a=0; a<n_clusters; a++)
                {
                fprintf (stderr, "\n");
                for ( b=0; b<S->nseq; b++)
                        {
                        if ( cluster_list[b]==a)fprintf ( stderr, "%s ", S->name[b]);
                        }
                }
                
        for ( a=0; a<S->nseq; a++)
                {
                if ( solution[a]==-1)
                        {
                        S->seq[a]=inverted_seq[a];
                        sprintf ( buf, "i_%s", S->name[a]);
                        sprintf ( S->name[a], "%s", buf);
                        }
                }
        return n_clusters;
        }

int search_for_cluster ( int seq, int cluster_number, int *cluster_list, int T, int nseq, int **S)      
        {
        int n=0,a;
        
        if (cluster_list[seq]==-1)
                {
                cluster_list[seq]=cluster_number;
                n++;
                }
        for ( a=0; a<nseq; a++)
                if ( cluster_list[a]==-1)
                        {
                        
                        if (S[seq][a]>T)
                                {
                                n++;
                                cluster_list[a]=cluster_number;
                                n+=search_for_cluster ( a, cluster_number, cluster_list, T, nseq, S);
                                }
                        }
        return n;
        }       
                
int * SHC ( int nseq, int **NST, int **ST)
        {
        int a;
        int mut;
        int score, new_score;
        int N_IT=VERY_LONG_STRING;
        int *sol;
        int count;
        
        sol=vcalloc ( nseq, sizeof (int));
        for ( a=0; a<nseq; a++)
                sol[a]=(addrand ((unsigned long)100)>49)?1:-1;
                
        score=evaluate_sol (sol, nseq, ST, NST);
        fprintf ( stderr, "\nI_Score=%d\n", score);
        N_IT=N_IT*nseq;
        
        for ( count=0,a=0; a< N_IT && score<VERY_LONG_STRING; a++, count++)
                {
                mut=mutate_sol ( sol,nseq);
                new_score=evaluate_sol (sol, nseq, ST, NST);
                if ( new_score>score)
                        {
                        score=new_score;
                        }
                else if ( (addrand ((unsigned long)VERY_LONG_STRING))>score)
                        {
                        score=new_score;
                        }
                else
                        sol[mut]=sol[mut]*-1;
                if ( count==VERY_LONG_STRING)
                        {
                        count=0;
                        fprintf ( stderr, "\nScore=%d", score);
                        }       
                }
        fprintf ( stderr, "\nScore=%d\n", score);
        return sol;
        }

int mutate_sol (int *sol, int nseq)
        {
        int n;
        n=addrand ((unsigned long)nseq);
        sol[n]=sol[n]*-1;
        return n;
        }
int evaluate_sol ( int *sol, int nseq, int **ST, int **NST)
        {
        static int max_score;
        int a, b, score=0;
        
        if ( max_score==0)
                {
                for ( a=0; a<nseq-1; a++)
                        for ( b=a+1; b<nseq; b++)
                                {
                                max_score+=(ST[a][b]>NST[a][b])?ST[a][b]:NST[a][b];
                                }
                }
        
        for ( a=0; a<nseq-1; a++)
                for (b=a+1; b<nseq; b++)
                        if ( (sol[a]*sol[b])<0)score+=NST[a][b];
                        else score+=ST[a][b];
        return (score*VERY_LONG_STRING)/max_score;
        }               
                
     
char * invert_seq ( char *seq)
        {
        int a, b;
        
        char *nseq;
        int l;
        
        
        l=strlen ( seq);
        for ( a=0; a<l; a++)
                seq[a]=tolower ( seq[a]);
        nseq=vcalloc ( l+1, sizeof (char));
        
        for ( a=0, b=l-1; a<l; a++, b--)
                {
                if (seq[b]=='n')nseq[a]='n';
                else if (seq[b]=='g')nseq[a]='c';
                else if (seq[b]=='c')nseq[a]='g';
                else if (seq[b]=='a')nseq[a]='t';
                else if (seq[b]=='t')nseq[a]='a';
                }
                
        nseq[l]='\0';
        return nseq;
        }
                
                
int get_best_match ( char *seq1, char *seq2)
        {
        static int **m;
        static int ml;
        int a, b;
        int **mdiag;
        int n_mdiag=0;
        int best;
        int l1, l2;
        
        
        l1=strlen ( seq1);
        l2=strlen (seq2);
        if ( m==NULL)
                {
                ml=(l1>l2)?l1:l2;
                m=declare_int (ml, ml);
                }
        else if ( (ml<l1) || (ml<l2))
                {
                free_int (m, ml);
                ml=(l1>l2)?l1:l2;
                m=declare_int (ml, ml);
                }
                
        for ( a=0; a<l1; a++)
                {
                for ( b=0; b<l2; b++)
                        m[a][b]=((seq1[a]==seq2[b])|| seq1[a]=='n' ||seq2[b]=='n')?1:0;
                }
        mdiag= extract_m_diag_streches ( m, l1, l2,seq1, seq2, &n_mdiag); 
        
        for ( best=0,a=0; a<n_mdiag; a++)
                best=(mdiag[a][0]>best)?mdiag[a][0]:best;
        
        return best;
        }

int** extract_m_diag_streches ( int ** m, int l1, int l2,char *seq1, char *seq2, int *n_mdiag)
        {
        
        int b, x, y, s1, s2;
        static int **mdiag;
        int in;
        static int max_diag=VERY_LONG_STRING;
         
         /*
         diag[0]=len;
         diag[1]=x_start;
         diag[2]=y_start;
         diag[3]=x_end;
         diag[4]=y_end;
         */
         
        if ( mdiag==NULL)
                mdiag=declare_int ( max_diag, 5);
        
        for ( s1=l1-1, s2=0;s2<l2;)
                {
                for ( in=0,x=s1, y=s2; x<l1 && y<l2; x++, y++)
                        { 
                        if (m[x][y]>0)
                                {
                                if (in==1)
                                        mdiag[n_mdiag[0]][0]++;
                                else 
                                        {
                                        mdiag[n_mdiag[0]][0]=1;
                                        mdiag[n_mdiag[0]][1]=x;
                                        mdiag[n_mdiag[0]][2]=y;
                                        in=1;
                                        }
                                }
                        else
                                if (in==1)
                                        {
                                        in=0;
                                        mdiag[n_mdiag[0]][3]=x-1;
                                        mdiag[n_mdiag[0]][4]=y-1;
                                        if ( !is_strech ( "ta", seq1, seq2,mdiag[n_mdiag[0]][0], mdiag[n_mdiag[0]][1],mdiag[n_mdiag[0]][2]))n_mdiag[0]++;
                                        }
                        if (n_mdiag[0]==(max_diag-1))
                                {mdiag=vrealloc (mdiag, (max_diag+VERY_LONG_STRING)*sizeof (int*));
                                for ( b=max_diag; b<max_diag+VERY_LONG_STRING; b++)mdiag[b]=vcalloc ( 5, sizeof (int));
                                max_diag+=VERY_LONG_STRING;
                                }
                        }
                s2+= (s1==0)?1:0;       
                s1-= (s1==0)?0:1;
                if (in==1)
                        {
                        in=0;
                        mdiag[n_mdiag[0]][3]=x-1;
                        mdiag[n_mdiag[0]][4]=y-1;
                        if ( !is_strech ( "ta", seq1, seq2,mdiag[n_mdiag[0]][0], mdiag[n_mdiag[0]][1],mdiag[n_mdiag[0]][2]))n_mdiag[0]++;
                        }
                }
        
        return mdiag;
        }                               
int is_strech ( char *AA, char *seq1, char *seq2, int len, int x, int y)
        {
        int n, i, j, c,a,nr;
        int T=70;
        
        n=strlen ( AA);
        for ( a=0; a<n; a++)
                {
                for (nr=0, i=x, j=y, c=0; c<len; c++, i++, j++)
                        if ((seq1[i]==AA[a]) && (seq2[j]==AA[a]))nr++;
                if ( ((nr*100)/len)>T)return 1;
                }
        return 0;
        }
        
        
/************************************************************************************/
/*                                                                                  */
/*                                      STRUC                                       */
/*                                                                                  */
/*                                                                                  */
/************************************************************************************/

char * oneletaa2threeletaa(char aa);
float aa2property   (char aa, char *mode);

int output_seq2struc(char *outfile, Alignment *A)
{
  FILE *fp1, *fp2;
  int a,c, l;
  float v, h, x, y, z, dx, dy, dz;
  char *s;
  char *tmpfile1, *tmpfile2;
  char command[1000];

  tmpfile1=vtmpnam(NULL);
  tmpfile2=vtmpnam(NULL);
  
  ungap (A->seq_al[0]);
  s=A->seq_al[0];l=strlen (s);
  fp1=vfopen (tmpfile1, "w");

  x=y=z=0;
  for ( a=0; a< l; a++)
    {
      h=aa2property ( s[a], "doolittle"   );
      v=aa2property (s[a], "volume");
      /*14.398907: peptide bond length*/
      dx=(float)sqrt ((double)(14.398907/(((h*h)/(v*v))+1)));
      dy=dx*(h/v);
      dz=0;

        
      x+=dx;
      y+=dy;
      z+=dz;
      fprintf (fp1, "ATOM%7d   CA %s A%4d%12.3f%8.3f%8.3f  1.00   5.30\n",a+1, oneletaa2threeletaa(s[a]),a+1, x, y, z);
    }   
  vfclose (fp1);
  sprintf ( command, "extract_from_pdb -infile %s -force > %s", tmpfile1,  tmpfile2);
  my_system  (command);
  fp1=vfopen (tmpfile2, "r");
  fp2=vfopen (outfile, "w");
  
  while ( (c=fgetc(fp1))!=EOF)fprintf (fp2, "%c", c);
  vfclose (fp1);
  vfclose (fp2);
  
  return 0;
}

char * oneletaa2threeletaa(char aa)
  {
    aa=tolower (aa);
    if ( aa=='a')return "ALA";
    else if ( aa=='r') return "ARG";
    else if ( aa=='n') return "ASN";
    else if ( aa=='d') return "ASP";
    else if ( aa=='c') return "CYS";
    else if ( aa=='q') return "GLN";
    else if ( aa=='e') return "GLU";
    else if ( aa=='g') return "GLY";
    else if ( aa=='h') return "HIS";
    else if ( aa=='i') return "ILE";
    else if ( aa=='l') return "LEU";
    else if ( aa=='k') return "LYS";
    else if ( aa=='m') return "MET";
    else if ( aa=='f') return "PHE";
    else if ( aa=='p') return "PRO";
    else if ( aa=='s') return "SER";
    else if ( aa=='t') return "THR";
    else if ( aa=='w') return "TRP";
    else if ( aa=='y') return "TYR";
    else if ( aa=='v') return "VAL";
    else 
      {
        fprintf ( stderr, "\nERROR: %c is not an amino acid [FATAL::aa2hydropathy::%s]", aa, PROGRAM);
        myexit (EXIT_FAILURE);
        return NULL;
      }
    return NULL;
  } 
  
float aa2property   (char aa, char *mode)
  {
    if ( mode==NULL || strm (mode, "doolittle"))
         {
           aa=tolower (aa);
           if ( aa=='i')return 4.5;
           else if ( aa=='v') return 4.2;
           else if ( aa=='l') return 3.8;
           else if ( aa=='f') return 2.8;
           else if ( aa=='c') return 2.5;
           else if ( aa=='m') return 1.9;
           else if ( aa=='a') return 1.8;
           else if ( aa=='g') return -0.4;
           else if ( aa=='t') return -0.7;
           else if ( aa=='w') return -0.9;
           else if ( aa=='s') return -0.8;
           else if ( aa=='y') return -1.3;
           else if ( aa=='p') return -1.6;
           else if ( aa=='h') return -3.2;
           else if ( aa=='e') return -3.5;
           else if ( aa=='q') return -3.5;
           else if ( aa=='d') return -3.5;
           else if ( aa=='n') return -3.5;
           else if ( aa=='k') return -3.9;
           else if ( aa=='r') return -4.5;
           else 
             {
               fprintf ( stderr, "\nERROR: %c is not an amino acid [FATAL::aa2hydropathy::%s]", aa, PROGRAM);
               myexit (EXIT_FAILURE);
             }
         }
    else if (strm (mode, "volume"))
         {
           aa=tolower (aa);
           if ( aa=='a')return 0.915;
           else if ( aa=='r') return 2.02;
           else if ( aa=='n') return 1.35;
           else if ( aa=='d') return 1.24;
           else if ( aa=='c') return 1.18;
           else if ( aa=='q') return 1.61;
           else if ( aa=='e') return 1.55;
           else if ( aa=='g') return 0.66;
           else if ( aa=='h') return 1.67;
           else if ( aa=='i') return 1.69;
           else if ( aa=='l') return 1.68;
           else if ( aa=='k') return 1.71;
           else if ( aa=='m') return 1.70;
           else if ( aa=='f') return 2.03;
           else if ( aa=='p') return 1.29;
           else if ( aa=='s') return 0.99;
           else if ( aa=='t') return 1.22;
           else if ( aa=='w') return 2.37;
           else if ( aa=='y') return 2.03;
           else if ( aa=='v') return 1.41;
           else 
             {
               fprintf ( stderr, "\nERROR: %c is not an amino acid [FATAL::aa2hydropathy::%s]", aa, PROGRAM);
               myexit (EXIT_FAILURE);
             }
         }
    
    else
      {
        fprintf ( stderr, "\nERROR: %s is an unknown mode [FATAL::aa2hydropathy::%s]", mode  , PROGRAM);
        myexit (EXIT_FAILURE);
      }
  return 0;
  } 
           

          
           
        
/************************************************************************************/
/*                                                                                  */
/*                                      DNA                                         */
/*                                                                                  */
/*                                                                                  */
/************************************************************************************/

Alignment *code_dna_aln (Alignment *A)
       {
         int a, b,l,r;

         for ( a=0; a< A->nseq; a++)
           {
             for (l=0, b=0; b< A->len_aln; b++)
               {
                 r=A->seq_al[a][b];
                 if ( r=='-')l++;
                 else if ( r=='~')continue;
                 else if ( r=='.')l++;
                 else if ( !islower(r))A->seq_al[a][b]='4';
                 else
                   {
                     A->seq_al[a][b]=(l+3)%3+'0';
                     l++;
                   }
               }
           }
         return A;
       }

  
Alignment *back_translate_dna_aln (Alignment *A)
       {
         /*Given a set of aligned sequences
           starts from left to right
           1 aa->3 nuc
           ambiguities are randomly resolved.
           returns the corresponding amino acid alignment
         */      
          int a;
          char *seq    ;
         
         ungap_aln(A);
         A=realloc_aln (A, 10000);
         seq=vcalloc ( 10000, sizeof (char));

         
         for ( a=0; a< A->nseq; a++)
           {
           seq=back_translate_dna_seq (A->seq_al[a], seq, RANDOM);
           sprintf ( A->seq_al[a], "%s", seq);
           }
         A->len_aln=A->len_aln*3;
         compress_aln (A);
         vfree (seq);
         return A;
       }
char * back_translate_dna_seq ( char *in_seq,char *out_seq, int mode)     
       {
         int a,len;

         len=strlen(in_seq);
         
         if (out_seq==NULL)out_seq=vcalloc ( len*3+1, sizeof (char));
         
         out_seq[0]='\0';
         for (a=0; a<len; a++)
           {
           strcat (out_seq,  back_translate_dna_codon (in_seq[a],mode));
           }
         
         return out_seq;
       }

static Sequence *rna_seq2dna_seq (Sequence *S);
static Sequence *dna_seq2rna_seq (Sequence *S);
Sequence * transform_sequence ( Sequence *S, char *mode)
{
  if ( strm (mode, "rna2dna"))
    return rna_seq2dna_seq (S);
  else if ( strm (mode, "dna2rna"))
    return dna_seq2rna_seq (S);
  else 
    printf_exit (EXIT_FAILURE, stderr, "Unknown -transform mode: %s [FATAL:%s]\n", mode,PROGRAM);
  return NULL;}

Sequence *rna_seq2dna_seq (Sequence *S)
{
  int a, b;
  
  if ( !strm(S->type, "DNA") && !strm (S->type, "RNA")) printf_exit (EXIT_FAILURE, stderr, "Sequences should be *RNA* type [FATAL:%s]\n", PROGRAM);
  for ( a=0; a<S->nseq; a++)
    {
      for (b=0; b<strlen (S->seq[a]); b++)
        {
          if ( S->seq[a][b]=='u') S->seq[a][b]='t';
          if ( S->seq[a][b]=='U') S->seq[a][b]='T';
        }
      HERE ("%s", S->seq[a]);
    }
  return S;
}
Sequence *dna_seq2rna_seq (Sequence *S)
{
  int a, b;
  
  if ( !strm(S->type, "DNA") && !strm (S->type, "RNA")) printf_exit (EXIT_FAILURE, stderr, "Sequences should be *DNA* type (type=%s) [FATAL:%s]\n", PROGRAM, S->type);
  for ( a=0; a<S->nseq; a++)
    for (b=0; b<S->len[a]; b++)
      {
        if ( S->seq[a][b]=='t') S->seq[a][b]='u';
        if ( S->seq[a][b]=='T') S->seq[a][b]='U';
      }
  return S;
}

  

int get_longest_frame (char *seq, int mode);
Sequence  *translate_dna_seqS     (Sequence *S, int frame, int stop)
{
  //frame: 1->3
  char *s;
  int a, b,c,l;

  for (a=0; a<S->nseq; a++)
    {
      s=S->seq[a];
      ungap(s);
      l=strlen (s);
      for (b=(frame-1); b<l; b+=3)
        {
          s[b]=translate_dna_codon (s+b,stop);
          for (c=b+1; c<b+3 && c<l; c++)s[c]='-';
        }
    }
  return S;
}
Alignment *translate_dna_aln (Alignment *A, int frame)
       {
         /*Given a set of aligned sequences
           starts from left to right
           3 nuc->1 aa
           2nuc+1gap, 1nuc+2gap->3 gaps
           1 stop-> 3gaps
           returns the corresponding amino acid alignment
         */


         int a, b,r;


         if (frame==3 || frame ==4)
           {
             
             for (a=0; a< A->nseq; a++)
               {
                 char *d, *buf, f;
                 d=A->seq_al[a];
                 f=get_longest_frame (d,frame);
                 buf=vcalloc ( strlen (d)+1, sizeof (char));
                 if ( f<3)
                   {
                     sprintf (buf, "%s", d+f);
                     sprintf (d, "%s", buf);
                     sprintf (A->seq_comment[a], " frame: %d", f);
                   }
                 else if ( f>=3)
                   {
                     f-=3;
                     sprintf ( buf, "%s", d);
                     buf=complement_string (buf);
                     sprintf (d, "%s",buf+f);
                     sprintf (A->seq_comment[a], " frame: %d Reverse Complement", f);
                   }
                 vfree (buf);
               }
           }
         else
           {
             
             for ( a=0; a< A->nseq; a++)
               for (b=0; b< frame; b++)
                 A->seq_al[a][b]='-';
             ungap_aln(A);
           }

         for ( b=0; b< A->nseq; b++)
           for ( a=0; a< A->len_aln;)
             {
               
               r=translate_dna_codon (A->seq_al[b]+a, 'z');
               if (is_gap(r))
                 {
                   A->seq_al[b][a++]='-';
                   A->seq_al[b][a++]='-';
                   A->seq_al[b][a++]='-';
                 }
               else if ( r=='x')
                 {
                   A->seq_al[b][a++]='o';
                   A->seq_al[b][a++]='-';
                   A->seq_al[b][a++]='-';
                 }
               else if ( r=='z')
                 {
                   A->seq_al[b][a++]='x';
                   A->seq_al[b][a++]='-';
                   A->seq_al[b][a++]='-';
                 }
               else
                 {
                   A->seq_al[b][a++]=r;
                   A->seq_al[b][a++]='-';
                   A->seq_al[b][a++]='-';
                 }
             }   
         compress_aln (A);
         
         return A;
       }


int seq2tblastx_db (char *out,Sequence *S, int strand)
{
  //strand : same values as in ncbi blastall
  //1: direct
  //2:revers
  //3: both
  int a, b,d, l;
  char *prot, *pprot;
  int min_exon_len=5;
  FILE *fp;
  fp=vfopen (out, "w");
  for (a=0; a<S->nseq; a++)
    {
      for (b=-3; b<=3; b++)
        {
          int f;
          int dl;

          dl=strlen (S->seq[a]);
          if (b==0)continue; 
          else if ( strand==1 && b<0)continue;//only direct strand
          else if ( strand==2 && b>0)continue;//only reverse strand
          else if (b<0)
            {
              S->seq[a]=complement_string (S->seq[a]);
              f=b*-1;
            }
          else
            f=b;
          prot=translate_dna_seq (S->seq[a], f, 'X', NULL);
          upper_string (prot);
         
          l=strlen (prot);
          pprot=prot;
          for (pprot=prot,d=0; d<=l; d++)
            {
              if (prot[d]=='\0')
                {
                  prot[d]='\0';
                  if ( strlen (pprot)>min_exon_len)
                    {
                      int start, end;
                      end=(d)*3+(f-1);
                      start=(end-(strlen (pprot))*3)+1;
                      fprintf (fp, ">%s__%c__%d__%d__%d\n%s\n", S->name[a],(b>0)?'d':'r',start,end,dl, pprot);
                      pprot=prot+d+1;
                    }
                }
            }
          vfree (prot);
          if (b<0) S->seq[a]=complement_string (S->seq[a]);
        }
    }
  vfclose (fp);
  return EXIT_SUCCESS;
}

int get_longest_frame (char *in_seq, int mode)
{
  char *prot, *seq;
  int a;
  int max_l=0, l;
  int best_frame=0;
  int nf;
  
  seq=vcalloc (strlen (in_seq)+1, sizeof (char));
  prot=vcalloc (strlen (in_seq)+1, sizeof (char));
  sprintf ( seq, "%s", in_seq);
  
  if ( mode == 3)nf=3;
  else if ( mode == 4) nf=6;
  
  for (a=0; a<nf; a++)
    {
      int f;
      if (a==3)seq=complement_string (seq);
      f=(a>=3)?a-3:a;
      prot=translate_dna_seq ( seq,f,'\0', prot);
      l=strlen (prot);
      if (l>=max_l){max_l=l;best_frame=a;}
    }
  vfree (seq);
  vfree (prot);
  return best_frame;
}

Alignment *clean_gdna_aln (Alignment *A)
       {
           int a, b, c, r1, r2,s, p, n, tn;
           int *col;
           static int **mat;
           Alignment *T=NULL;
           int **score;
           char *buffer;
           

           /*Viterbi Parameters*/
           int AL=0;        /*Allowed Transition*/
           int F=-1000000; /*Forbiden Transition*/
           int SPLICE_PENALTY=100;
           int ORF1=0, ORF2=1, ORF3=2, NC=3;
           
           int state, pstate, best_e, best_pstate_p,best_state_p, best_pstate_v, best_state_v, v;
           int nstate=4;
           int **transitions;
           int e;
           int **v_tab_p;
           int **v_tab;
           int * is_dna;
           
           best_state_p=best_state_v=best_pstate_p=best_pstate_v=best_e=0;
           buffer=vcalloc ( 100000, sizeof (char));
           is_dna=vcalloc ( A->nseq, sizeof (int));
           score=declare_int ( A->nseq+1, A->len_aln);


           if ( !mat)mat=read_matrice("pam250mt");
           T=copy_aln (A, T);
           col=vcalloc ( A->nseq, sizeof (int));
           
           for (a=0; a<= A->len_aln; a++)
               for ( b=0; b< A->nseq; b++){A->seq_al[b][a]=tolower(A->seq_al[b][a]); A->seq_al[b][a]=(A->seq_al[b][a]=='t')?'u':A->seq_al[b][a];}

           for ( a=0; a< A->nseq; a++)
               {
                   sprintf ( buffer, "%s", A->seq_al[a]);
                   ungap (buffer);
                   is_dna[a]=strm ( get_string_type (buffer), "DNA");
               }
           

           for (a=0; a< A->len_aln-2; a++)
               {
               for (b=0; b< A->nseq; b++)
                       {
                       if (is_dna[b])col[b]=translate_dna_codon (A->seq_al[b]+a, 'x');
                       else col[b]=tolower ( A->seq_al[b][a]);   
                       }

               for (n=0,tn=0,b=0; b< A->nseq; b++)
                   for ( c=b; c< A->nseq; c++   )
                       {
                           r1=col[b];
                           r2=col[c];
                           
                           if (r1=='x' || r2=='x'){score[A->nseq][a]=F;break;}
                           else if (r1=='-' && r2=='-');
                           else if (r1=='-' || r2=='-');
                           else 
                               {
                               
                                   if ( is_dna[b] && is_dna[c])score[A->nseq][a]+= mat[r1-'A'][r2-'A'];
                                   else score[A->nseq][a]+=mat[r1-'A'][r2-'A']* (A->nseq*A->nseq);
                               }
                           n+=( !is_gap(r1) && !is_gap(r2));
                           score[A->nseq][a]=(((tn!=0)?score[A->nseq][a]/tn:0));
                       }
               
               }

           /*initialisation*/

           transitions=declare_int ( nstate, nstate);
           v_tab=declare_int ( A->len_aln+2, nstate       );
           v_tab_p=declare_int ( A->len_aln+2, nstate       );

           for (a=0; a<nstate;a++)
               for (b=0; b<nstate;b++)
                     {transitions[a][b]=F;}

           transitions[ORF1][ORF2]=AL;
           transitions[ORF2][ORF3]=AL;
           transitions[ORF3][ORF1]=AL;     
           
           transitions[ORF3][NC]  =AL-SPLICE_PENALTY;
           transitions[NC][ORF1]  =AL-SPLICE_PENALTY;


           for ( s=0; s<A->nseq; s++)
               {
               for ( p=0; p<=A->len_aln; p++){for (state=0; state< nstate; state++)v_tab_p[p][state]=-1; }
               for (p=1+2; p<= A->len_aln; p++)
                   {

                   for (state=0; state< nstate; state++)
                       {
                           
                           if ( state==NC){e=-best_e;}
                           else
                              {
                                  e=score[A->nseq][(p-1)-state];
                                  if ( state==0)best_e=e;
                                  else best_e=MAX(e, best_e);
                              }

                           for ( pstate=0; pstate<nstate; pstate++)
                               {
                                   v=e+transitions[pstate][state]+v_tab[p-1][pstate];
                                   if (pstate==0 ||(v>best_pstate_v) )
                                      {
                                       best_pstate_v=v;
                                       best_pstate_p=pstate;
                                      }
                               }
                        
                           v_tab[p][state]=best_pstate_v;
                           v_tab_p[p][state]=best_pstate_p;
                           if (state==0 ||best_pstate_v>best_state_v )
                              {
                               best_state_p=state; 
                               best_state_v=best_pstate_v;
                              }
                       }

                   }

               
       
               for (p=0; p< A->len_aln; p++)T->seq_al[s][p]='.';
               for (p=A->len_aln; p>0; p--)
                   {
                       
                       if ( best_state_p==0)T->seq_al[s][p-1]=translate_dna_codon (A->seq_al[s]+(p-1), 'x');
                       else if ( best_state_p==1 || best_state_p==2)T->seq_al[s][p-1]='-';
                      
                      
                       
                       best_state_p=v_tab_p[p][best_state_p];
                       
                   }
               }
           
           

           vfree (col);
           return T;
       }

Alignment *clean_cdna_aln (Alignment *A)
       {
         /*Given an alignmnet of nucleotides
           Returns the same alignmnent whith non coding nucleotides replaced with dots
           
           at each position, the emission probability is the sum of pair of the substitution of amino-acids
         */
         
           int a, b, c,s, p;
           static int **mat;
           int   *emission;
           float em1, em2;
           char *buffer;
           Alignment *B=NULL;


           

           /*Viterbi Parameters*/
           int AL=0;        /*Allowed Transition*/
           int F=-1000000; /*Forbiden Transition*/
           int PENALTY=30;
           int NC, C1,C2, C3, START, END;
           int nstate=0;
           int state=0,best_state=0, score=0, best_score=0;
           int p_state;
           int e=0;
           int **score_tab;
           int **state_tab;
         
           int **transitions;
           int n;
           int r1, r2, r3;

           NC=nstate++;
           C1=nstate++;
           C2=nstate++;
           C3=nstate++;
           START=nstate++;
           END=nstate++;

           
           B=copy_aln (A, B);
           buffer=vcalloc ( 100000, sizeof (char));
           emission=vcalloc (A->len_aln, sizeof (int));

           if ( !mat)
             {
               mat=read_matrice("pam250mt");
             }

           /*Computation of the emission proba for the coding state*/


           for (a=0; a< A->len_aln; a++)
             {

               /*First component: % occupancy of the column*/
               em1=0;
               for ( b=0; b< A->nseq; b++) em1+=!is_gap(translate_dna_codon (A->seq_al[b]+a, '-'));
               em1=em1/(float)A->nseq;
               
               /*Second Component: % similarity within column*/
               em2=0;
               for (n=0,b=0; b< A->nseq-1; b++)
                 {
                   r1=translate_dna_codon (A->seq_al[b]+a, '-');
                   
                   for (c=b+1; c<A->nseq; c++)
                     {
                       r2=translate_dna_codon (A->seq_al[c]+a, '-');
                       if (is_gap(r2) || is_gap(r1));
                       else
                         {
                           n++;
                           em2+=((mat[r1-'A'][r2-'A'])>1)?1:0;
                         }
                     }
                 }
               em2=em2/(float)((n==0)?1:n);
               
               
               emission[a]=(em1*100);

             }
           
         

           /*initialisation*/

           transitions=declare_int ( nstate, nstate);
           score_tab=declare_int ( A->len_aln+2, nstate       );
           state_tab=declare_int ( A->len_aln+2, nstate       );

           for (a=0; a<nstate;a++)
               for (b=0; b<nstate;b++)
                     {transitions[a][b]=F;}

           
           transitions[START][C1]=AL;
           transitions[START][NC]=AL;
           transitions[C3][END]=AL;
           transitions[NC][END]=AL;
           transitions[C1 ][C2 ]=AL;
           transitions[C2 ][C3 ]=AL;
           transitions[C3 ][C1 ]=AL;
           transitions[C3 ][NC ]=AL-PENALTY;
           transitions[NC ][C1 ]=AL-PENALTY;
           transitions[NC][NC]=AL-PENALTY;
           
           
                   
           for ( s=0; s< A->nseq; s++)
             {
             for ( p=0; p<=A->len_aln; p++){for (state=0; state< nstate; state++){score_tab[p][state]=F;state_tab[p][state]=-1;} }
             score_tab[0][START]=0;
             
             for (p=1; p<= A->len_aln; p++)
               {
                 for (state=0; state< nstate; state++)
                   {
                     if ( state==START || state==END)continue;
                     else if      ( state==NC)  e=-10;
                     else if ( state==C1)
                       {
                         e=emission[p-1];
                       }
                     else if ( state ==C2)
                       {
                         if ( p-2<0)e=F;
                         else e=emission[p-2];
                       }
                     else if ( state==C3)
                       {
                         if ( p-3<0)e=F;
                         else e=emission[p-3];
                       }
                     
                     for (p_state=0; p_state<nstate; p_state++)
                       {
                         
                         if (e==F)score=F;
                         else 
                           {
                             score=(score_tab[p-1][p_state]==F)?F:(e+transitions[p_state][state]+score_tab[p-1][p_state]);
                           }
                         
                         if(p_state==0 || score>best_score){ best_score=score;best_state=p_state;}
                         
                       }
                     
                     score_tab[p][state]=best_score;
                     state_tab[p][state]=best_state;
                     
                   }
               }
             
             best_score=best_state=UNDEFINED;
             for (state=0; state<nstate; state++)
               {
                 if (state==START || state==END)continue;
                 e=transitions[state][END];
                 if (e==F || score_tab[p-1][state]==F)continue;
                 
                 if (best_score==UNDEFINED || score_tab[p-1][state]>best_score)
                   {
                     best_score=score_tab[p-1][state]+e; 
                     best_state=state;
                   }
                 
               }
             
             for (p=A->len_aln; p>0;)
               {
                 B->seq_al[s][p-1]=best_state+'0';
                 best_state=state_tab[p][best_state];
                 p--;
               }
             }

           for ( a=0; a< A->nseq; a++)
             for ( b=0; b< A->len_aln;)
               {
                 s=B->seq_al[a][b];
                 if ( s==C1+'0')
                   {
                     r1=A->seq_al[a][b];
                     r2=A->seq_al[a][b+1];
                     r3=A->seq_al[a][b+2];
                     

                     if ( is_gap(r1) ||is_gap(r2) ||  is_gap(r3))
                       {
                         A->seq_al[a][b]=(is_gap(r1))?'~':'.';
                         A->seq_al[a][b+1]=(is_gap(r2))?'~':'.';
                         A->seq_al[a][b+2]=(is_gap(r3))?'~':'.';
                       }
                     b+=3;
                   }
                 else if ( s==NC+'0')
                   {
                     A->seq_al[a][b]=(is_gap(A->seq_al[a][b]))?'~':'.';
                     b++;
                   }
                 else 
                   {
                     fprintf (stderr, "\nPROBLEM: [%d %d]->%d", a, b, s-'0');
                   }
               }
                 

           free_aln (B);
           free_int (transitions, -1);
           free_int (score_tab, -1);
           free_int (state_tab, -1);
           vfree (emission);
           vfree (buffer);
           
           return A;
       }




Alignment *translate_splice_dna_aln (Alignment *A, Alignment *ST)
       {
           int a, b, c, r1, r2,s, p, n, tn;
           int *col;
           static int **mat;
           Alignment *T=NULL;
           int **score;
           
           /*Viterbi Parameters*/
           int AL=0;        /*Allowed Transition*/
           int F=-1000000; /*Forbiden Transition*/
           int ORF1=0, ORF2=1, ORF3=2,SPL1=3, SPL2=4, SPL3=5, SPL4=6, NC=7;
           int SPLICE_PENALTY;
           int frame1, frame2, frame3, best_frame;
           int nstate=8;
           char r;
           


           int state=0, pstate=0, best_pstate_p=0,best_state_p=0, best_pstate_v=0, best_state_v=0, v=0;
           
           int **transitions;
           int e=0;
           int **v_tab_p;
           int **v_tab;

           score=declare_int ( A->nseq+1, A->len_aln);


           if ( !mat)mat=read_matrice("pam250mt");
           T=copy_aln (A, T);
           col=vcalloc ( A->nseq, sizeof (int));
           
           for (a=0; a<= A->len_aln; a++)
               for ( b=0; b< A->nseq; b++){A->seq_al[b][a]=tolower(A->seq_al[b][a]); A->seq_al[b][a]=(A->seq_al[b][a]=='t')?'u':A->seq_al[b][a];}

           
           

           for (a=0; a< A->len_aln-2; a++)
               {
               for (b=0; b< A->nseq; b++)
                       {
                       col[b]=translate_dna_codon (A->seq_al[b]+a, 'x');
                       }
               
               for (n=0,tn=0,b=0; b< A->nseq-1; b++)
                   for ( c=b+1; c< A->nseq; c++, tn++   )
                       {
                           r1=col[b];
                           r2=col[c];
                           
                           if (r1=='x' || r2=='x')score[A->nseq][a]=F;
                           else if (r1=='-' && r2=='-');
                           else if (r1=='-' || r2=='-');
                           else 
                               {
                                   score[A->nseq][a]+= mat[r1-'A'][r2-'A'];
                                   
                               }
                           n+=( !is_gap(r1) && !is_gap(r2));
                       }   
               score[A->nseq][a]=(((tn!=0)?score[A->nseq][a]/tn:0));
                 
               }
               
           /*initialisation*/

           transitions=declare_int ( nstate, nstate);
           v_tab=declare_int ( A->len_aln+2, nstate*nstate);
           v_tab_p=declare_int ( A->len_aln+2, nstate*nstate);

           for (a=0; a<nstate;a++)
             for (b=0; b<nstate;b++)
               {transitions[a][b]=F;}

           SPLICE_PENALTY=-1000;

           transitions[ORF1][ORF2]    =AL;
           transitions[ORF1][SPL1]    =AL-SPLICE_PENALTY;
           
           transitions[ORF2][ORF3]    =AL;
           transitions[ORF2][SPL1]    =AL-SPLICE_PENALTY;
           
           transitions[ORF3][ORF1]    =AL;
           transitions[ORF3][SPL1]    =AL-SPLICE_PENALTY;
           
           transitions[ORF3][ORF1]    =AL;
           transitions[ORF3][SPL1]    =AL-SPLICE_PENALTY;
           
           transitions[ORF3][NC]=AL-100;
           transitions[NC][ORF1]=AL-100;


           transitions[SPL1][SPL2]=AL;
           transitions[SPL2][NC  ]=AL-SPLICE_PENALTY;
           transitions[NC  ][NC  ]=AL;
           transitions[NC  ][SPL3]=AL-SPLICE_PENALTY;
           transitions[SPL3][SPL4]=AL;
           transitions[SPL4][ORF1]=AL;
           transitions[SPL4][ORF2]=AL;
           transitions[SPL4][ORF3]=AL;
           

           for ( s=0; s<A->nseq; s++)
               {
               for ( p=0; p<=A->len_aln; p++){for (state=0; state< nstate; state++)v_tab_p[p][state]=-1; }
               for (p=1+2; p<= A->len_aln; p++)
                   {
                    frame1=score[A->nseq][(p-1)];
                    frame2=score[A->nseq][(p-1)-1];
                    frame3=score[A->nseq][(p-1)-2];  
                    best_frame=best_int (3, 1, &a, frame1, frame2, frame3);
                    for (state=0; state< nstate; state++)
                       {
                         r=tolower (A->seq_al[s][p-1]);
                         r=(r=='u')?'t':r;
                         
                         if      (state==ORF1)e=frame1;
                         else if (state==ORF2)e=frame2;
                         else if (state==ORF3)e=frame3;
                         else if (state==SPL1)e=(r=='g')?best_frame:F;
                         else if (state==SPL2)e=(r=='t')?best_frame:F;
                         else if (state==SPL3)e=(r=='a')?best_frame:F;
                         else if (state==SPL4)e=(r=='g')?best_frame:F;
                         else if (state==NC)e=-best_frame;
                         for ( pstate=0; pstate<nstate; pstate++)
                               {
                                   v=e+transitions[pstate][state]+v_tab[p-1][pstate];
                                   if (pstate==0 ||(v>best_pstate_v) ){best_pstate_v=v;best_pstate_p=pstate;}
                               }
                        
                           v_tab[p][state]=best_pstate_v;
                           v_tab_p[p][state]=best_pstate_p;
                           if (state==0 ||best_pstate_v>best_state_v ){best_state_p=state; best_state_v=best_pstate_v;}
                       }
                   }

               
       
               for (p=0; p< A->len_aln; p++)T->seq_al[s][p]='.';
               for (p=A->len_aln; p>0; p--)
                   {
                       if ( best_state_p==0)T->seq_al[s][p-1]=toupper(translate_dna_codon (A->seq_al[s]+(p-1), 'x'));
                       else if ( best_state_p>=SPL1  && best_state_p<=SPL4)T->seq_al[s][p-1]='-';
                       best_state_p=v_tab_p[p][best_state_p];
                   }
               }
           
           

           vfree (col);
           return T;
       }

Alignment * mutate_cdna_aln ( Alignment *A)
{
    int a, b, c, n;
    int n1, n2, r1, r2;
    int **pos, ps;
    int neutral_substitution=50;
    int random_substitution=0;
    int random_deletion=0;
    int amino_acid_deletion=0;
    int amino_acid_substitution=0;
    char nuc_list[]="agct";
    char *new_codon;

    neutral_substitution=atoi(get_env_variable ("NEUTRAL_SUBSTITUTION",IS_FATAL));
    random_substitution =atoi(get_env_variable ("RANDOM_SUBSTITUTION", IS_FATAL));
    random_deletion     =atoi(get_env_variable ("RANDOM_DELETION", IS_FATAL));
    amino_acid_deletion =atoi(get_env_variable ("AMINO_ACID_DELETION", IS_FATAL));
    amino_acid_substitution =atoi(get_env_variable ("AMINO_ACID_SUBSTITUTION", IS_FATAL));
    
    
    if (A->S)free_sequence ( A->S, (A->S)->nseq);
    A->S=aln2seq(A);

    addrandinit(time (NULL));

    
    pos=aln2pos_simple ( A, A->nseq);
    
    /* 1 Apply neutral substitutions    */
    
    if ( neutral_substitution)
        {
        for (  c=0; c< neutral_substitution; c++)
            {
            for (  a=0; a< A->nseq; a++)
                {
                    
                    for ( b=0; b< A->len_aln; b++)
                        {
                        
                        if (pos[a][b]<=0)continue; 
                        ps=MAX(0,pos[a][b]-(pos[a][b]-1)%3-1);


                        n1=(A->S)->seq[a][pos[a][b]-1];
                        r1=translate_dna_codon ( (A->S)->seq[a]+ps, 'o');
                        
                        n2=nuc_list[(int)addrand((unsigned long) 4)];
                        (A->S)->seq[a][pos[a][b]-1]=n2;
                        r2=translate_dna_codon ( (A->S)->seq[a]+ps, 'o');
                        
                        
                        if ( r1==r2 && r1!='o')A->seq_al[a][b]=n2;
                        
                        else (A->S)->seq[a][pos[a][b]-1]=n1;
                        }
                }
            }
        }

    /* 2 Apply         substitutions    */
     if ( random_substitution)
        {
        for (  a=0; a< A->nseq; a++)
            {
                for ( b=0; b< A->len_aln; b++)
                    {
                    if (pos[a][b]<=0)continue; 
                    if (addrand ((unsigned long) 100)>random_substitution)continue; 
                    
                    n1=nuc_list[(int)addrand((unsigned long)4)];
                    (A->S)->seq[a][pos[a][b]-1]=n1;
                    A->seq_al[a][b]=n1;
                    }
            }
        }
    
    /* 3 Apply amino acid substitutions */
      if ( amino_acid_substitution)
        {
        for (  a=0; a< A->nseq; a++)
            {
                for ( b=0; b< A->len_aln; b+=3)
                    {
                    if (pos[a][b]<=0)continue; 
                    if (addrand ((unsigned long) 100)>amino_acid_substitution)continue; 
                    ps=MAX(0,pos[a][b]-(pos[a][b]-1)%3-1);
                    
                    r1=translate_dna_codon ( (A->S)->seq[a]+ps, 'o');
                    new_codon=mutate_amino_acid(r1, "clustalw_col");
                    
                    for ( c=ps; c<ps+3; c++)(A->S)->seq[a][c]=new_codon[c-ps];
                    }
                for ( b=0; b< A->len_aln; b++)
                    {
                    if (pos[a][b]<=0)continue; 
                    else A->seq_al[a][b]=(A->S)->seq[a][pos[a][b]-1];
                    }
            }
        }  
    /* 3 Apply amino acid deletions     */
     if ( amino_acid_deletion)
        {
        for (  a=0; a< A->nseq; a++)
            {
                for ( b=0; b< A->len_aln; b+=3)
                    {
                    if (pos[a][b]<=0)continue; 
                    if (addrand ((unsigned long) 1000)>amino_acid_deletion)continue; 
                    ps=MAX(0,pos[a][b]-(pos[a][b]-1)%3-1);
                    n=addrand ((unsigned long) 4)+1;
                    
                    for ( c=ps; c<ps+(3*n) && c<A->len_aln; c++)(A->S)->seq[a][c]='-';
                    }
                for ( b=0; b< A->len_aln; b++)
                    {
                    if (pos[a][b]<=0)continue; 
                    else A->seq_al[a][b]=(A->S)->seq[a][pos[a][b]-1];
                    }
            }
        }
    /* 4 Apply amino acid insertions    */

/*FRAMESHIFT MUTATIONS*/
    /* 5 Apply nucleotide deletions*/
     if ( random_deletion)
        {
        for (  a=0; a< A->nseq; a++)
            {
                for ( b=0; b< A->len_aln; b++)
                    {
                    if (pos[a][b]<=0)continue; 
                    if (addrand ((unsigned long) 1000)>random_deletion)continue; 
                    
                    n1='-';
                    (A->S)->seq[a][pos[a][b]-1]=n1;
                    A->seq_al[a][b]=n1;
                    }
            }
        }
    /* 6 Apply nucleotide deletions*/
     free_int (pos, -1);
   return A;

}    
    
Alignment* clean_est  ( Alignment *A)
        {
          /*Rules are as follow:
            Internal Gap > 30% Requences ----> -
            Best Residue < 50% Residues  ----> 'N'
          */
          int a, b,c;
          int best;
          int tot;

          for ( a=0; a< A->len_aln; a++)
            {
              
              for (tot=0, b=0; b<4; b++)tot+=(A->P)->count[b][a];
              best=best_int (5,1, &c, (A->P)->count[0][a],(A->P)->count[1][a],(A->P)->count[2][a],(A->P)->count[3][a],(A->P)->count[4][a]);
              
              if ( tot==0)
                {
                  fprintf ( stderr, "\nWARNING: POSITION WITH NO INFORMATION [clean_est:%s]", PROGRAM);
                  A->seq_al[0][a]='-';
                }
              else if (((A->P)->count[4][a]*100)/tot >30)A->seq_al[0][a]='-';
              else if ( (best*100)/tot<50)A->seq_al[0][a]='n';
              
            }
        return A;
        }
           
    

char **make_symbols ( char *name, int *n)
    {
    char **symbol;

    symbol=declare_char ( STRING, STRING);
    
    if ( strcmp (name, "3d_ali")==0)
        {
        sprintf ( symbol[0], "gih");
        sprintf ( symbol[1], "eb");
        sprintf ( symbol[2], "x");
        sprintf ( symbol[3], "#l");
        n[0]=4;
        }
    
    else if ( strcmp (name, "all")==0)
        {
          int a, i;
          for ( i=0,a=0; a<26; a++)
            {
              sprintf ( symbol[i++], "%c%c", 'a'+a, 'a'+a);
              sprintf ( symbol[i++], "%c%c", 'A'+a, 'A'+a);
            }
          sprintf ( symbol[i++], "--");
          n[0]=i;
        }
    
    else if ( strcmp (name, "set1")==0)
        {
        sprintf ( symbol[0], "ilvmfywhktcagH");
        sprintf ( symbol[1], "reqdnsP");
        sprintf ( symbol[2], "--");
        sprintf ( symbol[3], "#l");
        n[0]=4;
        }
    else if ( strcmp (name, "set2")==0)
        {
        n[0]=0;
        sprintf ( symbol[n[0]++], "gsacT");
        sprintf ( symbol[n[0]++], "ndtvpS");
        sprintf ( symbol[n[0]++], "ilkreqL");
        sprintf ( symbol[n[0]++], "--");
        sprintf ( symbol[n[0]++],"#l"); 
        }
    else if ( strcmp ( name, "any")==0)
        {
        sprintf ( symbol[0], "*x");
        n[0]=1;
        }




    return symbol;
    }

char *testdna2gene (char *dna)
{
  int *w,a,l;
  l=strlen (dna);
  HERE ("%s", dna);
  w=vcalloc(l+1, sizeof (int));
  for (a=0; a<l; a++)
    {
      w[a]=isupper (dna[a])?1:-1;
    }
  dna=dna2gene (dna,w);
  vfree (w);
  return dna;
}

Sequence *dnaseq2geneseq (Sequence *S, int **w)
{
  Sequence *PS;
  int a;
  char *p;

  PS=duplicate_sequence (S);
  for (a=0; a<S->nseq; a++)
    {
      p=dna2gene (S->seq[a], w[a]);
      if (strstr (p, "F"))
        {
          HERE ("----FRAMESHIFT: %s", S->name[a]);
        }
      vfree (PS->seq[a]);
      PS->len[a]=strlen(p);
      PS->seq[a]=vcalloc (PS->len[a]+1, sizeof (char));
      sprintf ( PS->seq[a], "%s", p);
      vfree (p);
    }
  PS=reset_sequence_len (PS);
  return PS;
}

char *dna2gene (char *dna, int *w)
{
  int a, b, c, ns,l,od;
  int I1, I2, I3, START, NCE, NCS;
  int C1, S1_1, S2_1, S3_1, S4_1,NC1;
  int C2, S1_2, S2_2, S3_2, S4_2,NC2;
  int C3, S1_3, S2_3, S3_3, S4_3,NC3;
  int ST;
  int st;
  
  double p_C1, p_C2;
  double **C1_mat, **C2_mat;
  double *tb, **sc_mat, **tb_mat;
  double **em, **trans;
  double avg_w=0;
  
  char **string;
  double forbiden   =-100000;
  double frameshift1;
  double frameshift2;
  double exon_penalty;
  double exon_reward;
  double nostop_penalty;
  double shiftw;
  int frameshift_symbol='F';
  char *out_dna;
  int max=0;

  char *three_dna;

  three_dna=translate_dna_seq_on3frame (dna, 'x', NULL);
  lower_string(three_dna);
  l=strlen (dna);
  for (a=0; a<l; a++){max=MAX(max,w[a]);avg_w+=(double)w[a];}
  avg_w/=(double)l;
  shiftw=avg_w*-2;
  
  exon_penalty=-100*avg_w;
  exon_reward=avg_w;
  nostop_penalty=-100 *avg_w;
  frameshift1=forbiden;
  frameshift2=frameshift1;
  
  out_dna=vcalloc ( 2*strlen (dna)+1, sizeof (char));
  sprintf (out_dna, "%s", dna);
  ns=0;
  START=ns++;  I1=ns++;I2=ns++;I3=ns++;NCE=ns++;NCS=ns++;
  
  C1=ns++; S1_1=ns++;S2_1=ns++;NC1=ns++;S3_1=ns++;S4_1=ns++;
  C2=ns++; S1_2=ns++;S2_2=ns++;NC2=ns++;S3_2=ns++;S4_2=ns++;
  C3=ns++; S1_3=ns++;S2_3=ns++;NC3=ns++;S3_3=ns++;S4_3=ns++;
  ST=ns++;
  
  string=declare_char ( ns+1, 10);
  sprintf (string [S1_1], "S1_1");
  sprintf (string [S2_1], "S2_1");
  sprintf (string [S3_1], "S3_1");  
  sprintf (string [S4_1], "S4_1");
 
  sprintf (string [S1_2], "S1_2");
  sprintf (string [S2_2], "S2_2");
  sprintf (string [S3_2], "S3_2");  
  sprintf (string [S4_2], "S4_2");
  
  sprintf (string [S1_3], "S1_3");
  sprintf (string [S2_3], "S2_3");
  sprintf (string [S3_3], "S3_3");  
  sprintf (string [S4_3], "S4_3");
  
  sprintf (string [START], "START");
  sprintf (string [NCE], "NCE");
  sprintf (string [NCS], "NCS");
  sprintf (string [NC1], "NC1");
  sprintf (string [NC2], "NC2");
  sprintf (string [NC3], "NC3");
  sprintf (string [I1], "I1");
  sprintf (string [I2], "I2");
  sprintf (string [I3], "I3");
 
  sprintf (string [C1], "C1");
  sprintf (string [C2], "C2");
  sprintf (string [C3], "C3");
  
  sprintf (string [ST], "STOP");

  trans=declare_double(ns,ns);
  em=declare_double   (ns,256);
  tb=vcalloc ( l+1, sizeof (double));
  sc_mat=declare_double (l+1, ns);
  tb_mat=declare_double (l+1, ns);
  C1_mat=declare_double (l+1, ns);
  C2_mat=declare_double (l+1, ns);
  
  for (a=0; a<ns; a++)
    {
      for (b=0; b<ns; b++)trans[a][b]=forbiden;
      for (b=0; b<256; b++)em[a][b]=forbiden;
    }
 
  trans[START][I1]=0;
  trans[START][NCS]=0;
  trans[NCS][NCS]=0;
  trans[NCS][NCE]=0;//allow sequence entirely non coding
  
  trans[NCS][I1]=0;
  trans[I1][I2]=0;
  trans[I2][I3]=0;
  trans[I3][C1]=0;
  
  trans[C1][C2]=0;
  trans[C1][C3]=frameshift1;
  trans[C1][C1]=frameshift2;
  
  trans[C2][C3]=0;
  trans[C2][C1]=frameshift1;
  trans[C2][C2]=frameshift2;
 
  
  trans[C3][C1]=exon_reward;
  trans[C3][C2]=frameshift1;
  trans[C3][C3]=frameshift2;
  
  trans[C3][NCE]=nostop_penalty;
  trans[C3][ST] =0; //normal termination
  trans[ST][NCE]=0;
  trans[NCE][NCE]=0;
  
  trans[C1][S1_1]=exon_penalty;
  trans[S1_1][S2_1]=0;
  trans[S2_1][NC1]=0;
  trans[NC1][NC1]=0;
  trans[NC1][S3_1]=0;
  trans[S3_1][S4_1]=0;
  trans[S4_1][C2]=0;
  trans[S4_1][C3]=frameshift1;
  trans[S4_1][C1]=frameshift2;
  

  trans[C2][S1_2]=exon_penalty;
  trans[S1_2][S2_2]=0;
  trans[S2_2][NC2]=0;
  trans[NC2][NC2]=0;
  trans[NC2][S3_2]=0;
  trans[S3_2][S4_2]=0;
  trans[S4_2][C3]=0;
  trans[S4_2][C1]=frameshift1;
  trans[S4_2][C2]=frameshift2;
  
  trans[C3][S1_3]=exon_penalty;
  trans[S1_3][S2_3]=0;
  trans[S2_3][NC3]=0;
  trans[NC3][NC3]=0;
  trans[NC3][S3_3]=0;
  trans[S3_3][S4_3]=0;
  trans[S4_3][C1]=0;
  trans[S4_3][C2]=frameshift1;
  trans[S4_3][C3]=frameshift2;
  
  em[I1]['A']=1;
  em[I2]['T']=1;
  em[I3]['G']=1;

  em[S1_1]['G']=1;
  em[S2_1]['T']=1;
  em[S3_1]['A']=1;
  em[S4_1]['G']=1;

  em[S1_2]['G']=1;
  em[S2_2]['T']=1;
  em[S3_2]['A']=1;
  em[S4_2]['G']=1;

  em[S1_3]['G']=1;
  em[S2_3]['T']=1;
  em[S3_3]['A']=1;
  em[S4_3]['G']=1;
 

  for (a=0; a<ns; a++)sc_mat[0][a]=tb_mat[0][a]=forbiden;
  sc_mat[0][START]=tb_mat[0][START]=0;
  
  for (a=1; a<=l ;a++)
    {
      int r;
      r=toupper (dna[a-1]);
      for (b=0; b<ns; b++)
        {
          double best_sc,e,lw;
          int best_t;
          
          lw=(double)w[a-1]+shiftw;

          if (b==ST && three_dna[a-1]=='x')e=0;
          else if (b==C1 || b == C2 || b== C3)e=lw;
          else if ( b==NC1|| b==NC2 || b==NC3 || b==NCE || b==NCS)e=-lw;
          else e=em[b][r];
          
          if (e==forbiden)
          {
                sc_mat[a][b]=forbiden;
                tb_mat[a][b]=0;
          }
          else
             {
               for (best_sc=forbiden,best_t=0,c=0; c<ns; c++)
                 {
                   double tr, sc, p_sc;
                   tr  = trans[c][b];
                   p_sc=sc_mat[a-1][c];

                   //Frameshift handling
                   
                   if ( tr== forbiden || p_sc==forbiden);
                   else if (tr!=forbiden)
                     {
                       if     (b==C2 && c!=C1 && c!=S4_1){p_C1='N'; p_C2=r;  }
                       else if(b==C3 && c!=C2 && c!=S4_2){p_C1='N'; p_C2='N';}
                       else
                         {
                           p_C1=C1_mat[a-1][c];
                           p_C2=C2_mat[a-1][c];
                         }
                       
                       if (b==C3 && is_stop (p_C1, p_C2,r)){tr=forbiden;}
                       else
                         {
                           sc=tr+e+p_sc;
                           if (c==0 || sc>best_sc)
                             {
                               best_sc=sc;
                               best_t =c;
                             }
                         }
                     }
                 }
          
               C1_mat[a][b]=(b==C1)?r:C1_mat[a-1][best_t];
               C2_mat[a][b]=(b==C2)?r:C2_mat[a-1][best_t];
               sc_mat[a][b]=best_sc;
               tb_mat [a][b]=best_t;
             }
         
        }
    }
  
  a=l;
  b=NCE;
  c=sc_mat[a][NCE];
  
  while (a>0)
    {
//      HERE ("**%d [%s] %c in %d", b,string[b], dna[a-1], a);
      tb[a]=b;
      b=tb_mat[a][b];
      a--;
    }

  od=0;
  st=0;
  for (a=0;a<l;a++)
    {
      int r,t,pt, coding;
      t =tb[a+1];
      pt=tb[a ];
      r=dna[a];
      if ( st || t==ST)st++;
      coding=(t==C1 || t==C2 || t==C3 || t==I1 || t==I2 || t==I3 ||(st && st<=3))?1:0;

      
      
      if      (t==C1 && (pt==C2 || pt==S4_2)){out_dna[od++]=frameshift_symbol;}
      else if (t==C1 && (pt==C1 || pt==S4_1)){out_dna[od++]=frameshift_symbol;out_dna[od++]=frameshift_symbol;}
     
      else if (t==C2 && (pt==C3 || pt==S4_3)){out_dna[od++]=frameshift_symbol;}
      else if (t==C2 && (pt==C2 || pt==S4_2)){out_dna[od++]=frameshift_symbol;out_dna[od++]=frameshift_symbol;}
      
      else if (t==C3 && (pt==C1 || pt==S4_1)){out_dna[od++]=frameshift_symbol;}
      else if (t==C3 && (pt==C3 || pt==S4_3)){out_dna[od++]=frameshift_symbol;out_dna[od++]=frameshift_symbol;}
      
      if (coding)out_dna[od++]=toupper (r);
      else out_dna[od++]=tolower(r);
      
    }

  free_double (tb_mat, -1);
  free_double (sc_mat, -1);
  free_double (trans, -1);
  free_double (em, -1);
  free_double (C1_mat, -1);
  free_double (C2_mat, -1);
  vfree (tb);
  vfree (three_dna);
  return out_dna;
}   

   
int res_weights2avg(Sequence *R, int **w)
{
  int a, b;
  double avg=0;
  int n=0;
  
  for (a=0; a<R->nseq; a++)
    for (b=0; b<R->len[a]; b++){avg+=w[a][b];n++;}
  return avg/n;
}
int res_weights2min(Sequence *R, int **w)
{
  int a,b;
  int min=w[0][0];
  
  for (a=0; a<R->nseq; a++)
    for (b=0; b<R->len[a]; b++)min=MIN(min,(w[a][b]));
  return min;
}
int res_weights2max(Sequence *R, int **w)
{
  int a, b;
  int max=w[0][0];
  
  for (a=0; a<R->nseq; a++)
    for (b=0; b<R->len[a]; b++)max=MAX(max,(w[a][b]));
  return max;
}
int scan_res_weights4ac (Sequence *R, int **w, int start, int end, int step)
{
  int best_t, a;
  float best_ac=0;
  float *count;
  float *acc;
  int avg;

  avg=res_weights2avg(R,w);
  best_t=start;
  for (a=start; a<=end; a+=step)
    {
     
      count=res_weights2accuracy_counts (R,w,a,NULL);
      acc=counts2accuracy (count);
      
      if (acc[3]>best_ac)
        {
          best_ac=acc[3];
          best_t=a;
        }
      vfree (count);vfree (acc);
    }
  count=res_weights2accuracy_counts (R,w,best_t,NULL);
  acc=counts2accuracy (count);
  fprintf (stderr, "\nBest_T: %d ", best_t);
  display_accuracy (count,stderr);
  
  count=res_weights2accuracy_counts (R,w,2*avg,NULL);
  acc=counts2accuracy (count);
  fprintf (stderr, " Avg_T: %d ", 2*avg);
  display_accuracy (count,stderr);
  
  vfree (acc); vfree (count);
  return best_t;
}
int ** shift_res_weights ( Sequence *R, int **w, int shift)
{
  int a, b;
  for (a=0; a<R->nseq; a++)
    for (b=0; b<R->len[a]; b++)
      w[a][b]+=shift;
  return w;
}
float *res_weights2accuracy_counts ( Sequence *R, int **w,int T, float *result)
{
  int a, b, coding,pcoding;
  
  if (!result)result=vcalloc (4, sizeof (float));
  
  for (a=0; a<R->nseq; a++)
    {
      for (b=0; b<R->len[a]; b++)
        {
          coding=(isupper(R->seq[a][b]))?1:0;
          pcoding=(w[a][b]>T)?1:0;
          if      (  coding &&  pcoding)result[0]++;//TP
          else if ( !coding && !pcoding)result[1]++;//TN
          else if ( !coding &&  pcoding)result[2]++;//FP
          else if (  coding && !pcoding)result[3]++;//FN
        }
    }
  return result;
}

void genepred_seq2accuracy_counts4all (Sequence *R, Sequence *T)
{
  int a,b;
  float *result =vcalloc (4, sizeof (float));

  fprintf ( stderr, "\n");

  for (a=0; a<R->nseq; a++)
  {
    fprintf ( stderr, "gene: %s ", R->name[a]);
    for (b=0; b<T->nseq; b++)
    {
      if ( strm (R->name[a], T->name[b]) && hasupper(R->seq[a]))
      {
        vfree (display_accuracy (genepred2accuracy_counts (R->seq[a], T->seq[b], NULL),stderr));
        break;
      }
    }
  }
  vfree(result);
}
      
float* genepred_seq2accuracy_counts (Sequence *R, Sequence *T,float *result)
{
  int a,b;
  
  if (!result)result=vcalloc (4, sizeof (float));

  for (a=0; a<R->nseq; a++)
    for (b=0; b<T->nseq; b++)
      if ( strm (R->name[a], T->name[b]) && hasupper(R->seq[a]))
        genepred2accuracy_counts (R->seq[a], T->seq[b], result);
  return result;
}

float* genepred2accuracy_counts      (char *ref,  char *target , float *result)
{
  char *ref2, *target2;
  int l,a;
  if ( !result) result=vcalloc (4, sizeof (float));
  ref2=vcalloc ( strlen (ref)+1, sizeof (char));
  sprintf ( ref2, "%s", ref);
  
  target2=vcalloc ( strlen (target)+1, sizeof (char));
  sprintf ( target2, "%s", target);
  
  remove_charset (ref2, "Ff");
  remove_charset (target2, "Ff");

  if ( strlen (target2) != strlen (ref2))
    {fprintf (stderr, "ERROR: Gene and target have different length [FATAL]\n"); myexit (EXIT_FAILURE);}
  
  l=strlen (ref2);
  for (a=0; a<l; a++)
    {
      int coding, pcoding;
      coding =isupper (ref2[a]);
      pcoding=isupper (target2[a]);
      if      ( coding  &&  pcoding)result[0]++;//TP
      else if ( !coding && !pcoding)result[1]++;//TN
      else if ( !coding &&  pcoding)result[2]++;//FP
      else if (  coding && !pcoding)result[3]++;//FN
    }
  
  vfree (ref2);
  vfree (target2);
  return result;
 }

int is_stop( char r1, char r2, char r3)
{
  char codon[4];
  
  if (!r2 || !r3) return 0;
  else if (tolower (r1)=='n' || tolower(r2)=='n' || tolower(r3)=='n') return 0;
  else 
    {
      sprintf (codon, "%c%c%c", tolower(r1), tolower(r2), tolower(r3));
      if (translate_dna_codon (codon, 'x')=='x')return 1;
      else return 0;
    }
}


char * translate_dna_seq_on3frame (  char *dna_seq, char stop, char *prot)
       {
          int a, l;
          char *buf;

          l=strlen (dna_seq);
          if ( prot==NULL)prot=vcalloc ( l+2, sizeof (char));
           
           buf=vcalloc (l+4, sizeof (char));
           sprintf (buf, "%s", dna_seq);
           lower_string ( buf);
           for ( a=0; a< l; a++)buf[a]=(buf[a]=='t')?'u':buf[a];
           
           for (a=0; a< l; a++)
               prot[a]=translate_dna_codon (buf+a, stop);
           vfree (buf);
           prot[a]='\0';

           return prot;
       }
char * translate_dna_seq ( char *dna_seq, int frame, char stop, char *prot)
       {
         //frame: 1->3
           int a, b, l;
           char *buf;

           l=strlen (dna_seq);
           if ( prot==NULL)prot=vcalloc ( l, sizeof (char));
           frame--;
           buf=vcalloc (l+4, sizeof (char));
           sprintf (buf, "%s", dna_seq);
           lower_string ( buf);
           for ( a=0; a< l; a++)buf[a]=(buf[a]=='t')?'u':buf[a];
           
           
           for ( b=0,a=0+frame; a< l; a+=3,b++)
             {

               prot[b]=translate_dna_codon (buf+a, stop);
             }
           vfree (buf);
           prot[b]='\0';
           upper_string (buf);
           return prot;
       }
char * back_translate_dna_codon ( char aa, int deterministic)
        {
        static char *r;
        int choice;
        
        vsrand(0);
        if ( r==NULL)r=vcalloc (4, sizeof (char));
        
        if (!is_gap(aa))aa=tolower(aa);
        
        if (is_gap(aa))sprintf (r, "---");
        else if ( aa>=0 && aa<=9)
          {
            sprintf (r, "%d%d%d", aa, aa,aa);
          }
        else if ( aa>='0' && aa<='9')
          {
             sprintf (r, "%c%c%c", aa, aa,aa);
          }
        else if ( aa=='a')
          {
            choice=(deterministic)?0:rand()%4;
            if      ( choice==0)sprintf (r, "gca");
            else if ( choice==1)sprintf (r, "gcg");
            else if ( choice==2)sprintf (r, "gcc");
            else if ( choice==3)sprintf (r, "gct");
          }
        else if ( aa=='c')
          {
           choice=(deterministic)?0:rand()%2;
            if      ( choice==0)sprintf (r, "tgc");
            else if ( choice==1)sprintf (r, "tgt");
          } 
        else if ( aa=='d')
          {
          choice=(deterministic)?0:rand()%2;
          if ( choice==0)sprintf (r, "gac");
          else if ( choice==1)sprintf (r, "gat");
          }
        
        else if ( aa=='e')
          {
            choice=(deterministic)?0:rand()%2;
            if ( choice==0)sprintf (r, "gaa");
            else sprintf (r, "gag");
          }
        else if ( aa=='f')
          {
            choice=(deterministic)?0:rand()%2;
            if ( choice==0)sprintf (r, "ttc");
            else sprintf (r, "ttt");
          }
        else if ( aa=='g')
          {
            choice=(deterministic)?0:rand()%4;
            if  ( choice==0)     sprintf (r, "gga");
            else if ( choice==1) sprintf (r, "ggg");
            else if ( choice==2) sprintf (r, "ggc");
            else if ( choice==3) sprintf (r, "ggt");
          }     
        else if ( aa=='h')
          {
            choice =rand()%2;
            if ( choice==0)sprintf (r, "cac");
            else sprintf (r, "cat");
          }
        else if ( aa=='i')
          {
            choice=(deterministic)?0:rand()%3;
            if  ( choice==0)     sprintf (r, "ata");
            else if ( choice==1) sprintf (r, "atc");
            else if ( choice==2) sprintf (r, "att");
          }     
        else if ( aa=='k')
          {
            choice=(deterministic)?0:rand()%2;
            if  ( choice==0)     sprintf (r, "aaa");
            else if ( choice==1) sprintf (r, "aag");
            
          }
        else if ( aa=='l')
          {
            choice=(deterministic)?0:rand()%6;
            if  ( choice==0)     sprintf (r, "cta");
            else if ( choice==1) sprintf (r, "ctg");
            else if ( choice==2) sprintf (r, "ctc");
            else if ( choice==3) sprintf (r, "ctt");
            else if ( choice==4) sprintf (r, "tta");
            else if ( choice==5) sprintf (r, "ttg");        
          }     
        else if ( aa=='m')sprintf ( r, "atg");
        else if ( aa=='n')
          {
            choice=(deterministic)?0:rand()%2;
            if  ( choice==0)     sprintf (r, "aac");
            else if ( choice==1) sprintf (r, "aat");
          }     
        else if ( aa=='p')
          {
            choice=(deterministic)?0:rand()%4;
            if  ( choice==0)     sprintf (r, "cca");
            else if ( choice==1) sprintf (r, "ccg");
            else if ( choice==2) sprintf (r, "ccc");
            else if ( choice==3) sprintf (r, "cct");
          }     
        else if ( aa=='q')
          {
            choice=(deterministic)?0:rand()%2;
            if  ( choice==0)     sprintf (r, "caa");
            else if ( choice==1) sprintf (r, "cag");
          }
        else if ( aa=='r')
          {
            choice=(deterministic)?0:rand()%6;
            if  ( choice==0)     sprintf (r, "cga");
            else if ( choice==1) sprintf (r, "cgg");
            else if ( choice==2) sprintf (r, "cgc");
            else if ( choice==3) sprintf (r, "cgt");
            else if ( choice==4) sprintf (r, "aga");
            else if ( choice==5) sprintf (r, "agg");
            
          }
        else if ( aa=='s')
          {
            choice=(deterministic)?0:rand()%6;
            if  ( choice==0)     sprintf (r, "tca");
            else if ( choice==1) sprintf (r, "tcg");
            else if ( choice==2) sprintf (r, "tcc");
            else if ( choice==3) sprintf (r, "tct");
            else if ( choice==4) sprintf (r, "agt");
            else if ( choice==5) sprintf (r, "agc");
            
          }
        else if ( aa=='t')
          {
            choice=(deterministic)?0:rand()%4;
            if  ( choice==0)     sprintf (r, "aca");
            else if ( choice==1) sprintf (r, "acg");
            else if ( choice==2) sprintf (r, "acc");
            else if ( choice==3) sprintf (r, "act");
          }
        else if ( aa=='v')
          {
            choice=(deterministic)?0:rand()%4;
            if  ( choice==0)     sprintf (r, "gta");
            else if ( choice==1) sprintf (r, "gtg");
            else if ( choice==2) sprintf (r, "gtc");
            else if ( choice==3) sprintf (r, "gtt");
          }
        else if ( aa=='w')
          {
            sprintf (r, "tgg");
          }
        else if ( aa=='y')
          {
             choice=(deterministic)?0:rand()%2;
            if  ( choice==0)     sprintf (r, "tac");
            else if ( choice==1) sprintf (r, "tat");
          }
        else
          {
            sprintf (r, "nnn");
          }
        return r;
                
        }
int translate_dna_codon ( char *sequence, char stop)
        {
        char seq[4];
        int b;
        int upper;
        int ret;
        
        if ( strlen (sequence)<1) return 'n';
        upper=isupper (sequence[0])?1:0;
        
        if ( (b=strlen (sequence))<3)
          ret='x';
        else
          {
            seq[0]=tolower(sequence[0]);
            seq[1]=tolower(sequence[1]); 
            seq[2]=tolower(sequence[2]);
            seq[3]='\0';
            
            seq[0]=(seq[0]=='u')?'t':seq[0];
            seq[1]=(seq[1]=='u')?'t':seq[1];
            seq[2]=(seq[2]=='u')?'t':seq[2];
            if ( strm5(seq, "gca", "gcg", "gcc", "gct","gcn"))ret='a';
            else if ( strm2(seq, "tgc","tgt"))ret='c';
            else if ( strm2(seq, "gac","gat"))ret='d';
            else if ( strm2(seq, "gaa","gag"))ret='e';
            else if ( strm2(seq, "ttc","ttt"))ret='f';
            else if ( strm5(seq, "gga","ggg","ggc", "ggt", "ggn"))ret='g';
            else if ( strm2(seq, "cac","cat"))ret='h';
            else if ( strm3(seq, "ata","atc","att"))ret='i';
            else if ( strm2(seq, "aaa","aag"))ret= 'k';
            else if ( strm6(seq, "cta","ctg","ctc", "ctt", "tta", "ttg"))ret='l';
            else if ( strm (seq, "ctn"))ret='l';
            else if ( strm (seq, "atg"))ret='m';
            else if ( strm2(seq, "aac","aat"))ret= 'n';
            else if ( strm5(seq, "cca","ccg","ccc", "cct","ccn"))ret='p';
            else if ( strm2(seq, "cag","caa"))ret='q';
            else if ( strm6(seq, "cga","cgg","cgc", "cgt","aga","agg"))ret='r';
            else if ( strm (seq, "cgn"))ret= 'r';
            else if ( strm6(seq, "tca","tcg","tcc", "tct","agc","agt"))ret='s';
            else if ( strm (seq, "ccn"))ret='s';
            else if ( strm5(seq, "aca","acg","acc", "act", "acn"))ret='t';
            else if ( strm5(seq, "gta","gtg","gtc", "gtt", "gtn"))ret='v';
            else if ( strm (seq, "tgg"))ret='w';
            else if ( strm2(seq, "tac","tat"))ret='y';
            else if ( strm3(seq, "tag","taa","tga"))ret=stop;
            else ret='x';
            
            ret= (upper)?toupper(ret):ret;
          }
        return ret;
        }

int extend_seqaln (Sequence *S, Alignment *A)
{
  char **s;
  int n,a;
  if (S){s=S->seq;n=S->nseq;}
  else if (A){s=A->seq_al;n=A->nseq;}
  else return 0;
  
  for (a=0; a<n;a++){extend_seq(s[a]);}
  return 1;
}
int unextend_seqaln (Sequence *S, Alignment *A)
{
  char **s;
  int n, a;
  if (S){s=S->seq;n=S->nseq;}
  else if (A){s=A->seq_al;n=A->nseq;}
  else return 0;
  
  for (a=0; a<n;a++){unextend_seq(s[a]);}
  return 1;
}
    

char *extend_seq (char *seq)
{
  char *buf, *ebuf;
  int l, lb, a, b, upper,v;
  char r1, r2;
  
  l=strlen (seq);
  buf =vcalloc ( l+1, sizeof (char));
  ebuf=vcalloc ( l+1, sizeof (char));
  sprintf (  buf, "%s", seq);
  sprintf ( ebuf, "%s", seq);
  
  ungap ( buf);
  ungap (ebuf);
  lb=strlen (buf);
  
  for (a=0; a<lb-1; a++)
    {
      r1=buf[a];
      r2=buf[a+1];
      
      upper=(isupper(r1))?1:0;
      r1=tolower(r1);
      r2=tolower(r2);
    
      r1=(r1=='u')?'t':r1;
      r2=(r2=='u')?'t':r2;
            
      if (r1=='x' || r1=='n')v='x';
      else if (r2=='n' || r2=='x')v=r1;
      
      else if (r1=='a' && r2=='a')v='d';
      else if (r1=='a' && r2=='c')v='e';
      else if (r1=='a' && r2=='g')v='f';
      else if (r1=='a' && r2=='t')v='h';
      
      else if (r1=='c' && r2=='a')v='i';
      else if (r1=='c' && r2=='c')v='k';
      else if (r1=='c' && r2=='g')v='l';
      else if (r1=='c' && r2=='t')v='m';
      
      else if (r1=='g' && r2=='a')v='n';
      else if (r1=='g' && r2=='c')v='p';
      else if (r1=='g' && r2=='g')v='q';
      else if (r1=='g' && r2=='t')v='r';
      
      else if (r1=='t' && r2=='a')v='s';
      else if (r1=='t' && r2=='c')v='v';
      else if (r1=='t' && r2=='g')v='w';
      else if (r1=='t' && r2=='t')v='y';
      else
        {
          v='j';
        }
      ebuf[a]=(upper)?toupper(v):v;
    }
  
  for (b=0,a=0; a<l; a++)
    {
      if ( !is_gap(seq[a]))seq[a]=ebuf[b++];
    }
  vfree (ebuf);
  vfree (buf);
  return seq;
}
char *unextend_seq (char *seq)
{
  char *buf, *ebuf;
  int l, lb, a, b, upper,v;
  char r1, r2;
  
  l=strlen (seq);
  buf =vcalloc ( l+1, sizeof (char));
  ebuf=vcalloc ( l+1, sizeof (char));
  sprintf (  buf, "%s", seq);
  sprintf ( ebuf, "%s", seq);
  
  ungap ( buf);
  ungap (ebuf);
  lb=strlen (buf);
  
  for (a=0; a<lb-1; a++)
    {
      r1=buf[a];
      upper=(isupper(r1))?1:0;
      r1=tolower(r1);
      r1=(r1=='u')?'t':r1;
      
      if (r1=='x')v='n';
      else if (r1=='d' || r1=='e' || r1 == 'f' || r1 == 'h')v='a';
      else if (r1=='i' || r1=='k' || r1 == 'l' || r1 == 'm')v='c';
      else if (r1=='n' || r1=='p' || r1 == 'q' || r1 == 'r')v='g';
      else if (r1=='s' || r1=='v' || r1 == 'w' || r1 == 'y')v='t';
      else v='j';
            
      ebuf[a]=(upper)?toupper(v):v;
    }
  
  for (b=0,a=0; a<l; a++)
    {
      if ( !is_gap(seq[a]))seq[a]=ebuf[b++];
    }
  vfree (ebuf);
  vfree (buf);
  return seq;
}

  

Alignment * mutate_aln ( Alignment *A, char *r)
{
  int a, b, c, mut,type, ratio;
  char alp[30];
  int alp_size;
  Sequence *S;
  Alignment*B;
  int n_mut, tot;

  vsrand(0);
  if ( r[0]=='\0')ratio=0.01*RAND_MAX;
  else ratio=atof(r)*RAND_MAX;

  S=aln2seq(A);
  S=get_sequence_type(S);
  


  if ( strm(S->type, "DNA") ||  strm(S->type, "RNA"))sprintf (alp, "AGCT");
  else if (  strm(S->type, "PROTEIN"))sprintf (alp, "ACDEFGHIKLMNPQRSTVWY");

  alp_size=strlen(alp);

  B=copy_aln (A,NULL);
  B=realloc_aln(B, B->len_aln*2+1);

  for ( a=0, b=0; a< A->len_aln; a++, b+=2)
    {
      for ( c=0; c< A->nseq; c++)
        {
          B->seq_al[c][b]=tolower(A->seq_al[c][a]);
          B->seq_al[c][b+1]='~';
        }      
    }

  for ( c=0; c< A->nseq; c++)B->seq_al[c][b]='\0';
  B->len_aln=A->len_aln*2;
  

 
  tot=n_mut=0;
  for (a=0; a< B->len_aln; a+=2)
    for ( b=0; b<B->nseq; b++)
      {
        if ( is_gap(B->seq_al[b][a]))continue;
        mut=((rand()%RAND_MAX)>ratio)?0:1;
        tot++;
        n_mut+=mut;

        if (mut)
          {
            type=rand()%2;
            if (type==0)/*deletion*/
              {
                B->seq_al[b][a]='.';
              }
            else if ( type==1)
              {
                B->seq_al[b][a+1]=alp[rand()%alp_size];
              }
            else if (type==2)
              {
                B->seq_al[b][a]=alp[rand()%alp_size];
              }
            
          }
      }
  ungap_aln (B);
  
  
  free_sequence (S, S->nseq);
  free_aln (A);
  return B;
  
}

char* mutate_amino_acid ( char aa, char *mode)

     {
         int a, b, c, d;
         char nucleotide[]="agct";
         char amino_acid[]="acdefghiklmnpqrstvwy";
         static char **triplet;
         static char **cw_col;
         int ng_cw_col;
         static int **amino_acid_list;
         static int *lu;
         char a1, a2;
         char *mat;
         
         aa=tolower(aa);
         declare_name(mat);
         if ( !mode)sprintf (mat, "clustalw_col");
         else sprintf (mat, "%s", mode);
         if (!triplet)
            {
                triplet=declare_char ( 64, 4);
                for (d=0, a=0; a< 4;a++)
                    for ( b=0; b< 4; b++)
                        for ( c=0; c< 4; c++, d++)
                            {
                                triplet[d][0]=nucleotide[a];
                                triplet[d][1]=nucleotide[b];
                                triplet[d][2]=nucleotide[c];
                            }
            }
         if ( !cw_col)cw_col=make_group_aa ( &ng_cw_col,mat);
         if ( !amino_acid_list)
            {
                amino_acid_list=declare_int ( 20, 65);
                for ( a=0; a< 20; a++)
                    for ( b=0; b< 64; b++)
                        {
                            a1=translate_dna_codon ( triplet[b], 'x');
                            a2=amino_acid[a];
                            for ( d=0; d< ng_cw_col; d++)
                                if ( is_in_set ( a1, cw_col[d]) && is_in_set ( a2, cw_col[d]))
                                   {
                                       amino_acid_list[a][++amino_acid_list[a][0]]=b;
                                   }
                        }
                lu=vcalloc ( 26, sizeof (int));
                for ( a=0; a<20; a++)
                    {
                        lu[amino_acid[a]-'a']=a;
                    }
                /*
                for ( a=0; a< 20; a++)
                    {
                        fprintf ( stderr, "\n%c", amino_acid[a]);
                        for ( b=1; b<=amino_acid_list[a][0]; b++)
                            fprintf ( stderr, "\n\t%s %c", triplet[amino_acid_list[a][b]], translate_dna_codon (triplet[amino_acid_list[a][b]], 'x'));
                    }
                */                  
            }
        
         return triplet [addrand((unsigned long)amino_acid_list[lu[aa-'a']][0])+1];
     }                  
                                 
/**************************************************************************************************/
/********************************                      ********************************************/
/********************************    PROCESSING        ********************************************/
/********************************                      ********************************************/


         
void modify_data  (Sequence_data_struc *D1in, Sequence_data_struc *D2in, Sequence_data_struc *DSTin, char **action_list,int n_actions, Action_data_struc *RAD)
     {
       Sequence  *COOR=NULL, *NS=NULL,*BUFS=NULL, *OUT_S=NULL;
       Constraint_list *CL;
       char *s;
       int value,upper_value, lower_value, start, end, a, b,c;
       int *count_table=NULL;
       char *action;
       Sequence_data_struc *D1; 
       Sequence_data_struc *D2;
       Sequence_data_struc *DST;
       int s1, s2, r1, r2;
       static int clean_flag;
       Alignment *BUF;
       
       /*Switches*/

       action=action_list[0];

       if (action[0]=='2')
         {
           
           D1=D2in;
           D2=D1in;
           DST=DSTin;
           action++;
         }
       else if ( action[0]=='1')
         {
           D1=D1in;
           D2=D2in;
           DST=DSTin;
           action++;
         }
       else if ( action[0]=='3')
         {
           D1=DSTin;
           D2=D1in;
           DST=DSTin;
           action++;
         }
       else
         {
           D1=D1in;
           D2=D2in;
           DST=DSTin;
         }
       if (!D1->A)D1->A=copy_aln (D1in->A, NULL); 
         
       if (  strm(action, "seqnos"))
         {
          (D1->A)->output_res_num=1;
         } 
       else if ( strm (action,"aln2bootstrap"))
         {
           (D1->A)=aln2bootstrap (D1->A, ATOI_ACTION (1));
           D1->S=aln2seq (D1->A);
         }
       else if ( strm (action,"aln2sample"))
         {
           (D1->A)=aln2sample (D1->A, ATOI_ACTION (1));
           D1->S=aln2seq (D1->A);
         }
       else if ( strm (action,"aln2random_aln"))
         {
           (D1->A)=aln2random_aln (D1->A, ACTION (1));
           D1->S=aln2seq (D1->A);
         }
       else if ( strm (action, "or_scan"))
         {
           HERE ("OR SCAN");
           D1->A=or_scan(D1->A, D2->A, ACTION(1));
           D1->S=aln2seq (D1->A);
         }
       else if ( strm (action, "or_sar"))
         {
           D1->A=or_sar(D1->A, D2->A, ACTION(1), PRINT);
           D1->S=aln2seq (D1->A);
         }
       else if ( strm ( action, "sar2subsar"))
         {
           /*in->sequences
             in2->sar data
           */
           Alignment *subA, *subS;
           
           if ( n_actions==1)
             {
               fprintf ( stderr, "\nin=aln, in2=sar sar2subsar [filter value compound1 compound2...] | [jack1] | [file]\n");
               myexit (EXIT_FAILURE);
             }
           
           sarset2subsarset ( D1->A, D2->A, &subA, &subS, main_read_aln (action_list[2], NULL));
           D1->A=subA;D2->A=subS;
         }
       else if ( strm (action, "display_sar"))
         {
           D1->A=display_sar (D1->A, D2->A, action_list[1]);
         }
       else if ( strm ( action, "sar2simpred"))
         {
           /*in->sequences
             in2->sar data
           */
           sar2simpred ( D1->A, D2->A, action_list[1], action_list[2], atoi(action_list[3]), atoi (action_list[4]));
         }
       else if ( strm ( action, "sar2simpred2"))
         {
           /*in->sequences
             in2->sar data
           */
           if ( n_actions!=5)
             {
               fprintf ( stderr, "\nERROR: +sar2simpred2 seqnamesfile posfile compound limit");
               myexit (EXIT_FAILURE);
             }
           sar2simpred2 ( D1->A, D2->A, action_list[1], action_list[2], action_list[3], atoi (action_list[4]));
         }
        else if ( strm ( action, "sar_analyze"))
         {
           /*in->sequences
             in2->sar data
           */
           sar_analyze ( D1->A, D2->A,action_list[1]);
         }
        else if ( strm ( action, "simple_sar_predict"))
          {
            //displays each column with ist score;
            simple_sar_predict (D1->A, D2->A,ACTION(1));
            myexit (EXIT_SUCCESS);
          }
        else if ( strm ( action, "display_sar_analyze"))
          {
            //displays each column with ist score;
            display_simple_sar_analyze_col (D1->A, D2->A,ACTION(1));
            myexit (EXIT_SUCCESS);
          }
       else if ( strm ( action, "display_sar_analyze_pc"))
          {
            //displays each column with ist score;
            display_simple_sar_analyze_pair_col (D1->A, D2->A,ACTION(1));
            myexit (EXIT_SUCCESS);
          }
       else if ( strm ( action, "weight2sar"))
         {
           /*in->sequences
             in2->sar data
           */
           if ( n_actions!=3)
             {
               fprintf ( stderr, "\nERROR: +weight2sar <weight_file> <limit>");
               myexit (EXIT_FAILURE);
             }
           D1->A=weight2sar ( D1->A,D2->A, action_list[1], atoi(action_list[2]));
           
         }
        else if ( strm ( action, "sar_weight"))
         {
           /*in->sequences
             in2->sar data
           */
           if ( n_actions!=3)
             {
               fprintf ( stderr, "\nERROR: +sar_weight <sar_analyze> <compound>");
               myexit (EXIT_FAILURE);
             }
           D1->A=aln2weighted_sar_score ( D1->A,D2->A, action_list[1], action_list[2]);
           D1->S=aln2seq ( D1->A);
         }
       
       else if ( strm (action, "name2unique_name"))
         {
           char *tmp1, *tmp2;
           char command[1000];
           tmp1=vtmpnam (NULL); tmp2=vtmpnam (NULL);
           
           output_fasta_aln (tmp1,D1->A);
           free_aln (D1->A);free_sequence (D1->S, -1);
           sprintf ( command, "fasta_aln2fasta_aln_unique_name.pl %s >%s", tmp1, tmp2);
           my_system ( command);
           D1->S=get_fasta_sequence ( tmp2, NULL);
           D1->A=seq2aln (D1->S,NULL, 1);
         }
       else if ( strm (action, "rm_tag") || strm (action, "rm_template"))
         {

           char **temp_name=NULL,**temp_list=NULL, temp_nseq=0;
           int z;
                        
           if ( D1 && D1->A){temp_name=(D1->A)->name;temp_nseq=(D1->A)->nseq;}
           else if ( D1 && D1->S){temp_name=(D1->S)->name;temp_nseq=(D1->S)->nseq;}
           temp_list=rm_name_tag (temp_name,temp_nseq, NULL);
           if ( n_actions>1 && strm (action_list[1], "template"))
              {
              
               for ( z=0; z<temp_nseq; z++)
                {
                if (temp_list[z][0])
                        {fprintf (stdout, "%s\n", temp_list[z]);}
                }
                myexit (EXIT_SUCCESS);
              } 
         }
       else if (strm (action, "add_template") || strm (action, "swap_header"))
         {
           D1->S=seq2template_seq (D1->S, action_list[1], NULL);
            D1->A=seq2aln(D1->S, NULL, 1);
         }
       else if ( strm ( action, "seq2year"))
         {
           D1->S=seq2year (D1->S, (n_actions>1)?atoi(action_list[1]):1);
           D1->A=seq2aln(D1->S, NULL, 1);
         }
       else if ( strm (action, "swap_lib_header"))
         {
           Sequence *S;
           S=main_read_seq (action_list[1]);
           (D1->CL)->S=S;
           
         }
       else if ( strm (action, "weight_lib"))
         {
           int l;
           int w;
           w=atoi (action_list[1]);
           if ( D1->CL)
             {
               int s1, s2,r1,r2;
               Sequence *S=(D1->CL)->S;
               int ***r=(D1->CL)->residue_index;
               
               for (s1=0; s1<S->nseq; s1++)
                 for (r1=1; r1<=S->len[s1]; r1++)
                   for (b=1; b<r[s1][r1][0]; b+=3)
                     {
                       r[s1][r1][b+2]=w;
                     }
             }
         }
       else if ( strm (action, "struc2nb"))
         {
           int c;
           for ( c=0; c< (D1->S)->nseq; c++)
             {
               struclist2nb ((D1->S)->name[c],(D1->S)->seq[c], (D1->S)->seq_comment[c], atof(action_list[1]),ACTION(2),ACTION(3) );
             }
           myexit (EXIT_SUCCESS);
         }
       
     
      
       else if ( strm(action, "seq2contacts"))
         {
           int z;
           D1->S=swap_header (D1->S, D2->S); 
           for ( z=0; z< (D1->S)->nseq; z++)sprintf ( (D1->A)->name[z], "%s", (D1->S)->name[z]);
           DST->S=seq2contacts (D1->S, atof (action_list[1]));
           DST->A=copy_aln (D1->A, NULL);
           thread_seq_struc2aln ( DST->A,DST->S);
           for (z=0; z< (D1->S)->nseq; z++)
           (DST->A)->S=D1->S;
           
         }
       else if ( strm(action, "struc2contacts"))
         {
           char *seq;
           if ( atof (action_list[3])>0)
             {
               seq=map_contacts  (action_list[1], action_list[2], atof (action_list[3]));
               fprintf ( stderr, "\n>%s %s\n%s",action_list[1], action_list[2],seq);
             }
           else 
             print_contacts  (action_list[1], action_list[2], atof (action_list[3]));
           
           myexit (EXIT_SUCCESS);
         }
       else if ( strm(action, "treelist_prune")|| strm(action, "prune_treelist"))
         {
           Sequence *TS;
           if (D2 && D2->S)TS=D2->S;
           else TS=treelist2sub_seq((D1->S),ATOI_ACTION(1));
           treelist2prune_treelist ( D1->S,TS, NULL);
           D1->A=seq2aln (D1->S, NULL, NO_PAD);
         }
       else if ( strm (action, "tree2unresolved_nodes"))
         {
           int ns;
           int *l;
           ns=tree2nseq (D1->T);
           l=vcalloc (ns, sizeof (int));
           tree2nnode_unresolved (D1->T, l);
           for ( a=0; a<ns; a++)if (l[a])fprintf ( stdout, "SIZE: %d COUNT: %d\n", a, l[a]); 
           vfree (l);
           myexit (EXIT_SUCCESS);
         }
       else if ( strm(action, "tree_prune") || strm(action, "prune_tree"))
         {
           D1->T=main_prune_tree ( D1->T, D2->S);
         }
       else if ( strm ( action, "tree2seq"))
         {
           D1->S=tree2seq(D1->T, NULL);
           D1->A=seq2aln (D1->S, D1->A, 1);
           (D1->A)->len_aln=1;
           for ( a=0; a< (D1->A)->nseq; a++)sprintf ( (D1->A)->seq_al[a], "sequence");
         }
       else if ( strm (action, "seq2dpatree"))
         {
           D1->T= seq2dpa_tree(D1->S,"ktup");
         }
       else if ( strm (action, "tree2dpatree"))
         {
           D1->T= tree2dpa_tree(D1->T,(D2 && D2->A)?D2->A:D1->A, (n_actions==1)?"idmat":action_list[1]);
         }
       else if ( strm (action, "tree2group"))
         {
           vfclose (tree2group (D1->T, (tree2seq(D1->T,NULL)), atoi(action_list[1]), atoi(action_list[2]),(n_actions==4)?action_list[3]:NULL, stdout));    
           myexit (EXIT_SUCCESS);
         }
       else if ( strm(action, "unroot"))
         {
           D1->T=unroot_tree(D1->T);
         }
     
       
       else if ( strm(action, "treelist2group")|| strm(action, "treelist2groups") )
         {
           Sequence *TS;
           
           if (D2 && D2->S)TS=D2->S;
           else TS=treelist2seq((D1->S));
           treelist2groups (D1->S, TS, ACTION(1), stdout);
           myexit (EXIT_SUCCESS);
           
           //      treelist2groups (D1->S,(D2)?D2->S:NULL, ACTION(1), stdout );
           //exit (EXIT_SUCCESS);
         }
       else if ( strm(action, "splits2tree"))
          {
          
           D1->T=split2tree ((D2)?D2->T:NULL,D1->S, ACTION(1));
           
         }
       else if ( strm(action, "count_splits"))
         {
          
           count_splits ((D2)?D2->T:NULL,D1->S, ACTION(1));
           myexit (EXIT_SUCCESS);
         }
        else if ( strm(action, "count_groups"))
         {
           count_tree_groups (D1->S, ACTION(1));
         }
       else if ( strm (action, "tree2dist"))
         {
           int ta, tb, ***td;
           Sequence *TS;
           
           TS=(D2)?D2->S:NULL;
           td=tree2dist (D1->T,TS, NULL);
           if (!TS)TS=tree2seq(D1->T, NULL);
           for (ta=0; ta<TS->nseq; ta++)
             {
               fprintf ( stdout, "%-15s ",TS->name[ta]);
               for ( tb=0; tb<TS->nseq; tb++)
                 {
                   int n=0;
                   if ( ACTION(1) && strm (ACTION(1), "length"))n=1;
                   
                   fprintf (stdout, " %4d", td [n][ta][tb]);
                 }
               fprintf ( stdout, "\n");
             }
           myexit (EXIT_SUCCESS);
         }
       else if ( strm (action, "treelist2lti"))
         {
           Sequence *TS;
           if (D2 && D2->S)TS=D2->S;
           else TS=treelist2sub_seq((D1->S),ATOI_ACTION(2));
           treelist2lti (D1->S,TS, (int)ATOI_ACTION(1), stdout );
           myexit (0);
         }       
       else if ( strm (action,"treelist2frame"))
         {
           Sequence *TS;
           if (D2 && D2->S)TS=D2->S;
           else TS=treelist2sub_seq((D1->S),ATOI_ACTION(1));
           treelist2frame (D1->S, TS);
           myexit (EXIT_SUCCESS);
         }
       
       else if ( strm (action, "treelist2seq"))
         {
           D1->S=treelist2sub_seq (D1->S,ATOI_ACTION(1));
           D1->A=seq2aln(D1->S, NULL, 1);
         }       
       else if ( strm (action, "treelist2leafgroup"))
         {
           treelist2leafgroup (D1->S, (D2)?D2->S:NULL, ACTION(1));
           myexit (0);
         }       
       else if ( strm(action, "treelist2splits"))
         {
           if (D1->T)D1->S=add_file2file_list ((D1->T)->file, NULL);
           treelist2splits (D1->S, (D2)?D2->S:NULL);
         }
      
       else if ( strm(action, "treelist2dmat"))
         {
           treelist2dmat (D1->S);
         }
       else if ( strm(action, "tree2node") )
         {
           print_node_list ( D1->T,(DST)?DST->S:NULL);
           myexit (EXIT_SUCCESS);
         }
       else if ( strm(action, "tree_cmp_list") )
         {
           D1->T=main_compare_trees_list ( D1->T, D2->S, stdout);         
         }
       else if ( strm(action, "tree_cmp") || strm (action, "tree_compare"))
         {
           D1->T=main_compare_trees ( D1->T, D2->T, stdout);       
         }
       else if ( strm (action, "tree_scan"))
         {
           D1->T=tree_scan (D1->A, D2->T, ACTION(1), ACTION(2));
         }
       else if ( strm (action, "split_cmp"))
         {
           main_compare_splits (D1->T, D2->T, ACTION(1), stdout);
         }
       
       else if ( strm(action, "node_sort"))
         {
           node_sort ( action_list[1], D1->T);
           myexit (EXIT_SUCCESS);
         }
       
       else if ( strm ( action, "avg_bootstrap"))
         {
           display_avg_bootstrap (D1->T);
           myexit (EXIT_SUCCESS);
         }
       else if ( strm (action, "genepred2acc"))
         {
           //D2->S=reference
           //D1->S=prediction
           vfree (display_accuracy (genepred_seq2accuracy_counts (D2->S, D1->S, NULL),stderr));
           myexit (EXIT_SUCCESS);
         }
       else if ( strm (action, "tree_cog_cmp"))
         {
           main_compare_cog_tree (D1->T,action_list[1]);
           myexit (EXIT_SUCCESS);
         }
       else if ( strm (action, "tree_aln_cmp"))
         {
           main_compare_aln_tree (D1->T, D2->A, stdout);
           myexit (EXIT_SUCCESS);
         }
       else if ( strm(action, "change_bootstrap"))
         {
           D1->T=reset_boot_tree ( D1->T, (n_actions>=2)?atoi(action_list[1]):0);
         }
       else if ( strm(action, "change_distances"))
         {
           D1->T=reset_dist_tree ( D1->T, (n_actions>=2)?atof(action_list[1]):0.00);
         }
       
       else if ( strm(action, "aln2tree"))
         {
           D1->T=tree_compute (D1->A, n_actions-1, action_list+1);
         }
       else if ( strm(action, "similarities2tree"))
         {
           D1->T=similarities_file2tree (ACTION(1));
         }
       
       else if (  strm(action, "original_seqnos"))
         {
          (D1->A)->output_res_num=2;
         }
       
       else if ( strm (action, "aln2pred"))
         {
           aln2pred (D1->A, D2->A, ACTION (1));
           myexit (EXIT_SUCCESS);
         }
       else if ( strm(action, "evaluate"))
         {
           Alignment *A;


           DST->A=copy_aln (D1->A, NULL);
           DST->S=aln2seq(DST->A);
           if (n_actions>1 && strm (  action_list[1], "categories"))
             {
               CL=declare_constraint_list ( DST->S,NULL, NULL, 0,NULL, read_matrice("pam250mt"));
               DST->A=  main_coffee_evaluate_output(DST->A, CL, "categories");
             }
           else if (n_actions>1 && strm (  action_list[1], "sar"))
             {
               CL=declare_constraint_list ( DST->S,NULL, NULL, 0,NULL, read_matrice("pam250mt"));
               DST->A=  main_coffee_evaluate_output(DST->A, CL, "sar");
             }
           else if (n_actions>1 && strstr (  action_list[1], "boxshade"))
             {
               char color_mode[1000];
               sprintf (color_mode,"boxshade_%d", atoi(ACTION2(2,"30")));
               CL=declare_constraint_list ( DST->S,NULL, NULL, 0,NULL, read_matrice("pam250mt"));
               DST->A=  main_coffee_evaluate_output(DST->A, CL, color_mode);
             }
           else
             {
               CL=declare_constraint_list ( DST->S,NULL, NULL, 0,NULL, read_matrice((n_actions==1)?"pam250mt":action_list[1]));
               DST->A=  main_coffee_evaluate_output(DST->A, CL, "matrix");
             }
           
           DST->S=aln2seq ( DST->A);
           
           A=D1->A;
           
           sprintf ( A->name[A->nseq], "cons");
           sprintf ( A->seq_al[A->nseq], "%s", aln2cons_seq_mat (A, "idmat"));
          
         }
       else if ( strm (action, "sp_evaluate"))
         {
           fprintf ( stdout, "SP Score: %.2f", sum_pair ((DST && DST->A)?DST->A:D1->A,ACTION(1),atoi(ACTION2(2,"0")),atoi(ACTION2(3,"0"))));
           myexit (EXIT_SUCCESS);
         }
       else if ( strm (action, "lat_evaluate"))
         {
           float score;
           score=lat_sum_pair ( D1->A, action_list[1]);
           fprintf ( stdout, "\nLAT_SCORE: %.2f", score);
           myexit (EXIT_SUCCESS);
           
         }
       else if ( strm (action, "add_scale"))
         {
           D1->A=aln2scale (D1->A, ACTION(1));
         }
       else if ( strm (action, "RNAfold_cmp"))
         {
           D1->A=compare_RNA_fold (D1->A, D2->A);
         }
       else if ( strm (action, "aln2alifold"))
         {
           D1->A=aln2alifold (D1->A);
           D1->S=aln2seq ( D1->A);
         }
                 

       else if ( strm (action, "add_alifold"))
         {
           D1->A=add_alifold2aln (D1->A, (D2)?D2->A:NULL);
         
         }
       else if ( strm (action, "alifold2analyze"))
         {
           D1->A=alifold2analyze (D1->A, (D2)?D2->A:NULL, ACTION(1));
           D1->S=aln2seq(D1->A);
         }
       else if ( strm (action, "aln2conservation"))
         {
           D1->A=aln2conservation ( D1->A, ATOI_ACTION (1), ACTION (2));
           myexit (EXIT_FAILURE);
         }
       else if ( strm (action, "aln2cons"))
         {
           char *cons_seq;
           char *cons_name;
           cons_name=vcalloc (100, sizeof (char));
           sprintf(cons_name, "%s", (n_actions<=2)?"Cons":action_list[2]);
           cons_seq=aln2cons_seq_mat (D1->A, (n_actions==1)?"blosum62mt":action_list[1]);
           free_aln (D1->A);free_sequence(D1->S, -1);
           D1->S=fill_sequence_struc (1, &cons_seq, &cons_name);
           /*keep the gaps*/
           (D1->S)->len[0]=strlen (cons_seq); sprintf ( (D1->S)->seq[0], "%s", cons_seq);
           D1->A=seq2aln (D1->S, NULL, KEEP_GAP);
           vfree (cons_name);vfree (cons_seq);
         }
       else if ( strm (action, "seq2filter"))
         {
           D1->S=seq2filter ( D1->S, atoi(action_list[1]), atoi(action_list[2]));
                              
         }
       else if ( strm (action, "aln2resindex"))
         {
           //-in: aln, file: ref_seq ref_res target_seq
           //-in2 target sequences
           aln2resindex (D1->A, (D2)?D2->A:NULL, stdout);
           myexit (EXIT_SUCCESS);
         }
       else if (strm(action, "keep_name"))
         {
           RAD->keep_name=1-RAD->keep_name;
         }
        else if (strm(action, "use_consensus") ||strm(action, "use_cons") )
         {
           RAD->use_consensus=1-RAD->use_consensus;
         }
       else if ( strm(action, "ungap"))
         {
           seq2aln (D1->S, D1->A, 1);
         }
       else if ( strm2(action, "rmgap", "rm_gap"))
         {

           ungap_aln_n (D1->A, (n_actions==1)?100:atoi(action_list[1]));
           //free_sequence ( D1->S, (D1->S)->nseq);
           D1->S=aln2seq ( D1->A);
           (D1->A)->S=D1->S;
         }
       else if ( strm(action, "rmgap_col"))
         {
           D1->A=remove_gap_column ( D1->A,action_list[1]);
         }
       else if ( strm(action,"random"))
         {
           
           D1->A= make_random_aln(NULL,(n_actions==1)?1:atoi(action_list[1]),(n_actions==2)?100:atoi(action_list[2]),"acdefghiklmnpqrstvwy");
           
           D1->S=aln2seq ( D1->A);
         }
            
       else if ( strm(action, "landscape"))
          {
            
            set_landscape_msa ((n_actions==1)?0:atoi(action_list[1]));
          }
       else if ( strm(action, "clean_maln"))
          {
            if ( !DST) 
                   {
                   fprintf ( stderr,"\n[You Need an evaluation File: Change the output format][FATAL:%s]\n", PROGRAM);  
                   myexit(EXIT_FAILURE);
                   }
            (DST->A)=aln2number (DST->A);
            D1->A=clean_maln(D1->A, DST->A,(n_actions==1)?1:atoi(action_list[1]),(n_actions==1)?1:atoi(action_list[2]));   
          }
       else if ( strm (action, "extract"))
         {
           
           COOR=get_pir_sequence  (RAD->coor_file, NULL);
           D1->S=extract_sub_seq ( COOR, D1->S);
           free_aln (D1->A);
           D1->A=declare_Alignment(D1->S);
           seq2aln (D1->S, D1->A, RAD->rm_gap);
           free_sequence (COOR, COOR->nseq);
         }
       else if ( strm (action, "reorder_column"))
         {


          
               Alignment *RO1, *RO2;
               Sequence *OUT_S;
               int s;
               
               RO1=rotate_aln (D1->A,NULL);
               if (ACTION(1) && strm (ACTION(1), "tree"))
                 {
                   D1->T=tree_compute (RO1,n_actions-2, action_list+2);
                    OUT_S=tree2seq(D1->T, NULL);
                    RO1=reorder_aln(RO1, OUT_S->name, OUT_S->nseq);
                  }
               else if ( ACTION(1) && strm (ACTION(1), "random"))
                 {
                   RO1=reorder_aln ( RO1, NULL, RO1->nseq);
                 }
               
               RO2=rotate_aln (RO1, NULL);
               for (s=0; s< RO2->nseq; s++)
                 sprintf ( RO2->name[s], "%s", (D1->A)->name[s]);
               free_aln (RO1);
               free_aln (D1->A);
               D1->A=RO2;
               D1->S=aln2seq(D1->A);
         }
                               
       else if ( strm (action, "reorder"))
         {
           
           if ( n_actions==2 && strm (action_list[1], "random"))
             {
               D1->A=reorder_aln ( D1->A, NULL, (D1->A)->nseq);
             }
           else if (n_actions==2 && strm (action_list[1], "invert"))
             {
               char **nname;
               int z, y;
              
               nname=declare_char ((D1->A)->nseq, 100);
               for ( z=0,y=(D1->A)->nseq-1; z<(D1->A)->nseq; z++, y--)
                 {
                   sprintf (nname[z], "%s",(D1->A)->name[y]);
                 }

               D1->A=reorder_aln ( D1->A, nname, (D1->A)->nseq);
               free_char (nname, -1);
             }
           else if (n_actions==2 && strm (action_list[1], "scramble"))
             {
               D1->A=aln2scramble_seq(D1->A);
             }

           else if ( n_actions==2 && strm (action_list[1], "tree"))
             {

               OUT_S=tree2seq (D2->T, NULL);
               D1->A=reorder_aln(D1->A, OUT_S->name, OUT_S->nseq);
               free_sequence (D1->S,(D1->S)->nseq);
               D1->S=aln2seq (D1->A);
             }
           else
             {
               (D2->A)->S=aln2seq (D2->A);
               (D1->A)->S=aln2seq (D1->A);
               OUT_S=trim_aln_seq_name(D2->A, D1->A);
               D1->A=reorder_aln(D1->A, OUT_S->name, OUT_S->nseq);
               free_sequence (D1->S,(D1->S)->nseq);
               D1->S=aln2seq (D1->A);
             }
         }
       else if ( strm (action, "aln2replicate"))
         {
           aln2N_replicate (D1->A, ACTION(1), ACTION(2));
         }
       else if ( strm (action, "paralogous_cat"))
         {
           D1->A=orthologous_concatenate_aln (D1->A,D2->S, ACTION (1));
         }
       
       else if ( strm (action, "cat_aln"))
         {
           /*D1->A=aln_cat ( D1->A, D2 ->A);*/

           if (D2 && D2->A && !ACTION(1))
             D1->A=concatenate_aln (D1->A, D2->A, ACTION(1));
           else if (ACTION(1) && is_aln(ACTION(1)))
             {
                 Alignment *B;
                 int n=1;

                 while (ACTION(n))
                   {

                     B=main_read_aln (ACTION(n), NULL);
                     D1->A=concatenate_aln (D1->A, B, NULL);
                     n++;
                   }
                 D1->S=aln2seq(D1->A);
             }
                     
           else
             {
               Alignment *A, *B;
               
               A=main_read_aln ((D1->A)->name[0], NULL);
               
               for ( a=1; a<(D1->A)->nseq; a++)
                 {
                   B=main_read_aln ((D1->A)->name[a], NULL);
                   A=concatenate_aln (A, B, ACTION(1));
                   
                 }
               D1->A=A;
               D1->S=aln2seq(D1->A);
             }
         }
           
       else if ( strm ( action, "msalist2cat_pwaln"))
         {
           int a, b, c;
           int sim, min, max;
           
           if (n_actions!=3)
             {
               min=0;
               max=100;
             }
           else
             {
               min=atoi(action_list[1]);
               max=atoi(action_list[2]);
             }
           
           fprintf ( stdout, ">A\n");
           for (a=0;a<(D1->S)->nseq; a++)
             {
               Alignment *A;
               HERE ("process %s",  (D1->S)->name[a]);
               A=main_read_aln((D1->S)->name[a],NULL);
               for (b=0; b<A->nseq-1; b++)
                 {
                   for ( c=b+1; c<A->nseq; c++)
                     {
                       sim=get_seq_sim (A->seq_al[b], A->seq_al[c], "-", "");
                       if (sim>=min && sim<=max)fprintf (stdout, "xxx%s", A->seq_al[b]);
                     }
                 }
               free_aln (A);
             }
           fprintf ( stdout, "\n>B\n");
           for (a=0;a<(D1->S)->nseq; a++)
             {
               Alignment *A;
               HERE ("process %s",  (D1->S)->name[a]);
               A=main_read_aln((D1->S)->name[a],NULL);
               for (b=0; b<A->nseq-1; b++)
                 {
                   for ( c=b+1; c<A->nseq; c++)
                     {
                       sim=get_seq_sim (A->seq_al[b], A->seq_al[c], "-", "");
                       if (sim>=min && sim<=max)fprintf (stdout, "xxx%s", A->seq_al[c]);
                     }
                 }
               free_aln (A);
             }
           
           fprintf ( stdout, "\n");
           myexit (EXIT_SUCCESS);
         }
       
       else if ( strm (action, "collapse_tree"))
         {
           D1->T=tree2collapsed_tree (D1->T, n_actions-1, action_list+1);
         }
       else if ( strm (action, "collapse_aln"))
         {
           D1->A=aln2collapsed_aln (D1->A, n_actions-1, action_list+1);
         }
       else if ( strm (action, "extract_aln"))
         {
           D1->A=aln2sub_aln_file (D1->A, n_actions-1, action_list+1);
           myexit (EXIT_SUCCESS);
         }
      
       
      
       else if ( strm (action, "remove_aa"))
         {
           int pos,len, n;
           pos=atoi(action_list[1]);
           len=atoi(action_list[2]);
           n=atoi (action_list[3]);
           if ( atoi (action_list[4])==1)len=-len; 
           if (pos && n>1) 
             {
               fprintf ( stderr, "\nWARNING: rm_aa, position (pos) and iteration number (n) simulatneously defined. Iteration number reset to 1 [%s]\n", PROGRAM);
               n=1;
             }
           for ( a=0; a< n; a++)
             D1->A=probabilistic_rm_aa (D1->A, pos, len);
         }
       else if ( strm (action, "remove_nuc"))
         {
           int pos;
           pos=atoi(action_list[1]);
           
           if ( pos>3 || pos<1)
             printf_exit (EXIT_FAILURE, stderr, "Remove_nuc: indicate a number between 1 and 3\n");
           
           pos--;
           for ( c=0,a=0; a<(D1->A)->len_aln; a++, c++)
             {
               if (c==3)c=0;
               for (b=0; b<(D1->A)->nseq; b++)
                 {
                 if (c==pos)
                   {
                     (D1->A)->seq_al[b][a]='-';
                   }
                 }
             }
           
           D1->S=aln2seq (D1->A);
         }
       
       else if (strm ( action, "conserved_positions"))
         {
           Alignment *A;
           int  a, b, c;
           int *cache=NULL;
           

           A=D1->A;
           for ( a=0; a< A->nseq && !cache; a++)
             {
               if ( strm (action_list[1], A->name[a]))
                 {
                   cache=vcalloc ( A->len_aln+1, sizeof (int));
                   for ( c=0,b=0; b<A->len_aln; b++)
                     {
                       if ( is_gap (A->seq_al[a][b]))cache[b]=-1;
                       else cache[b]=++c;
                     }
                 }
             }

           for ( a=0; a< A->len_aln; a++)
             {
               r1=A->seq_al[0][a];
               if ( is_gap(r1))continue;
               for ( c=0,b=0; b<A->nseq; b++)
                 {
                   r2=A->seq_al[b][a];
                   c+=(r1==r2)?1:0;
                 }
               if ( (c*100)/A->nseq>=atoi(action_list[2]))
                 fprintf ( stdout, "COL: %d Res: %c %s %d\n", a+1, r1, action_list[1], cache[a]+atoi(action_list[3]));
             }
           myexit (EXIT_FAILURE);
         }
       else if (strm ( action, "extract_block") )
         {
           
           BUF=copy_aln (D1->A, NULL);
           if ( check_file_exists(action_list[1]))
             BUF=extract_aln3(BUF,action_list[1]);
           else
             BUF=extract_aln2(BUF,atoi(action_list[2]),atoi(action_list[3]),action_list[1]);
           D1->A=copy_aln (BUF,D1->A);
          
         }
       else if ( strm ( action, "extract_pos_list"))
         {
           D1->A=alnpos_list2block (D1->A, n_actions-1, action_list+1);
         }
       else if ( strm ( action, "seq2msa"))
         {
           D1->A=simple_progressive_aln ( D1->S, NULL, NULL, action_list[1]);
         }
       else if ( strm ( action, "realign_block") )
         {
           D1->A=realign_block ( D1->A, atoi (action_list[1]), atoi (action_list[2]), (n_actions==4)?action_list[3]:NULL);
         }
       else if ( strm (action, "extract_seq"))   
         {
           int is_file;
           if ( check_file_exists (action_list[1])&& format_is_fasta (action_list[1]))
             {
               is_file=1;
               BUFS=main_read_seq (action_list[1]);
               action_list=BUFS->name;
               n_actions=BUFS->nseq;           
             }
           else
             {
               is_file=0;
               action_list++;
               n_actions--;
             }
           
           for ( a=0; a< n_actions;)
             {
               s=action_list[a];
               
               if ( n_actions==1 || is_file==1)
                 {
                   start=1;
                   end=0;
                   a+=1;
                 }
               else
                 {

                   start=(strm2 (s,"#","*"))?1:(atoi(action_list[a+1]));
                   end=  (strm2 (action_list[a+2],"#","*"))?0:(atoi(action_list[a+2]));
                   a+=3;
                 }
               
               if ( strm2 (s, "#", "*"))
                 {
                   OUT_S=extract_one_seq((D1->A)->name[0],start, end, D1->A, RAD->keep_name);
                   for (b=1; b< (D1->A)->nseq; b++)
                     {
                      NS=extract_one_seq((D1->A)->name[b],start, end, D1->A, RAD->keep_name);
                      if (count_n_res_in_array(NS->seq[0], -1))
                        OUT_S=add_sequence ( NS,OUT_S, 0);
                     }
                 }
               else
                 {
                  if ( a==1)OUT_S=extract_one_seq(s,start, end, D1->A, RAD->keep_name);
                  else
                    {
                      NS=extract_one_seq(s,start, end, D1->A, RAD->keep_name); 
                      OUT_S=add_sequence ( NS,OUT_S, 0);
                    }
                 }
             }
           D1->S=OUT_S;
           free_aln (D1->A);
           D1->A=declare_Alignment(D1->S);
           seq2aln (D1->S, D1->A, RAD->rm_gap);
         }
       
       else if ( strm (action, "extract_seq_list"))      
         {
           if ( check_file_exists (action_list[1]) && format_is_fasta (action_list[1]))
             {
              
               BUFS=main_read_seq (action_list[1]);
               action_list=BUFS->name;
               n_actions=BUFS->nseq;           
             }
           else
             {
               action_list++;
               n_actions--;
             }
           
           for ( a=0; a< n_actions;a++)
             {
            
               NS=extract_one_seq(action_list[a],1,0, D1->A, KEEP_NAME); 
               OUT_S=add_sequence ( NS,OUT_S, 0);
            
             }
           
           D1->S=OUT_S;
           free_aln (D1->A);
           D1->A=declare_Alignment(D1->S);
           seq2aln (D1->S, D1->A, RAD->rm_gap);
         }
       else if ( strm (action, "remove_seq") || strm (action, "rm_seq"))         
         {
           char *buf;
           char **list;
           int n;
           int l;
           
           list=declare_char ((D1->S)->nseq, 200);
           
           buf=vcalloc ((D1->S)->max_len+1, sizeof (char));
           for ( n=0,a=0; a< (D1->A)->nseq; a++)
             {
               
               sprintf (buf, "%s", (D1->S)->seq[a]);
               ungap (buf);
               l=strlen(buf);
               
               for (c=1, b=1; b< n_actions; b++)
                 {
                   if ( strm (action_list[b], (D1->S)->name[a])){(D1->S)->seq[a]=NULL;break;}
                   else if ( strm (action_list[b], "empty") && l==0)
                     {
                       fprintf ( stderr, "WARNING: Sequence %s does not contain any residue: automatically removed from the set [WARNING:%s]\n",(D1->S)->name[a], PROGRAM);
                       (D1->S)->seq[a]=NULL;break;
                     }
                   else if ( strm (action_list[b], "unique"))
                     {
                       if ( name_is_in_list ((D1->S)->name[a], list,n, 100)!=-1)
                         {
                           (D1->S)->seq[a]=NULL;break;
                         }
                       else
                         {
                           sprintf ( list[n++], "%s", (D1->S)->name[a]);
                         }
                     }
                 }
             }
           D1->S=duplicate_sequence (D1->S);
           free_aln (D1->A);
           free_char ( list, -1);
           D1->A=declare_Alignment(D1->S);
           seq2aln (D1->S, D1->A, RAD->rm_gap);
         }
       
       else if (  strm (action, "aln2overaln")|| strm (action,"overaln_param"))
         {
           //mode (lower|number|uanlign) Penalty (0-100) Thresold (0-9)
           int  p1,p2,p3,f, t;
           char *s;
           int eb=0;
           char clean_mode[100];
           OveralnP *F;

           F=vcalloc (1, sizeof (OveralnP));
           if ( D2 && D2->A)
             {
               D1->A=mark_exon_boundaries (D1->A, D2->A);
               eb=1;
             }
           else if ( (s=get_string_variable ("exon_boundaries")))
             {
              Sequence *S;
              Alignment *EB;
              EB=seq2aln(S=main_read_seq(s),NULL, 0);
              D1->A=mark_exon_boundaries (D1->A, EB);
              free_sequence (S, S->nseq); free_aln (EB);
              eb=1; 
             }
           

           if (ACTION(1)==NULL)sprintf (F->mode, "lower");
           else if (strstr (ACTION(1), "h"))
             {
               fprintf ( stdout, "aln2unalign lower|number|unalign|uanlign2 F P1 P2 P3 T\n");
               myexit (EXIT_SUCCESS);
             }
           else sprintf (F->mode, "%s", ACTION(1));
           
           F->t=ATOI_ACTION(2);
           F->f=ATOI_ACTION(3);
           F->p1=ATOI_ACTION(4); 
           F->p2=ATOI_ACTION(5);
           F->p3=ATOI_ACTION(6);
           F->p3=ATOI_ACTION(7);
           
           if (int_variable_isset ("overaln_target"))f=get_int_variable ("overaln_target");
           if (int_variable_isset ("overaln_threshold"))t=get_int_variable ("overaln_threshold");
           if (eb)sprintf (F->model, "fsa2");
           else   sprintf (F->model, "fsa1");
           
           D1->A=aln2clean_pw_aln (D1->A, F);
           
         }
       else if (  strm (action, "unalign_groups"))
         {
           //unalign everything in lower case
           unalign_aln_2 (D1->A, NULL, 0);
         }
       else if (  strm (action,"aln2unalign"))
         {
           Alignment *SA;
           Sequence *SS;
           SA=copy_aln (D1->A, NULL);
           SS=aln2seq(SA);
           
           thread_seq_struc2aln (SA, SS);
           D1->A=unalign_aln (D1->A,SA, ATOI_ACTION(1));
           D1->S=aln2seq ( D1->A);
         }
       else if (  strm (action, "clean_cdna"))
         { 
           Alignment *A;
           A=D1->A;
           for (a=0; a< A->nseq; a++)
             {
               char *d, *buf, f;
               
               d=A->seq_al[a];
               f=get_longest_frame (d, 3);
               buf=vcalloc ( strlen (d)+1, sizeof (char));
               sprintf (buf, "%s", d+f);
               sprintf (d, "%s", buf);
               vfree (buf);
             }
         }
       else if ( strm (action, "clean_cdna2"))
         {
           D1->A=clean_cdna_aln ( D1->A);
           free_sequence ( D1->S, (D1->S)->nseq);
           D1->S=aln2seq ( D1->A);
         }
       else if ( strm  (action, "aln2short_aln"))
           {
             D1->A=aln2short_aln (D1->A, action_list[1], action_list[2], atoi(action_list[3]));
             free_sequence ( D1->S, (D1->S)->nseq);
             D1->S=aln2seq ( D1->A);
           }
       else if ( strm ( action, "complement"))
         {
           D1->A=complement_aln (D1->A);
           free_sequence ( D1->S, (D1->S)->nseq);
           D1->S=aln2seq ( D1->A);
         }
       else if ( strm ( action, "extend"))
         {
           extend_seqaln( NULL,D1->A);
           free_sequence ( D1->S, (D1->S)->nseq);
           D1->S=aln2seq ( D1->A);
         }
       else if ( strm ( action, "unextend"))
         {
           unextend_seqaln( NULL,D1->A);
           free_sequence ( D1->S, (D1->S)->nseq);
           D1->S=aln2seq ( D1->A);
         }
       else if ( strm ( action, "translate"))
         {
           D1->A=translate_dna_aln( D1->A,(n_actions==1)?0:atoi(action_list[1]));
           free_sequence ( D1->S, (D1->S)->nseq);
           D1->S=aln2seq ( D1->A);
         }
       else if (strm2 ( action, "back_translate","backtranslate"))
         {
          D1->A=back_translate_dna_aln( D1->A);
          free_sequence ( D1->S, (D1->S)->nseq);
          D1->S=aln2seq ( D1->A);
         }
       else if (strm ( action, "rotate"))
         {
           D1->A=rotate_aln( D1->A, action_list[1]);
           free_sequence ( D1->S, (D1->S)->nseq);
           D1->S=aln2seq ( D1->A);
         }
       else if (strm ( action, "invert"))
         {
          D1->A=invert_aln( D1->A);
          free_sequence ( D1->S, (D1->S)->nseq);
          D1->S=aln2seq ( D1->A);
         }
       else if (strm ( action, "test_dna2gene"))
         {
           testdna2gene ((D1->S)->seq[0]);
         }
       else if (strm ( action, "code_dna_aln"))
         {
          D1->A=code_dna_aln( D1->A);
          free_sequence ( D1->S, (D1->S)->nseq);
          D1->S=aln2seq ( D1->A);
         }
       
       else if ( strm ( action, "mutate"))
         {
           D1->A=mutate_aln( D1->A,(n_actions==1)?"0":action_list[1]);
           free_sequence ( D1->S, (D1->S)->nseq);
           D1->S=aln2seq (D1->A);
         }
       else if ( strm ( action, "thread_profile_on_msa"))
         {
           (D1->A)->S=NULL;
           D1->A=thread_profile_files2aln (D1->A, action_list[1], NULL);
           D1->S=aln2seq(D1->A);
         }
       else if ( strm ( action, "thread_dna_on_prot_aln"))
          {
            D1->A=thread_dnaseq_on_prot_aln (D1->S, D2->A);
            free_sequence (D1->S,(D1->S)->nseq);
            D1->S=aln2seq (D1->A); 
          }
       else if ( strm ( action, "thread_struc_on_aln"))
         {
           thread_seq_struc2aln ( D2->A, D1->S);
           D1->A=copy_aln(D2->A, D1->A);
           free_sequence ( D1->S, (D1->S)->nseq);
           D1->S=aln2seq (D1->A);
         }
       else if ( strm (action, "sim_filter"))
         {
           D1->A=sim_filter (D1->A, action_list[1], ACTION (2));
           free_sequence (D1->S,(D1->S)->nseq);
           D1->S=aln2seq (D1->A); 
         }
       else if ( strm (action, "seq2blast"))
         {
           D1->A=seq2blast (D1->S);
           free_sequence (D1->S,(D1->S)->nseq);
           D1->S=aln2seq (D1->A); 
         }
           
       else if ( strm (action, "trim"))
         {
           D1->A=simple_trimseq (D1->A,(D2)?D2->A:NULL, action_list[1], ACTION (2), NULL);
           
           free_sequence (D1->S,(D1->S)->nseq);
           D1->S=aln2seq (D1->A); 
         }
       
       else if (strm ( action, "trimTC"))
         {
           value=(n_actions==1)?10:atoi(action_list[1]);
        
           D1->A=tc_trimseq(D1->A,D1->S,action_list[1]);
           free_sequence (D1->S,(D1->S)->nseq);
           D1->S=aln2seq (D1->A); 
         }
       else if (strm ( action, "trimTC2"))
         {
           char *group_file;
           Alignment *B=NULL;
           char trim_mode[100];
           if ( n_actions==1 || !(strm (action_list[1], "NSEQ") ||strm (action_list[1], "MINID")) )
             {
               fprintf ( stderr, "\nTrimTC2 <NSEQ | MINID>  <number sequences| minimum identity> (<matrix>)\n");
               myexit (EXIT_FAILURE);
             }
           sprintf (trim_mode, "%s", action_list[1]);action_list+=2; n_actions-=2;
           
           if ( strm ( trim_mode, "NSEQ"))
             {
               group_file=tree2Ngroup( (D1)?D1->A:NULL, (D2)?D2->T:NULL, atoi (action_list[0]), vtmpnam(NULL), (n_actions==1)?"idmat":action_list[1]);
             }
           else
             {
               group_file=tree2Ngroup( (D1)?D1->A:NULL, (D2)?D2->T:NULL, -1*atoi (action_list[0]), vtmpnam(NULL), (n_actions==1)?"idmat":action_list[1]);
             }
           
           B=copy_aln (D1->A, B);
           B=aln2sub_aln_file (B,1,&group_file);
           B=aln2sub_seq (B, 1, &group_file);
           D1->A=extract_sub_aln2 (D1->A, B->nseq, B->name);
         }
       else if ( strm (action, "chain"))
         {
           D1->A=seq2seq_chain (D1->A,D2->A, ACTION(2));
         }
       
       
       else if (strm ( action, "master_trim"))
         {
           value=(n_actions==1)?10:atoi(action_list[1]);
        
           D1->A=master_trimseq(D1->A,D1->S,action_list[1]);
           free_sequence (D1->S,(D1->S)->nseq);
           D1->S=aln2seq (D1->A); 
         }
        else if ( strm (action, "force_aln"))    
         {
           char ***rlist=NULL;
           int count=0;

           if ( n_actions==2)
             {
               if (!is_lib_02(action_list[1]))
                 {
                   fprintf ( stderr, "\nERROR: force_aln requires files in TC_LIB_FORMAT_02 [FATAL:%s]", PROGRAM);
                   myexit (EXIT_FAILURE);
                 }
               else
                   rlist=file2list (action_list[1], " ");
             }
           else
             {
               rlist=declare_arrayN(3, sizeof (char),3,7, 10);
               
               strcat (rlist[1][1],action_list[1]);strcat (rlist[1][3],action_list[2]);
               strcat (rlist[1][4],action_list[3]);strcat (rlist[1][6],action_list[4]);
               sprintf ( rlist[2][0], "-1");
             }
           count=1;
           while (rlist[count] && atoi(rlist[count][0])!=-1)
             {
               char st1[100], st2[100], st3[100], st4[100];
               
               sprintf ( st1, "%s", rlist[count][1]);sprintf ( st2, "%s", rlist[count][3]);
               sprintf ( st3, "%s", rlist[count][4]);sprintf ( st4, "%s", rlist[count][6]);
               fprintf ( stderr, "\nFORCE: %s %s %s %s", st1, st2, st3, st4);
               
               if (is_number (st1))s1=atoi (st1)-1;
               else s1=name_is_in_list (st1,(D1->A)->name, (D1->A)->nseq, 100);
               if ( s1<0 || s1>= (D1->A)->nseq)crash ("wrong sequence index");
               r1=atoi (st2)-1;
               
               if (is_number (st3))s2=atoi (st3)-1;
               else s2=name_is_in_list (st3,(D1->A)->name, (D1->A)->nseq, 100);
               if ( s2<0 || s2>= (D1->A)->nseq)crash ("wrong sequence index");
               r2=atoi (st4)-1;
               
               (D1->A)=add_constraint2aln ((D1->A), s1, r1, s2, r2);
               count++;
             }
           fprintf ( stderr, "\n");
           free_arrayN((void*)rlist,3);
         }
      
        else if (strm ( action, "grep"))
          {
            D1->A=grep_seq (D1->A, ACTION(1),ACTION(2), ACTION(3));
            if (D1->A==NULL) myexit (EXIT_SUCCESS);
            else D1->S=aln2seq (D1->A); 
          }
                      
        else if (strm (action, "find"))
          {
            int r, l;
            char *search_string;

            search_string=vcalloc ( 30, sizeof (char));
            if ( strm (action_list[1], "lower"))sprintf ( search_string, "abcdefghijklmnopqrstuvwxyz");
            else if ( strm ( action_list[1], "upper"))sprintf ( search_string, "ABCDEFGHIJKLMNOPQRSTUVWXYZ");
            else 
              {
                vfree (search_string);search_string=vcalloc ( strlen (action_list[1])+1, sizeof (char));
                sprintf (search_string, "%s", action_list[1]);
              }
            
            for (a=0; a<(D1->A)->nseq; a++)
              for ( l=0,b=0; b< (D1->A)->len_aln; b++)
                {
                  r=(D1->A)->seq_al[a][b];
                  l+=!is_gap(r);
                  if ( r!='\0' && strrchr (search_string, r))
                    {
                      /*fprintf ( stdout, "%-15s res %c alnpos %4d seqpos %4d\n", (D1->A)->name[a], r, b+1, l);*/
                      fprintf ( stdout, "%s %d %d\n", (D1->A)->name[a], l, l+1);
                    }
                }
            myexit (EXIT_SUCCESS);
          }
        else if ( strm (action, "merge_annotation"))
          {
            D1->A=merge_annotation (D1->A, DST?DST->A:NULL, ACTION(1));
            D1->S=aln2seq (D1->A); 
          }
        else if ( strm  (action, "color_residue"))
          {
            int i;
            Alignment *A;
            A=D1->A;
            
            DST->A=copy_aln (D1->A, NULL);
            DST->S=aln2seq (DST->A);
            for (a=0; a< (DST->S)->nseq; a++)ungap ((DST->S)->seq[a]);
            
            if (n_actions>2)
              {
                for (a=1; a<n_actions; a+=3)
                  {
                    i=name_is_in_list(action_list[a], (D1->A)->name, (D1->A)->nseq, 100);
                    if (i!=-1)
                      {
                        (DST->S)->seq[i][atoi(action_list[a+1])-1]='0'+atoi(action_list[a+2])-1;
                      }
                    else fprintf (stderr, "\nWARNING: Could not find Sequence %s", action_list[a]);
                  }
              }
            else
              {
                char name[1000];
                int pos, val;
                FILE *fp;
                
                fp=vfopen (action_list[1], "r");
                while (fscanf (fp, "%s %d %d\n", name, &pos, &val)==3)
                  {
                
                     i=name_is_in_list(name, (D1->A)->name, (D1->A)->nseq, 100);
                     if (i!=-1)(DST->S)->seq[i][pos-1]='0'+val; 
                     else fprintf (stderr, "\nWARNING: Could not find Sequence %s", action_list[a]);
                  }
                vfclose (fp);
              }
            DST->A=seq2aln (DST->S, NULL, 1);
          }
       else if ( strm  (action, "edit_residue"))
          {
            FILE *fp;
            int i, pos;
            int **p;
            char mod[100], name[100];
            Alignment *A;           
            
            A=D1->A;
            
            p=aln2inv_pos (A);
            if (n_actions>2)
              {
                for (a=1; a<n_actions; a+=3)
                  {
                    
                    i=name_is_in_list(action_list[a], (D1->A)->name, (D1->A)->nseq, 100);
                    if (i!=-1)
                      {
                        pos=atoi(action_list[a+1]);
                        
                        pos=p[i][pos]-1;
                        sprintf (mod, "%s", action_list[a+2]);
                        if ( strm (mod, "upper"))(D1->A)->seq_al[i][pos]=toupper((D1->A)->seq_al[i][pos]);
                        else if ( strm (mod, "lower"))(D1->A)->seq_al[i][pos]=tolower((D1->A)->seq_al[i][pos]);
                        else (D1->A)->seq_al[i][pos]=mod[0];
                      }
                    else fprintf (stderr, "\nWARNING: Could not find Sequence %s", action_list[a]);
                    
                  }
              }
            else
              {
                fp=vfopen (action_list[1], "r");
                while (fscanf (fp, "%s %d %s\n", name, &pos, mod)==3)
                  {
                
                     i=name_is_in_list(name, (D1->A)->name, (D1->A)->nseq, 100);
                     if (i!=-1)
                       {
                         pos=p[i][pos]-1;
                         if ( strm (mod, "upper"))(D1->A)->seq_al[i][pos]=toupper(A->seq_al[i][pos]);
                         else if ( strm (mod, "lower"))A->seq_al[i][pos]=tolower(A->seq_al[i][pos]);
                         else A->seq_al[i][pos]=mod[0];
                       }
                      else fprintf(stderr, "\nWARNING: Could not find Sequence %s", action_list[1]);
                  }
                vfclose (fp);
              }
            D1->S=aln2seq (D1->A);
          }
       else if ( strm (action, "clean_flag"))
         {
           clean_flag=1-clean_flag;
         }
       else if ( strm  (action, "aln2case"))
         {
           D1->A=aln2case_aln (D1->A, ACTION(1), ACTION(2));
           D1->S=aln2seq(D1->A);
         }
       
       else if ( strm5 (action, "convert","upper","lower", "keep", "switchcase"))
         {
           b=1;

           if ( n_actions>1 && is_number (action_list[b]))
             {
               lower_value=upper_value=atoi(action_list[b++]);
             }
           else if ( n_actions>1 && strm (action_list[b], "gap"))
             {
               DST=vcalloc (1,sizeof(Sequence_data_struc));
               DST->A=aln2gap_cache (D1->A,0);
               lower_value=0;
               upper_value=0;
               b++;
             }
           else if (n_actions>1 && action_list[b] && action_list[b][0]=='[')
             
             {
               lower_value=atoi(strtok (action_list[b]+1, "-[]"));
               upper_value=atoi(strtok (NULL, "-[]"));
             
               b++;
             }
           else
             {
               lower_value=upper_value=-1;
             }

           if ( n_actions >b ||strm (action, "keep") )
             {
               if ( !RAD->symbol_list)RAD->symbol_list=declare_char (STRING, STRING);
               RAD->n_symbol=0;
               if ( strm (action, "keep") )sprintf ( RAD->symbol_list[RAD->n_symbol++], "#-");
               else
                 {
                   for (a=b; a< n_actions; a++)
                     {
                       sprintf ( RAD->symbol_list[RAD->n_symbol], "%s", action_list[a]);
                       RAD->n_symbol++;
                     }
                 }
             }
           
           for ( value=0; value<=9; value++)
             {
               if ( lower_value==-1)value=-1;
               
               if ( (value>=lower_value && value<=upper_value)|| value==-1)
                 {
                   if (strm(action,"convert")) D1->A=filter_aln_convert (D1->A, DST?DST->A:NULL,RAD->use_consensus,value,RAD->n_symbol, RAD->symbol_list);
                   else if (strm(action,"upper"))D1->A=filter_aln_lower_upper (D1->A, DST?DST->A:NULL,RAD->use_consensus,value);
                   else if (strm(action,"lower"))D1->A=filter_aln_upper_lower (D1->A, DST?DST->A:NULL,RAD->use_consensus,value);
                   else if (strm(action,"switchcase"))D1->A=filter_aln_switchcase (D1->A, DST?DST->A:NULL,RAD->use_consensus,value);
                 }
               else
                 {
                   if (strm(action,"keep")) D1->A=filter_aln_convert (D1->A, DST?DST->A:NULL,RAD->use_consensus,value,RAD->n_symbol, RAD->symbol_list);
                 }
               if (value==-1)break;

             }

           /*free_sequence (D1->S,(D1->S)->nseq);*/
           if (!D1->S)D1->S=aln2seq (D1->A); 
         } 
        else if ( strm ( action, "count_pairs"))
          {
            int a, b,c,v, **matrix;
            Alignment *A;
            matrix=declare_int (300,300);
            A=D1->A;
            for ( a=0; a< A->nseq-1; a++)
              for (b=0; b< A->nseq; b++)
                for (c=0; c<A->len_aln; c++)
                  matrix[(int)A->seq_al[a][c]][(int)A->seq_al[b][c]]++;
            for ( a=0; a<255; a++)
              for ( b=a; b<256; b++)
                {
                  v=matrix[a][b]+matrix[b][a];
                  if (v)fprintf ( stdout, "\n%c %c %d", a, b, v);
                }
            myexit (EXIT_SUCCESS);
          }
        else if ( strm (action, "count_misc"))
          {
            count_misc (D1->A, (!D2)?NULL:D2->A);
          }
       else if ( strm (action, "count"))
         {
           b=1;
           if ( n_actions>1 && is_number (action_list[b]))
             {
               lower_value=upper_value=atoi(action_list[b++]);
             }
           else if (n_actions>1 && action_list[b] && action_list[b] && action_list[b][0]=='[')
             
             {
               lower_value=atoi(strtok (action_list[b]+1, "-[]"));
               upper_value=atoi(strtok (NULL, "-[]"));
             
               b++;
             }
           else
             {
               lower_value=upper_value=-1;
             }
           if ( n_actions >b)
             {
               if ( !RAD->symbol_list)RAD->symbol_list=declare_char (STRING, STRING);
               RAD->n_symbol=0;
               for (a=b; a< n_actions; a++)
                 {
                   sprintf ( RAD->symbol_list[RAD->n_symbol], "%s", action_list[a]);
                   RAD->n_symbol++;
                 }
             }
           for ( value=lower_value; value<=upper_value; value++)
             {
               count_table=count_in_aln (D1->A, DST?DST->A:NULL,value,RAD->n_symbol, RAD->symbol_list, count_table);           
             }
           for ( a=0; a<RAD->n_symbol; a++)
             {
               fprintf ( stdout, "%s %d\n", RAD->symbol_list[a], count_table[a]);
             }
           free_sequence (D1->S,(D1->S)->nseq);
           D1->S=aln2seq (D1->A); 
           vfree(count_table);
           myexit(EXIT_SUCCESS);
         }
       else if ( strm (action, "species_weight"))
         {
           seq_weight2species_weight (D1->A, D2->S);
           exit (0);
         }
       else if ( strm (action, "aln2voronoi"))
         {
           aln2voronoi_weights (D1->A);
           
         }
       else if ( strm (action, "msa_weight"))
         {
           int random_value;
           char command [LONG_STRING];
           char aln_name[FILENAMELEN];
           char tree_name[FILENAMELEN];
           char dist_matrix_name[FILENAMELEN];
           char weight_name[FILENAMELEN]; 
           char method_4_msa_weights[1000];
           
           if ( n_actions==1)
             {
               fprintf ( stderr, "\nError: msa_weight requires a weight_method");
             }
           
           sprintf ( method_4_msa_weights, "%s", (get_env_variable ("METHOD_4_MSA_WEIGHTS",NO_REPORT))?get_env_variable ("METHOD_4_MSA_WEIGHTS",NO_REPORT):METHOD_4_MSA_WEIGHTS);
           
           /*1 Computation of the tree and the distance matrix*/
           random_value=addrand ((unsigned long) 100000)+1;
           sprintf (aln_name, "%d.aln", random_value);
           sprintf (tree_name, "%d.ph", random_value);
           sprintf (dist_matrix_name, "%d.dst", random_value);
           sprintf (weight_name, "%d.weight", random_value);
           output_fasta_aln (aln_name, D1->A);
          
           sprintf ( command, "clustalw -infile=%s -tree -outputtree=dist %s", aln_name, TO_NULL_DEVICE);
           my_system ( command);
           sprintf ( command, "%s -method %s -aln %s -tree %s -dmatrix %s -weightfile %s %s",method_4_msa_weights, action_list[1],aln_name, tree_name, dist_matrix_name,weight_name, TO_NULL_DEVICE); 
           my_system ( command);
           
           (D1->A)->S=aln2seq (D1->A);
           ((D1->A)->S)->W=read_seq_weight ( (D1->A)->name, (D1->A)->nseq,weight_name);    
           vremove (weight_name);
           vremove (aln_name);
           vremove (tree_name);
           vremove (dist_matrix_name);     
         }
       else if ( strm (action, "pavie_seq2random_seq"))
         {
           D1->S=pavie_seq2random_seq (D1->S, action_list[1]);
           D1->A=seq2aln (D1->S,NULL,1);
         }
       else if ( strm ( action, "pavie_seq2noisy_seq"))
         {
           /*<amount of noise: 0-100> (<alp>)*/
           
           D1->S=pavie_seq2noisy_seq (D1->S, atoi(action_list[1]),ACTION(2));
           D1->A=seq2aln (D1->S,NULL,1);
         }
       else if ( strm (action, "pavie_seq2pavie_mat"))
         {

           pavie_seq2trained_pavie_mat ( D1->S, (n_actions==2)?action_list[1]:NULL);
           myexit (EXIT_SUCCESS);
         }
       else if ( strm (action, "pavie_seq2pavie_aln"))
         {

           pavie_seq2pavie_aln ( D1->S, action_list[1], ACTION(2));
           myexit (EXIT_SUCCESS);
         }
       else if ( strm (action, "pavie_seq2pavie_dm"))
         {
            if (strstr (ACTION2(2,""), "_MSA_"))
              D1->S=aln2seq_main(D1->A, KEEP_GAP);
           
                   
           pavie_seq2pavie_aln ( D1->S, action_list[1],(n_actions==3)?action_list[2]:"_MATDIST_");
           myexit (EXIT_SUCCESS);
         }
       else if ( strm (action, "pavie_seq2pavie_msa"))
         {
           D1->A=pavie_seq2pavie_msa ( D1->S, action_list[1], (n_actions==3)?action_list[2]:NULL);
         }
       else if ( strm (action, "pavie_seq2pavie_tree"))
         {
           D1->T=pavie_seq2pavie_tree ( D1->S, action_list[1], (n_actions==3)?action_list[2]:NULL);
         }
       else if ( strm (action, "pavie_seq2pavie_sort"))
         {
           D1->A=pavie_seq2pavie_sort ( D1->S, action_list[1], (n_actions==3)?action_list[2]:NULL);
         }
      
       else if ( strm (action, "aln2mat_diaa"))
         {
           aln2mat_diaa (D1->S);
         }
       else if ( strm (action, "aln2mat"))
         {
           aln2mat(D1->S);
         }
       
       else if ( strm (action, "seq2latmat"))
         {
           seq2latmat ( D1->S, "stdout");
           myexit (EXIT_SUCCESS);
         }
       else if ( strm (action , "rm_target_pdb"))
         {
           int i, j;
           char *buf;
           
           for (i=0; i< (D1->A)->nseq; i++)
             {
               j=1;buf=(D1->A)->name[i];
               while (buf[j]!='_' && buf[j-1]!='_' && buf[j]!='\0')j++;
               buf[j]='\0';
             }
         }
       else if ( strm ( action, "mat2cmp"))
         {
           double *r;
           r=mat2cmp (D1->M, D2->M);
           fprintf ( stdout, "\nMATRIX COMPARISON: R=%.3f R2=%.3f On %d pairs of values\n", (float)r[0], (float)r[1], (int)r[2]);
           myexit (EXIT_SUCCESS);
         }
//Special modes
       else if ( strm ( action, "overaln_list"))
         {
           float *re, tre=0,sn, tsn=0, sp, tsp=0;
           int p1,p2,p3, t, f;
           FILE *fp;
           char fname [100];
           Alignment **LA;
           Alignment **LB;
           
           HERE ("F P1 P2 P3 T");

           t=ATOI_ACTION(1);
           f=ATOI_ACTION(2);
           p1=ATOI_ACTION(3);
           p2=ATOI_ACTION(4);
           p3=ATOI_ACTION(5);
           
           
           
           LA=vcalloc ((D1->A)->nseq, sizeof (Alignment*));
           LB=vcalloc ((D2->A)->nseq, sizeof (Alignment*));
           for (a=0; a<(D1->A)->nseq; a++)
             {
                LA[a]=main_read_aln ((D1->A)->name[a], NULL);
                LB[a]=main_read_aln ((D2->A)->name[a], NULL);
             }
        
           for ( a=0; a<(D1->A)->nseq; a++)
             {
               Alignment *A, *B;
               A=LA[a];
               B=LB[a];
               re=analyze_overaln (A, B, "_case_l_",t,f,p1,p2,p3);
               fprintf (stdout, "\n%d: sn: %.2f sp: %.2f re: %.2f F: %d P: %d P2: %d T: %d",a, re[0],re[1],re[2],f, p1,p2,t);
               tsn+=re[0];
               tsp+=re[1];
               tre+=re[2];
               vfree(re);
             }
           fprintf (stdout, "\nTOT: sn: %.2f sp: %.2f re: %.2f F: %d P: %d P2: %d T: %d", tsn/(D1->A)->nseq,tsp/(D1->A)->nseq, tre/(D1->A)->nseq,f,p1,p2,t);
           
           myexit (0);
         }
       else if ( strm ( action, "overaln_list_scan"))
         {
           float *re, tre=0, tsn=0, tsp;
           int p1,p2, p3, t, f;
           FILE *fp;
           char fname [100];
           Alignment **LA;
           Alignment **LB;
           
           if ( ACTION(1))sprintf ( fname, "%s", ACTION(1));
           else sprintf ( fname, "scan_results.txt");
           
           fprintf ( stdout, "SCAN Results will be ouput in %s\n", fname);
           
           
           LA=vcalloc ((D1->A)->nseq, sizeof (Alignment*));
           LB=vcalloc ((D2->A)->nseq, sizeof (Alignment*));
           for (a=0; a<(D1->A)->nseq; a++)
             {
                LA[a]=main_read_aln ((D1->A)->name[a], NULL);
                LB[a]=main_read_aln ((D2->A)->name[a], NULL);
             }
           for (f=32; f<=40; f++)
             {
               for (p1=90; p1<=100; p1+=5)
                 {
                   for ( t=1; t<=3; t++)
                     {
                       for (p2=0; p2<=40; p2+=5)
                         {
                           for (p3=0;p3<=0;p3+=5)
                             {
                               tre=tsn=tsp=0;
                               for ( a=0; a<(D1->A)->nseq; a++)
                                 {
                                   Alignment *A, *B;
                                   A=LA[a];
                                   B=LB[a];
                                   re=analyze_overaln (A, B, "_case_l_",t,f,p1,p2,p3);
                                   
                                   tsn+=re[0];
                                   tsp+=re[1];
                                   tre+=re[2];
                                   vfree (re);
                                 }
                               fp=vfopen (fname, "a");
                               fprintf (fp, "\nTOT: sn: %.2f sp: %.2f re: %.2f P: %d P2: %d P3: %d T: %d F: %d", tsn/(D1->A)->nseq,tsp/(D1->A)->nseq, tre/(D1->A)->nseq, p1,p2, p3,t,f);
                               fprintf (stderr, "\nTOT: sn: %.2f sp: %.2f re: %.2f P: %d P2: %d P3: %d T: %d F: %d", tsn/(D1->A)->nseq,tsp/(D1->A)->nseq, tre/(D1->A)->nseq, p1,p2, p3,t,f);
                               vfclose (fp);
                             }
                         }
                     }
                 }
             }
           myexit (0);
         }
       else if ( strm ( action, "overaln"))//Evaluate the capacity to predict over-aligned regions
         {
           OveralnP *F;
           F=vcalloc (1, sizeof (OveralnP));
           //al1: ref
           //al2: alignment
           //ATOI(1): P (0-100)
           //ATOI(2): T (0-9)
           
           float *r;
           DST=vcalloc (1,sizeof(Sequence_data_struc));
           DST->A=aln2gap_cache (D1->A,0);
           lower_value=0;
           upper_value=0;
           D1->A=filter_aln_upper_lower (D1->A, DST->A, 0, 0);
           
           sprintf (F->mode, "%s", ((s=get_string_variable ("overaln_mode")))?s:"lower");
           if (!strm (F->mode, "lower") && !strstr (F->mode, "unalign"))printf_exit (EXIT_FAILURE,stderr,"\nERROR: unknown overal_mode in overal output [%s] [FATAL:%s]", F->mode, PROGRAM);
           
           if (int_variable_isset ("overaln_threshold"))F->t=get_int_variable ("overaln_threshold");
           if (int_variable_isset ("overaln_target"))F->f=get_int_variable ("overaln_target");
           if (int_variable_isset ("overaln_P1"))F->f=get_int_variable ("overaln_P1");
           if (int_variable_isset ("overaln_P1"))F->f=get_int_variable ("overaln_P2");
           if (int_variable_isset ("overaln_P1"))F->f=get_int_variable ("overaln_P3");
           if (int_variable_isset ("overaln_P1"))F->f=get_int_variable ("overaln_P4");//F P1 P2 P3 T;
           
           D2->A=aln2clean_pw_aln (D2->A, F);
           r=aln2pred (D1->A, D2->A,"case_l_");
           fprintf ( stdout, "sn %.2f sp %.2f re %.2f\n", r[0], r[1], r[2]);
           myexit (0);
         }
       
           
//JM_START
       else if ( strm ( action, "aln2hitMat"))
         {
                aln2hitMat(D1->A, ACTION(1));
                myexit (EXIT_SUCCESS);
         }
//JM_END
       
       else
         {
           fprintf ( stderr, "\nWARNING: ACTION %s UNKNOWN and IGNORED\n", action);
         }
     
     }


void aln2mat_diaa (Sequence *S)
{
  int a, aa1, aa2, aa3, aa4;
  int s1, s2, p;
  Alignment *A;
  
  int ****m;
  int **c;
  int naa=0;
  int count=0;
  double Delta=0.00001;
  int *alp;
  int tot,u;
  double observed, expected, f_diaa1, f_diaa2, v;
  

  alp=vcalloc (256, sizeof (int));
  for (a=0; a<26; a++)alp[a+'a']=1;
  alp['b']=0;
  alp['j']=0;
  alp['o']=0;
  alp['u']=0;
  alp['x']=0;
  alp['z']=0;

  m=declare_arrayN (4,sizeof (int),26,26,26,26);
  c=declare_arrayN  (2,sizeof (int),26,26);
  
  for ( a=0; a< S->nseq; a++)
    {
      fprintf ( stderr, "%s\n", S->name[a]);
      A=main_read_aln (S->name[a],NULL);
      for (s1=0; s1<A->nseq; s1++)lower_string (A->seq_al[s1]);
      
      for ( s1=0; s1<A->nseq-1; s1++)
        for (s2=s1+1; s2<A->nseq; s2++)
          {
            for (p=0; p<A->len_aln-1; p++)
              {
                
                u =alp[aa1=A->seq_al[s1][p]];
                u+=alp[aa2=A->seq_al[s1][p+1]];
                u+=alp[aa3=A->seq_al[s2][p]];
                u+=alp[aa4=A->seq_al[s2][p+1]];
        
                if ( u==4)
                  {
                    aa1-='a';aa2-='a';aa3-='a'; aa4-='a';
                    
                    c[aa1][aa2]++;
                    c[aa3][aa4]++;
                    m[aa1][aa2][aa3][aa4]++;
                    count+=2;
                  }
              }
          }
      free_aln (A);
    }
  fprintf ( stdout, "# DIAA_MATRIX_FORMAT_01\n");
  naa=26;
  for (aa1=0; aa1<naa; aa1++)
    for (aa2=0; aa2<naa; aa2++)
      for (aa3=0; aa3<naa; aa3++)
        for (aa4=0; aa4<naa;aa4++) 
          {
            u =alp[aa1+'a'];
            u+=alp[aa2+'a'];
            u+=alp[aa3+'a'];
            u+=alp[aa4+'a'];
            
            if ( u==4)
              {
                tot=m[aa1][aa2][aa3][aa4]+m[aa3][aa4][aa1][aa2];
                observed=((double)tot)/(double)((double)count/(double)2);
                f_diaa1=(double)c[aa1][aa2]/(double)count;
                f_diaa2=(double)c[aa3][aa4]/(double)count;
                
                expected=f_diaa1*f_diaa2;
                if (expected<Delta)v=0;
                else if (observed<Delta)v=-100;
                else 
                  {
                    v=log(observed/expected)*10;
                  }
            // if (tot>0)fprintf ( stdout, "TEST C=%d expected=%.4f observed=%.4f v=%.4f [%d %d %d][%d] tot=%d\n", count, (float)expected, (float)observed, (float) v, c[aa1][aa2], c[aa3][aa4], count, m[aa1][aa2][aa3][aa4], tot);
                fprintf ( stdout, "%c%c %c%c %d %d\n", aa1+'a', aa2+'a', aa3+'a', aa4+'a', (int)v, m[aa1][aa2][aa3][aa4]+ m[aa3][aa4][aa1][aa2]);
              }
          }
  myexit (EXIT_SUCCESS);
}
void aln2mat (Sequence *S)
{
  int a, aa1, aa3;
  int s1, s2, p;
  Alignment *A;
  int **mat;
  int **m;
  int *c;
  int naa=0;
  int count=0;
  double Delta=0.00001;
  int *alp;
  int tot,u;
  double observed, expected, f_diaa1, f_diaa2, v;
  char *balp;

  balp=vcalloc ( 256, sizeof (char));
  for (a=0; a<strlen (BLAST_AA_ALPHABET); a++)balp[BLAST_AA_ALPHABET[a]]=a;
  
  mat=declare_int (256, 256);
  alp=vcalloc (256, sizeof (int));
  for (a=0; a<26; a++)alp[a+'a']=1;
  alp['b']=0;
  alp['j']=0;
  alp['o']=0;
  alp['u']=0;
  alp['x']=0;
  alp['z']=0;

  m=declare_arrayN (2,sizeof (int),26,26);
  c=declare_arrayN  (1,sizeof (int),26);
  
  for ( a=0; a< S->nseq; a++)
    {
      fprintf ( stderr, "%s\n", S->name[a]);
      A=main_read_aln (S->name[a],NULL);
      for (s1=0; s1<A->nseq; s1++)lower_string (A->seq_al[s1]);
      
      for ( s1=0; s1<A->nseq-1; s1++)
        for (s2=s1+1; s2<A->nseq; s2++)
          {
            for (p=0; p<A->len_aln-1; p++)
              {
                
                u =alp[aa1=A->seq_al[s1][p]];
                u+=alp[aa3=A->seq_al[s2][p]];
                
                if ( u==2)
                  {
                    aa1-='a';aa3-='a';
                    
                    c[aa1]++;
                    c[aa3]++;
                    m[aa1][aa3]++;
                    count+=2;
                  }
              }
          }
      free_aln (A);
    }
  fprintf ( stdout, "# MONOAA_MATRIX_FORMAT_01\n");
  naa=26;
  for (aa1=0; aa1<naa; aa1++)
      for (aa3=0; aa3<naa; aa3++)
          {
            u =alp[aa1+'a'];
            u+=alp[aa3+'a'];
            
            if ( u==2)
              {
                tot=m[aa1][aa3]+m[aa3][aa1];
                observed=((double)tot)/(double)((double)count/(double)2);
                f_diaa1=(double)c[aa1]/(double)count;
                f_diaa2=(double)c[aa3]/(double)count;
                
                expected=f_diaa1*f_diaa2;
                if (expected<Delta)v=0;
                else if (observed<Delta)v=-100;
                else 
                  {
                    v=log(observed/expected)/(log(2)/2);
                  }
            // if (tot>0)fprintf ( stdout, "TEST C=%d expected=%.4f observed=%.4f v=%.4f [%d %d %d][%d] tot=%d\n", count, (float)expected, (float)observed, (float) v, c[aa1][aa2], c[aa3][aa4], count, m[aa1][aa2][aa3][aa4], tot);
                //fprintf ( stdout, "%c %c %d %d\n", aa1+'A', aa3+'A', (int)v, m[aa1][aa3]+ m[aa3][aa1]);
                mat[aa1][aa3]=(int)v;
              }
          }
  output_blast_mat (mat, "stdout");
  myexit (EXIT_SUCCESS);
}           
        

int **seq2latmat ( Sequence *S, char *fname)
{
  int a, b, r0, r1;
  char *aa;
  int naa;
  int *count, tot;
  int **mat;
  double observed, expected;
  FILE *fp;

  fp=vfopen (fname, "w");
  
  count=vcalloc ( 256, sizeof (int));
  mat=declare_int (256, 256);
  
  naa=strlen ( BLAST_AA_ALPHABET);
  aa=vcalloc ( naa+2, sizeof (char));
  sprintf ( aa, "%s", BLAST_AA_ALPHABET);
  lower_string (aa);
  
  for ( tot=0,a=0; a< S->nseq; a++)
    {
      ungap (S->seq[a]);
      for ( b=1; b<S->len[a]; b++)
        {
          r0=tolower(S->seq[a][b-1]);
          r1=tolower(S->seq[a][b]);
          
          mat[r0][r1]++;
          //count[r0]++;
          count[r1]++;
          tot++;
        }
    }
  for ( a=0; a< naa; a++)
    for (b=0; b< naa; b++)
      {
        if ( aa[a]=='*' || aa[b]=='*');
        else
          {
            expected=((double)count[(int)aa[a]]/(double)tot)* ((double)count[(int)aa[b]]/(double)tot)*(double)tot;
            observed=((double)mat[(int)aa[a]][(int)aa[b]]);
        
            /*
              fprintf ( stderr, "\n%c=%d %c=%d Tot=%d Obs=%d Exp=%d\n", aa[a],count[aa[a]], aa[b],count[aa[b]],tot, mat[aa[a]][aa[b]],(int)expected);  
              fprintf ( stderr, "\n%d", mat[aa[a]][aa[b]]);
              fprintf ( stderr, "\n%d", mat[aa[a]][aa[b]]);
            */
            mat[(int)aa[a]][(int)aa[b]]=(expected==0 || observed==0)?0:((int)10*log((observed/expected)));
          }
      }
 
  fprintf (fp,"# BLAST_MATRIX FORMAT\n#ALPHABET=%s\n#TRANSITION MATRIX TRAINED ON %d Sequence\n#", BLAST_AA_ALPHABET, S->nseq);
  for (a=0; a< naa; a++)fprintf ( fp, "%3c ", toupper(aa[a]));
  fprintf (fp,"\n");
  for (a=0; a< naa; a++)
    {
      
      fprintf (fp, "%c", toupper(aa[a]));
      for ( b=0; b< naa; b++)
        {
          fprintf (fp, "%3d ", mat[(int)aa[a]][(int)aa[b]]);
        }
      fprintf ( fp, "\n");
    }
  vfclose (fp);
  vfree (count);
  vfree (aa);
  
  return mat;
}
 
double* mat2cmp ( int **mat1, int **mat2)
{
  int a, b, n, x, y;
  double **list, *r;
  if ( !mat1 || !mat2)
    {
      fprintf ( stderr, "\nERROR: mat2cmp needs two matrices [FATAL:%s]", PROGRAM);
      myexit (EXIT_FAILURE);
    }
  
  for (n=0, a=0; a< 256; a++)
    for ( b=0; b<256; b++)
      {
        x=mat1[a][b];
        y=mat2[a][b];
        if ( x|| y)n++;
      }
  if ( n==0) return 0;
  list=declare_double (n, 2);
  
  for (n=0, a=0; a<256; a++)
    for ( b=0; b<256; b++)
      {
        x=mat1[a][b];
        y=mat2[a][b];
        if ( x || y)
          {
            list[n][0]=x;
            list[n][1]=y;
            n++;
          }
      }
  r=return_r (list, n);
  free_double(list, -1);
  return r;
}
   
int ** read_blast_matrix ( char *mat_name)
        {
        FILE *fp;
        int n_aa,aa1, aa2;
        int a, b, c;
        int **matrix;
        int value;
        char sbuf[VERY_LONG_STRING];
        char buf[2];
        char alp[257];

        matrix=declare_int (256,256);
        vfree ( matrix[30]);
        matrix[30]=vcalloc(10000, sizeof (int));
        fp=vfopen ( mat_name, "r");
        while ( (c=fgetc(fp))=='#' || isspace(c) )
          {
            char *p;
            fgets ( sbuf, VERY_LONG_STRING, fp);
            if ( (p=strstr (sbuf, "ALPHABET")))
              sscanf (p, "ALPHABET=%s", alp);
        }
        ungetc(c, fp);
        lower_string (alp);
        n_aa=strlen (alp);

        for ( a=0; a< n_aa; a++)
            {
            fscanf ( fp, "%s ", buf);

            aa1=tolower(buf[0]);
            
            if ( aa1!=alp[a])
                {
                fprintf ( stderr, "\nParsing_error when reading blast_matrix %s:\n%c %c",mat_name, aa1,alp[a]);
                fprintf ( stderr, "\n%c ", fgetc(fp));
                myexit (EXIT_FAILURE);
                }
            for ( b=0; b<n_aa; b++)
                {
                aa2=tolower ((char) alp[b]);
                fscanf ( fp, "%d ", &value);
                if (is_gap(aa1) || is_gap(aa2))
                  {
                    int c1, c2;
                    c1=(is_gap(aa1))?GAP_CODE:aa1;
                    c2=(is_gap(aa2))?GAP_CODE:aa2;
                    if ( c1==GAP_CODE && c2==GAP_CODE)
                      matrix[c1][c2]=value;
                    else if ( c1==GAP_CODE)
                      {
                        matrix[c1][tolower(c2)]=value;
                        matrix[c1][toupper(c2)]=value;
                      }
                    else
                      {
                        matrix[tolower(c1)][c2]=value;
                        matrix[toupper(c1)][c2]=value;
                      }
                  }
                else if ( aa1!='*' && aa2!='*')
                  {
                    matrix[tolower(aa1)-'A'][tolower(aa2)-'A']=value;
                    matrix[toupper(aa1)-'A'][toupper(aa2)-'A']=value;
                    matrix[tolower(aa1)-'A'][toupper(aa2)-'A']=value;
                    matrix[toupper(aa1)-'A'][tolower(aa2)-'A']=value;
                  }
                }
            fscanf(fp, "\n");
            }
        fclose (fp);

        return matrix;
        }

int output_blast_mat (int **mat, char *fname)
{
  return output_mat(mat, fname, BLAST_AA_ALPHABET, 'a');
  
}
int output_header_mat (int **mat, char *fname, char *alp)
{
  int a, b,l;
  FILE *fp;
  int naa;

  char raa[]="ABCDEFGHIKLMNPQRSTVWXYZ";
  char *aa;
  
  naa=strlen (raa);
  aa=vcalloc ( naa+2, sizeof (char));
  sprintf ( aa, "%s",raa);
  lower_string (aa);
  
  fp=vfopen (fname, "w");
  fprintf ( fp, "int new_mat[]={\n");
  l=strlen (aa);
  for (a=0; a<naa; a++)
    {
      for (b=0; b<=a; b++)
        {
          fprintf (fp, "%3d, ", mat[aa[a]-'a'][aa[b]-'a']);
        }
      fprintf (fp, "\n");
    }
  fprintf ( fp, "}");
  vfclose (fp);
}
int output_mat (int **mat, char *fname, char *alp, int offset)
{
  char *aa;
  int a,b, naa;
  FILE *fp;


  
  naa=strlen (alp);
  aa=vcalloc ( naa+2, sizeof (char));
  sprintf ( aa, "%s",alp);
  lower_string (aa);
  if (!(fp=vfopen (fname, "w")))return 0;
  fprintf (fp,"# BLAST_MATRIX FORMAT\n#ALPHABET=%s\n  ",alp);
  for (a=0; a< naa; a++)fprintf ( fp, "%5c ", toupper(aa[a]));
  fprintf (fp,"\n");
  for (a=0; a< naa; a++)
    {
      
      fprintf (fp, "%c", toupper(aa[a]));
      for ( b=0; b< naa; b++)
        {
          if (aa[a]!='*' && aa[b]!='*')
            fprintf (fp, " %5d", mat[aa[a]-offset][aa[b]-offset]);
          else 
            fprintf (fp, " %5d", 0);
        }
      fprintf ( fp, "\n");
    }
  vfree (aa);
  vfclose (fp);
  return 1;
}               

void output_pavie_mat (int **mat, char *fname, double gep, char *alp)
{
  int n, a, b;
  FILE *fp;
  
  n=strlen (alp);
  fp=vfopen (fname, "w");
  fprintf (fp,"# PAVIE_MATRIX FORMAT\n#ALPHABET=%s\n",alp);
  
  for(a=0; a< n; a++)
     {
       for ( b=a; b<n; b++)
        {         
          fprintf (fp, "%c %c %.3f\n", toupper(alp[a]), toupper(alp[b]), (float)mat[alp[a]-'A'][alp[b]-'A']/PAVIE_MAT_FACTOR);
        }
     }
   if ( gep!=UNDEFINED)fprintf ( fp, "- - %.3f\n", gep/PAVIE_MAT_FACTOR);
   vfclose(fp);
 }

int ** read_pavie_matrix ( char *mat_name)
        {
        FILE *fp;
        int c, n_aa;
        char aa1, aa2;
        float v;
        int **matrix;
        char sbuf[VERY_LONG_STRING];
        char alp[257];
        int gep=UNDEFINED;
        
        matrix=declare_int (256,256);
        
        
        fp=vfopen ( mat_name, "r");
        while ( (c=fgetc(fp))=='#' || isspace(c) )
          {
            fgets ( sbuf, VERY_LONG_STRING, fp);
            if ( sscanf (sbuf, "ALPHABET=%s", alp)==1);
          }
        ungetc(c, fp);
        
        n_aa=strlen (alp);
        while ( fgets ( sbuf, VERY_LONG_STRING, fp)!=NULL)
            {
              aa1=aa2='Z';
              if (sscanf (sbuf, "%c %c %f",&aa1, &aa2, &v)==3)
                {
                  v*=PAVIE_MAT_FACTOR;
                  if (aa1=='-' && aa2=='-')gep=v;
                  else
                    {
                      matrix[tolower(aa1)-'A'][tolower(aa2)-'A']=v;
                      matrix[toupper(aa1)-'A'][toupper(aa2)-'A']=v;
                      matrix[tolower(aa1)-'A'][toupper(aa2)-'A']=v;
                      matrix[toupper(aa1)-'A'][tolower(aa2)-'A']=v;
                      
                      matrix[tolower(aa2)-'A'][tolower(aa1)-'A']=v;
                      matrix[toupper(aa2)-'A'][toupper(aa1)-'A']=v;
                      matrix[tolower(aa2)-'A'][toupper(aa1)-'A']=v;
                      matrix[toupper(aa2)-'A'][tolower(aa1)-'A']=v;
                    }             
              }
            }
        if ( gep!=UNDEFINED)
          {
            int a;
            for (a=0; a< n_aa; a++)
              {
                if (!matrix[tolower(alp[a])-'A'][GAP_CODE])
                  {
                    matrix[tolower(alp[a])-'A'][GAP_CODE]=gep;
                    matrix[toupper(alp[a])-'A'][GAP_CODE]=gep;
                  }
              }
          }
        vfclose (fp);
        return matrix;
        }

Sequence *seq2year ( Sequence *S, int modulo)
{
  int a, b, y;
  int first;
  char *s;
  char new_channel[100];
  
  sprintf( new_channel, "_agechannel%d",modulo);
  
  for ( a=0; a<S->nseq; a++)
    {
      if (S->seq_comment[a] && (s=strstr(S->seq_comment[a], "_FIRSTYEAR")))
        {
          sscanf (s, "_FIRSTYEAR%d_", &first);
        }      
      else first=1;
     
      for ( y=first,b=0; b<S->len[a]; b++)
        {
          if ( !is_gap(S->seq[a][b]))
            {
              S->seq[a][b]='a'+((y/modulo))%10;
              y++;
            }
        }
      if ( (s=strstr ( S->name[a], "_agechannel")))
           {
             sprintf ( s, "%s", new_channel);
           }
      else strcat (S->name[a], new_channel);
    }
  return S;
}

Sequence* output_n_pavie_age_channel (Sequence *S, char *name, int n)
{
  int x, a;
  if (!n)n=2;
  

  for ( x=1,a=0; a< n; a++, x*=10)
    {
      S=output_pavie_age_channel(S, name,x);
    }
return S;
}
  



Sequence* output_pavie_age_channel (Sequence *S, char *name, int modulo)
  {
    Alignment *A;
    FILE *fp;
    static int display;
    char mat_list_name[100];
    char seq_list[1000];
    char mat_name[1000];
    char *tmp;
    
    sprintf ( mat_list_name, "%s_pavie_age_matrix.mat_list", name);
    sprintf (seq_list, "%s_age_channel.fasta",name);
    
    if ( display==0 )
      {
        if (check_file_exists(seq_list))vremove (seq_list);
        if (check_file_exists(mat_list_name))vremove (mat_list_name);
      }
    sprintf (mat_name, "%s_age_mat_mod%d.mat",name, modulo);
    output_age_matrix ( mat_name, modulo);
      
    fp=vfopen  ( mat_list_name,"a"); 
    fprintf ( fp, "%s\n", mat_name);
    vfclose ( fp);
    
    S=seq2year (S,modulo);
    A=seq2aln (S, NULL, KEEP_GAP);
    output_fasta_seq (tmp=vtmpnam (NULL),A);
    file_cat ( tmp, seq_list);
        
    if ( display==0)
      {
        display_output_filename ( stdout, "AGE_MAT_LIST", "MAT_LIST", mat_list_name, CHECK);
        display_output_filename ( stdout, "AGE_SEQ", "FASTA", seq_list, CHECK);
        display=1;
      }
    fprintf ( stderr, "\nModulo:%d years", modulo); 
    fprintf ( stderr, "\n");
    free_aln (A);
    return S;
  }
//
// Name MAnipulation
//

Alignment *clean_aln (Alignment *A)
{
  if ( A)
    {
      A->seq_comment=clean_string (A->nseq, A->seq_comment);
      A->aln_comment=clean_string (A->nseq, A->aln_comment);
      A->name=translate_names(A->nseq, A->name);
      (A->S)=clean_sequence ((A->S));
    }
  return A;
}
Sequence *clean_sequence ( Sequence *S)
{
  if ( !S) return S;
  
  S->seq_comment=clean_string (S->nseq, S->seq_comment);
  S->name=translate_names(S->nseq, S->name);
  return S;
}
char ** translate_names (int n, char **name)
{
  int a;
  for ( a=0; a<n; a++)
    name[a]=translate_name(name[a]);
  return name;
}
char * translate_name ( char *name)
        {

        int len;
        int a;
        char buf[1000];
        
        len=strlen (name);
                
        //if ( name[0]=='\'')return name;
        
        for ( a=0; a<len; a++)
                {
                if ( isspace(name[a]))name[a]='\0';
                else if (strchr (";(),:#><'�", name[a]))name[a]='_';
                
                }
        sprintf (buf,"%s",decode_name (name, DECODE));
        if ( strlen (buf)>read_array_size_new ((char *)name))
          {
            name=vrealloc (name, sizeof (char)*(strlen (buf)+1));
          }
        sprintf (name, "%s", buf);
        
        return name;
        }
char *decode_name (char *name, int mode)
{
  static char ***name_list;
  static int n;
  static char tag[100];
  int a;
  
  if (mode==CLEAN)
    {
      for (a=0; a<n; a++)
        {
          vfree (name_list[a][0]);
          vfree (name_list[a][1]);
          vfree (name_list[a]);
        }
      vfree (name_list);
      tag[0]='\0';
    }
  
  //spacial modes
  if ( mode == CODELIST)
    {
      char *file;
      file=vtmpnam (NULL);
      for (a=0; a< n; a++)
        printf_file(file, "a", "#CODE: %s <=> %s\n", name_list[a][0], name_list[a][1]);
      return file;
    }
  if (mode ==DECODE && name_list==NULL)return name;
  if ( name==NULL) return name;
  
        
  
  if (!tag[0])
    {
      vsrand (0);
      sprintf ( tag, "TCTAG_%d",rand ()%100000);
    }
  
  if ( mode==CODE)
    {
      for (a=0; a< n; a++)
        if ( strm (name, name_list[a][0]))return name_list[a][1];
     

      name_list=realloc (name_list, sizeof (char**)*(n+1));
      name_list[n]=vcalloc (2, sizeof (char*));
      name_list[n][0]=vcalloc (strlen (name)+1, sizeof (char));
      name_list[n][1]=vcalloc (100, sizeof (char));
      sprintf ( name_list[n][0], "%s", name);
      sprintf ( name_list[n][1], "%s_%d", tag,n+1);
      return name_list[n++][1];
    }
  else if ( mode ==DECODE)
    {
      char *p;
      int i;
      if ( !(p=after_strstr (name, tag)))return name;
      else 
        {
          sscanf (p, "_%d", &i);
          return name_list[i-1][0];
        }
    }
  else 
    {
      printf_exit (EXIT_FAILURE, stderr,"Unknown Mode for Decode_name [FATAL:%s]", PROGRAM);
    }
  return NULL;
}
      

FILE * display_sequences_names (Sequence *S, FILE *fp, int check_pdb_status, int print_templates)
        {
            int a;
            int max_len;
            char *r;
            
            if ( !S)
               {
                   fprintf (fp,"\nERROR: NO SEQUENCE READ [FATAL:%s]\n", PROGRAM); myexit (EXIT_FAILURE);
               }
            for ( a=0, max_len=0; a< S->nseq; a++)max_len=MAX(max_len, strlen (S->name[a]));
            fprintf ( fp, "\nINPUT SEQUENCES: %d SEQUENCES  [%s]", S->nseq,(S->type)?S->type:"Unknown type");
            for ( a=0; a< S->nseq; a++)
                {
                  fprintf (fp, "\n  Input File %-*s Seq %-*s Length %4d type %s",max_len,S->file[a], max_len,S->name[a],(int)strlen ( S->seq[a]), S->type);
                    if (check_pdb_status)
                      {
                        if ((r=seq_is_pdb_struc (S, a)))fprintf (fp, " Struct Yes PDBID %s", get_pdb_id(r));
                        else fprintf (fp, " Struct No");
                        /*
                        if (is_pdb_struc (S->name[a])||is_pdb_struc (S->file[a]) )fprintf (fp, " Struct Yes");
                        else fprintf (fp, " Struct No");
                        */
                      }
                    else fprintf (fp, " Struct Unchecked");
                    if ( print_templates)fp=display_sequence_templates (S, a, fp);
                    

                }
            fprintf ( fp, "\n");
            return fp;
            
        }
Sequence *add_file2file_list (char *name, Sequence *S)
{
  
  if (!S) S=declare_sequence (1,1,10);
  else S=realloc_sequence   (S,S->nseq+1,0);S->nseq=0;
 
  sprintf ( S->name[S->nseq++], "%s", name);
  return S;

}
#ifdef DO_PHECOMP
int parse_phecomp_data (char *in, char *out)
{
  static char *buffer;
  in=quick_find_token_in_file (in, "[EXPERIMENT HEADER]");
  while (fgets (buffer,fp,MAX_LINE_LENGTH));
}
FILE * quick_find_token_in_file  (FILE *fp, char *token)
{
  //returns fp pointing to the begining of the line FOLLOWING the line containing token 
  static char *buffer;
  if (!line) line=vcalloc (MAX_LINE_LENGTH+1, sizeof (char)); 
  while (fgets (buffer,MAX_LINE_LENGTH, fp)!=NULL)
    if (strstr (buffer,token))return fp;
  vfclose (fp);
  return NULL;
}

int * file2cage (char *file, int cage)
{
  









#endif
/******************************COPYRIGHT NOTICE*******************************/
/*© Centro de Regulacio Genomica */
/*and */
/*Cedric Notredame */
/*Fri Feb 18 08:27:45 CET 2011 - Revision 596. */
/*All rights reserved.*/
/*This file is part of T-COFFEE.*/
/**/
/*    T-COFFEE is free software; you can redistribute it and/or modify*/
/*    it under the terms of the GNU General Public License as published by*/
/*    the Free Software Foundation; either version 2 of the License, or*/
/*    (at your option) any later version.*/
/**/
/*    T-COFFEE is distributed in the hope that it will be useful,*/
/*    but WITHOUT ANY WARRANTY; without even the implied warranty of*/
/*    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the*/
/*    GNU General Public License for more details.*/
/**/
/*    You should have received a copy of the GNU General Public License*/
/*    along with Foobar; if not, write to the Free Software*/
/*    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA*/
/*...............................................                                                                                      |*/
/*  If you need some more information*/
/*  cedric.notredame@europe.com*/
/*...............................................                                                                                                                                     |*/
/**/
/**/
/*      */
/******************************COPYRIGHT NOTICE*******************************/