#pragma COLUMNS 239
#pragma list
#define      NOT_TRUE   0
#define      AEI_maxj   20
 
short                           rtv = 0;
short                           lnp = 0;
short                           erp = 0;
short                           cnt = 0;
short                           tpc = 0;
short                           tfc = 0;
short                           pas = 1;
short                           err = 1;
short                           btb = 1;
short                           btw = 1;
short                           bte = 1;
short                           wtb = 1;
short                           wtw = 1;
short                           wte = 1;
short                           etb = 1;
short                           etw = 1;
short                           ete = 1;
short                           t_num = -1;
short                           ppd[9];
short                           t_name[12];
short     *ptr_t_name = (short *)t_name;
short                           t_b[39];
short     *ptr_t_b = (short *)t_b;
char                            array_byte[27];
char      *ptr_array_byte = (char *)array_byte;
char                            eq_byte[27];
char      *ptr_eq_byte = (char *)array_byte;
short                           eq_notb[13];
short     *ptr_eq_notb = (short *)array_byte;
short                           array_word[13];
short     *ptr_array_word = (short *)array_word;
short                           eq_word[13];
short     *ptr_eq_word = (short *)array_word;
char                            eq_notw[25];
char      *ptr_eq_notw = (char *)array_word;
char                            i_b[27];
char      *ptr_i_b = (char *)i_b;
short                           i_w[13];
short     *ptr_i_w = (short *)i_w;
#define   SP                    3
#define   SM                    -3
char                            p_b[11];
char      *ptr_p_b = (char *)p_b;
short                           p_w[6];
short     *ptr_p_w = (short *)p_w;
char                            m_b[11];
char      *ptr_m_b = (char *)m_b;
short                           m_w[6];
short     *ptr_m_w = (short *)m_w;
char                            *sn = (char *)t_name;
char                            *bp = (char *)array_byte;
short                           c_name[12];
short     *ptr_c_name = (short *)c_name;
short                           *wp = (short *)array_word;
short                           *lpt = (short *)&lnp;
short                           *ept = (short *)&erp;
char      dir_ptr_s;
char                            *ptr_s = (char *)&dir_ptr_s;
short     dir_pd;
short                           *pd = (short *)&dir_pd;
short     dir_pi;
short                           *pi = (short *)&dir_pi;
short     dir_iid;
short                           *iid = (short *)&dir_iid;
short                           id = 0;
short                           q_double = 0;
__int64                         f = (__int64)0;
__int64                         f1 = (__int64)0;
__int64                         f2 = (__int64)0;
__int64                         fm1 = (__int64)0;
__int64                         fm2 = (__int64)0;
__int64                         fa = (__int64)0;
long      garray_init[100] = {0,0,0,0,0,0,0,0,0,0,10,10,10,10,10,10,10,10,
          10,10,100,100,100,100,100,100,100,100,100,100,1000,1000,1000,1000,1000,
          1000,1000,1000,1000,1000,10000,10000,10000,10000,10000,10000,10000,10000,
          10000,10000,10000,10000,10000,10000,10000,10000,10000,10000,10000,10000,
          1000,1000,1000,1000,1000,1000,1000,1000,1000,1000,100,100,100,100,100,100,
          100,100,100,100,10,10,10,10,10,10,10,10,10,10};
long      *ptr_garray_init = (long *)garray_init;
const char p_st[] = {(char)65,(char)66,(char)67,(char)68,(char)69,
          (char)70,(char)71,(char)72,(char)73,(char)74,(char)75,(char)76,
          (char)77,(char)78,(char)79,(char)80,(char)81,(char)82,(char)83,
          (char)84,(char)85,(char)86,(char)87,(char)88,(char)89,(char)90};
#pragma fieldalign matched2 __sf_def
typedef   struct __sf_def
   {
   union                                                                    /* added for equivalenced */
      {
      __int64                         fa;
      __int64                         f1;
      __int64                         fm1;
      } un_fa;
   } sf_def;
sf_def   sf;
sf_def   *ptr_sf = (sf_def *)&sf;
typedef   struct __sb_def
   {
   struct                                                                   /* DUMMY */
      {
      union                                                                 /* added for equivalenced */
         {
         char                            a_b[27];
         char                            eq_byte[27];
         } un_a_b;
      } dummy;
   } sb_def;
sb_def                   struct_byte;
sb_def   *ptr_struct_byte = (sb_def *)&struct_byte;
sb_def                   isb;
sb_def   *ptr_isb = (sb_def *)&isb;
typedef   struct __sw_def
   {
   short                           a_w[13];
   } sw_def;
sw_def                   struct_word;
sw_def   *ptr_struct_word = (sw_def *)&struct_word;
sw_def                         isw;
sw_def*ptr_isw = (sw_def *)&isw;
sw_def                   ise;
sw_def   *ptr_ise = (sw_def *)&ise;
typedef   struct __os_def
   {
   short                           w_p[6];
   short                           w_m[6];
   } os_def;
os_def                   pse[6];
os_def   *ptr_pse = pse;
os_def                   nse[6];
os_def   *ptr_nse = nse;
typedef   struct __assign_msg_def
   {
   short                           msg_code;
   struct                                                                   /* LOGICALUNIT */
      {
      char                            prognamelen;
      char                            progname[31];
      char                            filenamelen;
      char                            filename[31];
      } logicalunit;
   long                            fieldmask;
   union                                                                    /* added for equivalenced */
      {
      struct                                                                /* INTERNAL_NAME */
         {
         short                           full[12];
         } internal_name;
      struct                                                                /* TANDEM_NAME */
         {
         short                           vol[4];
         short                           subvol[4];
         short                           dfile[4];
         } tandem_name;
      } un_internal_name;
   short                           primaryextent;
   short                           secondaryextent;
   short                           filecode;
   short                           exclusionspec;
   short                           accessspec;
   short                           recordsize;
   short                           blocksize;
   } assign_msg_def;
typedef   struct __param_msg_def
   {
   short                           msg_code;
   short                           numparams;
   char                            parameters[1024];
   } param_msg_def;
#define   ALL_BITS              0xFFFF
jmp_buf    Test_Sub_jbuf[AEI_maxj];
#define   DO_SUB2_PD   0x1
#define   DO_SUB2_PI   0x2
#define   DO_SUB1_PD   0x1
#define   DO_SUB1_PI   0x2
#include <stack>
#include <vector>
#include <deque>
#include <iostream.h>
stack<int> s;

void AEI_Init_Declarations(void)
{
memset(t_name,(char)' ',(12 * 2));
memset(t_b,(char)' ',(39 * 2));
memset(array_byte,(char)'B',27);
memcpy(array_word,"WwWwWwWwWwWwWwWwWwWwWwWwWw",(13 * 2));
memset(ptr_i_b,(char)' ',27);
memset(ptr_i_w,(char)' ',(13 * 2));
memset(ptr_p_b,(char)' ',10);
memset(ptr_p_w,(char)' ',(5 * 2));
memset(ptr_m_b,(char)' ',10);
memset(ptr_m_w,(char)' ',(5 * 2));
memcpy(ptr_c_name,"TESTINIT                ",24);
}
startup_msg_type      startup_msg;
startup_msg_type   *ptr_startup_msg = (startup_msg_type *)&startup_msg;
void  Clear_Cnt (void);
 
 
short Test_Move_Indirect (void);
 
short Test_Scan (void);
 
#pragma PAGE  /* Clear_Cnt */
void  Clear_Cnt (void)
{
 
err = (short)0;
btb = (short)0;
btw = (short)0;
bte = (short)0;
wtb = (short)0;
wtw = (short)0;
wte = (short)0;
etb = (short)0;
etw = (short)0;
ete = (short)0;
pas = (short)0;
AEI_cc = AEI_WRITE(0x00000007,
                  (short)t_num,
                  (short *)t_b,
                  (short)0,
                  _psGP,
                  _lGP);
}
#pragma PAGE  /* Test_Notsub */
short Test_Notsub(long      Test_Notsub_bmap,
                  short     pd,
                  short     pi)
  {
#define   PD   0x1
#define   PI   0x2
 
if ((Test_Notsub_bmap & PD) != NOT_TRUE)
   {
   pd++;
   }
return(pd);
}
#pragma PAGE  /* Test_Sub */
short Test_Sub(short   *ps,
               short     pd,
               short     *pi)
  {
#pragma fieldalign matched2 __ps_def
typedef   struct __ps_def
   {
   short     psi;
   char      pss;
   } ps_def;
ps_def   *ptr_ps = (ps_def *)ps;
#define   UNIQUE                -1
typedef   struct __q_def
   {
   struct                                                                   /* DUMMY */
      {
      union                                                                 /* added for equivalenced */
         {
         struct                                                             /* US */
            {
            short     unique;
            } us;
         struct                                                             /* NUS */
            {
            short     not_unique;
            } nus;
         } un_us;
      } dummy;
   } q_def;
q_def                    qst;
q_def   *ptr_qst = (q_def *)&qst;
typedef   struct __s_def
   {
   char      b_a[26];
   short     i_27;
   } s_def;
s_def                    lst;
s_def   *ptr_lst = (s_def *)&lst;
short     *iit = (short *)&lst;
short     dir_iid;
short     *iid = (short *)&dir_iid;
short     id;
short     do_sub2_pd;
short     dir_do_sub2_pi;
short     *do_sub2_pi = (short *)&dir_do_sub2_pi;
long      Do_Sub2_bmap;
short     dir_do_sub2_iid;
short     *do_sub2_iid = (short *)&dir_do_sub2_iid;
short     do_sub2_id;
short     do_sub1_pd;
short     dir_do_sub1_pi;
short     *do_sub1_pi = (short *)&dir_do_sub1_pi;
long      Do_Sub1_bmap;
short     dir_do_sub1_iid;
short     *do_sub1_iid = (short *)&dir_do_sub1_iid;
short     do_sub1_id;
 
goto_boolean = 0;
if (AEI_jc > AEI_maxj)
   AEI_DEBUG();
Do_Sub2:
if (goto_boolean > 0)
   {
   do_sub2_id++;
   do_sub2_iid = (short *)&do_sub2_id;
   if (((Do_Sub2_bmap & DO_SUB2_PD) != NOT_TRUE) &&
        (do_sub2_pd > 1))
      {
      ptr_qst->dummy.un_us.us.unique = (short)UNIQUE;
      if ((ptr_qst->dummy.un_us.us.unique == UNIQUE) &&
          (ptr_qst->dummy.un_us.nus.not_unique == UNIQUE))
         {
         pas++;
         }
      else
         {
         err++;
         }
      memcpy(ptr_lst->b_a,(char *)"ABCDEFGHIJKLMNOPQRSTUVWXYZ",26);
      ptr_lst->i_27 = (short)UNIQUE;
      do_sub2_pi = (short *)ptr_lst;
      }
   else
      {
      pas++;
      Test_Sub((short *)ptr_isw,(short)do_sub2_id,(short *)do_sub2_iid);
      }
   goto_parm = ++do_sub2_pd;
   goto_boolean = 0;
   longjmp(Test_Sub_jbuf[AEI_jc],goto_parm);
   }
goto_boolean = 0;
Do_Sub1:
if (goto_boolean > 0)
   {
   do_sub1_id++;
   do_sub1_iid = (short *)&do_sub1_id;
   if (do_sub1_pd == 0)
      {
      goto_parm = Test_Notsub((long)0x00000001,(short)do_sub1_pd,_sGP);
      }
   else
      {
      goto_boolean = 1;
      AEI_jc++;
      setjmp(Test_Sub_jbuf[AEI_jc]);
      if (goto_boolean > 0)
         {
         do_sub2_pd = (short)do_sub1_pd;
         Do_Sub2_bmap = (DO_SUB2_PD);
         goto Do_Sub2;
         }
      else
         AEI_jc--;
      }
   goto_boolean = 0;
   longjmp(Test_Sub_jbuf[AEI_jc],goto_parm);
   }
id++;
iid = (short *)&id;
while (goto_parm < 3)
   {
   goto_boolean = 1;
   AEI_jc++;
   setjmp(Test_Sub_jbuf[AEI_jc]);
   if (goto_boolean > 0)
      {
      do_sub1_pd = (short)pas;
      Do_Sub1_bmap = (DO_SUB1_PD);
      goto Do_Sub1;
      }
   else
      AEI_jc--;
   sr  = goto_parm;
   sr = goto_parm;
   if (sr  < 3)
      {
      pas++;
      }
   }
if (memcmp(iit,ptr_lst,sizeof(s_def))  ==  0)
   {
   pas++;
   }
else
   {
   err++;
   }
if (memcmp(iit,p_st,sizeof(p_st))  ==  0)
   {
   pas++;
   }
else
   {
   err++;
   }
bp[3] = (char)13;
wp = (short *)&iit[bp[3]];
if (*wp == UNIQUE)
   {
   pas++;
   }
else
   {
   err++;
   }
if (memcmp(array_byte,ptr_eq_byte,sizeof(array_byte))  ==  0)
   {
   btb++;
   }
else
   {
   err++;
   }
if (memcmp(array_word,ptr_eq_word,sizeof(array_word))  ==  0)
   {
   wtw++;
   }
else
   {
   err++;
   }
if (memcmp(array_byte,ptr_eq_byte,sizeof(array_byte))  ==  0)
   {
   btb++;
   }
else
   {
   err++;
   }
if (memcmp(array_byte,ptr_eq_notb,sizeof(array_byte))  ==  0)
   {
   btw++;
   }
else
   {
   err++;
   }
if (memcmp(array_word,ptr_eq_word,sizeof(array_word))  ==  0)
   {
   wtw++;
   }
else
   {
   err++;
   }
if (memcmp(array_word,ptr_eq_notw,sizeof(array_word))  ==  0)
   {
   wtb++;
   }
else
   {
   err++;
   }
return(err);
}
#pragma PAGE  /* Test_Move_Indirect */
short Test_Move_Indirect (void)
{
 
bp = (char *)array_byte;
if (memcmp(bp,array_byte,sizeof(array_byte))  ==  0)
   {
   btb++;
   }
else
   {
   err++;
   }
bp = (char *)array_word;
if (memcmp(bp,array_word,sizeof(array_word))  ==  0)
   {
   btw++;
   }
else
   {
   err++;
   }
bp = (char *)ptr_isw;
if (memcmp(bp,ptr_isw,sizeof(struct_word))  ==  0)
   {
   bte++;
   }
else
   {
   err++;
   }
ptr_i_b = (char *)array_byte;
if (memcmp(ptr_i_b,array_byte,sizeof(array_byte))  ==  0)
   {
   btb++;
   }
else
   {
   err++;
   }
ptr_i_b = (char *)array_word;
if (memcmp(ptr_i_b,array_word,sizeof(array_word))  ==  0)
   {
   btw++;
   }
else
   {
   err++;
   }
ptr_i_b = (char *)ptr_isb->dummy.un_a_b.a_b;
if (memcmp(ptr_i_b,ptr_isb->dummy.un_a_b.a_b,sizeof(struct_byte))  ==  0)
   {
   bte++;
   }
else
   {
   err++;
   }
wp = (short *)array_byte;
if (memcmp(wp,array_byte,sizeof(array_byte))  ==  0)
   {
   wtb++;
   }
else
   {
   err++;
   }
wp = (short *)array_word;
if (memcmp(wp,array_word,sizeof(array_word))  ==  0)
   {
   wtw++;
   }
else
   {
   err++;
   }
wp = (short *)ptr_isw;
if (memcmp(wp,ptr_isw,sizeof(struct_word))  ==  0)
   {
   wte++;
   }
else
   {
   err++;
   }
ptr_i_w = (short *)array_byte;
if (memcmp(ptr_i_w,array_byte,sizeof(array_byte))  ==  0)
   {
   wtb++;
   }
else
   {
   err++;
   }
ptr_i_w = (short *)array_word;
if (memcmp(ptr_i_w,array_word,sizeof(array_word))  ==  0)
   {
   wtw++;
   }
else
   {
   err++;
   }
ptr_i_w = (short *)ptr_isw;
if (memcmp(ptr_i_w,ptr_isw,sizeof(struct_word))  ==  0)
   {
   wte++;
   }
else
   {
   err++;
   }
ptr_ise = (sw_def *)array_byte;
if (memcmp(ptr_ise,array_byte,sizeof(array_byte))  ==  0)
   {
   etb++;
   }
else
   {
   err++;
   }
ptr_ise = (sw_def *)array_word;
if (memcmp(ptr_ise,array_word,sizeof(array_word))  ==  0)
   {
   etw++;
   }
else
   {
   err++;
   }
ptr_ise = (sw_def *)ptr_isw;
if (memcmp(ptr_ise,ptr_isw,sizeof(struct_word))  ==  0)
   {
   ete++;
   }
else
   {
   err++;
   }
bp = (char *)t_b;
memcpy(t_b,
       (char *)"     INDIRECT TEST            FAILED       = XXXX      PASSED       = XXXX  ",76);
sr = AEI_NUMOUT(0x0000000F,(char  *)&bp[45],(short)err,(short)10,(short)4);
pas = (short)(pas + btb + btw + bte + wtb + wtw + wte + etb + etw + ete);
sr = AEI_NUMOUT(0x0000000F,(char  *)&bp[70],(short)pas,(short)10,(short)4);
AEI_cc = AEI_WRITE(0x00000007,
                  (short)t_num,
                  (short *)t_b,
                  (short)sizeof(t_b),
                  _psGP,
                  _lGP);
return(err);
}
#pragma PAGE  /* Test_Scan */
short Test_Scan (void)
{
 
memcpy(array_byte,(char *)"ABCDEFGHIJKLMNOPQRSTUVWXY",25);
array_byte[25] = (char)0;
bp = (char *)scanuntil((char *)&array_byte[0],(char)'G');
if ((_status_eq(AEI_cc)) &&
  (((long)bp - (long)array_byte) == (char)(long)(6)))
   {
   btb++;
   }
else
   {
   err++;
   }
wp = (short *)scanuntil((char *)&array_byte[0],(char)'G');
if ((_status_eq(AEI_cc)) &&
  (((long)wp - (long)array_byte) == (char)(long)(6)))
   {
   btw++;
   }
else
   {
   err++;
   }
bp = (char *)array_word;
memcpy(bp,(char *)"ABCDEFGHIJKLMNOPQRSTUVWXY",25);
bp[25] = (char)0;
ptr_i_b = (char *)scanuntil((char *)bp,(char)'G');
if ((_status_eq(AEI_cc)) &&
  (((long)ptr_i_b - (long)bp) == (long)(6)))
   {
   btb++;
   }
else
   {
   err++;
   }
wp = (short *)scanuntil((char *)bp,(char)'G');
if ((_status_eq(AEI_cc)) &&
  (((long)wp - (long)bp) == (long)(6)))
   {
   btw++;
   }
else
   {
   err++;
   }
ptr_ise = (sw_def *)scanuntil((char *)bp,(char)'Z');
if (_status_ne(AEI_cc))
   {
   bte++;
   }
else
   {
   err++;
   }
memcpy(bp,(char *)"AAAAAAGHIJKLMNOPQRSTUVWXY",25);
bp[25] = (char)0;
ptr_i_b = (char *)scanwhile((char *)bp,(char)'A');
if ((_status_eq(AEI_cc)) &&
  (((long)ptr_i_b - (long)bp) == (long)(6)))
   {
   btb++;
   }
else
   {
   err++;
   }
wp = (short *)scanwhile((char *)bp,(char)'A');
if ((_status_eq(AEI_cc)) &&
  (((long)wp - (long)bp) == (long)(6)))
   {
   btw++;
   }
else
   {
   err++;
   }
ptr_ise = (sw_def *)scanwhile((char *)bp,(char)'A');
if ((_status_eq(AEI_cc)) &&
  (((long)ptr_ise - (long)bp) == (long)(6)))
   {
   bte++;
   }
else
   {
   err++;
   }
memcpy(array_word,(char *)"ABCDEFGHIJKLMNOPQRSTUVWXY",25);
word_ptr = (short *)((long)&array_word[0] + (long)25);
word_ptr[0] = 0;
wp = (short *)array_word;
bp = (char *)scanuntil((char *)wp,(char)'G');
if ((_status_eq(AEI_cc)) &&
  (((long)bp - (long)wp) == (long)(6)))
   {
   wtb++;
   }
else
   {
   err++;
   }
bp = (char *)scanuntil((char *)wp,(char)'Z');
if (_status_ne(AEI_cc))
   {
   wtb++;
   }
else
   {
   err++;
   }
memcpy(wp,(char *)"AAAAAAGHIJKLMNOPQRSTUVWXY",25);
word_ptr = (short *)((long)&wp[0] + (long)25);
word_ptr[0] = (short)0;
bp = (char *)scanwhile((char *)wp,(char)'A');
if ((_status_eq(AEI_cc)) &&
  (((long)bp - (long)wp) == (long)(6)))
   {
   wtb++;
   }
else
   {
   err++;
   }
bp = (char *)scanuntil((char *)&array_word[0],(char)'G');
if ((_status_eq(AEI_cc)) &&
  (((long)bp - (long)array_word) == (long)(6)))
   {
   wtb++;
   }
else
   {
   err++;
   }
wp = (short *)scanuntil((char *)&array_word[0],(char)'G');
if ((_status_eq(AEI_cc)) &&
  (((long)wp - (long)array_word) == (long)(6)))
   {
   wtw++;
   }
else
   {
   err++;
   }
ptr_ise = (sw_def *)scanuntil((char *)&array_word[0],(char)'G');
if ((_status_eq(AEI_cc)) &&
  (((long)ptr_ise - (long)array_word) == (long)(6)))
   {
   wte++;
   }
else
   {
   err++;
   }
memcpy(ptr_isb,(char *)"ABCDEFGHIJKLMNOPQRSTUVWXY",25);
byte_ptr = (char *)((long)ptr_isb + (long)25);
byte_ptr[0] = (char)0;
bp = (char *)scanuntil((char *)ptr_isb,(char)'G');
if ((_status_eq(AEI_cc)) &&
  (((long)bp - (long)ptr_isb->dummy.un_a_b.a_b) == (char)(long)(6)))
   {
   etb++;
   }
else
   {
   err++;
   }
wp = (short *)scanuntil((char *)ptr_isb,(char)'G');
if ((_status_eq(AEI_cc)) &&
  (((long)wp - (long)ptr_isb->dummy.un_a_b.a_b) == (char)(long)(6)))
   {
   etw++;
   }
else
   {
   err++;
   }
memcpy(ptr_isb,(char *)"ABCDEFGHIJKLMNOPQRSTUVWXY",25);
byte_ptr = (char *)((long)ptr_isb + (long)25);
byte_ptr[0] = (char)0;
ptr_ise = (sw_def *)scanuntil((char *)ptr_isb,(char)'G');
if ((_status_eq(AEI_cc)) &&
  (((long)ptr_ise - (long)ptr_isb) == (long)(6)))
   {
   ete++;
   }
else
   {
   err++;
   }
bp = (char *)t_b;
memcpy(t_b,
       (char *)"     SCAN     TEST            FAILED       = XXXX      PASSED       = XXXX  ",76);
sr = AEI_NUMOUT(0x0000000F,(char  *)&bp[45],(short)err,(short)10,(short)4);
pas = (short)(pas + btb + btw + bte + wtb + wtw + wte + etb + etw + ete);
sr = AEI_NUMOUT(0x0000000F,(char  *)&bp[70],(short)pas,(short)10,(short)4);
AEI_cc = AEI_WRITE(0x00000007,
                  (short)t_num,
                  (short *)t_b,
                  (short)sizeof(t_b),
                  _psGP,
                  _lGP);
return(err);
}
#pragma PAGE  /* Test_Rscan */
short Test_Rscan (void)
{
 
array_byte[0] = (char)0;
memcpy(&array_byte[1],(char *)"BCDEFGHIJKLMNOPQRSTUVWXYZ",25);
bp = (char *)&array_byte[25];
ptr_i_b = (char *)rscanuntil((char *)bp,(char)'S');
if ((_status_eq(AEI_cc)) &&
  (((long)bp - (long)ptr_i_b) == (char)(long)(7)))
   {
   btb++;
   }
else
   {
   err++;
   }
wp = (short *)rscanuntil((char *)&array_byte[25],(char)'S');
if ((_status_eq(AEI_cc)) &&
  (((long)&array_byte[25] - (long)wp) == (long)(7)))
   {
   btw++;
   }
else
   {
   err++;
   }
ptr_ise = (sw_def *)rscanuntil((char *)bp,(char)'A');
if (_status_ne(AEI_cc))
   {
   bte++;
   }
else
   {
   err++;
   }
array_byte[0] = (char)0;
memcpy(&array_byte[1],(char *)"BCDEFGHIJKLMNOPQRSYYYYYYY",25);
wp = (short *)rscanwhile((char *)bp,(char)'Y');
if ((_status_eq(AEI_cc)) &&
  (((long)bp - (long)wp) == (long)(7)))
   {
   btw++;
   }
else
   {
   err++;
   }
ptr_i_b = (char *)rscanwhile((char *)bp,(char)'Y');
if ((_status_eq(AEI_cc)) &&
  (((long)bp - (long)ptr_i_b) == (char)(long)(7)))
   {
   btb++;
   }
else
   {
   err++;
   }
array_word[0] = (short)0;
word_ptr = (short *)((long)&array_word[0] + (long)2);
memcpy(word_ptr,(char *)"CDEFGHIJKLMNOPQRSTUVWXYZ",24);
bp = (char *)rscanuntil((char *)&array_word[12],(char)'S');
if ((_status_eq(AEI_cc)) &&
  (((long)&array_word[12] - (long)bp) == (long)(6)))
   {
   wtb++;
   }
else
   {
   err++;
   }
wp = (short *)&array_word[12];
bp = (char *)rscanuntil((char *)wp,(char)'S');
if ((_status_eq(AEI_cc)) &&
  (((long)wp - (long)bp) == (long)(6)))
   {
   wtb++;
   }
else
   {
   err++;
   }
ptr_ise = (sw_def *)rscanuntil((char *)wp,(char)'B');
if (_status_ne(AEI_cc))
   {
   wte++;
   }
else
   {
   err++;
   }
array_word[0] = (short)0;
word_ptr = (short *)((long)&array_word[0] + (long)2);
memcpy(word_ptr,(char *)"CDEFGHIJKLMNOPQRSYYYYYYY",24);
wp = (short *)rscanwhile((char *)&array_word[12],(char)'Y');
if ((_status_eq(AEI_cc)) &&
  (((long)&array_word[12] - (long)wp) == (long)(6)))
   {
   wtw++;
   }
else
   {
   err++;
   }
word_ptr = (short *)((long)ptr_isb);
word_ptr[0] = (short)0;
byte_ptr = (char *)((long)word_ptr + (long)2);
memcpy(byte_ptr,(char *)"BCDEFGHIJKLMNOPQRSTUVWXYZ",25);
bp = (char *)rscanuntil((char *)&ptr_isb->dummy.un_a_b.a_b[25],(char)'S');
if ((_status_eq(AEI_cc)) &&
  (((long)&ptr_isb->dummy.un_a_b.a_b[25] - (long)bp) == (long)(6)))
   {
   etb++;
   }
else
   {
   err++;
   }
wp = (short *)rscanuntil((char *)&ptr_isb->dummy.un_a_b.a_b[25],(char)'S');
if ((_status_eq(AEI_cc)) &&
  (((long)&ptr_isb->dummy.un_a_b.a_b[25] - (long)wp) == (long)(6)))
   {
   etw++;
   }
else
   {
   err++;
   }
word_ptr = (short *)((long)ptr_isb);
word_ptr[0] = (short)0;
byte_ptr = (char *)((long)word_ptr + (long)2);
memcpy(byte_ptr,(char *)"BCDEFGHIJKLMNOPQRSTUVWXYZ",25);
ptr_ise = (sw_def *)rscanuntil((char *)&ptr_isb->dummy.un_a_b.a_b[25],
           (char)'S');
if ((_status_eq(AEI_cc)) &&
  (((long)&ptr_isb->dummy.un_a_b.a_b[25] - (long)ptr_ise) == (long)(6)))
   {
   ete++;
   }
else
   {
   err++;
   }
bp = (char *)t_b;
memcpy(t_b,
       (char *)"     RSCAN    TEST            FAILED       = XXXX      PASSED       = XXXX  ",76);
sr = AEI_NUMOUT(0x0000000F,(char  *)&bp[45],(short)err,(short)10,(short)4);
pas = (short)(pas + btb + btw + bte + wtb + wtw + wte + etb + etw + ete);
sr = AEI_NUMOUT(0x0000000F,(char  *)&bp[70],(short)pas,(short)10,(short)4);
AEI_cc = AEI_WRITE(0x00000007,
                  (short)t_num,
                  (short *)t_b,
                  (short)sizeof(t_b),
                  _psGP,
                  _lGP);
return(err);
}
#pragma PAGE  /* Test_And_Bit */
void  Test_And_Bit (void)
{
short     i;
 
i = (short)((ALL_BITS & 0xFF00) >> 8);
if (((i & 0xFF00) >> 8) == NOT_TRUE)
   {
   pas++;
   }
else
   {
   err++;
   }
i = (short)((0xFFFF & 0x00FF) >> 0);
if (((i & 0xFF00) >> 8) == NOT_TRUE)
   {
   pas++;
   }
else
   {
   err++;
   }
bp = (char *)t_b;
memcpy(bp,(char *)"~~~",3);
memcpy(&bp[3],(char *)bp,2);
memcpy(&bp[5],(char *)"BIT & &  TEST",13);
memcpy(&bp[18],(char *)bp,5);
memcpy(&bp[23],(char *)bp,2);
memcpy(&bp[25],(char *)bp,5);
memcpy(&bp[30],(char *)"FAILED       = xxxx",19);
memcpy(&bp[49],(char *)bp,2);
memcpy(&bp[51],(char *)bp,4);
memcpy(&bp[55],(char *)"PASSED       = XXXX",19);
memcpy(&bp[74],(char *)bp,2);
for (i = 0; i <= 4; i++)
   {
   ptr_p_w[(i + 3 - 3)] = (short)i;
   ptr_p_b[(i + 3 - 3)] = (char)i;
   ptr_m_w[(i - 3 + 3)] = (short)i;
   ptr_m_b[(i - 3 + 3)] = (char)i;
   ptr_pse[(i + 3 - 3)].w_p[(i + 3 - 3)] = (short)i;
   ptr_nse[(i - 3 + 3)].w_m[(i - 3 + 3)] = (short)i;
   }
if ((ptr_p_w[(3 - 3)] == ptr_m_w[(-3 + 3)]) &&
    (ptr_p_b[(3 - 3)] == ptr_m_b[(-3 + 3)]))
   {
   pas++;
   }
else
   {
   err++;
   }
if ((ptr_p_w[(7 - 3)] == ptr_m_w[(1 + 3)]) &&
    (ptr_p_b[(7 - 3)] == ptr_m_b[(1 + 3)]))
   {
   pas++;
   }
else
   {
   err++;
   }
if (ptr_pse[(3 - 3)].w_p[(3 - 3)] == ptr_nse[(-3 + 3)].w_m[(-3 + 3)])
   {
   pas++;
   }
else
   {
   err++;
   }
if (ptr_pse[(7 - 3)].w_p[(7 - 3)] == ptr_nse[(1 + 3)].w_m[(1 + 3)])
   {
   pas++;
   }
else
   {
   err++;
   }
sr = AEI_NUMOUT(0x0000000F,(char  *)&bp[45],(short)err,(short)10,(short)4);
sr = AEI_NUMOUT(0x0000000F,(char  *)&bp[70],(short)pas,(short)10,(short)4);
AEI_cc = AEI_WRITE(0x00000007,
                  (short)t_num,
                  (short *)t_b,
                  (short)sizeof(t_b),
                  _psGP,
                  _lGP);
AEI_cc = AEI_WRITE(0x00000007,
                  (short)t_num,
                  (short *)t_b,
                  (short)0,
                  _psGP,
                  _lGP);
memcpy(t_b,
       (char *)"     ALL      TESTS           FAILED       = XXXX      PASSED       = XXXX   ",77);
sr = AEI_NUMOUT(0x0000000F,(char  *)&bp[45],(short)tfc,(short)10,(short)4);
sr = AEI_NUMOUT(0x0000000F,(char  *)&bp[70],(short)tpc,(short)10,(short)4);
AEI_cc = AEI_WRITE(0x00000007,
                  (short)t_num,
                  (short *)t_b,
                  (short)sizeof(t_b),
                  _psGP,
                  _lGP);
AEI_cc = AEI_WRITE(0x00000007,
                  (short)t_num,
                  (short *)t_b,
                  (short)0,
                  _psGP,
                  _lGP);
AEI_cc = AEI_WRITE(0x00000007,
                  (short)t_num,
                  (short *)t_b,
                  (short)0,
                  _psGP,
                  _lGP);
return;
}
#pragma PAGE  /* Test_Var */
short Test_Var(long      Test_Var_bmap,
               short     *p1,
               short     p2,
               short     *p3,
               short     p4,
               short     p5,
               short     p6,
               short     p7,
               short     p8,
               short     p9,
               short     format)
  {
#define   P1   0x1
#define   P2   0x2
#define   P3   0x4
#define   P4   0x8
#define   P5   0x10
#define   P6   0x20
#define   P7   0x40
#define   P8   0x80
#define   P9   0x100
#define   FORMAT   0x200
 
if ((Test_Var_bmap & P1) != NOT_TRUE)
   {
   *p1 = (short)(*p1 + 1);
   }
else
   {
   *p3 = (short)(*p3 + 1);
   }
if ((Test_Var_bmap & P2) == NOT_TRUE)
   {
   *p1 = (short)(*p1 + 1);
   }
else
   {
   *p3 = (short)(*p3 + 1);
   }
if ((Test_Var_bmap & P3) != NOT_TRUE)
   {
   *p1 = (short)(*p1 + 1);
   }
else
   {
   *p3 = (short)(*p3 + 1);
   }
if ((Test_Var_bmap & P4) == NOT_TRUE)
   {
   *p1 = (short)(*p1 + 1);
   }
else
   {
   *p3 = (short)(*p3 + 1);
   }
if ((Test_Var_bmap & P5) != NOT_TRUE)
   {
   *p1 = (short)(*p1 + 1);
   }
else
   {
   *p3 = (short)(*p3 + 1);
   }
if ((Test_Var_bmap & P6) == NOT_TRUE)
   {
   *p1 = (short)(*p1 + 1);
   }
else
   {
   *p3 = (short)(*p3 + 1);
   }
if ((Test_Var_bmap & P7) != NOT_TRUE)
   {
   *p1 = (short)(*p1 + 1);
   }
else
   {
   *p3 = (short)(*p3 + 1);
   }
if ((Test_Var_bmap & P8) == NOT_TRUE)
   {
   *p1 = (short)(*p1 + 1);
   }
else
   {
   *p3 = (short)(*p3 + 1);
   }
if ((Test_Var_bmap & P9) == NOT_TRUE)
   {
   *p1 = (short)(*p1 + 1);
   }
else
   {
   *p3 = (short)(*p3 + 1);
   }
if ((Test_Var_bmap & FORMAT) == NOT_TRUE)
   {
   *p1 = (short)(*p1 + 1);
   }
else
   {
   *p3 = (short)(*p3 + 1);
   }
bp = (char *)t_b;
memcpy(t_b,
       (char *)"     PARAM    TEST            FAILED       = XXXX      PASSED       = XXXX  ",76);
sr = AEI_NUMOUT(0x0000000F,(char  *)&bp[45],(short)err,(short)10,(short)4);
sr = AEI_NUMOUT(0x0000000F,(char  *)&bp[70],(short)pas,(short)10,(short)4);
AEI_cc = AEI_WRITE(0x00000007,
                  (short)t_num,
                  (short *)t_b,
                  (short)sizeof(t_b),
                  _psGP,
                  _lGP);
return(err);
}
#pragma PAGE  /* Test_Fixed */
short Test_Fixed (void)
{
 
fa = (fa + (__int64)1);
if (fa == (__int64)1)
   {
   pas++;
   }
else
   {
   err++;
   }
f = (f + (__int64)1);
if (f == (__int64)1)
   {
   pas++;
   }
else
   {
   err++;
   }
f = (f + (__int64)0.1);
if (f == (__int64)1)
   {
   pas++;
   }
else
   {
   err++;
   }
f = (f + (__int64)10);
if (f == (__int64)11)
   {
   pas++;
   }
else
   {
   err++;
   }
f1 = (f1 + (__int64)(0.1 * 10));
if (f1 == (__int64)(0.1 * 10))
   {
   pas++;
   }
else
   {
   err++;
   }
f1 = (f1 + (__int64)(0.01 * 10));
if (f1 == (__int64)(0.1 * 10))
   {
   pas++;
   }
else
   {
   err++;
   }
f1 = (f1 + (__int64)(1 * 10));
if (f1 == (__int64)(1.1 * 10))
   {
   pas++;
   }
else
   {
   err++;
   }
f2 = (f2 + (__int64)(0.01 * 100));
if (f2 == (__int64)(0.01 * 100))
   {
   pas++;
   }
else
   {
   err++;
   }
f2 = (f2 + (__int64)(0.001 * 100));
if (f2 == (__int64)(0.01 * 100))
   {
   pas++;
   }
else
   {
   err++;
   }
f2 = (f2 + (__int64)(1 * 100));
if (f2 == (__int64)(1.01 * 100))
   {
   pas++;
   }
else
   {
   err++;
   }
f2 = (__int64)(0.01 * 100);
f1 = (__int64)(0.1 * 10);
f2 = (f2 + (f1 * 10));
if (f2 == (__int64)(0.11 * 100))
   {
   pas++;
   }
else
   {
   err++;
   }
fm1 = (fm1 + (__int64)(10 / 10));
if (fm1 == (__int64)(10 / 10))
   {
   pas++;
   }
else
   {
   err++;
   }
fm1 = (fm1 + (__int64)(1 / 10));
if (fm1 == (__int64)(10 / 10))
   {
   pas++;
   }
else
   {
   err++;
   }
fm1 = (fm1 + (__int64)(100 / 10));
if (fm1 == (__int64)(110 / 10))
   {
   pas++;
   }
else
   {
   err++;
   }
fm2 = (fm2 + (__int64)(100 / 100));
if (fm2 == (__int64)(100 / 100))
   {
   pas++;
   }
else
   {
   err++;
   }
fm2 = (fm2 + (__int64)(10 / 100));
if (fm2 == (__int64)(100 / 100))
   {
   pas++;
   }
else
   {
   err++;
   }
fm2 = (fm2 + (__int64)(1000 / 100));
if (fm2 == (__int64)(1100 / 100))
   {
   pas++;
   }
else
   {
   err++;
   }
fm2 = (__int64)(100 / 100);
fm1 = (__int64)(10 / 10);
fm1 = (fm1 + (fm2 * 10));
if (fm1 == (__int64)(110 / 10))
   {
   pas++;
   }
else
   {
   err++;
   }
ptr_sf->un_fa.fa = (__int64)1;
ptr_sf->un_fa.f1 = (__int64)(0.1 * 10);
ptr_sf->un_fa.f1 = (ptr_sf->un_fa.f1 + (ptr_sf->un_fa.fa * 10));
if (ptr_sf->un_fa.f1 == (__int64)(1.1 * 10))
   {
   pas++;
   }
else
   {
   err++;
   }
ptr_sf->un_fa.fa = (__int64)1;
ptr_sf->un_fa.fm1 = (__int64)(10 / 10);
ptr_sf->un_fa.fa = (ptr_sf->un_fa.fa + (ptr_sf->un_fa.fm1 * 10));
if (ptr_sf->un_fa.fa == (__int64)11)
   {
   pas++;
   }
else
   {
   err++;
   }
bp = (char *)t_b;
memcpy(t_b,
       (char *)"     FIXED    TEST            FAILED       = XXXX      PASSED       = XXXX  ",76);
sr = AEI_NUMOUT(0x0000000F,(char  *)&bp[45],(short)err,(short)10,(short)4);
sr = AEI_NUMOUT(0x0000000F,(char  *)&bp[70],(short)pas,(short)10,(short)4);
AEI_cc = AEI_WRITE(0x00000007,
                  (short)t_num,
                  (short *)t_b,
                  (short)sizeof(t_b),
                  _psGP,
                  _lGP);
return(err);
}
#pragma PAGE  /* Arm_Trap */
void  Arm_Trap (void)
{
 
/* CODE  (RDE); */
/* CODE  (ANRI %577); */
/* CODE  (SETE); */
return;
}
#pragma PAGE  /* Handle_Startup_Msg */
void  Handle_Startup_Msg(long      Handle_Startup_Msg_bmap,
                         short     *rucb,
                         short     *passthru,
                         short     *startup_msg_p,
                         short     meslen,
                         short     match)
  {
#define   RUCB   0x1
#define   PASSTHRU   0x2
#define   STARTUP_MSG_P   0x4
#define   MESLEN   0x8
#define   MATCH   0x10
 
memcpy(ptr_aei_startup_msg,(char *)startup_msg_p,meslen);
sr = AEI_SHIFTSTRING(0x00000007,
                    (char  *)ptr_aei_startup_msg->param,
                    (short)sizeof(startup_msg.param),
                    (short)0);
ptr_s = (char *)scanwhile((char *)&ptr_aei_startup_msg->param[0],
         (char)' ');
if ((_status_ne(AEI_cc)) ||
   (sr = AEI_FNAMEEXPAND(0x00000007,
                        (char  *)ptr_s,
                        (short *)ptr_c_name,
                        (short *)&ptr_aei_startup_msg->defaults) == NOT_TRUE))
   {
   tfc++;
   }
else
   {
   tpc++;
   }
}
#pragma PAGE  /* Handle_Assign_Msg */
void  Handle_Assign_Msg(long      Handle_Assign_Msg_bmap,
                        short     *rucb,
                        short     *passthru,
                        assign_msg_def   *assign_msg ,
                        short     meslen,
                        short     match)
  {
#define   RUCB   0x1
#define   PASSTHRU   0x2
#define   ASSIGN_MSG   0x4
#define   MESLEN   0x8
#define   MATCH   0x10
assign_msg_def*ptr_assign_msg  = (assign_msg_def *)assign_msg ;
char      logical_name[31];
char      *ptr_logical_name = (char *)logical_name;
 
if 
(((((ptr_assign_msg->fieldmask & 0xFFFF0000) >> 16) & 0x8000) >> 15) != 1)
   {
   return;
   }
memcpy(ptr_logical_name,(char *)"                              ",30);
memcpy(ptr_logical_name,
       (char *)ptr_assign_msg->logicalunit.filename,ptr_assign_msg->logicalunit.filenamelen);
}
#pragma PAGE  /* Handle_Param_Msg */
void  Handle_Param_Msg(long      Handle_Param_Msg_bmap,
                       short     *rucb,
                       short     *passthru,
                       param_msg_def   *param_msg ,
                       short     meslen,
                       short     match)
  {
#define   RUCB   0x1
#define   PASSTHRU   0x2
#define   PARAM_MSG   0x4
#define   MESLEN   0x8
#define   MATCH   0x10
param_msg_def*ptr_param_msg  = (param_msg_def *)param_msg ;
short     name_len;
short     param_cnt;
char      dir_param_msg_name;
char      *param_msg_name = (char *)&dir_param_msg_name;
char      dir_param_msg_value;
char      *param_msg_value = (char *)&dir_param_msg_value;
char      param_name[31];
char      *ptr_param_name = (char *)param_name;
char      dir_sbp;
char      *sbp = (char *)&dir_sbp;
short     value_len;
 
param_cnt = (short)0;
sbp = (char *)&ptr_param_msg->parameters[0];
while (param_cnt++  <=  ptr_param_msg->numparams)
   {
   name_len = (short)*sbp;
   param_msg_name = (char *)&sbp[1];
   value_len = (short)sbp[(name_len + 1)];
   param_msg_value = (char *)&sbp[(name_len + 2)];
   memcpy(ptr_param_name,(char *)"                              ",30);
   memcpy(ptr_param_name,(char *)param_msg_name,name_len);
   sbp = (char *)(sbp + name_len + value_len + 2);
   }
}
#pragma PAGE  /* Init */
void  Init (void)
{
long      larray_init[100] = {0,0,0,0,0,0,0,0,0,0,10,10,10,10,10,10,10,10,
          10,10,100,100,100,100,100,100,100,100,100,100,1000,1000,1000,1000,1000,
          1000,1000,1000,1000,1000,10000,10000,10000,10000,10000,10000,10000,10000,
          10000,10000,10000,10000,10000,10000,10000,10000,10000,10000,10000,10000,
          1000,1000,1000,1000,1000,1000,1000,1000,1000,1000,100,100,100,100,100,100,
          100,100,100,100,10,10,10,10,10,10,10,10,10,10};
long      *ptr_larray_init = (long *)larray_init;
 
/* ARM_TRAP */
sr = AEI_INITIALIZER();
Handle_Startup_Msg((long)0x0000000C,
                   _psGP,
                   _psGP,
                   (short *)ptr_aei_startup_msg,
                   (short)sizeof(aei_startup_msg),_sGP);
sr = AEI_GETCRTPID(0x00000002,_psGP,(short *)ppd);
AEI_cc = AEI_LOOKUPPROCESSNAME(0x00000001,(short *)ppd);
if (_status_eq(AEI_cc))
   {
   tpc++;
   memcpy(&ppd[3],(char *)"            ",12);
   }
else
   {
   tfc++;
   memcpy(ppd,(char *)"UNNAMED           ",18);
   }
s.push(0);
err=s.top();
s.pop();
if (err == 0)
   {
   tpc++;
   }
else
   {
   tfc++;
   }
if (q_double == 0)
   {
   tpc++;
   }
else
   {
   tfc++;
   }
if (memcmp(larray_init,garray_init,sizeof(larray_init))  ==  0)
   {
   tpc++;
   }
else
   {
   tfc++;
   }
err = (short)0;
pas = (short)0;
btb = (short)0;
btw = (short)0;
bte = (short)0;
wtb = (short)0;
wtw = (short)0;
wte = (short)0;
etb = (short)0;
etw = (short)0;
ete = (short)0;
sr = AEI_MYTERM(0x00000001,(short *)t_name);
AEI_cc = AEI_OPEN(0x00000003,
                 (short *)t_name,
                 (short *)&t_num,
                 _sGP,
                 _sGP,
                 _sGP,
                 _psGP,
                 _psGP,
                 _sGP,
                 _psGP);
if (_status_eq(AEI_cc))
   {
   tpc++;
   }
else
   {
   tfc++;
   }
rtv = AEI_PROCESS_GETINFO_(0x001001C0,
                          _psGP,
                          _pcGP,
                          _sGP,
                          _psGP,
                          _psGP,
                          _psGP,
                          (char  *)sn,
                          (short)sizeof(t_name),
                          (short *)lpt,
                          _pllGP,
                          _psGP,
                          _psGP,
                          _psGP,
                          _psGP,
                          _pcGP,
                          _sGP,
                          _psGP,
                          _pcGP,
                          _sGP,
                          _psGP,
                          (short *)ept,
                          _psGP,
                          _plGP);
if (rtv == NOT_TRUE)
   {
   tpc++;
   }
else
   {
   tfc++;
   }
rtv = AEI_FILE_OPEN_(0x00000007,
                    (char  *)t_name,
                    (short)lnp,
                    (short *)&t_num,
                    _sGP,
                    _sGP,
                    _sGP,
                    _sGP,
                    _sGP,
                    _sGP,
                    _sGP,
                    _psGP);
if (rtv == NOT_TRUE)
   {
   tpc++;
   }
else
   {
   tfc++;
   }
if (memcmp(array_byte,"BBBBBBBBBBBBBBBBBBBBBBBBBBB",27)  ==  0)
   {
   tpc++;
   }
else
   {
   tfc++;
   }
if (memcmp(array_word,"WwWwWwWwWwWwWwWwWwWwWwWwWw",26)  ==  0)
   {
   tpc++;
   }
else
   {
   tfc++;
   }
bp = (char *)t_b;
memcpy(bp,(char *)"                        AEI   TAL TO C Conversion test ",55);
bp = (char *)((long)bp + (long)(55));
memcpy(&t_b[2],(char *)ppd,10);
AEI_cc = AEI_WRITE(0x00000007,
                  (short)t_num,
                  (short *)t_b,
                  (short)0,
                  _psGP,
                  _lGP);
AEI_cc = AEI_WRITE(0x00000007,
                  (short)t_num,
                  (short *)t_b,
                  (short)((long)bp - (long)t_b),
                  _psGP,
                  _lGP);
AEI_cc = AEI_WRITE(0x00000007,
                  (short)t_num,
                  (short *)t_b,
                  (short)0,
                  _psGP,
                  _lGP);
AEI_cc = AEI_WRITE(0x00000007,
                  (short)t_num,
                  (short *)t_b,
                  (short)0,
                  _psGP,
                  _lGP);
bp = (char *)t_b;
memcpy(t_b,
       (char *)"     INIT     TEST            FAILED       = XXXX      PASSED       = XXXX  ",76);
sr = AEI_NUMOUT(0x0000000F,(char  *)&bp[45],(short)tfc,(short)10,(short)4);
sr = AEI_NUMOUT(0x0000000F,(char  *)&bp[70],(short)tpc,(short)10,(short)4);
AEI_cc = AEI_WRITE(0x00000007,
                  (short)t_num,
                  (short *)t_b,
                  (short)sizeof(t_b),
                  _psGP,
                  _lGP);
AEI_cc = AEI_WRITE(0x00000007,
                  (short)t_num,
                  (short *)t_b,
                  (short)0,
                  _psGP,
                  _lGP);
}
#pragma PAGE  /* Write_Result */
void  Write_Result (void)
{
 
bp = (char *)t_b;
memcpy(t_b,
       (char *)"     SUBPROC  TEST            FAILED       = XXXX      PASSED       = XXXX  ",76);
sr = AEI_NUMOUT(0x0000000F,(char  *)&bp[45],(short)err,(short)10,(short)4);
sr = AEI_NUMOUT(0x0000000F,(char  *)&bp[70],(short)pas,(short)10,(short)4);
AEI_cc = AEI_WRITE(0x00000007,
                  (short)t_num,
                  (short *)t_b,
                  (short)sizeof(t_b),
                  _psGP,
                  _lGP);
}
#pragma PAGE  /* Main */
short Main (void)
{
 
Init();
do
   {
   switch (cnt)
      {
      case 0                         :
         {
         if (Test_Sub((short *)ptr_isw,(short)id,(short *)iid) == NOT_TRUE)
            {
            tpc++;
            }
         else
            {
            tfc++;
            }
         Write_Result();
         break;
         }
      case 1                         :
         {
         if (Test_Move_Indirect() == NOT_TRUE)
            {
            tpc++;
            }
         else
            {
            tfc++;
            }
         break;
         }
      case 2                         :
         {
         if (Test_Scan() == NOT_TRUE)
            {
            tpc++;
            }
         else
            {
            tfc++;
            }
         break;
         }
      case 3                         :
         {
         if (Test_Rscan() == NOT_TRUE)
            {
            tpc++;
            }
         else
            {
            tfc++;
            }
         break;
         }
      case 4                         :
         {
         if (Test_Var((long)0x00000055,
                      (short *)&pas,
                      _sGP,
                      (short *)&err,
                      _sGP,
                      (short)btb,
                      _sGP,(short)btw,_sGP,_sGP,_sGP) == NOT_TRUE)
            {
            tpc++;
            }
         else
            {
            tfc++;
            }
         break;
         }
      case 5                         :
         {
         if (Test_Fixed() == NOT_TRUE)
            {
            tpc++;
            }
         else
            {
            tfc++;
            }
         break;
         }
      default                        :
         {
         cnt = (short)6;
         break;
         }
      }
   Clear_Cnt();
   }
while (cnt++  <  5);
Test_And_Bit();
return(0);
}
void AEI_Main(void)
{
AEI_Init_Declarations();
sr = Main();
}