/*~-1*/
/*~XSF_LANGUAGE: C/C++*/
/*~T*/
#define TRUE 1
#define FALSE 0
#define SIZE 18

/*~A:1*/
/*~+:Definitions*/
/*~T*/
static int mstatic1, mstatic2;

volatile float vfloat = 1.0;
volatile double vdouble = 1.0;

typedef int tdef1;

tdef1 vtdef1;

typedef short tdef2[10];

tdef2 vtdef2;

struct
{
        int x, y;
}
vstruct1;

char vchar;
short vshort;
int vint;
long vlong;

char * vpchar;
short * vpshort;
int * vpint;
long * vplong;

unsigned char vuchar;
unsigned short vushort;
unsigned int vuint;
unsigned long vulong;

unsigned char * vpuchar;
unsigned short * vpushort;
unsigned int * vpuint;
unsigned long * vpulong;

unsigned char * * vppuchar;
unsigned short * * vppushort;
unsigned int * * vppuint;
unsigned long * * vppulong;


int varray[10];

typedef int tarray[10];

tarray vtarray;

char vdarray[5];

char vdiarray[] = "abcd";

char vdblarray[5][6];

struct struct4 {
                struct struct5 * pstruct5;
                struct struct5 * * ppstruct5;
                struct struct5 * pastruct5[2];
                } ;

struct struct5 {
                struct struct4 * pstruct4;
                struct struct4 * * ppstruct4;
                struct struct4 * pastruct4[2];
                } ;


typedef struct struct1 {
        char * word;
        int count;
        struct struct1 * left;
        struct struct1 * right;
        int field1:2;
        unsigned field2:3;
        } strtype1 ;

strtype1 ast;

typedef struct struct1 structarray[10];

structarray stra1;

struct struct4 stra2[5][5];

struct union1 {
        char * word;
        int count;
        struct struct1 * left;
        struct struct1 * right;
        union {
                int ival;
                float fval;
                char * pval;
                } uval;
        int field1:2;
        unsigned field2:3;
} aun;

struct struct2 {
        char * word;
        int count;
} str2;

struct struct6 {
        int x;
        struct struct7 {
                char * word;
                int count;
                } vstruct7;
        int y;
} str6;


struct abc
{
        int x;
        int y;
};

struct abc def;

union tunion
{
        int z1;
        short z2;
        char z3;
        struct abc z4;
} vunion;

enum enumtyp { enum1, enum2, enum4=4, enum7=7, enum8, enumx= -1 } enumvar;

int ( *funcptr ) ();

void func1b( int * );

/*~E:A1*/
/*~A:2*/
/*~+:func0*/
/*~F:3*/
func0()                                 /* empty function */

/*~-1*/
{
   /*~T*/

/*~-1*/
}
/*~E:F3*/
/*~E:A2*/
/*~A:4*/
/*~+:static void func1(*/
/*~F:5*/
static void func1( intptr )             /* static function for inline  */
int * intptr;

/*~-1*/
{
   /*~T*/
   (*intptr)++;

/*~-1*/
}
/*~E:F5*/
/*~E:A4*/
/*~A:6*/
/*~+:void func1g(*/
/*~F:7*/
void func1g( intptr )                   /* global function for referencing  */
int * intptr;

/*~-1*/
{
   /*~T*/
   func1( intptr );
   (*intptr)++;

/*~-1*/
}
/*~E:F7*/
/*~E:A6*/
/*~A:8*/
/*~+:void func2*/
/*~F:9*/
void func2()

/*~-1*/
{
   /*~T*/
   int autovar;
   register int regvar;
   static int fstatic = 44;        /* initialized static variable */
   static int fstatic2;            /* not initialized static variable */

   autovar = regvar = fstatic;
   autovar++;

   func1g( &autovar );     /* to force autovar as stack-scope */

   func1g( &fstatic );     /* to force fstatic as static-scope */

   /*~L:10*/
   for ( regvar = 0; regvar < 5 ; regvar++ )

   /*~-1*/
   {
      /*~T*/
      mstatic1 += regvar*autovar;

   /*~-1*/
   }
   /*~E:L10*/
   /*~T*/
   fstatic += mstatic1;

   fstatic2 = 2*fstatic;

   func1( &fstatic2 );     /* reference to inline function */

/*~-1*/
}
/*~E:F9*/
/*~E:A8*/
/*~A:11*/
/*~+:static int func3*/
/*~F:12*/
static int func3()                      /* simple function */

/*~-1*/
{
   /*~T*/
   return 5;

/*~-1*/
}
/*~E:F12*/
/*~E:A11*/
/*~A:13*/
/*~+:struct struct1 func4(*/
/*~F:14*/
struct struct1 func4( str )             /* function returning struct */
struct struct1 str;

/*~-1*/
{
   /*~T*/
   str.count++;

   return str;

/*~-1*/
}
/*~E:F14*/
/*~E:A13*/
/*~A:15*/
/*~+:int func5(*/
/*~F:16*/
int func5( a, b, c )                    /* multiple arguments */
int a;
char b;
long c;

/*~-1*/
{
   /*~T*/
   return a+b*c;

/*~-1*/
}
/*~E:F16*/
/*~E:A15*/
/*~A:17*/
/*~+:float func6(*/
/*~F:18*/
float func6( a, b )
float a;
float b;

/*~-1*/
{
   /*~T*/
   vfloat = 1.0;
   vfloat = -1.0;
   vfloat = 10.0;
   vfloat = 1.6;

   return a*b;

/*~-1*/
}
/*~E:F18*/
/*~E:A17*/
/*~A:19*/
/*~+:double func7(*/
/*~F:20*/
double func7( a, b )
double a;
double b;

/*~-1*/
{
   /*~T*/
   vdouble = 1.0;
   vdouble = -1.0;
   vdouble = 10.0;
   vdouble = 1.6;

   return a*b;

/*~-1*/
}
/*~E:F20*/
/*~E:A19*/
/*~T*/
struct bfield
{
        int a:1;
        int b:2;
        int c:3;
        int d:7;
        int e:8;
        int f:15;
        int g:1;
        int h:15;
        int i:1;
        int j:16;
        unsigned k:1;
        unsigned l:2;
        unsigned m:16;
        long n;
        char o;
        long p:27;
        char q:6;
        char r:1;
        enum enumtyp enum1:4;
        enum enumtyp enum2:7;
};

struct bfield vbfield;

/*~A:21*/
/*~+:void func8*/
/*~F:22*/
void func8()

/*~-1*/
{
   /*~T*/
   vbfield.a = 1;
   vbfield.b = 1;
   vbfield.c = 1;
   vbfield.d = 1;
   vbfield.e = 1;
   vbfield.f = 1;
   vbfield.g = 1;
   vbfield.h = 1;
   vbfield.i = 1;
   vbfield.j = 1;
   vbfield.k = 1;
   vbfield.l = 1;
   vbfield.m = 1;
   vbfield.n = 1;
   vbfield.o = 1;
   vbfield.p = 1;
   vbfield.q = 1;
   vbfield.r = 1;
   vbfield.enum1 = enum2;
   vbfield.enum2 = enum2;

   vbfield.a = -1;
   vbfield.b = -1;
   vbfield.c = -1;
   vbfield.d = -1;
   vbfield.e = -1;
   vbfield.f = -1;
   vbfield.g = -1;
   vbfield.h = -1;
   vbfield.i = -1;
   vbfield.j = -1;
   vbfield.k = -1;
   vbfield.l = -1;
   vbfield.m = -1;
   vbfield.n = -1;
   vbfield.o = -1;
   vbfield.p = -1;
   vbfield.q = -1;
   vbfield.r = -1;
   vbfield.enum1 = enumx;
   vbfield.enum2 = enumx;

/*~-1*/
}
/*~E:F22*/
/*~E:A21*/
/*~A:23*/
/*~+:static int * func9*/
/*~F:24*/
static int * func9()                    /* nested local variables */

/*~-1*/
{
   /*~T*/
   static stat1 = 0;
   register reg1;
   auto auto1;

   /*~L:25*/
   for ( reg1 = 0 ; reg1 < 2 ; reg1++ )

   /*~-1*/
   {
      /*~T*/
      static stat2 = 0;
      register reg2;
      auto auto2;

      /*~L:26*/
      for ( reg2 = 0 ; reg2 < reg1 ; reg2++ )

      /*~-1*/
      {
         /*~T*/
         func1g( &stat1 );
         func1g( &auto1 );
         func1g( &stat2 );
         func1g( &auto2 );

      /*~-1*/
      }
      /*~E:L26*/
   /*~-1*/
   }
   /*~E:L25*/
   /*~T*/
   return &stat1;

/*~-1*/
}
/*~E:F24*/
/*~E:A23*/
/*~A:27*/
/*~+:func10*/
/*~F:28*/
func10()                                /* local variables with coloring */

/*~-1*/
{
   /*~T*/
   register i, j;
   register v1, v2, v3, v4, v5, v6, v7, v8;
   register v9, v10, v11, v12, v13, v14, v15, v16, v17;

   v17 = 0;

   /*~L:29*/
   for ( i = 0 ; i < 3 ; i++ )

   /*~-1*/
   {
      /*~T*/
      v17 += i;

   /*~-1*/
   }
   /*~E:L29*/
   /*~L:30*/
   for ( v1 = 0 ; v1 < 3 ; v1++ )

   /*~-1*/
   {
      /*~T*/
      v17 += v1;

   /*~-1*/
   }
   /*~E:L30*/
   /*~L:31*/
   for ( v2 = 0 ; v2 < 3 ; v2++ )

   /*~-1*/
   {
      /*~T*/
      v17 += v2;

   /*~-1*/
   }
   /*~E:L31*/
   /*~L:32*/
   for ( v3 = 0 ; v3 < 3 ; v3++ )

   /*~-1*/
   {
      /*~T*/
      v17 += v3;

   /*~-1*/
   }
   /*~E:L32*/
   /*~L:33*/
   for ( v4 = 0 ; v4 < 3 ; v4++ )

   /*~-1*/
   {
      /*~T*/
      v17 += v4;

   /*~-1*/
   }
   /*~E:L33*/
   /*~L:34*/
   for ( v5 = 0 ; v5 < 3 ; v5++ )

   /*~-1*/
   {
      /*~T*/
      v17 += v5;

   /*~-1*/
   }
   /*~E:L34*/
   /*~L:35*/
   for ( v6 = 0 ; v6 < 3 ; v6++ )

   /*~-1*/
   {
      /*~T*/
      v17 += v6;

   /*~-1*/
   }
   /*~E:L35*/
   /*~L:36*/
   for ( v7 = 0 ; v7 < 3 ; v7++ )

   /*~-1*/
   {
      /*~T*/
      v17 += v7;

   /*~-1*/
   }
   /*~E:L36*/
   /*~L:37*/
   for ( v8 = 0 ; v8 < 3 ; v8++ )

   /*~-1*/
   {
      /*~T*/
      v17 += v8;

   /*~-1*/
   }
   /*~E:L37*/
   /*~L:38*/
   for ( v9 = 0 ; v9 < 3 ; v9++ )

   /*~-1*/
   {
      /*~T*/
      v17 += v9;

   /*~-1*/
   }
   /*~E:L38*/
   /*~L:39*/
   for ( v10 = 0 ; v10 < 3 ; v10++ )

   /*~-1*/
   {
      /*~T*/
      v17 += v10;

   /*~-1*/
   }
   /*~E:L39*/
   /*~L:40*/
   for ( v11 = 0 ; v11 < 3 ; v11++ )

   /*~-1*/
   {
      /*~T*/
      v17 += v11;

   /*~-1*/
   }
   /*~E:L40*/
   /*~L:41*/
   for ( v12 = 0 ; v12 < 3 ; v12++ )

   /*~-1*/
   {
      /*~T*/
      v17 += v12;

   /*~-1*/
   }
   /*~E:L41*/
   /*~L:42*/
   for ( v13 = 0 ; v13 < 3 ; v13++ )

   /*~-1*/
   {
      /*~T*/
      v17 += v13;

   /*~-1*/
   }
   /*~E:L42*/
   /*~L:43*/
   for ( v14 = 0 ; v14 < 3 ; v14++ )

   /*~-1*/
   {
      /*~T*/
      v17 += v14;

   /*~-1*/
   }
   /*~E:L43*/
   /*~L:44*/
   for ( v15 = 0 ; v15 < 3 ; v15++ )

   /*~-1*/
   {
      /*~T*/
      v17 += v15;

   /*~-1*/
   }
   /*~E:L44*/
   /*~L:45*/
   for ( v16 = 0 ; v16 < 3 ; v16++ )

   /*~-1*/
   {
      /*~T*/
      v17 += v16;

   /*~-1*/
   }
   /*~E:L45*/
   /*~T*/
   i = j = v17;

   /*~L:46*/
   for ( v1 = 0 ; v1 < 3 ; v1++ )

   /*~-1*/
   {
      /*~T*/
      v17 += v1;

   /*~-1*/
   }
   /*~E:L46*/
   /*~L:47*/
   for ( v2 = 0 ; v2 < 3 ; v2++ )

   /*~-1*/
   {
      /*~T*/
      v17 += v2;

   /*~-1*/
   }
   /*~E:L47*/
   /*~L:48*/
   for ( v3 = 0 ; v3 < 3 ; v3++ )

   /*~-1*/
   {
      /*~T*/
      v17 += v3;

   /*~-1*/
   }
   /*~E:L48*/
   /*~L:49*/
   for ( v4 = 0 ; v4 < 3 ; v4++ )

   /*~-1*/
   {
      /*~T*/
      v17 += v4;

   /*~-1*/
   }
   /*~E:L49*/
   /*~L:50*/
   for ( v5 = 0 ; v5 < 3 ; v5++ )

   /*~-1*/
   {
      /*~T*/
      v17 += v5;

   /*~-1*/
   }
   /*~E:L50*/
   /*~L:51*/
   for ( v6 = 0 ; v6 < 3 ; v6++ )

   /*~-1*/
   {
      /*~T*/
      v17 += v6;

   /*~-1*/
   }
   /*~E:L51*/
   /*~L:52*/
   for ( v7 = 0 ; v7 < 3 ; v7++ )

   /*~-1*/
   {
      /*~T*/
      v17 += v7;

   /*~-1*/
   }
   /*~E:L52*/
   /*~L:53*/
   for ( v8 = 0 ; v8 < 3 ; v8++ )

   /*~-1*/
   {
      /*~T*/
      v17 += v8;

   /*~-1*/
   }
   /*~E:L53*/
   /*~L:54*/
   for ( v9 = 0 ; v9 < 3 ; v9++ )

   /*~-1*/
   {
      /*~T*/
      v17 += v9;

   /*~-1*/
   }
   /*~E:L54*/
   /*~L:55*/
   for ( v10 = 0 ; v10 < 3 ; v10++ )

   /*~-1*/
   {
      /*~T*/
      v17 += v10;

   /*~-1*/
   }
   /*~E:L55*/
   /*~L:56*/
   for ( v11 = 0 ; v11 < 3 ; v11++ )

   /*~-1*/
   {
      /*~T*/
      v17 += v11;

   /*~-1*/
   }
   /*~E:L56*/
   /*~L:57*/
   for ( v12 = 0 ; v12 < 3 ; v12++ )

   /*~-1*/
   {
      /*~T*/
      v17 += v12;

   /*~-1*/
   }
   /*~E:L57*/
   /*~L:58*/
   for ( v13 = 0 ; v13 < 3 ; v13++ )

   /*~-1*/
   {
      /*~T*/
      v17 += v13;

   /*~-1*/
   }
   /*~E:L58*/
   /*~L:59*/
   for ( v14 = 0 ; v14 < 3 ; v14++ )

   /*~-1*/
   {
      /*~T*/
      v17 += v14;

   /*~-1*/
   }
   /*~E:L59*/
   /*~L:60*/
   for ( v15 = 0 ; v15 < 3 ; v15++ )

   /*~-1*/
   {
      /*~T*/
      v17 += v15;

   /*~-1*/
   }
   /*~E:L60*/
   /*~L:61*/
   for ( v16 = 0 ; v16 < 3 ; v16++ )

   /*~-1*/
   {
      /*~T*/
      v17 += v16;

   /*~-1*/
   }
   /*~E:L61*/
   /*~T*/
   return v17;

/*~-1*/
}
/*~E:F28*/
/*~E:A27*/
/*~A:62*/
/*~+:int func11(*/
/*~F:63*/
int func11( x )                 /* problems with optimizer */
int x;                          /* multiple returns in function */

/*~-1*/
{
   /*~C:64*/
   switch ( x )

   /*~-1*/
   {
      /*~F:65*/
      case 1:

      /*~-1*/
      {
         /*~T*/
         x = x+1;
         x = x*2;
         return x*x;

      /*~-1*/
      }
      /*~E:F65*/
      /*~F:66*/
      case 2:

      /*~-1*/
      {
         /*~T*/
         return x+x;

      /*~-1*/
      }
      /*~E:F66*/
      /*~F:67*/
      case 3:

      /*~-1*/
      {
         /*~T*/
         return x-x;

      /*~-1*/
      }
      /*~E:F67*/
      /*~F:68*/
      case 4:

      /*~-1*/
      {
         /*~T*/
         x = x+1;
         x = x*2;
         return x*x;

      /*~-1*/
      }
      /*~E:F68*/
      /*~F:69*/
      case 5:

      /*~-1*/
      {
         /*~T*/
         break;

      /*~-1*/
      }
      /*~E:F69*/
      /*~F:70*/
      case 6:

      /*~-1*/
      {
         /*~T*/
         return x+x;

      /*~-1*/
      }
      /*~E:F70*/
      /*~O:C64*/
      /*~-2*/
      default:
      {
         /*~T*/
         break;

      /*~-1*/
      }
   /*~-1*/
   }
   /*~E:C64*/
   /*~T*/
   return x;

/*~-1*/
}
/*~E:F63*/
/*~E:A62*/
/*~A:71*/
/*~+:void func11a*/
/*~F:72*/
void func11a()                  /* problems with optimizer */

/*~-1*/
{
   /*~T*/
   /* multiple returns in function */

   /*~C:73*/
   switch ( vchar )

   /*~-1*/
   {
      /*~F:74*/
      case 1:

      /*~-1*/
      {
         /*~T*/
         vfloat = 1.0;
         return;

      /*~-1*/
      }
      /*~E:F74*/
      /*~F:75*/
      case 2:

      /*~-1*/
      {
         /*~T*/
         vfloat = 2.0;
         return;

      /*~-1*/
      }
      /*~E:F75*/
      /*~O:C73*/
      /*~-2*/
      default:
      {
         /*~T*/
         vfloat = 0.0;
         return;

      /*~-1*/
      }
   /*~-1*/
   }
   /*~E:C73*/
/*~-1*/
}
/*~E:F72*/
/*~E:A71*/
/*~T*/
typedef char undefarray[];
typedef undefarray * undefptr;

/*~A:76*/
/*~+:int func12(*/
/*~F:77*/
int func12( ptr )                       /* pointer to array of unknown size */
undefptr ptr;

/*~-1*/
{
   /*~T*/
   (*ptr)[0] = 1;

/*~-1*/
}
/*~E:F77*/
/*~E:A76*/
/*~A:78*/
/*~+:int func13(*/
/*~F:79*/
int func13( a, c, e )                   /* arguments and locals stack-tracking */
int a, c, e;

/*~-1*/
{
   /*~T*/
   int b, d, f;

   b = a+c+e;
   f = b+a;
   d = f*b;

   /*~I:80*/
   if ( e > 0 )

   /*~-1*/
   {
      /*~T*/
      c += func13( b, f, e-1 );

   /*~-1*/
   }
   /*~E:I80*/
   /*~T*/
   return c+e+d;

/*~-1*/
}
/*~E:F79*/
/*~E:A78*/
/*~A:81*/
/*~+:int func13a(*/
/*~F:82*/
int func13a( a, c, e )          /* arguments and locals stack-tracking */
int a, c, e;

/*~-1*/
{
   /*~T*/
   int b, d, f;

   b = a+c+e;
   f = b+a;
   d = f*b;

   func1g( &a );
   func1g( &c );

   /*~I:83*/
   if ( e > 0 )

   /*~-1*/
   {
      /*~T*/
      func1g( &a );
      func1g( &c );
      c += func13a( b, f, e-1 );

   /*~-1*/
   }
   /*~E:I83*/
   /*~T*/
   return c+e+d;

/*~-1*/
}
/*~E:F82*/
/*~E:A81*/
/*~A:84*/
/*~+:main*/
/*~F:85*/
main()

/*~-1*/
{
   /*~T*/
           int j;

           func2();

           funcptr = func3;

           ast.count = 12345;
           ast.left = &ast;
           ast.field1 = 1;
           ast.field2 = 2;

           ast = func4( ast );

           j = (*funcptr)();

   start:
           j = func5( j, 2, 3 );

   /*~I:86*/
   if ( j == 0 )

   /*~-1*/
   {
      /*~T*/
      goto start;

   /*~-1*/
   }
   /*~E:I86*/
   /*~T*/
   vfloat = 2.0;

   vfloat += func6( vfloat, (float) 3.0 );

   vdouble = 2.0;

   vdouble += func7( vdouble, (double) 3.0 );

   func8();

   func9();

   func10();

   func11( 5 );

   func12( "abc" );

   func13( 1, 2, 3 );

   func13a( 1, 2, 3 );

   func1b( &vint );        /* foreward ref. inline function */

   /*~L:87*/
   while ( TRUE )

   /*~-1*/
   {
      /*~T*/
      sieve();

   /*~-1*/
   }
   /*~E:L87*/
/*~-1*/
}
/*~E:F85*/
/*~E:A84*/
/*~T*/
char flags[SIZE+1];

/*~A:88*/
/*~+:int sieve*/
/*~F:89*/
int sieve()                             /* sieve of erathostenes */

/*~-1*/
{
   /*~T*/
   register int i, prime, k;
   int count;

   count = 0;

   /*~L:90*/
   for ( i = 0 ; i <= SIZE ; flags[ i++ ] = TRUE )
   /*~-1*/
   {
      /*~T*/
      ;

   /*~-1*/
   }
   /*~E:L90*/
   /*~L:91*/
   for ( i = 0 ; i <= SIZE ; i++ )

   /*~-1*/
   {
      /*~I:92*/
      if ( flags[ i ] )

      /*~-1*/
      {
         /*~T*/
         prime = i + i + 3;
         k = i + prime;

         /*~L:93*/
         while ( k <= SIZE )

         /*~-1*/
         {
            /*~T*/
            flags[ k ] = FALSE;
            k += prime;

         /*~-1*/
         }
         /*~E:L93*/
         /*~T*/
         count++;

      /*~-1*/
      }
      /*~E:I92*/
   /*~-1*/
   }
   /*~E:L91*/
   /*~T*/
   return count;

/*~-1*/
}
/*~E:F89*/
/*~E:A88*/
/*~A:94*/
/*~+:int background*/
/*~F:95*/
int background()                        /* job for background-demo */

/*~-1*/
{
   /*~T*/
   register long count1, count2;

   count1 = count2 = 0;

   /*~L:96*/
   while ( TRUE )

   /*~-1*/
   {
      /*~L:97*/
      while ( ++count1 )
      /*~-1*/
      {
         /*~T*/
         ;

      /*~-1*/
      }
      /*~E:L97*/
      /*~T*/
      count2++;

   /*~-1*/
   }
   /*~E:L96*/
   /*~T*/
   return TRUE;

/*~-1*/
}
/*~E:F95*/
/*~E:A94*/
/*~A:98*/
/*~+:static void func1b(*/
/*~F:99*/
static void func1b( intptr )            /* static function for inline  */
int * intptr;

/*~-1*/
{
   /*~T*/
   (*intptr)++;

/*~-1*/
}
/*~E:F99*/
/*~E:A98*/