lm3jo Synthétiseur musical et vocal, une application sur le temps jo fixe a deux octets par front, un exemple d'étude sur un système à 2 dimensions.

La première dimension répond aux lois d'association des lettres, la deuxième dimension aux lois d'association des fronts de pressions acoustiques

joris Abadiejoris Abadie

Synthétiseur vocal et musical en mode graphique
synthétiseur musical
lm3jo synthé musical en mode graphique
Wiki du synthetiseur de voix, lecteur de texte au format abadie.jo

Téléchargement de AbadieJoueurDeVoix.deb

Téléchargement de Lm3jo.deb

Téléchargement de Lm3jo.deb version qt4 debian wheezy 32

Téléchargement de Lm7jo version gtk sources en construction

lm3jo et AbadieJoueurDeVoix se lancent en ligne de commande après installation des paquet en tapant leurs nom dans un terminal. il faut utiliser un paquet des deux, lm3jo pour les ordinateurs avec ressources, et l'autres pour ceux possédant moins de ressources. Banque de sons musicale et vocale


La page du projet sur LinuxMAO pour avoir une vue d'ensemble plus complète et aussi les autres projets audio sous linux
La page du projet présentant le cheminement des découvertes utilisées dans la BAUL


cursus.edu

Pour créer vos propres sons à l'aide des tableaux, attention les deux éléments utilisés sont de nature contraire,
c.f. la définition de la vinaigrette que j'ai donné, mais en plus, il y a aussi des portes à cet endroit.
En exemple pour telle forme de variation des souffles, nous faisons varier le son entendue que de telle à telle durée.
De même pour telle forme de variation de durée, la variation des souffles n'aura de l'influence que sous des formes restreinte.
En exemple, voir le son "O" que j'avais mis en ligne, je pouvais utiliser plusieurs souffles différents, sans changer le son entendu
car j'étais en dehors des limites de variations des souffles.
Les tableaux s'utilisent avec les souffles, les durées, le marteau, la licorne, le mariage, la vinaigrette, les portes, le triangle d'Aphrodite,
les définitions sont en ligne, elles représentent des formes particulières qui correspondent aux effets observés.

/*************************************debut du synthetiseur vocal****************************************/

/* Imaginer et creer par Abadie joris*/
/* en utilisant un concept de Andre pierre jocelyn*/
/*Cette oeuvre est protégée et n'est divulguée que pour utilisation sous linux dans les conditions Creative common ci-dessous*/
/* Cette oeuvre est mise à disposition selon les termes de la Licence Creative Commons Paternité - Pas d'Utilisation Commerciale - Partage des Conditions Initiales à l'Identique 2.0 France. */
/*Aucune garantie n'est donner sur les effets de cet executable*mais je peux dire qu'il fonctionne bien sur mes PC****/
/* pour compiler : gcc synthe.c -lm -o synthe -Wall*/
/**le concept de cet executable reprend la perception des sciences comme pouvaient l'avoir les Celtes ou la Grèce antique.*/
/* A savoir qu'ils avaient nommés chaque dimension du nom d'un Dieu ou d'une entité et que chaque dimension possédait son propre système mathématique, l'assemblage du tout n'était qu'une histoire d'équilibre ainsi chez les Celtes c'est l'environnement qui faisait que le même symbole désignait un nom, une action, ils n'accordaient aucun absolue aux termes respectant ainsi les lois des sciences.*/
 /* Je pense que l'erreur de ces deux derniers millénaires est de ne pas avoir su reconnaitre que les trois grandes activités de l'esprit ( Dieu, les sciences, l'art) ne répondaient pas aux mêmes lois et d'avoir voulu leurs accorder les mêmes lois , ces trois activités se complètent et se grandissent mais ne sont pas de même nature
Ce n'est qu'un sentiment personnel ou un rève, mais il existe deux grandes périodes historiques, la première c'est les trois premiers siècles du christianisme quand les femmes faisaient la messe et sont venues jusqu'à nos cotes aux Saintes-Maries-de-la-Mer (un système sociale qui plaçait chaque nouveau né comme l'avenir de l'humanité quelque soit ses parents ou son lieu de vie, il avait droit à l'eau pure, aux nutriments, au respect et à l'amour poussant par la même les sciences en reniant les titres). Et le deuxième quand les chercheurs du siècles des lumières ont travaillé à l'aide d'équivalences arrivant ainsi à traduire les états d'équilibres quand ceux-ci étaient très simples.*/


#include 
#include 
#include 
#include 
#include 
#include 
#define total 256
#define total1 256
#define total2 256
#define efface "joris.wav"
#define cecci21 "abadie.jo"
#define construit "tampon.jo"
#define ja1 "temps/a.jo"
#define ja2 "temps/b.jo"
#define ja3 "temps/c.jo"
#define ja4 "temps/d.jo"
#define ja5 "temps/e.jo"
#define ja6 "temps/f.jo"
#define ja7 "temps/g.jo"
#define ja8 "temps/h.jo"
#define ja9 "temps/i.jo"
#define ja10 "temps/j.jo"
#define ja11 "temps/k.jo"
#define ja12 "temps/l.jo"
#define ja13 "temps/m.jo"
#define ja14 "temps/n.jo"
#define ja15 "temps/o.jo"
#define ja16 "temps/p.jo"
#define ja17 "temps/q.jo"
#define ja18 "temps/r.jo"
#define ja19 "temps/s.jo"
#define ja20 "temps/t.jo"
#define ja21 "temps/u.jo"
#define ja22 "temps/v.jo"
#define ja23 "temps/w.jo"
#define ja24 "temps/x.jo"
#define ja25 "temps/y.jo"
#define ja26 "temps/z.jo"
#define ja27 "temps/espace.jo"
#define ja28 "temps/ai.jo"

int fonctionlecteur ();
int FonctionEntete ();
int fonctionconvertisseur ();
int fonctionidentification ();

/**********************************************************************************************************************************************/
long int longueurentete, nbdepoints, amplitudeentete, durerentete;
int sequence, sequence1, sequence2, actif, position, ausuivant, assemblage1, saitfait;
unsigned int calcultemps;

int fonctionlecteur()
{

/***	ausuivant = system("play joris.wav &");****/
/***	ausuivant = system("play joris.wav >resultat.txt");****/
	ausuivant = system("play joris.wav");
    printf("ausuivant est %d\n",ausuivant);
	return ausuivant;
}
/* attenton : ignoring return value of system declared with attribut warm_unused_result*/

int FonctionEntete(int argc, char *argv[])
{

int abadie = 0;
int assemble =0;
durerentete = 0;
longueurentete = 0;
int ouaitu;
int force1 = 1;
int filtreabadiejoris = 1;
int compte = 1;

/*j ouvre mon fichier de donner*/
FILE* fichierjoa1 = NULL;

unsigned char tab1[total1] =
{0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F,0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1A,0x1B,0x1C,0x1D,0x1E,0x1F,0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,0x2A,0x2B,0x2C,0x2D,0x2E,0x2F,0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x3A,0x3B,0x3C,0x3D,0x3E,0x3F,0x40,0x41,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4A,0x4B,0x4C,0x4D,0x4E,0x4F,0x50,0x51,0x52,0x53,0x54,0x55,0x56,0x57,0x58,0x59,0x5A,0x5B,0x5C,0x5D,0x5E,0x5F,0x60,0x61,0x62,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F,0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7A,0x7B,0x7C,0x7D,0x7E,0x7F,0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F,0xA0,0xA1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF,0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,
0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF,0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xEA,0xEB,0xEC,0xED,0xEE,0xEF,0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF};


fichierjoa1 = NULL;
  fichierjoa1 = fopen(construit, "rb");
  if(fichierjoa1 == NULL){
    printf("Ce fichier ne va pas %s\n",construit);
    exit(1);
  }


if (fichierjoa1 != NULL)
{

/************************************************************************************************************************************/
abadie = fgetc(fichierjoa1); /* abadie vient chercher tout ce qui bouge*/
while (abadie != EOF)
{  /*acco1*/

switch (filtreabadiejoris) {/*acco2*/
case 1 :
compte++;
if (compte >12)
{filtreabadiejoris =2;}
break;

default:

assemble++;
/***debut assemble***/

switch (assemble) {/*acco3*/

case 1 :
/***laisse*passer*amplitude***/
break;


default:
for (ouaitu=0; ouaitu<255; ouaitu++)
{
if ( abadie == tab1[ouaitu])
{
force1 = ouaitu;

}
}

nbdepoints = nbdepoints + (int)(force1);
assemble = 0;
} /***fin assemble***//*acco3*/
}/*acco2*/
abadie = fgetc(fichierjoa1); /* abadie va chercher la suivante*/
}/*acco1*/
fclose(fichierjoa1), fichierjoa1 = NULL;;
/****fin traitement bin******/


durerentete = nbdepoints ;

 calcultemps = ((unsigned int)durerentete )* 0.0441;
/*******************************************************************************************************************************************/

/*ici*je*commence*le*traitement*comme*jécris*chaque*base*de*temps*sur*deux*octets*je*multiplis*par*2*/

durerentete = durerentete*2;



longueurentete = durerentete + 56 - 8;

}

FILE* debutwav = NULL;
debutwav = fopen(efface, "wb+");
if (debutwav != NULL)
   {

/****declaration**type**audio*4octets**/


unsigned char riff[4] = {0x52,0x49,0x46,0x46};

fwrite(riff,1,sizeof(riff),debutwav);

/****longueurentete*du*fichier*audio*ici*21200**/


/*

unsigned char durerentetea[4] = {0x32,0x65,0x0B,0x01};

fwrite(durerentetea,1,sizeof(durerentetea),debutwav);

*/

fwrite( &longueurentete , sizeof(longueurentete) , 1 , debutwav);


/****declaration**type**wave*4octets**/

unsigned char wave[4] = {0x57,0x41,0x56,0x45};

fwrite(wave,1,sizeof(wave),debutwav);


/****declaration**type**fmt suivit d'un espace qui s'écrit 0x20 soit 4octets**/

unsigned char fmt[4] = {0x66,0x6D,0x74,0x20};

fwrite(fmt,1,sizeof(fmt),debutwav);

/****declaration**de*la*maniere d'écrire*sous forme*d'un*entier long (long int) soit 4octets**/
/**comme c'est du 16 octets en exadécimal cela donne 0x10****/

unsigned char poids[4] = {0x10,0x00,0x00,0x00};

fwrite(poids,1,sizeof(poids),debutwav);


/****codage pour indiquer le PCM c'est : 1 soit 2octets**/

unsigned char pourpcm[2] = {0x01,0x00};

fwrite(pourpcm,1,sizeof(pourpcm),debutwav);

/****nombre de piste sur 2octets*ici c'est du mono, donc 1*/

unsigned char piste[2] = {0x01,0x00};

fwrite(piste,1,sizeof(piste),debutwav);



/**nombre d'échantillons par seconde**sur 4 octets**/

unsigned char tempsunitaire[4] = {0x44,0xAC,0x00,0x00};

fwrite(tempsunitaire,1,sizeof(tempsunitaire),debutwav);

/**nombre d'octets par secondes**sur 4 octets***le*double*du*précédent*dans*ce*cas*/

unsigned char octetpars[4] = {0x88,0x58,0x01,0x00};

fwrite(octetpars,1,sizeof(octetpars),debutwav);


/*taille en octet d'1 échantillon***sur*2octets**/

unsigned char tailleechant[2] = {0x02,0x00};

fwrite(tailleechant,1,sizeof(tailleechant),debutwav);

/*contient le nombre de bits par échantillon*2x8=16*soit*10*en*exa**sur*2octets**/

unsigned char bitparechan[2] = {0x10,0x00};

fwrite(bitparechan,1,sizeof(bitparechan),debutwav);


/**On ecrit ici data pour dire que le fichier commence**sur 4cotets**/

unsigned char mono[4] =
{0x64,0x61,0x74,0x61};


fwrite(mono,1,sizeof(mono),debutwav);

/****longueurentete*du*fichier*audio**/

/*
unsigned char durerenteteb[4] = {0x0E,0x65,0x0B,0x01};

fwrite(durerenteteb,1,sizeof(durerenteteb),debutwav);
*/

fwrite( &durerentete , sizeof(durerentete) , 1 , debutwav);




fclose(debutwav), debutwav = NULL;;

   }
return 0;
}

/************fin*du createur**entete********************************************************************************/
/*********************************************************************************************************************************************/
int fonctionconvertisseur(int argc, char *argv[])

{

FonctionEntete(argc, argv);

/*j ouvre mon fichier de donner*/
FILE* jojo = NULL;

int abadie = 0;
int filtreabadiejoris = 2;
int compte = 1;


unsigned char tab1[total1] =
{0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F,0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1A,0x1B,0x1C,0x1D,0x1E,0x1F,0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,0x2A,0x2B,0x2C,0x2D,0x2E,0x2F,0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x3A,0x3B,0x3C,0x3D,0x3E,0x3F,0x40,0x41,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4A,0x4B,0x4C,0x4D,0x4E,0x4F,0x50,0x51,0x52,0x53,0x54,0x55,0x56,0x57,0x58,0x59,0x5A,0x5B,0x5C,0x5D,0x5E,0x5F,0x60,0x61,0x62,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F,0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7A,0x7B,0x7C,0x7D,0x7E,0x7F,0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F,0xA0,0xA1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF,0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,
0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF,0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xEA,0xEB,0xEC,0xED,0xEE,0xEF,0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF};




  jojo = fopen(construit, "rb");
  if(jojo == NULL){
    printf("Ce fichier ne va pas %s\n", construit);
    exit(1);
  }

if (jojo != NULL)
{

int assemble = 0;
int ludion = 32768;
int enclanche = 0;
int nbdepoints;

int ouaitu;
int amplitude = 32768;
int force1 = 0;
int joencour;
float jo;

abadie = fgetc(jojo); /* abadie vient chercher tout ce qui bouge*/
while (abadie != EOF)
{

switch (filtreabadiejoris) {
case 1 :
compte++;
if (compte >12)
{filtreabadiejoris =2;}
break;

default:

for (ouaitu=0; ouaitu<255; ouaitu++)
{
if ( abadie == tab1[ouaitu])
{
force1 = ouaitu;
assemble++;
}
}
/***debut assemble***/

switch (assemble) {

case 1 :
amplitude = (force1 * 256);

/****************************traitement*amplitude****/

break;

default:
nbdepoints = force1;


/****fin traitement bin******/
joencour = 17;
float okioki ;
float okioki1 ;
okioki = (float)(nbdepoints);
okioki1 = (float)(joencour);

jo = (okioki * okioki1 * (0.01));


if (jo < 2){ jo = 1; }
int sens;
if (ludion > amplitude) { sens = 2; }
else { sens = 1; }

/***fin conversion***/
double codebash;

FILE* temps = NULL;

char tab[total] = {0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F,0xA0,0xA1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF,0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF,0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xEA,0xEB,0xEC,0xED,0xEE,0xEF,0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF,0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F,0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1A,0x1B,0x1C,0x1D,0x1E,0x1F,0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,0x2A,0x2B,0x2C,0x2D,0x2E,0x2F,0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x3A,0x3B,0x3C,0x3D,0x3E,0x3F,0x40,0x41,0x42,0x43,0x44,0x45,0x46,0x47,0x48,
0x49,0x4A,0x4B,0x4C,0x4D,0x4E,0x4F,0x50,0x51,0x52,0x53,0x54,0x55,0x56,0x57,0x58,0x59,0x5A,0x5B,0x5C,0x5D,0x5E,0x5F,0x60,0x61,0x62,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F,0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7A,0x7B,0x7C,0x7D,0x7E,0x7F};



char *ptr;
char *petr;


temps = fopen(efface, "ab"); /* pour ajouter a. possible w ou r+ w+ tester */

if (temps != NULL)

{





/*******/

if(sens == 2)

/*ajouter dessous*/
{


if ( nbdepoints < 2)
{
codebash = (int)(amplitude);



int ji;
int ij;
int ola;
ola = (int)codebash;

/*ji = ola%256;*/
ij = (int)(ola*0.00390625);
ji = ola - (256*ij);

ptr = &tab[ji];
petr = &tab[ij];


fwrite( ptr, sizeof(char), 1, temps);
fwrite( petr, sizeof(char), 1, temps);


}



else
{


 float ote, ote1;
int boucle;
boucle = nbdepoints * 0.5;

int reste;
reste = nbdepoints - boucle;

ote = (ludion - amplitude) * 0.5;




while ( boucle > 0)





{
ote1 = ote * ( 1 - exp (-boucle/jo));

/*
fprintf(temps,"%d ", (int)codebash );
*/


codebash = (int)( amplitude + ote + ote1);


int ji;
int ij;
int ola;
ola = (int)codebash;

/*ji = ola%256;*/
ij = (int)(ola*0.00390625);
ji = ola - (256*ij);

ptr = &tab[ji];
petr = &tab[ij];


fwrite( ptr, sizeof(char), 1, temps);
fwrite( petr, sizeof(char), 1, temps);





/*fin modif*/
boucle--;

}


enclanche = 2; /*** deuxieme enclanche du sens 2**********/

if ( enclanche == 2)
{




 float ote, ote1;

ote = (ludion - amplitude) * 0.5;



int boucle1 = 1;
while (boucle1 < reste + 1)
{

ote1 = ote * ( 1 - exp (-boucle1/jo));




codebash = (int) ( ludion - ote -ote1);


int ji;
int ij;
int ola;
ola = (int)codebash;

/*ji = ola%256;*/
ij = (int)(ola*0.00390625);
ji = ola - (256*ij);

ptr = &tab[ji];
petr = &tab[ij];


fwrite( ptr, sizeof(char), 1, temps);
fwrite( petr, sizeof(char), 1, temps);






/*fin modif*/

boucle1++;

}



enclanche = 0;




/* fin descente 2*/


}
}

}


/*en attente*/

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

if(sens == 1)
{
if ( nbdepoints < 2)
{
codebash = (int)(amplitude);



int ji;
int ij;
int ola;
ola = (int)codebash;

/*ji = ola%256;*/
ij = (int)(ola*0.00390625);
ji = ola - (256*ij);

ptr = &tab[ji];
petr = &tab[ij];


fwrite( ptr, sizeof(char), 1, temps);
fwrite( petr, sizeof(char), 1, temps);


}


else
{


 float ote, ote1;



int boucle;
boucle = nbdepoints * 0.5;
int ajuste;
ajuste = nbdepoints - boucle;

if ( boucle == 0)
{
boucle = 1;
}


ote = ( amplitude - ludion ) * 0.5;




while ( boucle > 0)
{

ote1 = ote * ( 1 - exp (-boucle/jo));

codebash = amplitude - ote - ote1;
/*
fprintf(temps,"%d ", (int)codebash );
*/



codebash = (int)(amplitude - ote - ote1);



int ji;
int ij;
int ola;
ola = (int)codebash;

/*ji = ola%256;*/
ij = (int)(ola*0.00390625);
ji = ola - (256*ij);

ptr = &tab[ji];
petr = &tab[ij];


fwrite( ptr, sizeof(char), 1, temps);
fwrite( petr, sizeof(char), 1, temps);


/*fin modif*/
boucle--;

}

enclanche = 1;
/* debut descente inverse du sens 1 */
if (enclanche == 1)

{


 float ote, ote1;
int boucle, boncompte;
boucle = 1;

ote = ( amplitude - ludion ) * 0.5;
boncompte = ajuste;
if (boncompte == 0)
{
boncompte = 1;
}


while (boucle < (boncompte+1))


{
ote1 = ote * ( 1 - exp (-boucle/jo));




codebash = (int) (ludion + ote + ote1);


int ji;
int ij;
int ola;
ola = (int)codebash;

/*ji = ola%256;*/
ij = (int)(ola*0.00390625);
ji = ola - (256*ij);

ptr = &tab[ji];
petr = &tab[ij];


fwrite( ptr, sizeof(char), 1, temps);
fwrite( petr, sizeof(char), 1, temps);






/*fin modif*/
boucle++;
}


enclanche = 0;

}

}


}


/* fin*/






/********/


/*****/



fclose(temps), temps = NULL;;
}
ludion = amplitude;

/*pas*toucher*/
assemble = 0;
} /***fin assemble***/
}
abadie = fgetc(jojo); /* abadie va chercher la suivante*/
}
fclose(jojo), jojo = NULL;;


}






	ausuivant = fonctionlecteur();
	if (ausuivant == EOF);

return 0;
}

/************************fin fonction conversion***********************************************************************************************************/

/*
fonction identification
C'est ici que nous essayons de créer un lien entre le système mathématique de la dimension des lettres et du système
mathématique de la dimension des fronts acoustiques, j'utilise des boucles goto pour lier les points d'équilibres.
*/
#define total3 30
int vacherchergotodehorsswitch;
int fonctionidentification(int argc, char *argv[], int quicou)
{  /**acco 1**/
	
	saitfait = 2;
	int abadie=0;
	char regle[1];


	int quiaitu[total3] = {97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,32,46,36};

	int debut = 0;
	int fin = 29;
	assemblage1 = 0;

    for (debut = 0; debut < fin; debut++) {
	if (quicou == quiaitu[debut]) {
	assemblage1 = debut;}
    }
    printf("indique-pos %d\n",assemblage1);
/**reprise du traitement des données pour concaténation *avec gestion des cas de position*/

FILE* fichierjo1 = NULL;
FILE* fichiertampon1 = NULL;
/************/


remonteswitch : /*label point de retour des dérivés de premier ordre, de deuxième ordre, de ... fonction goto*/
vacherchergotodehorsswitch = 1;


switch (actif) {/* debut switch (actif)*/
case 1 :
actif = 1;
	switch (assemblage1) {/* debut switch (assemblage1)*/ /**acco 3**/

	case 0 :  /*lettre a et ses sons dérivés de premier ordre*/
	actif = 8;
	break;/**fin lettre a*/
/***************************************************************************************************************************/
	case 1 : /*lettre b */	
		fichierjo1 = NULL;
  		fichierjo1 = fopen(ja2, "rb");
  		if(fichierjo1 == NULL){
    		printf("Ce fichier ne va pas %s\n",ja2);
    		exit(1);
		}
  		fichiertampon1 = fopen(construit, "ab");
  		if(fichiertampon1 == NULL){
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		}
		if (fichierjo1 != NULL)	{
		if (fichiertampon1 != NULL){
		abadie = fgetc(fichierjo1);
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL;
	break;/*fin lettre b  */
/***************************************************************************************************************************/	
	case 2 :  /*lettre c  et ses sons dérivés*/
	actif = 3;
	break;/**fin lettre c*/
/***************************************************************************************************************************/
	case 3 : /*lettre d */	
		fichierjo1 = NULL;
  		fichierjo1 = fopen(ja4, "rb");
  		if(fichierjo1 == NULL){
    		printf("Ce fichier ne va pas %s\n",ja4);
    		exit(1);
		}
  		fichiertampon1 = fopen(construit, "ab");
  		if(fichiertampon1 == NULL){
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		}
		if (fichierjo1 != NULL)	{
		if (fichiertampon1 != NULL){
		abadie = fgetc(fichierjo1);
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL;
	break;/*fin lettre d  */
/***************************************************************************************************************************/
	case 4 :  /*lettre e et ses sons dérivés de premier ordre*/
	actif = 20;
	break;/**fin lettre e*/
/***************************************************************************************************************************/
	case 5 : /*lettre f  */			
		fichierjo1 = NULL;
  		fichierjo1 = fopen(ja6, "rb");
  		if(fichierjo1 == NULL){
    		printf("Ce fichier ne va pas %s\n",ja6);
    		exit(1);
		}
  		fichiertampon1 = fopen(construit, "ab");
  		if(fichiertampon1 == NULL){
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		}
		if (fichierjo1 != NULL)	{
		if (fichiertampon1 != NULL){
		abadie = fgetc(fichierjo1);
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL;
	break;/*fin lettre f  */
/***************************************************************************************************************************/
	case 6 : /*lettre g et ses sons dérivés de premier ordre*/
	actif = 7;
	break;/**fin lettre g*/
/***************************************************************************************************************************/
	case 7 : /*lettre h  */
		fichierjo1 = NULL;
  		fichierjo1 = fopen(ja8, "rb");
  		if(fichierjo1 == NULL){
    		printf("Ce fichier ne va pas %s\n",ja8);
    		exit(1);
		}
  		fichiertampon1 = fopen(construit, "ab");
  		if(fichiertampon1 == NULL){
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		}
		if (fichierjo1 != NULL)	{
		if (fichiertampon1 != NULL){
		abadie = fgetc(fichierjo1);
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL;
	break;/*fin lettre h  */
/***************************************************************************************************************************/
	case 8 : /*lettre i et ses sons dérivés de premier ordre*/
	actif = 12;
	break;/**fin lettre i */			
/***************************************************************************************************************************/
	case 9 : /*lettre j  */
		fichierjo1 = NULL;
  		fichierjo1 = fopen(ja10, "rb");
  		if(fichierjo1 == NULL){
    		printf("Ce fichier ne va pas %s\n",ja10);
    		exit(1);
		}
  		fichiertampon1 = fopen(construit, "ab");
  		if(fichiertampon1 == NULL){
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		}
		if (fichierjo1 != NULL)	{
		if (fichiertampon1 != NULL){
		abadie = fgetc(fichierjo1);
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL;
	break;/*fin lettre j  */
/***************************************************************************************************************************/
	case 10 : /*lettre k  */
		fichierjo1 = NULL;
  		fichierjo1 = fopen(ja11, "rb");
  		if(fichierjo1 == NULL){
    		printf("Ce fichier ne va pas %s\n",ja11);
    		exit(1);
		}
  		fichiertampon1 = fopen(construit, "ab");
  		if(fichiertampon1 == NULL){
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		}
		if (fichierjo1 != NULL)	{
		if (fichiertampon1 != NULL){
		abadie = fgetc(fichierjo1);
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL;
	break;/*fin lettre k  */
/***************************************************************************************************************************/
	case 11 : /*lettre l  */
		fichierjo1 = NULL;
  		fichierjo1 = fopen(ja12, "rb");
  		if(fichierjo1 == NULL){
    		printf("Ce fichier ne va pas %s\n",ja12);
    		exit(1);
		}
  		fichiertampon1 = fopen(construit, "ab");
  		if(fichiertampon1 == NULL){
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		}
		if (fichierjo1 != NULL)	{
		if (fichiertampon1 != NULL){
		abadie = fgetc(fichierjo1);
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL;
	break;/*fin lettre l  */
/***************************************************************************************************************************/
	case 12 : /*lettre m  */
		fichierjo1 = NULL;
  		fichierjo1 = fopen(ja13, "rb");
  		if(fichierjo1 == NULL){
    		printf("Ce fichier ne va pas %s\n",ja13);
    		exit(1);
		}
  		fichiertampon1 = fopen(construit, "ab");
  		if(fichiertampon1 == NULL){
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		}
		if (fichierjo1 != NULL)	{
		if (fichiertampon1 != NULL){
		abadie = fgetc(fichierjo1);
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL; 
	break;/*fin lettre m  */
/***************************************************************************************************************************/
	case 13 : /*lettre n  */
		fichierjo1 = NULL;
  		fichierjo1 = fopen(ja14, "rb");
  		if(fichierjo1 == NULL){
    		printf("Ce fichier ne va pas %s\n",ja14);
    		exit(1);
		}
  		fichiertampon1 = fopen(construit, "ab");
  		if(fichiertampon1 == NULL){
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		}
		if (fichierjo1 != NULL)	{
		if (fichiertampon1 != NULL){
		abadie = fgetc(fichierjo1);
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL;
	break;/*fin lettre n  */
/***************************************************************************************************************************/
		case 14 : /**debut lettre o*/
		actif = 2;
		break;/**fin lettre o*/
/***************************************************************************************************************************/
	case 15 : /*lettre p  */	
		fichierjo1 = NULL;
  		fichierjo1 = fopen(ja16, "rb");
  		if(fichierjo1 == NULL){
    		printf("Ce fichier ne va pas %s\n",ja16);
    		exit(1);
		}
  		fichiertampon1 = fopen(construit, "ab");
  		if(fichiertampon1 == NULL){
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		}
		if (fichierjo1 != NULL)	{
		if (fichiertampon1 != NULL){
		abadie = fgetc(fichierjo1);
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL;
	break;/*fin lettre p  */
/***************************************************************************************************************************/
	case 16 : /*lettre q et ses sons dérivés de premier ordre*/

		fichierjo1 = NULL;
  		fichierjo1 = fopen(ja11, "rb"); 
  		if(fichierjo1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n",ja11);
    		exit(1);
		}
  		fichiertampon1 = fopen(construit, "ab"); 
  		if(fichiertampon1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		} 
		if (fichierjo1 != NULL)
		{
		if (fichiertampon1 != NULL)
		{
		abadie = fgetc(fichierjo1); 
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL; 
	actif = 4;
	break;/**fin lettre q*/
/***************************************************************************************************************************/
	case 17 : /*lettre r  */
		fichierjo1 = NULL;
  		fichierjo1 = fopen(ja18, "rb");
  		if(fichierjo1 == NULL){
    		printf("Ce fichier ne va pas %s\n",ja18);
    		exit(1);
		}
  		fichiertampon1 = fopen(construit, "ab");
  		if(fichiertampon1 == NULL){
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		}
		if (fichierjo1 != NULL)	{
		if (fichiertampon1 != NULL){
		abadie = fgetc(fichierjo1);
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL;
	break;/*fin lettre r  */
/***************************************************************************************************************************/
	case 18 : /*lettre s  */

	actif = 26;

	break;/*fin lettre s  */
/**************************************************************************************************************/
	case 19 : /*lettre t  */

	actif = 25;

	break;/*fin lettre t  */
/*****************************************************************************************************************/
	case 20 : /*lettre u et ses sons dérivés de deuxième ordre*/
	actif = 10;
	break;/**fin lettre u */

/***************************************************************************************************************************/
	case 21 : /*lettre v  */
		fichierjo1 = NULL;
  		fichierjo1 = fopen(ja22, "rb");
  		if(fichierjo1 == NULL){
    		printf("Ce fichier ne va pas %s\n",ja22);
    		exit(1);
		}
  		fichiertampon1 = fopen(construit, "ab");
  		if(fichiertampon1 == NULL){
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		}
		if (fichierjo1 != NULL)	{
		if (fichiertampon1 != NULL){
		abadie = fgetc(fichierjo1);
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL;
	break;/*fin lettre v  */
/***************************************************************************************************************************/
	case 22 : /*lettre w  */			
		fichierjo1 = NULL;
  		fichierjo1 = fopen(ja23, "rb");
  		if(fichierjo1 == NULL){
    		printf("Ce fichier ne va pas %s\n",ja23);
    		exit(1);
		}
  		fichiertampon1 = fopen(construit, "ab");
  		if(fichiertampon1 == NULL){
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		}
		if (fichierjo1 != NULL)	{
		if (fichiertampon1 != NULL){
		abadie = fgetc(fichierjo1);
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL;
	break;/*fin lettre w  */
/***************************************************************************************************************************/
	case 23 : /*lettre x  */			
		fichierjo1 = NULL;
  		fichierjo1 = fopen(ja24, "rb");
  		if(fichierjo1 == NULL){
    		printf("Ce fichier ne va pas %s\n",ja24);
    		exit(1);
		}
  		fichiertampon1 = fopen(construit, "ab");
  		if(fichiertampon1 == NULL){
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		}
		if (fichierjo1 != NULL)	{
		if (fichiertampon1 != NULL){
		abadie = fgetc(fichierjo1);
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL;
	break;/*fin lettre x  */
/***************************************************************************************************************************/
	case 24 : /*lettre y */
		fichierjo1 = NULL;
  		fichierjo1 = fopen(ja25, "rb");
  		if(fichierjo1 == NULL){
    		printf("Ce fichier ne va pas %s\n",ja25);
    		exit(1);
		}
  		fichiertampon1 = fopen(construit, "ab");
  		if(fichiertampon1 == NULL){
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		}
		if (fichierjo1 != NULL)	{
		if (fichiertampon1 != NULL){
		abadie = fgetc(fichierjo1);
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL;
	break;/*fin lettre y  */
/***************************************************************************************************************************/
	case 25 : /*lettre z  */
		fichierjo1 = NULL;
  		fichierjo1 = fopen(ja26, "rb");
  		if(fichierjo1 == NULL){
    		printf("Ce fichier ne va pas %s\n",ja26);
    		exit(1);
		}
  		fichiertampon1 = fopen(construit, "ab");
  		if(fichiertampon1 == NULL){
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		}
		if (fichierjo1 != NULL)	{
		if (fichiertampon1 != NULL){
		abadie = fgetc(fichierjo1);
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL;
	break;/*fin lettre z  */
/***************************************************************************************************************************/
	case 26 : /**debut espace*/
	case 27 :/**debut point traité comme un espace*/
		fichierjo1 = NULL;
  		fichierjo1 = fopen(ja27, "rb");
  		if(fichierjo1 == NULL){
    		printf("Ce fichier ne va pas %s\n",ja27);
    		exit(1);
		}
  		fichiertampon1 = fopen(construit, "ab");
  		if(fichiertampon1 == NULL){
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		}
		if (fichierjo1 != NULL)	{
		if (fichiertampon1 != NULL){
		abadie = fgetc(fichierjo1);
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL;

		actif = 1;
	fonctionconvertisseur(argc,argv);/*je lance la lecture*audio du fichier tampon.jo*/

/***********nettoyage fichier tampon******/
		FILE* fichiertampon1 = NULL;
  		fichiertampon1 = fopen(construit, "wb");
  		if(fichiertampon1 == NULL){
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		}
		if (fichiertampon1 != NULL){
		char commence[3] = {0x80,0x02};
		char *ave1;
		char *ave2;
		ave1 = &commence[0];
		ave2 = &commence[1];
	    fwrite( ave1, sizeof(unsigned char), 1, fichiertampon1);
	    fwrite( ave2, sizeof(unsigned char), 1, fichiertampon1);
		}

		fclose(fichiertampon1), fichiertampon1 = NULL;;

/***fin du nettoyage fichier tampon*/


	break;/*fin point et espace */
/***************************************************************************************************************************/
	case 28 : /**debut é traité comme $*/
		fichierjo1 = NULL;
  		fichierjo1 = fopen(ja28, "rb");
  		if(fichierjo1 == NULL){
    		printf("Ce fichier ne va pas %s\n",ja28);
    		exit(1);
		}
  		fichiertampon1 = fopen(construit, "ab");
  		if(fichiertampon1 == NULL){
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		}
		if (fichierjo1 != NULL)	{
		if (fichiertampon1 != NULL){
		abadie = fgetc(fichierjo1);
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL;
	break;/***sortie*****switch assemblage1*****/
/***************************************************************************************************************************/
	default :/****pas de son a écrire cas son qu*********/
	printf("rien a ecrire %s\n","son-u");
	} /*fin switch assemblage1*/

break;/***sortie*****switch actif 1*****/
/***************************************************************************************************************************/
/***************************************************************************************************************************/


case 2 :/********switch actif 2 études des dérivées de premier ordre des sons o  *******************************************/
actif = 1;
	switch (assemblage1) {

	case 8 :   /**son oi***/
		fichierjo1 = NULL;
  		fichierjo1 = fopen("temps/oi.jo", "rb"); 
  		if(fichierjo1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n","temps/oi.jo");
    		exit(1);
		}
  		fichiertampon1 = fopen(construit, "ab"); 
  		if(fichiertampon1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		} 
		if (fichierjo1 != NULL)
		{
		if (fichiertampon1 != NULL)
		{
		abadie = fgetc(fichierjo1); 
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL; 
		actif = 1;
	break;/****fin son  oi ****/
/***************************************************************************************************************************/
	case 13 :/*** son on *******/
		fichierjo1 = NULL;
		fichierjo1 = fopen("temps/on.jo", "rb"); 
		if(fichierjo1 == NULL){ 
		printf("Ce fichier ne va pas %s\n","temps/on.jo");
		exit(1);
		}
		fichiertampon1 = fopen(construit, "ab"); 
		if(fichiertampon1 == NULL){ 
		printf("Ce fichier ne va pas %s\n",construit);
		exit(1);
		} 
		if (fichierjo1 != NULL) {
		if (fichiertampon1 != NULL) {
		abadie = fgetc(fichierjo1); 
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL; 
		actif = 1;
	break;/******* fin son on  ****************/
/***************************************************************************************************************************/
	case 20 :/***debut son ou*****/
		fichierjo1 = NULL;
  		fichierjo1 = fopen("temps/ou.jo", "rb"); 
  		if(fichierjo1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n","temps/ou.jo");
    		exit(1);
		}
  		fichiertampon1 = fopen(construit, "ab"); 
  		if(fichiertampon1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		} 
		if (fichierjo1 != NULL){
		if (fichiertampon1 != NULL){
		abadie = fgetc(fichierjo1); 
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL; 
		actif = 1;
	break;/******* fin son ou  ****************/
/***************************************************************************************************************************/
	default :/****son o seul***pas de dérivée**retour au point d'ancrage*********/
		fichierjo1 = NULL;
  		fichierjo1 = fopen("temps/o.jo", "rb"); 
  		if(fichierjo1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n","temps/o.jo");
    		exit(1);
		}
  		fichiertampon1 = fopen(construit, "ab"); 
  		if(fichiertampon1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		} 
		if (fichierjo1 != NULL)
		{
		if (fichiertampon1 != NULL)
		{
		abadie = fgetc(fichierjo1); 
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL;
		actif = 1;
		 vacherchergotodehorsswitch = 3;

	}/* fin switch (assemblage1)*/


break;/******************************************bloc  fin derivé du son o *****fin actif 2***********/

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

case 3 :/********switch actif 3 developpement des son c  ***********************************/
actif = 1;
	switch (assemblage1) {


	case 4 :/***debut son ce*****/
	case 8 :/*** son ci *******/
		fichierjo1 = NULL;
  		fichierjo1 = fopen("temps/s.jo", "rb"); 
  		if(fichierjo1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n","temps/s.jo");
    		exit(1);
		}
  		fichiertampon1 = fopen(construit, "ab"); 
  		if(fichiertampon1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		} 
		if (fichierjo1 != NULL){
		if (fichiertampon1 != NULL){
		abadie = fgetc(fichierjo1); 
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL; 
		actif = 1;
		 vacherchergotodehorsswitch = 3;
	break;/******* fin son se  ****************/
/***************************************************************************************************************************/
	case 7 :   /**son ch***/
		fichierjo1 = NULL;
  		fichierjo1 = fopen("temps/ch.jo", "rb"); 
  		if(fichierjo1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n","temps/ch.jo");
    		exit(1);
		}
  		fichiertampon1 = fopen(construit, "ab"); 
  		if(fichiertampon1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		} 
		if (fichierjo1 != NULL)
		{
		if (fichiertampon1 != NULL)
		{
		abadie = fgetc(fichierjo1); 
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL; 
		actif = 1;
	break;/****fin son ch ****/
/***************************************************************************************************************************/

	default :/****son c seul****************/
		fichierjo1 = NULL;
  		fichierjo1 = fopen(ja3, "rb"); 
  		if(fichierjo1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n",ja3);
    		exit(1);
		}
  		fichiertampon1 = fopen(construit, "ab"); 
  		if(fichiertampon1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		} 
		if (fichierjo1 != NULL)
		{
		if (fichiertampon1 != NULL)
		{
		abadie = fgetc(fichierjo1); 
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL; 

		actif = 1;
		 vacherchergotodehorsswitch = 3;
	}/* fin switch (assemblage1)*/


break;/******************************************bloc  fin derivé du son c ****************************/
/***************************************************************************************************************************/
/***************************************************************************************************************************/

case 4 :/********switch actif 4 dérivée de premier ordre du son  q  ******************************************/
actif = 1;

/*case vide pour effacer u*/

break;

/******************************************  fin derivé du son q ****************************/
/***************************************************************************************************************************/
/***************************************************************************************************************************/


case 7 :/********switch actif 7 dérivée de premier ordre des son g  ************************/
actif = 1;
	switch (assemblage1) {


	case 4 :/***debut son ge gi****/
	case 8 :

		fichierjo1 = NULL;
  		fichierjo1 = fopen(ja10, "rb"); 
  		if(fichierjo1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n",ja10);
    		exit(1);
		}
  		fichiertampon1 = fopen(construit, "ab"); 
  		if(fichiertampon1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		} 
		if (fichierjo1 != NULL)
		{
		if (fichiertampon1 != NULL)
		{
		abadie = fgetc(fichierjo1); 
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL; 
		actif = 1;
		 vacherchergotodehorsswitch = 3;
	break;/******* fin son ge gi  ****************/
/***************************************************************************************************************************/
	default :/****son g seul*********************/
		fichierjo1 = NULL;
  		fichierjo1 = fopen(ja7, "rb"); 
  		if(fichierjo1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n",ja6);
    		exit(1);
		}
  		fichiertampon1 = fopen(construit, "ab"); 
  		if(fichiertampon1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		} 
		if (fichierjo1 != NULL)
		{
		if (fichiertampon1 != NULL)
		{
		abadie = fgetc(fichierjo1); 
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL; 
		actif = 1;
		 vacherchergotodehorsswitch = 3;
	}/* fin switch (assemblage1)*/

break;/****************fin actif 7******bloc  fin derivé du son g ****************************/
/***************************************************************************************************************************/
/***************************************************************************************************************************/
case 8 :/********switch actif 6 dérivés du premier ordre du son a  **************************/
actif = 1;
	switch (assemblage1) {

	case 8 :   /**son ai***/

		fichierjo1 = NULL;
  		fichierjo1 = fopen("temps/ai.jo", "rb"); 
  		if(fichierjo1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n","temps/ai.jo");
    		exit(1);
		}
  		fichiertampon1 = fopen(construit, "ab"); 
  		if(fichiertampon1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		} 
		if (fichierjo1 != NULL)
		{
		if (fichiertampon1 != NULL)
		{
		abadie = fgetc(fichierjo1); 
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL; 
		actif = 1;

	break;/****fin son  ai ****/
/***************************************************************************************************************************/

	case 13 :/***debut son an  vers dérivée d'ordre 2****/
	actif = 9;
	break;/**fin de la dérivée première lettres an*/
/***************************************************************************************************************************/

	case 20 :/***debut son au*****/

		fichierjo1 = NULL;
  		fichierjo1 = fopen(ja15, "rb"); 
  		if(fichierjo1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n",ja15);
    		exit(1);
		}
  		fichiertampon1 = fopen(construit, "ab"); 
  		if(fichiertampon1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		} 
		if (fichierjo1 != NULL){
		if (fichiertampon1 != NULL){
		abadie = fgetc(fichierjo1); 
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL; 
		actif = 1;

	break;/******* fin son au  ****************/
/***************************************************************************************************************************/
	default :/****son a seul*********************/
		fichierjo1 = NULL;
  		fichierjo1 = fopen(ja1, "rb"); 
  		if(fichierjo1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n",ja1);
    		exit(1);
		}
  		fichiertampon1 = fopen(construit, "ab"); 
  		if(fichiertampon1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		} 
		if (fichierjo1 != NULL)
		{
		if (fichiertampon1 != NULL)
		{
		abadie = fgetc(fichierjo1); 
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL; 
		actif = 1;
		 vacherchergotodehorsswitch = 3;

	}/* fin switch (assemblage1)*/

break;/******************************************bloc  fin derivé du son a ****************************/
/***************************************************************************************************************************/
/***************************************************************************************************************************/
case 9 :/********switch actif 9 dérivée de deuxième ordre des sons an  ************************/
actif = 1;
	switch (assemblage1) {


	case 3  :/***and****/
	actif = 15;

	break;/******* fin son and  ****************/

/***************************************************************************************************************************/
	case 18 :/***ans****/
	actif = 16;

	break;/******* fin son ans  ****************/
/***************************************************************************************************************************/

	case 19 :/***ant****/
	actif = 14;

	break;/******* fin son ant  ****************/
/***************************************************************************************************************************/

	case 26 : /**  an avec espace*/
	case 27 :/**an. avec point traité comme un espace*/
		fichierjo1 = NULL;
  		fichierjo1 = fopen("temps/en.jo", "rb"); 
  		if(fichierjo1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n","temps/en.jo");
    		exit(1);
		}
  		fichiertampon1 = fopen(construit, "ab"); 
  		if(fichiertampon1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		} 
		if (fichierjo1 != NULL)
		{
		if (fichiertampon1 != NULL)
		{
		abadie = fgetc(fichierjo1); 
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL; 
/*********************************************************************/
		fichierjo1 = NULL;
  		fichierjo1 = fopen(ja27, "rb");
  		if(fichierjo1 == NULL){
    		printf("Ce fichier ne va pas %s\n",ja27);
    		exit(1);
		}
  		fichiertampon1 = fopen(construit, "ab");
  		if(fichiertampon1 == NULL){
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		}
		if (fichierjo1 != NULL)	{
		if (fichiertampon1 != NULL){
		abadie = fgetc(fichierjo1);
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL;

		actif = 1;
	fonctionconvertisseur(argc,argv);/*je lance la lecture*audio du fichier tampon.jo*/

/***********nettoyage fichier tampon******/
		FILE* fichiertampon1 = NULL;
  		fichiertampon1 = fopen(construit, "wb");
  		if(fichiertampon1 == NULL){
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		}
		if (fichiertampon1 != NULL){
		char commence[3] = {0x80,0x02};
		char *ave1;
		char *ave2;
		ave1 = &commence[0];
		ave2 = &commence[1];
	    fwrite( ave1, sizeof(unsigned char), 1, fichiertampon1);
	    fwrite( ave2, sizeof(unsigned char), 1, fichiertampon1);
		}

		fclose(fichiertampon1), fichiertampon1 = NULL;;

/***fin du nettoyage fichier tampon*/




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



	break;/******* fin son an  ****************/
/***************************************************************************************************************************/
	default :/****son a+n seul*********************/
		fichierjo1 = NULL;
  		fichierjo1 = fopen(ja1, "rb"); 
  		if(fichierjo1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n",ja1);
    		exit(1);
		}
  		fichiertampon1 = fopen(construit, "ab"); 
  		if(fichiertampon1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		} 
		if (fichierjo1 != NULL)
		{
		if (fichiertampon1 != NULL)
		{
		abadie = fgetc(fichierjo1); 
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL; 
		fichierjo1 = NULL;
  		fichierjo1 = fopen(ja14, "rb"); 
  		if(fichierjo1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n",ja14);
    		exit(1);
		}
  		fichiertampon1 = fopen(construit, "ab"); 
  		if(fichiertampon1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		} 
		if (fichierjo1 != NULL)
		{
		if (fichiertampon1 != NULL)
		{
		abadie = fgetc(fichierjo1); 
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL; 
		 vacherchergotodehorsswitch = 3;

	}/* fin switch (assemblage1)*/

break;/******************************************bloc  fin derivé du son an ****************************/
/***************************************************************************************************************************/
/***************************************************************************************************************************/
case 10 :/********switch actif 10 dérivée de deuxième ordre du son  u un  ******************************************/
actif = 1;
	switch (assemblage1) {

	case 13 :/***debut son un  vers eau dérivée d'ordre 2****/
	actif = 11;
	break;/**fin de la dérivée première lettres un*/

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

	default : 

		fichierjo1 = NULL;
  		fichierjo1 = fopen(ja21, "rb"); 
  		if(fichierjo1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n",ja21);
    		exit(1);
		}
  		fichiertampon1 = fopen(construit, "ab"); 
  		if(fichiertampon1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		} 
		if (fichierjo1 != NULL)
		{
		if (fichiertampon1 != NULL)
		{
		abadie = fgetc(fichierjo1); 
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL; 
		actif = 1;
		 vacherchergotodehorsswitch = 3;
	}
break;

/*****************************  fin actif 10 dérivée de deuxième ordre du son u ****************************/
/***************************************************************************************************************************/
/***************************************************************************************************************************/
case 11 :/********switch actif 11 dérivée de deuxième ordre du son  u un  ******************************************/
actif = 1;
	switch (assemblage1) {

	case 26 :/***debut son un  vers eau dérivée d'ordre 2****/
	case 27 :
		fichierjo1 = NULL;
  		fichierjo1 = fopen("temps/un.jo", "rb"); 
  		if(fichierjo1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n","temps/un.jo");
    		exit(1);
		}
  		fichiertampon1 = fopen(construit, "ab"); 
  		if(fichiertampon1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		} 
		if (fichierjo1 != NULL){
		if (fichiertampon1 != NULL){
		abadie = fgetc(fichierjo1); 
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL; 

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

		fichierjo1 = NULL;
  		fichierjo1 = fopen(ja27, "rb");
  		if(fichierjo1 == NULL){
    		printf("Ce fichier ne va pas %s\n",ja27);
    		exit(1);
		}
  		fichiertampon1 = fopen(construit, "ab");
  		if(fichiertampon1 == NULL){
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		}
		if (fichierjo1 != NULL)	{
		if (fichiertampon1 != NULL){
		abadie = fgetc(fichierjo1);
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL;

		actif = 1;
	fonctionconvertisseur(argc,argv);/*je lance la lecture*audio du fichier tampon.jo*/

/***********nettoyage fichier tampon******/
		FILE* fichiertampon1 = NULL;
  		fichiertampon1 = fopen(construit, "wb");
  		if(fichiertampon1 == NULL){
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		}
		if (fichiertampon1 != NULL){
		char commence[3] = {0x80,0x02};
		char *ave1;
		char *ave2;
		ave1 = &commence[0];
		ave2 = &commence[1];
	    fwrite( ave1, sizeof(unsigned char), 1, fichiertampon1);
	    fwrite( ave2, sizeof(unsigned char), 1, fichiertampon1);
		}

		fclose(fichiertampon1), fichiertampon1 = NULL;;

/***fin du nettoyage fichier tampon*/
/******************************************************************/

	break;/******* fin son un  ****************/

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

	default : 

		fichierjo1 = NULL;/*je place le son u dans le fichier tampon*/
  		fichierjo1 = fopen(ja21, "rb"); 
  		if(fichierjo1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n",ja21);
    		exit(1);
		}
  		fichiertampon1 = fopen(construit, "ab"); 
  		if(fichiertampon1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		} 
		if (fichierjo1 != NULL)
		{
		if (fichiertampon1 != NULL)
		{
		abadie = fgetc(fichierjo1); 
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL; 
		fichierjo1 = NULL;/*je place le son n dans le fichier tampon*/
  		fichierjo1 = fopen(ja14, "rb"); 
  		if(fichierjo1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n",ja14);
    		exit(1);
		}
  		fichiertampon1 = fopen(construit, "ab"); 
  		if(fichiertampon1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		} 
		if (fichierjo1 != NULL)
		{
		if (fichiertampon1 != NULL)
		{
		abadie = fgetc(fichierjo1); 
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL; 
		actif = 1;
		 vacherchergotodehorsswitch = 3;
	}

break;

/******************************  fin actif 11 dérivée de deuxième ordre du son u *************************/
/***************************************************************************************************************************/
/***************************************************************************************************************************/
case 12 :/********switch actif 12 developpement des son i  *********************/
actif = 1;
	switch (assemblage1) {

/***debut son ie vers eau dérivée d'ordre 2****/
	case 4 :
	actif = 13;
	break;/**fin de la dérivée première lettres ie*/

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

/***debut son in*****/
	case 13 :

		fichierjo1 = NULL;
  		fichierjo1 = fopen("temps/in.jo", "rb"); 
  		if(fichierjo1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n","temps/in.jo");
    		exit(1);
		}
  		fichiertampon1 = fopen(construit, "ab"); 
  		if(fichiertampon1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		} 
		if (fichierjo1 != NULL)
		{
		if (fichiertampon1 != NULL)
		{
		abadie = fgetc(fichierjo1); 
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL; 
		actif = 1;

	break;/******* fin son in  ****************/
/***************************************************************************************************************************/
	default :/****son i seul*********************/
		fichierjo1 = NULL;
  		fichierjo1 = fopen(ja9, "rb"); 
  		if(fichierjo1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n",ja9);
    		exit(1);
		}
  		fichiertampon1 = fopen(construit, "ab"); 
  		if(fichiertampon1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		} 
		if (fichierjo1 != NULL)
		{
		if (fichiertampon1 != NULL)
		{
		abadie = fgetc(fichierjo1); 
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL; 
		actif = 1;
		 vacherchergotodehorsswitch = 3;

	}/* fin switch (assemblage1)*/

break;/******************************************bloc  fin derivé du son i ****************************/
/***************************************************************************************************************************/
/***************************************************************************************************************************/
case 13 :/********switch actif 13 dérivée de deuxième ordre des son ie  **************************************/
actif = 1;
	switch (assemblage1) {

/***debut son ied ier****/
	case 3 :
	case 17 :

		fichierjo1 = NULL;
  		fichierjo1 = fopen(ja9, "rb"); 
  		if(fichierjo1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n",ja9);
    		exit(1);
		}
  		fichiertampon1 = fopen(construit, "ab"); 
  		if(fichiertampon1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		} 
		if (fichierjo1 != NULL)
		{
		if (fichiertampon1 != NULL)
		{
		abadie = fgetc(fichierjo1); 
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL; 
		fichierjo1 = NULL;
  		fichierjo1 = fopen("temps/ai.jo", "rb"); 
  		if(fichierjo1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n","temps/ai.jo");
    		exit(1);
		}
  		fichiertampon1 = fopen(construit, "ab"); 
  		if(fichiertampon1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		} 
		if (fichierjo1 != NULL)
		{
		if (fichiertampon1 != NULL)
		{
		abadie = fgetc(fichierjo1); 
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL; 
		actif = 1;

	break;/******* fin son ied ier  ****************/
/***************************************************************************************************************************/
/***debut son ien****/
	case 13 :
		fichierjo1 = NULL;
  		fichierjo1 = fopen(ja9, "rb"); 
  		if(fichierjo1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n",ja9);
    		exit(1);
		}
  		fichiertampon1 = fopen(construit, "ab"); 
  		if(fichiertampon1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		} 
		if (fichierjo1 != NULL)
		{
		if (fichiertampon1 != NULL)
		{
		abadie = fgetc(fichierjo1); 
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL; 
		fichierjo1 = NULL;
  		fichierjo1 = fopen("temps/in.jo", "rb"); 
  		if(fichierjo1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n","temps/in.jo");
    		exit(1);
		}
  		fichiertampon1 = fopen(construit, "ab"); 
  		if(fichiertampon1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		} 
		if (fichierjo1 != NULL)
		{
		if (fichiertampon1 != NULL)
		{
		abadie = fgetc(fichierjo1); 
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL; 
		actif = 1;

	break;/******* fin son ien  ****************/

/***************************************************************************************************************************/
	default :/****son ie seul****************/
		fichierjo1 = NULL;
  		fichierjo1 = fopen(ja9, "rb");
  		if(fichierjo1 == NULL){
    		printf("Ce fichier ne va pas %s\n",ja9);
    		exit(1);
		}
  		fichiertampon1 = fopen(construit, "ab");
  		if(fichiertampon1 == NULL){
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		}
		if (fichierjo1 != NULL)	{
		if (fichiertampon1 != NULL){
		abadie = fgetc(fichierjo1);
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL;
		actif = 1;
		 vacherchergotodehorsswitch = 3;
	}/* fin switch (assemblage1)*/

break;/**************bloc  fin switch actif 13 dérivée de deuxième ordre des son ie ****************************/
/***************************************************************************************************************************/
/***************************************************************************************************************************/
case 14 :/********switch actif 14 developpement des son ant and ans  *********************/
actif = 1;
	switch (assemblage1) {

	case 26 : /**  ant and ans avec espace*/
	case 27 :/**ant. and ans avec point traité comme un espace*/
		fichierjo1 = NULL;
  		fichierjo1 = fopen("temps/en.jo", "rb"); 
  		if(fichierjo1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n","temps/en.jo");
    		exit(1);
		}
  		fichiertampon1 = fopen(construit, "ab"); 
  		if(fichiertampon1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		} 
		if (fichierjo1 != NULL)
		{
		if (fichiertampon1 != NULL)
		{
		abadie = fgetc(fichierjo1); 
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL; 

/**********************************************************************/
		fichierjo1 = NULL;
  		fichierjo1 = fopen(ja27, "rb");
  		if(fichierjo1 == NULL){
    		printf("Ce fichier ne va pas %s\n",ja27);
    		exit(1);
		}
  		fichiertampon1 = fopen(construit, "ab");
  		if(fichiertampon1 == NULL){
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		}
		if (fichierjo1 != NULL)	{
		if (fichiertampon1 != NULL){
		abadie = fgetc(fichierjo1);
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL;

		actif = 1;
	fonctionconvertisseur(argc,argv);/*je lance la lecture*audio du fichier tampon.jo*/

/***********nettoyage fichier tampon******/
		FILE* fichiertampon1 = NULL;
  		fichiertampon1 = fopen(construit, "wb");
  		if(fichiertampon1 == NULL){
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		}
		if (fichiertampon1 != NULL){
		char commence[3] = {0x80,0x02};
		char *ave1;
		char *ave2;
		ave1 = &commence[0];
		ave2 = &commence[1];
	    fwrite( ave1, sizeof(unsigned char), 1, fichiertampon1);
	    fwrite( ave2, sizeof(unsigned char), 1, fichiertampon1);
		}

		fclose(fichiertampon1), fichiertampon1 = NULL;;

/***fin du nettoyage fichier tampon*/

/**********************************************************************/
	break;/******* fin son ant and ans avec espace  ****************/
/***************************************************************************************************************************/

	default :/****son ant seul*********************/
		fichierjo1 = NULL;
  		fichierjo1 = fopen("temps/en.jo", "rb"); 
  		if(fichierjo1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n","temps/en.jo");
    		exit(1);
		}
  		fichiertampon1 = fopen(construit, "ab"); 
  		if(fichiertampon1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		} 
		if (fichierjo1 != NULL)
		{
		if (fichiertampon1 != NULL)
		{
		abadie = fgetc(fichierjo1); 
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL; 

		fichierjo1 = NULL;
  		fichierjo1 = fopen("temps/t.jo", "rb"); 
  		if(fichierjo1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n","temps/t.jo");
    		exit(1);
		}
  		fichiertampon1 = fopen(construit, "ab"); 
  		if(fichiertampon1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		} 
		if (fichierjo1 != NULL)
		{
		if (fichiertampon1 != NULL)
		{
		abadie = fgetc(fichierjo1); 
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL; 

		actif = 1;
		 vacherchergotodehorsswitch = 3;
	}/* fin switch (assemblage1)*/

break;/******************************************bloc  fin switch actif 14 developpement des son ant and ans ****************************/
/***************************************************************************************************************************/
/***************************************************************************************************************************/
case 15 :/********switch actif 15 developpement des son and  *********************/
actif = 1;
	switch (assemblage1) {

	case 26 : /**  ant and ans avec espace*/
	case 27 :/**ant. and ans avec point traité comme un espace*/
		fichierjo1 = NULL;
  		fichierjo1 = fopen("temps/en.jo", "rb"); 
  		if(fichierjo1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n","temps/en.jo");
    		exit(1);
		}
  		fichiertampon1 = fopen(construit, "ab"); 
  		if(fichiertampon1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		} 
		if (fichierjo1 != NULL)
		{
		if (fichiertampon1 != NULL)
		{
		abadie = fgetc(fichierjo1); 
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL; 

/*************************************************/
		fichierjo1 = NULL;
  		fichierjo1 = fopen(ja27, "rb");
  		if(fichierjo1 == NULL){
    		printf("Ce fichier ne va pas %s\n",ja27);
    		exit(1);
		}
  		fichiertampon1 = fopen(construit, "ab");
  		if(fichiertampon1 == NULL){
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		}
		if (fichierjo1 != NULL)	{
		if (fichiertampon1 != NULL){
		abadie = fgetc(fichierjo1);
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL;

		actif = 1;
	fonctionconvertisseur(argc,argv);/*je lance la lecture*audio du fichier tampon.jo*/

/***********nettoyage fichier tampon******/
		FILE* fichiertampon1 = NULL;
  		fichiertampon1 = fopen(construit, "wb");
  		if(fichiertampon1 == NULL){
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		}
		if (fichiertampon1 != NULL){
		char commence[3] = {0x80,0x02};
		char *ave1;
		char *ave2;
		ave1 = &commence[0];
		ave2 = &commence[1];
	    fwrite( ave1, sizeof(unsigned char), 1, fichiertampon1);
	    fwrite( ave2, sizeof(unsigned char), 1, fichiertampon1);
		}

		fclose(fichiertampon1), fichiertampon1 = NULL;;

/***fin du nettoyage fichier tampon*/

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

	break;/******* fin son ant and ans avec espace  ****************/
/***************************************************************************************************************************/

	default :/****son and seul*********************/
		fichierjo1 = NULL;
  		fichierjo1 = fopen("temps/en.jo", "rb"); 
  		if(fichierjo1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n","temps/en.jo");
    		exit(1);
		}
  		fichiertampon1 = fopen(construit, "ab"); 
  		if(fichiertampon1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		} 
		if (fichierjo1 != NULL)
		{
		if (fichiertampon1 != NULL)
		{
		abadie = fgetc(fichierjo1); 
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL; 

		fichierjo1 = NULL;
  		fichierjo1 = fopen("temps/d.jo", "rb"); 
  		if(fichierjo1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n","temps/d.jo");
    		exit(1);
		}
  		fichiertampon1 = fopen(construit, "ab"); 
  		if(fichiertampon1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		} 
		if (fichierjo1 != NULL)
		{
		if (fichiertampon1 != NULL)
		{
		abadie = fgetc(fichierjo1); 
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL; 

		actif = 1;
		 vacherchergotodehorsswitch = 3;

	}/* fin switch (assemblage1)*/

break;/******************************************bloc  fin switch actif 15 developpement des son and ****************************/
/***************************************************************************************************************************/
/***************************************************************************************************************************/
case 16 :/********switch actif 16 developpement des son and  *********************/
actif = 1;
	switch (assemblage1) {

	case 26 : /**  ant and ans avec espace*/
	case 27 :/**ant. and ans avec point traité comme un espace*/
		fichierjo1 = NULL;
  		fichierjo1 = fopen("temps/en.jo", "rb"); 
  		if(fichierjo1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n","temps/en.jo");
    		exit(1);
		}
  		fichiertampon1 = fopen(construit, "ab"); 
  		if(fichiertampon1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		} 
		if (fichierjo1 != NULL)
		{
		if (fichiertampon1 != NULL)
		{
		abadie = fgetc(fichierjo1); 
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL; 

/*****************************************************************/
		fichierjo1 = NULL;
  		fichierjo1 = fopen(ja27, "rb");
  		if(fichierjo1 == NULL){
    		printf("Ce fichier ne va pas %s\n",ja27);
    		exit(1);
		}
  		fichiertampon1 = fopen(construit, "ab");
  		if(fichiertampon1 == NULL){
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		}
		if (fichierjo1 != NULL)	{
		if (fichiertampon1 != NULL){
		abadie = fgetc(fichierjo1);
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL;

		actif = 1;
	fonctionconvertisseur(argc,argv);/*je lance la lecture*audio du fichier tampon.jo*/

/***********nettoyage fichier tampon******/
		FILE* fichiertampon1 = NULL;
  		fichiertampon1 = fopen(construit, "wb");
  		if(fichiertampon1 == NULL){
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		}
		if (fichiertampon1 != NULL){
		char commence[3] = {0x80,0x02};
		char *ave1;
		char *ave2;
		ave1 = &commence[0];
		ave2 = &commence[1];
	    fwrite( ave1, sizeof(unsigned char), 1, fichiertampon1);
	    fwrite( ave2, sizeof(unsigned char), 1, fichiertampon1);
		}

		fclose(fichiertampon1), fichiertampon1 = NULL;;

/***fin du nettoyage fichier tampon*/

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

	break;/******* fin son ans avec espace  ****************/
/***************************************************************************************************************************/

	default :/****son an+s seul*********************/
		fichierjo1 = NULL;
  		fichierjo1 = fopen("temps/en.jo", "rb"); 
  		if(fichierjo1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n","temps/en.jo");
    		exit(1);
		}
  		fichiertampon1 = fopen(construit, "ab"); 
  		if(fichiertampon1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		} 
		if (fichierjo1 != NULL)
		{
		if (fichiertampon1 != NULL)
		{
		abadie = fgetc(fichierjo1); 
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL; 

		fichierjo1 = NULL;
  		fichierjo1 = fopen("temps/s.jo", "rb"); 
  		if(fichierjo1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n","temps/s.jo");
    		exit(1);
		}
  		fichiertampon1 = fopen(construit, "ab"); 
  		if(fichiertampon1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		} 
		if (fichierjo1 != NULL)
		{
		if (fichiertampon1 != NULL)
		{
		abadie = fgetc(fichierjo1); 
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL; 

		actif = 1;
		 vacherchergotodehorsswitch = 3;
	}/* fin switch (assemblage1)*/

break;/*********************bloc  fin switch actif 16 developpement des son ans ****************************/
/***************************************************************************************************************************/
/***************************************************************************************************************************/
case 20 :/********switch actif 20 dérivée de premier ordre des son e  **************************************/
actif = 1;
	switch (assemblage1) {

/***debut son ei er****/
	case 8 :
	case 17 :

		fichierjo1 = NULL;
  		fichierjo1 = fopen("temps/ai.jo", "rb"); 
  		if(fichierjo1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n","temps/ai.jo");
    		exit(1);
		}
  		fichiertampon1 = fopen(construit, "ab"); 
  		if(fichiertampon1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		} 
		if (fichierjo1 != NULL)
		{
		if (fichiertampon1 != NULL)
		{
		abadie = fgetc(fichierjo1); 
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL; 
		actif = 1;

	break;/******* fin son ei er  ****************/
/***************************************************************************************************************************/

/***debut son ea  vers eau dérivée d'ordre 2****/
	case 0 :
	actif = 21;
	break;/**fin de la dérivée première lettres ea*/

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

/***debut son es  vers est dérivée d'ordre 2****/
	case 18 :
	actif = 23;
	break;/**fin de la dérivée première lettres es*/

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

/***debut son et  vers est dérivée d'ordre 2****/
	case 19 :
	actif = 22;
	break;/**fin de la dérivée première lettres et*/

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

/***debut son en  vers est dérivée d'ordre 2****/
	case 13 :
		fichierjo1 = NULL;
  		fichierjo1 = fopen("temps/en.jo", "rb");
  		if(fichierjo1 == NULL){
    		printf("Ce fichier ne va pas %s\n","temps/en.jo");
    		exit(1);
		}
  		fichiertampon1 = fopen(construit, "ab");
  		if(fichiertampon1 == NULL){
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		}
		if (fichierjo1 != NULL)	{
		if (fichiertampon1 != NULL){
		abadie = fgetc(fichierjo1);
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL;
	break;/**fin de la dérivée première lettres et*/

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

	default :/****son e seul****************/
		fichierjo1 = NULL;
  		fichierjo1 = fopen(ja5, "rb");
  		if(fichierjo1 == NULL){
    		printf("Ce fichier ne va pas %s\n",ja5);
    		exit(1);
		}
  		fichiertampon1 = fopen(construit, "ab");
  		if(fichiertampon1 == NULL){
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		}
		if (fichierjo1 != NULL)	{
		if (fichiertampon1 != NULL){
		abadie = fgetc(fichierjo1);
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL;
		 vacherchergotodehorsswitch = 3;
	}/* fin switch (assemblage1)*/

break;/******************************************bloc  fin derivé du son e *****switch 20***********************/
/***************************************************************************************************************************/
/***************************************************************************************************************************/
case 21 :/********switch actif 21 dérivée de deuxième ordre du son  e son eau  ******************************************/
actif = 1;

		fichierjo1 = NULL;
  		fichierjo1 = fopen(ja15, "rb"); 
  		if(fichierjo1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n",ja15);
    		exit(1);
		}
  		fichiertampon1 = fopen(construit, "ab"); 
  		if(fichiertampon1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		} 
		if (fichierjo1 != NULL)
		{
		if (fichiertampon1 != NULL)
		{
		abadie = fgetc(fichierjo1); 
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL; 
		actif = 1;
break;

/*********************  fin actif 21 dérivée de deuxième ordre du son e son eau ****************************/
/***************************************************************************************************************************/
/***************************************************************************************************************************/
case 22 :/********switch actif 22 developpement des son et  *********************/
actif = 1;
	switch (assemblage1) {
	case 18 : /**  ets  avec espace*/
	case 26 : /**  et avec espace*/
	case 27 :/**et avec point traité comme un espace*/
		fichierjo1 = NULL;
  		fichierjo1 = fopen("temps/ai.jo", "rb"); 
  		if(fichierjo1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n","temps/aie.jo");
    		exit(1);
		}
  		fichiertampon1 = fopen(construit, "ab"); 
  		if(fichiertampon1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		} 
		if (fichierjo1 != NULL)
		{
		if (fichiertampon1 != NULL)
		{
		abadie = fgetc(fichierjo1); 
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL; 

/***********************************************************/
		fichierjo1 = NULL;
  		fichierjo1 = fopen(ja27, "rb");
  		if(fichierjo1 == NULL){
    		printf("Ce fichier ne va pas %s\n",ja27);
    		exit(1);
		}
  		fichiertampon1 = fopen(construit, "ab");
  		if(fichiertampon1 == NULL){
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		}
		if (fichierjo1 != NULL)	{
		if (fichiertampon1 != NULL){
		abadie = fgetc(fichierjo1);
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL;

		actif = 1;
	fonctionconvertisseur(argc,argv);/*je lance la lecture*audio du fichier tampon.jo*/

/***********nettoyage fichier tampon******/
		FILE* fichiertampon1 = NULL;
  		fichiertampon1 = fopen(construit, "wb");
  		if(fichiertampon1 == NULL){
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		}
		if (fichiertampon1 != NULL){
		char commence[3] = {0x80,0x02};
		char *ave1;
		char *ave2;
		ave1 = &commence[0];
		ave2 = &commence[1];
	    fwrite( ave1, sizeof(unsigned char), 1, fichiertampon1);
	    fwrite( ave2, sizeof(unsigned char), 1, fichiertampon1);
		}

		fclose(fichiertampon1), fichiertampon1 = NULL;;

/***fin du nettoyage fichier tampon*/

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


	break;/******* fin son et avec espace  ****************/
/***************************************************************************************************************************/

	default :/****son et seul*********************/
		fichierjo1 = NULL;
  		fichierjo1 = fopen("temps/e.jo", "rb"); 
  		if(fichierjo1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n","temps/e.jo");
    		exit(1);
		}
  		fichiertampon1 = fopen(construit, "ab"); 
  		if(fichiertampon1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		} 
		if (fichierjo1 != NULL)
		{
		if (fichiertampon1 != NULL)
		{
		abadie = fgetc(fichierjo1); 
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL; 

		fichierjo1 = NULL;
  		fichierjo1 = fopen("temps/t.jo", "rb");
  		if(fichierjo1 == NULL){
    		printf("Ce fichier ne va pas %s\n","temps/t.jo");
    		exit(1);
		}
  		fichiertampon1 = fopen(construit, "ab");
  		if(fichiertampon1 == NULL){
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		}
		if (fichierjo1 != NULL)	{
		if (fichiertampon1 != NULL){
		abadie = fgetc(fichierjo1);
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL;

		actif = 1;
		 vacherchergotodehorsswitch = 3;

	}/* fin switch (assemblage1)*/

break;/********bloc  fin switch actif 22 developpement des sons et ****************************/
/***************************************************************************************************************************/
/***************************************************************************************************************************/
case 23 :/********switch actif 23 developpement des son and  *********************/
actif = 1;
	switch (assemblage1) {
	case 19 : /**  est  avec espace*/
	case 26 : /**  es avec espace*/
	case 27 :/**es avec point traité comme un espace*/
		fichierjo1 = NULL;
  		fichierjo1 = fopen("temps/aie.jo", "rb"); 
  		if(fichierjo1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n","temps/aie.jo");
    		exit(1);
		}
  		fichiertampon1 = fopen(construit, "ab"); 
  		if(fichiertampon1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		} 
		if (fichierjo1 != NULL)
		{
		if (fichiertampon1 != NULL)
		{
		abadie = fgetc(fichierjo1); 
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL; 

/************************************************************/
		fichierjo1 = NULL;
  		fichierjo1 = fopen(ja27, "rb");
  		if(fichierjo1 == NULL){
    		printf("Ce fichier ne va pas %s\n",ja27);
    		exit(1);
		}
  		fichiertampon1 = fopen(construit, "ab");
  		if(fichiertampon1 == NULL){
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		}
		if (fichierjo1 != NULL)	{
		if (fichiertampon1 != NULL){
		abadie = fgetc(fichierjo1);
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL;

		actif = 1;
	fonctionconvertisseur(argc,argv);/*je lance la lecture*audio du fichier tampon.jo*/

/***********nettoyage fichier tampon******/
		FILE* fichiertampon1 = NULL;
  		fichiertampon1 = fopen(construit, "wb");
  		if(fichiertampon1 == NULL){
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		}
		if (fichiertampon1 != NULL){
		char commence[3] = {0x80,0x02};
		char *ave1;
		char *ave2;
		ave1 = &commence[0];
		ave2 = &commence[1];
	    fwrite( ave1, sizeof(unsigned char), 1, fichiertampon1);
	    fwrite( ave2, sizeof(unsigned char), 1, fichiertampon1);
		}

		fclose(fichiertampon1), fichiertampon1 = NULL;;

/***fin du nettoyage fichier tampon*/

/************************************************************/
	break;/******* fin son es avec espace  ****************/
/***************************************************************************************************************************/

	default :/****son es seul*********************/
		fichierjo1 = NULL;
  		fichierjo1 = fopen("temps/aie.jo", "rb"); 
  		if(fichierjo1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n","temps/aie.jo");
    		exit(1);
		}
  		fichiertampon1 = fopen(construit, "ab"); 
  		if(fichiertampon1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		} 
		if (fichierjo1 != NULL)
		{
		if (fichiertampon1 != NULL)
		{
		abadie = fgetc(fichierjo1); 
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL; 

		fichierjo1 = NULL;
  		fichierjo1 = fopen("temps/s.jo", "rb");
  		if(fichierjo1 == NULL){
    		printf("Ce fichier ne va pas %s\n","temps/s.jo");
    		exit(1);
		}
  		fichiertampon1 = fopen(construit, "ab");
  		if(fichiertampon1 == NULL){
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		}
		if (fichierjo1 != NULL)	{
		if (fichiertampon1 != NULL){
		abadie = fgetc(fichierjo1);
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL;

		actif = 1;
		 vacherchergotodehorsswitch = 3;

	}/* fin switch (assemblage1)*/

break;/***************bloc  fin switch actif 23 developpement des son ans ****************************/
/***************************************************************************************************************************/
/***************************************************************************************************************************/


case 25 :/********switch actif 25 developpement des son t  *********************/
actif = 1;
	switch (assemblage1) {

	case 26 : /**  t avec espace*/
	case 27 :/**t avec point traité comme un espace*/

		fichierjo1 = NULL;
  		fichierjo1 = fopen(ja27, "rb");
  		if(fichierjo1 == NULL){
    		printf("Ce fichier ne va pas %s\n",ja27);
    		exit(1);
		}
  		fichiertampon1 = fopen(construit, "ab");
  		if(fichiertampon1 == NULL){
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		}
		if (fichierjo1 != NULL)	{
		if (fichiertampon1 != NULL){
		abadie = fgetc(fichierjo1);
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL;

		actif = 1;
	fonctionconvertisseur(argc,argv);/*je lance la lecture*audio du fichier tampon.jo*/

/***********nettoyage fichier tampon******/
		FILE* fichiertampon1 = NULL;
  		fichiertampon1 = fopen(construit, "wb");
  		if(fichiertampon1 == NULL){
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		}
		if (fichiertampon1 != NULL){
		char commence[3] = {0x80,0x02};
		char *ave1;
		char *ave2;
		ave1 = &commence[0];
		ave2 = &commence[1];
	    fwrite( ave1, sizeof(unsigned char), 1, fichiertampon1);
	    fwrite( ave2, sizeof(unsigned char), 1, fichiertampon1);
		}

		fclose(fichiertampon1), fichiertampon1 = NULL;;

/***fin du nettoyage fichier tampon*/

/************************************************************/
	break;/******* fin son t avec espace  ****************/
/***************************************************************************************************************************/

	default :/****son t prononcer*********************/
		fichierjo1 = NULL;
  		fichierjo1 = fopen(ja20, "rb");
  		if(fichierjo1 == NULL){
    		printf("Ce fichier ne va pas %s\n",ja20);
    		exit(1);
		}
  		fichiertampon1 = fopen(construit, "ab");
  		if(fichiertampon1 == NULL){
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		}
		if (fichierjo1 != NULL)	{
		if (fichiertampon1 != NULL){
		abadie = fgetc(fichierjo1);
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL;

		actif = 1;
		 vacherchergotodehorsswitch = 3;

	}/* fin switch (assemblage1)*/

break;/***************bloc  fin switch actif 25 developpement des son t ****************************/
/***************************************************************************************************************************/
/***************************************************************************************************************************/


case 26 :/********switch actif 26 developpement des son s  *********************/
actif = 1;
	switch (assemblage1) {

	case 26 : /**  t avec espace*/
	case 27 :/**t avec point traité comme un espace*/

		fichierjo1 = NULL;
  		fichierjo1 = fopen(ja27, "rb");
  		if(fichierjo1 == NULL){
    		printf("Ce fichier ne va pas %s\n",ja27);
    		exit(1);
		}
  		fichiertampon1 = fopen(construit, "ab");
  		if(fichiertampon1 == NULL){
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		}
		if (fichierjo1 != NULL)	{
		if (fichiertampon1 != NULL){
		abadie = fgetc(fichierjo1);
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL;

		actif = 1;
	fonctionconvertisseur(argc,argv);/*je lance la lecture*audio du fichier tampon.jo*/

/***********nettoyage fichier tampon******/
		FILE* fichiertampon1 = NULL;
  		fichiertampon1 = fopen(construit, "wb");
  		if(fichiertampon1 == NULL){
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		}
		if (fichiertampon1 != NULL){
		char commence[3] = {0x80,0x02};
		char *ave1;
		char *ave2;
		ave1 = &commence[0];
		ave2 = &commence[1];
	    fwrite( ave1, sizeof(unsigned char), 1, fichiertampon1);
	    fwrite( ave2, sizeof(unsigned char), 1, fichiertampon1);
		}

		fclose(fichiertampon1), fichiertampon1 = NULL;;

/***fin du nettoyage fichier tampon*/

/************************************************************/
	break;/******* fin son s avec espace  ****************/
/***************************************************************************************************************************/

	default :/****son s prononcer*********************/
		fichierjo1 = NULL;
  		fichierjo1 = fopen(ja19, "rb");
  		if(fichierjo1 == NULL){
    		printf("Ce fichier ne va pas %s\n",ja19);
    		exit(1);
		}
  		fichiertampon1 = fopen(construit, "ab");
  		if(fichiertampon1 == NULL){
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		}
		if (fichierjo1 != NULL)	{
		if (fichiertampon1 != NULL){
		abadie = fgetc(fichierjo1);
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL;

		actif = 1;
		 vacherchergotodehorsswitch = 3;

	}/* fin switch (assemblage1)*/

break;/***************bloc  fin switch actif 26 developpement des son s ****************************/
/***************************************************************************************************************************/
/***************************************************************************************************************************/


}/* fin switch (actif)*/
if ( vacherchergotodehorsswitch == 3)
{
vacherchergotodehorsswitch = 1;
goto remonteswitch ;
}
saitfait = 1;
return saitfait ;
}/*fin de la fonctionidentification*/



/*********************fonction main**************************************************************************************/

int main(int argc, char *argv[]) {

/***********nettoyage fichier tampon******/
		FILE* fichiertampon1 = NULL;
  		fichiertampon1 = fopen(construit, "wb");
  		if(fichiertampon1 == NULL){
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		}
		if (fichiertampon1 != NULL){
		char commence[3] = {0x80,0x02};
		char *ave1;
		char *ave2;
		ave1 = &commence[0];
		ave2 = &commence[1];
	    fwrite( ave1, sizeof(unsigned char), 1, fichiertampon1);
	    fwrite( ave2, sizeof(unsigned char), 1, fichiertampon1);
		}

		fclose(fichiertampon1), fichiertampon1 = NULL;;

/***fin du nettoyage fichier tampon*/

	int qui;
	int quicou;
	position = 1;
	actif = 1;
	calcultemps = 1000000;
	saitfait = 1;
  /*j ouvre mon fichier & lire*/
  FILE* jojo = NULL;
  jojo = fopen(argv[1], "r");
  if(jojo == NULL){
    exit(1);
  }


if (jojo != NULL)
{


/* while ((qui= fgetc(jojo)) != EOF) qui vient chercher tout ce qui bouge*/
while (((qui= fgetc(jojo)) != EOF) &&  (saitfait == 1))/* qui vient chercher tout ce qui bouge*/

        {
if (qui != '\n'){
    printf("lettre debut est %d\n",qui);
/*
if ((qui != 195)&& (qui != 169)&& (qui != 44)&& (qui != 59)&& (qui != 58)&& (qui != 33)&& (qui != 39)&& (qui != 63)&& (qui != 168)&& (qui != 160)&& (qui != 167)&& (qui< 123))*/
if (((qui > 96)&& (qui< 123)) ||((qui > 64)&& (qui< 91)) || (qui == 46)|| (qui == 32))
{
	quicou = tolower(qui);
saitfait = fonctionidentification(argc,argv,quicou);
/*
if((qui == 32) || (qui == 46)) {


	usleep(calcultemps);
}*/
}
if ((qui == 170) ||(qui == 169) ||(qui == 168)) /* é ou è*/
{
	qui = 36;

    printf("lettre lu est %d\n",qui);

		quicou = (qui);
saitfait = fonctionidentification(argc,argv,quicou);
}
if (qui == 167) /* ç*/
{
	qui = 115; /* s */

		quicou = (qui);
saitfait = fonctionidentification(argc,argv,quicou);

}
if (qui == 160) /* à*/
{
	qui = 97; /* a */

		quicou = (qui);
saitfait = fonctionidentification(argc,argv,quicou);

}
}

        }  /*while (qui != EOF);*jusqua la fin du texte*/
        fclose(jojo);

      }
/*	fonctionconvertisseur(argc,argv);je lance la lecture*audio du fichier tampon.jo*/
        return 0 ;

    }