#define FILE_CHECK 1
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>
#include <limits.h>
#include <float.h>
#include <math.h>
#include <stdarg.h>
#include <fcntl.h>
#include <sys/file.h>


#include "io_lib_header.h"
#include "util_lib_header.h"
#include "define_header.h"
#include "perl_header_lib.h"

int my_vsscanf(char *buf, char *fmt, va_list parms);
static int get_vtmpnam2_root();

static char CACHE_4_TCOFFEE[1000];
static char TMP_4_TCOFFEE[1000];
static char DIR_4_TCOFFEE[1000];
static int global_exit_signal;
static int no_error_report;
/*********************************************************************/
/*                                                                   */
/*                                  DICHOTOMY                        */
/*                                                                   */
/*                                                                   */
/*********************************************************************/
double dichotomy (double value, double target_value, double middle, double *bottom,double *top)
{
  if ( value> target_value)top[0]=middle;
  else if ( value<target_value)bottom[0]=middle;
  return (top[0]-bottom[0])/2+bottom[0];
}


/*********************************************************************/
/*                                                                   */
/*                                   QSORT                           */
/*                                                                   */
/*                                                                   */
/*********************************************************************/

#define MAXSTACK (sizeof(size_t) * CHAR_BIT)
static void exchange(void *a, void *b, size_t size) {
    size_t i;
    int *ia;
    int *ib;
    char *ca;
    char *cb;
    
    /******************
     *  exchange a,b  *
     ******************/
    ia=(int*)a;
    ib=(int*)b;
    for (i = sizeof(int); i <= size; i += sizeof(int)) {
        int t =ia[0];
	ia[0]=ib[0];
	ib[0]=t;
	ia++; ib++;
    
    }
    ca=(char*)ia;
    cb=(char*)ib;
    for (i = i - sizeof(int) + 1; i <= size; i++) {
        
        char t=ca[0];
	ca[0]=cb[0];
	cb[0]=t;
	ca++;cb++;

    }
}

void qsort(void *base, size_t nmemb, size_t size,
        int (*compar)(const void *, const void *)) {
    void *lbStack[MAXSTACK], *ubStack[MAXSTACK];
    int sp;
    unsigned int offset;

    /********************
     *  ANSI-C qsort()  *
     ********************/

    lbStack[0] = (char *)base;
    ubStack[0] = (char *)base + (nmemb-1)*size;
    for (sp = 0; sp >= 0; sp--) {
        char *lb, *ub, *m;
        char *P, *i, *j;

        lb = lbStack[sp];
        ub = ubStack[sp];

        while (lb < ub) {

            /* select pivot and exchange with 1st element */
            offset = (ub - lb) >> 1;
            P = lb + offset - offset % size;
            exchange (lb, P, size);

            /* partition into two segments */
            i = lb + size;
            j = ub;
            while (1) {
                while (i < j && compar(lb, i) > 0) i += size;
                while (j >= i && compar(j, lb) > 0) j -= size;
                if (i >= j) break;
                exchange (i, j, size);
                j -= size;
                i += size;
            }

            /* pivot belongs in A[j] */
            exchange (lb, j, size);
            m = j;

            /* keep processing smallest segment, and stack largest */
            if (m - lb <= ub - m) {
                if (m + size < ub) {
                    lbStack[sp] = m + size;
                    ubStack[sp++] = ub;
                }
                ub = m - size;
            } else {
                if (m - size > lb) {
                    lbStack[sp] = lb; 
                    ubStack[sp++] = m - size;
                }
                lb = m + size;
            }
        }
    }
}

int pstrcmp(char *p1, char *p2);



/*********************************************************************/
/*                                                                   */
/*                                   HEAPSORT                           */
/*                                                                   */
/*                                                                   */
/*********************************************************************/
FILE * hsort_file ( FILE *fp,int n,int len, size_t size,int first_comp_field, int n_comp_fields,int (*compare)(const void *, const void*,int, int, size_t),void * (*copy)(void *,void*, size_t))
     {
     unsigned long i, ir, j, l;
     void *rra, *rrb, *ra_j, *ra_j_1;
     void *tp;
     long  start;
     int FE=1;
     
    
    
     start=ftell(fp);
     rra   =vcalloc ( len, size);
     rrb   =vcalloc ( len, size);
     ra_j  =vcalloc ( len, size);
     ra_j_1=vcalloc ( len, size);

     if ( n<2)return fp;
     l=(n >>1)+1;
     ir=n;

     for (;;)
         {
	 if ( l>FE)
	    {
	    l--;
	    fseek( fp, start+(((l-1)*len)*size), SEEK_SET);
	    fread( rra, size, len,fp); /*rra=ra[--l]*/
	    }
	 else
	    {
	    fseek( fp, start+((ir-1)*len*size), SEEK_SET);
	    fread( rra, size, len,fp); /*rra=ra[ir]*/
	    
	    fseek( fp, start, SEEK_SET);
	    fread( rrb, size, len,fp); /*rrb=ra[0]*/
	    
	    fseek( fp, start+((ir-1)*len*size), SEEK_SET);
	    fwrite(rrb,size, len, fp); /*ra[ir]=rrb=ra[0]*/ 

	    if (--ir ==FE)
	       {
	       fseek ( fp,start, SEEK_SET);
	       fwrite(rra,size, len, fp); /*ra[0]=rra*/ 
	       break;
	       }
	    }	      
	 i=l;
	 j=l+l;
	 while ( j<=ir)
	       {
	       fseek ( fp, start+((j-1)*len*size), SEEK_SET);
	       fread (ra_j, size, len, fp);
	       
	       if ( j<ir)
	          {
		  fseek ( fp, start+(((j-1)+1)*len*size), SEEK_SET);
		  fread (ra_j_1, size, len, fp);
		  }

	       if ( j<ir && compare( ra_j, ra_j_1,first_comp_field,n_comp_fields, size )<0)
		   {
		   SWAPP(ra_j, ra_j_1, tp);
		   j++;
		   }

	       if (compare(rra, ra_j, first_comp_field,n_comp_fields, size)<0)
	               {
		       fseek ( fp, start+((i-1)*len*size), SEEK_SET);
		       fwrite(ra_j,size, len, fp);
		       i=j;
		       j<<= 1;
		       }
	       else
		       j=ir+1;
	       
	       }
	 fseek ( fp, start+((i-1)*len*size), SEEK_SET);
	 fwrite(rra,size, len, fp);	
	 }
     vfree (  rra);
     vfree ( rrb);

     vfree (  ra_j);
     vfree (  ra_j_1);
     return fp;
     }
void ** hsort_array ( void **ra,int n,int len, size_t size,int first_comp_field, int n_comp_fields,int (*compare)(const void *, const void*,int, int, size_t),void * (*copy)(void *,void*, size_t))
     {
     unsigned long i, ir, j, l;
     void *rra;
     int FE=1;
     
     if ( FE==1){ra--;}
     else
     {
     n--;
     }

     
     rra   =vcalloc ( len, size);
    
     
     if ( n<2)return ra;
     l=(n >>1)+1;
     ir=n;

     for (;;)
         {
	 if ( l>FE)
	    {
	    copy ( rra, ra[--l],len);
	    }
	 else
	    {	   
	    copy ( rra, ra[ir],len);
	    copy ( ra[ir], ra[FE], len);
	    if (--ir ==FE)
	       {
	       copy ( ra[FE],rra,len);
	       break;
	       }
	    }
	 i=l;
	 j=l+l;
	 while ( j<=ir)
	       {	       
	       if ( j<ir && compare( ra[j], ra[j+1],first_comp_field,n_comp_fields, size )<0)j++;
	       if (compare(rra, ra[j], first_comp_field,n_comp_fields, size)<0)
	               {copy(ra[i], ra[j],len);i=j;j<<= 1;}
	       else
		       j=ir+1;	       
	       }
	 copy( ra[i], rra,len);	 
	 }
     vfree (rra);
     ra+=FE;
     
     return ra;
     }
/*********************************************************************/
/*                                                                   */
/*                         CEDRIC BSEARCH                            */
/*                                                                   */
/*                                                                   */
/*********************************************************************/
void * bsearch_file ( const void *key,int *p,int comp_first,int comp_len, FILE *fp,int len, int entry_len,size_t el_size, int (*compare)(const void *, const void*,int, int, size_t))
       {
       int upper, lower, c, i;
       static void *key2;
       long start;
       static long key2_size;


       start=ftell(fp);

       upper=-1;
       lower=len;
       if ( key2==NULL){key2=vcalloc (entry_len, el_size);key2_size=entry_len* el_size;}
       else if (key2_size<  (entry_len* el_size)){vfree(key2);key2=vcalloc (entry_len, el_size);key2_size=entry_len* el_size;} 

       while ((lower-upper)>1)
             {
	     i=(lower+upper) >> 1;

	     fseek ( fp,start+(i*el_size*entry_len), SEEK_SET); 
	     fread ( key2, el_size, entry_len,fp);	     
	     c=compare(key2,key, comp_first, comp_len,el_size);
	     
	     if      ( c==0){p[0]=i;return key2;}
	     else if ( c< 0)upper=i;
	     else if ( c> 0)lower=i;
             }
       return NULL;
       }

void * bsearch_array ( const void *key,int *p,int comp_first, int comp_len,void**list,int len, int entry_len,size_t el_size, int (*compare)(const void *, const void*,int, int, size_t))
       {
       int upper, lower, c, i;
       void *key2;
       
       upper=-1;
       lower=len;
       while ((lower-upper)>1)
             {
	     i=(lower+upper) >>1;
	     key2=list[i];	     
	     c=compare(key2,key, comp_first,comp_len,el_size);
	     
	     if      ( c==0){p[0]=i;return key2;}
	     else if ( c< 0)upper=i;
	     else if ( c> 0)lower=i;
             }
       return NULL;
       }	             
		     
/**********************************************************************/
/*                                                                    */
/*                         HSORT/BSEARCH WRAPPERS                             */
/*                                                                    */
/*                                                                    */
/**********************************************************************/
void **search_in_list_file ( void *key, int *p,int comp_len,FILE *fp, int len, size_t size, int entry_len)  
      {
      static void **l;	
      

      if ( l==NULL)l=vcalloc ( 1, sizeof (int*));
	
      l[0]=bsearch_file (key,p,0,comp_len,fp,len,entry_len,size,hsort_cmp);  
      if (l[0]==NULL)return NULL;
      else return l;
      }
void **search_in_list_array ( void *key,int *p, int comp_len,void **L, int len, size_t size, int entry_len)  
      {
      static void **l;
 
      if ( l==NULL)l=vcalloc ( 1, sizeof (int*));	
      
      l[0]=bsearch_array (key,p,0,comp_len,L,len,entry_len,size,hsort_cmp);  
      if (l[0]==NULL)return NULL;
      else return l;
      }
void **hsort_list_array ( void **L, int len, size_t size, int entry_len, int first_comp_field, int n_comp_fields)  
       {
	 return hsort_array (L, len,entry_len, size,first_comp_field, n_comp_fields,hsort_cmp , hsort_cpy);
       }
FILE  *hsort_list_file ( FILE*fp  , int len, size_t size, int entry_len, int first_comp_field, int n_comp_fields)  
       {

       return hsort_file (fp, len,entry_len, size,first_comp_field, n_comp_fields,hsort_cmp , hsort_cpy);
       }

int hsort_cmp ( const void *a, const void *b, int first, int clen, size_t size)
       {
       int*ax;
       int*bx;
       int p;
       
       ax=(int*)a;
       bx=(int*)b;
       for ( p=first; p<clen+first; p++)
	   {
	   if ( ax[p]<bx[p])return -1;
	   else if ( ax[p]==bx[p]);
	   else return 1;
	   }
       return 0;
       }
void *hsort_cpy(void*to, void *from, size_t size)
       {
       
       int *ax;
       int *bx;
       int p;
       ax=(int*)to;
       bx=(int*)from;
       for (p=0; p<(int)size; p++)
	   ax[p]=bx[p];
       
       
       return to;
      
       }
       
       
void test_hsort_list_array()
      {
      int **array;
      int a;
      int n=100;

      array=declare_int(n, 3);
      for ( a=0; a<n; a++)array[a][0]=a;
      
      hsort_list_array( (void**)array,n, sizeof (int), 3, 0, 1);
      for ( a=0; a<n; a++)fprintf ( stderr, "\n%d %d", array[a][0],a);
      myexit(EXIT_FAILURE);
      }
      

/*********************************************************************/
/*                                                                   */
/*                         B_SEARCH_FILE FUNCTIONS                   */
/*                                                                   */
/*                                                                   */
/*********************************************************************/		 

/*********************************************************************/
/*                                                                   */
/*                         SORT/COMPARE/SEARCH FUNCTIONS             */
/*                                                                   */
/*                                                                   */
/*********************************************************************/
static int sort_field;
int **search_in_list_int ( int *key, int k_len, int **list, int ne)
	{
	int **l;		
	sort_field=k_len;	
	l=bsearch (&key,list, ne, sizeof(int**),(int(*)(const void*,const void*))(cmp_list_int));  
	return l;
	}
void sort_float ( float **V,int N_F, int F, int left, int right)
	{
	sort_field=F;
	qsort ( V, right+1, sizeof(int**),(int(*)(const void*,const void*))(cmp_int));
	}
int cmp_float ( const float **a, const float **b)
	{
	if ( a[0][sort_field]< b[0][sort_field])return-1;
	else if ( a[0][sort_field]==b[0][sort_field])return 0;
	else return 1;
	}

void sort_int_1D ( int *L, int n)
	{
	int **array;
	int a;
	
	array=declare_int ( n, 1);
	for ( a=0; a< n; a++)
		array[a][0]=L[a];
	sort_int ( array, 1, 0, 0, n-1);
	for ( a=0; a< n; a++)
		L[a]=array[a][0];
	free_int ( array, n);
	}

char** sort_string_array (char **V, int n)     
{
  
  
  qsort ( V,n,sizeof (char*),(int(*)(const void*,const void*))(pstrcmp));
  return V;

 
}

int pstrcmp(char *p1, char *p2)
{
  return strcmp(*(char **)p1, *(char **)p2);
}
void sort_int ( int **V,int N_F, int F, int left, int right)
	{
	  if (!V)return;
	sort_field=F;
	qsort ( V, (right-left)+1, sizeof(int**),(int(*)(const void*,const void*))(cmp_int));
	}
void sort_list_int ( int **V,int N_F, int F, int left, int right)
        {
	if (!V)return;
	sort_field=F;
	qsort ( V, (right-left)+1, sizeof(int**),(int(*)(const void*,const void*))(cmp_list_int));
	}
static int *order;
void sort_list_int2 ( int **V,int *list,int N_F, int left, int right)
        {
	  // just like sort_int_list, but uses list to to order the comparison of the keys
	  if (!V)return;
	order=list;
	
	qsort ( V, (right-left)+1, sizeof(int**),(int(*)(const void*,const void*))(cmp_list_int2));
	}
int cmp_list_int2 (const int**a, const int**b)
	{
	  int p=0;;
	  int c;

	  

	  while ((c=order[p])!=-1)
	  {
	    if ( a[0][c]>b[0][c])return   1;
	    else if ( a[0][c]<b[0][c])return  -1;
	    p++;
	  }
	return 0;
	}
void sort_int_inv ( int **V,int N_F, int F, int left, int right)
	{
	int a,b;
	int **list;
	if (!V)return;
	sort_field=F;
	qsort ( V, (right-left)+1, sizeof(int**),(int(*)(const void*,const void*))(cmp_int));
	
	list=declare_int ((right-left)+1, N_F);
	for ( a=left; a< (right-left)+1; a++)
		{
		for ( b=0; b< N_F; b++)
			{
			list[a-left][b]=V[a][b];
			}
		}
	for ( a=left; a< (right-left)+1; a++)
		{
		for ( b=0; b< N_F; b++)
			V[a][b]=list[(right-left)-a][b];
		}
	free_int (list, -1);
	}
	
void sort_list_int_inv ( int **V,int N_F, int F, int left, int right)
	{
	int a,b;
	int **list;
	if (!V)return;
	sort_field=F;
	qsort ( V, (right-left)+1, sizeof(int**),(int(*)(const void*,const void*))(cmp_list_int));
	
	list=declare_int ((right-left)+1, N_F);	
	for ( a=left; a< (right-left)+1; a++)
		{
		for ( b=0; b< N_F; b++)
			{
			list[a-left][b]=V[a][b];
			}
		}
	for ( a=left; a< (right-left)+1; a++)
		{
		for ( b=0; b< N_F; b++)
			V[a][b]=list[(right-left)-a][b];
		}
	free_int (list, -1);
	}	
	


int cmp_int ( const int**a, const int**b)
	{
	if ( a[0][sort_field]< b[0][sort_field])return-1;
	else if ( a[0][sort_field]==b[0][sort_field])return 0;
	else return 1;
	}
int cmp_list_int (const int**a, const int**b)
	{
	int c;
	int undef=0;
	int ret;
	
	for ( c=0; c<=sort_field; c++)
		{
		if ( a[0][c]==UNDEFINED|| b[0][c]==UNDEFINED)ret=0;
		else if ( a[0][c]>b[0][c])return   1;
		else if ( a[0][c]<b[0][c])return  -1;
		}
	if (undef==sort_field)
		{
		  if (a[0][0]==b[0][0])return 0;
		}
	return 0;
	}


int name_is_in_list ( char *name, char **name_list, int n_name, int len)
	{
	int a;
	int pos=-1;
	/*Note: RETURNS THE Offset of the LAST Occurence of name in name_list*/
	
	if ( name_list==NULL || name ==NULL)return -1;
	

	for ( a=0; a< n_name; a++)
	  {
	    if ( name_list[a]==NULL);
	    else if ( len!=-1)
	      {
		if (strncmp ( name, name_list[a], len)==0)pos=a;	
	      }
	    else if ( strm ( name, name_list[a]))pos=a;
	  }
	return pos;
	}
char * check_list_for_dup ( char **list, int ne)
        {
	int a, b;
	
	for ( a=0; a< ne-1; a++)
	    for ( b=a+1; b< ne; b++)if (strm ( list[a], list[b]))return list[a];
	return NULL;
	}
FILE *get_number_list_in_file ( FILE *fp, int *list, int *n, int *max_len)
	{
	
	int c;
	
	while ( isspace((c=fgetc (fp))));
	ungetc(c, fp);
	while ( c!='\n')
		{
		while ( isspace((c=fgetc (fp))) && c!='\n');
		
		if ( c!='\n')
			{
			ungetc(c, fp);
			if ( n[0]>=max_len[0])
				list=vrealloc ( list, (n[0]+100)*sizeof (int));
				max_len[0]=(n[0]+100);
			
			fscanf ( fp, "%d",&list[n[0]++]);
			}
		}
	return fp;
	}
/*********************************************************************/
/*                                                                   */
/*                         QUANTILE                                  */
/*                                                                   */
/*                                                                   */
/*********************************************************************/
int quantile (int argc, char *argv[])
{
  FILE *fp;
  int a,n,c, t;
  int **list; 
  char ***  string_list;
  char *name, s1[1000], s2[1000];


  if ( argc<2)
    {

      fprintf (stderr, "\nquantile <fname> <quant: 0.00-1.00> [<top | bottom>]");
      fprintf (stderr, "\nSplits your data in two according to the quantile");
      fprintf (stderr, "\nReturns the top quantile or the bottom quantile");
      fprintf (stderr, "\nData must be in <fname> with two fields/line: Field1=index, Field2=value\n");
      fprintf (stderr, "\n1 27\n2 46\n3 5\n...\n");
      fprintf (stderr, "\nValue can either be integer or float");
      
      
      myexit (EXIT_FAILURE);
    }
  
  if (strm (argv[1], "stdin"))
    {
      name=vtmpnam(NULL);
      fp=vfopen (name, "w");
      while ( (c=fgetc(stdin))!=EOF)
	{
	  fprintf ( fp, "%c", c);
	}
      vfclose (fp);
    }
  else
    name=argv[1];
  
  


  n=count_n_line_in_file (name);
  list=declare_int (n, 2);
  string_list=declare_arrayN(3,sizeof (char), n, 2, 10);
  
  fp=vfopen (name, "r");
  n=0;
  while ( (c=fgetc (fp))!=EOF)
    {
      ungetc(c,fp);
      fscanf ( fp, "%s %s\n", s1, s2);
      list[n][0]=(int)(atof(s1)*1000);
      list[n][1]=(int)(atof(s2)*1000);
      list[n][2]=n;
      
      sprintf (string_list[n][0],"%s",s1);
      sprintf (string_list[n][1],"%s",s2);

      
      n++;
    }
  sort_int_inv ( list,3, 1, 0, n-1);
  t=quantile_rank ( list,1,n, atof (argv[2]));
  if ( argc!=4 || (argc==4 && strm (argv[3], "bottom")))
    {
      for (a=t; a<n; a++)
	fprintf ( stdout, "%s %s\n", string_list[list[a][2]][0], string_list[list[a][2]][1]); 
    }
  else
    {
      for ( a=0; a<t; a++)
	fprintf ( stdout, "%s %s\n", string_list[list[a][2]][0], string_list[list[a][2]][1]);
    }
  
  fprintf (stderr, "\nQuantile %.2f T= %d Out of N= %d entries\n", atof (argv[2]), t, n), 
  free_int (list, -1);
  return n;

}
  
int quantile_rank (int **list,int field, int n, float p)
{
  int nr;
  
  
  if ( p==1) nr=0;
  else if ( p==0) nr=n;
  else
    {
      int a, b,j, *l;
      double g, q, np, i_part;
      l=vcalloc ( n, sizeof (int));
      for (a=n-1, b=0; b<n; a--, b++)
	l[b]=list[a][field];
            
      np=(double)n*(double)p;
      g=modf (np, &i_part);
      j=(int)i_part;
      j--;
      
      q=(float)l[j]+g*((float)l[j+1]-(float)l[j]);
      
      nr=0;
      while (nr<n && list[nr][field]>=q)nr++;
      vfree(l);
    }
  return nr;
}
/*********************************************************************/
/*                                                                   */
/*                         DUPLICATION                               */
/*                                                                   */
/*                                                                   */
/*********************************************************************/
short* ga_memcpy_short ( short *array1, short *array2, int n)
	{
	int a;
	
	for ( a=0; a< n; a++)
		array2[a]=array1[a];
	
	return array2;
	}
int * ga_memcpy_int ( int *array1, int *array2, int n)
	{
	int a;
	
	for ( a=0; a< n; a++)
		array2[a]=array1[a];
	
	return array2;
	}			
			
float* ga_memcpy_float ( float *array1, float *array2, int n)
	{
	int a;
	
	for ( a=0; a< n; a++)
		array2[a]=array1[a];
	
	return array2;
	}
double*  ga_memcpy_double (double *array1, double*array2, int n)
	{
	int a;
	
	for ( a=0; a< n; a++)
		array2[a]=array1[a];
	
	return array2;
	}



/*recycle: get the bottom pointer on the top of the heap*/

void ** recycle (void **A, int l, int cycle)
{
  void **B;
  int a,b,c;
  B=vcalloc (l, sizeof (void*));
 
  for ( c=0; c< cycle; c++)
    {
      for ( a=1, b=0; a<l; a++, b++) B[b]=A[a];
      B[l-1]=A[0];
      for ( a=0; a<l; a++)A[a]=B[a];
    }
  vfree (B);
  return A;
} 

/* Old READ/WRITE ARRAY SIZE*/
/*
#define WRITE_SIZE(type,function)\
void function ( int x, type *array, int os)\
     {\
     int a,l;\
     char buf[SIZE_OF_INT+1];\
     array+=os*SIZE_OF_INT;\
     for ( a=0;a<SIZE_OF_INT; a++)array[a]=0;\
     sprintf ( buf, "%d", x);\
     l=strlen (buf);\
     array+=SIZE_OF_INT-l;\
     for (a=0; a<l; a++)array[a]=(type)buf[a];\
     }
WRITE_SIZE(short,write_size_short)
WRITE_SIZE(char,write_size_char)
WRITE_SIZE(int,write_size_int)
WRITE_SIZE(float,write_size_float)
WRITE_SIZE(double,write_size_double)

#define READ_ARRAY_SIZE(type, function)\
int function (type *array, int os)\
    {\
    int a, b;\
    char buf[SIZE_OF_INT+1];\
    a=b=0;\
    array+=os*SIZE_OF_INT;\
    while ( a!=SIZE_OF_INT && array[a]==0)a++;\
    while ( a!=SIZE_OF_INT)buf[b++]=(char)array[a++];\
    buf[b]='\0';\
    return atoi(buf);\
    }
READ_ARRAY_SIZE(short,read_size_short)
READ_ARRAY_SIZE(char,read_size_char)
READ_ARRAY_SIZE(int,read_size_int)
READ_ARRAY_SIZE(float,read_size_float)
READ_ARRAY_SIZE(double,read_size_double)
*/
/*********************************************************************/
/*                                                                   */
/*                          DUPLICATION                              */
/*                                                                   */
/*                                                                   */
/*********************************************************************/

#define SET_NUMBERS(type,function)\
type * function(type *list,int n, ...)\
     {\
     type *buf;\
     int  *index,i;\
     va_list ap;\
     int max;\
\
     va_start(ap, n);\
     buf=vcalloc(n, sizeof(type));\
     index=vcalloc(n, sizeof(int));\
     max=0;\
     for ( i=0; i< n; i++)\
         {\
	 buf[i]  =va_arg(ap,type);\
	 index[i]=va_arg(ap, int);\
	 if (index[i]>max)max=index[i];\
	 }\
     va_end(ap);\
     if (list==NULL)list=vcalloc ( max+1, sizeof (type));\
     for ( i=0; i<n; i++)list[index[i]]=buf[i];\
     vfree(buf);\
     vfree(index);\
     return list;\
     }
     /*SET_NUMBERS(short ,set_short)*/
     /*SET_NUMBERS(char  ,set_char)*/
SET_NUMBERS(int   ,set_int)
     /*SET_NUMBERS(float ,set_float)*/
SET_NUMBERS(double,set_double)

short ** duplicate_short ( short **array , int len, int field)
    {
    return copy_short (array ,declare_short ( len, field),  len, field);
    }
int ** duplicate_int ( int **array , int len, int field)
    {
    return copy_int (array ,declare_int ( len, field),  len, field);
    }
char ** duplicate_char ( char **array , int len, int field)
    {
    return copy_char (array ,declare_char ( len, field),  len, field);
    }
char * duplicate_string ( char *string)
    {
      int l;
      char *buf=NULL;
      
      l=strlen (string);
      
      if ( !l);
      else
	{
	  buf=vcalloc ( l+1, sizeof(char));
	  sprintf ( buf, "%s", string);
	}
      return buf;
    }
float ** duplicate_float ( float **array , int len, int field)
    {
    return copy_float (array ,declare_float ( len, field),  len, field);
    }
double ** duplicate_double ( double **array , int len, int field)
    {
    return copy_double (array ,declare_double ( len, field),  len, field);
    }



/*********************************************************************/
/*                                                                   */
/*                           COPY OF 2D ARRAY                        */
/*                                                                   */
/*                                                                   */
/*********************************************************************/
short ** copy_short( short **array1, short  **array2, int len, int number_field)
    {
    int a;
    
    if ( len==-1)len=read_array_size (array1,sizeof (short*));
    if ( number_field==-1)number_field=read_array_size (array1[0],sizeof (short));
    if ( array2)free_short ( array2, -1);
    array2=declare_short ( len, number_field);

    for ( a=0; a< len; a++)
	ga_memcpy_short( array1[a],array2[a],number_field);
    
    return array2;
    }
char ** copy_char ( char **array1, char **array2, int len, int number_field)
    {
    int a;
    
    if ( array1==NULL)return NULL;
    if ( len==-1)len=read_size_char (array1,sizeof (char*));
    if ( number_field==-1)
	{
	number_field=read_size_char (array1[0],sizeof(char));
	for ( a=0; a< len; a++)
	    number_field=MAX(number_field, strlen ( array1[a]))+1;
	}
    
    if ( array2)free_char (array2, -1);
    array2=declare_char(len, number_field);
    
    for ( a=0; a< len; a++)
      sprintf ( array2[a], "%s", array1[a]);

    return array2;
    } 
int ** copy_int ( int **array1, int **array2, int len, int number_field)
    {
    int a;
    
    if ( array1==NULL) return NULL;
    if ( len==-1)len=read_size_int (array1, sizeof (int*));
    if ( number_field==-1)number_field=read_size_int (array1[0],sizeof (int));
    
    
    
    if (array2)free_int (array2, -1);
    array2=declare_int ( len, number_field);

    for ( a=0; a< len; a++)
	ga_memcpy_int( array1[a],array2[a],number_field);
    
    return array2;
    }

float ** copy_float ( float **array1, float **array2, int len, int number_field)
    {
    int a;
    
    if ( array1==NULL) return NULL;
    if ( len==-1)len=read_size_float (array1,sizeof (float*));
    if ( number_field==-1)number_field=read_size_float (array1[0],sizeof (float));

    if ( array2)free_float (array2, -1);
    array2=declare_float ( len, number_field);
    
    for ( a=0; a< len; a++)
	ga_memcpy_float( array1[a],array2[a],number_field);
    return array2;
    }
double ** copy_double (double **array1, double **array2, int len, int number_field)
    {
    int a;

    if ( array1==NULL) return NULL;
    if ( len==-1)len=read_size_double (array1,sizeof (double*));
    if ( number_field==-1)number_field=read_size_double (array1[0], sizeof (double));
    if ( array2)free_double (array2, -1);
    array2=declare_double ( len, number_field);

    for ( a=0; a< len; a++)
	ga_memcpy_double( array1[a],array2[a],number_field);
    return array2;
    }
/*********************************************************************/
/*                                                                   */
/*                        CONCATENATION                              */
/*                                                                   */
/*                                                                   */
/*********************************************************************/





Alignment ** cat_aln_list ( Alignment **list_to_cat,int first, int end, Alignment **rec_list)
    {
    int rec_list_start;
    int a, b;

    if ( list_to_cat==NULL)return rec_list;
    else
       {
       rec_list_start=(rec_list[-1])->nseq;       
       rec_list=realloc_aln_array ( rec_list, end-first);      
       for ( a=first, b=rec_list_start; a<end; a++, b++)copy_aln (list_to_cat[a], rec_list[b]);      
       free_aln_array ( list_to_cat);      
       return rec_list;
       }
    }
	   
/*********************************************************************/
/*                                                                   */
/*                         NUMBER ARRAY ANALYSE                      */
/*                                                                   */
/*                                                                   */
/*********************************************************************/

FILE * output_array_int (int  **array, int len, int nf ,FILE *fp)
     {
     int a, b;
     for ( a=0; a<len; a++)
         {fprintf ( fp, "\n");
	    for (b=0; b<nf; b++)fprintf (fp, "%5d ", array[a][b]);
     
	 }
     fprintf ( fp, "\n");
     return fp;
     }
#define RETURN_MAX_COOR(type,wf,rf,function,comparison,undef)\
type function ( type ** array, int len_array, int field, int *coor)\
    {\
    type max;\
    int a;\
\
    if (array==NULL || len_array==0)return 0;\
    else\
        {\
        len_array=rf(array,sizeof (type*));\
        max=array[0][field];\
        coor[0]=0;\
        for ( a=1; a< len_array; a++)\
	      if ( max==undef)max=array[a][field];\
	      else if ( array[a][field]!=undef)\
		   if (array[a][field] comparison max)\
		       {max=array[a][field];\
                        coor[0]=a;\
	                }\
	 }\
    return max;\
    }

RETURN_MAX_COOR(short,write_size_short,read_size_short,return_max_coor_short,>, UNDEFINED_SHORT)
RETURN_MAX_COOR(char,write_size_char,read_size_char,return_max_coor_char,>, UNDEFINED_CHAR)
RETURN_MAX_COOR(int,write_size_int,read_size_int,return_max_coor_int,>, UNDEFINED_INT)
RETURN_MAX_COOR(float,write_size_float,read_size_float,return_max_coor_float,>, UNDEFINED_FLOAT)
RETURN_MAX_COOR(double,write_size_double,read_size_double,return_max_coor_double,>, UNDEFINED_DOUBLE)
RETURN_MAX_COOR(short,write_size_short,read_size_short,return_min_coor_short,<, UNDEFINED_SHORT)
RETURN_MAX_COOR(char,write_size_char,read_size_char,return_min_coor_char,<, UNDEFINED_CHAR)
RETURN_MAX_COOR(int,write_size_int,read_size_int,return_min_coor_int,<, UNDEFINED_INT)
RETURN_MAX_COOR(float,write_size_float,read_size_float,return_min_coor_float,<, UNDEFINED_FLOAT)
RETURN_MAX_COOR(double,write_size_double,read_size_double,return_min_coor_double,<, UNDEFINED_DOUBLE)
#define RETURN_MAX(type,wf,rf,function,comparison,undef)\
type function ( type ** array, int len_array, int field)\
    {\
    type max;\
    int a;\
\
    if (array==NULL || len_array==0)return 0;\
    else\
        {\
        if (len_array==-1)len_array=rf(array,sizeof (type*));\
        max=array[0][field];\
        for ( a=1; a< len_array; a++)\
            if ( max==undef)max=array[a][field];\
	    else if ( array[a][field]!=undef)max=( array[a][field] comparison max)?array[a][field]:max;\
        }\
    return (max==undef)?0:max;\
    }

RETURN_MAX(short,write_size_short,read_size_short,return_max_short,>,UNDEFINED_SHORT)
RETURN_MAX(char,write_size_char,read_size_char,return_max_char,>,UNDEFINED_CHAR)
RETURN_MAX(int,write_size_int,read_size_int,return_max_int,>,UNDEFINED_INT)
RETURN_MAX(float,write_size_float,read_size_float,return_max_float,>,UNDEFINED_FLOAT)
RETURN_MAX(double,write_size_double,read_size_double,return_max_double,>,UNDEFINED_DOUBLE)
RETURN_MAX(short,write_size_short,read_size_short,return_min_short,<,UNDEFINED_SHORT)
RETURN_MAX(char,write_size_char,read_size_char,return_min_char,<,UNDEFINED_CHAR)
RETURN_MAX(int,write_size_int,read_size_int,return_min_int,<,UNDEFINED_INT)
RETURN_MAX(float,write_size_float,read_size_float,return_min_float,<,UNDEFINED_FLOAT)
RETURN_MAX(double,write_size_double,read_size_double,return_min_double,<,UNDEFINED_DOUBLE)



#define RETURN_2DMAX(type,wf,rf,function,comparison,undef)\
type function ( type ** array, int start, int len_array, int first_field, int number_field)\
    {\
    type max;\
    int a,b;\
    if (array==NULL || len_array==0 || first_field<0 || number_field==0)return 0;\
    else\
         {max=array[start][first_field];\
          for ( a=start; a< start+len_array; a++)\
	      for (b=first_field; b< first_field+number_field; b++)\
	             if (array[a][b]!=undef)max=( array[a][b] comparison max)?array[a][b]:max;\
         }\
    return max;\
    }
RETURN_2DMAX(short,write_size_short,read_size_short,return_2Dmax_short,>, UNDEFINED_SHORT)
RETURN_2DMAX(char,write_size_char,read_size_char,return_2Dmax_char,>,UNDEFINED_CHAR)
RETURN_2DMAX(int,write_size_int,read_size_int,return_2Dmax_int,>,UNDEFINED_INT)
RETURN_2DMAX(float,write_size_float,read_size_float,return_2Dmax_float,>,UNDEFINED_FLOAT)
RETURN_2DMAX(double,write_size_double,read_size_double,return_2Dmax_double,>,UNDEFINED_DOUBLE)
RETURN_2DMAX(short,write_size_short,read_size_short,return_2Dmin_short,<,UNDEFINED_SHORT)
RETURN_2DMAX(char,write_size_char,read_size_char,return_2Dmin_char,<,UNDEFINED_CHAR)
RETURN_2DMAX(int,write_size_int,read_size_int,return_2Dmin_int,<,UNDEFINED_INT)
RETURN_2DMAX(float,write_size_float,read_size_float,return_2Dmin_float,<,UNDEFINED_FLOAT)
RETURN_2DMAX(double,write_size_double,read_size_double,return_2Dmin_double,<,UNDEFINED_DOUBLE)

#define RETURN_2DMAX_COOR(type,wf,rf,function,compare,undef)\
type function ( type **array, int start1 , int end1, int start2, int end2,int *i, int *j)\
    {\
    int a, b;\
    double max=undef;\
    if ( start1==-1)start1=0;\
    if ( start2==-1)start2=0;\
    if ( end1==-1)end1=rf(array,sizeof (type*));\
    if ( end2==-1)end2=rf(array[0],sizeof (type));\
    if ( array==NULL || (end1-start1)==0 || (end1-start1)>rf ( array,sizeof (type*)) || (end2-start2)==0)\
        {\
	return 0;\
        i[0]=0;\
        j[0]=0;\
        }\
    i[0]=0;\
    j[0]=0;\
    for ( a=start1; a<end1; a++)\
	for ( b=start2; b<end2; b++)\
	    {\
            if ( max==undef && array[a][b]!=undef)max=array[a][b];\
	    else if ( array[a][b]!=undef && (array[a][b] compare max))\
	       {\
	       max=array[a][b];\
	       i[0]=a;\
	       j[0]=b;\
	       }\
	    }\
    return (type)max;\
    }
RETURN_2DMAX_COOR(short,write_size_short,read_size_short,return_2Dmax_coor_short,>,UNDEFINED_SHORT)
RETURN_2DMAX_COOR(char,write_size_char,read_size_char,return_2Dmax_coor_char,>,UNDEFINED_CHAR)
RETURN_2DMAX_COOR(int,write_size_int,read_size_int,return_2Dmax_coor_int,>,UNDEFINED_INT)
RETURN_2DMAX_COOR(float,write_size_float,read_size_float,return_2Dmax_coor_float,>,UNDEFINED_FLOAT)
RETURN_2DMAX_COOR(double,write_size_double,read_size_double,return_2Dmax_coor_double,>,UNDEFINED_DOUBLE)
RETURN_2DMAX_COOR(short,write_size_short,read_size_short,return_2Dmin_coor_short,<,UNDEFINED_SHORT)
RETURN_2DMAX_COOR(char,write_size_char,read_size_char,return_2Dmin_coor_char,<,UNDEFINED_CHAR)
RETURN_2DMAX_COOR(int,write_size_int,read_size_int,return_2Dmin_coor_int,<,UNDEFINED_INT)
RETURN_2DMAX_COOR(float,write_size_float,read_size_float,return_2Dmin_coor_float,<,UNDEFINED_FLOAT)
RETURN_2DMAX_COOR(double,write_size_double,read_size_double,return_2Dmin_coor_double,<,UNDEFINED_DOUBLE)

#define RETURN_WMEAN(type,wf,rf,function,sum_function,undef)\
double function ( type **array, int len, int wfield,int sfield)\
    {\
    double b;\
    int a, c;\
    if ( len==0 ||array==NULL || len>rf ( array,sizeof (type*)))return 0;\
    else\
         {\
         if ( len==-1)len=rf(array,sizeof (type*));\
         for ( b=0, c=0,a=0; a< len; a++)\
             {\
	     if (array[a][sfield]!=undef && array[a][wfield]!=undef )\
	        {\
		b+=array[a][sfield];\
		c+=array[a][wfield];\
		}\
             }\
         }\
    return (c==0)?0:(b/c);\
    }
RETURN_WMEAN(short,write_size_short,read_size_short,return_wmean_short, return_sum_short,UNDEFINED_SHORT)
RETURN_WMEAN(char,write_size_char,read_size_char, return_wmean_char,return_sum_char,UNDEFINED_CHAR)
RETURN_WMEAN(int,write_size_int,read_size_int,return_wmean_int,return_sum_int,UNDEFINED_INT)
RETURN_WMEAN(float,write_size_float,read_size_float,return_wmean_float,return_sum_float,UNDEFINED_FLOAT)
RETURN_WMEAN(double,write_size_double,read_size_double,return_wmean_double,return_sum_double,UNDEFINED_DOUBLE)

		     
#define RETURN_MEAN(type,wf,rf,function,sum_function,undef)\
double function ( type **array, int len, int field)\
    {\
    double b;\
    int a, c;\
    if ( len==0 ||array==NULL || len>rf ( array,sizeof(type*)))return 0;\
    else\
         {\
         for ( b=0, c=0,a=0; a< len; a++)\
             {\
	     if (array[a][field]!=undef)\
	        {\
		b+=array[a][field];\
		c++;\
		}\
             }\
         }\
    return (c==0)?0:(b/c);\
    }
RETURN_MEAN(short,write_size_short,read_size_short,return_mean_short, return_sum_short,UNDEFINED_SHORT)
RETURN_MEAN(char,write_size_char,read_size_char, return_mean_char,return_sum_char,UNDEFINED_CHAR)
RETURN_MEAN(int,write_size_int,read_size_int,return_mean_int,return_sum_int,UNDEFINED_INT)
RETURN_MEAN(float,write_size_float,read_size_float,return_mean_float,return_sum_float,UNDEFINED_FLOAT)
RETURN_MEAN(double,write_size_double,read_size_double,return_mean_double,return_sum_double,UNDEFINED_DOUBLE)

#define RETURN_SUM(type,wf,rf,function,undef)\
type function(type **array, int len, int field)\
{\
 int a;\
 type b=0;\
 if ( len==0 ||array==NULL)return 0;\
 else\
     {\
     if ( len==-1)len=rf ( array,sizeof (type*));\
     for ( a=0; a< len; a++)\
          if ( array[a][field]!=undef)b+=array[a][field];\
     }\
  return b;\
  }
RETURN_SUM(short,write_size_short,read_size_short, return_sum_short,UNDEFINED_SHORT)
RETURN_SUM(char,write_size_char,read_size_char,return_sum_char,UNDEFINED_CHAR)
RETURN_SUM(int,write_size_int,read_size_int,return_sum_int,UNDEFINED_INT)
RETURN_SUM(float,write_size_float,read_size_float,return_sum_float,UNDEFINED_FLOAT)
RETURN_SUM(double,write_size_double,read_size_double,return_sum_double,UNDEFINED_DOUBLE)    

#define RETURN_SD(type,wf,rf,function,undef)\
  type function ( type **array, int len, int field,type mean)	\
    {\
    int a;\
    double c=0;\
    if ( len==0 ||array==NULL || len>rf ( array,sizeof(type*)))return 0;\
    else\
        {\
        for ( a=0; a< len; a++)\
    	    {\
	    if ((array[a][field]!=undef) && (mean-array[a][field])!=0)\
             c+=((double)mean-array[a][field])*((double)mean-array[a][field]);\
            }\
        c=sqrt(c)/(double)len;\
	return (type)MAX(c,1);\
	}\
    }
RETURN_SD(short,write_size_short,read_size_short, return_sd_short,UNDEFINED_SHORT)
RETURN_SD(char,write_size_char,read_size_char,return_sd_char,UNDEFINED_CHAR)
RETURN_SD(int,write_size_int,read_size_int,return_sd_int,UNDEFINED_INT)
RETURN_SD(float,write_size_float,read_size_float,return_sd_float,UNDEFINED_FLOAT)
RETURN_SD(double,write_size_double,read_size_double,return_sd_double,UNDEFINED_DOUBLE) 
double return_z_score( double x,double sum, double sum2, double n)
    {
    double sd;
    double avg;
    double z;
    
   
    sd=(n==0)?0:sqrt(sum2*n -sum*sum)/n;
    avg=(n==0)?0:(sum/n);
    z=(sd==0)?0:(x-avg)/sd;
    return z;
    }

double* return_r (double **list, int n)
{
   double Sy, Sx, Sxy, Sx2, Sy2,r_up, r_low, x, y;
   double *r;
   int a;
   
   r=vcalloc ( 3, sizeof (double));
   Sy=Sx=Sxy=Sx2=Sy2=0;
   
   for ( a=0; a<n; a++)
     {
       x=list[a][0];
       y=list[a][1];
       Sy+=y;
       Sx+=x;
       Sy2+=y*y;
       Sx2+=x*x;
       Sxy+=x*y;
     }
   r_up=n*Sxy-(Sx*Sy);
   r_low=(n*Sx2-(Sx*Sx))*(n*Sy2-(Sy*Sy));
   r_low=sqrt(r_low);
   r[0]=(r_low==0)?0:r_up/r_low;
   
   x=Sx/(double)n;
   y=Sy/(double)n;
   r_up=Sxy-(n*x*y);
   r_up*=r_up;
   r_low=(Sx2-n*x*x)*(Sy2-n*y*y);
   r[1]=(r_low==0)?0:r_up/r_low;
   r[2]=n;
   return r;
  }

#define INVERT_LIST(type,wf,rf,function,swap_function)\
type* function (type *list, int len)\
    {\
    int a, b;\
    for ( a=0, b=len-1; a<b; a++, b--)swap_function ( &list[a], &list[b], 1);\
    return list;\
    }
INVERT_LIST(short,write_size_short,read_size_short, invert_list_short,swap_short)
INVERT_LIST(char,write_size_char,read_size_char,invert_list_char,swap_char)
INVERT_LIST(int,write_size_int,read_size_int,invert_list_int,swap_int)
INVERT_LIST(float,write_size_float,read_size_float,invert_list_float,swap_float)
INVERT_LIST(double,write_size_double,read_size_double,invert_list_double,swap_double) 

#define SWAP_FUNCTION(type,wf,rf,function)\
void function(type *a, type *b, int n)\
    {\
    type t;\
    int c;\
    for ( c=0;c<n;c++)\
	{t=a[c];\
	 a[c]=b[c];\
	 b[c]=t;\
	}\
    }
SWAP_FUNCTION(short,write_size_short,read_size_short,swap_short)
SWAP_FUNCTION(char,write_size_char,read_size_char,swap_char)
SWAP_FUNCTION(int,write_size_int,read_size_int,swap_int)
SWAP_FUNCTION(float,write_size_float,read_size_float,swap_float)
SWAP_FUNCTION(double,write_size_double,read_size_double,swap_double) 

#define RETURN_MAX_HORIZ(type,wf,rf,function,comparison,undef)\
type function  (type ** array, int len_array, int field)\
    {\
    type max;\
    int a;\
    if ( len_array==0)return 0;\
    else\
        {\
	max=array[field][0];\
        for ( a=1; a< len_array; a++)\
	    if ( array[field][a]!=undef) max=( array[field][a] comparison max)?array[field][a]:max;\
        return (int)max;\
        }\
    }
RETURN_MAX_HORIZ(short,write_size_short,read_size_short,return_max_short_hor,>,UNDEFINED_SHORT)
RETURN_MAX_HORIZ(char,write_size_char,read_size_char,return_max_char_hor,>,UNDEFINED_CHAR)
RETURN_MAX_HORIZ(int,write_size_int,read_size_int,return_max_int_hor,>,UNDEFINED_INT)
RETURN_MAX_HORIZ(float,write_size_float,read_size_float,return_max_float_hor,>,UNDEFINED_FLOAT)
RETURN_MAX_HORIZ(double,write_size_double,read_size_double,return_max_double_hor,>,UNDEFINED_DOUBLE) 

RETURN_MAX_HORIZ(short,write_size_short,read_size_short,return_min_short_hor,<,UNDEFINED_SHORT)
RETURN_MAX_HORIZ(char,write_size_char,read_size_char,return_min_char_hor,<,UNDEFINED_CHAR)
RETURN_MAX_HORIZ(int,write_size_int,read_size_int,return_min_int_hor,<,UNDEFINED_INT)
RETURN_MAX_HORIZ(float,write_size_float,read_size_float,return_min_float_hor,<,UNDEFINED_FLOAT)
RETURN_MAX_HORIZ(double,write_size_double,read_size_double,return_min_double_hor,<,UNDEFINED_DOUBLE) 

  

#define BEST_OF_MANY(type,wf,rf,function,undef)\
type function (int n, ...)\
	{\
	va_list ap;\
	int *fop,a;\
	type v, best;\
	int maximise;\
	/*first Arg: number of values\
	  2nd   Arg: maximise(1)/minimise(0)\
	  3rd   Arg: *int contains the indice of the best value\
	  ...   Arg: n type values\
	*/\
	va_start (ap, n);\
	maximise=va_arg (ap, int);\
	fop=va_arg (ap, int*);\
	best=va_arg (ap, type);\
	fop[0]=0;\
	for ( a=1; a<n; a++)\
		{\
		v=va_arg (ap, type);\
		if (best==undef)\
			{\
			best=v;\
			fop[0]=a;\
			}\
		if ( best==undef || v==undef);\
		else if ( maximise==1 && v>best)\
			{\
			fop[0]=a;\
			best=v;\
			}\
		else if ( maximise==0 && v<best)\
			{\
			fop[0]=a;\
			best=v;\
			}\
		}\
	va_end (ap);\
	return best;\
	}
     /*BEST_OF_MANY(short,write_size_short,read_size_short, best_short,UNDEFINED_SHORT)*/
     /*BEST_OF_MANY(char,write_size_char,read_size_char,best_char,UNDEFINED_CHAR)*/
BEST_OF_MANY(int,write_size_int,read_size_int,best_int,UNDEFINED_INT)
     /*BEST_OF_MANY(float,write_size_float,read_size_float,best_float,UNDEFINED_FLOAT)*/
BEST_OF_MANY(double,write_size_double,read_size_double,best_double,UNDEFINED_DOUBLE)
#define IS_DEFINED(type,function,undef)\
int function(int n, ...)\
     {\
     int i;\
     va_list ap;\
\
     va_start(ap, n);\
     for ( i=0; i< n; i++)\
         {\
	 if(va_arg(ap,type)==undef)\
	      {\
		va_end(ap);\
		return 0;\
	      }\
	 }\
     va_end(ap);\
     return 1;\
     }	
     /*IS_DEFINED(short,is_defined_short,UNDEFINED_SHORT)*/
     /*IS_DEFINED(char,is_defined_char,  UNDEFINED_CHAR)*/
IS_DEFINED(int,is_defined_int,   UNDEFINED_INT)
     /*IS_DEFINED(float,is_defined_float, UNDEFINED_FLOAT)*/
IS_DEFINED(double,is_defined_double,UNDEFINED_DOUBLE)
  
  int return_maxlen ( char ** array, int number)
    {
    int a;
    int max=0;
    for ( a=0; a< number; a++)
	max=( strlen ( array[a])>max)?strlen ( array[a]):max;

    return max;
    }


int return_minlen ( char ** array, int number)
    {
    int a;
    int min;

    min=strlen( array[0]);
    for ( a=1; a< number; a++)
	min=( strlen ( array[a])>min)?strlen ( array[a]):min;

    return min;
    }
 


float return_mean_diff_float ( float **array, int len, int field,float mean)
    {
    int a;
    float b=0;
    
    for ( a=0; a< len; a++)
    	{
    	if ( (mean-array[a][field])!=0) 
	 	b+=sqrt((double)((float) ( mean-array[a][field])*(float)(mean-array[a][field])));
	}
	
    return ((float)b/(float)len);
    }



void inverse_int ( int**array, int len, int field, int max, int min)
    {
    int a;
    for ( a=0; a< len; a++)
	array[a][field]=max-array[a][field]+min;
    }
void inverse_float ( float**array, int len, int field, int max, int min)
    {
    int a;
    for ( a=0; a< len; a++)
	array[a][field]=max-array[a][field]+min;
    }
void inverse_2D_float ( float **array, int start, int len, int start_field, int number_field, float max,float min)
    {
    int a, b;
    for ( a=0; a< start+len; a++)
	for ( b=start_field; b< start_field+ number_field; b++)
	    array[a][b]=max-array[a][b]+min;
    }

int max_int (int*i, ...)
{ 
  va_list ap;					\
  int index, best_value=0, value;
  int a=0;
 //  expects n values : n, &index, i1, v1, i2, v2...., -1
     va_start(ap, i);
     while ((index=va_arg(ap,int))!=-1)
       {
	 value=va_arg(ap, int);
	 if ( a==0 || value>best_value)
	   {
	     i[0]=index;
	     best_value=value;
	     a=1;
	   }
       }
     va_end (ap);
     return best_value;
}
  
/*********************************************************************/
/*                                                                   */
/*                         SHELL INTERFACES                          */
/*                                                                   */
/*                                                                   */
/*********************************************************************/
char* getenv4debug (const char * val)
{
  /*efficient mean of getting an environment variable: checks only if one DEBUG is on*/
  static int check;
  
  if ( !check)
    {
      
      if (getenv       ("DEBUG_BLAST"))check=1;      
      else if ( getenv ("DEBUG_TREE_COMPARE"))check=1;
      else if ( getenv ("DEBUG_MALN"))check=1;
      else if ( getenv ("DEBUG_EXTRACT_FROM_PDB"))check=1;
      else if ( getenv ("DEBUG_LIBRARY"))check=1;
      else if ( getenv ("DEBUG_FUGUE"))check=1;
      
      else if ( getenv ("DEBUG_REFORMAT"))check=1;
      else if ( getenv ("DEBUG_RECONCILIATION"))check=1;
      else if ( getenv ("DEBUG_TMP_FILE"))check=1;
      else if ( getenv ("DEBUG_TREE"))check=1;
      
     else if ( getenv ("DEBUG_SEQ_REFORMAT") && strm (PROGRAM, "SEQ_REFORMAT"))check=2;
      else if ( getenv ("DEBUG_TCOFFEE") && strm (PROGRAM, "T-COFFEE"))check=2;
      else check=-1;      
    }

  if ( check>0 && strm ( val, "DEBUG_TMP_FILE"))
    {
      return "1";
    }
  
  else if ( check==1)
    {
      return getenv (val);
    }
  else if ( check==2)
    {
      return "1";
    }
  else
    return NULL;
}

char* get_env_variable ( const char *var, int mode)
        {
	    /*mode 0: return NULL if variable not set*/
	    /*mode 1: crash if variable not set*/
	    if ( !getenv (var))
	       {
		   if (mode==NO_REPORT)return NULL;
		   else if ( mode ==IS_NOT_FATAL)
		     {
		       fprintf ( stderr, "\nYou must set the variable %s [FATAL]\n", var);
		       return NULL;
		      }
		   else
		      {
			  fprintf ( stderr, "\nYou must set the variable %s [FATAL]\n", var);
	 		  myexit (EXIT_FAILURE);
			  return NULL;
		      }
	       }
	    else return getenv (var);
	}
		
void get_pwd ( char *name)
	{
	char *string;
	char command[1000];
	FILE *fp;
	 

	string=vtmpnam(NULL);
	sprintf ( command, "pwd > %s", string);
	my_system (command);
	fp=vfopen ( string, "r");
	fscanf ( fp, "%s",name);
	vfclose (fp);
	sprintf ( command, "rm %s", string);
	my_system ( command);
	}
int pg_is_installed ( char *pg)
        {
	char *fname;
	char command[1000];
	FILE *fp;
	int r=0;

	return 1;

	fname= vtmpnam(NULL);
	
	sprintf ( command, "which %s > %s", pg, fname);
	my_system ( command);
	
	
        if ((fp=find_token_in_file ( fname, NULL, "Command"))){r=1;vfclose(fp);}
	 

	return r;
	
	}

	    
/*********************************************************************/
/*                                                                   */
/*                           MISC                                    */  
/*                                                                   */
/*********************************************************************/
char *num2plot (int value, int max, int line_len)
        {
	       int   len;
	       int   value_len;
	       char *buf;
	static char *string;

	if ( string==NULL)string=vcalloc (1000, sizeof(char));
 
	if ( line_len==-1)len=30;
	else len=line_len;
	
	value_len=((float)value/(float)max)*(float)len;
	if ( value==0)
	    sprintf ( string, "|");
	else
	    {
	    buf=generate_string(value_len, '*');
	    sprintf ( string,"%s", buf);
	    vfree(buf);
	    }
	return string;
	}
	
int   perl_strstr ( char *string, char *pattern)
{
  char *tmp;
  FILE *fp;
  int r;
  char command[10000];
  char *string2;

  if (!string)  return 0;
  if (!pattern) return 0;
  
  
  
  string2=vcalloc ( strlen (string)+1, sizeof (char));
  sprintf ( string2,"%s", string);
  string2=substitute (string2, "(", " ");
  string2=substitute (string2, ")", " ");
  string2=substitute (string2, "'", " ");
  tmp=vtmpnam(NULL);
  sprintf (command, "perl -e '$s=\"%s\";$x=($s=~/%s/);$x=($x==1)?1:0;print $x;'>%s", string2, pattern,tmp);
  system ( command);
  if (check_file_exists(tmp))
    {
      fp=vfopen (tmp, "r");
      fscanf (fp, "%d", &r);
      vfclose (fp);
    }
  else
    {
      fprintf ( stderr, "COM: %s\n");
      r=0;
    }
  vfree (string2);
  return r;
}
float grep_function ( char *pattern, char *file)
	{
	char command [1000];
	int a, b, l;
	char buf1[100];
	char buf2[100];
	FILE*fp;
	char *s;
	float f;
	
	

	s=vtmpnam(NULL);
	
	sprintf ( command, "grep %s %s > %s",pattern,file, s);
	my_system ( command);
	if ((fp=vfopen (s, "r"))==NULL )return 0;
	else
		{
		fgets ( command, 900, fp);
		l=strlen ( command);
		while ( !isdigit (command[l]))l--;
		a=0;
		while ( isdigit (command[l]) || command[l]=='.')
			{
			buf1[a++]=command[l];
			l--;
			}
		buf1[a]='\0';
		l=strlen (buf1);
		for ( a=0, b=l-1;a< l; a++, b--)
			buf2[b]=buf1[a];
		buf2[l]='\0';
		
		sscanf ( buf2, "%f", &f);
		sprintf ( command,"rm %s", s);
		my_system ( command); 
		vfclose (fp);
		return f;
		}
	}    

void crash_if ( int val, char *s)
    {
    if ( val==0)crash(s);
    }
void crash ( char *s)
	{
	int *a;

	

	fprintf ( stderr, "%s",s);
	a=vcalloc ( 10, sizeof (int));
	a[20]=1;
	error_exit();
	}

static int *local_table;
int ** make_recursive_combination_table ( int tot_n_param, int *n_param, int *nc, int**table, int field)
    {
    int a, b, c;
    
    /* makes a table of all possible combinations*/

    if ( tot_n_param==0)
	{
	    nc[0]=1;
	    fprintf ( stderr, "\nNULL RETURNED");
	    return NULL;
	}
    if (table==NULL)
        {
        if ( local_table!=NULL)vfree (local_table);
	local_table=vcalloc ( tot_n_param, sizeof (int));
	field=0;
	for ( a=0; a< tot_n_param; a++)local_table[a]=-1;
	for ( a=0; a< tot_n_param; a++)nc[0]=nc[0]*n_param[a];
	

	table=declare_int ( nc[0],tot_n_param);
	nc[0]=0;
	}
    
    for ( b=0; b<n_param[field]; b++)
	       {
               
               local_table[field]=b;
	       if ( field<tot_n_param-1)
	          {
                  table=make_recursive_combination_table ( tot_n_param, n_param, nc, table, field+1);
		  }
	       else
	          {
                  for ( c=0; c< tot_n_param; c++)table[nc[0]][c]=local_table[c];
		  nc[0]++;
		  }
	       }
    return table;
    }
	          
/*********************************************************************/
/*                                                                   */
/*                         STRING PROCESSING                         */
/*                                                                   */
/*                                                                   */
/*********************************************************************/
char *strnrchr ( char *s,char x, int n)
{
  int a;
  for (a=0; a< n; a++)if (s[a]=='x')return s+a;
  return NULL;
}
int intlen (int n)
{
  char buf [100];
  sprintf ( buf, "%d", n);
  return strlen (buf)+1;
}
char * update_string (char string1[], char string2[])
{
  if ( string1==string2);
  else if ( string2==NULL)
    {
      if ( string1==NULL)string1=vcalloc ( 1, sizeof(char));
      string1[0]='\0';
    }
  else
    {
      int l1, l2;
      l1=read_array_size_new (string1);
      l2=strlen (string2)+1;
      if (l1<l2)
	string1=vrealloc (string1, (l2)*sizeof (char));
      sprintf ( string1, "%s", string2);
    }
  return string1;
}
  
char* strcatf  (char *string1,char *string2, ...)
{
  
  va_list ap;
  char *buf;
  
  buf=vcalloc ( read_array_size_new (string1)+1, sizeof (char));
  va_start (ap, string2);
  vsprintf (buf, string2, ap);
  va_end (ap);
  string1=vcat (string1, buf);
  vfree (buf);
  return string1;
}

char *vcat ( char *st1, char *st2)
{
  int l=0;
  char *ns;
  
  if ( !st1 && !st2)return NULL;
  if ( st1) l+=strlen (st1);
  if ( st2) l+=strlen (st2);
  l++;
  
  ns=vcalloc ( l, sizeof (char));
  sprintf ( ns, "%s%s", (st1)?st1:"", (st2)?st2:"");
  return ns;
}
int print_param ( char *param, FILE *fp);
int print_param ( char *param, FILE *fp)
{
  static char **p;
  static int np;
  int a;
  
  if (!p)p=vcalloc (1000, sizeof (char*));
  
  for ( a=0; a<np; a++)if (p[a]==param) return 0;
  
  p[np++]=param;
  
  fprintf ( fp, "\nPARAMETERS: %s\n", param);
  return 1;
}
  
int strget_param ( char *string, char *token1, char *token2, char *format, ...)
{
  /*string: command line
    token1: parameter
    token2: default value (in a string)
    format: standard scanf format
    ... arguments for scanf
  */
  char *buf;
  char *buf2;
  int n;
  va_list ap;
  
  if (!string) return 0;
  //print_param (string, stdout);
  //print_param (string, stderr);
  va_start (ap, format);
  buf=after_strstr ( string, token1);
  
  
  if (buf)
    {
      buf2=vcalloc (strlen (buf)+1, sizeof (char));
      sprintf ( buf2, "%s", buf);
      buf2=substitute (buf2, "__", " ");
      n=my_vsscanf (buf2, format, ap);
      vfree (buf2);
    }
  else     {n=my_vsscanf (token2, format, ap);}
  va_end (ap);
  
  return n;
}

int strscanf (char *string1,char *token, char *format,...)
{
  char *buf;
  va_list ap;
  int n;
  
  va_start (ap,format);
  buf=after_strstr ( string1, token);
  if ( buf){n=my_vsscanf (buf, format, ap);}
  else n=0;
  
  va_end (ap);
  return n;
}

int match_motif ( char *string, char **motif)//crude string matching, the motif and the string have the same length
  {
  int l, a;
  if (!motif) return 0;
  l=strlen (string);
  for ( a=0; a<l; a++)
      {
	if ( motif[a][0]!='*' && !strchr (motif[a], string[a]))return 0;
      }
  return 1;
} 

char *after_strstr ( char *string, char *token)
{
  char *p;
  if ( (p=vstrstr (string, token)))return p+strlen (token);
  else return NULL;
}
char* lstrstr ( char *in, char *token)//return strstr if matches on the left
{
  char *s;
  if ((s=vstrstr(in, token))&&s==in)return s;
  else return NULL;
  
}

char *vstrstr ( char *in, char *token)
{
  if (!in || !token) return NULL;
  else return strstr (in, token);
}
char ** push_string (char *val, char **stack, int *nval, int position)
{
  char **new_stack;
  int a;
  
  
  if (!val || nval[0]<=position)return stack;
  nval[0]++;
  new_stack=vcalloc ( nval[0], sizeof (char*));  
  new_stack[position]=val;
  for (a=0; a< position; a++)new_stack[a]=stack[a];
  for (a=position+1; a<nval[0]; a++)new_stack[a]=stack[a-1];
  vfree (stack);
  
  return new_stack;
}

int vsrand (int val)
{
  static int initialized;
  
  if (initialized) return 0;
  else if (   getenv ("DEBUG_SRAND"))
    {
      srand (10);
      initialized=1;
    }
  else
    {
      
      /*Make sure two processes in a row do not get the same time value*/
      srand ((val==0)?time(NULL):val);
      initialized=1;
    }
  return 1;
}
int  *randomize_list (int *list, int len, int ncycle)
{
  int p1, p2, a, buf;
  
  vsrand (0);
  if ( ncycle==0)ncycle=len;
  for ( a=0; a<ncycle; a++)
    {
      p1=rand()%len;
      p2=rand()%len;
      buf=list[p1];
      list[p1]=list[p2];
      list[p2]=buf;
    }
  return list;
}
/*Replace by a gap the parts of the two strings that do not OVERLAP*/
/*returns the length of the overlap*/
int vstrcmp (const char *s1, const char *s2)
{
  if ( !s1 && !s2)return 0;
  else if ( !s1 || !s2)return 1;
  else return strcmp ( s1, s2);
}
int vstrncmp (const char *s1, const char *s2, int n)
{
  if ( !s1 && !s2)return 0;
  else if ( !s1 || !s2)return 1;
  else return strncmp ( s1, s2, n);
}
FILE *print_array_char (FILE *out, char **array, int n, char *sep)
        {
	int a;
	if ( array==NULL || read_size_char (array,sizeof (char*))<n)
	   {
	   fprintf ( stderr, "\nORB in print_array_char [FATAL]\n");
	   crash("");
	   }
	for ( a=0; a< n; a++)fprintf ( out, "%s%s", array[a],sep);
	return out;
	}
char * path2filename ( char *array)
{
  Fname *F;
  char *name;

  name=vcalloc ( strlen (array)+2, sizeof (char));
  F=parse_fname (array);
  if ( F->suffix)sprintf ( name, "%s.%s", F->name, F->suffix);
  else sprintf (name, "%s", F->name);
  free_fname (F);
  return name;
}
Fname* parse_fname ( char *array)
	 {
	 int l;
	 Fname *F;



	 F=declare_fname (sizeof (array));
	 
	 sprintf ( F->full, "%s", array);
	 sprintf ( F->path, "%s", array);	
	 l=strlen (array);
	 while (l!=-1 && (F->path)[l]!='/')(F->path)[l--]='\0';
	 
	 sprintf ( F->name, "%s", array+l+1);
	 l=strlen (F->name);
	 while (l!=-1)
	   {
	    if((F->name)[l]=='.')
	      {
	      F->name[l]='\0';
	      sprintf ( F->suffix, "%s", F->name+l+1);
	      break;
	      }
	    else l--;
	    }

	return F;
        }
char *filename2path (char *name)
{
  char *nname;
  int x;
  if (isdir (name))return name;
  
  x=strlen (name)-1;
  nname=vcalloc (x+2, sizeof (char));
  sprintf ( nname, "%s", name);
  while ( x >=0 && nname[x]!='/')nname[x--]='\0';
  
  if ( !isdir (nname) || !nname[0]){vfree (nname); return NULL;}
  return nname;
}
  
  

  
    
char *extract_suffixe ( char *array)
        {
	int l;
	char *new_string;
	char *x;
	l=strlen (array);
	new_string=vcalloc ( l+1, sizeof (char));
	sprintf (new_string, "%s",array);
	
	x=new_string+l;
	while (x!=new_string && x[0]!='.' && x[0]!='/' )x--;
	if ( x[0]=='.')x[0]='\0';
	else if (x[0]=='/')return x+1;
 
	while ( x!=new_string && x[0]!='/')x--;
	
	return (x[0]=='/')?x+1:x;
	}
void string_array_upper ( char **string, int n)
     {
     int a;
     for ( a=0; a< n; a++)upper_string (string[a]);
     }
void string_array_lower ( char **string, int n)
     {
     int a;
     for ( a=0; a< n; a++)lower_string (string[a]);
     }

char *upper_string ( char *string)
	{
	int len, a;
	
	len=strlen ( string);
	for ( a=0; a< len; a++)string[a]=toupper ( string[a]);
	return string;
	}	
char *lower_string ( char *string)
	{
	int len, a;
	
	len=strlen ( string);
	for ( a=0; a< len; a++)string[a]=tolower ( string[a]);
	return string;
	}	
void string_array_convert ( char **array, int n_strings, int ns, char **sl)
        {
	int a;

	for ( a=0; a< n_strings; a++)string_convert ( array[a], ns, sl);
	}
void string_convert( char *string, int ns, char **sl)
        {
	int a, l;
	l=strlen ( string);
	for ( a=0; a< l; a++)
	    string[a]=convert(string[a], ns, sl);
	}
int convert ( char c, int ns, char **sl)
        {
	int a;
	int return_char;

	for ( a=0; a< ns; a++)
	    {
	    if ((return_char=convert2 ( c, sl[a]))!=-1)
		return return_char;
	    }
	return c;
	

	}
int convert2 ( char c, char *list)
    {
    int a;
    int l1;
    int return_char;

    l1=strlen ( list);
    
    return_char=(list[l1-1]=='#')?c:list[l1-1];

    for ( a=0; a< l1; a++)
	   if (list[a]=='#')return return_char;
           else if ( list[a]==c)return return_char;
    
    return -1;
    }
char* substitute_old ( char *string_in, char *t, char *r)
{
  char *string_out;
  char *p, *heap_in;
  int delta, l;
  /*REplaces every occurence of token t with token r in string_in*/

  if ( string_in==NULL || t==NULL || r==NULL) return string_in;
  
  heap_in=string_in;

  l=read_array_size_new ((void*)string_in)+1;

  string_out=vcalloc (l, sizeof (char));
  delta=strlen(r)-strlen (t);
  delta=(delta<0)?0:delta;
	 
  while ( (p=strstr ( string_in, t))!=NULL)
    {

      p[0]='\0';
      if ( delta)
	{
	  l+=delta; 
	  string_out=vrealloc(string_out, sizeof (char)*l);
	}
      
      strcat ( string_out, string_in);
      strcat ( string_out, r);
      string_in=p+strlen (t);
    }
  strcat ( string_out, string_in);
  if (l<strlen (string_out))
    {
      heap_in=vrealloc (heap_in, sizeof(char)*(strlen (string_out)+1));
    }
  sprintf ( heap_in, "%s", string_out);  
  vfree (string_out);
  return heap_in;
}
//Makes sure substitutions of the tild only occur on valid UNIX pathnames
char* tild_substitute ( char *string_in, char *t, char *r)
{
  char *p;
 
  p=strstr ( string_in, "~");
  if ( p==NULL)return string_in;
  else if (p && p!=string_in && p[-1]!='/')return string_in;
  
  else
    {
      return substituteN (string_in, t, r,1);
    }
  
}
char* substitute_char ( char *string_in, char t, char r)
{
  int n=0;
  while ( string_in && string_in[n]!='\0')
    {
      if ( string_in[n] == t)string_in[n]=r;
      n++;
    }
  return string_in;
}
char* substitute ( char *string_in, char *t, char *r)
{
  /*REplaces every occurence of token t with token r in string_in*/
  return substituteN(string_in, t, r,0);
}
char* substituteN ( char *string_in, char *t, char *r, int N)
{
  char *string_out;
  char *p, *heap_in, n=0;
  int delta, l, lsi,lso,lr,lt,nt;
 
  /*REplaces the first N Occurences*/
  if ( string_in==NULL || t==NULL || r==NULL) return string_in;
  
  heap_in=string_in;

  l=read_array_size_new ((void*)string_in)+1;
  lr=strlen(r);
  lt=strlen(t);
  lsi=strlen (string_in);
  
  delta=((lr-lt)>0)?(lr-lt):0;
  nt=0;
  while ( (p=strstr (string_in, t))!=NULL)
    {
      string_in=p+lt;
      nt++;
    }
  string_in=heap_in;
  
  lso=nt*delta+lsi;
  string_out=vcalloc (lso+1, sizeof (char));
  
  while ((N==0 ||n<N) && (p=strstr ( string_in, t))!=NULL)
    {
      p[0]='\0';
      strcat ( string_out, string_in);
      strcat ( string_out, r);
      string_in=p+lt;
      if (N!=0)n++;
    }
  strcat ( string_out, string_in);
  if (l<(lso+1)){HERE ("Realloc %s %s delta=%d %d %d", t, r,delta, lsi, lso);heap_in=vrealloc (heap_in, sizeof (char)*(lso +1));}
  sprintf ( heap_in, "%s", string_out);  
  vfree (string_out);
  return heap_in;
}

  
char **clean_string (int n, char **string)
{
  int a,b,c,l;
  if ( !string) return string;
  for (a=0; a< n; a++)
    {
      if (!string[a]) continue;
      l=strlen (string[a]);
      for (b=0; b<l; b++)
	{
	  c=string[a][b];
	  if (!isgraph(c) && c!='\n' && c!='\t' && c!=' ')string[a][b]=' ';
	}
    }
  return string;
}
	       



int str_overlap ( char *string1, char *string2, char x)
        {	
	int a, b;
	int l1, l2;
	int **array;
	int max1=0, max2=0;
	int score;
	int max_val=-1;
	int end1, end2;
	int start1, start2;

	if ( strm ( string1, string2))return 0;
	else
	    {
	    l1=strlen ( string1);
	    l2=strlen ( string2);
	    array=declare_int ( strlen ( string1), strlen ( string2));
	    for ( a=0; a< l1; a++)
		for ( b=0; b< l2; b++)
		    {
			if ( a==0 || b==0)array[a][b]=(string1[a]==string2[b])?1:0;
			else
			    if (string1[a]==string2[b])
			       {
			       score=array[a][b]=array[a-1][b-1]+1;
			       if ( max_val<score)
			          {
				  max_val=score;
				  max1=a;
				  max2=b;
				  }
			       }
		    }
	    start1=(max1+1)-max_val;
	    end1=  max1;
	    
	    start2=(max2+1)-max_val;
	    end2=  max2;
	    
	    for ( a=0; a< l1; a++)if ( a<start1 || a> end1)string1[a]=x;
	    for ( a=0; a< l2; a++)if ( a<start2 || a> end2)string2[a]=x;
	    
	    free_int ( array, l1);
	    
	    return max_val;
	    }
	}

int get_string_line ( int start, int n_lines, char *in, char *out)
	{
	int nl=0;
	int a=0;
	int c=0;
	
	while ( nl<n_lines)
		{
		while ( (c=in[start++])!='\n' && c!='\0')
			{
			out[a++]=c;
			}
		out[a++]='\n';
		nl++;
		}
	out[a]='\0';
	return (c=='\0')?-1:start;
	}
	

FILE * output_string_wrap ( int wrap,char *string, FILE *fp)
	{

	 int a, b,l;
	 
	 l=strlen ( string);
	 
	 for ( a=0, b=1; a< l; a++, b++)
	 	{
	 	fprintf ( fp, "%c", string[a]);
	 	if ( b==wrap)
	 		{
	 		fprintf ( fp, "\n");
	 		b=0;
	 		}
	 	}
	 return fp;
	 }

char * extract_char ( char * array, int first, int len)
    {
    char *array2;
    int a;

    len= ( len<0)?0:len;    

    array2=vcalloc ((len+1), sizeof (char));
    
    for ( a=0; a<len; a++)
	array2[a]=array[first++];

    array2[a]='\0';

    return array2;
    }    

int check_cl4t_coffee (int argc, char **argv)
{
  char *name;
  if ( name_is_in_list ("-other_pg", argv, argc, 100)!=-1)return 1;
  else if (name_is_in_list ( "tcoffee_test_seq.pep", argv, argc, 100)!=-1)return 1;
  else
    {
      int a,  inseq, result;
      FILE *fp;
      char command[10000];
      command[0]='\0';

      for ( inseq=0,a=0; a<argc; a++)
	{
	  if ( inseq && argv[a][0]=='-')
	    {
	      inseq=0;
	    }
	  else if (strm ( argv[a], "-seq"))inseq=1;

	  if ( inseq==0)
	    {
	      strcat ( command, " ");
	      strcat ( command, argv[a]);
	    }
	}
      name=vcalloc ( 100, sizeof (char));
      sprintf ( name, "TCIT_%d", (int)rand()%10000);
      strcat ( command, " -seq tcoffee_test_seq.pep -quiet -no_error_report");
      fp=vfopen ( name, "w");
      fprintf ( fp, ">A\nthecat\n>B\nthecat\n");
      vfclose (fp);
      result=safe_system (command);
      printf_system ( "rm %s.*", name);
      vfree (name);
      if (result) {myexit (EXIT_FAILURE);return 0;}
      else return 1;
    }
}
      
char** merge_list ( char **argv, int *argc)
       {
       int a, b;
       int n_in;
       char **out;
       char current [STRING];

       out=declare_char (argc[0], STRING);
       n_in=argc[0];
       argc[0]=0;
       
       a=0;
       while (a< n_in && !is_parameter ( argv[a]))
	 {
	   sprintf (out[argc[0]++], "%s",  argv[a]);
	   argv[a][0]='\0';
	   a++;
	 }
     
       
       for ( a=0; a< n_in; a++)
	 {
	   if ( is_parameter (argv[a]))
	     {
	       sprintf ( out[argc[0]++], "%s", argv[a]);
	       sprintf ( current, "%s", argv[a]);
	       
	       for ( b=0; b< n_in;)
		 {
		   if ( is_parameter (argv[b]) && strm (current, argv[b]))
			{
			  argv[b][0]='\0';
			  b++;
			  while ( b<n_in && !is_parameter ( argv[b]) )
			    {
			      if (argv[b][0])
			       {
				 sprintf ( out[argc[0]++], "%s", argv[b]); 
				 argv[b][0]='\0';
			       }
			     b++;
			    }
			}

		   else b++;
		     
		     
		   
		 }
	     }
	 }
  			  
       free_char (argv, -1);
       return out;
       }


int *  string2num_list_old ( char *string)
{
  /*Breaks down a list of numbers separated by any legal separator and put them in an array of the right size*/
  /*Returns list a list of integer*/
  /*Skips non numbers*/
  
  char *buf, *s;
  int  *list, n;
  

  buf=vcalloc ( strlen (string)+1, sizeof (char));
  
  n=0;
  sprintf ( buf, "%s", string);
  s=strtok (buf, SEPARATORS);
  while (s!=NULL)
	  {
	    n++;
	    s=strtok (NULL, SEPARATORS);
	  }
  list=vcalloc (n+1, sizeof (int));
  
  n=0;
  sprintf ( buf, "%s", string);
  s=strtok (buf, SEPARATORS);
  while (s!=NULL)
	  {
	    if (is_number(s))list[n++]=atoi(s);
	    s=strtok (NULL, SEPARATORS);
	  }
  vfree (buf);
 
  return list;
}



int *name_array2index_array ( char **list1, int n1, char **list2, int n2)
{
  int *list,a, max;
  /*returns an indexed list of the position of list1 in list2*/
  list=vcalloc ( n1, sizeof (int));
  for ( a=0, max=0; a< n1; a++)max=MAX(max, strlen (list1[a]));
  for ( a=0       ; a< n2; a++)max=MAX(max, strlen (list2[a]));
  
  for ( a=0; a< n1; a++)
    {
      list[a]=name_is_in_list (list1[a],list2,n2,max);
    }
  return list;
}

int * string2num_list ( char *string)
{
  return string2num_list2(string, SEPARATORS);
}
int * string2num_list2 ( char *string, char *separators)
{
   /*Breaks down a list of numbers separated by any legal separator and put them in an array of the right size*/
  /*Returns list a list of integer*/
  /*Skips non numbers*/
  
  char **nlist;
  int *list;
  int a, m, n;
  
  nlist=string2list2 (string, separators);
  
  if (nlist==NULL) return NULL;
  
  n=atoi(nlist[0]);
  list=vcalloc ( n, sizeof (int));
  
  for (m=1, a=1; a< n; a++)
    {
      if (is_number(nlist[a]))list[m++]=atoi(nlist[a]);
    }
  
  list[0]=m;
  free_char (nlist, -1);
  if ( m==0){vfree(list); return NULL;}
  else
    {
      return list;
    }
  
  return NULL;
  
}
char * list2string  ( char **list, int n)
{
  return list2string2 ( list, n, " ");
}
char * list2string2 ( char **list,int n, char* sep)
{
  int l, a;
  char *string;
  
  for ( l=0,a=0; a<n; a++)l+=strlen ( list[a])+1;
  string=vcalloc (l+1, sizeof (char));
  for ( a=0; a< n; a++)
      {
	strcat ( string, list[a]);
	strcat ( string, sep);
      }
    return string;
  }

char **  string2list ( char *string)
  {
    return string2list2(string, SEPARATORS);
  }
char **  string2list2 ( char *string, char *separators)
  {
  /*Breaks down a list of words separated by any legal separator and put them in an array of the right size*/
  /*Returns list a list of char with the size written in list[0]*/
  
  
  char *buf, *s;
  char  **list;
  int n, max_len;
  
  if ( string==NULL)return NULL;
  buf=vcalloc ( strlen (string)+1, sizeof (char));
  

  n=max_len=0;
  sprintf ( buf, "%s", string);
  s=strtok (buf, separators);
  
  while (s!=NULL)
	  { 
	    n++;
	    max_len=MAX(max_len,(strlen (s)));
	    s=strtok (NULL, separators);
	    
	  }
  
  if ( n==0){vfree(buf); return NULL;}
  
  list=declare_arrayN (2, sizeof (char), n+1, max_len+1);
    
  n=1;
  sprintf ( buf, "%s", string);
  s=strtok (buf, separators);
  while (s!=NULL)
	  {
	    sprintf (list[n++], "%s",s);
	    s=strtok (NULL, separators);
	  }
  
  sprintf (list[0], "%d", n);
  
  vfree (buf); 
  
  return list;
}

char** break_list ( char **argv, int *argc, char *separators)
       {
       int a, b;
       int n_in;
       char **out;
       char **ar=NULL;
       int n_ar;
       int cont=1;

       /*Breaks down the argv command line in smaller units, breaking at every separator*/
       out=vcalloc (MAX_N_PARAM, sizeof (char*));
       n_in=argc[0];
       argc[0]=0;
       
       if ( n_in>=MAX_N_PARAM)
	 {
	   fprintf ( stderr, "\nERROR: too many parameters, recompile with MAX_N_PARAM set at a higher velue [FATAL:%s]\n", PROGRAM);\
	   myexit (EXIT_FAILURE);
	 }
       
       for ( a=0; a< n_in; a++)
           {
	     

	     
	     if (cont)ar=get_list_of_tokens( argv[a], separators,&n_ar);
	     else ar=get_list_of_tokens( argv[a],"",&n_ar);


	     for ( b=0; b< n_ar; b++)
	       {
		 out[argc[0]]=vcalloc( strlen (ar[b])+1, sizeof (char));
		 sprintf (out[argc[0]++], "%s", ar[b]);
	       }
	     free_char (ar, -1);
	     ar=NULL;
	     if ( strstr (argv[a], "-other_pg"))cont=0;
	   }
       free_char (ar, -1);
       return out;
       }
    
char *invert_string2 (char *string)
{
  char *buf;
  int a, b, l;
  
  l=strlen (string);
  buf=vcalloc ( l+1, sizeof (char));
  for ( a=l-1, b=0; a>=0; a--, b++)
    buf[b]=string[a];
  sprintf (string, "%s", buf);
  vfree (buf);
  return string;
}
char *invert_string (char *string)
{
  return string2inverted_string(string);
}
char* string2inverted_string(char *string)
{
  char *buf;
  int a, b, l;
  
  l=strlen (string);
  buf=vcalloc ( l+1, sizeof (char));
  for ( a=l-1, b=0; a>=0; a--, b++)
    buf[b]=string[a];
  return buf;
}

char ** get_list_of_tokens ( char *in_string, char *separators, int *n_tokens)
{
    char **list=NULL;
    char *p=NULL;
    char *string;
    
    
    n_tokens[0]=0;
    if ( in_string==NULL || strm(in_string, ""));
    else if ( in_string[0]=='[')
      {
	list=declare_char (1, strlen ( in_string)+1);
	sprintf ( list[n_tokens[0]], "%s",in_string);
	n_tokens[0]++;
      }
    else
      {
	list=declare_char (strlen ( in_string)+1, 1);	
	string=vcalloc ( strlen(in_string)+1, sizeof (char));
	sprintf ( string, "%s", in_string);	
	
	while ( (p=strtok ((p==NULL)?string:NULL, ((separators==NULL)?SEPARATORS:separators)))!=NULL)
           {
	   list[n_tokens[0]]=vrealloc ( list[n_tokens[0]], sizeof (char) *strlen (p)+1);
	   sprintf ( list[n_tokens[0]], "%s", p);
	   n_tokens[0]++;
	   }

	vfree (string);
	}
   return list;
   }

char **ungap_array ( char **array, int n)
        {
	int a;
	for ( a=0; a< n; a++)ungap(array[a]);
	return array;
	}

void ungap ( char *seq)
{
  remove_charset ( seq, "ungap");
}
int seq2len (char *seq, char *pset,char *nset)
{
  int a, l, t=0;
  //count all the residues in pset and NOT in nset
  if ( !seq) return 0;
  
  l=strlen (seq);
  //returns the len of the string 
  for (a=0; a< l; a++)
    {
      char c=seq[a];
      if ( pset && nset && strchr (pset, c) && !strchr (nset, c))t++;
      else if ( pset && strchr  (pset, c))t++;
      else if ( nset && !strchr (nset, c))t++;
    }
  return t;
}
int seq2res_len (char *seq)
{
  return seq2len (seq, NULL, GAP_LIST);
}
char* remove_charset_from_file (char *fname, char *set)
{
  char *tmp;
  char c;
  FILE *fp1;
  FILE *fp2;
  
  fp1=vfopen (fname, "r");
  fp2=vfopen (tmp=vtmpnam (NULL), "w");
  while ( (c=fgetc(fp1))!=EOF)
    {
    if (!strchr ( set,c))fprintf ( fp2, "%c", c);
    }
  vfclose (fp1);
  vfclose (fp2);
  return tmp;
}
  
void remove_charset ( char *seq, char *set)
	{
	int a, b, l;
	char *set2;

	set2=vcalloc (256, sizeof (char));
	if ( strm (set, "!alnum"))
	  {
	    for ( b=0,a=1;a< 256; a++)if ( !isalnum (a))set2[b++]=a;
	  }
	else if ( strm ( set, "ungap"))
	  {
	    sprintf ( set2, "%s", GAP_LIST);
	  }
	else
	  {
	    sprintf ( set2, "%s", set);
	  }
	
	l=strlen ( seq);
	for (b=0, a=0; a<=l; a++)
	  {
	    if ( strchr ( set2, seq[a]));
	    else seq[b++]=seq[a];
	  }
	seq[b]='\0';
	vfree (set2);
	}

  
char **char_array2number ( char ** array, int n)
       {
       int a;
       for ( a=0; a< n; a++)array[a]=char2number(array[a]);
       return array;
       }
char *char2number ( char * array)
       {
       int a, l;
       
       
       l=strlen ( array);
       for ( a=0; a< l; a++)
	   {
	     if ( isdigit(array[a]) && array[a]!=NO_COLOR_RESIDUE && array[a]!=NO_COLOR_GAP )array[a]-='0';
	     else if ( array[a]<9);
	     else if ( array[a]==NO_COLOR_RESIDUE || array[a]==NO_COLOR_GAP)array[a]=NO_COLOR_RESIDUE;
	   }
       return array;
       }
long atop (char*p)
{
  /*turns a char into a pointer*/
  if ( p==NULL) return 0;
  else return atol(p);
}

char *mark_internal_gaps(char *seq, char symbol)
{
  int l, a, gap;
  int in_seq;
  char *cache_seq;
  
  l=strlen(seq);
  cache_seq=vcalloc ( l+1, sizeof (char));
  sprintf ( cache_seq, "%s", seq);
  
  for ( gap=0, in_seq=0,a=0; a< l; a++)
    {
      gap=is_gap(seq[a]);
      if ( !gap && !in_seq)in_seq=1;
      if (gap && in_seq)seq[a]=symbol;      
    }
  
  for (gap=0, in_seq=0,a=l-1; a>=0; a--)
    {
      gap=is_gap(seq[a]);
      if ( !gap && !in_seq)break;
      if (gap && !in_seq)seq[a]=cache_seq[a];
    }
  vfree(cache_seq);
  return seq;
}

void splice_out ( char *seq, char x)
    
        {
	int a, b, l;

	l=strlen ( seq);
	for (b=0, a=0; a<=l; a++)
		if ( seq[a]==x);
		else seq[b++]=seq[a];	
	seq[b]='\0';
	}
char *splice_out_seg ( char *seq, int pos, int len)
{
  int l, a;
  
  if (seq==NULL || pos<0) return seq;
  l=strlen (seq);
  if ( l<(pos+len))
    printf_exit ( EXIT_FAILURE, stderr, "Splice_out_seg out of bound: Length %d seg: [%d %d] [splice_out_seg::util.c][FATAL:%s]\n", l, pos, pos+len, PROGRAM);
  l-=len;
  for (a=pos; a< l; a++)
    seq[a]=seq[a+len];
  seq[a]='\0';
  return seq;
}
  
int isblanc ( char *buf)
   {
   int a, l;
   
   if ( buf==NULL)return 0;
   l=strlen (buf);
   for ( a=0; a< l; a++)
   	if (isalnum (buf[a]))return 0;
   return 1;
   }



int is_number ( char *num)
   {
     int a, l;
     l=strlen (num);
     
     for (a=0;a<l; a++)
       if ( !strchr ("0123456789.-+", num[a]))return 0;
     return 1;
   }

int is_alnum_line ( char *buf)
   {
   int a, l;
   l=strlen (buf);
   for ( a=0; a< l; a++)
   	if (isalnum (buf[a]))return 1;
   return 0;
   } 
int is_alpha_line ( char *buf)
   {
   int a, l;
   l=strlen (buf);
   for ( a=0; a< l; a++)
   	if (isalpha (buf[a]))return 1;
   return 0;
   }
int case_insensitive_strcmp ( char *string1, char *string2)
{
  int a;
  int l;
  
  if ( !string1 && !string2) return 1;
  else if ( !string1 && !string2) return 0;
  else
    {
      l=strlen (string1);
      for ( a=0; a< l; a++)
	{
	  if (tolower(string1[a])!=tolower(string2[a]))return 0;
	}
    }
  return 1;
}	
int get_string_sim ( char *string1, char *string2, char *ignore)
	{
	int len1;
	int len2;
	int a;
	int pos=0;
	int sim=0;
	char r1, r2;
	
	
	len1=strlen (string1);
	len2=strlen (string2);
	
	if ( len1!=len2)return 0;
	
	for ( a=0; a< len1; a++)
		{
		r1=string1[a];
		r2=string2[a];
		if ( !is_in_set (r1, ignore) && !is_in_set (r2, ignore))
			{
			pos++;
			if (r1==r2)
				{
				sim++;
				}
			}
		}
	
	if (pos==0)
		 return 0;
	else	
		return (int) (sim*100)/pos;
	
	}
int is_aa  ( char x)
         {
	 return (is_in_set (x, AA_ALPHABET) && !is_in_set (x, GAP_LIST));
	 }
int is_rna ( char x)
         {
	 return (is_in_set (x, RNAONLY_ALPHABET)&& !is_in_set (x, GAP_LIST));
	 }
int is_dna ( char x)
         {
	 return (is_in_set (x, DNA_ALPHABET)&& !is_in_set (x, GAP_LIST));
	 }
int is_gap ( char x)
         {
	 return ( is_in_set ( x, GAP_LIST));
	 }
int is_gop ( int p, char *s)
{
  if (!s) return 0;
  else if (p<=0)return 0;
  else if (s[p]!='-' && s[p+1]=='-')return 1;
  else return 0;
}
    
char* get_alphabet   ( char *seq, char *alphabet)
/*This function builds an alphabet from the string seq*/
/*Alphabet does not need to be emppty. The total number of unique symbols is returned*/
/*Gaps, as defined in the GAP_LIST are ignored*/
    {
	int a;
	int len;
	
	if ( !alphabet) alphabet=vcalloc ( 200, sizeof (char));

	len=strlen (seq);
	
	for ( a=0; a<len; a++)
	  if ( !is_gap ( seq[a]) && !is_in_set ( seq[a], alphabet+1)){alphabet[(int)++alphabet[0]]=seq[a];}
	return alphabet;
    }

int array_is_in_set ( char *x, char *set )
         {
	 int len;
	 int a;
	 
	 len=strlen (x);
	 for ( a=0; a< len; a++)
	     if ( !is_in_set ( x[a], set))return 0;
	 return 1;
	 }


int is_in_set ( char r, char *list)
	{
	static char s[2];
	
	s[0]=r;

	
	if ( strstr ( list,s)!=NULL)return 1;
	
	return 0;
	}
char * generate_void ( int x)
    {
    return generate_string (x, ' ');
    }
   
char * generate_null ( int x)
    {
    return generate_string ( x, '-');
    }
    	 	
char * generate_string ( int x, char y)
    {
	 int a;
    char *string;
    
    string = vcalloc ( x+1, sizeof ( char));

    for ( a=0; a< x; a++)
	string[a]=y;

    string[a]='\0';
    return string;
    }
char * translate_string (char *string, char *in, char*out)
{
  int l1, l2;
  int a, b;

  l1=strlen(string);
  l2=strlen (in);

  if ( l2!=strlen (out))
    {
      fprintf ( stderr, "\nERROR: translate_string function: IN alphabet (%s) must have the same size as OUT alphabet (%s) [FATAL:%s]\n", in, out, PROGRAM);
      myexit (EXIT_FAILURE);
    }
  
  for ( a=0; a< l1; a++)
    {
      for ( b=0; b< l2; b++)
	{
	  if ( string[a]==in[b])
	    {
	      string[a]=out[b];
	      b=l2;
	    }
	}
    }
  return string;
}
  

int get_longest_string (char **array,int n, int *len, int *index)
     {
     int a, l;
     int max_len=0, max_index=0;

     if ( n==0 || array==NULL )return 0;     
     if ( n==-1)n=read_size_char(array,sizeof (char*));
     

     if (read_size_char ( array,sizeof (char*))<n)
         {
	 fprintf ( stderr, "\nBAD REQUEST: Number of strings=%d, expected number=%d", read_size_char ( array,sizeof (char*)),n);
	 crash ("[FATAL/util.c]");
	 }
     else
         {
	 max_len=strlen(array[0]);
	 max_index=0;
	 for ( a=1; a< n; a++)
	     {
	     l=strlen ( array[a]);
	     if ( l>max_len)
	        {
		max_len=l;
		max_index=a;
		}
	     }
	 if (index!=NULL)index[0]=max_index;
	 if (len!=NULL)len[0]=max_len;
	 }
     
     return max_len;
     }

int get_shortest_string (char **array,int n, int *len, int *index)
     {
     int a, l;
     int min_len;

     if ( n==0|| array==NULL || read_size_char ( array,sizeof (char*))<n)return 0;
     else
         {
	 min_len=strlen(array[0]);

	 for ( a=1; a< n; a++)
	     {
	     l=strlen ( array[a]);
	     if ( l<min_len)
	        {
		min_len=l;

		}
	     }
	 if (index!=NULL)index[0]=a;
	 if (len!=NULL)len[0]=min_len;
	 }
     return min_len;
     }

char **pad_string_array ( char **array, int n, int len, char pad)
     {
     int a, b, l;
     for ( a=0; a< n; a++)
         {
	 l= strlen ( array[a]);
	 for (b=l; b<len; b++)array[a][b]=pad;
	 array[a][len]='\0';
	 }
     return array;
     }
char **right_pad_string_array ( char **array, int n, int len, char pad)
     {
     return pad_string_array(array, n, len, pad);
     }
char **left_pad_string_array ( char **array, int n, int len, char pad)
     {
     int a, b, c, l;
     char *buf;

     buf=vcalloc ( len+1, sizeof (char));
     for ( a=0; a< n; a++)
         {
	 l= strlen ( array[a]);
	 for (b=0; b<(len-l); b++)buf[b]=pad;
	 for (c=0,b=(len-l); b<=len; c++,b++)buf[b]=array[a][c];	 
	 sprintf (array[a], "%s", buf);

	 }
     vfree(buf);
     return array;
     }
char * crop_string (char *string, int start, int end)
     {
     static char *buf;
     /*Extract [start-end[*/

     if ( strlen (string)<end)
             {
	     fprintf ( stderr, "\nString=%s, start=%d end=%d", string, start, end);
	     crash ( "Wrong End in crop String [FATAL]");
	     }
     else
         {
	 buf=vcalloc (strlen (string)+1, sizeof (char));
	 string[end]='\0';
	 sprintf ( buf, "%s", string+start);
	 sprintf ( string,"%s", buf);
	 vfree (buf);
	 }

     return string;
     }
		  
int get_distance2char ( char *x, char*list)
    {

    char *y;
    y=x;
    if (x==NULL) return 0;
    while (!is_in_set (y[0], list) && y[0]!='\0')y++;
    return y-x;
    }
/*********************************************************************/
/*                                                                   */
/*                         TIME        FUNCTIONS                     */
/*                                                                   */
/*                                                                   */
/*********************************************************************/
static long ref;
static int child;
static long ticks;
static long milli_sec_conv=1000;


FILE *print_program_information (FILE *fp, char *comment)
{
   fprintf ( fp, "# Results Produced with %s (%s)\n",PROGRAM, VERSION);
   fprintf ( fp, "# %s is available from %s\n",PROGRAM,URL);  
   if (comment)fprintf ( fp, "# %s\n", comment);
   return fp;
}
FILE* print_cpu_usage (FILE *fp, char *comment)
{
  fprintf ( fp, "# %s CPU Usage: %d millisec\n", comment, get_time());
  return fp;
}
void print_exit_success_message ()
{
  
  fprintf ( stderr, "\n# TERMINATION STATUS: SUCCESS [PROGRAM: %s]\n", PROGRAM);
}
void print_exit_failure_message ()
{
  fprintf ( stderr, "\n# TERMINATION STATUS: FAILURE [PROGRAM: %s]\n", PROGRAM);
}




int get_time ()
	{
	static long time;
        struct tms time_buf[1];
	long tms_stime, tms_utime;

	if ( child==1)return get_ctime();
	  
	if ( ticks==0)ticks = sysconf(_SC_CLK_TCK);
	times ( time_buf);

	tms_stime=(long)time_buf->tms_stime*milli_sec_conv;
	tms_utime=(long)time_buf->tms_utime*milli_sec_conv;
	


	
	if ( ref==0)
		{
		ref=(tms_stime+tms_utime);
		return 0;
		}
	else
		{
		time=(tms_utime+tms_stime)-ref;
		return (int) ((time)/ticks);
		}
	}
int get_ctime ()
	{
	static long time;
        struct tms time_buf[1];
	long   tms_cutime, tms_cstime; 
	
	if ( ticks==0)ticks = sysconf(_SC_CLK_TCK);
	times ( time_buf);



	tms_cstime=(long)time_buf->tms_cstime*milli_sec_conv;
	tms_cutime=(long)time_buf->tms_cutime*milli_sec_conv;

	if ( ref==0)
	        {
		child=1;
		ref=tms_cstime+tms_cutime;
		return 0;
		}
	else
		{
		time=(tms_cutime+tms_cstime)-ref;
		return (int)((time)/ticks);
		}
	}
int reset_time()
        {
	ref=0;
	return (int)get_time();
	}
int increase_ref_time(int increase)
        {
	if ( ref==0)get_time();
	
	ref-=(long)ticks*(long)increase;
	if (ref==0)ref++;
	return (int)ref;
	}

/*********************************************************************/
/*                                                                   */
/*                         SYSTEM CALLS                              */
/*                                                                   */
/*                                                                   */
/*********************************************************************/	
int evaluate_sys_call_io ( char *out_file, char *com, char *fonc)
     {
     if ( check_file_exists (out_file))return 1;
     else
        {
	fprintf ( stderr, "\nCommand\n%s\nFailed to produce File\n%s\n", com, out_file);
	return 0;
	}
     }
void HERE (char *string, ...)
{
  va_list ap;
  
  va_start (ap, string);
  fprintf ( stderr, "HERE: ");
  vfprintf (stderr, string, ap);
  fprintf ( stderr, "\n");
  va_end (ap);
  
}
void printf_exit  (int exit_code, FILE *fp, char *string, ...)
{

  
  va_list ap;
  
  va_start (ap, string);
  vfprintf (fp, string, ap);
  va_end (ap);
  myexit (exit_code);
}


int fprintf_fork  (FILE *fp, char *string, ...)
{
  va_list ap;
  static char *openF;
  static char *closeF;
  
  char *pid_file;
  FILE *flag;
  struct flock fl;
  int fd,a;

  char buf[100000];
 
  if (!openF)
    {
      openF=vcalloc (100, sizeof (char));
      sprintf (openF, "cedric1");
      closeF=vcalloc (100, sizeof (char));
      sprintf (closeF, "cedric2");
      
      //openF =vtmpnam (NULL);
      //closeF=vtmpnam (NULL);
      vfclose(vfopen (openF,"w"));
    }
  while ((rename (openF,closeF))==-1);
    
  va_start (ap, string);
  vsprintf (buf, string, ap);
  va_end (ap);
  fprintf ( fp, "%s", buf);
  fflush (fp);
  rename (closeF, openF);
  
  return 0;
}
int fprintf_fork2  (FILE *fp, char *string, ...)
{
  va_list ap;
  static char *openF;
  static struct flock fl;
  char buf[100000];
  int fd;
  va_start (ap, string);
  vsprintf (buf, string, ap);
  va_end (ap);
  
  fprintf ( fp, "%s", buf);
  fflush (fp);
  return 0;
}

int printf_file  (char *file,char *mode, char *string,...)
{
  FILE *fp;
  va_list ap;
  
  if (!(fp=vfopen (file, mode)))return 0;
  va_start (ap, string);
  vfprintf (fp, string, ap);
  va_end (ap);
  vfclose (fp);
  return 1;
  }
int printf_system_direct  (char *string, ...)
{
  char buf[10000];
  
  va_list ap;
  
  va_start (ap, string);
  vsprintf (buf, string, ap);
  va_end (ap);
  return safe_system (buf);
}

int printf_system  (char *string, ...)
{
  char buf[10000];
  
  va_list ap;
  
  va_start (ap, string);
  vsprintf (buf, string, ap);
  va_end (ap);
  return my_system (buf);
}

int my_system_cl (int argc, char *argv[])
{
  int a,l;
  char *command;
  
  for ( a=0, l=0; a< argc; a++)l+=(strlen(argv[a])+2);
  command=vcalloc (l+1, sizeof(char));
  for ( a=0; a< argc; a++)
    {
      command=strcat (command, argv[a]);
      command=strcat (command, " ");
    }
  a=my_system ( command);
  vfree (command);
  return a;
}

int my_system ( char *command0)
{
  static char ***unpacked_list;
  static int n_unpacked;
  static int proxy_set;
  static int email_set;
  int email=0, proxy=0, update_env=0;
 
  //Set the net and E-mail status
  //if ( strstr (command0, "wget"))proxy=1;
  //if ( strstr (command0, "curl"))proxy=1;

  
  
  if ( strstr (command0, "extract_from_pdb"))proxy=1;
  if ( strstr (command0, "tc_generic_method"))proxy=1;
  if ( strstr (command0, "install"))proxy=1;
  if ( strstr (command0, "tc_generic_method"))email=1;
  
  

  if (!unpacked_list)
    {
      unpacked_list=declare_arrayN(3, sizeof (char), 3, 200,300);
    }

  if ( getenv ("DEBUG_PERL"))return safe_system (command0);
  else
    {
      char **list;
      int is_command;
      int a, c=0;
      char *command1;
      char *command2;
      int return_val;
      
      command1=vcalloc ( 3*strlen (command0)+1, sizeof (char));
      command2=vcalloc ( 100000, sizeof (char));      
      sprintf ( command1, "%s", command0);
      
      command1=substitute (command1, "|", " | ");
      command1=substitute (command1, ";", " ; ");
      
      list=string2list (command1);
      if ( !list) return EXIT_SUCCESS;
      is_command=1;

      //Identify T-Coffee self threads and install threads
      if ( strstr (list[1], "t_coffee"))update_env=1;
      else if ( strstr (list[1], "install.pl"))check_internet_connection (IS_FATAL);
      
      
      for ( a=1; a< atoi(list[0]); a++)
	{
	  if ( is_command)
	    {
	      if ( strstr ( list[a], "unpack_"))
		{
		  unpack_all_perl_script (list[a]+strlen ("unpack_"));
		  myexit (EXIT_SUCCESS);
		}
	      else if ((c=name_is_in_list (list[a], unpacked_list[0], n_unpacked, 100))!=-1);
	      else
		{
		  n_unpacked=unpack_perl_script (list[a], unpacked_list, n_unpacked);c=n_unpacked-1;
		}
	      //if non unpacked script check pg is installed:
	   	      
	      if ( strm (unpacked_list[2][c], "shell"))
		{
		  check_program_is_installed (list[a], NULL, NULL, NULL, INSTALL_OR_DIE);
		}
	      strcat (command2, ((c!=-1)?unpacked_list[1][c]:list[a]));
	      strcat (command2, " ");
	      is_command=0;
	      
	    }
	  else
	    {
	      strcat (command2, list[a]);
	      strcat (command2, " ");
	      if ( strm (list[a], ",") ||strm (list[a], "|")) is_command=1;
	    }
	}
      
      free_char (list,-1);
      vfree ( command1);
      command2=substitute ( command2, "//", "/");
      
      return_val=safe_system (command2);
      
      //INTERCEPT POTENTIAL NETWORK CALLS
      
      if (return_val!=EXIT_SUCCESS && proxy==1 && proxy_set==0)
	{
	  if (simple_check_internet_connection (NULL))proxy_set=1;
	  else
	    {
	      check_internet_connection (IS_NOT_FATAL);proxy_set=1;
	      return_val=safe_system (command2);
	    }
	}
      //Intercept potential Missing E-mails
      if (return_val!=EXIT_SUCCESS && email==1 && email_set==0)
	{
	  Email(INPUT, RESET);email_set=1;
	  return_val=safe_system (command2);
	}
      
      //update the environement that may have been modified by a thread
    
      if (update_env)get_t_coffee_environement (NULL);
      
      vfree ( command2);
      return return_val;
    }
}
int safe_system (const char * com)
{
    pid_t pid;
    int   status;
    if (com == NULL)
        return (1);
        
    if ((pid = fork ()) < 0)
        return (-1);
        
    if (pid == 0) {
        
        char * argv [4];
        
        argv [0] = "sh";
        argv [1] = "-c";
        argv [2] =(char*) com;
        argv [3] = 0;
        execvp ("/bin/sh", argv);
    }
    else
      {
	set_pid(pid);
      }
    
    
    while (1) {
    
        if (vwaitpid (pid, &status, 0) == -1) 
	  {
            if (errno != EINTR)
	      return (EXIT_FAILURE);
	  } 
	else 
	  {
            return (status);
	  }
    } 
}
static int **pidtable;
static int pidtable_s;
pid_t **declare_pidtable ()
{
  int a;
  pidtable_s=MAX_N_PID;
  
  pidtable=vcalloc (pidtable_s, sizeof (pid_t*));
  for (a=0; a< pidtable_s; a++)
    {
      pidtable[a]=vcalloc (2, sizeof (pid_t));
    }
  return pidtable;
}
pid_t set_pid (pid_t p)
{
  int cpid;
  
  if (!pidtable)declare_pidtable();
  if ( p<=0) return;
  else if ( p>=MAX_N_PID)printf_exit (EXIT_FAILURE,stderr,"ERROR PID=%d superior to MAX_N_PID=%d [FATAL]",p, MAX_N_PID); 
  pidtable[(int)p][0]=getpid();
  pidtable[(int)p][1]=1;
}
pid_t vfork ()
{
  pid_t p;
  static int attempt;
  
  if ( attempt==1000) printf_exit (EXIT_FAILURE, stderr,"\nERROR: Could not fork processes. Run again with -multi_core=no\n");
  
  
  p=fork();
  if (p==-1)
    {
      attempt++;
      wait(-1);
      return vfork();
    }
  else
    {
      attempt=0;
      return p;
    }
}
int    vwait_npid (int sub, int max, int min)
{
  if (max==0)
    {
      while (sub>0)
	{
	  vwait (NULL);
	  sub--;
	}
    }
  else if ( sub>=max)
    {
      while (sub>=min)
	{
	  vwait (NULL);
	  sub--;
	}
    }
  else{;}
  return sub;
}
    
pid_t  vwaitpid (pid_t p, int *status, int options)
{
  pid_t p2;
  
  p=waitpid (p, status, options);
    
  if (pidtable)pidtable[(int)p][0]=pidtable[(int)p][1]=0;
  return p;
}
pid_t vwait (pid_t *p)
{
  pid_t p2;
  
  p2=wait (p);
    
  if (pidtable)pidtable[(int)p2][0]=pidtable[(int)p2][1]=0;
  return p2;
}
int kill_child_pid()
{
  int n;

  if ( !pidtable)return 0;
  else
    {
      int a;
      pid_t cpid;
      cpid=getpid();
      for (a=0; a<pidtable_s; a++)
	{
	  if (pidtable[a][1] && pidtable[a][0]==cpid )
	    {
	      pidtable[a][1]=pidtable[a][0]=0;
	      kill((pid_t)a, SIGTERM);n++;
	    }
	}
    }
  return n;
}
	  



void unpack_all_perl_script (char *script)
{
  int a=0;
  FILE *fp;
  char command[1000];
  
  while ( !strm(PerlScriptName[a], "EndList"))
    {
      if (script==NULL || strm (script, "all") ||strm (script, "perl_script")|| strm (script,PerlScriptName[a]))
	{
	  fprintf ( stderr, "\nUnpack Script %s\n", PerlScriptName[a]);
	  fp=vfopen ( PerlScriptName[a], "w");
	  fprintf (fp, "%s\n%s\n", PERL_HEADER,PerlScriptFile[a]);
	  vfclose (fp);
	  sprintf ( command, "chmod u+x %s",PerlScriptName[a] );
	  safe_system (command);
	}
      a++;
    }
  myexit (EXIT_SUCCESS);
}
int satoi (char *);
int satoi (char *c)
{
  if ( !c)return 0;
  else return atoi (c);
}
  
int unpack_perl_script (char *name, char ***unpacked, int n)
{
  int a=0;
  
  set_file2remove_extension(".pl", SET);
  
  if ( name==NULL) unpack_all_perl_script (NULL);
  while ( !strm(PerlScriptName[a], "EndList") && !strm ( name, PerlScriptName[a]))
    {
      a++;
    }
  
  if ( strm(PerlScriptName[a], "EndList")|| (check_file_exists (name) && isexec(name) && satoi(getenv("RUN_LOCAL_SCRIPT"))) || (pg_is_installed (name) &&(satoi(getenv("RUN_LOCAL_SCRIPT"))) ))
       {
	 if ( check_file_exists (name) && ! strstr (name, "/") && isexec(name) && satoi(getenv ("RUN_LOCAL_SCRIPT")))
	   {
	     add_warning ( stderr, "\nWARNING: Local Copy of %s detected [Debug mode]. DELETE this file\n", name);
	     sprintf ( unpacked[0][n], "%s", name);
	     sprintf ( unpacked[1][n], "./%s", name);
	     sprintf ( unpacked[2][n], "shell");
	   }
	 else if ( pg_is_installed (name) &&satoi(getenv("RUN_LOCAL_SCRIPT")) )
	   {
	     add_warning ( stderr, "\nWARNING: Running external copy of %s [Debug mode].\n", name);
	     sprintf ( unpacked[0][n], "%s", name);
	     sprintf ( unpacked[1][n], "%s", name);
	     sprintf ( unpacked[2][n], "local");
	   }
	 else if ( strstr (name, "t_coffee"))
	   {
	     /*Cygwin pb: t_coffee cannot call itself: making a local copy for recursion*/
	     char buf[1000];
	     char *b2;
	     b2=vtmpnam (NULL);
	     sprintf (buf, "cp `which %s` %s; chmod u+x %s",name, b2, b2);
	     safe_system (buf);
	     sprintf ( unpacked[0][n], "%s", name);
	     sprintf ( unpacked[1][n], "%s", b2);
	     sprintf ( unpacked[2][n], "shell");
	     
	   }
	 else
	   {
	     sprintf ( unpacked[0][n], "%s", name);
	     sprintf ( unpacked[1][n], "%s", name);
	     sprintf ( unpacked[2][n], "shell");
	   }
       }
  else
    {
      FILE *fp;
      char command[1000];
      sprintf ( unpacked[0][n], "%s", name);
      sprintf ( unpacked[1][n], "%s", vtmpnam(NULL));
      sprintf ( unpacked[2][n], "unpack");
      fp=vfopen (unpacked[1][n], "w");
      fprintf (fp, "%s\n%s\n", PERL_HEADER,PerlScriptFile[a]);            
      vfclose (fp);
      sprintf ( command, "chmod u+x %s", unpacked[1][n]);
      safe_system (command);
    }
  set_file2remove_extension(".pl", UNSET);
  return ++n;
}
	
/*********************************************************************/
/*                                                                   */
/*                         IO FUNCTIONS                              */
/*                                                                   */
/*                                                                   */
/*********************************************************************/
char *program_name;
char *error_file;
static int add_file2error_report ( char *type, char *format, char *name);

char *in_cl;
FILE * print_command_line (FILE *fp )
{
  fprintf ( fp, "# Command Line: %s [PROGRAM:%s]\n",in_cl, PROGRAM);
  return fp;
}
int check_dir_getenv ( char *string);
char *get_plugins_4_tcoffee ( char *mode)
{
  static char *plugins_4_tcoffee;
  
  if ( !plugins_4_tcoffee)plugins_4_tcoffee=vcalloc ( 1000, sizeof (char));
  
  if (mode)plugins_4_tcoffee[0]='\0';

  
  if ( plugins_4_tcoffee[0])return plugins_4_tcoffee;
  else if ( mode) sprintf (plugins_4_tcoffee, "%s", mode);
  else if ( check_dir_getenv ("PLUGINS_4_TCOFFEE"))
    {
      sprintf (plugins_4_tcoffee, "%s", getenv ("PLUGINS_4_TCOFFEE"));
    }
  else
    {
      sprintf (plugins_4_tcoffee, "%s/plugins/%s/", get_dir_4_tcoffee(), get_os());
    }
  //if (!isdir (plugins_4_tcoffee)){printf_exit (EXIT_FAILURE, stderr, "ERROR: The declared plugin directory for T-Coffee is invalid: [%s] [FATAL:%s %s]", plugins_4_tcoffee, PROGRAM, VERSION); }
  return plugins_4_tcoffee;
}
char *get_home_4_tcoffee ()
{
  static char *home_4_tcoffee;
  static char home[1000];
  

  if ( !home_4_tcoffee)
    home_4_tcoffee=vcalloc ( 1000, sizeof (char));
  
  if ( home_4_tcoffee[0])return home_4_tcoffee;
  else if ( check_dir_getenv ("HOME_4_TCOFFEE"))
    {
      sprintf (home_4_tcoffee, "%s", getenv ("HOME_4_TCOFFEE"));
    }
  else if ( check_dir_getenv ("HOME"))
    {
      sprintf (home_4_tcoffee, "%s", getenv ("HOME"));
      sprintf (home, "%s", home_4_tcoffee);
    }
  else if ( check_dir_getenv ("TMP"))
    {
      sprintf (home_4_tcoffee, "%s", getenv ("TMP"));
    }
  else if (check_dir_getenv ("TEMP"))
    {
      sprintf (home_4_tcoffee, "%s", getenv ("TEMP"));
    }
  else 
    {
      printf_exit (EXIT_FAILURE, stderr, "ERROR: Could not set a HOME directory.\nSet any of the following environement variables to some suitable location: HOME, HOME_4_TCOFFEE, TMP or TEMP [FATAL:%s]\n", PROGRAM);

    }
  
 
  if ( !strm( home, home_4_tcoffee))
    add_warning (stderr, "WARNING: The Home directory was set to %s", home_4_tcoffee);
 
  return home_4_tcoffee;
}
int get_nproc ()
{
  static int nproc;

  if (nproc);
  else if ( get_int_variable ("n_core"))
    {
      nproc=get_int_variable ("n_core");
    }
  else if ( getenv ("NUMBER_OF_PROCESSORS_4_TCOFFEE"))
    {
      nproc=atoi(getenv ("NUMBER_OF_PROCESSORS_4_TCOFFEE"));
    }
  else if ( getenv ("NUMBER_OF_PROCESSORS"))
    {
      nproc=atoi(getenv ("NUMBER_OF_PROCESSORS"));
    }
  else if ( check_file_exists ("/proc/cpuinfo"))
    {
      char *tmp;
      char string[100];
      tmp=vtmpnam (NULL);
      printf_system ("grep \"^processor\" /proc/cpuinfo | wc -l>%s", tmp);
      sprintf ( string, "%s", file2string (tmp));
      chomp (string);
      nproc=atoi (string);
    }
  else
    nproc=1;
    
  return nproc;
}
char * get_os()
{
  static char os[100];
  char *file;
  
  if ( os[0])return os;
  else
    {
      char *command;
      char *s;

      command=vcalloc (100, sizeof (char));
      file=tmpnam (NULL);
      sprintf ( command, "uname > %s", file);
      safe_system (command);
      s=file2string (file);
      lower_string (s);
      
      if (strstr (s, "cygwin"))sprintf ( os, "windows");
      else if ( strstr (s, "linux"))sprintf ( os, "linux");
      else if ( strstr (s, "osx"))sprintf ( os, "macosx");
      else if ( strstr (s, "darwin"))sprintf ( os, "macosx");
      else sprintf (os, "%s", s);
      vfree (s);
      vfree (command);
      vremove (file);
    }
  return os;
}

char *file_putenv (char *file)
{
  if (!file) return NULL;
  else if ( !check_file_exists (file))return NULL;
  else
    {
      char ***list;
      int n=0;
      list=file2list (file, "\n");
      while (list[n])
	{
	  if ( list[n][1][0]!='#')cputenv ("%s",list[n][1]);
	  n++;
	}
      free_arrayN ((void ***)list, 3);
    }

  return NULL;
}
int cputenv   (char * string, ...)
{
  va_list ap;
  char *file;
  char *s;
  FILE *fp;
  if (!string)return 0;
  file=vtmpnam (NULL);
  va_start (ap, string);
  fp=vfopen (file, "w");
  vfprintf (fp, string, ap);
  vfclose (fp);
  va_end (ap);
  s=file2string (file);
  if (!s) return 0;
  putenv (s);
  return 1;
}
  
int check_dir_getenv ( char *string)
{
  char *p;

  
 
  p=getenv ( string);
  if ( !p) return 0;
  if ( !p || access (p, F_OK)==-1 || access (p, W_OK)==-1 || access(p, R_OK)==-1 || access (p, X_OK)==-1)return 0;
  
  return 1;
}

char *get_dir_4_tcoffee()
{
  static char dir_4_tcoffee[1000];
  if (dir_4_tcoffee[0])return dir_4_tcoffee;
  else
    {
      if ( getenv ("DIR_4_TCOFFEE"))sprintf (dir_4_tcoffee, "%s", getenv("DIR_4_TCOFFEE"));
      else sprintf ( dir_4_tcoffee, "%s/.t_coffee",get_home_4_tcoffee());
      sprintf ( DIR_4_TCOFFEE, "%s", dir_4_tcoffee);
      my_mkdir (dir_4_tcoffee);
    }
  return dir_4_tcoffee;
}
char *get_tmp_4_tcoffee ()
{
  static char tmp_4_tcoffee [1000];
  
  if ( tmp_4_tcoffee[0])return tmp_4_tcoffee;
  else
    {
      
      if ( getenv ("TMP_4_TCOFFEE"))sprintf (tmp_4_tcoffee, "%s", getenv("TMP_4_TCOFFEE"));
      else
	{
	  char command [1000];
	  
	  if ( strm (get_os(), "windows"))
	    {
	      sprintf ( tmp_4_tcoffee, ".TCtmp");
	    }
	  else
	    {
	    sprintf ( tmp_4_tcoffee, "%s/tmp", get_dir_4_tcoffee());
	    }
	}
     
      sprintf ( TMP_4_TCOFFEE, "%s", tmp_4_tcoffee);
      my_mkdir (tmp_4_tcoffee);
    }

  return tmp_4_tcoffee;
}
char *get_cache_4_tcoffee ()
{

  static char cache_4_tcoffee [1000];
  if ( cache_4_tcoffee[0])return cache_4_tcoffee;
  else
    {
      if ( getenv ("CACHE_4_TCOFFEE"))sprintf (cache_4_tcoffee, "%s", getenv("CACHE_4_TCOFFEE"));
      else sprintf ( cache_4_tcoffee, "%s/cache/", get_dir_4_tcoffee());
      sprintf ( CACHE_4_TCOFFEE, "%s", cache_4_tcoffee);
      my_mkdir(cache_4_tcoffee); /*Do not use mkdir: not yet initialized*/
    }
  return cache_4_tcoffee;
}
char *get_mcoffee_4_tcoffee ()
{
  static char mcoffee_4_tcoffee [1000];
  if ( mcoffee_4_tcoffee[0])return mcoffee_4_tcoffee;
  else
    {
      if ( getenv ("MCOFFEE_4_TCOFFEE"))sprintf (mcoffee_4_tcoffee, "%s", getenv("MCOFFEE_4_TCOFFEE"));
      else sprintf ( mcoffee_4_tcoffee, "%s/mcoffee/", get_dir_4_tcoffee());
      my_mkdir (mcoffee_4_tcoffee);
    }
  return mcoffee_4_tcoffee;
}
char *get_methods_4_tcoffee ()
{
  static char methods_4_tcoffee [1000];
  if ( methods_4_tcoffee[0])return methods_4_tcoffee;
  else
    {
      if ( getenv ("METHODS_4_TCOFFEE"))sprintf (methods_4_tcoffee, "%s", getenv("METHODS_4_TCOFFEE"));
      else sprintf ( methods_4_tcoffee, "%s/methods/", get_dir_4_tcoffee());
      my_mkdir(methods_4_tcoffee);
    }
  return methods_4_tcoffee;
}
  
char ** standard_initialisation ( char **in_argv, int *in_argc)
{
  return standard_initialisation_end   (standard_initialisation_start (in_argv, in_argc), in_argc);
}
int getpid_ref()
{
  static int pid;
  if (!pid)pid=getpid();
  return pid;
}
  
char ** standard_initialisation_start ( char **in_argv, int *in_argc)
      {
	static int standard_initialisation_done;
	char **out_argv;
	FILE *fp, *fp2;
	int a,c, stdi;
	//Break the command line, intercept the pipe, prepare the exit
	
	getpid_ref();
	if ( in_argv==NULL)
	  {
	    standard_initialisation_done=0;
	    return NULL;
	  }
	
	else if ( standard_initialisation_done==1)
	  {
	    return in_argv;
	  }
	else standard_initialisation_done=1;
	/*1 Check for the cache and tmp directories*/
	
	get_dir_4_tcoffee();
	get_tmp_4_tcoffee();
	
	for (c=0,a=0; a<in_argc[0]; a++)c+=strlen (in_argv[a])+3;
	in_cl=vcalloc ( c, sizeof (char));
	for (a=0; a<in_argc[0]; a++)
	  {
	    strcat ( in_cl, in_argv[a]);
	    strcat (in_cl, " ");
	  }
	
/*Standard exit*/
	global_exit_signal=EXIT_SUCCESS;
	atexit (main_exit);	
	atexit (output_warning_list);
	signal (SIGTERM, main_exit);
	signal (SIGINT, main_exit);
		
	signal (SIGABRT ,error_exit);
	signal (SIGFPE  ,error_exit);
	signal (SIGILL  ,error_exit);
	signal (SIGSEGV ,error_exit);
	

/*Process the parameters*/
      
      program_name=vcalloc ( strlen (in_argv[0])+strlen (PROGRAM)+1, sizeof (char));
      if (in_argv)
	  {
	    sprintf ( program_name, "%s", in_argv[0]);
	    out_argv=break_list ( in_argv, in_argc, "=;, \n");
	  }
      else
	{
	 sprintf ( program_name, "%s",PROGRAM); 
	}
      
      if ( name_is_in_list ( "-no_error_report", out_argv, in_argc[0], 100)!=-1)
	no_error_report=1;

/*Error Log File: contains every input file*/      
      error_file=vtmpnam(NULL);
      fp=vfopen (error_file, "w");
      fprintf ( fp, "\n######### RUN_REPORT      START  ######");
      fprintf ( fp, "\n######### PROGRAM_VERSION START  ######");      
      fprintf ( fp, "\n          %s, %s", PROGRAM, VERSION);
      fprintf ( fp, "\n######### PROGRAM_VERSION END    ######");
      
      fprintf ( fp, "\n######### COMMAND_LINE    START  ######");
      fprintf ( fp, "\n");
      for (a=0; a<in_argc[0]; a++)fprintf (fp, "%s ", out_argv[a]);
      fprintf ( fp, "\n######### COMMAND_LINE    END    ######\n");
      
      for ( a=1; a<in_argc[0]; a++)
	{
	  if ( check_file_exists ( out_argv[a]) && !filename_is_special (out_argv[a]))
	    {
	      
	      fprintf ( fp, "\n######### FILE: %s        START  ######\n", out_argv[a]);
	      fprintf ( fp, "\n");
	      fp2=vfopen ( out_argv[a], "r");
	      while ((c=fgetc(fp2))!=EOF)fprintf (fp, "%c", c);
	      vfclose (fp2);
	      fprintf ( fp, "\n######### FILE: %s        END    ######\n", out_argv[1]);
	    }
	}
      fprintf ( fp, "\n######### RUN_REPORT END         ######\n");
      vfclose (fp);
      
/*Initialise the time*/
      get_time();	
      
   
      for (a=1, stdi=0; a<in_argc[0]; a++)
	{
	  if ( (strm ( out_argv[a], "stdin") || strm (out_argv[a], "STDIN")) && stdi==0)
	    {
	      char *file;
	      FILE *fp, *fp_stdi;
	      
	      if ( stdi==0)
		{
		  file=vtmpnam (NULL);
		  vfree (out_argv[a]);
		  out_argv[a]=vcalloc ( strlen (file)+1, sizeof (char));
		  sprintf (out_argv[a], "%s", file);
		  fp_stdi=vfopen ("stdin", "r");
		  fp=vfopen (file, "w");
		  while ( (c=fgetc (fp_stdi))!=EOF)fprintf (fp, "%c", c);
		  vfclose (fp);
		  vfclose (fp_stdi);
		  stdi=1;
		}
	      else if ( stdi ==1)
		{
		  printf_exit ( EXIT_FAILURE,stderr, "ERROR: Attempt to get more than one file via pipe [FATAL:%s]\n", PROGRAM);
		}
	    }
	}

      return out_argv;
      }
char ** standard_initialisation_end ( char **in_argv, int *in_argc)
{
  //All the initialization that 
  static int standard_initialisation_end_done;
  //Break the command line, intercept the pipe, prepare the exit
  if ( in_argv==NULL)
    {
      standard_initialisation_end_done=0;
      return NULL;
    }
  else if ( standard_initialisation_end_done==1)
    {
      return in_argv;
    }
  else standard_initialisation_end_done=1;
  
  //set the environement variables (proxy and E-mail if possible)
  get_t_coffee_environement (NULL);
  
  
  //clean the cache if needed
  //printf_system ("clean_cache.pl -dir=%s/cache -size=%d",get_dir_4_tcoffee (), CACHE_MAX_SIZE);
  return in_argv; 
}

  
int add_file2error_report ( char *type, char *format, char *name)
  {
  FILE *fp1, *fp2;
  int c;
  
  
  
  fp1=vfopen ( error_file, "a");
  fp2=vfopen (name, "r");
  fprintf ( fp1, "######### OUTFILE: %s        START  ######\n", name);
  while ( (c=fgetc(fp2))!=EOF)fprintf (fp1, "%c", c);
  c=ungetc(c,fp2);c=fgetc(fp2); if ( c!='\n')fprintf (fp1, "\n");
  fprintf ( fp1, "######### OUTFILE: %s        END    ######\n", name);
  vfclose ( fp1);vfclose(fp2);
  return 1;
  
}


void myexit (int signal)
{
  global_exit_signal=signal;
  if ( signal == EXIT_FAILURE)
    {
      print_exit_failure_message();
    }
  else if ( signal==EXIT_SUCCESS)
    {
      /*print_exit_success_message();*/;
    }
  exit (global_exit_signal);
}


static int n_warning;
static char **warning_list;

FILE *fatal_exit (FILE *fp,int exit_mode, char *string, ...)
{
  va_list ap;
  va_start (ap, string);
  vfprintf (fp, string, ap);
  va_end (ap);
  myexit (exit_mode);
  return fp;
}
static int warning_mode;
int set_warning_mode ( int mode)
{
  warning_mode=mode;
  return mode;
}
FILE *add_warning (FILE *fp, char *string, ...)
{
  char buf[10000];
  static int max_n_warning=100;
  va_list ap;


  if ( warning_mode==NO || getenv("NO_WARNING_4_TCOFFEE"))return fp;
  
  
  if ( !warning_list)warning_list=vcalloc (max_n_warning, sizeof (char*));
  else if ( n_warning>=max_n_warning)
    {
      max_n_warning+=100;
      warning_list=vrealloc ( warning_list,sizeof (char*)*max_n_warning);
    }
  
  va_start (ap, string);
  if (fp)
    {
      fprintf ( fp, "\n");
      vfprintf (fp, string, ap);
    }
  va_end(ap);
  
  va_start (ap, string);
  vsprintf (buf, string, ap);
  va_end (ap);

  warning_list[n_warning]=vcalloc (strlen (buf)+1, sizeof (char));
  sprintf ( warning_list[n_warning], "%s", buf);
  n_warning++;
  
  return fp;
}
void output_warning_list()
{
  int a;
  if ( n_warning==0){;}
  else
    {
      fprintf ( stderr, "\nWARNING RECAPITULATION: %d Warning%c [PROGRAM: %s]\n", n_warning, (n_warning>1)?'s':' ', PROGRAM);
      for (a=0; a< n_warning; a++)
	{
	  fprintf (stderr, "**WARNING: %3d** %s\n",a+1, warning_list[a]);
	}
    }
}
    
 
int   count_n_res_in_array  (char *array, int len)
      {
	return count_n_symbol_in_array(array, "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ", len);
      }
int   count_n_gap_in_array  (char *array, int len)
      {
	int l;
	if ( len<=0 ||len>strlen(array) )l=strlen(array);
	else l=len;
	
	return l- count_n_res_in_array (array,len);
      }
int count_n_symbol_in_array ( char *array, char *array_list, int len)
      {
	int a=0, t=0;
	int l;
	
	if ( len<=0 ||len>strlen(array) )l=strlen(array);
	else l=len;

	for ( a=0; a< l; a++)t+=is_in_set (array[a], array_list);
	return t;
      }

char* count_strings_in_file ( char *in, char *out)
{
  FILE *fp;
  int n,c;
  char **list, **result;

  
  if (!out) out=vtmpnam (NULL);
  list=declare_char (count_n_line_in_file(in)+1, measure_longest_line_in_file (in)+1);
  
  n=0;
  fp=vfopen (in, "r");
  while ((c=fgetc (fp))!=EOF)
    {
      ungetc (c, fp);
      fscanf (fp, "%s\n",list[n]);
      n++;
    }
  vfclose (fp);
  
  result=count_strings (list, n);
  
  
  n=0;
  fp=vfopen (out, "w");
  while (result[n])fprintf ( fp,"%s\n", result[n++]);
  vfclose (fp);
  
  free_char (list, -1);
  free_char (result, -1);
  
  return out;
}

int ** count_int_strings (int **array, int len, int s)
{
  int **result;
  int a,n;
  
  sort_list_int (array,s, s,0, len-1);
  result=vcalloc (len, sizeof (int*));
  for (n=-1,a=0; a<len; a++)
    {
      if (n==-1 || memcmp (array[a], result[n], sizeof (int)*s)!=0)
	{
	  n++;
	  result[n]=vcalloc (s+1, sizeof (int));
	  memcpy (result[n],array[a], sizeof (int)*s);
	  fprintf ( stdout, "*");
	}
      result[n][s]++;
    }
  sort_int (result, s+1, s, 0, n);
  result=vrealloc ( result, sizeof (int*)*n);
  return result;
}
  
char** count_strings ( char **array, int len)
{
  int a, c, n;
  char *cs;
  char **result;
  
  result=vcalloc (len+1, sizeof (char*));
  array=sort_string_array (array, len);

  for (c=0, a=0, n=0, cs=NULL; a< len; a++)
    {
      if (cs == NULL || !strm (cs, array[a]))
	{
	  if (cs)
	    {
	      result[c]=vcalloc (strlen (cs)+20, sizeof (char));
	      sprintf ( result[c], "%s %d", cs, n);
	      c++;
	    }
	  
	  n=1;
	  cs=array[a];
	}
      else n++;
    }
  
  result[c]=vcalloc (strlen (cs)+20, sizeof (char));
  sprintf ( result[c], "%s %d", cs, n);
 
  return result;
}
	  
int   get_first_non_white_char (char *name)
{
  if ( !name) return 0;
  else if ( !check_file_exists (name))return 0;
  else
    {
      FILE *fp;
      char c;
      
      fp=vfopen (name, "r");
      while (isspace ((c=fgetc (fp)))&& c!=EOF);
      vfclose (fp);
      return c;
    }
}
int   count_n_char_x_in_file(char *name, char x)
      {
      FILE *fp;
      int n, c;

      n=0;
      fp=vfopen(name, "r");
      while ( (c=fgetc(fp))!=EOF)n+=(c==x);
      vfclose (fp);
      return n;
      }
int   count_n_char_in_file(char *name)
      {
      int  c, n;
      FILE *fp;

      n=0;
      fp=vfopen(name, "r");
      while ( (c=fgetc(fp))!=EOF){n++;}
      vfclose (fp);
      return n;
      }
int count_n_line_in_file ( char *name )
     {
      int  c, n;
      FILE *fp;

      n=0;
      fp=vfopen(name, "r");
      while ( (c=fgetc(fp))!=EOF)n+=(c=='\n');
      vfclose (fp);
      return n;
      }
int measure_longest_line_in_file ( char *name )
     {
      int  c;
      FILE *fp;
      int longest=0;
      int current=0;


      fp=vfopen(name, "r");
      while ( (c=fgetc(fp))!=EOF)
	  {
	      if ( c=='\n'){longest=MAX(longest, current+1);current=0;}
	      else current++;
	  }
      longest=MAX(longest, current+1);

      vfclose (fp);
      return longest;
      }
char *input_name ()
	{
	char *string;
	int a;
	char ch;
	
	string= vcalloc ( 500, sizeof ( char));
	
	a=0;
    	while ( ( ch=getchar())!='\n' && a<500)
    			string[a++]=ch;
    	string[a]='\0'; 
    	
    	if ( string[0]=='\0')
    		{
    		vfree (string);
    		return NULL;
    		}
    	else
    		return string;
    	}

FILE * vtmpfile()
    {
        return tmpfile();
    }
int string_variable_isset (char *name)
{
  if (store_string_variable (name,NULL, ISSET)==NULL)return 0;
  else return 1;
}
char* set_string_variable (char *name, char * v)
{
  return store_string_variable (name, v, SET);
}
char * get_string_variable (char *name)
{
  return store_string_variable (name,NULL, GET);
}
char* unset_string_variable (char *name)
{
  return store_string_variable (name,0, UNSET);
}

char* store_string_variable (char *name, char* v, int mode)
{
  static char **name_array, **val_array;
  static int n;
  int a;
  
  if ( mode == SET)
    {
      
      for (a=0; a<n; a++)
	{
	  if ( strm (name,name_array[a]))
	    {
	      if (v)
		{
		  val_array[a]=vrealloc (val_array[a], strlen (v)+1);
		  sprintf (val_array[a],"%s",v);
		}
	      else val_array[a]='\0';
	      return v;
	    }
	}
      if (!name_array)
	{
	  name_array=vcalloc (1, sizeof (char*));
	  val_array=vcalloc  (1, sizeof (char*));
	}
      else
	{
	  name_array=vrealloc (name_array, (n+1)*sizeof (char*));
	  val_array=vrealloc (val_array, (n+1)*sizeof (char*));
	}
      name_array[n]=vcalloc ( strlen (name)+1, sizeof (char));
      val_array[n]=vcalloc ( strlen (v)+1, sizeof (char));
      
      sprintf ( name_array[n], "%s", name);
      sprintf ( val_array[n], "%s", v);
      n++;
      
      return v;
      
    }
  else if ( mode == ISSET)
    {
       for (a=0; a<n; a++) 
	 if ( strm (name_array[a], name))return (char *)1;
    }
  else if ( mode == UNSET)
    {
      for (a=0; a<n; a++) 
	if ( strm (name_array[a], name))
	  {
	    name_array[a][0]='\0';
	    val_array[a][0]='\0';
	    return 0;
	  }
      add_warning (stdout, "WARNING: Could not UNSET the value of %s. You must SET the value before it is used", name);
    }
  else if (mode==GET)
    {
      for (a=0; a<n; a++) 
	{
	  if ( strm (name_array[a], name))
	    return val_array[a];
	}
    }
  return NULL;
}
int int_variable_isset (char *name)
{
  return store_int_variable (name,0, ISSET);
}
int set_int_variable (char *name, int v)
{
  return store_int_variable (name, v, SET);
}
int get_int_variable (char *name)
{
  return store_int_variable (name, 0, GET);
}
int unset_int_variable (char *name)
{
  return store_int_variable (name,0, UNSET);
}

int store_int_variable (char *name, int v, int mode)
{
  static char **name_array; 
  static int *val_array;
  static int n;
  int a;
  
  if ( mode == SET)
    {
      for (a=0; a<n; a++)
	{
	  if ( strm (name,name_array[a]))
	    {
	      val_array[a]=v;
	      return v;
	    }
	}
      if (!name_array)
	{
	  name_array=vcalloc (1, sizeof (char*));
	  val_array=vcalloc  (1, sizeof (int));
	}
      else
	{
	  name_array=vrealloc (name_array, (n+1)*sizeof (char*));
	  val_array=vrealloc (val_array, (n+1)*sizeof (int));
	}
      name_array[n]=vcalloc ( strlen (name)+1, sizeof (char));
      sprintf ( name_array[n], "%s", name);
      val_array[n]=v;
      n++;
      
      return v;
      
    }
  else if ( mode == ISSET)
    {
       for (a=0; a<n; a++) 
	 if ( strm (name_array[a], name))return 1;
    }
  else if ( mode == UNSET)
    {
      for (a=0; a<n; a++) 
	if ( strm (name_array[a], name))
	  {
	    name_array[a][0]='\0';
	    val_array[a]=0;
	    return 0;
	  }
      add_warning (stdout, "WARNING: Could not UNSET the value of %s. You must SET the value before it is used", name);
    }
  else if (mode==GET)
    {
      for (a=0; a<n; a++) 
	{
	  if ( strm (name_array[a], name))
	    return val_array[a];
	}
    }
  return 0;
}

char *add2t_coffee_environement (char *env, ...)
{
  char *s;
  va_list ap;
  char *file;
  char *tmp_env_file;
  char *env_file;
  FILE *in, *out, *fp;
  static char *buf,*value1, *value2;
  
  if (!buf)
    {
      buf=vcalloc (LONG_STRING, sizeof (char));
      value1=vcalloc (LONG_STRING, sizeof (char));
      value2=vcalloc (LONG_STRING, sizeof (char));
    }
  file=vtmpnam (NULL);
  tmp_env_file=vtmpnam (NULL);
  
  va_start (ap, env);
  fp=vfopen (file, "w");
  vfprintf (fp,env, ap);
  vfclose (fp);
  va_end (ap);
  s=file2string (file);
  sprintf (value1, "%s", s);
  substitute_char (value1, '=', '\0');
  
  //add the new environement variable to the env file
  if (!get_string_variable ("t_coffee_env"))get_t_coffee_environement (NULL);
  env_file=get_string_variable ("t_coffee_env");
  
  out=vfopen(tmp_env_file, "w");
  if ( check_file_exists (env_file))
    {
      in=vfopen (env_file, "r");
      
      while ( (fgets (buf,LONG_STRING, in))!=NULL)
	{
	  sprintf (value2, "%s", buf);
	  substitute_char (value2, '=', '\0');
	  if ( !strm (value1, value2))fprintf ( out, "%s",buf);
	}
      vfclose (in);
    }
  
  fprintf ( out, "%s\n", s);
  vfclose (out);
  
  if ( check_file_exists (tmp_env_file))printf_system ("cp %s %s", tmp_env_file, env_file);
  //  fp=vfopen (get_string_variable ("t_coffee_env"), "a");
  //fprintf ( fp, "%s\n",s);
  //vfclose (fp);
  
  //add the variable to T-Coffee
  putenv (s);
  return NULL;
}
char *get_t_coffee_environement (char *file)
{
  char *def_env;
  
  
  if ( file);
  else if ((file=getenv ("ENV_4_TCOFFEE")));
  else if (get_dir_4_tcoffee())
    {
      file=vcalloc ( 100, sizeof (char));
      sprintf (file, "%s/t_coffee_env", get_dir_4_tcoffee());
    }
  else
    {
      file=vcalloc ( 100, sizeof (char));
      sprintf (file, "%s/t_coffee_env", getenv ("HOME"));
    }
  set_string_variable ("t_coffee_env", file);
  
  def_env=vtmpnam (NULL);
  printf_system ("env > %s", def_env);
  file_putenv (def_env);
  file_putenv (file);
  if (!getenv ("DIR_4_TCOFFEE")) cputenv("DIR_4_TCOFFEE=%s", get_dir_4_tcoffee());
  if (!getenv ("TMP_4_TCOFFEE")) cputenv("TMP_4_TCOFFEE=%s", get_tmp_4_tcoffee());
  if (!getenv ("CACHE_4_TCOFFEE")) cputenv("CACHE_4_TCOFFEE=%s", get_cache_4_tcoffee());
  
  set_path_4_plugins (NULL);
  get_email_from_env();
  get_proxy_from_env();
}
char * set_path_4_plugins (char *plugins)
{
  if (plugins)get_plugins_4_tcoffee (plugins);
  
  //set various important variables
  if (!getenv ("MAFFT_BINARIES"))cputenv ("MAFFT_BINARIES=%s", get_plugins_4_tcoffee(NULL));
  if (!getenv ("PLUGINS_4_TCOFFEE")) cputenv("PLUGINS_4_TCOFFEE=%s", get_plugins_4_tcoffee(NULL));
  
  if (!getenv ("MCOFFEE_4_TCOFFEE")) cputenv("MCOFFEE_4_TCOFFEE=%s", get_mcoffee_4_tcoffee());
  if (!getenv ("METHODS_4_TCOFFEE")) cputenv("METHODS_4_TCOFFEE=%s", get_methods_4_tcoffee());
  cputenv ("PATH=%s:%s", get_plugins_4_tcoffee(NULL), getenv ("PATH"));
  //set various packages 
  add_package2_tcoffee_env ("CLUSTALW_4_TCOFFEE");
  add_package2_tcoffee_env ("CLUSTALW2_4_TCOFFEE");
  add_package2_tcoffee_env ("FUGUE_4_TCOFFEE");
  add_package2_tcoffee_env ("CLUSTALW2_4_TCOFFEE");
  add_package2_tcoffee_env ("TMALIGN_4_TCOFFEE");
  add_package2_tcoffee_env ("SAP_4_TCOFFEE");
  add_package2_tcoffee_env ("DALILITEc_4_TCOFFEE");
  add_package2_tcoffee_env ("MUSTANG_4_TCOFFEE");
  add_package2_tcoffee_env ("NCBIBLAST_4_TCOFFEE");
  add_package2_tcoffee_env ("MAFFT_4_TCOFFEE");
  add_package2_tcoffee_env ("DIALIGNTX_4_TCOFFEE");
  add_package2_tcoffee_env ("POA_4_TCOFFEE");
  add_package2_tcoffee_env ("PROBCONS_4_TCOFFEE");
  add_package2_tcoffee_env ("PROBCONSRNA_4_TCOFFEE");
  add_package2_tcoffee_env ("TCOFFEE_4_TCOFFEE");
  add_package2_tcoffee_env ("PCMA_4_TCOFFEE");
  add_package2_tcoffee_env ("KALIGN_4_TCOFFEE");
  add_package2_tcoffee_env ("AMAP_4_TCOFFEE");
  add_package2_tcoffee_env ("PRODA_4_TCOFFEE");
  add_package2_tcoffee_env ("PRANK_4_TCOFFEE");
  add_package2_tcoffee_env ("CONSAN_4_TCOFFEE");
  add_package2_tcoffee_env ("RNAPlfold_4_TCOFFEE");
  add_package2_tcoffee_env ("HMMtop_4_TCOFFEE");
  add_package2_tcoffee_env ("GOR4_4_TCOFFEE");
  return NULL;
}

int add_package2_tcoffee_env (char *package)
{
  char *v1, *v2;
  
  if ((v1=getenv (package))==NULL)return 0;
  
  v2=filename2path (v1);
  if (!v2){vfree (v1);return 0;}
  cputenv ("PATH=%s:%s",v2, getenv ("PATH"));
  vfree (v1); vfree (v2);
  return 1;
}
    
      
char * Proxy( int input_mode, int write_mode)
{
  static char *proxy;
  static int set;

  if ( write_mode==RESET){set=0;vfree (proxy); proxy=NULL;return Proxy(input_mode, SET);}
  
  if (set);
  else if ( input_mode ==INPUT){proxy=get_proxy();}
  else if ( input_mode ==ENV  ){proxy=get_proxy_from_env (); }
  else printf_exit (EXIT_FAILURE,stderr, "Unknown mode for Proxy [FATAL:%s(%s)]", PROGRAM, VERSION);
  
  set=1;
  if (proxy)set_proxy (proxy);
  else proxy=vcalloc (1, sizeof (char));
  
  return proxy;
}
char * get_proxy_from_env ()
{
  char *proxy=NULL;
  
  if ((proxy=get_string_variable ("cl_proxy"))){;}//Command line proxy always wins
  else if ((proxy=getenv ("http_proxy_4_TCOFFEE"))); 
  else if ((proxy=get_string_variable ("proxy")));//use default T-Coffee proxy
  else if ( getenv ("HTTP_proxy") && getenv ("http_proxy")){return getenv ("HTTP_proxy");}//get environement proxy
  else if ((proxy=getenv ("HTTP_proxy")));//id 
  else if ((proxy=getenv ("http_proxy")));//id
  else if ((proxy=getenv ("HTTP_PROXY")));//id
  else if ((proxy=getenv ("ALL_proxy")));//id
  else if ((proxy=getenv ("all_proxy")));//id
  else if ((proxy=getenv ("ALL_PROXY")));//id
  
  if (proxy)set_proxy(proxy);
  return proxy;
}
char *get_proxy ()
{

  char *proxy=NULL;
  
  if ( (proxy=get_proxy_from_env()) && simple_check_internet_connection(NULL));
  else //read in the proxy
    {
      proxy_message();
      input_proxy();
      proxy=get_proxy();
    }
  return proxy;
}
int set_proxy (char *proxy)
{
  char *http;
  if (!proxy) return 0;
  
  cputenv ("HTTP_proxy_4_TCOFFEE=%s", proxy);
  cputenv ("HTTP_proxy=%s", proxy);
  cputenv ("http_proxy=%s", proxy);
  cputenv ("HTTP_PROXY=%s", proxy);
  cputenv ("ALL_proxy=%s", proxy);
  cputenv ("ALL_PROXY=%s", proxy);
  cputenv ("all_proxy=%s", proxy);
  
  return 1;
}
char *proxy_message ()
{
  fprintf ( stderr, "\n\n");
  fprintf ( stderr, "*************************************************************************************************\n");
  fprintf ( stderr, "*                        IMPORTANT: Please Read Carefuly                                        *\n");
  fprintf ( stderr, "*                                                                                               *\n");
  fprintf ( stderr, "* ------------------------------FIRST RUN CONFIGURATION---------------------------------------- *\n");
  fprintf ( stderr, "*                                                                                               *\n");
  fprintf ( stderr, "*                                                                                               *\n");
  fprintf ( stderr, "* If you are behind a firewall, you must enter your proxy address to use webservices            *\n");
  fprintf ( stderr, "* This address is usualy something like: http://some.place.here:8080                            *\n");            
  fprintf ( stderr, "*                                                                                               *\n");
  fprintf ( stderr, "* The proxy you will provide can be changed anytime by editing the file:                        *\n");
  fprintf ( stderr, "*  %s/t_coffee_env                                   \n",get_dir_4_tcoffee());         
  fprintf ( stderr, "*************************************************************************************************\n");
  return NULL;
}	    
char *input_proxy ()
{
  char *proxy;
  char *answer;
  static int ntries;
  
  ntries++;
  if ( ntries==MAX_N_TRIES)
    printf_exit (EXIT_FAILURE,stderr, "\nERROR: Could not use provided proxy. Provide proxy via the -email flag [FATAL:%s]\n", PROGRAM);
  
  fprintf ( stderr, "\n ### Tip: If you work from home (ADSL) you probably do no need a proxy. ");
  fprintf ( stderr, "\n ### Tip: The proxy is the address you may have had to enter in your navigator. ");
  
  fprintf ( stderr, "\n ### Proxy Input, Enter your proxy and type Return (Type Return if you do not need a proxy): ");
  proxy=input_name();
  
  if ( !proxy)
    {
      proxy=vcalloc ( 100, sizeof (char));
      sprintf ( proxy, "");
    }
  else if (!strstr (proxy, "."))return input_proxy();
  else
    {
      int a, c;
      a=0;
      while ((c=proxy[a])!='\0')
	{
	  if (!isalnum(c) && c!='.' && c!='_' )return input_proxy();
	  a++;
	}
    }
  fprintf ( stderr, "\n\tYou have entered:[%s]%s \nIs this correct ([Y] or N)?: ",proxy, (strm (proxy, "")?"(No Proxy Needed)":""));
  answer=input_name();
  
  if ( !answer || answer[0]=='y' ||answer[0]=='Y')
    {
      vfree (answer);
    }
  else
    {
      vfree (answer);
      return input_proxy ();
    }
  add2t_coffee_environement ("http_proxy_4_TCOFFEE=%s", proxy);
  set_string_variable ("proxy", proxy);
  return proxy;
}



char *input_email ()
{
  char *email;
  char *answer;
  static int ntries;

  ntries++;

  if ( ntries==MAX_N_TRIES)
    printf_exit (EXIT_FAILURE, stderr,"\nERROR: Could not use provided Email. Provide Email via the -email flag [FATAL:%s]\n", PROGRAM);
  
  
  
  fprintf ( stderr, "\n ### EMAIL Input, Enter your email and type Return: ");
  email=input_name();
  fprintf ( stderr, "\n\tYou have entered:%s \nIs this correct ([Y] or N)?: ", email);
  answer=input_name();
  
  if ( !answer || answer[0]=='y' ||answer[0]=='Y')
    {
      vfree (answer);
    }
  else
    {
      vfree (answer);
      return input_email ();
    }
  add2t_coffee_environement("EMAIL_4_TCOFFEE=%s", email);
  set_string_variable ("email", email);
  return email;
}
static char *ebi_email_message ();
char *ebi_email_message ()
{
  fprintf ( stderr, "\n\n");
  fprintf ( stderr, "*************************************************************************************************\n");
  fprintf ( stderr, "*                        IMPORTANT: Please Read Carefuly                                        *\n");
  fprintf ( stderr, "*                                                                                               *\n");
  fprintf ( stderr, "* ------------------------------FIRST RUN CONFIGURATION---------------------------------------- *\n");
  fprintf ( stderr, "*                                                                                               *\n");
  fprintf ( stderr, "* Some commands of T-Coffee use the  EBI BLAST webservices. The EBI requires a valid E-mail     *\n");
  fprintf ( stderr, "* address for this service to be used (check: www.ebi.ac.uk/Tools/webservices/).                *\n");            
  fprintf ( stderr, "* T-Coffee will keep it for further run but only to be used with the EBI webservices.           *\n");
  fprintf ( stderr, "*                                                                                               *\n");
  fprintf ( stderr, "* !!!!!!!!!!!!!!!!!! Your Email will not be sent to us, ONLY to the EBI !!!!!!!!!!!!!!!!!!!!!!!!*\n");
  fprintf ( stderr, "*                                                                                               *\n");
  fprintf ( stderr, "* -blast_server=EBI is the default mode of T-Coffee. If you do NOT want to provide your E-mail  *\n");
  fprintf ( stderr, "* you can use:                                                                                  *\n");
  fprintf ( stderr, "*    -blast_server=NCBI     (NCBI netblast)                                                     *\n");
  fprintf ( stderr, "*    -blast_server=LOCAL     Local NCBI BLAST                                                   *\n");
  fprintf ( stderr, "*                                                                                               *\n");
  fprintf ( stderr, "*The address you provide can be changed anytime by editing the file:                            *\n");
  fprintf ( stderr, "*    %s/t_coffee_env                                   \n",get_dir_4_tcoffee());         
  fprintf ( stderr, "*************************************************************************************************\n");
  return NULL;
}	    
char *Email( int input_mode, int write_mode)
{
  static char *email;
  static int set;
  
  if ( write_mode==RESET){set=0;vfree (email); email=NULL;return Email(input_mode, SET);}
  
  if (set);
  else if (input_mode ==INPUT){email=get_email();}
  else if (input_mode ==ENV  ){email=get_email_from_env (); }
  else printf_exit (EXIT_FAILURE, stderr,"Unknown mode for Email [FATAL:%s]",PROGRAM);
  
  set=1;
  
  if ( email)set_email (email);
  else email=vcalloc (1, sizeof (char));
  return email;
}
char *get_email_from_env ()
{
  char *email;

  if ( (email=get_string_variable ("cl_email")));
  else if ( (email=get_string_variable ("email")));
  else if ( (email=getenv ("EMAIL_4_TCOFFEE")));
  else if ( (email=getenv ("EMAIL")));
  return email;
}
char *get_email ()
{
  char file [1000];
  static char *email;
  
  if ( (email=get_email_from_env ()));
  else
    {
      ebi_email_message();
      email=input_email();
    }
  
  if (!strstr (email, "@"))
    {
      ebi_email_message();
      email=input_email();
    }  
  set_email (email);
	   
  return email;
}
int set_email (char *email)
{
  if (!email) return 0;
  
  cputenv ("EMAIL_4_TCOFFEE=%s", email);
  cputenv ("EMAIL=%s",email);
  return 1;
}
char *chomp (char *name)
{
  int a=0;
  while ( name[a]!='\n' && name[a]!='\0')a++;
  name[a]='\0';
  return name;
}
static Tmpname *tmpname;
static Tmpname *ntmpname;

static int n_tmpname;
static int file2remove_flag;

char *set_file2remove_extension (char *extension, int mode)
{
  static char ext[100];
  if (mode==SET)sprintf (ext, "%s", extension);
  else if ( mode==UNSET) ext[0]='\0';
  else if ( mode==GET);
  return ext;
}
int flag_file2remove_is_on ()
{ 
  return file2remove_flag;
}
void set_file2remove_on()
{
  file2remove_flag=1;
}
void set_file2remove_off()
{
  file2remove_flag=0;
}

char *add2file2remove_list (char *name)
{

  
  if ( !tmpname || !name)ntmpname=tmpname=vcalloc ( 1, sizeof (Tmpname));
  else if (!ntmpname->name);
  else ntmpname=ntmpname->next=vcalloc ( 1, sizeof (Tmpname));
  
  if (!name) return NULL;
  
  ntmpname->name=vcalloc(strlen(name)+1, sizeof (char));
  
  sprintf (ntmpname->name, "%s", name);
  return ntmpname->name;
}
//char *short_tmpnam_2(char *s);//used to generate very compact tmp names
void  initiate_vtmpnam (char *file)
{
  add2file2remove_list (NULL);
  tmpnam_2(NULL);
}
char *vtmpnam ( char *s1)
{
  char *s,*s2;

  n_tmpname++;
  
  standard_initialisation(NULL, NULL);
  
  s=vcalloc ( VERY_LONG_STRING, sizeof (char));
  s[0]='\0';
  
  s=tmpnam_2 (s);
  
  s2=add2file2remove_list (s);
  if (s!=s2)vfree (s);
  if (s1){sprintf (s1, "%s",s2);return s1;}
  else return s2;
}
     


int get_vtmpnam2_root()
{
  int MAX_TMPNAM_ROOT=10000;
  static int v;

  if (v) ;
  else
    {
      vsrand(0);
      v=rand()%MAX_TMPNAM_ROOT;
    }
  return v;
}
char *tmpnam_2 (char *s)
     { 
       static int root;   
       static int file;
       char buf[VERY_LONG_STRING];
       static char root2[VERY_LONG_STRING]; 
       static char *tmpdir;
       static int name_size;
       
       if ( !root || !s)
	 {
	   char *vtmpnam_prefixe;
	   
	   name_size=MAX( 2*L_tmpnam, MAXNAMES*2)+1;
	   root=get_vtmpnam2_root();
	   sprintf ( root2, "%d%d_", root, (int)getpid());
	 
	   vtmpnam_prefixe=vcalloc (strlen (root2)+strlen (get_tmp_4_tcoffee())+2, sizeof (char));
	   sprintf (vtmpnam_prefixe, "%s/%s", get_tmp_4_tcoffee(), root2);
	   set_string_variable ("vtmpnam_prefixe1", vtmpnam_prefixe);
	   set_string_variable ("vtmpnam_prefixe2", root2);
	   vfree (vtmpnam_prefixe);
	 }
       
       if (!s)return NULL;
       tmpdir=get_tmp_4_tcoffee();
                     
       sprintf (buf, "%s/%s%d_TCtmp%s",tmpdir,root2, file++,set_file2remove_extension (NULL, GET));
       if ( strlen(buf)>=name_size)s=vrealloc (s,(strlen(buf)+1)*sizeof (char));
       sprintf (s, "%s", buf);
       return s;
     }
char *short_tmpnam_2(char *s)
{
  static int root;   
  static int file;
  char buf[VERY_LONG_STRING];
  static char root2[VERY_LONG_STRING]; 
  static char *tmpdir;
  static int name_size;
  
  if ( !root || !s)
    {
      char *vtmpnam_prefixe;
      
      name_size=MAX( 2*L_tmpnam, MAXNAMES*2)+1;
      root=get_vtmpnam2_root();
      sprintf ( root2, "%d%d", root,getpid());
      
      vtmpnam_prefixe=vcalloc (strlen (root2)+strlen (get_tmp_4_tcoffee())+2, sizeof (char));
      sprintf (vtmpnam_prefixe, "%s", root2);
      set_string_variable ("vtmpnam_prefixe1", vtmpnam_prefixe);
      set_string_variable ("vtmpnam_prefixe2", root2);
      vfree (vtmpnam_prefixe);
    }
  if (!s) return NULL;
  
  sprintf (buf, "%s%d%s",root2, file++,set_file2remove_extension (NULL, GET));
  if ( strlen(buf)>=name_size)s=vrealloc (s,(strlen(buf)+1)*sizeof (char));
  sprintf (s, "%s", buf);
  return s;
}

char *vremove2 (char *s)
{
  char command[1000];
  char list_file[1000];
  char ***list;
  int a;

	
  //Remove filenames with a wildcard
  
  sprintf (list_file, "list_file_%d", (int)getpid());
  sprintf (command, "ls -1 %s>%s 2>/dev/null", s, list_file);
  safe_system (command);
  
  list=file2list (list_file, " ");
 
  a=0;
  while (list && list[a])
    {
      if ( check_file_exists (list[a][1]))
	{
	  vremove (list[a][1]);
	}
      a++;
    }
  vremove (list_file);
  return NULL;
}
char *vremove (char *s)
{

  
  if ( s && strstr (s, "*"))return vremove2(s);
  else if ( !s || !check_file_exists(s) ) return NULL;
  else if ( isdir (s))
    {
      rmdir (s);
      return NULL;
    }
  else
    {
      remove (s);
      return NULL;
    }
  return NULL;
}
int log_function ( char *fname)
{
  char command[1000];
  
  if ( check_file_exists (error_file))
    {
      
      sprintf ( command, "cp %s %s", error_file, fname);
      my_system ( command);
      fprintf( stderr,"\n\t******************************************************************");
      fprintf( stderr, "\n\t* Full Log of [%s, %s] in File [%s]",PROGRAM, VERSION, fname);
      fprintf( stderr, "\n\t******************************************************************\n");
    }
  return 1;
}

void clean_exit ()
{
  
  myexit (global_exit_signal);
}
void error_exit ( )
     {
       char command[1000];
       char final_report[1000];
       
       if ( no_error_report)return;
       if ( check_file_exists (error_file))
	 {
	   sprintf ( final_report, "error_report.%s",PROGRAM); 
	   if ( !getenv ("NO_ERROR_REPORT_4_TCOFFEE"))sprintf ( command, "cp %s %s", error_file, final_report);
	   my_system ( command);
	   fprintf( stderr,"\n\t******************************************************************");
	   fprintf( stderr, "\n\t* Job NOT Completed:[%s, %s]",PROGRAM, VERSION);
	   fprintf( stderr, "\n\t* Please CHECK:                                       ");
	   fprintf( stderr, "\n\t* \t-1 The format of your Input Files                 ");
	   fprintf( stderr, "\n\t* \t-2 The parameters                                 ");
	   fprintf( stderr, "\n\t* \t-3 The use of special characters in sequence names:");
	   fprintf( stderr, "\n\t* \t\t (@, |, %%...)");
	   
	   fprintf( stderr, "\n\t* \t-4 The Online Doc (%s)                   ", URL);
	   fprintf( stderr, "\n\t* \t-5 Send the file %s to:", final_report);
	   fprintf( stderr, "\n\t* \t\t%s",EMAIL);
	    
	   fprintf( stderr, "\n\t* If you run T-Coffee over the WEB:");
	   fprintf( stderr, "\n\t* \tWindows Cut and Paste is sometimes erratic and");
	   fprintf( stderr, "\n\t* \tit can loose carriage returns. If you suspect this,");
	   fprintf( stderr, "\n\t* \ttry to cut and paste through an intermediate application");
	   fprintf( stderr, "\n\t* \t(word pad) and inspect the results\n\n");
	   fprintf( stderr, "\n\t* CONFIDENTIALITY:");
	   fprintf( stderr, "\n\t* \tThe File %s may contain your personnal DATA", final_report);
	   fprintf( stderr, "\n\t* \tRemove ALL confidential DATA from this file BEFORE sending it");
	   fprintf( stderr, "\n\t******************************************************************\n");
	   print_command_line(stderr);
	 }
       print_exit_failure_message ();
       myexit (global_exit_signal=EXIT_FAILURE);
     }
void main_exit ()
{

  clean_function ();
  exit (global_exit_signal);
}


void clean_function ()
{
	 Tmpname *b;
	 char *tmp;
	 static int done;
	 Tmpname *start;
	 
	 start=tmpname;
	 
	 if ( done==1) return;
	 else done=1;
	 
	 kill_child_pid();
	 add_method_output2method_log (NULL, NULL, NULL, NULL, decode_name (NULL, CODELIST));
	 
	 //Kill all child processes (if any)
	 

	 if (getenv ("DEBUG_TMP_FILE") && atoi (getenv("DEBUG_TMP_FILE"))==1)
	   {
	     fprintf ( stderr, "\n[DEBUG_TMP_FILE:%s] TEMPORARY FILES HAVE NOT Been Removed:", PROGRAM);
	     while (start)
		 {
		   if ( getenv("PRINT_TMPFILE_NAME") && atoi(getenv("PRINT_TMPFILE_NAME"))==1)
		     {
		       fprintf ( stderr, "\n\t%s [EXISTS:%s]", tmpname->name, (check_file_exists(tmpname->name))?"YES":"NO");
		     }
		   
		   b=start;
		   start=start->next;
		   vfree(b->name);
		   vfree(b);
		 }
	     fprintf ( stderr, "\n");
	     return;
	   }
	 else
	   {
	     char name[10000];
	     char *x;
	     	     
	     //printf_system ("clean_cache.pl -dir=%s -size=0 -age=10 -force",get_tmp_4_tcoffee ());
	     //Remove all the temporary files generated during THIS run
	     while (start)
	       {
		 
		 remove (start->name);
		 if (isdir(start->name))rrmdir (start->name);
		   
		 b=start;
		 start=start->next;
		 vfree(b->name);vfree(b);
		 }
	    
	     //Remove potential log
	     //remove ( TO_NULL_DEVICE);	 
	     //Remove all the tmp/tmp* files generated by this process [potentialy generated by secondary processes]
	     //if ((x=get_string_variable("vtmpnam_prefixe1"))){ sprintf ( name, "%s*", x); vremove(name);}
	     //Remove all the tmp* file that may have sneaked in (from clustalw for instance) and could be in the current dir
	     //if ((x=get_string_variable("vtmpnam_prefixe2"))){ sprintf ( name, "%s*", x); vremove(name);}
	     //remove (get_tmp_4_tcoffee ());//removes tmpdir if empty
	   }
	 return;
     }
FILE *NFP;/*Null file pointer: should only be open once*/

/*********************************************************************/
/*                                                                   */
/*                         CACHE_FUNCTION                            */
/*                                                                   */
/*                                                                   */
/*********************************************************************/
static char *cache;
char * prepare_cache ( const char *mode)
{
  char command[1000];

  cache =vcalloc ( 10000, sizeof(char));
  
  if (strm (mode, "use"))
    {
      sprintf (cache, "%s",get_cache_4_tcoffee());
    }
  
  else if ( strm (mode, "ignore") ||  strm (mode, "no"))
    {
      
      cache=vtmpnam(cache);
      strcat (cache, "/");
      sprintf ( command, "mkdir %s",cache);
      my_system ( command);
    }
  else if ( strm (mode, "update"))
    {
      cache=vtmpnam(cache);
      strcat (cache, "/");
      sprintf ( command, "mkdir %s",cache);
      my_system ( command);
    }
  else if ( strm (mode, "local"))
    {
      cache[0]='\0';
    }
  else
    {
      sprintf ( cache, "%s/",mode);
      my_mkdir ( cache);
    }
  return cache;
	    
}

char * get_cache_dir()
{
  if ( cache==NULL){cache=vcalloc (1, sizeof (char));cache[0]='\0';}
  return cache;
}

void update_cache ()
{
  char command[1000];
  char old_cache[1000];

  sprintf ( old_cache, "%s", get_cache_dir());
  prepare_cache( "use");
  sprintf ( command, "mv %s* %s",old_cache, get_cache_dir());
  my_system (command);
  sprintf ( command, "rmdir %s",old_cache);
  my_system (command);
}
void ignore_cache()
{
  char command[1000];

  if (getenv4debug ("DEBUG_TMP_FILE"))
    {
      fprintf ( stderr, "\n[DEBUG_TMP_FILE:%s] TEMPORARY CACHE HAS NOT Been Removed:\n\t%s\n", PROGRAM,get_cache_dir());
    }
  else
    {

      sprintf ( command, "rm -r %s",get_cache_dir());
      my_system (command);
    }
  return;
  
}

  
FILE * vfopen  ( char *name_in, char *mode)
    {
    FILE *fp;
    int get_new_name;
    int tolerate_mistake;    
    int cache_used=0;
    FILE *tmp_fp;
    int c;
    static char *name;
    static char *name2;
    static char *stdin_file;

  
    if ( !name_in)return NULL;
    if (!name){name=vcalloc (1000, sizeof (char));}
    if (!name2){name2=vcalloc (1000, sizeof (char));}
    
    sprintf ( name, "%s", name_in);
    tild_substitute (name, "~", get_home_4_tcoffee());

    get_new_name=tolerate_mistake=0;    
    if ( mode[0]=='g'){get_new_name=1; mode++;}
    else if ( mode[0]=='t'){tolerate_mistake=1;mode++;}
/*Use the cached version from CACHE_4_TCOFFEE*/    
    else if ( mode[0]=='c'){cache_used=1;mode++;}

    if (name==NULL ||strm5 ( name, "no","NO","No","NULL","/dev/null") || strm2 (name, "no_file", "NO_FILE"))
    		{       
 		if ( NFP==NULL)NFP=fopen (NULL_DEVICE, mode);
 		return NFP;
 		} 
    else if ( strm3 (name,"stderr","STDERR","Stderr"))return stderr; 
    else if ( strm3 (name,"stdout","STDOUT","Stdout"))return stdout;
    else if ( strm3 ( name, "stdin","STDIN","Stdin"))
	{
	  if (!stdin_file)
	    {
	      stdin_file=vtmpnam (NULL);
	      tmp_fp=vfopen ( stdin_file, "w");
	      while ( (c=fgetc(stdin))!=EOF)fprintf (tmp_fp, "%c", c);
	      vfclose ( tmp_fp);
	    }
	  return vfopen (stdin_file, "r");
	}
	
    else if ( strm (name, "") && (strm (mode, "w") ||strm (mode, "a")) )return stdout;
    else if ( strm (name, "") && strm (mode, "r"))return stdin;    
    else if ( (fp= fopen ( name, mode))==NULL)
    		{
		if ( strcmp (mode, "r")==0 && cache_used==0)
		  {
		    sprintf ( name2, "%s%s",get_cache_dir(), name);		    
		    return vfopen ( name2, "cr");
		  }
    		else if ( strcmp (mode, "r")==0 && cache_used==1)
    			{
    			fprintf (stderr, "\nCOULD NOT READ %s\n", name);
    			if ( get_new_name){fprintf ( stderr, "\nNew name: ");return vfopen (input_name(), mode-1);}
    			else if ( tolerate_mistake)return NULL;
			else 
			    {	
			    fprintf (stderr, "\nFORCED EXIT (NON INTERACTIVE MODE)\n");
			    if ( getenv ( "DEBUG_TCOFFEE"))crash ("DEBUG");
			    else myexit (EXIT_FAILURE);
			    }
			}
    		else if ( strcmp (mode, "a")==0 && cache_used==0)
		  {
		    sprintf ( name2, "%s%s",get_cache_dir(), name);		    
		    return vfopen ( name, "ca");
		  }
		else if ( strcmp (mode, "a")==0 && cache_used==1)
    			{
    			fprintf (stderr, "\nCOULD NOT Append anything to %s\n", name);
    			if ( get_new_name){fprintf ( stderr, "\nNew name: ");return vfopen (input_name(), mode-1);}
    			else if ( tolerate_mistake)return NULL;
			else 
			    {	
			    fprintf (stderr, "\nFORCED EXIT (NON INTERACTIVE MODE)\n");
			    myexit (EXIT_FAILURE);
			    }
			}
		else if ( strcmp (mode, "w")==0)
    			{
    			fprintf (stderr, "\nCANNOT WRITE %s\n", name);
    			if ( get_new_name==1){fprintf ( stderr, "\nNew name: ");return vfopen (input_name(), mode-1);}	
    			else if ( tolerate_mistake)return NULL;
			else 
			    {
			    fprintf (stderr, "\nFORCED EXIT (NON INTERACTIVE MODE): %s %s\n", (strcmp ( mode, "r")==0)?"READ":"WRITE", name);
			    myexit(EXIT_FAILURE);
			    }
			}		
    		} 
    else
	return fp;
    
    return NULL;
    }

FILE * vfclose ( FILE *fp)
       {
       if ( fp==NFP)return NULL;
       if ( fp==stdout)return stdout;
       if ( fp==stderr)return stderr;
       if ( fp==stdin) return stdin;
       if ( fp==NULL)return NULL;
       else fclose (fp);
       return NULL;
       }
	

int echo ( char *string, char *fname)
{
int a;
/*
description:
prints the content of string into file fname

in:
string= string to print
fname =name of the file to create
*/

FILE *fp;

    fp=vfopen ( fname, "w");
    fprintf (fp, "%s", string);
    a=fclose (fp);
    return a;

}

int   file_cat ( char *from, char *to)
{
  FILE *fp;
  //appends the content of file1 to file 2
  if (!(fp=vfopen (to, "a")))return 0;
  if (!display_file_content (fp, from)) return 0;
  vfclose (fp);
  return 1;
}
  
FILE* display_file_content (FILE *output, char *name)
{
  FILE *fp;
  int c;
  if ( !name || !check_file_exists (name) || !(fp=vfopen (name, "r")))return NULL;
  while ( (c=fgetc(fp))!=EOF)fprintf (output,"%c", c);
  vfclose (fp);
  return output;
}

char ***file2list ( char *name, char *sep)
{
  /*Rturns an array where
    list[0]: first line
    list[0][0]: number of words
    list[0][1]:first word;
    list[n]=NULL
  */
  char **lines, ***list; 
  int a, n;

  lines=file2lines (name);
  if (!lines) return NULL;
  else
    {
      n=atoi (lines[0]);

      list=vcalloc ( n+1, sizeof (char**));
      for ( a=1; a<n; a++)
	{
	  
	  list[a-1]=string2list2(lines[a], sep);
	}
    }
  
  free_arrayN((void**)lines, 2);
  return list;
}
char **file2lines (char *name)
{
  /*lines[0]->nlines;
    lines[1]->first_line
  */
  char **lines;
  char *string;


  string=file2string (name);
  if ( !string) return NULL;
  else
    {
      lines=string2list2(string, "\n");
      vfree ( string);
      return lines;
    }
}
  
char *string2file ( char *string, char *file, char *mode)
{
  FILE *fp;
  if (!file)
    file=vtmpnam (NULL);
  fp=vfopen (file, mode);
  fprintf (fp, "%s", string);
  vfclose (fp);
  return file;
}
char *file2string (char *name)
{
  FILE*fp;
  char *string;
  int a, c;
  
  if (!name || !check_file_exists (name))return NULL;
  else
    {
      string=vcalloc ( count_n_char_in_file(name)+1, sizeof (char));
      fp=vfopen (name, "r");a=0;
      while ( (c=fgetc(fp))!=EOF)
	{
	  string[a++]=c;
	}
      string[a]='\0';
      vfclose (fp);
      return string;
    }
}

int get_cl_param (int argc, char **argv, FILE **fp,char *para_name, int *set_flag, char *type, int optional, int max_n_val,char *usage, ...)
        {
	/*
	usage:
	argc:       n_ arg
	argv        list *
	para_name   param
	set_flag    set to 1 if param set;
	para_type   F, I, S, R_FN (read_file, name), W_FN (written file, name), R_FP (pointer)
	max_n_val   maximum number of values;
	optional    1 for yes, 0 for no
	usage       usage list with optional value;
	val         pointer to the varaible holding the value(s)
	default1    default value (if value id not there)
	default2    default value if the flag is there but no value set ("")indicates an error
	range_left  min value ( "any" for any);
	range_right  max_value ( "any" for any);
	*/
	int pos=0;
	int a;
	va_list ap;
	
	int   *int_val=NULL;
	float *float_val=NULL;
	char  **string_val=NULL;

	
	char  *range_right;
	char  *range_left;
	
	
	char *default_value1;
	char *default_value2;
	int n_para=0;        
	double max, min;
	
	static char **parameter_list;
	static int    number_of_parameters;

	char **para_name_list;
	int    n_para_name;
	
	char **para_val;
	int    n_para_val;
	
	char **pv_l=NULL;
	int    n_pv_l;
	char **pv_r=NULL;
	int    n_pv_r;
	char   value[STRING];



/*CHECK THAT ALL THE PARAM IN ARG EXIST*/
	if ( para_name==NULL)
	   {
	   for ( a=1; a< argc; a++)
	       {
	       if ( is_parameter ( argv[a]))
		   if ( name_is_in_list ( argv[a], parameter_list, number_of_parameters, STRING)==-1)
		      {
			fprintf ( stderr, "\n%s IS NOT A PARAMETER  OF %s [FATAL/%s %s]\n",argv[a], argv[0], argv[0], VERSION);
		      myexit(EXIT_FAILURE);
		      }
		  
		     
	       }
	 
	   free_char (parameter_list,-1);
	   return 0;
	   }

	if ( parameter_list==NULL)parameter_list=declare_char(MAX_N_PARAM,STRING);
	para_name_list=get_list_of_tokens(para_name,NULL, &n_para_name);
	for ( a=0; a< n_para_name; a++)
	    {
	    sprintf ( parameter_list[number_of_parameters++],"%s", para_name_list[a]);
	    }
	free_char(para_name_list,-1);
        


	
	
	set_flag[0]=0;
	va_start (ap, usage);
	
	if (strm3 (type, "S","R_F","W_F"))
		string_val=va_arg(ap, char**);
	else if (strm2 (type, "D","FL"))
	        int_val=va_arg(ap, int*);
	else if (strm (type, "F"))
	        float_val=va_arg(ap, float*);
	else 
	    myexit (EXIT_FAILURE);
	
	
	
	default_value1=va_arg(ap, char*);
	default_value2=va_arg(ap, char*);
	range_left    =va_arg(ap, char*);
	range_right   =va_arg(ap, char*);
       	va_end(ap);


	para_name_list=get_list_of_tokens(para_name, NULL, &n_para_name);
	for ( a=0; a<n_para_name; a++) 
	    {
	    if ( (pos=name_is_in_list(para_name_list[a], argv,argc, STRING))!=-1)break;
	    }
	free_char (para_name_list,-1);
	
	if (  (name_is_in_list("-help" , argv,argc  ,STRING)!=-1) && (argc==2 || (name_is_in_list( para_name , argv,argc  ,STRING)!=-1)))
	  {
	
	       fprintf ( stderr, "PARAMETER   : %s\n",  para_name);
	       fprintf ( stderr, "USAGE       : %s\n",       usage);
	       fprintf ( stderr, "MAX_N_VALUES: %d\n",   max_n_val);
	       fprintf ( stderr, "DEFAULT     : %s OR %s (when flag set)\n", default_value1, default_value2);
	       fprintf ( stderr, "RANGE       : [%s]...[%s]\n", range_left,(strm(range_right,"any"))?"":range_right);
	       fprintf ( stderr, "TYPE        : %s\n\n", type);
	       return 0;
	  }
	else if ( name_is_in_list ("-help" , argv,argc  ,STRING)!=-1)
	  {
	    return 0;
	  }
	else if (para_name[0]!='-')
	   {
	   fprintf ( stderr, "\nWRONG PARAMETER DEFINITION %s Must Start with a dash", para_name);
	   myexit (EXIT_FAILURE);
	   }
     	else if (pos==-1)
	   {
	   if ( optional==OPTIONAL)
	      {
	      set_flag[0]=0;	      
	      para_val=get_list_of_tokens(default_value1, NULL, &n_para_val);
	      
	      for (n_para=0; n_para<n_para_val && !strm (default_value1, "NULL"); n_para++) 
	          {
		  if ( strm (para_val[n_para], ""))
		      {
		      set_flag[0]=0;
		      break;
		      }
		  else if ( strm (type, "FL"))
	              {
		      set_flag[0]=atoi(para_val[n_para]);
		      break;
		      }
		  else if (strm3 (type, "S", "R_F","W_F"))
		      {
		     
		      sprintf ( string_val[n_para], "%s",para_val[n_para]);
		      }		  
		  else if ( strm (type, "D"))
		      int_val[n_para]=atoi(para_val[n_para]);
		  else if ( strm (type, "F"))
		      float_val[n_para]=atof(para_val[n_para]);
		  }
	      free_char (para_val, -1);
               
	      if (n_para==0 && strm3(type, "S","W_F","R_F") && strm (default_value1, "NULL"))
		  {
		  vfree (string_val[0]);
		  string_val[0]=NULL;
		  
		  }
	      else if (n_para==0 && strm (type, "D") && strm (default_value1, "NULL"))int_val[0]=0;		   
	      else if (n_para==0 && strm (type, "F") && strm (default_value1, "NULL"))float_val[0]=0;
	 
	      }
	   else
	      {
	      fprintf ( stderr, "\nParameter %s is not optional",para_name);
	      myexit (EXIT_FAILURE);
	      }	   
	   }
	else if (pos!=-1)
	  {
	  set_flag[0]=1;
	  for (a=pos+1; a< argc; a++)
	      {
	      if ( is_parameter(argv[a]))break;
	      else
	          {
		  if ( n_para>=max_n_val)
		     {
		     n_para=max_n_val-1;
		     
		     }
		  if ( !(strm ( argv[a], "NULL")))		      	  
		    {
		      if ( strm3(type, "S", "R_F", "W_F"))
			  {
			  sprintf ( string_val[n_para],"%s", argv[a]);
			  }
		       else if (strm (type, "D"))
		          {
			  int_val[n_para]=atoi(argv[a]);
			  }
		       else if (strm ( type,"F"))
		          {
			  float_val[n_para]=atof(argv[a]);
			  }
		    }
		  n_para++;
		  }
	      }

	  if ( n_para==0 && !strm2(default_value2,"","NULL") && !strm(type, "FL"))
	      {
	      para_val=get_list_of_tokens(default_value2, NULL, &n_para_val);
	      for ( n_para=0; n_para<n_para_val; n_para++)
	          {
		  if ( strm3(type, "S", "R_F", "W_F"))sprintf ( string_val[n_para],"%s", para_val[n_para]);		  
		  else if (strm (type, "D"))int_val  [n_para]=atoi(para_val[n_para]);
		  else if (strm ( type,"F"))float_val[n_para]=atof(para_val[n_para]);		
		  }
	      free_char (para_val,-1);
	      }
	  else if (n_para==0 && strm (type, "FL"));
	  else if (n_para==0 && strm3(type, "S","W_F","R_F") && strm (default_value2, "NULL")){vfree (string_val[0]);string_val[0]=NULL;}
	  else if (n_para==0 && strm (type, "D") && strm (default_value2, "NULL"))int_val[0]=0;		   
	  else if (n_para==0 && strm (type, "F") && strm (default_value2, "NULL"))float_val[0]=0;
	  else if (n_para==0 && strm (default_value2, ""))
	         {
		 fprintf ( stderr, "\nParam %s needs a value [FATAL/%s]", para_name, argv[0]);
		 myexit(EXIT_FAILURE);
		 }
	  else;
	  }
	  
/*Check That The Parameters are in the Good Range*/
	
	pv_l=get_list_of_tokens( range_left , NULL, &n_pv_l);
	pv_r=get_list_of_tokens( range_right, NULL, &n_pv_r);

	for ( a=0; a< n_para; a++)
	    {	   
	    if ( strm (type, "R_F") && !check_file_exists(string_val[a]) && !check_file_exists(string_val[a]+1))
			{			
			fprintf ( stderr, "PARAM %s: File %s does not exist [FATAL/%s]\n",para_name,string_val[a], argv[0]);
			myexit(EXIT_FAILURE);
		        }	    
	    else if ( strm (pv_l[0], "any"));
	    else if ( strm (type, "D"))
	         {
		 if ( n_pv_l==1)
		    {
		    min=(double)atoi(pv_l[0]);
		    max=(double)atoi(pv_r[0]);
		    if ( int_val[a]<min || int_val[a]>max)
		       {
		       fprintf ( stderr, "\n%s out of range [%d %d] [FATAL/%s]\n", para_name, (int)min, (int)max,argv[0]);
		       myexit (EXIT_FAILURE);
		       }
		    }
		 else
		    {
		    sprintf ( value, "%d", int_val[a]);
		    if ( name_is_in_list(value, pv_l, n_pv_l, STRING)==-1)
			fprintf ( stderr, "\n%s out of range [%s: ", para_name, value);
		    print_array_char (stderr, pv_l, n_pv_l, " ");
		    fprintf ( stderr, "\n");
		    myexit(EXIT_FAILURE);
		    }
		 }
	    else if ( strm (type, "F"))
	         {
		  if ( n_pv_l==1)
		    {
		    min=(double)atof(range_left);
		    max=(double)atof(range_right);
		    if ( float_val[a]<min || float_val[a]>max)
		       {
		       fprintf ( stderr, "\n%s out of range [%f %f] [FATAL/%s]\n", para_name, (float)min, (float)max,argv[0]);
		       myexit (EXIT_FAILURE);
		       }
		     }
		  else
		     {
		     sprintf ( value, "%f", float_val[a]);
		     if ( name_is_in_list(value, pv_l, n_pv_l, STRING)==-1)
			fprintf ( stderr, "\n%s out of range [%s: ", para_name, value);
		     print_array_char (stderr, pv_l, n_pv_l, " ");
		     fprintf ( stderr, "\n");
		     myexit(EXIT_FAILURE);
		     }
		 }
	    }
         

	 if ( fp[0]!=NULL)
	      {
	      fprintf (fp[0], "%-15s\t%s\t[%d] ", para_name, type, set_flag[0]);
	      for (a=0; a<n_para; a++) 
		  {
		  if ( strm3 ( type, "S", "R_F", "W_F"))fprintf ( fp[0], "\t%s", string_val[a]);
		  else if ( strm  ( type, "D"))fprintf ( fp[0], "\t%d ", int_val[a]);
		  else if ( strm  ( type, "F"))fprintf ( fp[0], "\t%f ", float_val[a]);
	         }	    
	      if ( strm (type, "FL"))fprintf ( fp[0], "\t%d", int_val[0]);
	      fprintf ( fp[0], "\n");     
	      }

	free_char ( pv_l, -1);
	free_char ( pv_r, -1);
	return n_para;
	}

	
	
char ** get_parameter ( char *para_name, int *np, char *fname)
{
    /*
    In:
    para_name: the name of the parameter to look for
    fname: the name of the file containing the parameters
    np[0]: set to 0

    Out:
    char ** containing the np[0] values taken by para_name in fname.
    
    Special:
    if fname=NULL, para_name is searched using the last value taken by fp.
    
    Note: by default, the function keeps a file handle open until the first unsuccessful call.
    */

    static FILE *fp;
    static char *line;
    char ** return_value;
    
    if ( strm (para_name, "CLOSE THE FILE"))
      {
	vfclose ( fp);
	return NULL;
      }
    
    if ( line==NULL)line=vcalloc ( VERY_LONG_STRING+1, sizeof (char));
    if ( fname!=NULL && fp!=NULL)vfclose (fp);
    
    np[0]=0;

    if ((fp=find_token_in_file ( fname,(fname==NULL)?fp:NULL, para_name))==NULL) 
	{
	     return NULL;
	}
    else
        {
	fgets ( line, VERY_LONG_STRING,fp);
        return_value=get_list_of_tokens ( line, NULL, np);	
	return return_value;
	}
}

FILE * set_fp_id ( FILE *fp, char *id)
	{
/*Sets fp just after id, id needs to be at the begining of the line*/
	char string[10000];
	int cont=1;
	int c;
	
	while ( cont==1)	
		{
		c=fgetc(fp);
		if ( c!=EOF)
			{
			
			ungetc(c, fp);
			fscanf ( fp, "%s", string);
			
			if ( strcmp ( string, id)==0)
				return fp;
			else while ( c!='\n' && c!=EOF)
				c=fgetc(fp);			
			}
		else if ( c==EOF)
			{
			fclose ( fp);
			return NULL;
			}
		}	
	return fp;
	}
FILE * set_fp_after_char ( FILE *fp, char x)
	{
/*sets fp just after the first occurence of x*/
	


	int cont=1;
	int c;
	
	while ( cont==1)	
		{
		c=fgetc(fp);
		if ( c!=EOF)
			{
			if ( c==x)
				return fp;
			
			}
		else if ( c==EOF)
			{
			fclose ( fp);
			return NULL;
			}
		}	
	return fp;
	}
	
FILE * find_token_in_file_nlines ( char *fname, FILE * fp, char *token, int n_line)

        {
	  /*This function finds the string TOKEN (as a single word) in the n_line first lines of fname.
	    It returns NULL if not found or the position of the fp
	  */
	  
	  char *tmp_name=NULL;
	  FILE *fp1;
	  FILE *fp2;
	  char buffer[10001];
	  int a;
	  if ( !fp && !check_file_exists(fname))return NULL;
	  if ( fp==NULL)
	    {
	      tmp_name=vtmpnam ( NULL);
	
	      fp1=vfopen (fname, "r");
	      fp2=vfopen (tmp_name, "w");
	      
	      for ( a=0; a< n_line && fgets(buffer, 10000, fp1)!=NULL; a++)
		{
		  fprintf ( fp2, "%s", buffer);
		}
	      vfclose (fp1);
	      vfclose (fp2);
	    }
	  return find_token_in_file ( tmp_name,fp,token);
	}
	  
int token_is_in_file ( char *fname, char *token)
{
  /*TH:an argument against torture: innocents get tortured longer, likewise for token testing*/
  FILE *fp;
  static char *buf;
  char *b, *p;
  int begining;
  

  
  if (token[0]=='\n')
    {

      begining=1;
      token++;
    }
  else
    {
      begining=0;
    }
  
  if ( !fname || !check_file_exists(fname))return 0;
  else
    {
      fp=vfopen (fname, "r");
      while ((b=vfgets (buf,fp))!=NULL)
	{
	  buf=b;
	  p=strstr (buf, token);
	  if (!p);
	  else if ( begining==1 && p==buf){vfclose (fp); return 1;}
	  else if ( begining==0 && p){vfclose (fp); return 1;}
	}
      vfclose (fp);
      return 0;
    }
  return 0;
}

char *vfgets ( char *buf, FILE *fp)
{
  int c;
  int buf_len, l;
  char *bufin;
  static int debug;


  if ( !debug)
    debug=(getenv ("DEBUG_TCOFFEE"))?1:-1;
  

  bufin=buf;

  if (!buf)
    {
      buf=vcalloc ( 1000, sizeof (char));
      buf_len=1000;
    }
  else
    {
      buf_len=read_array_size_new (buf);
    }
  
  l=0;
  
  if ( (c=fgetc (fp))==EOF)return NULL;
  else ungetc (c, fp);
  
  
  while ( (c=fgetc (fp))!='\n' && c!=EOF)
    {
      if (l>=buf_len)
	{buf_len+=100;buf=vrealloc (buf, buf_len*sizeof (char));}
      buf[l++]=c;
    }
  /*Add the cariage return*/
  if ( c=='\n')
    {
      if (l>=buf_len){buf_len+=100,buf=vrealloc (buf, buf_len*sizeof (char));}
      buf[l++]='\n';
    }
  /*add the terminator*/  
  if (l>=buf_len){buf_len+=100,buf=vrealloc (buf, buf_len*sizeof (char));}
  buf[l]='\0';

  if ( bufin!=buf && bufin!=NULL && debug==1)
    fprintf ( stderr, "\nPointer change in vfgets...");
  
  return buf;
}
  

FILE * find_token_in_file ( char *fname, FILE * fp, char *token)
	{
	int c;
	static char *name;
	int token_len;

	int only_start;
	
	/*Note: Token: any string
	        If Token[0]=='\n' Then Token only from the beginning of the line
	*/

	if (!fp && !check_file_exists(fname))return NULL;

	if ( token[0]=='\n'){token++;only_start=1;}
	else only_start=0;

	token_len=strlen (token);

	
	
	
	
	if (!fp)
	  {
	    if (name)vfree (name);
	    name = vcalloc (((fname)?measure_longest_line_in_file (fname):10000)+1, sizeof (char));
	    fp=vfopen ( fname, "r");
	  }
	    
	while ( (fscanf ( fp, "%s", name))!=EOF)
		{
		 
		if ( name[0]=='*')while ( ((c=fgetc (fp))!='\n')&& (c!=EOF));
		else if (strncmp ( name, token,token_len)==0){return fp;}
		else if (only_start) while ( ((c=fgetc (fp))!='\n')&& (c!=EOF));
		}

	vfclose ( fp);
	return NULL;
	}
int **get_file_block_pattern (char *fname, int *n_blocks, int max_n_line)
        {
	int c;
	FILE *fp;
	char *line;
	int lline;
	int **l;
	int in_block;
	
	int max_block_size;
	int block_size;
	int x;
	int n_line;
	
	lline=measure_longest_line_in_file (fname)+1;			
	line=vcalloc ( sizeof (char),lline+1);
	
	fp=vfopen (fname, "r");
	max_block_size=block_size=0;
	in_block=1;
	n_blocks[0]=0;
	n_line=0;
	while ((c=fgetc(fp))!=EOF && (n_line<max_n_line || !max_n_line))
	    {
		  ungetc (c, fp);
		  fgets ( line, lline,fp);
		  n_line++;

		  if ( is_alnum_line (line) && !in_block){n_blocks[0]++;in_block=1;}
		  if ( is_alnum_line (line))
		     {
		     block_size++;
		     }
		  else
		      {
		      in_block=0;
		      max_block_size=MAX( max_block_size, block_size);
		      block_size=0;
		      }
	    }

	
	max_block_size=MAX( max_block_size, block_size);
	vfclose ( fp);
	
	l=declare_int (n_blocks[0]+1,max_block_size+1);  

	
	fp=vfopen (fname, "r");	
	in_block=1;
	n_blocks[0]=0;
	n_line=0;
	while ((c=fgetc(fp))!=EOF && (n_line<max_n_line || !(max_n_line)))
	      {
		  ungetc (c, fp);
		  fgets ( line, lline,fp);
		  n_line++;

		  if ( is_alnum_line (line) && !in_block){n_blocks[0]++;in_block=1;}
		  if ( is_alnum_line (line))
		      {
		      l[n_blocks[0]][0]++;
		      free_char (get_list_of_tokens (line, " \t\n*:,", &x), -1); 
		      
		      if ( l[n_blocks[0]][0]> max_block_size)fprintf ( stderr, "\nERROR %d", l[n_blocks[0]][0]);

		      l[n_blocks[0]] [l[n_blocks[0]][0]]=x;
		      }
		  else
		      {
			  in_block=0;
		      }
	      }
	n_blocks[0]++;
	vfree(line);
	vfclose (fp);
	return l;
	}		  

char * strip_file_from_comments (char *com, char *in_file)
{
  /*Removes in file in_file every portion of line to the right of one of the symbols included in com
    Writes the striped file into a vtmpnam file
   */
  FILE *fp1;
  FILE *fp2;
  char *out_file;
  int c;

  out_file=vtmpnam(NULL);


  fp1=vfopen (in_file , "r");
  fp2=vfopen (out_file, "w");
  while ( (c=fgetc(fp1))!=EOF)
	  {
	    if (strchr(com, c))
	      {	
		while ( (c=fgetc(fp1))!='\n' && c!=EOF);
	      }
	    else
	      {
		fprintf (fp2, "%c", c);
		while ( (c=fgetc(fp1))!='\n' && c!=EOF)fprintf (fp2, "%c", c);
		if ( c!=EOF)fprintf (fp2, "%c", c);
	      }
	  }
  vfclose (fp1);
  vfclose (fp2);
 
  return out_file;
}
FILE * skip_commentary_line_in_file ( char com, FILE *fp)
{
  int c=0;

  if ( fp==NULL)return NULL;
  while ((c=fgetc(fp))==com)
    {
      while ((c=fgetc(fp))!='\n' && c!=EOF);
    }
  if ( c!=EOF && c!='\n')ungetc(c, fp);
  return fp;
}
     
int check_for_update ( char *web_address)
{
  char command[1000];
  char *file;
  float new_version, old_version;
  FILE *fp;
  
  check_internet_connection (IS_NOT_FATAL);
  file=vtmpnam(NULL);
   
  sprintf ( command, "%s/%s.version",DISTRIBUTION_ADDRESS, PROGRAM);
  url2file ( command, file);
    
  fp=vfopen ( file, "r");
  fscanf ( fp, "Version_%f", &new_version);
  vfclose ( fp);
  sscanf ( VERSION, "Version_%f", &old_version);

  if ( old_version<new_version)
    {
      fprintf ( stdout, "\nUpdate Status: outdated");
      fprintf ( stdout, "\nYour version of %s is not up to date", PROGRAM);
      fprintf ( stdout, "\nDownload the latest version %.2f with the following command:", new_version);
      fprintf ( stdout, "\n\twget %s/%s_distribution_Version_%.2f.tar.gz\n", DISTRIBUTION_ADDRESS, PROGRAM, new_version);
      return EXIT_FAILURE;
    }
  else if ( old_version> new_version)
    {
      fprintf ( stdout, "\nUpdate Status: beta-release");
      fprintf ( stdout, "\nYour are using a beta-release of %s(%s)\n", PROGRAM, VERSION);
    }
  else
    {
      fprintf (stdout, "\nUpdate Status: uptodate");
      fprintf (stdout, "\nProgram %s(%s) is up to date\n", PROGRAM, VERSION);
    }
  return EXIT_SUCCESS;
}
	
      
  
  
  
int check_environement_variable_is_set ( char *variable, char *description, int fatal)
{
  if ( getenv (variable)==NULL)
    {
      fprintf ( stderr, "\nERROR: You must set %s\n%s %s", variable, description, description);
      if ( fatal==IS_FATAL)
	{
	fprintf ( stderr, "\n[%s:FATAL]\n", PROGRAM);
	exit (EXIT_FAILURE);
	}
      else
	fprintf ( stderr, "\n[%s:WARNING]\n", PROGRAM);
    }
  return 1;
}

int url2file (char *address, char *out)
{
  char command[1000];
  
  
  if      (check_program_is_installed ("wget",NULL, NULL,WGET_ADDRESS, IS_NOT_FATAL))sprintf (command, "wget %s -O%s >/dev/null 2>/dev/null", address, out);
  else if (check_program_is_installed ("curl",NULL, NULL,CURL_ADDRESS, IS_NOT_FATAL))sprintf (command, "curl %s -o%s >/dev/null 2>/dev/null", address, out);
  else 
    {
      printf_exit (EXIT_FAILURE, stderr, "ERROR: Impossible to fectch external file: Neither wget nor curl is installed on your system [FATAL:%s]\n", PROGRAM);
      return EXIT_FAILURE;
    }
  return safe_system (command);
}

int wget (char *address, char *out)
{
  return printf_system ( "curl %s -O%s >/dev/null 2>/dev/null", address, out);
  }

int curl (char *address, char *out)
{
  return printf_system ( "curl %s -o%s >/dev/null 2>/dev/null", address, out);
}
	

int simple_check_internet_connection (char *ref_site)
{
  char *test,command[1000];
  int n, internet=0;
  
  test=vtmpnam (NULL);
  if (url2file((ref_site)?ref_site:TEST_WWWSITE_4_TCOFFEE,test)!=EXIT_SUCCESS)internet=0;
  else if ((n=count_n_char_in_file(test))<10)internet=0;
  else internet =1;
  
  return internet;
}
int check_internet_connection  (int mode)
{
  int internet;
  internet=simple_check_internet_connection (NULL);
  if (internet)return 1;
  else if ( mode == NON_INTERACTIVE)return internet;
  else if ( mode == IS_FATAL)
    {
      add_warning ( stderr,"\nERROR: You do not seem to have an active Internet Connection. Check your Proxy Setting [proxy:%s][%s:SERIOUS]\n", getenv ("http_proxy"), PROGRAM);
      return EXIT_FAILURE;
    }
  else if ( mode==IS_NOT_FATAL)
    {
      
      fprintf ( stderr, "\n\n\n");
      fprintf ( stderr, "*!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
      fprintf ( stderr, "*\n");
      fprintf ( stderr, "*   Your Internet Connection Does not seem to be available. You may need to reconfigure your Proxy\n");
      fprintf ( stderr, "*   ------- Current Proxy Value: [%s]\n*\n", (getenv ("http_proxy")?getenv ("http_proxy"):"NO Proxy Set"));
      Proxy(INPUT, RESET);
      
      return check_internet_connection (IS_FATAL);
    }
  else
    {
      return 0;
    }
}
char *pg2path (char *pg)
{
  char *path;
  char *p;
  char *tmp;
  FILE *fp;
    
  if ( !pg) return NULL;
  tmp=vtmpnam(NULL);
  
  printf_system_direct("which %s>%s 2>/dev/null", pg, tmp);
  path=file2string (tmp);
  chomp (path);
  if (!check_file_exists (path) && !strstr (pg, ".exe"))
    {
      char pg2[1000];
      sprintf ( pg2, "%s.exe", pg);
      path=pg2path (pg2);
    }
  
  return path;
}
  

int check_program_is_installed ( char *program_name, char *path_variable, char *path_variable_name, char *where2getit, int fatal)
  {
   char command[LONG_STRING];
   static char *path;
   
   if ( strm (where2getit, "built_in"))return 1;
   
   if (path)vfree (path);
   
   if ( check_file_exists (path_variable))
     {
       return 1;
     }
   else 
     {
       
       path=pg2path (program_name);
       if (path && path[0])return 1;
       else
	 {
	   int install=EXIT_FAILURE;
	       
	   if (fatal==INSTALL || fatal==INSTALL_OR_DIE)
	     {
	       HERE ("************** %s is missing from your system. T-Coffee will make an attempt to install it.\n", program_name);
	       install=printf_system ("install.pl %s -plugins=%s -clean", program_name, get_plugins_4_tcoffee(NULL));
	     }
	   if ( install==EXIT_SUCCESS)return 1;
	   else if ( fatal==INSTALL)return 0;
	   else if ( fatal==NO_REPORT)return 0;
	   
	   if (fatal==IS_FATAL || fatal==INSTALL_OR_DIE)check_configuration4program();
	   
	   fprintf ( stderr, "\n#*****************************************************************");
	   if (fatal) fprintf ( stderr, "\n#ERROR [FATAL:%s]", PROGRAM);
	   else fprintf ( stderr, "\n#WARNING [%s]", PROGRAM);
	   fprintf ( stderr, "\n# The Program %s Needed by %s Could not be found", program_name, PROGRAM);
	   fprintf ( stderr, "\n# If %s is installed on your system:", program_name);
	   fprintf ( stderr, "\n#\t     -Make sure %s is in your $path:",program_name);
	   
	   fprintf ( stderr, "\n# If %s is NOT installed obtain a copy from:", program_name);
	   fprintf ( stderr, "\n#\t%s\n#\n#",where2getit); 
	   fprintf ( stderr, "\n# and install it manualy");
	   fprintf ( stderr, "\n******************************************************************\n");
	 }
     }
   if ( fatal==IS_FATAL || fatal==INSTALL_OR_DIE) myexit (EXIT_FAILURE);
   return 0;
  }

FILE * display_output_filename ( FILE *io, char *type, char *format, char *name, int check_output)
{
  static char ***buf;
  static int nbuf;
  
  if ( strm ( name, "stdout") || strm (name, "stderr"))return io;
  
  if ( check_output==STORE)
    {
      int a;
      if ( buf==NULL)buf=vcalloc ( 1000, sizeof (char**));
      
      for (a=0; a<nbuf; a++)
	if ( strm (name, buf[a][2]))return io;
      
      buf[nbuf]=declare_char (3, 1000);
      sprintf ( buf[nbuf][0], "%s", type);
      sprintf ( buf[nbuf][1], "%s", format);
      sprintf ( buf[nbuf][2], "%s", name);
      nbuf++;
      return io;
    }
  else if ( check_output==FLUSH)
    {
      int a;
      for ( a=0; a< nbuf; a++)
	{
	  io=display_output_filename ( io, buf[a][0], buf[a][1], buf[a][2], CHECK);
	  free_char (buf[a], -1);
	}
      nbuf=0;
    }
  else if ( check_output==CHECK)
    {
      if (check_file_exists(name)==NULL)
	{
	  fprintf ( io, "\n\t#### File Type= %10s Format= %10s Name= %s | NOT PRODUCED [WARNING:%s:%s]\n",type, format, name, PROGRAM, VERSION );
	  return io;
	}
      add_file2error_report (type, format, name);
      fprintf ( io, "\n\t#### File Type= %10s Format= %10s Name= %s",type, format, name );
    }
  return io;
}

FILE * display_input_filename ( FILE *io, char *type, char *format, char *name, int check_output)
{
  if ( check_output==CHECK && check_file_exists(name)==NULL)
    {
      fprintf ( io, "\n\tIIII INPUT File Type= %10s Format= %10s Name= %s | NOT PRODUCED [WARNING:%s:%s]\n",type, format, name, PROGRAM, VERSION );
      return io;
    }
  add_file2error_report (type, format, name);
  
  fprintf ( io, "\n\t#### File Type= %10s Format= %10s Name= %s",type, format, name );
  return io;
}

int file_is_empty (char *fname)
{
  struct stat s;
  if (!fname) return 1;

  stat (fname, &s);
  if (s.st_size)return 0;
  else return 1;
  }
int file_exists (char *path, char *fname)
{
  struct stat s;
  char file[1000];
  
  if (!fname)return 0;
  else if (!path)sprintf (file, "%s", fname);
  else sprintf ( file, "%s/%s", path, fname);
  
  
  
  if (stat(file,& s)!=-1)
    return S_ISREG(s.st_mode);
  else return 0;
}

int isdir  (char *file)
{
  struct stat s;
  if (stat (file,&s)!=-1)
    return S_ISDIR(s.st_mode);
  else return 0;
}
int rrmdir (char *s)
{
  if (isdir(s))return printf_system_direct ("rm -r %s", s);
  return EXIT_FAILURE;
}
    
int isexec (char *file)
{
  char *state;
  
  state=ls_l(NULL,file);
  if (state[0]==0) return 0;
  
  if ( state[0]=='d') return 0;
  if ( state[3]=='x') return 1;
  if ( state[6]=='x') return 1;
  if ( state[9]=='x') return 1;
  return 0;
}

char *ls_l ( char *path,char *file)
{
  char *tmpfile;
  static char *state;
  char command[10000];
  FILE *fp;
  int a;
  
  tmpfile=vtmpnam (NULL);
  if (!state)
    {
  
      state=vcalloc (100, sizeof (char));
    }
  for (a=0;a<100; a++)state[a]=0;
  if (!file)return state;
  
  
  sprintf ( command, "ls -l %s%s%s >%s 2>/dev/null", (path!=NULL)?path:"", (path!=NULL)?"/":"",file, tmpfile);
  safe_system (command);
  fp=vfopen (tmpfile, "r");
  if (!fscanf ( fp, "%s", state))
    {
      vfclose(fp); return 0;
    }
  vfclose (fp);
  return state;
}

int my_mkdir ( char *dir_in)
{
  
  int dir_sep='/';
  
  int a, buf;
  char *dir;

  dir=vcalloc ( strlen (dir_in)+strlen (get_home_4_tcoffee())+100, sizeof (char));
  sprintf ( dir, "%s", dir_in);
  tild_substitute ( dir, "~",get_home_4_tcoffee());
  
      
  
  a=0;

  while (dir[a]!='\0')
    {
      
      if ( dir[a]==dir_sep || dir[a+1]=='\0')
	{
	  buf= dir[a+1];
	  dir[a+1]='\0';

	  if (access(dir, F_OK)==-1)
	    {
	    
	      printf_system_direct("mkdir %s", dir);
	    
	      if ( access (dir, F_OK)==-1)
		{
		  fprintf ( stderr, "\nERROR: Could Not Create Directory %s [FATAL:%s]", dir, PROGRAM);
		  exit (EXIT_FAILURE);
		}
	    }
	  dir[a+1]=buf;
	} 
      a++;
    }

  vfree (dir);
  return 1;
}

int filename_is_special (char *fname)
{
  if ( strm5 (fname, "default", "stdin", "stdout","stderr", "/dev/null"))return 1;
  if ( strm3 (fname, "STDIN", "STDOUT", "STDERR"))return 1;
  return 0;
}

char* check_file_exists ( char *fname_in)
	{
	FILE *fp;
	static char *fname1;
	static char *fname2;
	
	
	if (!fname_in)return NULL;
	if (!fname_in[0])return NULL;
	if (fname_in[0]=='-')return NULL;
	
	if (!fname1){fname1=vcalloc (1000, sizeof (char));}
	if (!fname2){fname2=vcalloc (1000, sizeof (char));}
	
	sprintf ( fname1, "%s", fname_in);tild_substitute (fname1, "~", get_home_4_tcoffee());
	sprintf ( fname2, "%s%s", get_cache_dir(),fname1);

	if ( filename_is_special (fname1))return fname1;
	if ( strm5 (fname1, "no", "NO", "No", "NO_FILE","no_file"))return NULL/*fname1*/;
	if (!file_exists( NULL,fname1)) 
	  {
	    if (!file_exists (NULL,fname2))return NULL;
	    else return fname2;
	  }
	else return fname1;
	return NULL;
	}	


void create_file ( char *name)
	{
	FILE *fp;
	
	fp=fopen (name, "w");
	fclose (fp);
	}
void delete_file ( char *fname)
	{
	char command[1000];
	FILE * fp;
	
	fp=fopen ( fname, "w");
	fprintf ( fp, "x");
    	fclose ( fp);
	
	sprintf ( command, "rm %s", fname);
    	my_system ( command);
    		
    	}	

int util_rename ( char *from, char *to)
        {
	FILE *fp_from;
	FILE *fp_to;
	int c;

	
	if ( !check_file_exists (from))return 0;
        else if ( check_file_exists (to) && !vremove (to) && !rename ( from, to)==0 );
        else
                {
		 
	        fp_from=vfopen ( from, "r");
		fp_to=vfopen ( to, "w");
		
		while ( (c=fgetc (fp_from))!=EOF)fprintf ( fp_to, "%c", c);

		fclose (fp_from);
		fclose ( fp_to);

		vremove ( from);
		return 1;
		}
	return 0;
	}


int util_copy (  char *from, char *to)
        {
	FILE *fp_from;
	FILE *fp_to;
	int c;

	
	if (!check_file_exists (from))return 0;
        else
                {
		 
	        fp_from=vfopen ( from, "r");
		fp_to=vfopen ( to, "w");
		
		while ( (c=fgetc (fp_from))!=EOF)fprintf ( fp_to, "%c", c);

		fclose (fp_from);
		fclose ( fp_to);
		return 1;
		}
	return 0;
	} 
FILE * output_completion4halfmat ( FILE *fp,int n, int tot, int n_reports, char *s)

{
  int max, left, achieved;
  int up;
  
  if (n>=0)up=1;
  else up=-1;
  

  max=((tot*tot)-tot)/2;
  left=((tot-n)*(tot-n)-(tot-n))/2;
  
  achieved=max-left;
  if (up==1);
  else
    {
      int b;
      b=achieved;
      achieved=left;
      left=b;
    }
  return output_completion (fp,achieved, max, n_reports, s);
}
  
  
FILE * output_completion ( FILE *fp,int n, int tot, int n_reports, char *string)
        {

	  static int ref_val;
	  static int flag;
	  static int ref_time;
	  int t, elapsed;
	  n++;
	  
	  if ( n==1)
	    {
	      ref_val=flag=0;
	      ref_time=get_time()/1000;
	    }
	  t=get_time()/1000;
	  elapsed=t-ref_time;
	    
	  if ( !ref_val && !flag)
	    {
	      fprintf (fp, "\n\t\t[%s][TOT=%5d][%3d %%][ELAPSED TIME: %4d sec.]",(string)?string:"",tot,(tot==1)?100:0, elapsed);
	      flag=1;
	    }
	  else if ( n==tot)fprintf (fp, "\r\t\t[%s][TOT=%5d][%3d %%][ELAPSED TIME: %4d sec.]",(string)?string:"", tot,100, elapsed);
	  else if ( ((n*100)/tot)>ref_val)
	    {
	      ref_val=((n*100)/tot);
	      t=(ref_val==0)?0:elapsed/ref_val;
	      t=t*(100-ref_val);
	      t=0;
	      fprintf (fp, "\r\t\t[%s][TOT=%5d][%3d %%][ELAPSED TIME: %4d sec.]", (string)?string:"",tot,ref_val, elapsed);
	      flag=0;
	    }	   
	  return fp;
	}
void * null_function (int a,...)
{
  fprintf ( stderr, "\n[ERROR] Attempt to use the Null Function [FATAL:%s]", PROGRAM);
  crash ("");
  return NULL;
}

int  btoi ( int nc,...)
{
  va_list ap;
  int a, b;
  va_start (ap, nc);
  for ( a=0, b=0; a< nc; a++)
    {
      b+=pow(2,a)*va_arg (ap,int);
    }
  va_end(ap);
  return b;
}

/*********************************************************************/
/*                                                                   */
/*                         Geometric FUNCTIONS                    */
/*                                                                   */
/*                                                                   */
/*********************************************************************/

float get_geometric_distance ( float ** matrix, int ncoor, int d1, int d2, char *mode)
{
  float d;
  float t=0;
  int a;

  if ( strm (mode, "euclidian"))
    {
      for ( a=0; a< ncoor; a++)
	{
	  d=(matrix[d1][a]-matrix[d2][a]);
	  t+=d*d;
	}
      return (float)sqrt((double)t);
    }
  return 0;
}
       


/*********************************************************************/
/*                                                                   */
/*                         MATHEMATICAL FUNCTIONS                    */
/*                                                                   */
/*                                                                   */
/*********************************************************************/
static double EXP_UNDERFLOW_THRESHOLD = -4.60f;
static double LOG_UNDERFLOW_THRESHOLD = 7.50f;
static double LOG_ZERO = -FLT_MAX;
static double LOG_ONE = 0.0f;
double log_addN (int N, double*L)
     
{
  double v;
  int a;
  if (N==0)return 0;
  if ( N==1)return L[0];
  
  v=L[0];
  for ( a=1; a<N; a++)
    {
      v=log_add2(v, L[a]);
    }
  return v;
  }
double log_add6 (double x, double y, double z, double w, double v, double e)
{
  return log_add2(log_add3(x, y, z),log_add3(z,w,e));
}
double log_add5 (double x, double y, double z, double w, double v)
{
  return log_add3(log_add2(x, y),log_add2(z,w),v );
}
double log_add4 (double x, double y, double z, double w)
{
  return log_add2(log_add2(x, y),log_add2(z,w));
}
double log_add3 (double x, double y, double z)
{
  return log_add2(log_add2(x, y),z);
}
double log_add2 ( double x, double y)
{
  if (x < y)
    x = (x == LOG_ZERO || ((y - x) >= LOG_UNDERFLOW_THRESHOLD)) ? y : log (exp (x-y) + 1) + x;
  else
    x = (y == LOG_ZERO || ((x - y) >= LOG_UNDERFLOW_THRESHOLD)) ? x : log (exp (x-y) + 1) + y;
  return x;
}


  
  
float M_chooses_Nlog ( int m, int N)
{
  /*Choose M elemets in N*/
  float  z1, z2,z=0;
  if ( m==N) return 0;
  else if ( m>N)
    {
      fprintf ( stderr, "\nERROR: M chosses N out of bounds ( M>N) [FATAL:%s]", PROGRAM);
      myexit (EXIT_FAILURE);
    }
  else
    {
      z1=factorial_log (m+1, N);
      z2=factorial_log (1, N-m);
      z=z1-z2;
      return z;
    }
  
  return -1;
}  

float factorial_log ( int start, int end)
{
  if ( end==0)return 0;
  else if ( end==start) return (float)my_int_log((double)start);
  else if ( start>end)
     {
       fprintf ( stderr, "\nERROR: factorial log out of bounds (%d %d) [FATAL:%s]",start, end, PROGRAM);
       myexit (EXIT_FAILURE);
    }
  else
    {
      int a=0;
      float x=0;
      for ( x=0,a=start; a<=end; a++)
	{
	  x+=(float)my_int_log(a);
	}
      return x;
    }
  return 0;
}

float my_int_log(int a)
{
  
  if ( a>=100000)return log(a);
  else
    {
      static float *lu;
      if (!lu) lu=vcalloc ( 100000, sizeof (float));
      if ( !lu[a]){lu[a]=log(a);}
      return lu[a];
    }
  return 0;
}

double factorial (int start, int end);
double M_chooses_N ( int m, int N)
{
  /*Choose M elemets in N*/
  if ( m==N) return 1;
  else if ( m>N)
    {
      fprintf ( stderr, "\nERROR: M chosses N out of bounds ( M>N) [FATAL:%s]", PROGRAM);
      myexit (EXIT_FAILURE);
    }
  else if ( N<50)
    {
      return factorial (m+1, N)/factorial (1, N-m);
    }
  else
    {
      fprintf ( stderr, "\nERROR: M chosses N out of bounds ( N>50). Use log space [FATAL:%s]", PROGRAM);
      myexit (EXIT_FAILURE);
    }
  return -1;
}
double factorial (int start, int end)
  {
    
    if ( start>end || start<0 || end<0)
      {
	fprintf ( stderr, "\nERROR: Negative Factorial [FATAL:%s]", PROGRAM);
	myexit ( EXIT_FAILURE);
      }
    else if (end==0) return 1;
    else if (end==start) return end;
    else
      {
	static double **lu;
	if ( !lu)lu=declare_double (100, 100);
	
	if ( lu[start][end])return lu[start][end];
	else
	  {
	    int a;
	    lu[start][end]=(double)start;
	    for ( a=start+1; a<=end; a++)
	      {
		lu[start][end]*=(double)a;
	      }
	    return  lu[start][end];
	  }
      }
    return -1;
  }
/*********************************************************************/
/*                                                                   */
/*                         Fast Log Additions (adapted from Probcons)*/
/*                                                                   */
/*                                                                   */
/*********************************************************************/
double EXP (double x){
  //return exp(x);
  if (x > -2){
    if (x > -0.5){
      if (x > 0)
	return exp(x);
      return (((0.03254409303190190000*x + 0.16280432765779600000)*x + 0.49929760485974900000)*x + 0.99995149601363700000)*x + 0.99999925508501600000;
    }
    if (x > -1)
      return (((0.01973899026052090000*x + 0.13822379685007000000)*x + 0.48056651562365000000)*x + 0.99326940370383500000)*x + 0.99906756856399500000;
    return (((0.00940528203591384000*x + 0.09414963667859410000)*x + 0.40825793595877300000)*x + 0.93933625499130400000)*x + 0.98369508190545300000;
  }
  if (x > -8){
    if (x > -4)
      return (((0.00217245711583303000*x + 0.03484829428350620000)*x + 0.22118199801337800000)*x + 0.67049462206469500000)*x + 0.83556950223398500000;
    return (((0.00012398771025456900*x + 0.00349155785951272000)*x + 0.03727721426017900000)*x + 0.17974997741536900000)*x + 0.33249299994217400000;
  }
  if (x > -16)
    return (((0.00000051741713416603*x + 0.00002721456879608080)*x + 0.00053418601865636800)*x + 0.00464101989351936000)*x + 0.01507447981459420000;
  return 0;
}

float LOOKUP (float x){

  if (x <= 1.00f) return ((-0.009350833524763f * x + 0.130659527668286f) * x + 0.498799810682272f) * x + 0.693203116424741f;
  if (x <= 2.50f) return ((-0.014532321752540f * x + 0.139942324101744f) * x + 0.495635523139337f) * x + 0.692140569840976f;
  if (x <= 4.50f) return ((-0.004605031767994f * x + 0.063427417320019f) * x + 0.695956496475118f) * x + 0.514272634594009f;
  
  return ((-0.000458661602210f * x + 0.009695946122598f) * x + 0.930734667215156f) * x + 0.168037164329057f;
}
void LOG_PLUS_EQUALS (float *x, float y){
  
  if (x[0] < y)
    x[0] = (x[0] == LOG_ZERO || y - x[0] >= LOG_UNDERFLOW_THRESHOLD) ? y : LOOKUP(y-x[0]) + x[0];
  else
    x[0] = (y == LOG_ZERO || x[0] - y >= LOG_UNDERFLOW_THRESHOLD) ? x[0]  : LOOKUP(x[0]-y) + y;
}

float LOG_ADD (float x, float y){
  if (x < y) return (x == LOG_ZERO || y - x >= LOG_UNDERFLOW_THRESHOLD) ? y : LOOKUP(y-x) + x;
  return (y == LOG_ZERO || x - y >= LOG_UNDERFLOW_THRESHOLD) ? x : LOOKUP(x-y) + y;
}

float LOG_ADD3 (float x1, float x2, float x3){
  return LOG_ADD (x1, LOG_ADD (x2, x3));
}
float LOG_ADD4 (float x1, float x2, float x3, float x4){
  return LOG_ADD (x1, LOG_ADD (x2, LOG_ADD (x3, x4)));
}
float LOG_ADD5 (float x1, float x2, float x3, float x4, float x5){
  return LOG_ADD (x1, LOG_ADD (x2, LOG_ADD (x3, LOG_ADD (x4, x5))));
}
float LOG_ADD6 (float x1, float x2, float x3, float x4, float x5, float x6){
  return LOG_ADD (x1, LOG_ADD (x2, LOG_ADD (x3, LOG_ADD (x4, LOG_ADD (x5, x6)))));
}
float LOG_ADD7 (float x1, float x2, float x3, float x4, float x5, float x6, float x7){
  return LOG_ADD (x1, LOG_ADD (x2, LOG_ADD (x3, LOG_ADD (x4, LOG_ADD (x5, LOG_ADD (x6, x7))))));
}


#define LONG_SIZE 2
#define SHORT_SIZE 1
#define SPACE_PAD 4
#define STD_SIZE 0    
char *strscn(char *s, char *pattern);
long unsigned strtou(char *s, int base, char **scan_end);
long int strtoi(char *s, int base, char **scan_end);
int my_isnumber(char c, int base);
int tonumber(char c);

int my_vsscanf(char *buf, char *fmt, va_list parms)
 {
         int scanned = 0, size = 0, suppress = 0;
         int w = 0, flag = 0, l = 0;
         char c, *c_ptr;
         long int n1, *n1l;
         int *n1b;
         short int *n1s;
         long unsigned n2, *n2l, parsing = 0;
         unsigned *n2b;
         short unsigned *n2s;
         double n3, *n3l;
         float *n3s;
         char *base = buf;
         while (*fmt != 0) {
                 if (*fmt != '%' && !parsing) {
                         /* No token detected */
                         fmt++;
                 } else {
                         /* We need to make a conversion */
                         if (*fmt == '%') {
                                 fmt++;
                                 parsing = 1;
                                 size = STD_SIZE;
                                 suppress = 0;
                                 w = 0;
                                 flag = 0;
                                 l = 0;
                         }
                         /* Parse token */
                         switch (*fmt) {
                         case '1':
                         case '2':
                         case '3':
                         case '4':
                         case '5':
                         case '6':
                         case '7':
                         case '8':
                         case '9':
                         case '0':
                                 if (parsing == 1) {
                                         w = strtou(fmt, 10, &base);
                                         /* We use SPACE_PAD to parse %10s
                                          * commands where the number is the
                                          * maximum number of char to store!
                                          */
                                         flag |= SPACE_PAD;
                                         fmt = base - 1;
                                 }
                                 break;
                         case 'c':
                                 c = *buf++;
                                 c_ptr = va_arg(parms, char *);
                                 *c_ptr = c;
                                 scanned++;
                                 parsing = 0;
                                 break;
                         case 's':
                                 c_ptr = va_arg(parms, char *);
                                 while (*buf != 0 && isspace(*buf))
                                         buf++;
                                 l = 0;
                                 while (*buf != 0 && !isspace(*buf)) {
                                         if (!(flag & SPACE_PAD))
                                                 *c_ptr++ = *buf;
                                         else if (l < w) {
                                                 *c_ptr++ = *buf;
                                                 l++;
                                         }
                                         buf++;
                                 }
                                 *c_ptr = 0;
                                 scanned++;
                                 parsing = 0;
                                 break;
                         case 'i':
                         case 'd':
                                 buf = strscn(buf, "1234567890-+");
                                 n1 = strtoi(buf, 10, &base);
                                 buf = base;
                                 if (!suppress) {
                                         switch (size) {
                                         case STD_SIZE:
                                                 n1b = va_arg(parms, int *);
                                                 *n1b = (int) n1;
                                                 break;
                                         case LONG_SIZE:
                                                 n1l = va_arg(parms,
                                                              long int *);
                                                 *n1l = n1;
                                                 break;
                                         case SHORT_SIZE:
                                                 n1s = va_arg(parms,
                                                              short int *);
                                                 *n1s = (short) (n1);
                                                 break;
                                         }
                                         scanned++;
                                 }
                                 parsing = 0;
                                 break;
                         case 'u':
                                 buf = strscn(buf, "1234567890");
                                 n2 = strtou(buf, 10, &base);
                                 buf = base;
                                 if (!suppress) {
                                         switch (size) {
                                         case STD_SIZE:
                                                 n2b = va_arg(parms,
                                                              unsigned *);
                                                 *n2b = (unsigned) n2;
                                                 break;
                                         case LONG_SIZE:
                                                 n2l = va_arg(parms,
                                                              long unsigned *);
                                                 *n2l = n2;
                                                 break;
                                         case SHORT_SIZE:
                                                 n2s = va_arg(parms, short unsigned
                                                              *);
                                                 *n2s = (short) (n2);
                                                 break;
                                         }
                                         scanned++;
                                 }
                                 parsing = 0;
                                 break;
                         case 'x':
                                 buf = strscn(buf, "1234567890xabcdefABCDEF");
                                 n2 = strtou(buf, 16, &base);
                                 buf = base;
                                 if (!suppress) {
                                         switch (size) {
                                         case STD_SIZE:
                                                 n2b = va_arg(parms,
                                                              unsigned *);
                                                 *n2b = (unsigned) n2;
                                                 break;
                                         case LONG_SIZE:
                                                 n2l = va_arg(parms,
                                                              long unsigned *);
                                                 *n2l = n2;
                                                 break;
                                         case SHORT_SIZE:
                                                 n2s = va_arg(parms, short unsigned
                                                              *);
                                                 *n2s = (short) (n2);
                                                 break;
                                         }
                                         scanned++;
                                 }
                                 parsing = 0;
                                 break;
                         case 'f':
                         case 'g':
                         case 'e':
                                 buf = strscn(buf, "1234567890.e+-");
                                 n3 = strtod(buf, &base);
                                 buf = base;
                                 if (!suppress) {
                                         switch (size) {
                                         case STD_SIZE:
                                                 n3l = va_arg(parms, double *);
                                                 *n3l = n3;
                                                 break;
                                         case LONG_SIZE:
                                                 n3l = va_arg(parms, double *);
                                                 *n3l = n3;
                                                 break;
                                         case SHORT_SIZE:
                                                 n3s = va_arg(parms, float *);
                                                 *n3s = (float) (n3);
                                                 break;
                                         }
                                         scanned++;
                                 }
                                 parsing = 0;
                                 break;
                         case 'l':
                                 size = LONG_SIZE;
                                 break;
                         case 'h':
                         case 'n':
                                 size = SHORT_SIZE;
                                 break;
                         case '*':
                                 suppress = 1;
                                 break;
                         default:
                                 parsing = 0;
                                 break;
                         }
                         fmt++;
                 }
         }
         return (scanned);
 }
char *strscn(char *s, char *pattern)
 {
         char *scan;
         while (*s != 0) {
                 scan = pattern;
                 while (*scan != 0) {
                         if (*s == *scan)
                                 return (s);
                         else
                                 scan++;
                 }
                 s++;
         }
         return (NULL);
 }

long unsigned strtou(char *s, int base, char **scan_end)
 {
         int value, overflow = 0;
         long unsigned result = 0, oldresult;
         /* Skip trailing zeros */
         while (*s == '0')
                 s++;
         if (*s == 'x' && base == 16) {
                 s++;
                 while (*s == '0')
                         s++;
         }
         /* Convert number */
         while (my_isnumber(*s, base)) {
                 value = tonumber(*s++);
                 if (value > base || value < 0)
                         return (0);
                 oldresult = result;
                 result *= base;
                 result += value;
                 /* Detect overflow */
                 if (oldresult > result)
                         overflow = 1;
         }
         if (scan_end != 0L)
                 *scan_end = s;
         if (overflow)
                 result = INT_MAX;
         return (result);
 }
long int strtoi(char *s, int base, char **scan_end)
 {
         int sign, value, overflow = 0;
         long int result = 0, oldresult;
         /* Evaluate sign */
         if (*s == '-') {
                 sign = -1;
                 s++;
         } else if (*s == '+') {
                 sign = 1;
                 s++;
         } else
                 sign = 1;
         /* Skip trailing zeros */
         while (*s == '0')
                 s++;
         /* Convert number */
         while (my_isnumber(*s, base)) {
                 value = tonumber(*s++);
                 if (value > base || value < 0)
                         return (0);
                 oldresult = result;
                 result *= base;
                 result += value;
                 /* Detect overflow */
                 if (oldresult > result)
                         overflow = 1;
         }
         if (scan_end != 0L)
                 *scan_end = s;
         if (overflow)
                 result = INT_MAX;
         result *= sign;
         return (result);
 }

int my_isnumber(char c, int base)
 {
         static char *digits = "0123456789ABCDEF";
         if ((c >= '0' && c <= digits[base - 1]))
                 return (1);
         else
                 return (0);
 }
 
 int tonumber(char c)
 {
         if (c >= '0' && c <= '9')
                 return (c - '0');
         else if (c >= 'A' && c <= 'F')
                 return (c - 'A' + 10);
         else if (c >= 'a' && c <= 'f')
                 return (c - 'a' + 10);
         else
                 return (c);
 }

///////////////////////////////////////////////////////////////////////////////////////////
// Hash function
////////////////////////////////////////////////////////////////////////////////////////////
unsigned long hash_file(char* file)  //returns the hash value for key 
    {
      // Calculate a hash value by the division method: 
      // Transform key into a natural number k = sum ( key[i]*128^(L-i) ) and calculate i= k % num_slots. 
      // Since calculating k would lead to an overflow, i is calculated iteratively 
      // and at each iteration the part divisible by num_slots is subtracted, i.e. (% num_slots is taken).
      
      unsigned long i=0;     // Start of iteration: k is zero
      unsigned long num_slots=999999999;
      

      FILE *fp;
      unsigned long c;

      
      if (file==NULL || !check_file_exists (file) ) {printf("Warning from util.c:hasch_file: No File [FATAL:%s]\n", PROGRAM); myexit (EXIT_FAILURE);}
      num_slots/=128;
      fp=vfopen (file, "r");
      while ( (c=fgetc (fp))!=EOF)
	{
	  i = ((i<<7) + c) % num_slots; 
	}
      vfclose (fp);
	      
      return i;
    }
int ** r_generate_array_int_list ( int len, int min, int max,int step, int **array, int f, int *n,FILE *fp, int *c_array);
int **generate_array_int_list (int len, int min, int max, int step, int *n, char *file)
   {
     int **array, *c_array;
     FILE *fp=NULL;
     
     if (n==NULL)
       {
	 array=NULL;
	 fp=vfopen (file, "w");
       }
     else
       {
	 int a,s;
	 n[0]=0;
	 for (s=1, a=0; a<len; a++)s*=((max-min)+1)/step;
	 array=declare_int (s, len+1);
       }
     c_array=vcalloc (len, sizeof (int));
     array=r_generate_array_int_list ( len, max, min, step, array, 0, n,fp, c_array);
     vfree (c_array);
     if ( fp) vfclose (fp);
     return array;
   }
int ** r_generate_array_int_list ( int len, int min, int max,int step, int **array, int f, int *n,FILE *fp, int *c_array)
   {
     int a;
     
     if ( f==len)
       {
	 if ( array)
	   {
	     for (a=0; a<len; a++)
	       {
		 array[n[0]][a]=c_array[a];
	       }
	     n[0]++;
	   }
	 else
	   {
	     

	     for (a=0; a<len; a++)fprintf ( fp, "%3d ",c_array[a]);
	     fprintf (fp, "\n");
	   }
	 return array;
	 
       }
     else
       {
	 for (a=max; a<=min;a+=step)
	   {
	     c_array[f]=a;
	     r_generate_array_int_list (len, min, max, step, array, f+1, n,fp, c_array);
	   }
       }
     return array;
   }

char *** r_generate_array_string_list ( int len, char ***alp,int *alp_size, char ***array, int f, int *n,FILE *fp, char **c_array, int mode, int pstart);
char ***generate_array_string_list (int len, char ***alp, int *alp_size, int *n, char *file, int mode)
   {
     char  ***array, **c_array;
     FILE *fp=NULL;
     
     if (file!=NULL)
       {
	 array=NULL;
	 n[0]=0;
	 fp=vfopen (file, "w");
       }
     else
       {
	 
	 int a,s;
	 n[0]=0;
	 for (s=1, a=0; a<len; a++)
	   {
	     s*=alp_size[a];
	   }
	 array=declare_arrayN (3,sizeof (char), s, len,0);
       }
     c_array=declare_char (len,0);
     array=r_generate_array_string_list ( len, alp, alp_size, array, 0, n,fp, c_array, mode, -1);
     vfree (c_array);
     if ( fp) vfclose (fp);
     return array;
   }
char *** r_generate_array_string_list ( int len, char ***alp, int *alp_size, char  ***array, int f, int *n,FILE *fp, char **c_array, int mode, int pstart)
   {
     int a;
     int start;
     
     if ( f==len)
       {
	 if ( array)
	   {
	     for (a=0; a<len; a++)
	       {
		 array[n[0]][a]=c_array[a];
	       }
	     n[0]++;
	   }
	 else
	   {
	     
	     n[0]++;
	     for (a=0; a<len; a++)fprintf ( fp, "%s ",c_array[a]);
	     fprintf (fp, "\n");
	   }
	 return array;
	 
       }
     else
       {
	 if ( mode==OVERLAP)
	   {
	     start=0;
	   }
	 else if ( mode==NO_OVERLAP) 
	   {
	     start=pstart+1;
	   }

	 for (a=start; a<alp_size[f]; a++)
	   {
	     c_array[f]=alp[f][a];
	     r_generate_array_string_list (len,alp, alp_size, array, f+1, n,fp, c_array, mode, a);
	   }
       }
     return array;
   }

float rates2sensitivity (int tp, int tn, int fp, int fn, float *sp, float *sn, float *sen2, float *b)
{
  if (sp==NULL)
    {
      sp=vcalloc (1, sizeof (float));
      sn=vcalloc (1, sizeof (float));
      sen2=vcalloc (1, sizeof (float));
      b=vcalloc (1, sizeof (float));
    }
  sn[0]  =((tp+fn)==0)?1:(float)tp/(float)(tp+fn);
  sen2[0]=((tp+fp)==0)?1:(float)tp/(float)(tp+fp);
  sp[0]  =((tn+fp)==0)?1:(float)tn/(float)(tn+fp);
  b[0]=MIN((MIN((sp[0]),(sn[0]))),(sen2[0]));
  return b[0];
}
float profile2sensitivity (char *pred, char *ref, float *sp, float *sn, float *sen2, float *b)	      
{
  int tp=0, tn=0, fp=0, fn=0;
  int a, l;
  
  l=strlen (pred);
  
  for (a=0; a<l; a++)
    {
      if (pred[a]=='I' && ref[a]=='I')tp++;
      if (pred[a]=='O' && ref[a]=='I')fn++;
      if (pred[a]=='I' && ref[a]=='O')fp++;
      if (pred[a]=='O' && ref[a]=='O')tn++;
    }
  return  rates2sensitivity (tp, tn, fp, fn, sp, sn, sen2, b);
}
float profile2evalue (char *pred, char *ref)
{
  
  int a, l;
  double P=0;
  double E=0;
  double II=0;
  double p1, p2, p;
  l=strlen (pred);
  
  for (a=0; a<l; a++)
    {
      if (pred[a]=='I')P++;
      if (ref[a]=='I') E++;
      
      if (pred[a]=='I' && ref[a]=='I')II++;
    }

  if (II==0)return 0;

  p1= M_chooses_Nlog (P,l) + M_chooses_Nlog (II, P) + M_chooses_Nlog (E-II, l-P);
  p2=(M_chooses_Nlog (P,l)+M_chooses_Nlog (E,l));
  p=(p1-p2);

  return (float)-p;
}

		      

  
      
/*********************************COPYRIGHT NOTICE**********************************/
/*� Centro de Regulacio Genomica */
/*and */
/*Cedric Notredame */
/*Sat Aug 16 20:30:21 WEST 2008. */
/*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**********************************/
/*
FILE * farray()
{
  return tmpfile();
}
float fset (FILE *fp, int i, float v)
{
  fseek (fp, i*sizeof (float), SEEK_SET);
  fwrite(&v, sizeof (float), fp);
  return v;
}
float fread (FILE *fp, int i, float v)
{
  fseek (fp, i*sizeof (float), SEEK_SET);
  fread (&v, sizeof (float), fp);
  return v;
}
*/
/*********************************COPYRIGHT NOTICE**********************************/
/*© Centro de Regulacio Genomica */
/*and */
/*Cedric Notredame */
/*Tue Oct 27 10:12:26 WEST 2009. */
/*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**********************************/