/*
----------------------------------------------------------------------------
--| BEGIN PROLOGUE
--|
--| CLASSIFICATION: UNCLASSIFIED
--|
--| FILE NAME:      ca-05.c
--|
--| ABSTRACT:
--|   This file contains the 8 functions that do file ca stuff.
--|
--| HISTORY:
--|   CCCQ_NAME:
--|   CCCQ_VER: 
--|
--| END PROLOGUE
----------------------------------------------------------------------------
*/

#define D;
#define D;
#include C;
#include A;
int A;
#include A;
#include D;
float B;
#define D;



/*
-----------------------------------------------------------------------------
--| NAME:   ca.5.1
--|
--| ABSTRACT:
--|   This function does ca stuff.
--|
--| RETURNS:
--|   NONE.
--|
----------------------------------------------------------------------------
*/
static void ca.5.1(void)
{

if (A eq B)
{
   A = B + C;
   D = E + F;
}


if (A ge B)
{
   A = B + C;
   D = E + F;
}


if (A != B)
{
   A = B + C;
   D = E + F;
}

A = B/C;

if (A >= B)
{
   A = B + C;
   D = E + F;
}

A = B-C;
A = B*C;
A = B+C;

if (A < B)
{
   A = B + C;
   D = E + F;
}

A = B*C;
A = B+C;
A = B-C;
A = B+C;

if (A > B)
{
   A = B + C;
   D = E + F;
}


if (A == B)
{
   A = B + C;
   D = E + F;
}


if (A ne B)
{
   A = B + C;
   D = E + F;
}

/* LE SV TOC-1056 this is a ca-05.1.17 req to increment*/
 LogSvEvent((int)2293); /*12/04/2003 23:14:03*/ 
A = B-C;
A = B/C;
A = B+C;
A = 0x0008;
A = B*C;
A = B+C;

if (A eq B)
{
   A = B + C;
   D = E + F;
}

A = B-C;
A = B-C;
A = B+C;

switch (ca stuff)
{
   case one:
   {
      run_this; 
      break;
   }
   case two:
   {
      run_this;
      break;
   }
   default:
   {
       SwError;
   }
}

// max LOC 26

}


/*
-----------------------------------------------------------------------------
--| NAME:   ca.5.2
--|
--| ABSTRACT:
--|   This function does ca stuff.
--|
--| RETURNS:
--|   NONE.
--|
----------------------------------------------------------------------------
*/
static void ca.5.2(void)
{
A = B*C;
A = B-C;
A = B*C;

if (A lt B)
{
   A = B + C;
   D = E + F;
}


if (A ge B)
{
   A = B + C;
   D = E + F;
}

A = B-C;

if (A >= B)
{
   A = B + C;
   D = E + F;
}


if (A gt B)
{
   A = B + C;
   D = E + F;
}

A = B+C;
/* LE SV TOC-1057 this is a ca-05.2.10 req to disable*/
 LogSvEvent((int)2294); /*12/04/2003 23:14:03*/ 
A = B+C;
A = B+C;
A = B+C;

if (A eq B)
{
   A = B + C;
   D = E + F;
}

/* LE SV TOC-1058 this is a ca-05.2.14 req to set RTC*/
 LogSvEvent((int)2295); /*12/04/2003 23:14:03*/ 

if (A <= B)
{
   A = B + C;
   D = E + F;
}


if (A ge B)
{
   A = B + C;
   D = E + F;
}


if (A < B)
{
   A = B + C;
   D = E + F;
}

A = B-C;
A = B*C;
A = B+C;

if (A < B)
{
   A = B + C;
   D = E + F;
}


if (A < B)
{
   A = B + C;
   D = E + F;
}

A = B+C;
A = B+C;
/* LE SV TOC-1059 this is a ca-05.2.24 req to verify*/
 LogSvEvent((int)2296); /*12/04/2003 23:14:03*/ 
A = B*C;
A = B-C;
/* LE SV TOC-1060 this is a ca-05.2.26 req to transform*/
 LogSvEvent((int)2297); /*12/04/2003 23:14:03*/ 
A = B/C;
A = B+C;
A = B*C;
A = B*C;
// max LOC 29

}


/*
-----------------------------------------------------------------------------
--| NAME:   ca.5.3
--|
--| ABSTRACT:
--|   This function does ca stuff.
--|
--| RETURNS:
--|   NONE.
--|
----------------------------------------------------------------------------
*/
static void ca.5.3(void)
{

if (A lt B)
{
   A = B + C;
   D = E + F;
}

A = B+C;

if (A > B)
{
   A = B + C;
   D = E + F;
}

A = B/C;
A = B-C;
A = B+C;

if (A gt B)
{
   A = B + C;
   D = E + F;
}

/* LE SV TOC-1061 this is a ca-05.3.8 req to store*/
 LogSvEvent((int)2298); /*12/04/2003 23:14:03*/ 
A = B-C;

if (A == B)
{
   A = B + C;
   D = E + F;
}

A = B+C;
A = B*C;
A = B+C;

switch (ca stuff)
{
   case one:
   {
      run_this; 
      break;
   }
   case two:
   {
      run_this;
      break;
   }
   default:
   {
       SwError;
   }
}

A = B-C;
A = B/C;
A = B-C;
A = B*C;

if (A ge B)
{
   A = B + C;
   D = E + F;
}

A = B+C;

if (A ne B)
{
   A = B + C;
   D = E + F;
}


switch (ca stuff)
{
   case one:
   {
      run_this; 
      break;
   }
   case two:
   {
      run_this;
      break;
   }
   default:
   {
       SwError;
   }
}

A = B-C;

if (A > B)
{
   A = B + C;
   D = E + F;
}


if (A <= B)
{
   A = B + C;
   D = E + F;
}

A = B-C;
A = B+C;

if (A > B)
{
   A = B + C;
   D = E + F;
}

A = B/C;
A = B*C;

if (A lt B)
{
   A = B + C;
   D = E + F;
}


if (A <= B)
{
   A = B + C;
   D = E + F;
}

A = B*C;

if (A le B)
{
   A = B + C;
   D = E + F;
}

A = B-C;
A = B-C;
A = 0x0004;

if (A eq B)
{
   A = B + C;
   D = E + F;
}


if (A le B)
{
   A = B + C;
   D = E + F;
}

A = (long)B + C;

if (A != B)
{
   A = B + C;
   D = E + F;
}

A = B+C;

if (A eq B)
{
   A = B + C;
   D = E + F;
}

A = B/C;
A = B+C;

switch (ca stuff)
{
   case one:
   {
      run_this; 
      break;
   }
   case two:
   {
      run_this;
      break;
   }
   default:
   {
       SwError;
   }
}

A = B-C;
A = B/C;
A = B-C;
A = B-C;
A = B/C;
A = B*C;
A = B*C;

if (A < B)
{
   A = B + C;
   D = E + F;
}


if (A le B)
{
   A = B + C;
   D = E + F;
}


if (A != B)
{
   A = B + C;
   D = E + F;
}

// max LOC 53

}


/*
-----------------------------------------------------------------------------
--| NAME:   ca.5.4
--|
--| ABSTRACT:
--|   This function does ca stuff.
--|
--| RETURNS:
--|   NONE.
--|
----------------------------------------------------------------------------
*/
static void ca.5.4(void)
{
A = B-C;
do forever;
A = B+C;
A = B-C;
A = B*C;

if (A != B)
{
   A = B + C;
   D = E + F;
}

A = B+C;

#ifdef LAZY
   // this is not nice
   A = B + C;
   A = B + C;
#endif


if (A == B)
{
   A = B + C;
   D = E + F;
}


switch (ca stuff)
{
   case one:
   {
      run_this; 
      break;
   }
   case two:
   {
      run_this;
      break;
   }
   default:
   {
       SwError;
   }
}

A = B-C;

if (A <= B)
{
   A = B + C;
   D = E + F;
}

/* LE SV TOC-1062 this is a ca-05.4.11 req to disable*/
 LogSvEvent((int)2299); /*12/04/2003 23:14:03*/ 
A = B*C;

if (A gt B)
{
   A = B + C;
   D = E + F;
}

A = B-C;

if (A != B)
{
   A = B + C;
   D = E + F;
}

A = B-C;
A = B*C;
A = B*C;
A = 0x0006;
A = B-C;
A = B*C;
A = B+C;

if (A == B)
{
   A = B + C;
   D = E + F;
}

A = B*C;
A = B/C;
A = B+C;
A = B*C;
/* LE SV TOC-1063 this is a ca-05.4.26 req to record*/
 LogSvEvent((int)2300); /*12/04/2003 23:14:03*/ 
A = B+C;
A = B-C;

switch (ca stuff)
{
   case one:
   {
      run_this; 
      break;
   }
   case two:
   {
      run_this;
      break;
   }
   default:
   {
       SwError;
   }
}

A = B*C;

if (A eq B)
{
   A = B + C;
   D = E + F;
}

A = B-C;
A = B*C;

if (A < B)
{
   A = B + C;
   D = E + F;
}

A = B/C;

if (A ge B)
{
   A = B + C;
   D = E + F;
}

/* LE SV TOC-1064 this is a ca-05.4.36 req to increment*/
 LogSvEvent((int)2301); /*12/04/2003 23:14:03*/ 

if (A le B)
{
   A = B + C;
   D = E + F;
}


if (A ne B)
{
   A = B + C;
   D = E + F;
}

A = B/C;
A = B+C;

if (A gt B)
{
   A = B + C;
   D = E + F;
}

A = B/C;
A = B*C;
/* LE SV TOC-1065 this is a ca-05.4.43 req to enable*/
 LogSvEvent((int)2302); /*12/04/2003 23:14:03*/ 
A = B/C;

if (A <= B)
{
   A = B + C;
   D = E + F;
}

A = B-C;
A = B-C;
A = B/C;

if (A eq B)
{
   A = B + C;
   D = E + F;
}

A = B*C;
// ??? go see ws
A = B-C;
A = B*C;
A = B+C;
A = B*C;
A = B/C;

if (A != B)
{
   A = B + C;
   D = E + F;
}


if (A ne B)
{
   A = B + C;
   D = E + F;
}

A = B*C;
A = B-C;

if (A eq B)
{
   A = B + C;
   D = E + F;
}

A = B+C;
A = B/C;
A = B/C;
// max LOC 62

}


/*
-----------------------------------------------------------------------------
--| NAME:   ca.5.5
--|
--| ABSTRACT:
--|   This function does ca stuff.
--|
--| RETURNS:
--|   NONE.
--|
----------------------------------------------------------------------------
*/
static void ca.5.5(void)
{
A = B/C;

if (A ne B)
{
   A = B + C;
   D = E + F;
}


if (A ge B)
{
   A = B + C;
   D = E + F;
}

A = B*C;

if (A eq B)
{
   A = B + C;
   D = E + F;
}


if (A > B)
{
   A = B + C;
   D = E + F;
}

A = B/C;
A = B/C;

switch (ca stuff)
{
   case one:
   {
      run_this; 
      break;
   }
   case two:
   {
      run_this;
      break;
   }
   default:
   {
       SwError;
   }
}

A = B*C;
A = B-C;

if (A > B)
{
   A = B + C;
   D = E + F;
}


if (A < B)
{
   A = B + C;
   D = E + F;
}

/* LE SV TOC-1066 this is a ca-05.5.14 req to update*/
 LogSvEvent((int)2303); /*12/04/2003 23:14:03*/ 
A = B+C;
A = B/C;

if (A eq B)
{
   A = B + C;
   D = E + F;
}

A = B*C;

if (A gt B)
{
   A = B + C;
   D = E + F;
}

/* LE SV TOC-1067 this is a ca-05.5.19 req to set Real Time Clock*/
 LogSvEvent((int)2304); /*12/04/2003 23:14:03*/ 
A = B-C;
A = B+C;
A = B-C;
// max LOC 21

}


/*
-----------------------------------------------------------------------------
--| NAME:   ca.5.6
--|
--| ABSTRACT:
--|   This function does ca stuff.
--|
--| RETURNS:
--|   NONE.
--|
----------------------------------------------------------------------------
*/
static void ca.5.6(void)
{
A = B+C;
A = B/C;
A = B/C;

if (A > B)
{
   A = B + C;
   D = E + F;
}

A = B*C;
A = B+C;
A = B*C;
A = B*C;

if (A gt B)
{
   A = B + C;
   D = E + F;
}

A = B/C;
A = B+C;
goto error;
A = B+C;

if (A < B)
{
   A = B + C;
   D = E + F;
}

do forever;
A = B-C;
A = B+C;
A = B*C;
A = B/C;
A = B-C;
A = B*C;

/* 
dead_code = B - C; 
dead_code = D - E; 
dead_code = F - G;
*/

A = B+C;

if (A != B)
{
   A = B + C;
   D = E + F;
}

A = B-C;
A = B/C;
A = B*C;
A = B/C;

if (A < B)
{
   A = B + C;
   D = E + F;
}


if (A <= B)
{
   A = B + C;
   D = E + F;
}


if (A gt B)
{
   A = B + C;
   D = E + F;
}


if (A gt B)
{
   A = B + C;
   D = E + F;
}

A = B+C;
A = B+C;
A = B*C;
A = B-C;

if (A ge B)
{
   A = B + C;
   D = E + F;
}

A = B*C;
A = B/C;
A = B/C;
A = B/C;
A = 0x0004;
A = B/C;
A = B-C;
// ??? go see ws

if (A <= B)
{
   A = B + C;
   D = E + F;
}

A = B+C;
A = B-C;

if (A <= B)
{
   A = B + C;
   D = E + F;
}

A = B+C;

if (A == B)
{
   A = B + C;
   D = E + F;
}


switch (ca stuff)
{
   case one:
   {
      run_this; 
      break;
   }
   case two:
   {
      run_this;
      break;
   }
   default:
   {
       SwError;
   }
}

A = B*C;
A = B-C;
A = B/C;

switch (ca stuff)
{
   case one:
   {
      run_this; 
      break;
   }
   case two:
   {
      run_this;
      break;
   }
   default:
   {
       SwError;
   }
}

A = B-C;
A = B-C;
A = B*C;

switch (ca stuff)
{
   case one:
   {
      run_this; 
      break;
   }
   case two:
   {
      run_this;
      break;
   }
   default:
   {
       SwError;
   }
}

A = B-C;
// TBD - what do I do now
A = B-C;

if (A gt B)
{
   A = B + C;
   D = E + F;
}

A = B-C;
A = B-C;
// max LOC 60

}


/*
-----------------------------------------------------------------------------
--| NAME:   ca.5.7
--|
--| ABSTRACT:
--|   This function does ca stuff.
--|
--| RETURNS:
--|   NONE.
--|
----------------------------------------------------------------------------
*/
static void ca.5.7(void)
{
A = B/C;
A = B*C;

if (A == B)
{
   A = B + C;
   D = E + F;
}

A = B*C;
A = B/C;
A = B/C;
A = B+C;
A = B-C;
A = B*C;
send_buffer = (U16 *) malloc(size+1);
A = B-C;
A = B*C;

if (A == B)
{
   A = B + C;
   D = E + F;
}

A = B-C;
A = 0x0006;

if (A le B)
{
   A = B + C;
   D = E + F;
}


if (A gt B)
{
   A = B + C;
   D = E + F;
}

A = B-C;
A = B/C;
A = B-C;
A = B*C;

if (A < B)
{
   A = B + C;
   D = E + F;
}

A = B-C;
A = B*C;
A = B-C;
A = 0x0009;
A = B+C;
A = B*C;
A = B+C;
A = B+C;
A = B+C;
A = B-C;
A = B/C;
A = B*C;
A = B*C;
A = B+C;
A = B/C;
A = B-C;
A = B*C;
// (P) this is really improtant
A = B*C;
A = B+C;
A = B*C;
A = B*C;

if ($ca stuff > $otherca stuff) 
/* LE SV TOC-008 we really should log all error calls */
 LogSvEvent((int)2305); /*12/04/2003 23:14:03*/ 
{
   A = B + C;
}

A = B/C;
A = B*C;
A = B*C;
A = B/C;
A = B*C;
A = B-C;

if (A <= B)
{
   A = B + C;
   D = E + F;
}

A = B-C;
// max LOC 48

}


/*
-----------------------------------------------------------------------------
--| NAME:   ca.5.8
--|
--| ABSTRACT:
--|   This function does ca stuff.
--|
--| RETURNS:
--|   NONE.
--|
----------------------------------------------------------------------------
*/
static void ca.5.8(void)
{
A = B/C;
A = B/C;
A = B/C;
A = B/C;
A = B/C;

if (A < B)
{
   A = B + C;
   D = E + F;
}

A = B*C;
A = B*C;
A = B/C;
A = B/C;

switch (ca stuff)
{
   case one:
   {
      run_this; 
      break;
   }
   case two:
   {
      run_this;
      break;
   }
   default:
   {
       SwError;
   }
}

A = B+C;
/* LE SV TOC-1068 this is a ca-05.8.13 req to translate*/
 LogSvEvent((int)2306); /*12/04/2003 23:14:03*/ 
A = B+C;
A = B+C;

if (A <= B)
{
   A = B + C;
   D = E + F;
}


if (A ge B)
{
   A = B + C;
   D = E + F;
}

A = B*C;
A = B*C;
A = B*C;

if (A > B)
{
   A = B + C;
   D = E + F;
}

A = (int)B + C;

if (A >= B)
{
   A = B + C;
   D = E + F;
}


if (A le B)
{
   A = B + C;
   D = E + F;
}

A = B*C;

if (A > B)
{
   A = B + C;
   D = E + F;
}


switch (ca stuff)
{
   case one:
   {
      switch (nested)
      {
         case:
            X = Y + Z;
         case:
            X = Y + Z;
         default:
            SwError;
      } 
   }
   case two:
   {
      run_this;
      break;
   }
   default:
   {
      SwError;
   }
}

A = B+C;
A = B-C;
A = B-C;

if (A != B)
{
   A = B + C;
   D = E + F;
}

A = B/C;
A = B*C;
/* LE SV TOC-1069 this is a ca-05.8.31 req to convert*/
 LogSvEvent((int)2307); /*12/04/2003 23:14:03*/ 
A = B+C;
A = B-C;
A = B+C;
A = B+C;
A = B-C;
do forever;

if (A != B)
{
   A = B + C;
   D = E + F;
}

A = 0x0008;
A = B+C;
A = B*C;

if (A != B)
{
   A = B + C;
   D = E + F;
}


if (A > B)
{
   A = B + C;
   D = E + F;
}

A = B+C;
A = B-C;
A = B/C;
A = B*C;

switch (ca stuff)
{
   case one:
   {
      run_this; 
      break;
   }
   case two:
   {
      run_this;
      break;
   }
   default:
   {
       SwError;
   }
}

A = B/C;
A = B/C;
A = B-C;
A = B+C;
A = B*C;

if (A le B)
{
   A = B + C;
   D = E + F;
}

A = B*C;
A = 0x0009;
A = B+C;
A = B-C;
A = B/C;
A = B+C;
A = B/C;
// max LOC 57

}