extern char *malloc(), *realloc();

# line 8 "sesh.y"
#include <malloc.h>
typedef char * YYSTYPE;
char* genere();
extern void initialise_lex();
#include <stdio.h>
#ifndef NULL
#define NULL (char *)0
#endif
# define TEXTE 257
# define DEBUTHIEROGS 258
# define FINHIEROGS 259
# define HIEROGLYPHE 260
# define LIGAD 261
# define POINT 262
# define POINTPOINT 263
# define SYMBOLE 264
# define KERNING 265
# define ESPACE 266
# define CARTO 267
# define CARTF 268
# define DEBCARTO 269
# define MILCARTO 270
# define FINCARTO 271
# define DIEZE0 272
# define DIEZE1 273
# define ROMAIN 274
# define INTERNALSPACE 275
#define yyclearin yychar = -1
#define yyerrok yyerrflag = 0
extern int yychar;
extern int yyerrflag;
#ifndef YYMAXDEPTH
#define YYMAXDEPTH 150
#endif
#ifndef YYSTYPE
#define YYSTYPE int
#endif
YYSTYPE yylval, yyval;
# define YYERRCODE 256

# line 144 "sesh.y"


#include <varargs.h>  
#include <malloc.h>
  
char * genere(va_alist)
     va_dcl
{
  char * chaine;
  static char * curr[10];
  int i, j, w, longueur;
  va_list pvar;
  va_start(pvar);

  i=0;
  longueur=0;
  
  while (curr[i]= (va_arg(pvar, char *)))
    longueur+= strlen(curr[i++]);
  
  va_end(pvar);
  
  chaine= (char *)malloc(sizeof(char)* (longueur +1));
  for (j=0, w=0; j< i; j++)
    {
      int k;
      for (k=0; curr[j][k]; k++)
	chaine[w++]= curr[j][k];
    }
  chaine[w]=0;
  return chaine;
}
 

yyerror(s)
     char *s;
{
  extern int yytext;
  printf("\n\n%s, pres de %s\n",s,yytext);
}

main()
{
  int yydebug;
  initialise_lex();  
  yydebug= 1;
  yyparse();
}
int yyexca[] ={
-1, 1,
	0, -1,
	-2, 0,
-1, 22,
	58, 38,
	42, 38,
	-2, 17,
-1, 23,
	58, 39,
	42, 39,
	-2, 18,
-1, 46,
	58, 38,
	42, 38,
	-2, 21,
-1, 47,
	58, 39,
	42, 39,
	-2, 22,
-1, 69,
	58, 40,
	42, 40,
	-2, 25,
	};
# define YYNPROD 45
# define YYLAST 260
int yyact[]={

    35,    61,    60,    59,    58,    57,    49,    19,     2,     4,
     8,    54,    52,    50,    45,    66,    38,    38,    44,    69,
    25,    38,    34,    63,    10,    22,    35,     9,    16,    13,
     8,    62,    64,    37,    17,    63,    12,    20,     7,    11,
     6,     5,     3,    25,    53,    15,     1,    46,    22,    36,
     0,     0,     0,     0,     0,    39,    40,    41,    42,    43,
     0,    56,    46,     0,    17,    17,    17,    17,    17,    65,
     0,    53,     0,    70,    51,    46,     0,    68,    67,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    23,     0,    26,    32,    33,    21,     0,    27,    18,    28,
    29,    30,    31,    47,    24,    26,    32,    33,     0,     0,
    27,     0,    28,    29,    30,    31,    55,    48,    26,    32,
    33,     0,     0,    27,     0,    28,    29,    30,    31,    14 };
int yypact[]={

 -1000,  -249, -1000, -1000, -1000,    20,     0, -1000, -1000,    18,
 -1000, -1000,   -38,   -40, -1000, -1000, -1000, -1000, -1000, -1000,
 -1000, -1000, -1000, -1000, -1000,   -25, -1000, -1000, -1000, -1000,
 -1000, -1000, -1000, -1000, -1000,   -27,   -40,   -14,   -14,  -263,
  -264,  -265,  -266,  -272,   -10, -1000, -1000, -1000, -1000,   -26,
   -27, -1000,   -43,   -21, -1000, -1000, -1000, -1000, -1000, -1000,
 -1000, -1000, -1000,   -27,   -14,   -22,   -14, -1000,   -43, -1000,
   -21 };
int yypgo[]={

     0,    46,    42,    41,    40,    38,    27,    24,    39,    36,
    29,    37,    11,     6,    12,    14,    18,    22 };
int yyr1[]={

     0,     1,     1,     1,     3,     2,     4,     4,     5,     5,
     6,     6,     7,     8,     8,     9,     9,    11,    11,    11,
    11,    15,    15,    15,    15,    15,    12,    12,    12,    12,
    12,    12,    12,    12,    14,    14,    13,    13,    17,    17,
    17,    16,    16,    10,    10 };
int yyr2[]={

     0,     4,     4,     0,     1,     9,     2,     4,     2,     5,
     2,     5,     2,     5,     2,     5,     9,     3,     3,     3,
     7,     2,     2,     3,     7,     7,     3,     7,     7,     7,
     7,     7,     3,     2,     3,     7,     7,     2,     2,     2,
     7,     2,     7,     1,     5 };
int yychk[]={

 -1000,    -1,   257,    -2,   258,    -3,    -4,    -5,    10,    -6,
    -7,    -8,    -9,   -10,   259,    -5,    10,    -7,   266,    45,
   -11,   265,   -12,   260,   274,   -13,   262,   267,   269,   270,
   271,   272,   263,   264,   -17,    40,   -10,    58,    42,    -6,
    -6,    -6,    -6,    -6,   -16,   -15,   -12,   260,   274,   -13,
    40,   -11,   -14,   -13,   -12,   260,   -17,   268,   268,   268,
   268,   273,    41,    45,    58,   -16,    58,   -15,   -14,    41,
   -13 };
int yydef[]={

     3,    -2,     1,     2,     4,    43,    43,     6,     8,    43,
    10,    12,    14,     0,     5,     7,     9,    11,    13,    43,
    15,    44,    -2,    -2,    19,     0,    26,    43,    43,    43,
    43,    43,    32,    33,    37,     0,     0,     0,     0,    43,
    43,    43,    43,    43,     0,    41,    -2,    -2,    23,     0,
     0,    16,    20,    34,    38,    39,    36,    27,    28,    29,
    30,    31,    40,     0,     0,     0,     0,    42,    24,    -2,
    35 };
typedef struct { char *t_name; int t_val; } yytoktype;
#ifndef YYDEBUG
#	define YYDEBUG	0	/* don't allow debugging */
#endif

#if YYDEBUG

yytoktype yytoks[] =
{
	"TEXTE",	257,
	"DEBUTHIEROGS",	258,
	"FINHIEROGS",	259,
	"HIEROGLYPHE",	260,
	"LIGAD",	261,
	"POINT",	262,
	"POINTPOINT",	263,
	"SYMBOLE",	264,
	"KERNING",	265,
	"ESPACE",	266,
	"CARTO",	267,
	"CARTF",	268,
	"DEBCARTO",	269,
	"MILCARTO",	270,
	"FINCARTO",	271,
	"DIEZE0",	272,
	"DIEZE1",	273,
	"ROMAIN",	274,
	"INTERNALSPACE",	275,
	"-",	45,
	":",	58,
	"-unknown-",	-1	/* ends search */
};

char * yyreds[] =
{
	"-no such reduction-",
	"tout : tout TEXTE",
	"tout : tout hierogs",
	"tout : /* empty */",
	"hierogs : DEBUTHIEROGS",
	"hierogs : DEBUTHIEROGS lignes FINHIEROGS",
	"lignes : ligne",
	"lignes : lignes ligne",
	"ligne : '\n'",
	"ligne : exprs '\n'",
	"exprs : express0",
	"exprs : exprs express0",
	"express0 : express1",
	"express1 : quadras ESPACE",
	"express1 : quadras",
	"quadras : kerning quadra",
	"quadras : quadras '-' kerning quadra",
	"quadra : quadra_commun",
	"quadra : HIEROGLYPHE",
	"quadra : ROMAIN",
	"quadra : sousquadra ':' sousquadras",
	"quadra_interne : quadra_commun",
	"quadra_interne : HIEROGLYPHE",
	"quadra_interne : ROMAIN",
	"quadra_interne : sousquadra ':' sousquadras",
	"quadra_interne : '(' quadras1 ')'",
	"quadra_commun : POINT",
	"quadra_commun : CARTO exprs CARTF",
	"quadra_commun : DEBCARTO exprs CARTF",
	"quadra_commun : MILCARTO exprs CARTF",
	"quadra_commun : FINCARTO exprs CARTF",
	"quadra_commun : DIEZE0 exprs DIEZE1",
	"quadra_commun : POINTPOINT",
	"quadra_commun : SYMBOLE",
	"sousquadras : sousquadra",
	"sousquadras : sousquadras ':' sousquadra",
	"sousquadra : sousquadra '*' inhierliste",
	"sousquadra : inhierliste",
	"inhierliste : quadra_commun",
	"inhierliste : HIEROGLYPHE",
	"inhierliste : '(' quadras1 ')'",
	"quadras1 : quadra_interne",
	"quadras1 : quadras1 '-' quadra_interne",
	"kerning : /* empty */",
	"kerning : kerning KERNING",
};
#endif /* YYDEBUG */
#line 1 "/usr/lib/yaccpar"
/*	@(#)yaccpar 1.10 89/04/04 SMI; from S5R3 1.10	*/

/*
** Skeleton parser driver for yacc output
*/

/*
** yacc user known macros and defines
*/
#define YYERROR		goto yyerrlab
#define YYACCEPT	{ free(yys); free(yyv); return(0); }
#define YYABORT		{ free(yys); free(yyv); return(1); }
#define YYBACKUP( newtoken, newvalue )\
{\
	if ( yychar >= 0 || ( yyr2[ yytmp ] >> 1 ) != 1 )\
	{\
		yyerror( "syntax error - cannot backup" );\
		goto yyerrlab;\
	}\
	yychar = newtoken;\
	yystate = *yyps;\
	yylval = newvalue;\
	goto yynewstate;\
}
#define YYRECOVERING()	(!!yyerrflag)
#ifndef YYDEBUG
#	define YYDEBUG	1	/* make debugging available */
#endif

/*
** user known globals
*/
int yydebug;			/* set to 1 to get debugging */

/*
** driver internal defines
*/
#define YYFLAG		(-1000)

/*
** static variables used by the parser
*/
static YYSTYPE *yyv;			/* value stack */
static int *yys;			/* state stack */

static YYSTYPE *yypv;			/* top of value stack */
static int *yyps;			/* top of state stack */

static int yystate;			/* current state */
static int yytmp;			/* extra var (lasts between blocks) */

int yynerrs;			/* number of errors */

int yyerrflag;			/* error recovery flag */
int yychar;			/* current input token number */


/*
** yyparse - return 0 if worked, 1 if syntax error not recovered from
*/
int
yyparse()
{
	register YYSTYPE *yypvt;	/* top of value stack for $vars */
	unsigned yymaxdepth = YYMAXDEPTH;

	/*
	** Initialize externals - yyparse may be called more than once
	*/
	yyv = (YYSTYPE*)malloc(yymaxdepth*sizeof(YYSTYPE));
	yys = (int*)malloc(yymaxdepth*sizeof(int));
	if (!yyv || !yys)
	{
		yyerror( "out of memory" );
		return(1);
	}
	yypv = &yyv[-1];
	yyps = &yys[-1];
	yystate = 0;
	yytmp = 0;
	yynerrs = 0;
	yyerrflag = 0;
	yychar = -1;

	goto yystack;
	{
		register YYSTYPE *yy_pv;	/* top of value stack */
		register int *yy_ps;		/* top of state stack */
		register int yy_state;		/* current state */
		register int  yy_n;		/* internal state number info */

		/*
		** get globals into registers.
		** branch to here only if YYBACKUP was called.
		*/
	yynewstate:
		yy_pv = yypv;
		yy_ps = yyps;
		yy_state = yystate;
		goto yy_newstate;

		/*
		** get globals into registers.
		** either we just started, or we just finished a reduction
		*/
	yystack:
		yy_pv = yypv;
		yy_ps = yyps;
		yy_state = yystate;

		/*
		** top of for (;;) loop while no reductions done
		*/
	yy_stack:
		/*
		** put a state and value onto the stacks
		*/
#if YYDEBUG
		/*
		** if debugging, look up token value in list of value vs.
		** name pairs.  0 and negative (-1) are special values.
		** Note: linear search is used since time is not a real
		** consideration while debugging.
		*/
		if ( yydebug )
		{
			register int yy_i;

			(void)printf( "State %d, token ", yy_state );
			if ( yychar == 0 )
				(void)printf( "end-of-file\n" );
			else if ( yychar < 0 )
				(void)printf( "-none-\n" );
			else
			{
				for ( yy_i = 0; yytoks[yy_i].t_val >= 0;
					yy_i++ )
				{
					if ( yytoks[yy_i].t_val == yychar )
						break;
				}
				(void)printf( "%s\n", yytoks[yy_i].t_name );
			}
		}
#endif /* YYDEBUG */
		if ( ++yy_ps >= &yys[ yymaxdepth ] )	/* room on stack? */
		{
			/*
			** reallocate and recover.  Note that pointers
			** have to be reset, or bad things will happen
			*/
			int yyps_index = (yy_ps - yys);
			int yypv_index = (yy_pv - yyv);
			int yypvt_index = (yypvt - yyv);
			yymaxdepth += YYMAXDEPTH;
			yyv = (YYSTYPE*)realloc((char*)yyv,
				yymaxdepth * sizeof(YYSTYPE));
			yys = (int*)realloc((char*)yys,
				yymaxdepth * sizeof(int));
			if (!yyv || !yys)
			{
				yyerror( "yacc stack overflow" );
				return(1);
			}
			yy_ps = yys + yyps_index;
			yy_pv = yyv + yypv_index;
			yypvt = yyv + yypvt_index;
		}
		*yy_ps = yy_state;
		*++yy_pv = yyval;

		/*
		** we have a new state - find out what to do
		*/
	yy_newstate:
		if ( ( yy_n = yypact[ yy_state ] ) <= YYFLAG )
			goto yydefault;		/* simple state */
#if YYDEBUG
		/*
		** if debugging, need to mark whether new token grabbed
		*/
		yytmp = yychar < 0;
#endif
		if ( ( yychar < 0 ) && ( ( yychar = yylex() ) < 0 ) )
			yychar = 0;		/* reached EOF */
#if YYDEBUG
		if ( yydebug && yytmp )
		{
			register int yy_i;

			(void)printf( "Received token " );
			if ( yychar == 0 )
				(void)printf( "end-of-file\n" );
			else if ( yychar < 0 )
				(void)printf( "-none-\n" );
			else
			{
				for ( yy_i = 0; yytoks[yy_i].t_val >= 0;
					yy_i++ )
				{
					if ( yytoks[yy_i].t_val == yychar )
						break;
				}
				(void)printf( "%s\n", yytoks[yy_i].t_name );
			}
		}
#endif /* YYDEBUG */
		if ( ( ( yy_n += yychar ) < 0 ) || ( yy_n >= YYLAST ) )
			goto yydefault;
		if ( yychk[ yy_n = yyact[ yy_n ] ] == yychar )	/*valid shift*/
		{
			yychar = -1;
			yyval = yylval;
			yy_state = yy_n;
			if ( yyerrflag > 0 )
				yyerrflag--;
			goto yy_stack;
		}

	yydefault:
		if ( ( yy_n = yydef[ yy_state ] ) == -2 )
		{
#if YYDEBUG
			yytmp = yychar < 0;
#endif
			if ( ( yychar < 0 ) && ( ( yychar = yylex() ) < 0 ) )
				yychar = 0;		/* reached EOF */
#if YYDEBUG
			if ( yydebug && yytmp )
			{
				register int yy_i;

				(void)printf( "Received token " );
				if ( yychar == 0 )
					(void)printf( "end-of-file\n" );
				else if ( yychar < 0 )
					(void)printf( "-none-\n" );
				else
				{
					for ( yy_i = 0;
						yytoks[yy_i].t_val >= 0;
						yy_i++ )
					{
						if ( yytoks[yy_i].t_val
							== yychar )
						{
							break;
						}
					}
					(void)printf( "%s\n", yytoks[yy_i].t_name );
				}
			}
#endif /* YYDEBUG */
			/*
			** look through exception table
			*/
			{
				register int *yyxi = yyexca;

				while ( ( *yyxi != -1 ) ||
					( yyxi[1] != yy_state ) )
				{
					yyxi += 2;
				}
				while ( ( *(yyxi += 2) >= 0 ) &&
					( *yyxi != yychar ) )
					;
				if ( ( yy_n = yyxi[1] ) < 0 )
					YYACCEPT;
			}
		}

		/*
		** check for syntax error
		*/
		if ( yy_n == 0 )	/* have an error */
		{
			/* no worry about speed here! */
			switch ( yyerrflag )
			{
			case 0:		/* new error */
				yyerror( "syntax error" );
				goto skip_init;
			yyerrlab:
				/*
				** get globals into registers.
				** we have a user generated syntax type error
				*/
				yy_pv = yypv;
				yy_ps = yyps;
				yy_state = yystate;
				yynerrs++;
			skip_init:
			case 1:
			case 2:		/* incompletely recovered error */
					/* try again... */
				yyerrflag = 3;
				/*
				** find state where "error" is a legal
				** shift action
				*/
				while ( yy_ps >= yys )
				{
					yy_n = yypact[ *yy_ps ] + YYERRCODE;
					if ( yy_n >= 0 && yy_n < YYLAST &&
						yychk[yyact[yy_n]] == YYERRCODE)					{
						/*
						** simulate shift of "error"
						*/
						yy_state = yyact[ yy_n ];
						goto yy_stack;
					}
					/*
					** current state has no shift on
					** "error", pop stack
					*/
#if YYDEBUG
#	define _POP_ "Error recovery pops state %d, uncovers state %d\n"
					if ( yydebug )
						(void)printf( _POP_, *yy_ps,
							yy_ps[-1] );
#	undef _POP_
#endif
					yy_ps--;
					yy_pv--;
				}
				/*
				** there is no state on stack with "error" as
				** a valid shift.  give up.
				*/
				YYABORT;
			case 3:		/* no shift yet; eat a token */
#if YYDEBUG
				/*
				** if debugging, look up token in list of
				** pairs.  0 and negative shouldn't occur,
				** but since timing doesn't matter when
				** debugging, it doesn't hurt to leave the
				** tests here.
				*/
				if ( yydebug )
				{
					register int yy_i;

					(void)printf( "Error recovery discards " );
					if ( yychar == 0 )
						(void)printf( "token end-of-file\n" );
					else if ( yychar < 0 )
						(void)printf( "token -none-\n" );
					else
					{
						for ( yy_i = 0;
							yytoks[yy_i].t_val >= 0;
							yy_i++ )
						{
							if ( yytoks[yy_i].t_val
								== yychar )
							{
								break;
							}
						}
						(void)printf( "token %s\n",
							yytoks[yy_i].t_name );
					}
				}
#endif /* YYDEBUG */
				if ( yychar == 0 )	/* reached EOF. quit */
					YYABORT;
				yychar = -1;
				goto yy_newstate;
			}
		}/* end if ( yy_n == 0 ) */
		/*
		** reduction by production yy_n
		** put stack tops, etc. so things right after switch
		*/
#if YYDEBUG
		/*
		** if debugging, print the string that is the user's
		** specification of the reduction which is just about
		** to be done.
		*/
		if ( yydebug )
			(void)printf( "Reduce by (%d) \"%s\"\n",
				yy_n, yyreds[ yy_n ] );
#endif
		yytmp = yy_n;			/* value to switch over */
		yypvt = yy_pv;			/* $vars top of value stack */
		/*
		** Look in goto table for next state
		** Sorry about using yy_state here as temporary
		** register variable, but why not, if it works...
		** If yyr2[ yy_n ] doesn't have the low order bit
		** set, then there is no action to be done for
		** this reduction.  So, no saving & unsaving of
		** registers done.  The only difference between the
		** code just after the if and the body of the if is
		** the goto yy_stack in the body.  This way the test
		** can be made before the choice of what to do is needed.
		*/
		{
			/* length of production doubled with extra bit */
			register int yy_len = yyr2[ yy_n ];

			if ( !( yy_len & 01 ) )
			{
				yy_len >>= 1;
				yyval = ( yy_pv -= yy_len )[1];	/* $$ = $1 */
				yy_state = yypgo[ yy_n = yyr1[ yy_n ] ] +
					*( yy_ps -= yy_len ) + 1;
				if ( yy_state >= YYLAST ||
					yychk[ yy_state =
					yyact[ yy_state ] ] != -yy_n )
				{
					yy_state = yyact[ yypgo[ yy_n ] ];
				}
				goto yy_stack;
			}
			yy_len >>= 1;
			yyval = ( yy_pv -= yy_len )[1];	/* $$ = $1 */
			yy_state = yypgo[ yy_n = yyr1[ yy_n ] ] +
				*( yy_ps -= yy_len ) + 1;
			if ( yy_state >= YYLAST ||
				yychk[ yy_state = yyact[ yy_state ] ] != -yy_n )
			{
				yy_state = yyact[ yypgo[ yy_n ] ];
			}
		}
					/* save until reenter driver code */
		yystate = yy_state;
		yyps = yy_ps;
		yypv = yy_pv;
	}
	/*
	** code supplied by user is placed in this switch
	*/
	switch( yytmp )
	{
		
case 4:
# line 41 "sesh.y"
{printf("{%%\n\\leavevmode\\makeatletter%%\n");} break;
case 5:
# line 44 "sesh.y"
{printf("}%%\n\\end{hieroglyph}");} break;
case 9:
# line 54 "sesh.y"
{printf("%s", yypvt[-1]);} break;
case 11:
# line 60 "sesh.y"
{yyval= (YYSTYPE)genere(yypvt[-1],yypvt[-0],NULL); free(yypvt[-1]); free(yypvt[-0]);} break;
case 13:
# line 68 "sesh.y"
{yyval= (YYSTYPE)genere(yypvt[-1],"\\intermots%\n",NULL);
		  representation(yypvt[-1]);} break;
case 15:
# line 74 "sesh.y"
{yyval= (YYSTYPE)genere(yypvt[-1],yypvt[-0], NULL); free(yypvt[-1]); free(yypvt[-0]);} break;
case 16:
# line 75 "sesh.y"
{yyval= (YYSTYPE)genere( yypvt[-3], "\\AROBrempl ",
						    yypvt[-1], yypvt[-0], NULL);
			       free(yypvt[-3]); free(yypvt[-1]); free(yypvt[-0]);} break;
case 17:
# line 81 "sesh.y"
{yyval= yypvt[-0];} break;
case 18:
# line 82 "sesh.y"
{yyval= (YYSTYPE)genere("\\unhieroglyphe{", yypvt[-0], "}", NULL);
		 free(yypvt[-0]);} break;
case 19:
# line 84 "sesh.y"
{yyval= (YYSTYPE)genere("{\\rm ", yypvt[-0], "}", NULL); free(yypvt[-0]);} break;
case 20:
# line 85 "sesh.y"
{yyval= (YYSTYPE) genere("\\boite{\\hboiteI{",
						      yypvt[-2], "}",
						      yypvt[-0], "}", NULL);
			         free(yypvt[-2]);free(yypvt[-0]);} break;
case 23:
# line 94 "sesh.y"
{yyval= (YYSTYPE)genere("{\\footnotesize \\rm ", yypvt[-0], "}", NULL);
		        free(yypvt[-0]);} break;
case 24:
# line 96 "sesh.y"
{yyval= (YYSTYPE) genere("\\boiteinter{\\hboiteI{",
							  yypvt[-2], "}",
							  yypvt[-0], "}", NULL);
				     free(yypvt[-2]);free(yypvt[-0]);} break;
case 25:
# line 100 "sesh.y"
{yyval= yypvt[-1];} break;
case 26:
# line 104 "sesh.y"
{yyval=(YYSTYPE)genere("\\quartespace ",NULL);} break;
case 27:
# line 105 "sesh.y"
{yyval= (YYSTYPE)genere("\\cartouche{",yypvt[-1],"}",NULL);} break;
case 28:
# line 106 "sesh.y"
{yyval= (YYSTYPE)genere("\\debcartouche{",yypvt[-1],"}",NULL);} break;
case 29:
# line 107 "sesh.y"
{yyval= (YYSTYPE)genere("\\milcartouche{",yypvt[-1],"}",NULL);} break;
case 30:
# line 108 "sesh.y"
{yyval= (YYSTYPE)genere("\\fincartouche{",yypvt[-1],"}",NULL);} break;
case 31:
# line 109 "sesh.y"
{yyval=(YYSTYPE)genere("\\hachure{",yypvt[-1],"}%\n",NULL);
		       free(yypvt[-1]);} break;
case 32:
# line 111 "sesh.y"
{yyval=(YYSTYPE)genere("\\espace ",NULL);} break;
case 34:
# line 117 "sesh.y"
{yyval= (YYSTYPE)genere("\\hboite{", yypvt[-0], "}",NULL);
		    free(yypvt[-0]);} break;
case 35:
# line 119 "sesh.y"
{yyval= (YYSTYPE)genere(yypvt[-2], "\\hboite{" ,
							  yypvt[-0], "}",NULL);
				      free(yypvt[-2]);free(yypvt[-0]);} break;
case 36:
# line 124 "sesh.y"
{yyval= (YYSTYPE)genere(yypvt[-2], "\\hfil", yypvt[-0], NULL);
				      free(yypvt[-2]); free(yypvt[-0]);} break;
case 40:
# line 131 "sesh.y"
{yyval= yypvt[-1];} break;
case 42:
# line 136 "sesh.y"
{yyval= (YYSTYPE)genere( yypvt[-2], "\\hfil", yypvt[-0], NULL);
		       free(yypvt[-2]); free(yypvt[-0]);} break;
case 43:
# line 140 "sesh.y"
{yyval= (YYSTYPE)genere("",NULL);} break;
case 44:
# line 141 "sesh.y"
{yyval= (YYSTYPE)genere(yypvt[-1], "\\negAROBspace", NULL);
		   free(yypvt[-1]);} break;
	}
	goto yystack;		/* reset registers in driver code */
}
