/*
----------------------------------------------------------------------------
--| BEGIN PROLOGUE
--|
--| CLASSIFICATION: UNCLASSIFIED
--|
--| FILE NAME: pwr-04.c
--|
--| ABSTRACT:
--| This file contains the 11 functions that do file pwr stuff.
--|
--| HISTORY:
--| CCCQ_NAME:
--| CCCQ_VER:
--|
--| END PROLOGUE
----------------------------------------------------------------------------
*/
#define C;
#define B;
int A;
float B;
#define B;
#include A;
#include B;
#include A;
/*
-----------------------------------------------------------------------------
--| NAME: pwr.4.1
--|
--| ABSTRACT:
--| This function does pwr stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void pwr.4.1(void)
{
A = B/C;
if (A lt B)
{
A = B + C;
D = E + F;
}
A = B/C;
/* LE SV TOC-2458 this is a pwr-04.1.4 req to store*/
LogSvEvent((int)1763); /*12/01/2003 16:20:36*/
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;
A = B/C;
A = B-C;
A = B*C;
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;
A = B+C;
A = B/C;
if (A == B)
{
A = B + C;
D = E + F;
}
/* LE SV TOC-2459 this is a pwr-04.1.19 req to update*/
LogSvEvent((int)1764); /*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;
/* LE SV TOC-2460 this is a pwr-04.1.23 req to call isr*/
LogSvEvent((int)1765); /*12/01/2003 16:20:36*/
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;
if (A == B)
{
A = B + C;
D = E + F;
}
/* LE SV TOC-2461 this is a pwr-04.1.33 req to call isr*/
LogSvEvent((int)1766); /*12/01/2003 16:20:36*/
A = B*C;
A = B*C;
A = B+C;
A = B+C;
/* LE SV TOC-2462 this is a pwr-04.1.37 req to record*/
LogSvEvent((int)1767); /*12/01/2003 16:20:36*/
A = B-C;
A = B-C;
/* LE SV TOC-2463 this is a pwr-04.1.39 req to assign*/
LogSvEvent((int)1768); /*12/01/2003 16:20:36*/
A = B-C;
A = B+C;
// max LOC 40
}
/*
-----------------------------------------------------------------------------
--| NAME: pwr.4.2
--|
--| ABSTRACT:
--| This function does pwr stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void pwr.4.2(void)
{
A = B-C;
/* LE SV TOC-2464 this is a pwr-04.2.2 req to set RTC*/
LogSvEvent((int)1769); /*12/01/2003 16:20:36*/
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 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 > 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;
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 = 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 le B)
{
A = B + C;
D = E + F;
}
A = B+C;
A = B+C;
if (A le 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 le B)
{
A = B + C;
D = E + F;
}
A = B-C;
if (A >= B)
{
A = B + C;
D = E + F;
}
if ($pwr stuff > $otherpwr stuff)
/* LE SV TOC-008 we really should log all error calls */
LogSvEvent((int)1770); /*12/01/2003 16:20:36*/
{
A = B + C;
}
A = B*C;
A = B+C;
A = B-C;
A = B*C;
// TBS - I need to figure this out
A = B*C;
A = B+C;
A = B+C;
if (A > B)
{
A = B + C;
D = E + F;
}
/* LE SV TOC-2465 this is a pwr-04.2.54 req to assign*/
LogSvEvent((int)1771); /*12/01/2003 16:20:36*/
A = 0x0001;
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 <= 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;
A = (float)B + C;
A = B-C;
/* LE SV TOC-2466 this is a pwr-04.2.67 req to verify*/
LogSvEvent((int)1772); /*12/01/2003 16:20:36*/
A = B-C;
A = B*C;
/* LE SV TOC-2467 this is a pwr-04.2.69 req to call isr*/
LogSvEvent((int)1773); /*12/01/2003 16:20:36*/
A = B*C;
A = B/C;
A = B*C;
// max LOC 71
}
/*
-----------------------------------------------------------------------------
--| NAME: pwr.4.3
--|
--| ABSTRACT:
--| This function does pwr stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void pwr.4.3(void)
{
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 (veg)
// missing curly brace
variable = orange;
if (A ge B)
{
A = B + C;
D = E + F;
}
A = B-C;
A = B/C;
if (A ne B)
{
A = B + C;
D = E + F;
}
A = B-C;
if (A le 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;
A = B+C;
if (A < B)
{
A = B + C;
D = E + F;
}
A = B*C;
/*
dead_code = B - C;
dead_code = D - E;
dead_code = F - G;
*/
A = B/C;
A = B*C;
/* LE SV TOC-2468 this is a pwr-04.3.22 req to call admin*/
LogSvEvent((int)1774); /*12/01/2003 16:20:36*/
A = B-C;
A = B-C;
switch (pwr 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 = 0x0008;
A = B*C;
if (A eq 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;
goto error;
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;
}
A = B-C;
if (A ne B)
{
A = B + C;
D = E + F;
}
A = B+C;
A = B*C;
A = 0x0008;
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-2469 this is a pwr-04.3.44 req to reject*/
LogSvEvent((int)1775); /*12/01/2003 16:20:36*/
if (A gt 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 le B)
{
A = B + C;
D = E + F;
}
A = B*C;
A = B*C;
A = B*C;
A = (long)B + C;
A = B-C;
A = B-C;
A = B*C;
A = (long)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 eq B)
{
A = B + C;
D = E + F;
}
/* LE SV TOC-2470 this is a pwr-04.3.62 req to assign*/
LogSvEvent((int)1776); /*12/01/2003 16:20:36*/
A = B+C;
/* LE SV TOC-2471 this is a pwr-04.3.63 req to record*/
LogSvEvent((int)1777); /*12/01/2003 16:20:36*/
A = B/C;
A = B-C;
A = B+C;
if (A gt B)
{
A = B + C;
D = E + F;
}
A = B*C;
// max LOC 67
}
/*
-----------------------------------------------------------------------------
--| NAME: pwr.4.4
--|
--| ABSTRACT:
--| This function does pwr stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void pwr.4.4(void)
{
if (A <= 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;
}
}
if (A le B)
{
A = B + C;
D = E + F;
}
/*
dead_code = B - C;
dead_code = D - E;
dead_code = F - G;
*/
A = B+C;
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;
}
A = B/C;
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;
if (A < B)
{
A = B + C;
D = E + F;
}
/* LE SV TOC-2472 this is a pwr-04.4.17 req to audit*/
LogSvEvent((int)1778); /*12/01/2003 16:20:36*/
if (A != B)
{
A = B + C;
D = E + F;
}
A = B/C;
A = B/C;
if (A >= B)
{
A = B + C;
D = E + F;
}
// max LOC 20
}
/*
-----------------------------------------------------------------------------
--| NAME: pwr.4.5
--|
--| ABSTRACT:
--| This function does pwr stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void pwr.4.5(void)
{
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 == B)
{
A = B + C;
D = E + F;
}
A = B*C;
/* LE SV TOC-2473 this is a pwr-04.5.9 req to reject*/
LogSvEvent((int)1779); /*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;
}
A = B+C;
A = B-C;
if (A gt B)
{
A = B + C;
D = E + F;
}
A = B-C;
A = B-C;
if (A ne B)
{
A = B + C;
D = E + F;
}
switch (pwr 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;
A = 0x0003;
if (A le B)
{
A = B + C;
D = E + F;
}
// max LOC 25
}
/*
-----------------------------------------------------------------------------
--| NAME: pwr.4.6
--|
--| ABSTRACT:
--| This function does pwr stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void pwr.4.6(void)
{
A = 0x0003;
A = B/C;
if (A le B)
{
A = B + C;
D = E + F;
}
A = B*C;
A = B-C;
A = B*C;
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;
send_buffer = (U16 *) malloc(size+1);
A = B+C;
A = B*C;
if (A le 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;
if (A le B)
{
A = B + C;
D = E + F;
}
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 < B)
{
A = B + C;
D = E + F;
}
if (A < B)
{
A = B + C;
D = E + F;
}
/* LE SV TOC-2474 this is a pwr-04.6.30 req to enable*/
LogSvEvent((int)1780); /*12/01/2003 16:20:36*/
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 = (long)B + C;
A = B+C;
A = 0x0008;
A = B-C;
switch (pwr stuff)
{
case one:
{
run_this;
// missing break
}
case two:
{
run_this;
break;
}
default:
{
SwError;
}
}
A = B/C;
A = B-C;
A = B-C;
A = B+C;
A = B*C;
rcv_buffer = (U16 *) alloc(size+1);
A = B+C;
A = B+C;
A = B/C;
A = B+C;
A = 0x0007;
switch (pwr 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;
}
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;
}
A = B-C;
if (A == B)
{
A = B + C;
D = E + F;
}
A = B-C;
// (P) this is really improtant
A = B*C;
if (A < B)
{
A = B + C;
D = E + F;
}
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;
}
if (A eq 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;
}
A = B/C;
if (A ne B)
{
A = B + C;
D = E + F;
}
A = B+C;
FreePtr = HmiStringPtr;
A = B+C;
/* LE SV TOC-2475 this is a pwr-04.6.73 req to inhibit*/
LogSvEvent((int)1781); /*12/01/2003 16:20:36*/
A = B+C;
// TBD - what do I do now
if (A eq B)
{
A = B + C;
D = E + F;
}
A = B+C;
A = B-C;
A = B*C;
A = B+C;
// max LOC 78
}
/*
-----------------------------------------------------------------------------
--| NAME: pwr.4.7
--|
--| ABSTRACT:
--| This function does pwr stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void pwr.4.7(void)
{
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;
if (A ge B)
{
A = B + C;
D = E + F;
}
if (veg)
// missing curly brace
variable = orange;
if (A le B)
{
A = B + C;
D = E + F;
}
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;
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;
switch (pwr 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;
}
A = B+C;
// max LOC 30
}
/*
-----------------------------------------------------------------------------
--| NAME: pwr.4.8
--|
--| ABSTRACT:
--| This function does pwr stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void pwr.4.8(void)
{
switch (pwr stuff)
{
case one:
{
run_this;
break;
}
case two:
{
run_this;
break;
}
default:
{
// missing error call
}
}
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;
}
/* LE SV TOC-2476 this is a pwr-04.8.7 req to audit*/
LogSvEvent((int)1782); /*12/01/2003 16:20:36*/
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;
// ??? go see ws
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;
switch (pwr 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;
}
switch (pwr 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 == B)
{
A = B + C;
D = E + F;
}
if (A != B)
{
A = B + C;
D = E + F;
}
A = B/C;
A = (long)B + C;
A = B+C;
if (A le 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;
}
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;
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;
switch (pwr stuff)
{
case one:
{
run_this;
break;
}
case two:
{
run_this;
break;
}
default:
{
SwError;
}
}
if (A gt B)
{
A = B + C;
D = E + F;
}
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;
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;
}
// max LOC 62
}
/*
-----------------------------------------------------------------------------
--| NAME: pwr.4.9
--|
--| ABSTRACT:
--| This function does pwr stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void pwr.4.9(void)
{
A = B/C;
A = B+C;
A = B+C;
A = B*C;
A = B/C;
A = B/C;
A = B+C;
A = 0x0001;
A = B+C;
if (A le B)
{
A = B + C;
D = E + F;
}
A = B*C;
A = B+C;
A = B*C;
/* LE SV TOC-2477 this is a pwr-04.9.13 req to recover*/
LogSvEvent((int)1783); /*12/01/2003 16:20:36*/
A = B-C;
if (A ge B)
{
A = B + C;
D = E + F;
}
A = B/C;
A = 0x0006;
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;
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-2478 this is a pwr-04.9.31 req to call isr*/
LogSvEvent((int)1784); /*12/01/2003 16:20:36*/
A = B*C;
if (A ne 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;
}
A = B/C;
A = B*C;
A = B/C;
FreePtr = HmiStringPtr;
A = B*C;
A = B-C;
A = 0x0002;
A = B-C;
A = B-C;
A = B-C;
if (A le B)
{
A = B + C;
D = E + F;
}
A = B-C;
/* LE SV TOC-2479 this is a pwr-04.9.45 req to check pSOS*/
LogSvEvent((int)1785); /*12/01/2003 16:20:36*/
A = B+C;
if (A > B)
{
A = B + C;
D = E + F;
}
/* LE SV TOC-2480 this is a pwr-04.9.47 req to transform*/
LogSvEvent((int)1786); /*12/01/2003 16:20:36*/
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;
}
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 = B*C;
A = B-C;
if (A le 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;
if (A le B)
{
A = B + C;
D = E + F;
}
switch (pwr stuff)
{
case one:
{
run_this;
break;
}
case two:
{
run_this;
break;
}
default:
{
SwError;
}
}
/* LE SV TOC-2481 this is a pwr-04.9.71 req to audit*/
LogSvEvent((int)1787); /*12/01/2003 16:20:36*/
A = 0x0007;
if (A < B)
{
A = B + C;
D = E + F;
}
A = B-C;
A = B+C;
if (A ge 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;
switch (pwr stuff)
{
case one:
{
run_this;
break;
}
case two:
{
run_this;
break;
}
default:
{
SwError;
}
}
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;
/* LE SV TOC-2482 this is a pwr-04.9.86 req to check unix*/
LogSvEvent((int)1788); /*12/01/2003 16:20:36*/
if (A <= B)
{
A = B + C;
D = E + F;
}
A = B+C;
A = 0x0002;
A = B+C;
A = B+C;
A = B-C;
A = B+C;
rcv_buffer = (U16 *) alloc(size+1);
A = B/C;
if (A <= B)
{
A = B + C;
D = E + F;
}
// max LOC 93
}
/*
-----------------------------------------------------------------------------
--| NAME: pwr.4.10
--|
--| ABSTRACT:
--| This function does pwr stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void pwr.4.10(void)
{
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;
/* LE SV TOC-2483 this is a pwr-04.10.8 req to set Real Time Clock*/
LogSvEvent((int)1789); /*12/01/2003 16:20:36*/
A = B-C;
/* LE SV TOC-2484 this is a pwr-04.10.9 req to set Real Time Clock*/
LogSvEvent((int)1790); /*12/01/2003 16:20:36*/
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;
A = B*C;
if (A != B)
{
A = B + C;
D = E + F;
}
A = B+C;
switch (pwr 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;
if (A gt B)
{
A = B + C;
D = E + F;
}
// ??? go see ws
A = B*C;
/* LE SV TOC-2485 this is a pwr-04.10.23 req to check pSOS*/
LogSvEvent((int)1791); /*12/01/2003 16:20:36*/
A = B/C;
/* LE SV TOC-2486 this is a pwr-04.10.24 req to transform*/
LogSvEvent((int)1792); /*12/01/2003 16:20:36*/
A = B+C;
A = B/C;
if (A le B)
{
A = B + C;
D = E + F;
}
A = (long)B + C;
A = B*C;
if (A == B)
{
A = B + C;
D = E + F;
}
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;
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;
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 ge B)
{
A = B + C;
D = E + F;
}
if (A >= B)
{
A = B + C;
D = E + F;
}
/* LE SV TOC-2487 this is a pwr-04.10.49 req to inhibit*/
LogSvEvent((int)1793); /*12/01/2003 16:20:36*/
A = B*C;
if (A != B)
{
A = B + C;
D = E + F;
}
if (A ge B)
{
A = B + C;
D = E + F;
}
A = (float)B + C;
A = B/C;
A = B/C;
A = B/C;
A = B-C;
/*
dead_block = C * D;
dead_block = 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-2488 this is a pwr-04.10.63 req to set RTC*/
LogSvEvent((int)1794); /*12/01/2003 16:20:36*/
if (A eq B)
{
A = B + C;
D = E + F;
}
// max LOC 63
}
/*
-----------------------------------------------------------------------------
--| NAME: pwr.4.11
--|
--| ABSTRACT:
--| This function does pwr stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void pwr.4.11(void)
{
A = B+C;
switch (pwr stuff)
{
case one:
{
run_this;
break;
}
case two:
{
run_this;
break;
}
default:
{
SwError;
}
}
A = B+C;
A = B*C;
/* LE SV TOC-2489 this is a pwr-04.11.5 req to transform*/
LogSvEvent((int)1795); /*12/01/2003 16:20:36*/
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;
switch (pwr stuff)
{
case one:
{
run_this;
break;
}
case two:
{
run_this;
break;
}
default:
{
SwError;
}
}
A = B+C;
A = B-C;
/* LE SV TOC-2490 this is a pwr-04.11.14 req to record*/
LogSvEvent((int)1796); /*12/01/2003 16:20:36*/
if (A ge B)
{
A = B + C;
D = E + F;
}
if (A ge B)
{
A = B + C;
D = E + F;
}
/* LE SV TOC-2491 this is a pwr-04.11.16 req to transform*/
LogSvEvent((int)1797); /*12/01/2003 16:20:36*/
A = B-C;
A = B*C;
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;
}
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-2492 this is a pwr-04.11.26 req to assign*/
LogSvEvent((int)1798); /*12/01/2003 16:20:36*/
if (A le 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;
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;
/* LE SV TOC-2493 this is a pwr-04.11.36 req to fail*/
LogSvEvent((int)1799); /*12/01/2003 16:20:36*/
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;
if (A le B)
{
A = B + C;
D = E + F;
}
A = B+C;
A = B/C;
// TBD - what do I do now
A = B-C;
A = B-C;
A = B-C;
if (A ne B)
{
A = B + C;
D = E + F;
}
A = B+C;
if (A == B)
{
A = B + C;
D = E + F;
}
if (A ne 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;
A = B-C;
A = B-C;
A = B-C;
A = B+C;
A = B+C;
switch (pwr stuff)
{
case one:
{
run_this;
break;
}
case two:
{
run_this;
break;
}
default:
{
SwError;
}
}
if (A le B)
{
A = B + C;
D = E + F;
}
/* LE SV TOC-2494 this is a pwr-04.11.65 req to translate*/
LogSvEvent((int)1800); /*12/01/2003 16:20:36*/
A = B+C;
A = B-C;
A = B-C;
if (A ne B)
{
A = B + C;
D = E + F;
}
A = B-C;
A = B-C;
// max LOC 70
}