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

#include B;



/*
-----------------------------------------------------------------------------
--| NAME:   dlp.4.1
--|
--| ABSTRACT:
--|   This function does dlp stuff.
--|
--| RETURNS:
--|   NONE.
--|
----------------------------------------------------------------------------
*/
static void dlp.4.1(void)
{
/* LE SV TOC-1237 this is a dlp-04.1.1 req to recover*/
 LogSvEvent((int)1213); /*12/01/2003 16:20:36*/ 

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

A = 0x0009;
A = B+C;

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

A = B*C;
A = B-C;
A = B-C;
/* LE SV TOC-1238 this is a dlp-04.1.7 req to halt*/
 LogSvEvent((int)1214); /*12/01/2003 16:20:36*/ 
A = B/C;
A = B+C;
A = B-C;
A = B+C;
A = B/C;

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

// max LOC 12

}


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

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 gt B)
{
   A = B + C;
   D = E + F;
}

/* LE SV TOC-1239 this is a dlp-04.2.7 req to recover*/
 LogSvEvent((int)1215); /*12/01/2003 16:20:36*/ 
A = B/C;
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;
}

A = B*C;
A = B+C;
A = B-C;
A = 0x0007;
FreePtr = HmiStringPtr;
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;
A = B*C;

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


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


if (A eq 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;
A = B*C;
A = B/C;
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;
}

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;

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

A = B+C;
A = B*C;
A = B*C;
/* LE SV TOC-1240 this is a dlp-04.2.57 req to transform*/
 LogSvEvent((int)1216); /*12/01/2003 16:20:36*/ 

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

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

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

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

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

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

}


/*
-----------------------------------------------------------------------------
--| NAME:   dlp.4.3
--|
--| ABSTRACT:
--|   This function does dlp stuff.
--|
--| RETURNS:
--|   NONE.
--|
----------------------------------------------------------------------------
*/
static void dlp.4.3(void)
{
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;

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

A = B*C;
A = (int)B + C;

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


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

A = B+C;
/* LE SV TOC-1241 this is a dlp-04.3.15 req to halt*/
 LogSvEvent((int)1217); /*12/01/2003 16:20:36*/ 
A = B*C;
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;

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

A = B/C;

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

A = B*C;

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


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

goto error;
A = B-C;
A = B/C;
A = B*C;
/* LE SV TOC-1242 this is a dlp-04.3.29 req to translate*/
 LogSvEvent((int)1218); /*12/01/2003 16:20:36*/ 
A = B*C;

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

A = B+C;
A = B*C;
// max LOC 32

}


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

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

A = B+C;
A = 0x0007;

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;

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

A = B-C;
// max LOC 13

}


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

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

A = B*C;

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

A = B*C;
A = B/C;
A = B*C;
// TBS - I need to figure this out
A = B/C;

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


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

A = B+C;
A = 0x0001;
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 le B)
{
   A = B + C;
   D = E + F;
}

/* LE SV TOC-1243 this is a dlp-04.5.20 req to assign*/
 LogSvEvent((int)1219); /*12/01/2003 16:20:36*/ 
A = B-C;
A = B/C;
A = B*C;
A = B-C;

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


switch (dlp 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;

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

/* LE SV TOC-1244 this is a dlp-04.5.28 req to translate*/
 LogSvEvent((int)1220); /*12/01/2003 16:20:36*/ 
A = B+C;
A = B/C;
A = B-C;
A = B+C;
A = B+C;
A = B/C;
A = B*C;
A = B*C;

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


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


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


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

// max LOC 39

}


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

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


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

/* LE SV TOC-1245 this is a dlp-04.6.4 req to call admin*/
 LogSvEvent((int)1221); /*12/01/2003 16:20:36*/ 
A = B-C;

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

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 = 0x0007;
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;
/* LE SV TOC-1246 this is a dlp-04.6.15 req to store*/
 LogSvEvent((int)1222); /*12/01/2003 16:20:36*/ 
A = B/C;
/* LE SV TOC-1247 this is a dlp-04.6.16 req to recover*/
 LogSvEvent((int)1223); /*12/01/2003 16:20:36*/ 

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

A = B*C;
/* LE SV TOC-1248 this is a dlp-04.6.18 req to reject*/
 LogSvEvent((int)1224); /*12/01/2003 16:20:36*/ 
A = B*C;

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

/* LE SV TOC-1249 this is a dlp-04.6.20 req to verify*/
 LogSvEvent((int)1225); /*12/01/2003 16:20:36*/ 
A = B*C;

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

A = B+C;

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

A = B-C;
A = B*C;
do forever;
A = B+C;
A = B*C;
A = (float)B + C;
A = B+C;
A = B+C;
free(FreePtr);
A = B*C;
A = B*C;
A = B+C;
A = B-C;
A = B*C;

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


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


if (A ge 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 gt B)
{
   A = B + C;
   D = E + F;
}


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

A = B*C;
A = B-C;
A = B+C;
A = B+C;
/* LE SV TOC-1250 this is a dlp-04.6.48 req to inhibit*/
 LogSvEvent((int)1226); /*12/01/2003 16:20:36*/ 

if (A < 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;

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


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

A = B+C;

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

A = B+C;
A = 0x0004;
A = B-C;
A = B*C;
// max LOC 59

}


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

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

/* LE SV TOC-1251 this is a dlp-04.7.2 req to set Real Time Clock*/
 LogSvEvent((int)1227); /*12/01/2003 16:20:36*/ 

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

A = B*C;
A = (float)B + C;
A = B/C;

/*
dead_block = C * D; 
dead_block = E * F;
*/

A = B/C;

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


switch (dlp 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;

/* dead_block = C * D; 
dead_block = E * F; */


if (A ne 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;
A = B-C;
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 = B*C;
A = B*C;
A = B-C;

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

do forever;
A = B+C;

if {
   X = Y + Z;
}
else {
   halt;
}

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;
A = B+C;
A = B+C;
A = B+C;
/* LE SV TOC-1252 this is a dlp-04.7.43 req to check pSOS*/
 LogSvEvent((int)1228); /*12/01/2003 16:20:36*/ 

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


switch (dlp stuff)
{
   case:
   case:
   // stacked case statements but only if there is a new line in between

   case:
   case:
   case:
   {
      run_this;
      break;
   }
   default:
   {
      halt;
   }
}

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;

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


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

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 = B*C;

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

/* LE SV TOC-1253 this is a dlp-04.7.62 req to process*/
 LogSvEvent((int)1229); /*12/01/2003 16:20:36*/ 
A = B-C;
A = B-C;
A = B/C;

switch (dlp 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 ge B)
{
   A = B + C;
   D = E + F;
}

A = B/C;

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

A = B/C;
// max LOC 74

}


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

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

A = B-C;

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

A = B/C;

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

A = B/C;
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;

switch (dlp stuff)
{
   case:
   case:
   // stacked case statements but only if there is a new line in between

   case:
   case:
   case:
   {
      run_this;
      break;
   }
   default:
   {
      halt;
   }
}

A = B*C;

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

A = B*C;
// max LOC 20

}


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

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

A = B+C;
/* LE SV TOC-1254 this is a dlp-04.9.4 req to process*/
 LogSvEvent((int)1230); /*12/01/2003 16:20:36*/ 
rcv_buffer = (U16 *) alloc(size+1);

if (A ge 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;
A = B*C;

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

A = B+C;
A = B*C;
// max LOC 14

}


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

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

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

switch (dlp 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;
}

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

if (A lt 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;
A = B-C;
A = B*C;
goto error;

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

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

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

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

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


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


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

/* LE SV TOC-1255 this is a dlp-04.10.42 req to enable*/
 LogSvEvent((int)1231); /*12/01/2003 16:20:36*/ 

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

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;

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;
}

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

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

A = B/C;

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

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

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

A = B+C;
/* LE SV TOC-1256 this is a dlp-04.10.62 req to validate*/
 LogSvEvent((int)1232); /*12/01/2003 16:20:36*/ 
A = B+C;
A = B-C;
// max LOC 63

}


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

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


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

A = B-C;
// (P) this is really improtant
A = B-C;
A = 0x0001;
A = B-C;

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

/* LE SV TOC-1257 this is a dlp-04.11.8 req to halt*/
 LogSvEvent((int)1233); /*12/01/2003 16:20:36*/ 
A = B*C;

if ($dlp stuff > $otherdlp stuff) 
/* LE SV TOC-008 we really should log all error calls */
 LogSvEvent((int)1234); /*12/01/2003 16:20:36*/ 
{
   A = B + C;
}

A = B*C;

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

A = B/C;

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


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

A = B+C;
A = B/C;
A = B/C;
A = B*C;
/* LE SV TOC-1258 this is a dlp-04.11.18 req to check unix*/
 LogSvEvent((int)1235); /*12/01/2003 16:20:36*/ 
A = B/C;

if (A ne 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;
A = B+C;
A = B+C;
A = B/C;
/* LE SV TOC-1259 this is a dlp-04.11.30 req to reject*/
 LogSvEvent((int)1236); /*12/01/2003 16:20:36*/ 
A = B-C;

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


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

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;
}


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


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


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


switch (dlp stuff)
{
   case one:
   {
      run_this;
      break;
   }
   case two:
   {
      run_this;
      break;
   }
   // missing default
}

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;
}

send_buffer = (U16 *) malloc(size+1);
A = B+C;
// max LOC 47

}