/*
----------------------------------------------------------------------------
--| BEGIN PROLOGUE
--|
--| CLASSIFICATION: UNCLASSIFIED
--|
--| FILE NAME: pwr-01.c
--|
--| ABSTRACT:
--| This file contains the 13 functions that do file pwr stuff.
--|
--| HISTORY:
--| CCCQ_NAME:
--| CCCQ_VER:
--|
--| END PROLOGUE
----------------------------------------------------------------------------
*/
char D;
#include C;
char D;
#define C;
#define A;
/*
-----------------------------------------------------------------------------
--| NAME: pwr.1.1
--|
--| ABSTRACT:
--| This function does pwr stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void pwr.1.1(void)
{
A = B*C;
A = B/C;
if (A < B)
{
A = B + C;
D = E + F;
}
A = 0x0009;
if (A > B)
{
A = B + C;
D = E + F;
}
if (A < B)
{
A = B + C;
D = E + F;
}
A = B-C;
A = B-C;
// max LOC 7
}
/*
-----------------------------------------------------------------------------
--| NAME: pwr.1.2
--|
--| ABSTRACT:
--| This function does pwr stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void pwr.1.2(void)
{
if (A != B)
{
A = B + C;
D = E + F;
}
A = B/C;
if (A gt 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;
}
A = B-C;
if (A eq B)
{
A = B + C;
D = E + F;
}
A = B*C;
A = B-C;
// (P) this is really improtant
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;
/* LE SV TOC-2401 this is a pwr-01.2.19 req to disable*/
LogSvEvent((int)1726); /*12/01/2003 17:21:26*/
A = B/C;
A = B+C;
A = B/C;
A = B*C;
A = B*C;
A = B/C;
/* LE SV TOC-2402 this is a pwr-01.2.25 req to update*/
LogSvEvent((int)1727); /*12/01/2003 17:21:26*/
A = B-C;
if (A lt B)
{
A = B + C;
D = E + F;
}
A = B*C;
if (A ge B)
{
A = B + C;
D = E + F;
}
switch (pwr stuff)
{
case one:
{
run_this;
break;
}
case two:
{
run_this;
break;
}
default:
{
SwError;
}
}
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;
if (A < B)
{
A = B + C;
D = E + F;
}
if (A lt B)
{
A = B + C;
D = E + F;
}
/* LE SV TOC-2403 this is a pwr-01.2.39 req to call admin*/
LogSvEvent((int)1728); /*12/01/2003 17:21:26*/
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;
#ifdef LAZY
// this is not nice
A = B + C;
A = B + C;
#endif
if (A <= B)
{
A = B + C;
D = E + F;
}
/* LE SV TOC-2404 this is a pwr-01.2.47 req to validate*/
LogSvEvent((int)1729); /*12/01/2003 17:21:26*/
if (A le 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 ne 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 = B+C;
if (A eq B)
{
A = B + C;
D = E + F;
}
A = B+C;
switch (pwr stuff)
{
case one:
{
run_this;
break;
}
case two:
{
run_this;
break;
}
default:
{
SwError;
}
}
FreePtr = HmiStringPtr;
A = B*C;
A = B-C;
// max LOC 62
}
/*
-----------------------------------------------------------------------------
--| NAME: pwr.1.3
--|
--| ABSTRACT:
--| This function does pwr stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void pwr.1.3(void)
{
if (A le B)
{
A = B + C;
D = E + F;
}
A = B+C;
A = B/C;
rcv_buffer = (U16 *) alloc(size+1);
A = B*C;
A = B*C;
if (A <= B)
{
A = B + C;
D = E + F;
}
A = B-C;
A = B/C;
A = B+C;
/* LE SV TOC-2405 this is a pwr-01.3.10 req to transform*/
LogSvEvent((int)1730); /*12/01/2003 17:21:26*/
A = B*C;
if (A lt 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;
}
A = B/C;
A = B/C;
switch (pwr stuff)
{
case one:
{
run_this;
break;
}
case two:
{
run_this;
break;
}
default:
{
SwError;
}
}
A = B*C;
A = B-C;
A = B/C;
// max LOC 19
}
/*
-----------------------------------------------------------------------------
--| NAME: pwr.1.4
--|
--| ABSTRACT:
--| This function does pwr stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void pwr.1.4(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;
if (A >= 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;
// max LOC 11
}
/*
-----------------------------------------------------------------------------
--| NAME: pwr.1.5
--|
--| ABSTRACT:
--| This function does pwr stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void pwr.1.5(void)
{
A = B*C;
A = B/C;
/* LE SV TOC-2406 this is a pwr-01.5.3 req to set Real Time Clock*/
LogSvEvent((int)1731); /*12/01/2003 17:21:26*/
A = B+C;
A = B*C;
A = B-C;
A = B+C;
if {
X = Y + Z;
}
else {
halt;
}
A = B-C;
A = B/C;
A = B/C;
if (A lt B)
{
A = B + C;
D = E + F;
}
/* LE SV TOC-2407 this is a pwr-01.5.11 req to compare*/
LogSvEvent((int)1732); /*12/01/2003 17:21:26*/
A = B+C;
A = B+C;
A = B-C;
if (A == B)
{
A = B + C;
D = E + F;
}
A = B*C;
switch (pwr stuff)
{
case one:
{
run_this;
break;
}
case two:
{
run_this;
break;
}
default:
{
// missing error call
}
}
if (A > B)
{
A = B + C;
D = E + F;
}
if (A > B)
{
A = B + C;
D = E + F;
}
switch (pwr 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;
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;
if (A >= B)
{
A = B + C;
D = E + F;
}
A = B/C;
if (A ge B)
{
A = B + C;
D = E + F;
}
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;
}
// max LOC 36
}
/*
-----------------------------------------------------------------------------
--| NAME: pwr.1.6
--|
--| ABSTRACT:
--| This function does pwr stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void pwr.1.6(void)
{
A = B+C;
A = B+C;
if (A != B)
{
A = B + C;
D = E + F;
}
/* LE SV TOC-2408 this is a pwr-01.6.4 req to enable*/
LogSvEvent((int)1733); /*12/01/2003 17:21:26*/
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;
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;
}
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;
switch (pwr stuff)
{
case one:
{
run_this;
break;
}
case two:
{
run_this;
break;
}
// missing default
}
A = B+C;
A = B+C;
switch (pwr stuff)
{
case one:
{
run_this;
break;
}
case two:
{
run_this;
break;
}
default:
{
// missing error call
}
}
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;
A = B/C;
A = B/C;
A = B*C;
A = B+C;
A = B*C;
A = B*C;
A = B+C;
/* LE SV TOC-2409 this is a pwr-01.6.43 req to convert*/
LogSvEvent((int)1734); /*12/01/2003 17:21:26*/
if (A <= B)
{
A = B + C;
D = E + F;
}
/* LE SV TOC-2410 this is a pwr-01.6.44 req to verify*/
LogSvEvent((int)1735); /*12/01/2003 17:21:26*/
A = B*C;
A = B*C;
/* LE SV TOC-2411 this is a pwr-01.6.46 req to convert*/
LogSvEvent((int)1736); /*12/01/2003 17:21:26*/
A = B*C;
A = B-C;
A = B/C;
// max LOC 48
}
/*
-----------------------------------------------------------------------------
--| NAME: pwr.1.7
--|
--| ABSTRACT:
--| This function does pwr stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void pwr.1.7(void)
{
/* LE SV TOC-2412 this is a pwr-01.7.1 req to transform*/
LogSvEvent((int)1737); /*12/01/2003 17:21:26*/
A = B/C;
A = B/C;
/* LE SV TOC-2413 this is a pwr-01.7.3 req to increment*/
LogSvEvent((int)1738); /*12/01/2003 17:21:26*/
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;
if (A ge B)
{
A = B + C;
D = E + F;
}
switch (pwr 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;
/* LE SV TOC-2414 this is a pwr-01.7.16 req to halt*/
LogSvEvent((int)1739); /*12/01/2003 17:21:26*/
A = 0x0002;
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;
}
// max LOC 19
}
/*
-----------------------------------------------------------------------------
--| NAME: pwr.1.8
--|
--| ABSTRACT:
--| This function does pwr stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void pwr.1.8(void)
{
if (A eq B)
{
A = B + C;
D = E + F;
}
A = B-C;
if (A == B)
{
A = B + C;
D = E + F;
}
if (A eq B)
{
A = B + C;
D = E + F;
}
/* LE SV TOC-2415 this is a pwr-01.8.5 req to increment*/
LogSvEvent((int)1740); /*12/01/2003 17:21:26*/
if (A ne B)
{
A = B + C;
D = E + F;
}
A = B+C;
A = B/C;
/* LE SV TOC-2416 this is a pwr-01.8.8 req to check unix*/
LogSvEvent((int)1741); /*12/01/2003 17:21:26*/
if (A > B)
{
A = B + C;
D = E + F;
}
if (A gt 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 ne B)
{
A = B + C;
D = E + F;
}
if (A eq B)
{
A = B + C;
D = E + F;
}
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;
if (A > B)
{
A = B + C;
D = E + F;
}
A = B*C;
A = B/C;
// max LOC 25
}
/*
-----------------------------------------------------------------------------
--| NAME: pwr.1.9
--|
--| ABSTRACT:
--| This function does pwr stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void pwr.1.9(void)
{
switch (pwr 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;
/* LE SV TOC-2417 this is a pwr-01.9.6 req to reject*/
LogSvEvent((int)1742); /*12/01/2003 17:21:26*/
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;
}
A = B-C;
A = B/C;
/* LE SV TOC-2418 this is a pwr-01.9.13 req to process*/
LogSvEvent((int)1743); /*12/01/2003 17:21:26*/
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 (pwr stuff)
{
case one:
{
run_this;
break;
}
case two:
{
run_this;
break;
}
default:
{
SwError;
}
}
/* LE SV TOC-2419 this is a pwr-01.9.20 req to audit*/
LogSvEvent((int)1744); /*12/01/2003 17:21:26*/
if (A le B)
{
A = B + C;
D = E + F;
}
A = B-C;
A = B/C;
A = B+C;
A = B*C;
do forever;
switch (pwr stuff)
{
case one:
{
run_this;
break;
}
case two:
{
run_this;
break;
}
default:
{
SwError;
}
}
if (A >= B)
{
A = B + C;
D = E + F;
}
/* LE SV TOC-2420 this is a pwr-01.9.27 req to detect error*/
LogSvEvent((int)1745); /*12/01/2003 17:21:26*/
A = B+C;
switch (pwr stuff)
{
case one:
{
run_this;
break;
}
case two:
{
run_this;
break;
}
// missing default
}
A = B+C;
A = B-C;
A = B+C;
A = B/C;
if (A ne 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;
}
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 le B)
{
A = B + C;
D = E + F;
}
A = B+C;
switch (pwr stuff)
{
case one:
{
run_this;
break;
}
case two:
{
run_this;
break;
}
default:
{
SwError;
}
}
A = B*C;
A = B/C;
if (A lt B)
{
A = B + C;
D = E + F;
}
A = B/C;
A = B*C;
if (A ge B)
{
A = B + C;
D = E + F;
}
// max LOC 50
}
/*
-----------------------------------------------------------------------------
--| NAME: pwr.1.10
--|
--| ABSTRACT:
--| This function does pwr stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void pwr.1.10(void)
{
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;
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;
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;
rcv_buffer = (U16 *) alloc(size+1);
A = B-C;
send_buffer = (U16 *) malloc(size+1);
A = B+C;
if (A gt B)
{
A = B + C;
D = E + F;
}
// (P) this is really improtant
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 = 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;
// max LOC 44
}
/*
-----------------------------------------------------------------------------
--| NAME: pwr.1.11
--|
--| ABSTRACT:
--| This function does pwr stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void pwr.1.11(void)
{
A = B/C;
A = B/C;
A = B/C;
/* LE SV TOC-2421 this is a pwr-01.11.4 req to store*/
LogSvEvent((int)1746); /*12/01/2003 17:21:26*/
A = B+C;
/* LE SV TOC-2422 this is a pwr-01.11.5 req to update*/
LogSvEvent((int)1747); /*12/01/2003 17:21:26*/
if (A >= B)
{
A = B + C;
D = E + F;
}
A = B-C;
A = B/C;
A = B/C;
/* LE SV TOC-2423 this is a pwr-01.11.9 req to fail*/
LogSvEvent((int)1748); /*12/01/2003 17:21:26*/
A = B-C;
if (A > B)
{
A = B + C;
D = E + F;
}
if (A >= B)
{
A = B + C;
D = E + F;
}
A = B-C;
/*
dead_block = C * D;
dead_block = E * F;
*/
if (A ge B)
{
A = B + C;
D = E + F;
}
/* LE SV TOC-2424 this is a pwr-01.11.14 req to compare*/
LogSvEvent((int)1749); /*12/01/2003 17:21:26*/
if (A le B)
{
A = B + C;
D = E + F;
}
if (A gt 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;
}
if (A >= B)
{
A = B + C;
D = E + F;
}
free(FreePtr);
A = B-C;
if (A >= B)
{
A = B + C;
D = E + F;
}
/* dead_code = A * B; */
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;
if (A lt B)
{
A = B + C;
D = E + F;
}
// max LOC 27
}
/*
-----------------------------------------------------------------------------
--| NAME: pwr.1.12
--|
--| ABSTRACT:
--| This function does pwr stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void pwr.1.12(void)
{
A = B-C;
if (A lt B)
{
A = B + C;
D = E + F;
}
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;
A = B+C;
if (A ne B)
{
A = B + C;
D = E + F;
}
if (A == B)
{
A = B + C;
D = E + F;
}
A = 0x0004;
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 eq 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;
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;
/* LE SV TOC-2425 this is a pwr-01.12.29 req to call admin*/
LogSvEvent((int)1750); /*12/01/2003 17:21:26*/
A = 0x0004;
if (A lt B)
{
A = B + C;
D = E + F;
}
A = B*C;
if (A == B)
{
A = B + C;
D = E + F;
}
/* LE SV TOC-2426 this is a pwr-01.12.32 req to set RTC*/
LogSvEvent((int)1751); /*12/01/2003 17:21:26*/
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;
if (A le B)
{
A = B + C;
D = E + F;
}
A = B*C;
if (A gt 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 eq B)
{
A = B + C;
D = E + F;
}
/* LE SV TOC-2427 this is a pwr-01.12.46 req to convert*/
LogSvEvent((int)1752); /*12/01/2003 17:21:26*/
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;
// max LOC 52
}
/*
-----------------------------------------------------------------------------
--| NAME: pwr.1.13
--|
--| ABSTRACT:
--| This function does pwr stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void pwr.1.13(void)
{
if (A gt B)
{
A = B + C;
D = E + F;
}
switch (pwr stuff)
{
case one:
{
run_this;
// missing break
}
case two:
{
run_this;
break;
}
default:
{
SwError;
}
}
A = B-C;
A = B+C;
if (A le B)
{
A = B + C;
D = E + F;
}
if (A ne 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;
}
/* LE SV TOC-2428 this is a pwr-01.13.10 req to detect error*/
LogSvEvent((int)1753); /*12/01/2003 17:21:26*/
A = B*C;
A = B-C;
if (A <= B)
{
A = B + C;
D = E + F;
}
A = B*C;
A = B/C;
// max LOC 14
}