#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#define LONGBUFF 4096
typedef struct {
	int debut;
	int lg;
	int lgpref;
	int lgsuff;
	int lgmaxfuspref;
	int lgmaxfussuf;
	int Imotpref;
	int Imotsuff;
} Indic;
Indic Ref,*TabRef;
int Mn,*TabOrdPref,*TabOrdSuff,*TabMaxFus;
/* Quick Sort */
void tripref(int D,int F)
{
	int I,J,M,N;
	I = D;
	J = F;
	M = TabRef[TabOrdPref[((I + J)/2)]].lgpref;
	N = TabRef[TabOrdPref[((I + J)/2)]].debut;
	do {
		while((TabRef[TabOrdPref[I]].lgpref > M) || ((TabRef[TabOrdPref[I]].lgpref == M) && (TabRef[TabOrdPref[I]].debut < N)))
			++I;
		while((TabRef[TabOrdPref[J]].lgpref < M) || ((TabRef[TabOrdPref[J]].lgpref == M) && (TabRef[TabOrdPref[J]].debut > N)))
			--J;
		if ((TabRef[TabOrdPref[I]].lgpref == TabRef[TabOrdPref[J]].lgpref) && (TabRef[TabOrdPref[I]].debut == TabRef[TabOrdPref[J]].debut))
			++I;
		else if (I < J)
		{
			Mn = TabOrdPref[I];
			TabOrdPref[I] = TabOrdPref[J];
			TabOrdPref[J] = Mn;
		}
	} while(I < J);
	if ((I > D) && (I <= F))
		tripref(D,I-1);
	if ((J >= D) && (J < F))
		tripref(J + 1,F);
}
void trisuf(int D,int F)
{
	int I,J,M,N;
	I = D;
	J = F;
	M = TabRef[TabOrdSuff[(I + J)/2]].lgsuff;
	N = TabRef[TabOrdSuff[(I + J)/2]].debut;
	do {
		while((TabRef[TabOrdSuff[I]].lgsuff > M) || ((TabRef[TabOrdSuff[I]].lgsuff == M) && (TabRef[TabOrdSuff[I]].debut < N)))
			++I;
		while((TabRef[TabOrdSuff[J]].lgsuff < M) || ((TabRef[TabOrdSuff[J]].lgsuff == M) && (TabRef[TabOrdSuff[J]].debut > N)))
			--J;
		if ((TabRef[TabOrdSuff[I]].lgsuff == TabRef[TabOrdSuff[J]].lgsuff) && (TabRef[TabOrdSuff[I]].debut == TabRef[TabOrdSuff[J]].debut))
			++I;
		else if (I < J)
		{
			Mn = TabOrdSuff[I];
			TabOrdSuff[I] = TabOrdSuff[J];
			TabOrdSuff[J] = Mn;
		}
	} while(I < J);
	if ((I > D) && (I <= F))
		trisuf(D,I-1);
	if ((J >= D) && (J < F))
		trisuf(J + 1,F);
}
void trifus(int D,int F)
{
	int I,J,M,N;
	I = D;
	J = F;
	M = (TabRef[TabMaxFus[(I + J)/2]].lgmaxfuspref > TabRef[TabMaxFus[(I + J)/2]].lgmaxfussuf) ? TabRef[TabMaxFus[(I + J)/2]].lgmaxfuspref : TabRef[TabMaxFus[(I + J)/2]].lgmaxfussuf;
	N = TabRef[TabMaxFus[(I + J)/2]].debut;
	do {
		while((((TabRef[TabMaxFus[I]].lgmaxfuspref > TabRef[TabMaxFus[I]].lgmaxfussuf) ? TabRef[TabMaxFus[I]].lgmaxfuspref : TabRef[TabMaxFus[I]].lgmaxfussuf) > M) ||
			((((TabRef[TabMaxFus[I]].lgmaxfuspref > TabRef[TabMaxFus[I]].lgmaxfussuf) ? TabRef[TabMaxFus[I]].lgmaxfuspref : TabRef[TabMaxFus[I]].lgmaxfussuf) == M) &&
			(TabRef[TabMaxFus[I]].debut < N)))
				++I;
		while((((TabRef[TabMaxFus[J]].lgmaxfuspref > TabRef[TabMaxFus[J]].lgmaxfussuf) ? TabRef[TabMaxFus[J]].lgmaxfuspref : TabRef[TabMaxFus[J]].lgmaxfussuf) < M) ||
			((((TabRef[TabMaxFus[J]].lgmaxfuspref > TabRef[TabMaxFus[J]].lgmaxfussuf) ? TabRef[TabMaxFus[J]].lgmaxfuspref : TabRef[TabMaxFus[J]].lgmaxfussuf) == M) &&
			(TabRef[TabMaxFus[J]].debut > N)))
				--J;
		if (TabRef[TabMaxFus[I]].debut == TabRef[TabMaxFus[J]].debut)
			++I;
		else if (I < J)
		{
			Mn = TabMaxFus[I];
			TabMaxFus[I] = TabMaxFus[J];
			TabMaxFus[J] = Mn;
		}
	} while(I < J);
	if ((I > D) && (I <= F))
		trifus(D,I - 1);
	if ((J >= D) && (J < F))
		trifus(J + 1,F);
}
main(int argc, char *argv[])
{
	/*	fs identificateur du fichier super chaine
		fc  "             "   "     liste des chaines
		ft   "            "   creation des tables d'adressage
		ls: longueur super chaine
		nc: nombre de chaines
		la: somme des longueur des chaine ajoutee (normalement 0)
		ic: indice courant de lecture dans la super chaine
		Indic: element du tableau d'adressage d'une chaine dans la superchaine
	*/
	int fs,fc,ft,ls,lsp,la,nc,Im,Ip,i,l,lgmax,Lsup,lg,k,Boucle,tour,econom,M,Imf,lpref,lsuf,lrord;
	char *SuperChaine;	
	/* Buffer: zone de lecture de la liste des mots
		ptbuf: pointer de lecture dans la zone buffer
		lglect longueur de la chaine lue dans le buffer
		lgprov: longueur de lecture
	*/
	char Buffer[2 * LONGBUFF];
	char *ptbuf,*ptprov,*ptsch,*ptschp,*pttst;
	int lglect,lgprov;
	if (argc != 3)
	{
		printf("usage: makesuperchaine <nom fichier liste chaines> <nom fichier superchaine resultat>\n");
		exit(0);		
	}
	if ((fc = open(argv[1],O_RDONLY)) < 0)
	{
		printf("fichier liste chaines %s inexistant\n");
		exit(0);
	}
	if ((fs = creat(argv[2],0666)) < 0)
	{
		printf("fichier super chaine impossible a creer\n");
		close(fc);
		exit(0);
	}
	if ((ft = creat("Table_Chaines",0666)) < 0)
	{
		printf("fichier de travail impossible a creer\n");
		close(fs);
		close(fc);
		exit(0);
	}
	la = 0;
	nc = 0;
	/* lecture de la liste des chaines a reconnaitre
		cette lecture est buffurisee
		le buffer a deux fois la longueur de lecture
		(pour permettre une lecture des mots qui sont a cheval
		sur deux buffer)
	*/
	if ((lglect = read(fc,Buffer,LONGBUFF)) <= 0)
	{
		printf("fichier liste des chaines vide\n");
		close(fs);
		close(fc);
		close(ft);
		exit(0);
	}
	/* Si un premier buffer est lu completement il reste des elements a lire
		que l'on place dans la deuxieme  partie du buffer
		lgprov contiendra la longueur complementaire
		tant que cette longueur sera egale a LONGBUFF
		on sera dans une lecture bufferisee
		a la fin lgprov vaudra 0 */
	if (lglect == LONGBUFF)
		lgprov = read(fc,&Buffer[LONGBUFF],LONGBUFF);
	else lgprov = 0;
	/* Les mots seront reconnu et leurs caracteristique seront place dans un fichier provisoire
	car on ne connait pas leur nombre
	Ces caracteristique sont definies dans la structure Ref */
	/* Le buffer (compose de deux parties ) sera parcouru avec ptbuf
		quand ptbuf depassera le milieu
		on deplace la moitie terminale sur la moitie initiale
		on lit une nouvelle moitie terminale */
	ptbuf = Buffer;
	Ref.Imotpref = Ref.Imotsuff = -1;
	Ref.lgmaxfuspref = Ref.lgmaxfussuf = 0;
	lgmax = 0;
	do
	{
		lglect += lgprov;
		/* On doit parcourir la moitie au moins du buffer
			ou dans le cas ou celui ci est incomplet (fin de buffisation)
			la partie lue */
		while(((ptbuf - Buffer) < LONGBUFF) && ((ptbuf - Buffer) < lglect))
		{
			/* Pour isoler un mot de la liste on doit rechercher
				le caractere changement de ligne
				cette recherche s'effectue evidement a partir du pointeur
				courant */
			ptprov = ptbuf;
			while(*ptprov != '\n')
				++ptprov;
			/* Lorsque l'on a trouver un caractere de changement de ligne
				ce dernier n'appartient pas a la chaine et on peut le remplacer par
				un caractere nul
				De plus on obtient alors la longueur du mot
				par une difference de pointeur
				ptbuf pointe sur le debut du mot
				ptprov sur le caractere changement de ligne
				On met eventuellement a jour la variable globale lgmax: longeur max d'un mot
			*/
			Ref.lg = ptprov - ptbuf;
			*ptprov++ = '\0';
			/* Il faut prevoir le cas ou la chaine lu est la chaine vide (deux saut de ligne successifs */
			if (Ref.lg > 0)
			{
				if (Ref.lg > lgmax)
					lgmax = Ref.lg;
				Ref.debut = la;
				Ref.lgpref = Ref.lgsuff = Ref.lg - 1;
				write(fs,ptbuf,Ref.lg);
				la += Ref.lg;
				write(ft,&Ref,sizeof(Ref));
				++nc;
			}
			/* Quand un mot est completement traite on passe au suivant
				ptprov pointe sur le premier caractere du mot suivant */
			ptbuf = ptprov;
		}
		/* On a lu completement un 1/2 buffer ou le reste des caracteres
			On effectue donc un deplacement: fin de buffer vers debut
			lecture de la fin */
		lglect -= LONGBUFF;
		if (lglect > 0)
		{
			ptbuf -= LONGBUFF;
			ptsch = Buffer;
			ptschp = &Buffer[LONGBUFF];
			for(k = 0; k < lglect; ++k)
				*ptsch++ = *ptschp++;
		}
		/* Si lgprov est egale a 1/2 buffer alors il reste eventuellement des choses a lire */
		if (lgprov == LONGBUFF)
			lgprov = read(fc,&Buffer[LONGBUFF],LONGBUFF);
		else lgprov = 0;
	} while(lglect > 0);
	/* La lecture de la liste des chaines est terminee
		la super chaine a eventuellement ete completee
		dans ce cas il faut donc la relire
		au prealable on replace le caractere de changement de ligne en fin de super chaine */
	/* On lit la nouvelle taille de la super chaine */
	close(fc);
	close(ft);
	close(fs);
	SuperChaine = malloc(la + lgmax + 1);
	if ((fs = open(argv[2],O_RDONLY)) < 0)
	{
		printf("fichier super chaine impossible a ouvrir\n");
		exit(0);
	}
	lseek(fs,0,SEEK_SET);
	read(fs,SuperChaine,la);
	close(fs);
	SuperChaine[la++] = '\0';
	/* Les fichiers super chaine et liste des chaine ont ete traite on peut les ferme
		le fichier table de reference contient la table des caracteristiques des mots
		Il va permettre de reserver la place en memoire et de construire cette table */
	if ((ft = open("Table_Chaines",O_RDONLY)) < 0)
	{
		printf("fichier de travail impossible a ouvrir\n");
		close(ft);
		exit(0);
	}
printf("Fin lecture\n");
	ls = lseek(ft,0,SEEK_END);
	TabRef = (Indic *) malloc(ls);
	lseek(ft,0,SEEK_SET);
	read(ft,(char *) TabRef,ls);
	close(ft);
	TabOrdPref = malloc(nc * sizeof(int));
	TabOrdSuff = malloc(nc * sizeof(int));
	TabMaxFus = malloc(nc * sizeof(int));
	/* Tout est positionne pour le traitement
		On tri le tableau de reference par rapport a l'indice de debut des chaines */
	for(Im = 0; Im < nc; ++Im)
		TabOrdPref[Im] = TabOrdSuff[Im] = Im;
	tripref(0,nc - 1);
	/*  trisuf(0, nc - 1); */
printf("Fin tri pref\n");
	for(Im = 0; Im < nc; ++Im)
		TabOrdSuff[Im] = TabOrdPref[Im];
	Boucle = 1;
	tour = econom = 0;
	while(Boucle)
	{
		Boucle = 0;
		++tour;
		econom = 0;
		/* Pour savoir si on effectue des suppression on parcour l'ensemble des chaines */
		for(Im = 0; Im < nc; ++Im)
			TabMaxFus[Im] = Im;
		for(Im = 0; Im < nc; ++Im)
		{
			TabMaxFus[Im] = Im;
			TabRef[Im].lgmaxfussuf = TabRef[Im].lgmaxfuspref = 0;
			TabRef[Im].Imotpref = TabRef[Im].Imotsuff = -1;
			/* On calcul les superpositions possibles de TabRef[Im] */
			/* D'abord en prefixe (la chaine Im sera alors suffixe */
			/* cette recherhe s'effectue suivant l'ordre decroissant des suffixes
				le mot trouve deviendra alors prefixe */
			for(Ip = 0; Ip < nc; ++Ip)
			{
				/* On ne combine les mots qu'avec ceux qui sont plus eloignes dans la table
					car si a est avant b on note sur a la combinaison ab ou ba
					et on a donc pas besoin de la noter sur b */
				if (TabOrdSuff[Ip] <= Im)
					continue;
				if (TabRef[TabOrdSuff[Ip]].lgsuff < TabRef[Im].lgmaxfuspref)
					break;
				Lsup = (TabRef[Im].lgpref < TabRef[TabOrdSuff[Ip]].lgsuff) ? TabRef[Im].lgpref : TabRef[TabOrdSuff[Ip]].lgsuff;
				for(k = Lsup; k > 0; --k)
				{
					if ((k < TabRef[Im].lgmaxfuspref) || ((k == TabRef[Im].lgmaxfuspref) && (TabRef[Im].Imotpref <= TabOrdSuff[Ip])))
						break;
					ptsch = &SuperChaine[TabRef[Im].debut];
					pttst = &SuperChaine[TabRef[TabOrdSuff[Ip]].debut + TabRef[TabOrdSuff[Ip]].lg - k];
					for(l = 0; l < k; ++l)
						if (*ptsch++ != *pttst++)
							break;
					if (l == k)
					{
						TabRef[Im].lgmaxfuspref = k;
						TabRef[Im].Imotpref = TabOrdSuff[Ip];
						break;
					}
				}
			}
			/* cette recherhe s'effectue ensuite dans l'ordre decroissant des prefixes 
				le mot trouve deviendra alors suffixe */
			for(Ip = 0; Ip < nc; ++Ip)
			{
				if (TabOrdPref[Ip] <= Im)
					continue;
				if (TabRef[TabOrdPref[Ip]].lgpref < TabRef[Im].lgmaxfussuf)
					break;
				Lsup = (TabRef[Im].lgsuff < TabRef[TabOrdPref[Ip]].lgpref) ? TabRef[Im].lgsuff : TabRef[TabOrdPref[Ip]].lgpref;
				for(k = Lsup; k > 0; --k)
				{
					if ((k < TabRef[Im].lgmaxfussuf) || ((k == TabRef[Im].lgmaxfussuf) && (TabRef[Im].Imotsuff <= TabOrdPref[Ip])))
						break;
					ptsch = &SuperChaine[TabRef[Im].debut + TabRef[Im].lg - k];
					pttst = &SuperChaine[TabRef[TabOrdPref[Ip]].debut];
					for(l = 0; l < k; ++l)
						if (*ptsch++ != *pttst++)
							break;
					if (l == k)
					{
						TabRef[Im].lgmaxfussuf = k;
						TabRef[Im].Imotsuff = TabOrdPref[Ip];
						break;
					}
				}
			}
		}
		for(Im = 0; Im < nc; ++Im)
			TabMaxFus[Im] = Im;
printf(" fin Tri fusion\n");
		trifus(0,nc - 1);
		/* fusion des max */
		M = (TabRef[TabMaxFus[0]].lgmaxfuspref > TabRef[TabMaxFus[0]].lgmaxfussuf) ? TabRef[TabMaxFus[0]].lgmaxfuspref : TabRef[TabMaxFus[0]].lgmaxfussuf;
		if (M > 0)
		{
			Boucle = 1;
			Imf = 1;
			while(M == ((TabRef[TabMaxFus[Imf]].lgmaxfuspref > TabRef[TabMaxFus[Imf]].lgmaxfussuf) ? TabRef[TabMaxFus[Imf]].lgmaxfuspref : TabRef[TabMaxFus[Imf]].lgmaxfussuf))
				++Imf;
			for(Im = 0; Im < Imf; ++Im)
			{
				/* Fusion et creation d'un mot fusione
					avec mise a jour des tableaux d'index
				*/
				while(TabRef[TabMaxFus[Im]].lgmaxfuspref == M)
				{
					/* fusion par prefixe (le mot indexe en Im est en suffixe */
					k = TabRef[TabRef[TabMaxFus[Im]].Imotpref].lg;
					ptsch = &SuperChaine[la];
					pttst = &SuperChaine[TabRef[TabRef[TabMaxFus[Im]].Imotpref].debut];
					for(l = 0; l < k; ++l)
						*ptsch++ = *pttst++;
					k = TabRef[TabMaxFus[Im]].lg - TabRef[TabMaxFus[Im]].lgmaxfuspref;
					pttst = &SuperChaine[TabRef[TabMaxFus[Im]].debut + TabRef[TabMaxFus[Im]].lgmaxfuspref];
					for(l = 0; l < k; ++l)
						*ptsch++ = *pttst++;
					k = TabRef[TabRef[TabMaxFus[Im]].Imotpref].debut - TabRef[TabMaxFus[Im]].debut - TabRef[TabMaxFus[Im]].lg;
					ptsch = &SuperChaine[TabRef[TabRef[TabMaxFus[Im]].Imotpref].debut + TabRef[TabRef[TabMaxFus[Im]].Imotpref].lg - TabRef[TabMaxFus[Im]].lgmaxfuspref];
					pttst = &SuperChaine[TabRef[TabRef[TabMaxFus[Im]].Imotpref].debut];
					for(l = 0; l < k; ++l)
						*--ptsch = *--pttst;
					k = la - (TabRef[TabRef[TabMaxFus[Im]].Imotpref].debut + TabRef[TabRef[TabMaxFus[Im]].Imotpref].lg);
					ptsch = &SuperChaine[TabRef[TabRef[TabMaxFus[Im]].Imotpref].debut + TabRef[TabRef[TabMaxFus[Im]].Imotpref].lg - TabRef[TabMaxFus[Im]].lgmaxfuspref];
					pttst = &SuperChaine[TabRef[TabRef[TabMaxFus[Im]].Imotpref].debut + TabRef[TabRef[TabMaxFus[Im]].Imotpref].lg];
					for(l = 0; l < k; ++l)
						*ptsch++ = *pttst++;
					k = TabRef[TabRef[TabMaxFus[Im]].Imotpref].lg + TabRef[TabMaxFus[Im]].lg - TabRef[TabMaxFus[Im]].lgmaxfuspref;
					ptsch = &SuperChaine[TabRef[TabMaxFus[Im]].debut];
					pttst = &SuperChaine[la];
					for(l = 0; l < k; ++l)
						*ptsch++ = *pttst++;
					TabRef[TabMaxFus[Im]].lg = k;
					la -= (l = TabRef[TabMaxFus[Im]].lgmaxfuspref);
					lg = TabRef[TabRef[TabMaxFus[Im]].Imotpref].lg - l;
					k = TabRef[TabMaxFus[Im]].Imotpref;
					for(Ip = TabMaxFus[Im] + 1; Ip < nc; ++Ip)
						if (Ip < k)
							TabRef[Ip].debut += lg;
						else TabRef[Ip].debut -= l;
					l = TabRef[TabMaxFus[Im]].Imotpref;
					TabRef[TabMaxFus[Im]].lgpref = TabRef[TabRef[TabMaxFus[Im]].Imotpref].lgpref;
					TabRef[TabMaxFus[Im]].lgmaxfuspref = TabRef[TabRef[TabMaxFus[Im]].Imotpref].lgmaxfuspref;
					for(Ip = TabMaxFus[Im]; Ip < l; ++Ip)
					{
						if (TabRef[Ip].Imotpref == l)
							TabRef[Ip].lgmaxfuspref = 0;
						/* On ne rattrape pas une fusion en suffixe
							qui modifie l'ordre */
						if (TabRef[Ip].Imotsuff == l)
							TabRef[Ip].lgmaxfussuf = 0;
					}
					for(Ip = 0; Ip < nc; ++Ip)
					{
						if (TabRef[Ip].Imotpref > l)
							--TabRef[Ip].Imotpref;
						if (TabRef[Ip].Imotsuff > l)
							--TabRef[Ip].Imotsuff;
						if (TabOrdPref[Ip] > l)
							--TabOrdPref[Ip];
						if (TabOrdPref[Ip] == l)
							lpref = Ip;
						if (TabOrdPref[Ip] == TabMaxFus[Im])
							lrord = Ip;
						if (TabOrdSuff[Ip] > l)
							--TabOrdSuff[Ip];
						if (TabOrdSuff[Ip] == l)
							lsuf = Ip;
					}
					for(Ip = lpref; Ip < nc - 1; ++Ip)
						TabOrdPref[Ip] = TabOrdPref[Ip + 1];
					for(Ip = lsuf; Ip < nc - 1; ++Ip)
						TabOrdSuff[Ip] = TabOrdSuff[Ip + 1];
					for(Ip = TabRef[TabMaxFus[Im]].Imotpref; Ip < nc - 1; ++Ip)
						TabRef[Ip] = TabRef[Ip + 1];
					for(Ip = lrord; Ip < nc - 1; ++Ip)
						if (TabRef[TabOrdPref[Ip]].lgpref < TabRef[TabOrdPref[Ip + 1]].lgpref)
						{
							k = TabOrdPref[Ip];
							TabOrdPref[Ip] = TabOrdPref[Ip + 1];
							TabOrdPref[Ip + 1] = k;
						}
						else break;
					--nc;
					++econom;
				}
				while(TabRef[TabMaxFus[Im]].lgmaxfussuf == M)
				{
					/* fusion par suffixe (le mot indexe en Im est en prefixe */
					k = TabRef[TabRef[TabMaxFus[Im]].Imotsuff].lg - TabRef[TabMaxFus[Im]].lgmaxfussuf;
					ptsch = &SuperChaine[la];
					pttst = &SuperChaine[TabRef[TabRef[TabMaxFus[Im]].Imotsuff].debut + TabRef[TabMaxFus[Im]].lgmaxfussuf];
					for(l = 0; l < k; ++l)
						*ptsch++ = *pttst++;
					k = TabRef[TabRef[TabMaxFus[Im]].Imotsuff].debut - TabRef[TabMaxFus[Im]].debut - TabRef[TabMaxFus[Im]].lg;
					ptsch = &SuperChaine[TabRef[TabRef[TabMaxFus[Im]].Imotsuff].debut + TabRef[TabRef[TabMaxFus[Im]].Imotsuff].lg - TabRef[TabMaxFus[Im]].lgmaxfussuf];
					pttst = &SuperChaine[TabRef[TabRef[TabMaxFus[Im]].Imotsuff].debut];
					for(l = 0; l < k; ++l)
						*--ptsch = *--pttst;
					k = la - (TabRef[TabRef[TabMaxFus[Im]].Imotsuff].debut + TabRef[TabRef[TabMaxFus[Im]].Imotsuff].lg);
					ptsch = &SuperChaine[TabRef[TabRef[TabMaxFus[Im]].Imotsuff].debut + TabRef[TabRef[TabMaxFus[Im]].Imotsuff].lg - TabRef[TabMaxFus[Im]].lgmaxfussuf];
					pttst = &SuperChaine[TabRef[TabRef[TabMaxFus[Im]].Imotsuff].debut + TabRef[TabRef[TabMaxFus[Im]].Imotsuff].lg];
					for(l = 0; l < k; ++l)
						*ptsch++ = *pttst++;
					k = TabRef[TabRef[TabMaxFus[Im]].Imotsuff].lg - TabRef[TabMaxFus[Im]].lgmaxfussuf;
					ptsch = &SuperChaine[TabRef[TabMaxFus[Im]].debut + TabRef[TabMaxFus[Im]].lg];
					pttst = &SuperChaine[la];
					for(l = 0; l < k; ++l)
						*ptsch++ = *pttst++;
					TabRef[TabMaxFus[Im]].lg += k;
					la -= (l = TabRef[TabMaxFus[Im]].lgmaxfussuf);
					lg = TabRef[TabRef[TabMaxFus[Im]].Imotsuff].lg - l;
					k = TabRef[TabMaxFus[Im]].Imotsuff;
					for(Ip = TabMaxFus[Im] + 1; Ip < nc; ++Ip)
						if (Ip < k)
							TabRef[Ip].debut += lg;
						else TabRef[Ip].debut -= l;
					l = TabRef[TabMaxFus[Im]].Imotsuff;
					TabRef[TabMaxFus[Im]].lgsuff = TabRef[TabRef[TabMaxFus[Im]].Imotsuff].lgsuff;
					TabRef[TabMaxFus[Im]].lgmaxfussuf = TabRef[TabRef[TabMaxFus[Im]].Imotsuff].lgmaxfussuf;
					for(Ip = TabMaxFus[Im]; Ip < l; ++Ip)
					{
						if (TabRef[Ip].Imotsuff == l)
							TabRef[Ip].lgmaxfussuf = 0;
						/* On ne rattrape pas une fusion en prefixe
							qui modifie l'ordre */
						if (TabRef[Ip].Imotpref == l)
							TabRef[Ip].lgmaxfuspref = 0;
					}
					for(Ip = 0; Ip < nc; ++Ip)
					{
						if (TabRef[Ip].Imotpref > l)
							--TabRef[Ip].Imotpref;
						if (TabRef[Ip].Imotsuff > l)
							--TabRef[Ip].Imotsuff;
						if (TabOrdPref[Ip] > l)
							--TabOrdPref[Ip];
						if (TabOrdPref[Ip] == l)
							lpref = Ip;
						if (TabOrdSuff[Ip] > l)
							--TabOrdSuff[Ip];
						if (TabOrdSuff[Ip] == l)
							lsuf = Ip;
						if (TabOrdSuff[Ip] == TabMaxFus[Im])
							lrord = Ip;
					}
					for(Ip = lpref; Ip < nc - 1; ++Ip)
						TabOrdPref[Ip] = TabOrdPref[Ip + 1];
					for(Ip = lsuf; Ip < nc - 1; ++Ip)
						TabOrdSuff[Ip] = TabOrdSuff[Ip + 1];
					for(Ip = TabRef[TabMaxFus[Im]].Imotsuff; Ip < nc - 1; ++Ip)
						TabRef[Ip] = TabRef[Ip + 1];
					for(Ip = lrord; Ip < nc - 1; ++Ip)
						if (TabRef[TabOrdSuff[Ip]].lgsuff < TabRef[TabOrdSuff[Ip + 1]].lgsuff)
						{
							k = TabOrdSuff[Ip];
							TabOrdSuff[Ip] = TabOrdSuff[Ip + 1];
							TabOrdSuff[Ip + 1] = k;
						}
						else break;
					--nc;
					++econom;
				}
			}
		}
printf("Boucle: tour %d  nombre de fusion: %d longueur fusion: %d chaine: %d\n",tour,econom,M,la);
	}
	/* Le traitement est termine On ecrit la nouvelle super chaine dans le fichier prevu (2eme arg) */
	if ((fs = creat(argv[2],0666)) < 0)
	{
		printf("fichier resultat SuperChaine impossible a creer\n");
		exit(0);
	}
	/* On calcule la longueur de la nouvelle superchaine */
	ptsch = SuperChaine;
	ls = 0;
	while(*ptsch++ != '\0')
		++ls;
	/* On lui met un changement de ligne en fin */
	*(--ptsch) = '\n';
	/* On l'ecrit */
	write(fs,SuperChaine,++ls);
	close(fs);
	exit(0);
}