Logevents v111003 analysis/pr-app-PWR123 s

Logevents v111003 analysis/pr-app-PWR123 s_cpc-listing-c.html C:\IndigoPerl\bin\perl.exe 5.006
Description This report generates a single listing of multiple c files. Its original purpose was to facilitate printing the software, not a easy activity on a windows system with hundreds of files. Currently it has been augmented with HTML anchors and color coding to support the hyper links in other reports such as stats-problems.
Analysis	Comment
Details	This analysis shows the details from the original source code that are extracted from the search requests and internal error, warning, and caution settings. It also includes software metrics on a module basis.
Other Analysis Reports . Original Source Code . Instrumented Source Code . Help
12/08/2003 16:12:05
Details Report

1 1 Source: source/pr-app/pr-app-PWR123/pwr-01.c
 1-0 . /*
 1-1 . ----------------------------------------------------------------------------
 1-2 . --| BEGIN PROLOGUE
 1-3 . --|
 1-4 . --| CLASSIFICATION: UNCLASSIFIED
 1-5 . --|
 1-6 . --| FILE NAME:      pwr-01.c
 1-7 . --|
 1-8 . --| ABSTRACT:
 1-9 . --|   This file contains the 13 functions that do file pwr stuff.
 1-10 . --|
 1-11 . --| HISTORY:
 1-12 . --|   CCCQ_NAME:
 1-13 . --|   CCCQ_VER: 
 1-14 . --|
 1-15 . --| END PROLOGUE
 1-16 . ----------------------------------------------------------------------------
 1-17 . */
 1-18 . 
 1-19 . char D;
 1-20 . #include C;
 1-21 . char D;
 1-22 . #define C;
 1-23 . #define A;
 1-24 . 
 1-25 . 
 1-26 . 
 1-27 . /*
 1-28 . -----------------------------------------------------------------------------
 1-29 . --| NAME:   pwr.1.1
 1-30 . --|
 1-31 . --| ABSTRACT:
 1-32 . --|   This function does pwr stuff.
 1-33 . --|
 1-34 . --| RETURNS:
 1-35 . --|   NONE.
 1-36 . --|
 1-37 . ----------------------------------------------------------------------------
 1-38 . */
 1-39 . static void pwr.1.1(void)
 1-40 . {
 1-41 . A = B*C;
 1-42 . A = B/C;
 1-43 . 
 1-44 . if (A <  B)
 1-45 . {
 1-46 .    A = B + C;
 1-47 .    D = E + F;
 1-48 . }
 1-49 . 
 1-50 . A = 0x0009;
 1-51 . 
 1-52 . if (A >  B)
 1-53 . {
 1-54 .    A = B + C;
 1-55 .    D = E + F;
 1-56 . }
 1-57 . 
 1-58 . 
 1-59 . if (A <  B)
 1-60 . {
 1-61 .    A = B + C;
 1-62 .    D = E + F;
 1-63 . }
 1-64 . 
 1-65 . A = B-C;
 1-66 . A = B-C;
 1-67 . // max LOC 7
 1-68 . 
 1-69 . }
 1-70 . 
 1-71 . 
 1-72 . /*
 1-73 . -----------------------------------------------------------------------------
 1-74 . --| NAME:   pwr.1.2
 1-75 . --|
 1-76 . --| ABSTRACT:
 1-77 . --|   This function does pwr stuff.
 1-78 . --|
 1-79 . --| RETURNS:
 1-80 . --|   NONE.
 1-81 . --|
 1-82 . ----------------------------------------------------------------------------
 1-83 . */
 1-84 . static void pwr.1.2(void)
 1-85 . {
 1-86 . 
 1-87 . if (A != B)
 1-88 . {
 1-89 .    A = B + C;
 1-90 .    D = E + F;
 1-91 . }
 1-92 . 
 1-93 . A = B/C;
 1-94 . 
 1-95 . if (A gt B)
 1-96 . {
 1-97 .    A = B + C;
 1-98 .    D = E + F;
 1-99 . }
 1-100 . 
 1-101 . 
 1-102 . if (A == B)
 1-103 . {
 1-104 .    A = B + C;
 1-105 .    D = E + F;
 1-106 . }
 1-107 . 
 1-108 . A = B/C;
 1-109 . A = B/C;
 1-110 . A = B+C;
 1-111 . 
 1-112 . if (A <  B)
 1-113 . {
 1-114 .    A = B + C;
 1-115 .    D = E + F;
 1-116 . }
 1-117 . 
 1-118 . A = B-C;
 1-119 . 
 1-120 . if (A eq B)
 1-121 . {
 1-122 .    A = B + C;
 1-123 .    D = E + F;
 1-124 . }
 1-125 . 
 1-126 . A = B*C;
 1-127 . A = B-C;
 1-128 . // (P) this is really improtant
 1-129 . A = B+C;
 1-130 . 
 1-131 . if (A < = B)
 1-132 . {
 1-133 .    A = B + C;
 1-134 .    D = E + F;
 1-135 . }
 1-136 . 
 1-137 . A = B+C;
 1-138 . 
 1-139 . if (A gt B)
 1-140 . {
 1-141 .    A = B + C;
 1-142 .    D = E + F;
 1-143 . }
 1-144 . 
 1-145 . 
 1-146 . if (A le B)
 1-147 . {
 1-148 .    A = B + C;
 1-149 .    D = E + F;
 1-150 . }
 1-151 . 
 1-152 . A = B/C;
 1-153 . /* LE SV TOC-2401 this is a pwr-01.2.19 req to disable*/
 1-154 . A = B/C;
 1-155 . A = B+C;
 1-156 . A = B/C;
 1-157 . A = B*C;
 1-158 . A = B*C;
 1-159 . A = B/C;
 1-160 . /* LE SV TOC-2402 this is a pwr-01.2.25 req to update*/
 1-161 . A = B-C;
 1-162 . 
 1-163 . if (A lt B)
 1-164 . {
 1-165 .    A = B + C;
 1-166 .    D = E + F;
 1-167 . }
 1-168 . 
 1-169 . A = B*C;
 1-170 . 
 1-171 . if (A ge B)
 1-172 . {
 1-173 .    A = B + C;
 1-174 .    D = E + F;
 1-175 . }
 1-176 . 
 1-177 . 
 1-178 . switch (pwr stuff)
 1-179 . {
 1-180 .    case one:
 1-181 .    {
 1-182 .       run_this; 
 1-183 .       break;
 1-184 .    }
 1-185 .    case two:
 1-186 .    {
 1-187 .       run_this;
 1-188 .       break;
 1-189 .    }
 1-190 .    default:
 1-191 .    {
 1-192 .        SwError;
 1-193 .    }
 1-194 . }
 1-195 . 
 1-196 . A = B*C;
 1-197 . A = B*C;
 1-198 . 
 1-199 . if (A gt B)
 1-200 . {
 1-201 .    A = B + C;
 1-202 .    D = E + F;
 1-203 . }
 1-204 . 
 1-205 . A = B+C;
 1-206 . A = B*C;
 1-207 . A = B/C;
 1-208 . A = B*C;
 1-209 . 
 1-210 . if (A <  B)
 1-211 . {
 1-212 .    A = B + C;
 1-213 .    D = E + F;
 1-214 . }
 1-215 . 
 1-216 . 
 1-217 . if (A lt B)
 1-218 . {
 1-219 .    A = B + C;
 1-220 .    D = E + F;
 1-221 . }
 1-222 . 
 1-223 . /* LE SV TOC-2403 this is a pwr-01.2.39 req to call admin*/
 1-224 . 
 1-225 . if (A >  B)
 1-226 . {
 1-227 .    A = B + C;
 1-228 .    D = E + F;
 1-229 . }
 1-230 . 
 1-231 . 
 1-232 . if (A <  B)
 1-233 . {
 1-234 .    A = B + C;
 1-235 .    D = E + F;
 1-236 . }
 1-237 . 
 1-238 . A = B*C;
 1-239 . A = B+C;
 1-240 . A = B/C;
 1-241 . A = B-C;
 1-242 . A = B/C;
 1-243 . 
 1-244 . #ifdef LAZY
 1-245 .    // this is not nice
 1-246 .    A = B + C;
 1-247 .    A = B + C;
 1-248 . #endif
 1-249 . 
 1-250 . 
 1-251 . if (A < = B)
 1-252 . {
 1-253 .    A = B + C;
 1-254 .    D = E + F;
 1-255 . }
 1-256 . 
 1-257 . /* LE SV TOC-2404 this is a pwr-01.2.47 req to validate*/
 1-258 . 
 1-259 . if (A le B)
 1-260 . {
 1-261 .    A = B + C;
 1-262 .    D = E + F;
 1-263 . }
 1-264 . 
 1-265 . A = B-C;
 1-266 . A = B/C;
 1-267 . A = B+C;
 1-268 . 
 1-269 . if (A > = B)
 1-270 . {
 1-271 .    A = B + C;
 1-272 .    D = E + F;
 1-273 . }
 1-274 . 
 1-275 . 
 1-276 . if (A ne B)
 1-277 . {
 1-278 .    A = B + C;
 1-279 .    D = E + F;
 1-280 . }
 1-281 . 
 1-282 . A = B*C;
 1-283 . 
 1-284 . if (A > = B)
 1-285 . {
 1-286 .    A = B + C;
 1-287 .    D = E + F;
 1-288 . }
 1-289 . 
 1-290 . 
 1-291 . if (A != B)
 1-292 . {
 1-293 .    A = B + C;
 1-294 .    D = E + F;
 1-295 . }
 1-296 . 
 1-297 . A = B-C;
 1-298 . A = B+C;
 1-299 . 
 1-300 . if (A eq B)
 1-301 . {
 1-302 .    A = B + C;
 1-303 .    D = E + F;
 1-304 . }
 1-305 . 
 1-306 . A = B+C;
 1-307 . 
 1-308 . switch (pwr stuff)
 1-309 . {
 1-310 .    case one:
 1-311 .    {
 1-312 .       run_this; 
 1-313 .       break;
 1-314 .    }
 1-315 .    case two:
 1-316 .    {
 1-317 .       run_this;
 1-318 .       break;
 1-319 .    }
 1-320 .    default:
 1-321 .    {
 1-322 .        SwError;
 1-323 .    }
 1-324 . }
 1-325 . 
 1-326 . FreePtr = HmiStringPtr;
 1-327 . A = B*C;
 1-328 . A = B-C;
 1-329 . // max LOC 62
 1-330 . 
 1-331 . }
 1-332 . 
 1-333 . 
 1-334 . /*
 1-335 . -----------------------------------------------------------------------------
 1-336 . --| NAME:   pwr.1.3
 1-337 . --|
 1-338 . --| ABSTRACT:
 1-339 . --|   This function does pwr stuff.
 1-340 . --|
 1-341 . --| RETURNS:
 1-342 . --|   NONE.
 1-343 . --|
 1-344 . ----------------------------------------------------------------------------
 1-345 . */
 1-346 . static void pwr.1.3(void)
 1-347 . {
 1-348 . 
 1-349 . if (A le B)
 1-350 . {
 1-351 .    A = B + C;
 1-352 .    D = E + F;
 1-353 . }
 1-354 . 
 1-355 . A = B+C;
 1-356 . A = B/C;
 1-357 . rcv_buffer = (U16 *) alloc(size+1);
 1-358 . A = B*C;
 1-359 . A = B*C;
 1-360 . 
 1-361 . if (A < = B)
 1-362 . {
 1-363 .    A = B + C;
 1-364 .    D = E + F;
 1-365 . }
 1-366 . 
 1-367 . A = B-C;
 1-368 . A = B/C;
 1-369 . A = B+C;
 1-370 . /* LE SV TOC-2405 this is a pwr-01.3.10 req to transform*/
 1-371 . A = B*C;
 1-372 . 
 1-373 . if (A lt B)
 1-374 . {
 1-375 .    A = B + C;
 1-376 .    D = E + F;
 1-377 . }
 1-378 . 
 1-379 . 
 1-380 . if (A == B)
 1-381 . {
 1-382 .    A = B + C;
 1-383 .    D = E + F;
 1-384 . }
 1-385 . 
 1-386 . 
 1-387 . if (A ne B)
 1-388 . {
 1-389 .    A = B + C;
 1-390 .    D = E + F;
 1-391 . }
 1-392 . 
 1-393 . A = B/C;
 1-394 . A = B/C;
 1-395 . 
 1-396 . switch (pwr stuff)
 1-397 . {
 1-398 .    case one:
 1-399 .    {
 1-400 .       run_this; 
 1-401 .       break;
 1-402 .    }
 1-403 .    case two:
 1-404 .    {
 1-405 .       run_this;
 1-406 .       break;
 1-407 .    }
 1-408 .    default:
 1-409 .    {
 1-410 .        SwError;
 1-411 .    }
 1-412 . }
 1-413 . 
 1-414 . A = B*C;
 1-415 . A = B-C;
 1-416 . A = B/C;
 1-417 . // max LOC 19
 1-418 . 
 1-419 . }
 1-420 . 
 1-421 . 
 1-422 . /*
 1-423 . -----------------------------------------------------------------------------
 1-424 . --| NAME:   pwr.1.4
 1-425 . --|
 1-426 . --| ABSTRACT:
 1-427 . --|   This function does pwr stuff.
 1-428 . --|
 1-429 . --| RETURNS:
 1-430 . --|   NONE.
 1-431 . --|
 1-432 . ----------------------------------------------------------------------------
 1-433 . */
 1-434 . static void pwr.1.4(void)
 1-435 . {
 1-436 . A = B+C;
 1-437 . A = B-C;
 1-438 . 
 1-439 . if (A < = B)
 1-440 . {
 1-441 .    A = B + C;
 1-442 .    D = E + F;
 1-443 . }
 1-444 . 
 1-445 . A = B-C;
 1-446 . A = B*C;
 1-447 . A = B/C;
 1-448 . 
 1-449 . if (A > = B)
 1-450 . {
 1-451 .    A = B + C;
 1-452 .    D = E + F;
 1-453 . }
 1-454 . 
 1-455 . A = B+C;
 1-456 . 
 1-457 . if (A != B)
 1-458 . {
 1-459 .    A = B + C;
 1-460 .    D = E + F;
 1-461 . }
 1-462 . 
 1-463 . 
 1-464 . if (A == B)
 1-465 . {
 1-466 .    A = B + C;
 1-467 .    D = E + F;
 1-468 . }
 1-469 . 
 1-470 . A = B/C;
 1-471 . // max LOC 11
 1-472 . 
 1-473 . }
 1-474 . 
 1-475 . 
 1-476 . /*
 1-477 . -----------------------------------------------------------------------------
 1-478 . --| NAME:   pwr.1.5
 1-479 . --|
 1-480 . --| ABSTRACT:
 1-481 . --|   This function does pwr stuff.
 1-482 . --|
 1-483 . --| RETURNS:
 1-484 . --|   NONE.
 1-485 . --|
 1-486 . ----------------------------------------------------------------------------
 1-487 . */
 1-488 . static void pwr.1.5(void)
 1-489 . {
 1-490 . A = B*C;
 1-491 . A = B/C;
 1-492 . /* LE SV TOC-2406 this is a pwr-01.5.3 req to set Real Time Clock*/
 1-493 . A = B+C;
 1-494 . A = B*C;
 1-495 . A = B-C;
 1-496 . A = B+C;
 1-497 . 
 1-498 . if {
 1-499 .    X = Y + Z;
 1-500 . }
 1-501 . else {
 1-502 .    halt;
 1-503 . }
 1-504 . 
 1-505 . A = B-C;
 1-506 . A = B/C;
 1-507 . A = B/C;
 1-508 . 
 1-509 . if (A lt B)
 1-510 . {
 1-511 .    A = B + C;
 1-512 .    D = E + F;
 1-513 . }
 1-514 . 
 1-515 . /* LE SV TOC-2407 this is a pwr-01.5.11 req to compare*/
 1-516 . A = B+C;
 1-517 . A = B+C;
 1-518 . A = B-C;
 1-519 . 
 1-520 . if (A == B)
 1-521 . {
 1-522 .    A = B + C;
 1-523 .    D = E + F;
 1-524 . }
 1-525 . 
 1-526 . A = B*C;
 1-527 . 
 1-528 . switch (pwr stuff)
 1-529 . {
 1-530 .       case one:
 1-531 .    {
 1-532 .       run_this;
 1-533 .       break;
 1-534 .    }
 1-535 .    case two:
 1-536 .    {
 1-537 .       run_this;
 1-538 .       break;
 1-539 .    }
 1-540 .    default:
 1-541 .    {
 1-542 .       // missing error call
 1-543 .    }
 1-544 . }
 1-545 . 
 1-546 . 
 1-547 . if (A >  B)
 1-548 . {
 1-549 .    A = B + C;
 1-550 .    D = E + F;
 1-551 . }
 1-552 . 
 1-553 . 
 1-554 . if (A >  B)
 1-555 . {
 1-556 .    A = B + C;
 1-557 .    D = E + F;
 1-558 . }
 1-559 . 
 1-560 . 
 1-561 . switch (pwr stuff)
 1-562 . {
 1-563 .    case one:
 1-564 .    {
 1-565 .       run_this; 
 1-566 .       break;
 1-567 .    }
 1-568 .    case two:
 1-569 .    {
 1-570 .       run_this;
 1-571 .       break;
 1-572 .    }
 1-573 .    default:
 1-574 .    {
 1-575 .        SwError;
 1-576 .    }
 1-577 . }
 1-578 . 
 1-579 . A = B*C;
 1-580 . A = B-C;
 1-581 . A = B+C;
 1-582 . A = B/C;
 1-583 . A = B-C;
 1-584 . A = B*C;
 1-585 . A = B/C;
 1-586 . A = B*C;
 1-587 . 
 1-588 . if (A ne B)
 1-589 . {
 1-590 .    A = B + C;
 1-591 .    D = E + F;
 1-592 . }
 1-593 . 
 1-594 . 
 1-595 . if (A eq B)
 1-596 . {
 1-597 .    A = B + C;
 1-598 .    D = E + F;
 1-599 . }
 1-600 . 
 1-601 . A = B-C;
 1-602 . 
 1-603 . if (A > = B)
 1-604 . {
 1-605 .    A = B + C;
 1-606 .    D = E + F;
 1-607 . }
 1-608 . 
 1-609 . A = B/C;
 1-610 . 
 1-611 . if (A ge B)
 1-612 . {
 1-613 .    A = B + C;
 1-614 .    D = E + F;
 1-615 . }
 1-616 . 
 1-617 . A = B/C;
 1-618 . 
 1-619 . if (A ge B)
 1-620 . {
 1-621 .    A = B + C;
 1-622 .    D = E + F;
 1-623 . }
 1-624 . 
 1-625 . 
 1-626 . if (A <  B)
 1-627 . {
 1-628 .    A = B + C;
 1-629 .    D = E + F;
 1-630 . }
 1-631 . 
 1-632 . 
 1-633 . if (A ge B)
 1-634 . {
 1-635 .    A = B + C;
 1-636 .    D = E + F;
 1-637 . }
 1-638 . 
 1-639 . // max LOC 36
 1-640 . 
 1-641 . }
 1-642 . 
 1-643 . 
 1-644 . /*
 1-645 . -----------------------------------------------------------------------------
 1-646 . --| NAME:   pwr.1.6
 1-647 . --|
 1-648 . --| ABSTRACT:
 1-649 . --|   This function does pwr stuff.
 1-650 . --|
 1-651 . --| RETURNS:
 1-652 . --|   NONE.
 1-653 . --|
 1-654 . ----------------------------------------------------------------------------
 1-655 . */
 1-656 . static void pwr.1.6(void)
 1-657 . {
 1-658 . A = B+C;
 1-659 . A = B+C;
 1-660 . 
 1-661 . if (A != B)
 1-662 . {
 1-663 .    A = B + C;
 1-664 .    D = E + F;
 1-665 . }
 1-666 . 
 1-667 . /* LE SV TOC-2408 this is a pwr-01.6.4 req to enable*/
 1-668 . A = B*C;
 1-669 . 
 1-670 . if (A < = B)
 1-671 . {
 1-672 .    A = B + C;
 1-673 .    D = E + F;
 1-674 . }
 1-675 . 
 1-676 . A = B*C;
 1-677 . A = B-C;
 1-678 . A = B+C;
 1-679 . 
 1-680 . if (A eq B)
 1-681 . {
 1-682 .    A = B + C;
 1-683 .    D = E + F;
 1-684 . }
 1-685 . 
 1-686 . A = B-C;
 1-687 . A = B*C;
 1-688 . A = B-C;
 1-689 . A = B/C;
 1-690 . A = B*C;
 1-691 . 
 1-692 . if (A <  B)
 1-693 . {
 1-694 .    A = B + C;
 1-695 .    D = E + F;
 1-696 . }
 1-697 . 
 1-698 . 
 1-699 . if (A lt B)
 1-700 . {
 1-701 .    A = B + C;
 1-702 .    D = E + F;
 1-703 . }
 1-704 . 
 1-705 . A = B+C;
 1-706 . A = B-C;
 1-707 . A = B*C;
 1-708 . 
 1-709 . if (A < = B)
 1-710 . {
 1-711 .    A = B + C;
 1-712 .    D = E + F;
 1-713 . }
 1-714 . 
 1-715 . A = B-C;
 1-716 . 
 1-717 . if (A != B)
 1-718 . {
 1-719 .    A = B + C;
 1-720 .    D = E + F;
 1-721 . }
 1-722 . 
 1-723 . A = B/C;
 1-724 . 
 1-725 . switch (pwr stuff)
 1-726 . {
 1-727 .    case one:
 1-728 .    {
 1-729 .       run_this;
 1-730 .       break;
 1-731 .    }
 1-732 .    case two:
 1-733 .    {
 1-734 .       run_this;
 1-735 .       break;
 1-736 .    }
 1-737 .    // missing default
 1-738 . }
 1-739 . 
 1-740 . A = B+C;
 1-741 . A = B+C;
 1-742 . 
 1-743 . switch (pwr stuff)
 1-744 . {
 1-745 .       case one:
 1-746 .    {
 1-747 .       run_this;
 1-748 .       break;
 1-749 .    }
 1-750 .    case two:
 1-751 .    {
 1-752 .       run_this;
 1-753 .       break;
 1-754 .    }
 1-755 .    default:
 1-756 .    {
 1-757 .       // missing error call
 1-758 .    }
 1-759 . }
 1-760 . 
 1-761 . A = B-C;
 1-762 . 
 1-763 . if (A <  B)
 1-764 . {
 1-765 .    A = B + C;
 1-766 .    D = E + F;
 1-767 . }
 1-768 . 
 1-769 . A = B/C;
 1-770 . A = B-C;
 1-771 . A = B+C;
 1-772 . A = B/C;
 1-773 . A = B-C;
 1-774 . A = B+C;
 1-775 . A = B-C;
 1-776 . A = B-C;
 1-777 . A = B/C;
 1-778 . A = B/C;
 1-779 . A = B*C;
 1-780 . A = B+C;
 1-781 . A = B*C;
 1-782 . A = B*C;
 1-783 . A = B+C;
 1-784 . /* LE SV TOC-2409 this is a pwr-01.6.43 req to convert*/
 1-785 . 
 1-786 . if (A < = B)
 1-787 . {
 1-788 .    A = B + C;
 1-789 .    D = E + F;
 1-790 . }
 1-791 . 
 1-792 . /* LE SV TOC-2410 this is a pwr-01.6.44 req to verify*/
 1-793 . A = B*C;
 1-794 . A = B*C;
 1-795 . /* LE SV TOC-2411 this is a pwr-01.6.46 req to convert*/
 1-796 . A = B*C;
 1-797 . A = B-C;
 1-798 . A = B/C;
 1-799 . // max LOC 48
 1-800 . 
 1-801 . }
 1-802 . 
 1-803 . 
 1-804 . /*
 1-805 . -----------------------------------------------------------------------------
 1-806 . --| NAME:   pwr.1.7
 1-807 . --|
 1-808 . --| ABSTRACT:
 1-809 . --|   This function does pwr stuff.
 1-810 . --|
 1-811 . --| RETURNS:
 1-812 . --|   NONE.
 1-813 . --|
 1-814 . ----------------------------------------------------------------------------
 1-815 . */
 1-816 . static void pwr.1.7(void)
 1-817 . {
 1-818 . /* LE SV TOC-2412 this is a pwr-01.7.1 req to transform*/
 1-819 . A = B/C;
 1-820 . A = B/C;
 1-821 . /* LE SV TOC-2413 this is a pwr-01.7.3 req to increment*/
 1-822 . 
 1-823 . if (A > = B)
 1-824 . {
 1-825 .    A = B + C;
 1-826 .    D = E + F;
 1-827 . }
 1-828 . 
 1-829 . A = B*C;
 1-830 . A = B*C;
 1-831 . A = B*C;
 1-832 . 
 1-833 . if (A < = B)
 1-834 . {
 1-835 .    A = B + C;
 1-836 .    D = E + F;
 1-837 . }
 1-838 . 
 1-839 . A = B*C;
 1-840 . 
 1-841 . if (A ge B)
 1-842 . {
 1-843 .    A = B + C;
 1-844 .    D = E + F;
 1-845 . }
 1-846 . 
 1-847 . 
 1-848 . switch (pwr stuff)
 1-849 . {
 1-850 .    case one:
 1-851 .    {
 1-852 .       run_this; 
 1-853 .       break;
 1-854 .    }
 1-855 .    case two:
 1-856 .    {
 1-857 .       run_this;
 1-858 .       break;
 1-859 .    }
 1-860 .    default:
 1-861 .    {
 1-862 .        SwError;
 1-863 .    }
 1-864 . }
 1-865 . 
 1-866 . A = B-C;
 1-867 . A = B-C;
 1-868 . A = B-C;
 1-869 . A = B/C;
 1-870 . A = B/C;
 1-871 . /* LE SV TOC-2414 this is a pwr-01.7.16 req to halt*/
 1-872 . A = 0x0002;
 1-873 . A = B-C;
 1-874 . 
 1-875 . if (A == B)
 1-876 . {
 1-877 .    A = B + C;
 1-878 .    D = E + F;
 1-879 . }
 1-880 . 
 1-881 . A = B+C;
 1-882 . 
 1-883 . if (A le B)
 1-884 . {
 1-885 .    A = B + C;
 1-886 .    D = E + F;
 1-887 . }
 1-888 . 
 1-889 . // max LOC 19
 1-890 . 
 1-891 . }
 1-892 . 
 1-893 . 
 1-894 . /*
 1-895 . -----------------------------------------------------------------------------
 1-896 . --| NAME:   pwr.1.8
 1-897 . --|
 1-898 . --| ABSTRACT:
 1-899 . --|   This function does pwr stuff.
 1-900 . --|
 1-901 . --| RETURNS:
 1-902 . --|   NONE.
 1-903 . --|
 1-904 . ----------------------------------------------------------------------------
 1-905 . */
 1-906 . static void pwr.1.8(void)
 1-907 . {
 1-908 . 
 1-909 . if (A eq B)
 1-910 . {
 1-911 .    A = B + C;
 1-912 .    D = E + F;
 1-913 . }
 1-914 . 
 1-915 . A = B-C;
 1-916 . 
 1-917 . if (A == B)
 1-918 . {
 1-919 .    A = B + C;
 1-920 .    D = E + F;
 1-921 . }
 1-922 . 
 1-923 . 
 1-924 . if (A eq B)
 1-925 . {
 1-926 .    A = B + C;
 1-927 .    D = E + F;
 1-928 . }
 1-929 . 
 1-930 . /* LE SV TOC-2415 this is a pwr-01.8.5 req to increment*/
 1-931 . 
 1-932 . if (A ne B)
 1-933 . {
 1-934 .    A = B + C;
 1-935 .    D = E + F;
 1-936 . }
 1-937 . 
 1-938 . A = B+C;
 1-939 . A = B/C;
 1-940 . /* LE SV TOC-2416 this is a pwr-01.8.8 req to check unix*/
 1-941 . 
 1-942 . if (A >  B)
 1-943 . {
 1-944 .    A = B + C;
 1-945 .    D = E + F;
 1-946 . }
 1-947 . 
 1-948 . 
 1-949 . if (A gt B)
 1-950 . {
 1-951 .    A = B + C;
 1-952 .    D = E + F;
 1-953 . }
 1-954 . 
 1-955 . A = B+C;
 1-956 . A = B*C;
 1-957 . 
 1-958 . if (A >  B)
 1-959 . {
 1-960 .    A = B + C;
 1-961 .    D = E + F;
 1-962 . }
 1-963 . 
 1-964 . A = B+C;
 1-965 . A = B*C;
 1-966 . 
 1-967 . if (A ne B)
 1-968 . {
 1-969 .    A = B + C;
 1-970 .    D = E + F;
 1-971 . }
 1-972 . 
 1-973 . 
 1-974 . if (A eq B)
 1-975 . {
 1-976 .    A = B + C;
 1-977 .    D = E + F;
 1-978 . }
 1-979 . 
 1-980 . A = B*C;
 1-981 . A = B*C;
 1-982 . 
 1-983 . if (A ge B)
 1-984 . {
 1-985 .    A = B + C;
 1-986 .    D = E + F;
 1-987 . }
 1-988 . 
 1-989 . A = B+C;
 1-990 . A = B+C;
 1-991 . A = B*C;
 1-992 . 
 1-993 . if (A >  B)
 1-994 . {
 1-995 .    A = B + C;
 1-996 .    D = E + F;
 1-997 . }
 1-998 . 
 1-999 . A = B*C;
 1-1000 . A = B/C;
 1-1001 . // max LOC 25
 1-1002 . 
 1-1003 . }
 1-1004 . 
 1-1005 . 
 1-1006 . /*
 1-1007 . -----------------------------------------------------------------------------
 1-1008 . --| NAME:   pwr.1.9
 1-1009 . --|
 1-1010 . --| ABSTRACT:
 1-1011 . --|   This function does pwr stuff.
 1-1012 . --|
 1-1013 . --| RETURNS:
 1-1014 . --|   NONE.
 1-1015 . --|
 1-1016 . ----------------------------------------------------------------------------
 1-1017 . */
 1-1018 . static void pwr.1.9(void)
 1-1019 . {
 1-1020 . 
 1-1021 . switch (pwr stuff)
 1-1022 . {
 1-1023 .    case one:
 1-1024 .    {
 1-1025 .       run_this; 
 1-1026 .       break;
 1-1027 .    }
 1-1028 .    case two:
 1-1029 .    {
 1-1030 .       run_this;
 1-1031 .       break;
 1-1032 .    }
 1-1033 .    default:
 1-1034 .    {
 1-1035 .        SwError;
 1-1036 .    }
 1-1037 . }
 1-1038 . 
 1-1039 . A = B-C;
 1-1040 . A = B-C;
 1-1041 . A = B*C;
 1-1042 . A = B+C;
 1-1043 . /* LE SV TOC-2417 this is a pwr-01.9.6 req to reject*/
 1-1044 . A = B-C;
 1-1045 . A = B+C;
 1-1046 . 
 1-1047 . if (A >  B)
 1-1048 . {
 1-1049 .    A = B + C;
 1-1050 .    D = E + F;
 1-1051 . }
 1-1052 . 
 1-1053 . A = B/C;
 1-1054 . 
 1-1055 . if (A eq B)
 1-1056 . {
 1-1057 .    A = B + C;
 1-1058 .    D = E + F;
 1-1059 . }
 1-1060 . 
 1-1061 . A = B-C;
 1-1062 . A = B/C;
 1-1063 . /* LE SV TOC-2418 this is a pwr-01.9.13 req to process*/
 1-1064 . A = B*C;
 1-1065 . A = B-C;
 1-1066 . 
 1-1067 . if (A eq B)
 1-1068 . {
 1-1069 .    A = B + C;
 1-1070 .    D = E + F;
 1-1071 . }
 1-1072 . 
 1-1073 . A = B+C;
 1-1074 . A = B/C;
 1-1075 . A = B/C;
 1-1076 . 
 1-1077 . switch (pwr stuff)
 1-1078 . {
 1-1079 .    case one:
 1-1080 .    {
 1-1081 .       run_this; 
 1-1082 .       break;
 1-1083 .    }
 1-1084 .    case two:
 1-1085 .    {
 1-1086 .       run_this;
 1-1087 .       break;
 1-1088 .    }
 1-1089 .    default:
 1-1090 .    {
 1-1091 .        SwError;
 1-1092 .    }
 1-1093 . }
 1-1094 . 
 1-1095 . /* LE SV TOC-2419 this is a pwr-01.9.20 req to audit*/
 1-1096 . 
 1-1097 . if (A le B)
 1-1098 . {
 1-1099 .    A = B + C;
 1-1100 .    D = E + F;
 1-1101 . }
 1-1102 . 
 1-1103 . A = B-C;
 1-1104 . A = B/C;
 1-1105 . A = B+C;
 1-1106 . A = B*C;
 1-1107 . do forever;
 1-1108 . 
 1-1109 . switch (pwr stuff)
 1-1110 . {
 1-1111 .    case one:
 1-1112 .    {
 1-1113 .       run_this; 
 1-1114 .       break;
 1-1115 .    }
 1-1116 .    case two:
 1-1117 .    {
 1-1118 .       run_this;
 1-1119 .       break;
 1-1120 .    }
 1-1121 .    default:
 1-1122 .    {
 1-1123 .        SwError;
 1-1124 .    }
 1-1125 . }
 1-1126 . 
 1-1127 . 
 1-1128 . if (A > = B)
 1-1129 . {
 1-1130 .    A = B + C;
 1-1131 .    D = E + F;
 1-1132 . }
 1-1133 . 
 1-1134 . /* LE SV TOC-2420 this is a pwr-01.9.27 req to detect error*/
 1-1135 . A = B+C;
 1-1136 . 
 1-1137 . switch (pwr stuff)
 1-1138 . {
 1-1139 .    case one:
 1-1140 .    {
 1-1141 .       run_this;
 1-1142 .       break;
 1-1143 .    }
 1-1144 .    case two:
 1-1145 .    {
 1-1146 .       run_this;
 1-1147 .       break;
 1-1148 .    }
 1-1149 .    // missing default
 1-1150 . }
 1-1151 . 
 1-1152 . A = B+C;
 1-1153 . A = B-C;
 1-1154 . A = B+C;
 1-1155 . A = B/C;
 1-1156 . 
 1-1157 . if (A ne B)
 1-1158 . {
 1-1159 .    A = B + C;
 1-1160 .    D = E + F;
 1-1161 . }
 1-1162 . 
 1-1163 . 
 1-1164 . if (A >  B)
 1-1165 . {
 1-1166 .    A = B + C;
 1-1167 .    D = E + F;
 1-1168 . }
 1-1169 . 
 1-1170 . 
 1-1171 . if (A ne B)
 1-1172 . {
 1-1173 .    A = B + C;
 1-1174 .    D = E + F;
 1-1175 . }
 1-1176 . 
 1-1177 . A = B+C;
 1-1178 . A = B-C;
 1-1179 . A = B*C;
 1-1180 . A = B*C;
 1-1181 . A = B/C;
 1-1182 . 
 1-1183 . if (A ge B)
 1-1184 . {
 1-1185 .    A = B + C;
 1-1186 .    D = E + F;
 1-1187 . }
 1-1188 . 
 1-1189 . A = B-C;
 1-1190 . 
 1-1191 . if (A le B)
 1-1192 . {
 1-1193 .    A = B + C;
 1-1194 .    D = E + F;
 1-1195 . }
 1-1196 . 
 1-1197 . A = B+C;
 1-1198 . 
 1-1199 . switch (pwr stuff)
 1-1200 . {
 1-1201 .    case one:
 1-1202 .    {
 1-1203 .       run_this; 
 1-1204 .       break;
 1-1205 .    }
 1-1206 .    case two:
 1-1207 .    {
 1-1208 .       run_this;
 1-1209 .       break;
 1-1210 .    }
 1-1211 .    default:
 1-1212 .    {
 1-1213 .        SwError;
 1-1214 .    }
 1-1215 . }
 1-1216 . 
 1-1217 . A = B*C;
 1-1218 . A = B/C;
 1-1219 . 
 1-1220 . if (A lt B)
 1-1221 . {
 1-1222 .    A = B + C;
 1-1223 .    D = E + F;
 1-1224 . }
 1-1225 . 
 1-1226 . A = B/C;
 1-1227 . A = B*C;
 1-1228 . 
 1-1229 . if (A ge B)
 1-1230 . {
 1-1231 .    A = B + C;
 1-1232 .    D = E + F;
 1-1233 . }
 1-1234 . 
 1-1235 . // max LOC 50
 1-1236 . 
 1-1237 . }
 1-1238 . 
 1-1239 . 
 1-1240 . /*
 1-1241 . -----------------------------------------------------------------------------
 1-1242 . --| NAME:   pwr.1.10
 1-1243 . --|
 1-1244 . --| ABSTRACT:
 1-1245 . --|   This function does pwr stuff.
 1-1246 . --|
 1-1247 . --| RETURNS:
 1-1248 . --|   NONE.
 1-1249 . --|
 1-1250 . ----------------------------------------------------------------------------
 1-1251 . */
 1-1252 . static void pwr.1.10(void)
 1-1253 . {
 1-1254 . A = B*C;
 1-1255 . A = B*C;
 1-1256 . A = B*C;
 1-1257 . A = B/C;
 1-1258 . A = B/C;
 1-1259 . A = B*C;
 1-1260 . A = B/C;
 1-1261 . 
 1-1262 . if (A le B)
 1-1263 . {
 1-1264 .    A = B + C;
 1-1265 .    D = E + F;
 1-1266 . }
 1-1267 . 
 1-1268 . A = B/C;
 1-1269 . A = B/C;
 1-1270 . A = B/C;
 1-1271 . A = B/C;
 1-1272 . A = B-C;
 1-1273 . 
 1-1274 . if (A lt B)
 1-1275 . {
 1-1276 .    A = B + C;
 1-1277 .    D = E + F;
 1-1278 . }
 1-1279 . 
 1-1280 . A = B*C;
 1-1281 . A = B+C;
 1-1282 . A = B*C;
 1-1283 . A = B-C;
 1-1284 . 
 1-1285 . if (A <  B)
 1-1286 . {
 1-1287 .    A = B + C;
 1-1288 .    D = E + F;
 1-1289 . }
 1-1290 . 
 1-1291 . A = B+C;
 1-1292 . A = B/C;
 1-1293 . A = B/C;
 1-1294 . A = B+C;
 1-1295 . A = B+C;
 1-1296 . A = B/C;
 1-1297 . rcv_buffer = (U16 *) alloc(size+1);
 1-1298 . A = B-C;
 1-1299 . send_buffer = (U16 *) malloc(size+1);
 1-1300 . A = B+C;
 1-1301 . 
 1-1302 . if (A gt B)
 1-1303 . {
 1-1304 .    A = B + C;
 1-1305 .    D = E + F;
 1-1306 . }
 1-1307 . 
 1-1308 . // (P) this is really improtant
 1-1309 . A = B*C;
 1-1310 . A = B*C;
 1-1311 . A = B/C;
 1-1312 . A = B*C;
 1-1313 . A = B*C;
 1-1314 . A = B-C;
 1-1315 . 
 1-1316 . if (A != B)
 1-1317 . {
 1-1318 .    A = B + C;
 1-1319 .    D = E + F;
 1-1320 . }
 1-1321 . 
 1-1322 . A = B/C;
 1-1323 . A = B*C;
 1-1324 . A = B/C;
 1-1325 . A = B-C;
 1-1326 . 
 1-1327 . if (A == B)
 1-1328 . {
 1-1329 .    A = B + C;
 1-1330 .    D = E + F;
 1-1331 . }
 1-1332 . 
 1-1333 . A = B-C;
 1-1334 . 
 1-1335 . if (A != B)
 1-1336 . {
 1-1337 .    A = B + C;
 1-1338 .    D = E + F;
 1-1339 . }
 1-1340 . 
 1-1341 . A = B/C;
 1-1342 . A = B+C;
 1-1343 . // max LOC 44
 1-1344 . 
 1-1345 . }
 1-1346 . 
 1-1347 . 
 1-1348 . /*
 1-1349 . -----------------------------------------------------------------------------
 1-1350 . --| NAME:   pwr.1.11
 1-1351 . --|
 1-1352 . --| ABSTRACT:
 1-1353 . --|   This function does pwr stuff.
 1-1354 . --|
 1-1355 . --| RETURNS:
 1-1356 . --|   NONE.
 1-1357 . --|
 1-1358 . ----------------------------------------------------------------------------
 1-1359 . */
 1-1360 . static void pwr.1.11(void)
 1-1361 . {
 1-1362 . A = B/C;
 1-1363 . A = B/C;
 1-1364 . A = B/C;
 1-1365 . /* LE SV TOC-2421 this is a pwr-01.11.4 req to store*/
 1-1366 . A = B+C;
 1-1367 . /* LE SV TOC-2422 this is a pwr-01.11.5 req to update*/
 1-1368 . 
 1-1369 . if (A > = B)
 1-1370 . {
 1-1371 .    A = B + C;
 1-1372 .    D = E + F;
 1-1373 . }
 1-1374 . 
 1-1375 . A = B-C;
 1-1376 . A = B/C;
 1-1377 . A = B/C;
 1-1378 . /* LE SV TOC-2423 this is a pwr-01.11.9 req to fail*/
 1-1379 . A = B-C;
 1-1380 . 
 1-1381 . if (A >  B)
 1-1382 . {
 1-1383 .    A = B + C;
 1-1384 .    D = E + F;
 1-1385 . }
 1-1386 . 
 1-1387 . 
 1-1388 . if (A > = B)
 1-1389 . {
 1-1390 .    A = B + C;
 1-1391 .    D = E + F;
 1-1392 . }
 1-1393 . 
 1-1394 . A = B-C;
 1-1395 . 
 1-1396 . /*
 1-1397 . dead_block = C * D; 
 1-1398 . dead_block = E * F;
 1-1399 . */
 1-1400 . 
 1-1401 . 
 1-1402 . if (A ge B)
 1-1403 . {
 1-1404 .    A = B + C;
 1-1405 .    D = E + F;
 1-1406 . }
 1-1407 . 
 1-1408 . /* LE SV TOC-2424 this is a pwr-01.11.14 req to compare*/
 1-1409 . 
 1-1410 . if (A le B)
 1-1411 . {
 1-1412 .    A = B + C;
 1-1413 .    D = E + F;
 1-1414 . }
 1-1415 . 
 1-1416 . 
 1-1417 . if (A gt B)
 1-1418 . {
 1-1419 .    A = B + C;
 1-1420 .    D = E + F;
 1-1421 . }
 1-1422 . 
 1-1423 . 
 1-1424 . if (A ne B)
 1-1425 . {
 1-1426 .    A = B + C;
 1-1427 .    D = E + F;
 1-1428 . }
 1-1429 . 
 1-1430 . A = B-C;
 1-1431 . 
 1-1432 . if (A > = B)
 1-1433 . {
 1-1434 .    A = B + C;
 1-1435 .    D = E + F;
 1-1436 . }
 1-1437 . 
 1-1438 . 
 1-1439 . if (A > = B)
 1-1440 . {
 1-1441 .    A = B + C;
 1-1442 .    D = E + F;
 1-1443 . }
 1-1444 . 
 1-1445 . free(FreePtr);
 1-1446 . A = B-C;
 1-1447 . 
 1-1448 . if (A > = B)
 1-1449 . {
 1-1450 .    A = B + C;
 1-1451 .    D = E + F;
 1-1452 . }
 1-1453 . 
 1-1454 . /* dead_code = A * B; */
 1-1455 . 
 1-1456 . if (A != B)
 1-1457 . {
 1-1458 .    A = B + C;
 1-1459 .    D = E + F;
 1-1460 . }
 1-1461 . 
 1-1462 . 
 1-1463 . if (A == B)
 1-1464 . {
 1-1465 .    A = B + C;
 1-1466 .    D = E + F;
 1-1467 . }
 1-1468 . 
 1-1469 . A = B/C;
 1-1470 . A = B*C;
 1-1471 . A = B-C;
 1-1472 . 
 1-1473 . if (A lt B)
 1-1474 . {
 1-1475 .    A = B + C;
 1-1476 .    D = E + F;
 1-1477 . }
 1-1478 . 
 1-1479 . // max LOC 27
 1-1480 . 
 1-1481 . }
 1-1482 . 
 1-1483 . 
 1-1484 . /*
 1-1485 . -----------------------------------------------------------------------------
 1-1486 . --| NAME:   pwr.1.12
 1-1487 . --|
 1-1488 . --| ABSTRACT:
 1-1489 . --|   This function does pwr stuff.
 1-1490 . --|
 1-1491 . --| RETURNS:
 1-1492 . --|   NONE.
 1-1493 . --|
 1-1494 . ----------------------------------------------------------------------------
 1-1495 . */
 1-1496 . static void pwr.1.12(void)
 1-1497 . {
 1-1498 . A = B-C;
 1-1499 . 
 1-1500 . if (A lt B)
 1-1501 . {
 1-1502 .    A = B + C;
 1-1503 .    D = E + F;
 1-1504 . }
 1-1505 . 
 1-1506 . A = B+C;
 1-1507 . 
 1-1508 . if (A lt B)
 1-1509 . {
 1-1510 .    A = B + C;
 1-1511 .    D = E + F;
 1-1512 . }
 1-1513 . 
 1-1514 . 
 1-1515 . if (A >  B)
 1-1516 . {
 1-1517 .    A = B + C;
 1-1518 .    D = E + F;
 1-1519 . }
 1-1520 . 
 1-1521 . A = B/C;
 1-1522 . A = B+C;
 1-1523 . 
 1-1524 . if (A ne B)
 1-1525 . {
 1-1526 .    A = B + C;
 1-1527 .    D = E + F;
 1-1528 . }
 1-1529 . 
 1-1530 . 
 1-1531 . if (A == B)
 1-1532 . {
 1-1533 .    A = B + C;
 1-1534 .    D = E + F;
 1-1535 . }
 1-1536 . 
 1-1537 . A = 0x0004;
 1-1538 . 
 1-1539 . if (A <  B)
 1-1540 . {
 1-1541 .    A = B + C;
 1-1542 .    D = E + F;
 1-1543 . }
 1-1544 . 
 1-1545 . A = B*C;
 1-1546 . A = B/C;
 1-1547 . 
 1-1548 . if (A > = B)
 1-1549 . {
 1-1550 .    A = B + C;
 1-1551 .    D = E + F;
 1-1552 . }
 1-1553 . 
 1-1554 . A = B+C;
 1-1555 . A = B-C;
 1-1556 . 
 1-1557 . if (A eq B)
 1-1558 . {
 1-1559 .    A = B + C;
 1-1560 .    D = E + F;
 1-1561 . }
 1-1562 . 
 1-1563 . 
 1-1564 . if (A ge B)
 1-1565 . {
 1-1566 .    A = B + C;
 1-1567 .    D = E + F;
 1-1568 . }
 1-1569 . 
 1-1570 . A = B+C;
 1-1571 . A = B+C;
 1-1572 . A = B/C;
 1-1573 . A = B-C;
 1-1574 . A = B-C;
 1-1575 . 
 1-1576 . if (A > = B)
 1-1577 . {
 1-1578 .    A = B + C;
 1-1579 .    D = E + F;
 1-1580 . }
 1-1581 . 
 1-1582 . A = B/C;
 1-1583 . A = B+C;
 1-1584 . A = B-C;
 1-1585 . A = B+C;
 1-1586 . A = B-C;
 1-1587 . /* LE SV TOC-2425 this is a pwr-01.12.29 req to call admin*/
 1-1588 . A = 0x0004;
 1-1589 . 
 1-1590 . if (A lt B)
 1-1591 . {
 1-1592 .    A = B + C;
 1-1593 .    D = E + F;
 1-1594 . }
 1-1595 . 
 1-1596 . A = B*C;
 1-1597 . 
 1-1598 . if (A == B)
 1-1599 . {
 1-1600 .    A = B + C;
 1-1601 .    D = E + F;
 1-1602 . }
 1-1603 . 
 1-1604 . /* LE SV TOC-2426 this is a pwr-01.12.32 req to set RTC*/
 1-1605 . 
 1-1606 . if (A == B)
 1-1607 . {
 1-1608 .    A = B + C;
 1-1609 .    D = E + F;
 1-1610 . }
 1-1611 . 
 1-1612 . 
 1-1613 . if (A == B)
 1-1614 . {
 1-1615 .    A = B + C;
 1-1616 .    D = E + F;
 1-1617 . }
 1-1618 . 
 1-1619 . A = B*C;
 1-1620 . A = B-C;
 1-1621 . A = B-C;
 1-1622 . A = B/C;
 1-1623 . 
 1-1624 . if (A le B)
 1-1625 . {
 1-1626 .    A = B + C;
 1-1627 .    D = E + F;
 1-1628 . }
 1-1629 . 
 1-1630 . A = B*C;
 1-1631 . 
 1-1632 . if (A gt B)
 1-1633 . {
 1-1634 .    A = B + C;
 1-1635 .    D = E + F;
 1-1636 . }
 1-1637 . 
 1-1638 . 
 1-1639 . if (A ge B)
 1-1640 . {
 1-1641 .    A = B + C;
 1-1642 .    D = E + F;
 1-1643 . }
 1-1644 . 
 1-1645 . A = B*C;
 1-1646 . A = B/C;
 1-1647 . A = B-C;
 1-1648 . 
 1-1649 . if (A eq B)
 1-1650 . {
 1-1651 .    A = B + C;
 1-1652 .    D = E + F;
 1-1653 . }
 1-1654 . 
 1-1655 . /* LE SV TOC-2427 this is a pwr-01.12.46 req to convert*/
 1-1656 . A = B/C;
 1-1657 . A = B/C;
 1-1658 . A = B/C;
 1-1659 . 
 1-1660 . if (A ge B)
 1-1661 . {
 1-1662 .    A = B + C;
 1-1663 .    D = E + F;
 1-1664 . }
 1-1665 . 
 1-1666 . A = B*C;
 1-1667 . A = B/C;
 1-1668 . A = B/C;
 1-1669 . // max LOC 52
 1-1670 . 
 1-1671 . }
 1-1672 . 
 1-1673 . 
 1-1674 . /*
 1-1675 . -----------------------------------------------------------------------------
 1-1676 . --| NAME:   pwr.1.13
 1-1677 . --|
 1-1678 . --| ABSTRACT:
 1-1679 . --|   This function does pwr stuff.
 1-1680 . --|
 1-1681 . --| RETURNS:
 1-1682 . --|   NONE.
 1-1683 . --|
 1-1684 . ----------------------------------------------------------------------------
 1-1685 . */
 1-1686 . static void pwr.1.13(void)
 1-1687 . {
 1-1688 . 
 1-1689 . if (A gt B)
 1-1690 . {
 1-1691 .    A = B + C;
 1-1692 .    D = E + F;
 1-1693 . }
 1-1694 . 
 1-1695 . 
 1-1696 . switch (pwr stuff)
 1-1697 . {
 1-1698 .    case one:
 1-1699 .    {
 1-1700 .       run_this; 
 1-1701 .       // missing break
 1-1702 .    }
 1-1703 .    case two:
 1-1704 .    {
 1-1705 .       run_this;
 1-1706 .       break;
 1-1707 .    }
 1-1708 .    default:
 1-1709 .    {
 1-1710 .       SwError;
 1-1711 .    }
 1-1712 . }
 1-1713 . 
 1-1714 . A = B-C;
 1-1715 . A = B+C;
 1-1716 . 
 1-1717 . if (A le B)
 1-1718 . {
 1-1719 .    A = B + C;
 1-1720 .    D = E + F;
 1-1721 . }
 1-1722 . 
 1-1723 . 
 1-1724 . if (A ne B)
 1-1725 . {
 1-1726 .    A = B + C;
 1-1727 .    D = E + F;
 1-1728 . }
 1-1729 . 
 1-1730 . 
 1-1731 . if (A <  B)
 1-1732 . {
 1-1733 .    A = B + C;
 1-1734 .    D = E + F;
 1-1735 . }
 1-1736 . 
 1-1737 . A = B-C;
 1-1738 . A = B+C;
 1-1739 . 
 1-1740 . if (A < = B)
 1-1741 . {
 1-1742 .    A = B + C;
 1-1743 .    D = E + F;
 1-1744 . }
 1-1745 . 
 1-1746 . /* LE SV TOC-2428 this is a pwr-01.13.10 req to detect error*/
 1-1747 . A = B*C;
 1-1748 . A = B-C;
 1-1749 . 
 1-1750 . if (A < = B)
 1-1751 . {
 1-1752 .    A = B + C;
 1-1753 .    D = E + F;
 1-1754 . }
 1-1755 . 
 1-1756 . A = B*C;
 1-1757 . A = B/C;
 1-1758 . // max LOC 14
 1-1759 . 
 1-1760 . }
 1-1761 . 

1 1 Result: result/source/pr-app/pr-app-PWR123/pwr-01.c
2 2 Source: source/pr-app/pr-app-PWR123/pwr-02.c
 2-0 . /*
 2-1 . ----------------------------------------------------------------------------
 2-2 . --| BEGIN PROLOGUE
 2-3 . --|
 2-4 . --| CLASSIFICATION: UNCLASSIFIED
 2-5 . --|
 2-6 . --| FILE NAME:      pwr-02.c
 2-7 . --|
 2-8 . --| ABSTRACT:
 2-9 . --|   This file contains the 6 functions that do file pwr stuff.
 2-10 . --|
 2-11 . --| HISTORY:
 2-12 . --|   CCCQ_NAME:
 2-13 . --|   CCCQ_VER: 
 2-14 . --|
 2-15 . --| END PROLOGUE
 2-16 . ----------------------------------------------------------------------------
 2-17 . */
 2-18 . 
 2-19 . #define A;
 2-20 . 
 2-21 . 
 2-22 . 
 2-23 . /*
 2-24 . -----------------------------------------------------------------------------
 2-25 . --| NAME:   pwr.2.1
 2-26 . --|
 2-27 . --| ABSTRACT:
 2-28 . --|   This function does pwr stuff.
 2-29 . --|
 2-30 . --| RETURNS:
 2-31 . --|   NONE.
 2-32 . --|
 2-33 . ----------------------------------------------------------------------------
 2-34 . */
 2-35 . static void pwr.2.1(void)
 2-36 . {
 2-37 . 
 2-38 . if (A le B)
 2-39 . {
 2-40 .    A = B + C;
 2-41 .    D = E + F;
 2-42 . }
 2-43 . 
 2-44 . A = B+C;
 2-45 . A = B+C;
 2-46 . A = B-C;
 2-47 . A = B*C;
 2-48 . A = B*C;
 2-49 . 
 2-50 . if (A ge B)
 2-51 . {
 2-52 .    A = B + C;
 2-53 .    D = E + F;
 2-54 . }
 2-55 . 
 2-56 . A = B/C;
 2-57 . /* LE SV TOC-2429 this is a pwr-02.1.9 req to call admin*/
 2-58 . 
 2-59 . if (A lt B)
 2-60 . {
 2-61 .    A = B + C;
 2-62 .    D = E + F;
 2-63 . }
 2-64 . 
 2-65 . A = B-C;
 2-66 . // max LOC 10
 2-67 . 
 2-68 . }
 2-69 . 
 2-70 . 
 2-71 . /*
 2-72 . -----------------------------------------------------------------------------
 2-73 . --| NAME:   pwr.2.2
 2-74 . --|
 2-75 . --| ABSTRACT:
 2-76 . --|   This function does pwr stuff.
 2-77 . --|
 2-78 . --| RETURNS:
 2-79 . --|   NONE.
 2-80 . --|
 2-81 . ----------------------------------------------------------------------------
 2-82 . */
 2-83 . static void pwr.2.2(void)
 2-84 . {
 2-85 . 
 2-86 . if (A > = B)
 2-87 . {
 2-88 .    A = B + C;
 2-89 .    D = E + F;
 2-90 . }
 2-91 . 
 2-92 . // ??? go see ws
 2-93 . 
 2-94 . if (A le B)
 2-95 . {
 2-96 .    A = B + C;
 2-97 .    D = E + F;
 2-98 . }
 2-99 . 
 2-100 . 
 2-101 . switch (pwr stuff)
 2-102 . {
 2-103 .    case one:
 2-104 .    {
 2-105 .       run_this; 
 2-106 .       break;
 2-107 .    }
 2-108 .    case two:
 2-109 .    {
 2-110 .       run_this;
 2-111 .       break;
 2-112 .    }
 2-113 .    default:
 2-114 .    {
 2-115 .        SwError;
 2-116 .    }
 2-117 . }
 2-118 . 
 2-119 . A = B/C;
 2-120 . A = B/C;
 2-121 . 
 2-122 . if (A != B)
 2-123 . {
 2-124 .    A = B + C;
 2-125 .    D = E + F;
 2-126 . }
 2-127 . 
 2-128 . 
 2-129 . /* dead_block = C * D; 
 2-130 . dead_block = E * F; */
 2-131 . 
 2-132 . A = B+C;
 2-133 . A = B+C;
 2-134 . 
 2-135 . if (A ge B)
 2-136 . {
 2-137 .    A = B + C;
 2-138 .    D = E + F;
 2-139 . }
 2-140 . 
 2-141 . A = B*C;
 2-142 . A = B-C;
 2-143 . 
 2-144 . if (A > = B)
 2-145 . {
 2-146 .    A = B + C;
 2-147 .    D = E + F;
 2-148 . }
 2-149 . 
 2-150 . 
 2-151 . if (A == B)
 2-152 . {
 2-153 .    A = B + C;
 2-154 .    D = E + F;
 2-155 . }
 2-156 . 
 2-157 . 
 2-158 . /*
 2-159 . dead_block = C * D; 
 2-160 . dead_block = E * F;
 2-161 . */
 2-162 . 
 2-163 . A = B-C;
 2-164 . A = 0x0008;
 2-165 . A = B/C;
 2-166 . 
 2-167 . switch (pwr stuff)
 2-168 . {
 2-169 .    case one:
 2-170 .    {
 2-171 .       run_this; 
 2-172 .       break;
 2-173 .    }
 2-174 .    case two:
 2-175 .    {
 2-176 .       run_this;
 2-177 .       break;
 2-178 .    }
 2-179 .    default:
 2-180 .    {
 2-181 .        SwError;
 2-182 .    }
 2-183 . }
 2-184 . 
 2-185 . A = B/C;
 2-186 . A = B*C;
 2-187 . 
 2-188 . if (A != B)
 2-189 . {
 2-190 .    A = B + C;
 2-191 .    D = E + F;
 2-192 . }
 2-193 . 
 2-194 . /* LE SV TOC-2430 this is a pwr-02.2.20 req to increment*/
 2-195 . 
 2-196 . if (A >  B)
 2-197 . {
 2-198 .    A = B + C;
 2-199 .    D = E + F;
 2-200 . }
 2-201 . 
 2-202 . A = B-C;
 2-203 . A = B/C;
 2-204 . A = B/C;
 2-205 . A = B/C;
 2-206 . A = B*C;
 2-207 . A = B-C;
 2-208 . A = B*C;
 2-209 . 
 2-210 . if (A <  B)
 2-211 . {
 2-212 .    A = B + C;
 2-213 .    D = E + F;
 2-214 . }
 2-215 . 
 2-216 . A = (long)B + C;
 2-217 . 
 2-218 . if (A != B)
 2-219 . {
 2-220 .    A = B + C;
 2-221 .    D = E + F;
 2-222 . }
 2-223 . 
 2-224 . A = B*C;
 2-225 . 
 2-226 . if (A <  B)
 2-227 . {
 2-228 .    A = B + C;
 2-229 .    D = E + F;
 2-230 . }
 2-231 . 
 2-232 . A = B+C;
 2-233 . A = B-C;
 2-234 . 
 2-235 . if (A le B)
 2-236 . {
 2-237 .    A = B + C;
 2-238 .    D = E + F;
 2-239 . }
 2-240 . 
 2-241 . 
 2-242 . if (A != B)
 2-243 . {
 2-244 .    A = B + C;
 2-245 .    D = E + F;
 2-246 . }
 2-247 . 
 2-248 . A = B-C;
 2-249 . /* LE SV TOC-2431 this is a pwr-02.2.37 req to fail*/
 2-250 . A = B+C;
 2-251 . // max LOC 37
 2-252 . 
 2-253 . }
 2-254 . 
 2-255 . 
 2-256 . /*
 2-257 . -----------------------------------------------------------------------------
 2-258 . --| NAME:   pwr.2.3
 2-259 . --|
 2-260 . --| ABSTRACT:
 2-261 . --|   This function does pwr stuff.
 2-262 . --|
 2-263 . --| RETURNS:
 2-264 . --|   NONE.
 2-265 . --|
 2-266 . ----------------------------------------------------------------------------
 2-267 . */
 2-268 . static void pwr.2.3(void)
 2-269 . {
 2-270 . 
 2-271 . if (A < = B)
 2-272 . {
 2-273 .    A = B + C;
 2-274 .    D = E + F;
 2-275 . }
 2-276 . 
 2-277 . A = B/C;
 2-278 . A = 0x0001;
 2-279 . A = B*C;
 2-280 . FreePtr = HmiStringPtr;
 2-281 . 
 2-282 . if (A < = B)
 2-283 . {
 2-284 .    A = B + C;
 2-285 .    D = E + F;
 2-286 . }
 2-287 . 
 2-288 . A = B*C;
 2-289 . A = B+C;
 2-290 . A = B+C;
 2-291 . A = B-C;
 2-292 . A = B/C;
 2-293 . 
 2-294 . if (A ge B)
 2-295 . {
 2-296 .    A = B + C;
 2-297 .    D = E + F;
 2-298 . }
 2-299 . 
 2-300 . A = B/C;
 2-301 . A = B+C;
 2-302 . A = B+C;
 2-303 . A = B/C;
 2-304 . A = B/C;
 2-305 . 
 2-306 . if (A ne B)
 2-307 . {
 2-308 .    A = B + C;
 2-309 .    D = E + F;
 2-310 . }
 2-311 . 
 2-312 . A = B-C;
 2-313 . goto error;
 2-314 . A = B-C;
 2-315 . 
 2-316 . if (A == B)
 2-317 . {
 2-318 .    A = B + C;
 2-319 .    D = E + F;
 2-320 . }
 2-321 . 
 2-322 . A = B/C;
 2-323 . A = B-C;
 2-324 . A = B*C;
 2-325 . 
 2-326 . if (A lt B)
 2-327 . {
 2-328 .    A = B + C;
 2-329 .    D = E + F;
 2-330 . }
 2-331 . 
 2-332 . A = B*C;
 2-333 . 
 2-334 . if (A != B)
 2-335 . {
 2-336 .    A = B + C;
 2-337 .    D = E + F;
 2-338 . }
 2-339 . 
 2-340 . 
 2-341 . switch (pwr stuff)
 2-342 . {
 2-343 .    case one:
 2-344 .    {
 2-345 .       switch (nested)
 2-346 .       {
 2-347 .          case:
 2-348 .             X = Y + Z;
 2-349 .          case:
 2-350 .             X = Y + Z;
 2-351 .          default:
 2-352 .             SwError;
 2-353 .       } 
 2-354 .    }
 2-355 .    case two:
 2-356 .    {
 2-357 .       run_this;
 2-358 .       break;
 2-359 .    }
 2-360 .    default:
 2-361 .    {
 2-362 .       SwError;
 2-363 .    }
 2-364 . }
 2-365 . 
 2-366 . A = B/C;
 2-367 . 
 2-368 . switch (pwr stuff)
 2-369 . {
 2-370 .    case one:
 2-371 .    {
 2-372 .       run_this; 
 2-373 .       break;
 2-374 .    }
 2-375 .    case two:
 2-376 .    {
 2-377 .       run_this;
 2-378 .       break;
 2-379 .    }
 2-380 .    default:
 2-381 .    {
 2-382 .        SwError;
 2-383 .    }
 2-384 . }
 2-385 . 
 2-386 . A = B-C;
 2-387 . A = B+C;
 2-388 . 
 2-389 . if (A lt B)
 2-390 . {
 2-391 .    A = B + C;
 2-392 .    D = E + F;
 2-393 . }
 2-394 . 
 2-395 . A = B-C;
 2-396 . 
 2-397 . switch (pwr stuff)
 2-398 . {
 2-399 .    case one:
 2-400 .    {
 2-401 .       run_this; 
 2-402 .       // missing break
 2-403 .    }
 2-404 .    case two:
 2-405 .    {
 2-406 .       run_this;
 2-407 .       break;
 2-408 .    }
 2-409 .    default:
 2-410 .    {
 2-411 .       SwError;
 2-412 .    }
 2-413 . }
 2-414 . 
 2-415 . A = B*C;
 2-416 . A = B+C;
 2-417 . A = B+C;
 2-418 . 
 2-419 . if (A le B)
 2-420 . {
 2-421 .    A = B + C;
 2-422 .    D = E + F;
 2-423 . }
 2-424 . 
 2-425 . 
 2-426 . if (A >  B)
 2-427 . {
 2-428 .    A = B + C;
 2-429 .    D = E + F;
 2-430 . }
 2-431 . 
 2-432 . 
 2-433 . if (A le B)
 2-434 . {
 2-435 .    A = B + C;
 2-436 .    D = E + F;
 2-437 . }
 2-438 . 
 2-439 . A = B/C;
 2-440 . A = B+C;
 2-441 . A = B/C;
 2-442 . 
 2-443 . if (A lt B)
 2-444 . {
 2-445 .    A = B + C;
 2-446 .    D = E + F;
 2-447 . }
 2-448 . 
 2-449 . A = B+C;
 2-450 . 
 2-451 . if (A <  B)
 2-452 . {
 2-453 .    A = B + C;
 2-454 .    D = E + F;
 2-455 . }
 2-456 . 
 2-457 . A = B/C;
 2-458 . 
 2-459 . if (A le B)
 2-460 . {
 2-461 .    A = B + C;
 2-462 .    D = E + F;
 2-463 . }
 2-464 . 
 2-465 . A = B+C;
 2-466 . A = B*C;
 2-467 . 
 2-468 . if (A le B)
 2-469 . {
 2-470 .    A = B + C;
 2-471 .    D = E + F;
 2-472 . }
 2-473 . 
 2-474 . A = B/C;
 2-475 . A = B-C;
 2-476 . A = B-C;
 2-477 . /* LE SV TOC-2432 this is a pwr-02.3.52 req to update*/
 2-478 . A = B/C;
 2-479 . 
 2-480 . if (A lt B)
 2-481 . {
 2-482 .    A = B + C;
 2-483 .    D = E + F;
 2-484 . }
 2-485 . 
 2-486 . A = B-C;
 2-487 . 
 2-488 . switch (pwr stuff)
 2-489 . {
 2-490 .    case one:
 2-491 .    {
 2-492 .       run_this; 
 2-493 .       break;
 2-494 .    }
 2-495 .    case two:
 2-496 .    {
 2-497 .       run_this;
 2-498 .       break;
 2-499 .    }
 2-500 .    default:
 2-501 .    {
 2-502 .        SwError;
 2-503 .    }
 2-504 . }
 2-505 . 
 2-506 . A = B-C;
 2-507 . A = B-C;
 2-508 . 
 2-509 . if (A < = B)
 2-510 . {
 2-511 .    A = B + C;
 2-512 .    D = E + F;
 2-513 . }
 2-514 . 
 2-515 . 
 2-516 . if (A gt B)
 2-517 . {
 2-518 .    A = B + C;
 2-519 .    D = E + F;
 2-520 . }
 2-521 . 
 2-522 . A = B-C;
 2-523 . A = 0x0001;
 2-524 . A = B/C;
 2-525 . A = B*C;
 2-526 . 
 2-527 . if (A < = B)
 2-528 . {
 2-529 .    A = B + C;
 2-530 .    D = E + F;
 2-531 . }
 2-532 . 
 2-533 . A = B-C;
 2-534 . 
 2-535 . if (A <  B)
 2-536 . {
 2-537 .    A = B + C;
 2-538 .    D = E + F;
 2-539 . }
 2-540 . 
 2-541 . A = B/C;
 2-542 . A = B-C;
 2-543 . A = B+C;
 2-544 . 
 2-545 . if (A < = B)
 2-546 . {
 2-547 .    A = B + C;
 2-548 .    D = E + F;
 2-549 . }
 2-550 . 
 2-551 . A = B/C;
 2-552 . // max LOC 70
 2-553 . 
 2-554 . }
 2-555 . 
 2-556 . 
 2-557 . /*
 2-558 . -----------------------------------------------------------------------------
 2-559 . --| NAME:   pwr.2.4
 2-560 . --|
 2-561 . --| ABSTRACT:
 2-562 . --|   This function does pwr stuff.
 2-563 . --|
 2-564 . --| RETURNS:
 2-565 . --|   NONE.
 2-566 . --|
 2-567 . ----------------------------------------------------------------------------
 2-568 . */
 2-569 . static void pwr.2.4(void)
 2-570 . {
 2-571 . A = B*C;
 2-572 . A = B-C;
 2-573 . A = B+C;
 2-574 . A = B+C;
 2-575 . A = B*C;
 2-576 . A = B/C;
 2-577 . A = B*C;
 2-578 . 
 2-579 . if (A > = B)
 2-580 . {
 2-581 .    A = B + C;
 2-582 .    D = E + F;
 2-583 . }
 2-584 . 
 2-585 . A = B+C;
 2-586 . A = B+C;
 2-587 . A = B*C;
 2-588 . // max LOC 11
 2-589 . 
 2-590 . }
 2-591 . 
 2-592 . 
 2-593 . /*
 2-594 . -----------------------------------------------------------------------------
 2-595 . --| NAME:   pwr.2.5
 2-596 . --|
 2-597 . --| ABSTRACT:
 2-598 . --|   This function does pwr stuff.
 2-599 . --|
 2-600 . --| RETURNS:
 2-601 . --|   NONE.
 2-602 . --|
 2-603 . ----------------------------------------------------------------------------
 2-604 . */
 2-605 . static void pwr.2.5(void)
 2-606 . {
 2-607 . A = B-C;
 2-608 . send_buffer = (U16 *) malloc(size+1);
 2-609 . A = B-C;
 2-610 . A = B*C;
 2-611 . A = B-C;
 2-612 . 
 2-613 . if (A != B)
 2-614 . {
 2-615 .    A = B + C;
 2-616 .    D = E + F;
 2-617 . }
 2-618 . 
 2-619 . A = B+C;
 2-620 . A = B/C;
 2-621 . 
 2-622 . if (A <  B)
 2-623 . {
 2-624 .    A = B + C;
 2-625 .    D = E + F;
 2-626 . }
 2-627 . 
 2-628 . A = B-C;
 2-629 . A = B*C;
 2-630 . 
 2-631 . /* dead_block = C * D; 
 2-632 . dead_block = E * F; */
 2-633 . 
 2-634 . A = B+C;
 2-635 . A = B+C;
 2-636 . A = B/C;
 2-637 . A = B-C;
 2-638 . A = B+C;
 2-639 . A = B+C;
 2-640 . A = B-C;
 2-641 . A = B+C;
 2-642 . 
 2-643 . switch (pwr stuff)
 2-644 . {
 2-645 .    case:
 2-646 .    case:
 2-647 .    // stacked case statements but only if there is a new line in between
 2-648 . 
 2-649 .    case:
 2-650 .    case:
 2-651 .    case:
 2-652 .    {
 2-653 .       run_this;
 2-654 .       break;
 2-655 .    }
 2-656 .    default:
 2-657 .    {
 2-658 .       halt;
 2-659 .    }
 2-660 . }
 2-661 . 
 2-662 . 
 2-663 . if (A lt B)
 2-664 . {
 2-665 .    A = B + C;
 2-666 .    D = E + F;
 2-667 . }
 2-668 . 
 2-669 . A = B/C;
 2-670 . A = B/C;
 2-671 . 
 2-672 . if (A gt B)
 2-673 . {
 2-674 .    A = B + C;
 2-675 .    D = E + F;
 2-676 . }
 2-677 . 
 2-678 . 
 2-679 . /* dead_block = C * D; 
 2-680 . dead_block = E * F; */
 2-681 . 
 2-682 . A = B-C;
 2-683 . A = B*C;
 2-684 . 
 2-685 . if (A ge B)
 2-686 . {
 2-687 .    A = B + C;
 2-688 .    D = E + F;
 2-689 . }
 2-690 . 
 2-691 . 
 2-692 . if (A != B)
 2-693 . {
 2-694 .    A = B + C;
 2-695 .    D = E + F;
 2-696 . }
 2-697 . 
 2-698 . 
 2-699 . if (A ne B)
 2-700 . {
 2-701 .    A = B + C;
 2-702 .    D = E + F;
 2-703 . }
 2-704 . 
 2-705 . A = B-C;
 2-706 . A = B-C;
 2-707 . 
 2-708 . if (A ne B)
 2-709 . {
 2-710 .    A = B + C;
 2-711 .    D = E + F;
 2-712 . }
 2-713 . 
 2-714 . A = B+C;
 2-715 . A = B*C;
 2-716 . A = B/C;
 2-717 . /* LE SV TOC-2433 this is a pwr-02.5.34 req to call admin*/
 2-718 . 
 2-719 . if (A ge B)
 2-720 . {
 2-721 .    A = B + C;
 2-722 .    D = E + F;
 2-723 . }
 2-724 . 
 2-725 . 
 2-726 . if (A le B)
 2-727 . {
 2-728 .    A = B + C;
 2-729 .    D = E + F;
 2-730 . }
 2-731 . 
 2-732 . A = B/C;
 2-733 . A = B+C;
 2-734 . 
 2-735 . if (A != B)
 2-736 . {
 2-737 .    A = B + C;
 2-738 .    D = E + F;
 2-739 . }
 2-740 . 
 2-741 . A = B*C;
 2-742 . A = B*C;
 2-743 . A = B*C;
 2-744 . A = B*C;
 2-745 . A = B+C;
 2-746 . 
 2-747 . if (A < = B)
 2-748 . {
 2-749 .    A = B + C;
 2-750 .    D = E + F;
 2-751 . }
 2-752 . 
 2-753 . 
 2-754 . switch (pwr stuff)
 2-755 . {
 2-756 .    case one:
 2-757 .    {
 2-758 .       run_this; 
 2-759 .       break;
 2-760 .    }
 2-761 .    case two:
 2-762 .    {
 2-763 .       run_this;
 2-764 .       break;
 2-765 .    }
 2-766 .    default:
 2-767 .    {
 2-768 .        SwError;
 2-769 .    }
 2-770 . }
 2-771 . 
 2-772 . A = B+C;
 2-773 . A = B*C;
 2-774 . A = B+C;
 2-775 . A = B-C;
 2-776 . A = B*C;
 2-777 . 
 2-778 . if (A eq B)
 2-779 . {
 2-780 .    A = B + C;
 2-781 .    D = E + F;
 2-782 . }
 2-783 . 
 2-784 . 
 2-785 . if (A >  B)
 2-786 . {
 2-787 .    A = B + C;
 2-788 .    D = E + F;
 2-789 . }
 2-790 . 
 2-791 . 
 2-792 . if (A gt B)
 2-793 . {
 2-794 .    A = B + C;
 2-795 .    D = E + F;
 2-796 . }
 2-797 . 
 2-798 . // max LOC 53
 2-799 . 
 2-800 . }
 2-801 . 
 2-802 . 
 2-803 . /*
 2-804 . -----------------------------------------------------------------------------
 2-805 . --| NAME:   pwr.2.6
 2-806 . --|
 2-807 . --| ABSTRACT:
 2-808 . --|   This function does pwr stuff.
 2-809 . --|
 2-810 . --| RETURNS:
 2-811 . --|   NONE.
 2-812 . --|
 2-813 . ----------------------------------------------------------------------------
 2-814 . */
 2-815 . static void pwr.2.6(void)
 2-816 . {
 2-817 . A = B/C;
 2-818 . 
 2-819 . if (A > = B)
 2-820 . {
 2-821 .    A = B + C;
 2-822 .    D = E + F;
 2-823 . }
 2-824 . 
 2-825 . A = B-C;
 2-826 . A = B*C;
 2-827 . A = B-C;
 2-828 . A = B-C;
 2-829 . 
 2-830 . if (A le B)
 2-831 . {
 2-832 .    A = B + C;
 2-833 .    D = E + F;
 2-834 . }
 2-835 . 
 2-836 . A = B-C;
 2-837 . A = B*C;
 2-838 . A = B*C;
 2-839 . A = B/C;
 2-840 . A = B+C;
 2-841 . A = 0x0002;
 2-842 . 
 2-843 . if (veg)
 2-844 .    // missing curly brace
 2-845 .    variable = orange;
 2-846 . 
 2-847 . A = B/C;
 2-848 . A = B-C;
 2-849 . 
 2-850 . if (A <  B)
 2-851 . {
 2-852 .    A = B + C;
 2-853 .    D = E + F;
 2-854 . }
 2-855 . 
 2-856 . A = B*C;
 2-857 . A = B+C;
 2-858 . A = B+C;
 2-859 . 
 2-860 . if (A < = B)
 2-861 . {
 2-862 .    A = B + C;
 2-863 .    D = E + F;
 2-864 . }
 2-865 . 
 2-866 . A = B+C;
 2-867 . A = B*C;
 2-868 . 
 2-869 . if (A >  B)
 2-870 . {
 2-871 .    A = B + C;
 2-872 .    D = E + F;
 2-873 . }
 2-874 . 
 2-875 . A = B-C;
 2-876 . 
 2-877 . if (A > = B)
 2-878 . {
 2-879 .    A = B + C;
 2-880 .    D = E + F;
 2-881 . }
 2-882 . 
 2-883 . 
 2-884 . if (A lt B)
 2-885 . {
 2-886 .    A = B + C;
 2-887 .    D = E + F;
 2-888 . }
 2-889 . 
 2-890 . A = B*C;
 2-891 . 
 2-892 . if (A ge B)
 2-893 . {
 2-894 .    A = B + C;
 2-895 .    D = E + F;
 2-896 . }
 2-897 . 
 2-898 . A = B*C;
 2-899 . 
 2-900 . if (A <  B)
 2-901 . {
 2-902 .    A = B + C;
 2-903 .    D = E + F;
 2-904 . }
 2-905 . 
 2-906 . /* LE SV TOC-2434 this is a pwr-02.6.30 req to check unix*/
 2-907 . 
 2-908 . if (A le B)
 2-909 . {
 2-910 .    A = B + C;
 2-911 .    D = E + F;
 2-912 . }
 2-913 . 
 2-914 . A = B*C;
 2-915 . A = B*C;
 2-916 . A = B+C;
 2-917 . A = B*C;
 2-918 . A = B+C;
 2-919 . 
 2-920 . if (A lt B)
 2-921 . {
 2-922 .    A = B + C;
 2-923 .    D = E + F;
 2-924 . }
 2-925 . 
 2-926 . A = 0x0001;
 2-927 . A = B*C;
 2-928 . A = B+C;
 2-929 . 
 2-930 . if (A le B)
 2-931 . {
 2-932 .    A = B + C;
 2-933 .    D = E + F;
 2-934 . }
 2-935 . 
 2-936 . /* LE SV TOC-2435 this is a pwr-02.6.40 req to compare*/
 2-937 . 
 2-938 . if {
 2-939 .    X = Y + Z;
 2-940 . }
 2-941 . else {
 2-942 .    halt;
 2-943 . }
 2-944 . 
 2-945 . 
 2-946 . if (A ge B)
 2-947 . {
 2-948 .    A = B + C;
 2-949 .    D = E + F;
 2-950 . }
 2-951 . 
 2-952 . 
 2-953 . /*
 2-954 . dead_block = C * D; 
 2-955 . dead_block = E * F;
 2-956 . */
 2-957 . 
 2-958 . A = B+C;
 2-959 . 
 2-960 . if (A ge B)
 2-961 . {
 2-962 .    A = B + C;
 2-963 .    D = E + F;
 2-964 . }
 2-965 . 
 2-966 . A = B+C;
 2-967 . /* LE SV TOC-2436 this is a pwr-02.6.44 req to call admin*/
 2-968 . A = B*C;
 2-969 . 
 2-970 . if (A != B)
 2-971 . {
 2-972 .    A = B + C;
 2-973 .    D = E + F;
 2-974 . }
 2-975 . 
 2-976 . /* LE SV TOC-2437 this is a pwr-02.6.46 req to detect error*/
 2-977 . 
 2-978 . if (A >  B)
 2-979 . {
 2-980 .    A = B + C;
 2-981 .    D = E + F;
 2-982 . }
 2-983 . 
 2-984 . A = B+C;
 2-985 . /* LE SV TOC-2438 this is a pwr-02.6.48 req to verify*/
 2-986 . A = B*C;
 2-987 . 
 2-988 . if (A == B)
 2-989 . {
 2-990 .    A = B + C;
 2-991 .    D = E + F;
 2-992 . }
 2-993 . 
 2-994 . A = B-C;
 2-995 . 
 2-996 . if (A ge B)
 2-997 . {
 2-998 .    A = B + C;
 2-999 .    D = E + F;
 2-1000 . }
 2-1001 . 
 2-1002 . A = B*C;
 2-1003 . 
 2-1004 . if (A ge B)
 2-1005 . {
 2-1006 .    A = B + C;
 2-1007 .    D = E + F;
 2-1008 . }
 2-1009 . 
 2-1010 . A = B*C;
 2-1011 . 
 2-1012 . if (A le B)
 2-1013 . {
 2-1014 .    A = B + C;
 2-1015 .    D = E + F;
 2-1016 . }
 2-1017 . 
 2-1018 . 
 2-1019 . if (A == B)
 2-1020 . {
 2-1021 .    A = B + C;
 2-1022 .    D = E + F;
 2-1023 . }
 2-1024 . 
 2-1025 . 
 2-1026 . if (A ne B)
 2-1027 . {
 2-1028 .    A = B + C;
 2-1029 .    D = E + F;
 2-1030 . }
 2-1031 . 
 2-1032 . 
 2-1033 . if (A <  B)
 2-1034 . {
 2-1035 .    A = B + C;
 2-1036 .    D = E + F;
 2-1037 . }
 2-1038 . 
 2-1039 . 
 2-1040 . if (A le B)
 2-1041 . {
 2-1042 .    A = B + C;
 2-1043 .    D = E + F;
 2-1044 . }
 2-1045 . 
 2-1046 . 
 2-1047 . if (A gt B)
 2-1048 . {
 2-1049 .    A = B + C;
 2-1050 .    D = E + F;
 2-1051 . }
 2-1052 . 
 2-1053 . 
 2-1054 . if (A > = B)
 2-1055 . {
 2-1056 .    A = B + C;
 2-1057 .    D = E + F;
 2-1058 . }
 2-1059 . 
 2-1060 . A = B-C;
 2-1061 . A = B-C;
 2-1062 . // (P) this is really improtant
 2-1063 . 
 2-1064 . if (A > = B)
 2-1065 . {
 2-1066 .    A = B + C;
 2-1067 .    D = E + F;
 2-1068 . }
 2-1069 . 
 2-1070 . 
 2-1071 . if (A < = B)
 2-1072 . {
 2-1073 .    A = B + C;
 2-1074 .    D = E + F;
 2-1075 . }
 2-1076 . 
 2-1077 . 
 2-1078 . if (A gt B)
 2-1079 . {
 2-1080 .    A = B + C;
 2-1081 .    D = E + F;
 2-1082 . }
 2-1083 . 
 2-1084 . A = B*C;
 2-1085 . A = B+C;
 2-1086 . 
 2-1087 . if (A gt B)
 2-1088 . {
 2-1089 .    A = B + C;
 2-1090 .    D = E + F;
 2-1091 . }
 2-1092 . 
 2-1093 . A = B/C;
 2-1094 . A = B/C;
 2-1095 . /* LE SV TOC-2439 this is a pwr-02.6.72 req to update*/
 2-1096 . 
 2-1097 . if (A < = B)
 2-1098 . {
 2-1099 .    A = B + C;
 2-1100 .    D = E + F;
 2-1101 . }
 2-1102 . 
 2-1103 . 
 2-1104 . if (A <  B)
 2-1105 . {
 2-1106 .    A = B + C;
 2-1107 .    D = E + F;
 2-1108 . }
 2-1109 . 
 2-1110 . A = B*C;
 2-1111 . 
 2-1112 . if (A >  B)
 2-1113 . {
 2-1114 .    A = B + C;
 2-1115 .    D = E + F;
 2-1116 . }
 2-1117 . 
 2-1118 . A = B-C;
 2-1119 . /* LE SV TOC-2440 this is a pwr-02.6.77 req to set RTC*/
 2-1120 . 
 2-1121 . if (A == B)
 2-1122 . {
 2-1123 .    A = B + C;
 2-1124 .    D = E + F;
 2-1125 . }
 2-1126 . 
 2-1127 . // max LOC 77
 2-1128 . 
 2-1129 . }
 2-1130 . 

2 2 Result: result/source/pr-app/pr-app-PWR123/pwr-02.c

3 3 Source: source/pr-app/pr-app-PWR123/pwr-03.c
 3-0 . /*
 3-1 . ----------------------------------------------------------------------------
 3-2 . --| BEGIN PROLOGUE
 3-3 . --|
 3-4 . --| CLASSIFICATION: UNCLASSIFIED
 3-5 . --|
 3-6 . --| FILE NAME:      pwr-03.c
 3-7 . --|
 3-8 . --| ABSTRACT:
 3-9 . --|   This file contains the 8 functions that do file pwr stuff.
 3-10 . --|
 3-11 . --| HISTORY:
 3-12 . --|   CCCQ_NAME:
 3-13 . --|   CCCQ_VER: 
 3-14 . --|
 3-15 . --| END PROLOGUE
 3-16 . ----------------------------------------------------------------------------
 3-17 . */
 3-18 . 
 3-19 . #include D;
 3-20 . double C;
 3-21 . #define B;
 3-22 . 
 3-23 . 
 3-24 . 
 3-25 . /*
 3-26 . -----------------------------------------------------------------------------
 3-27 . --| NAME:   pwr.3.1
 3-28 . --|
 3-29 . --| ABSTRACT:
 3-30 . --|   This function does pwr stuff.
 3-31 . --|
 3-32 . --| RETURNS:
 3-33 . --|   NONE.
 3-34 . --|
 3-35 . ----------------------------------------------------------------------------
 3-36 . */
 3-37 . static void pwr.3.1(void)
 3-38 . {
 3-39 . /* LE SV TOC-2441 this is a pwr-03.1.1 req to fail*/
 3-40 . 
 3-41 . if (A != B)
 3-42 . {
 3-43 .    A = B + C;
 3-44 .    D = E + F;
 3-45 . }
 3-46 . 
 3-47 . A = B-C;
 3-48 . 
 3-49 . if (A <  B)
 3-50 . {
 3-51 .    A = B + C;
 3-52 .    D = E + F;
 3-53 . }
 3-54 . 
 3-55 . A = B+C;
 3-56 . A = B/C;
 3-57 . A = B-C;
 3-58 . A = B+C;
 3-59 . // max LOC 7
 3-60 . 
 3-61 . }
 3-62 . 
 3-63 . 
 3-64 . /*
 3-65 . -----------------------------------------------------------------------------
 3-66 . --| NAME:   pwr.3.2
 3-67 . --|
 3-68 . --| ABSTRACT:
 3-69 . --|   This function does pwr stuff.
 3-70 . --|
 3-71 . --| RETURNS:
 3-72 . --|   NONE.
 3-73 . --|
 3-74 . ----------------------------------------------------------------------------
 3-75 . */
 3-76 . static void pwr.3.2(void)
 3-77 . {
 3-78 . A = B/C;
 3-79 . 
 3-80 . if (A ne B)
 3-81 . {
 3-82 .    A = B + C;
 3-83 .    D = E + F;
 3-84 . }
 3-85 . 
 3-86 . A = B-C;
 3-87 . A = B-C;
 3-88 . A = B+C;
 3-89 . A = B/C;
 3-90 . A = B+C;
 3-91 . A = B+C;
 3-92 . 
 3-93 . if (A gt B)
 3-94 . {
 3-95 .    A = B + C;
 3-96 .    D = E + F;
 3-97 . }
 3-98 . 
 3-99 . A = B*C;
 3-100 . A = B-C;
 3-101 . 
 3-102 . if (A ne B)
 3-103 . {
 3-104 .    A = B + C;
 3-105 .    D = E + F;
 3-106 . }
 3-107 . 
 3-108 . 
 3-109 . if (A >  B)
 3-110 . {
 3-111 .    A = B + C;
 3-112 .    D = E + F;
 3-113 . }
 3-114 . 
 3-115 . 
 3-116 . if (A ge B)
 3-117 . {
 3-118 .    A = B + C;
 3-119 .    D = E + F;
 3-120 . }
 3-121 . 
 3-122 . A = B-C;
 3-123 . 
 3-124 . if (A ne B)
 3-125 . {
 3-126 .    A = B + C;
 3-127 .    D = E + F;
 3-128 . }
 3-129 . 
 3-130 . A = B-C;
 3-131 . A = B-C;
 3-132 . A = B/C;
 3-133 . 
 3-134 . /* dead_code = B + C; 
 3-135 . dead_code = D + E; 
 3-136 . dead_code = F + G; */
 3-137 . 
 3-138 . A = B+C;
 3-139 . A = B-C;
 3-140 . 
 3-141 . if (A != B)
 3-142 . {
 3-143 .    A = B + C;
 3-144 .    D = E + F;
 3-145 . }
 3-146 . 
 3-147 . A = B*C;
 3-148 . A = B+C;
 3-149 . 
 3-150 . if (A eq B)
 3-151 . {
 3-152 .    A = B + C;
 3-153 .    D = E + F;
 3-154 . }
 3-155 . 
 3-156 . A = B-C;
 3-157 . A = B*C;
 3-158 . A = B+C;
 3-159 . /* LE SV TOC-2442 this is a pwr-03.2.29 req to validate*/
 3-160 . 
 3-161 . if (A ne B)
 3-162 . {
 3-163 .    A = B + C;
 3-164 .    D = E + F;
 3-165 . }
 3-166 . 
 3-167 . A = B*C;
 3-168 . A = B/C;
 3-169 . /* LE SV TOC-2443 this is a pwr-03.2.32 req to call admin*/
 3-170 . A = 0x0003;
 3-171 . A = B-C;
 3-172 . A = B-C;
 3-173 . A = B*C;
 3-174 . A = B/C;
 3-175 . 
 3-176 . if (A < = B)
 3-177 . {
 3-178 .    A = B + C;
 3-179 .    D = E + F;
 3-180 . }
 3-181 . 
 3-182 . 
 3-183 . if (A le B)
 3-184 . {
 3-185 .    A = B + C;
 3-186 .    D = E + F;
 3-187 . }
 3-188 . 
 3-189 . 
 3-190 . switch (pwr stuff)
 3-191 . {
 3-192 .    case one:
 3-193 .    {
 3-194 .       run_this; 
 3-195 .       break;
 3-196 .    }
 3-197 .    case two:
 3-198 .    {
 3-199 .       run_this;
 3-200 .       break;
 3-201 .    }
 3-202 .    default:
 3-203 .    {
 3-204 .        SwError;
 3-205 .    }
 3-206 . }
 3-207 . 
 3-208 . A = B+C;
 3-209 . A = B/C;
 3-210 . 
 3-211 . if (A ne B)
 3-212 . {
 3-213 .    A = B + C;
 3-214 .    D = E + F;
 3-215 . }
 3-216 . 
 3-217 . 
 3-218 . if (A == B)
 3-219 . {
 3-220 .    A = B + C;
 3-221 .    D = E + F;
 3-222 . }
 3-223 . 
 3-224 . A = B+C;
 3-225 . A = B+C;
 3-226 . A = B+C;
 3-227 . A = B/C;
 3-228 . A = B*C;
 3-229 . 
 3-230 . if (A eq B)
 3-231 . {
 3-232 .    A = B + C;
 3-233 .    D = E + F;
 3-234 . }
 3-235 . 
 3-236 . A = B/C;
 3-237 . 
 3-238 . /*
 3-239 . dead_block = C * D; 
 3-240 . dead_block = E * F;
 3-241 . */
 3-242 . 
 3-243 . A = B/C;
 3-244 . A = B/C;
 3-245 . A = B-C;
 3-246 . A = B/C;
 3-247 . A = B+C;
 3-248 . A = B-C;
 3-249 . A = B/C;
 3-250 . A = B/C;
 3-251 . 
 3-252 . if (A gt B)
 3-253 . {
 3-254 .    A = B + C;
 3-255 .    D = E + F;
 3-256 . }
 3-257 . 
 3-258 . A = B*C;
 3-259 . // max LOC 59
 3-260 . 
 3-261 . }
 3-262 . 
 3-263 . 
 3-264 . /*
 3-265 . -----------------------------------------------------------------------------
 3-266 . --| NAME:   pwr.3.3
 3-267 . --|
 3-268 . --| ABSTRACT:
 3-269 . --|   This function does pwr stuff.
 3-270 . --|
 3-271 . --| RETURNS:
 3-272 . --|   NONE.
 3-273 . --|
 3-274 . ----------------------------------------------------------------------------
 3-275 . */
 3-276 . static void pwr.3.3(void)
 3-277 . {
 3-278 . 
 3-279 . /* 
 3-280 . dead_code = B - C; 
 3-281 . dead_code = D - E; 
 3-282 . dead_code = F - G;
 3-283 . */
 3-284 . 
 3-285 . A = B*C;
 3-286 . 
 3-287 . if (A ne B)
 3-288 . {
 3-289 .    A = B + C;
 3-290 .    D = E + F;
 3-291 . }
 3-292 . 
 3-293 . A = B+C;
 3-294 . 
 3-295 . if (A <  B)
 3-296 . {
 3-297 .    A = B + C;
 3-298 .    D = E + F;
 3-299 . }
 3-300 . 
 3-301 . /* LE SV TOC-2444 this is a pwr-03.3.5 req to check unix*/
 3-302 . A = B-C;
 3-303 . A = B*C;
 3-304 . 
 3-305 . switch (pwr stuff)
 3-306 . {
 3-307 .    case one:
 3-308 .    {
 3-309 .       run_this; 
 3-310 .       break;
 3-311 .    }
 3-312 .    case two:
 3-313 .    {
 3-314 .       run_this;
 3-315 .       break;
 3-316 .    }
 3-317 .    default:
 3-318 .    {
 3-319 .        SwError;
 3-320 .    }
 3-321 . }
 3-322 . 
 3-323 . A = B+C;
 3-324 . A = B/C;
 3-325 . // max LOC 9
 3-326 . 
 3-327 . }
 3-328 . 
 3-329 . 
 3-330 . /*
 3-331 . -----------------------------------------------------------------------------
 3-332 . --| NAME:   pwr.3.4
 3-333 . --|
 3-334 . --| ABSTRACT:
 3-335 . --|   This function does pwr stuff.
 3-336 . --|
 3-337 . --| RETURNS:
 3-338 . --|   NONE.
 3-339 . --|
 3-340 . ----------------------------------------------------------------------------
 3-341 . */
 3-342 . static void pwr.3.4(void)
 3-343 . {
 3-344 . A = B*C;
 3-345 . A = B+C;
 3-346 . A = B-C;
 3-347 . 
 3-348 . if (A <  B)
 3-349 . {
 3-350 .    A = B + C;
 3-351 .    D = E + F;
 3-352 . }
 3-353 . 
 3-354 . 
 3-355 . if (A le B)
 3-356 . {
 3-357 .    A = B + C;
 3-358 .    D = E + F;
 3-359 . }
 3-360 . 
 3-361 . 
 3-362 . if (A != B)
 3-363 . {
 3-364 .    A = B + C;
 3-365 .    D = E + F;
 3-366 . }
 3-367 . 
 3-368 . 
 3-369 . if (A > = B)
 3-370 . {
 3-371 .    A = B + C;
 3-372 .    D = E + F;
 3-373 . }
 3-374 . 
 3-375 . A = B*C;
 3-376 . A = B/C;
 3-377 . 
 3-378 . if (A <  B)
 3-379 . {
 3-380 .    A = B + C;
 3-381 .    D = E + F;
 3-382 . }
 3-383 . 
 3-384 . 
 3-385 . switch (pwr stuff)
 3-386 . {
 3-387 .    case one:
 3-388 .    {
 3-389 .       switch (nested)
 3-390 .       {
 3-391 .          case:
 3-392 .             X = Y + Z;
 3-393 .          case:
 3-394 .             X = Y + Z;
 3-395 .          default:
 3-396 .             SwError;
 3-397 .       } 
 3-398 .    }
 3-399 .    case two:
 3-400 .    {
 3-401 .       run_this;
 3-402 .       break;
 3-403 .    }
 3-404 .    default:
 3-405 .    {
 3-406 .       SwError;
 3-407 .    }
 3-408 . }
 3-409 . 
 3-410 . 
 3-411 . if (A le B)
 3-412 . {
 3-413 .    A = B + C;
 3-414 .    D = E + F;
 3-415 . }
 3-416 . 
 3-417 . 
 3-418 . switch (pwr stuff)
 3-419 . {
 3-420 .    case one:
 3-421 .    {
 3-422 .       run_this; 
 3-423 .       break;
 3-424 .    }
 3-425 .    case two:
 3-426 .    {
 3-427 .       run_this;
 3-428 .       break;
 3-429 .    }
 3-430 .    default:
 3-431 .    {
 3-432 .        SwError;
 3-433 .    }
 3-434 . }
 3-435 . 
 3-436 . A = B-C;
 3-437 . A = B+C;
 3-438 . /* LE SV TOC-2445 this is a pwr-03.4.15 req to fail*/
 3-439 . 
 3-440 . if (A eq B)
 3-441 . {
 3-442 .    A = B + C;
 3-443 .    D = E + F;
 3-444 . }
 3-445 . 
 3-446 . A = B+C;
 3-447 . 
 3-448 . switch (pwr stuff)
 3-449 . {
 3-450 .    case one:
 3-451 .    {
 3-452 .       run_this; 
 3-453 .       break;
 3-454 .    }
 3-455 .    case two:
 3-456 .    {
 3-457 .       run_this;
 3-458 .       break;
 3-459 .    }
 3-460 .    default:
 3-461 .    {
 3-462 .        SwError;
 3-463 .    }
 3-464 . }
 3-465 . 
 3-466 . A = B+C;
 3-467 . A = B/C;
 3-468 . 
 3-469 . if (A > = B)
 3-470 . {
 3-471 .    A = B + C;
 3-472 .    D = E + F;
 3-473 . }
 3-474 . 
 3-475 . A = B-C;
 3-476 . A = B/C;
 3-477 . 
 3-478 . if (A lt B)
 3-479 . {
 3-480 .    A = B + C;
 3-481 .    D = E + F;
 3-482 . }
 3-483 . 
 3-484 . 
 3-485 . if (A gt B)
 3-486 . {
 3-487 .    A = B + C;
 3-488 .    D = E + F;
 3-489 . }
 3-490 . 
 3-491 . A = B*C;
 3-492 . 
 3-493 . if (A > = B)
 3-494 . {
 3-495 .    A = B + C;
 3-496 .    D = E + F;
 3-497 . }
 3-498 . 
 3-499 . A = B-C;
 3-500 . A = B/C;
 3-501 . A = 0x0003;
 3-502 . A = B+C;
 3-503 . /* LE SV TOC-2446 this is a pwr-03.4.30 req to disable*/
 3-504 . A = B+C;
 3-505 . // max LOC 30
 3-506 . 
 3-507 . }
 3-508 . 
 3-509 . 
 3-510 . /*
 3-511 . -----------------------------------------------------------------------------
 3-512 . --| NAME:   pwr.3.5
 3-513 . --|
 3-514 . --| ABSTRACT:
 3-515 . --|   This function does pwr stuff.
 3-516 . --|
 3-517 . --| RETURNS:
 3-518 . --|   NONE.
 3-519 . --|
 3-520 . ----------------------------------------------------------------------------
 3-521 . */
 3-522 . static void pwr.3.5(void)
 3-523 . {
 3-524 . A = B+C;
 3-525 . 
 3-526 . if (A <  B)
 3-527 . {
 3-528 .    A = B + C;
 3-529 .    D = E + F;
 3-530 . }
 3-531 . 
 3-532 . /* LE SV TOC-2447 this is a pwr-03.5.3 req to compare*/
 3-533 . 
 3-534 . if (A < = B)
 3-535 . {
 3-536 .    A = B + C;
 3-537 .    D = E + F;
 3-538 . }
 3-539 . 
 3-540 . A = B+C;
 3-541 . 
 3-542 . if (A == B)
 3-543 . {
 3-544 .    A = B + C;
 3-545 .    D = E + F;
 3-546 . }
 3-547 . 
 3-548 . A = B+C;
 3-549 . 
 3-550 . if (A ge B)
 3-551 . {
 3-552 .    A = B + C;
 3-553 .    D = E + F;
 3-554 . }
 3-555 . 
 3-556 . A = B/C;
 3-557 . A = B/C;
 3-558 . A = B-C;
 3-559 . A = B*C;
 3-560 . A = B+C;
 3-561 . A = B*C;
 3-562 . 
 3-563 . if (A le B)
 3-564 . {
 3-565 .    A = B + C;
 3-566 .    D = E + F;
 3-567 . }
 3-568 . 
 3-569 . A = B*C;
 3-570 . A = B+C;
 3-571 . 
 3-572 . if (A >  B)
 3-573 . {
 3-574 .    A = B + C;
 3-575 .    D = E + F;
 3-576 . }
 3-577 . 
 3-578 . A = B/C;
 3-579 . A = B+C;
 3-580 . 
 3-581 . if (A < = B)
 3-582 . {
 3-583 .    A = B + C;
 3-584 .    D = E + F;
 3-585 . }
 3-586 . 
 3-587 . A = B-C;
 3-588 . A = B-C;
 3-589 . A = B+C;
 3-590 . A = B-C;
 3-591 . 
 3-592 . if (A gt B)
 3-593 . {
 3-594 .    A = B + C;
 3-595 .    D = E + F;
 3-596 . }
 3-597 . 
 3-598 . 
 3-599 . if (A ne B)
 3-600 . {
 3-601 .    A = B + C;
 3-602 .    D = E + F;
 3-603 . }
 3-604 . 
 3-605 . A = B+C;
 3-606 . A = B+C;
 3-607 . A = B/C;
 3-608 . /* LE SV TOC-2448 this is a pwr-03.5.30 req to check pSOS*/
 3-609 . 
 3-610 . /* 
 3-611 . dead_code = B - C; 
 3-612 . dead_code = D - E; 
 3-613 . dead_code = F - G;
 3-614 . */
 3-615 . 
 3-616 . A = B/C;
 3-617 . A = B/C;
 3-618 . A = B-C;
 3-619 . A = B/C;
 3-620 . A = B-C;
 3-621 . A = B*C;
 3-622 . A = B-C;
 3-623 . 
 3-624 . if (A eq B)
 3-625 . {
 3-626 .    A = B + C;
 3-627 .    D = E + F;
 3-628 . }
 3-629 . 
 3-630 . A = B*C;
 3-631 . // max LOC 38
 3-632 . 
 3-633 . }
 3-634 . 
 3-635 . 
 3-636 . /*
 3-637 . -----------------------------------------------------------------------------
 3-638 . --| NAME:   pwr.3.6
 3-639 . --|
 3-640 . --| ABSTRACT:
 3-641 . --|   This function does pwr stuff.
 3-642 . --|
 3-643 . --| RETURNS:
 3-644 . --|   NONE.
 3-645 . --|
 3-646 . ----------------------------------------------------------------------------
 3-647 . */
 3-648 . static void pwr.3.6(void)
 3-649 . {
 3-650 . A = B-C;
 3-651 . A = 0x0002;
 3-652 . rcv_buffer = (U16 *) alloc(size+1);
 3-653 . A = B*C;
 3-654 . A = B*C;
 3-655 . A = B-C;
 3-656 . A = B+C;
 3-657 . A = B+C;
 3-658 . A = B-C;
 3-659 . A = B-C;
 3-660 . A = B/C;
 3-661 . A = B+C;
 3-662 . 
 3-663 . if (A != B)
 3-664 . {
 3-665 .    A = B + C;
 3-666 .    D = E + F;
 3-667 . }
 3-668 . 
 3-669 . A = B+C;
 3-670 . 
 3-671 . if (A eq B)
 3-672 . {
 3-673 .    A = B + C;
 3-674 .    D = E + F;
 3-675 . }
 3-676 . 
 3-677 . A = B*C;
 3-678 . A = B-C;
 3-679 . A = B*C;
 3-680 . A = B-C;
 3-681 . A = B/C;
 3-682 . free(FreePtr);
 3-683 . A = B+C;
 3-684 . A = B+C;
 3-685 . 
 3-686 . if (A != B)
 3-687 . {
 3-688 .    A = B + C;
 3-689 .    D = E + F;
 3-690 . }
 3-691 . 
 3-692 . A = B+C;
 3-693 . A = B*C;
 3-694 . 
 3-695 . if (A ge B)
 3-696 . {
 3-697 .    A = B + C;
 3-698 .    D = E + F;
 3-699 . }
 3-700 . 
 3-701 . A = B*C;
 3-702 . 
 3-703 . if (A gt B)
 3-704 . {
 3-705 .    A = B + C;
 3-706 .    D = E + F;
 3-707 . }
 3-708 . 
 3-709 . A = B/C;
 3-710 . 
 3-711 . if (A == B)
 3-712 . {
 3-713 .    A = B + C;
 3-714 .    D = E + F;
 3-715 . }
 3-716 . 
 3-717 . 
 3-718 . switch (pwr stuff)
 3-719 . {
 3-720 .    case one:
 3-721 .    {
 3-722 .       run_this;
 3-723 .       break;
 3-724 .    }
 3-725 .    case two:
 3-726 .    {
 3-727 .       run_this;
 3-728 .       break;
 3-729 .    }
 3-730 .    // missing default
 3-731 . }
 3-732 . 
 3-733 . A = B-C;
 3-734 . A = B*C;
 3-735 . A = B-C;
 3-736 . 
 3-737 . if (A ge B)
 3-738 . {
 3-739 .    A = B + C;
 3-740 .    D = E + F;
 3-741 . }
 3-742 . 
 3-743 . A = B*C;
 3-744 . A = B*C;
 3-745 . A = B/C;
 3-746 . A = B*C;
 3-747 . A = B*C;
 3-748 . 
 3-749 . if (A >  B)
 3-750 . {
 3-751 .    A = B + C;
 3-752 .    D = E + F;
 3-753 . }
 3-754 . 
 3-755 . 
 3-756 . if (A le B)
 3-757 . {
 3-758 .    A = B + C;
 3-759 .    D = E + F;
 3-760 . }
 3-761 . 
 3-762 . A = B*C;
 3-763 . A = B*C;
 3-764 . 
 3-765 . if (A > = B)
 3-766 . {
 3-767 .    A = B + C;
 3-768 .    D = E + F;
 3-769 . }
 3-770 . 
 3-771 . 
 3-772 . if (A le B)
 3-773 . {
 3-774 .    A = B + C;
 3-775 .    D = E + F;
 3-776 . }
 3-777 . 
 3-778 . A = B*C;
 3-779 . /* LE SV TOC-2449 this is a pwr-03.6.45 req to store*/
 3-780 . A = B/C;
 3-781 . 
 3-782 . #ifdef LAZY
 3-783 .    // this is not nice
 3-784 .    A = B + C;
 3-785 .    A = B + C;
 3-786 . #endif
 3-787 . 
 3-788 . A = B*C;
 3-789 . 
 3-790 . switch (pwr stuff)
 3-791 . {
 3-792 .    case one:
 3-793 .    {
 3-794 .       run_this; 
 3-795 .       break;
 3-796 .    }
 3-797 .    case two:
 3-798 .    {
 3-799 .       run_this;
 3-800 .       break;
 3-801 .    }
 3-802 .    default:
 3-803 .    {
 3-804 .        SwError;
 3-805 .    }
 3-806 . }
 3-807 . 
 3-808 . 
 3-809 . if (A lt B)
 3-810 . {
 3-811 .    A = B + C;
 3-812 .    D = E + F;
 3-813 . }
 3-814 . 
 3-815 . A = B-C;
 3-816 . A = B-C;
 3-817 . 
 3-818 . if (A le B)
 3-819 . {
 3-820 .    A = B + C;
 3-821 .    D = E + F;
 3-822 . }
 3-823 . 
 3-824 . A = B-C;
 3-825 . A = B/C;
 3-826 . 
 3-827 . if (A ge B)
 3-828 . {
 3-829 .    A = B + C;
 3-830 .    D = E + F;
 3-831 . }
 3-832 . 
 3-833 . A = B+C;
 3-834 . A = B*C;
 3-835 . // max LOC 56
 3-836 . 
 3-837 . }
 3-838 . 
 3-839 . 
 3-840 . /*
 3-841 . -----------------------------------------------------------------------------
 3-842 . --| NAME:   pwr.3.7
 3-843 . --|
 3-844 . --| ABSTRACT:
 3-845 . --|   This function does pwr stuff.
 3-846 . --|
 3-847 . --| RETURNS:
 3-848 . --|   NONE.
 3-849 . --|
 3-850 . ----------------------------------------------------------------------------
 3-851 . */
 3-852 . static void pwr.3.7(void)
 3-853 . {
 3-854 . 
 3-855 . if (A lt B)
 3-856 . {
 3-857 .    A = B + C;
 3-858 .    D = E + F;
 3-859 . }
 3-860 . 
 3-861 . A = B+C;
 3-862 . 
 3-863 . if (A eq B)
 3-864 . {
 3-865 .    A = B + C;
 3-866 .    D = E + F;
 3-867 . }
 3-868 . 
 3-869 . A = B-C;
 3-870 . A = B/C;
 3-871 . 
 3-872 . if (A ge B)
 3-873 . {
 3-874 .    A = B + C;
 3-875 .    D = E + F;
 3-876 . }
 3-877 . 
 3-878 . 
 3-879 . switch (pwr stuff)
 3-880 . {
 3-881 .    case one:
 3-882 .    {
 3-883 .       run_this; 
 3-884 .       break;
 3-885 .    }
 3-886 .    case two:
 3-887 .    {
 3-888 .       run_this;
 3-889 .       break;
 3-890 .    }
 3-891 .    default:
 3-892 .    {
 3-893 .        SwError;
 3-894 .    }
 3-895 . }
 3-896 . 
 3-897 . 
 3-898 . if (A != B)
 3-899 . {
 3-900 .    A = B + C;
 3-901 .    D = E + F;
 3-902 . }
 3-903 . 
 3-904 . A = B-C;
 3-905 . A = B/C;
 3-906 . A = B-C;
 3-907 . A = B+C;
 3-908 . A = B+C;
 3-909 . 
 3-910 . if (A lt B)
 3-911 . {
 3-912 .    A = B + C;
 3-913 .    D = E + F;
 3-914 . }
 3-915 . 
 3-916 . 
 3-917 . if (A == B)
 3-918 . {
 3-919 .    A = B + C;
 3-920 .    D = E + F;
 3-921 . }
 3-922 . 
 3-923 . 
 3-924 . if (A == B)
 3-925 . {
 3-926 .    A = B + C;
 3-927 .    D = E + F;
 3-928 . }
 3-929 . 
 3-930 . 
 3-931 . if (A le B)
 3-932 . {
 3-933 .    A = B + C;
 3-934 .    D = E + F;
 3-935 . }
 3-936 . 
 3-937 . A = B/C;
 3-938 . 
 3-939 . if (A ne B)
 3-940 . {
 3-941 .    A = B + C;
 3-942 .    D = E + F;
 3-943 . }
 3-944 . 
 3-945 . A = B-C;
 3-946 . A = B*C;
 3-947 . 
 3-948 . if (A ne B)
 3-949 . {
 3-950 .    A = B + C;
 3-951 .    D = E + F;
 3-952 . }
 3-953 . 
 3-954 . /* LE SV TOC-2450 this is a pwr-03.7.23 req to set RTC*/
 3-955 . A = 0x0004;
 3-956 . A = B+C;
 3-957 . A = B+C;
 3-958 . A = B/C;
 3-959 . A = B+C;
 3-960 . 
 3-961 . switch (pwr stuff)
 3-962 . {
 3-963 .    case one:
 3-964 .    {
 3-965 .       run_this; 
 3-966 .       break;
 3-967 .    }
 3-968 .    case two:
 3-969 .    {
 3-970 .       run_this;
 3-971 .       break;
 3-972 .    }
 3-973 .    default:
 3-974 .    {
 3-975 .        SwError;
 3-976 .    }
 3-977 . }
 3-978 . 
 3-979 . A = B+C;
 3-980 . 
 3-981 . switch (pwr stuff)
 3-982 . {
 3-983 .    case one:
 3-984 .    {
 3-985 .       run_this; 
 3-986 .       break;
 3-987 .    }
 3-988 .    case two:
 3-989 .    {
 3-990 .       run_this;
 3-991 .       break;
 3-992 .    }
 3-993 .    default:
 3-994 .    {
 3-995 .        SwError;
 3-996 .    }
 3-997 . }
 3-998 . 
 3-999 . 
 3-1000 . switch (pwr stuff)
 3-1001 . {
 3-1002 .    case one:
 3-1003 .    {
 3-1004 .       run_this; 
 3-1005 .       break;
 3-1006 .    }
 3-1007 .    case two:
 3-1008 .    {
 3-1009 .       run_this;
 3-1010 .       break;
 3-1011 .    }
 3-1012 .    default:
 3-1013 .    {
 3-1014 .        SwError;
 3-1015 .    }
 3-1016 . }
 3-1017 . 
 3-1018 . // max LOC 30
 3-1019 . 
 3-1020 . }
 3-1021 . 
 3-1022 . 
 3-1023 . /*
 3-1024 . -----------------------------------------------------------------------------
 3-1025 . --| NAME:   pwr.3.8
 3-1026 . --|
 3-1027 . --| ABSTRACT:
 3-1028 . --|   This function does pwr stuff.
 3-1029 . --|
 3-1030 . --| RETURNS:
 3-1031 . --|   NONE.
 3-1032 . --|
 3-1033 . ----------------------------------------------------------------------------
 3-1034 . */
 3-1035 . static void pwr.3.8(void)
 3-1036 . {
 3-1037 . A = B-C;
 3-1038 . A = B*C;
 3-1039 . A = B/C;
 3-1040 . A = B+C;
 3-1041 . A = 0x0001;
 3-1042 . 
 3-1043 . if (A lt B)
 3-1044 . {
 3-1045 .    A = B + C;
 3-1046 .    D = E + F;
 3-1047 . }
 3-1048 . 
 3-1049 . A = B/C;
 3-1050 . A = B+C;
 3-1051 . 
 3-1052 . switch (pwr stuff)
 3-1053 . {
 3-1054 .    case one:
 3-1055 .    {
 3-1056 .       run_this; 
 3-1057 .       break;
 3-1058 .    }
 3-1059 .    case two:
 3-1060 .    {
 3-1061 .       run_this;
 3-1062 .       break;
 3-1063 .    }
 3-1064 .    default:
 3-1065 .    {
 3-1066 .        SwError;
 3-1067 .    }
 3-1068 . }
 3-1069 . 
 3-1070 . 
 3-1071 . if (A < = B)
 3-1072 . {
 3-1073 .    A = B + C;
 3-1074 .    D = E + F;
 3-1075 . }
 3-1076 . 
 3-1077 . A = B+C;
 3-1078 . A = B*C;
 3-1079 . A = B-C;
 3-1080 . A = B/C;
 3-1081 . 
 3-1082 . if (A gt B)
 3-1083 . {
 3-1084 .    A = B + C;
 3-1085 .    D = E + F;
 3-1086 . }
 3-1087 . 
 3-1088 . 
 3-1089 . if (A < = B)
 3-1090 . {
 3-1091 .    A = B + C;
 3-1092 .    D = E + F;
 3-1093 . }
 3-1094 . 
 3-1095 . A = B+C;
 3-1096 . rcv_buffer = (U16 *) alloc(size+1);
 3-1097 . 
 3-1098 . if (A < = B)
 3-1099 . {
 3-1100 .    A = B + C;
 3-1101 .    D = E + F;
 3-1102 . }
 3-1103 . 
 3-1104 . A = B*C;
 3-1105 . A = B-C;
 3-1106 . A = B+C;
 3-1107 . 
 3-1108 . if (A gt B)
 3-1109 . {
 3-1110 .    A = B + C;
 3-1111 .    D = E + F;
 3-1112 . }
 3-1113 . 
 3-1114 . /* LE SV TOC-2451 this is a pwr-03.8.22 req to compare*/
 3-1115 . A = B-C;
 3-1116 . A = B*C;
 3-1117 . 
 3-1118 . if (A gt B)
 3-1119 . {
 3-1120 .    A = B + C;
 3-1121 .    D = E + F;
 3-1122 . }
 3-1123 . 
 3-1124 . A = B+C;
 3-1125 . /* LE SV TOC-2452 this is a pwr-03.8.26 req to translate*/
 3-1126 . 
 3-1127 . if (A > = B)
 3-1128 . {
 3-1129 .    A = B + C;
 3-1130 .    D = E + F;
 3-1131 . }
 3-1132 . 
 3-1133 . /* LE SV TOC-2453 this is a pwr-03.8.27 req to convert*/
 3-1134 . A = 0x0002;
 3-1135 . 
 3-1136 . if (A < = B)
 3-1137 . {
 3-1138 .    A = B + C;
 3-1139 .    D = E + F;
 3-1140 . }
 3-1141 . 
 3-1142 . A = B*C;
 3-1143 . A = B*C;
 3-1144 . A = B/C;
 3-1145 . A = B*C;
 3-1146 . A = B+C;
 3-1147 . /* LE SV TOC-2454 this is a pwr-03.8.33 req to translate*/
 3-1148 . 
 3-1149 . if (A gt B)
 3-1150 . {
 3-1151 .    A = B + C;
 3-1152 .    D = E + F;
 3-1153 . }
 3-1154 . 
 3-1155 . 
 3-1156 . if (A > = B)
 3-1157 . {
 3-1158 .    A = B + C;
 3-1159 .    D = E + F;
 3-1160 . }
 3-1161 . 
 3-1162 . A = B+C;
 3-1163 . 
 3-1164 . if (A ge B)
 3-1165 . {
 3-1166 .    A = B + C;
 3-1167 .    D = E + F;
 3-1168 . }
 3-1169 . 
 3-1170 . A = B-C;
 3-1171 . A = B*C;
 3-1172 . A = B/C;
 3-1173 . 
 3-1174 . if (A <  B)
 3-1175 . {
 3-1176 .    A = B + C;
 3-1177 .    D = E + F;
 3-1178 . }
 3-1179 . 
 3-1180 . 
 3-1181 . if (A ne B)
 3-1182 . {
 3-1183 .    A = B + C;
 3-1184 .    D = E + F;
 3-1185 . }
 3-1186 . 
 3-1187 . A = B-C;
 3-1188 . A = B-C;
 3-1189 . A = B-C;
 3-1190 . /* dead_code = A * B; */
 3-1191 . A = B+C;
 3-1192 . A = B*C;
 3-1193 . A = B*C;
 3-1194 . 
 3-1195 . if (A le B)
 3-1196 . {
 3-1197 .    A = B + C;
 3-1198 .    D = E + F;
 3-1199 . }
 3-1200 . 
 3-1201 . 
 3-1202 . switch (pwr stuff)
 3-1203 . {
 3-1204 .    case one:
 3-1205 .    {
 3-1206 .       run_this; 
 3-1207 .       break;
 3-1208 .    }
 3-1209 .    case two:
 3-1210 .    {
 3-1211 .       run_this;
 3-1212 .       break;
 3-1213 .    }
 3-1214 .    default:
 3-1215 .    {
 3-1216 .        SwError;
 3-1217 .    }
 3-1218 . }
 3-1219 . 
 3-1220 . A = B+C;
 3-1221 . /* LE SV TOC-2455 this is a pwr-03.8.51 req to check pSOS*/
 3-1222 . A = 0x0007;
 3-1223 . A = B/C;
 3-1224 . 
 3-1225 . /* 
 3-1226 . dead_code = B - C; 
 3-1227 . dead_code = D - E; 
 3-1228 . dead_code = F - G;
 3-1229 . */
 3-1230 . 
 3-1231 . A = B+C;
 3-1232 . A = B+C;
 3-1233 . A = B-C;
 3-1234 . A = B*C;
 3-1235 . A = B-C;
 3-1236 . A = B+C;
 3-1237 . /* LE SV TOC-2456 this is a pwr-03.8.58 req to translate*/
 3-1238 . 
 3-1239 . if (A > = B)
 3-1240 . {
 3-1241 .    A = B + C;
 3-1242 .    D = E + F;
 3-1243 . }
 3-1244 . 
 3-1245 . A = B-C;
 3-1246 . 
 3-1247 . if (A <  B)
 3-1248 . {
 3-1249 .    A = B + C;
 3-1250 .    D = E + F;
 3-1251 . }
 3-1252 . 
 3-1253 . A = B*C;
 3-1254 . A = B*C;
 3-1255 . 
 3-1256 . if (A > = B)
 3-1257 . {
 3-1258 .    A = B + C;
 3-1259 .    D = E + F;
 3-1260 . }
 3-1261 . 
 3-1262 . A = B*C;
 3-1263 . /* LE SV TOC-2457 this is a pwr-03.8.65 req to convert*/
 3-1264 . A = B*C;
 3-1265 . A = B-C;
 3-1266 . A = B+C;
 3-1267 . A = B*C;
 3-1268 . 
 3-1269 . /* dead_code = B + C; 
 3-1270 . dead_code = D + E; 
 3-1271 . dead_code = F + G; */
 3-1272 . 
 3-1273 . 
 3-1274 . if (A eq B)
 3-1275 . {
 3-1276 .    A = B + C;
 3-1277 .    D = E + F;
 3-1278 . }
 3-1279 . 
 3-1280 . A = B+C;
 3-1281 . A = B/C;
 3-1282 . A = B*C;
 3-1283 . A = B-C;
 3-1284 . 
 3-1285 . if (A ne B)
 3-1286 . {
 3-1287 .    A = B + C;
 3-1288 .    D = E + F;
 3-1289 . }
 3-1290 . 
 3-1291 . A = B-C;
 3-1292 . A = B*C;
 3-1293 . A = B/C;
 3-1294 . 
 3-1295 . if (A == B)
 3-1296 . {
 3-1297 .    A = B + C;
 3-1298 .    D = E + F;
 3-1299 . }
 3-1300 . 
 3-1301 . A = B*C;
 3-1302 . A = B/C;
 3-1303 . // max LOC 80
 3-1304 . 
 3-1305 . }
 3-1306 . 

3 3 Result: result/source/pr-app/pr-app-PWR123/pwr-03.c

4 4 Source: source/pr-app/pr-app-PWR123/pwr-04.c
 4-0 . /*
 4-1 . ----------------------------------------------------------------------------
 4-2 . --| BEGIN PROLOGUE
 4-3 . --|
 4-4 . --| CLASSIFICATION: UNCLASSIFIED
 4-5 . --|
 4-6 . --| FILE NAME:      pwr-04.c
 4-7 . --|
 4-8 . --| ABSTRACT:
 4-9 . --|   This file contains the 11 functions that do file pwr stuff.
 4-10 . --|
 4-11 . --| HISTORY:
 4-12 . --|   CCCQ_NAME:
 4-13 . --|   CCCQ_VER: 
 4-14 . --|
 4-15 . --| END PROLOGUE
 4-16 . ----------------------------------------------------------------------------
 4-17 . */
 4-18 . 
 4-19 . #define C;
 4-20 . #define B;
 4-21 . int A;
 4-22 . float B;
 4-23 . #define B;
 4-24 . #include A;
 4-25 . #include B;
 4-26 . #include A;
 4-27 . 
 4-28 . 
 4-29 . 
 4-30 . /*
 4-31 . -----------------------------------------------------------------------------
 4-32 . --| NAME:   pwr.4.1
 4-33 . --|
 4-34 . --| ABSTRACT:
 4-35 . --|   This function does pwr stuff.
 4-36 . --|
 4-37 . --| RETURNS:
 4-38 . --|   NONE.
 4-39 . --|
 4-40 . ----------------------------------------------------------------------------
 4-41 . */
 4-42 . static void pwr.4.1(void)
 4-43 . {
 4-44 . A = B/C;
 4-45 . 
 4-46 . if (A lt B)
 4-47 . {
 4-48 .    A = B + C;
 4-49 .    D = E + F;
 4-50 . }
 4-51 . 
 4-52 . A = B/C;
 4-53 . /* LE SV TOC-2458 this is a pwr-04.1.4 req to store*/
 4-54 . 
 4-55 . if (A ne B)
 4-56 . {
 4-57 .    A = B + C;
 4-58 .    D = E + F;
 4-59 . }
 4-60 . 
 4-61 . A = B*C;
 4-62 . A = B/C;
 4-63 . A = B-C;
 4-64 . A = B/C;
 4-65 . A = B*C;
 4-66 . A = B/C;
 4-67 . A = B-C;
 4-68 . A = B*C;
 4-69 . A = B-C;
 4-70 . A = B-C;
 4-71 . 
 4-72 . switch (pwr stuff)
 4-73 . {
 4-74 .       case one:
 4-75 .    {
 4-76 .       run_this;
 4-77 .       break;
 4-78 .    }
 4-79 .    case two:
 4-80 .    {
 4-81 .       run_this;
 4-82 .       break;
 4-83 .    }
 4-84 .    default:
 4-85 .    {
 4-86 .       // missing error call
 4-87 .    }
 4-88 . }
 4-89 . 
 4-90 . A = B*C;
 4-91 . A = B+C;
 4-92 . A = B/C;
 4-93 . 
 4-94 . if (A == B)
 4-95 . {
 4-96 .    A = B + C;
 4-97 .    D = E + F;
 4-98 . }
 4-99 . 
 4-100 . /* LE SV TOC-2459 this is a pwr-04.1.19 req to update*/
 4-101 . A = B/C;
 4-102 . 
 4-103 . if (A ne B)
 4-104 . {
 4-105 .    A = B + C;
 4-106 .    D = E + F;
 4-107 . }
 4-108 . 
 4-109 . A = B*C;
 4-110 . A = B-C;
 4-111 . /* LE SV TOC-2460 this is a pwr-04.1.23 req to call isr*/
 4-112 . 
 4-113 . if (A >  B)
 4-114 . {
 4-115 .    A = B + C;
 4-116 .    D = E + F;
 4-117 . }
 4-118 . 
 4-119 . A = B/C;
 4-120 . A = B-C;
 4-121 . A = B+C;
 4-122 . A = B/C;
 4-123 . A = B*C;
 4-124 . A = B-C;
 4-125 . 
 4-126 . if (A == B)
 4-127 . {
 4-128 .    A = B + C;
 4-129 .    D = E + F;
 4-130 . }
 4-131 . 
 4-132 . A = B*C;
 4-133 . 
 4-134 . if (A == B)
 4-135 . {
 4-136 .    A = B + C;
 4-137 .    D = E + F;
 4-138 . }
 4-139 . 
 4-140 . /* LE SV TOC-2461 this is a pwr-04.1.33 req to call isr*/
 4-141 . A = B*C;
 4-142 . A = B*C;
 4-143 . A = B+C;
 4-144 . A = B+C;
 4-145 . /* LE SV TOC-2462 this is a pwr-04.1.37 req to record*/
 4-146 . A = B-C;
 4-147 . A = B-C;
 4-148 . /* LE SV TOC-2463 this is a pwr-04.1.39 req to assign*/
 4-149 . A = B-C;
 4-150 . A = B+C;
 4-151 . // max LOC 40
 4-152 . 
 4-153 . }
 4-154 . 
 4-155 . 
 4-156 . /*
 4-157 . -----------------------------------------------------------------------------
 4-158 . --| NAME:   pwr.4.2
 4-159 . --|
 4-160 . --| ABSTRACT:
 4-161 . --|   This function does pwr stuff.
 4-162 . --|
 4-163 . --| RETURNS:
 4-164 . --|   NONE.
 4-165 . --|
 4-166 . ----------------------------------------------------------------------------
 4-167 . */
 4-168 . static void pwr.4.2(void)
 4-169 . {
 4-170 . A = B-C;
 4-171 . /* LE SV TOC-2464 this is a pwr-04.2.2 req to set RTC*/
 4-172 . A = B/C;
 4-173 . 
 4-174 . if (A == B)
 4-175 . {
 4-176 .    A = B + C;
 4-177 .    D = E + F;
 4-178 . }
 4-179 . 
 4-180 . A = B*C;
 4-181 . 
 4-182 . if (A ge B)
 4-183 . {
 4-184 .    A = B + C;
 4-185 .    D = E + F;
 4-186 . }
 4-187 . 
 4-188 . A = B+C;
 4-189 . 
 4-190 . if (A gt B)
 4-191 . {
 4-192 .    A = B + C;
 4-193 .    D = E + F;
 4-194 . }
 4-195 . 
 4-196 . A = B*C;
 4-197 . A = B-C;
 4-198 . A = B+C;
 4-199 . A = B+C;
 4-200 . A = B*C;
 4-201 . 
 4-202 . if (A >  B)
 4-203 . {
 4-204 .    A = B + C;
 4-205 .    D = E + F;
 4-206 . }
 4-207 . 
 4-208 . A = B*C;
 4-209 . A = B+C;
 4-210 . 
 4-211 . if (A != B)
 4-212 . {
 4-213 .    A = B + C;
 4-214 .    D = E + F;
 4-215 . }
 4-216 . 
 4-217 . A = B*C;
 4-218 . A = B/C;
 4-219 . A = B+C;
 4-220 . A = B-C;
 4-221 . A = B-C;
 4-222 . 
 4-223 . if (A ge B)
 4-224 . {
 4-225 .    A = B + C;
 4-226 .    D = E + F;
 4-227 . }
 4-228 . 
 4-229 . A = B/C;
 4-230 . A = B/C;
 4-231 . A = B*C;
 4-232 . A = B-C;
 4-233 . A = B+C;
 4-234 . A = B-C;
 4-235 . 
 4-236 . if (A < = B)
 4-237 . {
 4-238 .    A = B + C;
 4-239 .    D = E + F;
 4-240 . }
 4-241 . 
 4-242 . A = B*C;
 4-243 . A = B-C;
 4-244 . A = B+C;
 4-245 . A = B+C;
 4-246 . A = B/C;
 4-247 . 
 4-248 . if (A le B)
 4-249 . {
 4-250 .    A = B + C;
 4-251 .    D = E + F;
 4-252 . }
 4-253 . 
 4-254 . A = B+C;
 4-255 . A = B+C;
 4-256 . 
 4-257 . if (A le B)
 4-258 . {
 4-259 .    A = B + C;
 4-260 .    D = E + F;
 4-261 . }
 4-262 . 
 4-263 . 
 4-264 . if (A ge B)
 4-265 . {
 4-266 .    A = B + C;
 4-267 .    D = E + F;
 4-268 . }
 4-269 . 
 4-270 . A = B/C;
 4-271 . A = B-C;
 4-272 . A = B*C;
 4-273 . 
 4-274 . if (A le B)
 4-275 . {
 4-276 .    A = B + C;
 4-277 .    D = E + F;
 4-278 . }
 4-279 . 
 4-280 . A = B-C;
 4-281 . 
 4-282 . if (A > = B)
 4-283 . {
 4-284 .    A = B + C;
 4-285 .    D = E + F;
 4-286 . }
 4-287 . 
 4-288 . 
 4-289 . if ($pwr stuff >  $otherpwr stuff) 
 4-290 . /* LE SV TOC-008 we really should log all error calls */
 4-291 . {
 4-292 .    A = B + C;
 4-293 . }
 4-294 . 
 4-295 . A = B*C;
 4-296 . A = B+C;
 4-297 . A = B-C;
 4-298 . A = B*C;
 4-299 . // TBS - I need to figure this out
 4-300 . A = B*C;
 4-301 . A = B+C;
 4-302 . A = B+C;
 4-303 . 
 4-304 . if (A >  B)
 4-305 . {
 4-306 .    A = B + C;
 4-307 .    D = E + F;
 4-308 . }
 4-309 . 
 4-310 . /* LE SV TOC-2465 this is a pwr-04.2.54 req to assign*/
 4-311 . A = 0x0001;
 4-312 . 
 4-313 . if (A != B)
 4-314 . {
 4-315 .    A = B + C;
 4-316 .    D = E + F;
 4-317 . }
 4-318 . 
 4-319 . 
 4-320 . if (A < = B)
 4-321 . {
 4-322 .    A = B + C;
 4-323 .    D = E + F;
 4-324 . }
 4-325 . 
 4-326 . A = B-C;
 4-327 . A = B*C;
 4-328 . A = B*C;
 4-329 . 
 4-330 . if (A < = B)
 4-331 . {
 4-332 .    A = B + C;
 4-333 .    D = E + F;
 4-334 . }
 4-335 . 
 4-336 . A = B-C;
 4-337 . 
 4-338 . if (A != B)
 4-339 . {
 4-340 .    A = B + C;
 4-341 .    D = E + F;
 4-342 . }
 4-343 . 
 4-344 . A = B*C;
 4-345 . A = B+C;
 4-346 . A = B/C;
 4-347 . A = B*C;
 4-348 . A = (float)B + C;
 4-349 . A = B-C;
 4-350 . /* LE SV TOC-2466 this is a pwr-04.2.67 req to verify*/
 4-351 . A = B-C;
 4-352 . A = B*C;
 4-353 . /* LE SV TOC-2467 this is a pwr-04.2.69 req to call isr*/
 4-354 . A = B*C;
 4-355 . A = B/C;
 4-356 . A = B*C;
 4-357 . // max LOC 71
 4-358 . 
 4-359 . }
 4-360 . 
 4-361 . 
 4-362 . /*
 4-363 . -----------------------------------------------------------------------------
 4-364 . --| NAME:   pwr.4.3
 4-365 . --|
 4-366 . --| ABSTRACT:
 4-367 . --|   This function does pwr stuff.
 4-368 . --|
 4-369 . --| RETURNS:
 4-370 . --|   NONE.
 4-371 . --|
 4-372 . ----------------------------------------------------------------------------
 4-373 . */
 4-374 . static void pwr.4.3(void)
 4-375 . {
 4-376 . A = B*C;
 4-377 . A = B+C;
 4-378 . A = B+C;
 4-379 . A = B*C;
 4-380 . 
 4-381 . if (A < = B)
 4-382 . {
 4-383 .    A = B + C;
 4-384 .    D = E + F;
 4-385 . }
 4-386 . 
 4-387 . A = B+C;
 4-388 . 
 4-389 . if (veg)
 4-390 .    // missing curly brace
 4-391 .    variable = orange;
 4-392 . 
 4-393 . 
 4-394 . if (A ge B)
 4-395 . {
 4-396 .    A = B + C;
 4-397 .    D = E + F;
 4-398 . }
 4-399 . 
 4-400 . A = B-C;
 4-401 . A = B/C;
 4-402 . 
 4-403 . if (A ne B)
 4-404 . {
 4-405 .    A = B + C;
 4-406 .    D = E + F;
 4-407 . }
 4-408 . 
 4-409 . A = B-C;
 4-410 . 
 4-411 . if (A le B)
 4-412 . {
 4-413 .    A = B + C;
 4-414 .    D = E + F;
 4-415 . }
 4-416 . 
 4-417 . 
 4-418 . if (A lt B)
 4-419 . {
 4-420 .    A = B + C;
 4-421 .    D = E + F;
 4-422 . }
 4-423 . 
 4-424 . A = B/C;
 4-425 . A = B+C;
 4-426 . A = B*C;
 4-427 . A = B+C;
 4-428 . 
 4-429 . if (A <  B)
 4-430 . {
 4-431 .    A = B + C;
 4-432 .    D = E + F;
 4-433 . }
 4-434 . 
 4-435 . A = B*C;
 4-436 . 
 4-437 . /* 
 4-438 . dead_code = B - C; 
 4-439 . dead_code = D - E; 
 4-440 . dead_code = F - G;
 4-441 . */
 4-442 . 
 4-443 . A = B/C;
 4-444 . A = B*C;
 4-445 . /* LE SV TOC-2468 this is a pwr-04.3.22 req to call admin*/
 4-446 . A = B-C;
 4-447 . A = B-C;
 4-448 . 
 4-449 . switch (pwr stuff)
 4-450 . {
 4-451 .    case one:
 4-452 .    {
 4-453 .       switch (nested)
 4-454 .       {
 4-455 .          case:
 4-456 .             X = Y + Z;
 4-457 .          case:
 4-458 .             X = Y + Z;
 4-459 .          default:
 4-460 .             SwError;
 4-461 .       } 
 4-462 .    }
 4-463 .    case two:
 4-464 .    {
 4-465 .       run_this;
 4-466 .       break;
 4-467 .    }
 4-468 .    default:
 4-469 .    {
 4-470 .       SwError;
 4-471 .    }
 4-472 . }
 4-473 . 
 4-474 . A = B-C;
 4-475 . A = 0x0008;
 4-476 . A = B*C;
 4-477 . 
 4-478 . if (A eq B)
 4-479 . {
 4-480 .    A = B + C;
 4-481 .    D = E + F;
 4-482 . }
 4-483 . 
 4-484 . 
 4-485 . if (A <  B)
 4-486 . {
 4-487 .    A = B + C;
 4-488 .    D = E + F;
 4-489 . }
 4-490 . 
 4-491 . 
 4-492 . if (A ne B)
 4-493 . {
 4-494 .    A = B + C;
 4-495 .    D = E + F;
 4-496 . }
 4-497 . 
 4-498 . A = B*C;
 4-499 . A = B/C;
 4-500 . goto error;
 4-501 . A = B*C;
 4-502 . A = B*C;
 4-503 . A = B+C;
 4-504 . A = B*C;
 4-505 . A = B/C;
 4-506 . 
 4-507 . if (A ne B)
 4-508 . {
 4-509 .    A = B + C;
 4-510 .    D = E + F;
 4-511 . }
 4-512 . 
 4-513 . A = B-C;
 4-514 . 
 4-515 . if (A ne B)
 4-516 . {
 4-517 .    A = B + C;
 4-518 .    D = E + F;
 4-519 . }
 4-520 . 
 4-521 . A = B+C;
 4-522 . A = B*C;
 4-523 . A = 0x0008;
 4-524 . A = B+C;
 4-525 . 
 4-526 . if (A > = B)
 4-527 . {
 4-528 .    A = B + C;
 4-529 .    D = E + F;
 4-530 . }
 4-531 . 
 4-532 . 
 4-533 . if (A lt B)
 4-534 . {
 4-535 .    A = B + C;
 4-536 .    D = E + F;
 4-537 . }
 4-538 . 
 4-539 . /* LE SV TOC-2469 this is a pwr-04.3.44 req to reject*/
 4-540 . 
 4-541 . if (A gt B)
 4-542 . {
 4-543 .    A = B + C;
 4-544 .    D = E + F;
 4-545 . }
 4-546 . 
 4-547 . A = B-C;
 4-548 . A = B+C;
 4-549 . A = B*C;
 4-550 . 
 4-551 . if (A == B)
 4-552 . {
 4-553 .    A = B + C;
 4-554 .    D = E + F;
 4-555 . }
 4-556 . 
 4-557 . 
 4-558 . if (A le B)
 4-559 . {
 4-560 .    A = B + C;
 4-561 .    D = E + F;
 4-562 . }
 4-563 . 
 4-564 . A = B*C;
 4-565 . A = B*C;
 4-566 . A = B*C;
 4-567 . A = (long)B + C;
 4-568 . A = B-C;
 4-569 . A = B-C;
 4-570 . A = B*C;
 4-571 . A = (long)B + C;
 4-572 . A = B-C;
 4-573 . A = B/C;
 4-574 . 
 4-575 . if (A == B)
 4-576 . {
 4-577 .    A = B + C;
 4-578 .    D = E + F;
 4-579 . }
 4-580 . 
 4-581 . A = B*C;
 4-582 . A = B-C;
 4-583 . 
 4-584 . if (A eq B)
 4-585 . {
 4-586 .    A = B + C;
 4-587 .    D = E + F;
 4-588 . }
 4-589 . 
 4-590 . /* LE SV TOC-2470 this is a pwr-04.3.62 req to assign*/
 4-591 . A = B+C;
 4-592 . /* LE SV TOC-2471 this is a pwr-04.3.63 req to record*/
 4-593 . A = B/C;
 4-594 . A = B-C;
 4-595 . A = B+C;
 4-596 . 
 4-597 . if (A gt B)
 4-598 . {
 4-599 .    A = B + C;
 4-600 .    D = E + F;
 4-601 . }
 4-602 . 
 4-603 . A = B*C;
 4-604 . // max LOC 67
 4-605 . 
 4-606 . }
 4-607 . 
 4-608 . 
 4-609 . /*
 4-610 . -----------------------------------------------------------------------------
 4-611 . --| NAME:   pwr.4.4
 4-612 . --|
 4-613 . --| ABSTRACT:
 4-614 . --|   This function does pwr stuff.
 4-615 . --|
 4-616 . --| RETURNS:
 4-617 . --|   NONE.
 4-618 . --|
 4-619 . ----------------------------------------------------------------------------
 4-620 . */
 4-621 . static void pwr.4.4(void)
 4-622 . {
 4-623 . 
 4-624 . if (A < = B)
 4-625 . {
 4-626 .    A = B + C;
 4-627 .    D = E + F;
 4-628 . }
 4-629 . 
 4-630 . A = B+C;
 4-631 . A = B-C;
 4-632 . A = B+C;
 4-633 . 
 4-634 . switch (pwr stuff)
 4-635 . {
 4-636 .    case one:
 4-637 .    {
 4-638 .       run_this; 
 4-639 .       break;
 4-640 .    }
 4-641 .    case two:
 4-642 .    {
 4-643 .       run_this;
 4-644 .       break;
 4-645 .    }
 4-646 .    default:
 4-647 .    {
 4-648 .        SwError;
 4-649 .    }
 4-650 . }
 4-651 . 
 4-652 . 
 4-653 . if (A le B)
 4-654 . {
 4-655 .    A = B + C;
 4-656 .    D = E + F;
 4-657 . }
 4-658 . 
 4-659 . 
 4-660 . /* 
 4-661 . dead_code = B - C; 
 4-662 . dead_code = D - E; 
 4-663 . dead_code = F - G;
 4-664 . */
 4-665 . 
 4-666 . A = B+C;
 4-667 . A = B-C;
 4-668 . 
 4-669 . if (A le B)
 4-670 . {
 4-671 .    A = B + C;
 4-672 .    D = E + F;
 4-673 . }
 4-674 . 
 4-675 . A = B/C;
 4-676 . 
 4-677 . if (A > = B)
 4-678 . {
 4-679 .    A = B + C;
 4-680 .    D = E + F;
 4-681 . }
 4-682 . 
 4-683 . A = B/C;
 4-684 . 
 4-685 . if (A >  B)
 4-686 . {
 4-687 .    A = B + C;
 4-688 .    D = E + F;
 4-689 . }
 4-690 . 
 4-691 . 
 4-692 . switch (pwr stuff)
 4-693 . {
 4-694 .    case one:
 4-695 .    {
 4-696 .       run_this; 
 4-697 .       break;
 4-698 .    }
 4-699 .    case two:
 4-700 .    {
 4-701 .       run_this;
 4-702 .       break;
 4-703 .    }
 4-704 .    default:
 4-705 .    {
 4-706 .        SwError;
 4-707 .    }
 4-708 . }
 4-709 . 
 4-710 . A = B+C;
 4-711 . 
 4-712 . if (A <  B)
 4-713 . {
 4-714 .    A = B + C;
 4-715 .    D = E + F;
 4-716 . }
 4-717 . 
 4-718 . /* LE SV TOC-2472 this is a pwr-04.4.17 req to audit*/
 4-719 . 
 4-720 . if (A != B)
 4-721 . {
 4-722 .    A = B + C;
 4-723 .    D = E + F;
 4-724 . }
 4-725 . 
 4-726 . A = B/C;
 4-727 . A = B/C;
 4-728 . 
 4-729 . if (A > = B)
 4-730 . {
 4-731 .    A = B + C;
 4-732 .    D = E + F;
 4-733 . }
 4-734 . 
 4-735 . // max LOC 20
 4-736 . 
 4-737 . }
 4-738 . 
 4-739 . 
 4-740 . /*
 4-741 . -----------------------------------------------------------------------------
 4-742 . --| NAME:   pwr.4.5
 4-743 . --|
 4-744 . --| ABSTRACT:
 4-745 . --|   This function does pwr stuff.
 4-746 . --|
 4-747 . --| RETURNS:
 4-748 . --|   NONE.
 4-749 . --|
 4-750 . ----------------------------------------------------------------------------
 4-751 . */
 4-752 . static void pwr.4.5(void)
 4-753 . {
 4-754 . 
 4-755 . if (A < = B)
 4-756 . {
 4-757 .    A = B + C;
 4-758 .    D = E + F;
 4-759 . }
 4-760 . 
 4-761 . A = B/C;
 4-762 . A = B/C;
 4-763 . 
 4-764 . if (A lt B)
 4-765 . {
 4-766 .    A = B + C;
 4-767 .    D = E + F;
 4-768 . }
 4-769 . 
 4-770 . A = B-C;
 4-771 . A = B/C;
 4-772 . 
 4-773 . if (A == B)
 4-774 . {
 4-775 .    A = B + C;
 4-776 .    D = E + F;
 4-777 . }
 4-778 . 
 4-779 . A = B*C;
 4-780 . /* LE SV TOC-2473 this is a pwr-04.5.9 req to reject*/
 4-781 . A = B+C;
 4-782 . A = B/C;
 4-783 . A = B/C;
 4-784 . A = B*C;
 4-785 . A = B*C;
 4-786 . 
 4-787 . if (A != B)
 4-788 . {
 4-789 .    A = B + C;
 4-790 .    D = E + F;
 4-791 . }
 4-792 . 
 4-793 . A = B+C;
 4-794 . A = B-C;
 4-795 . 
 4-796 . if (A gt B)
 4-797 . {
 4-798 .    A = B + C;
 4-799 .    D = E + F;
 4-800 . }
 4-801 . 
 4-802 . A = B-C;
 4-803 . A = B-C;
 4-804 . 
 4-805 . if (A ne B)
 4-806 . {
 4-807 .    A = B + C;
 4-808 .    D = E + F;
 4-809 . }
 4-810 . 
 4-811 . 
 4-812 . switch (pwr stuff)
 4-813 . {
 4-814 .    case:
 4-815 .    case:
 4-816 .    // stacked case statements but only if there is a new line in between
 4-817 . 
 4-818 .    case:
 4-819 .    case:
 4-820 .    case:
 4-821 .    {
 4-822 .       run_this;
 4-823 .       break;
 4-824 .    }
 4-825 .    default:
 4-826 .    {
 4-827 .       halt;
 4-828 .    }
 4-829 . }
 4-830 . 
 4-831 . A = B/C;
 4-832 . A = B*C;
 4-833 . A = B/C;
 4-834 . A = B+C;
 4-835 . A = 0x0003;
 4-836 . 
 4-837 . if (A le B)
 4-838 . {
 4-839 .    A = B + C;
 4-840 .    D = E + F;
 4-841 . }
 4-842 . 
 4-843 . // max LOC 25
 4-844 . 
 4-845 . }
 4-846 . 
 4-847 . 
 4-848 . /*
 4-849 . -----------------------------------------------------------------------------
 4-850 . --| NAME:   pwr.4.6
 4-851 . --|
 4-852 . --| ABSTRACT:
 4-853 . --|   This function does pwr stuff.
 4-854 . --|
 4-855 . --| RETURNS:
 4-856 . --|   NONE.
 4-857 . --|
 4-858 . ----------------------------------------------------------------------------
 4-859 . */
 4-860 . static void pwr.4.6(void)
 4-861 . {
 4-862 . A = 0x0003;
 4-863 . A = B/C;
 4-864 . 
 4-865 . if (A le B)
 4-866 . {
 4-867 .    A = B + C;
 4-868 .    D = E + F;
 4-869 . }
 4-870 . 
 4-871 . A = B*C;
 4-872 . A = B-C;
 4-873 . A = B*C;
 4-874 . 
 4-875 . if (A le B)
 4-876 . {
 4-877 .    A = B + C;
 4-878 .    D = E + F;
 4-879 . }
 4-880 . 
 4-881 . 
 4-882 . if (A gt B)
 4-883 . {
 4-884 .    A = B + C;
 4-885 .    D = E + F;
 4-886 . }
 4-887 . 
 4-888 . A = B+C;
 4-889 . A = B/C;
 4-890 . A = B+C;
 4-891 . send_buffer = (U16 *) malloc(size+1);
 4-892 . A = B+C;
 4-893 . A = B*C;
 4-894 . 
 4-895 . if (A le B)
 4-896 . {
 4-897 .    A = B + C;
 4-898 .    D = E + F;
 4-899 . }
 4-900 . 
 4-901 . 
 4-902 . if (A eq B)
 4-903 . {
 4-904 .    A = B + C;
 4-905 .    D = E + F;
 4-906 . }
 4-907 . 
 4-908 . A = B+C;
 4-909 . A = B/C;
 4-910 . A = B*C;
 4-911 . A = B*C;
 4-912 . 
 4-913 . if (A le B)
 4-914 . {
 4-915 .    A = B + C;
 4-916 .    D = E + F;
 4-917 . }
 4-918 . 
 4-919 . A = B+C;
 4-920 . A = B-C;
 4-921 . 
 4-922 . if (A le B)
 4-923 . {
 4-924 .    A = B + C;
 4-925 .    D = E + F;
 4-926 . }
 4-927 . 
 4-928 . A = B*C;
 4-929 . A = B/C;
 4-930 . A = B+C;
 4-931 . A = B/C;
 4-932 . A = B-C;
 4-933 . 
 4-934 . if (A <  B)
 4-935 . {
 4-936 .    A = B + C;
 4-937 .    D = E + F;
 4-938 . }
 4-939 . 
 4-940 . 
 4-941 . if (A <  B)
 4-942 . {
 4-943 .    A = B + C;
 4-944 .    D = E + F;
 4-945 . }
 4-946 . 
 4-947 . /* LE SV TOC-2474 this is a pwr-04.6.30 req to enable*/
 4-948 . A = B-C;
 4-949 . A = B/C;
 4-950 . 
 4-951 . if (A < = B)
 4-952 . {
 4-953 .    A = B + C;
 4-954 .    D = E + F;
 4-955 . }
 4-956 . 
 4-957 . A = B/C;
 4-958 . A = B-C;
 4-959 . A = B+C;
 4-960 . A = B/C;
 4-961 . A = (long)B + C;
 4-962 . A = B+C;
 4-963 . A = 0x0008;
 4-964 . A = B-C;
 4-965 . 
 4-966 . switch (pwr stuff)
 4-967 . {
 4-968 .    case one:
 4-969 .    {
 4-970 .       run_this; 
 4-971 .       // missing break
 4-972 .    }
 4-973 .    case two:
 4-974 .    {
 4-975 .       run_this;
 4-976 .       break;
 4-977 .    }
 4-978 .    default:
 4-979 .    {
 4-980 .       SwError;
 4-981 .    }
 4-982 . }
 4-983 . 
 4-984 . A = B/C;
 4-985 . A = B-C;
 4-986 . A = B-C;
 4-987 . A = B+C;
 4-988 . A = B*C;
 4-989 . rcv_buffer = (U16 *) alloc(size+1);
 4-990 . A = B+C;
 4-991 . A = B+C;
 4-992 . A = B/C;
 4-993 . A = B+C;
 4-994 . A = 0x0007;
 4-995 . 
 4-996 . switch (pwr stuff)
 4-997 . {
 4-998 .    case one:
 4-999 .    {
 4-1000 .       run_this; 
 4-1001 .       break;
 4-1002 .    }
 4-1003 .    case two:
 4-1004 .    {
 4-1005 .       run_this;
 4-1006 .       break;
 4-1007 .    }
 4-1008 .    default:
 4-1009 .    {
 4-1010 .        SwError;
 4-1011 .    }
 4-1012 . }
 4-1013 . 
 4-1014 . 
 4-1015 . if (A == B)
 4-1016 . {
 4-1017 .    A = B + C;
 4-1018 .    D = E + F;
 4-1019 . }
 4-1020 . 
 4-1021 . 
 4-1022 . if (A < = B)
 4-1023 . {
 4-1024 .    A = B + C;
 4-1025 .    D = E + F;
 4-1026 . }
 4-1027 . 
 4-1028 . A = B/C;
 4-1029 . 
 4-1030 . if (A eq B)
 4-1031 . {
 4-1032 .    A = B + C;
 4-1033 .    D = E + F;
 4-1034 . }
 4-1035 . 
 4-1036 . A = B+C;
 4-1037 . 
 4-1038 . if (A > = B)
 4-1039 . {
 4-1040 .    A = B + C;
 4-1041 .    D = E + F;
 4-1042 . }
 4-1043 . 
 4-1044 . A = B-C;
 4-1045 . 
 4-1046 . if (A == B)
 4-1047 . {
 4-1048 .    A = B + C;
 4-1049 .    D = E + F;
 4-1050 . }
 4-1051 . 
 4-1052 . A = B-C;
 4-1053 . // (P) this is really improtant
 4-1054 . A = B*C;
 4-1055 . 
 4-1056 . if (A <  B)
 4-1057 . {
 4-1058 .    A = B + C;
 4-1059 .    D = E + F;
 4-1060 . }
 4-1061 . 
 4-1062 . A = B+C;
 4-1063 . A = B*C;
 4-1064 . 
 4-1065 . if (A > = B)
 4-1066 . {
 4-1067 .    A = B + C;
 4-1068 .    D = E + F;
 4-1069 . }
 4-1070 . 
 4-1071 . 
 4-1072 . if (A gt B)
 4-1073 . {
 4-1074 .    A = B + C;
 4-1075 .    D = E + F;
 4-1076 . }
 4-1077 . 
 4-1078 . A = B+C;
 4-1079 . 
 4-1080 . if (A != B)
 4-1081 . {
 4-1082 .    A = B + C;
 4-1083 .    D = E + F;
 4-1084 . }
 4-1085 . 
 4-1086 . 
 4-1087 . if (A eq B)
 4-1088 . {
 4-1089 .    A = B + C;
 4-1090 .    D = E + F;
 4-1091 . }
 4-1092 . 
 4-1093 . 
 4-1094 . if (A > = B)
 4-1095 . {
 4-1096 .    A = B + C;
 4-1097 .    D = E + F;
 4-1098 . }
 4-1099 . 
 4-1100 . 
 4-1101 . if (A >  B)
 4-1102 . {
 4-1103 .    A = B + C;
 4-1104 .    D = E + F;
 4-1105 . }
 4-1106 . 
 4-1107 . A = B/C;
 4-1108 . 
 4-1109 . if (A ne B)
 4-1110 . {
 4-1111 .    A = B + C;
 4-1112 .    D = E + F;
 4-1113 . }
 4-1114 . 
 4-1115 . A = B+C;
 4-1116 . FreePtr = HmiStringPtr;
 4-1117 . A = B+C;
 4-1118 . /* LE SV TOC-2475 this is a pwr-04.6.73 req to inhibit*/
 4-1119 . A = B+C;
 4-1120 . // TBD - what do I do now
 4-1121 . 
 4-1122 . if (A eq B)
 4-1123 . {
 4-1124 .    A = B + C;
 4-1125 .    D = E + F;
 4-1126 . }
 4-1127 . 
 4-1128 . A = B+C;
 4-1129 . A = B-C;
 4-1130 . A = B*C;
 4-1131 . A = B+C;
 4-1132 . // max LOC 78
 4-1133 . 
 4-1134 . }
 4-1135 . 
 4-1136 . 
 4-1137 . /*
 4-1138 . -----------------------------------------------------------------------------
 4-1139 . --| NAME:   pwr.4.7
 4-1140 . --|
 4-1141 . --| ABSTRACT:
 4-1142 . --|   This function does pwr stuff.
 4-1143 . --|
 4-1144 . --| RETURNS:
 4-1145 . --|   NONE.
 4-1146 . --|
 4-1147 . ----------------------------------------------------------------------------
 4-1148 . */
 4-1149 . static void pwr.4.7(void)
 4-1150 . {
 4-1151 . 
 4-1152 . if (A != B)
 4-1153 . {
 4-1154 .    A = B + C;
 4-1155 .    D = E + F;
 4-1156 . }
 4-1157 . 
 4-1158 . A = B+C;
 4-1159 . A = B+C;
 4-1160 . A = B*C;
 4-1161 . A = B+C;
 4-1162 . A = B-C;
 4-1163 . A = B+C;
 4-1164 . 
 4-1165 . if (A == B)
 4-1166 . {
 4-1167 .    A = B + C;
 4-1168 .    D = E + F;
 4-1169 . }
 4-1170 . 
 4-1171 . A = B+C;
 4-1172 . 
 4-1173 . if (A ge B)
 4-1174 . {
 4-1175 .    A = B + C;
 4-1176 .    D = E + F;
 4-1177 . }
 4-1178 . 
 4-1179 . 
 4-1180 . if (veg)
 4-1181 .    // missing curly brace
 4-1182 .    variable = orange;
 4-1183 . 
 4-1184 . 
 4-1185 . if (A le B)
 4-1186 . {
 4-1187 .    A = B + C;
 4-1188 .    D = E + F;
 4-1189 . }
 4-1190 . 
 4-1191 . 
 4-1192 . if (A eq B)
 4-1193 . {
 4-1194 .    A = B + C;
 4-1195 .    D = E + F;
 4-1196 . }
 4-1197 . 
 4-1198 . 
 4-1199 . if (A >  B)
 4-1200 . {
 4-1201 .    A = B + C;
 4-1202 .    D = E + F;
 4-1203 . }
 4-1204 . 
 4-1205 . A = B/C;
 4-1206 . A = B/C;
 4-1207 . A = B+C;
 4-1208 . A = B/C;
 4-1209 . A = B+C;
 4-1210 . A = B*C;
 4-1211 . A = B/C;
 4-1212 . A = B+C;
 4-1213 . 
 4-1214 . if (A != B)
 4-1215 . {
 4-1216 .    A = B + C;
 4-1217 .    D = E + F;
 4-1218 . }
 4-1219 . 
 4-1220 . A = B*C;
 4-1221 . A = B-C;
 4-1222 . A = B-C;
 4-1223 . 
 4-1224 . switch (pwr stuff)
 4-1225 . {
 4-1226 .    case one:
 4-1227 .    {
 4-1228 .       run_this; 
 4-1229 .       break;
 4-1230 .    }
 4-1231 .    case two:
 4-1232 .    {
 4-1233 .       run_this;
 4-1234 .       break;
 4-1235 .    }
 4-1236 .    default:
 4-1237 .    {
 4-1238 .        SwError;
 4-1239 .    }
 4-1240 . }
 4-1241 . 
 4-1242 . A = B/C;
 4-1243 . A = B-C;
 4-1244 . 
 4-1245 . if (A < = B)
 4-1246 . {
 4-1247 .    A = B + C;
 4-1248 .    D = E + F;
 4-1249 . }
 4-1250 . 
 4-1251 . A = B+C;
 4-1252 . // max LOC 30
 4-1253 . 
 4-1254 . }
 4-1255 . 
 4-1256 . 
 4-1257 . /*
 4-1258 . -----------------------------------------------------------------------------
 4-1259 . --| NAME:   pwr.4.8
 4-1260 . --|
 4-1261 . --| ABSTRACT:
 4-1262 . --|   This function does pwr stuff.
 4-1263 . --|
 4-1264 . --| RETURNS:
 4-1265 . --|   NONE.
 4-1266 . --|
 4-1267 . ----------------------------------------------------------------------------
 4-1268 . */
 4-1269 . static void pwr.4.8(void)
 4-1270 . {
 4-1271 . 
 4-1272 . switch (pwr stuff)
 4-1273 . {
 4-1274 .       case one:
 4-1275 .    {
 4-1276 .       run_this;
 4-1277 .       break;
 4-1278 .    }
 4-1279 .    case two:
 4-1280 .    {
 4-1281 .       run_this;
 4-1282 .       break;
 4-1283 .    }
 4-1284 .    default:
 4-1285 .    {
 4-1286 .       // missing error call
 4-1287 .    }
 4-1288 . }
 4-1289 . 
 4-1290 . A = B/C;
 4-1291 . A = B*C;
 4-1292 . A = B-C;
 4-1293 . 
 4-1294 . if (A ge B)
 4-1295 . {
 4-1296 .    A = B + C;
 4-1297 .    D = E + F;
 4-1298 . }
 4-1299 . 
 4-1300 . A = B+C;
 4-1301 . 
 4-1302 . if (A > = B)
 4-1303 . {
 4-1304 .    A = B + C;
 4-1305 .    D = E + F;
 4-1306 . }
 4-1307 . 
 4-1308 . /* LE SV TOC-2476 this is a pwr-04.8.7 req to audit*/
 4-1309 . A = B+C;
 4-1310 . 
 4-1311 . if (A > = B)
 4-1312 . {
 4-1313 .    A = B + C;
 4-1314 .    D = E + F;
 4-1315 . }
 4-1316 . 
 4-1317 . 
 4-1318 . if (A <  B)
 4-1319 . {
 4-1320 .    A = B + C;
 4-1321 .    D = E + F;
 4-1322 . }
 4-1323 . 
 4-1324 . A = B+C;
 4-1325 . A = B*C;
 4-1326 . // ??? go see ws
 4-1327 . A = B/C;
 4-1328 . A = B/C;
 4-1329 . A = B/C;
 4-1330 . A = B+C;
 4-1331 . A = B+C;
 4-1332 . A = B-C;
 4-1333 . A = B*C;
 4-1334 . A = B+C;
 4-1335 . A = B-C;
 4-1336 . A = B+C;
 4-1337 . A = B/C;
 4-1338 . 
 4-1339 . switch (pwr stuff)
 4-1340 . {
 4-1341 .    case one:
 4-1342 .    {
 4-1343 .       run_this; 
 4-1344 .       break;
 4-1345 .    }
 4-1346 .    case two:
 4-1347 .    {
 4-1348 .       run_this;
 4-1349 .       break;
 4-1350 .    }
 4-1351 .    default:
 4-1352 .    {
 4-1353 .        SwError;
 4-1354 .    }
 4-1355 . }
 4-1356 . 
 4-1357 . A = B+C;
 4-1358 . 
 4-1359 . if (A < = B)
 4-1360 . {
 4-1361 .    A = B + C;
 4-1362 .    D = E + F;
 4-1363 . }
 4-1364 . 
 4-1365 . 
 4-1366 . switch (pwr stuff)
 4-1367 . {
 4-1368 .    case one:
 4-1369 .    {
 4-1370 .       switch (nested)
 4-1371 .       {
 4-1372 .          case:
 4-1373 .             X = Y + Z;
 4-1374 .          case:
 4-1375 .             X = Y + Z;
 4-1376 .          default:
 4-1377 .             SwError;
 4-1378 .       } 
 4-1379 .    }
 4-1380 .    case two:
 4-1381 .    {
 4-1382 .       run_this;
 4-1383 .       break;
 4-1384 .    }
 4-1385 .    default:
 4-1386 .    {
 4-1387 .       SwError;
 4-1388 .    }
 4-1389 . }
 4-1390 . 
 4-1391 . A = B+C;
 4-1392 . A = B*C;
 4-1393 . 
 4-1394 . if (A == B)
 4-1395 . {
 4-1396 .    A = B + C;
 4-1397 .    D = E + F;
 4-1398 . }
 4-1399 . 
 4-1400 . 
 4-1401 . if (A != B)
 4-1402 . {
 4-1403 .    A = B + C;
 4-1404 .    D = E + F;
 4-1405 . }
 4-1406 . 
 4-1407 . A = B/C;
 4-1408 . A = (long)B + C;
 4-1409 . A = B+C;
 4-1410 . 
 4-1411 . if (A le B)
 4-1412 . {
 4-1413 .    A = B + C;
 4-1414 .    D = E + F;
 4-1415 . }
 4-1416 . 
 4-1417 . 
 4-1418 . if (A >  B)
 4-1419 . {
 4-1420 .    A = B + C;
 4-1421 .    D = E + F;
 4-1422 . }
 4-1423 . 
 4-1424 . A = B/C;
 4-1425 . 
 4-1426 . if (A == B)
 4-1427 . {
 4-1428 .    A = B + C;
 4-1429 .    D = E + F;
 4-1430 . }
 4-1431 . 
 4-1432 . 
 4-1433 . if (A gt B)
 4-1434 . {
 4-1435 .    A = B + C;
 4-1436 .    D = E + F;
 4-1437 . }
 4-1438 . 
 4-1439 . A = B+C;
 4-1440 . A = B/C;
 4-1441 . A = B/C;
 4-1442 . A = B/C;
 4-1443 . A = B/C;
 4-1444 . A = B+C;
 4-1445 . 
 4-1446 . if (A < = B)
 4-1447 . {
 4-1448 .    A = B + C;
 4-1449 .    D = E + F;
 4-1450 . }
 4-1451 . 
 4-1452 . A = B-C;
 4-1453 . A = B+C;
 4-1454 . A = B-C;
 4-1455 . A = B+C;
 4-1456 . A = B+C;
 4-1457 . A = B*C;
 4-1458 . A = B-C;
 4-1459 . 
 4-1460 . switch (pwr stuff)
 4-1461 . {
 4-1462 .    case one:
 4-1463 .    {
 4-1464 .       run_this; 
 4-1465 .       break;
 4-1466 .    }
 4-1467 .    case two:
 4-1468 .    {
 4-1469 .       run_this;
 4-1470 .       break;
 4-1471 .    }
 4-1472 .    default:
 4-1473 .    {
 4-1474 .        SwError;
 4-1475 .    }
 4-1476 . }
 4-1477 . 
 4-1478 . 
 4-1479 . if (A gt B)
 4-1480 . {
 4-1481 .    A = B + C;
 4-1482 .    D = E + F;
 4-1483 . }
 4-1484 . 
 4-1485 . 
 4-1486 . if (A eq B)
 4-1487 . {
 4-1488 .    A = B + C;
 4-1489 .    D = E + F;
 4-1490 . }
 4-1491 . 
 4-1492 . 
 4-1493 . if (A le B)
 4-1494 . {
 4-1495 .    A = B + C;
 4-1496 .    D = E + F;
 4-1497 . }
 4-1498 . 
 4-1499 . A = B+C;
 4-1500 . A = B*C;
 4-1501 . A = B-C;
 4-1502 . A = B-C;
 4-1503 . A = B*C;
 4-1504 . 
 4-1505 . if (A >  B)
 4-1506 . {
 4-1507 .    A = B + C;
 4-1508 .    D = E + F;
 4-1509 . }
 4-1510 . 
 4-1511 . A = B/C;
 4-1512 . 
 4-1513 . if (A eq B)
 4-1514 . {
 4-1515 .    A = B + C;
 4-1516 .    D = E + F;
 4-1517 . }
 4-1518 . 
 4-1519 . // max LOC 62
 4-1520 . 
 4-1521 . }
 4-1522 . 
 4-1523 . 
 4-1524 . /*
 4-1525 . -----------------------------------------------------------------------------
 4-1526 . --| NAME:   pwr.4.9
 4-1527 . --|
 4-1528 . --| ABSTRACT:
 4-1529 . --|   This function does pwr stuff.
 4-1530 . --|
 4-1531 . --| RETURNS:
 4-1532 . --|   NONE.
 4-1533 . --|
 4-1534 . ----------------------------------------------------------------------------
 4-1535 . */
 4-1536 . static void pwr.4.9(void)
 4-1537 . {
 4-1538 . A = B/C;
 4-1539 . A = B+C;
 4-1540 . A = B+C;
 4-1541 . A = B*C;
 4-1542 . A = B/C;
 4-1543 . A = B/C;
 4-1544 . A = B+C;
 4-1545 . A = 0x0001;
 4-1546 . A = B+C;
 4-1547 . 
 4-1548 . if (A le B)
 4-1549 . {
 4-1550 .    A = B + C;
 4-1551 .    D = E + F;
 4-1552 . }
 4-1553 . 
 4-1554 . A = B*C;
 4-1555 . A = B+C;
 4-1556 . A = B*C;
 4-1557 . /* LE SV TOC-2477 this is a pwr-04.9.13 req to recover*/
 4-1558 . A = B-C;
 4-1559 . 
 4-1560 . if (A ge B)
 4-1561 . {
 4-1562 .    A = B + C;
 4-1563 .    D = E + F;
 4-1564 . }
 4-1565 . 
 4-1566 . A = B/C;
 4-1567 . A = 0x0006;
 4-1568 . A = B*C;
 4-1569 . A = B+C;
 4-1570 . A = B*C;
 4-1571 . A = B+C;
 4-1572 . 
 4-1573 . if (A >  B)
 4-1574 . {
 4-1575 .    A = B + C;
 4-1576 .    D = E + F;
 4-1577 . }
 4-1578 . 
 4-1579 . A = B-C;
 4-1580 . A = B-C;
 4-1581 . A = B*C;
 4-1582 . A = B/C;
 4-1583 . A = B-C;
 4-1584 . A = B/C;
 4-1585 . A = B-C;
 4-1586 . A = B-C;
 4-1587 . 
 4-1588 . if (A != B)
 4-1589 . {
 4-1590 .    A = B + C;
 4-1591 .    D = E + F;
 4-1592 . }
 4-1593 . 
 4-1594 . 
 4-1595 . if (A lt B)
 4-1596 . {
 4-1597 .    A = B + C;
 4-1598 .    D = E + F;
 4-1599 . }
 4-1600 . 
 4-1601 . /* LE SV TOC-2478 this is a pwr-04.9.31 req to call isr*/
 4-1602 . A = B*C;
 4-1603 . 
 4-1604 . if (A ne B)
 4-1605 . {
 4-1606 .    A = B + C;
 4-1607 .    D = E + F;
 4-1608 . }
 4-1609 . 
 4-1610 . 
 4-1611 . if (A >  B)
 4-1612 . {
 4-1613 .    A = B + C;
 4-1614 .    D = E + F;
 4-1615 . }
 4-1616 . 
 4-1617 . 
 4-1618 . if (A > = B)
 4-1619 . {
 4-1620 .    A = B + C;
 4-1621 .    D = E + F;
 4-1622 . }
 4-1623 . 
 4-1624 . A = B/C;
 4-1625 . A = B*C;
 4-1626 . A = B/C;
 4-1627 . FreePtr = HmiStringPtr;
 4-1628 . A = B*C;
 4-1629 . A = B-C;
 4-1630 . A = 0x0002;
 4-1631 . A = B-C;
 4-1632 . A = B-C;
 4-1633 . A = B-C;
 4-1634 . 
 4-1635 . if (A le B)
 4-1636 . {
 4-1637 .    A = B + C;
 4-1638 .    D = E + F;
 4-1639 . }
 4-1640 . 
 4-1641 . A = B-C;
 4-1642 . /* LE SV TOC-2479 this is a pwr-04.9.45 req to check pSOS*/
 4-1643 . A = B+C;
 4-1644 . 
 4-1645 . if (A >  B)
 4-1646 . {
 4-1647 .    A = B + C;
 4-1648 .    D = E + F;
 4-1649 . }
 4-1650 . 
 4-1651 . /* LE SV TOC-2480 this is a pwr-04.9.47 req to transform*/
 4-1652 . A = B*C;
 4-1653 . 
 4-1654 . if (A < = B)
 4-1655 . {
 4-1656 .    A = B + C;
 4-1657 .    D = E + F;
 4-1658 . }
 4-1659 . 
 4-1660 . A = B+C;
 4-1661 . A = B/C;
 4-1662 . 
 4-1663 . if (A eq B)
 4-1664 . {
 4-1665 .    A = B + C;
 4-1666 .    D = E + F;
 4-1667 . }
 4-1668 . 
 4-1669 . A = B-C;
 4-1670 . A = B/C;
 4-1671 . A = B-C;
 4-1672 . A = B+C;
 4-1673 . A = B+C;
 4-1674 . A = B*C;
 4-1675 . A = B/C;
 4-1676 . 
 4-1677 . if (A < = B)
 4-1678 . {
 4-1679 .    A = B + C;
 4-1680 .    D = E + F;
 4-1681 . }
 4-1682 . 
 4-1683 . A = B+C;
 4-1684 . A = B*C;
 4-1685 . A = B-C;
 4-1686 . 
 4-1687 . if (A le B)
 4-1688 . {
 4-1689 .    A = B + C;
 4-1690 .    D = E + F;
 4-1691 . }
 4-1692 . 
 4-1693 . A = B+C;
 4-1694 . A = B-C;
 4-1695 . 
 4-1696 . if (A ge B)
 4-1697 . {
 4-1698 .    A = B + C;
 4-1699 .    D = E + F;
 4-1700 . }
 4-1701 . 
 4-1702 . A = B+C;
 4-1703 . A = B*C;
 4-1704 . 
 4-1705 . if (A le B)
 4-1706 . {
 4-1707 .    A = B + C;
 4-1708 .    D = E + F;
 4-1709 . }
 4-1710 . 
 4-1711 . 
 4-1712 . switch (pwr stuff)
 4-1713 . {
 4-1714 .    case one:
 4-1715 .    {
 4-1716 .       run_this; 
 4-1717 .       break;
 4-1718 .    }
 4-1719 .    case two:
 4-1720 .    {
 4-1721 .       run_this;
 4-1722 .       break;
 4-1723 .    }
 4-1724 .    default:
 4-1725 .    {
 4-1726 .        SwError;
 4-1727 .    }
 4-1728 . }
 4-1729 . 
 4-1730 . /* LE SV TOC-2481 this is a pwr-04.9.71 req to audit*/
 4-1731 . A = 0x0007;
 4-1732 . 
 4-1733 . if (A <  B)
 4-1734 . {
 4-1735 .    A = B + C;
 4-1736 .    D = E + F;
 4-1737 . }
 4-1738 . 
 4-1739 . A = B-C;
 4-1740 . A = B+C;
 4-1741 . 
 4-1742 . if (A ge B)
 4-1743 . {
 4-1744 .    A = B + C;
 4-1745 .    D = E + F;
 4-1746 . }
 4-1747 . 
 4-1748 . 
 4-1749 . if (A eq B)
 4-1750 . {
 4-1751 .    A = B + C;
 4-1752 .    D = E + F;
 4-1753 . }
 4-1754 . 
 4-1755 . A = B+C;
 4-1756 . A = B/C;
 4-1757 . A = B+C;
 4-1758 . A = B-C;
 4-1759 . 
 4-1760 . switch (pwr stuff)
 4-1761 . {
 4-1762 .    case one:
 4-1763 .    {
 4-1764 .       run_this; 
 4-1765 .       break;
 4-1766 .    }
 4-1767 .    case two:
 4-1768 .    {
 4-1769 .       run_this;
 4-1770 .       break;
 4-1771 .    }
 4-1772 .    default:
 4-1773 .    {
 4-1774 .        SwError;
 4-1775 .    }
 4-1776 . }
 4-1777 . 
 4-1778 . A = B/C;
 4-1779 . 
 4-1780 . switch (pwr stuff)
 4-1781 . {
 4-1782 .    case one:
 4-1783 .    {
 4-1784 .       run_this; 
 4-1785 .       break;
 4-1786 .    }
 4-1787 .    case two:
 4-1788 .    {
 4-1789 .       run_this;
 4-1790 .       break;
 4-1791 .    }
 4-1792 .    default:
 4-1793 .    {
 4-1794 .        SwError;
 4-1795 .    }
 4-1796 . }
 4-1797 . 
 4-1798 . A = B/C;
 4-1799 . A = B+C;
 4-1800 . A = B+C;
 4-1801 . /* LE SV TOC-2482 this is a pwr-04.9.86 req to check unix*/
 4-1802 . 
 4-1803 . if (A < = B)
 4-1804 . {
 4-1805 .    A = B + C;
 4-1806 .    D = E + F;
 4-1807 . }
 4-1808 . 
 4-1809 . A = B+C;
 4-1810 . A = 0x0002;
 4-1811 . A = B+C;
 4-1812 . A = B+C;
 4-1813 . A = B-C;
 4-1814 . A = B+C;
 4-1815 . rcv_buffer = (U16 *) alloc(size+1);
 4-1816 . A = B/C;
 4-1817 . 
 4-1818 . if (A < = B)
 4-1819 . {
 4-1820 .    A = B + C;
 4-1821 .    D = E + F;
 4-1822 . }
 4-1823 . 
 4-1824 . // max LOC 93
 4-1825 . 
 4-1826 . }
 4-1827 . 
 4-1828 . 
 4-1829 . /*
 4-1830 . -----------------------------------------------------------------------------
 4-1831 . --| NAME:   pwr.4.10
 4-1832 . --|
 4-1833 . --| ABSTRACT:
 4-1834 . --|   This function does pwr stuff.
 4-1835 . --|
 4-1836 . --| RETURNS:
 4-1837 . --|   NONE.
 4-1838 . --|
 4-1839 . ----------------------------------------------------------------------------
 4-1840 . */
 4-1841 . static void pwr.4.10(void)
 4-1842 . {
 4-1843 . A = B-C;
 4-1844 . 
 4-1845 . if (A lt B)
 4-1846 . {
 4-1847 .    A = B + C;
 4-1848 .    D = E + F;
 4-1849 . }
 4-1850 . 
 4-1851 . A = B+C;
 4-1852 . A = B*C;
 4-1853 . A = B+C;
 4-1854 . A = B*C;
 4-1855 . A = B*C;
 4-1856 . /* LE SV TOC-2483 this is a pwr-04.10.8 req to set Real Time Clock*/
 4-1857 . A = B-C;
 4-1858 . /* LE SV TOC-2484 this is a pwr-04.10.9 req to set Real Time Clock*/
 4-1859 . A = B+C;
 4-1860 . 
 4-1861 . if (A le B)
 4-1862 . {
 4-1863 .    A = B + C;
 4-1864 .    D = E + F;
 4-1865 . }
 4-1866 . 
 4-1867 . A = B/C;
 4-1868 . A = B/C;
 4-1869 . A = B-C;
 4-1870 . A = B*C;
 4-1871 . A = B-C;
 4-1872 . A = B*C;
 4-1873 . 
 4-1874 . if (A != B)
 4-1875 . {
 4-1876 .    A = B + C;
 4-1877 .    D = E + F;
 4-1878 . }
 4-1879 . 
 4-1880 . A = B+C;
 4-1881 . 
 4-1882 . switch (pwr stuff)
 4-1883 . {
 4-1884 .    case:
 4-1885 .    case:
 4-1886 .    // stacked case statements but only if there is a new line in between
 4-1887 . 
 4-1888 .    case:
 4-1889 .    case:
 4-1890 .    case:
 4-1891 .    {
 4-1892 .       run_this;
 4-1893 .       break;
 4-1894 .    }
 4-1895 .    default:
 4-1896 .    {
 4-1897 .       halt;
 4-1898 .    }
 4-1899 . }
 4-1900 . 
 4-1901 . A = B*C;
 4-1902 . A = B-C;
 4-1903 . 
 4-1904 . if (A gt B)
 4-1905 . {
 4-1906 .    A = B + C;
 4-1907 .    D = E + F;
 4-1908 . }
 4-1909 . 
 4-1910 . // ??? go see ws
 4-1911 . A = B*C;
 4-1912 . /* LE SV TOC-2485 this is a pwr-04.10.23 req to check pSOS*/
 4-1913 . A = B/C;
 4-1914 . /* LE SV TOC-2486 this is a pwr-04.10.24 req to transform*/
 4-1915 . A = B+C;
 4-1916 . A = B/C;
 4-1917 . 
 4-1918 . if (A le B)
 4-1919 . {
 4-1920 .    A = B + C;
 4-1921 .    D = E + F;
 4-1922 . }
 4-1923 . 
 4-1924 . A = (long)B + C;
 4-1925 . A = B*C;
 4-1926 . 
 4-1927 . if (A == B)
 4-1928 . {
 4-1929 .    A = B + C;
 4-1930 .    D = E + F;
 4-1931 . }
 4-1932 . 
 4-1933 . A = B*C;
 4-1934 . 
 4-1935 . if (A ne B)
 4-1936 . {
 4-1937 .    A = B + C;
 4-1938 .    D = E + F;
 4-1939 . }
 4-1940 . 
 4-1941 . 
 4-1942 . if (A != B)
 4-1943 . {
 4-1944 .    A = B + C;
 4-1945 .    D = E + F;
 4-1946 . }
 4-1947 . 
 4-1948 . 
 4-1949 . if (A ne B)
 4-1950 . {
 4-1951 .    A = B + C;
 4-1952 .    D = E + F;
 4-1953 . }
 4-1954 . 
 4-1955 . A = B-C;
 4-1956 . A = B+C;
 4-1957 . 
 4-1958 . if (A ge B)
 4-1959 . {
 4-1960 .    A = B + C;
 4-1961 .    D = E + F;
 4-1962 . }
 4-1963 . 
 4-1964 . A = B/C;
 4-1965 . A = B+C;
 4-1966 . A = B/C;
 4-1967 . A = B-C;
 4-1968 . A = B-C;
 4-1969 . A = B+C;
 4-1970 . A = B-C;
 4-1971 . A = B*C;
 4-1972 . A = B*C;
 4-1973 . A = B+C;
 4-1974 . 
 4-1975 . if (A == B)
 4-1976 . {
 4-1977 .    A = B + C;
 4-1978 .    D = E + F;
 4-1979 . }
 4-1980 . 
 4-1981 . 
 4-1982 . if (A ge B)
 4-1983 . {
 4-1984 .    A = B + C;
 4-1985 .    D = E + F;
 4-1986 . }
 4-1987 . 
 4-1988 . 
 4-1989 . if (A > = B)
 4-1990 . {
 4-1991 .    A = B + C;
 4-1992 .    D = E + F;
 4-1993 . }
 4-1994 . 
 4-1995 . /* LE SV TOC-2487 this is a pwr-04.10.49 req to inhibit*/
 4-1996 . A = B*C;
 4-1997 . 
 4-1998 . if (A != B)
 4-1999 . {
 4-2000 .    A = B + C;
 4-2001 .    D = E + F;
 4-2002 . }
 4-2003 . 
 4-2004 . 
 4-2005 . if (A ge B)
 4-2006 . {
 4-2007 .    A = B + C;
 4-2008 .    D = E + F;
 4-2009 . }
 4-2010 . 
 4-2011 . A = (float)B + C;
 4-2012 . A = B/C;
 4-2013 . A = B/C;
 4-2014 . A = B/C;
 4-2015 . A = B-C;
 4-2016 . 
 4-2017 . /*
 4-2018 . dead_block = C * D; 
 4-2019 . dead_block = E * F;
 4-2020 . */
 4-2021 . 
 4-2022 . A = B*C;
 4-2023 . A = B-C;
 4-2024 . A = B-C;
 4-2025 . A = B/C;
 4-2026 . A = B-C;
 4-2027 . A = B-C;
 4-2028 . A = B-C;
 4-2029 . /* LE SV TOC-2488 this is a pwr-04.10.63 req to set RTC*/
 4-2030 . 
 4-2031 . if (A eq B)
 4-2032 . {
 4-2033 .    A = B + C;
 4-2034 .    D = E + F;
 4-2035 . }
 4-2036 . 
 4-2037 . // max LOC 63
 4-2038 . 
 4-2039 . }
 4-2040 . 
 4-2041 . 
 4-2042 . /*
 4-2043 . -----------------------------------------------------------------------------
 4-2044 . --| NAME:   pwr.4.11
 4-2045 . --|
 4-2046 . --| ABSTRACT:
 4-2047 . --|   This function does pwr stuff.
 4-2048 . --|
 4-2049 . --| RETURNS:
 4-2050 . --|   NONE.
 4-2051 . --|
 4-2052 . ----------------------------------------------------------------------------
 4-2053 . */
 4-2054 . static void pwr.4.11(void)
 4-2055 . {
 4-2056 . A = B+C;
 4-2057 . 
 4-2058 . switch (pwr stuff)
 4-2059 . {
 4-2060 .    case one:
 4-2061 .    {
 4-2062 .       run_this; 
 4-2063 .       break;
 4-2064 .    }
 4-2065 .    case two:
 4-2066 .    {
 4-2067 .       run_this;
 4-2068 .       break;
 4-2069 .    }
 4-2070 .    default:
 4-2071 .    {
 4-2072 .        SwError;
 4-2073 .    }
 4-2074 . }
 4-2075 . 
 4-2076 . A = B+C;
 4-2077 . A = B*C;
 4-2078 . /* LE SV TOC-2489 this is a pwr-04.11.5 req to transform*/
 4-2079 . A = B*C;
 4-2080 . 
 4-2081 . if (A eq B)
 4-2082 . {
 4-2083 .    A = B + C;
 4-2084 .    D = E + F;
 4-2085 . }
 4-2086 . 
 4-2087 . A = B+C;
 4-2088 . A = B+C;
 4-2089 . A = B/C;
 4-2090 . A = B*C;
 4-2091 . 
 4-2092 . switch (pwr stuff)
 4-2093 . {
 4-2094 .    case one:
 4-2095 .    {
 4-2096 .       run_this; 
 4-2097 .       break;
 4-2098 .    }
 4-2099 .    case two:
 4-2100 .    {
 4-2101 .       run_this;
 4-2102 .       break;
 4-2103 .    }
 4-2104 .    default:
 4-2105 .    {
 4-2106 .        SwError;
 4-2107 .    }
 4-2108 . }
 4-2109 . 
 4-2110 . A = B+C;
 4-2111 . A = B-C;
 4-2112 . /* LE SV TOC-2490 this is a pwr-04.11.14 req to record*/
 4-2113 . 
 4-2114 . if (A ge B)
 4-2115 . {
 4-2116 .    A = B + C;
 4-2117 .    D = E + F;
 4-2118 . }
 4-2119 . 
 4-2120 . 
 4-2121 . if (A ge B)
 4-2122 . {
 4-2123 .    A = B + C;
 4-2124 .    D = E + F;
 4-2125 . }
 4-2126 . 
 4-2127 . /* LE SV TOC-2491 this is a pwr-04.11.16 req to transform*/
 4-2128 . A = B-C;
 4-2129 . A = B*C;
 4-2130 . A = B-C;
 4-2131 . 
 4-2132 . switch (pwr stuff)
 4-2133 . {
 4-2134 .       case one:
 4-2135 .    {
 4-2136 .       run_this;
 4-2137 .       break;
 4-2138 .    }
 4-2139 .    case two:
 4-2140 .    {
 4-2141 .       run_this;
 4-2142 .       break;
 4-2143 .    }
 4-2144 .    default:
 4-2145 .    {
 4-2146 .       // missing error call
 4-2147 .    }
 4-2148 . }
 4-2149 . 
 4-2150 . 
 4-2151 . if (A >  B)
 4-2152 . {
 4-2153 .    A = B + C;
 4-2154 .    D = E + F;
 4-2155 . }
 4-2156 . 
 4-2157 . A = B-C;
 4-2158 . A = B-C;
 4-2159 . A = B+C;
 4-2160 . 
 4-2161 . if (A > = B)
 4-2162 . {
 4-2163 .    A = B + C;
 4-2164 .    D = E + F;
 4-2165 . }
 4-2166 . 
 4-2167 . A = B+C;
 4-2168 . A = B/C;
 4-2169 . /* LE SV TOC-2492 this is a pwr-04.11.26 req to assign*/
 4-2170 . 
 4-2171 . if (A le B)
 4-2172 . {
 4-2173 .    A = B + C;
 4-2174 .    D = E + F;
 4-2175 . }
 4-2176 . 
 4-2177 . A = B+C;
 4-2178 . A = B-C;
 4-2179 . A = B-C;
 4-2180 . 
 4-2181 . if (A ne B)
 4-2182 . {
 4-2183 .    A = B + C;
 4-2184 .    D = E + F;
 4-2185 . }
 4-2186 . 
 4-2187 . A = B-C;
 4-2188 . 
 4-2189 . if (A >  B)
 4-2190 . {
 4-2191 .    A = B + C;
 4-2192 .    D = E + F;
 4-2193 . }
 4-2194 . 
 4-2195 . 
 4-2196 . if (A lt B)
 4-2197 . {
 4-2198 .    A = B + C;
 4-2199 .    D = E + F;
 4-2200 . }
 4-2201 . 
 4-2202 . A = B*C;
 4-2203 . A = B+C;
 4-2204 . /* LE SV TOC-2493 this is a pwr-04.11.36 req to fail*/
 4-2205 . A = B+C;
 4-2206 . A = B*C;
 4-2207 . A = B-C;
 4-2208 . A = B*C;
 4-2209 . A = B-C;
 4-2210 . 
 4-2211 . if (A lt B)
 4-2212 . {
 4-2213 .    A = B + C;
 4-2214 .    D = E + F;
 4-2215 . }
 4-2216 . 
 4-2217 . A = B-C;
 4-2218 . 
 4-2219 . if (A le B)
 4-2220 . {
 4-2221 .    A = B + C;
 4-2222 .    D = E + F;
 4-2223 . }
 4-2224 . 
 4-2225 . A = B+C;
 4-2226 . A = B/C;
 4-2227 . // TBD - what do I do now
 4-2228 . A = B-C;
 4-2229 . A = B-C;
 4-2230 . A = B-C;
 4-2231 . 
 4-2232 . if (A ne B)
 4-2233 . {
 4-2234 .    A = B + C;
 4-2235 .    D = E + F;
 4-2236 . }
 4-2237 . 
 4-2238 . A = B+C;
 4-2239 . 
 4-2240 . if (A == B)
 4-2241 . {
 4-2242 .    A = B + C;
 4-2243 .    D = E + F;
 4-2244 . }
 4-2245 . 
 4-2246 . 
 4-2247 . if (A ne B)
 4-2248 . {
 4-2249 .    A = B + C;
 4-2250 .    D = E + F;
 4-2251 . }
 4-2252 . 
 4-2253 . 
 4-2254 . if (A le B)
 4-2255 . {
 4-2256 .    A = B + C;
 4-2257 .    D = E + F;
 4-2258 . }
 4-2259 . 
 4-2260 . A = B-C;
 4-2261 . A = B-C;
 4-2262 . A = B-C;
 4-2263 . A = B-C;
 4-2264 . A = B-C;
 4-2265 . A = B-C;
 4-2266 . A = B-C;
 4-2267 . A = B+C;
 4-2268 . A = B+C;
 4-2269 . 
 4-2270 . switch (pwr stuff)
 4-2271 . {
 4-2272 .    case one:
 4-2273 .    {
 4-2274 .       run_this; 
 4-2275 .       break;
 4-2276 .    }
 4-2277 .    case two:
 4-2278 .    {
 4-2279 .       run_this;
 4-2280 .       break;
 4-2281 .    }
 4-2282 .    default:
 4-2283 .    {
 4-2284 .        SwError;
 4-2285 .    }
 4-2286 . }
 4-2287 . 
 4-2288 . 
 4-2289 . if (A le B)
 4-2290 . {
 4-2291 .    A = B + C;
 4-2292 .    D = E + F;
 4-2293 . }
 4-2294 . 
 4-2295 . /* LE SV TOC-2494 this is a pwr-04.11.65 req to translate*/
 4-2296 . A = B+C;
 4-2297 . A = B-C;
 4-2298 . A = B-C;
 4-2299 . 
 4-2300 . if (A ne B)
 4-2301 . {
 4-2302 .    A = B + C;
 4-2303 .    D = E + F;
 4-2304 . }
 4-2305 . 
 4-2306 . A = B-C;
 4-2307 . A = B-C;
 4-2308 . // max LOC 70
 4-2309 . 
 4-2310 . }
 4-2311 . 

4 4 Result: result/source/pr-app/pr-app-PWR123/pwr-04.c

5 5 Source: source/pr-app/pr-app-PWR123/pwr-05.c
 5-0 . /*
 5-1 . ----------------------------------------------------------------------------
 5-2 . --| BEGIN PROLOGUE
 5-3 . --|
 5-4 . --| CLASSIFICATION: UNCLASSIFIED
 5-5 . --|
 5-6 . --| FILE NAME:      pwr-05.c
 5-7 . --|
 5-8 . --| ABSTRACT:
 5-9 . --|   This file contains the 14 functions that do file pwr stuff.
 5-10 . --|
 5-11 . --| HISTORY:
 5-12 . --|   CCCQ_NAME:
 5-13 . --|   CCCQ_VER: 
 5-14 . --|
 5-15 . --| END PROLOGUE
 5-16 . ----------------------------------------------------------------------------
 5-17 . */
 5-18 . 
 5-19 . #define A;
 5-20 . #include D;
 5-21 . char D;
 5-22 . #include B;
 5-23 . #define D;
 5-24 . 
 5-25 . 
 5-26 . 
 5-27 . /*
 5-28 . -----------------------------------------------------------------------------
 5-29 . --| NAME:   pwr.5.1
 5-30 . --|
 5-31 . --| ABSTRACT:
 5-32 . --|   This function does pwr stuff.
 5-33 . --|
 5-34 . --| RETURNS:
 5-35 . --|   NONE.
 5-36 . --|
 5-37 . ----------------------------------------------------------------------------
 5-38 . */
 5-39 . static void pwr.5.1(void)
 5-40 . {
 5-41 . A = B-C;
 5-42 . 
 5-43 . if (A eq B)
 5-44 . {
 5-45 .    A = B + C;
 5-46 .    D = E + F;
 5-47 . }
 5-48 . 
 5-49 . A = B*C;
 5-50 . A = B-C;
 5-51 . A = B*C;
 5-52 . 
 5-53 . if (A lt B)
 5-54 . {
 5-55 .    A = B + C;
 5-56 .    D = E + F;
 5-57 . }
 5-58 . 
 5-59 . 
 5-60 . if (A lt B)
 5-61 . {
 5-62 .    A = B + C;
 5-63 .    D = E + F;
 5-64 . }
 5-65 . 
 5-66 . A = B*C;
 5-67 . 
 5-68 . switch (pwr stuff)
 5-69 . {
 5-70 .    case one:
 5-71 .    {
 5-72 .       run_this; 
 5-73 .       break;
 5-74 .    }
 5-75 .    case two:
 5-76 .    {
 5-77 .       run_this;
 5-78 .       break;
 5-79 .    }
 5-80 .    default:
 5-81 .    {
 5-82 .        SwError;
 5-83 .    }
 5-84 . }
 5-85 . 
 5-86 . A = B/C;
 5-87 . 
 5-88 . if (A == B)
 5-89 . {
 5-90 .    A = B + C;
 5-91 .    D = E + F;
 5-92 . }
 5-93 . 
 5-94 . A = B*C;
 5-95 . A = B/C;
 5-96 . // max LOC 13
 5-97 . 
 5-98 . }
 5-99 . 
 5-100 . 
 5-101 . /*
 5-102 . -----------------------------------------------------------------------------
 5-103 . --| NAME:   pwr.5.2
 5-104 . --|
 5-105 . --| ABSTRACT:
 5-106 . --|   This function does pwr stuff.
 5-107 . --|
 5-108 . --| RETURNS:
 5-109 . --|   NONE.
 5-110 . --|
 5-111 . ----------------------------------------------------------------------------
 5-112 . */
 5-113 . static void pwr.5.2(void)
 5-114 . {
 5-115 . A = B-C;
 5-116 . A = B/C;
 5-117 . A = B*C;
 5-118 . 
 5-119 . if (A lt B)
 5-120 . {
 5-121 .    A = B + C;
 5-122 .    D = E + F;
 5-123 . }
 5-124 . 
 5-125 . 
 5-126 . if (A >  B)
 5-127 . {
 5-128 .    A = B + C;
 5-129 .    D = E + F;
 5-130 . }
 5-131 . 
 5-132 . A = B-C;
 5-133 . A = B+C;
 5-134 . 
 5-135 . if (A != B)
 5-136 . {
 5-137 .    A = B + C;
 5-138 .    D = E + F;
 5-139 . }
 5-140 . 
 5-141 . 
 5-142 . if (A ge B)
 5-143 . {
 5-144 .    A = B + C;
 5-145 .    D = E + F;
 5-146 . }
 5-147 . 
 5-148 . 
 5-149 . if (A ge B)
 5-150 . {
 5-151 .    A = B + C;
 5-152 .    D = E + F;
 5-153 . }
 5-154 . 
 5-155 . A = B+C;
 5-156 . /* LE SV TOC-2495 this is a pwr-05.2.12 req to transform*/
 5-157 . 
 5-158 . switch (pwr stuff)
 5-159 . {
 5-160 .    case one:
 5-161 .    {
 5-162 .       run_this; 
 5-163 .       break;
 5-164 .    }
 5-165 .    case two:
 5-166 .    {
 5-167 .       run_this;
 5-168 .       break;
 5-169 .    }
 5-170 .    default:
 5-171 .    {
 5-172 .        SwError;
 5-173 .    }
 5-174 . }
 5-175 . 
 5-176 . 
 5-177 . if (A lt B)
 5-178 . {
 5-179 .    A = B + C;
 5-180 .    D = E + F;
 5-181 . }
 5-182 . 
 5-183 . A = B-C;
 5-184 . 
 5-185 . if (A le B)
 5-186 . {
 5-187 .    A = B + C;
 5-188 .    D = E + F;
 5-189 . }
 5-190 . 
 5-191 . A = B+C;
 5-192 . A = B*C;
 5-193 . A = B*C;
 5-194 . A = B+C;
 5-195 . A = B+C;
 5-196 . A = B/C;
 5-197 . A = B-C;
 5-198 . 
 5-199 . if (A lt B)
 5-200 . {
 5-201 .    A = B + C;
 5-202 .    D = E + F;
 5-203 . }
 5-204 . 
 5-205 . A = B+C;
 5-206 . 
 5-207 . if (A eq B)
 5-208 . {
 5-209 .    A = B + C;
 5-210 .    D = E + F;
 5-211 . }
 5-212 . 
 5-213 . A = B+C;
 5-214 . A = B+C;
 5-215 . 
 5-216 . switch (pwr stuff)
 5-217 . {
 5-218 .    case one:
 5-219 .    {
 5-220 .       run_this;
 5-221 .       break;
 5-222 .    }
 5-223 .    case two:
 5-224 .    {
 5-225 .       run_this;
 5-226 .       break;
 5-227 .    }
 5-228 .    // missing default
 5-229 . }
 5-230 . 
 5-231 . 
 5-232 . if (A != B)
 5-233 . {
 5-234 .    A = B + C;
 5-235 .    D = E + F;
 5-236 . }
 5-237 . 
 5-238 . A = B-C;
 5-239 . 
 5-240 . if (A gt B)
 5-241 . {
 5-242 .    A = B + C;
 5-243 .    D = E + F;
 5-244 . }
 5-245 . 
 5-246 . A = B/C;
 5-247 . 
 5-248 . if (A < = B)
 5-249 . {
 5-250 .    A = B + C;
 5-251 .    D = E + F;
 5-252 . }
 5-253 . 
 5-254 . A = B/C;
 5-255 . 
 5-256 . if (A == B)
 5-257 . {
 5-258 .    A = B + C;
 5-259 .    D = E + F;
 5-260 . }
 5-261 . 
 5-262 . A = B*C;
 5-263 . A = (int)B + C;
 5-264 . A = B*C;
 5-265 . /* LE SV TOC-2496 this is a pwr-05.2.37 req to inhibit*/
 5-266 . A = B*C;
 5-267 . A = B/C;
 5-268 . A = 0x0009;
 5-269 . do forever;
 5-270 . 
 5-271 . if (A ge B)
 5-272 . {
 5-273 .    A = B + C;
 5-274 .    D = E + F;
 5-275 . }
 5-276 . 
 5-277 . A = B+C;
 5-278 . 
 5-279 . if (A != B)
 5-280 . {
 5-281 .    A = B + C;
 5-282 .    D = E + F;
 5-283 . }
 5-284 . 
 5-285 . 
 5-286 . switch (pwr stuff)
 5-287 . {
 5-288 .    case one:
 5-289 .    {
 5-290 .       run_this; 
 5-291 .       break;
 5-292 .    }
 5-293 .    case two:
 5-294 .    {
 5-295 .       run_this;
 5-296 .       break;
 5-297 .    }
 5-298 .    default:
 5-299 .    {
 5-300 .        SwError;
 5-301 .    }
 5-302 . }
 5-303 . 
 5-304 . A = B-C;
 5-305 . 
 5-306 . if (A <  B)
 5-307 . {
 5-308 .    A = B + C;
 5-309 .    D = E + F;
 5-310 . }
 5-311 . 
 5-312 . A = B*C;
 5-313 . A = B*C;
 5-314 . A = B*C;
 5-315 . A = B*C;
 5-316 . 
 5-317 . if (A eq B)
 5-318 . {
 5-319 .    A = B + C;
 5-320 .    D = E + F;
 5-321 . }
 5-322 . 
 5-323 . A = B*C;
 5-324 . 
 5-325 . if (A > = B)
 5-326 . {
 5-327 .    A = B + C;
 5-328 .    D = E + F;
 5-329 . }
 5-330 . 
 5-331 . 
 5-332 . if (A > = B)
 5-333 . {
 5-334 .    A = B + C;
 5-335 .    D = E + F;
 5-336 . }
 5-337 . 
 5-338 . A = B-C;
 5-339 . 
 5-340 . if (A eq B)
 5-341 . {
 5-342 .    A = B + C;
 5-343 .    D = E + F;
 5-344 . }
 5-345 . 
 5-346 . goto error;
 5-347 . A = B+C;
 5-348 . A = B+C;
 5-349 . A = 0x0008;
 5-350 . A = B-C;
 5-351 . 
 5-352 . if (A > = B)
 5-353 . {
 5-354 .    A = B + C;
 5-355 .    D = E + F;
 5-356 . }
 5-357 . 
 5-358 . A = B*C;
 5-359 . A = B-C;
 5-360 . A = B-C;
 5-361 . A = B/C;
 5-362 . 
 5-363 . if (A == B)
 5-364 . {
 5-365 .    A = B + C;
 5-366 .    D = E + F;
 5-367 . }
 5-368 . 
 5-369 . 
 5-370 . if (A eq B)
 5-371 . {
 5-372 .    A = B + C;
 5-373 .    D = E + F;
 5-374 . }
 5-375 . 
 5-376 . A = B-C;
 5-377 . A = B*C;
 5-378 . 
 5-379 . if (A >  B)
 5-380 . {
 5-381 .    A = B + C;
 5-382 .    D = E + F;
 5-383 . }
 5-384 . 
 5-385 . 
 5-386 . if (A <  B)
 5-387 . {
 5-388 .    A = B + C;
 5-389 .    D = E + F;
 5-390 . }
 5-391 . 
 5-392 . A = B-C;
 5-393 . A = B-C;
 5-394 . A = B+C;
 5-395 . 
 5-396 . if (A ge B)
 5-397 . {
 5-398 .    A = B + C;
 5-399 .    D = E + F;
 5-400 . }
 5-401 . 
 5-402 . 
 5-403 . if (A eq B)
 5-404 . {
 5-405 .    A = B + C;
 5-406 .    D = E + F;
 5-407 . }
 5-408 . 
 5-409 . A = B*C;
 5-410 . 
 5-411 . if (A ge B)
 5-412 . {
 5-413 .    A = B + C;
 5-414 .    D = E + F;
 5-415 . }
 5-416 . 
 5-417 . 
 5-418 . if (A eq B)
 5-419 . {
 5-420 .    A = B + C;
 5-421 .    D = E + F;
 5-422 . }
 5-423 . 
 5-424 . A = B+C;
 5-425 . A = B-C;
 5-426 . 
 5-427 . if (A > = B)
 5-428 . {
 5-429 .    A = B + C;
 5-430 .    D = E + F;
 5-431 . }
 5-432 . 
 5-433 . // max LOC 79
 5-434 . 
 5-435 . }
 5-436 . 
 5-437 . 
 5-438 . /*
 5-439 . -----------------------------------------------------------------------------
 5-440 . --| NAME:   pwr.5.3
 5-441 . --|
 5-442 . --| ABSTRACT:
 5-443 . --|   This function does pwr stuff.
 5-444 . --|
 5-445 . --| RETURNS:
 5-446 . --|   NONE.
 5-447 . --|
 5-448 . ----------------------------------------------------------------------------
 5-449 . */
 5-450 . static void pwr.5.3(void)
 5-451 . {
 5-452 . 
 5-453 . if (A > = B)
 5-454 . {
 5-455 .    A = B + C;
 5-456 .    D = E + F;
 5-457 . }
 5-458 . 
 5-459 . 
 5-460 . if (A > = B)
 5-461 . {
 5-462 .    A = B + C;
 5-463 .    D = E + F;
 5-464 . }
 5-465 . 
 5-466 . A = B*C;
 5-467 . A = B-C;
 5-468 . A = B/C;
 5-469 . 
 5-470 . if (A eq B)
 5-471 . {
 5-472 .    A = B + C;
 5-473 .    D = E + F;
 5-474 . }
 5-475 . 
 5-476 . 
 5-477 . if (A < = B)
 5-478 . {
 5-479 .    A = B + C;
 5-480 .    D = E + F;
 5-481 . }
 5-482 . 
 5-483 . 
 5-484 . if (A ne B)
 5-485 . {
 5-486 .    A = B + C;
 5-487 .    D = E + F;
 5-488 . }
 5-489 . 
 5-490 . A = B+C;
 5-491 . A = B/C;
 5-492 . 
 5-493 . if (A > = B)
 5-494 . {
 5-495 .    A = B + C;
 5-496 .    D = E + F;
 5-497 . }
 5-498 . 
 5-499 . 
 5-500 . if (A ne B)
 5-501 . {
 5-502 .    A = B + C;
 5-503 .    D = E + F;
 5-504 . }
 5-505 . 
 5-506 . 
 5-507 . if (A != B)
 5-508 . {
 5-509 .    A = B + C;
 5-510 .    D = E + F;
 5-511 . }
 5-512 . 
 5-513 . A = B+C;
 5-514 . /* LE SV TOC-2497 this is a pwr-05.3.15 req to inhibit*/
 5-515 . A = B*C;
 5-516 . /* LE SV TOC-2498 this is a pwr-05.3.16 req to check unix*/
 5-517 . A = B*C;
 5-518 . 
 5-519 . if (A ne B)
 5-520 . {
 5-521 .    A = B + C;
 5-522 .    D = E + F;
 5-523 . }
 5-524 . 
 5-525 . 
 5-526 . if (A < = B)
 5-527 . {
 5-528 .    A = B + C;
 5-529 .    D = E + F;
 5-530 . }
 5-531 . 
 5-532 . 
 5-533 . if (A ne B)
 5-534 . {
 5-535 .    A = B + C;
 5-536 .    D = E + F;
 5-537 . }
 5-538 . 
 5-539 . A = B-C;
 5-540 . A = B+C;
 5-541 . 
 5-542 . if (A ne B)
 5-543 . {
 5-544 .    A = B + C;
 5-545 .    D = E + F;
 5-546 . }
 5-547 . 
 5-548 . A = B/C;
 5-549 . A = 0x0006;
 5-550 . 
 5-551 . if (A ge B)
 5-552 . {
 5-553 .    A = B + C;
 5-554 .    D = E + F;
 5-555 . }
 5-556 . 
 5-557 . A = B-C;
 5-558 . A = B+C;
 5-559 . 
 5-560 . if (A le B)
 5-561 . {
 5-562 .    A = B + C;
 5-563 .    D = E + F;
 5-564 . }
 5-565 . 
 5-566 . /* LE SV TOC-2499 this is a pwr-05.3.28 req to increment*/
 5-567 . 
 5-568 . if (A > = B)
 5-569 . {
 5-570 .    A = B + C;
 5-571 .    D = E + F;
 5-572 . }
 5-573 . 
 5-574 . 
 5-575 . if (A != B)
 5-576 . {
 5-577 .    A = B + C;
 5-578 .    D = E + F;
 5-579 . }
 5-580 . 
 5-581 . A = B*C;
 5-582 . 
 5-583 . if (A > = B)
 5-584 . {
 5-585 .    A = B + C;
 5-586 .    D = E + F;
 5-587 . }
 5-588 . 
 5-589 . A = B-C;
 5-590 . A = B+C;
 5-591 . A = B+C;
 5-592 . A = B*C;
 5-593 . A = B-C;
 5-594 . A = B-C;
 5-595 . A = B/C;
 5-596 . 
 5-597 . if (A lt B)
 5-598 . {
 5-599 .    A = B + C;
 5-600 .    D = E + F;
 5-601 . }
 5-602 . 
 5-603 . 
 5-604 . if (A le B)
 5-605 . {
 5-606 .    A = B + C;
 5-607 .    D = E + F;
 5-608 . }
 5-609 . 
 5-610 . // max LOC 40
 5-611 . 
 5-612 . }
 5-613 . 
 5-614 . 
 5-615 . /*
 5-616 . -----------------------------------------------------------------------------
 5-617 . --| NAME:   pwr.5.4
 5-618 . --|
 5-619 . --| ABSTRACT:
 5-620 . --|   This function does pwr stuff.
 5-621 . --|
 5-622 . --| RETURNS:
 5-623 . --|   NONE.
 5-624 . --|
 5-625 . ----------------------------------------------------------------------------
 5-626 . */
 5-627 . static void pwr.5.4(void)
 5-628 . {
 5-629 . A = B+C;
 5-630 . A = B*C;
 5-631 . A = (long)B + C;
 5-632 . A = B/C;
 5-633 . A = B-C;
 5-634 . A = B+C;
 5-635 . 
 5-636 . if (A eq B)
 5-637 . {
 5-638 .    A = B + C;
 5-639 .    D = E + F;
 5-640 . }
 5-641 . 
 5-642 . A = B/C;
 5-643 . /* LE SV TOC-2500 this is a pwr-05.4.8 req to increment*/
 5-644 . A = B/C;
 5-645 . A = B/C;
 5-646 . 
 5-647 . if (A ne B)
 5-648 . {
 5-649 .    A = B + C;
 5-650 .    D = E + F;
 5-651 . }
 5-652 . 
 5-653 . A = B+C;
 5-654 . A = 0x0001;
 5-655 . A = B*C;
 5-656 . /* LE SV TOC-2501 this is a pwr-05.4.13 req to detect error*/
 5-657 . A = B-C;
 5-658 . A = B*C;
 5-659 . A = B-C;
 5-660 . A = B-C;
 5-661 . A = B+C;
 5-662 . A = B+C;
 5-663 . A = B/C;
 5-664 . A = B/C;
 5-665 . A = B-C;
 5-666 . 
 5-667 . switch (pwr stuff)
 5-668 . {
 5-669 .    case one:
 5-670 .    {
 5-671 .       run_this; 
 5-672 .       break;
 5-673 .    }
 5-674 .    case two:
 5-675 .    {
 5-676 .       run_this;
 5-677 .       break;
 5-678 .    }
 5-679 .    default:
 5-680 .    {
 5-681 .        SwError;
 5-682 .    }
 5-683 . }
 5-684 . 
 5-685 . A = 0x0009;
 5-686 . A = B+C;
 5-687 . A = B*C;
 5-688 . A = B/C;
 5-689 . A = B+C;
 5-690 . A = B*C;
 5-691 . 
 5-692 . if (A <  B)
 5-693 . {
 5-694 .    A = B + C;
 5-695 .    D = E + F;
 5-696 . }
 5-697 . 
 5-698 . A = B/C;
 5-699 . A = B-C;
 5-700 . 
 5-701 . switch (pwr stuff)
 5-702 . {
 5-703 .    case one:
 5-704 .    {
 5-705 .       run_this; 
 5-706 .       // missing break
 5-707 .    }
 5-708 .    case two:
 5-709 .    {
 5-710 .       run_this;
 5-711 .       break;
 5-712 .    }
 5-713 .    default:
 5-714 .    {
 5-715 .       SwError;
 5-716 .    }
 5-717 . }
 5-718 . 
 5-719 . 
 5-720 . if (A gt B)
 5-721 . {
 5-722 .    A = B + C;
 5-723 .    D = E + F;
 5-724 . }
 5-725 . 
 5-726 . A = B/C;
 5-727 . A = B-C;
 5-728 . A = B+C;
 5-729 . A = B/C;
 5-730 . /* LE SV TOC-2502 this is a pwr-05.4.36 req to set RTC*/
 5-731 . A = B*C;
 5-732 . A = B/C;
 5-733 . 
 5-734 . if (A le B)
 5-735 . {
 5-736 .    A = B + C;
 5-737 .    D = E + F;
 5-738 . }
 5-739 . 
 5-740 . A = B*C;
 5-741 . A = B/C;
 5-742 . A = B+C;
 5-743 . A = B*C;
 5-744 . // max LOC 42
 5-745 . 
 5-746 . }
 5-747 . 
 5-748 . 
 5-749 . /*
 5-750 . -----------------------------------------------------------------------------
 5-751 . --| NAME:   pwr.5.5
 5-752 . --|
 5-753 . --| ABSTRACT:
 5-754 . --|   This function does pwr stuff.
 5-755 . --|
 5-756 . --| RETURNS:
 5-757 . --|   NONE.
 5-758 . --|
 5-759 . ----------------------------------------------------------------------------
 5-760 . */
 5-761 . static void pwr.5.5(void)
 5-762 . {
 5-763 . /* LE SV TOC-2503 this is a pwr-05.5.1 req to fail*/
 5-764 . A = B+C;
 5-765 . 
 5-766 . if (A == B)
 5-767 . {
 5-768 .    A = B + C;
 5-769 .    D = E + F;
 5-770 . }
 5-771 . 
 5-772 . /* LE SV TOC-2504 this is a pwr-05.5.3 req to check pSOS*/
 5-773 . 
 5-774 . if (A == B)
 5-775 . {
 5-776 .    A = B + C;
 5-777 .    D = E + F;
 5-778 . }
 5-779 . 
 5-780 . A = B*C;
 5-781 . 
 5-782 . if (A >  B)
 5-783 . {
 5-784 .    A = B + C;
 5-785 .    D = E + F;
 5-786 . }
 5-787 . 
 5-788 . A = B*C;
 5-789 . A = B/C;
 5-790 . A = B/C;
 5-791 . A = B-C;
 5-792 . A = B-C;
 5-793 . A = B+C;
 5-794 . 
 5-795 . switch (pwr stuff)
 5-796 . {
 5-797 .       case one:
 5-798 .    {
 5-799 .       run_this;
 5-800 .       break;
 5-801 .    }
 5-802 .    case two:
 5-803 .    {
 5-804 .       run_this;
 5-805 .       break;
 5-806 .    }
 5-807 .    default:
 5-808 .    {
 5-809 .       // missing error call
 5-810 .    }
 5-811 . }
 5-812 . 
 5-813 . A = B+C;
 5-814 . A = B+C;
 5-815 . A = B+C;
 5-816 . A = B/C;
 5-817 . A = B-C;
 5-818 . 
 5-819 . if (A ge B)
 5-820 . {
 5-821 .    A = B + C;
 5-822 .    D = E + F;
 5-823 . }
 5-824 . 
 5-825 . 
 5-826 . if (A lt B)
 5-827 . {
 5-828 .    A = B + C;
 5-829 .    D = E + F;
 5-830 . }
 5-831 . 
 5-832 . A = B+C;
 5-833 . 
 5-834 . if (A gt B)
 5-835 . {
 5-836 .    A = B + C;
 5-837 .    D = E + F;
 5-838 . }
 5-839 . 
 5-840 . A = B+C;
 5-841 . A = B-C;
 5-842 . A = B+C;
 5-843 . 
 5-844 . if (A < = B)
 5-845 . {
 5-846 .    A = B + C;
 5-847 .    D = E + F;
 5-848 . }
 5-849 . 
 5-850 . A = B-C;
 5-851 . 
 5-852 . if (A > = B)
 5-853 . {
 5-854 .    A = B + C;
 5-855 .    D = E + F;
 5-856 . }
 5-857 . 
 5-858 . /* LE SV TOC-2505 this is a pwr-05.5.27 req to halt*/
 5-859 . A = B+C;
 5-860 . A = B/C;
 5-861 . A = B/C;
 5-862 . A = B*C;
 5-863 . A = B+C;
 5-864 . rcv_buffer = (U16 *) alloc(size+1);
 5-865 . 
 5-866 . if (A lt B)
 5-867 . {
 5-868 .    A = B + C;
 5-869 .    D = E + F;
 5-870 . }
 5-871 . 
 5-872 . 
 5-873 . if (A > = B)
 5-874 . {
 5-875 .    A = B + C;
 5-876 .    D = E + F;
 5-877 . }
 5-878 . 
 5-879 . A = B/C;
 5-880 . /* dead_code = A * B; */
 5-881 . 
 5-882 . if (A gt B)
 5-883 . {
 5-884 .    A = B + C;
 5-885 .    D = E + F;
 5-886 . }
 5-887 . 
 5-888 . 
 5-889 . switch (pwr stuff)
 5-890 . {
 5-891 .    case one:
 5-892 .    {
 5-893 .       run_this; 
 5-894 .       break;
 5-895 .    }
 5-896 .    case two:
 5-897 .    {
 5-898 .       run_this;
 5-899 .       break;
 5-900 .    }
 5-901 .    default:
 5-902 .    {
 5-903 .        SwError;
 5-904 .    }
 5-905 . }
 5-906 . 
 5-907 . A = B*C;
 5-908 . A = B+C;
 5-909 . A = B*C;
 5-910 . A = B-C;
 5-911 . 
 5-912 . if (A eq B)
 5-913 . {
 5-914 .    A = B + C;
 5-915 .    D = E + F;
 5-916 . }
 5-917 . 
 5-918 . A = B-C;
 5-919 . A = B*C;
 5-920 . A = B*C;
 5-921 . A = B/C;
 5-922 . /* LE SV TOC-2506 this is a pwr-05.5.46 req to check unix*/
 5-923 . A = B/C;
 5-924 . A = B*C;
 5-925 . A = B-C;
 5-926 . A = B-C;
 5-927 . A = B+C;
 5-928 . // max LOC 50
 5-929 . 
 5-930 . }
 5-931 . 
 5-932 . 
 5-933 . /*
 5-934 . -----------------------------------------------------------------------------
 5-935 . --| NAME:   pwr.5.6
 5-936 . --|
 5-937 . --| ABSTRACT:
 5-938 . --|   This function does pwr stuff.
 5-939 . --|
 5-940 . --| RETURNS:
 5-941 . --|   NONE.
 5-942 . --|
 5-943 . ----------------------------------------------------------------------------
 5-944 . */
 5-945 . static void pwr.5.6(void)
 5-946 . {
 5-947 . A = B+C;
 5-948 . 
 5-949 . if (A le B)
 5-950 . {
 5-951 .    A = B + C;
 5-952 .    D = E + F;
 5-953 . }
 5-954 . 
 5-955 . A = B+C;
 5-956 . A = B*C;
 5-957 . A = B-C;
 5-958 . 
 5-959 . if (A == B)
 5-960 . {
 5-961 .    A = B + C;
 5-962 .    D = E + F;
 5-963 . }
 5-964 . 
 5-965 . 
 5-966 . if (A != B)
 5-967 . {
 5-968 .    A = B + C;
 5-969 .    D = E + F;
 5-970 . }
 5-971 . 
 5-972 . 
 5-973 . if (A gt B)
 5-974 . {
 5-975 .    A = B + C;
 5-976 .    D = E + F;
 5-977 . }
 5-978 . 
 5-979 . A = B/C;
 5-980 . A = B*C;
 5-981 . A = B+C;
 5-982 . A = B-C;
 5-983 . A = B/C;
 5-984 . 
 5-985 . if (A gt B)
 5-986 . {
 5-987 .    A = B + C;
 5-988 .    D = E + F;
 5-989 . }
 5-990 . 
 5-991 . A = B-C;
 5-992 . A = B*C;
 5-993 . 
 5-994 . if (A != B)
 5-995 . {
 5-996 .    A = B + C;
 5-997 .    D = E + F;
 5-998 . }
 5-999 . 
 5-1000 . A = B+C;
 5-1001 . A = B/C;
 5-1002 . // ??? go see ws
 5-1003 . A = B*C;
 5-1004 . A = B/C;
 5-1005 . /* LE SV TOC-2507 this is a pwr-05.6.22 req to translate*/
 5-1006 . 
 5-1007 . if (A ge B)
 5-1008 . {
 5-1009 .    A = B + C;
 5-1010 .    D = E + F;
 5-1011 . }
 5-1012 . 
 5-1013 . A = B+C;
 5-1014 . A = B/C;
 5-1015 . A = B+C;
 5-1016 . A = B/C;
 5-1017 . A = B*C;
 5-1018 . A = B+C;
 5-1019 . A = B-C;
 5-1020 . 
 5-1021 . if (A lt B)
 5-1022 . {
 5-1023 .    A = B + C;
 5-1024 .    D = E + F;
 5-1025 . }
 5-1026 . 
 5-1027 . A = B+C;
 5-1028 . A = B+C;
 5-1029 . 
 5-1030 . if (A le B)
 5-1031 . {
 5-1032 .    A = B + C;
 5-1033 .    D = E + F;
 5-1034 . }
 5-1035 . 
 5-1036 . 
 5-1037 . switch (pwr stuff)
 5-1038 . {
 5-1039 .    case one:
 5-1040 .    {
 5-1041 .       run_this; 
 5-1042 .       break;
 5-1043 .    }
 5-1044 .    case two:
 5-1045 .    {
 5-1046 .       run_this;
 5-1047 .       break;
 5-1048 .    }
 5-1049 .    default:
 5-1050 .    {
 5-1051 .        SwError;
 5-1052 .    }
 5-1053 . }
 5-1054 . 
 5-1055 . A = B*C;
 5-1056 . A = B-C;
 5-1057 . 
 5-1058 . if (A <  B)
 5-1059 . {
 5-1060 .    A = B + C;
 5-1061 .    D = E + F;
 5-1062 . }
 5-1063 . 
 5-1064 . A = B/C;
 5-1065 . A = B*C;
 5-1066 . 
 5-1067 . if (A != B)
 5-1068 . {
 5-1069 .    A = B + C;
 5-1070 .    D = E + F;
 5-1071 . }
 5-1072 . 
 5-1073 . 
 5-1074 . if (A <  B)
 5-1075 . {
 5-1076 .    A = B + C;
 5-1077 .    D = E + F;
 5-1078 . }
 5-1079 . 
 5-1080 . 
 5-1081 . if (A eq B)
 5-1082 . {
 5-1083 .    A = B + C;
 5-1084 .    D = E + F;
 5-1085 . }
 5-1086 . 
 5-1087 . A = B+C;
 5-1088 . 
 5-1089 . if (A ge B)
 5-1090 . {
 5-1091 .    A = B + C;
 5-1092 .    D = E + F;
 5-1093 . }
 5-1094 . 
 5-1095 . A = B*C;
 5-1096 . 
 5-1097 . if (A != B)
 5-1098 . {
 5-1099 .    A = B + C;
 5-1100 .    D = E + F;
 5-1101 . }
 5-1102 . 
 5-1103 . 
 5-1104 . if (A gt B)
 5-1105 . {
 5-1106 .    A = B + C;
 5-1107 .    D = E + F;
 5-1108 . }
 5-1109 . 
 5-1110 . A = B/C;
 5-1111 . A = B/C;
 5-1112 . 
 5-1113 . if (A == B)
 5-1114 . {
 5-1115 .    A = B + C;
 5-1116 .    D = E + F;
 5-1117 . }
 5-1118 . 
 5-1119 . A = B*C;
 5-1120 . A = B/C;
 5-1121 . 
 5-1122 . if (A > = B)
 5-1123 . {
 5-1124 .    A = B + C;
 5-1125 .    D = E + F;
 5-1126 . }
 5-1127 . 
 5-1128 . A = B+C;
 5-1129 . A = B-C;
 5-1130 . A = B-C;
 5-1131 . A = B*C;
 5-1132 . A = B+C;
 5-1133 . A = B-C;
 5-1134 . 
 5-1135 . if (A eq B)
 5-1136 . {
 5-1137 .    A = B + C;
 5-1138 .    D = E + F;
 5-1139 . }
 5-1140 . 
 5-1141 . A = B*C;
 5-1142 . A = B+C;
 5-1143 . A = B+C;
 5-1144 . A = B+C;
 5-1145 . A = B+C;
 5-1146 . A = B+C;
 5-1147 . A = B+C;
 5-1148 . // max LOC 67
 5-1149 . 
 5-1150 . }
 5-1151 . 
 5-1152 . 
 5-1153 . /*
 5-1154 . -----------------------------------------------------------------------------
 5-1155 . --| NAME:   pwr.5.7
 5-1156 . --|
 5-1157 . --| ABSTRACT:
 5-1158 . --|   This function does pwr stuff.
 5-1159 . --|
 5-1160 . --| RETURNS:
 5-1161 . --|   NONE.
 5-1162 . --|
 5-1163 . ----------------------------------------------------------------------------
 5-1164 . */
 5-1165 . static void pwr.5.7(void)
 5-1166 . {
 5-1167 . A = B*C;
 5-1168 . A = B/C;
 5-1169 . A = B/C;
 5-1170 . 
 5-1171 . switch (pwr stuff)
 5-1172 . {
 5-1173 .       case one:
 5-1174 .    {
 5-1175 .       run_this;
 5-1176 .       break;
 5-1177 .    }
 5-1178 .    case two:
 5-1179 .    {
 5-1180 .       run_this;
 5-1181 .       break;
 5-1182 .    }
 5-1183 .    default:
 5-1184 .    {
 5-1185 .       // missing error call
 5-1186 .    }
 5-1187 . }
 5-1188 . 
 5-1189 . A = B-C;
 5-1190 . A = B-C;
 5-1191 . A = B-C;
 5-1192 . A = B/C;
 5-1193 . A = B*C;
 5-1194 . 
 5-1195 . if (A ne B)
 5-1196 . {
 5-1197 .    A = B + C;
 5-1198 .    D = E + F;
 5-1199 . }
 5-1200 . 
 5-1201 . A = B+C;
 5-1202 . A = B+C;
 5-1203 . A = B-C;
 5-1204 . A = B*C;
 5-1205 . 
 5-1206 . if (A ne B)
 5-1207 . {
 5-1208 .    A = B + C;
 5-1209 .    D = E + F;
 5-1210 . }
 5-1211 . 
 5-1212 . A = B-C;
 5-1213 . 
 5-1214 . if (A == B)
 5-1215 . {
 5-1216 .    A = B + C;
 5-1217 .    D = E + F;
 5-1218 . }
 5-1219 . 
 5-1220 . 
 5-1221 . if (A == B)
 5-1222 . {
 5-1223 .    A = B + C;
 5-1224 .    D = E + F;
 5-1225 . }
 5-1226 . 
 5-1227 . A = B+C;
 5-1228 . send_buffer = (U16 *) malloc(size+1);
 5-1229 . A = B/C;
 5-1230 . 
 5-1231 . if (A eq B)
 5-1232 . {
 5-1233 .    A = B + C;
 5-1234 .    D = E + F;
 5-1235 . }
 5-1236 . 
 5-1237 . A = B-C;
 5-1238 . A = B-C;
 5-1239 . 
 5-1240 . if (A >  B)
 5-1241 . {
 5-1242 .    A = B + C;
 5-1243 .    D = E + F;
 5-1244 . }
 5-1245 . 
 5-1246 . A = B/C;
 5-1247 . 
 5-1248 . switch (pwr stuff)
 5-1249 . {
 5-1250 .    case one:
 5-1251 .    {
 5-1252 .       run_this; 
 5-1253 .       break;
 5-1254 .    }
 5-1255 .    case two:
 5-1256 .    {
 5-1257 .       run_this;
 5-1258 .       break;
 5-1259 .    }
 5-1260 .    default:
 5-1261 .    {
 5-1262 .        SwError;
 5-1263 .    }
 5-1264 . }
 5-1265 . 
 5-1266 . send_buffer = (U16 *) malloc(size+1);
 5-1267 . A = B-C;
 5-1268 . A = B+C;
 5-1269 . A = B/C;
 5-1270 . A = B*C;
 5-1271 . 
 5-1272 . if (A gt B)
 5-1273 . {
 5-1274 .    A = B + C;
 5-1275 .    D = E + F;
 5-1276 . }
 5-1277 . 
 5-1278 . A = B-C;
 5-1279 . 
 5-1280 . /* dead_block = C * D; 
 5-1281 . dead_block = E * F; */
 5-1282 . 
 5-1283 . A = B/C;
 5-1284 . A = 0x0003;
 5-1285 . A = B*C;
 5-1286 . A = B*C;
 5-1287 . A = B-C;
 5-1288 . // max LOC 35
 5-1289 . 
 5-1290 . }
 5-1291 . 
 5-1292 . 
 5-1293 . /*
 5-1294 . -----------------------------------------------------------------------------
 5-1295 . --| NAME:   pwr.5.8
 5-1296 . --|
 5-1297 . --| ABSTRACT:
 5-1298 . --|   This function does pwr stuff.
 5-1299 . --|
 5-1300 . --| RETURNS:
 5-1301 . --|   NONE.
 5-1302 . --|
 5-1303 . ----------------------------------------------------------------------------
 5-1304 . */
 5-1305 . static void pwr.5.8(void)
 5-1306 . {
 5-1307 . A = B*C;
 5-1308 . A = B/C;
 5-1309 . 
 5-1310 . if (A eq B)
 5-1311 . {
 5-1312 .    A = B + C;
 5-1313 .    D = E + F;
 5-1314 . }
 5-1315 . 
 5-1316 . /* LE SV TOC-2508 this is a pwr-05.8.4 req to set RTC*/
 5-1317 . 
 5-1318 . switch (pwr stuff)
 5-1319 . {
 5-1320 .    case:
 5-1321 .    case:
 5-1322 .    // stacked case statements but only if there is a new line in between
 5-1323 . 
 5-1324 .    case:
 5-1325 .    case:
 5-1326 .    case:
 5-1327 .    {
 5-1328 .       run_this;
 5-1329 .       break;
 5-1330 .    }
 5-1331 .    default:
 5-1332 .    {
 5-1333 .       halt;
 5-1334 .    }
 5-1335 . }
 5-1336 . 
 5-1337 . A = B/C;
 5-1338 . A = B*C;
 5-1339 . A = B*C;
 5-1340 . 
 5-1341 . if (A < = B)
 5-1342 . {
 5-1343 .    A = B + C;
 5-1344 .    D = E + F;
 5-1345 . }
 5-1346 . 
 5-1347 . 
 5-1348 . if (A ne B)
 5-1349 . {
 5-1350 .    A = B + C;
 5-1351 .    D = E + F;
 5-1352 . }
 5-1353 . 
 5-1354 . A = B+C;
 5-1355 . A = B-C;
 5-1356 . rcv_buffer = (U16 *) alloc(size+1);
 5-1357 . A = B*C;
 5-1358 . A = B/C;
 5-1359 . A = B-C;
 5-1360 . A = B*C;
 5-1361 . A = B/C;
 5-1362 . A = B/C;
 5-1363 . A = B-C;
 5-1364 . A = B/C;
 5-1365 . 
 5-1366 . if (A != B)
 5-1367 . {
 5-1368 .    A = B + C;
 5-1369 .    D = E + F;
 5-1370 . }
 5-1371 . 
 5-1372 . 
 5-1373 . if (A != B)
 5-1374 . {
 5-1375 .    A = B + C;
 5-1376 .    D = E + F;
 5-1377 . }
 5-1378 . 
 5-1379 . A = B+C;
 5-1380 . free(FreePtr);
 5-1381 . A = B*C;
 5-1382 . A = B*C;
 5-1383 . A = B/C;
 5-1384 . A = B*C;
 5-1385 . 
 5-1386 . if (A > = B)
 5-1387 . {
 5-1388 .    A = B + C;
 5-1389 .    D = E + F;
 5-1390 . }
 5-1391 . 
 5-1392 . 
 5-1393 . if (A ne B)
 5-1394 . {
 5-1395 .    A = B + C;
 5-1396 .    D = E + F;
 5-1397 . }
 5-1398 . 
 5-1399 . 
 5-1400 . if (A ge B)
 5-1401 . {
 5-1402 .    A = B + C;
 5-1403 .    D = E + F;
 5-1404 . }
 5-1405 . 
 5-1406 . A = B+C;
 5-1407 . A = (long)B + C;
 5-1408 . A = B/C;
 5-1409 . A = B+C;
 5-1410 . // max LOC 31
 5-1411 . 
 5-1412 . }
 5-1413 . 
 5-1414 . 
 5-1415 . /*
 5-1416 . -----------------------------------------------------------------------------
 5-1417 . --| NAME:   pwr.5.9
 5-1418 . --|
 5-1419 . --| ABSTRACT:
 5-1420 . --|   This function does pwr stuff.
 5-1421 . --|
 5-1422 . --| RETURNS:
 5-1423 . --|   NONE.
 5-1424 . --|
 5-1425 . ----------------------------------------------------------------------------
 5-1426 . */
 5-1427 . static void pwr.5.9(void)
 5-1428 . {
 5-1429 . 
 5-1430 . if (A ge B)
 5-1431 . {
 5-1432 .    A = B + C;
 5-1433 .    D = E + F;
 5-1434 . }
 5-1435 . 
 5-1436 . A = B*C;
 5-1437 . A = B+C;
 5-1438 . 
 5-1439 . /*
 5-1440 . dead_block = C * D; 
 5-1441 . dead_block = E * F;
 5-1442 . */
 5-1443 . 
 5-1444 . A = B-C;
 5-1445 . A = B-C;
 5-1446 . 
 5-1447 . if ($pwr stuff >  $otherpwr stuff) 
 5-1448 . /* LE SV TOC-008 we really should log all error calls */
 5-1449 . {
 5-1450 .    A = B + C;
 5-1451 . }
 5-1452 . 
 5-1453 . 
 5-1454 . if (A ge B)
 5-1455 . {
 5-1456 .    A = B + C;
 5-1457 .    D = E + F;
 5-1458 . }
 5-1459 . 
 5-1460 . A = B-C;
 5-1461 . 
 5-1462 . if (A < = B)
 5-1463 . {
 5-1464 .    A = B + C;
 5-1465 .    D = E + F;
 5-1466 . }
 5-1467 . 
 5-1468 . A = B/C;
 5-1469 . A = B/C;
 5-1470 . 
 5-1471 . if (A != B)
 5-1472 . {
 5-1473 .    A = B + C;
 5-1474 .    D = E + F;
 5-1475 . }
 5-1476 . 
 5-1477 . A = B/C;
 5-1478 . 
 5-1479 . switch (pwr stuff)
 5-1480 . {
 5-1481 .    case one:
 5-1482 .    {
 5-1483 .       run_this; 
 5-1484 .       // missing break
 5-1485 .    }
 5-1486 .    case two:
 5-1487 .    {
 5-1488 .       run_this;
 5-1489 .       break;
 5-1490 .    }
 5-1491 .    default:
 5-1492 .    {
 5-1493 .       SwError;
 5-1494 .    }
 5-1495 . }
 5-1496 . 
 5-1497 . 
 5-1498 . if (A == B)
 5-1499 . {
 5-1500 .    A = B + C;
 5-1501 .    D = E + F;
 5-1502 . }
 5-1503 . 
 5-1504 . A = B*C;
 5-1505 . A = B*C;
 5-1506 . A = B/C;
 5-1507 . A = B*C;
 5-1508 . A = B/C;
 5-1509 . 
 5-1510 . if (A != B)
 5-1511 . {
 5-1512 .    A = B + C;
 5-1513 .    D = E + F;
 5-1514 . }
 5-1515 . 
 5-1516 . A = B*C;
 5-1517 . A = B+C;
 5-1518 . A = B/C;
 5-1519 . A = B/C;
 5-1520 . A = B+C;
 5-1521 . A = B/C;
 5-1522 . A = B*C;
 5-1523 . A = B*C;
 5-1524 . A = B*C;
 5-1525 . A = B*C;
 5-1526 . A = B-C;
 5-1527 . A = 0x0009;
 5-1528 . A = B*C;
 5-1529 . A = B-C;
 5-1530 . A = B+C;
 5-1531 . 
 5-1532 . if (A ge B)
 5-1533 . {
 5-1534 .    A = B + C;
 5-1535 .    D = E + F;
 5-1536 . }
 5-1537 . 
 5-1538 . /* LE SV TOC-2509 this is a pwr-05.9.35 req to record*/
 5-1539 . A = B-C;
 5-1540 . A = B+C;
 5-1541 . // max LOC 36
 5-1542 . 
 5-1543 . }
 5-1544 . 
 5-1545 . 
 5-1546 . /*
 5-1547 . -----------------------------------------------------------------------------
 5-1548 . --| NAME:   pwr.5.10
 5-1549 . --|
 5-1550 . --| ABSTRACT:
 5-1551 . --|   This function does pwr stuff.
 5-1552 . --|
 5-1553 . --| RETURNS:
 5-1554 . --|   NONE.
 5-1555 . --|
 5-1556 . ----------------------------------------------------------------------------
 5-1557 . */
 5-1558 . static void pwr.5.10(void)
 5-1559 . {
 5-1560 . A = B/C;
 5-1561 . 
 5-1562 . if ($pwr stuff >  $otherpwr stuff) 
 5-1563 . /* LE SV TOC-008 we really should log all error calls */
 5-1564 . {
 5-1565 .    A = B + C;
 5-1566 . }
 5-1567 . 
 5-1568 . A = B+C;
 5-1569 . A = B*C;
 5-1570 . A = B-C;
 5-1571 . 
 5-1572 . switch (pwr stuff)
 5-1573 . {
 5-1574 .    case one:
 5-1575 .    {
 5-1576 .       run_this; 
 5-1577 .       break;
 5-1578 .    }
 5-1579 .    case two:
 5-1580 .    {
 5-1581 .       run_this;
 5-1582 .       break;
 5-1583 .    }
 5-1584 .    default:
 5-1585 .    {
 5-1586 .        SwError;
 5-1587 .    }
 5-1588 . }
 5-1589 . 
 5-1590 . A = B*C;
 5-1591 . 
 5-1592 . if (A < = B)
 5-1593 . {
 5-1594 .    A = B + C;
 5-1595 .    D = E + F;
 5-1596 . }
 5-1597 . 
 5-1598 . 
 5-1599 . if (A lt B)
 5-1600 . {
 5-1601 .    A = B + C;
 5-1602 .    D = E + F;
 5-1603 . }
 5-1604 . 
 5-1605 . A = B/C;
 5-1606 . A = B/C;
 5-1607 . A = B+C;
 5-1608 . A = B*C;
 5-1609 . A = B+C;
 5-1610 . A = B+C;
 5-1611 . 
 5-1612 . if (A ge B)
 5-1613 . {
 5-1614 .    A = B + C;
 5-1615 .    D = E + F;
 5-1616 . }
 5-1617 . 
 5-1618 . A = B/C;
 5-1619 . A = B-C;
 5-1620 . A = B*C;
 5-1621 . A = B-C;
 5-1622 . 
 5-1623 . if (A == B)
 5-1624 . {
 5-1625 .    A = B + C;
 5-1626 .    D = E + F;
 5-1627 . }
 5-1628 . 
 5-1629 . A = B*C;
 5-1630 . 
 5-1631 . if (A ne B)
 5-1632 . {
 5-1633 .    A = B + C;
 5-1634 .    D = E + F;
 5-1635 . }
 5-1636 . 
 5-1637 . A = B*C;
 5-1638 . 
 5-1639 . if (A <  B)
 5-1640 . {
 5-1641 .    A = B + C;
 5-1642 .    D = E + F;
 5-1643 . }
 5-1644 . 
 5-1645 . 
 5-1646 . if (A ne B)
 5-1647 . {
 5-1648 .    A = B + C;
 5-1649 .    D = E + F;
 5-1650 . }
 5-1651 . 
 5-1652 . A = B/C;
 5-1653 . /* LE SV TOC-2510 this is a pwr-05.10.27 req to transform*/
 5-1654 . A = B-C;
 5-1655 . A = B+C;
 5-1656 . A = B*C;
 5-1657 . A = B*C;
 5-1658 . A = B+C;
 5-1659 . // max LOC 31
 5-1660 . 
 5-1661 . }
 5-1662 . 
 5-1663 . 
 5-1664 . /*
 5-1665 . -----------------------------------------------------------------------------
 5-1666 . --| NAME:   pwr.5.11
 5-1667 . --|
 5-1668 . --| ABSTRACT:
 5-1669 . --|   This function does pwr stuff.
 5-1670 . --|
 5-1671 . --| RETURNS:
 5-1672 . --|   NONE.
 5-1673 . --|
 5-1674 . ----------------------------------------------------------------------------
 5-1675 . */
 5-1676 . static void pwr.5.11(void)
 5-1677 . {
 5-1678 . 
 5-1679 . if (A ne B)
 5-1680 . {
 5-1681 .    A = B + C;
 5-1682 .    D = E + F;
 5-1683 . }
 5-1684 . 
 5-1685 . A = B-C;
 5-1686 . A = B*C;
 5-1687 . A = B-C;
 5-1688 . A = B-C;
 5-1689 . A = B/C;
 5-1690 . A = B*C;
 5-1691 . A = B+C;
 5-1692 . 
 5-1693 . if (A <  B)
 5-1694 . {
 5-1695 .    A = B + C;
 5-1696 .    D = E + F;
 5-1697 . }
 5-1698 . 
 5-1699 . A = B+C;
 5-1700 . A = B/C;
 5-1701 . A = B+C;
 5-1702 . A = B/C;
 5-1703 . 
 5-1704 . if (A eq B)
 5-1705 . {
 5-1706 .    A = B + C;
 5-1707 .    D = E + F;
 5-1708 . }
 5-1709 . 
 5-1710 . A = B+C;
 5-1711 . A = B/C;
 5-1712 . A = B+C;
 5-1713 . A = B-C;
 5-1714 . // max LOC 18
 5-1715 . 
 5-1716 . }
 5-1717 . 
 5-1718 . 
 5-1719 . /*
 5-1720 . -----------------------------------------------------------------------------
 5-1721 . --| NAME:   pwr.5.12
 5-1722 . --|
 5-1723 . --| ABSTRACT:
 5-1724 . --|   This function does pwr stuff.
 5-1725 . --|
 5-1726 . --| RETURNS:
 5-1727 . --|   NONE.
 5-1728 . --|
 5-1729 . ----------------------------------------------------------------------------
 5-1730 . */
 5-1731 . static void pwr.5.12(void)
 5-1732 . {
 5-1733 . 
 5-1734 . if (A ge B)
 5-1735 . {
 5-1736 .    A = B + C;
 5-1737 .    D = E + F;
 5-1738 . }
 5-1739 . 
 5-1740 . A = B/C;
 5-1741 . A = B/C;
 5-1742 . A = B-C;
 5-1743 . 
 5-1744 . if (A lt B)
 5-1745 . {
 5-1746 .    A = B + C;
 5-1747 .    D = E + F;
 5-1748 . }
 5-1749 . 
 5-1750 . A = B/C;
 5-1751 . A = B-C;
 5-1752 . A = B-C;
 5-1753 . 
 5-1754 . if (A > = B)
 5-1755 . {
 5-1756 .    A = B + C;
 5-1757 .    D = E + F;
 5-1758 . }
 5-1759 . 
 5-1760 . A = B-C;
 5-1761 . A = B+C;
 5-1762 . A = 0x0008;
 5-1763 . A = B-C;
 5-1764 . A = B/C;
 5-1765 . A = B*C;
 5-1766 . A = B*C;
 5-1767 . A = B/C;
 5-1768 . A = B*C;
 5-1769 . A = B*C;
 5-1770 . A = B+C;
 5-1771 . 
 5-1772 . if (A >  B)
 5-1773 . {
 5-1774 .    A = B + C;
 5-1775 .    D = E + F;
 5-1776 . }
 5-1777 . 
 5-1778 . 
 5-1779 . if (A != B)
 5-1780 . {
 5-1781 .    A = B + C;
 5-1782 .    D = E + F;
 5-1783 . }
 5-1784 . 
 5-1785 . /* LE SV TOC-2511 this is a pwr-05.12.22 req to convert*/
 5-1786 . 
 5-1787 . if (A < = B)
 5-1788 . {
 5-1789 .    A = B + C;
 5-1790 .    D = E + F;
 5-1791 . }
 5-1792 . 
 5-1793 . 
 5-1794 . /* 
 5-1795 . dead_code = B - C; 
 5-1796 . dead_code = D - E; 
 5-1797 . dead_code = F - G;
 5-1798 . */
 5-1799 . 
 5-1800 . A = B/C;
 5-1801 . 
 5-1802 . if (A eq B)
 5-1803 . {
 5-1804 .    A = B + C;
 5-1805 .    D = E + F;
 5-1806 . }
 5-1807 . 
 5-1808 . A = B-C;
 5-1809 . 
 5-1810 . if (A lt B)
 5-1811 . {
 5-1812 .    A = B + C;
 5-1813 .    D = E + F;
 5-1814 . }
 5-1815 . 
 5-1816 . 
 5-1817 . if (A <  B)
 5-1818 . {
 5-1819 .    A = B + C;
 5-1820 .    D = E + F;
 5-1821 . }
 5-1822 . 
 5-1823 . A = B-C;
 5-1824 . A = B/C;
 5-1825 . 
 5-1826 . if (A lt B)
 5-1827 . {
 5-1828 .    A = B + C;
 5-1829 .    D = E + F;
 5-1830 . }
 5-1831 . 
 5-1832 . /* LE SV TOC-2512 this is a pwr-05.12.31 req to audit*/
 5-1833 . 
 5-1834 . if (A lt B)
 5-1835 . {
 5-1836 .    A = B + C;
 5-1837 .    D = E + F;
 5-1838 . }
 5-1839 . 
 5-1840 . A = 0x0009;
 5-1841 . A = B+C;
 5-1842 . 
 5-1843 . if (A <  B)
 5-1844 . {
 5-1845 .    A = B + C;
 5-1846 .    D = E + F;
 5-1847 . }
 5-1848 . 
 5-1849 . A = 0x0006;
 5-1850 . A = B/C;
 5-1851 . A = B-C;
 5-1852 . A = B*C;
 5-1853 . A = B+C;
 5-1854 . A = B/C;
 5-1855 . A = B+C;
 5-1856 . A = B*C;
 5-1857 . A = B-C;
 5-1858 . 
 5-1859 . if (A gt B)
 5-1860 . {
 5-1861 .    A = B + C;
 5-1862 .    D = E + F;
 5-1863 . }
 5-1864 . 
 5-1865 . 
 5-1866 . if (A == B)
 5-1867 . {
 5-1868 .    A = B + C;
 5-1869 .    D = E + F;
 5-1870 . }
 5-1871 . 
 5-1872 . 
 5-1873 . if (A gt B)
 5-1874 . {
 5-1875 .    A = B + C;
 5-1876 .    D = E + F;
 5-1877 . }
 5-1878 . 
 5-1879 . A = B*C;
 5-1880 . A = B+C;
 5-1881 . A = B+C;
 5-1882 . A = B+C;
 5-1883 . A = B/C;
 5-1884 . A = B/C;
 5-1885 . 
 5-1886 . switch (pwr stuff)
 5-1887 . {
 5-1888 .    case one:
 5-1889 .    {
 5-1890 .       run_this; 
 5-1891 .       break;
 5-1892 .    }
 5-1893 .    case two:
 5-1894 .    {
 5-1895 .       run_this;
 5-1896 .       break;
 5-1897 .    }
 5-1898 .    default:
 5-1899 .    {
 5-1900 .        SwError;
 5-1901 .    }
 5-1902 . }
 5-1903 . 
 5-1904 . 
 5-1905 . if (A != B)
 5-1906 . {
 5-1907 .    A = B + C;
 5-1908 .    D = E + F;
 5-1909 . }
 5-1910 . 
 5-1911 . A = B/C;
 5-1912 . A = B/C;
 5-1913 . A = 0x0003;
 5-1914 . A = B+C;
 5-1915 . 
 5-1916 . if ($pwr stuff >  $otherpwr stuff) 
 5-1917 . /* LE SV TOC-008 we really should log all error calls */
 5-1918 . {
 5-1919 .    A = B + C;
 5-1920 . }
 5-1921 . 
 5-1922 . 
 5-1923 . if (A >  B)
 5-1924 . {
 5-1925 .    A = B + C;
 5-1926 .    D = E + F;
 5-1927 . }
 5-1928 . 
 5-1929 . 
 5-1930 . if (A > = B)
 5-1931 . {
 5-1932 .    A = B + C;
 5-1933 .    D = E + F;
 5-1934 . }
 5-1935 . 
 5-1936 . A = B+C;
 5-1937 . 
 5-1938 . if (A <  B)
 5-1939 . {
 5-1940 .    A = B + C;
 5-1941 .    D = E + F;
 5-1942 . }
 5-1943 . 
 5-1944 . A = B*C;
 5-1945 . A = B+C;
 5-1946 . A = B+C;
 5-1947 . A = B-C;
 5-1948 . A = B/C;
 5-1949 . 
 5-1950 . if (A ge B)
 5-1951 . {
 5-1952 .    A = B + C;
 5-1953 .    D = E + F;
 5-1954 . }
 5-1955 . 
 5-1956 . A = B-C;
 5-1957 . 
 5-1958 . if (A == B)
 5-1959 . {
 5-1960 .    A = B + C;
 5-1961 .    D = E + F;
 5-1962 . }
 5-1963 . 
 5-1964 . 
 5-1965 . if (A < = B)
 5-1966 . {
 5-1967 .    A = B + C;
 5-1968 .    D = E + F;
 5-1969 . }
 5-1970 . 
 5-1971 . /* dead_code = A * B; */
 5-1972 . 
 5-1973 . if (A >  B)
 5-1974 . {
 5-1975 .    A = B + C;
 5-1976 .    D = E + F;
 5-1977 . }
 5-1978 . 
 5-1979 . 
 5-1980 . if (A lt B)
 5-1981 . {
 5-1982 .    A = B + C;
 5-1983 .    D = E + F;
 5-1984 . }
 5-1985 . 
 5-1986 . 
 5-1987 . if (A < = B)
 5-1988 . {
 5-1989 .    A = B + C;
 5-1990 .    D = E + F;
 5-1991 . }
 5-1992 . 
 5-1993 . A = B-C;
 5-1994 . A = B+C;
 5-1995 . 
 5-1996 . if (A >  B)
 5-1997 . {
 5-1998 .    A = B + C;
 5-1999 .    D = E + F;
 5-2000 . }
 5-2001 . 
 5-2002 . A = B+C;
 5-2003 . 
 5-2004 . if (A lt B)
 5-2005 . {
 5-2006 .    A = B + C;
 5-2007 .    D = E + F;
 5-2008 . }
 5-2009 . 
 5-2010 . // max LOC 76
 5-2011 . 
 5-2012 . }
 5-2013 . 
 5-2014 . 
 5-2015 . /*
 5-2016 . -----------------------------------------------------------------------------
 5-2017 . --| NAME:   pwr.5.13
 5-2018 . --|
 5-2019 . --| ABSTRACT:
 5-2020 . --|   This function does pwr stuff.
 5-2021 . --|
 5-2022 . --| RETURNS:
 5-2023 . --|   NONE.
 5-2024 . --|
 5-2025 . ----------------------------------------------------------------------------
 5-2026 . */
 5-2027 . static void pwr.5.13(void)
 5-2028 . {
 5-2029 . A = B*C;
 5-2030 . 
 5-2031 . if (A le B)
 5-2032 . {
 5-2033 .    A = B + C;
 5-2034 .    D = E + F;
 5-2035 . }
 5-2036 . 
 5-2037 . A = B/C;
 5-2038 . A = B*C;
 5-2039 . /* LE SV TOC-2513 this is a pwr-05.13.5 req to detect error*/
 5-2040 . A = B/C;
 5-2041 . 
 5-2042 . if (A != B)
 5-2043 . {
 5-2044 .    A = B + C;
 5-2045 .    D = E + F;
 5-2046 . }
 5-2047 . 
 5-2048 . 
 5-2049 . if (A != B)
 5-2050 . {
 5-2051 .    A = B + C;
 5-2052 .    D = E + F;
 5-2053 . }
 5-2054 . 
 5-2055 . 
 5-2056 . if (A < = B)
 5-2057 . {
 5-2058 .    A = B + C;
 5-2059 .    D = E + F;
 5-2060 . }
 5-2061 . 
 5-2062 . A = B/C;
 5-2063 . A = B-C;
 5-2064 . A = B*C;
 5-2065 . A = B+C;
 5-2066 . A = B/C;
 5-2067 . A = B+C;
 5-2068 . A = B+C;
 5-2069 . 
 5-2070 . if (A lt B)
 5-2071 . {
 5-2072 .    A = B + C;
 5-2073 .    D = E + F;
 5-2074 . }
 5-2075 . 
 5-2076 . A = B-C;
 5-2077 . 
 5-2078 . if (A > = B)
 5-2079 . {
 5-2080 .    A = B + C;
 5-2081 .    D = E + F;
 5-2082 . }
 5-2083 . 
 5-2084 . A = B/C;
 5-2085 . A = B-C;
 5-2086 . /* LE SV TOC-2514 this is a pwr-05.13.21 req to check unix*/
 5-2087 . 
 5-2088 . if (A < = B)
 5-2089 . {
 5-2090 .    A = B + C;
 5-2091 .    D = E + F;
 5-2092 . }
 5-2093 . 
 5-2094 . 
 5-2095 . if (A gt B)
 5-2096 . {
 5-2097 .    A = B + C;
 5-2098 .    D = E + F;
 5-2099 . }
 5-2100 . 
 5-2101 . 
 5-2102 . if (A >  B)
 5-2103 . {
 5-2104 .    A = B + C;
 5-2105 .    D = E + F;
 5-2106 . }
 5-2107 . 
 5-2108 . A = B-C;
 5-2109 . A = B/C;
 5-2110 . 
 5-2111 . if (A == B)
 5-2112 . {
 5-2113 .    A = B + C;
 5-2114 .    D = E + F;
 5-2115 . }
 5-2116 . 
 5-2117 . A = B-C;
 5-2118 . A = B-C;
 5-2119 . 
 5-2120 . if (A < = B)
 5-2121 . {
 5-2122 .    A = B + C;
 5-2123 .    D = E + F;
 5-2124 . }
 5-2125 . 
 5-2126 . 
 5-2127 . if (A gt B)
 5-2128 . {
 5-2129 .    A = B + C;
 5-2130 .    D = E + F;
 5-2131 . }
 5-2132 . 
 5-2133 . 
 5-2134 . if (A < = B)
 5-2135 . {
 5-2136 .    A = B + C;
 5-2137 .    D = E + F;
 5-2138 . }
 5-2139 . 
 5-2140 . A = B/C;
 5-2141 . 
 5-2142 . if (A gt B)
 5-2143 . {
 5-2144 .    A = B + C;
 5-2145 .    D = E + F;
 5-2146 . }
 5-2147 . 
 5-2148 . A = B+C;
 5-2149 . A = B*C;
 5-2150 . A = B/C;
 5-2151 . A = B-C;
 5-2152 . A = B/C;
 5-2153 . A = B+C;
 5-2154 . 
 5-2155 . if (A <  B)
 5-2156 . {
 5-2157 .    A = B + C;
 5-2158 .    D = E + F;
 5-2159 . }
 5-2160 . 
 5-2161 . A = B/C;
 5-2162 . A = B*C;
 5-2163 . A = B-C;
 5-2164 . A = B*C;
 5-2165 . 
 5-2166 . switch (pwr stuff)
 5-2167 . {
 5-2168 .    case one:
 5-2169 .    {
 5-2170 .       run_this; 
 5-2171 .       break;
 5-2172 .    }
 5-2173 .    case two:
 5-2174 .    {
 5-2175 .       run_this;
 5-2176 .       break;
 5-2177 .    }
 5-2178 .    default:
 5-2179 .    {
 5-2180 .        SwError;
 5-2181 .    }
 5-2182 . }
 5-2183 . 
 5-2184 . A = B-C;
 5-2185 . A = B*C;
 5-2186 . 
 5-2187 . if (A == B)
 5-2188 . {
 5-2189 .    A = B + C;
 5-2190 .    D = E + F;
 5-2191 . }
 5-2192 . 
 5-2193 . /* LE SV TOC-2515 this is a pwr-05.13.49 req to reject*/
 5-2194 . 
 5-2195 . if (A <  B)
 5-2196 . {
 5-2197 .    A = B + C;
 5-2198 .    D = E + F;
 5-2199 . }
 5-2200 . 
 5-2201 . A = 0x0004;
 5-2202 . A = B/C;
 5-2203 . A = B+C;
 5-2204 . /* LE SV TOC-2516 this is a pwr-05.13.52 req to update*/
 5-2205 . A = B*C;
 5-2206 . A = B/C;
 5-2207 . 
 5-2208 . if (A le B)
 5-2209 . {
 5-2210 .    A = B + C;
 5-2211 .    D = E + F;
 5-2212 . }
 5-2213 . 
 5-2214 . A = B+C;
 5-2215 . A = B-C;
 5-2216 . 
 5-2217 . if (A <  B)
 5-2218 . {
 5-2219 .    A = B + C;
 5-2220 .    D = E + F;
 5-2221 . }
 5-2222 . 
 5-2223 . A = B/C;
 5-2224 . // max LOC 58
 5-2225 . 
 5-2226 . }
 5-2227 . 
 5-2228 . 
 5-2229 . /*
 5-2230 . -----------------------------------------------------------------------------
 5-2231 . --| NAME:   pwr.5.14
 5-2232 . --|
 5-2233 . --| ABSTRACT:
 5-2234 . --|   This function does pwr stuff.
 5-2235 . --|
 5-2236 . --| RETURNS:
 5-2237 . --|   NONE.
 5-2238 . --|
 5-2239 . ----------------------------------------------------------------------------
 5-2240 . */
 5-2241 . static void pwr.5.14(void)
 5-2242 . {
 5-2243 . A = B*C;
 5-2244 . A = B-C;
 5-2245 . A = B+C;
 5-2246 . A = B+C;
 5-2247 . A = B+C;
 5-2248 . A = B+C;
 5-2249 . A = B*C;
 5-2250 . 
 5-2251 . if ($pwr stuff >  $otherpwr stuff) 
 5-2252 . /* LE SV TOC-008 we really should log all error calls */
 5-2253 . {
 5-2254 .    A = B + C;
 5-2255 . }
 5-2256 . 
 5-2257 . A = B+C;
 5-2258 . A = B+C;
 5-2259 . A = B/C;
 5-2260 . A = 0x0007;
 5-2261 . A = (float)B + C;
 5-2262 . A = B/C;
 5-2263 . /* LE SV TOC-2517 this is a pwr-05.14.12 req to record*/
 5-2264 . A = B-C;
 5-2265 . 
 5-2266 . if (A < = B)
 5-2267 . {
 5-2268 .    A = B + C;
 5-2269 .    D = E + F;
 5-2270 . }
 5-2271 . 
 5-2272 . A = B*C;
 5-2273 . 
 5-2274 . if (A le B)
 5-2275 . {
 5-2276 .    A = B + C;
 5-2277 .    D = E + F;
 5-2278 . }
 5-2279 . 
 5-2280 . 
 5-2281 . /* dead_code = B + C; 
 5-2282 . dead_code = D + E; 
 5-2283 . dead_code = F + G; */
 5-2284 . 
 5-2285 . 
 5-2286 . if (A != B)
 5-2287 . {
 5-2288 .    A = B + C;
 5-2289 .    D = E + F;
 5-2290 . }
 5-2291 . 
 5-2292 . 
 5-2293 . if (A < = B)
 5-2294 . {
 5-2295 .    A = B + C;
 5-2296 .    D = E + F;
 5-2297 . }
 5-2298 . 
 5-2299 . 
 5-2300 . if (A != B)
 5-2301 . {
 5-2302 .    A = B + C;
 5-2303 .    D = E + F;
 5-2304 . }
 5-2305 . 
 5-2306 . A = B*C;
 5-2307 . A = B+C;
 5-2308 . A = B*C;
 5-2309 . 
 5-2310 . if (A >  B)
 5-2311 . {
 5-2312 .    A = B + C;
 5-2313 .    D = E + F;
 5-2314 . }
 5-2315 . 
 5-2316 . 
 5-2317 . /* dead_code = B + C; 
 5-2318 . dead_code = D + E; 
 5-2319 . dead_code = F + G; */
 5-2320 . 
 5-2321 . A = B/C;
 5-2322 . 
 5-2323 . switch (pwr stuff)
 5-2324 . {
 5-2325 .    case one:
 5-2326 .    {
 5-2327 .       run_this; 
 5-2328 .       // missing break
 5-2329 .    }
 5-2330 .    case two:
 5-2331 .    {
 5-2332 .       run_this;
 5-2333 .       break;
 5-2334 .    }
 5-2335 .    default:
 5-2336 .    {
 5-2337 .       SwError;
 5-2338 .    }
 5-2339 . }
 5-2340 . 
 5-2341 . A = B*C;
 5-2342 . A = B-C;
 5-2343 . A = B+C;
 5-2344 . A = B-C;
 5-2345 . // max LOC 27
 5-2346 . 
 5-2347 . }
 5-2348 . 

5 5 Result: result/source/pr-app/pr-app-PWR123/pwr-05.c

6 6 Source: source/pr-app/pr-app-PWR123/pwr-06.c
 6-0 . /*
 6-1 . ----------------------------------------------------------------------------
 6-2 . --| BEGIN PROLOGUE
 6-3 . --|
 6-4 . --| CLASSIFICATION: UNCLASSIFIED
 6-5 . --|
 6-6 . --| FILE NAME:      pwr-06.c
 6-7 . --|
 6-8 . --| ABSTRACT:
 6-9 . --|   This file contains the 9 functions that do file pwr stuff.
 6-10 . --|
 6-11 . --| HISTORY:
 6-12 . --|   CCCQ_NAME:
 6-13 . --|   CCCQ_VER: 
 6-14 . --|
 6-15 . --| END PROLOGUE
 6-16 . ----------------------------------------------------------------------------
 6-17 . */
 6-18 . 
 6-19 . char D;
 6-20 . #define B;
 6-21 . #include D;
 6-22 . int A;
 6-23 . 
 6-24 . 
 6-25 . 
 6-26 . /*
 6-27 . -----------------------------------------------------------------------------
 6-28 . --| NAME:   pwr.6.1
 6-29 . --|
 6-30 . --| ABSTRACT:
 6-31 . --|   This function does pwr stuff.
 6-32 . --|
 6-33 . --| RETURNS:
 6-34 . --|   NONE.
 6-35 . --|
 6-36 . ----------------------------------------------------------------------------
 6-37 . */
 6-38 . static void pwr.6.1(void)
 6-39 . {
 6-40 . A = B/C;
 6-41 . /* LE SV TOC-2518 this is a pwr-06.1.2 req to record*/
 6-42 . A = B-C;
 6-43 . A = B/C;
 6-44 . A = B-C;
 6-45 . 
 6-46 . if (A > = B)
 6-47 . {
 6-48 .    A = B + C;
 6-49 .    D = E + F;
 6-50 . }
 6-51 . 
 6-52 . A = B*C;
 6-53 . A = B+C;
 6-54 . 
 6-55 . if (A == B)
 6-56 . {
 6-57 .    A = B + C;
 6-58 .    D = E + F;
 6-59 . }
 6-60 . 
 6-61 . /* LE SV TOC-2519 this is a pwr-06.1.9 req to process*/
 6-62 . A = B/C;
 6-63 . A = B+C;
 6-64 . A = B+C;
 6-65 . 
 6-66 . if (A < = B)
 6-67 . {
 6-68 .    A = B + C;
 6-69 .    D = E + F;
 6-70 . }
 6-71 . 
 6-72 . A = B+C;
 6-73 . A = B-C;
 6-74 . A = B-C;
 6-75 . A = B-C;
 6-76 . A = B/C;
 6-77 . A = B*C;
 6-78 . A = B/C;
 6-79 . A = B*C;
 6-80 . /* LE SV TOC-2520 this is a pwr-06.1.21 req to fail*/
 6-81 . A = B*C;
 6-82 . A = B/C;
 6-83 . 
 6-84 . if (A le B)
 6-85 . {
 6-86 .    A = B + C;
 6-87 .    D = E + F;
 6-88 . }
 6-89 . 
 6-90 . 
 6-91 . if (A < = B)
 6-92 . {
 6-93 .    A = B + C;
 6-94 .    D = E + F;
 6-95 . }
 6-96 . 
 6-97 . 
 6-98 . if (A >  B)
 6-99 . {
 6-100 .    A = B + C;
 6-101 .    D = E + F;
 6-102 . }
 6-103 . 
 6-104 . A = B*C;
 6-105 . 
 6-106 . if (A != B)
 6-107 . {
 6-108 .    A = B + C;
 6-109 .    D = E + F;
 6-110 . }
 6-111 . 
 6-112 . A = B+C;
 6-113 . A = B*C;
 6-114 . A = B*C;
 6-115 . A = 0x0001;
 6-116 . A = B+C;
 6-117 . A = B+C;
 6-118 . A = B/C;
 6-119 . A = B+C;
 6-120 . A = B/C;
 6-121 . 
 6-122 . if (A lt B)
 6-123 . {
 6-124 .    A = B + C;
 6-125 .    D = E + F;
 6-126 . }
 6-127 . 
 6-128 . // max LOC 36
 6-129 . 
 6-130 . }
 6-131 . 
 6-132 . 
 6-133 . /*
 6-134 . -----------------------------------------------------------------------------
 6-135 . --| NAME:   pwr.6.2
 6-136 . --|
 6-137 . --| ABSTRACT:
 6-138 . --|   This function does pwr stuff.
 6-139 . --|
 6-140 . --| RETURNS:
 6-141 . --|   NONE.
 6-142 . --|
 6-143 . ----------------------------------------------------------------------------
 6-144 . */
 6-145 . static void pwr.6.2(void)
 6-146 . {
 6-147 . A = B*C;
 6-148 . A = B-C;
 6-149 . A = B+C;
 6-150 . 
 6-151 . if (A != B)
 6-152 . {
 6-153 .    A = B + C;
 6-154 .    D = E + F;
 6-155 . }
 6-156 . 
 6-157 . send_buffer = (U16 *) malloc(size+1);
 6-158 . A = B-C;
 6-159 . A = B*C;
 6-160 . A = (int)B + C;
 6-161 . A = B-C;
 6-162 . A = B+C;
 6-163 . A = B*C;
 6-164 . /* LE SV TOC-2521 this is a pwr-06.2.10 req to record*/
 6-165 . A = B*C;
 6-166 . A = B+C;
 6-167 . A = B*C;
 6-168 . 
 6-169 . if (A lt B)
 6-170 . {
 6-171 .    A = B + C;
 6-172 .    D = E + F;
 6-173 . }
 6-174 . 
 6-175 . 
 6-176 . if (A != B)
 6-177 . {
 6-178 .    A = B + C;
 6-179 .    D = E + F;
 6-180 . }
 6-181 . 
 6-182 . A = B+C;
 6-183 . 
 6-184 . if (A != B)
 6-185 . {
 6-186 .    A = B + C;
 6-187 .    D = E + F;
 6-188 . }
 6-189 . 
 6-190 . 
 6-191 . if (A >  B)
 6-192 . {
 6-193 .    A = B + C;
 6-194 .    D = E + F;
 6-195 . }
 6-196 . 
 6-197 . // max LOC 17
 6-198 . 
 6-199 . }
 6-200 . 
 6-201 . 
 6-202 . /*
 6-203 . -----------------------------------------------------------------------------
 6-204 . --| NAME:   pwr.6.3
 6-205 . --|
 6-206 . --| ABSTRACT:
 6-207 . --|   This function does pwr stuff.
 6-208 . --|
 6-209 . --| RETURNS:
 6-210 . --|   NONE.
 6-211 . --|
 6-212 . ----------------------------------------------------------------------------
 6-213 . */
 6-214 . static void pwr.6.3(void)
 6-215 . {
 6-216 . // ??? go see ws
 6-217 . 
 6-218 . switch (pwr stuff)
 6-219 . {
 6-220 .    case one:
 6-221 .    {
 6-222 .       run_this; 
 6-223 .       break;
 6-224 .    }
 6-225 .    case two:
 6-226 .    {
 6-227 .       run_this;
 6-228 .       break;
 6-229 .    }
 6-230 .    default:
 6-231 .    {
 6-232 .        SwError;
 6-233 .    }
 6-234 . }
 6-235 . 
 6-236 . A = B*C;
 6-237 . /* LE SV TOC-2522 this is a pwr-06.3.3 req to audit*/
 6-238 . A = B+C;
 6-239 . A = B/C;
 6-240 . A = B*C;
 6-241 . A = B-C;
 6-242 . 
 6-243 . if (A > = B)
 6-244 . {
 6-245 .    A = B + C;
 6-246 .    D = E + F;
 6-247 . }
 6-248 . 
 6-249 . A = B+C;
 6-250 . A = B*C;
 6-251 . A = B+C;
 6-252 . 
 6-253 . if (A < = B)
 6-254 . {
 6-255 .    A = B + C;
 6-256 .    D = E + F;
 6-257 . }
 6-258 . 
 6-259 . /* LE SV TOC-2523 this is a pwr-06.3.12 req to enable*/
 6-260 . A = B+C;
 6-261 . A = B/C;
 6-262 . A = B*C;
 6-263 . A = B+C;
 6-264 . 
 6-265 . if (A gt B)
 6-266 . {
 6-267 .    A = B + C;
 6-268 .    D = E + F;
 6-269 . }
 6-270 . 
 6-271 . A = B*C;
 6-272 . A = B*C;
 6-273 . A = B/C;
 6-274 . A = B-C;
 6-275 . // max LOC 20
 6-276 . 
 6-277 . }
 6-278 . 
 6-279 . 
 6-280 . /*
 6-281 . -----------------------------------------------------------------------------
 6-282 . --| NAME:   pwr.6.4
 6-283 . --|
 6-284 . --| ABSTRACT:
 6-285 . --|   This function does pwr stuff.
 6-286 . --|
 6-287 . --| RETURNS:
 6-288 . --|   NONE.
 6-289 . --|
 6-290 . ----------------------------------------------------------------------------
 6-291 . */
 6-292 . static void pwr.6.4(void)
 6-293 . {
 6-294 . A = B-C;
 6-295 . A = B/C;
 6-296 . A = B/C;
 6-297 . A = B-C;
 6-298 . A = B/C;
 6-299 . A = B*C;
 6-300 . /* LE SV TOC-2524 this is a pwr-06.4.7 req to enable*/
 6-301 . A = B/C;
 6-302 . // (P) this is really improtant
 6-303 . 
 6-304 . if (A > = B)
 6-305 . {
 6-306 .    A = B + C;
 6-307 .    D = E + F;
 6-308 . }
 6-309 . 
 6-310 . A = B+C;
 6-311 . A = B*C;
 6-312 . A = B*C;
 6-313 . A = B*C;
 6-314 . A = B-C;
 6-315 . 
 6-316 . if (A lt B)
 6-317 . {
 6-318 .    A = B + C;
 6-319 .    D = E + F;
 6-320 . }
 6-321 . 
 6-322 . A = B/C;
 6-323 . A = B/C;
 6-324 . 
 6-325 . if (A < = B)
 6-326 . {
 6-327 .    A = B + C;
 6-328 .    D = E + F;
 6-329 . }
 6-330 . 
 6-331 . A = B-C;
 6-332 . 
 6-333 . if (A eq B)
 6-334 . {
 6-335 .    A = B + C;
 6-336 .    D = E + F;
 6-337 . }
 6-338 . 
 6-339 . 
 6-340 . if (A gt B)
 6-341 . {
 6-342 .    A = B + C;
 6-343 .    D = E + F;
 6-344 . }
 6-345 . 
 6-346 . A = B+C;
 6-347 . A = B/C;
 6-348 . A = B*C;
 6-349 . 
 6-350 . if (A ne B)
 6-351 . {
 6-352 .    A = B + C;
 6-353 .    D = E + F;
 6-354 . }
 6-355 . 
 6-356 . 
 6-357 . if (A ne B)
 6-358 . {
 6-359 .    A = B + C;
 6-360 .    D = E + F;
 6-361 . }
 6-362 . 
 6-363 . A = B-C;
 6-364 . 
 6-365 . if (A ge B)
 6-366 . {
 6-367 .    A = B + C;
 6-368 .    D = E + F;
 6-369 . }
 6-370 . 
 6-371 . A = B/C;
 6-372 . A = B*C;
 6-373 . A = B-C;
 6-374 . A = B-C;
 6-375 . A = B/C;
 6-376 . A = B-C;
 6-377 . A = B/C;
 6-378 . A = B+C;
 6-379 . 
 6-380 . if (A le B)
 6-381 . {
 6-382 .    A = B + C;
 6-383 .    D = E + F;
 6-384 . }
 6-385 . 
 6-386 . A = B+C;
 6-387 . A = B+C;
 6-388 . A = B*C;
 6-389 . A = B*C;
 6-390 . A = B*C;
 6-391 . A = B*C;
 6-392 . A = B+C;
 6-393 . A = B*C;
 6-394 . A = B+C;
 6-395 . 
 6-396 . if (A gt B)
 6-397 . {
 6-398 .    A = B + C;
 6-399 .    D = E + F;
 6-400 . }
 6-401 . 
 6-402 . 
 6-403 . if (A gt B)
 6-404 . {
 6-405 .    A = B + C;
 6-406 .    D = E + F;
 6-407 . }
 6-408 . 
 6-409 . A = B/C;
 6-410 . 
 6-411 . if (A <  B)
 6-412 . {
 6-413 .    A = B + C;
 6-414 .    D = E + F;
 6-415 . }
 6-416 . 
 6-417 . A = B-C;
 6-418 . A = B*C;
 6-419 . A = B-C;
 6-420 . 
 6-421 . if (A ge B)
 6-422 . {
 6-423 .    A = B + C;
 6-424 .    D = E + F;
 6-425 . }
 6-426 . 
 6-427 . A = B-C;
 6-428 . 
 6-429 . if (A eq B)
 6-430 . {
 6-431 .    A = B + C;
 6-432 .    D = E + F;
 6-433 . }
 6-434 . 
 6-435 . A = B/C;
 6-436 . goto error;
 6-437 . A = B+C;
 6-438 . A = 0x0009;
 6-439 . 
 6-440 . if (A lt B)
 6-441 . {
 6-442 .    A = B + C;
 6-443 .    D = E + F;
 6-444 . }
 6-445 . 
 6-446 . A = B/C;
 6-447 . A = B/C;
 6-448 . A = B/C;
 6-449 . 
 6-450 . if (A ge B)
 6-451 . {
 6-452 .    A = B + C;
 6-453 .    D = E + F;
 6-454 . }
 6-455 . 
 6-456 . A = B*C;
 6-457 . A = B-C;
 6-458 . // max LOC 64
 6-459 . 
 6-460 . }
 6-461 . 
 6-462 . 
 6-463 . /*
 6-464 . -----------------------------------------------------------------------------
 6-465 . --| NAME:   pwr.6.5
 6-466 . --|
 6-467 . --| ABSTRACT:
 6-468 . --|   This function does pwr stuff.
 6-469 . --|
 6-470 . --| RETURNS:
 6-471 . --|   NONE.
 6-472 . --|
 6-473 . ----------------------------------------------------------------------------
 6-474 . */
 6-475 . static void pwr.6.5(void)
 6-476 . {
 6-477 . A = B-C;
 6-478 . /* LE SV TOC-2525 this is a pwr-06.5.2 req to set RTC*/
 6-479 . 
 6-480 . if (A < = B)
 6-481 . {
 6-482 .    A = B + C;
 6-483 .    D = E + F;
 6-484 . }
 6-485 . 
 6-486 . A = B/C;
 6-487 . /* LE SV TOC-2526 this is a pwr-06.5.4 req to recover*/
 6-488 . A = B-C;
 6-489 . A = B/C;
 6-490 . A = B*C;
 6-491 . 
 6-492 . if (A gt B)
 6-493 . {
 6-494 .    A = B + C;
 6-495 .    D = E + F;
 6-496 . }
 6-497 . 
 6-498 . A = B*C;
 6-499 . A = B+C;
 6-500 . A = B-C;
 6-501 . A = B/C;
 6-502 . A = B+C;
 6-503 . A = B+C;
 6-504 . A = B-C;
 6-505 . 
 6-506 . if (A <  B)
 6-507 . {
 6-508 .    A = B + C;
 6-509 .    D = E + F;
 6-510 . }
 6-511 . 
 6-512 . A = B-C;
 6-513 . A = B-C;
 6-514 . A = B*C;
 6-515 . A = B*C;
 6-516 . A = B*C;
 6-517 . 
 6-518 . if (A < = B)
 6-519 . {
 6-520 .    A = B + C;
 6-521 .    D = E + F;
 6-522 . }
 6-523 . 
 6-524 . 
 6-525 . if (A == B)
 6-526 . {
 6-527 .    A = B + C;
 6-528 .    D = E + F;
 6-529 . }
 6-530 . 
 6-531 . A = B+C;
 6-532 . A = B+C;
 6-533 . A = B+C;
 6-534 . A = B+C;
 6-535 . A = B-C;
 6-536 . 
 6-537 . if (A lt B)
 6-538 . {
 6-539 .    A = B + C;
 6-540 .    D = E + F;
 6-541 . }
 6-542 . 
 6-543 . A = B*C;
 6-544 . A = B*C;
 6-545 . A = B+C;
 6-546 . A = B/C;
 6-547 . A = B*C;
 6-548 . /* dead_code = A * B; */
 6-549 . 
 6-550 . if (A <  B)
 6-551 . {
 6-552 .    A = B + C;
 6-553 .    D = E + F;
 6-554 . }
 6-555 . 
 6-556 . 
 6-557 . #ifdef LAZY
 6-558 .    // this is not nice
 6-559 .    A = B + C;
 6-560 .    A = B + C;
 6-561 . #endif
 6-562 . 
 6-563 . A = B*C;
 6-564 . A = B*C;
 6-565 . A = B*C;
 6-566 . A = B-C;
 6-567 . A = B*C;
 6-568 . A = B*C;
 6-569 . A = B-C;
 6-570 . 
 6-571 . if (A != B)
 6-572 . {
 6-573 .    A = B + C;
 6-574 .    D = E + F;
 6-575 . }
 6-576 . 
 6-577 . A = B/C;
 6-578 . 
 6-579 . if (A eq B)
 6-580 . {
 6-581 .    A = B + C;
 6-582 .    D = E + F;
 6-583 . }
 6-584 . 
 6-585 . do forever;
 6-586 . A = B/C;
 6-587 . A = B*C;
 6-588 . A = B+C;
 6-589 . 
 6-590 . if (A > = B)
 6-591 . {
 6-592 .    A = B + C;
 6-593 .    D = E + F;
 6-594 . }
 6-595 . 
 6-596 . A = B*C;
 6-597 . A = B+C;
 6-598 . A = B+C;
 6-599 . A = B-C;
 6-600 . A = B*C;
 6-601 . 
 6-602 . switch (pwr stuff)
 6-603 . {
 6-604 .    case one:
 6-605 .    {
 6-606 .       run_this; 
 6-607 .       break;
 6-608 .    }
 6-609 .    case two:
 6-610 .    {
 6-611 .       run_this;
 6-612 .       break;
 6-613 .    }
 6-614 .    default:
 6-615 .    {
 6-616 .        SwError;
 6-617 .    }
 6-618 . }
 6-619 . 
 6-620 . A = 0x0003;
 6-621 . A = B+C;
 6-622 . A = B-C;
 6-623 . A = B+C;
 6-624 . A = B*C;
 6-625 . 
 6-626 . if (A gt B)
 6-627 . {
 6-628 .    A = B + C;
 6-629 .    D = E + F;
 6-630 . }
 6-631 . 
 6-632 . A = B/C;
 6-633 . A = B-C;
 6-634 . A = B*C;
 6-635 . A = B*C;
 6-636 . 
 6-637 . if (A > = B)
 6-638 . {
 6-639 .    A = B + C;
 6-640 .    D = E + F;
 6-641 . }
 6-642 . 
 6-643 . A = B*C;
 6-644 . A = B+C;
 6-645 . 
 6-646 . if (A le B)
 6-647 . {
 6-648 .    A = B + C;
 6-649 .    D = E + F;
 6-650 . }
 6-651 . 
 6-652 . A = (float)B + C;
 6-653 . A = B+C;
 6-654 . 
 6-655 . switch (pwr stuff)
 6-656 . {
 6-657 .    case one:
 6-658 .    {
 6-659 .       run_this; 
 6-660 .       break;
 6-661 .    }
 6-662 .    case two:
 6-663 .    {
 6-664 .       run_this;
 6-665 .       break;
 6-666 .    }
 6-667 .    default:
 6-668 .    {
 6-669 .        SwError;
 6-670 .    }
 6-671 . }
 6-672 . 
 6-673 . 
 6-674 . if (A ne B)
 6-675 . {
 6-676 .    A = B + C;
 6-677 .    D = E + F;
 6-678 . }
 6-679 . 
 6-680 . A = B-C;
 6-681 . 
 6-682 . if ($pwr stuff >  $otherpwr stuff) 
 6-683 . /* LE SV TOC-008 we really should log all error calls */
 6-684 . {
 6-685 .    A = B + C;
 6-686 . }
 6-687 . 
 6-688 . A = B-C;
 6-689 . /* LE SV TOC-2527 this is a pwr-06.5.73 req to validate*/
 6-690 . A = B+C;
 6-691 . A = 0x0003;
 6-692 . A = B+C;
 6-693 . A = B*C;
 6-694 . A = B+C;
 6-695 . A = B+C;
 6-696 . 
 6-697 . if (A ge B)
 6-698 . {
 6-699 .    A = B + C;
 6-700 .    D = E + F;
 6-701 . }
 6-702 . 
 6-703 . rcv_buffer = (U16 *) alloc(size+1);
 6-704 . A = B-C;
 6-705 . // max LOC 79
 6-706 . 
 6-707 . }
 6-708 . 
 6-709 . 
 6-710 . /*
 6-711 . -----------------------------------------------------------------------------
 6-712 . --| NAME:   pwr.6.6
 6-713 . --|
 6-714 . --| ABSTRACT:
 6-715 . --|   This function does pwr stuff.
 6-716 . --|
 6-717 . --| RETURNS:
 6-718 . --|   NONE.
 6-719 . --|
 6-720 . ----------------------------------------------------------------------------
 6-721 . */
 6-722 . static void pwr.6.6(void)
 6-723 . {
 6-724 . A = B/C;
 6-725 . A = B*C;
 6-726 . A = 0x0008;
 6-727 . A = B+C;
 6-728 . A = B/C;
 6-729 . /* LE SV TOC-2528 this is a pwr-06.6.5 req to compare*/
 6-730 . A = B*C;
 6-731 . A = B/C;
 6-732 . 
 6-733 . if (A >  B)
 6-734 . {
 6-735 .    A = B + C;
 6-736 .    D = E + F;
 6-737 . }
 6-738 . 
 6-739 . A = B-C;
 6-740 . A = B-C;
 6-741 . 
 6-742 . if (A le B)
 6-743 . {
 6-744 .    A = B + C;
 6-745 .    D = E + F;
 6-746 . }
 6-747 . 
 6-748 . A = B+C;
 6-749 . A = B-C;
 6-750 . A = B/C;
 6-751 . A = B-C;
 6-752 . 
 6-753 . if (A lt B)
 6-754 . {
 6-755 .    A = B + C;
 6-756 .    D = E + F;
 6-757 . }
 6-758 . 
 6-759 . 
 6-760 . if (A >  B)
 6-761 . {
 6-762 .    A = B + C;
 6-763 .    D = E + F;
 6-764 . }
 6-765 . 
 6-766 . 
 6-767 . if (A lt B)
 6-768 . {
 6-769 .    A = B + C;
 6-770 .    D = E + F;
 6-771 . }
 6-772 . 
 6-773 . 
 6-774 . if (A ge B)
 6-775 . {
 6-776 .    A = B + C;
 6-777 .    D = E + F;
 6-778 . }
 6-779 . 
 6-780 . A = B-C;
 6-781 . A = B/C;
 6-782 . A = B-C;
 6-783 . A = B*C;
 6-784 . A = B*C;
 6-785 . 
 6-786 . if (A != B)
 6-787 . {
 6-788 .    A = B + C;
 6-789 .    D = E + F;
 6-790 . }
 6-791 . 
 6-792 . FreePtr = HmiStringPtr;
 6-793 . A = B/C;
 6-794 . A = B-C;
 6-795 . A = B-C;
 6-796 . 
 6-797 . switch (pwr stuff)
 6-798 . {
 6-799 .    case one:
 6-800 .    {
 6-801 .       run_this; 
 6-802 .       break;
 6-803 .    }
 6-804 .    case two:
 6-805 .    {
 6-806 .       run_this;
 6-807 .       break;
 6-808 .    }
 6-809 .    default:
 6-810 .    {
 6-811 .        SwError;
 6-812 .    }
 6-813 . }
 6-814 . 
 6-815 . A = B*C;
 6-816 . A = B+C;
 6-817 . 
 6-818 . if (A ge B)
 6-819 . {
 6-820 .    A = B + C;
 6-821 .    D = E + F;
 6-822 . }
 6-823 . 
 6-824 . 
 6-825 . if (A gt B)
 6-826 . {
 6-827 .    A = B + C;
 6-828 .    D = E + F;
 6-829 . }
 6-830 . 
 6-831 . A = B*C;
 6-832 . 
 6-833 . if (A <  B)
 6-834 . {
 6-835 .    A = B + C;
 6-836 .    D = E + F;
 6-837 . }
 6-838 . 
 6-839 . A = B*C;
 6-840 . A = B-C;
 6-841 . 
 6-842 . if (A ge B)
 6-843 . {
 6-844 .    A = B + C;
 6-845 .    D = E + F;
 6-846 . }
 6-847 . 
 6-848 . 
 6-849 . if (A gt B)
 6-850 . {
 6-851 .    A = B + C;
 6-852 .    D = E + F;
 6-853 . }
 6-854 . 
 6-855 . 
 6-856 . if (A lt B)
 6-857 . {
 6-858 .    A = B + C;
 6-859 .    D = E + F;
 6-860 . }
 6-861 . 
 6-862 . 
 6-863 . /* 
 6-864 . dead_code = B - C; 
 6-865 . dead_code = D - E; 
 6-866 . dead_code = F - G;
 6-867 . */
 6-868 . 
 6-869 . A = B+C;
 6-870 . 
 6-871 . if (A ge B)
 6-872 . {
 6-873 .    A = B + C;
 6-874 .    D = E + F;
 6-875 . }
 6-876 . 
 6-877 . /* LE SV TOC-2529 this is a pwr-06.6.42 req to check unix*/
 6-878 . A = B/C;
 6-879 . A = B+C;
 6-880 . A = B/C;
 6-881 . 
 6-882 . if (A != B)
 6-883 . {
 6-884 .    A = B + C;
 6-885 .    D = E + F;
 6-886 . }
 6-887 . 
 6-888 . A = B*C;
 6-889 . A = B-C;
 6-890 . A = B/C;
 6-891 . 
 6-892 . if (A ne B)
 6-893 . {
 6-894 .    A = B + C;
 6-895 .    D = E + F;
 6-896 . }
 6-897 . 
 6-898 . A = B/C;
 6-899 . // max LOC 50
 6-900 . 
 6-901 . }
 6-902 . 
 6-903 . 
 6-904 . /*
 6-905 . -----------------------------------------------------------------------------
 6-906 . --| NAME:   pwr.6.7
 6-907 . --|
 6-908 . --| ABSTRACT:
 6-909 . --|   This function does pwr stuff.
 6-910 . --|
 6-911 . --| RETURNS:
 6-912 . --|   NONE.
 6-913 . --|
 6-914 . ----------------------------------------------------------------------------
 6-915 . */
 6-916 . static void pwr.6.7(void)
 6-917 . {
 6-918 . A = B/C;
 6-919 . A = B-C;
 6-920 . A = B-C;
 6-921 . /* LE SV TOC-2530 this is a pwr-06.7.4 req to convert*/
 6-922 . A = B*C;
 6-923 . A = B+C;
 6-924 . A = B*C;
 6-925 . 
 6-926 . if (A == B)
 6-927 . {
 6-928 .    A = B + C;
 6-929 .    D = E + F;
 6-930 . }
 6-931 . 
 6-932 . A = B-C;
 6-933 . // TBS - I need to figure this out
 6-934 . A = B/C;
 6-935 . A = B-C;
 6-936 . A = B/C;
 6-937 . A = B*C;
 6-938 . 
 6-939 . if (A lt B)
 6-940 . {
 6-941 .    A = B + C;
 6-942 .    D = E + F;
 6-943 . }
 6-944 . 
 6-945 . A = 0x0001;
 6-946 . A = B/C;
 6-947 . /* LE SV TOC-2531 this is a pwr-06.7.15 req to set Real Time Clock*/
 6-948 . A = B+C;
 6-949 . 
 6-950 . if (A < = B)
 6-951 . {
 6-952 .    A = B + C;
 6-953 .    D = E + F;
 6-954 . }
 6-955 . 
 6-956 . A = B-C;
 6-957 . A = B/C;
 6-958 . /* LE SV TOC-2532 this is a pwr-06.7.19 req to set Real Time Clock*/
 6-959 . A = B+C;
 6-960 . 
 6-961 . if (A > = B)
 6-962 . {
 6-963 .    A = B + C;
 6-964 .    D = E + F;
 6-965 . }
 6-966 . 
 6-967 . A = B*C;
 6-968 . A = B/C;
 6-969 . A = B/C;
 6-970 . A = B+C;
 6-971 . /* LE SV TOC-2533 this is a pwr-06.7.25 req to assign*/
 6-972 . A = B*C;
 6-973 . A = 0x0006;
 6-974 . A = B*C;
 6-975 . 
 6-976 . if (A lt B)
 6-977 . {
 6-978 .    A = B + C;
 6-979 .    D = E + F;
 6-980 . }
 6-981 . 
 6-982 . A = B*C;
 6-983 . A = B-C;
 6-984 . A = B/C;
 6-985 . A = B/C;
 6-986 . A = B*C;
 6-987 . A = B+C;
 6-988 . A = B-C;
 6-989 . A = B*C;
 6-990 . A = B*C;
 6-991 . A = B*C;
 6-992 . 
 6-993 . if (A >  B)
 6-994 . {
 6-995 .    A = B + C;
 6-996 .    D = E + F;
 6-997 . }
 6-998 . 
 6-999 . A = B+C;
 6-1000 . 
 6-1001 . if (A ge B)
 6-1002 . {
 6-1003 .    A = B + C;
 6-1004 .    D = E + F;
 6-1005 . }
 6-1006 . 
 6-1007 . 
 6-1008 . if (A le B)
 6-1009 . {
 6-1010 .    A = B + C;
 6-1011 .    D = E + F;
 6-1012 . }
 6-1013 . 
 6-1014 . A = B-C;
 6-1015 . 
 6-1016 . if (A ne B)
 6-1017 . {
 6-1018 .    A = B + C;
 6-1019 .    D = E + F;
 6-1020 . }
 6-1021 . 
 6-1022 . A = B+C;
 6-1023 . A = B+C;
 6-1024 . A = B-C;
 6-1025 . 
 6-1026 . if (A gt B)
 6-1027 . {
 6-1028 .    A = B + C;
 6-1029 .    D = E + F;
 6-1030 . }
 6-1031 . 
 6-1032 . A = B*C;
 6-1033 . A = B*C;
 6-1034 . A = B-C;
 6-1035 . A = B/C;
 6-1036 . 
 6-1037 . if (A == B)
 6-1038 . {
 6-1039 .    A = B + C;
 6-1040 .    D = E + F;
 6-1041 . }
 6-1042 . 
 6-1043 . 
 6-1044 . if (A > = B)
 6-1045 . {
 6-1046 .    A = B + C;
 6-1047 .    D = E + F;
 6-1048 . }
 6-1049 . 
 6-1050 . A = B-C;
 6-1051 . 
 6-1052 . if (A <  B)
 6-1053 . {
 6-1054 .    A = B + C;
 6-1055 .    D = E + F;
 6-1056 . }
 6-1057 . 
 6-1058 . // max LOC 55
 6-1059 . 
 6-1060 . }
 6-1061 . 
 6-1062 . 
 6-1063 . /*
 6-1064 . -----------------------------------------------------------------------------
 6-1065 . --| NAME:   pwr.6.8
 6-1066 . --|
 6-1067 . --| ABSTRACT:
 6-1068 . --|   This function does pwr stuff.
 6-1069 . --|
 6-1070 . --| RETURNS:
 6-1071 . --|   NONE.
 6-1072 . --|
 6-1073 . ----------------------------------------------------------------------------
 6-1074 . */
 6-1075 . static void pwr.6.8(void)
 6-1076 . {
 6-1077 . 
 6-1078 . if (A lt B)
 6-1079 . {
 6-1080 .    A = B + C;
 6-1081 .    D = E + F;
 6-1082 . }
 6-1083 . 
 6-1084 . A = B*C;
 6-1085 . A = B+C;
 6-1086 . A = B-C;
 6-1087 . // max LOC 4
 6-1088 . 
 6-1089 . }
 6-1090 . 
 6-1091 . 
 6-1092 . /*
 6-1093 . -----------------------------------------------------------------------------
 6-1094 . --| NAME:   pwr.6.9
 6-1095 . --|
 6-1096 . --| ABSTRACT:
 6-1097 . --|   This function does pwr stuff.
 6-1098 . --|
 6-1099 . --| RETURNS:
 6-1100 . --|   NONE.
 6-1101 . --|
 6-1102 . ----------------------------------------------------------------------------
 6-1103 . */
 6-1104 . static void pwr.6.9(void)
 6-1105 . {
 6-1106 . A = B/C;
 6-1107 . 
 6-1108 . if (A >  B)
 6-1109 . {
 6-1110 .    A = B + C;
 6-1111 .    D = E + F;
 6-1112 . }
 6-1113 . 
 6-1114 . 
 6-1115 . if (A < = B)
 6-1116 . {
 6-1117 .    A = B + C;
 6-1118 .    D = E + F;
 6-1119 . }
 6-1120 . 
 6-1121 . A = B-C;
 6-1122 . A = B/C;
 6-1123 . 
 6-1124 . if (A > = B)
 6-1125 . {
 6-1126 .    A = B + C;
 6-1127 .    D = E + F;
 6-1128 . }
 6-1129 . 
 6-1130 . A = B-C;
 6-1131 . 
 6-1132 . if (A == B)
 6-1133 . {
 6-1134 .    A = B + C;
 6-1135 .    D = E + F;
 6-1136 . }
 6-1137 . 
 6-1138 . A = B*C;
 6-1139 . A = B-C;
 6-1140 . A = B+C;
 6-1141 . 
 6-1142 . if (A > = B)
 6-1143 . {
 6-1144 .    A = B + C;
 6-1145 .    D = E + F;
 6-1146 . }
 6-1147 . 
 6-1148 . A = B+C;
 6-1149 . 
 6-1150 . if (A lt B)
 6-1151 . {
 6-1152 .    A = B + C;
 6-1153 .    D = E + F;
 6-1154 . }
 6-1155 . 
 6-1156 . A = B/C;
 6-1157 . A = B/C;
 6-1158 . A = B-C;
 6-1159 . A = B-C;
 6-1160 . /* LE SV TOC-2534 this is a pwr-06.9.19 req to convert*/
 6-1161 . 
 6-1162 . if (A == B)
 6-1163 . {
 6-1164 .    A = B + C;
 6-1165 .    D = E + F;
 6-1166 . }
 6-1167 . 
 6-1168 . A = B-C;
 6-1169 . 
 6-1170 . if (A < = B)
 6-1171 . {
 6-1172 .    A = B + C;
 6-1173 .    D = E + F;
 6-1174 . }
 6-1175 . 
 6-1176 . A = B-C;
 6-1177 . A = B/C;
 6-1178 . A = B-C;
 6-1179 . A = B*C;
 6-1180 . A = B/C;
 6-1181 . A = B-C;
 6-1182 . A = B+C;
 6-1183 . A = B/C;
 6-1184 . 
 6-1185 . if (A ge B)
 6-1186 . {
 6-1187 .    A = B + C;
 6-1188 .    D = E + F;
 6-1189 . }
 6-1190 . 
 6-1191 . 
 6-1192 . if (A ne B)
 6-1193 . {
 6-1194 .    A = B + C;
 6-1195 .    D = E + F;
 6-1196 . }
 6-1197 . 
 6-1198 . 
 6-1199 . if (A != B)
 6-1200 . {
 6-1201 .    A = B + C;
 6-1202 .    D = E + F;
 6-1203 . }
 6-1204 . 
 6-1205 . A = B*C;
 6-1206 . 
 6-1207 . if ($pwr stuff >  $otherpwr stuff) 
 6-1208 . /* LE SV TOC-008 we really should log all error calls */
 6-1209 . {
 6-1210 .    A = B + C;
 6-1211 . }
 6-1212 . 
 6-1213 . A = B/C;
 6-1214 . A = B/C;
 6-1215 . A = B+C;
 6-1216 . A = B+C;
 6-1217 . A = B*C;
 6-1218 . A = B/C;
 6-1219 . A = B/C;
 6-1220 . A = B-C;
 6-1221 . A = B*C;
 6-1222 . A = B-C;
 6-1223 . A = B*C;
 6-1224 . 
 6-1225 . if (A le B)
 6-1226 . {
 6-1227 .    A = B + C;
 6-1228 .    D = E + F;
 6-1229 . }
 6-1230 . 
 6-1231 . 
 6-1232 . if (A >  B)
 6-1233 . {
 6-1234 .    A = B + C;
 6-1235 .    D = E + F;
 6-1236 . }
 6-1237 . 
 6-1238 . A = B*C;
 6-1239 . A = B+C;
 6-1240 . 
 6-1241 . if (A le B)
 6-1242 . {
 6-1243 .    A = B + C;
 6-1244 .    D = E + F;
 6-1245 . }
 6-1246 . 
 6-1247 . 
 6-1248 . if (A eq B)
 6-1249 . {
 6-1250 .    A = B + C;
 6-1251 .    D = E + F;
 6-1252 . }
 6-1253 . 
 6-1254 . A = B/C;
 6-1255 . 
 6-1256 . if (A ne B)
 6-1257 . {
 6-1258 .    A = B + C;
 6-1259 .    D = E + F;
 6-1260 . }
 6-1261 . 
 6-1262 . 
 6-1263 . if (A ne B)
 6-1264 . {
 6-1265 .    A = B + C;
 6-1266 .    D = E + F;
 6-1267 . }
 6-1268 . 
 6-1269 . A = B+C;
 6-1270 . A = B/C;
 6-1271 . A = B+C;
 6-1272 . /* LE SV TOC-2535 this is a pwr-06.9.57 req to compare*/
 6-1273 . A = B-C;
 6-1274 . A = B-C;
 6-1275 . A = B*C;
 6-1276 . A = B*C;
 6-1277 . A = B+C;
 6-1278 . A = B/C;
 6-1279 . A = B+C;
 6-1280 . 
 6-1281 . if (A >  B)
 6-1282 . {
 6-1283 .    A = B + C;
 6-1284 .    D = E + F;
 6-1285 . }
 6-1286 . 
 6-1287 . 
 6-1288 . if (A != B)
 6-1289 . {
 6-1290 .    A = B + C;
 6-1291 .    D = E + F;
 6-1292 . }
 6-1293 . 
 6-1294 . A = B-C;
 6-1295 . A = B+C;
 6-1296 . /* dead_code = A * B; */
 6-1297 . A = B*C;
 6-1298 . free(FreePtr);
 6-1299 . A = B+C;
 6-1300 . 
 6-1301 . if (A < = B)
 6-1302 . {
 6-1303 .    A = B + C;
 6-1304 .    D = E + F;
 6-1305 . }
 6-1306 . 
 6-1307 . A = B-C;
 6-1308 . // max LOC 71
 6-1309 . 
 6-1310 . }
 6-1311 . 

6 6 Result: result/source/pr-app/pr-app-PWR123/pwr-06.c

7 7 Source: source/pr-app/pr-app-PWR123/pwr-07.c
 7-0 . /*
 7-1 . ----------------------------------------------------------------------------
 7-2 . --| BEGIN PROLOGUE
 7-3 . --|
 7-4 . --| CLASSIFICATION: UNCLASSIFIED
 7-5 . --|
 7-6 . --| FILE NAME:      pwr-07.c
 7-7 . --|
 7-8 . --| ABSTRACT:
 7-9 . --|   This file contains the 8 functions that do file pwr stuff.
 7-10 . --|
 7-11 . --| HISTORY:
 7-12 . --|   CCCQ_NAME:
 7-13 . --|   CCCQ_VER: 
 7-14 . --|
 7-15 . --| END PROLOGUE
 7-16 . ----------------------------------------------------------------------------
 7-17 . */
 7-18 . 
 7-19 . #include A;
 7-20 . char D;
 7-21 . int A;
 7-22 . #define C;
 7-23 . #include B;
 7-24 . #define C;
 7-25 . char D;
 7-26 . #define A;
 7-27 . 
 7-28 . 
 7-29 . 
 7-30 . /*
 7-31 . -----------------------------------------------------------------------------
 7-32 . --| NAME:   pwr.7.1
 7-33 . --|
 7-34 . --| ABSTRACT:
 7-35 . --|   This function does pwr stuff.
 7-36 . --|
 7-37 . --| RETURNS:
 7-38 . --|   NONE.
 7-39 . --|
 7-40 . ----------------------------------------------------------------------------
 7-41 . */
 7-42 . static void pwr.7.1(void)
 7-43 . {
 7-44 . A = B+C;
 7-45 . A = B/C;
 7-46 . A = B*C;
 7-47 . A = B+C;
 7-48 . A = B*C;
 7-49 . 
 7-50 . if (A lt B)
 7-51 . {
 7-52 .    A = B + C;
 7-53 .    D = E + F;
 7-54 . }
 7-55 . 
 7-56 . A = B-C;
 7-57 . A = B*C;
 7-58 . A = B+C;
 7-59 . A = B+C;
 7-60 . A = B-C;
 7-61 . A = B*C;
 7-62 . A = B/C;
 7-63 . 
 7-64 . if (A eq B)
 7-65 . {
 7-66 .    A = B + C;
 7-67 .    D = E + F;
 7-68 . }
 7-69 . 
 7-70 . A = B*C;
 7-71 . A = B+C;
 7-72 . 
 7-73 . if (A < = B)
 7-74 . {
 7-75 .    A = B + C;
 7-76 .    D = E + F;
 7-77 . }
 7-78 . 
 7-79 . A = B/C;
 7-80 . A = B*C;
 7-81 . 
 7-82 . if {
 7-83 .    X = Y + Z;
 7-84 . }
 7-85 . else {
 7-86 .    halt;
 7-87 . }
 7-88 . 
 7-89 . A = B*C;
 7-90 . A = B/C;
 7-91 . A = (int)B + C;
 7-92 . 
 7-93 . if (A != B)
 7-94 . {
 7-95 .    A = B + C;
 7-96 .    D = E + F;
 7-97 . }
 7-98 . 
 7-99 . 
 7-100 . if (A le B)
 7-101 . {
 7-102 .    A = B + C;
 7-103 .    D = E + F;
 7-104 . }
 7-105 . 
 7-106 . A = B/C;
 7-107 . A = B-C;
 7-108 . A = B/C;
 7-109 . 
 7-110 . if (A >  B)
 7-111 . {
 7-112 .    A = B + C;
 7-113 .    D = E + F;
 7-114 . }
 7-115 . 
 7-116 . A = B/C;
 7-117 . A = B-C;
 7-118 . // max LOC 29
 7-119 . 
 7-120 . }
 7-121 . 
 7-122 . 
 7-123 . /*
 7-124 . -----------------------------------------------------------------------------
 7-125 . --| NAME:   pwr.7.2
 7-126 . --|
 7-127 . --| ABSTRACT:
 7-128 . --|   This function does pwr stuff.
 7-129 . --|
 7-130 . --| RETURNS:
 7-131 . --|   NONE.
 7-132 . --|
 7-133 . ----------------------------------------------------------------------------
 7-134 . */
 7-135 . static void pwr.7.2(void)
 7-136 . {
 7-137 . A = B+C;
 7-138 . A = B-C;
 7-139 . A = B*C;
 7-140 . A = B+C;
 7-141 . A = B+C;
 7-142 . 
 7-143 . if (A le B)
 7-144 . {
 7-145 .    A = B + C;
 7-146 .    D = E + F;
 7-147 . }
 7-148 . 
 7-149 . 
 7-150 . if (A >  B)
 7-151 . {
 7-152 .    A = B + C;
 7-153 .    D = E + F;
 7-154 . }
 7-155 . 
 7-156 . A = B-C;
 7-157 . 
 7-158 . if (A < = B)
 7-159 . {
 7-160 .    A = B + C;
 7-161 .    D = E + F;
 7-162 . }
 7-163 . 
 7-164 . A = B/C;
 7-165 . /* LE SV TOC-2536 this is a pwr-07.2.11 req to fail*/
 7-166 . A = B/C;
 7-167 . A = B+C;
 7-168 . /* LE SV TOC-2537 this is a pwr-07.2.13 req to transform*/
 7-169 . A = B/C;
 7-170 . 
 7-171 . switch (pwr stuff)
 7-172 . {
 7-173 .    case one:
 7-174 .    {
 7-175 .       run_this; 
 7-176 .       break;
 7-177 .    }
 7-178 .    case two:
 7-179 .    {
 7-180 .       run_this;
 7-181 .       break;
 7-182 .    }
 7-183 .    default:
 7-184 .    {
 7-185 .        SwError;
 7-186 .    }
 7-187 . }
 7-188 . 
 7-189 . A = 0x0009;
 7-190 . A = B+C;
 7-191 . 
 7-192 . if (A le B)
 7-193 . {
 7-194 .    A = B + C;
 7-195 .    D = E + F;
 7-196 . }
 7-197 . 
 7-198 . A = B+C;
 7-199 . A = B+C;
 7-200 . A = B/C;
 7-201 . A = B*C;
 7-202 . 
 7-203 . if (A le B)
 7-204 . {
 7-205 .    A = B + C;
 7-206 .    D = E + F;
 7-207 . }
 7-208 . 
 7-209 . A = B*C;
 7-210 . A = B/C;
 7-211 . 
 7-212 . if (A gt B)
 7-213 . {
 7-214 .    A = B + C;
 7-215 .    D = E + F;
 7-216 . }
 7-217 . 
 7-218 . A = B*C;
 7-219 . A = B-C;
 7-220 . A = B+C;
 7-221 . A = B+C;
 7-222 . A = B*C;
 7-223 . 
 7-224 . if (A lt B)
 7-225 . {
 7-226 .    A = B + C;
 7-227 .    D = E + F;
 7-228 . }
 7-229 . 
 7-230 . 
 7-231 . /* dead_block = C * D; 
 7-232 . dead_block = E * F; */
 7-233 . 
 7-234 . A = B-C;
 7-235 . 
 7-236 . if (A == B)
 7-237 . {
 7-238 .    A = B + C;
 7-239 .    D = E + F;
 7-240 . }
 7-241 . 
 7-242 . A = B+C;
 7-243 . 
 7-244 . if (A lt B)
 7-245 . {
 7-246 .    A = B + C;
 7-247 .    D = E + F;
 7-248 . }
 7-249 . 
 7-250 . A = B-C;
 7-251 . A = B/C;
 7-252 . A = B-C;
 7-253 . A = B/C;
 7-254 . A = B*C;
 7-255 . A = B+C;
 7-256 . 
 7-257 . if (A gt B)
 7-258 . {
 7-259 .    A = B + C;
 7-260 .    D = E + F;
 7-261 . }
 7-262 . 
 7-263 . A = B+C;
 7-264 . A = B-C;
 7-265 . A = B*C;
 7-266 . A = B-C;
 7-267 . A = B/C;
 7-268 . A = B+C;
 7-269 . A = B*C;
 7-270 . 
 7-271 . if (A ge B)
 7-272 . {
 7-273 .    A = B + C;
 7-274 .    D = E + F;
 7-275 . }
 7-276 . 
 7-277 . A = B/C;
 7-278 . 
 7-279 . if (A <  B)
 7-280 . {
 7-281 .    A = B + C;
 7-282 .    D = E + F;
 7-283 . }
 7-284 . 
 7-285 . A = B+C;
 7-286 . A = B*C;
 7-287 . A = B+C;
 7-288 . A = B+C;
 7-289 . A = B-C;
 7-290 . // max LOC 56
 7-291 . 
 7-292 . }
 7-293 . 
 7-294 . 
 7-295 . /*
 7-296 . -----------------------------------------------------------------------------
 7-297 . --| NAME:   pwr.7.3
 7-298 . --|
 7-299 . --| ABSTRACT:
 7-300 . --|   This function does pwr stuff.
 7-301 . --|
 7-302 . --| RETURNS:
 7-303 . --|   NONE.
 7-304 . --|
 7-305 . ----------------------------------------------------------------------------
 7-306 . */
 7-307 . static void pwr.7.3(void)
 7-308 . {
 7-309 . A = B-C;
 7-310 . 
 7-311 . if (A ge B)
 7-312 . {
 7-313 .    A = B + C;
 7-314 .    D = E + F;
 7-315 . }
 7-316 . 
 7-317 . A = B+C;
 7-318 . 
 7-319 . if (A eq B)
 7-320 . {
 7-321 .    A = B + C;
 7-322 .    D = E + F;
 7-323 . }
 7-324 . 
 7-325 . A = B+C;
 7-326 . 
 7-327 . if (A ge B)
 7-328 . {
 7-329 .    A = B + C;
 7-330 .    D = E + F;
 7-331 . }
 7-332 . 
 7-333 . A = B*C;
 7-334 . A = B*C;
 7-335 . FreePtr = HmiStringPtr;
 7-336 . 
 7-337 . if (A < = B)
 7-338 . {
 7-339 .    A = B + C;
 7-340 .    D = E + F;
 7-341 . }
 7-342 . 
 7-343 . 
 7-344 . if (A <  B)
 7-345 . {
 7-346 .    A = B + C;
 7-347 .    D = E + F;
 7-348 . }
 7-349 . 
 7-350 . A = B-C;
 7-351 . A = B*C;
 7-352 . A = B-C;
 7-353 . /* LE SV TOC-2538 this is a pwr-07.3.14 req to transform*/
 7-354 . A = B-C;
 7-355 . A = B-C;
 7-356 . A = B/C;
 7-357 . A = B+C;
 7-358 . A = B/C;
 7-359 . A = B+C;
 7-360 . A = B-C;
 7-361 . A = B+C;
 7-362 . A = B+C;
 7-363 . A = B*C;
 7-364 . 
 7-365 . if (A <  B)
 7-366 . {
 7-367 .    A = B + C;
 7-368 .    D = E + F;
 7-369 . }
 7-370 . 
 7-371 . A = B*C;
 7-372 . A = B+C;
 7-373 . A = B+C;
 7-374 . /* LE SV TOC-2539 this is a pwr-07.3.28 req to convert*/
 7-375 . A = B*C;
 7-376 . 
 7-377 . if (A != B)
 7-378 . {
 7-379 .    A = B + C;
 7-380 .    D = E + F;
 7-381 . }
 7-382 . 
 7-383 . 
 7-384 . if (A ne B)
 7-385 . {
 7-386 .    A = B + C;
 7-387 .    D = E + F;
 7-388 . }
 7-389 . 
 7-390 . A = B-C;
 7-391 . 
 7-392 . if (A ge B)
 7-393 . {
 7-394 .    A = B + C;
 7-395 .    D = E + F;
 7-396 . }
 7-397 . 
 7-398 . A = B/C;
 7-399 . A = B*C;
 7-400 . 
 7-401 . if (A le B)
 7-402 . {
 7-403 .    A = B + C;
 7-404 .    D = E + F;
 7-405 . }
 7-406 . 
 7-407 . A = B/C;
 7-408 . A = B-C;
 7-409 . A = B/C;
 7-410 . 
 7-411 . switch (pwr stuff)
 7-412 . {
 7-413 .    case:
 7-414 .    case:
 7-415 .    // stacked case statements but only if there is a new line in between
 7-416 . 
 7-417 .    case:
 7-418 .    case:
 7-419 .    case:
 7-420 .    {
 7-421 .       run_this;
 7-422 .       break;
 7-423 .    }
 7-424 .    default:
 7-425 .    {
 7-426 .       halt;
 7-427 .    }
 7-428 . }
 7-429 . 
 7-430 . A = B*C;
 7-431 . A = B/C;
 7-432 . // max LOC 40
 7-433 . 
 7-434 . }
 7-435 . 
 7-436 . 
 7-437 . /*
 7-438 . -----------------------------------------------------------------------------
 7-439 . --| NAME:   pwr.7.4
 7-440 . --|
 7-441 . --| ABSTRACT:
 7-442 . --|   This function does pwr stuff.
 7-443 . --|
 7-444 . --| RETURNS:
 7-445 . --|   NONE.
 7-446 . --|
 7-447 . ----------------------------------------------------------------------------
 7-448 . */
 7-449 . static void pwr.7.4(void)
 7-450 . {
 7-451 . A = B*C;
 7-452 . 
 7-453 . switch (pwr stuff)
 7-454 . {
 7-455 .    case one:
 7-456 .    {
 7-457 .       switch (nested)
 7-458 .       {
 7-459 .          case:
 7-460 .             X = Y + Z;
 7-461 .          case:
 7-462 .             X = Y + Z;
 7-463 .          default:
 7-464 .             SwError;
 7-465 .       } 
 7-466 .    }
 7-467 .    case two:
 7-468 .    {
 7-469 .       run_this;
 7-470 .       break;
 7-471 .    }
 7-472 .    default:
 7-473 .    {
 7-474 .       SwError;
 7-475 .    }
 7-476 . }
 7-477 . 
 7-478 . A = B+C;
 7-479 . A = B*C;
 7-480 . A = B/C;
 7-481 . 
 7-482 . if (A le B)
 7-483 . {
 7-484 .    A = B + C;
 7-485 .    D = E + F;
 7-486 . }
 7-487 . 
 7-488 . 
 7-489 . if (A == B)
 7-490 . {
 7-491 .    A = B + C;
 7-492 .    D = E + F;
 7-493 . }
 7-494 . 
 7-495 . A = B/C;
 7-496 . 
 7-497 . if (A ge B)
 7-498 . {
 7-499 .    A = B + C;
 7-500 .    D = E + F;
 7-501 . }
 7-502 . 
 7-503 . A = B*C;
 7-504 . A = B-C;
 7-505 . // max LOC 10
 7-506 . 
 7-507 . }
 7-508 . 
 7-509 . 
 7-510 . /*
 7-511 . -----------------------------------------------------------------------------
 7-512 . --| NAME:   pwr.7.5
 7-513 . --|
 7-514 . --| ABSTRACT:
 7-515 . --|   This function does pwr stuff.
 7-516 . --|
 7-517 . --| RETURNS:
 7-518 . --|   NONE.
 7-519 . --|
 7-520 . ----------------------------------------------------------------------------
 7-521 . */
 7-522 . static void pwr.7.5(void)
 7-523 . {
 7-524 . A = B+C;
 7-525 . 
 7-526 . if (A lt B)
 7-527 . {
 7-528 .    A = B + C;
 7-529 .    D = E + F;
 7-530 . }
 7-531 . 
 7-532 . 
 7-533 . switch (pwr stuff)
 7-534 . {
 7-535 .    case one:
 7-536 .    {
 7-537 .       run_this;
 7-538 .       break;
 7-539 .    }
 7-540 .    case two:
 7-541 .    {
 7-542 .       run_this;
 7-543 .       break;
 7-544 .    }
 7-545 .    // missing default
 7-546 . }
 7-547 . 
 7-548 . A = B/C;
 7-549 . A = 0x0007;
 7-550 . A = B+C;
 7-551 . 
 7-552 . if (A lt B)
 7-553 . {
 7-554 .    A = B + C;
 7-555 .    D = E + F;
 7-556 . }
 7-557 . 
 7-558 . 
 7-559 . if (A gt B)
 7-560 . {
 7-561 .    A = B + C;
 7-562 .    D = E + F;
 7-563 . }
 7-564 . 
 7-565 . 
 7-566 . if (A ge B)
 7-567 . {
 7-568 .    A = B + C;
 7-569 .    D = E + F;
 7-570 . }
 7-571 . 
 7-572 . A = B/C;
 7-573 . A = B-C;
 7-574 . A = B/C;
 7-575 . A = B-C;
 7-576 . A = (int)B + C;
 7-577 . A = B+C;
 7-578 . /* LE SV TOC-2540 this is a pwr-07.5.13 req to check unix*/
 7-579 . A = B+C;
 7-580 . 
 7-581 . if (A lt B)
 7-582 . {
 7-583 .    A = B + C;
 7-584 .    D = E + F;
 7-585 . }
 7-586 . 
 7-587 . 
 7-588 . if (A le B)
 7-589 . {
 7-590 .    A = B + C;
 7-591 .    D = E + F;
 7-592 . }
 7-593 . 
 7-594 . 
 7-595 . if (A != B)
 7-596 . {
 7-597 .    A = B + C;
 7-598 .    D = E + F;
 7-599 . }
 7-600 . 
 7-601 . A = B+C;
 7-602 . 
 7-603 . if (A == B)
 7-604 . {
 7-605 .    A = B + C;
 7-606 .    D = E + F;
 7-607 . }
 7-608 . 
 7-609 . A = B+C;
 7-610 . /* LE SV TOC-2541 this is a pwr-07.5.20 req to convert*/
 7-611 . A = B+C;
 7-612 . A = B+C;
 7-613 . A = B+C;
 7-614 . 
 7-615 . switch (pwr stuff)
 7-616 . {
 7-617 .       case one:
 7-618 .    {
 7-619 .       run_this;
 7-620 .       break;
 7-621 .    }
 7-622 .    case two:
 7-623 .    {
 7-624 .       run_this;
 7-625 .       break;
 7-626 .    }
 7-627 .    default:
 7-628 .    {
 7-629 .       // missing error call
 7-630 .    }
 7-631 . }
 7-632 . 
 7-633 . A = B/C;
 7-634 . /* LE SV TOC-2542 this is a pwr-07.5.24 req to recover*/
 7-635 . 
 7-636 . if (A gt B)
 7-637 . {
 7-638 .    A = B + C;
 7-639 .    D = E + F;
 7-640 . }
 7-641 . 
 7-642 . A = B*C;
 7-643 . A = B-C;
 7-644 . A = B/C;
 7-645 . 
 7-646 . #ifdef LAZY
 7-647 .    // this is not nice
 7-648 .    A = B + C;
 7-649 .    A = B + C;
 7-650 . #endif
 7-651 . 
 7-652 . A = B/C;
 7-653 . A = B*C;
 7-654 . 
 7-655 . if (A gt B)
 7-656 . {
 7-657 .    A = B + C;
 7-658 .    D = E + F;
 7-659 . }
 7-660 . 
 7-661 . A = B-C;
 7-662 . 
 7-663 . if (A ne B)
 7-664 . {
 7-665 .    A = B + C;
 7-666 .    D = E + F;
 7-667 . }
 7-668 . 
 7-669 . A = B/C;
 7-670 . A = B+C;
 7-671 . A = B-C;
 7-672 . 
 7-673 . if (A > = B)
 7-674 . {
 7-675 .    A = B + C;
 7-676 .    D = E + F;
 7-677 . }
 7-678 . 
 7-679 . A = B-C;
 7-680 . A = B/C;
 7-681 . 
 7-682 . if (A < = B)
 7-683 . {
 7-684 .    A = B + C;
 7-685 .    D = E + F;
 7-686 . }
 7-687 . 
 7-688 . 
 7-689 . if (A lt B)
 7-690 . {
 7-691 .    A = B + C;
 7-692 .    D = E + F;
 7-693 . }
 7-694 . 
 7-695 . A = B/C;
 7-696 . 
 7-697 . if (A > = B)
 7-698 . {
 7-699 .    A = B + C;
 7-700 .    D = E + F;
 7-701 . }
 7-702 . 
 7-703 . A = B-C;
 7-704 . A = B+C;
 7-705 . A = B/C;
 7-706 . /* LE SV TOC-2543 this is a pwr-07.5.46 req to set Real Time Clock*/
 7-707 . A = B+C;
 7-708 . A = B+C;
 7-709 . A = B*C;
 7-710 . 
 7-711 . if (A eq B)
 7-712 . {
 7-713 .    A = B + C;
 7-714 .    D = E + F;
 7-715 . }
 7-716 . 
 7-717 . A = B+C;
 7-718 . A = B+C;
 7-719 . A = B/C;
 7-720 . goto error;
 7-721 . 
 7-722 . if (A le B)
 7-723 . {
 7-724 .    A = B + C;
 7-725 .    D = E + F;
 7-726 . }
 7-727 . 
 7-728 . A = B+C;
 7-729 . A = B+C;
 7-730 . 
 7-731 . if (A gt B)
 7-732 . {
 7-733 .    A = B + C;
 7-734 .    D = E + F;
 7-735 . }
 7-736 . 
 7-737 . A = B*C;
 7-738 . A = B-C;
 7-739 . A = 0x0001;
 7-740 . A = B-C;
 7-741 . A = B+C;
 7-742 . A = B*C;
 7-743 . A = B-C;
 7-744 . A = B*C;
 7-745 . 
 7-746 . if (A != B)
 7-747 . {
 7-748 .    A = B + C;
 7-749 .    D = E + F;
 7-750 . }
 7-751 . 
 7-752 . 
 7-753 . if (A >  B)
 7-754 . {
 7-755 .    A = B + C;
 7-756 .    D = E + F;
 7-757 . }
 7-758 . 
 7-759 . A = B*C;
 7-760 . 
 7-761 . if (A == B)
 7-762 . {
 7-763 .    A = B + C;
 7-764 .    D = E + F;
 7-765 . }
 7-766 . 
 7-767 . 
 7-768 . /* dead_block = C * D; 
 7-769 . dead_block = E * F; */
 7-770 . 
 7-771 . A = B/C;
 7-772 . A = B-C;
 7-773 . 
 7-774 . if (A le B)
 7-775 . {
 7-776 .    A = B + C;
 7-777 .    D = E + F;
 7-778 . }
 7-779 . 
 7-780 . rcv_buffer = (U16 *) alloc(size+1);
 7-781 . 
 7-782 . if (A gt B)
 7-783 . {
 7-784 .    A = B + C;
 7-785 .    D = E + F;
 7-786 . }
 7-787 . 
 7-788 . // max LOC 71
 7-789 . 
 7-790 . }
 7-791 . 
 7-792 . 
 7-793 . /*
 7-794 . -----------------------------------------------------------------------------
 7-795 . --| NAME:   pwr.7.6
 7-796 . --|
 7-797 . --| ABSTRACT:
 7-798 . --|   This function does pwr stuff.
 7-799 . --|
 7-800 . --| RETURNS:
 7-801 . --|   NONE.
 7-802 . --|
 7-803 . ----------------------------------------------------------------------------
 7-804 . */
 7-805 . static void pwr.7.6(void)
 7-806 . {
 7-807 . A = B+C;
 7-808 . 
 7-809 . #ifdef LAZY
 7-810 .    // this is not nice
 7-811 .    A = B + C;
 7-812 .    A = B + C;
 7-813 . #endif
 7-814 . 
 7-815 . A = B*C;
 7-816 . A = 0x0007;
 7-817 . 
 7-818 . if (A le B)
 7-819 . {
 7-820 .    A = B + C;
 7-821 .    D = E + F;
 7-822 . }
 7-823 . 
 7-824 . A = B*C;
 7-825 . A = B+C;
 7-826 . /* LE SV TOC-2544 this is a pwr-07.6.6 req to call admin*/
 7-827 . A = B+C;
 7-828 . 
 7-829 . if (A == B)
 7-830 . {
 7-831 .    A = B + C;
 7-832 .    D = E + F;
 7-833 . }
 7-834 . 
 7-835 . // max LOC 7
 7-836 . 
 7-837 . }
 7-838 . 
 7-839 . 
 7-840 . /*
 7-841 . -----------------------------------------------------------------------------
 7-842 . --| NAME:   pwr.7.7
 7-843 . --|
 7-844 . --| ABSTRACT:
 7-845 . --|   This function does pwr stuff.
 7-846 . --|
 7-847 . --| RETURNS:
 7-848 . --|   NONE.
 7-849 . --|
 7-850 . ----------------------------------------------------------------------------
 7-851 . */
 7-852 . static void pwr.7.7(void)
 7-853 . {
 7-854 . A = B*C;
 7-855 . A = B*C;
 7-856 . 
 7-857 . if (A gt B)
 7-858 . {
 7-859 .    A = B + C;
 7-860 .    D = E + F;
 7-861 . }
 7-862 . 
 7-863 . A = B-C;
 7-864 . A = B/C;
 7-865 . 
 7-866 . if (A < = B)
 7-867 . {
 7-868 .    A = B + C;
 7-869 .    D = E + F;
 7-870 . }
 7-871 . 
 7-872 . 
 7-873 . if (A gt B)
 7-874 . {
 7-875 .    A = B + C;
 7-876 .    D = E + F;
 7-877 . }
 7-878 . 
 7-879 . A = B-C;
 7-880 . 
 7-881 . if (A >  B)
 7-882 . {
 7-883 .    A = B + C;
 7-884 .    D = E + F;
 7-885 . }
 7-886 . 
 7-887 . A = B-C;
 7-888 . 
 7-889 . if (A gt B)
 7-890 . {
 7-891 .    A = B + C;
 7-892 .    D = E + F;
 7-893 . }
 7-894 . 
 7-895 . A = B*C;
 7-896 . 
 7-897 . if (A ne B)
 7-898 . {
 7-899 .    A = B + C;
 7-900 .    D = E + F;
 7-901 . }
 7-902 . 
 7-903 . A = B*C;
 7-904 . A = B-C;
 7-905 . 
 7-906 . if (A > = B)
 7-907 . {
 7-908 .    A = B + C;
 7-909 .    D = E + F;
 7-910 . }
 7-911 . 
 7-912 . A = B-C;
 7-913 . 
 7-914 . if {
 7-915 .    X = Y + Z;
 7-916 . }
 7-917 . else {
 7-918 .    halt;
 7-919 . }
 7-920 . 
 7-921 . A = B/C;
 7-922 . 
 7-923 . if (A == B)
 7-924 . {
 7-925 .    A = B + C;
 7-926 .    D = E + F;
 7-927 . }
 7-928 . 
 7-929 . A = 0x0009;
 7-930 . 
 7-931 . if (A gt B)
 7-932 . {
 7-933 .    A = B + C;
 7-934 .    D = E + F;
 7-935 . }
 7-936 . 
 7-937 . A = B*C;
 7-938 . 
 7-939 . if (A le B)
 7-940 . {
 7-941 .    A = B + C;
 7-942 .    D = E + F;
 7-943 . }
 7-944 . 
 7-945 . A = (long)B + C;
 7-946 . 
 7-947 . if (A == B)
 7-948 . {
 7-949 .    A = B + C;
 7-950 .    D = E + F;
 7-951 . }
 7-952 . 
 7-953 . A = B/C;
 7-954 . 
 7-955 . if (A ne B)
 7-956 . {
 7-957 .    A = B + C;
 7-958 .    D = E + F;
 7-959 . }
 7-960 . 
 7-961 . A = B/C;
 7-962 . A = B/C;
 7-963 . 
 7-964 . if (A == B)
 7-965 . {
 7-966 .    A = B + C;
 7-967 .    D = E + F;
 7-968 . }
 7-969 . 
 7-970 . 
 7-971 . if (A != B)
 7-972 . {
 7-973 .    A = B + C;
 7-974 .    D = E + F;
 7-975 . }
 7-976 . 
 7-977 . 
 7-978 . if (A eq B)
 7-979 . {
 7-980 .    A = B + C;
 7-981 .    D = E + F;
 7-982 . }
 7-983 . 
 7-984 . A = 0x0001;
 7-985 . 
 7-986 . if (A gt B)
 7-987 . {
 7-988 .    A = B + C;
 7-989 .    D = E + F;
 7-990 . }
 7-991 . 
 7-992 . A = B-C;
 7-993 . // max LOC 32
 7-994 . 
 7-995 . }
 7-996 . 
 7-997 . 
 7-998 . /*
 7-999 . -----------------------------------------------------------------------------
 7-1000 . --| NAME:   pwr.7.8
 7-1001 . --|
 7-1002 . --| ABSTRACT:
 7-1003 . --|   This function does pwr stuff.
 7-1004 . --|
 7-1005 . --| RETURNS:
 7-1006 . --|   NONE.
 7-1007 . --|
 7-1008 . ----------------------------------------------------------------------------
 7-1009 . */
 7-1010 . static void pwr.7.8(void)
 7-1011 . {
 7-1012 . A = (float)B + C;
 7-1013 . A = B+C;
 7-1014 . 
 7-1015 . if (A < = B)
 7-1016 . {
 7-1017 .    A = B + C;
 7-1018 .    D = E + F;
 7-1019 . }
 7-1020 . 
 7-1021 . A = B-C;
 7-1022 . A = B+C;
 7-1023 . A = B+C;
 7-1024 . A = B*C;
 7-1025 . 
 7-1026 . if (A == B)
 7-1027 . {
 7-1028 .    A = B + C;
 7-1029 .    D = E + F;
 7-1030 . }
 7-1031 . 
 7-1032 . 
 7-1033 . if (A == B)
 7-1034 . {
 7-1035 .    A = B + C;
 7-1036 .    D = E + F;
 7-1037 . }
 7-1038 . 
 7-1039 . A = B/C;
 7-1040 . A = B*C;
 7-1041 . A = B-C;
 7-1042 . A = B-C;
 7-1043 . A = B*C;
 7-1044 . A = B+C;
 7-1045 . A = B+C;
 7-1046 . 
 7-1047 . if (A eq B)
 7-1048 . {
 7-1049 .    A = B + C;
 7-1050 .    D = E + F;
 7-1051 . }
 7-1052 . 
 7-1053 . A = B*C;
 7-1054 . /* LE SV TOC-2545 this is a pwr-07.8.18 req to transform*/
 7-1055 . 
 7-1056 . if (A == B)
 7-1057 . {
 7-1058 .    A = B + C;
 7-1059 .    D = E + F;
 7-1060 . }
 7-1061 . 
 7-1062 . 
 7-1063 . if (A > = B)
 7-1064 . {
 7-1065 .    A = B + C;
 7-1066 .    D = E + F;
 7-1067 . }
 7-1068 . 
 7-1069 . A = B*C;
 7-1070 . A = B+C;
 7-1071 . /* LE SV TOC-2546 this is a pwr-07.8.22 req to detect error*/
 7-1072 . A = B-C;
 7-1073 . A = B+C;
 7-1074 . 
 7-1075 . if (A lt B)
 7-1076 . {
 7-1077 .    A = B + C;
 7-1078 .    D = E + F;
 7-1079 . }
 7-1080 . 
 7-1081 . A = B/C;
 7-1082 . 
 7-1083 . if (A < = B)
 7-1084 . {
 7-1085 .    A = B + C;
 7-1086 .    D = E + F;
 7-1087 . }
 7-1088 . 
 7-1089 . // max LOC 26
 7-1090 . 
 7-1091 . }
 7-1092 . 

7 7 Result: result/source/pr-app/pr-app-PWR123/pwr-07.c

8 8 Source: source/pr-app/pr-app-PWR123/pwr-08.c
 8-0 . /*
 8-1 . ----------------------------------------------------------------------------
 8-2 . --| BEGIN PROLOGUE
 8-3 . --|
 8-4 . --| CLASSIFICATION: UNCLASSIFIED
 8-5 . --|
 8-6 . --| FILE NAME:      pwr-08.c
 8-7 . --|
 8-8 . --| ABSTRACT:
 8-9 . --|   This file contains the 1 functions that do file pwr stuff.
 8-10 . --|
 8-11 . --| HISTORY:
 8-12 . --|   CCCQ_NAME:
 8-13 . --|   CCCQ_VER: 
 8-14 . --|
 8-15 . --| END PROLOGUE
 8-16 . ----------------------------------------------------------------------------
 8-17 . */
 8-18 . 
 8-19 . double C;
 8-20 . char D;
 8-21 . #define D;
 8-22 . #define A;
 8-23 . 
 8-24 . 
 8-25 . 
 8-26 . /*
 8-27 . -----------------------------------------------------------------------------
 8-28 . --| NAME:   pwr.8.1
 8-29 . --|
 8-30 . --| ABSTRACT:
 8-31 . --|   This function does pwr stuff.
 8-32 . --|
 8-33 . --| RETURNS:
 8-34 . --|   NONE.
 8-35 . --|
 8-36 . ----------------------------------------------------------------------------
 8-37 . */
 8-38 . static void pwr.8.1(void)
 8-39 . {
 8-40 . 
 8-41 . if (A ge B)
 8-42 . {
 8-43 .    A = B + C;
 8-44 .    D = E + F;
 8-45 . }
 8-46 . 
 8-47 . A = B+C;
 8-48 . A = B/C;
 8-49 . A = B-C;
 8-50 . A = B/C;
 8-51 . A = (long)B + C;
 8-52 . 
 8-53 . if (A != B)
 8-54 . {
 8-55 .    A = B + C;
 8-56 .    D = E + F;
 8-57 . }
 8-58 . 
 8-59 . A = 0x0001;
 8-60 . 
 8-61 . if (A > = B)
 8-62 . {
 8-63 .    A = B + C;
 8-64 .    D = E + F;
 8-65 . }
 8-66 . 
 8-67 . A = B+C;
 8-68 . A = B+C;
 8-69 . A = B/C;
 8-70 . 
 8-71 . if (A eq B)
 8-72 . {
 8-73 .    A = B + C;
 8-74 .    D = E + F;
 8-75 . }
 8-76 . 
 8-77 . 
 8-78 . if (A gt B)
 8-79 . {
 8-80 .    A = B + C;
 8-81 .    D = E + F;
 8-82 . }
 8-83 . 
 8-84 . A = B/C;
 8-85 . A = B/C;
 8-86 . A = B-C;
 8-87 . A = B-C;
 8-88 . A = B/C;
 8-89 . A = B+C;
 8-90 . 
 8-91 . /*
 8-92 . dead_block = C * D; 
 8-93 . dead_block = E * F;
 8-94 . */
 8-95 . 
 8-96 . A = B-C;
 8-97 . 
 8-98 . if (A > = B)
 8-99 . {
 8-100 .    A = B + C;
 8-101 .    D = E + F;
 8-102 . }
 8-103 . 
 8-104 . A = B+C;
 8-105 . rcv_buffer = (U16 *) alloc(size+1);
 8-106 . A = B-C;
 8-107 . A = B-C;
 8-108 . 
 8-109 . /* 
 8-110 . dead_code = B - C; 
 8-111 . dead_code = D - E; 
 8-112 . dead_code = F - G;
 8-113 . */
 8-114 . 
 8-115 . A = B-C;
 8-116 . A = B-C;
 8-117 . A = B*C;
 8-118 . A = B*C;
 8-119 . A = B/C;
 8-120 . A = B-C;
 8-121 . 
 8-122 . if (A gt B)
 8-123 . {
 8-124 .    A = B + C;
 8-125 .    D = E + F;
 8-126 . }
 8-127 . 
 8-128 . A = B*C;
 8-129 . A = B+C;
 8-130 . A = B-C;
 8-131 . A = B/C;
 8-132 . A = B/C;
 8-133 . A = B/C;
 8-134 . A = 0x0001;
 8-135 . A = B+C;
 8-136 . A = B*C;
 8-137 . A = B*C;
 8-138 . 
 8-139 . if (A ne B)
 8-140 . {
 8-141 .    A = B + C;
 8-142 .    D = E + F;
 8-143 . }
 8-144 . 
 8-145 . A = B+C;
 8-146 . // ??? go see ws
 8-147 . 
 8-148 . if (A != B)
 8-149 . {
 8-150 .    A = B + C;
 8-151 .    D = E + F;
 8-152 . }
 8-153 . 
 8-154 . 
 8-155 . if (A lt B)
 8-156 . {
 8-157 .    A = B + C;
 8-158 .    D = E + F;
 8-159 . }
 8-160 . 
 8-161 . A = B-C;
 8-162 . A = B/C;
 8-163 . A = B-C;
 8-164 . A = B+C;
 8-165 . A = B+C;
 8-166 . A = B*C;
 8-167 . A = B*C;
 8-168 . A = B+C;
 8-169 . 
 8-170 . if (A gt B)
 8-171 . {
 8-172 .    A = B + C;
 8-173 .    D = E + F;
 8-174 . }
 8-175 . 
 8-176 . 
 8-177 . if (A ge B)
 8-178 . {
 8-179 .    A = B + C;
 8-180 .    D = E + F;
 8-181 . }
 8-182 . 
 8-183 . A = B-C;
 8-184 . A = B-C;
 8-185 . A = B*C;
 8-186 . /* LE SV TOC-2547 this is a pwr-08.1.57 req to set RTC*/
 8-187 . A = B/C;
 8-188 . A = B-C;
 8-189 . A = B*C;
 8-190 . A = B-C;
 8-191 . 
 8-192 . if (A > = B)
 8-193 . {
 8-194 .    A = B + C;
 8-195 .    D = E + F;
 8-196 . }
 8-197 . 
 8-198 . 
 8-199 . if (A le B)
 8-200 . {
 8-201 .    A = B + C;
 8-202 .    D = E + F;
 8-203 . }
 8-204 . 
 8-205 . 
 8-206 . if (A != B)
 8-207 . {
 8-208 .    A = B + C;
 8-209 .    D = E + F;
 8-210 . }
 8-211 . 
 8-212 . A = B*C;
 8-213 . A = B-C;
 8-214 . // max LOC 65
 8-215 . 
 8-216 . }
 8-217 . 

8 8 Result: result/source/pr-app/pr-app-PWR123/pwr-08.c
Settings

Hide Controls Show Checked Summary Checked Details Not Checked All
done
12/08/2003 16:12:05 start
12/08/2003 16:12:11 end