(declare (salience -100))
              (inspect eng run)
         =>
              (printout t " " crlf)
              (printout t "Is the radiator showing any leaks?" crlf)
              (printout t " " crlf)
              (bind ?prlk (read))
              (assert (final road test))
              (assert (pleak ?prlk)))



         (defrule eng14-1
              (inspect eng run)
         =>
              (printout t " " crlf)
              (printout t "What color is the exhaust?" crlf
              "NONE" crlf "WHITE" crlf "BLACK" crlf "BLUE" crlf)
              (printout t " " crlf)
              (bind ?color (read))
              (assert (smoke ?color)))


         ;-----------------------------------------------------------



         (defrule eng15
              ?leak <- (pleak ?prlk)
              (test (eq ?prlk yes))
         =>
              (assert (HIGH PRESSURE RADIATOR LEAK))
              (retract ?leak))



         (defrule eng17
              ?eng <- (rough ?rogh)
              (test (eq ?rogh yes))








         =>
              (assert (ENGINE IDLE PROBLEM))
              (retract ?eng))


         (defrule eng19
              ?clutch <- (clstall ?stall)
              (test (eq ?stall no))
         =>
              (assert (WORN CLUTCH))
              (retract ?clutch))


         (defrule eng21
              ?clutch <- (clgrnd ?clgr)
              (test (eq ?clgr yes))
         =>
              (assert (WORN THROUGH OUT BEARING))
              (retract ?clutch))


         (defrule eng23
              ?breaks <- (blsink ?sink)
              (test (eq ?sink yes))
         =>
              (assert (BREAKS FADE STATIC))
              (retract ?breaks))


         (defrule eng25
              ?lights <- (trnsig ?tnsl)
              (test (eq ?tnsl no))
         =>
              (assert (TURN SIGNALS OUT))
              (retract ?lights))


         (defrule eng27
              ?lights <- (bkhght ?blgt)
              (test (eq ?blgt no))
         =>
              (assert (BREAK LIGHTS OUT))
              (retract ?lights))


         (defrule eng29
              ?lights <- (hdhght ?hlgt)
              (test (eq ?hlgt no))
         =>
              (assert (HEAD LIGHTS OUT))
              (retract ?lights))











         (defrule eng31
              ?eng <- (wrmeng ?warm)
              (test (eq ?warm yes))
         =>
              (assert (ENGINE RUN BEFORE INSPECTION))
              (retract ?eng))


         (defrule eng33
              ?gauge <- (gauges ?gage)
              (test (eq ?gage no))
         =>
              (assert (GAUGES SHOW PROBLEM))
              (retract ?gauge))


         (defrule eng35
              ?eng <- (noisec ?clunk)
              (test (eq ?clunk yes))
         =>
              (assert (LOWER ENGINE PROBLEM))
              (retract ?eng))


         (defrule eng37
              ?eng <- (noiset ?tick)
              (test (eq ?tick yes))
         =>
              (assert (UPPER ENGINE PROBLEM))
              (retract ?eng))


         (defrule eng39
              ?exhst <- (exhstf ?fume)
              (test (eq ?fume yes))
         =>
              (assert (EXHAUST LEAK INTO CABIN))
              (retract ?exhst))



         (defrule eng41
              ?steer <- (swjump ?jump)
              (test (eq ?jump yes))
         =>
              (assert (STEERING JUMPS))
              (retract ?steer))


         (defrule eng43
              ?xhaus <- (smoke ?color)
              (test (eq ?color WHITE))
         =>
              (assert (WATER IN EXHAUST GAS))










              (retract ?xhaus))


         (defrule eng44
              ?xhaus <- (smoke ?color)
              (test (eq ?color BLACK))
         =>
              (assert (CARBON IN EXHAUST GAS))
              (retract ?xhaus))


         (defrule eng45
              ?xhaus <- (smoke ?color)
              (test (eq ?color BLUE))
         =>
              (assert (OIL IN EXHAUST GAS))
              (retract ?xhaus))


         (defrule eng47
              ?xhaus <- (smoke ?color)
              (test (eq ?color NONE))
         =>
              (retract ?xhaus))


         (defrule road1
              (final road test)
         =>
              (bind ?count 0)
              (while (<= ?count 20)
                 (printout t " " crlf)
                 (bind ?count (+ ?count 1)))
         (printout t "We now begin the final portion of the inspection"
              crlf)
         (printout t crlf)
         (printout t "                THE ROAD TEST" crlf crlf)
         (printout t "If you feel the car is safe enough at this point,"
              crlf)
         (printout t "take it on the road and try to answer the" crlf)
         (printout t "following questions." crlf)
              (bind ?count 0)
              (while (<= ?count 10)
                 (printout t " " crlf)
                 (bind ?count (+ ?count 1))))


         (defrule road2
              (final road test)
         =>
              (printout t crlf)
              (printout t "Does the car pull to the left or right?"
                  crlf)
              (printout t crlf)








              (bind ?pull (read))
              (assert (pulls ?pull)))


         (defrule road3
              (final road test)
         =>
              (printout t crlf)
              (printout t "When you hit the brakes, do they:" crlf)
              (printout t crlf)
              (printout t "PULL " crlf
                        "SQUEEL" crlf
                        "GRAB" crlf
                        "SINK" crlf
                        "NORMAL" crlf)
              (printout t crlf)
              (bind ?brek (read))
              (assert (break ?brek)))


         (defrule road4
              (final road test)
         =>
              (printout t crlf)
              (printout t "Do whining noises come from the rear" crlf
                       "of the car at various speeds" crlf)
              (printout t crlf)
              (bind ?rend (read))
              (assert (reare ?rend)))


         (defrule road5
              (final road test)
              (options tran yes)
         =>
              (printout t crlf)
              (printout t "Is there a clunking sound when the " crlf
                 "transmission is put in gear?" crlf)
              (printout t crlf)
              (bind ?tran (read))
              (assert (clunk ?tran)))


         (defrule road6
              (final road test)
         =>
              (printout t crlf)
              (printout t "Is the car overheating, steam from the" crlf
                  "hood, temp gauge reading too high?" crlf)
              (printout t crlf)
              (bind ?heat (read))
              (assert (oheat ?heat)))











         (defrule road7
              (declare (salience -100))
              ?final <- (final road test)
         =>
              (retract ?final)
              (printout t crlf)
              (printout t "Is there a vibration that increases as" crlf
                  "your speed increases?" crlf)
              (printout t crlf)
              (bind ?vibe (read))
              (assert (compile the problems))
              (assert (vibes ?vibe)))



         (defrule road8
              ?puller <- (pulls ?pull)
              (test (eq ?pull yes))
         =>
              (assert (CAR PULLS TO SIDE))
              (retract ?puller))


         (defrule road9
              ?breaks <- (break ?brek)
              (test (eq ?brek pull))
         =>
              (assert (BREAKS PULL TO ONE SIDE))
              (retract ?breaks))


         (defrule road10
              ?breaks <- (break ?brek)
              (test (eq ?brek grab))
         =>
              (assert (BREAKS GRAB))
              (retract ?breaks))


         (defrule road11
              ?breaks <- (break ?brek)
              (test (eq ?brek squeel))
         =>
              (assert (BREAKS MAY NEED REPLACING))
              (retract ?breaks))


         (defrule road12
              ?breaks <- (break ?brek)
              (test (eq ?brek sink))
         =>
              (assert (MAJOR BREAK SYSTEM PROBLEM))
              (retract ?breaks))








         (defrule road13
              ?breaks <- (break ?brek)
              (test (eq ?brek normal))
         =>
              (retract ?breaks))


         (defrule road14
              ?rerend <- (reare ?rend)
              (test (eq ?rend yes))
         =>
              (assert (PROBLEM WITH THIRD MEMBER))
              (retract ?rerend))


         (defrule road15
              ?ujoint <- (clunk ?tran)
              (test (eq ?tran yes))
         =>
              (assert (FAILING UJOINTS))
              (retract ?ujoint))


         (defrule road16
              ?overht <- (oheat ?heat)
              (test (eq ?heat yes))
         =>
              (assert (MAJOR COOLING SYSTEM FAILURE))
              (retract ?overht))


         (defrule road17
              ?frntnd <- (vibes ?vibe)
              (test (eq ?vibe yes))
         =>
              (assert (POSSIBLE TIRE OUT OF BALANCE))
              (retract ?frntnd))


         (defrule compile1
              (declare (salience 100))
              (compile the problems)
         =>
              (bind ?value 0)
              (assert (estimated total ?value))
              (bind ?count 0)
              (while (<= ?count 20)
                 (printout t " " crlf)
                 (bind ?count (+ ?count 1)))
              (printout t "The question and answer phase is now over"
             crlf crlf "I will now take the info you gave me and "
             crlf crlf "determine the problems with the car." crlf
             crlf "After each problem identified is a number. This"
             crlf crlf "value rates the seriousness of the problem."








             crlf crlf "If the values total 100 or more, the" crlf
             crlf "recommendation is don't buy the car" crlf crlf
              "Hit <cr> to proceed." crlf)
              (bind ?answer (readline))
              (bind ?count 0)
              (while (<= ?count 20)
                 (printout t " " crlf)
                 (bind ?count (+ ?count 1))))



         (defrule compile1-1
              ?val <- (estimated value ?num)
              ?tot <- (estimated total ?tot-num)
         =>
              (retract ?val ?tot)
              (assert (estimated total =(+ ?num ?tot-num))))