#pragma COLUMNS 239
#pragma list
#define      NOT_TRUE   0
#define      AEI_maxj   20
 
#define   EXACT                 2
#define   PREV                  0xe000
#define   NEXT                  0x8000
short                           amt = 0;
short                           err = 0;
short                           f_num = -1;
short                           r_num = -1;
short                           t_num = -1;
short                           f_name[12];
short     *ptr_f_name = (short *)f_name;
short                           r_name[16];
short     *ptr_r_name = (short *)r_name;
short                           t_name[16];
short     *ptr_t_name = (short *)t_name;
short                           error;
short                           done;
short                           pass;
short                           fail;
short                           start;
long                            tag = (long)0;
long                            aw_time = (long)1000;
typedef   struct __tal_rec_def
   {
   short                           tal_code;
   struct                                                                   /* TAL_KEY */
      {
      struct                                                                /* KEY_STRING */
         {
         char                            key_byte;
         struct                                                             /* KEY_ODD */
            {
            char                            byte[5];
            } key_odd;
         struct                                                             /* KEY_EVEN */
            {
            char                            byte[6];
            } key_even;
         struct                                                             /* KEY_A6 */
            {
            char                            byte[6];
            } key_a6;
         } key_string;
      } tal_key;
   struct                                                                   /* TAL_TEST */
      {
      short                           key_int;
      long                            key_i32;
      __int64                         key_fix0;
      __int64                         key_fix2;
      short                           i_int;
      long                            i_i32;
      __int64                         i_fix0;
      __int64                         i_fix2;
      short                           o_int;
      long                            o_i32;
      __int64                         o_fix0;
      __int64                         o_fix2;
      } tal_test;
   struct                                                                   /* TAL_RESULTS */
      {
      struct                                                                /* PASSED */
         {
         char                            byte[20];
         } passed;
      struct                                                                /* FAILED */
         {
         char                            byte[20];
         } failed;
      struct                                                                /* RET_ALPHA */
         {
         char                            byte[40];
         } ret_alpha;
      struct                                                                /* RET_NUMERIC */
         {
         short                           ret_num1;
         short                           ret_num2;
         short                           ret_num3;
         short                           ret_num4;
         short                           ret_num5;
         short                           ret_num6;
         short                           ret_num7;
         } ret_numeric;
      } tal_results;
   } tal_rec_def;
tal_rec_def              tal_rec;
tal_rec_def   *ptr_tal_rec = (tal_rec_def *)&tal_rec;
#pragma fieldalign matched2 __sql_tal_rec_def
typedef   struct __sql_tal_rec_def
   {
   short                           pre_key;
   char                            key_col[18];
   char                            aft_key[160];
   } sql_tal_rec_def;
sql_tal_rec_def   sql_tal_rec;
sql_tal_rec_def   *ptr_sql_tal_rec = (sql_tal_rec_def *)&sql_tal_rec;

 #pragma section AEI_SQL_KEYPOSITION_TALFILE
 short AEI_SQL_KEYPOSITION_TALFILE(char *pa1,short pb1)
 {
 Form1->Timer1->Enabled = false;
 memset(&sql_tal_rec,(char)' ',sizeof(sql_tal_rec));
 memcpy(&sql_tal_rec,pa1,sizeof(sql_tal_rec));
 sqlfirst = true;
 if ((pb1 & 0xE000) == 0xE000)
    sqlmode = PREV;            /*PREV*/
 else if ((pb1 & 0xE000) == 0x8000)
    sqlmode = NEXT;           /*NEXT*/
 else if ((pb1 & 0x0003) == 2)
    sqlmode = EXACT;          /*EXACT*/
 Form1->TALFILEQ->Close();
 Form1->TALFILEQ->SQL->Clear();
 Form1->TALFILEQ->SQL->Add("SELECT * FROM TALFILE");
 if (sqlmode == PREV)
    {
    Form1->TALFILEQ->SQL->Add("WHERE   (KEY_COL <= :sql_tal_rec.key_col)");
    Form1->TALFILEQ->SQL->Add("ORDER BY KEY_COL ASC");
    }
 else if (sqlmode == EXACT)
    {
    Form1->TALFILEQ->SQL->Add("WHERE   (KEY_COL = :sql_tal_rec.key_col)");
    Form1->TALFILEQ->SQL->Add("ORDER BY KEY_COL ASC");
    }
 else if (sqlmode == NEXT)
    {
    Form1->TALFILEQ->SQL->Add("WHERE   (KEY_COL >= :sql_tal_rec.key_col)");
    Form1->TALFILEQ->SQL->Add("ORDER BY KEY_COL ASC");
    }
 Form1->TALFILEQ->Params->Items[0]->AsString   = (char *)sql_tal_rec.key_col;
 Form1->TALFILEQ->Prepare();
 Form1->TALFILEQ->Open();
 sqlcode = CCE;
 Form1->Timer1->Enabled = true;
 return(sqlcode);
 }

 #pragma section AEI_SQL_READ_TALFILE
 short AEI_SQL_READ_TALFILE(char *pa1,short pb1)
 {
 Form1->Timer1->Enabled = false;
 memset(&sql_tal_rec,(char)' ',sizeof(sql_tal_rec));
 memcpy(&sql_tal_rec,pa1,sizeof(sql_tal_rec));
 if (sqlmode == PREV)
    {
    if (sqlfirst)
       {
       sqlfirst=false;
       if (Form1->TALFILEQ->FindLast() )
          sqlcode = CCE;
       else
         sqlcode = SQL_EOF;
       }
     else
       {
       if (Form1->TALFILEQ->FindPrior() )
          sqlcode = CCE;
       else
         sqlcode = SQL_EOF;
       }
    }
 else if (sqlmode == EXACT)
    {
    if (Form1->TALFILEQ->FindFirst() )
       sqlcode = CCE;
    else
      sqlcode = SQL_EOF;
    }
else if (sqlmode == NEXT)
    {
    if (sqlfirst)
       {
       sqlfirst=false;
       if (Form1->TALFILEQ->FindFirst() )
          sqlcode = CCE;
       else
         sqlcode = SQL_EOF;
       }
     else
       {
       if (Form1->TALFILEQ->FindNext() )
          sqlcode = CCE;
       else
         sqlcode = SQL_EOF;
       }
    }
else
   {
   sqlcode = SQL_EOF;
   }
 if (sqlcode == CCE)
    {
    Form1->TALFILEQ->Fields->Fields[0]->GetData((char *)sql_tal_rec.key_col,True);
    Form1->TALFILEQ->Fields->Fields[1]->GetData((char *)gl,True);
    sql_tal_rec.pre_key = (short)gl;
    try
      {
      AEIS = Form1->TALFILEQ->CreateBlobStream(Form1->TALFILEQ->Fields->Fields[2],bmRead);
      AEIS->Read(sql_tal_rec.aft_key,sizeof(sql_tal_rec.aft_key));
      }
    catch (...)
      {
      sqlcode = SQL_EOF;
      throw;
      }
    delete AEIS;
    memcpy((char *)pa1,(char *)&sql_tal_rec,sizeof(sql_tal_rec));
    }
 else
    sqlcode = SQL_EOF;
 Form1->Timer1->Enabled = true;
 return(sqlcode);
 }

 #pragma section AEI_SQL_WRITE_TALFILE
 short AEI_SQL_WRITE_TALFILE(char *pa1,short pb1)
 {
 Form1->Timer1->Enabled = false;
 memset(&sql_tal_rec,(char)' ',sizeof(sql_tal_rec));
 memcpy(&sql_tal_rec,pa1,sizeof(sql_tal_rec));
 Form1->TALFILEQ->Close();
 Form1->TALFILEQ->SQL->Clear();
 Form1->TALFILEQ->SQL->Add("SELECT * FROM TALFILE");
 Form1->TALFILEQ->SQL->Add("WHERE   (KEY_COL = :sql_tal_rec.key_col)");
 Form1->TALFILEQ->SQL->Add("ORDER BY KEY_COL ASC");
 Form1->TALFILEQ->Params->Items[0]->AsString   = (char *)sql_tal_rec.key_col;
 Form1->TALFILEQ->Prepare();
 Form1->TALFILEQ->Open();
 if (Form1->TALFILEQ->IsEmpty() )
    {
    Form1->TALFILEQ->Close();
    Form1->TALFILEQ->SQL->Clear();
    Form1->TALFILEQ->SQL->Add("INSERT  INTO TALFILE");
    Form1->TALFILEQ->SQL->Add("       (KEY_COL,PRE_KEY,AFT_KEY)");
    Form1->TALFILEQ->SQL->Add("VALUES (:sql_tal_rec.key_col,");
    Form1->TALFILEQ->SQL->Add("        :sql_tal_rec.pre_key,");
    Form1->TALFILEQ->SQL->Add("        :sql_tal_rec.aft_key)");
    Form1->TALFILEQ->Params->Items[0]->AsString   = (char *)sql_tal_rec.key_col;
    Form1->TALFILEQ->Params->Items[1]->AsSmallInt = (short )sql_tal_rec.pre_key;
    Form1->TALFILEQ->Params->Items[2]->SetBlobData(sql_tal_rec.aft_key,sizeof(sql_tal_rec.aft_key));
    Form1->TALFILEQ->ExecSQL();
    sqlcode = CCE;
    }
 else
    sqlcode = SQL_EOF;
 Form1->Timer1->Enabled = true;
 return(sqlcode);
 }

 #pragma section AEI_SQL_UPDATE_TALFILE
 short AEI_SQL_UPDATE_TALFILE(char *pa1,short pb1)
 {
 Form1->Timer1->Enabled = false;
 memset(&sql_tal_rec,(char)' ',sizeof(sql_tal_rec));
 memcpy(&sql_tal_rec,pa1,sizeof(sql_tal_rec));
 Form1->TALFILEQ->Close();
 Form1->TALFILEQ->SQL->Clear();
 Form1->TALFILEQ->SQL->Add("SELECT * FROM TALFILE");
 Form1->TALFILEQ->SQL->Add("WHERE   (KEY_COL = :sql_tal_rec.key_col)");
 Form1->TALFILEQ->SQL->Add("ORDER BY KEY_COL ASC");
 Form1->TALFILEQ->Params->Items[0]->AsString   = (char *)sql_tal_rec.key_col;
 Form1->TALFILEQ->Prepare();
 Form1->TALFILEQ->Open();
 if (Form1->TALFILEQ->IsEmpty() )
    sqlcode = SQL_EOF;
 else
    {
    Form1->TALFILEQ->Close();
    Form1->TALFILEQ->SQL->Clear();
    Form1->TALFILEQ->SQL->Add("UPDATE    TALFILE");
    Form1->TALFILEQ->SQL->Add("  SET     KEY_COL = :sql_tal_rec.key_col,");
    Form1->TALFILEQ->SQL->Add("          PRE_KEY = :sql_tal_rec.pre_key,");
    Form1->TALFILEQ->SQL->Add("          AFT_KEY = :sql_tal_rec.aft_key ");
    Form1->TALFILEQ->SQL->Add("  WHERE  (KEY_COL = :sql_tal_rec.key_col)");
    Form1->TALFILEQ->Params->Items[0]->AsString   = (char *)sql_tal_rec.key_col;
    Form1->TALFILEQ->Params->Items[1]->AsSmallInt = (short )sql_tal_rec.pre_key;
    Form1->TALFILEQ->Params->Items[2]->SetBlobData(sql_tal_rec.aft_key,sizeof(sql_tal_rec.aft_key));
    Form1->TALFILEQ->ExecSQL();
    sqlcode = CCE;
    }
 Form1->Timer1->Enabled = true;
 return(sqlcode);
 }

 #pragma section AEI_SQL_DELETE_TALFILE
 short AEI_SQL_DELETE_TALFILE(char *pa1,short pb1)
 {
 char   key_col[100];

 Form1->Timer1->Enabled = false;
 memset(&sql_tal_rec,(char)' ',sizeof(sql_tal_rec));
 memcpy(&sql_tal_rec,pa1,sizeof(sql_tal_rec));
 memcpy(key_col,sql_tal_rec.key_col,sizeof(sql_tal_rec.key_col));
 Form1->TALFILEQ->Close();
 Form1->TALFILEQ->SQL->Clear();
 Form1->TALFILEQ->SQL->Add("DELETE   FROM TALFILE");
 Form1->TALFILEQ->SQL->Add("WHERE    KEY_COL = :key_col");
 Form1->TALFILEQ->ParamByName("KEY_COL")->AsString   = (char *)sql_tal_rec.key_col;
 Form1->TALFILEQ->ExecSQL();
 sqlcode = CCE;
 Form1->Timer1->Enabled = true;
 return(sqlcode);
 }

 #pragma section AEI_SQL_OPEN_TALFILE
 short AEI_SQL_OPEN_TALFILE(void)
 {
 Form1->TALFILET->Active=true;
 return(CCE);
 }

 #pragma section AEI_SQL_CLOSE_TALFILE
 short AEI_SQL_CLOSE_TALFILE(void)
 {
 Form1->TALFILET->Close();
 Form1->TALFILE->Close();
 return(CCE);
 }

void AEI_Init_Declarations(void)
{
memcpy(ptr_f_name,"$DATA11 RLACSD  TALFILE ",24);
memcpy(ptr_r_name,"$RECEIVE                        ",32);
memcpy(&ptr_r_name[32],"$RECEIVE                        ",1);
memcpy(ptr_t_name,"                                ",32);
}
void  Rcv_In_Error (void);
 
void  Rcv_Out_Error (void);
 
void  Key_File_Error (void);
 
void  Start_2001 (void);
 
void  Start_Next_2002 (void);
 
void  Start_Prev_2003 (void);
 
#pragma PAGE  /* Rcv_In_Error */
void  Rcv_In_Error (void)
{
 
memcpy(&ptr_tal_rec->tal_results.ret_alpha,
       (char *)"RCV-IN ERROR                            ",40);
}
#pragma PAGE  /* Rcv_Out_Error */
void  Rcv_Out_Error (void)
{
 
memcpy(&ptr_tal_rec->tal_results.ret_alpha,
       (char *)"RCV-OUT ERROR                           ",40);
}
#pragma PAGE  /* Key_File_Error */
void  Key_File_Error (void)
{
 
memcpy(&ptr_tal_rec->tal_results.ret_alpha,
       (char *)"KEY-FILE ERROR                          ",40);
}
#pragma PAGE  /* Start_2001 */
void  Start_2001 (void)
{
 
sqlmode = 2;
AEI_cc = AEI_SQL_KEYPOSITION_TALFILE((char  *)ptr_tal_rec,(short)sqlmode);
if (_status_ne(AEI_cc))
   {
   fail++;
   }
else
   {
   pass++;
   start = (short)1;
   }
}
#pragma PAGE  /* Start_Next_2002 */
void  Start_Next_2002 (void)
{
 
sqlmode = 0x8000;
AEI_cc = AEI_SQL_KEYPOSITION_TALFILE((char  *)ptr_tal_rec,(short)sqlmode);
if (_status_ne(AEI_cc))
   {
   fail++;
   }
else
   {
   pass++;
   start = (short)2;
   }
}
#pragma PAGE  /* Start_Prev_2003 */
void  Start_Prev_2003 (void)
{
 
sqlmode = 0xe000;
AEI_cc = AEI_SQL_KEYPOSITION_TALFILE((char  *)ptr_tal_rec,(short)sqlmode);
if (_status_ne(AEI_cc))
   {
   fail++;
   }
else
   {
   pass++;
   start = (short)3;
   }
}
#pragma PAGE  /* Read_2004 */
void  Read_2004 (void)
{
 
if (start == 1)
   {
   AEI_cc = AEI_SQL_READ_TALFILE((char  *)ptr_tal_rec,
                        (short)sizeof(tal_rec));
   if (_status_ne(AEI_cc))
      {
      fail++;
      }
   else
      {
      pass++;
      }
   }
else
   {
   fail++;
   }
}
#pragma PAGE  /* Read_Next_2005 */
void  Read_Next_2005 (void)
{
 
if (start == 2)
   {
   AEI_cc = AEI_SQL_READ_TALFILE((char  *)ptr_tal_rec,
                        (short)sizeof(tal_rec));
   if (_status_ne(AEI_cc))
      {
      fail++;
      }
   else
      {
      pass++;
      }
   }
else
   {
   fail++;
   }
}
#pragma PAGE  /* Read_Prev_2006 */
void  Read_Prev_2006 (void)
{
 
if (start == 3)
   {
   AEI_cc = AEI_SQL_READ_TALFILE((char  *)ptr_tal_rec,
                        (short)sizeof(tal_rec));
   if (_status_ne(AEI_cc))
      {
      fail++;
      }
   else
      {
      pass++;
      }
   }
else
   {
   fail++;
   }
}
#pragma PAGE  /* Write_2007 */
void  Write_2007 (void)
{
 
start = (short)0;
AEI_cc = AEI_SQL_WRITE_TALFILE((char  *)ptr_tal_rec,
                      (short)sizeof(tal_rec));
if (_status_ne(AEI_cc))
   {
   fail++;
   }
else
   {
   pass++;
   }
}
#pragma PAGE  /* Update_2008 */
void  Update_2008 (void)
{
 
start = (short)0;
AEI_cc = AEI_SQL_UPDATE_TALFILE((char  *)ptr_tal_rec,
          (short)sizeof(tal_rec));
if (_status_ne(AEI_cc))
   {
   fail++;
   }
else
   {
   pass++;
   }
}
#pragma PAGE  /* Del_2009 */
void  Del_2009 (void)
{
 
start = (short)0;
AEI_cc = AEI_SQL_DELETE_TALFILE((char  *)ptr_tal_rec,
          (short)sizeof(tal_rec));
if (_status_ne(AEI_cc))
   {
   fail++;
   }
else
   {
   pass++;
   }
}
#pragma PAGE  /* Math_Test_3000 */
void  Math_Test_3000 (void)
{
 
if (ptr_tal_rec->tal_code == 31)
   {
   ptr_tal_rec->tal_test.o_int = 
   (short)(ptr_tal_rec->tal_test.key_int + ptr_tal_rec->tal_test.i_int);
   ptr_tal_rec->tal_test.o_i32 = 
   ((long)ptr_tal_rec->tal_test.key_i32 + (long)ptr_tal_rec->tal_test.i_i32);
   ptr_tal_rec->tal_test.o_fix0 = 
   (ptr_tal_rec->tal_test.key_fix0 + ptr_tal_rec->tal_test.i_fix0);
   ptr_tal_rec->tal_test.o_fix2 = 
   (ptr_tal_rec->tal_test.key_fix2 + ptr_tal_rec->tal_test.i_fix2);
   }
else if (ptr_tal_rec->tal_code == 32)
   {
   ptr_tal_rec->tal_test.o_int = 
   (short)(ptr_tal_rec->tal_test.key_int - ptr_tal_rec->tal_test.i_int);
   ptr_tal_rec->tal_test.o_i32 = 
   ((long)ptr_tal_rec->tal_test.key_i32 - (long)ptr_tal_rec->tal_test.i_i32);
   ptr_tal_rec->tal_test.o_fix0 = 
   (ptr_tal_rec->tal_test.key_fix0 - ptr_tal_rec->tal_test.i_fix0);
   ptr_tal_rec->tal_test.o_fix2 = 
   (ptr_tal_rec->tal_test.key_fix2 - ptr_tal_rec->tal_test.i_fix2);
   }
else if (ptr_tal_rec->tal_code == 33)
   {
   ptr_tal_rec->tal_test.o_int = 
   (short)(ptr_tal_rec->tal_test.key_int * ptr_tal_rec->tal_test.i_int);
   ptr_tal_rec->tal_test.o_i32 = 
   ((long)ptr_tal_rec->tal_test.key_i32 * (long)ptr_tal_rec->tal_test.i_i32);
   ptr_tal_rec->tal_test.o_fix0 = 
   (ptr_tal_rec->tal_test.key_fix0 * ptr_tal_rec->tal_test.i_fix0);
   ptr_tal_rec->tal_test.o_fix2 = 
   ((__int64)(ptr_tal_rec->tal_test.key_fix2 * ptr_tal_rec->tal_test.i_fix2) / 100);
   }
else if (ptr_tal_rec->tal_code == 34)
   {
   ptr_tal_rec->tal_test.o_int = 
   (short)(ptr_tal_rec->tal_test.key_int / ptr_tal_rec->tal_test.i_int);
   ptr_tal_rec->tal_test.o_i32 = 
   ((long)ptr_tal_rec->tal_test.key_i32 / (long)ptr_tal_rec->tal_test.i_i32);
   ptr_tal_rec->tal_test.o_fix0 = 
   (ptr_tal_rec->tal_test.key_fix0 / ptr_tal_rec->tal_test.i_fix0);
   ptr_tal_rec->tal_test.o_fix2 = 
   ((__int64)(ptr_tal_rec->tal_test.key_fix2 / ptr_tal_rec->tal_test.i_fix2) * 100);
   }
pass++;
}
#pragma PAGE  /* Nsk_Test_6000 */
void  Nsk_Test_6000 (void)
{
 
sr = AEI_MYTERM(0x00000001,(short *)ptr_t_name);
memcpy(&ptr_tal_rec->tal_results.ret_alpha,(char *)"MYTERM = ",9);
byte_ptr = (char *)((long)&ptr_tal_rec->tal_results.ret_alpha + (long)9);
memcpy(byte_ptr,(char *)ptr_t_name,14);
sr = AEI_TIME((short *)&ptr_tal_rec->tal_results.ret_numeric.ret_num1);
pass++;
}
#pragma PAGE  /* Process_2000 */
void  Process_2000 (void)
{
 
memset(ptr_tal_rec,(char)' ',sizeof(tal_rec_def));
ptr_tal_rec->tal_code = (short)0;
pass = (short)0;
fail = (short)0;
do
   {
   err = (short)0;
   AEI_cc = AEI_READUPDATE(0x00000007,
                          (short)r_num,
                          (char  *)ptr_tal_rec,
                          (short)sizeof(tal_rec),
                          _psGP,
                          _lGP);
   if (_status_ne(AEI_cc))
      {
      sr = AEI_FILEINFO(0x00000003,
                       (short)-1,
                       (short *)&err,
                       _psGP,
                       _psGP,
                       _psGP,
                       _psGP,
                       _plGP,
                       _plGP,
                       _psGP,
                       _psGP,
                       _psGP,
                       _plGP,
                       _psGP,
                       _psGP,
                       _psGP,
                       _pcGP,
                       _psGP,
                       _plGP,
                       _psGP,
                       _psGP,
                       _psGP,
                       _psGP,
                       _psGP,
                       _psGP,
                       _psGP,
                       _psGP);
      sr = AEI_ABEND(0x00000000,
                    _psGP,
                    _sGP,
                    _psGP,
                    _sGP,
                    _sGP,
                    _psGP,
                    _sGP,
                    _pcGP);
      }
   else
      {
      AEI_cc = AEI_AWAITIO((short *)&r_num,
                          _psGP,
                          (short *)&amt,
                          (long  *)&tag,
                          (long)aw_time);
      if (_status_ne(AEI_cc))
         {
         sr = AEI_FILEINFO(0x00000003,
                          (short)-1,
                          (short *)&err,
                          _psGP,
                          _psGP,
                          _psGP,
                          _psGP,
                          _plGP,
                          _plGP,
                          _psGP,
                          _psGP,
                          _psGP,
                          _plGP,
                          _psGP,
                          _psGP,
                          _psGP,
                          _pcGP,
                          _psGP,
                          _plGP,
                          _psGP,
                          _psGP,
                          _psGP,
                          _psGP,
                          _psGP,
                          _psGP,
                          _psGP,
                          _psGP);
         if (err != 40)
            {
            AEI_cc = AEI_WRITE(0x00000007,
                              (short)t_num,
                              (short *)"TIMEOUT RECEIVE",
                              (short)15,
                              _psGP,
                              _lGP);
            }
         }
      }
   }
while (err  !=  0);
if (ptr_tal_rec->tal_code == 1)
   {
   Start_2001();
   }
else if (ptr_tal_rec->tal_code == 2)
   {
   Start_Next_2002();
   }
else if (ptr_tal_rec->tal_code == 3)
   {
   Start_Prev_2003();
   }
else if (ptr_tal_rec->tal_code == 4)
   {
   Read_2004();
   }
else if (ptr_tal_rec->tal_code == 5)
   {
   Read_Next_2005();
   }
else if (ptr_tal_rec->tal_code == 6)
   {
   Read_Prev_2006();
   }
else if (ptr_tal_rec->tal_code == 7)
   {
   Write_2007();
   }
else if (ptr_tal_rec->tal_code == 8)
   {
   Update_2008();
   }
else if (ptr_tal_rec->tal_code == 9)
   {
   Del_2009();
   }
else if ((ptr_tal_rec->tal_code > 30) &&
         (ptr_tal_rec->tal_code < 40))
   {
   Math_Test_3000();
   }
else if (ptr_tal_rec->tal_code == 50)
   {
   Nsk_Test_6000();
   }
else if (ptr_tal_rec->tal_code == 99)
   {
   done = (short)1;
   }
memcpy(&ptr_tal_rec->tal_results.passed,(char *)"SUCCESS = XXX       ",20);
sr = AEI_NUMOUT(0x0000000F,
               (char  *)&ptr_tal_rec->tal_results.passed.byte[(11 - 1)],
               (short)pass,
               (short)10,
               (short)3);
memcpy(&ptr_tal_rec->tal_results.failed,(char *)"ERRORS  = XXX       ",20);
sr = AEI_NUMOUT(0x0000000F,
               (char  *)&ptr_tal_rec->tal_results.failed.byte[(11 - 1)],
               (short)fail,
               (short)10,
               (short)3);
AEI_cc = AEI_REPLY(0x00000007,
                  (short *)ptr_tal_rec,
                  (short)sizeof(tal_rec),
                  (short *)&err,
                  _sGP,
                  _sGP);
}
#pragma PAGE  /* Main */
short Main (void)
{
 
sr = AEI_INITIALIZER();
AEI_cc = AEI_SQL_OPEN_TALFILE();
if (_status_ne(AEI_cc))
   {
   sr = AEI_FILEINFO(0x00000007,
                    (short)-1,
                    (short *)&err,
                    (short *)ptr_f_name,
                    _psGP,
                    _psGP,
                    _psGP,
                    _plGP,
                    _plGP,
                    _psGP,
                    _psGP,
                    _psGP,
                    _plGP,
                    _psGP,
                    _psGP,
                    _psGP,
                    _pcGP,
                    _psGP,
                    _plGP,
                    _psGP,
                    _psGP,
                    _psGP,
                    _psGP,
                    _psGP,
                    _psGP,
                    _psGP,
                    _psGP);
   }
AEI_cc = AEI_OPEN(0x0000000F,
                 (short *)ptr_r_name,
                 (short *)&r_num,
                 (short)1,
                 (short)1,
                 _sGP,
                 _psGP,
                 _psGP,
                 _sGP,
                 _psGP);
if (_status_ne(AEI_cc))
   {
   sr = AEI_FILEINFO(0x00000007,
                    (short)-1,
                    (short *)&err,
                    (short *)ptr_r_name,
                    _psGP,
                    _psGP,
                    _psGP,
                    _plGP,
                    _plGP,
                    _psGP,
                    _psGP,
                    _psGP,
                    _plGP,
                    _psGP,
                    _psGP,
                    _psGP,
                    _pcGP,
                    _psGP,
                    _plGP,
                    _psGP,
                    _psGP,
                    _psGP,
                    _psGP,
                    _psGP,
                    _psGP,
                    _psGP,
                    _psGP);
   }
sr = AEI_MYTERM(0x00000001,(short *)ptr_t_name);
AEI_cc = AEI_OPEN(0x00000003,
                 (short *)ptr_t_name,
                 (short *)&t_num,
                 _sGP,
                 _sGP,
                 _sGP,
                 _psGP,
                 _psGP,
                 _sGP,
                 _psGP);
done = (short)0;
error = (short)0;
while ((done  !=  1) &&
       (error  !=  1))
   {
   Process_2000();
   }
return(0);
}