/*
----------------------------------------------------------------------------
--| BEGIN PROLOGUE
--|
--| CLASSIFICATION: UNCLASSIFIED
--|
--| FILE NAME: stp-05.c
--|
--| ABSTRACT:
--| This file contains the 14 functions that do file stp stuff.
--|
--| HISTORY:
--| CCCQ_NAME:
--| CCCQ_VER:
--|
--| END PROLOGUE
----------------------------------------------------------------------------
*/
double C;
#include B;
double C;
#include B;
#include C;
/*
-----------------------------------------------------------------------------
--| NAME: stp.5.1
--|
--| ABSTRACT:
--| This function does stp stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void stp.5.1(void)
{
A = B-C;
A = B-C;
A = B+C;
A = B/C;
/* LE SV TOC-2889 this is a stp-05.1.5 req to call isr*/
LogSvEvent((int)1993); /*12/01/2003 16:20:36*/
A = B*C;
A = B+C;
A = B-C;
A = B/C;
if ($stp stuff > $otherstp stuff)
/* LE SV TOC-008 we really should log all error calls */
LogSvEvent((int)1994); /*12/01/2003 16:20:36*/
{
A = B + C;
}
if (A ge B)
{
A = B + C;
D = E + F;
}
if (A le 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-2890 this is a stp-05.1.15 req to check unix*/
LogSvEvent((int)1995); /*12/01/2003 16:20:36*/
A = B*C;
if (A eq B)
{
A = B + C;
D = E + F;
}
if (A ne B)
{
A = B + C;
D = E + F;
}
/* LE SV TOC-2891 this is a stp-05.1.18 req to call admin*/
LogSvEvent((int)1996); /*12/01/2003 16:20:36*/
A = B+C;
A = B-C;
/* LE SV TOC-2892 this is a stp-05.1.20 req to set Real Time Clock*/
LogSvEvent((int)1997); /*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;
if (A le B)
{
A = B + C;
D = E + F;
}
A = B/C;
A = B+C;
A = (long)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;
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-2893 this is a stp-05.1.45 req to check unix*/
LogSvEvent((int)1998); /*12/01/2003 16:20:36*/
A = B/C;
if (A ge B)
{
A = B + C;
D = E + F;
}
A = B*C;
A = B*C;
A = B-C;
// max LOC 49
}
/*
-----------------------------------------------------------------------------
--| NAME: stp.5.2
--|
--| ABSTRACT:
--| This function does stp stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void stp.5.2(void)
{
A = B-C;
A = B*C;
/* LE SV TOC-2894 this is a stp-05.2.3 req to verify*/
LogSvEvent((int)1999); /*12/01/2003 16:20:36*/
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;
// (P) this is really improtant
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;
}
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;
}
/* LE SV TOC-2895 this is a stp-05.2.25 req to update*/
LogSvEvent((int)2000); /*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;
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 < 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 <= B)
{
A = B + C;
D = E + F;
}
#ifdef LAZY
// this is not nice
A = B + C;
A = B + C;
#endif
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;
/* LE SV TOC-2896 this is a stp-05.2.46 req to set Real Time Clock*/
LogSvEvent((int)2001); /*12/01/2003 16:20:36*/
A = B-C;
A = B+C;
if (A lt 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;
}
if (A != B)
{
A = B + C;
D = E + F;
}
A = 0x0006;
A = B+C;
A = B-C;
A = B*C;
switch (stp stuff)
{
case one:
{
run_this;
break;
}
case two:
{
run_this;
break;
}
default:
{
SwError;
}
}
if (A > B)
{
A = B + C;
D = E + F;
}
A = B+C;
A = B*C;
/* LE SV TOC-2897 this is a stp-05.2.60 req to recover*/
LogSvEvent((int)2002); /*12/01/2003 16:20:36*/
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 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;
/* LE SV TOC-2898 this is a stp-05.2.73 req to convert*/
LogSvEvent((int)2003); /*12/01/2003 16:20:36*/
A = B/C;
A = B*C;
A = B+C;
A = 0x0008;
if (A < B)
{
A = B + C;
D = E + F;
}
A = B*C;
if (A > B)
{
A = B + C;
D = E + F;
}
// max LOC 78
}
/*
-----------------------------------------------------------------------------
--| NAME: stp.5.3
--|
--| ABSTRACT:
--| This function does stp stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void stp.5.3(void)
{
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;
FreePtr = HmiStringPtr;
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;
A = B+C;
switch (stp stuff)
{
case one:
{
run_this;
break;
}
case two:
{
run_this;
break;
}
default:
{
// missing error call
}
}
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 (stp stuff)
{
case one:
{
run_this;
break;
}
case two:
{
run_this;
break;
}
default:
{
SwError;
}
}
A = B+C;
/* LE SV TOC-2899 this is a stp-05.3.20 req to translate*/
LogSvEvent((int)2004); /*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;
}
// max LOC 23
}
/*
-----------------------------------------------------------------------------
--| NAME: stp.5.4
--|
--| ABSTRACT:
--| This function does stp stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void stp.5.4(void)
{
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;
}
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;
}
A = B/C;
A = B/C;
/* LE SV TOC-2900 this is a stp-05.4.12 req to convert*/
LogSvEvent((int)2005); /*12/01/2003 16:20:36*/
switch (stp stuff)
{
case one:
{
run_this;
break;
}
case two:
{
run_this;
break;
}
default:
{
SwError;
}
}
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;
}
A = B/C;
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;
A = B/C;
if (A gt 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;
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 = 0x0007;
A = B*C;
A = B*C;
switch (stp stuff)
{
case one:
{
run_this;
break;
}
case two:
{
run_this;
break;
}
default:
{
SwError;
}
}
A = B+C;
#ifdef LAZY
// this is not nice
A = B + C;
A = B + C;
#endif
A = B*C;
A = B*C;
A = B+C;
/* LE SV TOC-2901 this is a stp-05.4.43 req to compare*/
LogSvEvent((int)2006); /*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;
A = B+C;
A = B-C;
A = B+C;
A = B-C;
A = B-C;
// max LOC 55
}
/*
-----------------------------------------------------------------------------
--| NAME: stp.5.5
--|
--| ABSTRACT:
--| This function does stp stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void stp.5.5(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;
if (A ne B)
{
A = B + C;
D = E + F;
}
A = B/C;
A = B+C;
A = B-C;
A = (int)B + C;
if (A lt B)
{
A = B + C;
D = E + F;
}
A = B*C;
A = B+C;
A = B+C;
/*
dead_code = B - C;
dead_code = D - E;
dead_code = F - G;
*/
if (A le 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;
/* LE SV TOC-2902 this is a stp-05.5.23 req to compare*/
LogSvEvent((int)2007); /*12/01/2003 16:20:36*/
A = B+C;
A = B-C;
A = B+C;
switch (stp stuff)
{
case one:
{
run_this;
break;
}
case two:
{
run_this;
break;
}
default:
{
// missing error call
}
}
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;
}
A = B*C;
/* LE SV TOC-2903 this is a stp-05.5.38 req to set RTC*/
LogSvEvent((int)2008); /*12/01/2003 16:20:36*/
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;
A = B-C;
A = B-C;
/* LE SV TOC-2904 this is a stp-05.5.47 req to convert*/
LogSvEvent((int)2009); /*12/01/2003 16:20:36*/
A = B-C;
if (veg)
// missing curly brace
variable = orange;
A = B+C;
if (A ne 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 55
}
/*
-----------------------------------------------------------------------------
--| NAME: stp.5.6
--|
--| ABSTRACT:
--| This function does stp stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void stp.5.6(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;
A = B/C;
A = B*C;
if (A le B)
{
A = B + C;
D = E + F;
}
if (A lt 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;
}
if (A le B)
{
A = B + C;
D = E + F;
}
A = (int)B + C;
A = B/C;
A = 0x0004;
A = B*C;
A = B*C;
if (A eq B)
{
A = B + C;
D = E + F;
}
A = B+C;
// max LOC 18
}
/*
-----------------------------------------------------------------------------
--| NAME: stp.5.7
--|
--| ABSTRACT:
--| This function does stp stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void stp.5.7(void)
{
A = B/C;
if (A != 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;
}
A = B*C;
A = B-C;
switch (stp stuff)
{
case one:
{
run_this;
break;
}
case two:
{
run_this;
break;
}
default:
{
SwError;
}
}
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;
switch (stp 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;
// TBS - I need to figure this out
A = B+C;
A = B+C;
A = 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;
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;
if (A eq B)
{
A = B + C;
D = E + F;
}
if (A < B)
{
A = B + C;
D = E + F;
}
/* LE SV TOC-2905 this is a stp-05.7.37 req to process*/
LogSvEvent((int)2010); /*12/01/2003 16:20:36*/
A = B*C;
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;
}
// max LOC 41
}
/*
-----------------------------------------------------------------------------
--| NAME: stp.5.8
--|
--| ABSTRACT:
--| This function does stp stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void stp.5.8(void)
{
A = B-C;
A = B*C;
A = B-C;
if (A > B)
{
A = B + C;
D = E + F;
}
/* LE SV TOC-2906 this is a stp-05.8.5 req to disable*/
LogSvEvent((int)2011); /*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;
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;
#ifdef LAZY
// this is not nice
A = B + C;
A = B + C;
#endif
A = B/C;
A = B*C;
goto error;
A = B-C;
A = B/C;
A = B/C;
if (A != B)
{
A = B + C;
D = E + F;
}
switch (stp 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;
/* LE SV TOC-2907 this is a stp-05.8.29 req to halt*/
LogSvEvent((int)2012); /*12/01/2003 16:20:36*/
A = B/C;
A = B*C;
/* LE SV TOC-2908 this is a stp-05.8.31 req to compare*/
LogSvEvent((int)2013); /*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;
}
A = B+C;
/* LE SV TOC-2909 this is a stp-05.8.36 req to set Real Time Clock*/
LogSvEvent((int)2014); /*12/01/2003 16:20:36*/
switch (stp stuff)
{
case one:
{
run_this;
break;
}
case two:
{
run_this;
break;
}
default:
{
SwError;
}
}
A = B+C;
switch (stp 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 >= 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 ($stp stuff > $otherstp stuff)
/* LE SV TOC-008 we really should log all error calls */
LogSvEvent((int)2015); /*12/01/2003 16:20:36*/
{
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;
}
A = B-C;
if (A > B)
{
A = B + C;
D = E + F;
}
A = B-C;
switch (stp 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;
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;
A = B+C;
A = B+C;
A = B/C;
A = B*C;
A = B+C;
/* LE SV TOC-2910 this is a stp-05.8.70 req to validate*/
LogSvEvent((int)2016); /*12/01/2003 16:20:36*/
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;
if (A lt B)
{
A = B + C;
D = E + F;
}
switch (stp stuff)
{
case one:
{
run_this;
break;
}
case two:
{
run_this;
break;
}
default:
{
SwError;
}
}
/* LE SV TOC-2911 this is a stp-05.8.77 req to set RTC*/
LogSvEvent((int)2017); /*12/01/2003 16:20:36*/
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;
if (A eq B)
{
A = B + C;
D = E + F;
}
A = B/C;
/* LE SV TOC-2912 this is a stp-05.8.85 req to fail*/
LogSvEvent((int)2018); /*12/01/2003 16:20:36*/
if (A lt B)
{
A = B + C;
D = E + F;
}
A = B*C;
A = 0x0007;
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;
if (A != B)
{
A = B + C;
D = E + F;
}
A = B-C;
/* LE SV TOC-2913 this is a stp-05.8.94 req to store*/
LogSvEvent((int)2019); /*12/01/2003 16:20:36*/
A = B-C;
/* LE SV TOC-2914 this is a stp-05.8.95 req to update*/
LogSvEvent((int)2020); /*12/01/2003 16:20:36*/
A = B*C;
A = B-C;
A = B+C;
// max LOC 97
}
/*
-----------------------------------------------------------------------------
--| NAME: stp.5.9
--|
--| ABSTRACT:
--| This function does stp stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void stp.5.9(void)
{
if (A > B)
{
A = B + C;
D = E + F;
}
/* LE SV TOC-2915 this is a stp-05.9.2 req to validate*/
LogSvEvent((int)2021); /*12/01/2003 16:20:36*/
A = B*C;
/* LE SV TOC-2916 this is a stp-05.9.3 req to check pSOS*/
LogSvEvent((int)2022); /*12/01/2003 16:20:36*/
A = B/C;
A = B/C;
A = B*C;
A = B*C;
A = (int)B + C;
A = B-C;
A = B*C;
if (A <= B)
{
A = B + C;
D = E + F;
}
A = B/C;
A = B/C;
A = 0x0003;
A = B/C;
A = B-C;
// max LOC 13
}
/*
-----------------------------------------------------------------------------
--| NAME: stp.5.10
--|
--| ABSTRACT:
--| This function does stp stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void stp.5.10(void)
{
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;
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-2917 this is a stp-05.10.13 req to disable*/
LogSvEvent((int)2023); /*12/01/2003 16:20:36*/
if (A > B)
{
A = B + C;
D = E + F;
}
if (A != B)
{
A = B + C;
D = E + F;
}
/* LE SV TOC-2918 this is a stp-05.10.15 req to verify*/
LogSvEvent((int)2024); /*12/01/2003 16:20:36*/
if (A eq 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 > 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 (stp 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 == B)
{
A = B + C;
D = E + F;
}
/* LE SV TOC-2919 this is a stp-05.10.37 req to audit*/
LogSvEvent((int)2025); /*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;
A = B-C;
if (A lt B)
{
A = B + C;
D = E + F;
}
switch (stp 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;
A = B*C;
if (A le B)
{
A = B + C;
D = E + F;
}
A = B/C;
A = B/C;
A = 0x0002;
if (A ne 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 = 0x0004;
A = B-C;
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;
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;
A = B/C;
if (A le B)
{
A = B + C;
D = E + F;
}
if (A <= B)
{
A = B + C;
D = E + F;
}
// TBS - I need to figure this out
switch (stp stuff)
{
case one:
{
run_this;
break;
}
case two:
{
run_this;
break;
}
default:
{
SwError;
}
}
A = B/C;
// max LOC 76
}
/*
-----------------------------------------------------------------------------
--| NAME: stp.5.11
--|
--| ABSTRACT:
--| This function does stp stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void stp.5.11(void)
{
/* LE SV TOC-2920 this is a stp-05.11.1 req to halt*/
LogSvEvent((int)2026); /*12/01/2003 16:20:36*/
A = B/C;
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;
}
if (A <= B)
{
A = B + C;
D = E + F;
}
A = B*C;
A = B*C;
A = B+C;
A = B*C;
A = B/C;
// (P) this is really improtant
if (A >= B)
{
A = B + C;
D = E + F;
}
if (A != B)
{
A = B + C;
D = E + F;
}
A = B-C;
if (A lt B)
{
A = B + C;
D = E + F;
}
A = B*C;
A = B+C;
send_buffer = (U16 *) malloc(size+1);
A = B+C;
A = B+C;
A = 0x0001;
A = B-C;
free(FreePtr);
A = B+C;
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;
A = B+C;
A = B/C;
/* LE SV TOC-2921 this is a stp-05.11.30 req to inhibit*/
LogSvEvent((int)2027); /*12/01/2003 16:20:36*/
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;
}
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;
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;
}
if (A ne B)
{
A = B + C;
D = E + F;
}
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;
A = B+C;
A = 0x0008;
if (A != B)
{
A = B + C;
D = E + F;
}
A = B-C;
if (veg)
// missing curly brace
variable = orange;
A = B+C;
if (A != B)
{
A = B + C;
D = E + F;
}
// max LOC 59
}
/*
-----------------------------------------------------------------------------
--| NAME: stp.5.12
--|
--| ABSTRACT:
--| This function does stp stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void stp.5.12(void)
{
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;
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;
/* LE SV TOC-2922 this is a stp-05.12.14 req to record*/
LogSvEvent((int)2028); /*12/01/2003 16:20:36*/
A = B/C;
A = B*C;
A = B/C;
if (A eq B)
{
A = B + C;
D = E + F;
}
A = B+C;
/* LE SV TOC-2923 this is a stp-05.12.19 req to fail*/
LogSvEvent((int)2029); /*12/01/2003 16:20:36*/
A = B-C;
A = B/C;
/* LE SV TOC-2924 this is a stp-05.12.21 req to detect error*/
LogSvEvent((int)2030); /*12/01/2003 16:20:36*/
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 = 0x0003;
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;
A = 0x0006;
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;
}
if (A > B)
{
A = B + C;
D = E + F;
}
A = 0x0002;
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;
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;
// ??? go see ws
if (A <= B)
{
A = B + C;
D = E + F;
}
A = B+C;
A = B+C;
A = B+C;
/* LE SV TOC-2925 this is a stp-05.12.55 req to store*/
LogSvEvent((int)2031); /*12/01/2003 16:20:36*/
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 lt B)
{
A = B + C;
D = E + F;
}
switch (stp 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;
/* LE SV TOC-2926 this is a stp-05.12.67 req to verify*/
LogSvEvent((int)2032); /*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;
// max LOC 73
}
/*
-----------------------------------------------------------------------------
--| NAME: stp.5.13
--|
--| ABSTRACT:
--| This function does stp stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void stp.5.13(void)
{
A = B/C;
A = B+C;
if (A != B)
{
A = B + C;
D = E + F;
}
A = B-C;
A = B/C;
/* LE SV TOC-2927 this is a stp-05.13.6 req to call admin*/
LogSvEvent((int)2033); /*12/01/2003 16:20:36*/
A = B-C;
A = B*C;
A = B-C;
A = B*C;
A = B-C;
/* LE SV TOC-2928 this is a stp-05.13.11 req to halt*/
LogSvEvent((int)2034); /*12/01/2003 16:20:36*/
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;
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 >= 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;
// max LOC 29
}
/*
-----------------------------------------------------------------------------
--| NAME: stp.5.14
--|
--| ABSTRACT:
--| This function does stp stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void stp.5.14(void)
{
A = B+C;
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;
}
if (A eq B)
{
A = B + C;
D = E + F;
}
A = B*C;
A = B-C;
do forever;
if (A ne B)
{
A = B + C;
D = E + F;
}
A = B-C;
A = B-C;
A = B*C;
// max LOC 13
}