auxfns.lisp,2974 (defun requires requires34,1211 (defvar *paip-files**paip-files*38,1344 (defparameter *paip-directory**paip-directory*48,1858 (defparameter *paip-source* *paip-source*55,2185 (defparameter *paip-binary**paip-binary*59,2313 (defun paip-pathname paip-pathname73,2762 (defun compile-all-paip-files compile-all-paip-files79,2950 (defun compile-paip-file compile-paip-file82,3027 (defun load-paip-file load-paip-file87,3187 (defun find-all find-all155,5340 (defun partition-if partition-if165,5765 (defun maybe-add maybe-add176,6099 (defun seq-ref seq-ref186,6425 (defun maybe-set-fill-pointer maybe-set-fill-pointer194,6669 (defun symbol symbol209,7320 (defun new-symbol new-symbol213,7449 (defun last1 last1217,7589 (defun mappend mappend223,7726 (defun mklist mklist228,7900 (defun flatten flatten232,8010 (defun random-elt random-elt236,8109 (defun member-equal member-equal242,8251 (defun compose compose247,8356 (defvar *dbg-ids* *dbg-ids*253,8509 (defun dbg dbg255,8559 (defun debug debug261,8771 (defun undebug undebug265,8878 (defun dbg-indent dbg-indent272,9095 (defconstant fail fail281,9411 (defconstant no-bindings no-bindings282,9434 (defun pat-match pat-match284,9472 (defun match-variable match-variable294,9931 (defun make-binding make-binding301,10230 (defun binding-var binding-var303,10277 (defun binding-val binding-val307,10371 (defun get-binding get-binding311,10462 (defun lookup lookup315,10575 (defun extend-bindings extend-bindings319,10703 (defun variable-p variable-p328,10987 (defmacro defun-memo defun-memo336,11186 (defun memo memo340,11301 (defun memoize memoize351,11703 (defun clear-memoize clear-memoize358,11977 (defstruct delay delay365,12155 (defmacro delay delay367,12196 (defun force force371,12327 (defmacro defresource defresource380,12613 (defmacro with-resource with-resource400,13478 (defun queue-contents queue-contents416,14015 (defun make-queue make-queue418,14051 (defun enqueue enqueue423,14165 (defun dequeue dequeue430,14313 (defun front front436,14441 (defun empty-queue-p empty-queue-p438,14487 (defun queue-nconc queue-nconc440,14540 (defun sort* sort*447,14696 (defun reuse-cons reuse-cons451,14809 (defun length=1 length=1459,15016 (defun rest3 rest3463,15101 (defun unique-find-if-anywhere unique-find-if-anywhere469,15229 (defun find-if-anywhere find-if-anywhere483,15707 (defmacro define-enumerated-type define-enumerated-type492,15990 (defun not-null not-null506,16479 (defun first-or-nil first-or-nil508,16516 (defun first-or-self first-or-self512,16627 (defmacro defmethod defmethod521,16846 (defun map-into map-into526,16953 (defun complement complement572,18765 (defmacro with-compilation-unit with-compilation-unit578,18940 (defun reduce* reduce*595,19493 (defun reduce reduce599,19671 (defun reduce-vect reduce-vect604,19880 (defun reduce-list reduce-list649,21685 clos.lisp,495 (defstruct account account7,205 (defun account-withdraw account-withdraw10,274 (defun account-deposit account-deposit16,466 (defun account-interest account-interest20,580 (defun new-account new-account28,809 (defun get-method get-method46,1471 (defun send send50,1598 (defun withdraw withdraw57,1804 (defmacro define-class define-class63,1977 (defun make-clause make-clause73,2368 (defun ensure-generic-fn ensure-generic-fn77,2526 (defun generic-fn-p generic-fn-p86,2896 cmacsyma.lisp,1446 (defun exp-p exp-p18,486 (defun exp-args exp-args19,514 (defun binary-exp-p binary-exp-p21,545 (deftype polynomial polynomial27,704 (defsetf main-var main-var29,744 (defsetf coef coef32,820 (defun main-var main-var35,900 (defun coef coef36,950 (defun degree degree37,1006 (defun poly poly39,1062 (defun make-poly make-poly44,1203 (defun prefix->canon prefix->canon50,1381 (defun poly+ poly+65,1975 (defun poly- poly-71,2136 (defun var= var=78,2340 (defun var> var>80,2369 (defun poly+poly poly+poly82,2403 (defun k+poly k+poly92,2756 (defun poly+same poly+same101,3099 (defun copy-poly copy-poly112,3504 (defun poly*poly poly*poly116,3572 (defun k*poly k*poly126,3930 (defun poly*same poly*same140,4425 (defun normalize-poly normalize-poly154,4984 (defun deriv-poly deriv-poly166,5402 (defun prefix->infix prefix->infix196,6611 (defun intersperse intersperse205,6845 (defun canon->prefix canon->prefix214,7098 (defun exponent->prefix exponent->prefix227,7509 (defun args->prefix args->prefix234,7673 (defun canon canon247,8200 (defun canon-simplifier canon-simplifier251,8358 (defun poly^n poly^n257,8506 (defun p-add-into! p-add-into!290,9910 (defun make-rat make-rat301,10304 (defun rat-numerator rat-numerator307,10506 (defun rat-denominator rat-denominator314,10658 (defun rat*rat rat*rat321,10814 (defun rat+rat rat+rat328,11056 (defun rat/rat rat/rat338,11393 compile1.lisp,601 (defun comp comp9,262 (defun comp-begin comp-begin29,1072 (defun comp-if comp-if39,1408 (defun comp-lambda comp-lambda53,1792 (defvar *label-num* *label-num*67,2302 (defun compiler compiler69,2326 (defun comp-show comp-show74,2471 (defun gen gen81,2621 (defun seq seq85,2742 (defun gen-label gen-label89,2830 (defun gen-var gen-var95,3013 (defun gen-set gen-set102,3218 (def-scheme-macro define define111,3461 (defun name! name!118,3672 (defun print-fn print-fn127,3913 (defun show-fn show-fn131,4053 (defun label-p label-p149,4663 (defun in-env-p in-env-p151,4709 compile2.lisp,839 (defun comp comp10,318 (defun arg-count arg-count39,1600 (defun comp-begin comp-begin49,1969 (defun comp-list comp-list57,2305 (defun comp-const comp-const65,2524 (defun comp-var comp-var72,2754 (defun comp-if comp-if78,2924 (defun comp-funcall comp-funcall114,4518 (defparameter *primitive-fns**primitive-fns*154,6123 (defun primitive-p primitive-p166,6805 (defun list1 list1175,7189 (defun list2 list2176,7216 (defun list3 list3177,7247 (defun display display178,7282 (defun newline newline179,7312 (defun gen-set gen-set183,7377 (defun init-scheme-comp init-scheme-comp194,7719 (defun comp-lambda comp-lambda204,8067 (defun gen-args gen-args212,8380 (defun make-true-list make-true-list220,8699 (defun new-fn new-fn227,8976 (defun optimize optimize234,9177 (defun assemble assemble235,9206 compile3.lisp,1312 (defun opcode opcode15,481 (defun args args16,546 (defun arg1 arg117,599 (defun arg2 arg218,654 (defun arg3 arg319,708 (defsetf arg1 arg121,764 (defun assemble assemble25,859 (defun asm-first-pass asm-first-pass34,1118 (defun asm-second-pass asm-second-pass44,1388 (defun show-fn show-fn59,1855 (defstruct ret-addr ret-addr80,2630 (defun is is82,2662 (defun top top88,2832 (defun machine machine90,2867 (defun init-scheme-comp init-scheme-comp195,7310 (defconstant scheme-top-levelscheme-top-level211,7930 (defun scheme scheme219,8121 (defun comp-go comp-go224,8244 (defun optimize optimize233,8405 (defun optimize-1 optimize-1247,8822 (defun gen1 gen1270,9555 (defun target target271,9618 (defun next-instr next-instr272,9682 (defmacro def-optimizer def-optimizer276,9783 (defconstant eof eof286,10126 (defun eof-object? eof-object?287,10150 (defvar *scheme-readtable* *scheme-readtable*288,10185 (defun scheme-read scheme-read290,10231 (defparameter *primitive-fns**primitive-fns*328,11355 (defun quasi-q quasi-q345,12010 (defun combine-quasiquote combine-quasiquote366,12733 (defun scheme-read scheme-read380,13263 (defun convert-numbers convert-numbers384,13409 (defun convert-number convert-number397,13897 (defun sign-p sign-p408,14365 compopt.lisp,0 edge-tab.lisp,0 eliza-pm.lisp,73 (defun eliza eliza9,223 (defun use-eliza-rules use-eliza-rules15,373 eliza.lisp,308 (defun read-line-no-punct read-line-no-punct12,306 (defun punctuation-p punctuation-p19,551 (defun eliza eliza23,647 (defun print-with-spaces print-with-spaces32,932 (defun print-with-spaces print-with-spaces35,1017 (defun mappend mappend40,1115 (defparameter *eliza-rules**eliza-rules*46,1293 eliza1.lisp,615 (defun variable-p variable-p11,328 (defun pat-match pat-match15,459 (defun segment-pattern-p segment-pattern-p29,1076 (defun segment-match segment-match36,1271 (defun segment-match segment-match57,2210 (defun rule-pattern rule-pattern80,3179 (defun rule-responses rule-responses81,3220 (defparameter *eliza-rules**eliza-rules*85,3299 (defun eliza eliza107,4114 (defun use-eliza-rules use-eliza-rules113,4274 (defun switch-viewpoint switch-viewpoint122,4633 (defun flatten flatten129,4822 (defun mklist mklist133,4933 (defun mappend mappend139,5038 (defun random-elt random-elt143,5171 examples.lisp,674 (defexamples 1 17,152 (defexamples 2 298,3931 (defexamples 3 3131,5133 (defexamples 4 4223,9130 (defexamples 5 5420,17507 (defexamples 6 6457,19464 (defexamples 7 7538,23589 (defexamples 8 8570,25327 (defexamples 9 9645,28944 (defexamples 10 10665,29685 (defexamples 11 11680,30297 (defexamples 12 12787,34939 (defexamples 13 13796,35308 (defexamples 14 141007,43210 (defexamples 15 151071,45951 (defexamples 16 161098,47244 (defexamples 17 171106,47588 (defexamples 18 181185,50102 (defexamples 19 191241,52653 (defexamples 20 201356,58014 (defexamples 21 211529,64436 (defexamples 22 221543,65015 (defexamples 23 231604,67639 gps-srch.lisp,127 (defun search-gps search-gps9,220 (defun gps-successors gps-successors24,706 (defun applicable-ops applicable-ops35,1027 gps.lisp,1111 (defun executing-p executing-p11,242 (defun starts-with starts-with15,336 (defun convert-op convert-op19,453 (defun op op25,647 (defvar *ops* *ops*37,986 (defstruct op op39,1039 (defun GPS GPS42,1130 (defun achieve-all achieve-all48,1351 (defun achieve achieve58,1749 (defun member-equal member-equal69,2208 (defun apply-op apply-op74,2313 (defun appropriate-p appropriate-p87,2895 (defun use use93,3064 (defparameter *banana-ops**banana-ops*101,3284 (defun make-maze-ops make-maze-ops130,4257 (defun make-maze-op make-maze-op135,4425 (defparameter *maze-ops**maze-ops*142,4635 (defun GPS GPS150,4924 (defun action-p action-p155,5130 (defun find-path find-path161,5285 (defun destination destination169,5588 (defun make-block-ops make-block-ops175,5729 (defun move-op move-op187,6074 (defun move-ons move-ons194,6299 (defun achieve-all achieve-all202,6437 (defun achieve-each achieve-each207,6624 (defun orderings orderings217,7023 (defun achieve achieve224,7149 (defun appropriate-ops appropriate-ops233,7562 (defun permutations permutations244,7992 gps1.lisp,261 (defvar *state* *state*7,213 (defvar *ops* *ops*9,278 (defstruct op op11,331 (defun GPS GPS14,422 (defun achieve achieve18,555 (defun appropriate-p appropriate-p25,795 (defun apply-op apply-op29,922 (defparameter *school-ops**school-ops*39,1249 grammar.lisp,0 interp1.lisp,940 (defun interp interp7,214 (defun set-var! set-var!29,1114 (defun get-var get-var36,1316 (defun set-global-var! set-global-var!42,1501 (defun get-global-var get-global-var45,1571 (defun extend-env extend-env52,1765 (defparameter *scheme-procs**scheme-procs*56,1894 (defun init-scheme-interp init-scheme-interp61,2094 (defun init-scheme-proc init-scheme-proc70,2441 (defun scheme scheme76,2659 (defun interp interp88,3004 (defun scheme-macro scheme-macro115,4067 (defmacro def-scheme-macro def-scheme-macro118,4150 (defun scheme-macro-expand scheme-macro-expand123,4307 (def-scheme-macro let let132,4551 (def-scheme-macro let* let*136,4679 (def-scheme-macro and and142,4845 (def-scheme-macro or or148,5016 (def-scheme-macro cond cond155,5248 (def-scheme-macro case case165,5633 (def-scheme-macro define define176,6014 (def-scheme-macro delay delay182,6191 (def-scheme-macro letrec letrec185,6259 interp2.lisp,66 (defun interp interp9,226 (defun print-proc print-proc54,2189 interp3.lisp,261 (defun interp interp11,295 (defun scheme scheme42,1505 (defun interp-begin interp-begin53,1870 (defun interp-call interp-call61,2186 (defun map-interp map-interp69,2461 (defun init-scheme-proc init-scheme-proc81,2845 (defun call/cc call/cc91,3175 intro.lisp,583 (defun last-name last-name7,215 (defun first-name first-name11,323 (defparameter *titles**titles*22,656 (defun first-name first-name28,833 (defun numbers-and-negations numbers-and-negations38,1081 (defun number-and-negation number-and-negation42,1223 (defun atomprint atomprint50,1391 (defun power power59,1670 (defun count-atoms count-atoms68,1961 (defun count-all-atoms count-all-atoms75,2180 (defun count-anywhere count-anywhere85,2525 (defun dot-product dot-product94,2804 (defun dot-product dot-product101,3001 (defun dot-product dot-product108,3181 krep.lisp,1183 (defparameter *primitives* *primitives*10,324 (defun add-fact add-fact12,376 (defun fact-present-p fact-present-p25,804 (defun run-attached-fn run-attached-fn31,932 (defun index-new-fact index-new-fact37,1123 (defun test-bears test-bears44,1304 (defmacro a a55,1621 (defmacro each each59,1767 (defmacro ?? ??63,1917 (defun translate-exp translate-exp71,2160 (defun replace-?-vars replace-?-vars119,3946 (defvar *world* *world*132,4378 (defun index-in-world index-in-world134,4445 (defun dtree-index-in-world dtree-index-in-world139,4683 (defun nalist-push nalist-push158,5488 (defun get-world get-world175,5960 (defun use-world use-world188,6435 (defun use-new-world use-new-world199,6802 (defun set-world-current set-world-current206,6996 (defun print-world print-world215,7292 (defun mapc-retrieve-in-world mapc-retrieve-in-world221,7447 (defun retrieve-in-world retrieve-in-world232,7890 (defun retrieve-bagof-in-world retrieve-bagof-in-world240,8119 (defun nlist-delete nlist-delete248,8407 (def-attached-fn ind ind259,8675 (def-attached-fn val val264,8854 (def-attached-fn rel rel270,9077 (def-attached-fn sub sub275,9272 krep1.lisp,711 (defun make-empty-nlist make-empty-nlist12,323 (defun nlist-n nlist-n16,399 (defun nlist-list nlist-list17,465 (defun nlist-push nlist-push19,525 (defvar *predicates* *predicates*34,944 (defun get-dtree get-dtree36,971 (defun clear-dtrees clear-dtrees42,1168 (defun index index50,1379 (defun dtree-index dtree-index55,1557 (defun lookup-atom lookup-atom71,2259 (defun test-index test-index80,2529 (defun fetch fetch91,2824 (defun dtree-fetch dtree-fetch99,3097 (defun dtree-atom-fetch dtree-atom-fetch120,4148 (defun mapc-retrieve mapc-retrieve135,4742 (defun retrieve retrieve146,5074 (defun retrieve-matches retrieve-matches153,5292 (defmacro query-bind query-bind161,5544 krep2.lisp,749 (defun index index10,336 (defvar *search-cut-off* *search-cut-off*21,733 (defun prove-all prove-all23,795 (defun prove prove30,1068 (defparameter *depth-start* *depth-start*53,2040 (defparameter *depth-incr* *depth-incr*55,2125 (defparameter *depth-max* *depth-max*57,2214 (defun top-level-prove top-level-prove62,2336 (defun show-prolog-vars show-prolog-vars74,2733 (defun add-fact add-fact93,3291 (defun retrieve-fact retrieve-fact101,3476 (defun retrieve-conjunction retrieve-conjunction107,3730 (defun mapc-retrieve mapc-retrieve122,4236 (defun retrieve retrieve131,4586 (defun retrieve-bagof retrieve-bagof141,4883 (defun retrieve-setof retrieve-setof147,5101 (defmacro def-attached-fn def-attached-fn156,5384 lexicon.lisp,1107 (defvar *abbrevs* *abbrevs*8,227 (defmacro abbrev abbrev10,265 (defun clear-abbrevs clear-abbrevs14,407 (defun get-abbrev get-abbrev15,452 (defvar *words* *words*19,544 (defmacro word word21,590 (defun add-word add-word25,739 (defun kwote kwote31,940 (defun expand-abbrevs-and-variables expand-abbrevs-and-variables35,1011 (defun word/n word/n60,1785 (defun word/2 word/274,2281 (defun word/3 word/375,2329 (defun word/4 word/476,2381 (defun word/5 word/577,2437 (defun word/6 word/678,2497 (defmacro noun noun82,2598 (defun add-noun-form add-noun-form86,2729 (defmacro verb verb94,3013 (defun add-verb add-verb98,3163 (defun strip-vowel strip-vowel116,3892 (defun vowel-p vowel-p124,4104 (defun passivize-sense passivize-sense128,4203 (defun passivize-subcat passivize-subcat132,4365 (defun slot-number slot-number145,4942 (defun copula copula149,5036 (defun clear-lexicon clear-lexicon160,5452 (defun clear-grammar clear-grammar164,5516 (defmacro try try170,5610 (defun try-dcg try-dcg176,5835 (defun test-unknown-word test-unknown-word195,6631 loop.lisp,1665 (defstruct looploop59,917 (defmacro loop loop66,1119 (defun fill-loop-template fill-loop-template77,1498 (defun add-body add-body93,1943 (defun add-test add-test95,1994 (defun add-var add-var99,2105 (defun parse-loop-body parse-loop-body108,2397 (defun call-loop-fn call-loop-fn115,2628 (defmacro defloop defloop121,2866 (defloop repeat repeat135,3435 (defloop as as143,3641 (defloop for for145,3685 (defun loop-for-arithmetic loop-for-arithmetic176,4763 (defun maybe-temp maybe-temp205,5762 (defloop until until215,5984 (defloop while while217,6028 (defloop always always219,6080 (defloop never never223,6180 (defloop thereis thereis227,6273 (defmacro return-if return-if229,6333 (defmacro loop-finish loop-finish235,6476 (defconstant *acc* *acc*239,6549 (defloop collect collect244,6668 (defloop nconc nconc249,6817 (defloop append append254,6968 (defloop count count257,7052 (defloop sum sum262,7172 (defloop maximize maximize267,7283 (defloop minimize minimize275,7502 (defloop collecting collecting283,7721 (defloop nconcing nconcing284,7750 (defloop appending appending285,7777 (defloop counting counting286,7805 (defloop summing summing287,7832 (defloop maximizing maximizing288,7857 (defloop minimizing minimizing289,7887 (defloop with with295,8007 (defloop when when305,8221 (defloop unless unless308,8308 (defun maybe-set-it maybe-set-it311,8388 (defloop if if318,8588 (defun loop-unless loop-unless320,8607 (defloop do do339,9221 (defloop return return344,9350 (defloop initially initially348,9440 (defloop finally finally353,9600 (defloop named named358,9758 macsyma.lisp,1274 (defun variable-p variable-p9,217 (defun exp-p exp-p20,549 (defun exp-args exp-args21,577 (defun binary-exp-p binary-exp-p23,608 (defun prefix->infix prefix->infix26,680 (defparameter *infix->prefix-rules**infix->prefix-rules*43,1200 (defun infix->prefix infix->prefix56,1580 (defvar *simplification-rules* *simplification-rules*75,2368 (defun ^ ^77,2438 (defun simplifier simplifier79,2483 (defun simp simp85,2637 (defun simplify simplify87,2704 (defun evaluable evaluable102,3260 (defun not-numberp not-numberp109,3520 (defun simp-rule simp-rule111,3563 (defun simp-fn simp-fn117,3750 (defun set-simp-fn set-simp-fn118,3789 (defun simplify-exp simplify-exp120,3846 (defun simplify-by-fn simplify-by-fn131,4326 (defun factorize factorize141,4639 (defun unfactorize unfactorize174,5745 (defun divide-factors divide-factors180,5966 (defun free-of free-of191,6403 (defun find-anywhere find-anywhere195,6511 (defun integrate integrate202,6748 (defun partition-if partition-if228,7935 (defun deriv-divides deriv-divides239,8269 (defun deriv deriv262,9241 (defun integration-table integration-table264,9284 (defun in-integral-table? in-integral-table?271,9521 (defun integrate-from-table integrate-from-table274,9599 macsymar.lisp,0 mycin-r.lisp,559 (defparm name name10,245 (defparm sex sex11,301 (defparm age age12,353 (defparm burn burn13,391 (defparm compromised-host compromised-host15,492 (defparm site site19,593 (defparm days-old days-old21,683 (defparm identity identity25,803 (defparm gram gram29,975 (defparm morphology morphology31,1054 (defparm aerobicity aerobicity33,1138 (defparm growth-conformation growth-conformation34,1195 (defrule 525239,1282 (defrule 717147,1468 (defrule 737354,1646 (defrule 757562,1841 (defrule 10710769,2006 (defrule 16516576,2178 mycin.lisp,1734 (defconstant true true8,245 (defconstant false false9,271 (defconstant unknown unknown10,297 (defun cf-or cf-or12,324 (defun cf-and cf-and22,648 (defconstant cf-cut-off cf-cut-off26,743 (defun true-p true-p29,817 (defun false-p false-p33,920 (defun cf-p cf-p37,1033 (defun get-vals get-vals46,1308 (defun get-cf get-cf50,1424 (defun update-cf update-cf55,1571 (defconstant help-stringhelp-string64,1923 (defun ask-vals ask-vals74,2303 (defun prompt-and-read-vals prompt-and-read-vals94,3156 (defun inst-name inst-name103,3431 (defun check-reply check-reply109,3605 (defun parse-reply parse-reply123,4153 (defmacro defparm defparm136,4679 (defun parm-type parm-type140,4803 (defun get-parm get-parm144,4938 (deftype yes/no yes/no150,5137 (defstruct contextcontext152,5175 (defmacro defcontext defcontext156,5272 (defun new-instance new-instance161,5445 (defun find-out find-out188,6276 (defun use-rules use-rules198,6749 (defun use-rule use-rule203,6929 (defun satisfy-premises satisfy-premises217,7498 (defun eval-condition eval-condition228,7911 (defun reject-premise reject-premise240,8385 (defun conclude conclude245,8556 (defun is is251,8763 (defun parse-condition parse-condition253,8793 (defun emycin emycin262,9126 (defun get-context-data get-context-data268,9322 (defmacro defrule defrule285,10035 (defun check-conditions check-conditions303,10770 (defun report-findings report-findings320,11486 (defun print-rule print-rule333,12037 (defun print-conditions print-conditions341,12371 (defun print-condition print-condition347,12583 (defun cf->english cf->english359,13059 (defun print-why print-why369,13544 (defun mycin mycin388,14335 othello.lisp,2118 (defun cross-product cross-product10,298 (defconstant all-directions all-directions17,509 (defconstant empty empty19,566 (defconstant black black20,606 (defconstant white white21,644 (defconstant outer outer22,682 (deftype piece piece24,743 (defun name-of name-of26,788 (defun opponent opponent28,833 (deftype board board30,896 (defun bref bref32,944 (defsetf bref bref33,992 (defun copy-board copy-board36,1067 (defconstant all-squaresall-squares39,1114 (defun initial-board initial-board42,1205 (defun count-difference count-difference55,1778 (defun valid-p valid-p60,1934 (defun legal-p legal-p64,2085 (defun make-move make-move71,2350 (defun make-flips make-flips79,2591 (defun would-flip? would-flip?86,2869 (defun find-bracketing-piece find-bracketing-piece96,3325 (defun next-to-play next-to-play103,3622 (defun any-legal-move? any-legal-move?114,4042 (defun random-strategy random-strategy119,4212 (defun legal-moves legal-moves123,4319 (defun maximize-difference maximize-difference129,4559 (defun maximizer maximizer133,4715 (defparameter *weights**weights*150,5312 (defun weighted-squares weighted-squares162,5709 (defconstant winning-value winning-value171,6031 (defconstant losing-value losing-value172,6080 (defun final-value final-value174,6130 (defun minimax minimax181,6317 (defun minimax-searcher minimax-searcher206,7392 (defun alpha-beta alpha-beta214,7656 (defun alpha-beta-searcher alpha-beta-searcher241,8897 (defun modified-weighted-squares modified-weighted-squares250,9218 (defun human human291,10582 (defvar *move-number* *move-number*297,10778 (defun othello othello299,10842 (defvar *clock* *clock*321,11792 (defvar *board* *board*322,11851 (defun get-move get-move324,11912 (defun print-board print-board350,13026 (defun time-string time-string369,13834 (defun random-othello-series random-othello-series375,14060 (defun switch-strategies switch-strategies383,14394 (defun othello-series othello-series390,14658 (defun round-robin round-robin406,15337 (defun mobility mobility435,16517 othello2.lisp,1258 (defconstant all-squaresall-squares15,562 (defun alpha-beta-searcher2 alpha-beta-searcher222,759 (defun alpha-beta2 alpha-beta233,1185 (defun negate-value negate-value61,2507 (defun legal-nodes legal-nodes66,2637 (defvar *ply-boards**ply-boards*80,3174 (defun alpha-beta3 alpha-beta383,3257 (defun alpha-beta-searcher3 alpha-beta-searcher3117,4852 (defun put-first put-first126,5180 (defun mobility mobility133,5391 (defvar *edge-table* *edge-table*150,6105 (defconstant edge-and-x-listsedge-and-x-lists153,6211 (defun edge-index edge-index160,6431 (defun edge-stability edge-stability171,6815 (defconstant top-edge top-edge177,7038 (defun init-edge-table init-edge-table179,7087 (defun map-edge-n-pieces map-edge-n-pieces199,7883 (defun possible-edge-moves-value possible-edge-moves-value217,8676 (defun possible-edge-move possible-edge-move228,9079 (defun combine-edge-moves combine-edge-moves237,9466 (defun edge-move-probability edge-move-probability254,10128 (defun count-edge-neighbors count-edge-neighbors273,10871 (defparameter *static-edge-table**static-edge-table*279,11090 (defun static-edge-stability static-edge-stability293,11461 (defun Iago-eval Iago-eval335,13054 (defun Iago Iago354,13894 overview.lisp,1704 (defun tax-bracket tax-bracket7,217 (defstruct player player17,522 (defun determine-winner determine-winner19,563 (defun length1 length126,798 (defun length1.1 length1.134,1051 (defun length2 length241,1284 (defun length3 length350,1585 (defun length4 length457,1810 (defun length5 length561,1960 (defun length6 length665,2110 (defun length7 length774,2438 (defun true true77,2487 (defun length8 length881,2543 (defun length9 length988,2680 (defun length10 length1095,2801 (defun length10-aux length10-aux98,2850 (defun length11 length11105,3021 (defun length12 length12112,3189 (defun product product122,3423 (defmacro while while132,3672 (defmacro while while140,3853 (defmacro while while147,4067 (defun dprint dprint154,4229 (defun pr-rest pr-rest163,4448 (defun pr-rest pr-rest169,4534 (defun same-shape-tree same-shape-tree176,4716 (defun true true180,4829 (defun english->french english->french184,4896 (defstruct node node192,5131 (defvar *db* *db*197,5180 (defun questions questions205,5384 (defun give-up give-up218,5881 (defun average average224,6006 (defun average average232,6204 (defun sqr sqr243,6469 (defun sqr sqr250,6582 (defun sqr sqr257,6694 (defun eat-porridge eat-porridge264,6810 (defun adder adder273,7104 (defun bank-account bank-account279,7235 (defun math-quiz math-quiz288,7515 (defun problem problem293,7656 (defun math-quiz math-quiz302,7931 (defun math-quiz math-quiz309,8134 (defun find-all find-all316,8332 (defmacro while2 while2328,8793 (defun length14 length14335,8959 (defun length-r length-r341,9078 (defun length-r length-r344,9149 (defun length-r length-r348,9242 patmatch.lisp,907 (defun variable-p variable-p11,330 (defun pat-match pat-match15,461 (defun segment-pattern-p segment-pattern-p42,1550 (defun single-pattern-p single-pattern-p48,1789 (defun segment-matcher segment-matcher54,1990 (defun single-matcher single-matcher59,2191 (defun segment-match-fn segment-match-fn64,2388 (defun single-match-fn single-match-fn69,2539 (defun match-is match-is74,2687 (defun match-and match-and85,3075 (defun match-or match-or93,3384 (defun match-not match-not103,3744 (defun segment-match segment-match110,3948 (defun first-match-pos first-match-pos128,4718 (defun segment-match+ segment-match+137,5109 (defun segment-match? segment-match?141,5242 (defun match-if match-if148,5491 (defun pat-match-abbrev pat-match-abbrev157,5861 (defun expand-pat-match-abbrev expand-pat-match-abbrev162,6057 (defun rule-based-translator rule-based-translator169,6356 prolog.lisp,906 (defun clause-head clause-head12,377 (defun clause-body clause-body13,421 (defun get-clauses get-clauses16,512 (defun predicate predicate17,559 (defun args args18,605 (defvar *db-predicates* *db-predicates*20,662 (defmacro <- <-23,745 (defun add-clause add-clause27,852 (defun clear-db clear-db37,1229 (defun clear-predicate clear-predicate41,1357 (defun rename-variables rename-variables45,1479 (defun unique-find-anywhere-if unique-find-anywhere-if51,1672 (defun find-anywhere-if find-anywhere-if65,2150 (defmacro ?- ?-72,2399 (defun prove-all prove-all74,2472 (defun prove prove80,2680 (defun top-level-prove top-level-prove96,3298 (defun show-prolog-vars show-prolog-vars102,3455 (defun continue-p continue-p116,3882 (defun variables-in variables-in126,4127 (defun non-anon-variable-p non-anon-variable-p130,4256 (defun replace-?-vars replace-?-vars133,4328 prolog1.lisp,798 (defun clause-head clause-head10,274 (defun clause-body clause-body11,318 (defun get-clauses get-clauses14,409 (defun predicate predicate15,456 (defvar *db-predicates* *db-predicates*17,503 (defmacro <- <-20,586 (defun add-clause add-clause24,676 (defun clear-db clear-db34,1053 (defun clear-predicate clear-predicate38,1181 (defun prove prove42,1303 (defun prove-all prove-all50,1645 (defun rename-variables rename-variables58,1977 (defun unique-find-anywhere-if unique-find-anywhere-if64,2170 (defun find-anywhere-if find-anywhere-if78,2648 (defmacro ?- ?-85,2897 (defun top-level-prove top-level-prove87,2953 (defun show-prolog-solutions show-prolog-solutions93,3122 (defun show-prolog-vars show-prolog-vars101,3372 (defun variables-in variables-in110,3621 prologc.lisp,2273 (defconstant unbound unbound10,253 (defstruct var var12,286 (defun bound-p bound-p14,326 (defmacro deref deref16,386 (defun unify! unify!22,571 (defun set-binding! set-binding!32,887 (defun print-var print-var37,1020 (defvar *trail* *trail*44,1236 (defun set-binding! set-binding!46,1301 (defun undo-bindings! undo-bindings!54,1530 (defvar *var-counter* *var-counter*59,1734 (defun prolog-compile prolog-compile66,1893 (defun clauses-with-arity clauses-with-arity78,2409 (defun relation-arity relation-arity85,2655 (defun args args90,2804 (defun make-parameters make-parameters92,2861 (defun make-predicate make-predicate97,3011 (defun make-= make-=101,3113 (defun compile-call compile-call103,3146 (defun prolog-compiler-macro prolog-compiler-macro107,3261 (defmacro def-prolog-compiler-macro def-prolog-compiler-macro112,3439 (defun compile-arg compile-arg117,3625 (defun has-variable-p has-variable-p126,3951 (defun proper-listp proper-listp130,4069 (defun maybe-add-undo-bindings maybe-add-undo-bindings135,4194 (defun bind-unbound-vars bind-unbound-vars146,4608 (defmacro <- <-157,4979 (defun make-anonymous make-anonymous161,5086 (defun anonymous-variables-in anonymous-variables-in171,5464 (defun anon-vars-in anon-vars-in175,5608 (defun compile-unify compile-unify190,6247 (defun compile-if compile-if207,7024 (defun compile-unify-variable compile-unify-variable214,7200 (defun bind-variables-in bind-variables-in238,8343 (defun follow-binding follow-binding246,8639 (defun compile-arg compile-arg254,8879 (defun bind-new-variables bind-new-variables270,9551 (defun self-cons self-cons276,9827 (def-prolog-compiler-macro = =278,9861 (defun compile-clause compile-clause289,10263 (defvar *uncompiled* *uncompiled*300,10615 (defun add-clause add-clause303,10691 (defun top-level-prove top-level-prove314,11130 (defun run-prolog run-prolog328,11606 (defun prolog-compile-symbols prolog-compile-symbols339,11971 (defun ignore ignore345,12222 (defun show-prolog-vars/2 show-prolog-vars/2349,12283 (defun deref-exp deref-exp361,12688 (defvar *predicate* *predicate*370,12910 (defun compile-predicate compile-predicate373,12986 (defun compile-body compile-body386,13426 prologc1.lisp,1231 (defconstant unbound unbound10,277 (defstruct var var12,310 (defun bound-p bound-p14,350 (defmacro deref deref16,410 (defun unify! unify!22,595 (defun set-binding! set-binding!32,911 (defun print-var print-var37,1044 (defvar *trail* *trail*44,1260 (defun set-binding! set-binding!46,1325 (defun undo-bindings! undo-bindings!54,1554 (defvar *var-counter* *var-counter*59,1758 (defun prolog-compile prolog-compile66,1917 (defun clauses-with-arity clauses-with-arity78,2433 (defun relation-arity relation-arity85,2679 (defun args args90,2828 (defun compile-predicate compile-predicate92,2885 (defun make-parameters make-parameters104,3281 (defun make-predicate make-predicate109,3431 (defun compile-clause compile-clause113,3533 (defun make-= make-=121,3761 (defun compile-body compile-body123,3794 (defun compile-call compile-call143,4552 (defun prolog-compiler-macro prolog-compiler-macro147,4667 (defmacro def-prolog-compiler-macro def-prolog-compiler-macro152,4845 (def-prolog-compiler-macro = =157,5031 (defun compile-unify compile-unify164,5249 (defun compile-arg compile-arg168,5374 (defun has-variable-p has-variable-p177,5700 (defun proper-listp proper-listp181,5818 prologc2.lisp,1348 (defconstant unbound unbound10,243 (defstruct var var12,276 (defun bound-p bound-p14,316 (defmacro deref deref16,376 (defun unify! unify!22,561 (defun set-binding! set-binding!32,877 (defun print-var print-var37,1010 (defvar *trail* *trail*44,1226 (defun set-binding! set-binding!46,1291 (defun undo-bindings! undo-bindings!54,1520 (defvar *var-counter* *var-counter*59,1724 (defun prolog-compile prolog-compile66,1883 (defun clauses-with-arity clauses-with-arity78,2399 (defun relation-arity relation-arity85,2645 (defun args args90,2794 (defun make-parameters make-parameters92,2851 (defun make-predicate make-predicate97,3001 (defun make-= make-=101,3103 (defun compile-body compile-body103,3136 (defun compile-call compile-call123,3894 (defun prolog-compiler-macro prolog-compiler-macro127,4009 (defmacro def-prolog-compiler-macro def-prolog-compiler-macro132,4187 (def-prolog-compiler-macro = =137,4373 (defun compile-unify compile-unify144,4591 (defun compile-arg compile-arg148,4716 (defun has-variable-p has-variable-p157,5042 (defun proper-listp proper-listp161,5160 (defun compile-predicate compile-predicate166,5285 (defun compile-clause compile-clause179,5735 (defun maybe-add-undo-bindings maybe-add-undo-bindings189,6094 (defun bind-unbound-vars bind-unbound-vars200,6508 prologcp.lisp,624 (defun read/1 read/113,350 (defun write/1 write/117,425 (defun nl/0 nl/021,506 (defun =/2 =/223,551 (defun ==/2 ==/227,632 (defun deref-equal deref-equal33,815 (defun call/1 call/142,1085 (defmacro with-undo-bindings with-undo-bindings54,1385 (defun not/1 not/164,1732 (defun bagof/3 bagof/371,1967 (defun deref-copy deref-copy85,2516 (defun setof/3 setof/393,2853 (defun is/2 is/2107,3398 (defun unbound-var-p unbound-var-p114,3648 (defun var/1 var/1118,3744 (defun lisp/2 lisp/2123,3875 (defun repeat/0 repeat/0129,4083 (defun numberp/1 numberp/1148,4453 (defun atom/1 atom/1152,4529 search.lisp,1441 (defun tree-search tree-search7,178 (defun depth-first-search depth-first-search19,666 (defun binary-tree binary-tree23,827 (defun is is25,881 (defun prepend prepend27,930 (defun breadth-first-search breadth-first-search29,992 (defun finite-binary-tree finite-binary-tree33,1156 (defun diff diff40,1364 (defun sorter sorter44,1478 (defun best-first-search best-first-search49,1640 (defun price-is-right price-is-right53,1824 (defun beam-search beam-search60,2075 (defparameter *cities**cities*72,2609 (defun neighbors neighbors85,3299 (defun city city92,3524 (defun trip trip96,3604 (defun trip trip105,3892 (defconstant earth-diameter earth-diameter115,4208 (defun air-distance air-distance118,4290 (defun xyz-coords xyz-coords125,4590 (defun distance distance134,4912 (defun deg->radians deg->radians140,5153 (defun is is144,5282 (defun path-saver path-saver148,5451 (defun print-path print-path164,6085 (defun show-city-path show-city-path169,6261 (defun map-path map-path176,6515 (defun iter-wide-search iter-wide-search183,6722 (defun graph-search graph-search193,7170 (defun new-states new-states210,7856 (defun next2 next2218,8152 (defun a*-search a*-search220,8194 (defun find-path find-path260,10087 (defun better-path better-path264,10236 (defun insert-path insert-path268,10358 (defun path-states path-states273,10547 (defun search-all search-all280,10722 simple.lisp,785 (defun sentence sentence5,145 (defun noun-phrase noun-phrase6,205 (defun verb-phrase verb-phrase7,254 (defun Article Article8,307 (defun Noun Noun9,348 (defun Verb Verb10,404 (defun one-of one-of14,495 (defun random-elt random-elt18,595 (defun Adj* Adj*24,748 (defun PP* PP*29,827 (defun PP PP35,973 (defun Adj Adj36,1017 (defun Prep Prep37,1076 (defparameter *simple-grammar**simple-grammar*41,1158 (defvar *grammar* *grammar*50,1450 (defun rule-lhs rule-lhs56,1634 (defun rule-rhs rule-rhs60,1708 (defun rewrites rewrites64,1789 (defun generate generate70,1956 (defparameter *bigger-grammar**bigger-grammar*80,2228 (defun generate-tree generate-tree99,2819 (defun generate-all generate-all111,3165 (defun combine-all combine-all121,3537 student.lisp,1005 (defun exp-p exp-p15,374 (defun exp-args exp-args16,402 (defparameter *student-rules* *student-rules*21,500 (defun student student56,1932 (defun translate-to-expression translate-to-expression62,2115 (defun translate-pair translate-pair72,2518 (defun create-list-of-equations create-list-of-equations77,2703 (defun noise-word-p noise-word-p84,2980 (defun make-variable make-variable88,3114 (defun solve-equations solve-equations92,3221 (defun solve solve97,3426 (defun isolate isolate112,4063 (defun print-equations print-equations140,5303 (defconstant operators-and-inversesoperators-and-inverses145,5467 (defun inverse-op inverse-op148,5540 (defun unknown-p unknown-p151,5610 (defun in-exp in-exp154,5651 (defun no-unknown no-unknown160,5821 (defun one-unknown one-unknown167,6031 (defun commutative-p commutative-p175,6324 (defun solve-arithmetic solve-arithmetic179,6404 (defun binary-exp-p binary-exp-p184,6611 (defun prefix->infix prefix->infix187,6683 syntax1.lisp,620 (defvar *grammar* *grammar*11,429 (defun new-tree new-tree18,629 (defun tree-lhs tree-lhs19,671 (defun tree-rhs tree-rhs20,708 (defun parse-lhs parse-lhs22,745 (defparameter *open-categories* *open-categories*24,802 (defun lexical-rules lexical-rules27,895 (defun rules-starting-with rules-starting-with32,1116 (defun complete-parses complete-parses37,1298 (defun parse parse41,1435 (defun extend-parse extend-parse49,1736 (defun append1 append169,2556 (defun parser parser77,2738 (defun use use82,2899 (defparameter *grammar3**grammar3*91,3074 (defparameter *grammar4**grammar4*100,3363 syntax2.lisp,980 (defvar *grammar* *grammar*9,310 (defun parse-lhs parse-lhs18,590 (defun lexical-rules lexical-rules20,647 (defun rules-starting-with rules-starting-with25,868 (defun first-or-nil first-or-nil30,1050 (defun complete-parses complete-parses34,1161 (defun append1 append138,1298 (defun parser parser46,1480 (defun use use51,1641 (defparameter *open-categories* *open-categories*57,1801 (defun parse parse60,1894 (defun extend-parse extend-parse69,2246 (defun apply-semantics apply-semantics92,3264 (defun terminal-tree-p terminal-tree-p101,3575 (defun meanings meanings106,3730 (defparameter *grammar5**grammar5*113,3921 (defun infix-funcall infix-funcall124,4330 (defun integers integers128,4449 (defun ordered-union ordered-union133,4619 (defun ordered-set-difference ordered-set-difference138,4814 (defparameter *grammar6**grammar6*144,5020 (defun union* union*158,5488 (defun set-diff set-diff159,5553 (defun 10*N+D 10*N+D160,5624 syntax3.lisp,1537 (defvar *grammar* *grammar*8,243 (defun use use17,546 (defun parse-lhs parse-lhs27,850 (defun lexical-rules lexical-rules29,907 (defun rules-starting-with rules-starting-with33,1056 (defun first-or-nil first-or-nil38,1238 (defun complete-parses complete-parses42,1349 (defun append1 append146,1486 (defun parser parser50,1583 (defparameter *open-categories* *open-categories*55,1744 (defun lexical-rules lexical-rules58,1837 (defun apply-semantics apply-semantics63,2058 (defun terminal-tree-p terminal-tree-p72,2369 (defun parse parse77,2524 (defun extend-parse extend-parse87,2946 (defun apply-scorer apply-scorer114,4133 (defun tree-score-or-0 tree-score-or-0127,4605 (defun all-parses all-parses130,4694 (defun bracketing bracketing138,5018 (defun meaning meaning145,5256 (defun query-user query-user158,5898 (defparameter *grammar7**grammar7*174,6378 (defun infix-funcall infix-funcall194,7208 (defun 10*N+D 10*N+D198,7327 (defun prefer< prefer<199,7363 (defun prefer-disjoint prefer-disjoint200,7414 (defun prefer-subset prefer-subset201,7483 (defun prefer-not-singleton prefer-not-singleton203,7566 (defun infix-scorer infix-scorer206,7652 (defun arg2 arg2209,7735 (defun rev-scorer rev-scorer211,7796 (defun rev-funcall rev-funcall213,7863 (defun repeat repeat215,7922 (defun span-length span-length221,8039 (defun inv-span inv-span226,8173 (defun sem sem228,8223 (defun integers integers230,8259 (defun sum sum237,8547 (defun permute permute243,8727 tutor.lisp,672 (defvar *chapters* *chapters*9,160 (defun do-examples do-examples11,232 (defmacro defexamples defexamples20,640 (defun do-chapter do-chapter31,1239 (defun add-chapter add-chapter52,1922 (defun find-chapter find-chapter62,2270 (defun do-example do-example68,2498 (defun do-documentation-examples do-documentation-examples113,4154 (defun nearly-equal nearly-equal121,4432 (defmethod set-chapter set-chapter155,5670 (defmethod set-page set-page159,5828 (defmethod set-example set-example163,5976 (defmethod display-example display-example169,6237 (defmethod display-section display-section173,6408 (defmethod output-stream output-stream177,6578 unifgram.lisp,876 (defmacro rule rule9,208 (defun dcg-normal-goal-p dcg-normal-goal-p17,511 (defun dcg-word-list-p dcg-word-list-p19,579 (defun make-dcg make-dcg23,675 (defun make-dcg-body make-dcg-body28,841 (defun make-augmented-dcg make-augmented-dcg54,1810 (defun collect-sems collect-sems74,2585 (defun and*/2 and*/288,3116 (defun conjuncts conjuncts95,3376 (defmacro :ex :ex105,3660 (defvar *examples* *examples*109,3816 (defun get-examples get-examples111,3866 (defun clear-examples clear-examples113,3929 (defun add-examples add-examples115,3977 (defun run-examples run-examples129,4536 (defun remove-punctuation remove-punctuation143,5072 (defun string->list string->list147,5205 (defun punctuation-p punctuation-p151,5335 (defmacro conj-rule conj-rule153,5397 (defun handle-conj handle-conj167,5899 (defun conj-category conj-category174,6141 unify.lisp,243 (defparameter *occurs-check* *occurs-check*9,213 (defun unify unify11,279 (defun unify-variable unify-variable22,695 (defun occurs-check occurs-check32,1110 (defun subst-bindings subst-bindings43,1499 (defun unifier unifier57,2027 waltz.lisp,1193 (defstruct diagram diagram7,186 (defun ambiguous-vertex-p ambiguous-vertex-p15,480 (defun number-of-labelings number-of-labelings19,614 (defun impossible-vertex-p impossible-vertex-p22,689 (defun impossible-diagram-p impossible-diagram-p26,812 (defun possible-labelings possible-labelings30,970 (defun print-labelings print-labelings40,1404 (defun propagate-constraints propagate-constraints56,2048 (defun consistent-labelings consistent-labelings67,2566 (defun search-solutions search-solutions81,3170 (defun labels-for labels-for101,4014 (defun reverse-label reverse-label107,4254 (defun find-vertex find-vertex111,4400 (defun print-vertex print-vertex115,4558 (defun show-vertex show-vertex122,4762 (defun show-diagram show-diagram132,5175 (defun matrix-transpose matrix-transpose143,5604 (defun construct-diagram construct-diagram158,6007 (defun construct-vertex construct-vertex172,6567 (defun v-d-neighbors v-d-neighbors180,6857 (defun make-copy-diagram make-copy-diagram184,6991 (defun ground ground197,7502 (defun find-labelings find-labelings209,7949 (defmacro defdiagram defdiagram214,8135 (defun check-diagram check-diagram219,8360