#include "cpascal.h"
#include <setjmp.h> 
jmp_buf jmp9998, jmp32; int lab31=0;
/* 9998 9999 31 32 9932 */ 
#define bufsize 3000 
#define minprintline 3 
#define maxprintline 79 
#define auxstacksize 20 
#define maxbibfiles 1000 
#define poolsize 512000L 
#define maxstrings 20000 
#define maxcites 3000 
#define wizfnspace 3000 
#define singlefnspace 100 
#define maxentints 25000 
#define maxentstrs 10000 
#define entstrsize 100 
#define globstrsize 1000 
#define maxfields 69000L 
#define litstksize 100 
#define numbltinfns 37 
#define noptions 2 
#define argoptions 1 
typedef unsigned char ASCIIcode  ; 
typedef char lextype  ; 
typedef char idtype  ; 
typedef integer bufpointer  ; 
typedef ASCIIcode buftype [bufsize + 1] ; 
typedef integer poolpointer  ; 
typedef integer strnumber  ; 
typedef short hashloc  ; 
typedef short hashpointer  ; 
typedef char strilk  ; 
typedef char pdsloc  ; 
typedef char pdslen  ; 
typedef char pdstype [13] ; 
typedef integer auxnumber  ; 
typedef integer bibnumber  ; 
typedef integer citenumber  ; 
typedef char fnclass  ; 
typedef integer wizfnloc  ; 
typedef integer intentloc  ; 
typedef integer strentloc  ; 
typedef char strglobloc  ; 
typedef integer fieldloc  ; 
typedef short hashptr2  ; 
typedef integer litstkloc  ; 
typedef char stktype  ; 
typedef integer bltinrange  ; 
integer bad  ; 
char history  ; 
integer errcount  ; 
ASCIIcode xord[256]  ; 
ASCIIcode xchr[256]  ; 
lextype lexclass[256]  ; 
idtype idclass[256]  ; 
integer charwidth[256]  ; 
integer stringwidth  ; 
char nameoffile[PATHMAX + 1]  ; 
integer namelength  ; 
integer nameptr  ; 
buftype buffer  ; 
bufpointer last  ; 
buftype svbuffer  ; 
bufpointer svptr1  ; 
bufpointer svptr2  ; 
integer tmpptr, tmpendptr  ; 
ASCIIcode strpool[poolsize + 1]  ; 
poolpointer strstart[maxstrings + 1]  ; 
poolpointer poolptr  ; 
strnumber strptr  ; 
strnumber strnum  ; 
poolpointer pptr1, pptr2  ; 
hashpointer hashnext[21001]  ; 
strnumber hashtext[21001]  ; 
strilk hashilk[21001]  ; 
integer ilkinfo[21001]  ; 
short hashused  ; 
boolean hashfound  ; 
hashloc dummyloc  ; 
strnumber sauxextension  ; 
strnumber slogextension  ; 
strnumber sbblextension  ; 
strnumber sbstextension  ; 
strnumber sbibextension  ; 
strnumber sbstarea  ; 
strnumber sbibarea  ; 
hashloc predefloc  ; 
integer commandnum  ; 
bufpointer bufptr1  ; 
bufpointer bufptr2  ; 
char scanresult  ; 
integer tokenvalue  ; 
integer auxnamelength  ; 
alphafile auxfile[auxstacksize + 1]  ; 
strnumber auxlist[auxstacksize + 1]  ; 
auxnumber auxptr  ; 
integer auxlnstack[auxstacksize + 1]  ; 
strnumber toplevstr  ; 
alphafile logfile  ; 
alphafile bblfile  ; 
strnumber biblist[maxbibfiles + 1]  ; 
bibnumber bibptr  ; 
bibnumber numbibfiles  ; 
boolean bibseen  ; 
alphafile bibfile[maxbibfiles + 1]  ; 
boolean bstseen  ; 
strnumber bststr  ; 
alphafile bstfile  ; 
strnumber citelist[maxcites + 1]  ; 
citenumber citeptr  ; 
citenumber entryciteptr  ; 
citenumber numcites  ; 
citenumber oldnumcites  ; 
boolean citationseen  ; 
hashloc citeloc  ; 
hashloc lcciteloc  ; 
hashloc lcxciteloc  ; 
boolean citefound  ; 
boolean allentries  ; 
citenumber allmarker  ; 
integer bbllinenum  ; 
integer bstlinenum  ; 
hashloc fnloc  ; 
hashloc wizloc  ; 
hashloc literalloc  ; 
hashloc macronameloc  ; 
hashloc macrodefloc  ; 
fnclass fntype[21001]  ; 
wizfnloc wizdefptr  ; 
wizfnloc wizfnptr  ; 
hashptr2 wizfunctions[wizfnspace + 1]  ; 
intentloc intentptr  ; 
integer entryints[maxentints + 1]  ; 
intentloc numentints  ; 
strentloc strentptr  ; 
ASCIIcode entrystrs[maxentstrs + 1][entstrsize + 1]  ; 
strentloc numentstrs  ; 
char strglbptr  ; 
strnumber glbstrptr[10]  ; 
ASCIIcode globalstrs[10][globstrsize + 1]  ; 
integer glbstrend[10]  ; 
char numglbstrs  ; 
fieldloc fieldptr  ; 
fieldloc fieldparentptr, fieldendptr  ; 
citenumber citeparentptr, citexptr  ; 
strnumber fieldinfo[maxfields + 1]  ; 
fieldloc numfields  ; 
fieldloc numpredefinedfields  ; 
fieldloc crossrefnum  ; 
boolean nofields  ; 
boolean entryseen  ; 
boolean readseen  ; 
boolean readperformed  ; 
boolean readingcompleted  ; 
boolean readcompleted  ; 
integer implfnnum  ; 
integer biblinenum  ; 
hashloc entrytypeloc  ; 
hashptr2 typelist[maxcites + 1]  ; 
boolean typeexists  ; 
boolean entryexists[maxcites + 1]  ; 
boolean storeentry  ; 
hashloc fieldnameloc  ; 
hashloc fieldvalloc  ; 
boolean storefield  ; 
boolean storetoken  ; 
ASCIIcode rightouterdelim  ; 
ASCIIcode rightstrdelim  ; 
boolean atbibcommand  ; 
hashloc curmacroloc  ; 
strnumber citeinfo[maxcites + 1]  ; 
boolean citehashfound  ; 
bibnumber preambleptr  ; 
bibnumber numpreamblestrings  ; 
integer bibbracelevel  ; 
integer litstack[litstksize + 1]  ; 
stktype litstktype[litstksize + 1]  ; 
litstkloc litstkptr  ; 
strnumber cmdstrptr  ; 
integer entchrptr  ; 
integer globchrptr  ; 
buftype exbuf  ; 
bufpointer exbufptr  ; 
bufpointer exbuflength  ; 
buftype outbuf  ; 
bufpointer outbufptr  ; 
bufpointer outbuflength  ; 
boolean messwithentries  ; 
citenumber sortciteptr  ; 
strentloc sortkeynum  ; 
integer bracelevel  ; 
hashloc bequals  ; 
hashloc bgreaterthan  ; 
hashloc blessthan  ; 
hashloc bplus  ; 
hashloc bminus  ; 
hashloc bconcatenate  ; 
hashloc bgets  ; 
hashloc baddperiod  ; 
hashloc bcalltype  ; 
hashloc bchangecase  ; 
hashloc bchrtoint  ; 
hashloc bcite  ; 
hashloc bduplicate  ; 
hashloc bempty  ; 
hashloc bformatname  ; 
hashloc bif  ; 
hashloc binttochr  ; 
hashloc binttostr  ; 
hashloc bmissing  ; 
hashloc bnewline  ; 
hashloc bnumnames  ; 
hashloc bpop  ; 
hashloc bpreamble  ; 
hashloc bpurify  ; 
hashloc bquote  ; 
hashloc bskip  ; 
hashloc bstack  ; 
hashloc bsubstring  ; 
hashloc bswap  ; 
hashloc btextlength  ; 
hashloc btextprefix  ; 
hashloc btopstack  ; 
hashloc btype  ; 
hashloc bwarning  ; 
hashloc bwhile  ; 
hashloc bwidth  ; 
hashloc bwrite  ; 
hashloc bdefault  ; 
#ifdef STAT
hashloc bltinloc[numbltinfns + 1]  ; 
integer executioncount[numbltinfns + 1]  ; 
integer totalexcount  ; 
bltinrange bltinptr  ; 
#endif /* STAT */
strnumber snull  ; 
strnumber sdefault  ; 
strnumber st  ; 
strnumber sl  ; 
strnumber su  ; 
strnumber spreamble[maxbibfiles + 1]  ; 
integer poplit1, poplit2, poplit3  ; 
stktype poptyp1, poptyp2, poptyp3  ; 
poolpointer spptr  ; 
poolpointer spxptr1, spxptr2  ; 
poolpointer spend  ; 
poolpointer splength, sp2length  ; 
integer spbracelevel  ; 
bufpointer exbufxptr, exbufyptr  ; 
hashloc controlseqloc  ; 
boolean precedingwhite  ; 
boolean andfound  ; 
integer numnames  ; 
bufpointer namebfptr  ; 
bufpointer namebfxptr, namebfyptr  ; 
integer nmbracelevel  ; 
bufpointer nametok[bufsize + 1]  ; 
ASCIIcode namesepchar[bufsize + 1]  ; 
bufpointer numtokens  ; 
boolean tokenstarting  ; 
boolean alphafound  ; 
boolean doubleletter, endofgroup, tobewritten  ; 
bufpointer firststart  ; 
bufpointer firstend  ; 
bufpointer lastend  ; 
bufpointer vonstart  ; 
bufpointer vonend  ; 
bufpointer jrend  ; 
bufpointer curtoken, lasttoken  ; 
boolean usedefault  ; 
bufpointer numcommas  ; 
bufpointer comma1, comma2  ; 
bufpointer numtextchars  ; 
char conversiontype  ; 
boolean prevcolon  ; 
cinttype verbose  ; 
integer mincrossrefs  ; 

#include "coerce.h"
void 
printanewline ( ) 
{putc ('\n',  logfile );
  putc ('\n',  standardoutput );
} 
void 
markwarning ( ) 
{if ( ( history == 1 ) ) 
  errcount = errcount + 1 ; 
  else if ( ( history == 0 ) ) 
  {
    history = 1 ; 
    errcount = 1 ; 
  } 
} 
void 
markerror ( ) 
{if ( ( history < 2 ) ) 
  {
    history = 2 ; 
    errcount = 1 ; 
  } 
  else errcount = errcount + 1 ; 
} 
void 
markfatal ( ) 
{history = 3 ; 
} 
void 
printoverflow ( ) 
{{
    
    Fputs( logfile ,  "Sorry---you've exceeded BibTeX's " ) ; 
    Fputs( standardoutput ,  "Sorry---you've exceeded BibTeX's " ) ; 
  } 
  markfatal () ; 
} 
void 
printconfusion ( ) 
{{
    
    fprintf( logfile , "%s\n",  "---this can't happen" ) ; 
    fprintf( standardoutput , "%s\n",  "---this can't happen" ) ; 
  } 
  {
    fprintf( logfile , "%s\n",  "*Please notify the BibTeX maintainer*" ) ; 
    fprintf( standardoutput , "%s\n",  "*Please notify the BibTeX maintainer*" ) ; 
  } 
  markfatal () ; 
} 
void 
bufferoverflow ( ) 
{{
    
    printoverflow () ; 
    {
      fprintf( logfile , "%s%ld\n",  "buffer size " , (long)bufsize ) ; 
      fprintf( standardoutput , "%s%ld\n",  "buffer size " , (long)bufsize ) ; 
    } 
    longjmp(jmp9998,1) ; 
  } 
} 
boolean 
zinputln ( f ) 
  alphafile * f ; 
{/* 15 */ register boolean Result; last = 0 ; 
  if ( ( eof ( *f ) ) ) 
  Result = false ; 
  else {
      
    while ( ( ! eoln ( *f ) ) ) {
	
      if ( ( last >= bufsize ) ) 
      bufferoverflow () ; 
      buffer [ last ] = xord [ getc ( *f ) ] ; 
      last = last + 1 ; 
    } 
    vgetc ( *f ) ; 
    while ( ( last > 0 ) ) if ( ( lexclass [ buffer [ last - 1 ] ] == 1 ) ) 
    last = last - 1 ; 
    else goto lab15 ; 
    lab15: Result = true ; 
  } 
  return Result ; 
} 
void 
zoutpoolstr ( f , s ) 
  alphafile * f ; 
  strnumber s ; 
{poolpointer i  ; 
  if ( ( ( s < 0 ) || ( s >= strptr + 3 ) || ( s >= maxstrings ) ) ) 
  {
    {
      fprintf( logfile , "%s%ld",  "Illegal string number:" , (long)s ) ; 
      fprintf( standardoutput , "%s%ld",  "Illegal string number:" , (long)s ) ; 
    } 
    printconfusion () ; 
    longjmp(jmp9998,1) ; 
  } 
  {register integer for_end; i = strstart [ s ] ; for_end = strstart [ s + 1 
  ] - 1 ; if ( i <= for_end) do 
    putc ( xchr [ strpool [ i ] ] ,  *f );
  while ( i++ < for_end ) ; } 
} 
void 
zprintapoolstr ( s ) 
  strnumber s ; 
{outpoolstr ( standardoutput , s ) ; 
  outpoolstr ( logfile , s ) ; 
} 
void 
pooloverflow ( ) 
{{
    
    printoverflow () ; 
    {
      fprintf( logfile , "%s%ld\n",  "pool size " , (long)poolsize ) ; 
      fprintf( standardoutput , "%s%ld\n",  "pool size " , (long)poolsize ) ; 
    } 
    longjmp(jmp9998,1) ; 
  } 
} 
void 
filenmsizeoverflow ( ) 
{{
    
    printoverflow () ; 
    {
      fprintf( logfile , "%s%ld\n",  "file name size " , (long)PATHMAX ) ; 
      fprintf( standardoutput , "%s%ld\n",  "file name size " , (long)PATHMAX ) ; 
    } 
    longjmp(jmp9998,1) ; 
  } 
} 
void 
zouttoken ( f ) 
  alphafile * f ; 
{bufpointer i  ; 
  i = bufptr1 ; 
  while ( ( i < bufptr2 ) ) {
      
    putc ( xchr [ buffer [ i ] ] ,  *f );
    i = i + 1 ; 
  } 
} 
void 
printatoken ( ) 
{outtoken ( standardoutput ) ; 
  outtoken ( logfile ) ; 
} 
void 
printbadinputline ( ) 
{bufpointer bfptr  ; 
  {
    Fputs( logfile ,  " : " ) ; 
    Fputs( standardoutput ,  " : " ) ; 
  } 
  bfptr = 0 ; 
  while ( ( bfptr < bufptr2 ) ) {
      
    if ( ( lexclass [ buffer [ bfptr ] ] == 1 ) ) 
    {
      putc ( xchr [ 32 ] ,  logfile );
      putc ( xchr [ 32 ] ,  standardoutput );
    } 
    else {
	
      putc ( xchr [ buffer [ bfptr ] ] ,  logfile );
      putc ( xchr [ buffer [ bfptr ] ] ,  standardoutput );
    } 
    bfptr = bfptr + 1 ; 
  } 
  printanewline () ; 
  {
    Fputs( logfile ,  " : " ) ; 
    Fputs( standardoutput ,  " : " ) ; 
  } 
  bfptr = 0 ; 
  while ( ( bfptr < bufptr2 ) ) {
      
    {
      putc ( xchr [ 32 ] ,  logfile );
      putc ( xchr [ 32 ] ,  standardoutput );
    } 
    bfptr = bfptr + 1 ; 
  } 
  bfptr = bufptr2 ; 
  while ( ( bfptr < last ) ) {
      
    if ( ( lexclass [ buffer [ bfptr ] ] == 1 ) ) 
    {
      putc ( xchr [ 32 ] ,  logfile );
      putc ( xchr [ 32 ] ,  standardoutput );
    } 
    else {
	
      putc ( xchr [ buffer [ bfptr ] ] ,  logfile );
      putc ( xchr [ buffer [ bfptr ] ] ,  standardoutput );
    } 
    bfptr = bfptr + 1 ; 
  } 
  printanewline () ; 
  bfptr = 0 ; 
  while ( ( ( bfptr < bufptr2 ) && ( lexclass [ buffer [ bfptr ] ] == 1 ) ) ) 
  bfptr = bfptr + 1 ; 
  if ( ( bfptr == bufptr2 ) ) 
  {
    fprintf( logfile , "%s\n",  "(Error may have been on previous line)" ) ; 
    fprintf( standardoutput , "%s\n",  "(Error may have been on previous line)" ) ; 
  } 
  markerror () ; 
} 
void 
printskippingwhateverremains ( ) 
{{
    
    Fputs( logfile ,  "I'm skipping whatever remains of this " ) ; 
    Fputs( standardoutput ,  "I'm skipping whatever remains of this " ) ; 
  } 
} 
void 
samtoolongfilenameprint ( ) 
{Fputs( standardoutput ,  "File name `" ) ; 
  nameptr = 1 ; 
  while ( ( nameptr <= auxnamelength ) ) {
      
    putc ( nameoffile [ nameptr ] ,  standardoutput );
    nameptr = nameptr + 1 ; 
  } 
  fprintf( standardoutput , "%s\n",  "' is too long" ) ; 
} 
void 
samwrongfilenameprint ( ) 
{Fputs( standardoutput ,  "I couldn't open file name `" ) ; 
  nameptr = 1 ; 
  while ( ( nameptr <= namelength ) ) {
      
    putc ( nameoffile [ nameptr ] ,  standardoutput );
    nameptr = nameptr + 1 ; 
  } 
  fprintf( standardoutput , "%c\n",  '\'' ) ; 
} 
void 
printauxname ( ) 
{printapoolstr ( auxlist [ auxptr ] ) ; 
  printanewline () ; 
} 
void 
auxerrprint ( ) 
{{
    
    fprintf( logfile , "%s%ld%s",  "---line " , (long)auxlnstack [ auxptr ] , " of file " ) ; 
    fprintf( standardoutput , "%s%ld%s",  "---line " , (long)auxlnstack [ auxptr ] , " of file "     ) ; 
  } 
  printauxname () ; 
  printbadinputline () ; 
  printskippingwhateverremains () ; 
  {
    fprintf( logfile , "%s\n",  "command" ) ; 
    fprintf( standardoutput , "%s\n",  "command" ) ; 
  } 
} 
void 
zauxerrillegalanotherprint ( cmdnum ) 
  integer cmdnum ; 
{{
    
    Fputs( logfile ,  "Illegal, another \\bib" ) ; 
    Fputs( standardoutput ,  "Illegal, another \\bib" ) ; 
  } 
  switch ( ( cmdnum ) ) 
  {case 0 : 
    {
      Fputs( logfile ,  "data" ) ; 
      Fputs( standardoutput ,  "data" ) ; 
    } 
    break ; 
  case 1 : 
    {
      Fputs( logfile ,  "style" ) ; 
      Fputs( standardoutput ,  "style" ) ; 
    } 
    break ; 
    default: 
    {
      {
	Fputs( logfile ,  "Illegal auxiliary-file command" ) ; 
	Fputs( standardoutput ,  "Illegal auxiliary-file command" ) ; 
      } 
      printconfusion () ; 
      longjmp(jmp9998,1) ; 
    } 
    break ; 
  } 
  {
    Fputs( logfile ,  " command" ) ; 
    Fputs( standardoutput ,  " command" ) ; 
  } 
} 
void 
auxerrnorightbraceprint ( ) 
{{
    
    fprintf( logfile , "%s%c%c",  "No \"" , xchr [ 125 ] , '"' ) ; 
    fprintf( standardoutput , "%s%c%c",  "No \"" , xchr [ 125 ] , '"' ) ; 
  } 
} 
void 
auxerrstuffafterrightbraceprint ( ) 
{{
    
    fprintf( logfile , "%s%c%c",  "Stuff after \"" , xchr [ 125 ] , '"' ) ; 
    fprintf( standardoutput , "%s%c%c",  "Stuff after \"" , xchr [ 125 ] , '"' ) ; 
  } 
} 
void 
auxerrwhitespaceinargumentprint ( ) 
{{
    
    Fputs( logfile ,  "White space in argument" ) ; 
    Fputs( standardoutput ,  "White space in argument" ) ; 
  } 
} 
void 
printbibname ( ) 
{printapoolstr ( biblist [ bibptr ] ) ; 
  printapoolstr ( sbibextension ) ; 
  printanewline () ; 
} 
void 
printbstname ( ) 
{printapoolstr ( bststr ) ; 
  printapoolstr ( sbstextension ) ; 
  printanewline () ; 
} 
void 
hashciteconfusion ( ) 
{{
    
    {
      Fputs( logfile ,  "Cite hash error" ) ; 
      Fputs( standardoutput ,  "Cite hash error" ) ; 
    } 
    printconfusion () ; 
    longjmp(jmp9998,1) ; 
  } 
} 
void 
zcheckciteoverflow ( lastcite ) 
  citenumber lastcite ; 
{if ( ( lastcite == maxcites ) ) 
  {
    printapoolstr ( hashtext [ citeloc ] ) ; 
    {
      fprintf( logfile , "%s\n",  " is the key:" ) ; 
      fprintf( standardoutput , "%s\n",  " is the key:" ) ; 
    } 
    {
      printoverflow () ; 
      {
	fprintf( logfile , "%s%ld\n",  "number of cite keys " , (long)maxcites ) ; 
	fprintf( standardoutput , "%s%ld\n",  "number of cite keys " , (long)maxcites ) ; 
      } 
      longjmp(jmp9998,1) ; 
    } 
  } 
} 
void 
auxend1errprint ( ) 
{{
    
    Fputs( logfile ,  "I found no " ) ; 
    Fputs( standardoutput ,  "I found no " ) ; 
  } 
} 
void 
auxend2errprint ( ) 
{{
    
    Fputs( logfile ,  "---while reading file " ) ; 
    Fputs( standardoutput ,  "---while reading file " ) ; 
  } 
  printauxname () ; 
  markerror () ; 
} 
void 
bstlnnumprint ( ) 
{{
    
    fprintf( logfile , "%s%ld%s",  "--line " , (long)bstlinenum , " of file " ) ; 
    fprintf( standardoutput , "%s%ld%s",  "--line " , (long)bstlinenum , " of file " ) ; 
  } 
  printbstname () ; 
} 
void 
bsterrprintandlookforblankline ( ) 
{{
    
    putc ( '-' ,  logfile );
    putc ( '-' ,  standardoutput );
  } 
  bstlnnumprint () ; 
  printbadinputline () ; 
  while ( ( last != 0 ) ) if ( ( ! inputln ( bstfile ) ) ) 
  longjmp(jmp32,1) ; 
  else bstlinenum = bstlinenum + 1 ; 
  bufptr2 = last ; 
} 
void 
bstwarnprint ( ) 
{bstlnnumprint () ; 
  markwarning () ; 
} 
void 
eatbstprint ( ) 
{{
    
    Fputs( logfile ,  "Illegal end of style file in command: " ) ; 
    Fputs( standardoutput ,  "Illegal end of style file in command: " ) ; 
  } 
} 
void 
unknwnfunctionclassconfusion ( ) 
{{
    
    {
      Fputs( logfile ,  "Unknown function class" ) ; 
      Fputs( standardoutput ,  "Unknown function class" ) ; 
    } 
    printconfusion () ; 
    longjmp(jmp9998,1) ; 
  } 
} 
void 
zprintfnclass ( fnloc ) 
  hashloc fnloc ; 
{switch ( ( fntype [ fnloc ] ) ) 
  {case 0 : 
    {
      Fputs( logfile ,  "built-in" ) ; 
      Fputs( standardoutput ,  "built-in" ) ; 
    } 
    break ; 
  case 1 : 
    {
      Fputs( logfile ,  "wizard-defined" ) ; 
      Fputs( standardoutput ,  "wizard-defined" ) ; 
    } 
    break ; 
  case 2 : 
    {
      Fputs( logfile ,  "integer-literal" ) ; 
      Fputs( standardoutput ,  "integer-literal" ) ; 
    } 
    break ; 
  case 3 : 
    {
      Fputs( logfile ,  "string-literal" ) ; 
      Fputs( standardoutput ,  "string-literal" ) ; 
    } 
    break ; 
  case 4 : 
    {
      Fputs( logfile ,  "field" ) ; 
      Fputs( standardoutput ,  "field" ) ; 
    } 
    break ; 
  case 5 : 
    {
      Fputs( logfile ,  "integer-entry-variable" ) ; 
      Fputs( standardoutput ,  "integer-entry-variable" ) ; 
    } 
    break ; 
  case 6 : 
    {
      Fputs( logfile ,  "string-entry-variable" ) ; 
      Fputs( standardoutput ,  "string-entry-variable" ) ; 
    } 
    break ; 
  case 7 : 
    {
      Fputs( logfile ,  "integer-global-variable" ) ; 
      Fputs( standardoutput ,  "integer-global-variable" ) ; 
    } 
    break ; 
  case 8 : 
    {
      Fputs( logfile ,  "string-global-variable" ) ; 
      Fputs( standardoutput ,  "string-global-variable" ) ; 
    } 
    break ; 
    default: 
    unknwnfunctionclassconfusion () ; 
    break ; 
  } 
} 
#ifdef TRACE
void 
ztraceprfnclass ( fnloc ) 
  hashloc fnloc ; 
{switch ( ( fntype [ fnloc ] ) ) 
  {case 0 : 
    {
      Fputs( logfile ,  "built-in" ) ; 
    } 
    break ; 
  case 1 : 
    {
      Fputs( logfile ,  "wizard-defined" ) ; 
    } 
    break ; 
  case 2 : 
    {
      Fputs( logfile ,  "integer-literal" ) ; 
    } 
    break ; 
  case 3 : 
    {
      Fputs( logfile ,  "string-literal" ) ; 
    } 
    break ; 
  case 4 : 
    {
      Fputs( logfile ,  "field" ) ; 
    } 
    break ; 
  case 5 : 
    {
      Fputs( logfile ,  "integer-entry-variable" ) ; 
    } 
    break ; 
  case 6 : 
    {
      Fputs( logfile ,  "string-entry-variable" ) ; 
    } 
    break ; 
  case 7 : 
    {
      Fputs( logfile ,  "integer-global-variable" ) ; 
    } 
    break ; 
  case 8 : 
    {
      Fputs( logfile ,  "string-global-variable" ) ; 
    } 
    break ; 
    default: 
    unknwnfunctionclassconfusion () ; 
    break ; 
  } 
} 
#endif /* TRACE */
void 
idscanningconfusion ( ) 
{{
    
    {
      Fputs( logfile ,  "Identifier scanning error" ) ; 
      Fputs( standardoutput ,  "Identifier scanning error" ) ; 
    } 
    printconfusion () ; 
    longjmp(jmp9998,1) ; 
  } 
} 
void 
bstidprint ( ) 
{if ( ( scanresult == 0 ) ) 
  {
    fprintf( logfile , "%c%c%s",  '"' , xchr [ buffer [ bufptr2 ] ] ,     "\" begins identifier, command: " ) ; 
    fprintf( standardoutput , "%c%c%s",  '"' , xchr [ buffer [ bufptr2 ] ] ,     "\" begins identifier, command: " ) ; 
  } 
  else if ( ( scanresult == 2 ) ) 
  {
    fprintf( logfile , "%c%c%s",  '"' , xchr [ buffer [ bufptr2 ] ] ,     "\" immediately follows identifier, command: " ) ; 
    fprintf( standardoutput , "%c%c%s",  '"' , xchr [ buffer [ bufptr2 ] ] ,     "\" immediately follows identifier, command: " ) ; 
  } 
  else idscanningconfusion () ; 
} 
void 
bstleftbraceprint ( ) 
{{
    
    fprintf( logfile , "%c%c%s",  '"' , xchr [ 123 ] , "\" is missing in command: " ) ; 
    fprintf( standardoutput , "%c%c%s",  '"' , xchr [ 123 ] , "\" is missing in command: "     ) ; 
  } 
} 
void 
bstrightbraceprint ( ) 
{{
    
    fprintf( logfile , "%c%c%s",  '"' , xchr [ 125 ] , "\" is missing in command: " ) ; 
    fprintf( standardoutput , "%c%c%s",  '"' , xchr [ 125 ] , "\" is missing in command: "     ) ; 
  } 
} 
void 
zalreadyseenfunctionprint ( seenfnloc ) 
  hashloc seenfnloc ; 
{/* 10 */ printapoolstr ( hashtext [ seenfnloc ] ) ; 
  {
    Fputs( logfile ,  " is already a type \"" ) ; 
    Fputs( standardoutput ,  " is already a type \"" ) ; 
  } 
  printfnclass ( seenfnloc ) ; 
  {
    fprintf( logfile , "%s\n",  "\" function name" ) ; 
    fprintf( standardoutput , "%s\n",  "\" function name" ) ; 
  } 
  {
    bsterrprintandlookforblankline () ; 
    goto lab10 ; 
  } 
  lab10: ; 
} 
void 
singlfnoverflow ( ) 
{{
    
    printoverflow () ; 
    {
      fprintf( logfile , "%s%ld\n",  "single function space " , (long)singlefnspace ) ; 
      fprintf( standardoutput , "%s%ld\n",  "single function space " , (long)singlefnspace ) ; 
    } 
    longjmp(jmp9998,1) ; 
  } 
} 
void 
biblnnumprint ( ) 
{{
    
    fprintf( logfile , "%s%ld%s",  "--line " , (long)biblinenum , " of file " ) ; 
    fprintf( standardoutput , "%s%ld%s",  "--line " , (long)biblinenum , " of file " ) ; 
  } 
  printbibname () ; 
} 
void 
biberrprint ( ) 
{{
    
    putc ( '-' ,  logfile );
    putc ( '-' ,  standardoutput );
  } 
  biblnnumprint () ; 
  printbadinputline () ; 
  printskippingwhateverremains () ; 
  if ( ( atbibcommand ) ) 
  {
    fprintf( logfile , "%s\n",  "command" ) ; 
    fprintf( standardoutput , "%s\n",  "command" ) ; 
  } 
  else {
      
    fprintf( logfile , "%s\n",  "entry" ) ; 
    fprintf( standardoutput , "%s\n",  "entry" ) ; 
  } 
} 
void 
bibwarnprint ( ) 
{biblnnumprint () ; 
  markwarning () ; 
} 
void 
zcheckfieldoverflow ( totalfields ) 
  integer totalfields ; 
{if ( ( totalfields > maxfields ) ) 
  {
    {
      fprintf( logfile , "%ld%s\n",  (long)totalfields , " fields:" ) ; 
      fprintf( standardoutput , "%ld%s\n",  (long)totalfields , " fields:" ) ; 
    } 
    {
      printoverflow () ; 
      {
	fprintf( logfile , "%s%ld\n",  "total number of fields " , (long)maxfields ) ; 
	fprintf( standardoutput , "%s%ld\n",  "total number of fields " , (long)maxfields ) ; 
      } 
      longjmp(jmp9998,1) ; 
    } 
  } 
} 
void 
eatbibprint ( ) 
{/* 10 */ {
    
    {
      Fputs( logfile ,  "Illegal end of database file" ) ; 
      Fputs( standardoutput ,  "Illegal end of database file" ) ; 
    } 
    biberrprint () ; 
    goto lab10 ; 
  } 
  lab10: ; 
} 
void 
zbiboneoftwoprint ( char1 , char2 ) 
  ASCIIcode char1 ; 
  ASCIIcode char2 ; 
{/* 10 */ {
    
    {
      fprintf( logfile , "%s%c%s%c%c",  "I was expecting a `" , xchr [ char1 ] , "' or a `" ,       xchr [ char2 ] , '\'' ) ; 
      fprintf( standardoutput , "%s%c%s%c%c",  "I was expecting a `" , xchr [ char1 ] ,       "' or a `" , xchr [ char2 ] , '\'' ) ; 
    } 
    biberrprint () ; 
    goto lab10 ; 
  } 
  lab10: ; 
} 
void 
bibequalssignprint ( ) 
{/* 10 */ {
    
    {
      fprintf( logfile , "%s%c%c",  "I was expecting an \"" , xchr [ 61 ] , '"' ) ; 
      fprintf( standardoutput , "%s%c%c",  "I was expecting an \"" , xchr [ 61 ] , '"' ) ; 
    } 
    biberrprint () ; 
    goto lab10 ; 
  } 
  lab10: ; 
} 
void 
bibunbalancedbracesprint ( ) 
{/* 10 */ {
    
    {
      Fputs( logfile ,  "Unbalanced braces" ) ; 
      Fputs( standardoutput ,  "Unbalanced braces" ) ; 
    } 
    biberrprint () ; 
    goto lab10 ; 
  } 
  lab10: ; 
} 
void 
bibfieldtoolongprint ( ) 
{/* 10 */ {
    
    {
      fprintf( logfile , "%s%ld%s",  "Your field is more than " , (long)bufsize , " characters" ) 
      ; 
      fprintf( standardoutput , "%s%ld%s",  "Your field is more than " , (long)bufsize ,       " characters" ) ; 
    } 
    biberrprint () ; 
    goto lab10 ; 
  } 
  lab10: ; 
} 
void 
macrowarnprint ( ) 
{{
    
    Fputs( logfile ,  "Warning--string name \"" ) ; 
    Fputs( standardoutput ,  "Warning--string name \"" ) ; 
  } 
  printatoken () ; 
  {
    Fputs( logfile ,  "\" is " ) ; 
    Fputs( standardoutput ,  "\" is " ) ; 
  } 
} 
void 
bibidprint ( ) 
{if ( ( scanresult == 0 ) ) 
  {
    Fputs( logfile ,  "You're missing " ) ; 
    Fputs( standardoutput ,  "You're missing " ) ; 
  } 
  else if ( ( scanresult == 2 ) ) 
  {
    fprintf( logfile , "%c%c%s",  '"' , xchr [ buffer [ bufptr2 ] ] ,     "\" immediately follows " ) ; 
    fprintf( standardoutput , "%c%c%s",  '"' , xchr [ buffer [ bufptr2 ] ] ,     "\" immediately follows " ) ; 
  } 
  else idscanningconfusion () ; 
} 
void 
bibcmdconfusion ( ) 
{{
    
    {
      Fputs( logfile ,  "Unknown database-file command" ) ; 
      Fputs( standardoutput ,  "Unknown database-file command" ) ; 
    } 
    printconfusion () ; 
    longjmp(jmp9998,1) ; 
  } 
} 
void 
citekeydisappearedconfusion ( ) 
{{
    
    {
      Fputs( logfile ,  "A cite key disappeared" ) ; 
      Fputs( standardoutput ,  "A cite key disappeared" ) ; 
    } 
    printconfusion () ; 
    longjmp(jmp9998,1) ; 
  } 
} 
void 
zbadcrossreferenceprint ( s ) 
  strnumber s ; 
{{
    
    Fputs( logfile ,  "--entry \"" ) ; 
    Fputs( standardoutput ,  "--entry \"" ) ; 
  } 
  printapoolstr ( citelist [ citeptr ] ) ; 
  {
    fprintf( logfile , "%c\n",  '"' ) ; 
    fprintf( standardoutput , "%c\n",  '"' ) ; 
  } 
  {
    Fputs( logfile ,  "refers to entry \"" ) ; 
    Fputs( standardoutput ,  "refers to entry \"" ) ; 
  } 
  printapoolstr ( s ) ; 
} 
void 
nonexistentcrossreferenceerror ( ) 
{{
    
    Fputs( logfile ,  "A bad cross reference-" ) ; 
    Fputs( standardoutput ,  "A bad cross reference-" ) ; 
  } 
  badcrossreferenceprint ( fieldinfo [ fieldptr ] ) ; 
  {
    fprintf( logfile , "%s\n",  "\", which doesn't exist" ) ; 
    fprintf( standardoutput , "%s\n",  "\", which doesn't exist" ) ; 
  } 
  markerror () ; 
} 
void 
zprintmissingentry ( s ) 
  strnumber s ; 
{{
    
    Fputs( logfile ,  "Warning--I didn't find a database entry for \"" ) ; 
    Fputs( standardoutput ,  "Warning--I didn't find a database entry for \""     ) ; 
  } 
  printapoolstr ( s ) ; 
  {
    fprintf( logfile , "%c\n",  '"' ) ; 
    fprintf( standardoutput , "%c\n",  '"' ) ; 
  } 
  markwarning () ; 
} 
void 
bstexwarnprint ( ) 
{if ( ( messwithentries ) ) 
  {
    {
      Fputs( logfile ,  " for entry " ) ; 
      Fputs( standardoutput ,  " for entry " ) ; 
    } 
    printapoolstr ( citelist [ citeptr ] ) ; 
  } 
  printanewline () ; 
  {
    Fputs( logfile ,  "while executing-" ) ; 
    Fputs( standardoutput ,  "while executing-" ) ; 
  } 
  bstlnnumprint () ; 
  markerror () ; 
} 
void 
bstmildexwarnprint ( ) 
{if ( ( messwithentries ) ) 
  {
    {
      Fputs( logfile ,  " for entry " ) ; 
      Fputs( standardoutput ,  " for entry " ) ; 
    } 
    printapoolstr ( citelist [ citeptr ] ) ; 
  } 
  printanewline () ; 
  {
    {
      Fputs( logfile ,  "while executing" ) ; 
      Fputs( standardoutput ,  "while executing" ) ; 
    } 
    bstwarnprint () ; 
  } 
} 
void 
bstcantmesswithentriesprint ( ) 
{{
    
    {
      Fputs( logfile ,  "You can't mess with entries here" ) ; 
      Fputs( standardoutput ,  "You can't mess with entries here" ) ; 
    } 
    bstexwarnprint () ; 
  } 
} 
void 
illeglliteralconfusion ( ) 
{{
    
    {
      Fputs( logfile ,  "Illegal literal type" ) ; 
      Fputs( standardoutput ,  "Illegal literal type" ) ; 
    } 
    printconfusion () ; 
    longjmp(jmp9998,1) ; 
  } 
} 
void 
unknwnliteralconfusion ( ) 
{{
    
    {
      Fputs( logfile ,  "Unknown literal type" ) ; 
      Fputs( standardoutput ,  "Unknown literal type" ) ; 
    } 
    printconfusion () ; 
    longjmp(jmp9998,1) ; 
  } 
} 
void 
zprintstklit ( stklt , stktp ) 
  integer stklt ; 
  stktype stktp ; 
{switch ( ( stktp ) ) 
  {case 0 : 
    {
      fprintf( logfile , "%ld%s",  (long)stklt , " is an integer literal" ) ; 
      fprintf( standardoutput , "%ld%s",  (long)stklt , " is an integer literal" ) ; 
    } 
    break ; 
  case 1 : 
    {
      {
	putc ( '"' ,  logfile );
	putc ( '"' ,  standardoutput );
      } 
      printapoolstr ( stklt ) ; 
      {
	Fputs( logfile ,  "\" is a string literal" ) ; 
	Fputs( standardoutput ,  "\" is a string literal" ) ; 
      } 
    } 
    break ; 
  case 2 : 
    {
      {
	putc ( '`' ,  logfile );
	putc ( '`' ,  standardoutput );
      } 
      printapoolstr ( hashtext [ stklt ] ) ; 
      {
	Fputs( logfile ,  "' is a function literal" ) ; 
	Fputs( standardoutput ,  "' is a function literal" ) ; 
      } 
    } 
    break ; 
  case 3 : 
    {
      {
	putc ( '`' ,  logfile );
	putc ( '`' ,  standardoutput );
      } 
      printapoolstr ( stklt ) ; 
      {
	Fputs( logfile ,  "' is a missing field" ) ; 
	Fputs( standardoutput ,  "' is a missing field" ) ; 
      } 
    } 
    break ; 
  case 4 : 
    illeglliteralconfusion () ; 
    break ; 
    default: 
    unknwnliteralconfusion () ; 
    break ; 
  } 
} 
void 
zprintlit ( stklt , stktp ) 
  integer stklt ; 
  stktype stktp ; 
{switch ( ( stktp ) ) 
  {case 0 : 
    {
      fprintf( logfile , "%ld\n",  (long)stklt ) ; 
      fprintf( standardoutput , "%ld\n",  (long)stklt ) ; 
    } 
    break ; 
  case 1 : 
    {
      printapoolstr ( stklt ) ; 
      printanewline () ; 
    } 
    break ; 
  case 2 : 
    {
      printapoolstr ( hashtext [ stklt ] ) ; 
      printanewline () ; 
    } 
    break ; 
  case 3 : 
    {
      printapoolstr ( stklt ) ; 
      printanewline () ; 
    } 
    break ; 
  case 4 : 
    illeglliteralconfusion () ; 
    break ; 
    default: 
    unknwnliteralconfusion () ; 
    break ; 
  } 
} 
void 
outputbblline ( ) 
{/* 15 10 */ if ( ( outbuflength != 0 ) ) 
  {
    while ( ( outbuflength > 0 ) ) if ( ( lexclass [ outbuf [ outbuflength - 1 
    ] ] == 1 ) ) 
    outbuflength = outbuflength - 1 ; 
    else goto lab15 ; 
    lab15: if ( ( outbuflength == 0 ) ) 
    goto lab10 ; 
    outbufptr = 0 ; 
    while ( ( outbufptr < outbuflength ) ) {
	
      putc ( xchr [ outbuf [ outbufptr ] ] ,  bblfile );
      outbufptr = outbufptr + 1 ; 
    } 
  } 
  putc ('\n',  bblfile );
  bbllinenum = bbllinenum + 1 ; 
  outbuflength = 0 ; 
  lab10: ; 
} 
void 
bst1printstringsizeexceeded ( ) 
{{
    
    Fputs( logfile ,  "Warning--you've exceeded " ) ; 
    Fputs( standardoutput ,  "Warning--you've exceeded " ) ; 
  } 
} 
void 
bst2printstringsizeexceeded ( ) 
{{
    
    Fputs( logfile ,  "-string-size," ) ; 
    Fputs( standardoutput ,  "-string-size," ) ; 
  } 
  bstmildexwarnprint () ; 
  {
    fprintf( logfile , "%s\n",  "*Please notify the bibstyle designer*" ) ; 
    fprintf( standardoutput , "%s\n",  "*Please notify the bibstyle designer*" ) ; 
  } 
} 
void 
zbracesunbalancedcomplaint ( poplitvar ) 
  strnumber poplitvar ; 
{{
    
    Fputs( logfile ,  "Warning--\"" ) ; 
    Fputs( standardoutput ,  "Warning--\"" ) ; 
  } 
  printapoolstr ( poplitvar ) ; 
  {
    {
      Fputs( logfile ,  "\" isn't a brace-balanced string" ) ; 
      Fputs( standardoutput ,  "\" isn't a brace-balanced string" ) ; 
    } 
    bstmildexwarnprint () ; 
  } 
} 
void 
caseconversionconfusion ( ) 
{{
    
    {
      Fputs( logfile ,  "Unknown type of case conversion" ) ; 
      Fputs( standardoutput ,  "Unknown type of case conversion" ) ; 
    } 
    printconfusion () ; 
    longjmp(jmp9998,1) ; 
  } 
} 
void 
traceandstatprinting ( ) 
{
	;
#ifdef TRACE
  {
    if ( ( numbibfiles == 1 ) ) 
    {
      fprintf( logfile , "%s\n",  "The 1 database file is" ) ; 
    } 
    else {
	
      fprintf( logfile , "%s%ld%s\n",  "The " , (long)numbibfiles , " database files are" ) ; 
    } 
    if ( ( numbibfiles == 0 ) ) 
    {
      fprintf( logfile , "%s\n",  "   undefined" ) ; 
    } 
    else {
	
      bibptr = 0 ; 
      while ( ( bibptr < numbibfiles ) ) {
	  
	{
	  Fputs( logfile ,  "   " ) ; 
	} 
	{
	  outpoolstr ( logfile , biblist [ bibptr ] ) ; 
	} 
	{
	  outpoolstr ( logfile , sbibextension ) ; 
	} 
	{
	  putc ('\n',  logfile );
	} 
	bibptr = bibptr + 1 ; 
      } 
    } 
    {
      Fputs( logfile ,  "The style file is " ) ; 
    } 
    if ( ( bststr == 0 ) ) 
    {
      fprintf( logfile , "%s\n",  "undefined" ) ; 
    } 
    else {
	
      {
	outpoolstr ( logfile , bststr ) ; 
      } 
      {
	outpoolstr ( logfile , sbstextension ) ; 
      } 
      {
	putc ('\n',  logfile );
      } 
    } 
  } 
  {
    if ( ( allentries ) ) 
    {
      fprintf( logfile , "%s%ld%s",  "all_marker=" , (long)allmarker , ", " ) ; 
    } 
    if ( ( readperformed ) ) 
    {
      fprintf( logfile , "%s%ld\n",  "old_num_cites=" , (long)oldnumcites ) ; 
    } 
    else {
	
      putc ('\n',  logfile );
    } 
    {
      fprintf( logfile , "%s%ld",  "The " , (long)numcites ) ; 
    } 
    if ( ( numcites == 1 ) ) 
    {
      fprintf( logfile , "%s\n",  " entry:" ) ; 
    } 
    else {
	
      fprintf( logfile , "%s\n",  " entries:" ) ; 
    } 
    if ( ( numcites == 0 ) ) 
    {
      fprintf( logfile , "%s\n",  "   undefined" ) ; 
    } 
    else {
	
      sortciteptr = 0 ; 
      while ( ( sortciteptr < numcites ) ) {
	  
	if ( ( ! readcompleted ) ) 
	citeptr = sortciteptr ; 
	else citeptr = citeinfo [ sortciteptr ] ; 
	{
	  outpoolstr ( logfile , citelist [ citeptr ] ) ; 
	} 
	if ( ( readperformed ) ) 
	{
	  {
	    Fputs( logfile ,  ", entry-type " ) ; 
	  } 
	  if ( ( typelist [ citeptr ] == 21001 ) ) 
	  lab21001: {
	      
	    Fputs( logfile ,  "unknown" ) ; 
	  } 
	  else if ( ( typelist [ citeptr ] == 0 ) ) 
	  {
	    Fputs( logfile ,  "--- no type found" ) ; 
	  } 
	  else {
	      
	    outpoolstr ( logfile , hashtext [ typelist [ citeptr ] ] ) ; 
	  } 
	  {
	    fprintf( logfile , "%s\n",  ", has entry strings" ) ; 
	  } 
	  {
	    if ( ( numentstrs == 0 ) ) 
	    {
	      fprintf( logfile , "%s\n",  "    undefined" ) ; 
	    } 
	    else if ( ( ! readcompleted ) ) 
	    {
	      fprintf( logfile , "%s\n",  "    uninitialized" ) ; 
	    } 
	    else {
		
	      strentptr = citeptr * numentstrs ; 
	      while ( ( strentptr < ( citeptr + 1 ) * numentstrs ) ) {
		  
		entchrptr = 0 ; 
		{
		  Fputs( logfile ,  "    \"" ) ; 
		} 
		while ( ( entrystrs [ strentptr ] [ entchrptr ] != 127 ) ) {
		    
		  {
		    putc ( xchr [ entrystrs [ strentptr ] [                     entchrptr ] ] ,  logfile );
		  } 
		  entchrptr = entchrptr + 1 ; 
		} 
		{
		  fprintf( logfile , "%c\n",  '"' ) ; 
		} 
		strentptr = strentptr + 1 ; 
	      } 
	    } 
	  } 
	  {
	    Fputs( logfile ,  "  has entry integers" ) ; 
	  } 
	  {
	    if ( ( numentints == 0 ) ) 
	    {
	      Fputs( logfile ,  " undefined" ) ; 
	    } 
	    else if ( ( ! readcompleted ) ) 
	    {
	      Fputs( logfile ,  " uninitialized" ) ; 
	    } 
	    else {
		
	      intentptr = citeptr * numentints ; 
	      while ( ( intentptr < ( citeptr + 1 ) * numentints ) ) {
		  
		{
		  fprintf( logfile , "%c%ld",  ' ' , (long)entryints [ intentptr ] ) ; 
		} 
		intentptr = intentptr + 1 ; 
	      } 
	    } 
	    {
	      putc ('\n',  logfile );
	    } 
	  } 
	  {
	    fprintf( logfile , "%s\n",  "  and has fields" ) ; 
	  } 
	  {
	    if ( ( ! readperformed ) ) 
	    {
	      fprintf( logfile , "%s\n",  "    uninitialized" ) ; 
	    } 
	    else {
		
	      fieldptr = citeptr * numfields ; 
	      fieldendptr = fieldptr + numfields ; 
	      nofields = true ; 
	      while ( ( fieldptr < fieldendptr ) ) {
		  
		if ( ( fieldinfo [ fieldptr ] != 0 ) ) 
		{
		  {
		    Fputs( logfile ,  "    \"" ) ; 
		  } 
		  {
		    outpoolstr ( logfile , fieldinfo [ fieldptr ] ) ; 
		  } 
		  {
		    fprintf( logfile , "%c\n",  '"' ) ; 
		  } 
		  nofields = false ; 
		} 
		fieldptr = fieldptr + 1 ; 
	      } 
	      if ( ( nofields ) ) 
	      {
		fprintf( logfile , "%s\n",  "    missing" ) ; 
	      } 
	    } 
	  } 
	} 
	else {
	    
	  putc ('\n',  logfile );
	} 
	sortciteptr = sortciteptr + 1 ; 
      } 
    } 
  } 
  {
    {
      fprintf( logfile , "%s\n",  "The wiz-defined functions are" ) ; 
    } 
    if ( ( wizdefptr == 0 ) ) 
    {
      fprintf( logfile , "%s\n",  "   nonexistent" ) ; 
    } 
    else {
	
      wizfnptr = 0 ; 
      while ( ( wizfnptr < wizdefptr ) ) {
	  
	if ( ( wizfunctions [ wizfnptr ] == 21001 ) ) 
	{
	  fprintf( logfile , "%ld%s\n",  (long)wizfnptr , "--end-of-def--" ) ; 
	} 
	else if ( ( wizfunctions [ wizfnptr ] == 0 ) ) 
	{
	  fprintf( logfile , "%ld%s",  (long)wizfnptr , "  quote_next_function    " ) ; 
	} 
	else {
	    
	  {
	    fprintf( logfile , "%ld%s",  (long)wizfnptr , "  `" ) ; 
	  } 
	  {
	    outpoolstr ( logfile , hashtext [ wizfunctions [ wizfnptr ] ] ) ; 
	  } 
	  {
	    fprintf( logfile , "%c\n",  '\'' ) ; 
	  } 
	} 
	wizfnptr = wizfnptr + 1 ; 
      } 
    } 
  } 
  {
    {
      fprintf( logfile , "%s\n",  "The string pool is" ) ; 
    } 
    strnum = 1 ; 
    while ( ( strnum < strptr ) ) {
	
      {
	fprintf( logfile , "%ld%ld%s",  (long)strnum , (long)strstart [ strnum ] , " \"" ) ; 
      } 
      {
	outpoolstr ( logfile , strnum ) ; 
      } 
      {
	fprintf( logfile , "%c\n",  '"' ) ; 
      } 
      strnum = strnum + 1 ; 
    } 
  } 
#endif /* TRACE */
	;
#ifdef STAT
  {
    {
      fprintf( logfile , "%s%ld",  "You've used " , (long)numcites ) ; 
    } 
    if ( ( numcites == 1 ) ) 
    {
      fprintf( logfile , "%s\n",  " entry," ) ; 
    } 
    else {
	
      fprintf( logfile , "%s\n",  " entries," ) ; 
    } 
    {
      fprintf( logfile , "%s%ld%s\n",  "            " , (long)wizdefptr ,       " wiz_defined-function locations," ) ; 
    } 
    {
      fprintf( logfile , "%s%ld%s%ld%s\n",  "            " , (long)strptr , " strings with " ,       (long)strstart [ strptr ] , " characters," ) ; 
    } 
    bltinptr = 0 ; 
    totalexcount = 0 ; 
    while ( ( bltinptr < numbltinfns ) ) {
	
      totalexcount = totalexcount + executioncount [ bltinptr ] ; 
      bltinptr = bltinptr + 1 ; 
    } 
    {
      fprintf( logfile , "%s%ld%s\n",  "and the built_in function-call counts, " ,       (long)totalexcount , " in all, are:" ) ; 
    } 
    bltinptr = 0 ; 
    while ( ( bltinptr < numbltinfns ) ) {
	
      {
	outpoolstr ( logfile , hashtext [ bltinloc [ bltinptr ] ] ) ; 
      } 
      {
	fprintf( logfile , "%s%ld\n",  " -- " , (long)executioncount [ bltinptr ] ) ; 
      } 
      bltinptr = bltinptr + 1 ; 
    } 
  } 
#endif /* STAT */
} 
void 
zstartname ( filename ) 
  strnumber filename ; 
{poolpointer pptr  ; 
  if ( ( ( strstart [ filename + 1 ] - strstart [ filename ] ) > PATHMAX ) ) 
  {
    {
      Fputs( logfile ,  "File=" ) ; 
      Fputs( standardoutput ,  "File=" ) ; 
    } 
    printapoolstr ( filename ) ; 
    {
      fprintf( logfile , "%c\n",  ',' ) ; 
      fprintf( standardoutput , "%c\n",  ',' ) ; 
    } 
    filenmsizeoverflow () ; 
  } 
  nameptr = 1 ; 
  pptr = strstart [ filename ] ; 
  while ( ( pptr < strstart [ filename + 1 ] ) ) {
      
    nameoffile [ nameptr ] = chr ( strpool [ pptr ] ) ; 
    nameptr = nameptr + 1 ; 
    pptr = pptr + 1 ; 
  } 
  namelength = ( strstart [ filename + 1 ] - strstart [ filename ] ) ; 
} 
void 
zaddextension ( ext ) 
  strnumber ext ; 
{poolpointer pptr  ; 
  if ( ( namelength + ( strstart [ ext + 1 ] - strstart [ ext ] ) > PATHMAX ) 
  ) 
  {
    {
      fprintf( logfile , "%s%c%s",  "File=" , nameoffile , ", extension=" ) ; 
      fprintf( standardoutput , "%s%c%s",  "File=" , nameoffile , ", extension=" ) ; 
    } 
    printapoolstr ( ext ) ; 
    {
      fprintf( logfile , "%c\n",  ',' ) ; 
      fprintf( standardoutput , "%c\n",  ',' ) ; 
    } 
    filenmsizeoverflow () ; 
  } 
  nameptr = namelength + 1 ; 
  pptr = strstart [ ext ] ; 
  while ( ( pptr < strstart [ ext + 1 ] ) ) {
      
    nameoffile [ nameptr ] = chr ( strpool [ pptr ] ) ; 
    nameptr = nameptr + 1 ; 
    pptr = pptr + 1 ; 
  } 
  namelength = namelength + ( strstart [ ext + 1 ] - strstart [ ext ] ) ; 
  nameptr = namelength + 1 ; 
  while ( ( nameptr <= PATHMAX ) ) {
      
    nameoffile [ nameptr ] = ' ' ; 
    nameptr = nameptr + 1 ; 
  } 
} 
void 
zaddarea ( area ) 
  strnumber area ; 
{poolpointer pptr  ; 
  if ( ( namelength + ( strstart [ area + 1 ] - strstart [ area ] ) > PATHMAX 
  ) ) 
  {
    {
      Fputs( logfile ,  "File=" ) ; 
      Fputs( standardoutput ,  "File=" ) ; 
    } 
    printapoolstr ( area ) ; 
    {
      fprintf( logfile , "%c%c",  nameoffile , ',' ) ; 
      fprintf( standardoutput , "%c%c",  nameoffile , ',' ) ; 
    } 
    filenmsizeoverflow () ; 
  } 
  nameptr = namelength ; 
  while ( ( nameptr > 0 ) ) {
      
    nameoffile [ nameptr + ( strstart [ area + 1 ] - strstart [ area ] ) ] = 
    nameoffile [ nameptr ] ; 
    nameptr = nameptr - 1 ; 
  } 
  nameptr = 1 ; 
  pptr = strstart [ area ] ; 
  while ( ( pptr < strstart [ area + 1 ] ) ) {
      
    nameoffile [ nameptr ] = chr ( strpool [ pptr ] ) ; 
    nameptr = nameptr + 1 ; 
    pptr = pptr + 1 ; 
  } 
  namelength = namelength + ( strstart [ area + 1 ] - strstart [ area ] ) ; 
} 
strnumber 
makestring ( ) 
{register strnumber Result; if ( ( strptr == maxstrings ) ) 
  {
    printoverflow () ; 
    {
      fprintf( logfile , "%s%ld\n",  "number of strings " , (long)maxstrings ) ; 
      fprintf( standardoutput , "%s%ld\n",  "number of strings " , (long)maxstrings ) ; 
    } 
    longjmp(jmp9998,1) ; 
  } 
  strptr = strptr + 1 ; 
  strstart [ strptr ] = poolptr ; 
  Result = strptr - 1 ; 
  return Result ; 
} 
boolean 
zstreqbuf ( s , buf , bfptr , len ) 
  strnumber s ; 
  buftype buf ; 
  bufpointer bfptr ; 
  bufpointer len ; 
{/* 10 */ register boolean Result; bufpointer i  ; 
  poolpointer j  ; 
  if ( ( ( strstart [ s + 1 ] - strstart [ s ] ) != len ) ) 
  {
    Result = false ; 
    goto lab10 ; 
  } 
  i = bfptr ; 
  j = strstart [ s ] ; 
  while ( ( j < strstart [ s + 1 ] ) ) {
      
    if ( ( strpool [ j ] != buf [ i ] ) ) 
    {
      Result = false ; 
      goto lab10 ; 
    } 
    i = i + 1 ; 
    j = j + 1 ; 
  } 
  Result = true ; 
  lab10: ; 
  return Result ; 
} 
boolean 
zstreqstr ( s1 , s2 ) 
  strnumber s1 ; 
  strnumber s2 ; 
{/* 10 */ register boolean Result; if ( ( ( strstart [ s1 + 1 ] - strstart [ 
  s1 ] ) != ( strstart [ s2 + 1 ] - strstart [ s2 ] ) ) ) 
  {
    Result = false ; 
    goto lab10 ; 
  } 
  pptr1 = strstart [ s1 ] ; 
  pptr2 = strstart [ s2 ] ; 
  while ( ( pptr1 < strstart [ s1 + 1 ] ) ) {
      
    if ( ( strpool [ pptr1 ] != strpool [ pptr2 ] ) ) 
    {
      Result = false ; 
      goto lab10 ; 
    } 
    pptr1 = pptr1 + 1 ; 
    pptr2 = pptr2 + 1 ; 
  } 
  Result = true ; 
  lab10: ; 
  return Result ; 
} 
void 
zlowercase ( buf , bfptr , len ) 
  buftype buf ; 
  bufpointer bfptr ; 
  bufpointer len ; 
{bufpointer i  ; 
  if ( ( len > 0 ) ) 
  {register integer for_end; i = bfptr ; for_end = bfptr + len - 1 ; if ( i 
  <= for_end) do 
    if ( ( ( buf [ i ] >= 65 ) && ( buf [ i ] <= 90 ) ) ) 
    buf [ i ] = buf [ i ] + 32 ; 
  while ( i++ < for_end ) ; } 
} 
void 
zuppercase ( buf , bfptr , len ) 
  buftype buf ; 
  bufpointer bfptr ; 
  bufpointer len ; 
{bufpointer i  ; 
  if ( ( len > 0 ) ) 
  {register integer for_end; i = bfptr ; for_end = bfptr + len - 1 ; if ( i 
  <= for_end) do 
    if ( ( ( buf [ i ] >= 97 ) && ( buf [ i ] <= 122 ) ) ) 
    buf [ i ] = buf [ i ] - 32 ; 
  while ( i++ < for_end ) ; } 
} 
hashloc 
zstrlookup ( buf , j , l , ilk , insertit ) 
  buftype buf ; 
  bufpointer j ; 
  bufpointer l ; 
  strilk ilk ; 
  boolean insertit ; 
{/* 40 45 */ register hashloc Result; short h  ; 
  hashloc p  ; 
  bufpointer k  ; 
  boolean oldstring  ; 
  strnumber strnum  ; 
  {
    h = 0 ; 
    k = j ; 
    while ( ( k < j + l ) ) {
	
      h = h + h + buf [ k ] ; 
      while ( ( h >= 16319 ) ) h = h - 16319 ; 
      k = k + 1 ; 
    } 
  } 
  p = h + 1 ; 
  hashfound = false ; 
  oldstring = false ; 
  while ( true ) {
      
    {
      if ( ( hashtext [ p ] > 0 ) ) 
      if ( ( streqbuf ( hashtext [ p ] , buf , j , l ) ) ) 
      if ( ( hashilk [ p ] == ilk ) ) 
      {
	hashfound = true ; 
	goto lab40 ; 
      } 
      else {
	  
	oldstring = true ; 
	strnum = hashtext [ p ] ; 
      } 
    } 
    if ( ( hashnext [ p ] == 0 ) ) 
    {
      if ( ( ! insertit ) ) 
      goto lab45 ; 
      {
	if ( ( hashtext [ p ] > 0 ) ) 
	{
	  do {
	      if ( ( ( hashused == 1 ) ) ) 
	    {
	      printoverflow () ; 
	      {
		fprintf( logfile , "%s%ld\n",  "hash size " , (long)21000 ) ; 
		fprintf( standardoutput , "%s%ld\n",  "hash size " , (long)21000 ) ; 
	      } 
	      longjmp(jmp9998,1) ; 
	    } 
	    hashused = hashused - 1 ; 
	  } while ( ! ( ( hashtext [ hashused ] == 0 ) ) ) ; 
	  hashnext [ p ] = hashused ; 
	  p = hashused ; 
	} 
	if ( ( oldstring ) ) 
	hashtext [ p ] = strnum ; 
	else {
	    
	  {
	    if ( ( poolptr + l > poolsize ) ) 
	    pooloverflow () ; 
	  } 
	  k = j ; 
	  while ( ( k < j + l ) ) {
	      
	    {
	      strpool [ poolptr ] = buf [ k ] ; 
	      poolptr = poolptr + 1 ; 
	    } 
	    k = k + 1 ; 
	  } 
	  hashtext [ p ] = makestring () ; 
	} 
	hashilk [ p ] = ilk ; 
      } 
      goto lab40 ; 
    } 
    p = hashnext [ p ] ; 
  } 
  lab45: ; 
  lab40: Result = p ; 
  return Result ; 
} 
void 
zpredefine ( pds , len , ilk ) 
  pdstype pds ; 
  pdslen len ; 
  strilk ilk ; 
{pdslen i  ; 
  {register integer for_end; i = 1 ; for_end = len ; if ( i <= for_end) do 
    buffer [ i ] = xord [ pds [ i - 1 ] ] ; 
  while ( i++ < for_end ) ; } 
  predefloc = strlookup ( buffer , 1 , len , ilk , true ) ; 
} 
void 
zinttoASCII ( theint , intbuf , intbegin , intend ) 
  integer theint ; 
  buftype intbuf ; 
  bufpointer intbegin ; 
  bufpointer * intend ; 
{bufpointer intptr, intxptr  ; 
  ASCIIcode inttmpval  ; 
  intptr = intbegin ; 
  if ( ( theint < 0 ) ) 
  {
    {
      if ( ( intptr == bufsize ) ) 
      bufferoverflow () ; 
      intbuf [ intptr ] = 45 ; 
      intptr = intptr + 1 ; 
    } 
    theint = - (integer) theint ; 
  } 
  intxptr = intptr ; 
  do {
      { 
      if ( ( intptr == bufsize ) ) 
      bufferoverflow () ; 
      intbuf [ intptr ] = 48 + ( theint % 10 ) ; 
      intptr = intptr + 1 ; 
    } 
    theint = theint / 10 ; 
  } while ( ! ( ( theint == 0 ) ) ) ; 
*  intend = intptr ; 
  intptr = intptr - 1 ; 
  while ( ( intxptr < intptr ) ) {
      
    inttmpval = intbuf [ intxptr ] ; 
    intbuf [ intxptr ] = intbuf [ intptr ] ; 
    intbuf [ intptr ] = inttmpval ; 
    intptr = intptr - 1 ; 
    intxptr = intxptr + 1 ; 
  } 
} 
void 
zadddatabasecite ( newcite ) 
  citenumber * newcite ; 
{checkciteoverflow ( *newcite ) ; 
  checkfieldoverflow ( numfields * *newcite ) ; 
  citelist [ *newcite ] = hashtext [ citeloc ] ; 
  ilkinfo [ citeloc ] = *newcite ; 
  ilkinfo [ lcciteloc ] = citeloc ; 
*  newcite = *newcite + 1 ; 
} 
boolean 
zfindcitelocsforthiscitekey ( citestr ) 
  strnumber citestr ; 
{register boolean Result; exbufptr = 0 ; 
  tmpptr = strstart [ citestr ] ; 
  tmpendptr = strstart [ citestr + 1 ] ; 
  while ( ( tmpptr < tmpendptr ) ) {
      
    exbuf [ exbufptr ] = strpool [ tmpptr ] ; 
    exbufptr = exbufptr + 1 ; 
    tmpptr = tmpptr + 1 ; 
  } 
  citeloc = strlookup ( exbuf , 0 , ( strstart [ citestr + 1 ] - strstart [ 
  citestr ] ) , 9 , false ) ; 
  citehashfound = hashfound ; 
  lowercase ( exbuf , 0 , ( strstart [ citestr + 1 ] - strstart [ citestr ] ) 
  ) ; 
  lcciteloc = strlookup ( exbuf , 0 , ( strstart [ citestr + 1 ] - strstart [ 
  citestr ] ) , 10 , false ) ; 
  if ( ( hashfound ) ) 
  Result = true ; 
  else Result = false ; 
  return Result ; 
} 
void 
zswap ( swap1 , swap2 ) 
  citenumber swap1 ; 
  citenumber swap2 ; 
{citenumber innocentbystander  ; 
  innocentbystander = citeinfo [ swap2 ] ; 
  citeinfo [ swap2 ] = citeinfo [ swap1 ] ; 
  citeinfo [ swap1 ] = innocentbystander ; 
} 
boolean 
zlessthan ( arg1 , arg2 ) 
  citenumber arg1 ; 
  citenumber arg2 ; 
{/* 10 */ register boolean Result; integer charptr  ; 
  strentloc ptr1, ptr2  ; 
  ASCIIcode char1, char2  ; 
  ptr1 = arg1 * numentstrs + sortkeynum ; 
  ptr2 = arg2 * numentstrs + sortkeynum ; 
  charptr = 0 ; 
  while ( true ) {
      
    char1 = entrystrs [ ptr1 ] [ charptr ] ; 
    char2 = entrystrs [ ptr2 ] [ charptr ] ; 
    if ( ( char1 == 127 ) ) 
    if ( ( char2 == 127 ) ) 
    if ( ( arg1 < arg2 ) ) 
    {
      Result = true ; 
      goto lab10 ; 
    } 
    else if ( ( arg1 > arg2 ) ) 
    {
      Result = false ; 
      goto lab10 ; 
    } 
    else {
	
      {
	Fputs( logfile ,  "Duplicate sort key" ) ; 
	Fputs( standardoutput ,  "Duplicate sort key" ) ; 
      } 
      printconfusion () ; 
      longjmp(jmp9998,1) ; 
    } 
    else {
	
      Result = true ; 
      goto lab10 ; 
    } 
    else if ( ( char2 == 127 ) ) 
    {
      Result = false ; 
      goto lab10 ; 
    } 
    else if ( ( char1 < char2 ) ) 
    {
      Result = true ; 
      goto lab10 ; 
    } 
    else if ( ( char1 > char2 ) ) 
    {
      Result = false ; 
      goto lab10 ; 
    } 
    charptr = charptr + 1 ; 
  } 
  lab10: ; 
  return Result ; 
} 
void 
zquicksort ( leftend , rightend ) 
  citenumber leftend ; 
  citenumber rightend ; 
{/* 24 */ citenumber left, right  ; 
  citenumber insertptr  ; 
  citenumber middle  ; 
  citenumber partition  ; 
	;
#ifdef TRACE
  {
    fprintf( logfile , "%s%ld%s%ld\n",  "Sorting " , (long)leftend , " through " , (long)rightend ) ; 
  } 
#endif /* TRACE */
  if ( ( rightend - leftend < 10 ) ) 
  {
    {register integer for_end; insertptr = leftend + 1 ; for_end = rightend 
    ; if ( insertptr <= for_end) do 
      {
	{register integer for_end; right = insertptr ; for_end = leftend + 1 
	; if ( right >= for_end) do 
	  {
	    if ( ( lessthan ( citeinfo [ right - 1 ] , citeinfo [ right ] ) ) 
	    ) 
	    goto lab24 ; 
	    swap ( right - 1 , right ) ; 
	  } 
	while ( right-- > for_end ) ; } 
	lab24: ; 
      } 
    while ( insertptr++ < for_end ) ; } 
  } 
  else {
      
    {
      left = leftend + 4 ; 
      middle = ( leftend + rightend ) / 2 ; 
      right = rightend - 4 ; 
      if ( ( lessthan ( citeinfo [ left ] , citeinfo [ middle ] ) ) ) 
      if ( ( lessthan ( citeinfo [ middle ] , citeinfo [ right ] ) ) ) 
      swap ( leftend , middle ) ; 
      else if ( ( lessthan ( citeinfo [ left ] , citeinfo [ right ] ) ) ) 
      swap ( leftend , right ) ; 
      else swap ( leftend , left ) ; 
      else if ( ( lessthan ( citeinfo [ right ] , citeinfo [ middle ] ) ) ) 
      swap ( leftend , middle ) ; 
      else if ( ( lessthan ( citeinfo [ right ] , citeinfo [ left ] ) ) ) 
      swap ( leftend , right ) ; 
      else swap ( leftend , left ) ; 
    } 
    {
      partition = citeinfo [ leftend ] ; 
      left = leftend + 1 ; 
      right = rightend ; 
      do {
	  while ( ( lessthan ( citeinfo [ left ] , partition ) ) ) left = 
	left + 1 ; 
	while ( ( lessthan ( partition , citeinfo [ right ] ) ) ) right = 
	right - 1 ; 
	if ( ( left < right ) ) 
	{
	  swap ( left , right ) ; 
	  left = left + 1 ; 
	  right = right - 1 ; 
	} 
      } while ( ! ( ( left == right + 1 ) ) ) ; 
      swap ( leftend , right ) ; 
      quicksort ( leftend , right - 1 ) ; 
      quicksort ( left , rightend ) ; 
    } 
  } 
} 
void 
zbuildin ( pds , len , fnhashloc , bltinnum ) 
  pdstype pds ; 
  pdslen len ; 
  hashloc * fnhashloc ; 
  bltinrange bltinnum ; 
{predefine ( pds , len , 11 ) ; 
*  fnhashloc = predefloc ; 
  fntype [ *fnhashloc ] = 0 ; 
  ilkinfo [ *fnhashloc ] = bltinnum ; 
	;
#ifdef STAT
  bltinloc [ bltinnum ] = *fnhashloc ; 
  executioncount [ bltinnum ] = 0 ; 
#endif /* STAT */
} 
void 
predefcertainstrings ( ) 
{predefine ( ".aux        " , 4 , 7 ) ; 
  sauxextension = hashtext [ predefloc ] ; 
  predefine ( ".bbl        " , 4 , 7 ) ; 
  sbblextension = hashtext [ predefloc ] ; 
  predefine ( ".blg        " , 4 , 7 ) ; 
  slogextension = hashtext [ predefloc ] ; 
  predefine ( ".bst        " , 4 , 7 ) ; 
  sbstextension = hashtext [ predefloc ] ; 
  predefine ( ".bib        " , 4 , 7 ) ; 
  sbibextension = hashtext [ predefloc ] ; 
  predefine ( "texinputs:  " , 10 , 8 ) ; 
  sbstarea = hashtext [ predefloc ] ; 
  predefine ( "texbib:     " , 7 , 8 ) ; 
  sbibarea = hashtext [ predefloc ] ; 
  predefine ( "\\citation   " , 9 , 2 ) ; 
  ilkinfo [ predefloc ] = 2 ; 
  predefine ( "\\bibdata    " , 8 , 2 ) ; 
  ilkinfo [ predefloc ] = 0 ; 
  predefine ( "\\bibstyle   " , 9 , 2 ) ; 
  ilkinfo [ predefloc ] = 1 ; 
  predefine ( "\\@input     " , 7 , 2 ) ; 
  ilkinfo [ predefloc ] = 3 ; 
  predefine ( "entry       " , 5 , 4 ) ; 
  ilkinfo [ predefloc ] = 0 ; 
  predefine ( "execute     " , 7 , 4 ) ; 
  ilkinfo [ predefloc ] = 1 ; 
  predefine ( "function    " , 8 , 4 ) ; 
  ilkinfo [ predefloc ] = 2 ; 
  predefine ( "integers    " , 8 , 4 ) ; 
  ilkinfo [ predefloc ] = 3 ; 
  predefine ( "iterate     " , 7 , 4 ) ; 
  ilkinfo [ predefloc ] = 4 ; 
  predefine ( "macro       " , 5 , 4 ) ; 
  ilkinfo [ predefloc ] = 5 ; 
  predefine ( "read        " , 4 , 4 ) ; 
  ilkinfo [ predefloc ] = 6 ; 
  predefine ( "reverse     " , 7 , 4 ) ; 
  ilkinfo [ predefloc ] = 7 ; 
  predefine ( "sort        " , 4 , 4 ) ; 
  ilkinfo [ predefloc ] = 8 ; 
  predefine ( "strings     " , 7 , 4 ) ; 
  ilkinfo [ predefloc ] = 9 ; 
  predefine ( "comment     " , 7 , 12 ) ; 
  ilkinfo [ predefloc ] = 0 ; 
  predefine ( "preamble    " , 8 , 12 ) ; 
  ilkinfo [ predefloc ] = 1 ; 
  predefine ( "string      " , 6 , 12 ) ; 
  ilkinfo [ predefloc ] = 2 ; 
  buildin ( "=           " , 1 , bequals , 0 ) ; 
  buildin ( ">           " , 1 , bgreaterthan , 1 ) ; 
  buildin ( "<           " , 1 , blessthan , 2 ) ; 
  buildin ( "+           " , 1 , bplus , 3 ) ; 
  buildin ( "-           " , 1 , bminus , 4 ) ; 
  buildin ( "*           " , 1 , bconcatenate , 5 ) ; 
  buildin ( ":=          " , 2 , bgets , 6 ) ; 
  buildin ( "add.period$ " , 11 , baddperiod , 7 ) ; 
  buildin ( "call.type$  " , 10 , bcalltype , 8 ) ; 
  buildin ( "change.case$" , 12 , bchangecase , 9 ) ; 
  buildin ( "chr.to.int$ " , 11 , bchrtoint , 10 ) ; 
  buildin ( "cite$       " , 5 , bcite , 11 ) ; 
  buildin ( "duplicate$  " , 10 , bduplicate , 12 ) ; 
  buildin ( "empty$      " , 6 , bempty , 13 ) ; 
  buildin ( "format.name$" , 12 , bformatname , 14 ) ; 
  buildin ( "if$         " , 3 , bif , 15 ) ; 
  buildin ( "int.to.chr$ " , 11 , binttochr , 16 ) ; 
  buildin ( "int.to.str$ " , 11 , binttostr , 17 ) ; 
  buildin ( "missing$    " , 8 , bmissing , 18 ) ; 
  buildin ( "newline$    " , 8 , bnewline , 19 ) ; 
  buildin ( "num.names$  " , 10 , bnumnames , 20 ) ; 
  buildin ( "pop$        " , 4 , bpop , 21 ) ; 
  buildin ( "preamble$   " , 9 , bpreamble , 22 ) ; 
  buildin ( "purify$     " , 7 , bpurify , 23 ) ; 
  buildin ( "quote$      " , 6 , bquote , 24 ) ; 
  buildin ( "skip$       " , 5 , bskip , 25 ) ; 
  buildin ( "stack$      " , 6 , bstack , 26 ) ; 
  buildin ( "substring$  " , 10 , bsubstring , 27 ) ; 
  buildin ( "swap$       " , 5 , bswap , 28 ) ; 
  buildin ( "text.length$" , 12 , btextlength , 29 ) ; 
  buildin ( "text.prefix$" , 12 , btextprefix , 30 ) ; 
  buildin ( "top$        " , 4 , btopstack , 31 ) ; 
  buildin ( "type$       " , 5 , btype , 32 ) ; 
  buildin ( "warning$    " , 8 , bwarning , 33 ) ; 
  buildin ( "width$      " , 6 , bwidth , 35 ) ; 
  buildin ( "while$      " , 6 , bwhile , 34 ) ; 
  buildin ( "width$      " , 6 , bwidth , 35 ) ; 
  buildin ( "write$      " , 6 , bwrite , 36 ) ; 
  predefine ( "            " , 0 , 0 ) ; 
  snull = hashtext [ predefloc ] ; 
  fntype [ predefloc ] = 3 ; 
  predefine ( "default.type" , 12 , 0 ) ; 
  sdefault = hashtext [ predefloc ] ; 
  fntype [ predefloc ] = 3 ; 
  bdefault = bskip ; 
  preambleptr = 0 ; 
  predefine ( "i           " , 1 , 14 ) ; 
  ilkinfo [ predefloc ] = 0 ; 
  predefine ( "j           " , 1 , 14 ) ; 
  ilkinfo [ predefloc ] = 1 ; 
  predefine ( "oe          " , 2 , 14 ) ; 
  ilkinfo [ predefloc ] = 2 ; 
  predefine ( "OE          " , 2 , 14 ) ; 
  ilkinfo [ predefloc ] = 3 ; 
  predefine ( "ae          " , 2 , 14 ) ; 
  ilkinfo [ predefloc ] = 4 ; 
  predefine ( "AE          " , 2 , 14 ) ; 
  ilkinfo [ predefloc ] = 5 ; 
  predefine ( "aa          " , 2 , 14 ) ; 
  ilkinfo [ predefloc ] = 6 ; 
  predefine ( "AA          " , 2 , 14 ) ; 
  ilkinfo [ predefloc ] = 7 ; 
  predefine ( "o           " , 1 , 14 ) ; 
  ilkinfo [ predefloc ] = 8 ; 
  predefine ( "O           " , 1 , 14 ) ; 
  ilkinfo [ predefloc ] = 9 ; 
  predefine ( "l           " , 1 , 14 ) ; 
  ilkinfo [ predefloc ] = 10 ; 
  predefine ( "L           " , 1 , 14 ) ; 
  ilkinfo [ predefloc ] = 11 ; 
  predefine ( "ss          " , 2 , 14 ) ; 
  ilkinfo [ predefloc ] = 12 ; 
  predefine ( "crossref    " , 8 , 11 ) ; 
  fntype [ predefloc ] = 4 ; 
  ilkinfo [ predefloc ] = numfields ; 
  crossrefnum = numfields ; 
  numfields = numfields + 1 ; 
  numpredefinedfields = numfields ; 
  predefine ( "sort.key$   " , 9 , 11 ) ; 
  fntype [ predefloc ] = 6 ; 
  ilkinfo [ predefloc ] = numentstrs ; 
  sortkeynum = numentstrs ; 
  numentstrs = numentstrs + 1 ; 
  predefine ( "entry.max$  " , 10 , 11 ) ; 
  fntype [ predefloc ] = 7 ; 
  ilkinfo [ predefloc ] = entstrsize ; 
  predefine ( "global.max$ " , 11 , 11 ) ; 
  fntype [ predefloc ] = 7 ; 
  ilkinfo [ predefloc ] = globstrsize ; 
} 
boolean 
zscan1 ( char1 ) 
  ASCIIcode char1 ; 
{register boolean Result; bufptr1 = bufptr2 ; 
  while ( ( ( buffer [ bufptr2 ] != char1 ) && ( bufptr2 < last ) ) ) bufptr2 
  = bufptr2 + 1 ; 
  if ( ( bufptr2 < last ) ) 
  Result = true ; 
  else Result = false ; 
  return Result ; 
} 
boolean 
zscan1white ( char1 ) 
  ASCIIcode char1 ; 
{register boolean Result; bufptr1 = bufptr2 ; 
  while ( ( ( lexclass [ buffer [ bufptr2 ] ] != 1 ) && ( buffer [ bufptr2 ] 
  != char1 ) && ( bufptr2 < last ) ) ) bufptr2 = bufptr2 + 1 ; 
  if ( ( bufptr2 < last ) ) 
  Result = true ; 
  else Result = false ; 
  return Result ; 
} 
boolean 
zscan2 ( char1 , char2 ) 
  ASCIIcode char1 ; 
  ASCIIcode char2 ; 
{register boolean Result; bufptr1 = bufptr2 ; 
  while ( ( ( buffer [ bufptr2 ] != char1 ) && ( buffer [ bufptr2 ] != char2 ) 
  && ( bufptr2 < last ) ) ) bufptr2 = bufptr2 + 1 ; 
  if ( ( bufptr2 < last ) ) 
  Result = true ; 
  else Result = false ; 
  return Result ; 
} 
boolean 
zscan2white ( char1 , char2 ) 
  ASCIIcode char1 ; 
  ASCIIcode char2 ; 
{register boolean Result; bufptr1 = bufptr2 ; 
  while ( ( ( buffer [ bufptr2 ] != char1 ) && ( buffer [ bufptr2 ] != char2 ) 
  && ( lexclass [ buffer [ bufptr2 ] ] != 1 ) && ( bufptr2 < last ) ) ) 
  bufptr2 = bufptr2 + 1 ; 
  if ( ( bufptr2 < last ) ) 
  Result = true ; 
  else Result = false ; 
  return Result ; 
} 
boolean 
zscan3 ( char1 , char2 , char3 ) 
  ASCIIcode char1 ; 
  ASCIIcode char2 ; 
  ASCIIcode char3 ; 
{register boolean Result; bufptr1 = bufptr2 ; 
  while ( ( ( buffer [ bufptr2 ] != char1 ) && ( buffer [ bufptr2 ] != char2 ) 
  && ( buffer [ bufptr2 ] != char3 ) && ( bufptr2 < last ) ) ) bufptr2 = 
  bufptr2 + 1 ; 
  if ( ( bufptr2 < last ) ) 
  Result = true ; 
  else Result = false ; 
  return Result ; 
} 
boolean 
scanalpha ( ) 
{register boolean Result; bufptr1 = bufptr2 ; 
  while ( ( ( lexclass [ buffer [ bufptr2 ] ] == 2 ) && ( bufptr2 < last ) ) ) 
  bufptr2 = bufptr2 + 1 ; 
  if ( ( ( bufptr2 - bufptr1 ) == 0 ) ) 
  Result = false ; 
  else Result = true ; 
  return Result ; 
} 
void 
zscanidentifier ( char1 , char2 , char3 ) 
  ASCIIcode char1 ; 
  ASCIIcode char2 ; 
  ASCIIcode char3 ; 
{bufptr1 = bufptr2 ; 
  if ( ( lexclass [ buffer [ bufptr2 ] ] != 3 ) ) 
  while ( ( ( idclass [ buffer [ bufptr2 ] ] == 1 ) && ( bufptr2 < last ) ) ) 
  bufptr2 = bufptr2 + 1 ; 
  if ( ( ( bufptr2 - bufptr1 ) == 0 ) ) 
  scanresult = 0 ; 
  else if ( ( ( lexclass [ buffer [ bufptr2 ] ] == 1 ) || ( bufptr2 == last ) 
  ) ) 
  scanresult = 3 ; 
  else if ( ( ( buffer [ bufptr2 ] == char1 ) || ( buffer [ bufptr2 ] == char2 
  ) || ( buffer [ bufptr2 ] == char3 ) ) ) 
  scanresult = 1 ; 
  else scanresult = 2 ; 
} 
boolean 
scannonneginteger ( ) 
{register boolean Result; bufptr1 = bufptr2 ; 
  tokenvalue = 0 ; 
  while ( ( ( lexclass [ buffer [ bufptr2 ] ] == 3 ) && ( bufptr2 < last ) ) ) 
  {
    tokenvalue = tokenvalue * 10 + ( buffer [ bufptr2 ] - 48 ) ; 
    bufptr2 = bufptr2 + 1 ; 
  } 
  if ( ( ( bufptr2 - bufptr1 ) == 0 ) ) 
  Result = false ; 
  else Result = true ; 
  return Result ; 
} 
boolean 
scaninteger ( ) 
{register boolean Result; char signlength  ; 
  bufptr1 = bufptr2 ; 
  if ( ( buffer [ bufptr2 ] == 45 ) ) 
  {
    signlength = 1 ; 
    bufptr2 = bufptr2 + 1 ; 
  } 
  else signlength = 0 ; 
  tokenvalue = 0 ; 
  while ( ( ( lexclass [ buffer [ bufptr2 ] ] == 3 ) && ( bufptr2 < last ) ) ) 
  {
    tokenvalue = tokenvalue * 10 + ( buffer [ bufptr2 ] - 48 ) ; 
    bufptr2 = bufptr2 + 1 ; 
  } 
  if ( ( ( signlength == 1 ) ) ) 
  tokenvalue = - (integer) tokenvalue ; 
  if ( ( ( bufptr2 - bufptr1 ) == signlength ) ) 
  Result = false ; 
  else Result = true ; 
  return Result ; 
} 
boolean 
scanwhitespace ( ) 
{register boolean Result; while ( ( ( lexclass [ buffer [ bufptr2 ] ] == 1 ) 
  && ( bufptr2 < last ) ) ) bufptr2 = bufptr2 + 1 ; 
  if ( ( bufptr2 < last ) ) 
  Result = true ; 
  else Result = false ; 
  return Result ; 
} 
boolean 
eatbstwhitespace ( ) 
{/* 10 */ register boolean Result; while ( true ) {
    
    if ( ( scanwhitespace () ) ) 
    if ( ( buffer [ bufptr2 ] != 37 ) ) 
    {
      Result = true ; 
      goto lab10 ; 
    } 
    if ( ( ! inputln ( bstfile ) ) ) 
    {
      Result = false ; 
      goto lab10 ; 
    } 
    bstlinenum = bstlinenum + 1 ; 
    bufptr2 = 0 ; 
  } 
  lab10: ; 
  return Result ; 
} 
void 
skiptokenprint ( ) 
{{
    
    putc ( '-' ,  logfile );
    putc ( '-' ,  standardoutput );
  } 
  bstlnnumprint () ; 
  markerror () ; 
  if ( ( scan2white ( 125 , 37 ) ) ) 
  ; 
} 
void 
printrecursionillegal ( ) 
{
	;
#ifdef TRACE
  {
    putc ('\n',  logfile );
  } 
#endif /* TRACE */
  {
    fprintf( logfile , "%s\n",  "Curse you, wizard, before you recurse me:" ) ; 
    fprintf( standardoutput , "%s\n",  "Curse you, wizard, before you recurse me:" ) ; 
  } 
  {
    Fputs( logfile ,  "function " ) ; 
    Fputs( standardoutput ,  "function " ) ; 
  } 
  printatoken () ; 
  {
    fprintf( logfile , "%s\n",  " is illegal in its own definition" ) ; 
    fprintf( standardoutput , "%s\n",  " is illegal in its own definition" ) ; 
  } 
  skiptokenprint () ; 
} 
void 
skptokenunknownfunctionprint ( ) 
{printatoken () ; 
  {
    Fputs( logfile ,  " is an unknown function" ) ; 
    Fputs( standardoutput ,  " is an unknown function" ) ; 
  } 
  skiptokenprint () ; 
} 
void 
skipillegalstuffaftertokenprint ( ) 
{{
    
    fprintf( logfile , "%c%c%s",  '"' , xchr [ buffer [ bufptr2 ] ] ,     "\" can't follow a literal" ) ; 
    fprintf( standardoutput , "%c%c%s",  '"' , xchr [ buffer [ bufptr2 ] ] ,     "\" can't follow a literal" ) ; 
  } 
  skiptokenprint () ; 
} 
void 
zscanfndef ( fnhashloc ) 
  hashloc fnhashloc ; 
{/* 25 10 */ typedef integer fndefloc  ; 
  hashptr2 singlfunction[singlefnspace + 1]  ; 
  fndefloc singleptr  ; 
  fndefloc copyptr  ; 
  bufpointer endofnum  ; 
  hashloc implfnloc  ; 
  {
    if ( ( ! eatbstwhitespace () ) ) 
    {
      eatbstprint () ; 
      {
	{
	  Fputs( logfile ,  "function" ) ; 
	  Fputs( standardoutput ,  "function" ) ; 
	} 
	{
	  bsterrprintandlookforblankline () ; 
	  goto lab10 ; 
	} 
      } 
    } 
  } 
  singleptr = 0 ; 
  while ( ( buffer [ bufptr2 ] != 125 ) ) {
      
    switch ( ( buffer [ bufptr2 ] ) ) 
    {case 35 : 
      {
	bufptr2 = bufptr2 + 1 ; 
	if ( ( ! scaninteger () ) ) 
	{
	  {
	    Fputs( logfile ,  "Illegal integer in integer literal" ) ; 
	    Fputs( standardoutput ,  "Illegal integer in integer literal" ) ; 
	  } 
	  skiptokenprint () ; 
	  goto lab25 ; 
	} 
	;
#ifdef TRACE
	{
	  putc ( '#' ,  logfile );
	} 
	{
	  outtoken ( logfile ) ; 
	} 
	{
	  fprintf( logfile , "%s%ld\n",  " is an integer literal with value " ,           (long)tokenvalue ) ; 
	} 
#endif /* TRACE */
	literalloc = strlookup ( buffer , bufptr1 , ( bufptr2 - bufptr1 ) , 1 
	, true ) ; 
	if ( ( ! hashfound ) ) 
	{
	  fntype [ literalloc ] = 2 ; 
	  ilkinfo [ literalloc ] = tokenvalue ; 
	} 
	if ( ( ( lexclass [ buffer [ bufptr2 ] ] != 1 ) && ( bufptr2 < last ) 
	&& ( buffer [ bufptr2 ] != 125 ) && ( buffer [ bufptr2 ] != 37 ) ) ) 
	{
	  skipillegalstuffaftertokenprint () ; 
	  goto lab25 ; 
	} 
	{
	  singlfunction [ singleptr ] = literalloc ; 
	  if ( ( singleptr == singlefnspace ) ) 
	  singlfnoverflow () ; 
	  singleptr = singleptr + 1 ; 
	} 
      } 
      break ; 
    case 34 : 
      {
	bufptr2 = bufptr2 + 1 ; 
	if ( ( ! scan1 ( 34 ) ) ) 
	{
	  {
	    fprintf( logfile , "%s%c%s",  "No `" , xchr [ 34 ] , "' to end string literal"             ) ; 
	    fprintf( standardoutput , "%s%c%s",  "No `" , xchr [ 34 ] ,             "' to end string literal" ) ; 
	  } 
	  skiptokenprint () ; 
	  goto lab25 ; 
	} 
	;
#ifdef TRACE
	{
	  putc ( '"' ,  logfile );
	} 
	{
	  outtoken ( logfile ) ; 
	} 
	{
	  putc ( '"' ,  logfile );
	} 
	{
	  fprintf( logfile , "%s\n",  " is a string literal" ) ; 
	} 
#endif /* TRACE */
	literalloc = strlookup ( buffer , bufptr1 , ( bufptr2 - bufptr1 ) , 0 
	, true ) ; 
	fntype [ literalloc ] = 3 ; 
	bufptr2 = bufptr2 + 1 ; 
	if ( ( ( lexclass [ buffer [ bufptr2 ] ] != 1 ) && ( bufptr2 < last ) 
	&& ( buffer [ bufptr2 ] != 125 ) && ( buffer [ bufptr2 ] != 37 ) ) ) 
	{
	  skipillegalstuffaftertokenprint () ; 
	  goto lab25 ; 
	} 
	{
	  singlfunction [ singleptr ] = literalloc ; 
	  if ( ( singleptr == singlefnspace ) ) 
	  singlfnoverflow () ; 
	  singleptr = singleptr + 1 ; 
	} 
      } 
      break ; 
    case 39 : 
      {
	bufptr2 = bufptr2 + 1 ; 
	if ( ( scan2white ( 125 , 37 ) ) ) 
	; 
	;
#ifdef TRACE
	{
	  putc ( '\'' ,  logfile );
	} 
	{
	  outtoken ( logfile ) ; 
	} 
	{
	  Fputs( logfile ,  " is a quoted function " ) ; 
	} 
#endif /* TRACE */
	lowercase ( buffer , bufptr1 , ( bufptr2 - bufptr1 ) ) ; 
	fnloc = strlookup ( buffer , bufptr1 , ( bufptr2 - bufptr1 ) , 11 , 
	false ) ; 
	if ( ( ! hashfound ) ) 
	{
	  skptokenunknownfunctionprint () ; 
	  goto lab25 ; 
	} 
	else {
	    
	  if ( ( fnloc == wizloc ) ) 
	  {
	    printrecursionillegal () ; 
	    goto lab25 ; 
	  } 
	  else {
	      
	;
#ifdef TRACE
	    {
	      Fputs( logfile ,  "of type " ) ; 
	    } 
	    traceprfnclass ( fnloc ) ; 
	    {
	      putc ('\n',  logfile );
	    } 
#endif /* TRACE */
	    {
	      singlfunction [ singleptr ] = 0 ; 
	      if ( ( singleptr == singlefnspace ) ) 
	      singlfnoverflow () ; 
	      singleptr = singleptr + 1 ; 
	    } 
	    {
	      singlfunction [ singleptr ] = fnloc ; 
	      if ( ( singleptr == singlefnspace ) ) 
	      singlfnoverflow () ; 
	      singleptr = singleptr + 1 ; 
	    } 
	  } 
	} 
      } 
      break ; 
    case 123 : 
      {
	exbuf [ 0 ] = 39 ; 
	inttoASCII ( implfnnum , exbuf , 1 , endofnum ) ; 
	implfnloc = strlookup ( exbuf , 0 , endofnum , 11 , true ) ; 
	if ( ( hashfound ) ) 
	{
	  {
	    Fputs( logfile ,  "Already encountered implicit function" ) ; 
	    Fputs( standardoutput ,  "Already encountered implicit function" ) 
	    ; 
	  } 
	  printconfusion () ; 
	  longjmp(jmp9998,1) ; 
	} 
	;
#ifdef TRACE
	{
	  outpoolstr ( logfile , hashtext [ implfnloc ] ) ; 
	} 
	{
	  fprintf( logfile , "%s\n",  " is an implicit function" ) ; 
	} 
#endif /* TRACE */
	implfnnum = implfnnum + 1 ; 
	fntype [ implfnloc ] = 1 ; 
	{
	  singlfunction [ singleptr ] = 0 ; 
	  if ( ( singleptr == singlefnspace ) ) 
	  singlfnoverflow () ; 
	  singleptr = singleptr + 1 ; 
	} 
	{
	  singlfunction [ singleptr ] = implfnloc ; 
	  if ( ( singleptr == singlefnspace ) ) 
	  singlfnoverflow () ; 
	  singleptr = singleptr + 1 ; 
	} 
	bufptr2 = bufptr2 + 1 ; 
	scanfndef ( implfnloc ) ; 
      } 
      break ; 
      default: 
      {
	if ( ( scan2white ( 125 , 37 ) ) ) 
	; 
	;
#ifdef TRACE
	{
	  outtoken ( logfile ) ; 
	} 
	{
	  Fputs( logfile ,  " is a function " ) ; 
	} 
#endif /* TRACE */
	lowercase ( buffer , bufptr1 , ( bufptr2 - bufptr1 ) ) ; 
	fnloc = strlookup ( buffer , bufptr1 , ( bufptr2 - bufptr1 ) , 11 , 
	false ) ; 
	if ( ( ! hashfound ) ) 
	{
	  skptokenunknownfunctionprint () ; 
	  goto lab25 ; 
	} 
	else if ( ( fnloc == wizloc ) ) 
	{
	  printrecursionillegal () ; 
	  goto lab25 ; 
	} 
	else {
	    
	;
#ifdef TRACE
	  {
	    Fputs( logfile ,  "of type " ) ; 
	  } 
	  traceprfnclass ( fnloc ) ; 
	  {
	    putc ('\n',  logfile );
	  } 
#endif /* TRACE */
	  {
	    singlfunction [ singleptr ] = fnloc ; 
	    if ( ( singleptr == singlefnspace ) ) 
	    singlfnoverflow () ; 
	    singleptr = singleptr + 1 ; 
	  } 
	} 
      } 
      break ; 
    } 
    lab25: {
	
      if ( ( ! eatbstwhitespace () ) ) 
      {
	eatbstprint () ; 
	{
	  {
	    Fputs( logfile ,  "function" ) ; 
	    Fputs( standardoutput ,  "function" ) ; 
	  } 
	  {
	    bsterrprintandlookforblankline () ; 
	    goto lab10 ; 
	  } 
	} 
      } 
    } 
  } 
  {
    {
      singlfunction [ singleptr ] = 21001 ; 
      if ( ( singleptr == singlefnspace ) ) 
      singlfnoverflow () ; 
      singleptr = singleptr + 1 ; 
    } 
    if ( ( singleptr + wizdefptr > wizfnspace ) ) 
    {
      {
	fprintf( logfile , "%ld%s",  (long)singleptr + wizdefptr , ": " ) ; 
	fprintf( standardoutput , "%ld%s",  (long)singleptr + wizdefptr , ": " ) ; 
      } 
      {
	printoverflow () ; 
	{
	  fprintf( logfile , "%s%ld\n",  "wizard-defined function space " , (long)wizfnspace ) 
	  ; 
	  fprintf( standardoutput , "%s%ld\n",  "wizard-defined function space " ,           (long)wizfnspace ) ; 
	} 
	longjmp(jmp9998,1) ; 
      } 
    } 
    ilkinfo [ fnhashloc ] = wizdefptr ; 
    copyptr = 0 ; 
    while ( ( copyptr < singleptr ) ) {
	
      wizfunctions [ wizdefptr ] = singlfunction [ copyptr ] ; 
      copyptr = copyptr + 1 ; 
      wizdefptr = wizdefptr + 1 ; 
    } 
  } 
  bufptr2 = bufptr2 + 1 ; 
  lab10: ; 
} 
boolean 
eatbibwhitespace ( ) 
{/* 10 */ register boolean Result; while ( ( ! scanwhitespace () ) ) {
    
    if ( ( ! inputln ( bibfile [ bibptr ] ) ) ) 
    {
      Result = false ; 
      goto lab10 ; 
    } 
    biblinenum = biblinenum + 1 ; 
    bufptr2 = 0 ; 
  } 
  Result = true ; 
  lab10: ; 
  return Result ; 
} 
boolean 
compressbibwhite ( ) 
{/* 10 */ register boolean Result; Result = false ; 
  {
    if ( ( exbufptr == bufsize ) ) 
    {
      bibfieldtoolongprint () ; 
      goto lab10 ; 
    } 
    else {
	
      exbuf [ exbufptr ] = 32 ; 
      exbufptr = exbufptr + 1 ; 
    } 
  } 
  while ( ( ! scanwhitespace () ) ) {
      
    if ( ( ! inputln ( bibfile [ bibptr ] ) ) ) 
    {
      eatbibprint () ; 
      goto lab10 ; 
    } 
    biblinenum = biblinenum + 1 ; 
    bufptr2 = 0 ; 
  } 
  Result = true ; 
  lab10: ; 
  return Result ; 
} 
boolean 
scanbalancedbraces ( ) 
{/* 15 10 */ register boolean Result; Result = false ; 
  bufptr2 = bufptr2 + 1 ; 
  {
    if ( ( ( lexclass [ buffer [ bufptr2 ] ] == 1 ) || ( bufptr2 == last ) ) ) 
    if ( ( ! compressbibwhite () ) ) 
    goto lab10 ; 
  } 
  if ( ( exbufptr > 1 ) ) 
  if ( ( exbuf [ exbufptr - 1 ] == 32 ) ) 
  if ( ( exbuf [ exbufptr - 2 ] == 32 ) ) 
  exbufptr = exbufptr - 1 ; 
  bibbracelevel = 0 ; 
  if ( ( storefield ) ) 
  {
    while ( ( buffer [ bufptr2 ] != rightstrdelim ) ) switch ( ( buffer [ 
    bufptr2 ] ) ) 
    {case 123 : 
      {
	bibbracelevel = bibbracelevel + 1 ; 
	{
	  if ( ( exbufptr == bufsize ) ) 
	  {
	    bibfieldtoolongprint () ; 
	    goto lab10 ; 
	  } 
	  else {
	      
	    exbuf [ exbufptr ] = 123 ; 
	    exbufptr = exbufptr + 1 ; 
	  } 
	} 
	bufptr2 = bufptr2 + 1 ; 
	{
	  if ( ( ( lexclass [ buffer [ bufptr2 ] ] == 1 ) || ( bufptr2 == last 
	  ) ) ) 
	  if ( ( ! compressbibwhite () ) ) 
	  goto lab10 ; 
	} 
	{
	  while ( true ) switch ( ( buffer [ bufptr2 ] ) ) 
	  {case 125 : 
	    {
	      bibbracelevel = bibbracelevel - 1 ; 
	      {
		if ( ( exbufptr == bufsize ) ) 
		{
		  bibfieldtoolongprint () ; 
		  goto lab10 ; 
		} 
		else {
		    
		  exbuf [ exbufptr ] = 125 ; 
		  exbufptr = exbufptr + 1 ; 
		} 
	      } 
	      bufptr2 = bufptr2 + 1 ; 
	      {
		if ( ( ( lexclass [ buffer [ bufptr2 ] ] == 1 ) || ( bufptr2 
		== last ) ) ) 
		if ( ( ! compressbibwhite () ) ) 
		goto lab10 ; 
	      } 
	      if ( ( bibbracelevel == 0 ) ) 
	      goto lab15 ; 
	    } 
	    break ; 
	  case 123 : 
	    {
	      bibbracelevel = bibbracelevel + 1 ; 
	      {
		if ( ( exbufptr == bufsize ) ) 
		{
		  bibfieldtoolongprint () ; 
		  goto lab10 ; 
		} 
		else {
		    
		  exbuf [ exbufptr ] = 123 ; 
		  exbufptr = exbufptr + 1 ; 
		} 
	      } 
	      bufptr2 = bufptr2 + 1 ; 
	      {
		if ( ( ( lexclass [ buffer [ bufptr2 ] ] == 1 ) || ( bufptr2 
		== last ) ) ) 
		if ( ( ! compressbibwhite () ) ) 
		goto lab10 ; 
	      } 
	    } 
	    break ; 
	    default: 
	    {
	      {
		if ( ( exbufptr == bufsize ) ) 
		{
		  bibfieldtoolongprint () ; 
		  goto lab10 ; 
		} 
		else {
		    
		  exbuf [ exbufptr ] = buffer [ bufptr2 ] ; 
		  exbufptr = exbufptr + 1 ; 
		} 
	      } 
	      bufptr2 = bufptr2 + 1 ; 
	      {
		if ( ( ( lexclass [ buffer [ bufptr2 ] ] == 1 ) || ( bufptr2 
		== last ) ) ) 
		if ( ( ! compressbibwhite () ) ) 
		goto lab10 ; 
	      } 
	    } 
	    break ; 
	  } 
	  lab15: ; 
	} 
      } 
      break ; 
    case 125 : 
      {
	bibunbalancedbracesprint () ; 
	goto lab10 ; 
      } 
      break ; 
      default: 
      {
	{
	  if ( ( exbufptr == bufsize ) ) 
	  {
	    bibfieldtoolongprint () ; 
	    goto lab10 ; 
	  } 
	  else {
	      
	    exbuf [ exbufptr ] = buffer [ bufptr2 ] ; 
	    exbufptr = exbufptr + 1 ; 
	  } 
	} 
	bufptr2 = bufptr2 + 1 ; 
	{
	  if ( ( ( lexclass [ buffer [ bufptr2 ] ] == 1 ) || ( bufptr2 == last 
	  ) ) ) 
	  if ( ( ! compressbibwhite () ) ) 
	  goto lab10 ; 
	} 
      } 
      break ; 
    } 
  } 
  else {
      
    while ( ( buffer [ bufptr2 ] != rightstrdelim ) ) if ( ( buffer [ bufptr2 
    ] == 123 ) ) 
    {
      bibbracelevel = bibbracelevel + 1 ; 
      bufptr2 = bufptr2 + 1 ; 
      {
	if ( ( ! eatbibwhitespace () ) ) 
	{
	  eatbibprint () ; 
	  goto lab10 ; 
	} 
      } 
      while ( ( bibbracelevel > 0 ) ) {
	  
	if ( ( buffer [ bufptr2 ] == 125 ) ) 
	{
	  bibbracelevel = bibbracelevel - 1 ; 
	  bufptr2 = bufptr2 + 1 ; 
	  {
	    if ( ( ! eatbibwhitespace () ) ) 
	    {
	      eatbibprint () ; 
	      goto lab10 ; 
	    } 
	  } 
	} 
	else if ( ( buffer [ bufptr2 ] == 123 ) ) 
	{
	  bibbracelevel = bibbracelevel + 1 ; 
	  bufptr2 = bufptr2 + 1 ; 
	  {
	    if ( ( ! eatbibwhitespace () ) ) 
	    {
	      eatbibprint () ; 
	      goto lab10 ; 
	    } 
	  } 
	} 
	else {
	    
	  bufptr2 = bufptr2 + 1 ; 
	  if ( ( ! scan2 ( 125 , 123 ) ) ) 
	  {
	    if ( ( ! eatbibwhitespace () ) ) 
	    {
	      eatbibprint () ; 
	      goto lab10 ; 
	    } 
	  } 
	} 
      } 
    } 
    else if ( ( buffer [ bufptr2 ] == 125 ) ) 
    {
      bibunbalancedbracesprint () ; 
      goto lab10 ; 
    } 
    else {
	
      bufptr2 = bufptr2 + 1 ; 
      if ( ( ! scan3 ( rightstrdelim , 123 , 125 ) ) ) 
      {
	if ( ( ! eatbibwhitespace () ) ) 
	{
	  eatbibprint () ; 
	  goto lab10 ; 
	} 
      } 
    } 
  } 
  bufptr2 = bufptr2 + 1 ; 
  Result = true ; 
  lab10: ; 
  return Result ; 
} 
boolean 
scanafieldtokenandeatwhite ( ) 
{/* 10 */ register boolean Result; Result = false ; 
  switch ( ( buffer [ bufptr2 ] ) ) 
  {case 123 : 
    {
      rightstrdelim = 125 ; 
      if ( ( ! scanbalancedbraces () ) ) 
      goto lab10 ; 
    } 
    break ; 
  case 34 : 
    {
      rightstrdelim = 34 ; 
      if ( ( ! scanbalancedbraces () ) ) 
      goto lab10 ; 
    } 
    break ; 
  case 48 : 
  case 49 : 
  case 50 : 
  case 51 : 
  case 52 : 
  case 53 : 
  case 54 : 
  case 55 : 
  case 56 : 
  case 57 : 
    {
      if ( ( ! scannonneginteger () ) ) 
      {
	{
	  Fputs( logfile ,  "A digit disappeared" ) ; 
	  Fputs( standardoutput ,  "A digit disappeared" ) ; 
	} 
	printconfusion () ; 
	longjmp(jmp9998,1) ; 
      } 
      if ( ( storefield ) ) 
      {
	tmpptr = bufptr1 ; 
	while ( ( tmpptr < bufptr2 ) ) {
	    
	  {
	    if ( ( exbufptr == bufsize ) ) 
	    {
	      bibfieldtoolongprint () ; 
	      goto lab10 ; 
	    } 
	    else {
		
	      exbuf [ exbufptr ] = buffer [ tmpptr ] ; 
	      exbufptr = exbufptr + 1 ; 
	    } 
	  } 
	  tmpptr = tmpptr + 1 ; 
	} 
      } 
    } 
    break ; 
    default: 
    {
      scanidentifier ( 44 , rightouterdelim , 35 ) ; 
      {
	if ( ( ( scanresult == 3 ) || ( scanresult == 1 ) ) ) 
	; 
	else {
	    
	  bibidprint () ; 
	  {
	    {
	      Fputs( logfile ,  "a field part" ) ; 
	      Fputs( standardoutput ,  "a field part" ) ; 
	    } 
	    biberrprint () ; 
	    goto lab10 ; 
	  } 
	} 
      } 
      if ( ( storefield ) ) 
      {
	lowercase ( buffer , bufptr1 , ( bufptr2 - bufptr1 ) ) ; 
	macronameloc = strlookup ( buffer , bufptr1 , ( bufptr2 - bufptr1 ) , 
	13 , false ) ; 
	storetoken = true ; 
	if ( ( atbibcommand ) ) 
	if ( ( commandnum == 2 ) ) 
	if ( ( macronameloc == curmacroloc ) ) 
	{
	  storetoken = false ; 
	  {
	    macrowarnprint () ; 
	    {
	      {
		fprintf( logfile , "%s\n",  "used in its own definition" ) ; 
		fprintf( standardoutput , "%s\n",  "used in its own definition" ) ; 
	      } 
	      bibwarnprint () ; 
	    } 
	  } 
	} 
	if ( ( ! hashfound ) ) 
	{
	  storetoken = false ; 
	  {
	    macrowarnprint () ; 
	    {
	      {
		fprintf( logfile , "%s\n",  "undefined" ) ; 
		fprintf( standardoutput , "%s\n",  "undefined" ) ; 
	      } 
	      bibwarnprint () ; 
	    } 
	  } 
	} 
	if ( ( storetoken ) ) 
	{
	  tmpptr = strstart [ ilkinfo [ macronameloc ] ] ; 
	  tmpendptr = strstart [ ilkinfo [ macronameloc ] + 1 ] ; 
	  if ( ( exbufptr == 0 ) ) 
	  if ( ( ( lexclass [ strpool [ tmpptr ] ] == 1 ) && ( tmpptr < 
	  tmpendptr ) ) ) 
	  {
	    {
	      if ( ( exbufptr == bufsize ) ) 
	      {
		bibfieldtoolongprint () ; 
		goto lab10 ; 
	      } 
	      else {
		  
		exbuf [ exbufptr ] = 32 ; 
		exbufptr = exbufptr + 1 ; 
	      } 
	    } 
	    tmpptr = tmpptr + 1 ; 
	    while ( ( ( lexclass [ strpool [ tmpptr ] ] == 1 ) && ( tmpptr < 
	    tmpendptr ) ) ) tmpptr = tmpptr + 1 ; 
	  } 
	  while ( ( tmpptr < tmpendptr ) ) {
	      
	    if ( ( lexclass [ strpool [ tmpptr ] ] != 1 ) ) 
	    {
	      if ( ( exbufptr == bufsize ) ) 
	      {
		bibfieldtoolongprint () ; 
		goto lab10 ; 
	      } 
	      else {
		  
		exbuf [ exbufptr ] = strpool [ tmpptr ] ; 
		exbufptr = exbufptr + 1 ; 
	      } 
	    } 
	    else if ( ( exbuf [ exbufptr - 1 ] != 32 ) ) 
	    {
	      if ( ( exbufptr == bufsize ) ) 
	      {
		bibfieldtoolongprint () ; 
		goto lab10 ; 
	      } 
	      else {
		  
		exbuf [ exbufptr ] = 32 ; 
		exbufptr = exbufptr + 1 ; 
	      } 
	    } 
	    tmpptr = tmpptr + 1 ; 
	  } 
	} 
      } 
    } 
    break ; 
  } 
  {
    if ( ( ! eatbibwhitespace () ) ) 
    {
      eatbibprint () ; 
      goto lab10 ; 
    } 
  } 
  Result = true ; 
  lab10: ; 
  return Result ; 
} 
boolean 
scanandstorethefieldvalueandeatwhite ( ) 
{/* 10 */ register boolean Result; Result = false ; 
  exbufptr = 0 ; 
  if ( ( ! scanafieldtokenandeatwhite () ) ) 
  goto lab10 ; 
  while ( ( buffer [ bufptr2 ] == 35 ) ) {
      
    bufptr2 = bufptr2 + 1 ; 
    {
      if ( ( ! eatbibwhitespace () ) ) 
      {
	eatbibprint () ; 
	goto lab10 ; 
      } 
    } 
    if ( ( ! scanafieldtokenandeatwhite () ) ) 
    goto lab10 ; 
  } 
  if ( ( storefield ) ) 
  {
    if ( ( ! atbibcommand ) ) 
    if ( ( exbufptr > 0 ) ) 
    if ( ( exbuf [ exbufptr - 1 ] == 32 ) ) 
    exbufptr = exbufptr - 1 ; 
    if ( ( ( ! atbibcommand ) && ( exbuf [ 0 ] == 32 ) && ( exbufptr > 0 ) ) ) 
    exbufxptr = 1 ; 
    else exbufxptr = 0 ; 
    fieldvalloc = strlookup ( exbuf , exbufxptr , exbufptr - exbufxptr , 0 , 
    true ) ; 
    fntype [ fieldvalloc ] = 3 ; 
	;
#ifdef TRACE
    {
      putc ( '"' ,  logfile );
    } 
    {
      outpoolstr ( logfile , hashtext [ fieldvalloc ] ) ; 
    } 
    {
      fprintf( logfile , "%s\n",  "\" is a field value" ) ; 
    } 
#endif /* TRACE */
    if ( ( atbibcommand ) ) 
    {
      switch ( ( commandnum ) ) 
      {case 1 : 
	{
	  spreamble [ preambleptr ] = hashtext [ fieldvalloc ] ; 
	  preambleptr = preambleptr + 1 ; 
	} 
	break ; 
      case 2 : 
	ilkinfo [ curmacroloc ] = hashtext [ fieldvalloc ] ; 
	break ; 
	default: 
	bibcmdconfusion () ; 
	break ; 
      } 
    } 
    else {
	
      fieldptr = entryciteptr * numfields + ilkinfo [ fieldnameloc ] ; 
      if ( ( fieldinfo [ fieldptr ] != 0 ) ) 
      {
	{
	  Fputs( logfile ,  "Warning--I'm ignoring " ) ; 
	  Fputs( standardoutput ,  "Warning--I'm ignoring " ) ; 
	} 
	printapoolstr ( citelist [ entryciteptr ] ) ; 
	{
	  Fputs( logfile ,  "'s extra \"" ) ; 
	  Fputs( standardoutput ,  "'s extra \"" ) ; 
	} 
	printapoolstr ( hashtext [ fieldnameloc ] ) ; 
	{
	  {
	    fprintf( logfile , "%s\n",  "\" field" ) ; 
	    fprintf( standardoutput , "%s\n",  "\" field" ) ; 
	  } 
	  bibwarnprint () ; 
	} 
      } 
      else {
	  
	fieldinfo [ fieldptr ] = hashtext [ fieldvalloc ] ; 
	if ( ( ( ilkinfo [ fieldnameloc ] == crossrefnum ) && ( ! allentries ) 
	) ) 
	{
	  tmpptr = exbufxptr ; 
	  while ( ( tmpptr < exbufptr ) ) {
	      
	    outbuf [ tmpptr ] = exbuf [ tmpptr ] ; 
	    tmpptr = tmpptr + 1 ; 
	  } 
	  lowercase ( outbuf , exbufxptr , exbufptr - exbufxptr ) ; 
	  lcciteloc = strlookup ( outbuf , exbufxptr , exbufptr - exbufxptr , 
	  10 , true ) ; 
	  if ( ( hashfound ) ) 
	  {
	    citeloc = ilkinfo [ lcciteloc ] ; 
	    if ( ( ilkinfo [ citeloc ] >= oldnumcites ) ) 
	    citeinfo [ ilkinfo [ citeloc ] ] = citeinfo [ ilkinfo [ citeloc ] 
	    ] + 1 ; 
	  } 
	  else {
	      
	    citeloc = strlookup ( exbuf , exbufxptr , exbufptr - exbufxptr , 9 
	    , true ) ; 
	    if ( ( hashfound ) ) 
	    hashciteconfusion () ; 
	    adddatabasecite ( citeptr ) ; 
	    citeinfo [ ilkinfo [ citeloc ] ] = 1 ; 
	  } 
	} 
      } 
    } 
  } 
  Result = true ; 
  lab10: ; 
  return Result ; 
} 
void 
zdecrbracelevel ( poplitvar ) 
  strnumber poplitvar ; 
{if ( ( bracelevel == 0 ) ) 
  bracesunbalancedcomplaint ( poplitvar ) ; 
  else bracelevel = bracelevel - 1 ; 
} 
void 
zcheckbracelevel ( poplitvar ) 
  strnumber poplitvar ; 
{if ( ( bracelevel > 0 ) ) 
  bracesunbalancedcomplaint ( poplitvar ) ; 
} 
void 
znamescanforand ( poplitvar ) 
  strnumber poplitvar ; 
{bracelevel = 0 ; 
  precedingwhite = false ; 
  andfound = false ; 
  while ( ( ( ! andfound ) && ( exbufptr < exbuflength ) ) ) switch ( ( exbuf 
  [ exbufptr ] ) ) 
  {case 97 : 
  case 65 : 
    {
      exbufptr = exbufptr + 1 ; 
      if ( ( precedingwhite ) ) 
      {
	if ( ( exbufptr <= ( exbuflength - 3 ) ) ) 
	if ( ( ( exbuf [ exbufptr ] == 110 ) || ( exbuf [ exbufptr ] == 78 ) ) 
	) 
	if ( ( ( exbuf [ exbufptr + 1 ] == 100 ) || ( exbuf [ exbufptr + 1 ] 
	== 68 ) ) ) 
	if ( ( lexclass [ exbuf [ exbufptr + 2 ] ] == 1 ) ) 
	{
	  exbufptr = exbufptr + 2 ; 
	  andfound = true ; 
	} 
      } 
      precedingwhite = false ; 
    } 
    break ; 
  case 123 : 
    {
      bracelevel = bracelevel + 1 ; 
      exbufptr = exbufptr + 1 ; 
      while ( ( ( bracelevel > 0 ) && ( exbufptr < exbuflength ) ) ) {
	  
	if ( ( exbuf [ exbufptr ] == 125 ) ) 
	bracelevel = bracelevel - 1 ; 
	else if ( ( exbuf [ exbufptr ] == 123 ) ) 
	bracelevel = bracelevel + 1 ; 
	exbufptr = exbufptr + 1 ; 
      } 
      precedingwhite = false ; 
    } 
    break ; 
  case 125 : 
    {
      decrbracelevel ( poplitvar ) ; 
      exbufptr = exbufptr + 1 ; 
      precedingwhite = false ; 
    } 
    break ; 
    default: 
    if ( ( lexclass [ exbuf [ exbufptr ] ] == 1 ) ) 
    {
      exbufptr = exbufptr + 1 ; 
      precedingwhite = true ; 
    } 
    else {
	
      exbufptr = exbufptr + 1 ; 
      precedingwhite = false ; 
    } 
    break ; 
  } 
  checkbracelevel ( poplitvar ) ; 
} 
boolean 
vontokenfound ( ) 
{/* 10 */ register boolean Result; nmbracelevel = 0 ; 
  Result = false ; 
  while ( ( namebfptr < namebfxptr ) ) if ( ( ( svbuffer [ namebfptr ] >= 65 ) 
  && ( svbuffer [ namebfptr ] <= 90 ) ) ) 
  goto lab10 ; 
  else if ( ( ( svbuffer [ namebfptr ] >= 97 ) && ( svbuffer [ namebfptr ] <= 
  122 ) ) ) 
  {
    Result = true ; 
    goto lab10 ; 
  } 
  else if ( ( svbuffer [ namebfptr ] == 123 ) ) 
  {
    nmbracelevel = nmbracelevel + 1 ; 
    namebfptr = namebfptr + 1 ; 
    if ( ( ( namebfptr + 2 < namebfxptr ) && ( svbuffer [ namebfptr ] == 92 ) 
    ) ) 
    {
      namebfptr = namebfptr + 1 ; 
      namebfyptr = namebfptr ; 
      while ( ( ( namebfptr < namebfxptr ) && ( lexclass [ svbuffer [ 
      namebfptr ] ] == 2 ) ) ) namebfptr = namebfptr + 1 ; 
      controlseqloc = strlookup ( svbuffer , namebfyptr , namebfptr - 
      namebfyptr , 14 , false ) ; 
      if ( ( hashfound ) ) 
      {
	switch ( ( ilkinfo [ controlseqloc ] ) ) 
	{case 3 : 
	case 5 : 
	case 7 : 
	case 9 : 
	case 11 : 
	  goto lab10 ; 
	  break ; 
	case 0 : 
	case 1 : 
	case 2 : 
	case 4 : 
	case 6 : 
	case 8 : 
	case 10 : 
	case 12 : 
	  {
	    Result = true ; 
	    goto lab10 ; 
	  } 
	  break ; 
	  default: 
	  {
	    {
	      Fputs( logfile ,  "Control-sequence hash error" ) ; 
	      Fputs( standardoutput ,  "Control-sequence hash error" ) ; 
	    } 
	    printconfusion () ; 
	    longjmp(jmp9998,1) ; 
	  } 
	  break ; 
	} 
      } 
      while ( ( ( namebfptr < namebfxptr ) && ( nmbracelevel > 0 ) ) ) {
	  
	if ( ( ( svbuffer [ namebfptr ] >= 65 ) && ( svbuffer [ namebfptr ] <= 
	90 ) ) ) 
	goto lab10 ; 
	else if ( ( ( svbuffer [ namebfptr ] >= 97 ) && ( svbuffer [ namebfptr 
	] <= 122 ) ) ) 
	{
	  Result = true ; 
	  goto lab10 ; 
	} 
	else if ( ( svbuffer [ namebfptr ] == 125 ) ) 
	nmbracelevel = nmbracelevel - 1 ; 
	else if ( ( svbuffer [ namebfptr ] == 123 ) ) 
	nmbracelevel = nmbracelevel + 1 ; 
	namebfptr = namebfptr + 1 ; 
      } 
      goto lab10 ; 
    } 
    else while ( ( ( nmbracelevel > 0 ) && ( namebfptr < namebfxptr ) ) ) {
	
      if ( ( svbuffer [ namebfptr ] == 125 ) ) 
      nmbracelevel = nmbracelevel - 1 ; 
      else if ( ( svbuffer [ namebfptr ] == 123 ) ) 
      nmbracelevel = nmbracelevel + 1 ; 
      namebfptr = namebfptr + 1 ; 
    } 
  } 
  else namebfptr = namebfptr + 1 ; 
  lab10: ; 
  return Result ; 
} 
void 
vonnameendsandlastnamestartsstuff ( ) 
{/* 10 */ vonend = lastend - 1 ; 
  while ( ( vonend > vonstart ) ) {
      
    namebfptr = nametok [ vonend - 1 ] ; 
    namebfxptr = nametok [ vonend ] ; 
    if ( ( vontokenfound () ) ) 
    goto lab10 ; 
    vonend = vonend - 1 ; 
  } 
  lab10: ; 
} 
void 
skipstuffatspbracelevelgreaterthanone ( ) 
{while ( ( ( spbracelevel > 1 ) && ( spptr < spend ) ) ) {
    
    if ( ( strpool [ spptr ] == 125 ) ) 
    spbracelevel = spbracelevel - 1 ; 
    else if ( ( strpool [ spptr ] == 123 ) ) 
    spbracelevel = spbracelevel + 1 ; 
    spptr = spptr + 1 ; 
  } 
} 
void 
bracelvloneletterscomplaint ( ) 
{{
    
    Fputs( logfile ,  "The format string \"" ) ; 
    Fputs( standardoutput ,  "The format string \"" ) ; 
  } 
  printapoolstr ( poplit1 ) ; 
  {
    {
      Fputs( logfile ,  "\" has an illegal brace-level-1 letter" ) ; 
      Fputs( standardoutput ,  "\" has an illegal brace-level-1 letter" ) ; 
    } 
    bstexwarnprint () ; 
  } 
} 
boolean 
zenoughtextchars ( enoughchars ) 
  bufpointer enoughchars ; 
{register boolean Result; numtextchars = 0 ; 
  exbufyptr = exbufxptr ; 
  while ( ( ( exbufyptr < exbufptr ) && ( numtextchars < enoughchars ) ) ) {
      
    exbufyptr = exbufyptr + 1 ; 
    if ( ( exbuf [ exbufyptr - 1 ] == 123 ) ) 
    {
      bracelevel = bracelevel + 1 ; 
      if ( ( ( bracelevel == 1 ) && ( exbufyptr < exbufptr ) ) ) 
      if ( ( exbuf [ exbufyptr ] == 92 ) ) 
      {
	exbufyptr = exbufyptr + 1 ; 
	while ( ( ( exbufyptr < exbufptr ) && ( bracelevel > 0 ) ) ) {
	    
	  if ( ( exbuf [ exbufyptr ] == 125 ) ) 
	  bracelevel = bracelevel - 1 ; 
	  else if ( ( exbuf [ exbufyptr ] == 123 ) ) 
	  bracelevel = bracelevel + 1 ; 
	  exbufyptr = exbufyptr + 1 ; 
	} 
      } 
    } 
    else if ( ( exbuf [ exbufyptr - 1 ] == 125 ) ) 
    bracelevel = bracelevel - 1 ; 
    numtextchars = numtextchars + 1 ; 
  } 
  if ( ( numtextchars < enoughchars ) ) 
  Result = false ; 
  else Result = true ; 
  return Result ; 
} 
void 
figureouttheformattedname ( ) 
{/* 15 */ {
    
    exbufptr = 0 ; 
    spbracelevel = 0 ; 
    spptr = strstart [ poplit1 ] ; 
    spend = strstart [ poplit1 + 1 ] ; 
    while ( ( spptr < spend ) ) if ( ( strpool [ spptr ] == 123 ) ) 
    {
      spbracelevel = spbracelevel + 1 ; 
      spptr = spptr + 1 ; 
      {
	spxptr1 = spptr ; 
	alphafound = false ; 
	doubleletter = false ; 
	endofgroup = false ; 
	tobewritten = true ; 
	while ( ( ( ! endofgroup ) && ( spptr < spend ) ) ) if ( ( lexclass [ 
	strpool [ spptr ] ] == 2 ) ) 
	{
	  spptr = spptr + 1 ; 
	  {
	    if ( ( alphafound ) ) 
	    {
	      bracelvloneletterscomplaint () ; 
	      tobewritten = false ; 
	    } 
	    else {
		
	      switch ( ( strpool [ spptr - 1 ] ) ) 
	      {case 102 : 
	      case 70 : 
		{
		  curtoken = firststart ; 
		  lasttoken = firstend ; 
		  if ( ( curtoken == lasttoken ) ) 
		  tobewritten = false ; 
		  if ( ( ( strpool [ spptr ] == 102 ) || ( strpool [ spptr ] 
		  == 70 ) ) ) 
		  doubleletter = true ; 
		} 
		break ; 
	      case 118 : 
	      case 86 : 
		{
		  curtoken = vonstart ; 
		  lasttoken = vonend ; 
		  if ( ( curtoken == lasttoken ) ) 
		  tobewritten = false ; 
		  if ( ( ( strpool [ spptr ] == 118 ) || ( strpool [ spptr ] 
		  == 86 ) ) ) 
		  doubleletter = true ; 
		} 
		break ; 
	      case 108 : 
	      case 76 : 
		{
		  curtoken = vonend ; 
		  lasttoken = lastend ; 
		  if ( ( curtoken == lasttoken ) ) 
		  tobewritten = false ; 
		  if ( ( ( strpool [ spptr ] == 108 ) || ( strpool [ spptr ] 
		  == 76 ) ) ) 
		  doubleletter = true ; 
		} 
		break ; 
	      case 106 : 
	      case 74 : 
		{
		  curtoken = lastend ; 
		  lasttoken = jrend ; 
		  if ( ( curtoken == lasttoken ) ) 
		  tobewritten = false ; 
		  if ( ( ( strpool [ spptr ] == 106 ) || ( strpool [ spptr ] 
		  == 74 ) ) ) 
		  doubleletter = true ; 
		} 
		break ; 
		default: 
		{
		  bracelvloneletterscomplaint () ; 
		  tobewritten = false ; 
		} 
		break ; 
	      } 
	      if ( ( doubleletter ) ) 
	      spptr = spptr + 1 ; 
	    } 
	    alphafound = true ; 
	  } 
	} 
	else if ( ( strpool [ spptr ] == 125 ) ) 
	{
	  spbracelevel = spbracelevel - 1 ; 
	  spptr = spptr + 1 ; 
	  endofgroup = true ; 
	} 
	else if ( ( strpool [ spptr ] == 123 ) ) 
	{
	  spbracelevel = spbracelevel + 1 ; 
	  spptr = spptr + 1 ; 
	  skipstuffatspbracelevelgreaterthanone () ; 
	} 
	else spptr = spptr + 1 ; 
	if ( ( ( endofgroup ) && ( tobewritten ) ) ) 
	{
	  exbufxptr = exbufptr ; 
	  spptr = spxptr1 ; 
	  spbracelevel = 1 ; 
	  while ( ( spbracelevel > 0 ) ) if ( ( ( lexclass [ strpool [ spptr ] 
	  ] == 2 ) && ( spbracelevel == 1 ) ) ) 
	  {
	    spptr = spptr + 1 ; 
	    {
	      if ( ( doubleletter ) ) 
	      spptr = spptr + 1 ; 
	      usedefault = true ; 
	      spxptr2 = spptr ; 
	      if ( ( strpool [ spptr ] == 123 ) ) 
	      {
		usedefault = false ; 
		spbracelevel = spbracelevel + 1 ; 
		spptr = spptr + 1 ; 
		spxptr1 = spptr ; 
		skipstuffatspbracelevelgreaterthanone () ; 
		spxptr2 = spptr - 1 ; 
	      } 
	      while ( ( curtoken < lasttoken ) ) {
		  
		if ( ( doubleletter ) ) 
		{
		  namebfptr = nametok [ curtoken ] ; 
		  namebfxptr = nametok [ curtoken + 1 ] ; 
		  if ( ( exbuflength + ( namebfxptr - namebfptr ) > bufsize ) 
		  ) 
		  bufferoverflow () ; 
		  while ( ( namebfptr < namebfxptr ) ) {
		      
		    {
		      exbuf [ exbufptr ] = svbuffer [ namebfptr ] ; 
		      exbufptr = exbufptr + 1 ; 
		    } 
		    namebfptr = namebfptr + 1 ; 
		  } 
		} 
		else {
		    
		  namebfptr = nametok [ curtoken ] ; 
		  namebfxptr = nametok [ curtoken + 1 ] ; 
		  while ( ( namebfptr < namebfxptr ) ) {
		      
		    if ( ( lexclass [ svbuffer [ namebfptr ] ] == 2 ) ) 
		    {
		      {
			if ( ( exbufptr == bufsize ) ) 
			bufferoverflow () ; 
			{
			  exbuf [ exbufptr ] = svbuffer [ namebfptr ] ; 
			  exbufptr = exbufptr + 1 ; 
			} 
		      } 
		      goto lab15 ; 
		    } 
		    else if ( ( ( svbuffer [ namebfptr ] == 123 ) && ( 
		    namebfptr + 1 < namebfxptr ) ) ) 
		    if ( ( svbuffer [ namebfptr + 1 ] == 92 ) ) 
		    {
		      if ( ( exbufptr + 2 > bufsize ) ) 
		      bufferoverflow () ; 
		      {
			exbuf [ exbufptr ] = 123 ; 
			exbufptr = exbufptr + 1 ; 
		      } 
		      {
			exbuf [ exbufptr ] = 92 ; 
			exbufptr = exbufptr + 1 ; 
		      } 
		      namebfptr = namebfptr + 2 ; 
		      nmbracelevel = 1 ; 
		      while ( ( ( namebfptr < namebfxptr ) && ( nmbracelevel > 
		      0 ) ) ) {
			  
			if ( ( svbuffer [ namebfptr ] == 125 ) ) 
			nmbracelevel = nmbracelevel - 1 ; 
			else if ( ( svbuffer [ namebfptr ] == 123 ) ) 
			nmbracelevel = nmbracelevel + 1 ; 
			{
			  if ( ( exbufptr == bufsize ) ) 
			  bufferoverflow () ; 
			  {
			    exbuf [ exbufptr ] = svbuffer [ namebfptr ] ; 
			    exbufptr = exbufptr + 1 ; 
			  } 
			} 
			namebfptr = namebfptr + 1 ; 
		      } 
		      goto lab15 ; 
		    } 
		    namebfptr = namebfptr + 1 ; 
		  } 
		  lab15: ; 
		} 
		curtoken = curtoken + 1 ; 
		if ( ( curtoken < lasttoken ) ) 
		{
		  if ( ( usedefault ) ) 
		  {
		    if ( ( ! doubleletter ) ) 
		    {
		      if ( ( exbufptr == bufsize ) ) 
		      bufferoverflow () ; 
		      {
			exbuf [ exbufptr ] = 46 ; 
			exbufptr = exbufptr + 1 ; 
		      } 
		    } 
		    if ( ( lexclass [ namesepchar [ curtoken ] ] == 4 ) ) 
		    {
		      if ( ( exbufptr == bufsize ) ) 
		      bufferoverflow () ; 
		      {
			exbuf [ exbufptr ] = namesepchar [ curtoken ] ; 
			exbufptr = exbufptr + 1 ; 
		      } 
		    } 
		    else if ( ( ( curtoken == lasttoken - 1 ) || ( ! 
		    enoughtextchars ( 3 ) ) ) ) 
		    {
		      if ( ( exbufptr == bufsize ) ) 
		      bufferoverflow () ; 
		      {
			exbuf [ exbufptr ] = 126 ; 
			exbufptr = exbufptr + 1 ; 
		      } 
		    } 
		    else {
			
		      if ( ( exbufptr == bufsize ) ) 
		      bufferoverflow () ; 
		      {
			exbuf [ exbufptr ] = 32 ; 
			exbufptr = exbufptr + 1 ; 
		      } 
		    } 
		  } 
		  else {
		      
		    if ( ( exbuflength + ( spxptr2 - spxptr1 ) > bufsize ) ) 
		    bufferoverflow () ; 
		    spptr = spxptr1 ; 
		    while ( ( spptr < spxptr2 ) ) {
			
		      {
			exbuf [ exbufptr ] = strpool [ spptr ] ; 
			exbufptr = exbufptr + 1 ; 
		      } 
		      spptr = spptr + 1 ; 
		    } 
		  } 
		} 
	      } 
	      if ( ( ! usedefault ) ) 
	      spptr = spxptr2 + 1 ; 
	    } 
	  } 
	  else if ( ( strpool [ spptr ] == 125 ) ) 
	  {
	    spbracelevel = spbracelevel - 1 ; 
	    spptr = spptr + 1 ; 
	    if ( ( spbracelevel > 0 ) ) 
	    {
	      if ( ( exbufptr == bufsize ) ) 
	      bufferoverflow () ; 
	      {
		exbuf [ exbufptr ] = 125 ; 
		exbufptr = exbufptr + 1 ; 
	      } 
	    } 
	  } 
	  else if ( ( strpool [ spptr ] == 123 ) ) 
	  {
	    spbracelevel = spbracelevel + 1 ; 
	    spptr = spptr + 1 ; 
	    {
	      if ( ( exbufptr == bufsize ) ) 
	      bufferoverflow () ; 
	      {
		exbuf [ exbufptr ] = 123 ; 
		exbufptr = exbufptr + 1 ; 
	      } 
	    } 
	  } 
	  else {
	      
	    {
	      if ( ( exbufptr == bufsize ) ) 
	      bufferoverflow () ; 
	      {
		exbuf [ exbufptr ] = strpool [ spptr ] ; 
		exbufptr = exbufptr + 1 ; 
	      } 
	    } 
	    spptr = spptr + 1 ; 
	  } 
	  if ( ( exbufptr > 0 ) ) 
	  if ( ( exbuf [ exbufptr - 1 ] == 126 ) ) 
	  {
	    exbufptr = exbufptr - 1 ; 
	    if ( ( exbuf [ exbufptr - 1 ] == 126 ) ) 
	    ; 
	    else if ( ( ! enoughtextchars ( 3 ) ) ) 
	    exbufptr = exbufptr + 1 ; 
	    else {
		
	      exbuf [ exbufptr ] = 32 ; 
	      exbufptr = exbufptr + 1 ; 
	    } 
	  } 
	} 
      } 
    } 
    else if ( ( strpool [ spptr ] == 125 ) ) 
    {
      bracesunbalancedcomplaint ( poplit1 ) ; 
      spptr = spptr + 1 ; 
    } 
    else {
	
      {
	if ( ( exbufptr == bufsize ) ) 
	bufferoverflow () ; 
	{
	  exbuf [ exbufptr ] = strpool [ spptr ] ; 
	  exbufptr = exbufptr + 1 ; 
	} 
      } 
      spptr = spptr + 1 ; 
    } 
    if ( ( spbracelevel > 0 ) ) 
    bracesunbalancedcomplaint ( poplit1 ) ; 
    exbuflength = exbufptr ; 
  } 
} 
void 
zpushlitstk ( pushlt , pushtype ) 
  integer pushlt ; 
  stktype pushtype ; 
{
#ifdef TRACE
  litstkloc dumptr  ; 
#endif /* TRACE */
  litstack [ litstkptr ] = pushlt ; 
  litstktype [ litstkptr ] = pushtype ; 
	;
#ifdef TRACE
  {register integer for_end; dumptr = 0 ; for_end = litstkptr ; if ( dumptr 
  <= for_end) do 
    {
      Fputs( logfile ,  "  " ) ; 
    } 
  while ( dumptr++ < for_end ) ; } 
  {
    Fputs( logfile ,  "Pushing " ) ; 
  } 
  switch ( ( litstktype [ litstkptr ] ) ) 
  {case 0 : 
    {
      fprintf( logfile , "%ld\n",  (long)litstack [ litstkptr ] ) ; 
    } 
    break ; 
  case 1 : 
    {
      {
	putc ( '"' ,  logfile );
      } 
      {
	outpoolstr ( logfile , litstack [ litstkptr ] ) ; 
      } 
      {
	fprintf( logfile , "%c\n",  '"' ) ; 
      } 
    } 
    break ; 
  case 2 : 
    {
      {
	putc ( '`' ,  logfile );
      } 
      {
	outpoolstr ( logfile , hashtext [ litstack [ litstkptr ] ] ) ; 
      } 
      {
	fprintf( logfile , "%c\n",  '\'' ) ; 
      } 
    } 
    break ; 
  case 3 : 
    {
      {
	Fputs( logfile ,  "missing field `" ) ; 
      } 
      {
	outpoolstr ( logfile , litstack [ litstkptr ] ) ; 
      } 
      {
	fprintf( logfile , "%c\n",  '\'' ) ; 
      } 
    } 
    break ; 
  case 4 : 
    {
      fprintf( logfile , "%s\n",  "a bad literal--popped from an empty stack" ) ; 
    } 
    break ; 
    default: 
    unknwnliteralconfusion () ; 
    break ; 
  } 
#endif /* TRACE */
  if ( ( litstkptr == litstksize ) ) 
  {
    printoverflow () ; 
    {
      fprintf( logfile , "%s%ld\n",  "literal-stack size " , (long)litstksize ) ; 
      fprintf( standardoutput , "%s%ld\n",  "literal-stack size " , (long)litstksize ) ; 
    } 
    longjmp(jmp9998,1) ; 
  } 
  litstkptr = litstkptr + 1 ; 
} 
void 
zpoplitstk ( poplit , poptype ) 
  integer * poplit ; 
  stktype * poptype ; 
{if ( ( litstkptr == 0 ) ) 
  {
    {
      {
	Fputs( logfile ,  "You can't pop an empty literal stack" ) ; 
	Fputs( standardoutput ,  "You can't pop an empty literal stack" ) ; 
      } 
      bstexwarnprint () ; 
    } 
*    poptype = 4 ; 
  } 
  else {
      
    litstkptr = litstkptr - 1 ; 
*    poplit = litstack [ litstkptr ] ; 
*    poptype = litstktype [ litstkptr ] ; 
    if ( ( *poptype == 1 ) ) 
    if ( ( *poplit >= cmdstrptr ) ) 
    {
      if ( ( *poplit != strptr - 1 ) ) 
      {
	{
	  Fputs( logfile ,  "Nontop top of string stack" ) ; 
	  Fputs( standardoutput ,  "Nontop top of string stack" ) ; 
	} 
	printconfusion () ; 
	longjmp(jmp9998,1) ; 
      } 
      {
	strptr = strptr - 1 ; 
	poolptr = strstart [ strptr ] ; 
      } 
    } 
  } 
} 
void 
zprintwrongstklit ( stklt , stktp1 , stktp2 ) 
  integer stklt ; 
  stktype stktp1 ; 
  stktype stktp2 ; 
{if ( ( stktp1 != 4 ) ) 
  {
    printstklit ( stklt , stktp1 ) ; 
    switch ( ( stktp2 ) ) 
    {case 0 : 
      {
	Fputs( logfile ,  ", not an integer," ) ; 
	Fputs( standardoutput ,  ", not an integer," ) ; 
      } 
      break ; 
    case 1 : 
      {
	Fputs( logfile ,  ", not a string," ) ; 
	Fputs( standardoutput ,  ", not a string," ) ; 
      } 
      break ; 
    case 2 : 
      {
	Fputs( logfile ,  ", not a function," ) ; 
	Fputs( standardoutput ,  ", not a function," ) ; 
      } 
      break ; 
    case 3 : 
    case 4 : 
      illeglliteralconfusion () ; 
      break ; 
      default: 
      unknwnliteralconfusion () ; 
      break ; 
    } 
    bstexwarnprint () ; 
  } 
} 
void 
poptopandprint ( ) 
{integer stklt  ; 
  stktype stktp  ; 
  poplitstk ( stklt , stktp ) ; 
  if ( ( stktp == 4 ) ) 
  {
    fprintf( logfile , "%s\n",  "Empty literal" ) ; 
    fprintf( standardoutput , "%s\n",  "Empty literal" ) ; 
  } 
  else printlit ( stklt , stktp ) ; 
} 
void 
popwholestack ( ) 
{while ( ( litstkptr > 0 ) ) poptopandprint () ; 
} 
void 
initcommandexecution ( ) 
{litstkptr = 0 ; 
  cmdstrptr = strptr ; 
} 
void 
checkcommandexecution ( ) 
{if ( ( litstkptr != 0 ) ) 
  {
    {
      fprintf( logfile , "%s%ld%s\n",  "ptr=" , (long)litstkptr , ", stack=" ) ; 
      fprintf( standardoutput , "%s%ld%s\n",  "ptr=" , (long)litstkptr , ", stack=" ) ; 
    } 
    popwholestack () ; 
    {
      {
	Fputs( logfile ,  "---the literal stack isn't empty" ) ; 
	Fputs( standardoutput ,  "---the literal stack isn't empty" ) ; 
      } 
      bstexwarnprint () ; 
    } 
  } 
  if ( ( cmdstrptr != strptr ) ) 
  {
	;
#ifdef TRACE
    {
      fprintf( logfile , "%s%ld%s%ld\n",  "Pointer is " , (long)strptr , " but should be " ,       (long)cmdstrptr ) ; 
      fprintf( standardoutput , "%s%ld%s%ld\n",  "Pointer is " , (long)strptr , " but should be " ,       (long)cmdstrptr ) ; 
    } 
#endif /* TRACE */
    {
      {
	Fputs( logfile ,  "Nonempty empty string stack" ) ; 
	Fputs( standardoutput ,  "Nonempty empty string stack" ) ; 
      } 
      printconfusion () ; 
      longjmp(jmp9998,1) ; 
    } 
  } 
} 
void 
addpoolbufandpush ( ) 
{{
    
    if ( ( poolptr + exbuflength > poolsize ) ) 
    pooloverflow () ; 
  } 
  exbufptr = 0 ; 
  while ( ( exbufptr < exbuflength ) ) {
      
    {
      strpool [ poolptr ] = exbuf [ exbufptr ] ; 
      poolptr = poolptr + 1 ; 
    } 
    exbufptr = exbufptr + 1 ; 
  } 
  pushlitstk ( makestring () , 1 ) ; 
} 
void 
zaddbufpool ( pstr ) 
  strnumber pstr ; 
{pptr1 = strstart [ pstr ] ; 
  pptr2 = strstart [ pstr + 1 ] ; 
  if ( ( exbuflength + ( pptr2 - pptr1 ) > bufsize ) ) 
  bufferoverflow () ; 
  exbufptr = exbuflength ; 
  while ( ( pptr1 < pptr2 ) ) {
      
    {
      exbuf [ exbufptr ] = strpool [ pptr1 ] ; 
      exbufptr = exbufptr + 1 ; 
    } 
    pptr1 = pptr1 + 1 ; 
  } 
  exbuflength = exbufptr ; 
} 
void 
zaddoutpool ( pstr ) 
  strnumber pstr ; 
{bufpointer breakptr  ; 
  bufpointer endptr  ; 
  pptr1 = strstart [ pstr ] ; 
  pptr2 = strstart [ pstr + 1 ] ; 
  if ( ( outbuflength + ( pptr2 - pptr1 ) > bufsize ) ) 
  {
    printoverflow () ; 
    {
      fprintf( logfile , "%s%ld\n",  "output buffer size " , (long)bufsize ) ; 
      fprintf( standardoutput , "%s%ld\n",  "output buffer size " , (long)bufsize ) ; 
    } 
    longjmp(jmp9998,1) ; 
  } 
  outbufptr = outbuflength ; 
  while ( ( pptr1 < pptr2 ) ) {
      
    outbuf [ outbufptr ] = strpool [ pptr1 ] ; 
    pptr1 = pptr1 + 1 ; 
    outbufptr = outbufptr + 1 ; 
  } 
  outbuflength = outbufptr ; 
  while ( ( outbuflength > maxprintline ) ) {
      
    endptr = outbuflength ; 
    outbufptr = maxprintline ; 
    while ( ( ( lexclass [ outbuf [ outbufptr ] ] != 1 ) && ( outbufptr >= 
    minprintline ) ) ) outbufptr = outbufptr - 1 ; 
    if ( ( outbufptr == minprintline - 1 ) ) 
    {
      outbuf [ endptr ] = outbuf [ maxprintline - 1 ] ; 
      outbuf [ maxprintline - 1 ] = 37 ; 
      outbuflength = maxprintline ; 
      breakptr = outbuflength - 1 ; 
      outputbblline () ; 
      outbuf [ maxprintline - 1 ] = outbuf [ endptr ] ; 
      outbufptr = 0 ; 
      tmpptr = breakptr ; 
      while ( ( tmpptr < endptr ) ) {
	  
	outbuf [ outbufptr ] = outbuf [ tmpptr ] ; 
	outbufptr = outbufptr + 1 ; 
	tmpptr = tmpptr + 1 ; 
      } 
      outbuflength = endptr - breakptr ; 
    } 
    else {
	
      outbuflength = outbufptr ; 
      breakptr = outbuflength + 1 ; 
      outputbblline () ; 
      outbuf [ 0 ] = 32 ; 
      outbuf [ 1 ] = 32 ; 
      outbufptr = 2 ; 
      tmpptr = breakptr ; 
      while ( ( tmpptr < endptr ) ) {
	  
	outbuf [ outbufptr ] = outbuf [ tmpptr ] ; 
	outbufptr = outbufptr + 1 ; 
	tmpptr = tmpptr + 1 ; 
      } 
      outbuflength = endptr - breakptr + 2 ; 
    } 
  } 
} 
void 
xequals ( ) 
{poplitstk ( poplit1 , poptyp1 ) ; 
  poplitstk ( poplit2 , poptyp2 ) ; 
  if ( ( poptyp1 != poptyp2 ) ) 
  {
    if ( ( ( poptyp1 != 4 ) && ( poptyp2 != 4 ) ) ) 
    {
      printstklit ( poplit1 , poptyp1 ) ; 
      {
	Fputs( logfile ,  ", " ) ; 
	Fputs( standardoutput ,  ", " ) ; 
      } 
      printstklit ( poplit2 , poptyp2 ) ; 
      printanewline () ; 
      {
	{
	  Fputs( logfile ,  "---they aren't the same literal types" ) ; 
	  Fputs( standardoutput ,  "---they aren't the same literal types" ) ; 
	} 
	bstexwarnprint () ; 
      } 
    } 
    pushlitstk ( 0 , 0 ) ; 
  } 
  else if ( ( ( poptyp1 != 0 ) && ( poptyp1 != 1 ) ) ) 
  {
    if ( ( poptyp1 != 4 ) ) 
    {
      printstklit ( poplit1 , poptyp1 ) ; 
      {
	{
	  Fputs( logfile ,  ", not an integer or a string," ) ; 
	  Fputs( standardoutput ,  ", not an integer or a string," ) ; 
	} 
	bstexwarnprint () ; 
      } 
    } 
    pushlitstk ( 0 , 0 ) ; 
  } 
  else if ( ( poptyp1 == 0 ) ) 
  if ( ( poplit2 == poplit1 ) ) 
  pushlitstk ( 1 , 0 ) ; 
  else pushlitstk ( 0 , 0 ) ; 
  else if ( ( streqstr ( poplit2 , poplit1 ) ) ) 
  pushlitstk ( 1 , 0 ) ; 
  else pushlitstk ( 0 , 0 ) ; 
} 
void 
xgreaterthan ( ) 
{poplitstk ( poplit1 , poptyp1 ) ; 
  poplitstk ( poplit2 , poptyp2 ) ; 
  if ( ( poptyp1 != 0 ) ) 
  {
    printwrongstklit ( poplit1 , poptyp1 , 0 ) ; 
    pushlitstk ( 0 , 0 ) ; 
  } 
  else if ( ( poptyp2 != 0 ) ) 
  {
    printwrongstklit ( poplit2 , poptyp2 , 0 ) ; 
    pushlitstk ( 0 , 0 ) ; 
  } 
  else if ( ( poplit2 > poplit1 ) ) 
  pushlitstk ( 1 , 0 ) ; 
  else pushlitstk ( 0 , 0 ) ; 
} 
void 
xlessthan ( ) 
{poplitstk ( poplit1 , poptyp1 ) ; 
  poplitstk ( poplit2 , poptyp2 ) ; 
  if ( ( poptyp1 != 0 ) ) 
  {
    printwrongstklit ( poplit1 , poptyp1 , 0 ) ; 
    pushlitstk ( 0 , 0 ) ; 
  } 
  else if ( ( poptyp2 != 0 ) ) 
  {
    printwrongstklit ( poplit2 , poptyp2 , 0 ) ; 
    pushlitstk ( 0 , 0 ) ; 
  } 
  else if ( ( poplit2 < poplit1 ) ) 
  pushlitstk ( 1 , 0 ) ; 
  else pushlitstk ( 0 , 0 ) ; 
} 
void 
xplus ( ) 
{poplitstk ( poplit1 , poptyp1 ) ; 
  poplitstk ( poplit2 , poptyp2 ) ; 
  if ( ( poptyp1 != 0 ) ) 
  {
    printwrongstklit ( poplit1 , poptyp1 , 0 ) ; 
    pushlitstk ( 0 , 0 ) ; 
  } 
  else if ( ( poptyp2 != 0 ) ) 
  {
    printwrongstklit ( poplit2 , poptyp2 , 0 ) ; 
    pushlitstk ( 0 , 0 ) ; 
  } 
  else pushlitstk ( poplit2 + poplit1 , 0 ) ; 
} 
void 
xminus ( ) 
{poplitstk ( poplit1 , poptyp1 ) ; 
  poplitstk ( poplit2 , poptyp2 ) ; 
  if ( ( poptyp1 != 0 ) ) 
  {
    printwrongstklit ( poplit1 , poptyp1 , 0 ) ; 
    pushlitstk ( 0 , 0 ) ; 
  } 
  else if ( ( poptyp2 != 0 ) ) 
  {
    printwrongstklit ( poplit2 , poptyp2 , 0 ) ; 
    pushlitstk ( 0 , 0 ) ; 
  } 
  else pushlitstk ( poplit2 - poplit1 , 0 ) ; 
} 
void 
xconcatenate ( ) 
{poplitstk ( poplit1 , poptyp1 ) ; 
  poplitstk ( poplit2 , poptyp2 ) ; 
  if ( ( poptyp1 != 1 ) ) 
  {
    printwrongstklit ( poplit1 , poptyp1 , 1 ) ; 
    pushlitstk ( snull , 1 ) ; 
  } 
  else if ( ( poptyp2 != 1 ) ) 
  {
    printwrongstklit ( poplit2 , poptyp2 , 1 ) ; 
    pushlitstk ( snull , 1 ) ; 
  } 
  else {
      
    if ( ( poplit2 >= cmdstrptr ) ) 
    if ( ( poplit1 >= cmdstrptr ) ) 
    {
      strstart [ poplit1 ] = strstart [ poplit1 + 1 ] ; 
      {
	strptr = strptr + 1 ; 
	poolptr = strstart [ strptr ] ; 
      } 
      litstkptr = litstkptr + 1 ; 
    } 
    else if ( ( ( strstart [ poplit2 + 1 ] - strstart [ poplit2 ] ) == 0 ) ) 
    pushlitstk ( poplit1 , 1 ) ; 
    else {
	
      poolptr = strstart [ poplit2 + 1 ] ; 
      {
	if ( ( poolptr + ( strstart [ poplit1 + 1 ] - strstart [ poplit1 ] ) > 
	poolsize ) ) 
	pooloverflow () ; 
      } 
      spptr = strstart [ poplit1 ] ; 
      spend = strstart [ poplit1 + 1 ] ; 
      while ( ( spptr < spend ) ) {
	  
	{
	  strpool [ poolptr ] = strpool [ spptr ] ; 
	  poolptr = poolptr + 1 ; 
	} 
	spptr = spptr + 1 ; 
      } 
      pushlitstk ( makestring () , 1 ) ; 
    } 
    else {
	
      if ( ( poplit1 >= cmdstrptr ) ) 
      if ( ( ( strstart [ poplit2 + 1 ] - strstart [ poplit2 ] ) == 0 ) ) 
      {
	{
	  strptr = strptr + 1 ; 
	  poolptr = strstart [ strptr ] ; 
	} 
	litstack [ litstkptr ] = poplit1 ; 
	litstkptr = litstkptr + 1 ; 
      } 
      else if ( ( ( strstart [ poplit1 + 1 ] - strstart [ poplit1 ] ) == 0 ) ) 
      litstkptr = litstkptr + 1 ; 
      else {
	  
	splength = ( strstart [ poplit1 + 1 ] - strstart [ poplit1 ] ) ; 
	sp2length = ( strstart [ poplit2 + 1 ] - strstart [ poplit2 ] ) ; 
	{
	  if ( ( poolptr + splength + sp2length > poolsize ) ) 
	  pooloverflow () ; 
	} 
	spptr = strstart [ poplit1 + 1 ] ; 
	spend = strstart [ poplit1 ] ; 
	spxptr1 = spptr + sp2length ; 
	while ( ( spptr > spend ) ) {
	    
	  spptr = spptr - 1 ; 
	  spxptr1 = spxptr1 - 1 ; 
	  strpool [ spxptr1 ] = strpool [ spptr ] ; 
	} 
	spptr = strstart [ poplit2 ] ; 
	spend = strstart [ poplit2 + 1 ] ; 
	while ( ( spptr < spend ) ) {
	    
	  {
	    strpool [ poolptr ] = strpool [ spptr ] ; 
	    poolptr = poolptr + 1 ; 
	  } 
	  spptr = spptr + 1 ; 
	} 
	poolptr = poolptr + splength ; 
	pushlitstk ( makestring () , 1 ) ; 
      } 
      else {
	  
	if ( ( ( strstart [ poplit1 + 1 ] - strstart [ poplit1 ] ) == 0 ) ) 
	litstkptr = litstkptr + 1 ; 
	else if ( ( ( strstart [ poplit2 + 1 ] - strstart [ poplit2 ] ) == 0 ) 
	) 
	pushlitstk ( poplit1 , 1 ) ; 
	else {
	    
	  {
	    if ( ( poolptr + ( strstart [ poplit1 + 1 ] - strstart [ poplit1 ] 
	    ) + ( strstart [ poplit2 + 1 ] - strstart [ poplit2 ] ) > poolsize 
	    ) ) 
	    pooloverflow () ; 
	  } 
	  spptr = strstart [ poplit2 ] ; 
	  spend = strstart [ poplit2 + 1 ] ; 
	  while ( ( spptr < spend ) ) {
	      
	    {
	      strpool [ poolptr ] = strpool [ spptr ] ; 
	      poolptr = poolptr + 1 ; 
	    } 
	    spptr = spptr + 1 ; 
	  } 
	  spptr = strstart [ poplit1 ] ; 
	  spend = strstart [ poplit1 + 1 ] ; 
	  while ( ( spptr < spend ) ) {
	      
	    {
	      strpool [ poolptr ] = strpool [ spptr ] ; 
	      poolptr = poolptr + 1 ; 
	    } 
	    spptr = spptr + 1 ; 
	  } 
	  pushlitstk ( makestring () , 1 ) ; 
	} 
      } 
    } 
  } 
} 
void 
xgets ( ) 
{poplitstk ( poplit1 , poptyp1 ) ; 
  poplitstk ( poplit2 , poptyp2 ) ; 
  if ( ( poptyp1 != 2 ) ) 
  printwrongstklit ( poplit1 , poptyp1 , 2 ) ; 
  else if ( ( ( ! messwithentries ) && ( ( fntype [ poplit1 ] == 6 ) || ( 
  fntype [ poplit1 ] == 5 ) ) ) ) 
  bstcantmesswithentriesprint () ; 
  else switch ( ( fntype [ poplit1 ] ) ) 
  {case 5 : 
    if ( ( poptyp2 != 0 ) ) 
    printwrongstklit ( poplit2 , poptyp2 , 0 ) ; 
    else entryints [ citeptr * numentints + ilkinfo [ poplit1 ] ] = poplit2 ; 
    break ; 
  case 6 : 
    {
      if ( ( poptyp2 != 1 ) ) 
      printwrongstklit ( poplit2 , poptyp2 , 1 ) ; 
      else {
	  
	strentptr = citeptr * numentstrs + ilkinfo [ poplit1 ] ; 
	entchrptr = 0 ; 
	spptr = strstart [ poplit2 ] ; 
	spxptr1 = strstart [ poplit2 + 1 ] ; 
	if ( ( spxptr1 - spptr > entstrsize ) ) 
	{
	  {
	    bst1printstringsizeexceeded () ; 
	    {
	      fprintf( logfile , "%ld%s",  (long)entstrsize , ", the entry" ) ; 
	      fprintf( standardoutput , "%ld%s",  (long)entstrsize , ", the entry" ) ; 
	    } 
	    bst2printstringsizeexceeded () ; 
	  } 
	  spxptr1 = spptr + entstrsize ; 
	} 
	while ( ( spptr < spxptr1 ) ) {
	    
	  entrystrs [ strentptr ] [ entchrptr ] = strpool [ spptr ] ; 
	  entchrptr = entchrptr + 1 ; 
	  spptr = spptr + 1 ; 
	} 
	entrystrs [ strentptr ] [ entchrptr ] = 127 ; 
      } 
    } 
    break ; 
  case 7 : 
    if ( ( poptyp2 != 0 ) ) 
    printwrongstklit ( poplit2 , poptyp2 , 0 ) ; 
    else ilkinfo [ poplit1 ] = poplit2 ; 
    break ; 
  case 8 : 
    {
      if ( ( poptyp2 != 1 ) ) 
      printwrongstklit ( poplit2 , poptyp2 , 1 ) ; 
      else {
	  
	strglbptr = ilkinfo [ poplit1 ] ; 
	if ( ( poplit2 < cmdstrptr ) ) 
	glbstrptr [ strglbptr ] = poplit2 ; 
	else {
	    
	  glbstrptr [ strglbptr ] = 0 ; 
	  globchrptr = 0 ; 
	  spptr = strstart [ poplit2 ] ; 
	  spend = strstart [ poplit2 + 1 ] ; 
	  if ( ( spend - spptr > globstrsize ) ) 
	  {
	    {
	      bst1printstringsizeexceeded () ; 
	      {
		fprintf( logfile , "%ld%s",  (long)globstrsize , ", the global" ) ; 
		fprintf( standardoutput , "%ld%s",  (long)globstrsize , ", the global" ) ; 
	      } 
	      bst2printstringsizeexceeded () ; 
	    } 
	    spend = spptr + globstrsize ; 
	  } 
	  while ( ( spptr < spend ) ) {
	      
	    globalstrs [ strglbptr ] [ globchrptr ] = strpool [ spptr ] ; 
	    globchrptr = globchrptr + 1 ; 
	    spptr = spptr + 1 ; 
	  } 
	  glbstrend [ strglbptr ] = globchrptr ; 
	} 
      } 
    } 
    break ; 
    default: 
    {
      {
	Fputs( logfile ,  "You can't assign to type " ) ; 
	Fputs( standardoutput ,  "You can't assign to type " ) ; 
      } 
      printfnclass ( poplit1 ) ; 
      {
	{
	  Fputs( logfile ,  ", a nonvariable function class" ) ; 
	  Fputs( standardoutput ,  ", a nonvariable function class" ) ; 
	} 
	bstexwarnprint () ; 
      } 
    } 
    break ; 
  } 
} 
void 
xaddperiod ( ) 
{/* 15 */ poplitstk ( poplit1 , poptyp1 ) ; 
  if ( ( poptyp1 != 1 ) ) 
  {
    printwrongstklit ( poplit1 , poptyp1 , 1 ) ; 
    pushlitstk ( snull , 1 ) ; 
  } 
  else if ( ( ( strstart [ poplit1 + 1 ] - strstart [ poplit1 ] ) == 0 ) ) 
  pushlitstk ( snull , 1 ) ; 
  else {
      
    spptr = strstart [ poplit1 + 1 ] ; 
    spend = strstart [ poplit1 ] ; 
    while ( ( spptr > spend ) ) {
	
      spptr = spptr - 1 ; 
      if ( ( strpool [ spptr ] != 125 ) ) 
      goto lab15 ; 
    } 
    lab15: switch ( ( strpool [ spptr ] ) ) 
    {case 46 : 
    case 63 : 
    case 33 : 
      {
	if ( ( litstack [ litstkptr ] >= cmdstrptr ) ) 
	{
	  strptr = strptr + 1 ; 
	  poolptr = strstart [ strptr ] ; 
	} 
	litstkptr = litstkptr + 1 ; 
      } 
      break ; 
      default: 
      {
	if ( ( poplit1 < cmdstrptr ) ) 
	{
	  {
	    if ( ( poolptr + ( strstart [ poplit1 + 1 ] - strstart [ poplit1 ] 
	    ) + 1 > poolsize ) ) 
	    pooloverflow () ; 
	  } 
	  spptr = strstart [ poplit1 ] ; 
	  spend = strstart [ poplit1 + 1 ] ; 
	  while ( ( spptr < spend ) ) {
	      
	    {
	      strpool [ poolptr ] = strpool [ spptr ] ; 
	      poolptr = poolptr + 1 ; 
	    } 
	    spptr = spptr + 1 ; 
	  } 
	} 
	else {
	    
	  poolptr = strstart [ poplit1 + 1 ] ; 
	  {
	    if ( ( poolptr + 1 > poolsize ) ) 
	    pooloverflow () ; 
	  } 
	} 
	{
	  strpool [ poolptr ] = 46 ; 
	  poolptr = poolptr + 1 ; 
	} 
	pushlitstk ( makestring () , 1 ) ; 
      } 
      break ; 
    } 
  } 
} 
void 
xchangecase ( ) 
{/* 21 */ poplitstk ( poplit1 , poptyp1 ) ; 
  poplitstk ( poplit2 , poptyp2 ) ; 
  if ( ( poptyp1 != 1 ) ) 
  {
    printwrongstklit ( poplit1 , poptyp1 , 1 ) ; 
    pushlitstk ( snull , 1 ) ; 
  } 
  else if ( ( poptyp2 != 1 ) ) 
  {
    printwrongstklit ( poplit2 , poptyp2 , 1 ) ; 
    pushlitstk ( snull , 1 ) ; 
  } 
  else {
      
    {
      switch ( ( strpool [ strstart [ poplit1 ] ] ) ) 
      {case 116 : 
      case 84 : 
	conversiontype = 0 ; 
	break ; 
      case 108 : 
      case 76 : 
	conversiontype = 1 ; 
	break ; 
      case 117 : 
      case 85 : 
	conversiontype = 2 ; 
	break ; 
	default: 
	conversiontype = 3 ; 
	break ; 
      } 
      if ( ( ( ( strstart [ poplit1 + 1 ] - strstart [ poplit1 ] ) != 1 ) || ( 
      conversiontype == 3 ) ) ) 
      {
	conversiontype = 3 ; 
	printapoolstr ( poplit1 ) ; 
	{
	  {
	    Fputs( logfile ,  " is an illegal case-conversion string" ) ; 
	    Fputs( standardoutput ,  " is an illegal case-conversion string" ) 
	    ; 
	  } 
	  bstexwarnprint () ; 
	} 
      } 
    } 
    exbuflength = 0 ; 
    addbufpool ( poplit2 ) ; 
    {
      bracelevel = 0 ; 
      exbufptr = 0 ; 
      while ( ( exbufptr < exbuflength ) ) {
	  
	if ( ( exbuf [ exbufptr ] == 123 ) ) 
	{
	  bracelevel = bracelevel + 1 ; 
	  if ( ( bracelevel != 1 ) ) 
	  goto lab21 ; 
	  if ( ( exbufptr + 4 > exbuflength ) ) 
	  goto lab21 ; 
	  else if ( ( exbuf [ exbufptr + 1 ] != 92 ) ) 
	  goto lab21 ; 
	  if ( ( conversiontype == 0 ) ) 
	  if ( ( exbufptr == 0 ) ) 
	  goto lab21 ; 
	  else if ( ( ( prevcolon ) && ( lexclass [ exbuf [ exbufptr - 1 ] ] 
	  == 1 ) ) ) 
	  goto lab21 ; 
	  {
	    exbufptr = exbufptr + 1 ; 
	    while ( ( ( exbufptr < exbuflength ) && ( bracelevel > 0 ) ) ) {
		
	      exbufptr = exbufptr + 1 ; 
	      exbufxptr = exbufptr ; 
	      while ( ( ( exbufptr < exbuflength ) && ( lexclass [ exbuf [ 
	      exbufptr ] ] == 2 ) ) ) exbufptr = exbufptr + 1 ; 
	      controlseqloc = strlookup ( exbuf , exbufxptr , exbufptr - 
	      exbufxptr , 14 , false ) ; 
	      if ( ( hashfound ) ) 
	      {
		switch ( ( conversiontype ) ) 
		{case 0 : 
		case 1 : 
		  switch ( ( ilkinfo [ controlseqloc ] ) ) 
		  {case 11 : 
		  case 9 : 
		  case 3 : 
		  case 5 : 
		  case 7 : 
		    lowercase ( exbuf , exbufxptr , exbufptr - exbufxptr ) ; 
		    break ; 
		    default: 
		    ; 
		    break ; 
		  } 
		  break ; 
		case 2 : 
		  switch ( ( ilkinfo [ controlseqloc ] ) ) 
		  {case 10 : 
		  case 8 : 
		  case 2 : 
		  case 4 : 
		  case 6 : 
		    uppercase ( exbuf , exbufxptr , exbufptr - exbufxptr ) ; 
		    break ; 
		  case 0 : 
		  case 1 : 
		  case 12 : 
		    {
		      uppercase ( exbuf , exbufxptr , exbufptr - exbufxptr ) ; 
		      while ( ( exbufxptr < exbufptr ) ) {
			  
			exbuf [ exbufxptr - 1 ] = exbuf [ exbufxptr ] ; 
			exbufxptr = exbufxptr + 1 ; 
		      } 
		      exbufxptr = exbufxptr - 1 ; 
		      while ( ( ( exbufptr < exbuflength ) && ( lexclass [ 
		      exbuf [ exbufptr ] ] == 1 ) ) ) exbufptr = exbufptr + 1 
		      ; 
		      tmpptr = exbufptr ; 
		      while ( ( tmpptr < exbuflength ) ) {
			  
			exbuf [ tmpptr - ( exbufptr - exbufxptr ) ] = exbuf [ 
			tmpptr ] ; 
			tmpptr = tmpptr + 1 ; 
		      } 
		      exbuflength = tmpptr - ( exbufptr - exbufxptr ) ; 
		      exbufptr = exbufxptr ; 
		    } 
		    break ; 
		    default: 
		    ; 
		    break ; 
		  } 
		  break ; 
		case 3 : 
		  ; 
		  break ; 
		  default: 
		  caseconversionconfusion () ; 
		  break ; 
		} 
	      } 
	      exbufxptr = exbufptr ; 
	      while ( ( ( exbufptr < exbuflength ) && ( bracelevel > 0 ) && ( 
	      exbuf [ exbufptr ] != 92 ) ) ) {
		  
		if ( ( exbuf [ exbufptr ] == 125 ) ) 
		bracelevel = bracelevel - 1 ; 
		else if ( ( exbuf [ exbufptr ] == 123 ) ) 
		bracelevel = bracelevel + 1 ; 
		exbufptr = exbufptr + 1 ; 
	      } 
	      {
		switch ( ( conversiontype ) ) 
		{case 0 : 
		case 1 : 
		  lowercase ( exbuf , exbufxptr , exbufptr - exbufxptr ) ; 
		  break ; 
		case 2 : 
		  uppercase ( exbuf , exbufxptr , exbufptr - exbufxptr ) ; 
		  break ; 
		case 3 : 
		  ; 
		  break ; 
		  default: 
		  caseconversionconfusion () ; 
		  break ; 
		} 
	      } 
	    } 
	    exbufptr = exbufptr - 1 ; 
	  } 
	  lab21: prevcolon = false ; 
	} 
	else if ( ( exbuf [ exbufptr ] == 125 ) ) 
	{
	  decrbracelevel ( poplit2 ) ; 
	  prevcolon = false ; 
	} 
	else if ( ( bracelevel == 0 ) ) 
	{
	  switch ( ( conversiontype ) ) 
	  {case 0 : 
	    {
	      if ( ( exbufptr == 0 ) ) 
	      ; 
	      else if ( ( ( prevcolon ) && ( lexclass [ exbuf [ exbufptr - 1 ] 
	      ] == 1 ) ) ) 
	      ; 
	      else lowercase ( exbuf , exbufptr , 1 ) ; 
	      if ( ( exbuf [ exbufptr ] == 58 ) ) 
	      prevcolon = true ; 
	      else if ( ( lexclass [ exbuf [ exbufptr ] ] != 1 ) ) 
	      prevcolon = false ; 
	    } 
	    break ; 
	  case 1 : 
	    lowercase ( exbuf , exbufptr , 1 ) ; 
	    break ; 
	  case 2 : 
	    uppercase ( exbuf , exbufptr , 1 ) ; 
	    break ; 
	  case 3 : 
	    ; 
	    break ; 
	    default: 
	    caseconversionconfusion () ; 
	    break ; 
	  } 
	} 
	exbufptr = exbufptr + 1 ; 
      } 
      checkbracelevel ( poplit2 ) ; 
    } 
    addpoolbufandpush () ; 
  } 
} 
void 
xchrtoint ( ) 
{poplitstk ( poplit1 , poptyp1 ) ; 
  if ( ( poptyp1 != 1 ) ) 
  {
    printwrongstklit ( poplit1 , poptyp1 , 1 ) ; 
    pushlitstk ( 0 , 0 ) ; 
  } 
  else if ( ( ( strstart [ poplit1 + 1 ] - strstart [ poplit1 ] ) != 1 ) ) 
  {
    {
      putc ( '"' ,  logfile );
      putc ( '"' ,  standardoutput );
    } 
    printapoolstr ( poplit1 ) ; 
    {
      {
	Fputs( logfile ,  "\" isn't a single character" ) ; 
	Fputs( standardoutput ,  "\" isn't a single character" ) ; 
      } 
      bstexwarnprint () ; 
    } 
    pushlitstk ( 0 , 0 ) ; 
  } 
  else pushlitstk ( strpool [ strstart [ poplit1 ] ] , 0 ) ; 
} 
void 
xcite ( ) 
{if ( ( ! messwithentries ) ) 
  bstcantmesswithentriesprint () ; 
  else pushlitstk ( citelist [ citeptr ] , 1 ) ; 
} 
void 
xduplicate ( ) 
{poplitstk ( poplit1 , poptyp1 ) ; 
  if ( ( poptyp1 != 1 ) ) 
  {
    pushlitstk ( poplit1 , poptyp1 ) ; 
    pushlitstk ( poplit1 , poptyp1 ) ; 
  } 
  else {
      
    {
      if ( ( litstack [ litstkptr ] >= cmdstrptr ) ) 
      {
	strptr = strptr + 1 ; 
	poolptr = strstart [ strptr ] ; 
      } 
      litstkptr = litstkptr + 1 ; 
    } 
    if ( ( poplit1 < cmdstrptr ) ) 
    pushlitstk ( poplit1 , poptyp1 ) ; 
    else {
	
      {
	if ( ( poolptr + ( strstart [ poplit1 + 1 ] - strstart [ poplit1 ] ) > 
	poolsize ) ) 
	pooloverflow () ; 
      } 
      spptr = strstart [ poplit1 ] ; 
      spend = strstart [ poplit1 + 1 ] ; 
      while ( ( spptr < spend ) ) {
	  
	{
	  strpool [ poolptr ] = strpool [ spptr ] ; 
	  poolptr = poolptr + 1 ; 
	} 
	spptr = spptr + 1 ; 
      } 
      pushlitstk ( makestring () , 1 ) ; 
    } 
  } 
} 
void 
xempty ( ) 
{/* 10 */ poplitstk ( poplit1 , poptyp1 ) ; 
  switch ( ( poptyp1 ) ) 
  {case 1 : 
    {
      spptr = strstart [ poplit1 ] ; 
      spend = strstart [ poplit1 + 1 ] ; 
      while ( ( spptr < spend ) ) {
	  
	if ( ( lexclass [ strpool [ spptr ] ] != 1 ) ) 
	{
	  pushlitstk ( 0 , 0 ) ; 
	  goto lab10 ; 
	} 
	spptr = spptr + 1 ; 
      } 
      pushlitstk ( 1 , 0 ) ; 
    } 
    break ; 
  case 3 : 
    pushlitstk ( 1 , 0 ) ; 
    break ; 
  case 4 : 
    pushlitstk ( 0 , 0 ) ; 
    break ; 
    default: 
    {
      printstklit ( poplit1 , poptyp1 ) ; 
      {
	{
	  Fputs( logfile ,  ", not a string or missing field," ) ; 
	  Fputs( standardoutput ,  ", not a string or missing field," ) ; 
	} 
	bstexwarnprint () ; 
      } 
      pushlitstk ( 0 , 0 ) ; 
    } 
    break ; 
  } 
  lab10: ; 
} 
void 
xformatname ( ) 
{/* 16 17 52 */ poplitstk ( poplit1 , poptyp1 ) ; 
  poplitstk ( poplit2 , poptyp2 ) ; 
  poplitstk ( poplit3 , poptyp3 ) ; 
  if ( ( poptyp1 != 1 ) ) 
  {
    printwrongstklit ( poplit1 , poptyp1 , 1 ) ; 
    pushlitstk ( snull , 1 ) ; 
  } 
  else if ( ( poptyp2 != 0 ) ) 
  {
    printwrongstklit ( poplit2 , poptyp2 , 0 ) ; 
    pushlitstk ( snull , 1 ) ; 
  } 
  else if ( ( poptyp3 != 1 ) ) 
  {
    printwrongstklit ( poplit3 , poptyp3 , 1 ) ; 
    pushlitstk ( snull , 1 ) ; 
  } 
  else {
      
    exbuflength = 0 ; 
    addbufpool ( poplit3 ) ; 
    {
      exbufptr = 0 ; 
      numnames = 0 ; 
      while ( ( ( numnames < poplit2 ) && ( exbufptr < exbuflength ) ) ) {
	  
	numnames = numnames + 1 ; 
	exbufxptr = exbufptr ; 
	namescanforand ( poplit3 ) ; 
      } 
      if ( ( exbufptr < exbuflength ) ) 
      exbufptr = exbufptr - 4 ; 
      if ( ( numnames < poplit2 ) ) 
      {
	if ( ( poplit2 == 1 ) ) 
	{
	  Fputs( logfile ,  "There is no name in \"" ) ; 
	  Fputs( standardoutput ,  "There is no name in \"" ) ; 
	} 
	else {
	    
	  fprintf( logfile , "%s%ld%s",  "There aren't " , (long)poplit2 , " names in \"" ) ; 
	  fprintf( standardoutput , "%s%ld%s",  "There aren't " , (long)poplit2 , " names in \""           ) ; 
	} 
	printapoolstr ( poplit3 ) ; 
	{
	  {
	    putc ( '"' ,  logfile );
	    putc ( '"' ,  standardoutput );
	  } 
	  bstexwarnprint () ; 
	} 
      } 
    } 
    {
      {
	while ( ( exbufptr > exbufxptr ) ) switch ( ( lexclass [ exbuf [ 
	exbufptr - 1 ] ] ) ) 
	{case 1 : 
	case 4 : 
	  exbufptr = exbufptr - 1 ; 
	  break ; 
	  default: 
	  if ( ( exbuf [ exbufptr - 1 ] == 44 ) ) 
	  {
	    {
	      fprintf( logfile , "%s%ld%s",  "Name " , (long)poplit2 , " in \"" ) ; 
	      fprintf( standardoutput , "%s%ld%s",  "Name " , (long)poplit2 , " in \"" ) ; 
	    } 
	    printapoolstr ( poplit3 ) ; 
	    {
	      Fputs( logfile ,  "\" has a comma at the end" ) ; 
	      Fputs( standardoutput ,  "\" has a comma at the end" ) ; 
	    } 
	    bstexwarnprint () ; 
	    exbufptr = exbufptr - 1 ; 
	  } 
	  else goto lab16 ; 
	  break ; 
	} 
	lab16: ; 
      } 
      namebfptr = 0 ; 
      numcommas = 0 ; 
      numtokens = 0 ; 
      tokenstarting = true ; 
      while ( ( exbufxptr < exbufptr ) ) switch ( ( exbuf [ exbufxptr ] ) ) 
      {case 44 : 
	{
	  if ( ( numcommas == 2 ) ) 
	  {
	    {
	      fprintf( logfile , "%s%ld%s",  "Too many commas in name " , (long)poplit2 ,               " of \"" ) ; 
	      fprintf( standardoutput , "%s%ld%s",  "Too many commas in name " , (long)poplit2 ,               " of \"" ) ; 
	    } 
	    printapoolstr ( poplit3 ) ; 
	    {
	      putc ( '"' ,  logfile );
	      putc ( '"' ,  standardoutput );
	    } 
	    bstexwarnprint () ; 
	  } 
	  else {
	      
	    numcommas = numcommas + 1 ; 
	    if ( ( numcommas == 1 ) ) 
	    comma1 = numtokens ; 
	    else comma2 = numtokens ; 
	    namesepchar [ numtokens ] = 44 ; 
	  } 
	  exbufxptr = exbufxptr + 1 ; 
	  tokenstarting = true ; 
	} 
	break ; 
      case 123 : 
	{
	  bracelevel = bracelevel + 1 ; 
	  if ( ( tokenstarting ) ) 
	  {
	    nametok [ numtokens ] = namebfptr ; 
	    numtokens = numtokens + 1 ; 
	  } 
	  svbuffer [ namebfptr ] = exbuf [ exbufxptr ] ; 
	  namebfptr = namebfptr + 1 ; 
	  exbufxptr = exbufxptr + 1 ; 
	  while ( ( ( bracelevel > 0 ) && ( exbufxptr < exbufptr ) ) ) {
	      
	    if ( ( exbuf [ exbufxptr ] == 125 ) ) 
	    bracelevel = bracelevel - 1 ; 
	    else if ( ( exbuf [ exbufxptr ] == 123 ) ) 
	    bracelevel = bracelevel + 1 ; 
	    svbuffer [ namebfptr ] = exbuf [ exbufxptr ] ; 
	    namebfptr = namebfptr + 1 ; 
	    exbufxptr = exbufxptr + 1 ; 
	  } 
	  tokenstarting = false ; 
	} 
	break ; 
      case 125 : 
	{
	  if ( ( tokenstarting ) ) 
	  {
	    nametok [ numtokens ] = namebfptr ; 
	    numtokens = numtokens + 1 ; 
	  } 
	  {
	    fprintf( logfile , "%s%ld%s",  "Name " , (long)poplit2 , " of \"" ) ; 
	    fprintf( standardoutput , "%s%ld%s",  "Name " , (long)poplit2 , " of \"" ) ; 
	  } 
	  printapoolstr ( poplit3 ) ; 
	  {
	    {
	      Fputs( logfile ,  "\" isn't brace balanced" ) ; 
	      Fputs( standardoutput ,  "\" isn't brace balanced" ) ; 
	    } 
	    bstexwarnprint () ; 
	  } 
	  exbufxptr = exbufxptr + 1 ; 
	  tokenstarting = false ; 
	} 
	break ; 
	default: 
	switch ( ( lexclass [ exbuf [ exbufxptr ] ] ) ) 
	{case 1 : 
	  {
	    if ( ( ! tokenstarting ) ) 
	    namesepchar [ numtokens ] = 32 ; 
	    exbufxptr = exbufxptr + 1 ; 
	    tokenstarting = true ; 
	  } 
	  break ; 
	case 4 : 
	  {
	    if ( ( ! tokenstarting ) ) 
	    namesepchar [ numtokens ] = exbuf [ exbufxptr ] ; 
	    exbufxptr = exbufxptr + 1 ; 
	    tokenstarting = true ; 
	  } 
	  break ; 
	  default: 
	  {
	    if ( ( tokenstarting ) ) 
	    {
	      nametok [ numtokens ] = namebfptr ; 
	      numtokens = numtokens + 1 ; 
	    } 
	    svbuffer [ namebfptr ] = exbuf [ exbufxptr ] ; 
	    namebfptr = namebfptr + 1 ; 
	    exbufxptr = exbufxptr + 1 ; 
	    tokenstarting = false ; 
	  } 
	  break ; 
	} 
	break ; 
      } 
      nametok [ numtokens ] = namebfptr ; 
    } 
    {
      if ( ( numcommas == 0 ) ) 
      {
	firststart = 0 ; 
	lastend = numtokens ; 
	jrend = lastend ; 
	{
	  vonstart = 0 ; 
	  while ( ( vonstart < lastend - 1 ) ) {
	      
	    namebfptr = nametok [ vonstart ] ; 
	    namebfxptr = nametok [ vonstart + 1 ] ; 
	    if ( ( vontokenfound () ) ) 
	    {
	      vonnameendsandlastnamestartsstuff () ; 
	      goto lab52 ; 
	    } 
	    vonstart = vonstart + 1 ; 
	  } 
	  while ( ( vonstart > 0 ) ) {
	      
	    if ( ( ( lexclass [ namesepchar [ vonstart ] ] != 4 ) || ( 
	    namesepchar [ vonstart ] == 126 ) ) ) 
	    goto lab17 ; 
	    vonstart = vonstart - 1 ; 
	  } 
	  lab17: vonend = vonstart ; 
	  lab52: firstend = vonstart ; 
	} 
      } 
      else if ( ( numcommas == 1 ) ) 
      {
	vonstart = 0 ; 
	lastend = comma1 ; 
	jrend = lastend ; 
	firststart = jrend ; 
	firstend = numtokens ; 
	vonnameendsandlastnamestartsstuff () ; 
      } 
      else if ( ( numcommas == 2 ) ) 
      {
	vonstart = 0 ; 
	lastend = comma1 ; 
	jrend = comma2 ; 
	firststart = jrend ; 
	firstend = numtokens ; 
	vonnameendsandlastnamestartsstuff () ; 
      } 
      else {
	  
	{
	  Fputs( logfile ,  "Illegal number of comma,s" ) ; 
	  Fputs( standardoutput ,  "Illegal number of comma,s" ) ; 
	} 
	printconfusion () ; 
	longjmp(jmp9998,1) ; 
      } 
    } 
    exbuflength = 0 ; 
    addbufpool ( poplit1 ) ; 
    figureouttheformattedname () ; 
    addpoolbufandpush () ; 
  } 
} 
void 
xinttochr ( ) 
{poplitstk ( poplit1 , poptyp1 ) ; 
  if ( ( poptyp1 != 0 ) ) 
  {
    printwrongstklit ( poplit1 , poptyp1 , 0 ) ; 
    pushlitstk ( snull , 1 ) ; 
  } 
  else if ( ( ( poplit1 < 0 ) || ( poplit1 > 127 ) ) ) 
  {
    {
      {
	fprintf( logfile , "%ld%s",  (long)poplit1 , " isn't valid ASCII" ) ; 
	fprintf( standardoutput , "%ld%s",  (long)poplit1 , " isn't valid ASCII" ) ; 
      } 
      bstexwarnprint () ; 
    } 
    pushlitstk ( snull , 1 ) ; 
  } 
  else {
      
    {
      if ( ( poolptr + 1 > poolsize ) ) 
      pooloverflow () ; 
    } 
    {
      strpool [ poolptr ] = poplit1 ; 
      poolptr = poolptr + 1 ; 
    } 
    pushlitstk ( makestring () , 1 ) ; 
  } 
} 
void 
xinttostr ( ) 
{poplitstk ( poplit1 , poptyp1 ) ; 
  if ( ( poptyp1 != 0 ) ) 
  {
    printwrongstklit ( poplit1 , poptyp1 , 0 ) ; 
    pushlitstk ( snull , 1 ) ; 
  } 
  else {
      
    inttoASCII ( poplit1 , exbuf , 0 , exbuflength ) ; 
    addpoolbufandpush () ; 
  } 
} 
void 
xmissing ( ) 
{poplitstk ( poplit1 , poptyp1 ) ; 
  if ( ( ! messwithentries ) ) 
  bstcantmesswithentriesprint () ; 
  else if ( ( ( poptyp1 != 1 ) && ( poptyp1 != 3 ) ) ) 
  {
    if ( ( poptyp1 != 4 ) ) 
    {
      printstklit ( poplit1 , poptyp1 ) ; 
      {
	{
	  Fputs( logfile ,  ", not a string or missing field," ) ; 
	  Fputs( standardoutput ,  ", not a string or missing field," ) ; 
	} 
	bstexwarnprint () ; 
      } 
    } 
    pushlitstk ( 0 , 0 ) ; 
  } 
  else if ( ( poptyp1 == 3 ) ) 
  pushlitstk ( 1 , 0 ) ; 
  else pushlitstk ( 0 , 0 ) ; 
} 
void 
xnumnames ( ) 
{poplitstk ( poplit1 , poptyp1 ) ; 
  if ( ( poptyp1 != 1 ) ) 
  {
    printwrongstklit ( poplit1 , poptyp1 , 1 ) ; 
    pushlitstk ( 0 , 0 ) ; 
  } 
  else {
      
    exbuflength = 0 ; 
    addbufpool ( poplit1 ) ; 
    {
      exbufptr = 0 ; 
      numnames = 0 ; 
      while ( ( exbufptr < exbuflength ) ) {
	  
	namescanforand ( poplit1 ) ; 
	numnames = numnames + 1 ;