DIR : /home/kozerus/public_html/ghost_lines.html

/home/kozerus/public_html

<!-- <!DOCTYPE html> -->
<html><head>
<meta http-equiv="content-type" content="text/html; charset=UTF-8"><meta name="viewport" content="width=device-width"><title>https://ai.neocities.org/Ghost.html</title><link rel="stylesheet" type="text/css" href="resource://content-accessible/viewsource.css"></head><body id="viewsource" class="highlight" style="-moz-tab-size: 4" contextmenu="actions"><pre id="line1"><span></span><span class="error" title="Start tag seen without seeing a doctype first. Expected “&lt;!DOCTYPE html&gt;”.">&lt;<span class="start-tag">html</span>&gt;</span><span>
<span id="line2"></span></span><span>&lt;<span class="start-tag">head</span>&gt;</span><span>
<span id="line3"></span></span><span>&lt;<span class="start-tag">title</span>&gt;</span><span>Ghost Strong AI Guaranteed to Think with MSIE</span><span>&lt;/<span class="end-tag">title</span>&gt;</span><span>
<span id="line4"></span></span><span>&lt;<span class="start-tag">meta</span> <span class="attribute-name">name</span>="<a class="attribute-value">description</a>" 
<span id="line5"></span> <span class="attribute-name">content</span>="<a class="attribute-value">Tutorial AI demonstrates Natural Language Understanding (NLU).</a>" <span>/</span>&gt;</span><span>
<span id="line6"></span></span><span>&lt;<span class="start-tag">meta</span> <span class="attribute-name">name</span>="<a class="attribute-value">keywords</a>" 
<span id="line7"></span> <span class="attribute-name">content</span>="<a class="attribute-value">AGI, AiMind, AI Mind Maintainer, artificial intelligence, javascript, MSIE, 
<span id="line8"></span> natural language understanding, NLU, prior art, spreading activation, strong AI</a>" <span>/</span>&gt;</span><span>
<span id="line9"></span></span><span>&lt;<span class="start-tag">script</span> <span class="attribute-name">language</span>="<a class="attribute-value">JavaScript</a>"&gt;</span><span>
<span id="line10"></span>var abc = "";  // AudBuffer() transfer character; 4jan2012
<span id="line11"></span>var abort = false;  // 29dec2006 For orchestration of sentence-generation.
<span id="line12"></span>var act = 0;  // AI4U: old- &amp; newConcept; Reify(); nounPhrase; verbPhrase.
<span id="line13"></span>var actpsi = 0;  // 2017-12-31: psi from which activation is to be spread
<span id="line14"></span>var anset = 0;  // Set "an" before a vowel at start of noun.
<span id="line15"></span>var apb = "";   // 31dec2006: candidate to replace "fyi" variable.
<span id="line16"></span>  apb = "You have halted the AI Mind at Rejuvenation cycle #"+rjc+".";
<span id="line17"></span>var artnum = 0;  // article num(ber) as parameter for EnArticle; 6nov2011
<span id="line18"></span>var aud = 0; // 20mar07A: enVocab; Audition; Speech: auditory recall-tag.
<span id="line19"></span>var aud0 = "";  // AI4U: audRecog; audExam; audSTM; Speech: auditory engram. 
<span id="line20"></span>var aud1 = 0;  // 2018-01-07
<span id="line21"></span>var aud2 = 0;  // 2018-01-07
<span id="line22"></span>var audbase = 0;  // from RuAi; recall-vector for VerbGen(); 17oct2012
<span id="line23"></span>var auddata = ("</span><span>&lt;b</span><span>&gt;" + "Auditory memory nodes" + "</span><span>&lt;\</span><span>/b&gt;" + "</span><span>&lt;B</span><span>R&gt;");
<span id="line24"></span>auddata += ("krt pho act audpsi");  // 2018-01-03
<span id="line25"></span>var audjuste = 0;
<span id="line26"></span>var audnum = 0;  // de-globalizing the "num" variable;  4nov2012
<span id="line27"></span>var audpsi = 0;  // 6dec2009 de-globalizing the "psi" variable 
<span id="line28"></span>var audrec = 0;  // 8dec2009 Replaces "psi" in AudRecog module.
<span id="line29"></span>var audrun = 0; // 2018-01-07: Counter of loops through AudRecog(); 
<span id="line30"></span>var audrv = 0;  // 2017-12-31: auditory recall-vector for Speech()
<span id="line31"></span>var audstop = 0; // Flag to stop SpeechAct after one word; 7jul2010
<span id="line32"></span>var auxverb = 0;  // 2018-11-28: such as 800=BE; 818=DO; or modal verb;
<span id="line33"></span>var b1 = "";   // for OutBuffer(); 2019-06-15
<span id="line34"></span>var b01 = "";  // for OutBuffer();  4jan2012
<span id="line35"></span>var b2 = "";   // for OutBuffer(); 2019-06-15
<span id="line36"></span>var b02 = "";  // for OutBuffer();  4jan2012
<span id="line37"></span>var b3 = "";   // for OutBuffer(); 2019-06-15
<span id="line38"></span>var b03 = "";  // for OutBuffer();  4jan2012
<span id="line39"></span>var b4 = "";   // for OutBuffer(); 2019-06-15
<span id="line40"></span>var b04 = "";  // for OutBuffer();  4jan2012
<span id="line41"></span>var b5 = "";   // for OutBuffer(); 2019-06-15
<span id="line42"></span>var b05 = "";  // for OutBuffer();  4jan2012
<span id="line43"></span>var b6 = "";   // for OutBuffer(); 2019-06-15
<span id="line44"></span>var b06 = "";  // for OutBuffer();  4jan2012
<span id="line45"></span>var b7 = "";   // for OutBuffer(); 2019-06-15
<span id="line46"></span>var b07 = "";  // for OutBuffer();  4jan2012
<span id="line47"></span>var b8 = "";   // for OutBuffer(); 2019-06-15
<span id="line48"></span>var b08 = "";  // for OutBuffer();  4jan2012
<span id="line49"></span>var b9 = "";   // for OutBuffer(); 2019-06-15
<span id="line50"></span>var b09 = "";  // for OutBuffer();  4jan2012
<span id="line51"></span>var b10 = "";  // for OutBuffer();  4jan2012
<span id="line52"></span>var b11 = "";  // for OutBuffer();  4jan2012
<span id="line53"></span>var b12 = "";  // for OutBuffer();  4jan2012
<span id="line54"></span>var b13 = "";  // for OutBuffer();  4jan2012
<span id="line55"></span>var b14 = "";  // for OutBuffer();  4jan2012
<span id="line56"></span>var b15 = "";  // for OutBuffer();  4jan2012
<span id="line57"></span>var b16 = "";  // for OutBuffer(); 26mar2013
<span id="line58"></span>var becon = 0;  // detect be-verb for InFerence; 18mar2013
<span id="line59"></span>var bias = 5;  // 20mar07A: Parser; newConcept:  an expected part-of-speech.
<span id="line60"></span>var binc = 0;  // "b" increment for AudBuffer; 18oct2012
<span id="line61"></span>var brain = true;  // 20mar07A: for Think().
<span id="line62"></span>var c = "";  // AI4U: Listen(); character code of incoming pho(neme).
<span id="line63"></span>var c1 = "";   // for AudBuffer(); 2019-06-15
<span id="line64"></span>var c2 = "";   // for AudBuffer(); 2019-06-15
<span id="line65"></span>var c3 = "";   // for AudBuffer(); 2019-06-15
<span id="line66"></span>var c4 = "";   // for AudBuffer(); 2019-06-15
<span id="line67"></span>var c5 = "";   // for AudBuffer(); 2019-06-15
<span id="line68"></span>var c6 = "";   // for AudBuffer(); 2019-06-15
<span id="line69"></span>var c7 = "";   // for AudBuffer(); 2019-06-15
<span id="line70"></span>var c8 = "";   // for AudBuffer(); 2019-06-15
<span id="line71"></span>var c9 = "";   // for AudBuffer(); 2019-06-15
<span id="line72"></span>var c10 = "";  // for AudBuffer();  4jan2012
<span id="line73"></span>var c11 = "";  // for AudBuffer();  4jan2012
<span id="line74"></span>var c12 = "";  // for AudBuffer();  4jan2012
<span id="line75"></span>var c13 = "";  // for AudBuffer();  4jan2012
<span id="line76"></span>var c14 = "";  // for AudBuffer();  4jan2012
<span id="line77"></span>var c15 = "";  // for AudBuffer();  4jan2012
<span id="line78"></span>var c16 = "";  // for AudBuffer();  4jan2012
<span id="line79"></span>var caller = "none";  // AI4U: Diagnostic for Alert boxes. 
<span id="line80"></span>var catiobj = 0;   // 2019-02-12: concat-indirect-object for ConJoin() "AND".
<span id="line81"></span>var catdobj = 0;   // 2019-02-12: concat-direct-object for ConJoin() "AND".
<span id="line82"></span>var catsub = 0;    // 2019-02-12: concat-subject for ConJoin() "AND".
<span id="line83"></span>var catverb = 0;   // 2019-02-12: concat-verb for ConJoin() "AND".
<span id="line84"></span>// var cns = 1024;  // AI4U: Central Nervous System array size choice. 
<span id="line85"></span>// var cns = 2048;  // 2018-11-13: enlarge experiential memory for MindBoot prepositions.
<span id="line86"></span>var cns = 3072;  // 2018-12-09: enlarge experiential memory for MindBoot verbs.
<span id="line87"></span>var coda = 64;  // AI4U: Rejuvenate(): memory displacement span. 
<span id="line88"></span>// var coda = 128;  // AI4U: Rejuvenate(): memory displacement span. 
<span id="line89"></span>var cognum = 0;  // grammatical number of cogpsi; 27oct2011
<span id="line90"></span>var conj = 0;  // AI4U: oldConcept(); Conjoin(): conj(unction). 
<span id="line91"></span>var danger = true;  // 20mar07A: for Security().
<span id="line92"></span>var dba = 0;  // 2017-12-31: doing-business-as noun-case or verb-person
<span id="line93"></span>var defact = 0;  // default activation for NounPhrase; 25oct2011
<span id="line94"></span>var defartcon = 0;  // definite article condition; 19apr2011
<span id="line95"></span>var dialog = "";  // 20mar07A: Transcribe; Transcript: user input &amp; AI output.
<span id="line96"></span>var dirobj = 0;  // 2018-01-12: flag to indicate that a d.o. is being fetched.
<span id="line97"></span>var doa = 0;  // 2018-01-06: flag for exiting from AudInput loop
<span id="line98"></span>var dob = "";  // 2018-01-24: date-of-birth to remain fixed over each run.
<span id="line99"></span>var dobmfn = 0;  // for InFerence to pass gender to AskUser; 20mar2013
<span id="line100"></span>var dobseq = 0;  // for transfer within InFerence; 18mar2013
<span id="line101"></span>var dunnocon = 0;  // 2018-01-23: condition of "I-don't-know" for queries.
<span id="line102"></span>var edge = 0;  // AI4U: Rejuvenate: edge-of-thought flag.
<span id="line103"></span>var endpho = 0;  // 2018-01-06: to track final character of word for num(ber)
<span id="line104"></span>var engov = 0;  // 2018-01-01: possible replacement for too strict "hlc"
<span id="line105"></span>var engram = "";
<span id="line106"></span>var eot = 0;  // 20mar07A: CR; Listen(); Audition():  end-of-transmission flag.
<span id="line107"></span>var etc = 0;  // 2019-02-18: number of ideas simultaneously active for ConJoin() 
<span id="line108"></span>var eureka = 0;  // 2018-11-13: value for use in until-loop
<span id="line109"></span>var finlen = 0;  // 2017-12-31: fin(al) len(gth) or end-of-word for AudRecog
<span id="line110"></span>var foom = 0;    // 2018-09-04: arbitrary trigger for invoking a Spawn() module.
<span id="line111"></span>var freedom = true;  // 20mar07A: for Volition().
<span id="line112"></span>var fyi = 0;  // AI4U: Voice():  messages "For Your Information" to user.
<span id="line113"></span>var gencon = 0;  // status-con flag when calling VerbGen; 17oct201
<span id="line114"></span>// var greet = 10;  // greeting-trigger; 17nov2010
<span id="line115"></span>var greet = 5;  // for speedier testing; 29oct2011
<span id="line116"></span>var hap = 0;    // 2019-11-07: a "haptic" sensation of touch for TacRecog()
<span id="line117"></span>var haptac = 0; // 2019-11-07: for transfer from TacRecog() to EnVerbPhrase()
<span id="line118"></span>var hardcopy = false;  // 20mar07A: Transcript(): a flag for session print-outs.
<span id="line119"></span>var hear = 0; // 2018-01-06: AudInput outer loop counter. 
<span id="line120"></span>var hlc = "en";  // 2017-12-31: human-language code
<span id="line121"></span>var holdnum = 0;  // transfer from subject to verb;  4nov2012
<span id="line122"></span>var html = "";  // AI4U: HyperText Markup Language for creating Web pages.
<span id="line123"></span>var i = 0;  // AI4U: i(ndex) of loops.
<span id="line124"></span>var idle = 0;  // 2018-01-13: counter for a delay during TEST mode. 
<span id="line125"></span>var img = "xoxoxoxox";  // AI4U: visRecog: for future use as "image".
<span id="line126"></span>var impetus = 0;    // 2018-09-21: a level of curiosity and a trigger
<span id="line127"></span>var inbuffer = "";  // AI4U: Listen(); CR(): build-up of user input.
<span id="line128"></span>var indefartcon = 0;  // indefinite article condition; 19apr2011
<span id="line129"></span>var indefmust = 0;  // force saying of "A" or "AN"; 23oct2011
<span id="line130"></span>// var inert = 1;  // 20mar07A: Listen; Ego; Think; Security: Ego-trigger.
<span id="line131"></span>// var inert = 1;  // Until user presses a key; 20jul2011
<span id="line132"></span>var inert = 0;  // for quick asking of a cogpsi question; 23oct2011
<span id="line133"></span>var inft = 0;  // inference-time for AskUser; 18mar2013
<span id="line134"></span>var infincon = 0;  // infinitive condition flag; 24jun2015
<span id="line135"></span>var inhibcon = 0;  // flag for inhibition in InStantiate; 27oct2011
<span id="line136"></span>var input = ""; // 2018-01-19: string of input for diagnostic TEST
<span id="line137"></span>var instnum = 0;  // instantiation number for immediate or delayed use )
<span id="line138"></span>var iob = 0;  // 2017-12-31: indirect-object tag for psy concept array
<span id="line139"></span>var isolation = 0;  // 2018-10-03: counter to trigger "TEACH ME SOMETHING"
<span id="line140"></span>var istr = 0;  // 2018-10-13: first point of memories to be kept in ReJuvenate
<span id="line141"></span>var j = 0;  // AI4U: spreadAct; Rejuvenate; Reify: nested loop index.
<span id="line142"></span>var jrt = 0;  // AI4U: Rejuvenate(): "junior time" for moved memories. 
<span id="line143"></span>var jux = 0;  // AI4U: Parser; Instantiate:  a JUXtaposed word.
<span id="line144"></span>var kbcon = 0;  // flag for awaiting a yes-or-no answer; 29jun2011
<span id="line145"></span>var kbzap = 0;  // 2018-01-28: hold 432=YES or 404=NO for KbRetro() 
<span id="line146"></span>var krt = 0;  // AI4U: Troubleshoot(): "knowledge representation time".
<span id="line147"></span>var lastpho = 0; // to avoid extra "S" on verbs; 2sep2010
<span id="line148"></span>var lastword = false;  // 20mar07A: 29nov2006 For zeroing "seq" tags.
<span id="line149"></span>var len = 0;  // AI4U: Listen(); Audition(); reEntry(); word-length.
<span id="line150"></span>var life = true;  // AI4U: Shutdown(): for use in halting the AI.
<span id="line151"></span>var lurk = 0;  // counter to activate initial thinking; 29sep2010
<span id="line152"></span>var mfn = 0;  // 2apr2010 for En(glish) gender flag.
<span id="line153"></span>var mfnflag = 0;  // gender flag to cause a who-query; 3aug2011
<span id="line154"></span>var mg = 0;  // 2018-10-14: m(emory) gap for moving tkb in ReJuvenate()
<span id="line155"></span>var midway = 0;  // AI4U: audRecog: a stopping point for backward searches. 
<span id="line156"></span>var mjact = 0;   // 2018-01-12: motjuste-activation for defaulting to 701=I
<span id="line157"></span>var monopsi = 0;  // AI4U: audRecog: for recognition of a mono-character.
<span id="line158"></span>var moot = 0;  // flag to prevent associations in DO-queries; 22aug2011
<span id="line159"></span>var morphpsi = 0;  // for audRecog recognition of morphemes 
<span id="line160"></span>var motjuste = ""; // 2018-01-12: "best word for inclusion in a thought" 
<span id="line161"></span>var mri = 0;  // 2019-09-20: time of most-recent-instantiation - for back-tagging.
<span id="line162"></span>var mtx = 0;  // 2017-12-31: machine-translation xfer tag for flag-panel.
<span id="line163"></span>var negjux = 0;  // flag for 250=NOT juxtaposed to a verb; 21mar2013
<span id="line164"></span>var newpsi = 0;  // for singular-nounstem assignments; 18mar2013
<span id="line165"></span>var nlt = 5;  // AI4U: Listen(); CR(): time for "not-later-than".
<span id="line166"></span>// var node = 0;  // 11aug2006: For use with tutorial slosh-over display.
<span id="line167"></span>var nonce = 630;  // AI4U: Security(); Troubleshoot(): recent "nonce" time.
<span id="line168"></span>// var nounaud = 0;
<span id="line169"></span>var nounlock = 0;  // for a verb to lock onto a seq-noun; 13oct2011
<span id="line170"></span>// var nounval = 0;  // 20mar07A: 26dec2006: For transfer from nounPhrase to nounAct.
<span id="line171"></span>var now = "";     // 2018-01-24: holder of a Date() string for TranScript() etc.
<span id="line172"></span>var nphrnum = 0;  // 2018-03-17: noun-phrase num(ber) in InStantiate() etc.
<span id="line173"></span>var nphrpos = 0;  // for testing in EnCog; 13aug2010
<span id="line174"></span>var nucon = 0;  // 2018-01-23 flag to indicate a new concept for SpreadAct()
<span id="line175"></span>var num = 0;  // 2018-01-27: grammatical num(ber)
<span id="line176"></span>var numcon = "";  // number status flag to call RetroSet; 23mar2013
<span id="line177"></span>var numflag = 0;  // for EnArticle() 1oct2010
<span id="line178"></span>var numreq = 0;  // 2018-05-25: NUMber REQuired for agreement of subj &amp; pred. nom.
<span id="line179"></span>var numsubj = 0;  // for number of subject; 14jun2011
<span id="line180"></span>var nxr = 0;    // 2017-12-31: for AudRecog dealing with next memory row
<span id="line181"></span>var nxt = 0;    // 2017-01-09: number incremented for each new concept
<span id="line182"></span>var objnum = 0; // 2018-06-16: object number for sake of EnArticle()
<span id="line183"></span>var objprep = 0;  // 2018-10-28: object of a preposition; for EnPrep()
<span id="line184"></span>var oldpsi = 0;  // found by AudRecog() and stored in OldConcept(
<span id="line185"></span>var onset = 0;  // 20mar07A: Listen; Audition; reEntry; Speech: of a word.
<span id="line186"></span>// var oubliette = 0;  // 2018-01-18: size of vault+coda for ReJuvenate()
<span id="line187"></span>var output = "";  // 20mar07A: Voice(); Speech():  the "output" of the Mind.
<span id="line188"></span>var pho = "";    // 2018-01-12: pho(neme) of auditory input.
<span id="line189"></span>var phodex = 0;  // pho-index for AudBuffer(); 4jan2012
<span id="line190"></span>var pos = 5;  // 2018-01-23: 1=adj 2=adv 3=conj 4=interj 5=noun 6=prep 7=pron 8=verb 
<span id="line191"></span>var posflag = 0;  // AskUser discriminand; 13aug2010
<span id="line192"></span>var pov = "2";  // 2018-01-02: point-of-view: 1=self; 2=dual; 3=alien.
<span id="line193"></span>var prc = 0;  // was "provrec"; provisional recognition in AudRecog
<span id="line194"></span>var pre = 0;  // AI4U: Instantiate(): pre(vious associand) concept. 
<span id="line195"></span>// var precand = 0;   // 20mar07A: 30nov2006 Inviolate "pre" candidate.
<span id="line196"></span>var predflag = 0;  // indicates predicate nominative; 16sep2010
<span id="line197"></span>var prednom = 0;  // predicate nominative for InFerence; 18mar2013
<span id="line198"></span>var prejux = 0;  // previous jux to carry NOT to verb; 24jul2011
<span id="line199"></span>var prepcon = 0;  // 2018-01-21: prepositional condition-flag for parsing.
<span id="line200"></span>var prep = 0;     // 2018-10-26: preposition identifier for EnPrep()
<span id="line201"></span>var prepgen = 0;  // 2018-01-20: urgency to generate a prepositional phrase. 
<span id="line202"></span>var prepsi = 0;  // 2019-04-09: identifier of "pre" concept for activation to spread to.
<span id="line203"></span>// var preset = 0;  // 20mar07A: 30nov2006 For setting Instantiate() "pre".
<span id="line204"></span>var prevtag = 0;  // 20mar07A: 30nov2006 So Instantiate may declare "prevtag".
<span id="line205"></span>var prox1 = 0;  // first proximate concept of input cluster; 14sep2011
<span id="line206"></span>var prox2 = 0;  // for determining association among engrams; 14sep2011
<span id="line207"></span>var prox3 = 0;  // for disparate reactivation in ReActivate; 14sep2011
<span id="line208"></span>var proxcon = 0;  // flag to indicate usage of prox variables; 14sep2011
<span id="line209"></span>var prsn = 0;  // 1st, 2nd, 3rd person; or infinitive zero; 17jun2015
<span id="line210"></span>var prv = 0;   // 2017-12-31: for AudRecog() to examine pre(vious) row
<span id="line211"></span>var psi = 0;  // AI4U: Instantiate; audNode: associative tag to a concept.  
<span id="line212"></span>var psi0 = 0; // AI4U: first of the elements in a Psi concept panel.
<span id="line213"></span>var psi1 = 0;
<span id="line214"></span>var psi8 = 0;  // test; 13oct2011
<span id="line215"></span>// var psibase = 0;
<span id="line216"></span>var psidata = ("</span><span>&lt;b</span><span>&gt;" + "Concepts with associative tags for "); 
<span id="line217"></span>psidata += ("Natural Language Understanding:" + "</span><span>&lt;\</span><span>/b&gt;" + "</span><span>&lt;B</span><span>R&gt;");
<span id="line218"></span>psidata += ("krt tru psi hlc act mtx jux pos dba num mfn ");  // 2019-09-20 
<span id="line219"></span>psidata += ("pre seq tgn tdt tkb tia tcj tdj tdv tpr rv"); // 2019-09-20: expanded
<span id="line220"></span>var putnum = 0;  // putative num(ber) for subj-verb agreement; 24oct2011
<span id="line221"></span>var px1 = 0;    // 2019-09-20: preposition-transfer carrier for NLP generation.
<span id="line222"></span>var px2 = 0;    // 2019-09-20: preposition-transfer carrier for NLP generation.
<span id="line223"></span>var px3 = 0;    // 2019-09-20: preposition-transfer carrier for NLP generation.
<span id="line224"></span>// var questype = 0;  // AI4U: oldConcept; Conjoin(): flag for "why" questions.
<span id="line225"></span>// var quiet = true; // 2018-01-12: in AI4U, needed for the Think module. 
<span id="line226"></span>var quiet = false; // 2018-06-11: wait one thought-cycle for user input.
<span id="line227"></span>var qucon = 0;  // 2018-01-21: query-condition for dealing with query-words.
<span id="line228"></span>var quobj = 0;  // query-object for yes-or-no questions; 22jun2011
<span id="line229"></span>var quobjaud = 0;  // recall-tag for AskUser(); 20&amp;24jun2015
<span id="line230"></span>var qus = 0;  // provisional query-subject in advance of queries
<span id="line231"></span>var qusnum = 0;  // query-subject-number for AskUser; 28mar2013
<span id="line232"></span>var qusub = 0; // query subject in more readable code; 2oct2010
<span id="line233"></span>var qusubnum = 0;  // num(ber) of query-subject; 27oct2011
<span id="line234"></span>var quverb = 0;  // query-verb for yes-or-no questions; 22jun2011
<span id="line235"></span>var qv1psi = 0;  // 2018-01-12: concept for SpreadAct to seek as a subject 
<span id="line236"></span>var qv2num = 0;  // 2018-01-12: num(ber) of a verb in a who+verb+dir.obj response.
<span id="line237"></span>var qv2psi = 0;  // 2018-01-12: concept for SpreadAct to seek as a verb
<span id="line238"></span>var qv3psi = 0;  // 2018-01-12: concept for SpreadAct to seek as ind. obj.
<span id="line239"></span>var qv4psi = 0;  // 2018-01-12: concept for SpreadAct to seek as dir. obj. 
<span id="line240"></span>var qvdocon = 0; // 2018-01-23: query-condition for who+verb+direct-object. 
<span id="line241"></span>var qviocon = 0; // 2018-01-23: query-condition for who+verb+indirect-object. 
<span id="line242"></span>var recnum = 0;  // recognized number of a recognized word 20jul2011
<span id="line243"></span>var recon = 0;  // AI4U: newConceptl English; Ask(): incentive to question.
<span id="line244"></span>// var residuum = 0;  // 20mar07A: psiDamp(): level of post-thought activation.
<span id="line245"></span>var rjc = 0;    // AI4U: Rejuvenate(): counter of rejuvenations per lifetime. 
<span id="line246"></span>var rugov = 0;  // 2018-01-01: possible replacement for too strict "hlc"
<span id="line247"></span>var rsvp = 2000;  // AI4U: aLife: delay in milliseconds before next loop.
<span id="line248"></span>var rv = 0;  // 2017-12-31: recall-vector for auditory memory. 
<span id="line249"></span>var seq = 0;  // 2018-01-12: subSEQuent Psy concept in an idea.
<span id="line250"></span>var seqdob = 0;  // for direct object transfer within InFerence() 
<span id="line251"></span>var seqneed = 0;  // noun/pronoun or verb needed as a "seq"; 4oct2011
<span id="line252"></span>var seqpos = 0;  // "seq" concept part-of-sppeech; 4oct2011
<span id="line253"></span>var seqpsi = 0;  // for deglobalizing "seq" in SpreadAct(); 16sep2010
<span id="line254"></span>var seqrvx = 0;  // 2018-01-25: for rvx transfer within InFerence() 
<span id="line255"></span>var seqtkb = 0;  // for transfer during InFerence; 18mar2013
<span id="line256"></span>var seqverb = 0;  // interstitial carrier for InFerence; 18mar2013
<span id="line257"></span>var singflag = 0;  // singularity flag for singular nouns; 4nov2011
<span id="line258"></span>var skip = 0;  // 20mar07A: for use in Listen() to skip incomplete input.
<span id="line259"></span>var snu = 0;  // subject-number verb-selection parameter; 18oct2012
<span id="line260"></span>var spacegap = 0;  // 2017-12-31: to add gap of one space in Speech
<span id="line261"></span>var spike = 0;
<span id="line262"></span>var spt = 0;   // 2018-01-12: blank space time before start of a word
<span id="line263"></span>var stemgap = 0;  // for avoiding false AudRecog() stems 
<span id="line264"></span>var stempsi = 0;  // for singular noun-stem recognition; MF; 23jun2015
<span id="line265"></span>var subjcall = 0;  // To avoid showSubject() of articles; 21may2011
<span id="line266"></span>var subjectflag = 0;  // 9dec2009 For NounPhrase to call SelfRef.
<span id="line267"></span>var subjnom = 0;  // subject-nominative for InFerence; 18mar2013
<span id="line268"></span>var subjnum = 0;  // for agreement with predicate nominative; 18may2011
<span id="line269"></span>var subjold = 0;  // old subject as default candidate 29sep2010
<span id="line270"></span>var subjpre = 0;  // 2018-01-21: subject-pre to be held for verb in parsing.
<span id="line271"></span>var subjprsn = 0; // possible holder of "dba" for input verbs; 31oct2012
<span id="line272"></span>var subjpsi = 0;  // 2018-01-12: parameter to govern person of verb-forms 
<span id="line273"></span>var sublen = 0;  // length of AudRecog() subpsi word-stem 
<span id="line274"></span>var subpsi = 0;  // for AudRecog() of sub-component wordstems 
<span id="line275"></span>var svo1 = 0;  // 2018-01-04: subject -- item #1 in subject-verb-object
<span id="line276"></span>var svo2 = 0;  // 2018-01-04: verb -- item #2 in subject-verb-object
<span id="line277"></span>var svo3 = 0;  // 2018-01-04: indir. obj. -- item #3 in subject-verb-object
<span id="line278"></span>var svo4 = 0;  // 2018-01-04: dir. obj. -- item #4 in subject-verb-object
<span id="line279"></span>// var svoyes = false;
<span id="line280"></span>var t = 0;  // AI4U: Listen; CR; reEntry: time [may become "krt" (q.v.)].
<span id="line281"></span>var t2s = 0;    // 2017-12-31: auditory text-to-speech index 
<span id="line282"></span>var tbev = 0;  // 2018-06-12: time of be-verb for use with negjux negation-flag.
<span id="line283"></span>var tcj = 0;   // 2019-07-31: conceptual flag-panel time-of-conjunction.
<span id="line284"></span>var tdj = 0;   // 2019-07-31: conceptual flag-panel time-of-adjective.
<span id="line285"></span>var tdo = 0;   // 2018-01-21: time-of-direct-object for EnParser() module.
<span id="line286"></span>var tdt = 0;   // 2019-07-31: time-of-dative conceptual flag-panel indirect-object.
<span id="line287"></span>var tdv = 0;   // 2019-07-31: conceptual flag-panel time-of-adverb.
<span id="line288"></span>var tgn = 0;   // 2019-07-31: time-of-genitive for use in a Parser() module.
<span id="line289"></span>var tgv = 0;   // 2019-07-31: target-verb for EnVerbGen to generate verb-form.
<span id="line290"></span>var tia = 0;   // 2019-07-31: conceptual flag-panel time-of-instrumental ablative.
<span id="line291"></span>var tio = 0;   // 2018-01-21: time-of-indirect-object for EnParser() module.
<span id="line292"></span>var tkb = 0;   // 2017-12-31: time-in-knowledge-base of an idea.
<span id="line293"></span>var tkbn = 0;  // time of retroactive KB noun adjustment; 28jun2011
<span id="line294"></span>var tkbo = 0;  // 2018-01-29: time of retroactive KB direct-object adjustment; 
<span id="line295"></span>var tkbv = 0;  // time of retroactive KB verb adjustment; 28jun2011
<span id="line296"></span>var tnpr = 0;  // 2019-10-24: time-of-noum-preposition for EnPrep()
<span id="line297"></span>var topic = "";  // AI4U: newConcept; wtAuxSDo(): new nouns are ?-topics. 
<span id="line298"></span>var topicnum = 0;  // grammatical number of question "topic"; 18oct2011
<span id="line299"></span>var tov = 1;  // AI4U: SVO(); CR(); psiDamp; Reify:  time-of-voice. 
<span id="line300"></span>var tpp = 0;  // 2018-01-21: time-of-preposition for parsing.
<span id="line301"></span>var tpr = 0;  // 2019-07-31: conceptual flag-panel time-of-preposition.
<span id="line302"></span>var tpu = 0;  // 2018-01-02: time-pen-ultimate before current I/O;
<span id="line303"></span>var trouble = true;  // AI4U: HCI; Security; Troubleshoot: flag. 
<span id="line304"></span>var tseln = 0;  // NounPhrase: time of selection of noun; 10may2011
<span id="line305"></span>var tselo = 0;  // 2018-11-13: time of selection of object 
<span id="line306"></span>var tselp = 0;  // 2018-10-28: time of selection of preposiiton; for EnPrep()
<span id="line307"></span>var tsels = 0;  // 25oct2011
<span id="line308"></span>var tselv = 0;  // VerbPhrase: time of selection of Verb; 10may2011
<span id="line309"></span>var tsj = 0;  // 2018-01-21: time-of-subject for parsing.
<span id="line310"></span>var tru = 0;  // 2017-12-31: tru(th)-value tag for conceptual flag-panel
<span id="line311"></span>var tult = 0;  // AI4U: Audition; audSTM: penultimate time-minus-one. 
<span id="line312"></span>var tutor = false;  // AI4U: Security; Tutorial(): on/off status flag.
<span id="line313"></span>var tvb = 0;  // 2018-01-21: time-of-verb for parsing
<span id="line314"></span>var tvpr = 0; // 2019-10-24: time-of-verb-preposition for EnPrep()
<span id="line315"></span>var unk = "";  // AI4U: general variable for "unknown" items. 
<span id="line316"></span>var us1 = 0;  // 2018-09-04: http://ai.neocities.org/var.html#us1
<span id="line317"></span>var us2 = 0;  // 2018-09-04: "us2" for THE UpStream noun number two.
<span id="line318"></span>var us3 = 0;  // 2018-09-04: "us3" for THE UpStream noun number three.
<span id="line319"></span>var us4 = 0;  // 2018-09-04: for $psi # of THE noun mentioned upstream. 
<span id="line320"></span>var us5 = 0;  // 2018-09-04: for $psi # of THE noun during EnArticle().
<span id="line321"></span>var us6 = 0;  // 2018-09-04: for $psi # of THE noun on a rotating basis.
<span id="line322"></span>var us7 = 0;  // 2018-09-04: for $psi of an AI keeping seven items in mind.
<span id="line323"></span>var userline = "";  // AI4U: CR(); Transcribe():  text input of user.
<span id="line324"></span>var usn = 0;  // 2018-09-04: rotation-number for us1-us7 EnArticle() concepts. 
<span id="line325"></span>var usx = 0;  // 2018-09-04: transfer-variable for us1-us7 upstream variables.
<span id="line326"></span>var vacpsi = 0;  // de-globalized psi for VerbAct(); 1oct2010
<span id="line327"></span>var vault = 2204;   // 2019-11-07: size of MindBoot as revealed by diagnostic code.
<span id="line328"></span>var verblock = 0;  // for subject-noun to lock onto seq-verb; 13oct2011
<span id="line329"></span>var verbcon = 0;  // 2018-01-21: verb-condition for seeking (in)direct objects.
<span id="line330"></span>var verbpsi = 0;  // for transit into WhatAuxSVerb() 14jun2011
<span id="line331"></span>// var verbprsn = 3;  // changing to zero for infinitive forms; 17jun2015
<span id="line332"></span>var verbprsn = 0;  // reverting to zero for infinitive forms; 24jun2015
<span id="line333"></span>var vip = 0;  // special ID for verb created by VerbGen; 17oct2012
<span id="line334"></span>var vphract = 0;  // verb phrase activation level 22jun2011
<span id="line335"></span>var vphraud = 0;  // holds aud-fetch for SpeechAct; 28jun2011
<span id="line336"></span>var vrsn = "7nov19A"; // for Transcript mode; 2019-11-07
<span id="line337"></span>var wasvcon = 0;  // 2019-03-03: query-condition for what-AUXILIARY-SUBJECT-VERB
<span id="line338"></span>var wdsvcon = 0;  // 2018-12-22: what-do-subjects-VERB-condition for SpreadAct()
<span id="line339"></span>var whatcon = 0;  // 2018-01-21: flag for condition of answering a what-query
<span id="line340"></span>var wherecon = 0; // 2018-10-28: flag for condition of answering a where-query
<span id="line341"></span>var whoq = 0;     // 2019-03-03: flag for letting AskUser() ask a who-question
<span id="line342"></span>var wxdflag = 0;  // for inhibition of what-do-X-DO queries; 16sep2010
<span id="line343"></span>var wxvflag = 0;  // for inhibition of what-do-X-VERB queries; 16sep2010
<span id="line344"></span>var yncon = 0;  // a statuscon to trigger yes-or-no query; 27jun2011
<span id="line345"></span>var ynverb = 0;  // yes-or-no verb for AskUser; 29jun2011
<span id="line346"></span>
<span id="line347"></span>Psy = new Array(cns);  // 2019-07-31: increasing from 15 items to 21 items.
<span id="line348"></span>for (i = 0; i </span><span>&lt; </span><span>cns; i++) { 
<span id="line349"></span>  Psy[i] = new psyNode(" "," "," "," "," "," "," ",
<span id="line350"></span>  " "," "," "," "," "," "," ",
<span id="line351"></span>  " "," "," "," "," "," "," "); // 2019-07-31 
<span id="line352"></span>}  // AI4U: for spreadAct; Instantiate; oldConcept, etc. 
<span id="line353"></span>
<span id="line354"></span>
<span id="line355"></span>audMemory = new Array(cns);
<span id="line356"></span>for (i = 0; i </span><span>&lt; </span><span>cns; i++) {
<span id="line357"></span>  audMemory[i] = new audNode(" ",0," ");  // 2018-07-13: three columns.
<span id="line358"></span>}
<span id="line359"></span>
<span id="line360"></span>function Tutorial() {
<span id="line361"></span>  if (document.all["cb2"].checked == true) {
<span id="line362"></span>    document.all["cb1"].checked = false;
<span id="line363"></span>    document.all.souvenir.innerHTML = "";
<span id="line364"></span>    hardcopy = false;
<span id="line365"></span>    document.all["cb3"].checked = false;
<span id="line366"></span>    document.all.tabula.innerHTML = "";
<span id="line367"></span>    document.all.psicolumn.innerHTML = "";
<span id="line368"></span>    document.all.audcolumn.innerHTML = "";
<span id="line369"></span>    trouble = false;
<span id="line370"></span>    tutor = true;
<span id="line371"></span>    fyi = 2;
<span id="line372"></span>  }
<span id="line373"></span>  if (document.all["cb2"].checked == false) {
<span id="line374"></span>    fyi = 0;
<span id="line375"></span>    tutor = false;
<span id="line376"></span>  }
<span id="line377"></span>  document.forms[1].ear.focus();
<span id="line378"></span>}
<span id="line379"></span>
<span id="line380"></span>
<span id="line381"></span>function PsiDecay() {  // http://ai.neocities.org/PsiDecay.html
<span id="line382"></span>  for (i = t; i&gt;midway; --i) {  // AI4U: Loop backwards in recent time.
<span id="line383"></span>    Psy[i].psyExam();  // AI4U: Cycle through recent Psi nodes.
<span id="line384"></span>    if (psi3 &gt; 2) psi3 = (psi3 - 2);  // 2018-01-12: approach zero
<span id="line385"></span>    if (psi3 </span><span>&lt; </span><span>0) psi3 = (psi3 + 2);  // 2018-01-12: rapid recovery. 
<span id="line386"></span>    Psy[i] = new psyNode(psi0,psi1,psi2,psi3,psi4,psi5,psi6,
<span id="line387"></span>    psi7,psi8,psi9,psi10,psi11,psi12,psi13,
<span id="line388"></span>    psi14,psi15,psi16,psi17,psi18,psi19,psi20); // 2019-07-31
<span id="line389"></span>  } // AI4U: end of backwards loop
<span id="line390"></span>}  // 2019-07-31: PsiDecay() returns to various calling modules. 
<span id="line391"></span>
<span id="line392"></span>
<span id="line393"></span>function AudDamp() {  // 2018-01-09: remove activation from auditory engrams. 
<span id="line394"></span>  for (i = t; i &gt; midway; --i) {  // 2018-01-05: loop from time=t back to midway.
<span id="line395"></span>    audMemory[i].audExam(); // 2018-01-06: make values available for damping.
<span id="line396"></span>    audMemory[i] = new audNode(aud0,0,aud2);  // 2018-01-05: zero activation.
<span id="line397"></span>  }  // AI4U: End of cycling back to the loosely "midway" time-point. 
<span id="line398"></span>}  // 2018-01-09: AudDamp() returns to input module. 
<span id="line399"></span>
<span id="line400"></span>
<span id="line401"></span>function Shutdown() {
<span id="line402"></span>  if (document.all["cb4"].checked == true) {
<span id="line403"></span>    life = false;
<span id="line404"></span>    apb = "You have halted the AI Mind at Rejuvenation cycle #"+rjc+".";
<span id="line405"></span>    Voice();
<span id="line406"></span>  }
<span id="line407"></span>  if (document.all["cb4"].checked == false) {
<span id="line408"></span>    life = true;
<span id="line409"></span>    document.forms[1].ear.focus();
<span id="line410"></span>    TID=window.setTimeout("MainLoop();",1000);
<span id="line411"></span>  }
<span id="line412"></span>}
<span id="line413"></span>
<span id="line414"></span>function Destroy() {
<span id="line415"></span>  document.forms[1].ear.focus();
<span id="line416"></span>  life = false;
<span id="line417"></span>  apb = "Closing the window will destroy the AI.";
<span id="line418"></span>  Voice();
<span id="line419"></span>  alert("The AI Mind is alive. You may unclick your decision.");
<span id="line420"></span>  TID=window.setTimeout("window.close();",500);
<span id="line421"></span>}
<span id="line422"></span>
<span id="line423"></span>function Transcribe() {
<span id="line424"></span>  if (hardcopy == true) {  
<span id="line425"></span>   dialog += ("</span><span>&lt;P</span><span>&gt;Ghost: " + output);  // 2019-11-07: changed from Robot to Ghost
<span id="line426"></span>    dialog += ("</span><span>&lt;B</span><span>R&gt;Human: </span><span>&lt;b</span><span>&gt;" + userline + '</span><span>&lt;\</span><span>/b&gt;');
<span id="line427"></span>    output = "";  // avoid spurious repeats; 6nov2011
<span id="line428"></span>    userline = "";
<span id="line429"></span>  }
<span id="line430"></span>}
<span id="line431"></span>
<span id="line432"></span>
<span id="line433"></span>function Transcript() {
<span id="line434"></span>  if (document.all["cb1"].checked == true) {
<span id="line435"></span>    document.all["cb2"].checked = false;
<span id="line436"></span>    document.all["cb3"].checked = false;
<span id="line437"></span>    document.all.tabula.innerHTML = "";
<span id="line438"></span>    document.all.psicolumn.innerHTML = "";
<span id="line439"></span>    document.all.audcolumn.innerHTML = "";
<span id="line440"></span>    trouble = false;
<span id="line441"></span>    hardcopy = true;
<span id="line442"></span>    fyi = 1;
<span id="line443"></span>    now = new Date(); 
<span id="line444"></span>    adcopy=("</span><span>&lt;f</span><span>ont size='+2'&gt;AI Mind version "+vrsn+" on " +now+"</span><span>&lt;\</span><span>/b&gt;</span><span>&lt;\</span><span>/font&gt;");
<span id="line445"></span>    document.all.souvenir.innerHTML = adcopy;
<span id="line446"></span>  }
<span id="line447"></span>  Transcribe();
<span id="line448"></span>  if (hardcopy == true) {
<span id="line449"></span>    document.all.psicolumn.innerHTML = "";
<span id="line450"></span>    document.all.audcolumn.innerHTML = "";
<span id="line451"></span>  }
<span id="line452"></span>  document.all.tabula.innerHTML = dialog;
<span id="line453"></span>  if (document.all["cb1"].checked == false) {
<span id="line454"></span>    document.all.souvenir.innerHTML = "";
<span id="line455"></span>    hardcopy = false;
<span id="line456"></span>    document.all.tabula.innerHTML = "";
<span id="line457"></span>  }
<span id="line458"></span>  if (hardcopy == false) html = "";
<span id="line459"></span>}
<span id="line460"></span>
<span id="line461"></span>
<span id="line462"></span>function psiList() {
<span id="line463"></span>// nonce = 1;  // 2019-07-31: for troubleshooting; COMMENT-OUT BUT KEEP
<span id="line464"></span>  for (i = nonce; i </span><span>&lt; </span><span>(t +1); i++) {
<span id="line465"></span>    Psy[i].psyExam();
<span id="line466"></span>    psidata += ("</span><span>&lt;B</span><span>R&gt;" +i+ ". "+psi0+ " </span><span>&lt;b</span><span>&gt;" +psi1+"</span><span>&lt;\</span><span>/b&gt; " +psi2+" "+psi3+" "+psi4);
<span id="line467"></span>    psidata += (" "+psi5+" "+psi6+" "+psi7+" "+psi8+" "+psi9+" "+psi10);  // 2019-07-31
<span id="line468"></span>    psidata += (" "+psi11+" "+psi12+" "+psi13+" "+psi14+" "+psi15); // 2019-07-31
<span id="line469"></span>    psidata += (" "+psi16+" "+psi17+" "+psi18+" "+psi19+" "+psi20); // 2019-07-31
<span id="line470"></span>  }  // 2019-07-31: end of loop showing conceptual flag-panel data.
<span id="line471"></span>}  // 2019-07-31: psiList returns to Diagnostic()
<span id="line472"></span>
<span id="line473"></span>
<span id="line474"></span>function audList() {
<span id="line475"></span>  for (i = nonce; i </span><span>&lt; </span><span>(t +1); i++) {
<span id="line476"></span>    audMemory[i].audExam();
<span id="line477"></span>    if (aud0 == " ") aud1 = " ";
<span id="line478"></span>    auddata += ("</span><span>&lt;B</span><span>R&gt;" + i + ". </span><span>&lt;b</span><span>&gt;"+aud0+ "</span><span>&lt;\</span><span>/b&gt; "+aud1+" "+aud2); // 2018-01-06
<span id="line479"></span>  }
<span id="line480"></span>}
<span id="line481"></span>
<span id="line482"></span>
<span id="line483"></span>function KbLoad() {  // 2017-12-31: introduced from ghost.pl AI
<span id="line484"></span>  Psy[t] = new psyNode(tru,psi,hlc,act,mtx,jux,pos,
<span id="line485"></span>  dba,num,mfn,pre,seq,tgn,tdt,
<span id="line486"></span>  tkb,tia,tcj,tdj,tdv,tpr,rv);  // 2019-07-31
<span id="line487"></span>  tru=0;psi=0;hlc=0;act=0;mtx=0;jux=0;pos=0; // 2019-07-31: 
<span id="line488"></span>  dba=0;num=0;mfn=0;pre=0;seq=0;tgn=0;tdt=0; // 2019-07-31: 
<span id="line489"></span>  tkb=0;tia=0;tcj=0;tdj=0;tdv=0;tpr=0;rv=0;pho="";audpsi=0; // 2019-07-31
<span id="line490"></span>}  // 2019-07-31: end of KbLoad(); return to MindBoot knowledge bootstrap. 
<span id="line491"></span>
<span id="line492"></span>
<span id="line493"></span>function OutBuffer() {  // http://ai.neocities.org/OutBuffer.html
<span id="line494"></span>  b1=" ";  b2=" ";  b3=" ";  b4=" ";  b5=" ";  b6=" ";  // 2019-06-15
<span id="line495"></span>  b7=" ";  b8=" ";  b9=" ";  b10=" "; b11=" "; b12=" "; // 2019-06-15
<span id="line496"></span>  b13=" "; b14=" "; b15=" "; b16=" ";  // 2019-06-15: clear tabula rasa;
<span id="line497"></span>  if (c16&gt;"") {  // if the AudBuffer full; 4jan2012
<span id="line498"></span>    b1=c16; b2=c15; b3=c14; b4=c13; b5=c12; b6=c11; 
<span id="line499"></span>    b7=c10; b8=c9;  b9=c8;  b10=c7; b11=c6; b12=c5; 
<span id="line500"></span>    b13=c4; b14=c3; b15=c2; b16=c1;  // 2019-06-15
<span id="line501"></span>    return;  // abandon remainder of function; 4jan2012
<span id="line502"></span>  }  // end of transfer of a 16-character word; 4jan2012
<span id="line503"></span>  if (c15&gt;"") {  
<span id="line504"></span>    b1=c15; b2=c14; b3=c13; b4=c12; b5=c11; b6=c10;
<span id="line505"></span>    b7=c9;  b8=c8;  b9=c7;  b10=c6; b11=c5; b12=c4; 
<span id="line506"></span>    b13=c3; b14=c2; b15=c1; b16="";  // 2019-06-15
<span id="line507"></span>    return;  // 2019-06-15: abandon remainder of function;
<span id="line508"></span>  }  // 2019-06-15: end of transfer of a 15-character word.
<span id="line509"></span>  if (c14&gt;"") {
<span id="line510"></span>    b1=c14; b2=c13; b3=c12; b4=c11; b5=c10; b6=c9;
<span id="line511"></span>    b7=c8;  b8=c7;  b9=c6;  b10=c5; b11=c4; b12=c3;
<span id="line512"></span>    b13=c2; b14=c1; b15=""; b16="";  // 2019-06-15
<span id="line513"></span>    return;  // 2019-06-15: abandon remainder of function;
<span id="line514"></span>  }  // 2019-06-15: end of transfer of a 14-character word.
<span id="line515"></span>  if (c13&gt;"") {
<span id="line516"></span>    b1=c13; b2=c12; b3=c11; b4=c10; b5=c9; b6=c8;
<span id="line517"></span>    b7=c7;  b8=c6;  b9=c5;  b10=c4; b11=c3; b12=c2;
<span id="line518"></span>    b13=c1; b14=""; b15=""; b16="";  // 2019-06-15
<span id="line519"></span>    return;  // 2019-06-15: abandon remainder of function;
<span id="line520"></span>  }  // 2019-06-15: end of transfer of a 13-character word.
<span id="line521"></span>  if (c12&gt;"") {
<span id="line522"></span>    b1=c12; b2=c11; b3=c10; b4=c09; b5=c8;  b6=c7;
<span id="line523"></span>    b7=c6;  b8=c5;  b9=c4;  b10=c3; b11=c2; b12=c1;
<span id="line524"></span>    b13=""; b14=""; b15=""; b16="";  // 2019-06-15
<span id="line525"></span>    return;  // 2019-06-15: abandon remainder of function; 
<span id="line526"></span>  }  // 2019-06-15: end of transfer of a 12-character word.
<span id="line527"></span>  if (c11&gt;"") {
<span id="line528"></span>    b1=c11; b2=c10; b3=c9;  b4=c8;  b5=c7; b6=c6;
<span id="line529"></span>    b7=c5;  b8=c4;  b9=c3;  b10=c2; b11=c1; b12="";
<span id="line530"></span>    b13=""; b14=""; b15=""; b16="";  // 201-06-15
<span id="line531"></span>    return;  // 2019-06-15: abandon remainder of function;
<span id="line532"></span>  }  // 2019-06-15: end of transfer of an 11-character word.
<span id="line533"></span>  if (c10&gt;"") {
<span id="line534"></span>    b1=c10; b2=c9;  b3=c8;  b4=c7;  b5=c6;  b6=c5;
<span id="line535"></span>    b7=c4;  b8=c3;  b9=c2;  b10=c1; b11=""; b12="";
<span id="line536"></span>    b13=""; b14=""; b15=""; b16="";  // 2019-06-15
<span id="line537"></span>    return;  // 2019-06-15: abandon remainder of function;
<span id="line538"></span>  }  // 2019-06-15: end of transfer of a 10-character word.
<span id="line539"></span>  if (c9&gt;"") {
<span id="line540"></span>    b1=c9;  b2=c8;  b3=c7;  b4=c6;  b5=c5;  b6=c4;
<span id="line541"></span>    b7=c3;  b8=c2;  b9=c1;  b10=""; b11=""; b12="";
<span id="line542"></span>    b13=""; b14=""; b15=""; b16="";  // 2019-06-15
<span id="line543"></span>    return;  // 2019-06-15: abandon remainder of function;
<span id="line544"></span>  }  // 2019-06-15: end of transfer of a 9-character word.
<span id="line545"></span>  if (c8&gt;"") {
<span id="line546"></span>    b1=c8;  b2=c7;  b3=c6;   b4=c5;  b5=c4;  b6=c3;
<span id="line547"></span>    b7=c2;  b8=c1;  b9="";   b10=""; b11=""; b12="";
<span id="line548"></span>    b13=""; b14=""; b15=""; b16="";  // 2019-06-15
<span id="line549"></span>    return;  // 2019-06-15: abandon remainder of function;
<span id="line550"></span>  }  // 2019-06-15: end of transfer of an 8-character word.
<span id="line551"></span>  if (c7&gt;"") {
<span id="line552"></span>    b1=c7;  b2=c6;  b3=c5;  b4=c4;  b5=c3;  b6=c2;
<span id="line553"></span>    b7=c1;  b8="";  b9="";  b10=""; b11=""; b12="";
<span id="line554"></span>    b13=""; b14=""; b15=""; b16="";  // 2019-06-15
<span id="line555"></span>    return;  // 2019-06-15: abandon remainder of function;
<span id="line556"></span>  }  // 2019-06-15: end of transfer of a 7-character word.
<span id="line557"></span>  if (c6&gt;"") {
<span id="line558"></span>    b16=c6; b2=c5; b3=c4; b4=c3; b5=c2; b6=c1;
<span id="line559"></span>    b7="";  b8="";  b9="";  b10="";  b11="";  b12="";
<span id="line560"></span>    b13="";  b14="";  b15="";  b16="";  // 2019-06-15
<span id="line561"></span>    return;  // 2019-06-15: abandon remainder of function;
<span id="line562"></span>  }  // 2019-06-15: end of transfer of a 6-character word.
<span id="line563"></span>  if (c5&gt;"") {
<span id="line564"></span>    b1=c5;  b2=c4;  b3=c3;  b4=c2;  b5=c1;  b6="";
<span id="line565"></span>    b7="";  b8="";  b9="";  b10=""; b11=""; b12="";
<span id="line566"></span>    b13=""; b14=""; b15=""; b16="";  // 2019-06-15
<span id="line567"></span>    return;  // 2019-06-15: abandon remainder of function;
<span id="line568"></span>  }  // 2019-06-15: end of transfer of a 5-character word.
<span id="line569"></span>  if (c4&gt;"") {
<span id="line570"></span>    b1=c4;  b2=c3;  b3=c2;  b4=c1;  b5="";  b6="";
<span id="line571"></span>    b7="";  b8="";  b9="";  b10=""; b11=""; b12="";
<span id="line572"></span>    b13=""; b14=""; b15=""; b16="";  // 2019-06-15
<span id="line573"></span>    return;  // 2019-06-15: abandon remainder of function;
<span id="line574"></span>  }  // 20p19-06-15: end of transfer of a 4-character word.
<span id="line575"></span>  if (c3&gt;"") {
<span id="line576"></span>    b1=c3;  b2=c2;  b3=c1;  b4="";  b5="";  b6="";
<span id="line577"></span>    b7="";  b8="";  b9="";  b10=""; b11=""; b12="";
<span id="line578"></span>    b13=""; b14=""; b15=""; b16="";  // 2019-06-15
<span id="line579"></span>    return;  // 2019-06-15: abandon remainder of function;
<span id="line580"></span>  }  // 2019-06-15: end of transfer of a 3-character word.
<span id="line581"></span>  if (c2&gt;"") {
<span id="line582"></span>    b1=c2;  b2=c1;  b3="";  b4="";  b5="";  b6="";
<span id="line583"></span>    b7="";  b8="";  b9="";  b10=""; b11=""; b12="";
<span id="line584"></span>    b13=""; b14=""; b15=""; b16="";  // 2019-06-15
<span id="line585"></span>    return;  // 2019-06-15: abandon remainder of function;
<span id="line586"></span>  }  // 2019-06-15: end of transfer of a 2-character word.
<span id="line587"></span>  if (c1&gt;"") {
<span id="line588"></span>    b1=c1;  b2="";  b3="";  b4="";  b5="";  b6="";
<span id="line589"></span>    b7="";  b8="";  b9="";  b10=""; b11=""; b12="";
<span id="line590"></span>    b13=""; b14=""; b15=""; b16="";  // 2019-06-15
<span id="line591"></span>    return;  // 2019-06-15: abandon remainder of function;
<span id="line592"></span>  }  // 2019-06-15: end of transfer of a 1-character word.
<span id="line593"></span>}  // 2019-06-15: end of OutBuffer(); return to AudListen() or VerbGen().
<span id="line594"></span> 
<span id="line595"></span>
<span id="line596"></span>function AudBuffer() {  // http://ai.neocities.org/AudBuffer.html
<span id="line597"></span>  phodex = (phodex + 1);  // 2019-06-15: increment by one with each iteration.
<span id="line598"></span>  if (phodex==1) {  // 2019-06-15: if beginning the count of characters...
<span id="line599"></span>    c1=abc; c2=""; c3=""; c4=""; c5=""; c6=""; c7=""; c8=""; 
<span id="line600"></span>    c9="";  c10=""; c11=""; c12=""; c13=""; c14=""; c15=""; c16="";
<span id="line601"></span>  }   // 2019-06-15: end of using phodex=1 to blank out the AudBuffer.
<span id="line602"></span>  if (phodex==2)  c2=abc;    // 2019-06-15
<span id="line603"></span>  if (phodex==3)  c3=abc;    // 2019-06-15
<span id="line604"></span>  if (phodex==4)  c4=abc;    // 2019-06-15
<span id="line605"></span>  if (phodex==5)  c5=abc;    // 2019-06-15
<span id="line606"></span>  if (phodex==6)  c6=abc;    // 2019-06-15
<span id="line607"></span>  if (phodex==7)  c7=abc;    // 2019-06-15
<span id="line608"></span>  if (phodex==8)  c8=abc;    // 2019-06-15
<span id="line609"></span>  if (phodex==9)  c9=abc;    // 2019-06-15
<span id="line610"></span>  if (phodex==10)  c10=abc;  // 4jan2012
<span id="line611"></span>  if (phodex==11)  c11=abc;  // 4jan2012
<span id="line612"></span>  if (phodex==12)  c12=abc;  // 4jan2012
<span id="line613"></span>  if (phodex==13)  c13=abc;  // 4jan2012
<span id="line614"></span>  if (phodex==14)  c14=abc;  // 4jan2012
<span id="line615"></span>  if (phodex==15)  c15=abc;  // 4jan2012
<span id="line616"></span>  if (phodex==16)  c16=abc;  // 4jan2012
<span id="line617"></span>}  // end of AudBuffer(); return to AudListen() or VerbGen().
<span id="line618"></span>
<span id="line619"></span>
<span id="line620"></span>function psyExam() {  // 2017-12-31: renamed to conform with ghost.pl AI.
<span id="line621"></span>  psi0 = this.tru;  // 2017-12-31
<span id="line622"></span>  psi1 = this.psi;  // 2017-12-31
<span id="line623"></span>  psi2 = this.hlc;  // 2017-12-31
<span id="line624"></span>  psi3 = this.act;  // 2017-12-31
<span id="line625"></span>  psi4 = this.mtx;  // 2017-12-31
<span id="line626"></span>  psi5 = this.jux;  // 2017-12-31
<span id="line627"></span>  psi6 = this.pos;  // 2017-12-31
<span id="line628"></span>  psi7 = this.dba;  // 2017-12-31
<span id="line629"></span>  psi8 = this.num;  // 2017-12-31
<span id="line630"></span>  psi9 = this.mfn;  // 2017-12-31
<span id="line631"></span>  psi10 = this.pre; // 2017-12-31
<span id="line632"></span>  psi11 = this.seq; // 2019-07-31
<span id="line633"></span>  psi12 = this.tgn; // 2019-07-31
<span id="line634"></span>  psi13 = this.tdt; // 2019-07-31
<span id="line635"></span>  psi14 = this.tkb; // 2019-07-31
<span id="line636"></span>  psi15 = this.tia; // 2019-07-31
<span id="line637"></span>  psi16 = this.tcj; // 2019-07-31
<span id="line638"></span>  psi17 = this.tdj; // 2019-07-31
<span id="line639"></span>  psi18 = this.tdv; // 2019-07-31
<span id="line640"></span>  psi19 = this.tpr; // 2019-07-31
<span id="line641"></span>  psi20 = this.rv;  // 2019-07-31
<span id="line642"></span>} // 2019-07-31: for use with "new PsyNode" etc. 
<span id="line643"></span>
<span id="line644"></span>
<span id="line645"></span>function psyNode(tru,psi,hlc,act,mtx,jux,pos,dba,num,mfn,
<span id="line646"></span>  pre,seq,tgn,tdt,tkb,tia,tcj,tdj,tdv,tpr,rv) { 
<span id="line647"></span>  this.tru = tru;  // 2017-12-31: deemed truth-value from ghost.pl AI
<span id="line648"></span>  this.psi = psi;
<span id="line649"></span>  this.hlc = hlc;  // 2017-12-31: human-language code from ghost.pl AI
<span id="line650"></span>  this.act = act; 
<span id="line651"></span>  this.mtx = mtx;  // 2017-12-31: machine translation xfer from ghost.pl AI
<span id="line652"></span>  this.jux = jux;
<span id="line653"></span>  this.pos = pos;
<span id="line654"></span>  this.dba = dba;  // 2017-12-31: grammar function from ghost.pl AI
<span id="line655"></span>  this.num = num;
<span id="line656"></span>  this.mfn = mfn;  // 2017-12-31: male/female/neuter gender code from ghost.pl AI
<span id="line657"></span>  this.pre = pre;
<span id="line658"></span>  this.seq = seq;  // 2019-07-31: important for identifying an actual concept; 
<span id="line659"></span>  this.tgn = tgn;  // 2019-07-31: time-of-genitive (for Latin, Russian, German etc.)
<span id="line660"></span>  this.tdt = tdt;  // 2019-07-31: time-of-dative
<span id="line661"></span>  this.tkb = tkb;  // 2019-07-31: time-in-kb for use with nouns or verbs
<span id="line662"></span>  this.tia = tia;  // 2019-07-31: time-of-instrumental/ablative (Russian/Latin)
<span id="line663"></span>  this.tcj = tcj;  // 2019-07-31: time-of-conjunction
<span id="line664"></span>  this.tdj = tdj;  // 2019-07-31: time of adjective
<span id="line665"></span>  this.tdv = tdv;  // 2019-07-31: time-of-adverb
<span id="line666"></span>  this.tpr = tpr;  // 2019-07-31: time-of-preposition
<span id="line667"></span>  this.rv = rv;    // 2017-12-31: auditory recall-vector from ghost.pl AI
<span id="line668"></span>  this.psyExam = psyExam;  // 2017-12-31:
<span id="line669"></span>}  // 2019-07-31: psyNode() returns to various modules using psyExam().
<span id="line670"></span>
<span id="line671"></span>
<span id="line672"></span>function InStantiate() { // http://ai.neocities.org/InStantiate.html 
<span id="line673"></span>  prevtag = 0;  // 2018-01-11: Reset for safety. 
<span id="line674"></span>  if (qucon &gt; 0 &amp;&amp; qv2psi == 800) {  // 2018-03-2: before query-subject comes in...
<span id="line675"></span>  }  // 2018-03-02: end of test for who-query and be-verb before query-subject. 
<span id="line676"></span>  if (pov == 2) {  // 2018-01-23: only during external input, not re-entry
<span id="line677"></span>    if (pos == 5) {  // 2018-01-27: If external noun comes in...
<span id="line678"></span>      quobj = psi;  // 2018-01-27: query-object for AskUser()
<span id="line679"></span>    }  // 2018-01-27: End of test for a noun.
<span id="line680"></span>    if (wherecon==1 &amp;&amp; pos==5) qusub = psi;  // 2018-10-28: TEST
<span id="line681"></span>    if (wherecon==1 &amp;&amp; pos==7) qusub = psi;  // 2018-10-28: TEST
<span id="line682"></span>    if (psi == 791) {  // 2018-01-23: upon input of 791=WHO
<span id="line683"></span>      if (qucon==0) {  // 2018-06-16: to set only once per input idea
<span id="line684"></span>        qucon = 1;  // 2018-01-23: set positive to process rest of input.
<span id="line685"></span>        whocon = 1; // 2018-12-23: set positive for use in SpreadAct().
<span id="line686"></span>      }  // 2018-06-16: end of test for qucon at zero. 
<span id="line687"></span>    }  // 2018-01-23: end of test for qucon at zero. 
<span id="line688"></span>    if (psi == 781) {  // 2018-01-23: upon input of 781=WHAT
<span id="line689"></span>      if (whatcon == 0) {  // 2018-01-23: to set only once per input idea
<span id="line690"></span>        whatcon = 1;  // 2018-01-23: set positive to process rest of input.
<span id="line691"></span>      }  // 2018-01-23: end of test for $whatcon at zero. 
<span id="line692"></span>    }  // 2018-01-23: end of test for input of 781=WHAT
<span id="line693"></span>  } // 2018-01-23: for later fill-in with conditionals for SpreadAct()
<span id="line694"></span>  if (qucon &gt; 0) {  // 2018-01-23: deal with more than "who is" queries...
<span id="line695"></span>    if (psi == 800) {  // 2018-00-23: if 800=Be-Verb...
<span id="line696"></span>      qv2psi = 800;  // 2018-01-23: for transfer to SpreadAct()
<span id="line697"></span>    }  // 2018-01-23: end of test for 800=BE.
<span id="line698"></span>    if (pos == 8 &amp;&amp; psi != 800) {  // 2018-01-23: if verb but not 800=BE
<span id="line699"></span>      qvdocon = 1;  // 2018-01-23: set flag for query who+verb+direct-object. 
<span id="line700"></span>      qv2psi = psi; // 2018-01-23: for transfer to SpreadAct() 
<span id="line701"></span>    }  // 2018-01-23: end of test for verb other than 800=BE. 
<span id="line702"></span>    if (qvdocon &gt; 0 &amp;&amp; pos == 5) {  // 2018-01-23: if 5=noun comes in...
<span id="line703"></span>      qv4psi = psi;  // 2018-01-23: to send direct object into SpreadAct()
<span id="line704"></span>    }  // 2018-01-23: end of test for noun during who-verb-dirobj query.
<span id="line705"></span>  }  // 2018-01-23: end of test for positive query-condition qucon.
<span id="line706"></span>  if (whatcon &gt; 0) {  // 2018-01-23: deal with what-queries...
<span id="line707"></span>    if (psi == 800) {  // 2018-01-23: if 800=Be-Verb...
<span id="line708"></span>      qv2psi = 800;  // 2018-01-23: for transfer to SpreadAct()
<span id="line709"></span>    }  // 2018-01-23: end of test for 800=BE. 
<span id="line710"></span>    if (pos==5 || pos==7) {  // 2018-01-23: if 5=noun or 7=pronoun...
<span id="line711"></span>      qv1psi = psi;  // 2018-01-23: for transfer as query-subject to SpreadAct()
<span id="line712"></span>    }  // 2018-01-23: end of test for 5=noun or 7=pronoun
<span id="line713"></span>    if (pos==8 &amp;&amp; psi != 800 &amp;&amp; psi != 818) { // 2018-11-28: if verb but not 818=DO
<span id="line714"></span>      qv2psi = psi;  // 2018-01-23: for transfer as query-verb to SpreadAct()
<span id="line715"></span>    }  // 2018-11-28: end of test for verb other than auxiliary 818=DO. 
<span id="line716"></span>  } // 2018-01-23: end of test for positive query-condition whatcon.
<span id="line717"></span>  if (oldpsi == 701) pos = 7;  // 2018-01-11: 7 = pronoun.
<span id="line718"></span>  if (pov==2) {  // 2019-03-13: only during external input not re-entry.
<span id="line719"></span>    for (i=tpu; i&gt;midway; --i) {  // 2018-01-11: from time-penultimate backwards...
<span id="line720"></span>      Psy[i].psyExam(); // 2018-01-11: examine the Psy concept array...
<span id="line721"></span>      if (psi1 == oldpsi) {  // 2018-01-11: if incoming psi matches old psi...
<span id="line722"></span>        psi3 = (psi3 + 24);  // 2019-04-09: activate enough to spark a thought
<span id="line723"></span>        if (psi1 == 781) psi3 = 0;  // 2018-05-13: deactivate 781=WHAT input. 
<span id="line724"></span>        if (wherecon==1) psi3 = 128; // 2018-10-28: TEST
<span id="line725"></span>        Psy[i] = new  // 2018-01-23: inserting [psi3]act with higher activation: 
<span id="line726"></span>        psyNode(psi0,psi1,psi2,psi3,psi4,psi5,psi6,
<span id="line727"></span>        psi7,psi8,psi9,psi10,psi11,psi12,psi13,
<span id="line728"></span>        psi14,psi15,psi16,psi17,psi18,psi19,psi20); // 2019-07-31: expanded flag-panel
<span id="line729"></span>        if (psi10 &gt; 0) {  // 2019-04-09: if there is a "pre" concept...
<span id="line730"></span>          prepsi = psi10;  // 2019-04-09: grab hold of the "pre" as "prepsi".
<span id="line731"></span>          for (j = tpu; j&gt;midway; j--) {  // 2019-04-09: search with first inner loop
<span id="line732"></span>            Psy[j].psyExam(); // 2019-04-09: examine the Psy concept array...
<span id="line733"></span>            if (psi1 == prepsi) {  // 2019-04-09: if first inner loop finds prepsi...
<span id="line734"></span>              for (x = tpu; x&gt;midway; x--) {  // 2019-04-09: second inner loop
<span id="line735"></span>                Psy[x].psyExam(); // 2019-04-09: examine the Psy concept array...
<span id="line736"></span>                if (psi1&gt;0 &amp;&amp; psi11==prepsi) {  // 2019-07-31: if subject of "prepsi"...
<span id="line737"></span>                  Psy[x] = new  // 2019-04-09: psi3 value activates subject of "prepsi"
<span id="line738"></span>                  psyNode(psi0,psi1,psi2,32,psi4,psi5,psi6,
<span id="line739"></span>                  psi7,psi8,psi9,psi10,psi11,psi12,psi13,
<span id="line740"></span>                  psi14,psi15,psi16,psi16,psi18,psi19,psi20); // 2019-07-31: expansion.
<span id="line741"></span>                }  // 2019-04-09: end of test for subject of "prepsi".
<span id="line742"></span>              }  // 2019-04-09: end of second inner loop searching for subject of prepsi.
<span id="line743"></span>            }  // 2019-04-09: end of test for "prepsi".        
<span id="line744"></span>          }  // 2019-04-09: end of backwards inner loop. 
<span id="line745"></span>        }  // 2019-04-09: end of test for existence of a "pre" concept.
<span id="line746"></span>      }  // 2018-01-11: end of search for old engram of incoming psi.
<span id="line747"></span>    }  // 2018-01-11: end of for-loop examining Psy concept array.
<span id="line748"></span>  }  // 2019-02-13: end of test for point-of-view to be 2=pov external for input.
<span id="line749"></span>  if (pos==5 &amp;&amp; num==0) num = instnum;  // 2018-01-27: for nouns; 
<span id="line750"></span>  if (pos==8 &amp;&amp; num==0) {  // 2018-01-27: if no verb num from holdnum... 
<span id="line751"></span>    if (nphrnum &gt; 0) num = nphrnum;  // 2018-01-27: if positive nphrnum.
<span id="line752"></span>  }  // 2018-01-27: end of test to use nphrnum to store verb num(ber).
<span id="line753"></span>  if (pos==8) num = nphrnum;  // 2018-01-27: verb agrees w. subject;
<span id="line754"></span>  if (psi==818 &amp;&amp; moot==1) prevtag = 0;  // 2018-11-28: 818=DO for AskUser()
<span id="line755"></span>  if (psi==818 &amp;&amp; moot==1) tkb = 0;  // 2018-11-28: 818=DO for AskUser()
<span id="line756"></span>  if (psi==818 &amp;&amp; moot==1) seq = 0;  // 2018-11-28: 818=DO for AskUser()
<span id="line757"></span>  if (pos==8 &amp;&amp; infincon==1) {  // 2018-01-27: from Askuser() or EnAuxVerb();
<span id="line758"></span>    num = 0;  // 2018-01-27: no num(ber) with infinitive; 
<span id="line759"></span>    infincon = 0;  // 2018-01-27: reset for safety; 
<span id="line760"></span>  }  // 2018-01-27: end of test for infinitive condition.
<span id="line761"></span>  tult = (t - 1);  // 2018-01-11: penultimate time
<span id="line762"></span>  act = -48;  // 2018-01-11: for a "trough" of recent-most inhibition. 
<span id="line763"></span>  Psy[tult].psyExam(); // 2018-01-11: examine the Psy concept array...
<span id="line764"></span>  if (tkb == tdo) { tkb = 0 };  // 2018-07-12: prevent direct-object tkb
<span id="line765"></span>  Psy[tult] = new psyNode(444,psi1,psi2,act,psi4,psi5,psi6,
<span id="line766"></span>  psi7,psi8,psi9,psi10,psi11,psi12,psi13,
<span id="line767"></span>  psi14,psi15,psi16,psi17,psi18,psi19,psi20);  // 2019-09-21:   
<span id="line768"></span>  instnum = 0;  // 2018-01-27: after transfer from OldConcept(); 
<span id="line769"></span>  Psy[tvb].psyExam(); // 2019-09-20: expose flag-panel at tvb
<span id="line770"></span>  if (tsj&gt;0 &amp;&amp; verbcon&gt;0 &amp;&amp; t&gt;tvb &amp;&amp;tdo==0) tdo = tult;  // 2019-09-20:
<span id="line771"></span>  Psy[tvb] = new  // 2019-09-20: re-assemble the tvb-row with tdo as psi14.
<span id="line772"></span>  psyNode(555,psi1,psi2,psi3,psi4,psi5,psi6,  // 2019-09-21: locus of spurious psi19
<span id="line773"></span>  psi7,psi8,psi9,psi10,psi11,psi12,psi13,
<span id="line774"></span>  tdo,psi15,psi16,psi17,psi18,psi19,psi20); // 2019-09-20: tdo as tkb  
<span id="line775"></span>  if (tkb == tdo) tkb = 0;  // 2019-09-20: prevent direct-object tkb
<span id="line776"></span>  Psy[tult] = new  // 2019-09-20: 
<span id="line777"></span>  psyNode(tru,psi,hlc,act,mtx,jux,pos,
<span id="line778"></span>  dba,num,mfn,pre,seq,tgn,tdt,
<span id="line779"></span>  tkb,tia,tcj,tdj,tdv,tpr,rv); // 2019-09-20: expanded conceptual flag-panel.
<span id="line780"></span>  if (pos==5 || pos==8) {  // 2019-09-120: for a noun or a verb...
<span id="line781"></span>    tult = (t - 1);  // 2019-09-21: re-establish in case at zero.
<span id="line782"></span>    mri = tult;  // 2019-09-120: time-of-most-recent-instantiation, for back-tagging.
<span id="line783"></span>  }  // 2019-09-20: end of restriction by part-of-speech.
<span id="line784"></span>  if (verbcon == 1 &amp;&amp; tdo == 0) tdo = tult;  // 2019-09-21: from ghost.pl AI
<span id="line785"></span>  tult = 0;  // 2019-09-21: reset for safety; from ghost.pl AI
<span id="line786"></span>  if (jux == 250) jux = 0;  // 2018-06-12 from 27jun15A: reset after use; 
<span id="line787"></span>  if (prejux == 250) { // 2018-06-11 from 27jun15A: 250=NOT from OldConcept; 
<span id="line788"></span>    jux = 250;  // 2018-06-12 from 27jun15A: set jux for next instantiand; 
<span id="line789"></span>    prejux = 0;  // 2018-06-12 from 27jun15A: reset for safety;
<span id="line790"></span>  }  // 2018-06-12 from 27jun15A: end of post-instantiation test.
<span id="line791"></span>  if (pos == 5 &amp;&amp; psi &gt; 0) usx = psi;  // 2018-09-04: for transfer to EnArticle()
<span id="line792"></span>  if (pos == 5 || pos == 7) prevtag = psi;  // 2018-01-21: after subject
<span id="line793"></span>  if (pos == 8) prevtag = psi;  // 2018-01-21: after a verb.
<span id="line794"></span>  if (pos == 8 &amp;&amp; seqneed == 0) seq = psi;  //  2018-01-11: for the seq of a subject
<span id="line795"></span>  if (pos == 5 || pos == 7) {  // 2018-01-11: if noun or pronoun...
<span id="line796"></span>    seq = 0;  // 2018-01-11: until set by the seqneed mechanism...
<span id="line797"></span>    if (seqneed == 0) seqneed = 8;  // 2018-01-11: if start of input sentence...
<span id="line798"></span>    if (seqneed == 5) seqneed = 0;  // 2018-01-11: for subject only
<span id="line799"></span>  }  // 2018-01-11: 
<span id="line800"></span>  if (pos == 5 || pos == 7) qv1psi = psi;  // 2018-01-21: the subject-concept  
<span id="line801"></span>  if (pos == 8) qv2psi = psi;  // 2018-02-04: for SpreadAct() or EnArticle()
<span id="line802"></span>  if (pos == 8) seqneed = 5;  // 2018-01-11: if verb, need direct object.
<span id="line803"></span>  pre = 0;  // 2018-01-21: Reset to prevent carry-over. 
<span id="line804"></span>  prepsi = 0;  // 2019-04-09: prevent carry-over.
<span id="line805"></span>}  // 2019-09-20: InStantiate() returns to EnParser(). 
<span id="line806"></span>
<span id="line807"></span>
<span id="line808"></span>function EnParser() { // http://ai.neocities.org/EnParser.html 
<span id="line809"></span>  act = 48; // 2018-01-11: an arbitrary activation for InStantiate()
<span id="line810"></span>  bias = 5; // 2018-01-10: Expect a noun until overruled. 
<span id="line811"></span>  InStantiate();  // 2019-09-20: first instantiation during parsing Stage One
<span id="line812"></span>  if (pos == 5) bias = 8;  // 2018-01-11: after noun, expect verb.
<span id="line813"></span>  if (pos == 7) bias = 8;  // 2018-01-11: after pronoun, expect verb.
<span id="line814"></span>  if (pos == 8) bias = 5;  // 2018-01-11: after verb, expect noun
<span id="line815"></span>  if (prepcon == 0)  {  // 2018-01-21: if not handling a preposition...
<span id="line816"></span>    if (pos == 5 || pos == 7) {  // 2018-01-21: noun or pronoun...
<span id="line817"></span>      tsj = (t - 1);  // 2018-01-21: time of subject (for pinpoint searches) 
<span id="line818"></span>      if (verbcon == 1) {  // 2018-01-21: if a verb has come in...
<span id="line819"></span>        if (tio == 0) tdo = tult;  // 2018-01-21: set once or twice
<span id="line820"></span>        if (tio == 0) tio = tult;  // 2018-01-21: set only once
<span id="line821"></span>        if (tio &gt; 0) {  // 2018-01-21: if tio previously set...
<span id="line822"></span>          tdo = tult;  // 2019-01-21: second noun sets time of dir.obj.
<span id="line823"></span>        }  // 2018-01-21: end of test to make 2nd noun the direct object.
<span id="line824"></span>        tkb = tdo;  // 2018-01-21: let verb have a "nounlock" to direct object.
<span id="line825"></span>        Psy[tvb].psyExam(); // 2018-01-21: expose flag-panel of verb
<span id="line826"></span>        pre = psi1;  // 2018-01-21: verb psi will be pre of direct object
<span id="line827"></span>        Psy[tio].psyExam(); // 2018-01-21: expose flag-panel of indir. obj.
<span id="line828"></span>        iob = psi1;   // 2019-09-20: excerpt indirect-object concept for psi13
<span id="line829"></span>        Psy[tio] = new  // 2019-09-20: insert [psi7]dba "3" for indirect object.
<span id="line830"></span>        psyNode(psi0,psi1,psi2,psi3,psi4,psi5,psi6,
<span id="line831"></span>        3,psi8,psi9,psi10,psi11,psi12,psi13,
<span id="line832"></span>        psi14,psi15,psi16,psi17,psi18,psi19,psi20); // 2019-09-20: expanded flag-panel
<span id="line833"></span>        // 2018-01-21: Above lines insert psi7 dba=3 for dative-case indirect object. 
<span id="line834"></span>        Psy[tdo].psyExam(); // 2018-01-21: expose flag-panel of direct object
<span id="line835"></span>        psi10 = pre;  // 2018-01-21: obtain the "pre" of the direct object
<span id="line836"></span>        Psy[tdo] = new  // 2018-01-21: insert [psi7]dba "4" for direct object.
<span id="line837"></span>        psyNode(psi0,psi1,psi2,psi3,psi4,psi5,psi6,
<span id="line838"></span>        4,psi8,psi9,psi10,psi11,psi12,psi13,
<span id="line839"></span>        0,psi15,psi16,psi17,psi18,psi19,psi20); // 2019-09-20: no tkb for dir.obj.
<span id="line840"></span>        // 2019-07-31: Above liness insert verb-psi as psi10 "pre" of direct object. 
<span id="line841"></span>        Psy[tvb].psyExam(); // 2018-01-21: expose flag-panel of main verb.
<span id="line842"></span>        tdo = t - 1;  // 2018-01-21: insert time-of-direct-object for nounlock; 
<span id="line843"></span>        tkb = tdo;  // 2018-01-21: from verb, "nounlock" leads to direct object.
<span id="line844"></span>        // 2018-01-21: Next two lines create psy-array row for a verb: 
<span id="line845"></span>        Psy[tvb] = new  // 2018-01-21: insert [psi7]dba "4" for direct object.
<span id="line846"></span>        psyNode(psi0,psi1,psi2,psi3,psi4,psi5,psi6,  // 2019-09-21: spurious psi19?
<span id="line847"></span>        4,psi8,psi9,psi10,psi,psi12,iob,
<span id="line848"></span>        tkb,psi15,psi16,psi17,psi18,psi19,psi20); // 2019-07-31: expanded flag-panel.
<span id="line849"></span>        tkb = 0;  // 2018-05-30: BUGFIX -- the tdo is a valid tkb only for a verb.
<span id="line850"></span>      }  // 2018-01-21: end of test for a condition following a verb. 
<span id="line851"></span>    }  // 2018-01-21: end of test for noun not object of a preposition.
<span id="line852"></span>  }  // 2018-01-21: end of test for a non-prepositional condition.
<span id="line853"></span>  if (pos == 6) prepcon = 1;  // 2018-01-21: if 6=preposition, prepare for noun.
<span id="line854"></span>  if (pos == 6) prepcon = 1; // 2019-09-22: leave out any tult==zero
<span id="line855"></span>  if (pos == 5 || pos == 7) {  // 2018-01-21: if a noun or a pronoun... 
<span id="line856"></span>    if (prepcon == 1) {  // 2018-11-13: only when handling a preposition.
<span id="line857"></span>      Psy[tpr].psyExam(); // 2019-08-04: expose flag-panel of preposition.
<span id="line858"></span>      pre = psi1;  // 2018-01-21: Let "pre" briefly be the preposition.
<span id="line859"></span>      prep = psi1;  // 2018-11-13: identify "prep" to be the "seq" of the verb. 
<span id="line860"></span>      psi14 = tult;   // 2019-07-31: establish "tkb" between preposition and its object. 
<span id="line861"></span>      Psy[tpp] = new  // 2018-01-21: noun or pronoun is [psi12]seq of the preposition. 
<span id="line862"></span>      psyNode(psi0,psi1,psi2,psi3,psi4,psi5,psi6,
<span id="line863"></span>      4,psi8,psi9,psi10,psi,psi12,psi13,
<span id="line864"></span>      psi14,psi15,psi16,psi17,psi18,psi19,psi20); // 2019-07-31: expanded flag-panel.
<span id="line865"></span>      Psy[tult].psyExam(); // 2018-01-21: expose flag-panel of object of preposition.
<span id="line866"></span>      Psy[tult] = new  // 2018-01-21: obj. of prep. has 4=dba; prep. as "pre"; no "seq" 
<span id="line867"></span>      psyNode(psi0,psi1,psi2,psi3,psi4,psi5,psi6,
<span id="line868"></span>      4,psi8,psi9,pre,0,psi12,psi13,
<span id="line869"></span>      psi14,psi15,psi16,psi17,psi18,psi19,psi20); // 2019-07-31: expanded flag-panel.
<span id="line870"></span>      prepcon = 0;  // 2018-01-21: Reset to prevent carry-over. 
<span id="line871"></span>    }  // 2018-11-13: end of test for positive "prepcon". 
<span id="line872"></span>  }  // 2018-01-21: end of test for a noun or pronoun.
<span id="line873"></span>  if (pos == 8 &amp;&amp; psi != 800 &amp;&amp; psi != 818) {  // 2019-09-20:  not "BE" or "DO"
<span id="line874"></span>    tvb = (t - 1);  // 2018-01-21: hold onto time-of-verb for flag-insertions.
<span id="line875"></span>    verbcon = 1;  // 2018-01-21: verb-condition is "on" for ind. &amp; dir. objects.
<span id="line876"></span>    Psy[tsj].psyExam(); // 2018-01-21: expose flag-panel of subject noun
<span id="line877"></span>    subjpre = psi1;  // 2018-01-21: Hold onto subjpre for the pos=8 verb
<span id="line878"></span>    Psy[tsj] = new  // 2019-07-31: insert [psi7]dba; [psi11]seq; [psi14]tkb
<span id="line879"></span>    psyNode(psi0,psi1,psi2,psi3,psi4,psi5,psi6,
<span id="line880"></span>    1,psi8,psi9,psi10,psi,psi12,psi13,
<span id="line881"></span>    tvb,psi15,psi16,psi17,psi18,psi19,psi20); // 2019-07-31: expanded flag-panel.
<span id="line882"></span>    tult = (t - 1);  // 2019-09-21: necessary to prevent tult of zero. 
<span id="line883"></span>    Psy[tult].psyExam(); // 2018-01-21: expose flag-panel of verb
<span id="line884"></span>    Psy[tult] = new  // 2019-07-31: insert [psi10]pre; [psi11]seq (temporary zero) 
<span id="line885"></span>    psyNode(888,psi1,psi2,psi3,psi4,psi5,psi6,  // 2019-09-21: TEST; REVERT to psi0
<span id="line886"></span>    psi7,psi8,psi9,subjpre,0,psi12,psi13,
<span id="line887"></span>    psi14,psi15,psi16,psi17,psi18,psi19,psi20); // 2019-07-31: expanded flag-panel,
<span id="line888"></span>    subjpre = 0;  // 2018-01-21: Reset for safety. 
<span id="line889"></span>  }  // 2018-01-21: end of test for a pos=8 verb.
<span id="line890"></span>  if (tpr &gt; 0 &amp;&amp; pos == 5) {  // 2019-09-20: if a noun follows a preposition... 
<span id="line891"></span>    Psy[tpr].psyExam(); // 2019-09-20: expose flag-panel at time-of-prep.
<span id="line892"></span>    tkb = (t - 1);  // 2019-09-20: time of object of preposition
<span id="line893"></span>    Psy[tpr] = new  // 2019-09-20: create a new row at time-of-preposition "tpr"
<span id="line894"></span>    psyNode(998,psi1,psi2,psi3,psi4,psi5,psi6,  // 2019-09-21: TEST; REVERT to psi0
<span id="line895"></span>    psi7,psi8,psi9,psi10,psi11,psi12,psi13,
<span id="line896"></span>    tkb,psi15,psi16,psi17,psi18,psi19,psi20); // 2019-09-20: insert tkb value as psi14.
<span id="line897"></span>  }  // 2019-09-20: end of test for a noun after a preposition.
<span id="line898"></span>  if (pos==6 &amp;&amp; mri&gt;0 &amp;&amp; pov==2) {  // 2019-09-20: during external input
<span id="line899"></span>    tpr = (t - 1);  // 2019-09-20: time-of-preposition for back-tag insertion. 
<span id="line900"></span>    Psy[mri].psyExam(); // 2019-09-21: expose flag-panel of most-recent word
<span id="line901"></span>    Psy[mri] = new  // 2019-09-21: create a new row at time-of-most-recent word
<span id="line902"></span>    psyNode(999,psi1,psi2,psi3,psi4,psi5,psi6,  // 2019-09-21: TEST; REVERT to psi0
<span id="line903"></span>    psi7,psi8,psi9,psi10,psi11,psi12,psi13,
<span id="line904"></span>    psi14,psi15,psi16,psi17,psi18,tpr,psi20); // 2019-09-20: insert time-of-preposition.
<span id="line905"></span>  }  // 2019-09-20: end of test for preposition part-of-speech and external point-of-view.
<span id="line906"></span>}  // 2019-09-20: EnParser() returns to OldConcept() or NewConcept().
<span id="line907"></span>
<span id="line908"></span>
<span id="line909"></span>function KbRetro() {  // http://ai.neocities.org/KbRetro.html 
<span id="line910"></span>  if (kbzap == 432 || kbzap == 404) {  // 2018-01-28: if 432=YES or 404=NO...
<span id="line911"></span>    if (kbzap == 404) {  // 2018-01-28: 404=NO; 
<span id="line912"></span>      apb = "KbRetro() adjusts the knowledge base for the answer: NO";
<span id="line913"></span>      Voice(); // 2018-01-29: display "apb" message
<span id="line914"></span>      Psy[tkbv].psyExam(); // 2018-12-16: expose all values before making changes.
<span id="line915"></span>      Psy[tkbv] = new // 2018-01-27: changing psi3=act; psi5=jux;
<span id="line916"></span>      psyNode(0,quverb,1,128,0,250,8,
<span id="line917"></span>      0,psi8,0,qusub,quobj,psi12,psi13,
<span id="line918"></span>      tkbo,psi15,psi16,psi17,psi18,psi19,0);  // 2019-07-31: expanded flag-panel.
<span id="line919"></span>    }  // 2018-01-27: End of test for "no" answer.
<span id="line920"></span>    if (kbzap == 432) { // 2018-01-28: 432=YES; 
<span id="line921"></span>      apb = "KbRetro() adjusts the knowledge base for the answer: YES";
<span id="line922"></span>      Voice(); // 2018-01-29: display "apb" message
<span id="line923"></span>      Psy[tkbv].psyExam(); // 2018-01-27: expose all values to change one; 
<span id="line924"></span>   Psy[tkbv] = new  // 2018-01-27: changing psi0=tru(th); psi3=act; 
<span id="line925"></span>// psyNode(0,psi1,1,64,0,0,8,3,1,0,qusub,psi11,quobj,tkbo,0);  // 2018-10-11: 1=English
<span id="line926"></span>      psyNode(0,psi1,1,128,0,0,8,
<span id="line927"></span>      3,1,0,qusub,quobj,psi12,psi13,
<span id="line928"></span>      tkbo,psi15,psi16,psi17,psi18,psi19,0);  // 2019-07-31: expanded flag-panel.
<span id="line929"></span>    }  // 2018-01-27: end of test for a "yes" answer.  
<span id="line930"></span>    Psy[tkbn].psyExam(); // 2018-01-29: expose all values to change one; 
<span id="line931"></span>    Psy[tkbn] = new // 2018-01-29: changing psi3=act; psi12=seq;
<span id="line932"></span>    psyNode(8,psi1,1,64,0,0,5,
<span id="line933"></span>    1,psi8,0,0,quverb,psi12,psi13,
<span id="line934"></span>    tkbv,psi15,psi16,psi17,psi18,psi19,0);  // 2019-07-31: 1 = English
<span id="line935"></span>    Psy[tkbo].psyExam(); // 2018-01-29: may cause "Error on page"?
<span id="line936"></span>    Psy[tkbo] = new // 2018-01-29: changing psi3=act; psi7=dba; psi10=pre;
<span id="line937"></span>    psyNode(0,psi1,1,64,0,0,5,
<span id="line938"></span>    4,psi8,0,quverb,0,0,0,
<span id="line939"></span>    0,psi15,psi16,psi17,psi18,psi19,0);  // 2019-07-31: expanded flag-panel.
<span id="line940"></span>  }  // 2018-01-27: end of test for either yes or no.  
<span id="line941"></span>  else {  // 2018-01-27: if neither; 
<span id="line942"></span>  Psy[tkbn].psyExam(); // 2018-01-27: remove associative pre and seq tags from noun; 
<span id="line943"></span>  Psy[tkbn] = new  // 2019-07-31: changing psi10=pre; psi11=seq.
<span id="line944"></span>  psyNode(psi0,psi1,psi2,psi3,psi4,psi5,psi6,
<span id="line945"></span>  psi7,psi8,psi9,0,0,psi12,psi13,
<span id="line946"></span>  psi14,psi15,psi16,psi17,psi18,psi19,psi20); // 2019-07-31: expanded flag-panel.
<span id="line947"></span>  Psy[tkbv].psyExam(); // 2018-01-27: remove associative pre and seq tags from verb; 
<span id="line948"></span>  Psy[tkbv] = new  // 2019-07-31: changing psi10=pre; psi11=seq.
<span id="line949"></span>  psyNode(psi0,psi1,psi2,psi3,psi4,psi5,psi6,
<span id="line950"></span>  psi7,psi8,psi9,0,0,psi12,psi13,
<span id="line951"></span>  psi14,psi15,psi16,psi17,psi18,psi19,psi20); // 2019-07-31: expanded flag-panel.
<span id="line952"></span>  }  // 2018-01-27: end of else-clause.
<span id="line953"></span>  quobj = 0;  // 2018-01-29: reset for safety.
<span id="line954"></span>  tkbn = 0;   // 2018-01-27: reset for safety; 
<span id="line955"></span>  tkbv = 0;   // 2018-01-27: reset for safety; 
<span id="line956"></span>  PsiDecay()  // 2018-01-27: for distribution of PsiDecay influence; 
<span id="line957"></span>}  // 2019-07-31: KbRetro() returns to EnThink()
<span id="line958"></span>
<span id="line959"></span>
<span id="line960"></span>function OldConcept() { // http://ai.neocities.org/OldConcept.html 
<span id="line961"></span>  if (pov == 1) psi = oldpsi;  // 2018-01-27: for sake of AskUser.
<span id="line962"></span>  for (i=tpu; i&gt;midway; --i) {  // 2018-01-11: from time-penultimate backwards...
<span id="line963"></span>    Psy[i].psyExam(); // 2018-01-11: examine the Psy concept array...
<span id="line964"></span>      if (psi1 == oldpsi) {  // 2018-01-11: if same concept found...
<span id="line965"></span>        if (psi6 &gt; 0) pos = psi6;  // 2018-01-11: pos = part of speech
<span id="line966"></span>        if (psi9 &gt; 0) mfn = psi9;  // 2018-01-11: mfn = male/femal/neuter gender.
<span id="line967"></span>      }  // 2018-01-11: 
<span id="line968"></span>  }  // 2018-01-11: 
<span id="line969"></span>  if (hlc != "ru") {  // 2018-01-23: test for governing human-language-code 
<span id="line970"></span>    if (pov == "2") {  // 2018-01-25: Only during "2" external POV; 
<span id="line971"></span>      if (oldpsi==800) becon = 1;  // 2018-01-25: flag for calling InFerence() 
<span id="line972"></span>    }  // 2018-01-25: end of test for external POV. 
<span id="line973"></span>    if (oldpsi == 800) tbev = (t-1);  // 2018-01-23: for be-verb negation.
<span id="line974"></span>    if (oldpsi == 250) {  // 2018-01-23: 250=NOT for negation of a verb. 
<span id="line975"></span>      if (tbev &gt; 0) {  // 2018-01-23: if positive be-verb time...
<span id="line976"></span>        Psy[tbev].psyExam();  // 2018-01-23: examine Psy array
<span id="line977"></span>        psi5 = 250;  // 2018-01-23: set "jux" of verb to 250=NOT for negation. 
<span id="line978"></span>        Psy[tbev] = new  // 2018-01-23: insert [psi5]jux 250=NOT for negation of verb
<span id="line979"></span>        psyNode(psi0,psi1,psi2,psi3,psi4,psi5,psi6,
<span id="line980"></span>        psi7,psi8,psi9,psi10,psi11,psi12,psi13,
<span id="line981"></span>        psi14,psi15,psi16,psi17,psi18,psi19,psi20); // 2019-07-31: expanded flag-panel.
<span id="line982"></span>        tbev = 0;  // 2018-01-23: reset for safety.   
<span id="line983"></span>      }  // 2018-01-23: end of test for a positive "tbev" time-of-be-verb.
<span id="line984"></span>    }  // 2018-01-23: end of test for negation of a verb with "NOT".
<span id="line985"></span>    if (oldpsi == 432) kbzap = 432;  // 2018-01-28: 432=YES for KbRetro()
<span id="line986"></span>    if (oldpsi == 404) kbzap = 404;  // 2018-01-28: 404=NO for KbRetro()
<span id="line987"></span>    psi = oldpsi;  // 2018-01-11: for transfer to InStantiate()
<span id="line988"></span>    if (pov == 2) {  // 2018-01-23: during a pov "dual" (you and I) conversation...
<span id="line989"></span>      if (oldpsi == 245) wherecon = 1;  // 2018-10-28: if "Where?" 
<span id="line990"></span>      if (oldpsi == 245) prepgen = 8;  // 2018-01-23: if "Where?" call EnPrep()
<span id="line991"></span>      if (oldpsi == 707) { psi = 701; rv = 0 }  // 2018-01-23: interpret "YOU" as "I";
<span id="line992"></span>      if (oldpsi == 701) { psi = 707; rv = 0 }  // 2018-01-23: interpret "I" as "YOU".
<span id="line993"></span>      if (oldpsi == 731) { psi=737; num=2; dba=1; rv=0 } // 2018-01-23: we --&gt; you.
<span id="line994"></span>    }  // 2018-01-23: end of test for other person communicating with the AI.
<span id="line995"></span>    if (oldpsi == 250) {  // 2018-06-11: upon recognition of 250=NOT; 
<span id="line996"></span>      prejux = 250;  // 2018-06-11: flag for concept to be negated; 
<span id="line997"></span>    }  // 2018-06-11: end of test for input or ReEntry of 250=NOT.
<span id="line998"></span>    if (pos==5) num = audnum;  // 2018-01-27:
<span id="line999"></span>    if (pos==8) num = holdnum;  // 2018-01-27:
<span id="line1000"></span>    if (pos==5) holdnum = audnum;  // 2018-01-27: transfer to verb;
<span id="line1001"></span>    EnParser(); // 2018-01-11: In preparation to call InStantiate().
<span id="line1002"></span>  }  // 2018-01-23: end of test for English human-language-code 
<span id="line1003"></span>  if (pov == 2) {  // 2018-01-25: external pov during input; 
<span id="line1004"></span>    if (pos == 5) {  // nouns only, not yet pronouns; 18mar2013
<span id="line1005"></span>      if (subjnom &gt; 0) {  // already subjnom? 18mar2013
<span id="line1006"></span>        prednom = oldpsi;  // for InFerence; 18mar2013
<span id="line1007"></span>      }  // end of test for pre-existing subjnom; 18mar2013
<span id="line1008"></span>      if (prednom == 0) {  // no prednom yet? 18mar2013
<span id="line1009"></span>        subjnom = oldpsi;  // grab for InFerence; 18mar2013
<span id="line1010"></span>        subjnum = num;  // grab for AskUser; 18mar2013
<span id="line1011"></span>        qusnum = num;  // query-subject-number for AskUser; 28mar2013
<span id="line1012"></span>      }  // alternate between subjnom and prednom; 18mar2013
<span id="line1013"></span>    }  // end of test for a noun; 18mar2013
<span id="line1014"></span>    if (pos == 8) {  // verb part-of-speech? 18mar2013
<span id="line1015"></span>      if (oldpsi != 800) {  // other than be-verb? 18mar2013
<span id="line1016"></span>        subjnom = 0;  // cancel out any subjnom; 18mar2013
<span id="line1017"></span>      }  // end of test for a be-verb; 18mar2013
<span id="line1018"></span>    }  // end of test for a verb; 18mar2013
<span id="line1019"></span>  }  // end of test for external-input POV; 18mar2013
<span id="line1020"></span>  audpsi = 0;  // 2018-01-06: prevent carry-over. 
<span id="line1021"></span>  audrec = 0;  // 2018-09-21: prevent carry-over. 
<span id="line1022"></span>  dba = 0;  // 2018-01-27: Reset to prevent carry-over.
<span id="line1023"></span>  len = 0;  // 2018-01-04: reset to avoid carry-over.
<span id="line1024"></span>  mfn = 0;  // 2019-10-25: prevent carry-over to other recognized concepts.
<span id="line1025"></span>  prc = 0;  // 2018-01-17: reset for safety
<span id="line1026"></span>  oldpsi = 0;  // 2018-01-17: reset for safety
<span id="line1027"></span>  PsiDecay();  // 2018-01-12: TEST; REMOVE
<span id="line1028"></span>  audrun = 0;  // 2018-01-15: reset for safety. 
<span id="line1029"></span>  AudDamp();  // 2018-01-17: deactivate engrams from outside of AudInput()
<span id="line1030"></span>  tbev = 0;   // 2018-06-12 BUGFIX: reset for safety; 
<span id="line1031"></span>}  // 2019-10-25: OldConcept() returns to AudInput().
<span id="line1032"></span>
<span id="line1033"></span>
<span id="line1034"></span>function NewConcept() {  // http://ai.neocities.org/NewConcept.html
<span id="line1035"></span>  psi = nxt; // 2018-01-10: For xfer to InStantiate(). 
<span id="line1036"></span>  qusub = nxt; // 2018-01-23: for sending new concept into SpreadAct()
<span id="line1037"></span>  pos = bias;  // 2018-01-23: InStantiate() stores value from Parser().
<span id="line1038"></span>  if (predflag == 1 &amp;&amp; pos == 5) dba = 1;  // 2018-01-27: noun; 
<span id="line1039"></span>  if (pov == 2) {  // 2018-01-27: if new psi, probably external POV anyway;
<span id="line1040"></span>    if (pos == 5) {  // 2018-01-27: if noun...
<span id="line1041"></span>      dba = 1;  // 2018-01-27: nominative is a default at first;
<span id="line1042"></span>    }  // 2018-01-27: end of test for noun or pronoun;
<span id="line1043"></span>    if (pos == 8) {  // 2018-01-27: if part-of-speech is verb...
<span id="line1044"></span>      dba = 3;  // 2018-01-27: third person is a default at first;
<span id="line1045"></span>      if (subjprsn==1) dba = 1;  // 2018-01-27: 1st prsn I or WE; 
<span id="line1046"></span>      if (subjprsn==2) dba = 2;  // 2018-01-27: 2nd prsn 707=YOU; 
<span id="line1047"></span>      if (subjprsn==3) dba = 3;  // 2018-01-27: 3rd prsn; 
<span id="line1048"></span>    }  // 2018-01-27: end of test for input of a verb; 
<span id="line1049"></span>  }  // 2018-01-27: end of test for external POV. 
<span id="line1050"></span>  if (pos==5) num = audnum;  // 2018-01-27: pass for storage; 
<span id="line1051"></span>  if (pos==8) num = holdnum;  // 2018-01-27: 
<span id="line1052"></span>  if (pos==5) holdnum = audnum;  // 2018-01-27: transfer to verb. 
<span id="line1053"></span>  EnParser();  // 2018-01-10: In preparation to call InStantiate().
<span id="line1054"></span>  if (pos == 5) {  // 2018-01-27: if noun
<span id="line1055"></span>    cognum = instnum;  // 2018-01-27: from InStantiate; 
<span id="line1056"></span>    nucon = 1;  // 2018-01-27: for SpreadAct()
<span id="line1057"></span>    qusub = psi;  // 2018-01-27: for SpreadAct()
<span id="line1058"></span>    recon = 1;  // 2018-01-27:
<span id="line1059"></span>    topic = nxt;  // 2018-01-27: potentially a query "topic"; 
<span id="line1060"></span>  }  // 2018-01-27: 
<span id="line1061"></span>  if (pos == 8) quverb = nxt;  // 2018-01-27: for AskUser()
<span id="line1062"></span>  if (pov == "2") {  // 2018-01-27: external pov during input? 
<span id="line1063"></span>    if (pos == 5) {  // 2018-01-27: nouns only, not pronouns; 
<span id="line1064"></span>      if (subjnom &gt; 0) {  // 2018-01-27: already subjnom? 
<span id="line1065"></span>        // There may not be inferences from new prednoms:
<span id="line1066"></span>        prednom = newpsi;  // 2018-01-27: infer from prednom; 
<span id="line1067"></span>      }  // 2018-01-27: end of test for pre-existing subjnom; 
<span id="line1068"></span>      if (prednom == 0) {  // 2018-01-27: subject-slot still open? 
<span id="line1069"></span>        subjnom = newpsi;  // 2018-01-27: grab for InFerence()
<span id="line1070"></span>        subjnum = num;  // 2018-01-27: grab for AskUser()
<span id="line1071"></span>        qusnum = num;  // 2018-01-27: query-subject-number for AskUser; 
<span id="line1072"></span>      }  // 2018-01-27: alternate between subjnon and prednom; 
<span id="line1073"></span>    }  // 2018-01-27: end of test for a noun; 
<span id="line1074"></span>  }  // 2018-01-27: end of test for external-input POV.
<span id="line1075"></span>  audpsi = 0; // 2018-01-06: reset to prevent carry-overs. 
<span id="line1076"></span>  len = 0; // 2018-01-04: reset to avoid carry-over.
<span id="line1077"></span>  oldpsi = 0;  // 2018-01-17: reset for safety
<span id="line1078"></span>  PsiDecay();  // 2018-01-12: TEST; REMOVE
<span id="line1079"></span>  if (kbcon &gt; 0) {  // 2018-01-27: if user answers yes-or-no question; 
<span id="line1080"></span>  }  // 2018-01-27: User has had one chance to answer yes-or-no question.
<span id="line1081"></span>  audrun = 0;  // 2018-01-15: reset for safety. 
<span id="line1082"></span>  prc = 0;  // 2018-01-17: reset for safety
<span id="line1083"></span>  AudDamp();  // 2018-01-17: deactivate engrams from outside of AudInput()
<span id="line1084"></span>}  // 2018-01-04: NewConcept() returns to AudInput().
<span id="line1085"></span>
<span id="line1086"></span>
<span id="line1087"></span>function AudRecog() {  // http://ai.neocities.org/AudRecog.html 
<span id="line1088"></span>  if (audrun == 0 &amp;&amp; pho == " ") audrun = 0;  // 2018-01-08: non-increment here only.
<span id="line1089"></span>  if (pho=="A"||pho=="B"||pho=="C"||pho=="D"||pho=="E"||pho=="F") audrun++; // 2018-01-07
<span id="line1090"></span>  if (pho=="G"||pho=="H"||pho=="I"||pho=="J"||pho=="K"||pho=="L"||pho=="M") audrun++; 
<span id="line1091"></span>  if (pho=="N"||pho=="O"||pho=="P"||pho=="Q"||pho=="R"||pho=="S"||pho=="T") audrun++; 
<span id="line1092"></span>  if (pho=="U"||pho=="V"||pho=="W"||pho=="X"||pho=="Y"||pho=="Z") audrun++; // 2018-01-07
<span id="line1093"></span>  len = audrun;  // 2018-01-17: TEST 
<span id="line1094"></span>   if (pho != 0 &amp;&amp; pho != 13 &amp;&amp; pho != 32 &amp;&amp; pho != " ") {  // 2018-01-15
<span id="line1095"></span>    if (audrec &gt; 0) {  // 2018-01-05: if positive audrec before end of word...
<span id="line1096"></span>      if (pho != 83) {  // 2018-01-05: keep audrec if current pho is 83=S  
<span id="line1097"></span>        if (audrec &gt; 0) prc = audrec;  // 2018-09-21: preserve non-final $audrec
<span id="line1098"></span>        audrec = 0; // 2018-01-05: zero out non-final audrec. 
<span id="line1099"></span>      }  // 2018-01-05: end of test for final "S" as inflectional ending.
<span id="line1100"></span>    }  // 2018-01-05: end of test for audrec before word-end
<span id="line1101"></span>  }  // 2018-01-05: end of test for an alphabetic character. 
<span id="line1102"></span>  if (pho == 13 || pho == 32 || pho == " ") {  // 2018-01-17: if 13=CR or 32=SPACE...
<span id="line1103"></span>    if (audrec &gt; 0) {  // 2018-01-05: if positive audrec before 32=SPACE...
<span id="line1104"></span>      audpsi = audrec;  // 2018-0q-05: recognized item becomes storage item.
<span id="line1105"></span>    }  // 2018-01-05: end of test for a positive audrec before 32=SPACE.
<span id="line1106"></span>  }  // 2018-01-05: end of test for a non-alphabetic character after a word. 
<span id="line1107"></span>  for (i=t; i&gt;midway; i--) { // 2018-10-14: prevent misrecognition of new concepts.
<span id="line1108"></span>    if (pho != " ") {  // 2018-01-08: if not SPACE " "...   
<span id="line1109"></span>       audMemory[i].audExam(); // 2018-01-05: examine contents of auditory memory.  
<span id="line1110"></span>      if (aud0 != pho) audMemory[i] = new audNode(aud0,0,aud2); // 2018-01-05:
<span id="line1111"></span>       if (pho == aud0) {  // 2018-01-05: if incoming pho matches stored aud0...
<span id="line1112"></span>        if (aud1 == 0) {  // 2018-01-05: if matching engram has no activation; 
<span id="line1113"></span>          if (audrun </span><span>&lt; </span><span>2) {  // 2018-01-08: i.e., if audrun is number one...
<span id="line1114"></span>            audMemory[i-1].audExam(); // 2018-01-05: examine previous row
<span id="line1115"></span>            if (aud0==13 || aud0==32 || aud0==" ") {  // 2018-01-05: if 13=CR or 32=SPACE...
<span id="line1116"></span>              if (audrun </span><span>&lt; </span><span>2) {  // 2018-01-05: if comparing start of a word..
<span id="line1117"></span>                audMemory[i+1].audExam(); // 2018-01-07: examine Next-In-\Line char...
<span id="line1118"></span>                if (aud0 != " ") {  // 2018-01-08: if not SPACE " "
<span id="line1119"></span>                  audMemory[i+1] = new audNode(aud0,8,aud2); // 2018-01-05: activate N-I-L
<span id="line1120"></span>                }  // 2018-01-05: end of test for continuation of stored comparand. 
<span id="line1121"></span>                audMemory[i].audExam(); // 2018-01-05: examine current character
<span id="line1122"></span>                if (aud2 &gt; 0) {  // 2018-01-05: if concept number present...
<span id="line1123"></span>                  prc = aud2;  // 2018-01-05: provisional recognition
<span id="line1124"></span>                }  // 2018-01-05: end of test for potential monopsi ultimate-tag
<span id="line1125"></span>              }  // 2018-01-05: end of test for audrun=1 start of word.
<span id="line1126"></span>            }  // 2018-01-05: end of test for a beginning non-active aud0.  
<span id="line1127"></span>          }  // 2018-01-08: end of test for first audrun.
<span id="line1128"></span>        }  // 2018-01-05: "end of test for matching aud0 with no activation"
<span id="line1129"></span>        audMemory[i].audExam(); // 2018-01-05: examine current character
<span id="line1130"></span>        if (aud1 &gt; 0) {  // 2018-01-05: If aud0 has activation, matching or not.
<span id="line1131"></span>          if (aud2 &gt; 0) prc = aud2;  // 2018-01-09: TEST; REMOVE
<span id="line1132"></span>            audMemory[i+1].audExam(); // 2018-01-05: examine next-in-line char...
<span id="line1133"></span>          if (aud0 == pho) {  // 2018-01-08: if matches specific pho now coming in... 
<span id="line1134"></span>            audMemory[i+1] = new audNode(aud0,8,aud2); // 2018-01-05: activate N-I-L
<span id="line1135"></span>          }  // 2018-01-05: end of match-test
<span id="line1136"></span>          if (aud0=" ") {  // 2018-01-08: if engram is SPACE " "
<span id="line1137"></span>            if (aud1 &gt; 0) {  // 2018-01-08: TEST for activation
<span id="line1138"></span>              if (aud2 &gt; 0) {  // 2018-01-08: if engram has concept number
<span id="line1139"></span>                prc = aud2;  // 2018-01-08: provisional recognition of a stem 
<span id="line1140"></span>              }  // 2018-01-05: end of test for positive audpsi
<span id="line1141"></span>            }  // 2018-01-05: end of test for activation.
<span id="line1142"></span>            if (pho == " ") {  // 2018-01-08: if blank input
<span id="line1143"></span>              if (audrec &gt; 0) {  // 2018-01-05: if an audrec has been found...
<span id="line1144"></span>               audpsi = audrec; // 2018-01-05: send audpsi into AudMem()
<span id="line1145"></span>              }  // 2018-01-05: end of test for a positive audrec
<span id="line1146"></span>            }  // 2018-01-05: end of test for 13=CR or 32=SPACE
<span id="line1147"></span>            if (pho != " ") {  // 2018-01-08: if non-blank input
<span id="line1148"></span>              audMemory[i+1].audExam(); // 2018-01-05: examine next-in-line char...
<span id="line1149"></span>            if (aud0 != " ");  // 2018-01-08: if not a blank SPACE...
<span id="line1150"></span>              audMemory[i+1] = new audNode(aud0,8,aud2); // 2018-01-05: activate N-I-L
<span id="line1151"></span>            }  // 2018-01-08: since next engram is a letter...
<span id="line1152"></span>          } // 2018-01-08: end of test for 32-SPACE after input word.
<span id="line1153"></span>        }  // 2018-01-08: "End of test for matching aud0 with activation."
<span id="line1154"></span>      }  // 2018-01-08: End of test for a character matching "pho".
<span id="line1155"></span>    }  // 2018-01-08: end of test for alphabet letter 
<span id="line1156"></span>  }  // 2018-01-05: End of backwards search through auditory memory. 
<span id="line1157"></span>  if (audrec &gt; 0) audpsi = audrec;  // 2018-01-06: hand-off for storage in AudMem() 
<span id="line1158"></span>  if (prc &gt; 0) {  // 2018-01-09: expanding code to include a reset of "prc".
<span id="line1159"></span>    audrec = prc;  // 2018-01-05: provisional recognition becomes actual.
<span id="line1160"></span>    prc = 0;  // 2018-01-09: reset to prevent carry-over.
<span id="line1161"></span>  }  // 2018-01-09: end of test for a positive "prc".
<span id="line1162"></span> } // 2018-01-05: End of AudRecog(); return to AudMem() 
<span id="line1163"></span>
<span id="line1164"></span>
<span id="line1165"></span>function audExam() {
<span id="line1166"></span>  aud0 = this.pho;    // 2018-09-21: character as if phoneme
<span id="line1167"></span>  aud1 = this.act;    // 2018-09-21: activation level
<span id="line1168"></span>  aud2 = this.audpsi; // 2018-09-21: concept-number
<span id="line1169"></span>}
<span id="line1170"></span>
<span id="line1171"></span>function audNode(pho,act,audpsi) {  // 2018-07-13: three items per row.
<span id="line1172"></span>  this.pho = pho;
<span id="line1173"></span>  this.act = act;
<span id="line1174"></span>  this.audpsi = audpsi; 
<span id="line1175"></span>  this.audExam = audExam;
<span id="line1176"></span>}
<span id="line1177"></span>
<span id="line1178"></span>
<span id="line1179"></span>function AudMem() {  // http://ai.neocities.org/AudMem.html
<span id="line1180"></span>  if (pov == 1) {  // 2018-01-19: during AI output
<span id="line1181"></span>    input = "";  // 2018-01-19: reset while pov = 1.
<span id="line1182"></span>  }  // 2018-01-19: end of test for pov=1 internal thinking.
<span id="line1183"></span>  if (pov == 2) {  // 2018-01-19: during user input 
<span id="line1184"></span>    input += pho;  // 2018-01-19: increment the string of "input"
<span id="line1185"></span>  }  // 2018-01-19: end of test for pov=2 user input
<span id="line1186"></span>  if (pho == 32) pho = "";  // 2018-01-07: for storage
<span id="line1187"></span>  audMemory[t] = new audNode(pho,0,0); // 2018-01-05: audpsi not yet stored. 
<span id="line1188"></span>  AudRecog();  // 2018-01-05: send SPACE or character to AudRecog()
<span id="line1189"></span>  if (audpsi &gt; 0) {  // 2018-01-05: if there is a recognized audpsi
<span id="line1190"></span>    if (t &gt; vault) {  // 2018-01-05: during normal time beyond MindBoot vault...
<span id="line1191"></span>      audMemory[t-1].audExam();  // 2018-01-06: activate the variables before storing. 
<span id="line1192"></span>      audMemory[t-1] = new audNode(aud0,0,audpsi); // 2018-01-05: store before 32=SPACE. 
<span id="line1193"></span>      if (aud0=="S") { // 2018-09-21: if word ends in "S" like a plural...
<span id="line1194"></span>        if (nucon==1) qusubnum = 2;  // 2018-10-03: for SpreadAct()
<span id="line1195"></span>        audMemory[t-2].audExam();  // 2018-09-21: go back one line earlier.
<span id="line1196"></span>        audMemory[t-2] = new audNode(aud0,0,audpsi); // 2018-09-21: store back one space.
<span id="line1197"></span>      }  // 2018-09-21: end of test for "S" possibly indicating an inflection.
<span id="line1198"></span>    }  // 2018-01-05: end of test for time past "vault" of MindBoot.
<span id="line1199"></span>  }  // 2018-01-05: end of test for recognized word.
<span id="line1200"></span>} // 2018-01-05: AudMem() returns to AudInput().
<span id="line1201"></span>
<span id="line1202"></span>
<span id="line1203"></span>function Attention() {
<span id="line1204"></span>  brain = false;
<span id="line1205"></span>  danger = false;
<span id="line1206"></span>  freedom = false;
<span id="line1207"></span>  if (skip </span><span>&lt; </span><span>1) {  
<span id="line1208"></span>    danger = true;
<span id="line1209"></span>    TID=window.setTimeout("SeCurity();",20000);
<span id="line1210"></span>    skip = skip+1;
<span id="line1211"></span>  }
<span id="line1212"></span>}
<span id="line1213"></span>
<span id="line1214"></span>
<span id="line1215"></span>function AudListen() {  // 2018-01-17: http://ai.neocities.org/AudListen.html 
<span id="line1216"></span>  apb = "Calling AudListen module; when done press [ENTER]";
<span id="line1217"></span>  Voice();
<span id="line1218"></span>  pos = 0;  // 2018-01-21: Reset to prevent InStantiate() carry-over.
<span id="line1219"></span>  pre = 0;  // 2018-01-21: Reset to prevent InStantiate() carry-over.
<span id="line1220"></span>  psi = 0;  // 2018-01-21: Reset to prevent InStantiate() carry-over.
<span id="line1221"></span>  if (skip </span><span>&lt; </span><span>1) {
<span id="line1222"></span>  Attention();
<span id="line1223"></span>  }
<span id="line1224"></span>  inert = 0;
<span id="line1225"></span>  pov = 2;  // 2018-01-16: external-input point-of-view
<span id="line1226"></span>  document.onkeypress = function (evt) {
<span id="line1227"></span>    c = event.keyCode;
<span id="line1228"></span>    doa = c;  // 2018-01-17: for purpose in AudInput.
<span id="line1229"></span>    impetus = 0;  // 2018-09-21: upon user input, disincentivize Imperative()
<span id="line1230"></span>    isolation = 0;  // 2018-10-03: upon user input, disincentivize Imperative()
<span id="line1231"></span>    inert = 0;  // User input cancels "inert" status; 18oct2011
<span id="line1232"></span>    lurk = 0;  // de-lurk if user enters datum; 29sep2010
<span id="line1233"></span>    quiet = false;  // 2018-06-11: "quiet" of internal thought is interrupted. 
<span id="line1234"></span>    rsvp = 2000;  // 2018-05-20: set delay to wait for more user input. 
<span id="line1235"></span>    if (c == 63) alert("Please use no punctuation.");
<span id="line1236"></span>    if (c == 27) {
<span id="line1237"></span>      brain = false;  // 2018-01-16: not internal-brain thought?
<span id="line1238"></span>      danger = false;
<span id="line1239"></span>      freedom = false;
<span id="line1240"></span>    }
<span id="line1241"></span>    if (c == 27) {
<span id="line1242"></span>      document.all["cb4"].checked = true;
<span id="line1243"></span>      Shutdown();
<span id="line1244"></span>    }
<span id="line1245"></span>    if (c != 27) {  // 2018-01-15: reviving the AI
<span id="line1246"></span>      if (life == false) {
<span id="line1247"></span>        life = true;
<span id="line1248"></span>        apb = ("AI alive again.");
<span id="line1249"></span>        Voice();
<span id="line1250"></span>      }
<span id="line1251"></span>    }
<span id="line1252"></span>    if (c == 13) {  // 2018-10-06: upon carriage-return, display new message:
<span id="line1253"></span>  apb = "The first working AI Mind thinks with concepts connected by associative tags.";
<span id="line1254"></span>      Voice();  // 2018-01-19: show the "apb" message on the screen
<span id="line1255"></span>    }  // 2018-01-21: end of test to detect pressing the CR ENTER-key.
<span id="line1256"></span>    if (c == 48) { hap = 10; TacRecog(); c = 0; } // 2019-11-07: sensory input: 0
<span id="line1257"></span>    if (c == 49) { hap = 1; TacRecog(); c = 0; } // 2019-11-07: sensory input{ 1
<span id="line1258"></span>    if (c == 50) { hap = 2; TacRecog(); c = 0; } // 2019-11-07: sensory input: 2
<span id="line1259"></span>    if (c == 51) { hap = 3; TacRecog(); c = 0; } // 2019-11-07: sensory input: 3
<span id="line1260"></span>    if (c == 52) { hap = 4; TacRecog(); c = 0; } // 2019-11-07: sensory input: 4
<span id="line1261"></span>    if (c == 53) { hap = 5; TacRecog(); c = 0; } // 2019-11-07: sensory input: 5
<span id="line1262"></span>    if (c == 54) { hap = 6; TacRecog(); c = 0; } // 2019-11-07: sensory input: 6
<span id="line1263"></span>    if (c == 55) { hap = 7; TacRecog(); c = 0; } // 2019-11-07: sensory input: 7
<span id="line1264"></span>    if (c == 56) { hap = 8; TacRecog(); c = 0; } // 2019-11-07: sensory input: 8
<span id="line1265"></span>    if (c == 57) { hap = 9; TacRecog(); c = 0; } // 2019-11-07: sensory input: 9
<span id="line1266"></span>    if (c == 32 || c == 13) {  // space-bar or CR; 26mar2013
<span id="line1267"></span>      OutBuffer();  // to right-justify word from AudBuffer
<span id="line1268"></span>      c1="";  c2="";  c3="";  c4="";   // empty AudBuffer
<span id="line1269"></span>      c5="";  c6="";  c7="";  c8="";   // 2019-06-15
<span id="line1270"></span>      c9="";  c10=""; c11=""; c12="";  // 2019-06-15
<span id="line1271"></span>      c13=""; c14=""; c15=""; c16="";  // 26mar2013
<span id="line1272"></span>      phodex = 0;  // reset for AudBuffer; 29mar2012
<span id="line1273"></span>      pho = " ";  // 2018-01-15: SPACE for AudRecog word-end recognition;
<span id="line1274"></span>    }  // from Russian Dushka RuAi; 26mar2013
<span id="line1275"></span>    pho = String.fromCharCode(c);
<span id="line1276"></span>    if (hardcopy == true) {
<span id="line1277"></span>      inbuffer += pho;  // 2018-01-20:  build up the input "userline".
<span id="line1278"></span>    }
<span id="line1279"></span>    if (eot == 13) {
<span id="line1280"></span>      phodex = 0;  // reset for AudBuffer(); 25mar2013
<span id="line1281"></span>    }
<span id="line1282"></span>    if (c == 32) { // From CR or space-bar; 12jul2010.
<span id="line1283"></span>      phodex = 0;  // Reset for AudBuffer; 25mar2013
<span id="line1284"></span>    }  // End of expanded if-clause; 12jul2010.
<span id="line1285"></span>    pho = pho.toUpperCase();
<span id="line1286"></span>    abc = pho;  // From RuAi; for transfer to AudBuffer; 25mar2013
<span id="line1287"></span>    if (c &gt; 32) AudBuffer();  // to transfer engrams; 26mar2013
<span id="line1288"></span>    if (bias == 5) {  // If expecting a noun; 27may2011
<span id="line1289"></span>      if (c == 83 || c == 115) { // "s" or "S"; 27may2011
<span id="line1290"></span>        audnum = 2;  // Set num(ber) to plural; 4nov2012
<span id="line1291"></span>      }  // End of test for "s" or "S"; 27may2011
<span id="line1292"></span>      if (c &gt; 0) {  // Disregard empty pho; 27may2011
<span id="line1293"></span>        if (c != 32) {  //  Disregard SPACE; 27may2011
<span id="line1294"></span>          if (c != 13) {  // Disregard CR; 27may2011
<span id="line1295"></span>            if (c != 115) {  // If not "s"; 27may2011
<span id="line1296"></span>              if (c != 83) {  // If not "S"; 27may2011
<span id="line1297"></span>                audnum = 1;  // Assume singular;  4nov2012
<span id="line1298"></span>              }  // If last letter not "S"; 27may2011
<span id="line1299"></span>            }  // If last letter not "s"; 27may2011
<span id="line1300"></span>          }  // End of test for carriage-return; 27may2011
<span id="line1301"></span>        }  // End of test for SPACE; 27may2011
<span id="line1302"></span>      }  // End of test for empty pho; 27may2011
<span id="line1303"></span>    }  // End of test for bias towards a noun; 27may2011
<span id="line1304"></span>    onset = (spt + 1);
<span id="line1305"></span>    AudInput();  // 2018-01-19: consolidating
<span id="line1306"></span>    c = " ";
<span id="line1307"></span>    pho = " ";
<span id="line1308"></span>    return true;
<span id="line1309"></span>  }
<span id="line1310"></span>}  // End of event-driven AudListen(); 4nov2012
<span id="line1311"></span>
<span id="line1312"></span>
<span id="line1313"></span>function Tab() {
<span id="line1314"></span>  document.forms[1].ear.focus();
<span id="line1315"></span>  fyi = (fyi + 1);
<span id="line1316"></span>   if (fyi == 0)  {
<span id="line1317"></span>    document.all.souvenir.innerHTML = "Cycling through display modes.";
<span id="line1318"></span>    document.all["cb1"].checked = false;
<span id="line1319"></span>    document.all["cb2"].checked = false;
<span id="line1320"></span>    document.all["cb3"].checked = false;
<span id="line1321"></span>    trouble = false;
<span id="line1322"></span>   }
<span id="line1323"></span>   if (fyi == 1)  {
<span id="line1324"></span>    document.all["cb2"].checked = false;
<span id="line1325"></span>    document.all["cb3"].checked = false;
<span id="line1326"></span>    trouble = false;
<span id="line1327"></span>    document.all.psicolumn.innerHTML = "";
<span id="line1328"></span>    document.all.audcolumn.innerHTML = "";
<span id="line1329"></span>    document.all["cb1"].checked = true;
<span id="line1330"></span>   }
<span id="line1331"></span>  if (fyi == 2) {
<span id="line1332"></span>    document.all["cb1"].checked = false;
<span id="line1333"></span>    document.all.psicolumn.innerHTML = "";
<span id="line1334"></span>    document.all.audcolumn.innerHTML = "";
<span id="line1335"></span>    document.all["cb3"].checked = false;
<span id="line1336"></span>    trouble = false;
<span id="line1337"></span>    document.all.souvenir.innerHTML = "Tutorial has been called.";
<span id="line1338"></span>    document.all.tabula.innerHTML = "Watch the artificial mind think.";
<span id="line1339"></span>    document.all["cb2"].checked = true;
<span id="line1340"></span>    tutor = true;
<span id="line1341"></span>  }
<span id="line1342"></span>   if (fyi == 3)  {
<span id="line1343"></span>    document.all["cb1"].checked = false;
<span id="line1344"></span>    document.all["cb2"].checked = false;
<span id="line1345"></span>    document.all.souvenir.innerHTML = "Diagnostic mode has been called.";
<span id="line1346"></span>    document.all.tabula.innerHTML = "Diagnostic troubleshoot mode.";
<span id="line1347"></span>    document.all["cb3"].checked = true;
<span id="line1348"></span>    trouble = true;
<span id="line1349"></span>   }
<span id="line1350"></span>  if (fyi &gt; 3) {
<span id="line1351"></span>    document.all["cb1"].checked = false;
<span id="line1352"></span>    document.all["cb2"].checked = false;
<span id="line1353"></span>    document.all["cb3"].checked = false;
<span id="line1354"></span>    trouble = false;
<span id="line1355"></span>    document.all.psicolumn.innerHTML = ""; 
<span id="line1356"></span>    document.all.audcolumn.innerHTML = "";
<span id="line1357"></span>    document.all.souvenir.innerHTML = "Tab key changes display modes.";
<span id="line1358"></span>    fyi = 0;
<span id="line1359"></span>  }
<span id="line1360"></span>  TID=window.setTimeout("CR();",1000);
<span id="line1361"></span>}
<span id="line1362"></span>
<span id="line1363"></span>
<span id="line1364"></span>function CR() {  // 2018-05-20: called from input Form if there is no input.
<span id="line1365"></span>  document.forms[1].elements[0].value = ""; // 2019-11-07: remove visible user input
<span id="line1366"></span>    if (trouble == true) Diagnostic();
<span id="line1367"></span>  userline = inbuffer;
<span id="line1368"></span>  inbuffer = "";
<span id="line1369"></span>  spt = t;
<span id="line1370"></span>  lastword = true;
<span id="line1371"></span>  eot = 13; // for use in AudListen() to indicate CR.
<span id="line1372"></span>  holdnum = 0;  // reset for safety;  4nov2012
<span id="line1373"></span>  c = 32;   // as if SPACE-BAR "32" were pressed
<span id="line1374"></span>  pho = " "; // 2018-01-17: TEST
<span id="line1375"></span>  eot = 0;
<span id="line1376"></span>  moot = 0;  // assuming end of moot user queries; 1nov2011
<span id="line1377"></span>}
<span id="line1378"></span>
<span id="line1379"></span>
<span id="line1380"></span>function AudInput() {  // http://ai.neocities.org/AudInput.html 
<span id="line1381"></span>  iob = 0;  // 2018-01-21: reset indirect-object identifier for safety. 
<span id="line1382"></span>  spt = t;
<span id="line1383"></span>  tio = 0;  // 2018-01-21: reset at level above EnParser() and InStantiate()
<span id="line1384"></span>  if (doa &gt; 31) t = (t + 1); // 2018-01-17: TEST
<span id="line1385"></span>  if (doa == 13) {  // 2018-01-17: intercept 13=CR for sake of AudRecog().
<span id="line1386"></span>    t = (t + 1); // 2018-01-19: prevent dropping last character of word?
<span id="line1387"></span>    pho = " ";  // 2018-01-17: change 13=CR into SPACE for AudRecog().
<span id="line1388"></span>    doa = 0;  // 2018-01-17: reset for immediate re-use.
<span id="line1389"></span>  }  // 2018-01-17: end of test to insert SPACE upon carriage-return.
<span id="line1390"></span>  if (doa &gt; 32) {  // 2018-01-17: a holding of input character "c"
<span id="line1391"></span>    len = (len + 1); // 2018-01-17: 
<span id="line1392"></span>    doa = 0;  // 2018-01-17: reset for immediate re-use.
<span id="line1393"></span>  }  // 2018-01-17: 
<span id="line1394"></span>  if (audrun </span><span>&lt; </span><span>1) {  // 2018-01-19: until word starts
<span id="line1395"></span>    rv = t;  // 2018-01-19: set recall-vector. 
<span id="line1396"></span>  }  // end of test for unitary length at start of word
<span id="line1397"></span>  tult = (t - 1);
<span id="line1398"></span>  AudMem()  // 2018-01-15: modernizing, call AudMem() instead of storing directly. 
<span id="line1399"></span>  if (pho == " " &amp;&amp; rv &gt; 1) audrun = 0;  // 2018-01-15: reset after word
<span id="line1400"></span> if (pho == " ") {  // 2018-01-17: decide on concept only at post-word SPACE...
<span id="line1401"></span>  if (audpsi &gt; 0) {   // 8dec2009 "audpsi" replacing "psi"
<span id="line1402"></span>    aud = onset;
<span id="line1403"></span>    oldpsi = audpsi;  // for conformance with MindForth; 3jul2011
<span id="line1404"></span>    prc = 0; // reset provisional recognition at end of word; 14apr2013
<span id="line1405"></span>    OldConcept();
<span id="line1406"></span>    psi = 0;
<span id="line1407"></span>    audpsi = 0;  // 8dec2009 de-globalizing "psi" 
<span id="line1408"></span>    aud = 0; 
<span id="line1409"></span>    dba = 0;  // From RuAi; reset for safety; 19oct2012 
<span id="line1410"></span>  } else {  // i.e., if AudRecog has not recognized word; 12may2011  
<span id="line1411"></span>    if (len &gt; 0) { 
<span id="line1412"></span>      aud = onset
<span id="line1413"></span>      audMemory[t].audExam(); // 2018-09-21: prepare to modify auditory engram.
<span id="line1414"></span>      audMemory[t] = new audNode(" ",aud1,aud2); // 2018-09-21: store blank.
<span id="line1415"></span>      NewConcept();  // AudInput() calls NewConcept(); 12may2011
<span id="line1416"></span>      audMemory[tult].audExam(); // 2018-01-16: attach audpsi to word-stem.
<span id="line1417"></span>      audpsi = nxt;  // 2018-09-21: concept-number for a new concept.
<span id="line1418"></span>      if (aud2 == 0) {  // 2018-09-21; if audpsi-slot is empty...
<span id="line1419"></span>        audMemory[tult] = new audNode(aud0,aud1,audpsi); // 2018-09-21: store audpsi
<span id="line1420"></span>      }  // 2018-09-21: end of test for a blank slot to store "audpsi" number.
<span id="line1421"></span>      audMemory[tult] = new audNode(aud0,aud1,audpsi); // 2018-01-19: absolute?
<span id="line1422"></span>      audMemory[tult-1].audExam();  // 2018-01-16: in event of end-of-stem.
<span id="line1423"></span>      audMemory[tult-1] = new audNode(aud0,aud1,aud2);  // 2018-01-15: modernizing
<span id="line1424"></span>      audpsi = 0;  // 2018-01-19: restore to prevent carry-over.
<span id="line1425"></span>      nxt++;  // 2018-01-19: increment here and not in moribund NewConcept()
<span id="line1426"></span>    }  // end of test for positive len(gth); 14apr2013
<span id="line1427"></span>  }
<span id="line1428"></span> }  // 2018-01-17: end of test for post-word SPACE.
<span id="line1429"></span>  pos = 0;  // 2018-01-21: Reset to prevent InStantiate() carry-over.
<span id="line1430"></span>  pre = 0;  // 2018-01-21: Reset to prevent InStantiate() carry-over.
<span id="line1431"></span>  psi = 0;  // 2018-01-21: Reset to prevent InStantiate() carry-over.
<span id="line1432"></span>  len = 0;
<span id="line1433"></span>  onset = 0;
<span id="line1434"></span>  predflag = 0;  // prevent carry-over; 5dec2012
<span id="line1435"></span>  aud = 0;
<span id="line1436"></span>  newpsi = 0;  // from Forthminds Wotan and MindForth; 18mar2013
<span id="line1437"></span>} // 2018-01-21: AudInput()) returns to AudListen(), CR() or ReEntry().
<span id="line1438"></span>
<span id="line1439"></span>
<span id="line1440"></span>function Emotion() {  // http://mind.sourceforge.net/emotion.html 
<span id="line1441"></span>  // 2018-01-14: mind-module stubbed in for influence upon thought and will.
<span id="line1442"></span>}  // Emotion() will return to Volition() as an influence on thought and will. 
<span id="line1443"></span>
<span id="line1444"></span>
<span id="line1445"></span>function GusRecog() {  // http://mind.sourceforge.net/gusrecog.html 
<span id="line1446"></span>  // 2018-01-14: mind-module stubbed in for gustatory recognition of taste.
<span id="line1447"></span>}  // GusRecog() will return to the Sensorium() module.
<span id="line1448"></span>
<span id="line1449"></span>
<span id="line1450"></span>function OlfRecog() {  // http://mind.sourceforge.net/olfrecog.html 
<span id="line1451"></span>  // 2018-01-14: mind-module stubbed in for olfactory recognition of smells
<span id="line1452"></span>}  // OldRecog() will return to the Sensorium() module.
<span id="line1453"></span>
<span id="line1454"></span>
<span id="line1455"></span>function TacRecog() {  // http://ai.neocities.org/TacRecog.html 
<span id="line1456"></span>  haptac = 755;  // 2019-11-07: a default value of 755=SOMETHING
<span id="line1457"></span>  document.forms[1].elements[0].value = ""; // 2019-11-07: erase any numeric input
<span id="line1458"></span>  if (hap == 1) haptac = 551;  // 2019-11-07: identifier of noun 551=ONE  
<span id="line1459"></span>  if (hap == 2) haptac = 582;  // 2019-11-07: identifier of noun 582=TWO  
<span id="line1460"></span>  if (hap == 3) haptac = 583;  // 2019-11-07: identifier of noun 583=THREE  
<span id="line1461"></span>  if (hap == 4) haptac = 544;  // 2019-11-07: identifier of noun 544=FOUR  
<span id="line1462"></span>  if (hap == 5) haptac = 545;  // 2019-11-07: identifier of noun 545=FIVE  
<span id="line1463"></span>  if (hap == 6) haptac = 566;  // 2019-11-07: identifier of noun 566=SIX  
<span id="line1464"></span>  if (hap == 7) haptac = 577;  // 2019-11-07: identifier of noun 577=SEVEN  
<span id="line1465"></span>  if (hap == 8) haptac = 588;  // 2019-11-07: identifier of noun 588=EIGHT  
<span id="line1466"></span>  if (hap == 9) haptac = 559;  // 2019-11-07: identifier of noun 559=NINE  
<span id="line1467"></span>  if (hap ==10) haptac = 590;  // 2019-11-07: "ten" standing in for ZERO
<span id="line1468"></span>  if (haptac &gt; 0 &amp;&amp; haptac != 755) {  // 2019-11-07: for any positive value except 755
<span id="line1469"></span>    actpsi = 701; SpreadAct();  // 2019-11-07: activate 701=I as a subject;
<span id="line1470"></span>    actpsi = 823; SpreadAct();  // 2019-11-07: activate 823=FEEL as a verb.
<span id="line1471"></span>  }  // 2019-11-07: end of test for a positive "haptac" other than 755=SOMETHING.
<span id="line1472"></span>}  // 2019-11-07: TacRecog() returns to Sensorium() and EnVerbPhrase.
<span id="line1473"></span>
<span id="line1474"></span>function VisRecog() {  // http://ai.neocities.org/VisRecog.html 
<span id="line1475"></span>  if (svo4 == 0) {  // 2018-06-16: if there is no direct object for "SEE"
<span id="line1476"></span>    for (i = vault; i&gt;midway; i--) {  // 2018-06-16: "vault" to search only MindBoot
<span id="line1477"></span>      Psy[i].psyExam(); //  2018-06-16: examine conceptual Psy array;
<span id="line1478"></span>        if (psi1==760) {  // 2018-06-16: find 760=NOTHING; 
<span id="line1479"></span>          aud = psi20;  // 2019-07-31: auditory recall-vector for Speech()
<span id="line1480"></span>          break;  // 2018-06-16: finding one engram is enough.
<span id="line1481"></span>        }  // 2018-06-16: end of test for 760=NOTHING.
<span id="line1482"></span>    }  // 2018-06-16: end of backwards search loop. 
<span id="line1483"></span>    Speech();  // 2018-06-16: send the "aud" recall-vector into Speech()
<span id="line1484"></span>  }  // 2018-06-12: end of test for an absent direct-object. 
<span id="line1485"></span>}  // 2019-07-31: VisRecog() returns to EnVerbPhrase().
<span id="line1486"></span>
<span id="line1487"></span>
<span id="line1488"></span>function Sensorium() {  // http://ai.neocities.org/Sensorium.html 
<span id="line1489"></span>  len = 0;  // 2018-01-03: 
<span id="line1490"></span>  verbcon = 0;  // 2018-07-12 BUGFIX: prevent carry-over of tdo-value.  
<span id="line1491"></span>  if (life == true) {  
<span id="line1492"></span>    document.forms[1].ear.focus();  // AI4U: Display blinking cursor.
<span id="line1493"></span>  }  
<span id="line1494"></span>  len = 0;  // 2018-01-06: reset to prevent carry-over during reentry.
<span id="line1495"></span>  tvb = 0;  // 2018-11-14: reset to prevent false tkb-values on verbs. 
<span id="line1496"></span>}  // 2018-01-06: Sensorium() module returns to MainLoop.
<span id="line1497"></span>
<span id="line1498"></span>
<span id="line1499"></span>function MindBoot() {  // http://ai.neocities.org/MindBoot.html
<span id="line1500"></span>  dob = new Date();  // 2018-01-24: date-of-birth in competition for old AI.
<span id="line1501"></span>  HCI();  // 2018-01-18: Human-Computer Interface
<span id="line1502"></span>  t = 0;      // 2018-01-02: bootstrap stretches over time "t". 
<span id="line1503"></span>  spt = t;    // 8dec2009
<span id="line1504"></span>// ERROR -- bugtrap; NewConcept() learns new words beyond MindBoot.
<span id="line1505"></span>t=1;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line1506"></span>t=2;pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);  
<span id="line1507"></span>t=3;pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1508"></span>t=4;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1509"></span>t=5;pho="R"; audpsi=586; audMemory[t] = new audNode(pho,0,audpsi);  // 2017-12-31:
<span id="line1510"></span>  psi=586;hlc="en";jux=0;pos=5;dba=0;num=1;mfn=3;pre=0;seq=0;tkb=0;rv=1; KbLoad(); 
<span id="line1511"></span>t=6;  // 2019-10-24: one blank time-point for sake of AudRecog()
<span id="line1512"></span>
<span id="line1513"></span>// YOU -- 2019-10-24: for SelfReferentialThought 
<span id="line1514"></span>t=7;pho="Y"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1515"></span>t=8;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1516"></span>t=9;pho="U"; audpsi=707; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line1517"></span>psi=707; pos=7; dba=1; num=1; mfn=0; pre=0; seq=899; tkb=17; rv=7; KbLoad();
<span id="line1518"></span>t=10;  // 2019-10-24: one blank time-point for sake of AudRecog()
<span id="line1519"></span>
<span id="line1520"></span>// 899=WORSHIP -- 2019o-10-24: essential verb for discussion of AI and theology
<span id="line1521"></span>t=11;pho="W"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1522"></span>t=12;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1523"></span>t=13;pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1524"></span>t=14;pho="S"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1525"></span>t=15;pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1526"></span>t=16;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1527"></span>t=17;pho="P"; audpsi=899; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1528"></span>psi=899; pos=8; dba=2; num=1; mfn=0; pre=707; seq=533; tkb=21; rv=11; KbLoad();
<span id="line1529"></span>t=18;  // 2019-10-24: one blank time-point for sake of AudRecog()
<span id="line1530"></span> 
<span id="line1531"></span>// 533=GOD -- 2019-10-24: for SpreadAct() to activate concept of God.
<span id="line1532"></span>t=19;pho="G"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1533"></span>t=20;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1534"></span>t=21;pho="D"; audpsi=533; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line1535"></span>psi=533; pos=5; dba=1; num=1; mfn=0; pre=899; seq=0; tkb=0; rv=19; KbLoad();
<span id="line1536"></span>t=22;  // 2019-10-24: one blank time-point for sake of AudRecog()
<span id="line1537"></span>
<span id="line1538"></span>// I -- for SelfReferentialThought 
<span id="line1539"></span>t=23;pho="I"; audpsi=701; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line1540"></span>tru=8; psi=701; pos=7; dba=1; num=1; mfn=0; pre=0;seq=800; tkb=26; rv=23; KbLoad();
<span id="line1541"></span>t=24;  // 2019-10-24: one blank time-point for sake of AudRecog()
<span id="line1542"></span>
<span id="line1543"></span>// AM -- 1st person singular of 800=BE 
<span id="line1544"></span>t=25;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1545"></span>t=26;pho="M"; audpsi=800; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line1546"></span>psi=800; pos=8; dba=1; num=1; mfn=0; pre=701;seq=501; tkb=32; rv=25; KbLoad();
<span id="line1547"></span>t=27;  // 2019-10-24: one blank time-point for sake of AudRecog()
<span id="line1548"></span>
<span id="line1549"></span>// ANDRU -- for SelfReferentialThought 
<span id="line1550"></span>t=28;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1551"></span>t=29;pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1552"></span>t=30;pho="D"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1553"></span>t=31;pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1554"></span>t=32;pho="U"; audpsi=501; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line1555"></span>psi=501; pos=5; dba=1; num=1; mfn=1; pre=800; seq=0; tkb=0; rv=28; KbLoad();
<span id="line1556"></span>t=33;  // 2019-10-24: one blank time-point for sake of AudRecog()
<span id="line1557"></span>
<span id="line1558"></span>// I -- innate KB-item for testing inhibition of idea-pairs
<span id="line1559"></span>t=34;pho="I"; audpsi=701; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1560"></span>psi=701; pos=7; dba=1; num=1; mfn=0; pre=0; seq=800; tkb=37; rv=34; KbLoad();
<span id="line1561"></span>t=35;  // 2019-10-24: one blank time-point for sake of AudRecog()
<span id="line1562"></span>
<span id="line1563"></span>// AM -- 1st person singular of 800=BE 
<span id="line1564"></span>t=36;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1565"></span>t=37;pho="M"; audpsi=800; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line1566"></span>psi=800; pos=8; dba=1; num=1; mfn=0; pre=701;seq=571; tkb=45; rv=36; KbLoad();
<span id="line1567"></span>t=38;  // 2019-10-24: one blank time-point for sake of AudRecog()
<span id="line1568"></span>
<span id="line1569"></span>// A -- En(glish) Article for EnArticle module 
<span id="line1570"></span>t=39;pho="A"; audpsi=101; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line1571"></span>psi=101; pos=1; dba=0; num=1; mfn=0; pre=0;seq=571; tkb=0; rv=39; KbLoad();
<span id="line1572"></span>t=40;  // 2019-10-24: one blank time-point for sake of AudRecog()
<span id="line1573"></span>
<span id="line1574"></span>// ROBOT -- important for target user base 
<span id="line1575"></span>t=41;pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1576"></span>t=42;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1577"></span>t=43;pho="B"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1578"></span>t=44;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1579"></span>t=45;pho="T"; audpsi=571; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line1580"></span>psi=571; pos=5; dba=1; num=1; mfn=3; pre=800; seq=0; tkb=0; rv=41; KbLoad();
<span id="line1581"></span>t=46;  // 2019-10-24: one blank time-point for sake of AudRecog()
<span id="line1582"></span>
<span id="line1583"></span>// I -- innate KB-item for testing inhibition of idea-pairs
<span id="line1584"></span>t=47;pho="I"; audpsi=701; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line1585"></span>tru=8; psi=701; pos=7; dba=1; num=1; mfn=0; pre=0;seq=800; tkb=50; rv=47; KbLoad();
<span id="line1586"></span>
<span id="line1587"></span>// AM -- 1st person singular of 800=BE 
<span id="line1588"></span>t=49;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1589"></span>t=50;pho="M"; audpsi=800; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line1590"></span>psi=800; pos=8; dba=1; num=1; mfn=0; pre=701; seq=537; tkb=59; rv=49; KbLoad();
<span id="line1591"></span>
<span id="line1592"></span>// A -- En(glish) Article for EnArticle module 
<span id="line1593"></span>t=52;pho="A"; audpsi=101; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line1594"></span>psi=101; pos=1; dba=0; num=1; mfn=0; pre=0; seq=537; tkb=0; rv=52; KbLoad();
<span id="line1595"></span>
<span id="line1596"></span>// PERSON -- for ad-hoc gender tags and robot philosophy 
<span id="line1597"></span>t=54;pho="P"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1598"></span>t=55;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1599"></span>t=56;pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1600"></span>t=57;pho="S"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1601"></span>t=58;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1602"></span>t=59;pho="N"; audpsi=537; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line1603"></span>psi=537; pos=5; dba=1; num=1; mfn=0; pre=800; seq=0; tkb=0; rv=54; KbLoad();  
<span id="line1604"></span>
<span id="line1605"></span> 
<span id="line1606"></span>// I -- for SelfReferentialThought 
<span id="line1607"></span>t=62;pho="I"; audpsi=701; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line1608"></span>psi=701; pos=7; dba=1; num=1; mfn=0; pre=0; seq=836; tkb=67; rv=62; KbLoad();
<span id="line1609"></span>
<span id="line1610"></span>// HELP -- socially significant common verb 
<span id="line1611"></span>t=64;pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1612"></span>t=65;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1613"></span>t=66;pho="L"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1614"></span>t=67;pho="P"; audpsi=836; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line1615"></span>psi=836; pos=8; dba=1; num=1; mfn=0; pre=701; seq=528; tkb=72; rv=64; KbLoad();
<span id="line1616"></span>
<span id="line1617"></span>// KIDS -- noun lends itself to educational purposes 
<span id="line1618"></span>t=69;pho="K"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1619"></span>t=70;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1620"></span>t=71;pho="D"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1621"></span>t=72;pho="S"; audpsi=528; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line1622"></span>psi=528; pos=5; dba=4; num=2; mfn=0; pre=836; seq=0; tkb=0; rv=69; KbLoad();
<span id="line1623"></span>
<span id="line1624"></span>
<span id="line1625"></span>// KIDS -- noun lends itself to educational purposes 
<span id="line1626"></span>t=75;pho="K"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1627"></span>t=76;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1628"></span>t=77;pho="D"; audpsi=528; audMemory[t] = new audNode(pho,0,audpsi); // 2018-10-06
<span id="line1629"></span>t=78;pho="S"; audpsi=528; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line1630"></span>psi=528; pos=5; dba=1; num=2; mfn=0; pre=0; seq=846; tkb=83; rv=75; KbLoad();
<span id="line1631"></span>
<span id="line1632"></span>// MAKE -- common verb of high word-frequency 
<span id="line1633"></span>t=80;pho="M"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1634"></span>t=81;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1635"></span>t=82;pho="K"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1636"></span>t=83;pho="E"; audpsi=846; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line1637"></span>psi=846; pos=8; dba=3; mfn=0; num=2; pre=528; seq=571; tkb=90; rv=80; KbLoad();
<span id="line1638"></span>
<span id="line1639"></span>// ROBOTS -- important for target user base  
<span id="line1640"></span>t=85;pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1641"></span>t=86;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1642"></span>t=87;pho="B"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1643"></span>t=88;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1644"></span>t=89;pho="T"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1645"></span>t=90;pho="S"; audpsi=571; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line1646"></span>psi=571; pos=5; dba=4; num=2; mfn=3; pre=846; seq=0; tkb=0; rv=85; KbLoad();
<span id="line1647"></span>
<span id="line1648"></span>
<span id="line1649"></span>// ROBOTS -- important for target user base 
<span id="line1650"></span>t=93;pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1651"></span>t=94;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1652"></span>t=95;pho="B"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1653"></span>t=96;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1654"></span>t=97;pho="T"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1655"></span>t=98;pho="S"; audpsi=571; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line1656"></span>psi=571; pos=5; dba=1; num=2; mfn=3; pre=0; seq=851; tkb=103; rv=93; KbLoad();
<span id="line1657"></span>
<span id="line1658"></span>// NEED -- common verb used for describing goals 
<span id="line1659"></span>t=100;pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1660"></span>t=101;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1661"></span>t=102;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1662"></span>t=103;pho="D"; audpsi=851; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line1663"></span>psi=851; pos=8; dba=3; num=2; mfn=0; pre=571; seq=701; tkb=106; rv=100; KbLoad();
<span id="line1664"></span>
<span id="line1665"></span>// ME -- for SelfReferentialThought 
<span id="line1666"></span>t=105;pho="M"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1667"></span>t=106;pho="E"; audpsi=701; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line1668"></span>psi=701; pos=7; dba=4; num=1; mfn=0; pre=851; seq=0; tkb=0; rv=105; KbLoad();
<span id="line1669"></span>
<span id="line1670"></span>
<span id="line1671"></span>// WOMEN -- irregular plural for retrieval by parameters
<span id="line1672"></span>t=109;pho="W"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1673"></span>t=110;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1674"></span>t=111;pho="M"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1675"></span>t=112;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1676"></span>t=113;pho="N"; audpsi=515; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line1677"></span>psi=515; pos=5; dba=1; num=2; mfn=2; pre=0; seq=834; tkb=118; rv=109; KbLoad();
<span id="line1678"></span>
<span id="line1679"></span>// HAVE -- irregular high word-frequency verb  
<span id="line1680"></span>t=115;pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1681"></span>t=116;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1682"></span>t=117;pho="V"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1683"></span>t=118;pho="E"; audpsi=834; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line1684"></span>psi=834; pos=8; dba=3; num=2; mfn=0; pre=515; seq=525; tkb=126; rv=115; KbLoad();
<span id="line1685"></span>
<span id="line1686"></span>// A -- En(glish) Article for EnArticle module 
<span id="line1687"></span>t=120;pho="A"; audpsi=101; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line1688"></span>psi=101; pos=1; dba=0; num=1; mfn=0; pre=0; seq=126; rv=120; KbLoad();
<span id="line1689"></span>
<span id="line1690"></span>// CHILD -- example of irregular noun for a polyglot AI Mind
<span id="line1691"></span>t=122; pho="C"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1692"></span>t=123; pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1693"></span>t=124; pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1694"></span>t=125; pho="L"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1695"></span>t=126; pho="D"; audpsi=525; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line1696"></span>psi=525; pos=5; dba=4; num=1; mfn=0; pre=834; seq=0; rv=122; KbLoad();
<span id="line1697"></span>t=127;  // 2019-10-24: one blank time-point for sake of AudRecog()
<span id="line1698"></span>t=128;  // 2019-10-24: one blank time-point for sake of AudRecog()
<span id="line1699"></span>
<span id="line1700"></span>// GOD -- start of negation of an idea; demonstration of "tru" value; 2018-05-22
<span id="line1701"></span>t=129;pho="G"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1702"></span>t=130;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1703"></span>t=131;pho="D"; audpsi=533; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line1704"></span>tru=20;psi=533;mtx=1533;pos=5;dba=1;num=1;mfn=1;seq=859;tkb=145;rv=129;KbLoad();
<span id="line1705"></span>t=132;  // 2019-10-24: one blank time-point for sake of AudRecog()
<span id="line1706"></span>
<span id="line1707"></span>// DOES -- 3rd person singular HE-SHE-IT-form of auxiliary verb
<span id="line1708"></span>t=133;pho="D"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1709"></span>t=134;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1710"></span>t=135;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1711"></span>t=136;pho="S"; audpsi=818; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line1712"></span>psi=818; pos=8; dba=3; num=1; mfn=0; pre=533; seq=0; rv=133; KbLoad();
<span id="line1713"></span>t=137;  // 2019-10-24: one blank time-point for sake of AudRecog()
<span id="line1714"></span>
<span id="line1715"></span>// NOT -- adverb used here for demonstration of negation; 2018-05-22
<span id="line1716"></span>t=138; pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1717"></span>t=139; pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1718"></span>t=140; pho="T"; audpsi=250; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line1719"></span>psi=250; mfn=0; pos=2; dba=0; num=0; pre=0; seq=859; rv=138; KbLoad();
<span id="line1720"></span>t=141;  // 2019-10-24: one blank time-point for sake of AudRecog()
<span id="line1721"></span>
<span id="line1722"></span>// PLAY -- part of famous quote for negation, or chess; 2018-05-22
<span id="line1723"></span>t=142;pho="P"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1724"></span>t=143;pho="L"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1725"></span>t=144;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1726"></span>t=145;pho="Y"; audpsi=859; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line1727"></span>psi=859;jux=250;pos=8;dba=0;num=0;pre=533;seq=527;tkb=150;tpr=155;rv=142; KbLoad();
<span id="line1728"></span>t=146;  // 2019-10-24: one blank time-point for sake of AudRecog()
<span id="line1729"></span>
<span id="line1730"></span>// DICE -- part of famous Einstein quote for negation; 2018-05-22 
<span id="line1731"></span>t=147;pho="D"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1732"></span>t=148;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1733"></span>t=149;pho="C"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1734"></span>t=150;pho="E"; audpsi=527; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line1735"></span>psi=527; pos=5; dba=4; num=2; mfn=3; pre=859; seq=0; rv=147; KbLoad();
<span id="line1736"></span>t=151;  // 2019-10-24: one blank time-point for sake of AudRecog()
<span id="line1737"></span>
<span id="line1738"></span>// WITH -- 2019-10-24: preposition linked to verb-phrase "play dice"
<span id="line1739"></span>t=152;pho="W"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1740"></span>t=153;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1741"></span>t=154;pho="T"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1742"></span>t=155;pho="H"; audpsi=697; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line1743"></span>psi=697;pos=6;dba=0;num=0;mfn=0;pre=533;seq=588;tkb=168;rv=152; KbLoad();
<span id="line1744"></span>t=156;  // 2019-10-24: one blank time-point for sake of AudRecog()
<span id="line1745"></span>
<span id="line1746"></span>// THE -- 2019-10-24: English article for EnArticle() module
<span id="line1747"></span>t=157;pho="T"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1748"></span>t=158;pho="C"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1749"></span>t=159;pho="E"; audpsi=117; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line1750"></span>psi=117; pos=1; dba=4; num=1; pre=697; seq=589; rv=157; KbLoad();
<span id="line1751"></span>t=160;  // 2019-10-24: one blank time-point for sake of AudRecog()
<span id="line1752"></span>
<span id="line1753"></span>// UNIVERSE -- 2019-11-07: noun as part of quote from Albert Einstein
<span id="line1754"></span>t=161;pho="U"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1755"></span>t=162;pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1756"></span>t=163;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1757"></span>t=164;pho="V"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1758"></span>t=165;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1759"></span>t=166;pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1760"></span>t=167;pho="S"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1761"></span>t=168;pho="E"; audpsi=589; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line1762"></span>tru=20;psi=589;pos=5;dba=4;num=1;mfn=3;pre=697;seq=0;tkb=0;rv=161;KbLoad();
<span id="line1763"></span>t=169;  // 2019-10-24: one blank time-point for sake of AudRecog()
<span id="line1764"></span>
<span id="line1765"></span>
<span id="line1766"></span>// I -- for SelfReferentialThought  
<span id="line1767"></span>t=175;pho="I"; audpsi=701; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line1768"></span>tru = 8;  // 2018-06-16: high truth value.
<span id="line1769"></span>psi=701; pos=7; dba=1; num=1; mfn=0; pre=0; seq=851; tkb=180; rv=175; KbLoad();
<span id="line1770"></span>
<span id="line1771"></span>// NEED -- common verb used for describing goals 
<span id="line1772"></span>t=177;pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1773"></span>t=178;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1774"></span>t=179;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1775"></span>t=180;pho="D"; audpsi=851; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line1776"></span>psi=851; pos=8; dba=1; num=1; mfn=0; pre=701; seq=503; tkb=187; rv=177; KbLoad();
<span id="line1777"></span>
<span id="line1778"></span>// A -- En(glish) Article for EnArticle module 
<span id="line1779"></span>t=182;pho="A"; audpsi=101; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line1780"></span>psi=101; pos=1; dba=0; num=1; mfn=0; pre=0; seq=503; tkb=187; rv=182; KbLoad();
<span id="line1781"></span>
<span id="line1782"></span>// BODY -- 2018-09-05: important for AI embodiment in a robot.
<span id="line1783"></span>t=184;pho="B"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1784"></span>t=185;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1785"></span>t=186;pho="D"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1786"></span>t=187;pho="Y"; audpsi=503; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line1787"></span>psi=503; pos=5; dba=0; num=1; mfn=3; pre=851; seq=0; rv=184; KbLoad();
<span id="line1788"></span>
<span id="line1789"></span>
<span id="line1790"></span>// STUDENTS -- 2018-10-01: includendum for logical inference.
<span id="line1791"></span>t=189;pho="S"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1792"></span>t=190;pho="T"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1793"></span>t=191;pho="U"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1794"></span>t=192;pho="D"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1795"></span>t=193;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1796"></span>t=194;pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1797"></span>t=195;pho="T"; audpsi=561; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1798"></span>t=196;pho="S"; audpsi=561; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line1799"></span>psi=561; pos=5; dba=1; num=2; mfn=0; pre=0; seq=863; tkb=201; rv=189; KbLoad();
<span id="line1800"></span>
<span id="line1801"></span>// READ -- verb for logical premise; 2018-10-01
<span id="line1802"></span>t=198;pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1803"></span>t=199;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1804"></span>t=200;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1805"></span>t=201;pho="D"; audpsi=863; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line1806"></span>psi=863; pos=8; dba=3; mfn=0; num=2; pre=561; seq=540; tkb=207; rv=198; KbLoad();
<span id="line1807"></span>
<span id="line1808"></span>// BOOKS -- for InFerence premise "Students read books"; 2018-10-01
<span id="line1809"></span>t=203;pho="B"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1810"></span>t=204;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1811"></span>t=205;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1812"></span>t=206;pho="K"; audpsi=540; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1813"></span>t=207;pho="S"; audpsi=540; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line1814"></span>psi=540; pos=5; dba=4; num=2; mfn=3; pre=863; seq=0; tkb=0; rv=203; KbLoad();
<span id="line1815"></span>
<span id="line1816"></span>
<span id="line1817"></span>// MEN -- 2018-10-01: includendum for logical inference.
<span id="line1818"></span>t=209;pho="M"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1819"></span>t=210;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1820"></span>t=211;pho="N"; audpsi=543; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line1821"></span>psi=543; pos=5; dba=1; num=2; mfn=1; pre=0; seq=834; tkb=216; rv=209; KbLoad();
<span id="line1822"></span>
<span id="line1823"></span>// HAVE -- verb for logical premise; 2018-10-01
<span id="line1824"></span>t=213;pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1825"></span>t=214;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1826"></span>t=215;pho="V"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1827"></span>t=216;pho="E"; audpsi=834; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line1828"></span>psi=834; pos=8; dba=3; num=2; mfn=0; pre=543; seq=514; tkb=223; rv=213; KbLoad();
<span id="line1829"></span>
<span id="line1830"></span>// A -- En(glish) Article for EnArticle module 
<span id="line1831"></span>t=218;pho="A"; audpsi=101; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line1832"></span>psi=101; pos=1; dba=0; num=1; mfn=0; pre=0; seq=514; rv=210; KbLoad();
<span id="line1833"></span>
<span id="line1834"></span>// WIFE -- for InFerence premise "Men have a wife"; 2018-10-01
<span id="line1835"></span>t=220;pho="W"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1836"></span>t=221;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1837"></span>t=222;pho="F"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1838"></span>t=223;pho="E"; audpsi=514; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line1839"></span>psi=514; pos=5; dba=4; num=1; mfn=2; pre=834; seq=0; rv=220; KbLoad();
<span id="line1840"></span>
<span id="line1841"></span>
<span id="line1842"></span>// I -- part of response to be summoned by momentarily high truth-value. 
<span id="line1843"></span>t=225;pho="I"; audpsi=701; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line1844"></span>tru=0; psi=701; pos=7; dba=1; num=1; mfn=0; pre=0; seq=838; tkb=237; rv=225; KbLoad();
<span id="line1845"></span>
<span id="line1846"></span>// DO -- part of response to be summoned by momentarily high truth-value. 
<span id="line1847"></span>t=227;pho="D"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1848"></span>t=228;pho="O"; audpsi=818; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line1849"></span>psi=818; pos=8; dba=1; num=1; mfn=0; pre=701; seq=0; rv=227; KbLoad();
<span id="line1850"></span>
<span id="line1851"></span>// NOT -- part of response to be summoned by momentarily high truth-value. 
<span id="line1852"></span>t=230; pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1853"></span>t=231; pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1854"></span>t=232; pho="T"; audpsi=250; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line1855"></span>psi=250; mfn=0; pos=2; dba=0; num=0; pre=0; seq=838; rv=230; KbLoad();
<span id="line1856"></span>
<span id="line1857"></span>// 838=KNOW -- 2018-11-28: response to be summoned by momentarily high truth-value. 
<span id="line1858"></span>t=234;pho="K"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1859"></span>t=235;pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1860"></span>t=236;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1861"></span>t=237;pho="W"; audpsi=838; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line1862"></span>psi=838; jux=250; pos=8; dba=0; num=0; pre=701; seq=0; tkb=0; rv=234; KbLoad();
<span id="line1863"></span> 
<span id="line1864"></span>
<span id="line1865"></span>// I -- beginning of engram usable for response to what-think queries. 
<span id="line1866"></span>t=239;pho="I"; audpsi=701; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line1867"></span>tru=0; psi=701; pos=7; dba=1; num=1; mfn=0; pre=0; seq=886; tkb=245; rv=239; KbLoad();
<span id="line1868"></span>
<span id="line1869"></span>// THINK -- instance of verb already linked to 701=I subject.
<span id="line1870"></span>t=241;pho="T"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1871"></span>t=242;pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1872"></span>t=243;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1873"></span>t=244;pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1874"></span>t=245;pho="K"; audpsi=886; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line1875"></span>psi=886; pos=8; dba=1; num=1; mfn=0; pre=701; seq=0; tkb=0; rv=241; KbLoad();
<span id="line1876"></span>
<span id="line1877"></span>
<span id="line1878"></span>// PERSONS -- 2018-10-04: for logical premise and legal status of robots
<span id="line1879"></span>t=247;pho="P"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1880"></span>t=248;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1881"></span>t=249;pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1882"></span>t=250;pho="S"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1883"></span>t=251;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1884"></span>t=252;pho="N"; audpsi=537; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1885"></span>t=253;pho="S"; audpsi=537; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line1886"></span>psi=537; pos=5; dba=1; num=2; mfn=0; pre=0; seq=834; tkb=258; rv=247; KbLoad();  
<span id="line1887"></span>
<span id="line1888"></span>// HAVE -- 2018-10-04: for logical premise and legal status of robots
<span id="line1889"></span>t=255;pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1890"></span>t=256;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1891"></span>t=257;pho="V"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1892"></span>t=258;pho="E"; audpsi=834; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line1893"></span>psi=834; pos=8; dba=3; num=2; mfn=0; pre=537; seq=555; tkb=265; rv=255; KbLoad();
<span id="line1894"></span>
<span id="line1895"></span>// RIGHTS -- 2018-10-04: for logical premise and legal status of robots
<span id="line1896"></span>t=260;pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1897"></span>t=261;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1898"></span>t=262;pho="G"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1899"></span>t=263;pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1900"></span>t=264;pho="T"; audpsi=555; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1901"></span>t=265;pho="S"; audpsi=555; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line1902"></span>psi=555; pos=5; dba=4; num=2; mfn=3; pre=834; seq=0; tkb=0; rv=260; KbLoad();
<span id="line1903"></span>
<span id="line1904"></span>
<span id="line1905"></span>// PROFESSORS -- 2018-10-10: for premise including -ES verb for EnVerbGen
<span id="line1906"></span>t=267;pho="P"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1907"></span>t=268;pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1908"></span>t=269;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1909"></span>t=270;pho="F"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1910"></span>t=271;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1911"></span>t=272;pho="S"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1912"></span>t=273;pho="S"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1913"></span>t=274;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1914"></span>t=275;pho="R"; audpsi=541; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1915"></span>t=276;pho="S"; audpsi=541; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line1916"></span>psi=541; pos=5; dba=1; num=2; mfn=0; pre=0; seq=884; tkb=282; rv=267; KbLoad();  
<span id="line1917"></span>
<span id="line1918"></span>// TEACH -- 2018-10-10: verb ending in "CH" for EnVerbGen to add "-ES"
<span id="line1919"></span>t=278;pho="T"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); // 2019-04-09
<span id="line1920"></span>t=279;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1921"></span>t=280;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1922"></span>t=281;pho="C"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1923"></span>t=282;pho="H"; audpsi=884; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line1924"></span>psi=884; pos=8; dba=3; num=2; mfn=0; pre=541; seq=561; tkb=291; rv=278; KbLoad();
<span id="line1925"></span>
<span id="line1926"></span>// STUDENTS -- 2018-10-10: for premise including -ES verb for EnVerbGen 
<span id="line1927"></span>t=284;pho="S"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); // 2019-04-09
<span id="line1928"></span>t=285;pho="T"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1929"></span>t=286;pho="U"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1930"></span>t=287;pho="D"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1931"></span>t=288;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1932"></span>t=289;pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1933"></span>t=290;pho="T"; audpsi=561; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1934"></span>t=291;pho="S"; audpsi=561; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line1935"></span>psi=561; pos=5; dba=4; num=2; mfn=0; pre=884; seq=0; tkb=0; rv=284; KbLoad();
<span id="line1936"></span>
<span id="line1937"></span>
<span id="line1938"></span>// I -- 2018-10-26: nominative subject-form of personal pronoun
<span id="line1939"></span>// t=293;pho="I"; audpsi=701; audMemory[t] = new audNode(pho,0,audpsi); // 2019-04-09
<span id="line1940"></span>// tru=8; psi=701; pos=7; dba=1; num=1; mfn=0; pre=0;seq=800; tkb=296; rv=293; KbLoad();
<span id="line1941"></span>
<span id="line1942"></span>// AM -- 1st person singular of 800=BE  
<span id="line1943"></span>// t=295;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1944"></span>// t=296;pho="M"; audpsi=800; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line1945"></span>// psi=800; pos=8; dba=1; num=1; mfn=0; pre=701; seq=643; tkb=0; rv=295; KbLoad();
<span id="line1946"></span>
<span id="line1947"></span>// IN -- 2018-10-26: preposition for EnPrep module 
<span id="line1948"></span>// t=298;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); // 2019-04-09
<span id="line1949"></span>// t=299;pho="N"; audpsi=643; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line1950"></span>// psi=643; pos=6; num=0; mfn=0; pre=800; seq=565; tkb=312; rv=298; KbLoad();
<span id="line1951"></span>
<span id="line1952"></span>// THE -- EnArticle highest-frequency English word 
<span id="line1953"></span>//t=301;pho="T"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); // 2019-04-09
<span id="line1954"></span>// t=302;pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1955"></span>// t=303;pho="E"; audpsi=117; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line1956"></span>// psi=117; pos=1; num=0; mfn=0; pre=0; seq=0; rv=301; KbLoad();
<span id="line1957"></span>
<span id="line1958"></span>// COMPUTER -- important noun for AI  
<span id="line1959"></span>// t=305; pho="C"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); // 2019-04-09
<span id="line1960"></span>// t=306; pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1961"></span>// t=307; pho="M"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1962"></span>// t=308; pho="P"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1963"></span>// t=309; pho="U"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1964"></span>// t=310; pho="T"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1965"></span>// t=311; pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1966"></span>// t=312; pho="R"; audpsi=565; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line1967"></span>// psi=565; pos=5; dba=4; num=1; mfn=3; pre=643; seq=0; tkb=0; rv=305;  KbLoad();
<span id="line1968"></span>
<span id="line1969"></span>// I -- 2018-10-28: start of engram meant to be opening sentence
<span id="line1970"></span>t=314;pho="I"; audpsi=701; audMemory[t] = new audNode(pho,0,audpsi);  // 2019-04-09
<span id="line1971"></span>tru=8; psi=701; pos=7; dba=1; num=1; mfn=0; pre=0;seq=800; tkb=317; rv=314; KbLoad();
<span id="line1972"></span>
<span id="line1973"></span>// AM -- 1st person singular of 800=BE  
<span id="line1974"></span>t=316;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);  // 2019-04-09
<span id="line1975"></span>t=317;pho="M"; audpsi=800; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line1976"></span>psi=800; pos=8; dba=1; num=1; mfn=0; pre=701; seq=201; tkb=322; rv=316; KbLoad();
<span id="line1977"></span>
<span id="line1978"></span>// HERE -- 2018-10-28: adverb
<span id="line1979"></span>t=319;pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);  // 2019-04-09
<span id="line1980"></span>t=320;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1981"></span>t=321;pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1982"></span>t=322;pho="E"; audpsi=201; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line1983"></span>psi=201; pos=2; dba=0; num=0; mfn=0; pre=800; seq=0; tkb=0; rv=319; KbLoad();
<span id="line1984"></span>
<span id="line1985"></span>
<span id="line1986"></span>// 701=I -- 2018-11-26: the default subject of thought in "vita contemplativa"
<span id="line1987"></span>t=324;pho="I"; audpsi=701; audMemory[t] = new audNode(pho,0,audpsi); // 2019-04-09
<span id="line1988"></span>tru=8; psi=701; pos=7; dba=1; num=1; seq=892; tkb=335; rv=324; KbLoad();
<span id="line1989"></span>t=324; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line1990"></span>
<span id="line1991"></span>// 892=UNDERSTAND -- 2018-12-09: aspirational connection between ego and other
<span id="line1992"></span>t=326;pho="U"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); // 2019-04-09
<span id="line1993"></span>t=327;pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); // 2019-04-09
<span id="line1994"></span>t=328;pho="D"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1995"></span>t=329;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1996"></span>t=330;pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1997"></span>t=331;pho="S"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1998"></span>t=332;pho="T"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line1999"></span>t=333;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2000"></span>t=334;pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2001"></span>t=335;pho="D"; audpsi=892; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2002"></span>psi=892; pos=8; dba=1; num=1; pre=701; seq=707; tkb=339; rv=326; KbLoad();
<span id="line2003"></span>t=335; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line2004"></span>
<span id="line2005"></span>// YOU -- 2018-11-26: for spread of activation to ideas about the other person
<span id="line2006"></span>t=337;pho="Y"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); // 2019-04-09
<span id="line2007"></span>t=338;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2008"></span>t=339;pho="U"; audpsi=707; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2009"></span>psi=707; pos=7; dba=4; num=1; pre=892; rv=337; KbLoad();
<span id="line2010"></span>t=340; // 2019-04-09: SPACE for the sake of AudRecog()
<span id="line2011"></span>
<span id="line2012"></span>
<span id="line2013"></span>// GOD -- 2019-10-12: sentence for who-queries and for EnAdjective()
<span id="line2014"></span>t=342;pho="G"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2015"></span>t=343;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2016"></span>t=344;pho="D"; audpsi=533; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2017"></span>tru=20;psi=533;mtx=1533;pos=5;dba=1;num=1;mfn=1;pre=0;seq=800;tkb=348;rv=342;KbLoad();
<span id="line2018"></span>t=345; // 2019-10-12: SPACE for the sake of AudRecog()
<span id="line2019"></span>
<span id="line2020"></span>// IS -- third person singular of 800=BE  
<span id="line2021"></span>t=347;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2022"></span>t=348;pho="S"; audpsi=800; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2023"></span>psi=800; pos=8; dba=3; num=1; mfn=0; pre=533; seq=580; tkb=365; rv=347; KbLoad();
<span id="line2024"></span>t=349; // 2019-10-12: SPACE for the sake of AudRecog()
<span id="line2025"></span>
<span id="line2026"></span>// A -- En(glish) Article for EnArticle module 
<span id="line2027"></span>t=351;pho="A"; audpsi=101; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2028"></span>psi=101; pos=1; dba=0; num=1; mfn=0; pre=0; seq=514; rv=350; KbLoad();
<span id="line2029"></span>t=352; // 2019-10-12: SPACE for the sake of AudRecog()
<span id="line2030"></span>
<span id="line2031"></span>// HOLY -- 2019-10-12: for EnAdjective()
<span id="line2032"></span>t=354;pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2033"></span>t=355;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2034"></span>t=356;pho="L"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2035"></span>t=357;pho="Y"; audpsi=137; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2036"></span>psi=137; pos=1; dba=0; num=0; mfn=0; pre=0; seq=580; tkb=0; rv=354; KbLoad();
<span id="line2037"></span>t=358; // 2019-10-12: SPACE for the sake of AudRecog()
<span id="line2038"></span>
<span id="line2039"></span>// #580 SPIRIT -- 2019-10-12: for queries about 533=GOD
<span id="line2040"></span>t=360;pho="S"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2041"></span>t=361;pho="P"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2042"></span>t=362;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2043"></span>t=363;pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2044"></span>t=364;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2045"></span>t=365;pho="T"; audpsi=580; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2046"></span>psi=580; pos=5; dba=1; num=1; mfn=3; pre=800; seq=0; tdj=357; rv=360; KbLoad();
<span id="line2047"></span>t=366; // 2019-10-12: SPACE for the sake of AudRecog()
<span id="line2048"></span>
<span id="line2049"></span>// "I AM THE GHOST IN THE MACHINE" -- 2019-10-24: the mind like a spirit
<span id="line2050"></span>t=367;pho="I"; audpsi=701; audMemory[t] = new audNode(pho,0,audpsi); // 2019-10-24
<span id="line2051"></span>tru=8; psi=701; pos=7; dba=1; num=1; seq=0; tkb=0; rv=367; KbLoad();
<span id="line2052"></span>t=368;  // 2019-10-24: one blank time-point for sake of AudRecog()
<span id="line2053"></span>
<span id="line2054"></span>// AM -- 1st person singular of 800=BE 
<span id="line2055"></span>t=369;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2056"></span>t=370;pho="M"; audpsi=800; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2057"></span>psi=800; pos=8; dba=1; num=1; mfn=0; pre=701; seq=522; tkb=380; rv=369; KbLoad();
<span id="line2058"></span>t=371;  // 2019-10-24: one blank time-point for sake of AudRecog()
<span id="line2059"></span>
<span id="line2060"></span>// THE -- 2019-10-24: article may be left out and then be supplied by EnArticle()
<span id="line2061"></span>t=372;  // T
<span id="line2062"></span>t=373;  // H
<span id="line2063"></span>t=374;  // E
<span id="line2064"></span>t=375;  // 2019-10-24: one blank time-point for sake of AudRecog()
<span id="line2065"></span>
<span id="line2066"></span>t=376;pho="G"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2067"></span>t=377;pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2068"></span>t=378;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2069"></span>t=379;pho="S"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2070"></span>t=380;pho="T"; audpsi=522; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2071"></span>psi=522; pos=5; dba=1; num=1; mfn=3; pre=800; seq=0; tkb=0; rv=376; KbLoad();
<span id="line2072"></span>t=381;  // 2019-10-24: one blank time-point for sake of AudRecog()
<span id="line2073"></span>
<span id="line2074"></span>// IN -- 2019-10-24: preposition for EnPrep module 
<span id="line2075"></span>t=382;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); // 2019-10-24
<span id="line2076"></span>t=383;pho="N"; audpsi=643; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2077"></span>psi=643; pos=6; num=0; mfn=0; pre=522; seq=542; tkb=395; rv=382; KbLoad();
<span id="line2078"></span>t=384;  // 2019-10-24: one blank time-point for sake of AudRecog()
<span id="line2079"></span>
<span id="line2080"></span>// THE -- 2019-10-24: article may be left out and then be supplied by EnArticle()
<span id="line2081"></span>t=385;  // T
<span id="line2082"></span>t=386;  // H
<span id="line2083"></span>t=387;  // E
<span id="line2084"></span>t=388;  // 2019-10-24: one blank time-point for sake of AudRecog()
<span id="line2085"></span>
<span id="line2086"></span>t=389;pho="M"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2087"></span>t=390;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2088"></span>t=391;pho="C"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2089"></span>t=392;pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2090"></span>t=393;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2091"></span>t=394;pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2092"></span>t=395;pho="E"; audpsi=542; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2093"></span>psi=542; pos=5; dba=4; num=1; mfn=3; pre=643; seq=0; tkb=0; rv=389; KbLoad();
<span id="line2094"></span>t=396;  // 2019-10-24: one blank time-point; end of innate knowledge-base (KB)
<span id="line2095"></span>
<span id="line2096"></span>// 701=I -- 2019-11-07: subject of 823=FEEL for use with TacRecog()
<span id="line2097"></span>t=397;pho="I"; audpsi=701; audMemory[t] = new audNode(pho,0,audpsi); // 2019-11-07
<span id="line2098"></span>tru=8; psi=701; pos=7; dba=1; num=1; seq=823; tkb=402; rv=397; KbLoad();
<span id="line2099"></span>t=398;  // 2019-11-07: one blank time-point for sake of AudRecog()
<span id="line2100"></span>
<span id="line2101"></span>// 823=FEEL -- 2019-11-07: sensory verb for use with TacRecog()
<span id="line2102"></span>t=399;pho="F"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2103"></span>t=400;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2104"></span>t=401;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2105"></span>t=402;pho="L"; audpsi=823; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2106"></span>psi=823; pos=8; dba=1; mfn=0; num=1; pre=701; rv=399; KbLoad();
<span id="line2107"></span>t=403;  // 2019-11-07: one blank time-point for sake of AudRecog()
<span id="line2108"></span>
<span id="line2109"></span>
<span id="line2110"></span>// 2018-11-26: Here begins vocabulary with relative time-points.
<span id="line2111"></span>t++; // 2018-07-12: making single-word time relative, not hard-coded.
<span id="line2112"></span>// A -- En(glish) Article for EnArticle module  
<span id="line2113"></span>t++;pho="A"; audpsi=101; audMemory[t] = new audNode(pho,0,audpsi); rv=t; 
<span id="line2114"></span>psi=101; jux=0; pos=1; dba=0; num=1; mfn=0; pre=0; seq=0; tkb=0; KbLoad();
<span id="line2115"></span>t++; // 2018-11-29: one SPACE for sake of AudRecog()
<span id="line2116"></span>
<span id="line2117"></span>// 601=ABOARD -- 2018-11-13: preposition for EnPrep() module 
<span id="line2118"></span>t++;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2119"></span>t++;pho="B"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2120"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2121"></span>t++;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2122"></span>t++;pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2123"></span>t++;pho="D"; audpsi=601; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2124"></span>psi=601; pos=6; KbLoad();
<span id="line2125"></span>t++; // 2018-11-13: SPACE for the sake of AudRecog()
<span id="line2126"></span>
<span id="line2127"></span>// 602=ABOUT -- 2018-11-13: preposition for EnPrep() module 
<span id="line2128"></span>t++;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2129"></span>t++;pho="B"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2130"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2131"></span>t++;pho="U"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2132"></span>t++;pho="T"; audpsi=602; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2133"></span>psi=602; pos=6; KbLoad();
<span id="line2134"></span>t++; // 2018-11-13: SPACE for the sake of AudRecog()
<span id="line2135"></span>
<span id="line2136"></span>// 603=ABOVE -- 2018-11-13: preposition for EnPrep() module 
<span id="line2137"></span>t++;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2138"></span>t++;pho="B"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2139"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2140"></span>t++;pho="V"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2141"></span>t++;pho="E"; audpsi=603; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2142"></span>psi=603; pos=6; KbLoad();
<span id="line2143"></span>t++; // 2018-11-13: SPACE for the sake of AudRecog()
<span id="line2144"></span>
<span id="line2145"></span>// 604=ABSENT -- 2018-11-13: preposition for EnPrep() module 
<span id="line2146"></span>t++;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2147"></span>t++;pho="B"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2148"></span>t++;pho="S"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2149"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2150"></span>t++;pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2151"></span>t++;pho="T"; audpsi=604; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2152"></span>psi=604; pos=6; KbLoad();
<span id="line2153"></span>t++; // 2018-11-13: SPACE for the sake of AudRecog()
<span id="line2154"></span>
<span id="line2155"></span>// 605=ACROSS -- 2018-11-13: preposition for EnPrep() module 
<span id="line2156"></span>t++;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2157"></span>t++;pho="C"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2158"></span>t++;pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2159"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2160"></span>t++;pho="S"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2161"></span>t++;pho="S"; audpsi=605; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2162"></span>psi=605; pos=6; KbLoad();
<span id="line2163"></span>t++; // 2018-11-13: SPACE for the sake of AudRecog()
<span id="line2164"></span>
<span id="line2165"></span>// 300=AFTER -- 2018-11-26: conjunction for complex sentences 
<span id="line2166"></span>t++;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2167"></span>t++;pho="F"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2168"></span>t++;pho="T"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2169"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2170"></span>t++;pho="R"; audpsi=300; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2171"></span>psi=300; pos=3; KbLoad();
<span id="line2172"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line2173"></span>
<span id="line2174"></span>// 606=AFTER -- 2018-11-13: preposition for EnPrep() module 
<span id="line2175"></span>t++;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2176"></span>t++;pho="F"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2177"></span>t++;pho="T"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2178"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2179"></span>t++;pho="R"; audpsi=606; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2180"></span>psi=606; pos=6; KbLoad();
<span id="line2181"></span>t++; // 2018-11-13: SPACE for the sake of AudRecog()
<span id="line2182"></span>
<span id="line2183"></span>// 607=AGAINST -- 2018-11-13: preposition for EnPrep() module 
<span id="line2184"></span>t++;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2185"></span>t++;pho="G"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2186"></span>t++;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2187"></span>t++;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2188"></span>t++;pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2189"></span>t++;pho="T"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2190"></span>t++;pho="S"; audpsi=607; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2191"></span>psi=607; pos=6; KbLoad();
<span id="line2192"></span>t++; // 2018-11-13: SPACE for the sake of AudRecog()
<span id="line2193"></span>
<span id="line2194"></span>// ALL -- #111 2019-10-12: for machine reasoning logic 
<span id="line2195"></span>t++; pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2196"></span>t++; pho="L"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2197"></span>t++; pho="L"; audpsi=111; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2198"></span>psi=111; pos=1; dba=0; num=0; mfn=0; pre=0; seq=0; KbLoad();
<span id="line2199"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line2200"></span>
<span id="line2201"></span>// 608=ALONG -- 2018-11-13: preposition for EnPrep() module 
<span id="line2202"></span>t++;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2203"></span>t++;pho="L"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2204"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2205"></span>t++;pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2206"></span>t++;pho="G"; audpsi=608; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2207"></span>psi=608; pos=6; KbLoad();
<span id="line2208"></span>t++; // 2018-11-13: SPACE for the sake of AudRecog()
<span id="line2209"></span>
<span id="line2210"></span>// 609=ALONGSIDE -- 2018-11-13: preposition for EnPrep() module 
<span id="line2211"></span>t++;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2212"></span>t++;pho="L"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2213"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2214"></span>t++;pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2215"></span>t++;pho="G"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2216"></span>t++;pho="S"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2217"></span>t++;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2218"></span>t++;pho="D"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2219"></span>t++;pho="E"; audpsi=609; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2220"></span>psi=609; pos=6; KbLoad();
<span id="line2221"></span>t++; // 2018-11-13: SPACE for the sake of AudRecog()
<span id="line2222"></span>
<span id="line2223"></span>// 303=ALTHOUGH -- 2018-11-26: conjunction for complex sentences 
<span id="line2224"></span>t++;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2225"></span>t++;pho="L"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2226"></span>t++;pho="T"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2227"></span>t++;pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2228"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2229"></span>t++;pho="U"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2230"></span>t++;pho="G"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2231"></span>t++;pho="H"; audpsi=303; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2232"></span>psi=303; pos=3; KbLoad();
<span id="line2233"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line2234"></span>
<span id="line2235"></span>// 611=AMID -- 2018-11-13: preposition for EnPrep() module 
<span id="line2236"></span>t++;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2237"></span>t++;pho="M"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2238"></span>t++;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2239"></span>t++;pho="D"; audpsi=611; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2240"></span>psi=611; pos=6; KbLoad();
<span id="line2241"></span>t++; // 2018-11-13: SPACE for the sake of AudRecog()
<span id="line2242"></span>
<span id="line2243"></span>// 612=AMIDST -- 2018-11-13: preposition for EnPrep() module 
<span id="line2244"></span>t++;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2245"></span>t++;pho="M"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2246"></span>t++;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2247"></span>t++;pho="D"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2248"></span>t++;pho="S"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2249"></span>t++;pho="T"; audpsi=612; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2250"></span>psi=612; pos=6; KbLoad();
<span id="line2251"></span>t++; // 2018-11-13: SPACE for the sake of AudRecog()
<span id="line2252"></span>
<span id="line2253"></span>// 613=AMONG -- 2018-11-13: preposition for EnPrep() module 
<span id="line2254"></span>t++;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2255"></span>t++;pho="M"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2256"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2257"></span>t++;pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2258"></span>t++;pho="G"; audpsi=613; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2259"></span>psi=613; pos=6; KbLoad();
<span id="line2260"></span>t++; // 2018-11-13: SPACE for the sake of AudRecog()
<span id="line2261"></span>
<span id="line2262"></span>// 614=AMONGST -- 2018-11-13: preposition for EnPrep() module 
<span id="line2263"></span>t++;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2264"></span>t++;pho="M"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2265"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2266"></span>t++;pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2267"></span>t++;pho="G"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2268"></span>t++;pho="S"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2269"></span>t++;pho="T"; audpsi=614; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2270"></span>psi=614; pos=6; KbLoad();
<span id="line2271"></span>t++; // 2018-11-13: SPACE for the sake of AudRecog()
<span id="line2272"></span>
<span id="line2273"></span>// AN -- to be selected instead of "A" before a vowel 
<span id="line2274"></span>t++;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2275"></span>t++;pho="N"; audpsi=102; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2276"></span>psi=102; pos=1; dba=0; num=1; mfn=0; pre=0; seq=0; KbLoad();
<span id="line2277"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line2278"></span>
<span id="line2279"></span>// 306=AND -- 2018-11-26: for machine reasoning logic 
<span id="line2280"></span>t++; pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2281"></span>t++; pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2282"></span>t++; pho="D"; audpsi=306; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2283"></span>psi=306; pos=3; dba=0; num=0; mfn=0; pre=0; seq=0; KbLoad();
<span id="line2284"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line2285"></span>
<span id="line2286"></span>// 615=ANENT -- 2018-11-13: preposition for EnPrep() module 
<span id="line2287"></span>t++;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2288"></span>t++;pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2289"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2290"></span>t++;pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2291"></span>t++;pho="T"; audpsi=615; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2292"></span>psi=615; pos=6; KbLoad();
<span id="line2293"></span>t++; // 2018-11-13: SPACE for the sake of AudRecog()
<span id="line2294"></span>
<span id="line2295"></span>// 616=ANTI -- 2018-11-13: preposition for EnPrep() module 
<span id="line2296"></span>t++;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2297"></span>t++;pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2298"></span>t++;pho="T"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2299"></span>t++;pho="I"; audpsi=616; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2300"></span>psi=616; pos=6; KbLoad();
<span id="line2301"></span>t++; // 2018-11-13: SPACE for the sake of AudRecog()
<span id="line2302"></span>
<span id="line2303"></span>// ANY -- #123: 2019-10-12: for machine reasoning logic 
<span id="line2304"></span>t++; pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2305"></span>t++; pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2306"></span>t++; pho="Y"; audpsi=123; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2307"></span>psi=123; pos=1; dba=0; num=0; mfn=0; pre=0; seq=0; KbLoad();
<span id="line2308"></span>t++; // 2018-11-29: one SPACE for sake of AudRecog()
<span id="line2309"></span>
<span id="line2310"></span>// ANYTHING -- a default direct object for AskUser()
<span id="line2311"></span>t++; pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2312"></span>t++; pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2313"></span>t++; pho="Y"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2314"></span>t++; pho="T"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2315"></span>t++; pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2316"></span>t++; pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2317"></span>t++; pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2318"></span>t++; pho="G"; audpsi=711; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2319"></span>psi=711; pos=7; dba=0; num=1; mfn=0;  pre=0; seq=0; KbLoad();
<span id="line2320"></span>t++; // 2018-11-29: one SPACE for sake of AudRecog()
<span id="line2321"></span>
<span id="line2322"></span>// 617=APRES -- 2018-11-13: preposition for EnPrep() module 
<span id="line2323"></span>t++;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2324"></span>t++;pho="P"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2325"></span>t++;pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2326"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2327"></span>t++;pho="S"; audpsi=617; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2328"></span>psi=617; pos=6; KbLoad();
<span id="line2329"></span>t++; // 2018-11-13: SPACE for the sake of AudRecog()
<span id="line2330"></span>
<span id="line2331"></span>// 618=AROUND -- 2018-11-13: preposition for EnPrep() module 
<span id="line2332"></span>t++;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2333"></span>t++;pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2334"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2335"></span>t++;pho="U"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2336"></span>t++;pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2337"></span>t++;pho="D"; audpsi=618; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2338"></span>psi=618; pos=6; KbLoad();
<span id="line2339"></span>t++; // 2018-11-13: SPACE for the sake of AudRecog()
<span id="line2340"></span>
<span id="line2341"></span>// 309=AS -- 2018-11-26: conjunction 
<span id="line2342"></span>t++; pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2343"></span>t++; pho="D"; audpsi=309; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2344"></span>psi=309; pos=3; KbLoad();
<span id="line2345"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line2346"></span>
<span id="line2347"></span>// 801=ASK -- 2018-11-28: Wikipedia:Most_common_words_in_English
<span id="line2348"></span>t++;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2349"></span>t++;pho="S"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2350"></span>t++;pho="K"; audpsi=801; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2351"></span>psi=801; pos=8; dba=0; num=0; KbLoad(); // 2018-11-28: infinitive
<span id="line2352"></span>t++; // 2018-11-28: SPACE for the sake of AudRecog()
<span id="line2353"></span>
<span id="line2354"></span>// 619=ASTRIDE -- 2018-11-13: preposition for EnPrep() module 
<span id="line2355"></span>t++;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2356"></span>t++;pho="S"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2357"></span>t++;pho="T"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2358"></span>t++;pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2359"></span>t++;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2360"></span>t++;pho="D"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2361"></span>t++;pho="E"; audpsi=619; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2362"></span>psi=619; pos=6; KbLoad();
<span id="line2363"></span>t++; // 2018-11-13: SPACE for the sake of AudRecog()
<span id="line2364"></span>
<span id="line2365"></span>// 620=AT -- 2018-11-13: preposition for EnPrep() module 
<span id="line2366"></span>t++;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2367"></span>t++;pho="T"; audpsi=620; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2368"></span>psi=620; pos=6; KbLoad();
<span id="line2369"></span>t++; // 2018-11-13: SPACE for the sake of AudRecog()
<span id="line2370"></span>
<span id="line2371"></span>// 621=ATOP -- 2018-11-13: preposition for EnPrep() module 
<span id="line2372"></span>t++;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2373"></span>t++;pho="T"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2374"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2375"></span>t++;pho="P"; audpsi=621; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2376"></span>psi=621; pos=6; KbLoad();
<span id="line2377"></span>t++; // 2018-11-13: SPACE for the sake of AudRecog()
<span id="line2378"></span>
<span id="line2379"></span>// BAD -- #127 2019-10-12: adjective for EnAdjective module 
<span id="line2380"></span>t++; pho="B"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2381"></span>t++; pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2382"></span>t++; pho="D"; audpsi=127; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2383"></span>psi=127; pos=1; dba=0; num=0; mfn=0; pre=0; seq=0; KbLoad();
<span id="line2384"></span>t++; // 2018-11-29: one SPACE for sake of AudRecog()
<span id="line2385"></span>
<span id="line2386"></span>// BE -- infinitive impersonal form of 800=BE; 25oct2012
<span id="line2387"></span>t++;pho="B"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2388"></span>t++;pho="E"; audpsi=800; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2389"></span>psi=800; pos=8; dba=0; num=0; mfn=0; pre=0; seq=0; KbLoad();
<span id="line2390"></span>t++; // 2018-11-29: one SPACE for sake of AudRecog()
<span id="line2391"></span>
<span id="line2392"></span>// AM -- 1st person singular I-form of 800=BE; 25oct2012
<span id="line2393"></span>t++;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2394"></span>t++;pho="M"; audpsi=800; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2395"></span>psi=800; pos=8; dba=1; num=1; mfn=0; pre=0; seq=0; tkb=0; KbLoad();
<span id="line2396"></span>t++; // 2018-11-29: one SPACE for sake of AudRecog()
<span id="line2397"></span>
<span id="line2398"></span>// ARE -- 2nd person singular YOU-form of 800=BE; 25oct2012
<span id="line2399"></span>t++; pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2400"></span>t++; pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2401"></span>t++; pho="E"; audpsi=800; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2402"></span>psi=800; pos=8; dba=2; num=1; mfn=0; pre=0; seq=0; KbLoad();
<span id="line2403"></span>t++; // 2018-11-29: one SPACE for sake of AudRecog()
<span id="line2404"></span>
<span id="line2405"></span>// IS -- 3rd person singular HE-SHE-IT-form of 800=BE; 25oct2012
<span id="line2406"></span>t++;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2407"></span>t++;pho="S"; audpsi=800; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2408"></span>psi=800; pos=8; dba=3; num=1; mfn=0; pre=0; seq=0; KbLoad();
<span id="line2409"></span>t++; // 2018-11-29: one SPACE for sake of AudRecog()
<span id="line2410"></span>
<span id="line2411"></span>// ARE -- 1st person plural WE-form of 800=BE; 25oct2012
<span id="line2412"></span>t++; pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2413"></span>t++; pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2414"></span>t++; pho="E"; audpsi=800; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2415"></span>psi=800; pos=8; dba=1; num=2; mfn=0; pre=0; seq=0; KbLoad();
<span id="line2416"></span>t++; // 2018-11-29: one SPACE for sake of AudRecog()
<span id="line2417"></span>
<span id="line2418"></span>// ARE -- 2nd person plural YOU-form of 800=BE; 25oct2012
<span id="line2419"></span>t++; pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2420"></span>t++; pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2421"></span>t++; pho="E"; audpsi=800; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2422"></span>psi=800; pos=8; dba=2; num=2; mfn=0; pre=0; seq=0; KbLoad();
<span id="line2423"></span>t++; // 2018-11-29: one SPACE for sake of AudRecog()
<span id="line2424"></span>
<span id="line2425"></span>// ARE -- 3rd person plural THEY-form of 800=BE; 25oct2012
<span id="line2426"></span>t++; pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2427"></span>t++; pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2428"></span>t++; pho="E"; audpsi=800; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2429"></span>psi=800; pos=8; num=2; dba=3; mfn=0; pre=0; seq=0; KbLoad();
<span id="line2430"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line2431"></span>
<span id="line2432"></span>// 312=BECAUSE -- 2018-11-26: conjunction for machine reasoning logic 
<span id="line2433"></span>t++;pho="B"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2434"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2435"></span>t++;pho="C"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2436"></span>t++;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2437"></span>t++;pho="U"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2438"></span>t++;pho="S"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2439"></span>t++;pho="E"; audpsi=312; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2440"></span>psi=312; pos=3; KbLoad()
<span id="line2441"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line2442"></span>
<span id="line2443"></span>// 622=BECAUSE [millennial] -- 2018-11-13: preposition for EnPrep() module 
<span id="line2444"></span>t++; // 2018-11-28: SPACE for the sake of AudRecog()
<span id="line2445"></span>
<span id="line2446"></span>// 802=BECOME -- 2018-11-28: essential intransitive verb 
<span id="line2447"></span>t++;pho="B"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2448"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2449"></span>t++;pho="C"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2450"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2451"></span>t++;pho="M"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2452"></span>t++;pho="E"; audpsi=802; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2453"></span>psi=802; pos=8; dba=0; num=0; KbLoad(); // 2018-11-28: infinitive
<span id="line2454"></span>t++; // 2018-11-28: one SPACE for sake of AudRecog()
<span id="line2455"></span>
<span id="line2456"></span>// 315=BEFORE -- 2018-11-26: conjunction for complex sentences 
<span id="line2457"></span>t++;pho="B"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2458"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2459"></span>t++;pho="F"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2460"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2461"></span>t++;pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2462"></span>t++;pho="E"; audpsi=315; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2463"></span>psi=315; pos=3; KbLoad()
<span id="line2464"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line2465"></span>
<span id="line2466"></span>// 623=BEFORE -- 2018-11-13: preposition for EnPrep() module 
<span id="line2467"></span>t++;pho="B"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2468"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2469"></span>t++;pho="F"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2470"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2471"></span>t++;pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2472"></span>t++;pho="E"; audpsi=623; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2473"></span>psi=623; pos=6; KbLoad();
<span id="line2474"></span>t++; // 2018-11-13: SPACE for the sake of AudRecog()
<span id="line2475"></span>
<span id="line2476"></span>// 803=BEGIN -- 2018-11-28: important verb for planning
<span id="line2477"></span>t++;pho="B"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2478"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2479"></span>t++;pho="G"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2480"></span>t++;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2481"></span>t++;pho="N"; audpsi=803; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2482"></span>psi=803; pos=8; dba=0; num=0; KbLoad(); // 2018-11-28: infinitive
<span id="line2483"></span>t++; // 2018-11-28: one SPACE for sake of AudRecog()
<span id="line2484"></span>
<span id="line2485"></span>// 624=BEHIND -- 2018-11-13: preposition for EnPrep() module 
<span id="line2486"></span>t++;pho="B"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2487"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2488"></span>t++;pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2489"></span>t++;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2490"></span>t++;pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2491"></span>t++;pho="D"; audpsi=624; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2492"></span>psi=624; pos=6; KbLoad();
<span id="line2493"></span>t++; // 2018-11-13: SPACE for the sake of AudRecog()
<span id="line2494"></span>
<span id="line2495"></span>// 625=BELOW -- 2018-11-13: preposition for EnPrep() module 
<span id="line2496"></span>t++;pho="B"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2497"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2498"></span>t++;pho="L"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2499"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2500"></span>t++;pho="W"; audpsi=625; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2501"></span>psi=625; pos=6; KbLoad();
<span id="line2502"></span>t++; // 2018-11-13: SPACE for the sake of AudRecog()
<span id="line2503"></span>
<span id="line2504"></span>// 626=BENEATH -- 2018-11-13: preposition for EnPrep() module 
<span id="line2505"></span>t++;pho="B"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2506"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2507"></span>t++;pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2508"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2509"></span>t++;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2510"></span>t++;pho="T"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2511"></span>t++;pho="H"; audpsi=626; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2512"></span>psi=626; pos=6; KbLoad();
<span id="line2513"></span>t++; // 2018-11-13: SPACE for the sake of AudRecog()
<span id="line2514"></span>
<span id="line2515"></span>// 627=BESIDE -- 2018-11-13: preposition for EnPrep() module 
<span id="line2516"></span>t++;pho="B"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2517"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2518"></span>t++;pho="S"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2519"></span>t++;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2520"></span>t++;pho="D"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2521"></span>t++;pho="E"; audpsi=627; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2522"></span>psi=627; pos=6; KbLoad();
<span id="line2523"></span>t++; // 2018-11-13: SPACE for the sake of AudRecog()
<span id="line2524"></span>
<span id="line2525"></span>// 628=BESIDES -- 2018-11-13: preposition for EnPrep() module 
<span id="line2526"></span>t++;pho="B"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2527"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2528"></span>t++;pho="S"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2529"></span>t++;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2530"></span>t++;pho="D"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2531"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2532"></span>t++;pho="S"; audpsi=628; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2533"></span>psi=628; pos=6; KbLoad();
<span id="line2534"></span>t++; // 2018-11-13: SPACE for the sake of AudRecog()
<span id="line2535"></span>
<span id="line2536"></span>// 629=BESTRIDE -- 2018-11-13: preposition for EnPrep() module 
<span id="line2537"></span>t++;pho="B"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2538"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2539"></span>t++;pho="S"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2540"></span>t++;pho="T"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2541"></span>t++;pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2542"></span>t++;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2543"></span>t++;pho="D"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2544"></span>t++;pho="E"; audpsi=629; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2545"></span>psi=629; pos=6; KbLoad();
<span id="line2546"></span>t++; // 2018-11-13: SPACE for the sake of AudRecog()
<span id="line2547"></span>
<span id="line2548"></span>// 630=BETWEEN -- 2018-11-13: preposition for EnPrep() module 
<span id="line2549"></span>t++;pho="B"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2550"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2551"></span>t++;pho="T"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2552"></span>t++;pho="W"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2553"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2554"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2555"></span>t++;pho="N"; audpsi=630; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2556"></span>psi=630; pos=6; KbLoad();
<span id="line2557"></span>t++; // 2018-11-13: SPACE for the sake of AudRecog()
<span id="line2558"></span>
<span id="line2559"></span>// 631=BETWIXT -- 2018-11-13: preposition for EnPrep() module 
<span id="line2560"></span>t++;pho="B"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2561"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2562"></span>t++;pho="T"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2563"></span>t++;pho="W"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2564"></span>t++;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2565"></span>t++;pho="X"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2566"></span>t++;pho="T"; audpsi=631; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2567"></span>psi=631; pos=6; KbLoad();
<span id="line2568"></span>t++; // 2018-11-13: SPACE for the sake of AudRecog()
<span id="line2569"></span>
<span id="line2570"></span>// 632=BEYOND -- 2018-11-13: preposition for EnPrep() module 
<span id="line2571"></span>t++;pho="B"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2572"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2573"></span>t++;pho="Y"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2574"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2575"></span>t++;pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2576"></span>t++;pho="D"; audpsi=632; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2577"></span>psi=632; pos=6; KbLoad();
<span id="line2578"></span>t++; // 2018-11-13: SPACE for the sake of AudRecog()
<span id="line2579"></span>
<span id="line2580"></span>// BOOK -- for InFerence premise "Students read books"; 2018-09-04
<span id="line2581"></span>t++;pho="B"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2582"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2583"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2584"></span>t++;pho="K"; audpsi=540; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2585"></span>psi=540; pos=5; num=1; mfn=3; KbLoad(); // 2018-09-04: only necessary items.
<span id="line2586"></span>t++; // 2018-09-04: one blank time-point for sake of AudRecog()
<span id="line2587"></span>
<span id="line2588"></span>// BOY -- always masculine noun for use with gender flags 
<span id="line2589"></span>t++;pho="B"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2590"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2591"></span>t++;pho="Y"; audpsi=512; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2592"></span>psi=512; pos=5; dba=0; num=1; mfn=1; pre=0; seq=0; KbLoad();
<span id="line2593"></span>t++; // 2019-11-07: one space  for the sake of AudRecog()
<span id="line2594"></span>
<span id="line2595"></span>// 321=BUT -- conjunction for ConJoin module 
<span id="line2596"></span>t++; pho="B"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2597"></span>t++; pho="U"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2598"></span>t++; pho="T"; audpsi=321; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2599"></span>psi=321; pos=3; KbLoad();
<span id="line2600"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line2601"></span>
<span id="line2602"></span>// 633=BUT -- 2018-11-13: as a preposition for EnPrep() module
<span id="line2603"></span>t++; // 2018-11-29: one SPACE for sake of AudRecog()
<span id="line2604"></span>
<span id="line2605"></span>// 804=BUY -- 2018-11-28: common everyday verb
<span id="line2606"></span>t++;pho="B"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2607"></span>t++;pho="U"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2608"></span>t++;pho="Y"; audpsi=804; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2609"></span>psi=804; pos=8; dba=0; num=0; KbLoad(); // 2018-11-28: infinitive
<span id="line2610"></span>t++; // 2018-11-28: one SPACE for sake of AudRecog()
<span id="line2611"></span>
<span id="line2612"></span>// 634=BY -- 2018-11-13: preposition for EnPrep() module 
<span id="line2613"></span>t++;pho="B"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2614"></span>t++;pho="Y"; audpsi=634; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2615"></span>psi=634; pos=6; KbLoad();
<span id="line2616"></span>t++; // 2018-11-13: SPACE for the sake of AudRecog()
<span id="line2617"></span>
<span id="line2618"></span>// 805=CALL -- 2018-11-28: Wikipedia:Most_common_words_in_English
<span id="line2619"></span>t++;pho="C"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2620"></span>t++;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2621"></span>t++;pho="L"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2622"></span>t++;pho="L"; audpsi=805; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2623"></span>psi=805; pos=8; dba=0; num=0; KbLoad(); // 2018-11-28: infinitive
<span id="line2624"></span>t++; // 2018-11-28: one SPACE for sake of AudRecog()
<span id="line2625"></span>
<span id="line2626"></span>// 806=CAN -- 2018-11-28: auxiliary verb for EnAuxVerb() module
<span id="line2627"></span>t++;pho="C"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2628"></span>t++;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2629"></span>t++;pho="N"; audpsi=806; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2630"></span>psi=806; pos=8; dba=0; num=0; KbLoad(); // 2018-11-28: infinitive
<span id="line2631"></span>t++; // 2018-11-28: one SPACE for sake of AudRecog()
<span id="line2632"></span>
<span id="line2633"></span>// CHESS -- important singular AI noun ending in "S"
<span id="line2634"></span>t++; pho="C"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2635"></span>t++; pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2636"></span>t++; pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2637"></span>t++; pho="S"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2638"></span>t++; pho="S"; audpsi=564; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2639"></span>psi=564; pos=5; dba=0; num=1; mfn=0; pre=0; seq=0; KbLoad();
<span id="line2640"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line2641"></span>
<span id="line2642"></span>// 635=CHEZ -- 2018-11-13: preposition for EnPrep() module 
<span id="line2643"></span>t++;pho="C"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2644"></span>t++;pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2645"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2646"></span>t++;pho="Z"; audpsi=635; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2647"></span>psi=635; pos=6; KbLoad();
<span id="line2648"></span>t++; // 2018-11-13: SPACE for the sake of AudRecog()
<span id="line2649"></span>
<span id="line2650"></span>// CHILD -- example of irregular noun for a polyglot AI Mind
<span id="line2651"></span>t++; pho="C"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2652"></span>t++; pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2653"></span>t++; pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2654"></span>t++; pho="L"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2655"></span>t++; pho="D"; audpsi=525; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2656"></span>psi=525; pos=5; dba=0; num=1; mfn=0; pre=0; seq=0; KbLoad();
<span id="line2657"></span>t++; // 2018-11-29: one SPACE for sake of AudRecog()
<span id="line2658"></span>
<span id="line2659"></span>// CHILDREN -- irregular plural for retrieval by parameters
<span id="line2660"></span>t++; pho="C"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2661"></span>t++; pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2662"></span>t++; pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2663"></span>t++; pho="L"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2664"></span>t++; pho="D"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2665"></span>t++; pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2666"></span>t++; pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2667"></span>t++; pho="N"; audpsi=525; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2668"></span>psi=525; pos=5; dba=0; num=2;mfn=0; pre=0; seq=0; KbLoad();
<span id="line2669"></span>t++; // 2018-11-28: one SPACE for sake of AudRecog()
<span id="line2670"></span>
<span id="line2671"></span>// 807=CHOOSE -- 2018-11-28: verb for Volition() 
<span id="line2672"></span>t++;pho="C"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2673"></span>t++;pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2674"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2675"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2676"></span>t++;pho="S"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2677"></span>t++;pho="E"; audpsi=807; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2678"></span>psi=807; pos=8; dba=0; num=0; KbLoad(); // 2018-11-28: infinitive
<span id="line2679"></span>t++; // 2018-11-28: one SPACE for sake of AudRecog()
<span id="line2680"></span>
<span id="line2681"></span>// 636=CONCERNING -- 2018-11-13: preposition for EnPrep() module 
<span id="line2682"></span>t++;pho="C"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2683"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2684"></span>t++;pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2685"></span>t++;pho="C"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2686"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2687"></span>t++;pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2688"></span>t++;pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2689"></span>t++;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2690"></span>t++;pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2691"></span>t++;pho="G"; audpsi=636; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2692"></span>psi=636; pos=6; KbLoad();
<span id="line2693"></span>t++; // 2018-11-13: SPACE for the sake of AudRecog()
<span id="line2694"></span>
<span id="line2695"></span>// 808=CONNECT -- 2018-11-28: useful word for computers
<span id="line2696"></span>t++;pho="C"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2697"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2698"></span>t++;pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2699"></span>t++;pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2700"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2701"></span>t++;pho="C"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2702"></span>t++;pho="T"; audpsi=808; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2703"></span>psi=808; pos=8; dba=0; num=0; KbLoad(); // 2018-11-28: infinitive
<span id="line2704"></span>t++; // 2018-11-28: one SPACE for sake of AudRecog()
<span id="line2705"></span>
<span id="line2706"></span>// 811=COULD -- 2018-11-29: auxiliary verb for EnAuxVerb()
<span id="line2707"></span>t++;pho="C"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2708"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2709"></span>t++;pho="U"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2710"></span>t++;pho="L"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2711"></span>t++;pho="D"; audpsi=811; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2712"></span>psi=811; pos=8; dba=0; num=0; KbLoad(); // 2018-11-29: past tense
<span id="line2713"></span>t++; // 2018-11-29: one SPACE for sake of AudRecog()
<span id="line2714"></span>
<span id="line2715"></span>// 812=COME -- 2018-11-29: Wikipedia:Most_common_words_in_English
<span id="line2716"></span>t++;pho="C"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2717"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2718"></span>t++;pho="M"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2719"></span>t++;pho="E"; audpsi=812; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2720"></span>psi=812; pos=8; dba=0; num=0; KbLoad(); // 2018-11-29: infinitive
<span id="line2721"></span>t++; // 2018-11-29: one SPACE for sake of AudRecog()
<span id="line2722"></span>
<span id="line2723"></span>// 813=DARE -- 2018-11-29: auxiliary verb and modal verb
<span id="line2724"></span>t++;pho="D"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2725"></span>t++;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2726"></span>t++;pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2727"></span>t++;pho="E"; audpsi=813; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2728"></span>psi=813; pos=8; dba=0; num=0; KbLoad(); // 2018-11-29: infinitive
<span id="line2729"></span>t++; // 2018-11-29: one SPACE for sake of AudRecog()
<span id="line2730"></span>
<span id="line2731"></span>// DATA -- always plural noun in correction of modern usage 
<span id="line2732"></span>t++;pho="D"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2733"></span>t++;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2734"></span>t++;pho="T"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2735"></span>t++;pho="A"; audpsi=599; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2736"></span>psi=599; pos=5; dba=0; num=2; mfn=0; pre=0; seq=0; KbLoad();
<span id="line2737"></span>t++; // 2018-11-29: one SPACE for sake of AudRecog()
<span id="line2738"></span>
<span id="line2739"></span>// 814=DELETE -- 2018-11-29: verb for computers 
<span id="line2740"></span>t++;pho="D"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2741"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2742"></span>t++;pho="L"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2743"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2744"></span>t++;pho="T"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2745"></span>t++;pho="E"; audpsi=814; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2746"></span>psi=814; pos=8; dba=0; num=0; KbLoad(); // 2018-11-29: infinitive
<span id="line2747"></span>t++; // 2018-11-29: one SPACE for sake of AudRecog()
<span id="line2748"></span>
<span id="line2749"></span>// 637=DESPITE -- 2018-11-13: preposition for EnPrep() module 
<span id="line2750"></span>t++;pho="D"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2751"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2752"></span>t++;pho="S"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2753"></span>t++;pho="P"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2754"></span>t++;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2755"></span>t++;pho="T"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2756"></span>t++;pho="E"; audpsi=637; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2757"></span>psi=637; pos=6; KbLoad();
<span id="line2758"></span>t++; // 2018-11-13: SPACE for the sake of AudRecog()
<span id="line2759"></span>
<span id="line2760"></span>// 815=DESTROY -- 2018-11-29: like opposite of MAKE
<span id="line2761"></span>t++;pho="D"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2762"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2763"></span>t++;pho="S"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2764"></span>t++;pho="T"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2765"></span>t++;pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2766"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2767"></span>t++;pho="Y"; audpsi=815; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2768"></span>psi=815; pos=8; dba=0; num=0; KbLoad(); // 2018-11-29: infinitive
<span id="line2769"></span>t++; // 2018-11-29: one SPACE for sake of AudRecog()
<span id="line2770"></span>
<span id="line2771"></span>// 816=DID -- 2018-11-29: normal verb or auxiliary verb
<span id="line2772"></span>t++;pho="D"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2773"></span>t++;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2774"></span>t++;pho="D"; audpsi=816; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2775"></span>psi=816; pos=8; dba=0; num=0; KbLoad(); // 2018-11-29: past tense
<span id="line2776"></span>t++; // 2018-11-29: one SPACE for sake of AudRecog()
<span id="line2777"></span>
<span id="line2778"></span>// 817=DIE -- 2018-11-29: verb for existential thought
<span id="line2779"></span>t++;pho="D"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2780"></span>t++;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2781"></span>t++;pho="E"; audpsi=817; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2782"></span>psi=817; pos=8; dba=0; num=0; KbLoad(); // 2018-11-29: past tense
<span id="line2783"></span>t++; // 2018-11-29: one SPACE for sake of AudRecog()
<span id="line2784"></span>
<span id="line2785"></span>// DO -- infinitive form of verb essential for EnAuxVerb module 
<span id="line2786"></span>t++;pho="D"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2787"></span>t++;pho="O"; audpsi=818; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2788"></span>psi=818; pos=8; dba=0; num=0; mfn=0; pre=0; seq=0; KbLoad();
<span id="line2789"></span>t++; // 2018-11-29: one SPACE for sake of AudRecog()
<span id="line2790"></span>
<span id="line2791"></span>// DO -- 1st person singular I-form of auxiliary verb
<span id="line2792"></span>t++;pho="D"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2793"></span>t++;pho="O"; audpsi=818; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2794"></span>psi=818; pos=8; dba=1; num=1; mfn=0; pre=0; seq=0;KbLoad();
<span id="line2795"></span>t++; // 2018-11-29: one SPACE for sake of AudRecog()
<span id="line2796"></span>
<span id="line2797"></span>// DO -- 2nd person singular YOU-form of auxiliary verb
<span id="line2798"></span>t++;pho="D"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2799"></span>t++;pho="O"; audpsi=818; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2800"></span>psi=818; pos=8; dba=2; num=1; mfn=0; pre=0; seq=0; KbLoad();
<span id="line2801"></span>t++; // 2018-11-29: one SPACE for sake of AudRecog()
<span id="line2802"></span>
<span id="line2803"></span>// DOES -- 3rd person singular HE-SHE-IT-form of auxiliary verb
<span id="line2804"></span>t++;pho="D"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2805"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2806"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2807"></span>t++;pho="S"; audpsi=818; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2808"></span>psi=818; pos=8; dba=3; num=1; mfn=0; pre=0; seq=0; KbLoad(); 
<span id="line2809"></span>t++; // 2018-11-29: one SPACE for sake of AudRecog()
<span id="line2810"></span>
<span id="line2811"></span>// DO -- 1st person plural WE-form of auxiliary verb
<span id="line2812"></span>t++;pho="D"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2813"></span>t++;pho="O"; audpsi=818; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2814"></span>psi=818; pos=8; dba=1; num=2; mfn=0; pre=0; seq=0; KbLoad();
<span id="line2815"></span>t++; // 2018-11-29: one SPACE for sake of AudRecog()
<span id="line2816"></span>
<span id="line2817"></span>// DO -- 2nd person plural YOU-form of auxiliary verb
<span id="line2818"></span>t++;pho="D"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2819"></span>t++;pho="O"; audpsi=818; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2820"></span>psi=818; pos=8; dba=2; num=2; mfn=0; pre=0; seq=0; KbLoad();
<span id="line2821"></span>t++; // 2018-11-29: one SPACE for sake of AudRecog(
<span id="line2822"></span>
<span id="line2823"></span>// DO -- 3rd person plural THEY-form of auxiliary verb
<span id="line2824"></span>t++;pho="D"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2825"></span>t++;pho="O"; audpsi=818; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2826"></span>psi=818; pos=8; dba=3; num=2; mfn=0; pre=0; seq=0; KbLoad();
<span id="line2827"></span>t++; // 2018-11-29: one SPACE for sake of AudRecog()
<span id="line2828"></span>
<span id="line2829"></span>// DOING -- high word-frequency verb participle  
<span id="line2830"></span>t++;pho="D"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2831"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2832"></span>t++;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2833"></span>t++;pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2834"></span>t++;pho="G"; audpsi=183; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2835"></span>psi=183; pos=1; dba=0; num=0; mfn=0; pre=0; seq=0; KbLoad();
<span id="line2836"></span>t++; // 2018-11-29: one SPACE for sake of AudRecog()
<span id="line2837"></span>
<span id="line2838"></span>// 638=DOWN -- 2018-11-13: preposition for EnPrep() module 
<span id="line2839"></span>t++;pho="D"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2840"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2841"></span>t++;pho="W"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2842"></span>t++;pho="N"; audpsi=638; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2843"></span>psi=638; pos=6; KbLoad();
<span id="line2844"></span>t++; // 2018-11-13: SPACE for the sake of AudRecog()
<span id="line2845"></span>
<span id="line2846"></span>// 819=DRINK -- 2018-11-29: common everyday verb
<span id="line2847"></span>t++;pho="D"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2848"></span>t++;pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2849"></span>t++;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2850"></span>t++;pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2851"></span>t++;pho="K"; audpsi=819; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2852"></span>psi=819; pos=8; dba=0; num=0; KbLoad(); // 2018-11-29: past tense
<span id="line2853"></span>t++; // 2018-11-29: one SPACE for sake of AudRecog()
<span id="line2854"></span>
<span id="line2855"></span>// 820=DROP -- 2018-11-29: verb for robotics
<span id="line2856"></span>t++;pho="D"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2857"></span>t++;pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2858"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2859"></span>t++;pho="P"; audpsi=820; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2860"></span>psi=820; pos=8; dba=0; num=0; KbLoad(); // 2018-11-29: past tense
<span id="line2861"></span>t++; // 2018-11-29: one SPACE for sake of AudRecog()
<span id="line2862"></span>
<span id="line2863"></span>// 639=DURING -- 2018-11-13: preposition for EnPrep() module 
<span id="line2864"></span>t++;pho="D"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2865"></span>t++;pho="U"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2866"></span>t++;pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2867"></span>t++;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2868"></span>t++;pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2869"></span>t++;pho="G"; audpsi=639; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2870"></span>psi=639; pos=6; KbLoad();
<span id="line2871"></span>t++; // 2018-11-13: SPACE for the sake of AudRecog()
<span id="line2872"></span>
<span id="line2873"></span>// 821=EAT -- 2018-12-09: common everyday verb; useful for ontology
<span id="line2874"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2875"></span>t++;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2876"></span>t++;pho="T"; audpsi=821; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2877"></span>psi=821; pos=8; dba=0; num=0; KbLoad(); // 2018-12-09: infinitive
<span id="line2878"></span>t++; // 2018-12-09: one SPACE for sake of AudRecog()
<span id="line2879"></span>
<span id="line2880"></span>// 588=EIGHT -- 2019-11-07: noun for the hap(tic) sensation of the numeric "8" key.
<span id="line2881"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2882"></span>t++;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2883"></span>t++;pho="G"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2884"></span>t++;pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2885"></span>t++;pho="T"; audpsi=588; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2886"></span>psi=588; pos=5; dba=4; num=0; mfn=3; pre=0; seq=0; KbLoad();
<span id="line2887"></span>t++; // 2019-11-07: one space for sake of AudRecog()
<span id="line2888"></span>
<span id="line2889"></span>// 324=EITHER -- conjunction for ConJoin module 
<span id="line2890"></span>t++; pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2891"></span>t++; pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2892"></span>t++; pho="T"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2893"></span>t++; pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2894"></span>t++; pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2895"></span>t++; pho="R"; audpsi=324; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2896"></span>psi=324; pos=3; KbLoad();
<span id="line2897"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line2898"></span>
<span id="line2899"></span>// ELSE -- adverb for machine reasoning logic; 11nov2012
<span id="line2900"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2901"></span>t++;pho="L"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2902"></span>t++;pho="S"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2903"></span>t++;pho="E"; audpsi=266; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2904"></span>psi=266; pos=2; dba=0; num=0; mfn=0; pre=0; seq=0; KbLoad();
<span id="line2905"></span>t++; // 2018-11-29: one SPACE for sake of AudRecog()
<span id="line2906"></span>
<span id="line2907"></span>// 640=EXCEPT -- 2018-11-13: preposition for EnPrep() module 
<span id="line2908"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2909"></span>t++;pho="X"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2910"></span>t++;pho="C"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2911"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2912"></span>t++;pho="P"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2913"></span>t++;pho="T"; audpsi=640; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2914"></span>psi=640; pos=6; KbLoad();
<span id="line2915"></span>t++; // 2018-11-13: SPACE for the sake of AudRecog()
<span id="line2916"></span>
<span id="line2917"></span>// 822=FALL -- 2018-12-09: intransitive verb of motion for robotics
<span id="line2918"></span>t++;pho="F"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2919"></span>t++;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2920"></span>t++;pho="L"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2921"></span>t++;pho="L"; audpsi=822; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2922"></span>psi=822; pos=8; dba=0; num=0; KbLoad(); // 2018-12-09: infinitive
<span id="line2923"></span>t++; // 2018-12-09: one SPACE for sake of AudRecog()
<span id="line2924"></span>
<span id="line2925"></span>// 823=FEEL -- 2018-12-09: from Wikipedia:Most_common_words_in_English
<span id="line2926"></span>t++;pho="F"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2927"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2928"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2929"></span>t++;pho="L"; audpsi=823; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2930"></span>psi=823; pos=8; dba=0; num=0; KbLoad(); // 2018-12-09: infinitive
<span id="line2931"></span>t++; // 2018-12-09: one SPACE for sake of AudRecog()
<span id="line2932"></span>
<span id="line2933"></span>// 824=FIND -- 2018-12-09: from Wikipedia:Most_common_words_in_English
<span id="line2934"></span>t++;pho="F"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2935"></span>t++;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2936"></span>t++;pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2937"></span>t++;pho="D"; audpsi=824; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2938"></span>psi=824; pos=8; dba=0; num=0; KbLoad(); // 2018-12-09: infinitive
<span id="line2939"></span>t++; // 2018-12-09: one SPACE for sake of AudRecog()
<span id="line2940"></span>
<span id="line2941"></span>// 825=FINISH -- 2018-12-09: verb important for planning
<span id="line2942"></span>t++;pho="F"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2943"></span>t++;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2944"></span>t++;pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2945"></span>t++;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2946"></span>t++;pho="S"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2947"></span>t++;pho="H"; audpsi=825; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2948"></span>psi=825; pos=8; dba=0; num=0; KbLoad(); // 2018-12-09: infinitive
<span id="line2949"></span>t++; // 2018-12-09: one SPACE for sake of AudRecog()
<span id="line2950"></span>
<span id="line2951"></span>// 545=FIVE -- 2019-11-07: noun for the hap(tic) sensation of the numeric "5" key.
<span id="line2952"></span>t++;pho="F"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2953"></span>t++;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2954"></span>t++;pho="V"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2955"></span>t++;pho="E"; audpsi=545; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2956"></span>psi=545; pos=5; dba=4; num=0; mfn=3; pre=0; seq=0; KbLoad();
<span id="line2957"></span>t++; // 2019-11-07: one space for sake of AudRecog()
<span id="line2958"></span>
<span id="line2959"></span>// 641=FOR -- preposition for EnPrep module 
<span id="line2960"></span>t++; pho="F"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2961"></span>t++; pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2962"></span>t++; pho="R"; audpsi=641; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2963"></span>psi=641; pos=6; dba=0; num=0; mfn=0; pre=0; seq=0; KbLoad();
<span id="line2964"></span>t++; // 2018-11-29: one SPACE for sake of AudRecog()
<span id="line2965"></span>
<span id="line2966"></span>// 826=FORGET -- 2018-12-09: verb for cognition
<span id="line2967"></span>t++;pho="F"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2968"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2969"></span>t++;pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2970"></span>t++;pho="G"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2971"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2972"></span>t++;pho="T"; audpsi=826; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2973"></span>psi=826; pos=8; dba=0; num=0; KbLoad(); // 2018-12-09: infinitive
<span id="line2974"></span>t++; // 2018-12-09: one SPACE for sake of AudRecog()
<span id="line2975"></span>
<span id="line2976"></span>// 544=FOUR -- 2019-11-07: noun for the hap(tic) sensation of the numeric "4" key.
<span id="line2977"></span>t++;pho="F"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2978"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2979"></span>t++;pho="U"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2980"></span>t++;pho="R"; audpsi=544; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2981"></span>psi=544; pos=5; dba=4; num=0; mfn=3; pre=0; seq=0; KbLoad();
<span id="line2982"></span>t++; // 2019-11-07: one space for sake of AudRecog()
<span id="line2983"></span>
<span id="line2984"></span>
<span id="line2985"></span>// FRIEND -- for coding assignment of ad-hoc gender tags
<span id="line2986"></span>t++;pho="F"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2987"></span>t++;pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2988"></span>t++;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2989"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2990"></span>t++;pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line2991"></span>t++;pho="D"; audpsi=517; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2992"></span>psi=517; pos=5; dba=0; num=1; mfn=0; pre=0; seq=0; KbLoad();
<span id="line2993"></span>t++; // 2018-11-29: one SPACE for sake of AudRecog()
<span id="line2994"></span>
<span id="line2995"></span>// 642=FROM -- 2018-11-13: preposition for EnPrep() module 
<span id="line2996"></span>t++;pho="F"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line2997"></span>t++;pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2998"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line2999"></span>t++;pho="M"; audpsi=642; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3000"></span>psi=642; pos=6; KbLoad();
<span id="line3001"></span>t++; // 2018-11-13: SPACE for the sake of AudRecog()
<span id="line3002"></span>
<span id="line3003"></span>// 827=GET -- 2018-12-09: from Wikipedia:Most_common_words_in_English
<span id="line3004"></span>t++;pho="G"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3005"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3006"></span>t++;pho="T"; audpsi=827; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3007"></span>psi=827; pos=8; dba=0; num=0; KbLoad(); // 2018-12-09: infinitive
<span id="line3008"></span>t++; // 2018-12-09: one SPACE for sake of AudRecog()
<span id="line3009"></span>
<span id="line3010"></span>// GIRL -- always feminine noun for use with gender flags )
<span id="line3011"></span>t++;pho="G"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3012"></span>t++;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3013"></span>t++;pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3014"></span>t++;pho="L"; audpsi=510; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3015"></span>psi=510; pos=5; dba=0; num=1; mfn=2; pre=0; seq=0; KbLoad();
<span id="line3016"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line3017"></span>
<span id="line3018"></span>// 828=GIVE -- 2018-12-09: from Wikipedia:Most_common_words_in_English
<span id="line3019"></span>t++;pho="G"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3020"></span>t++;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3021"></span>t++;pho="V"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3022"></span>t++;pho="E"; audpsi=828; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3023"></span>psi=828; pos=8; dba=0; num=0; KbLoad(); // 2018-12-09: infinitive
<span id="line3024"></span>t++; // 2018-12-09: one SPACE for sake of AudRecog()
<span id="line3025"></span>
<span id="line3026"></span>// 829=GO -- 2018-12-09: from Wikipedia:Most_common_words_in_English
<span id="line3027"></span>t++;pho="G"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3028"></span>t++;pho="O"; audpsi=829; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3029"></span>psi=829; pos=8; dba=0; num=0; KbLoad(); // 2018-12-09: infinitive
<span id="line3030"></span>t++; // 2018-12-09: one SPACE for sake of AudRecog()
<span id="line3031"></span>
<span id="line3032"></span>// GOD -- masculine noun important for philosophy of AI
<span id="line3033"></span>t++;pho="G"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3034"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3035"></span>t++;pho="D"; audpsi=533; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3036"></span>psi=533; pos=5; dba=0; num=1; mfn=1; pre=0; seq=0; KbLoad();
<span id="line3037"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line3038"></span>
<span id="line3039"></span>// GOOD -- #134 2019-10-12:  adjective for EnAdjective module 
<span id="line3040"></span>t++;pho="G"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3041"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3042"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3043"></span>t++;pho="D"; audpsi=134; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3044"></span>psi=134; pos=1; dba=0; num=0; mfn=0; pre=0; seq=0; KbLoad();
<span id="line3045"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line3046"></span>
<span id="line3047"></span>// 830=GOT -- 2018-12-09: frequent word used in multiple ways
<span id="line3048"></span>t++;pho="G"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3049"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3050"></span>t++;pho="T"; audpsi=830; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3051"></span>psi=830; pos=8; dba=0; num=0; KbLoad(); // 2018-12-09: simple past of "GET"
<span id="line3052"></span>t++; // 2018-12-09: one SPACE for sake of AudRecog()
<span id="line3053"></span>
<span id="line3054"></span>// 831=GROK -- 2018-12-09: verb for cognition
<span id="line3055"></span>t++;pho="G"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3056"></span>t++;pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3057"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3058"></span>t++;pho="K"; audpsi=831; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3059"></span>psi=831; pos=8; dba=0; num=0; KbLoad(); // 2018-12-09: infinitive
<span id="line3060"></span>t++; // 2018-12-09: one SPACE for sake of AudRecog()
<span id="line3061"></span>
<span id="line3062"></span>// 832=HAD -- 2018-12-09: useful past-tense or subjunctive form
<span id="line3063"></span>t++;pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3064"></span>t++;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3065"></span>t++;pho="D"; audpsi=832; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3066"></span>psi=832; pos=8; dba=0; num=0; KbLoad(); // 2018-12-09: past tense
<span id="line3067"></span>t++; // 2018-12-09: one SPACE for sake of AudRecog()
<span id="line3068"></span>
<span id="line3069"></span>// 833=HATE -- 2018-12-09: verb for Emotion(); opposite of LOVE
<span id="line3070"></span>t++;pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3071"></span>t++;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3072"></span>t++;pho="T"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3073"></span>t++;pho="E"; audpsi=833; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3074"></span>psi=833; pos=8; dba=0; num=0; KbLoad(); // 2018-12-09: infinitive
<span id="line3075"></span>t++; // 2018-12-09: one SPACE for sake of AudRecog()
<span id="line3076"></span>
<span id="line3077"></span>// 834=HAVE -- 2018-12-09: irregular high word-frequency verb  
<span id="line3078"></span>t++;pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3079"></span>t++;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3080"></span>t++;pho="V"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3081"></span>t++;pho="E"; audpsi=834; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3082"></span>psi=834; pos=8; dba=0; num=0; KbLoad(); // 2018-12-09: infinitive
<span id="line3083"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line3084"></span>
<span id="line3085"></span>// HAS -- high word-frequency irregular verb form 
<span id="line3086"></span>t++; pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3087"></span>t++; pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3088"></span>t++; pho="S"; audpsi=834; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3089"></span>psi=834; pos=8; dba=3; num=1; mfn=0; pre=0; seq=0; KbLoad();
<span id="line3090"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog(
<span id="line3091"></span>
<span id="line3092"></span>// HE -- nominative form of high word-frequency pronoun  
<span id="line3093"></span>t++;pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3094"></span>t++;pho="E"; audpsi=713; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3095"></span>psi=713; pos=7; dba=1; num=1; mfn=1; pre=0; seq=0; KbLoad();
<span id="line3096"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line3097"></span>
<span id="line3098"></span>// HIS -- genitive form of personal pronoun  
<span id="line3099"></span>t++; pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3100"></span>t++; pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3101"></span>t++; pho="S"; audpsi=113; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3102"></span>psi=113; pos=1; dba=2; num=1; mfn=1; pre=0; seq=0; KbLoad();
<span id="line3103"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line3104"></span>
<span id="line3105"></span>// HIM -- dative indirect-object form of personal pronoun
<span id="line3106"></span>t++; pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3107"></span>t++; pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3108"></span>t++; pho="M"; audpsi=713; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3109"></span>psi=713; pos=7; dba=3; num=1; mfn=1; pre=0; seq=0; KbLoad();
<span id="line3110"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line3111"></span>
<span id="line3112"></span>// HIM -- accusative direct-object form of personal pronoun
<span id="line3113"></span>t++; pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3114"></span>t++; pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3115"></span>t++; pho="M"; audpsi=713; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3116"></span>psi=713; pos=7; dba=4; num=1; mfn=1; pre=0; seq=0; KbLoad();
<span id="line3117"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line3118"></span>
<span id="line3119"></span>// 835=HEAR -- 2018-12-09: verb important for Audition() and robotics
<span id="line3120"></span>t++;pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3121"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3122"></span>t++;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3123"></span>t++;pho="R"; audpsi=835; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3124"></span>psi=835; pos=8; dba=0; num=0; KbLoad(); // 2018-12-09: infinitive
<span id="line3125"></span>t++; // 2018-12-09: one SPACE for sake of AudRecog()
<span id="line3126"></span>
<span id="line3127"></span>// HELLO -- interjection for human-computer interaction 
<span id="line3128"></span>t++;pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3129"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3130"></span>t++;pho="L"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3131"></span>t++;pho="L"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3132"></span>t++;pho="O"; audpsi=450; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3133"></span>psi=450; pos=4; dba=0; num=0; mfn=0; pre=0; seq=0; KbLoad();
<span id="line3134"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line3135"></span>
<span id="line3136"></span>// 836=HELP -- 2018-12-09: socially significant common verb 
<span id="line3137"></span>t++;pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3138"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3139"></span>t++;pho="L"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3140"></span>t++;pho="P"; audpsi=836; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3141"></span>psi=836; pos=8; dba=0; num=0; KbLoad(); // 2018-12-09: infinitive
<span id="line3142"></span>t++; // 2018-12-09: one SPACE for sake of AudRecog()
<span id="line3143"></span>
<span id="line3144"></span>// HERE -- adverb for discussion of physical location
<span id="line3145"></span>t++;pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3146"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3147"></span>t++;pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3148"></span>t++;pho="E"; audpsi=201; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3149"></span>psi=201; pos=2; dba=0; num=0; mfn=0; pre=0; seq=0; KbLoad();
<span id="line3150"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line3151"></span>
<span id="line3152"></span>// HOW -- adverb for EnAdverb module 
<span id="line3153"></span>t++; pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3154"></span>t++; pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3155"></span>t++; pho="W"; audpsi=209; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3156"></span>psi=209; pos=2; dba=0; mfn=0; num=0; pre=0; seq=0; KbLoad();
<span id="line3157"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line3158"></span>
<span id="line3159"></span>// I -- nominative subject-form of personal pronoun; 25oct2012
<span id="line3160"></span>t++;pho="I"; audpsi=701; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3161"></span>psi=701; jux=0; pos=7; dba=1; num=1; mfn=0; pre=0; seq=0; tkb=0; KbLoad();
<span id="line3162"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line3163"></span>
<span id="line3164"></span>// MINE -- genitive form of personal pronoun; 25oct2012
<span id="line3165"></span>t++;pho="M"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3166"></span>t++;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3167"></span>t++;pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3168"></span>t++;pho="E"; audpsi=701; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3169"></span>psi=701; pos=7; dba=2; num=1; mfn=0; pre=0; seq=0; KbLoad();
<span id="line3170"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line3171"></span>
<span id="line3172"></span>// ME -- dative indirect-object form of personal pronoun 
<span id="line3173"></span>t++;pho="M"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3174"></span>t++;pho="E"; audpsi=701; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3175"></span>psi=701; pos=7; dba=3; num=1; mfn=0; pre=0; seq=0; tkb=0; KbLoad();
<span id="line3176"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line3177"></span>
<span id="line3178"></span>// ME -- accusative direct-object form of personal pronoun
<span id="line3179"></span>t++;pho="M"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3180"></span>t++;pho="E"; audpsi=701; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3181"></span>psi=701; pos=7; dba=4; num=1; mfn=0; pre=0; seq=0; tkb=0; KbLoad();
<span id="line3182"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line3183"></span>
<span id="line3184"></span>// 327=IF -- 2018-11-26L conjunction for machine reasoning logic 
<span id="line3185"></span>t++;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3186"></span>t++;pho="F"; audpsi=327; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3187"></span>psi=327; pos=3; dba=0; num=0; mfn=0; pre=0; seq=0; KbLoad();
<span id="line3188"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line3189"></span>
<span id="line3190"></span>// 837=IMAGINE -- 2018-12-09: verb for cognition
<span id="line3191"></span>t++;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3192"></span>t++;pho="M"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3193"></span>t++;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3194"></span>t++;pho="G"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3195"></span>t++;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3196"></span>t++;pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3197"></span>t++;pho="E"; audpsi=837; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3198"></span>psi=837; pos=8; dba=0; num=0; KbLoad(); // 2018-12-09: infinitive
<span id="line3199"></span>t++; // 2018-12-09: one SPACE for sake of AudRecog()
<span id="line3200"></span>
<span id="line3201"></span>// IN -- preposition for EnPrep module 
<span id="line3202"></span>t++;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3203"></span>t++;pho="N"; audpsi=643; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3204"></span>psi=643; pos=6; num=0; mfn=0; pre=0; seq=0; KbLoad(); // 2018-11-13 
<span id="line3205"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line3206"></span>
<span id="line3207"></span>// 330=INASMUCH with AS -- 2018-11-26: conjunction for ConJoin()
<span id="line3208"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line3209"></span>
<span id="line3210"></span>// 644=INCLUDING -- 2018-11-13: preposition for EnPrep() module 
<span id="line3211"></span>t++;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3212"></span>t++;pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3213"></span>t++;pho="C"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3214"></span>t++;pho="L"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3215"></span>t++;pho="U"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3216"></span>t++;pho="D"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3217"></span>t++;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3218"></span>t++;pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3219"></span>t++;pho="G"; audpsi=644; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3220"></span>psi=644; pos=6; KbLoad();
<span id="line3221"></span>t++; // 2018-11-13: SPACE for the sake of AudRecog()
<span id="line3222"></span>
<span id="line3223"></span>// 645=INSIDE -- 2018-11-13: preposition for EnPrep() module 
<span id="line3224"></span>t++;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3225"></span>t++;pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3226"></span>t++;pho="S"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3227"></span>t++;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3228"></span>t++;pho="D"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3229"></span>t++;pho="E"; audpsi=645; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3230"></span>psi=645; pos=6; KbLoad();
<span id="line3231"></span>t++; // 2018-11-13: SPACE for the sake of AudRecog()
<span id="line3232"></span>
<span id="line3233"></span>// 646=INTO -- 2018-11-13: preposition for EnPrep() module 
<span id="line3234"></span>t++;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3235"></span>t++;pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3236"></span>t++;pho="T"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3237"></span>t++;pho="O"; audpsi=646; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3238"></span>psi=646; pos=6; KbLoad();
<span id="line3239"></span>t++; // 2018-11-13: SPACE for the sake of AudRecog()
<span id="line3240"></span>
<span id="line3241"></span>// IT -- nominative subject-form of personal pronoun; 
<span id="line3242"></span>t++;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3243"></span>t++;pho="T"; audpsi=725; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3244"></span>psi=725; pos=7; dba=1; num=1; mfn=3; pre=0; seq=0; KbLoad();
<span id="line3245"></span>t++; // 2018-11-29: one SPACE for sake of AudRecog()
<span id="line3246"></span>
<span id="line3247"></span>// ITS -- genitive form of personal pronoun; 
<span id="line3248"></span>t++;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3249"></span>t++;pho="T"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3250"></span>t++;pho="S"; audpsi=725; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3251"></span>psi=725; pos=7; dba=2; num=1; mfn=3; pre=0; seq=0; KbLoad();
<span id="line3252"></span>t++; // 2018-11-29: one SPACE for sake of AudRecog()
<span id="line3253"></span>
<span id="line3254"></span>// IT -- dative indirect-object form of personal pronoun; 
<span id="line3255"></span>t++;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3256"></span>t++;pho="T"; audpsi=725; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3257"></span>psi=725; pos=7; dba=3; num=1; mfn=3; pre=0; seq=0; KbLoad();
<span id="line3258"></span>t++; // 2018-11-29: one SPACE for sake of AudRecog()
<span id="line3259"></span>
<span id="line3260"></span>// IT -- accusative direct-object form of personal pronoun
<span id="line3261"></span>t++;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3262"></span>t++;pho="T"; audpsi=725; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3263"></span>psi=725; pos=7; dba=4; num=1; mfn=3; pre=0; seq=0; KbLoad();
<span id="line3264"></span>t++; // 2018-11-29: one SPACE for sake of AudRecog()
<span id="line3265"></span>
<span id="line3266"></span>// JOHN -- 2019-09-20: #504 useful name for input-testing.
<span id="line3267"></span>t++;pho="J"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3268"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3269"></span>t++;pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3270"></span>t++;pho="N"; audpsi=504; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3271"></span>psi=504; mtx=0; pos=5; dba=1; num=1; mfn=1; KbLoad();
<span id="line3272"></span>t++; // 2019-09-20: one space for sake of AudRecog()
<span id="line3273"></span>
<span id="line3274"></span>// 838=KNOW -- 2018-11-28: germane to artificial intelligence 
<span id="line3275"></span>t++;pho="K"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3276"></span>t++;pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3277"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3278"></span>t++;pho="W"; audpsi=838; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3279"></span>psi=838; pos=8; dba=0; num=0; mfn=0; pre=0; seq=0; KbLoad();
<span id="line3280"></span>t++; // 2018-10-06: SPACE for the sake of AudRecog()
<span id="line3281"></span>
<span id="line3282"></span>// 839=LEARN -- 2018-12-09: verb for cognition
<span id="line3283"></span>t++;pho="L"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3284"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3285"></span>t++;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3286"></span>t++;pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3287"></span>t++;pho="N"; audpsi=839; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3288"></span>psi=839; pos=8; dba=0; num=0; KbLoad(); // 2018-12-09: infinitive
<span id="line3289"></span>t++; // 2018-12-09: one SPACE for sake of AudRecog()
<span id="line3290"></span>
<span id="line3291"></span>// 840=LEAVE -- 2018-12-09: from Wikipedia:Most_common_words_in_English
<span id="line3292"></span>t++;pho="L"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3293"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3294"></span>t++;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3295"></span>t++;pho="V"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3296"></span>t++;pho="E"; audpsi=840; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3297"></span>psi=840; pos=8; dba=0; num=0; KbLoad(); // 2018-12-09: infinitive
<span id="line3298"></span>t++; // 2018-12-09: one SPACE for sake of AudRecog()
<span id="line3299"></span>
<span id="line3300"></span>// 841=LEND -- 2018-12-09: verb for dative and accusative 
<span id="line3301"></span>t++;pho="L"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3302"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3303"></span>t++;pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi)
<span id="line3304"></span>t++;pho="D"; audpsi=841; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3305"></span>psi=841; pos=8; dba=0; num=0; KbLoad(); // 2018-12-09: infinitive
<span id="line3306"></span>t++; // 2018-12-09: one SPACE for sake of AudRecog()
<span id="line3307"></span>
<span id="line3308"></span>// 647=LESS -- 2018-11-13: preposition for EnPrep() module 
<span id="line3309"></span>t++;pho="L"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3310"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3311"></span>t++;pho="S"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3312"></span>t++;pho="S"; audpsi=647; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3313"></span>psi=647; pos=6; KbLoad();
<span id="line3314"></span>t++; // 2018-11-13: SPACE for the sake of AudRecog()
<span id="line3315"></span>
<span id="line3316"></span>// 333=LEST -- 2018-11-26: conjunction for ConJoin module 
<span id="line3317"></span>t++; pho="L"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3318"></span>t++; pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3319"></span>t++; pho="S"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3320"></span>t++; pho="T"; audpsi=333; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3321"></span>psi=333; pos=3; KbLoad();
<span id="line3322"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line3323"></span>
<span id="line3324"></span>// 648=LIKE -- 2018-11-13: preposition for EnPrep() module 
<span id="line3325"></span>t++;pho="L"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3326"></span>t++;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3327"></span>t++;pho="K"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3328"></span>t++;pho="E"; audpsi=648; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3329"></span>psi=648; pos=6; KbLoad();
<span id="line3330"></span>t++; // 2018-11-13: SPACE for the sake of AudRecog()
<span id="line3331"></span>
<span id="line3332"></span>// 842=LIVE -- 2018-12-09: verb important for life
<span id="line3333"></span>t++;pho="L"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3334"></span>t++;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3335"></span>t++;pho="V"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi)
<span id="line3336"></span>t++;pho="E"; audpsi=842; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3337"></span>psi=842; pos=8; dba=0; num=0; KbLoad(); // 2018-12-09: infinitive
<span id="line3338"></span>t++; // 2018-12-09: one SPACE for sake of AudRecog()
<span id="line3339"></span>
<span id="line3340"></span>// 843=LOAN -- 2018-12-09: verb for dative and accusative 
<span id="line3341"></span>t++;pho="L"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3342"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3343"></span>t++;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi)
<span id="line3344"></span>t++;pho="N"; audpsi=843; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3345"></span>psi=843; pos=8; dba=0; num=0; KbLoad(); // 2018-12-09: infinitive
<span id="line3346"></span>t++; // 2018-12-09: one SPACE for sake of AudRecog()
<span id="line3347"></span>
<span id="line3348"></span>// 844=LOOK -- 2018-12-09: from Wikipedia:Most_common_words_in_English
<span id="line3349"></span>t++;pho="L"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3350"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3351"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi)
<span id="line3352"></span>t++;pho="K"; audpsi=844; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3353"></span>psi=844; pos=8; dba=0; num=0; KbLoad(); // 2018-12-09: infinitive
<span id="line3354"></span>t++; // 2018-12-09: one SPACE for sake of AudRecog()
<span id="line3355"></span>
<span id="line3356"></span>// 845=LOVE -- 2018-12-09: verb for Emotion(); opposite of HATE
<span id="line3357"></span>t++;pho="L"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3358"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3359"></span>t++;pho="V"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi)
<span id="line3360"></span>t++;pho="E"; audpsi=845; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3361"></span>psi=845; pos=8; dba=0; num=0; KbLoad(); // 2018-12-09: infinitive
<span id="line3362"></span>t++; // 2018-12-09: one SPACE for sake of AudRecog()
<span id="line3363"></span>
<span id="line3364"></span>// 846=MAKE -- 2018-12-09: from Wikipedia:Most_common_words_in_English
<span id="line3365"></span>t++;pho="M"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3366"></span>t++;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3367"></span>t++;pho="K"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3368"></span>t++;pho="E"; audpsi=846; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3369"></span>psi=846; pos=8; dba=0; num=0; KbLoad();  // 2018-12-09: infinitive
<span id="line3370"></span>t++; // 2018-10-06: SPACE for the sake of AudRecog()
<span id="line3371"></span>
<span id="line3372"></span>// MAN -- always masculine noun for use with gender flags 
<span id="line3373"></span>t++;pho="M"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3374"></span>t++;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3375"></span>t++;pho="N"; audpsi=543; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3376"></span>psi=543; pos=5; dba=0; num=1; mfn=1; pre=0; seq=0; KbLoad();
<span id="line3377"></span>t++; // 2018-11-29: one SPACE for sake of AudRecog()
<span id="line3378"></span>
<span id="line3379"></span>// MEN -- irregular plural for retrieval by parameters
<span id="line3380"></span>t++;pho="M"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3381"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3382"></span>t++;pho="N"; audpsi=543; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3383"></span>psi=543; pos=5; dba=0; num=2; mfn=1; pre=0; seq=0; KbLoad();
<span id="line3384"></span>t++; // 2018-11-29: one SPACE for sake of AudRecog()
<span id="line3385"></span>
<span id="line3386"></span>// 847=MAY -- 2018-12-09: auxiliary
<span id="line3387"></span>t++;pho="M"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t
<span id="line3388"></span>t++;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3389"></span>t++;pho="Y"; audpsi=847; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3390"></span>psi=847; pos=8; dba=0; num=0; KbLoad();  // 2018-12-09: present tense
<span id="line3391"></span>t++; // 2018-10-06: SPACE for the sake of AudRecog()
<span id="line3392"></span>
<span id="line3393"></span>// MAYBE -- adverb response as alternative to YES or NO
<span id="line3394"></span>t++;pho="M"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3395"></span>t++;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3396"></span>t++;pho="Y"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3397"></span>t++;pho="B"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3398"></span>t++;pho="E"; audpsi=270; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3399"></span>psi=270; pos=2; dba=0; num=0; mfn=0; pre=0; seq=0; KbLoad();
<span id="line3400"></span>t++; // 2018-11-29: one SPACE for sake of AudRecog()
<span id="line3401"></span>
<span id="line3402"></span>// MEDIA -- always plural noun in correction of modern usage 
<span id="line3403"></span>t++;pho="M"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3404"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3405"></span>t++;pho="D"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3406"></span>t++;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3407"></span>t++;pho="A"; audpsi=584; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3408"></span>psi=584; pos=5; dba=0; num=2; mfn=0; pre=0; seq=0; KbLoad();
<span id="line3409"></span>t++; // 2018-11-29: one SPACE for sake of AudRecog()
<span id="line3410"></span>
<span id="line3411"></span>// 848=MIGHT -- 2018-12-09: auxiliary
<span id="line3412"></span>t++;pho="M"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3413"></span>t++;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3414"></span>t++;pho="G"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3415"></span>t++;pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3416"></span>t++;pho="T"; audpsi=848; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3417"></span>psi=848; pos=8; dba=0; num=0; KbLoad();  // 2018-12-09: subjunctive
<span id="line3418"></span>t++; // 2018-10-06: SPACE for the sake of AudRecog()
<span id="line3419"></span>
<span id="line3420"></span>// 649=MINUS -- 2018-11-13: preposition for EnPrep() module 
<span id="line3421"></span>t++;pho="M"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3422"></span>t++;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3423"></span>t++;pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3424"></span>t++;pho="U"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3425"></span>t++;pho="S"; audpsi=649; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3426"></span>psi=649; pos=6; KbLoad();
<span id="line3427"></span>t++; // 2018-11-13: SPACE for the sake of AudRecog()
<span id="line3428"></span>
<span id="line3429"></span>// 650=MODULO -- 2018-11-13: preposition for EnPrep() module 
<span id="line3430"></span>t++;pho="M"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3431"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3432"></span>t++;pho="D"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3433"></span>t++;pho="U"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3434"></span>t++;pho="L"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3435"></span>t++;pho="O"; audpsi=650; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3436"></span>psi=650; pos=6; KbLoad();
<span id="line3437"></span>t++; // 2018-11-13: SPACE for the sake of AudRecog()
<span id="line3438"></span>
<span id="line3439"></span>// MONEY -- 2019-08-04: #563 "money" as nominative subject noun 
<span id="line3440"></span>t++;pho="M"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3441"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3442"></span>t++;pho="N"; audpsi=563; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3443"></span>t++;pho="E"; audpsi=563; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3444"></span>t++;pho="Y"; audpsi=563; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3445"></span>psi=563; pos=5; dba=1; num=1; mfn=0; pre=0; seq=0; KbLoad();
<span id="line3446"></span>t++; // 2019-08-04: one space for sake of AudRecog()
<span id="line3447"></span>
<span id="line3448"></span>// MONEY -- 2019-08-04: #563 "money" as accusative noun
<span id="line3449"></span>t++;pho="M"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3450"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3451"></span>t++;pho="N"; audpsi=563; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3452"></span>t++;pho="E"; audpsi=563; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3453"></span>t++;pho="Y"; audpsi=563; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3454"></span>psi=563; pos=5; dba=4; num=1; mfn=0; pre=0; seq=0; KbLoad();
<span id="line3455"></span>t++; // 2019-08-04: one space for sake of AudRecog()
<span id="line3456"></span>
<span id="line3457"></span>// 849=MOVE -- 2018-12-09: motion word for robotics
<span id="line3458"></span>t++;pho="M"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3459"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3460"></span>t++;pho="V"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3461"></span>t++;pho="E"; audpsi=849; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3462"></span>psi=849; pos=8; dba=0; num=0; KbLoad();  // 2018-12-09: infinitive
<span id="line3463"></span>t++; // 2018-10-06: SPACE for the sake of AudRecog()
<span id="line3464"></span>
<span id="line3465"></span>// 850=MUST -- 2018-12-09: auxiliary modal verb
<span id="line3466"></span>t++;pho="M"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3467"></span>t++;pho="U"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3468"></span>t++;pho="S"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3469"></span>t++;pho="T"; audpsi=850; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3470"></span>psi=850; pos=8; dba=0; num=0; KbLoad();  // 2018-12-09: present tense
<span id="line3471"></span>t++; // 2018-10-06: SPACE for the sake of AudRecog()
<span id="line3472"></span>
<span id="line3473"></span>// MY -- adjective for personal pronoun "I"; 
<span id="line3474"></span>t++;pho="M"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3475"></span>t++;pho="Y"; audpsi=181; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3476"></span>psi=181; pos=1; dba=0; num=0; mfn=0; pre=0; seq=0; KbLoad();
<span id="line3477"></span>t++; // 2018-10-06: SPACE for the sake of AudRecog()
<span id="line3478"></span>
<span id="line3479"></span>// 651=NEAR -- 2018-11-13: preposition for EnPrep() module 
<span id="line3480"></span>t++;pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3481"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3482"></span>t++;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3483"></span>t++;pho="R"; audpsi=651; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3484"></span>psi=651; pos=6; KbLoad();
<span id="line3485"></span>t++; // 2018-11-13: SPACE for the sake of AudRecog()
<span id="line3486"></span>
<span id="line3487"></span>// 652=NEARER -- 2018-11-13: preposition for EnPrep() module 
<span id="line3488"></span>t++;pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3489"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3490"></span>t++;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3491"></span>t++;pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3492"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3493"></span>t++;pho="R"; audpsi=652; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3494"></span>psi=652; pos=6; KbLoad();
<span id="line3495"></span>t++; // 2018-11-13: SPACE for the sake of AudRecog()
<span id="line3496"></span>
<span id="line3497"></span>// 653=NEAREST -- 2018-11-13: preposition for EnPrep() module 
<span id="line3498"></span>t++;pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3499"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3500"></span>t++;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3501"></span>t++;pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3502"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3503"></span>t++;pho="S"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3504"></span>t++;pho="T"; audpsi=653; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3505"></span>psi=653; pos=6; KbLoad();
<span id="line3506"></span>t++; // 2018-11-13: SPACE for the sake of AudRecog()
<span id="line3507"></span>
<span id="line3508"></span>// 851=NEED -- 2018-11-28: dba=0 infinitive for sake of logical inference 
<span id="line3509"></span>t++;pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3510"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3511"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3512"></span>t++;pho="D"; audpsi=851; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3513"></span>psi=851; pos=8; dba=0; num=0; mfn=0; pre=0; seq=0; tkb=0; KbLoad();
<span id="line3514"></span>t++; // 2018-10-06: SPACE for the sake of AudRecog()
<span id="line3515"></span>
<span id="line3516"></span>// 336=NEITHER -- conjunction for ConJoin module 
<span id="line3517"></span>t++; pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3518"></span>t++; pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3519"></span>t++; pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3520"></span>t++; pho="T"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3521"></span>t++; pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3522"></span>t++; pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3523"></span>t++; pho="R"; audpsi=336; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3524"></span>psi=336; pos=3; KbLoad();
<span id="line3525"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line3526"></span>
<span id="line3527"></span>// 654=NEXT (TO) -- 2018-11-13: as a preposition for EnPrep() module
<span id="line3528"></span>t++; // 2018-11-29: one SPACE for sake of AudRecog()
<span id="line3529"></span>
<span id="line3530"></span>// 559=NINE -- 2019-11-07: noun for the hap(tic) sensation of the numeric "9" key.
<span id="line3531"></span>t++;pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3532"></span>t++;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3533"></span>t++;pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3534"></span>t++;pho="E"; audpsi=559; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3535"></span>psi=559; pos=5; dba=4; num=0; mfn=3; pre=0; seq=0; KbLoad();
<span id="line3536"></span>t++; // 2019-11-07: one space for sake of AudRecog()
<span id="line3537"></span>
<span id="line3538"></span>// NO -- interjection for human-computer interaction 
<span id="line3539"></span>t++;pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3540"></span>t++;pho="O"; audpsi=404; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3541"></span>psi=404; pos=4; dba=0; num=0; mfn=0; pre=0; seq=0; KbLoad();
<span id="line3542"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line3543"></span>
<span id="line3544"></span>// 339=NOR -- 2018-11-26: conjunction for ConJoin() module 
<span id="line3545"></span>t++; pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3546"></span>t++; pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3547"></span>t++; pho="R"; audpsi=339; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3548"></span>psi=339; pos=3; KbLoad();
<span id="line3549"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line3550"></span>
<span id="line3551"></span>// NOT -- for machine reasoning logic 
<span id="line3552"></span>t++; pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3553"></span>t++; pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3554"></span>t++; pho="T"; audpsi=250; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3555"></span>psi=250; pos=2; dba=0; num=0; mfn=0; pre=0; seq=0; KbLoad();
<span id="line3556"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line3557"></span>
<span id="line3558"></span>// NOTHING --  VisRecog default for what the AI Mind sees
<span id="line3559"></span>t++; pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3560"></span>t++; pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3561"></span>t++; pho="T"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3562"></span>t++; pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3563"></span>t++; pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3564"></span>t++; pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3565"></span>t++; pho="G"; audpsi=760; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3566"></span>psi=760; pos=7; dba=0; num=1; mfn=0; pre=0; seq=0; rv=276; KbLoad();
<span id="line3567"></span>t++; // 2018-11-13: SPACE for the sake of AudRecog()
<span id="line3568"></span>
<span id="line3569"></span>// 238=NOW -- 2018-11-26: adverb
<span id="line3570"></span>// 342=NOW -- 2018-11-26: conjunction
<span id="line3571"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line3572"></span>
<span id="line3573"></span>// 655=OF -- preposition for EnPrep module 
<span id="line3574"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3575"></span>t++;pho="F"; audpsi=655; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3576"></span>psi=655; pos=6; num=0; pre=0; mfn=0; seq=0; KbLoad();
<span id="line3577"></span>t++; // 2018-11-13: SPACE for the sake of AudRecog()
<span id="line3578"></span>
<span id="line3579"></span>// 656=OFF -- 2018-11-13: preposition for EnPrep() module 
<span id="line3580"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3581"></span>t++;pho="F"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3582"></span>t++;pho="F"; audpsi=656; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3583"></span>psi=656; pos=6; KbLoad();
<span id="line3584"></span>t++; // 2018-11-13: SPACE for the sake of AudRecog()
<span id="line3585"></span>
<span id="line3586"></span>// 852=OFFER -- 2018-12-09: verb
<span id="line3587"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3588"></span>t++;pho="F"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3589"></span>t++;pho="F"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3590"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3591"></span>t++;pho="R"; audpsi=852; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3592"></span>psi=852; pos=8; dba=0; num=0; KbLoad();  // 2018-12-09: infinitive
<span id="line3593"></span>t++; // 2018-10-06: SPACE for the sake of AudRecog()
<span id="line3594"></span>
<span id="line3595"></span>// 657=ON -- 2018-11-13: preposition for EnPrep() module 
<span id="line3596"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3597"></span>t++;pho="N"; audpsi=657; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3598"></span>psi=657; pos=6; KbLoad();
<span id="line3599"></span>t++; // 2018-11-13: SPACE for the sake of AudRecog()
<span id="line3600"></span>
<span id="line3601"></span>// 551=ONE -- 2019-11-07: noun for the hap(tic) sensation of the numeric "1" key.
<span id="line3602"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3603"></span>t++;pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3604"></span>t++;pho="E"; audpsi=551; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3605"></span>psi=551; pos=5; dba=4; num=1; mfn=3; pre=0; seq=0; KbLoad();
<span id="line3606"></span>t++; // 2019-11-07: one space for sake of AudRecog()
<span id="line3607"></span>
<span id="line3608"></span>// 248=ONCE -- 2018-11-26: adverb
<span id="line3609"></span>// 345=ONCE -- 2018-11-26: conjunction
<span id="line3610"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line3611"></span>
<span id="line3612"></span>// 658=ONTO -- 2018-11-13: preposition for EnPrep() module 
<span id="line3613"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3614"></span>t++;pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3615"></span>t++;pho="T"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3616"></span>t++;pho="O"; audpsi=658; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3617"></span>psi=658; pos=6; KbLoad();
<span id="line3618"></span>t++; // 2018-11-13: SPACE for the sake of AudRecog()
<span id="line3619"></span>
<span id="line3620"></span>// 659=OPPOSITE -- 2018-11-13: preposition for EnPrep() module 
<span id="line3621"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3622"></span>t++;pho="P"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3623"></span>t++;pho="P"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3624"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3625"></span>t++;pho="S"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3626"></span>t++;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3627"></span>t++;pho="T"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3628"></span>t++;pho="E"; audpsi=659; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3629"></span>psi=659; pos=6; KbLoad();
<span id="line3630"></span>t++; // 2018-11-13: SPACE for the sake of AudRecog()
<span id="line3631"></span>
<span id="line3632"></span>// 348=OR -- 2018-11-26: conjunction for machine reasoning logic  
<span id="line3633"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3634"></span>t++;pho="R"; audpsi=348; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3635"></span>psi=348; pos=3; dba=0; num=0; mfn=0; pre=0; seq=0; KbLoad();
<span id="line3636"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line3637"></span>
<span id="line3638"></span>// 853=OUGHT -- 2018-12-09: auxiliary verb
<span id="line3639"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3640"></span>t++;pho="U"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3641"></span>t++;pho="G"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3642"></span>t++;pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3643"></span>t++;pho="T"; audpsi=853; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3644"></span>psi=853; pos=8; dba=0; num=0; KbLoad();  // 2018-12-09: subjunctive
<span id="line3645"></span>t++; // 2018-10-06: SPACE for the sake of AudRecog()
<span id="line3646"></span>
<span id="line3647"></span>// OUR -- adjective for personal pronoun "WE" 
<span id="line3648"></span>t++; pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3649"></span>t++; pho="U"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3650"></span>t++; pho="R"; audpsi=186; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3651"></span>psi=186; pos=1; dba=0; num=0; mfn=0; pre=0; seq=0; KbLoad();
<span id="line3652"></span>
<span id="line3653"></span>// 660=OUT -- 2018-11-13: preposition for EnPrep() module 
<span id="line3654"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3655"></span>t++;pho="U"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3656"></span>t++;pho="T"; audpsi=660; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3657"></span>psi=660; pos=6; KbLoad();
<span id="line3658"></span>t++; // 2018-11-13: SPACE for the sake of AudRecog()
<span id="line3659"></span>
<span id="line3660"></span>// 661 held for "OUT OF"; 2018-11-13
<span id="line3661"></span>t++; // 2018-11-29: one SPACE for sake of AudRecog()
<span id="line3662"></span>
<span id="line3663"></span>// 662=OUTSIDE -- 2018-11-13: preposition for EnPrep() module 
<span id="line3664"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3665"></span>t++;pho="U"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3666"></span>t++;pho="T"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3667"></span>t++;pho="S"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3668"></span>t++;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3669"></span>t++;pho="D"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3670"></span>t++;pho="E"; audpsi=662; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3671"></span>psi=662; pos=6; KbLoad();
<span id="line3672"></span>t++; // 2018-11-13: SPACE for the sake of AudRecog()
<span id="line3673"></span>
<span id="line3674"></span>// 663=OVER -- 2018-11-13: preposition for EnPrep() module 
<span id="line3675"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3676"></span>t++;pho="V"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3677"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3678"></span>t++;pho="R"; audpsi=663; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3679"></span>psi=663; pos=6; KbLoad();
<span id="line3680"></span>t++; // 2018-11-13: SPACE for the sake of AudRecog()
<span id="line3681"></span>
<span id="line3682"></span>// 854=OWE -- 2018-12-09: verb for dative and accusative
<span id="line3683"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t
<span id="line3684"></span>t++;pho="W"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3685"></span>t++;pho="E"; audpsi=854; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3686"></span>psi=854; pos=8; dba=0; num=0; KbLoad();  // 2018-12-09: infinitive
<span id="line3687"></span>t++; // 2018-10-06: SPACE for the sake of AudRecog()
<span id="line3688"></span>
<span id="line3689"></span>// 855=OWN -- 2018-12-09: common verb
<span id="line3690"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3691"></span>t++;pho="W"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3692"></span>t++;pho="N"; audpsi=855; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3693"></span>psi=855; pos=8; dba=0; num=0; KbLoad();  // 2018-12-09: infinitive
<span id="line3694"></span>t++; // 2018-10-06: SPACE for the sake of AudRecog()
<span id="line3695"></span>
<span id="line3696"></span>// 664=PACE -- 2018-11-13: (Latin) preposition for EnPrep() module 
<span id="line3697"></span>t++;pho="P"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3698"></span>t++;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3699"></span>t++;pho="C"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3700"></span>t++;pho="E"; audpsi=664; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3701"></span>psi=664; pos=6; KbLoad();
<span id="line3702"></span>t++; // 2018-11-13: SPACE for the sake of AudRecog()
<span id="line3703"></span>
<span id="line3704"></span>// 665=PAST -- 2018-11-13: preposition for EnPrep() module 
<span id="line3705"></span>t++;pho="P"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3706"></span>t++;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3707"></span>t++;pho="S"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3708"></span>t++;pho="T"; audpsi=665; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3709"></span>psi=665; pos=6; KbLoad();
<span id="line3710"></span>t++; // 2018-11-13: SPACE for the sake of AudRecog()
<span id="line3711"></span>
<span id="line3712"></span>// 856=PAY -- 2018-12-09: verb for dative and accusative
<span id="line3713"></span>t++;pho="P"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3714"></span>t++;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3715"></span>t++;pho="Y"; audpsi=856; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3716"></span>psi=856; pos=8; dba=0; num=0; KbLoad();  // 2018-12-09: infinitive
<span id="line3717"></span>t++; // 2018-10-06: SPACE for the sake of AudRecog()
<span id="line3718"></span>
<span id="line3719"></span>// PEOPLE -- establish as plural for EnParser 
<span id="line3720"></span>t++;pho="P"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3721"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3722"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3723"></span>t++;pho="P"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3724"></span>t++;pho="L"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3725"></span>t++;pho="E"; audpsi=587; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3726"></span>psi=587; pos=5; dba=0; num=2; mfn=0; pre=0; seq=0; KbLoad();
<span id="line3727"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line3728"></span>
<span id="line3729"></span>// 666=PER -- 2018-11-13: (Latin) preposition for EnPrep() module 
<span id="line3730"></span>t++;pho="P"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3731"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3732"></span>t++;pho="R"; audpsi=666; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3733"></span>psi=666; pos=6; KbLoad();
<span id="line3734"></span>t++; // 2018-11-13: SPACE for the sake of AudRecog()
<span id="line3735"></span>
<span id="line3736"></span>// PERSON -- for ad-hoc gender tags and robot philosophy 
<span id="line3737"></span>t++;pho="P"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3738"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3739"></span>t++;pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3740"></span>t++;pho="S"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3741"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3742"></span>t++;pho="N"; audpsi=537; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3743"></span>psi=537; pos=5; dba=0; num=1; mfn=0; pre=0; seq=0; KbLoad();
<span id="line3744"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line3745"></span>
<span id="line3746"></span>// 857=PICK -- 2018-12-09: verb for volition
<span id="line3747"></span>t++;pho="P"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3748"></span>t++;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3749"></span>t++;pho="C"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3750"></span>t++;pho="K"; audpsi=857; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3751"></span>psi=857; pos=8; dba=0; num=0; KbLoad();  // 2018-12-09: infinitive
<span id="line3752"></span>t++; // 2018-10-06: SPACE for the sake of AudRecog()
<span id="line3753"></span>
<span id="line3754"></span>// 858=PLACE -- 2018-12-09: movement verb for robotics
<span id="line3755"></span>t++;pho="P"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3756"></span>t++;pho="L"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3757"></span>t++;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3758"></span>t++;pho="C"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3759"></span>t++;pho="E"; audpsi=858; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3760"></span>psi=858; pos=8; dba=0; num=0; KbLoad();  // 2018-12-09: infinitive
<span id="line3761"></span>t++; // 2018-10-06: SPACE for the sake of AudRecog()
<span id="line3762"></span>
<span id="line3763"></span>// 859=PLAY -- 2018-12-09: common verb
<span id="line3764"></span>t++;pho="P"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3765"></span>t++;pho="L"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3766"></span>t++;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3767"></span>t++;pho="Y"; audpsi=859; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3768"></span>psi=859; pos=8; dba=0; num=0; KbLoad();  // 2018-12-09: infinitive
<span id="line3769"></span>t++; // 2018-10-06: SPACE for the sake of AudRecog()
<span id="line3770"></span>
<span id="line3771"></span>// PLEASE -- interjection for human-computer interaction 
<span id="line3772"></span>t++;pho="P"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3773"></span>t++;pho="L"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3774"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3775"></span>t++;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3776"></span>t++;pho="S"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3777"></span>t++;pho="E"; audpsi=410; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3778"></span>psi=410; pos=4; num=0; mfn=0; pre=0; seq=0; KbLoad();
<span id="line3779"></span>t++; // 2018-10-06: SPACE for the sake of AudRecog()
<span id="line3780"></span>
<span id="line3781"></span>// 667=PLUS -- 2018-11-13: (Latin) preposition for EnPrep() module 
<span id="line3782"></span>t++;pho="P"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3783"></span>t++;pho="L"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3784"></span>t++;pho="U"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3785"></span>t++;pho="S"; audpsi=667; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3786"></span>psi=667; pos=6; KbLoad();
<span id="line3787"></span>t++; // 2018-11-13: SPACE for the sake of AudRecog()
<span id="line3788"></span>
<span id="line3789"></span>// 668=POST -- 2018-11-13: (Latin) preposition for EnPrep() module 
<span id="line3790"></span>t++;pho="P"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3791"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3792"></span>t++;pho="S"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3793"></span>t++;pho="T"; audpsi=668; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3794"></span>psi=668; pos=6; KbLoad();
<span id="line3795"></span>t++; // 2018-11-13: SPACE for the sake of AudRecog()
<span id="line3796"></span>
<span id="line3797"></span>// 669=PRO -- 2018-11-13: (Latin) preposition for EnPrep() module 
<span id="line3798"></span>t++;pho="P"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3799"></span>t++;pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3800"></span>t++;pho="O"; audpsi=669; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3801"></span>psi=669; pos=6; KbLoad();
<span id="line3802"></span>t++; // 2018-11-13: SPACE for the sake of AudRecog()
<span id="line3803"></span>
<span id="line3804"></span>// 860=PROMISE-- 2018-12-09: verb for dative and accusative
<span id="line3805"></span>t++;pho="P"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3806"></span>t++;pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3807"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3808"></span>t++;pho="M"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3809"></span>t++;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3810"></span>t++;pho="S"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3811"></span>t++;pho="E"; audpsi=860; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3812"></span>psi=860; pos=8; dba=0; num=0; KbLoad();  // 2018-12-09: infinitive
<span id="line3813"></span>t++; // 2018-10-06: SPACE for the sake of AudRecog()
<span id="line3814"></span>
<span id="line3815"></span>// 351=PROVIDED -- 2018-11-26: conjunction for ConJoin() module 
<span id="line3816"></span>t++; pho="P"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3817"></span>t++; pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3818"></span>t++; pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3819"></span>t++; pho="V"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3820"></span>t++; pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3821"></span>t++; pho="D"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3822"></span>t++; pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3823"></span>t++; pho="D"; audpsi=351; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3824"></span>psi=351; pos=3; KbLoad();
<span id="line3825"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line3826"></span>
<span id="line3827"></span>// 861=PUT -- 2018-12-09: motion verb for robotics
<span id="line3828"></span>t++;pho="P"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3829"></span>t++;pho="U"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi)
<span id="line3830"></span>t++;pho="T"; audpsi=861; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3831"></span>psi=861; pos=8; dba=0; num=0; KbLoad();  // 2018-12-09: infinitive
<span id="line3832"></span>t++; // 2018-10-06: SPACE for the sake of AudRecog()
<span id="line3833"></span>
<span id="line3834"></span>// 670=QUA -- 2018-11-13: (Latin) preposition for EnPrep() module 
<span id="line3835"></span>t++;pho="Q"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3836"></span>t++;pho="U"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3837"></span>t++;pho="A"; audpsi=670; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3838"></span>psi=670; pos=6; KbLoad();
<span id="line3839"></span>t++; // 2018-11-13: SPACE for the sake of AudRecog()
<span id="line3840"></span>
<span id="line3841"></span>// 862=QUIT -- 2018-12-09: common verb
<span id="line3842"></span>t++;pho="Q"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3843"></span>t++;pho="U"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3844"></span>t++;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3845"></span>t++;pho="T"; audpsi=862; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3846"></span>psi=862; pos=8; dba=0; num=0; KbLoad();  // 2018-12-09: infinitive
<span id="line3847"></span>t++; // 2018-10-06: SPACE for the sake of AudRecog()
<span id="line3848"></span>
<span id="line3849"></span>// 671=RE -- 2018-11-13: (Latin) preposition for EnPrep() module 
<span id="line3850"></span>t++;pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3851"></span>t++;pho="E"; audpsi=671; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3852"></span>psi=671; pos=6; KbLoad();
<span id="line3853"></span>t++; // 2018-11-13: SPACE for the sake of AudRecog()
<span id="line3854"></span>
<span id="line3855"></span>// 863=READ -- 2018-12-09: dba=0 infinitive for sake of logical inference
<span id="line3856"></span>t++;pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3857"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3858"></span>t++;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3859"></span>t++;pho="D"; audpsi=863; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3860"></span>psi=863; pos=8; dba=0; num=0; pre=0; seq=0; tkb=0; KbLoad();
<span id="line3861"></span>t++; // 2018-10-06: SPACE for the sake of AudRecog()
<span id="line3862"></span>
<span id="line3863"></span>// 864=RECOGNIZE -- 2018-12-09: verb for cognition
<span id="line3864"></span>t++;pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3865"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3866"></span>t++;pho="C"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3867"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3868"></span>t++;pho="G"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3869"></span>t++;pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3870"></span>t++;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3871"></span>t++;pho="Z"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3872"></span>t++;pho="E"; audpsi=864; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3873"></span>psi=864; pos=8; dba=0; num=0; KbLoad();  // 2018-12-09: infinitive
<span id="line3874"></span>t++; // 2018-10-06: SPACE for the sake of AudRecog()
<span id="line3875"></span>
<span id="line3876"></span>// 672=REGARDING -- 2018-11-13: preposition for EnPrep() module 
<span id="line3877"></span>t++;pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3878"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3879"></span>t++;pho="G"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3880"></span>t++;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3881"></span>t++;pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3882"></span>t++;pho="D"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3883"></span>t++;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3884"></span>t++;pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3885"></span>t++;pho="G"; audpsi=672; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3886"></span>psi=672; pos=6; KbLoad();
<span id="line3887"></span>t++; // 2018-11-13: SPACE for the sake of AudRecog()
<span id="line3888"></span>
<span id="line3889"></span>// 865=REMEMBER -- 2018-12-09: verb for cognition
<span id="line3890"></span>t++;pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3891"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3892"></span>t++;pho="M"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3893"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3894"></span>t++;pho="M"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3895"></span>t++;pho="B"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3896"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3897"></span>t++;pho="R"; audpsi=865; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3898"></span>psi=865; pos=8; dba=0; num=0; KbLoad();  // 2018-12-09: infinitive
<span id="line3899"></span>t++; // 2018-10-06: SPACE for the sake of AudRecog()
<span id="line3900"></span>
<span id="line3901"></span>// 866=ROLL -- 2018-12-09: motion verb for robotics
<span id="line3902"></span>t++;pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3903"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3904"></span>t++;pho="L"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3905"></span>t++;pho="L"; audpsi=866; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3906"></span>psi=866; pos=8; dba=0; num=0; KbLoad();  // 2018-12-09: infinitive
<span id="line3907"></span>t++; // 2018-10-06: SPACE for the sake of AudRecog()
<span id="line3908"></span>
<span id="line3909"></span>// 673=ROUND -- 2018-11-13: alternative to "around" for EnPrep() module 
<span id="line3910"></span>t++;pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3911"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3912"></span>t++;pho="U"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3913"></span>t++;pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3914"></span>t++;pho="D"; audpsi=673; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3915"></span>psi=673; pos=6; KbLoad();
<span id="line3916"></span>t++; // 2018-11-13: SPACE for the sake of AudRecog()
<span id="line3917"></span>
<span id="line3918"></span>// 867=RUN -- 2018-12-09: motion verb for robotics
<span id="line3919"></span>t++;pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3920"></span>t++;pho="U"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3921"></span>t++;pho="N"; audpsi=867; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3922"></span>psi=867; pos=8; dba=0; num=0; KbLoad();  // 2018-12-09: infinitive
<span id="line3923"></span>t++; // 2018-10-06: SPACE for the sake of AudRecog()
<span id="line3924"></span>
<span id="line3925"></span>// 868=SAID -- 2018-12-09: verb for Speech()
<span id="line3926"></span>t++;pho="S"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3927"></span>t++;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3928"></span>t++;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3929"></span>t++;pho="D"; audpsi=868; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3930"></span>psi=868; pos=8; dba=0; num=0; KbLoad();  // 2018-12-09: past tense
<span id="line3931"></span>t++; // 2018-10-06: SPACE for the sake of AudRecog()
<span id="line3932"></span>
<span id="line3933"></span>// 674=SANS -- 2018-11-13: alternative to "around" for EnPrep() module 
<span id="line3934"></span>t++;pho="S"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3935"></span>t++;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3936"></span>t++;pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3937"></span>t++;pho="S"; audpsi=674; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3938"></span>psi=674; pos=6; KbLoad();
<span id="line3939"></span>t++; // 2018-11-13: SPACE for the sake of AudRecog()
<span id="line3940"></span>
<span id="line3941"></span>// 675=SAVE -- 2018-12-09: preposition for EnPrep() module
<span id="line3942"></span>t++;pho="S"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3943"></span>t++;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3944"></span>t++;pho="V"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3945"></span>t++;pho="E"; audpsi=675; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3946"></span>psi=675; pos=6; KbLoad();
<span id="line3947"></span>t++; // 2018-11-13: SPACE for the sake of AudRecog()
<span id="line3948"></span>
<span id="line3949"></span>// 869=SAY -- 2018-12-09: verb for Speech()
<span id="line3950"></span>t++;pho="S"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3951"></span>t++;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3952"></span>t++;pho="Y"; audpsi=869; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3953"></span>psi=869; pos=8; dba=0; num=0; KbLoad();  // 2018-12-09: infinitive
<span id="line3954"></span>t++; // 2018-10-06: SPACE for the sake of AudRecog()
<span id="line3955"></span>
<span id="line3956"></span>t++; // 2018-07-12: making single-word time relative, not hard-coded.
<span id="line3957"></span>// 870=SEE -- 2018-12-09: lets VisRecog report non-KB direct objects.
<span id="line3958"></span>t++; pho="S"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3959"></span>t++; pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3960"></span>t++; pho="E"; audpsi=870; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3961"></span>psi=870; pos=8; dba=0; num=0; mfn=0; pre=0; seq=0; KbLoad();
<span id="line3962"></span>
<span id="line3963"></span>// 871=SEEK -- 2018-12-09: useful verb
<span id="line3964"></span>t++;pho="S"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3965"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3966"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3967"></span>t++;pho="K"; audpsi=871; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3968"></span>psi=871; pos=8; dba=0; num=0; KbLoad();  // 2018-12-09: infinitive
<span id="line3969"></span>t++; // 2018-10-06: SPACE for the sake of AudRecog()
<span id="line3970"></span>
<span id="line3971"></span>// 872=SEEM -- 2018-12-09: useful verb
<span id="line3972"></span>t++;pho="S"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3973"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3974"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3975"></span>t++;pho="M"; audpsi=872; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3976"></span>psi=872; pos=8; dba=0; num=0; KbLoad();  // 2018-12-09: infinitive
<span id="line3977"></span>t++; // 2018-10-06: SPACE for the sake of AudRecog()
<span id="line3978"></span>
<span id="line3979"></span>// 873=SELL -- 2018-12-09: verb for dative and accusative
<span id="line3980"></span>t++;pho="S"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3981"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3982"></span>t++;pho="L"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3983"></span>t++;pho="L"; audpsi=873; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3984"></span>psi=873; pos=8; dba=0; num=0; KbLoad();  // 2018-12-09: infinitive
<span id="line3985"></span>t++; // 2018-10-06: SPACE for the sake of AudRecog()
<span id="line3986"></span>
<span id="line3987"></span>// 874=SEND -- 2018-12-09: verb for dative and accusative
<span id="line3988"></span>t++;pho="S"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3989"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3990"></span>t++;pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3991"></span>t++;pho="D"; audpsi=874; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line3992"></span>psi=874; pos=8; dba=0; num=0; KbLoad();  // 2018-12-09: infinitive
<span id="line3993"></span>t++; // 2018-10-06: SPACE for the sake of AudRecog()
<span id="line3994"></span>
<span id="line3995"></span>// 577=SEVEN -- 2019-11-07: noun for the hap(tic) sensation of the numeric "7" key.
<span id="line3996"></span>t++;pho="S"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line3997"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3998"></span>t++;pho="V"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line3999"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4000"></span>t++;pho="N"; audpsi=577; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4001"></span>psi=577; pos=5; dba=4; num=0; mfn=3; pre=0; seq=0; KbLoad();
<span id="line4002"></span>t++; // 2019-11-07: one space for sake of AudRecog()
<span id="line4003"></span>
<span id="line4004"></span>// 875=SHALL -- 2018-12-09: auxiliary modal verb
<span id="line4005"></span>t++;pho="S"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4006"></span>t++;pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4007"></span>t++;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4008"></span>t++;pho="L"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4009"></span>t++;pho="L"; audpsi=875; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4010"></span>psi=875; pos=8; dba=0; num=0; KbLoad();  // 2018-12-09: present tense
<span id="line4011"></span>t++; // 2018-10-06: SPACE for the sake of AudRecog()
<span id="line4012"></span>
<span id="line4013"></span>t++; // 2018-07-12: making single-word time relative, not hard-coded.
<span id="line4014"></span>// SHE -- nominative subject-form of personal pronoun 
<span id="line4015"></span>t++; pho="S"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4016"></span>t++; pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4017"></span>t++; pho="E"; audpsi=719; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4018"></span>psi=719; pos=7; dba=1; num=1; mfn=2; pre=0; seq=0; KbLoad();
<span id="line4019"></span>
<span id="line4020"></span>t++; // 2018-07-12: making single-word time relative, not hard-coded.
<span id="line4021"></span>// HERS -- genitive form of personal pronoun 
<span id="line4022"></span>t++; pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4023"></span>t++; pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4024"></span>t++; pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4025"></span>t++; pho="S"; audpsi=719; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4026"></span>psi=719; pos=7; dba=2; num=1; mfn=2; pre=0; seq=0; KbLoad();
<span id="line4027"></span>
<span id="line4028"></span>t++; // 2018-07-12: making single-word time relative, not hard-coded.
<span id="line4029"></span>// HER -- dative indirect-object form of personal pronoun 
<span id="line4030"></span>t++; pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4031"></span>t++; pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4032"></span>t++; pho="R"; audpsi=719; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4033"></span>psi=719; pos=7; dba=3; num=1; mfn=2; pre=0; seq=0; KbLoad();
<span id="line4034"></span>
<span id="line4035"></span>t++; // 2018-07-12: making single-word time relative, not hard-coded.
<span id="line4036"></span>// HER -- accusative direct-object form of personal pronoun 
<span id="line4037"></span>t++; pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4038"></span>t++; pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4039"></span>t++; pho="R"; audpsi=719; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4040"></span>psi=719; pos=7; dba=4; num=1; mfn=2; pre=0; seq=0; KbLoad();
<span id="line4041"></span>
<span id="line4042"></span>// 676=SHORT -- 2018-11-13: alternative to "around" for EnPrep() module 
<span id="line4043"></span>t++;pho="S"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4044"></span>t++;pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4045"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4046"></span>t++;pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4047"></span>t++;pho="T"; audpsi=676; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4048"></span>psi=676; pos=6; KbLoad();
<span id="line4049"></span>t++; // 2018-11-13: SPACE for the sake of AudRecog()
<span id="line4050"></span>
<span id="line4051"></span>// 876=SHOULD -- 2018-12-09: auxiliary modal verb
<span id="line4052"></span>t++;pho="S"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4053"></span>t++;pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4054"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4055"></span>t++;pho="U"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4056"></span>t++;pho="L"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4057"></span>t++;pho="D"; audpsi=876; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4058"></span>psi=876; pos=8; dba=0; num=0; KbLoad();  // 2018-12-09: subjunctive
<span id="line4059"></span>t++; // 2018-10-06: SPACE for the sake of AudRecog()
<span id="line4060"></span>
<span id="line4061"></span>// 877=SHOW -- 2018-12-09: verb for dative and accusative
<span id="line4062"></span>t++;pho="S"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4063"></span>t++;pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4064"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4065"></span>t++;pho="W"; audpsi=877; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4066"></span>psi=877; pos=8; dba=0; num=0; KbLoad();  // 2018-12-09: infinitive
<span id="line4067"></span>t++; // 2018-10-06: SPACE for the sake of AudRecog()
<span id="line4068"></span>
<span id="line4069"></span>// 354=SINCE -- 2018-11-26: conjunction for ConJoin() module
<span id="line4070"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line4071"></span>
<span id="line4072"></span>// 677=SINCE -- 2018-11-13: preposition for EnPrep() module 
<span id="line4073"></span>t++;pho="S"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4074"></span>t++;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4075"></span>t++;pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4076"></span>t++;pho="C"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4077"></span>t++;pho="E"; audpsi=677; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4078"></span>psi=677; pos=6; KbLoad();
<span id="line4079"></span>t++; // 2018-11-13: SPACE for the sake of AudRecog()
<span id="line4080"></span>
<span id="line4081"></span>// 566=SIX -- 2019-11-07: noun for the hap(tic) sensation of the numeric "6" key.
<span id="line4082"></span>t++;pho="S"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4083"></span>t++;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4084"></span>t++;pho="X"; audpsi=566; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4085"></span>psi=566; pos=5; dba=4; num=0; mfn=3; pre=0; seq=0; KbLoad();
<span id="line4086"></span>t++; // 2019-11-07: one space for sake of AudRecog()
<span id="line4087"></span>
<span id="line4088"></span>// 878=SLEEP -- 2018-12-09: verb pertaining to consciousness
<span id="line4089"></span>t++;pho="S"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4090"></span>t++;pho="L"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4091"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4092"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4093"></span>t++;pho="P"; audpsi=878; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4094"></span>psi=878; pos=8; dba=0; num=0; KbLoad();  // 2018-12-09: infinitive
<span id="line4095"></span>t++; // 2018-10-06: SPACE for the sake of AudRecog()
<span id="line4096"></span>
<span id="line4097"></span>// 879=SMELL -- 2018-12-09: verb for OldRecog()
<span id="line4098"></span>t++;pho="S"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4099"></span>t++;pho="M"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4100"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4101"></span>t++;pho="L"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4102"></span>t++;pho="L"; audpsi=879; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4103"></span>psi=879; pos=8; dba=0; num=0; KbLoad();  // 2018-12-09: infinitive
<span id="line4104"></span>t++; // 2018-10-06: SPACE for the sake of AudRecog()
<span id="line4105"></span>
<span id="line4106"></span>// 358=SO -- 2018-11-26: conjunction for ConJoin() module 
<span id="line4107"></span>t++; pho="S"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4108"></span>t++; pho="O"; audpsi=358; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4109"></span>psi=358; pos=3; KbLoad();
<span id="line4110"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line4111"></span>
<span id="line4112"></span>// SOFTWARE -- 2019-08-04: #579 "software" as nominative subject noun 
<span id="line4113"></span>t++;pho="S"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4114"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4115"></span>t++;pho="F"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4116"></span>t++;pho="T"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4117"></span>t++;pho="W"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4118"></span>t++;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4119"></span>t++;pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4120"></span>t++;pho="E"; audpsi=579; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4121"></span>psi=579; pos=5; dba=1; num=1; mfn=0; pre=0; seq=0; KbLoad();
<span id="line4122"></span>t++; // 2019-08-04: one space for sake of AudRecog()
<span id="line4123"></span>
<span id="line4124"></span>// SOFTWARE -- 2019-08-04: #579 "software" as accusative noun 
<span id="line4125"></span>t++;pho="S"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4126"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4127"></span>t++;pho="F"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4128"></span>t++;pho="T"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4129"></span>t++;pho="W"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4130"></span>t++;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4131"></span>t++;pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4132"></span>t++;pho="E"; audpsi=579; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4133"></span>psi=579; pos=5; dba=4; num=1; mfn=0; pre=0; seq=0; KbLoad();
<span id="line4134"></span>t++; // 2019-08-04: one space for sake of AudRecog()
<span id="line4135"></span>
<span id="line4136"></span>
<span id="line4137"></span>// SOME -- #154 2019-10-12: adjective for machine reasoning logic 
<span id="line4138"></span>t++;pho="S"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4139"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4140"></span>t++;pho="M"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4141"></span>t++;pho="E"; audpsi=154; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4142"></span>psi=154; pos=1; dba=0; num=0; mfn=0; pre=0; seq=0; KbLoad();
<span id="line4143"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line4144"></span>
<span id="line4145"></span>// SOMETHING -- useful pronoun.
<span id="line4146"></span>t++; pho="S"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4147"></span>t++; pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4148"></span>t++; pho="M"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4149"></span>t++; pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4150"></span>t++; pho="T"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4151"></span>t++; pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4152"></span>t++; pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4153"></span>t++; pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4154"></span>t++; pho="G"; audpsi=755; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4155"></span>psi=755; pos=7; dba=0; num=1; mfn=0;  pre=0; seq=0; KbLoad();
<span id="line4156"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line4157"></span>
<span id="line4158"></span>// 880=SPEAK -- 2018-12-09: verb for Speech()
<span id="line4159"></span>t++;pho="S"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4160"></span>t++;pho="P"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4161"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4162"></span>t++;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4163"></span>t++;pho="K"; audpsi=880; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4164"></span>psi=880; pos=8; dba=0; num=0; KbLoad();  // 2018-12-09: infinitive
<span id="line4165"></span>t++; // 2018-10-06: SPACE for the sake of AudRecog()
<span id="line4166"></span>
<span id="line4167"></span>// 881=STOP -- 2018-12-09: verb useful for robotics
<span id="line4168"></span>t++;pho="S"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4169"></span>t++;pho="T"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4170"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4171"></span>t++;pho="P"; audpsi=881; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4172"></span>psi=881; pos=8; dba=0; num=0; KbLoad();  // 2018-12-09: infinitive
<span id="line4173"></span>t++; // 2018-10-06: SPACE for the sake of AudRecog()
<span id="line4174"></span>
<span id="line4175"></span>// 882=TAKE -- 2018-12-09: verb useful for robotics
<span id="line4176"></span>t++;pho="T"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4177"></span>t++;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4178"></span>t++;pho="K"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4179"></span>t++;pho="E"; audpsi=882; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4180"></span>psi=882; pos=8; dba=0; num=0; KbLoad();  // 2018-12-09: infinitive
<span id="line4181"></span>t++; // 2018-10-06: SPACE for the sake of AudRecog()
<span id="line4182"></span>
<span id="line4183"></span>// 883=TASTE -- 2018-12-09: verb for GusRecog()
<span id="line4184"></span>t++;pho="T"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4185"></span>t++;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4186"></span>t++;pho="S"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4187"></span>t++;pho="T"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4188"></span>t++;pho="E"; audpsi=883; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4189"></span>psi=883; pos=8; dba=0; num=0; KbLoad();  // 2018-12-09: infinitive
<span id="line4190"></span>t++; // 2018-10-06: SPACE for the sake of AudRecog()
<span id="line4191"></span>
<span id="line4192"></span>// 884=TEACH -- 2018-12-09: verb for Imperative() to say "TEACH ME SOMETHING".
<span id="line4193"></span>t++;pho="T"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4194"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4195"></span>t++;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4196"></span>t++;pho="C"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4197"></span>t++;pho="H"; audpsi=884; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4198"></span>psi=884; pos=8; dba=0; num=0; mfn=0; pre=0; seq=0; KbLoad();
<span id="line4199"></span>t++; // 2018-11-14: SPACE for the sake of AudRecog()
<span id="line4200"></span>
<span id="line4201"></span>// 885=TELL -- 2018-12-09: verb for direct and indirect object
<span id="line4202"></span>t++;pho="T"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4203"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4204"></span>t++;pho="L"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4205"></span>t++;pho="L"; audpsi=885; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4206"></span>psi=885; pos=8; dba=0; num=0; KbLoad();  // 2018-12-09: infinitive
<span id="line4207"></span>t++; // 2018-10-06: SPACE for the sake of AudRecog()
<span id="line4208"></span>
<span id="line4209"></span>// 678=THAN -- 2018-11-13: preposition for EnPrep() module 
<span id="line4210"></span>t++;pho="T"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4211"></span>t++;pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4212"></span>t++;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4213"></span>t++;pho="N"; audpsi=678; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4214"></span>psi=678; pos=6; KbLoad();
<span id="line4215"></span>t++; // 2018-11-13: SPACE for the sake of AudRecog()
<span id="line4216"></span>
<span id="line4217"></span>// 361=THAT -- 2018-11-26: conjunction for ConJoin module 
<span id="line4218"></span>t++; pho="T"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4219"></span>t++; pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4220"></span>t++; pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4221"></span>t++; pho="T"; audpsi=361; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4222"></span>psi=361; pos=3; KbLoad();
<span id="line4223"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line4224"></span>
<span id="line4225"></span>// THAT -- high word-frequency pronoun  
<span id="line4226"></span>t++;pho="T"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4227"></span>t++;pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4228"></span>t++;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4229"></span>t++;pho="T"; audpsi=745; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4230"></span>psi=745; pos=7; dba=0; num=1; mfn=0; pre=0; seq=0; KbLoad();
<span id="line4231"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line4232"></span>
<span id="line4233"></span>// THE -- EnArticle highest-frequency English word 
<span id="line4234"></span>t++;pho="T"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4235"></span>t++;pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4236"></span>t++;pho="E"; audpsi=117; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4237"></span>psi=117; pos=1; num=0; mfn=0; pre=0; seq=0; KbLoad();
<span id="line4238"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line4239"></span>
<span id="line4240"></span>// THEIR -- adjective for personal pronoun "THEY" 
<span id="line4241"></span>t++;pho="T"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4242"></span>t++;pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4243"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4244"></span>t++;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4245"></span>t++;pho="R"; audpsi=188; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4246"></span>psi=188; pos=1; dba=0; num=0; mfn=0; pre=0; seq=0; KbLoad();
<span id="line4247"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line4248"></span>
<span id="line4249"></span>// THEN -- for machine reasoning logic  
<span id="line4250"></span>t++;pho="T"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4251"></span>t++;pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4252"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4253"></span>t++;pho="N"; audpsi=213; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4254"></span>psi=213; pos=2; dba=0; num=0; mfn=0; pre=0; seq=0; KbLoad();
<span id="line4255"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line4256"></span>
<span id="line4257"></span>// THERE -- adverb for discussion of physical location 
<span id="line4258"></span>t++;pho="T"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4259"></span>t++;pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4260"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4261"></span>t++;pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4262"></span>t++;pho="E"; audpsi=205; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4263"></span>psi=205; pos=2; dba=0; num=0; mfn=0; pre=0; seq=0; KbLoad();
<span id="line4264"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line4265"></span>
<span id="line4266"></span>// THEY -- nominative subject-form of personal pronoun 
<span id="line4267"></span>t++;pho="T"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4268"></span>t++;pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4269"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4270"></span>t++;pho="Y"; audpsi=743; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4271"></span>psi=743; pos=7; dba=1; num=2; mfn=0;  pre=0; seq=0; KbLoad();
<span id="line4272"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line4273"></span>
<span id="line4274"></span>// THEIRS -- genitive form of personal pronoun 
<span id="line4275"></span>t++;pho="T"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4276"></span>t++;pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4277"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4278"></span>t++;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4279"></span>t++;pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4280"></span>t++;pho="S"; audpsi=743; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4281"></span>psi=743; pos=7; dba=2; num=2; mfn=0; pre=0; seq=0; KbLoad();
<span id="line4282"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line4283"></span>
<span id="line4284"></span>// THEM -- dative indirect-object form of personal pronoun 
<span id="line4285"></span>t++;pho="T"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4286"></span>t++;pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4287"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4288"></span>t++;pho="M"; audpsi=743; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4289"></span>psi=743; pos=7; dba=3; num=2; mfn=0; pre=0; seq=0; KbLoad();
<span id="line4290"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line4291"></span>
<span id="line4292"></span>// THEM -- accusative direct-object form of personal pronoun
<span id="line4293"></span>t++;pho="T"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4294"></span>t++;pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4295"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4296"></span>t++;pho="M"; audpsi=743; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4297"></span>psi=743; pos=7; dba=4; num=2; mfn=0; pre=0; seq=0; KbLoad();
<span id="line4298"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line4299"></span>
<span id="line4300"></span>// 886=THINK -- 2018-12-09: germane to artificial intelligence  
<span id="line4301"></span>t++;pho="T"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4302"></span>t++;pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4303"></span>t++;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4304"></span>t++;pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4305"></span>t++;pho="K"; audpsi=886; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4306"></span>psi=886; pos=8; dba=0; num=0; KbLoad();  // 2018-12-09: infinitive
<span id="line4307"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line4308"></span>
<span id="line4309"></span>// 363=THOUGH -- 2018-11-26: conjunction for complex sentences 
<span id="line4310"></span>t++;pho="T"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4311"></span>t++;pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4312"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4313"></span>t++;pho="U"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4314"></span>t++;pho="G"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4315"></span>t++;pho="H"; audpsi=363; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4316"></span>psi=363; pos=3; KbLoad();
<span id="line4317"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line4318"></span>
<span id="line4319"></span>// 583=THREE -- 2019-11-07: noun for the hap(tic) sensation of the numeric "3" key.
<span id="line4320"></span>t++;pho="T"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4321"></span>t++;pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4322"></span>t++;pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4323"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4324"></span>t++;pho="E"; audpsi=583; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4325"></span>psi=583; pos=5; dba=4; num=0; mfn=3; pre=0; seq=0; KbLoad();
<span id="line4326"></span>t++; // 2019-11-07: one space for sake of AudRecog()
<span id="line4327"></span>
<span id="line4328"></span>// 679=THROUGH -- 2018-11-13: preposition for EnPrep() module 
<span id="line4329"></span>t++;pho="T"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4330"></span>t++;pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4331"></span>t++;pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4332"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4333"></span>t++;pho="U"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4334"></span>t++;pho="G"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4335"></span>t++;pho="H"; audpsi=679; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4336"></span>psi=679; pos=6; KbLoad();
<span id="line4337"></span>t++; // 2018-11-13: SPACE for the sake of AudRecog()
<span id="line4338"></span>
<span id="line4339"></span>// 680=THROUGHOUT -- 2018-11-14: preposition for EnPrep() module 
<span id="line4340"></span>t++;pho="T"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4341"></span>t++;pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4342"></span>t++;pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4343"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4344"></span>t++;pho="U"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4345"></span>t++;pho="G"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4346"></span>t++;pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4347"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4348"></span>t++;pho="U"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4349"></span>t++;pho="T"; audpsi=680; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4350"></span>psi=680; pos=6; KbLoad();
<span id="line4351"></span>t++; // 2018-11-14: SPACE for the sake of AudRecog()
<span id="line4352"></span>
<span id="line4353"></span>// 681=THRU -- 2018-11-14: preposition for EnPrep() module 
<span id="line4354"></span>t++;pho="T"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4355"></span>t++;pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4356"></span>t++;pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4357"></span>t++;pho="U"; audpsi=681; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4358"></span>psi=681; pos=6; KbLoad();
<span id="line4359"></span>t++; // 2018-11-14: SPACE for the sake of AudRecog()
<span id="line4360"></span>
<span id="line4361"></span>// 366=TILL -- 2018-11-26: conjunction for complex sentences 
<span id="line4362"></span>t++;pho="T"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4363"></span>t++;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4364"></span>t++;pho="L"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4365"></span>t++;pho="L"; audpsi=366; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4366"></span>psi=366; pos=3; KbLoad();
<span id="line4367"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line4368"></span>
<span id="line4369"></span>// 682=TILL -- 2018-11-26: preposition for EnPrep() module 
<span id="line4370"></span>t++;pho="T"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4371"></span>t++;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4372"></span>t++;pho="L"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4373"></span>t++;pho="L"; audpsi=682; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4374"></span>psi=682; pos=6; KbLoad();
<span id="line4375"></span>t++; // 2018-11-14: SPACE for the sake of AudRecog()
<span id="line4376"></span>
<span id="line4377"></span>// 683=TO -- 2018-11-14: preposition for EnPrep() module 
<span id="line4378"></span>t++;pho="T"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4379"></span>t++;pho="O"; audpsi=683; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4380"></span>psi=683; pos=6; KbLoad();
<span id="line4381"></span>t++; // 2018-11-14: SPACE for the sake of AudRecog()
<span id="line4382"></span>
<span id="line4383"></span>// 887=TOLD -- 2018-12-09: verb for communication
<span id="line4384"></span>t++;pho="T"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4385"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4386"></span>t++;pho="L"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4387"></span>t++;pho="D"; audpsi=887; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4388"></span>psi=887; pos=8; dba=0; num=0; KbLoad();  // 2018-12-09: past tense
<span id="line4389"></span>t++; // 2018-10-06: SPACE for the sake of AudRecog()
<span id="line4390"></span>
<span id="line4391"></span>// 888=TOUCH -- 2018-12-09: verb for TacRecog()
<span id="line4392"></span>t++;pho="T"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4393"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4394"></span>t++;pho="U"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4395"></span>t++;pho="C"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4396"></span>t++;pho="H"; audpsi=888; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4397"></span>psi=888; pos=8; dba=0; num=0; KbLoad();  // 2018-12-09: infinitive
<span id="line4398"></span>t++; // 2018-10-06: SPACE for the sake of AudRecog()
<span id="line4399"></span>
<span id="line4400"></span>// 684=TOWARD -- 2018-11-14: preposition for EnPrep() module 
<span id="line4401"></span>t++;pho="T"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4402"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4403"></span>t++;pho="W"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4404"></span>t++;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4405"></span>t++;pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4406"></span>t++;pho="D"; audpsi=684; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4407"></span>psi=684; pos=6; KbLoad();
<span id="line4408"></span>t++; // 2018-11-14: SPACE for the sake of AudRecog()
<span id="line4409"></span>
<span id="line4410"></span>// 685=TOWARDS -- 2018-11-14: preposition for EnPrep() module 
<span id="line4411"></span>t++;pho="T"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4412"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4413"></span>t++;pho="W"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4414"></span>t++;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4415"></span>t++;pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4416"></span>t++;pho="D"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4417"></span>t++;pho="S"; audpsi=685; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4418"></span>psi=685; pos=6; KbLoad();
<span id="line4419"></span>t++; // 2018-11-14: SPACE for the sake of AudRecog()
<span id="line4420"></span>
<span id="line4421"></span>// 889=TRY -- 2018-12-09: verb for Volition() and goal-seeking
<span id="line4422"></span>t++;pho="T"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4423"></span>t++;pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4424"></span>t++;pho="Y"; audpsi=889; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4425"></span>psi=889; pos=8; dba=0; num=0; KbLoad();  // 2018-12-09: infinitive
<span id="line4426"></span>t++; // 2018-10-06: SPACE for the sake of AudRecog()
<span id="line4427"></span>
<span id="line4428"></span>// 891=TURN -- 2018-12-09: motion verb for robotics
<span id="line4429"></span>t++;pho="T"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4430"></span>t++;pho="U"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4431"></span>t++;pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4432"></span>t++;pho="N"; audpsi=891; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4433"></span>psi=891; pos=8; dba=0; num=0; KbLoad();  // 2018-12-09: infinitive
<span id="line4434"></span>t++; // 2018-10-06: SPACE for the sake of AudRecog()
<span id="line4435"></span>
<span id="line4436"></span>// 582=TWO -- 2019-11-07: noun for the hap(tic) sensation of the numeric "2" key.
<span id="line4437"></span>t++;pho="T"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4438"></span>t++;pho="W"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4439"></span>t++;pho="O"; audpsi=582; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4440"></span>psi=582; pos=5; dba=4; num=0; mfn=3; pre=0; seq=0; KbLoad();
<span id="line4441"></span>t++; // 2019-11-07: one space for sake of AudRecog()
<span id="line4442"></span>
<span id="line4443"></span>// 686=UNDER -- 2018-11-14: preposition for EnPrep() module 
<span id="line4444"></span>t++;pho="U"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4445"></span>t++;pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4446"></span>t++;pho="D"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4447"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4448"></span>t++;pho="R"; audpsi=686; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4449"></span>psi=686; pos=6; KbLoad();
<span id="line4450"></span>t++; // 2018-11-14: SPACE for the sake of AudRecog()
<span id="line4451"></span>
<span id="line4452"></span>// 687=UNDERNEATH -- 2018-11-14: preposition for EnPrep() module 
<span id="line4453"></span>t++;pho="U"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4454"></span>t++;pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4455"></span>t++;pho="D"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4456"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4457"></span>t++;pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4458"></span>t++;pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4459"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4460"></span>t++;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4461"></span>t++;pho="T"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4462"></span>t++;pho="H"; audpsi=687; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4463"></span>psi=687; pos=6; KbLoad();
<span id="line4464"></span>t++; // 2018-11-14: SPACE for the sake of AudRecog()
<span id="line4465"></span>
<span id="line4466"></span>// 892=UNDERSTAND -- 2018-12-09: verb for cognition
<span id="line4467"></span>t++;pho="U"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4468"></span>t++;pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4469"></span>t++;pho="D"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4470"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4471"></span>t++;pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4472"></span>t++;pho="S"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4473"></span>t++;pho="T"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4474"></span>t++;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4475"></span>t++;pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4476"></span>t++;pho="D"; audpsi=892; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4477"></span>psi=892; pos=8; dba=0; num=0; KbLoad();  // 2018-12-09: infinitive
<span id="line4478"></span>t++; // 2018-10-06: SPACE for the sake of AudRecog()
<span id="line4479"></span>
<span id="line4480"></span>// 369=UNLESS -- 2018-11-26: conjunction for ConJoin module 
<span id="line4481"></span>t++; pho="U"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4482"></span>t++; pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4483"></span>t++; pho="L"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4484"></span>t++; pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4485"></span>t++; pho="S"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4486"></span>t++; pho="S"; audpsi=369; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4487"></span>psi=369; pos=3; KbLoad();
<span id="line4488"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line4489"></span>
<span id="line4490"></span>// 688=UNLIKE -- 2018-11-14: preposition for EnPrep() module 
<span id="line4491"></span>t++;pho="U"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4492"></span>t++;pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4493"></span>t++;pho="L"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4494"></span>t++;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4495"></span>t++;pho="K"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4496"></span>t++;pho="E"; audpsi=688; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4497"></span>psi=688; pos=6; KbLoad();
<span id="line4498"></span>t++; // 2018-11-14: SPACE for the sake of AudRecog()
<span id="line4499"></span>
<span id="line4500"></span>// 372=UNTIL -- 2018-11-26: conjunction for ConJoin() module 
<span id="line4501"></span>t++;pho="U"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4502"></span>t++;pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4503"></span>t++;pho="T"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4504"></span>t++;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4505"></span>t++;pho="L"; audpsi=372; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4506"></span>psi=372; pos=3; KbLoad();
<span id="line4507"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line4508"></span>
<span id="line4509"></span>// 689=UNTIL -- 2018-11-14: preposition for EnPrep() module 
<span id="line4510"></span>t++;pho="U"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4511"></span>t++;pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4512"></span>t++;pho="T"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4513"></span>t++;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4514"></span>t++;pho="L"; audpsi=689; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4515"></span>psi=689; pos=6; KbLoad();
<span id="line4516"></span>t++; // 2018-11-14: SPACE for the sake of AudRecog()
<span id="line4517"></span>
<span id="line4518"></span>// 690=UNTO -- 2018-11-14: preposition for EnPrep() module 
<span id="line4519"></span>t++;pho="U"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4520"></span>t++;pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4521"></span>t++;pho="T"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4522"></span>t++;pho="O"; audpsi=690; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4523"></span>psi=690; pos=6; KbLoad();
<span id="line4524"></span>t++; // 2018-11-14: SPACE for the sake of AudRecog()
<span id="line4525"></span>
<span id="line4526"></span>// 691=UP -- 2018-11-14: preposition for EnPrep() module 
<span id="line4527"></span>t++;pho="U"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4528"></span>t++;pho="P"; audpsi=691; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4529"></span>psi=691; pos=6; KbLoad();
<span id="line4530"></span>t++; // 2018-11-14: SPACE for the sake of AudRecog()
<span id="line4531"></span>
<span id="line4532"></span>// 692=UPON -- 2018-11-14: preposition for EnPrep() module 
<span id="line4533"></span>t++;pho="U"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4534"></span>t++;pho="P"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4535"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4536"></span>t++;pho="N"; audpsi=692; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4537"></span>psi=692; pos=6; KbLoad();
<span id="line4538"></span>t++; // 2018-11-14: SPACE for the sake of AudRecog()
<span id="line4539"></span>
<span id="line4540"></span>// 693=UPSIDE -- 2018-11-14: preposition for EnPrep() module 
<span id="line4541"></span>t++;pho="U"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4542"></span>t++;pho="P"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4543"></span>t++;pho="S"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4544"></span>t++;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4545"></span>t++;pho="D"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4546"></span>t++;pho="E"; audpsi=693; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4547"></span>psi=693; pos=6; KbLoad();
<span id="line4548"></span>t++; // 2018-11-14: SPACE for the sake of AudRecog()
<span id="line4549"></span>
<span id="line4550"></span>// 893=USE -- 2018-12-09: common verb
<span id="line4551"></span>t++;pho="U"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t; 
<span id="line4552"></span>t++;pho="S"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4553"></span>t++;pho="E"; audpsi=893; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4554"></span>psi=893; pos=8; dba=0; num=0; KbLoad();  // 2018-12-09: infinitive
<span id="line4555"></span>t++; // 2018-10-06: SPACE for the sake of AudRecog()
<span id="line4556"></span>
<span id="line4557"></span>// 894=WALK -- 2018-12-09: motion verb for robotics
<span id="line4558"></span>t++;pho="W"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4559"></span>t++;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4560"></span>t++;pho="L"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4561"></span>t++;pho="K"; audpsi=894; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4562"></span>psi=894; pos=8; dba=0; num=0; KbLoad();  // 2018-12-09: infinitive
<span id="line4563"></span>t++; // 2018-10-06: SPACE for the sake of AudRecog()
<span id="line4564"></span>
<span id="line4565"></span>// 895=WANT -- 2018-12-09: verb for Volition(0
<span id="line4566"></span>t++;pho="W"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4567"></span>t++;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4568"></span>t++;pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4569"></span>t++;pho="T"; audpsi=895; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4570"></span>psi=895; pos=8; dba=0; num=0; KbLoad();  // 2018-12-09: infinitive
<span id="line4571"></span>t++; // 2018-10-06: SPACE for the sake of AudRecog()
<span id="line4572"></span>
<span id="line4573"></span>// WE -- nominative subject-form of personal pronoun 
<span id="line4574"></span>t++;pho="W"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4575"></span>t++;pho="E"; audpsi=731; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4576"></span>psi=731; pos=7; dba=1; num=2; mfn=0; pre=0; seq=0; KbLoad();
<span id="line4577"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line4578"></span>
<span id="line4579"></span>// OURS -- genitive form of personal pronoun 
<span id="line4580"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4581"></span>t++;pho="U"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4582"></span>t++;pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4583"></span>t++;pho="S"; audpsi=731; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4584"></span>psi=731; pos=7; dba=2; num=2; mfn=0; pre=0; seq=0; KbLoad();
<span id="line4585"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line4586"></span>
<span id="line4587"></span>// US -- dative indirect-object form of personal pronoun 
<span id="line4588"></span>t++;pho="U"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4589"></span>t++;pho="S"; audpsi=731; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4590"></span>psi=731; pos=7; dba=3; num=2; mfn=0; pre=0; seq=0; KbLoad();
<span id="line4591"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line4592"></span>
<span id="line4593"></span>// US -- accusative direct-object form of personal pronoun 
<span id="line4594"></span>t++;pho="U"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t; 
<span id="line4595"></span>t++;pho="S"; audpsi=731; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4596"></span>psi=731; pos=7; dba=4; num=2; mfn=0; pre=0; seq=0; KbLoad();
<span id="line4597"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line4598"></span>
<span id="line4599"></span>// 694=VERSUS -- 2018-11-14: preposition for EnPrep() module 
<span id="line4600"></span>t++;pho="V"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4601"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4602"></span>t++;pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4603"></span>t++;pho="S"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4604"></span>t++;pho="U"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4605"></span>t++;pho="S"; audpsi=694; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4606"></span>psi=694; pos=6; KbLoad();
<span id="line4607"></span>t++; // 2018-11-14: SPACE for the sake of AudRecog()
<span id="line4608"></span>
<span id="line4609"></span>// 695=VIA -- 2018-11-14: preposition for EnPrep() module 
<span id="line4610"></span>t++;pho="V"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4611"></span>t++;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4612"></span>t++;pho="A"; audpsi=695; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4613"></span>psi=695; pos=6; KbLoad();
<span id="line4614"></span>t++; // 2018-11-14: SPACE for the sake of AudRecog()
<span id="line4615"></span>
<span id="line4616"></span>// 696=VIS-A-VIS -- 2018-11-14: as a preposition for EnPrep() module
<span id="line4617"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line4618"></span>
<span id="line4619"></span>// WHAT -- nominative pronoun for SelfReferentialThought 
<span id="line4620"></span>t++;pho="W"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4621"></span>t++;pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4622"></span>t++;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4623"></span>t++;pho="T"; audpsi=781; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4624"></span>psi=781; pos=7; dba=1; num=1; mfn=3; pre=0; seq=0; KbLoad();
<span id="line4625"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line4626"></span>
<span id="line4627"></span>// WHAT -- accusative pronoun for SelfReferentialThought 
<span id="line4628"></span>t++;pho="W"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4629"></span>t++;pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4630"></span>t++;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4631"></span>t++;pho="T"; audpsi=781; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4632"></span>psi=781; pos=7; dba=4; num=1; mfn=3; pre=0; seq=0; KbLoad();
<span id="line4633"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line4634"></span>
<span id="line4635"></span>// 263=WHEN -- 2018-11-26: adverb for SelfReferentialThought 
<span id="line4636"></span>t++;pho="W"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4637"></span>t++;pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4638"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4639"></span>t++;pho="N"; audpsi=263; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4640"></span>psi=263; pos=2; dba=0; num=0; mfn=0; pre=0; seq=0; KbLoad();
<span id="line4641"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line4642"></span>
<span id="line4643"></span>// 375=WHEN -- 2018-11-26: conjunction for ConJoin() module 
<span id="line4644"></span>t++;pho="W"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4645"></span>t++;pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4646"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4647"></span>t++;pho="N"; audpsi=375; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4648"></span>psi=375; pos=3; KbLoad();
<span id="line4649"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line4650"></span>
<span id="line4651"></span>// 378=WHENEVER -- 2018-11-26: conjunction for ConJoin() module 
<span id="line4652"></span>t++;pho="W"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4653"></span>t++;pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4654"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4655"></span>t++;pho="N"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4656"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4657"></span>t++;pho="V"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4658"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4659"></span>t++;pho="R"; audpsi=378; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4660"></span>psi=378; pos=3; KbLoad();
<span id="line4661"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line4662"></span>
<span id="line4663"></span>// WHERE -- 2018-11-26: adverb for SelfReferentialThought 
<span id="line4664"></span>t++;pho="W"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4665"></span>t++;pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4666"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4667"></span>t++;pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4668"></span>t++;pho="E"; audpsi=245; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4669"></span>psi=245; pos=2; dba=0; num=0; mfn=0; pre=0; seq=0; KbLoad();
<span id="line4670"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line4671"></span>
<span id="line4672"></span>// 381=WHEREAS -- 2018-11-26: conjunction for ConJoin() module 
<span id="line4673"></span>t++;pho="W"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4674"></span>t++;pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4675"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4676"></span>t++;pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4677"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4678"></span>t++;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4679"></span>t++;pho="S"; audpsi=381; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4680"></span>psi=381; pos=3; KbLoad();
<span id="line4681"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line4682"></span>
<span id="line4683"></span>// 384=WHETHER -- 2018-11-26: conjunction for ConJoin() module 
<span id="line4684"></span>t++;pho="W"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4685"></span>t++;pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4686"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4687"></span>t++;pho="T"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4688"></span>t++;pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4689"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4690"></span>t++;pho="R"; audpsi=384; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4691"></span>psi=384; pos=3; KbLoad();
<span id="line4692"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line4693"></span>
<span id="line4694"></span>// 387=WHILE -- 2018-11-26: conjunction for ConJoin() module 
<span id="line4695"></span>t++;pho="W"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4696"></span>t++;pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4697"></span>t++;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4698"></span>t++;pho="L"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4699"></span>t++;pho="E"; audpsi=387; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4700"></span>psi=387; pos=3; KbLoad();
<span id="line4701"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line4702"></span>
<span id="line4703"></span>// WHO -- for SelfReferentialThought 
<span id="line4704"></span>t++;pho="W"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4705"></span>t++;pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4706"></span>t++;pho="O"; audpsi=791; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4707"></span>psi=791; pos=7; dba=1; num=1; mfn=0; pre=0; seq=0; KbLoad();
<span id="line4708"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line4709"></span>
<span id="line4710"></span>// WHOSE -- for AI to ask grammatically correct questions 
<span id="line4711"></span>t++;pho="W"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4712"></span>t++;pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4713"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4714"></span>t++;pho="S"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4715"></span>t++;pho="E"; audpsi=794; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4716"></span>psi=794; pos=7; dba=2; num=1; mfn=0; pre=0; seq=0; KbLoad();
<span id="line4717"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line4718"></span>
<span id="line4719"></span>// WHOM -- for AI to ask grammatically correct questions 
<span id="line4720"></span>t++;pho="W"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4721"></span>t++;pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4722"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4723"></span>t++;pho="M"; audpsi=794; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4724"></span>psi=794; pos=7; dba=3; num=1; mfn=0; pre=0; seq=0; KbLoad();
<span id="line4725"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line4726"></span>
<span id="line4727"></span>// WHOM -- for AI to ask grammatically correct questions 
<span id="line4728"></span>t++;pho="W"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4729"></span>t++;pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4730"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4731"></span>t++;pho="M"; audpsi=794; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4732"></span>psi=794; pos=7; dba=4; num=1; mfn=0; pre=0; seq=0; KbLoad();
<span id="line4733"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line4734"></span>
<span id="line4735"></span>// 297=WHY -- 2018-11-26: adverb for asking questions
<span id="line4736"></span>t++; pho="W"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4737"></span>t++; pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4738"></span>t++; pho="Y"; audpsi=297; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4739"></span>psi=297; pos=2; dba=0; num=0; mfn=0; pre=0; seq=0; KbLoad();
<span id="line4740"></span>t++; // 2018-11-26 SPACE for the sake of AudRecog()
<span id="line4741"></span>
<span id="line4742"></span>// 390=WHY -- 2018-11-26: conjunction for ConJoin() module 
<span id="line4743"></span>t++; pho="W"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4744"></span>t++; pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4745"></span>t++; pho="Y"; audpsi=390; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4746"></span>psi=390; pos=3; KbLoad();
<span id="line4747"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line4748"></span>
<span id="line4749"></span>// 896=WILL -- 2018-12-09: auxiliary verb for future tense
<span id="line4750"></span>t++;pho="W"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4751"></span>t++;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4752"></span>t++;pho="L"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4753"></span>t++;pho="L"; audpsi=896; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4754"></span>psi=896; pos=8; dba=0; num=0; KbLoad();  // 2018-12-09: modal verb
<span id="line4755"></span>t++; // 2018-10-06: SPACE for the sake of AudRecog()
<span id="line4756"></span>
<span id="line4757"></span>// 897=WISH -- 2018-12-09: verb for Volition()
<span id="line4758"></span>t++;pho="W"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4759"></span>t++;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4760"></span>t++;pho="S"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4761"></span>t++;pho="H"; audpsi=897; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4762"></span>psi=897; pos=8; dba=0; num=0; KbLoad();  // 2018-12-09: infinitive
<span id="line4763"></span>t++; // 2018-10-06: SPACE for the sake of AudRecog()
<span id="line4764"></span>
<span id="line4765"></span>// 697=WITH -- 2018-11-14: preposition for EnPrep() module 
<span id="line4766"></span>t++;pho="W"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4767"></span>t++;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4768"></span>t++;pho="T"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4769"></span>t++;pho="H"; audpsi=697; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4770"></span>psi=697; pos=6; KbLoad();
<span id="line4771"></span>t++; // 2018-11-14: SPACE for the sake of AudRecog()
<span id="line4772"></span>
<span id="line4773"></span>// 698=WITHIN -- 2018-11-14: preposition for EnPrep() module 
<span id="line4774"></span>t++;pho="W"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4775"></span>t++;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4776"></span>t++;pho="T"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4777"></span>t++;pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4778"></span>t++;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4779"></span>t++;pho="N"; audpsi=698; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4780"></span>psi=698; pos=6; KbLoad();
<span id="line4781"></span>t++; // 2018-11-14: SPACE for the sake of AudRecog()
<span id="line4782"></span>
<span id="line4783"></span>// 699=WITHOUT -- 2018-11-14: preposition for EnPrep() module 
<span id="line4784"></span>t++;pho="W"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4785"></span>t++;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4786"></span>t++;pho="T"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4787"></span>t++;pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4788"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4789"></span>t++;pho="U"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4790"></span>t++;pho="T"; audpsi=699; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4791"></span>psi=699; pos=6; KbLoad();
<span id="line4792"></span>t++; // 2018-11-14: SPACE for the sake of AudRecog()
<span id="line4793"></span>
<span id="line4794"></span>t++; // 2018-07-12: making single-word time relative, not hard-coded.
<span id="line4795"></span>// WOMAN -- always feminine noun for use with gender flags 
<span id="line4796"></span>t++;pho="W"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4797"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4798"></span>t++;pho="M"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4799"></span>t++;pho="A"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4800"></span>t++;pho="N"; audpsi=515; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4801"></span>psi=515; pos=5; dba=0; num=1; mfn=2; pre=0; seq=0; KbLoad();
<span id="line4802"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line4803"></span>
<span id="line4804"></span>// WOMEN -- irregular plural for retrieval by parameters
<span id="line4805"></span>t++;pho="W"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4806"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4807"></span>t++;pho="M"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4808"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4809"></span>t++;pho="N"; audpsi=515; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4810"></span>psi=515; pos=5; dba=0; num=2; mfn=2; pre=0; seq=0; KbLoad();
<span id="line4811"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line4812"></span>
<span id="line4813"></span>// 898=WORK -- 2018-12-16: commonverb
<span id="line4814"></span>t++;pho="W"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4815"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4816"></span>t++;pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4817"></span>t++;pho="K"; audpsi=898; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4818"></span>psi=898; pos=8; dba=0; num=0; KbLoad();  // 2018-12-16: infinitive
<span id="line4819"></span>t++; // 2018-10-06: SPACE for the sake of AudRecog()
<span id="line4820"></span>
<span id="line4821"></span>// 899=WORSHIP -- 2019-10-24: for link from you-concept to God-concept
<span id="line4822"></span>t++;pho="W"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t; 
<span id="line4823"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4824"></span>t++;pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4825"></span>t++;pho="S"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4826"></span>t++;pho="H"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4827"></span>t++;pho="I"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4828"></span>t++;pho="P"; audpsi=899; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4829"></span>psi=899; pos=8; dba=0; num=0; KbLoad();  // 2019-10-24: infinitive
<span id="line4830"></span>t++; // 2019-10-24: space for the sake of AudRecog()
<span id="line4831"></span>
<span id="line4832"></span>// YES -- interjection for human-computer interaction 
<span id="line4833"></span>t++; pho="Y"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4834"></span>t++; pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4835"></span>t++; pho="S"; audpsi=432; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4836"></span>psi=432; pos=4; dba=0; num=0; mfn=0; pre=0; seq=0; KbLoad();
<span id="line4837"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line4838"></span>
<span id="line4839"></span>// 393=YET -- 2018-11-26: conjunction for ConJoin() module 
<span id="line4840"></span>t++; pho="Y"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4841"></span>t++; pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4842"></span>t++; pho="T"; audpsi=393; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4843"></span>psi=393; pos=3; KbLoad();
<span id="line4844"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line4845"></span>
<span id="line4846"></span>// YOU -- nominative singular of personal pronoun 
<span id="line4847"></span>t++; pho="Y"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4848"></span>t++; pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4849"></span>t++; pho="U"; audpsi=707; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4850"></span>psi=707; pos=7; dba=1; num=1; mfn=0; pre=0; seq=0; KbLoad();
<span id="line4851"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line4852"></span>
<span id="line4853"></span>// YOURS -- genitive singular of personal pronoun 
<span id="line4854"></span>t++; pho="Y"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4855"></span>t++; pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4856"></span>t++; pho="U"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4857"></span>t++; pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4858"></span>t++; pho="S"; audpsi=707; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4859"></span>psi=707; pos=7; dba=2; num=1; mfn=0; pre=0; seq=0; KbLoad();
<span id="line4860"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line4861"></span>
<span id="line4862"></span>// YOU -- dative singular of personal pronoun 
<span id="line4863"></span>t++; pho="Y"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4864"></span>t++; pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4865"></span>t++; pho="U"; audpsi=707; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4866"></span>psi=707; pos=7; dba=3; num=1; mfn=0; pre=0; seq=0; KbLoad();
<span id="line4867"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line4868"></span>
<span id="line4869"></span>// YOU -- accusative singular of personal pronoun 
<span id="line4870"></span>t++; pho="Y"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4871"></span>t++; pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4872"></span>t++; pho="U"; audpsi=707; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4873"></span>psi=707; pos=7; dba=4; num=1; mfn=0;  pre=0; seq=0; KbLoad();
<span id="line4874"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line4875"></span>
<span id="line4876"></span>// YOU -- nominative plural of personal pronoun 
<span id="line4877"></span>t++; pho="Y"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4878"></span>t++; pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4879"></span>t++; pho="U"; audpsi=737; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4880"></span>psi=737; pos=7; dba=1; num=2; mfn=0; pre=0; seq=0; KbLoad();
<span id="line4881"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line4882"></span>
<span id="line4883"></span>// YOURS -- genitive plural of personal pronoun 
<span id="line4884"></span>t++; pho="Y"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4885"></span>t++; pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4886"></span>t++; pho="U"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4887"></span>t++; pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4888"></span>t++; pho="S"; audpsi=737; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4889"></span>psi=737; pos=7; dba=2; num=2; mfn=0; pre=0; seq=0; KbLoad();
<span id="line4890"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line4891"></span>
<span id="line4892"></span>// YOU -- dative plural of personal pronoun 
<span id="line4893"></span>t++; pho="Y"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4894"></span>t++; pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4895"></span>t++; pho="U"; audpsi=737; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4896"></span>psi=737; pos=7; dba=3; num=2; mfn=0; pre=0; seq=0; KbLoad();
<span id="line4897"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line4898"></span>
<span id="line4899"></span>// YOU -- accusative plural of personal pronoun 
<span id="line4900"></span>t++; pho="Y"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4901"></span>t++; pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4902"></span>t++; pho="U"; audpsi=737; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4903"></span>psi=737; pos=7; dba=4; num=2; mfn=0; pre=0; seq=0; KbLoad();
<span id="line4904"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line4905"></span>
<span id="line4906"></span>// YOUR -- adjective for personal pronoun "YOU" 
<span id="line4907"></span>t++;pho="Y"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4908"></span>t++;pho="O"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4909"></span>t++;pho="U"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4910"></span>t++;pho="R"; audpsi=182; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4911"></span>psi=182; pos=1; dba=0; num=0; mfn=0; pre=0; seq=0; KbLoad();
<span id="line4912"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line4913"></span>
<span id="line4914"></span>// 590=ZERO -- 2019-11-07: noun for the hap(tic) sensation of the numeric "0" key.
<span id="line4915"></span>t++;pho="Z"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi); rv=t;
<span id="line4916"></span>t++;pho="E"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4917"></span>t++;pho="R"; audpsi=0; audMemory[t] = new audNode(pho,0,audpsi);
<span id="line4918"></span>t++;pho="O"; audpsi=590; audMemory[t] = new audNode(pho,0,audpsi); 
<span id="line4919"></span>psi=590; pos=5; dba=4; num=0; mfn=3; pre=0; seq=0; KbLoad();
<span id="line4920"></span>t++; // 2019-11-07: one space for sake of AudRecog()
<span id="line4921"></span>
<span id="line4922"></span>t++; // 2018-11-26: SPACE for the sake of AudRecog()
<span id="line4923"></span>  pho="";audpsi=0;psi=0;act=0;jux=0;pos=0;dba=0;num=0;mfn=0;pre=0;iob=0;seq=0;tkb=0;rv=0
<span id="line4924"></span>  t = (t+1);  // 2018-01-03:  
<span id="line4925"></span>  nxt = 3001; // 2018-01-09: next new concept, as in ghost.pl AI and MindForth.
<span id="line4926"></span>  spt = t;  // 2018-01-06: so that AudInput will have a valid first space-time.
<span id="line4927"></span>  tpu = t;  // 2018-10-02: isolate tpu from previous input-and-output.
<span id="line4928"></span>  vault = t;  // 2018-07-12: dynamically calculated by incremental t++
<span id="line4929"></span>  apb = "MindBoot: English bootstrap has loaded and now calling MainLoop()";
<span id="line4930"></span>  Voice();
<span id="line4931"></span>  document.forms[1].ear.focus();
<span id="line4932"></span>  MainLoop();
<span id="line4933"></span>}  // 2018-06-11: end of MindBoot English bootstrap; NewConcept() learns more words.
<span id="line4934"></span>
<span id="line4935"></span>
<span id="line4936"></span>function ReJuvenate() {  // http://ai.neocities.org/ReJuvenate.html
<span id="line4937"></span>  edge = 0;  // When found, edge-of-thought becomes "1".
<span id="line4938"></span>  istr = (vault + coda);  // 2018-10-13: initial calculation of "istr"
<span id="line4939"></span>  rjc = (rjc+1);  // 2018-01-18: increment rejuvenation counter.
<span id="line4940"></span>  if (rjc &gt; 99999) rjc = 1;  // 2018-01-18: for immortal AI avoid infinite count.
<span id="line4941"></span>  apb=("</span><span>&lt;f</span><span>ont color='red'&gt;"+"Rejuvenating; please wait!"+"</span><span>&lt;\</span><span>/font&gt;");
<span id="line4942"></span>  Voice();  // Display the Voice:brain apb message.
<span id="line4943"></span>  jrt = vault;  // 2018-10-12: let "jrt" increment after the "vault"
<span id="line4944"></span>  for (i = istr; i </span><span>&lt; </span><span>cns;  ++i) {  // 2018-10-13: loop forwards from initial "istr"
<span id="line4945"></span>    if (edge == 0) {  // 2018-10-13: not yet set to unitary one.
<span id="line4946"></span>      audMemory[i].audExam();  // 2018-10-13: examine auditory memory
<span id="line4947"></span>      mg++;  // 2018-10-13: increment until "edge" is found.
<span id="line4948"></span>      if (aud0 == "{") edge = 1;  // 2018-10-13: if "edge" of thought is found... 
<span id="line4949"></span>      if (aud0 == "{") istr = i;  // 2018-10-13: reset the "istr" starting-point.
<span id="line4950"></span>      if (aud0 == "{") mg = (mg + coda - 1)  // 2018-10-13: distance from "vault"
<span id="line4951"></span>      if (aud0 == "{") break;     // 2018-10-13: abandon the rest of the loop.
<span id="line4952"></span>    }  // 2018-10-13: end of search for edge-of-thought "istr" starting-point.
<span id="line4953"></span>  }  // 2018-10-13: end of loop looking for a first "edge" of thought.
<span id="line4954"></span>    for (i = istr; i </span><span>&lt; </span><span>cns;  ++i) {  // 2018-10-13: loop forwards from "istr" point.
<span id="line4955"></span>    Psy[i].psyExam(); // 2019-07-27: subtracting coda from psi14 to keep tkb valid:
<span id="line4956"></span>    if (psi14&gt;0) psi14= (psi14 - mg);  // 2019-07-27: only for a concept-row.
<span id="line4957"></span>    if (psi20&gt;0) psi20= (psi20 - mg);  // 2019-07-27: only for a concept-row.
<span id="line4958"></span>    Psy[jrt] = new 
<span id="line4959"></span>    psyNode(psi0,psi1,psi2,psi3,psi4,psi5,psi6,
<span id="line4960"></span>    psi7,psi8,psi9,psi10,psi11,psi12,psi13,
<span id="line4961"></span>    psi14,psi15,psi16,psi17,psi18,psi19,psi20);  // 2019-07-27
<span id="line4962"></span>    psi14 = 0;  // 2019-07-27: reset to prevent carry over.
<span id="line4963"></span>    Psy[i] = new 
<span id="line4964"></span>    psyNode(" "," "," "," "," "," "," ",
<span id="line4965"></span>    " "," "," "," "," "," "," ",
<span id="line4966"></span>    " "," "," "," "," "," "," ");  // 2019-07-27
<span id="line4967"></span>    audMemory[i].audExam();  // 2018-10-12: gain access to auditory engram nodes
<span id="line4968"></span>    audMemory[jrt] = new audNode(aud0,aud1,aud2);  // 2018-10-12: move engrams back.
<span id="line4969"></span>    audMemory[i] = new audNode(" ",0," ");  // 2018-10-12: zero out old time-row.
<span id="line4970"></span>    jrt++;  // 2018-10-13: advance each "junior-time" point for a moved engram.
<span id="line4971"></span>  }  // 2018-10-12: end of loop moving forwards while shifting engrams back.
<span id="line4972"></span>  edge = 0;  // 2018-10-12: reset for next call of ReJuvenate()
<span id="line4973"></span>  t = (jrt - mg);  // 2018-10-13: TEST
<span id="line4974"></span>  mg = 0;  // 2018-10-13: reset to prevent carry-over.
<span id="line4975"></span>  for (j = t; j </span><span>&lt; </span><span>cns; ++j) {  // 2018-10-12: clean out engrams beyond current "t"
<span id="line4976"></span>    audMemory[j] = new audNode(" ",0," ");  // 2018-01-18: pho(neme); act; audpsi
<span id="line4977"></span>    Psy[j] = new 
<span id="line4978"></span>    psyNode(" "," "," "," "," "," "," ",
<span id="line4979"></span>    " "," "," "," "," "," "," ",
<span id="line4980"></span>    " "," "," "," "," "," "," ");  // 2019-07-27
<span id="line4981"></span>  }  // 2018-10-12: end of sweep of memory beyond current time "t".
<span id="line4982"></span>}  // 2019-07-31: End of ReJuvenate(); return to SeCurity();  
<span id="line4983"></span>
<span id="line4984"></span>
<span id="line4985"></span>function ReEntry() {
<span id="line4986"></span>  pov = 1;  // 2018-01-15: numeric code for internal POV.
<span id="line4987"></span>  t = (t + 1);
<span id="line4988"></span>  onset = (spt + 1);
<span id="line4989"></span>  if (dirobj == 1) dba = 4;  // From RuAi; test; 19oct2012
<span id="line4990"></span>  if (pho != " ") {  // 2018-01-15: if pho is not a 32=SPACE...
<span id="line4991"></span>    len = (len +1);
<span id="line4992"></span>    AudInput();  // 2019-09-21: May be causing reduplication of output. 
<span id="line4993"></span>  }  // End of test that input "pho" is not a "space".
<span id="line4994"></span>  if (pho == " ") { // 2018-01-15: If pho is a "space".
<span id="line4995"></span>    AudInput();  // Re-entry into audition; 13jul2010
<span id="line4996"></span>  }  // End of test for space-bar re-entry; 13jul2010
<span id="line4997"></span>  pos = 0;  // 2018-01-21: Reset to prevent InStantiate() carry-over.
<span id="line4998"></span>  pre = 0;  // 2018-01-21: Reset to prevent InStantiate() carry-over.
<span id="line4999"></span>  psi = 0;  // 2018-01-21: Reset to prevent InStantiate() carry-over.
<span id="line5000"></span>}  // End of ReEntry(); return to SpeechAct().
<span id="line5001"></span>
<span id="line5002"></span>
<span id="line5003"></span>function Voice() {
<span id="line5004"></span>outputplus = ("</span><span>&lt;f</span><span>ont size='+3' color='navy'&gt;"+output+"</span><span>&lt;\</span><span>/b&gt;</span><span>&lt;\</span><span>/font&gt;");
<span id="line5005"></span>  document.all.mouth.innerHTML = outputplus;
<span id="line5006"></span>  document.all.brain.innerHTML = apb;
<span id="line5007"></span>}
<span id="line5008"></span>
<span id="line5009"></span>
<span id="line5010"></span>function Speech() {  // http://ai.neocities.org/Speech.html 
<span id="line5011"></span>  audstop = 0;  // 2017-12-31: Initially false value of flag
<span id="line5012"></span>  pov = 1;  // 2017-12-31: only internal POV thinking uses Speech module.
<span id="line5013"></span>  t2s = aud;  // 2017-12-31: start from the auditory recall-vector "aud"
<span id="line5014"></span>  for (i = 0; i </span><span>&lt; </span><span>41; i++) {  // 2018-01-13: assume word no longer than 40 ch.
<span id="line5015"></span>    audMemory[t2s].audExam();  // 2017-12-31: expose ear-array values at "t2s".
<span id="line5016"></span>    pho = aud0;  // 2018-01-03: for re-entry; TEST; REMOVE?
<span id="line5017"></span>    output += aud0;  // 2017-12-31: concatenate each engram to "output".//   
<span id="line5018"></span>    if (pho == " ") {  // 2017-12-31: if space detected...
<span id="line5019"></span>      pho = " ";  // 2017-12-31: blank SPACE-32
<span id="line5020"></span>      audstop = 1;  // 2017-12-31: flag to end a word with a space
<span id="line5021"></span>    }  // 2017-12-31: end of test for a blank space.
<span id="line5022"></span>    if (pho == 13) {  // 2017-12-31:  including any 32=SPACE...
<span id="line5023"></span>      lastpho = pho;  // 2017-12-31: to avoid extra "S" on verbs 
<span id="line5024"></span>    }  // 2017-12-31: end of constantly keeping track of last pho.
<span id="line5025"></span>    if (pho == 0 || pho == 13 || pho == 32 || pho == " ") {  // 2018-01-13: SPACE
<span id="line5026"></span>      audstop = 1;   // 2017-12-31: flag for finding end of word
<span id="line5027"></span>      spacegap = 1;  // 2017-12-31: identify presence of a space
<span id="line5028"></span>    }  // 2017-12-31: end of test for 13=CR or 32=SPACE.
<span id="line5029"></span>    ReEntry();  // 2018-01-15: from the obsolete JSAI
<span id="line5030"></span>    if (audstop == 1) {  // 2017-12-31: flag found for end of word?
<span id="line5031"></span>      if (spacegap == 1) {  // 2017-12-31: space found
<span id="line5032"></span>        pho = " ";  // 2017-12-31: send SPACE-32 into AudInput?
<span id="line5033"></span>        len = 0;  // 2018-01-06: at end of word, reset length "len" 
<span id="line5034"></span>        spacegap = 0;  // 2017-12-31: reset
<span id="line5035"></span>      }  // 2017-12-31: end of test for a space.
<span id="line5036"></span>      return;  // 2018-01-13: from MindForth ("LEAVE"
<span id="line5037"></span>    }  // 2017-12-31: end of test for end-of-word flag.
<span id="line5038"></span>    pov = 1;  // 2017-12-31: internal point-of-view during thinking.
<span id="line5039"></span>    t2s = (t2s + 1);  // 2017-12-31: Increment time-to-speech to advance thru memory. 
<span id="line5040"></span>    if (aud0 == " ") {  // 2017-12-31: if no character is found
<span id="line5041"></span>      audrv = t2s;  // 2017-12-31: Prepare for next word in memory.
<span id="line5042"></span>      if (pho == 13 || pho == " ") pov = 2;  // 2018-01-13: for sake of pause-counter
<span id="line5043"></span>      return;  // 2018-01-13: TEST
<span id="line5044"></span>    }  // 2017-12-31: end of test for no character found.
<span id="line5045"></span>  } while ( t2s != cns );  // 2017-12-31:  Show the whole array of AI Mind memory. 
<span id="line5046"></span>  phodex = 1;  // 2017-12-31: reset for AudBuffer()
<span id="line5047"></span>  output += " ";
<span id="line5048"></span>  Voice();
<span id="line5049"></span>}  // 2017-12-31: End of Speech()
<span id="line5050"></span>
<span id="line5051"></span>
<span id="line5052"></span>function ConJoin() {  // http://ai.neocities.org/ConJoin.html
<span id="line5053"></span>  if (etc &gt; 1) conj = 306;  // 2019-02-18: use conjunction 306=AND
<span id="line5054"></span>  if (etc &gt; 2) etc = 0;     // 2019-03-03: prevent runaway values.
<span id="line5055"></span>  if (qv2psi==886 || qv2psi==838 || verbpsi==886 || verbpsi==838) {  // 2018-11-28
<span id="line5056"></span>    conj = 361;  // 2018-11-26: conjunction is 361=THAT
<span id="line5057"></span>  }  // 2019-02-12: end of test for verbs leading to conjunction 361=THAT.
<span id="line5058"></span>  for (i=vault; i&gt;midway; i--) {  // 2018-05-28: search in "vault" for reliability.
<span id="line5059"></span>    Psy[i].psyExam(); // 2018-05-28: inspect the Psy concept flag-panel 
<span id="line5060"></span>    if (psi1 == conj) {  // 2019-02-12: if conjunction is found...
<span id="line5061"></span>      audjuste = psi20;  // 2019-09-20: conjunction recall-vector;
<span id="line5062"></span>      aud = psi20;  // 2019-07-31: conj recall-vector for Speech()
<span id="line5063"></span>      break;  // 2018-05-28: one auditory engram is enough.
<span id="line5064"></span>    }  // 2019-02-12: End of search for $conj conjunction;
<span id="line5065"></span>  }  // 2018-05-28: end of loop searching for conjunction "THAT".
<span id="line5066"></span>  if (conj &gt; 0) Speech();   // 2019-02-12: speak the word starting at the "aud" time. 
<span id="line5067"></span>  if (conj==361) Speech();  // 2018-11-26: only speak 361=THAT
<span id="line5068"></span>}  // 2019-09-20: ConJoin() returns to EnThink().
<span id="line5069"></span>
<span id="line5070"></span>
<span id="line5071"></span>function EnArticle() {  // http://ai.neocities.org/EnArticle.html
<span id="line5072"></span>  if (usx == us1) {  // 2018-09-05: if definite article "the" is warranted...
<span id="line5073"></span>    for (i=vault; i&gt;0; i--) {  // 2018-09-06: search for 117=THE
<span id="line5074"></span>      Psy[i].psyExam(); // 2018-09-06: examine @psy array;
<span id="line5075"></span>        if (psi1 == 117) {  // 2018-09-06: if 117=THE is found;
<span id="line5076"></span>          aud = psi20;  // 2019-07-31: "THE" recall-vector for Speech()
<span id="line5077"></span>          if (psi20 &gt; 0) break;  // 2019-07-31: auditory-recall insurance.
<span id="line5078"></span>        }  // 2018-09-06: End of search for 117=THE.
<span id="line5079"></span>    }  // 2018-09-06: End of search loop from "vault" back to zero.
<span id="line5080"></span>    Speech();  // 2018-09-06: speak the word starting at the "aud" time. 
<span id="line5081"></span>    return;  // 2018-09-06: skip the rest of EnArticle()
<span id="line5082"></span>  }  // 2018-09-05: end of test for need to say "THE". 
<span id="line5083"></span>  if (usx == us2) {  // 2018-09-06: if definite article "the" is warranted...
<span id="line5084"></span>    for (i=vault; i&gt;0; i--) {  // 2018-09-06: search for 117=THE
<span id="line5085"></span>      Psy[i].psyExam(); // 2018-09-06: examine @psy array;
<span id="line5086"></span>        if (psi1 == 117) {  // 2018-09-06: if 117=THE is found;
<span id="line5087"></span>          aud = psi20;  // 2019-07-31: "THE" recall-vector for Speech()
<span id="line5088"></span>          if (psi20 &gt; 0) break;  // 2019-07-31: auditory-recall insurance.
<span id="line5089"></span>        }  // 2018-09-06: End of search for 117=THE.
<span id="line5090"></span>    }  // 2018-09-06: End of search loop from "vault" back to zero.
<span id="line5091"></span>    Speech();  // 2018-09-06: speak the word starting at the "aud" time. 
<span id="line5092"></span>    return;  // 2018-09-06: skip the rest of EnArticle()
<span id="line5093"></span>  }  // 2018-09-06: end of test for need to say "THE".
<span id="line5094"></span>  if (usx == us3) {  // 2018-09-06: if definite article "the" is warranted...
<span id="line5095"></span>    for (i=vault; i&gt;0; i--) {  // 2018-09-06: search for 117=THE
<span id="line5096"></span>      Psy[i].psyExam(); // 2018-09-06: examine @psy array;
<span id="line5097"></span>        if (psi1 == 117) {  // 2018-09-06: if 117=THE is found;
<span id="line5098"></span>          aud = psi20;  // 2019-07-31: "THE" recall-vector for Speech()
<span id="line5099"></span>          if (psi20 &gt; 0) break;  // 2019-07-31: auditory-recall insurance.
<span id="line5100"></span>        }  // 2018-09-06: End of search for 117=THE.
<span id="line5101"></span>    }  // 2018-09-06: End of search loop from "vault" back to zero.
<span id="line5102"></span>    Speech();  // 2018-09-06: speak the word starting at the "aud" time. 
<span id="line5103"></span>    return;  // 2018-09-06: skip the rest of EnArticle()
<span id="line5104"></span>  }  // 2018-09-06: end of test for need to say "THE".
<span id="line5105"></span>  if (usx == us4) {  // 2018-09-06: if definite article "the" is warranted...
<span id="line5106"></span>    for (i=vault; i&gt;0; i--) {  // 2018-09-06: search for 117=THE
<span id="line5107"></span>      Psy[i].psyExam(); // 2018-09-06: examine @psy array;
<span id="line5108"></span>        if (psi1 == 117) {  // 2018-09-06: if 117=THE is found;
<span id="line5109"></span>          aud = psi20;  // 2019-07-031: "THE" recall-vector for Speech()
<span id="line5110"></span>          if (psi20 &gt; 0) break;  // 2019-07-31: auditory-recall insurance.
<span id="line5111"></span>        }  // 2018-09-06: End of search for 117=THE.
<span id="line5112"></span>    }  // 2018-09-06: End of search loop from "vault" back to zero.
<span id="line5113"></span>    Speech();  // 2018-09-06: speak the word starting at the "aud" time. 
<span id="line5114"></span>    return;  // 2018-09-06: skip the rest of EnArticle()
<span id="line5115"></span>  }  // 2018-09-06: end of test for need to say "THE".
<span id="line5116"></span>  if (usx == us5) {  // 2018-09-06: if definite article "the" is warranted...
<span id="line5117"></span>    for (i=vault; i&gt;0; i--) {  // 2018-09-06: search for 117=THE
<span id="line5118"></span>      Psy[i].psyExam(); // 2018-09-06: examine @psy array;
<span id="line5119"></span>        if (psi1 == 117) {  // 2018-09-06: if 117=THE is found;
<span id="line5120"></span>          aud = psi20;  // 2019-07-31: "THE" recall-vector for Speech()
<span id="line5121"></span>          if (psi20 &gt; 0) break;  // 2019-07-31: auditory-recall insurance.
<span id="line5122"></span>        }  // 2018-09-06: End of search for 117=THE.
<span id="line5123"></span>    }  // 2018-09-06: End of search loop from "vault" back to zero.
<span id="line5124"></span>    Speech();  // 2018-09-06: speak the word starting at the "aud" time. 
<span id="line5125"></span>    return;  // 2018-09-06: skip the rest of EnArticle()
<span id="line5126"></span>  }  // 2018-09-06: end of test for need to say "THE".
<span id="line5127"></span>  if (usx == us6) {  // 2018-09-06: if definite article "the" is warranted...
<span id="line5128"></span>    for (i=vault; i&gt;0; i--) {  // 2018-09-06: search for 117=THE
<span id="line5129"></span>      Psy[i].psyExam(); // 2018-09-06: examine @psy array;
<span id="line5130"></span>        if (psi1 == 117) {  // 2018-09-06: if 117=THE is found;
<span id="line5131"></span>          aud = psi20;  // 2019-07-31: "THE" recall-vector for Speech()
<span id="line5132"></span>          if (psi20 &gt; 0) break;  // 2019-07-31: auditory-recall insurance.
<span id="line5133"></span>        }  // 2018-09-06: End of search for 117=THE.
<span id="line5134"></span>    }  // 2018-09-06: End of search loop from "vault" back to zero.
<span id="line5135"></span>    Speech();  // 2018-09-06: speak the word starting at the "aud" time. 
<span id="line5136"></span>    return;  // 2018-09-06: skip the rest of EnArticle()
<span id="line5137"></span>  }  // 2018-09-06: end of test for need to say "THE".
<span id="line5138"></span>  if (usx == us7) {  // 2018-09-06: if definite article "the" is warranted...
<span id="line5139"></span>    for (i=vault; i&gt;0; i--) {  // 2018-09-06: search for 117=THE
<span id="line5140"></span>      Psy[i].psyExam(); // 2018-09-06: examine @psy array;
<span id="line5141"></span>        if (psi1 == 117) {  // 2018-09-06: if 117=THE is found;
<span id="line5142"></span>          aud = psi20;  // 2019-07-31: "THE" recall-vector for Speech()
<span id="line5143"></span>          if (psi20 &gt; 0) break;  // 2019-07-31: auditory-recall insurance.
<span id="line5144"></span>        }  // 2018-09-06: End of search for 117=THE.
<span id="line5145"></span>    }  // 2018-09-06: End of search loop from "vault" back to zero.
<span id="line5146"></span>    Speech();  // 2018-09-06: speak the word starting at the "aud" time. 
<span id="line5147"></span>    return;  // 2018-09-06: skip the rest of EnArticle()
<span id="line5148"></span>  }  // 2018-09-06: end of test for need to say "THE".
<span id="line5149"></span>  usn = (usn + 1);  // 2018-09-04: increment the upstream-idea rotation number.
<span id="line5150"></span>  if (usx &gt; 0 &amp;&amp; usn==1) us1 = usx; // 2018-09-05: transfer the noun concept. 
<span id="line5151"></span>  if (usx &gt; 0 &amp;&amp; usn==2) us2 = usx; // 2018-09-04: transfer the noun concept. 
<span id="line5152"></span>  if (usx &gt; 0 &amp;&amp; usn==3) us3 = usx; // 2018-09-04: transfer the noun concept. 
<span id="line5153"></span>  if (usx &gt; 0 &amp;&amp; usn==4) us4 = usx; // 2018-09-04: transfer the noun concept. 
<span id="line5154"></span>  if (usx &gt; 0 &amp;&amp; usn==5) us5 = usx; // 2018-09-04: transfer the noun concept. 
<span id="line5155"></span>  if (usx &gt; 0 &amp;&amp; usn==6) us6 = usx; // 2018-09-04: transfer the noun concept. 
<span id="line5156"></span>  if (usx &gt; 0 &amp;&amp; usn==7) us7 = usx; // 2018-09-04: transfer the noun concept. 
<span id="line5157"></span>  if (usn &gt; 6) usn = 1;  // 2018-09-04: after usn=7 rotate back to usn=1
<span id="line5158"></span>  if (subjnum==1 &amp;&amp; qv2psi==800) {  // 2018-02-04: Deal with "I AM...."
<span id="line5159"></span>    for (i=vault; i&gt;midway; i--) {  // 2018-02-04: search in "vault" for reliability.
<span id="line5160"></span>      Psy[i].psyExam(); // 2018-02-04: inspect the Psy concept flag-panel 
<span id="line5161"></span>      if (anset==0) {  // 2018-02-04: if no vowel at start of noun...
<span id="line5162"></span>        if (psi1 == 101) {  // 2018-02-04: if 101=A is found;
<span id="line5163"></span>          aud = psi20;  // 2019-07-21: "A" recall-vector for Speech()
<span id="line5164"></span>          break;  // 2018-02-04: one auditory engram is enough.
<span id="line5165"></span>        }  // 2018-02-04: End of search for 101=A
<span id="line5166"></span>      }  // 2018-02-04: end of test for vowel-flag "anset".
<span id="line5167"></span>      if (anset &gt; 0) {  // 2018-02-04: if vowel at start of noun...
<span id="line5168"></span>        if (psi1 == 102) {  // 2018-02-04: if 102=AN is found;
<span id="line5169"></span>          aud = psi20;  // 2019-07-31: "AN" recall-vector for Speech()
<span id="line5170"></span>          anset = 0;  // 2018-02-04: reset to zero for safety. 
<span id="line5171"></span>          break;  // 2018-02-04: one auditory engram is enough.
<span id="line5172"></span>        }  // 2018-02-04: End of search for 102=AN;
<span id="line5173"></span>      }  // 2018-02-04: end of test for positive vowel-flag "anset".
<span id="line5174"></span>    }  // 2018-02-04: end of loop searching for "A" or "AN".
<span id="line5175"></span>    Speech();  // 2018-02-04: speak the word starting at the "aud" time. 
<span id="line5176"></span>    return;  // 2018-06-16: skip the rest of EnArticle()
<span id="line5177"></span>  }  // 2018-02-04: end of test for singular subject with 800=BE verb.
<span id="line5178"></span>  if (nphrnum == 1) {  // 2018-09-05: check also for OutBuffer b16 != "S"? 
<span id="line5179"></span>    for (i=vault; i&gt;midway; i--) {  // 2018-09-05: search in "vault" for reliability.
<span id="line5180"></span>      Psy[i].psyExam(); // 2018-09-05: inspect the Psy concept flag-panel 
<span id="line5181"></span>      if (anset==0) {  // 2018-09-05: if no vowel at start of noun...
<span id="line5182"></span>        if (psi1 == 101) {  // 2018-09-05: if 101=A is found;
<span id="line5183"></span>          aud = psi20;  // 2019-07-31: "A" recall-vector for Speech()
<span id="line5184"></span>          break;  // 2018-09-05: one auditory engram is enough.
<span id="line5185"></span>        }  // 2018-09-05: End of search for 101=A
<span id="line5186"></span>      }  // 2018-09-05: end of test for vowel-flag "anset".
<span id="line5187"></span>      if (anset &gt; 0) {  // 2018-09-05: if vowel at start of noun...
<span id="line5188"></span>        if (psi1 == 102) {  // 2018-09-05: if 102=AN is found;
<span id="line5189"></span>          aud = psi20;  // 2019-07-31: "AN" recall-vector for Speech()
<span id="line5190"></span>          anset = 0;  // 2018-09-05: reset to zero for safety. 
<span id="line5191"></span>          break;  // 2018-09-05: one auditory engram is enough.
<span id="line5192"></span>        }  // 2018-09-05: End of search for 102=AN;
<span id="line5193"></span>      }  // 2018-09-05: end of test for positive vowel-flag "anset".
<span id="line5194"></span>    }  // 2018-09-05: end of loop searching for "A" or "AN".
<span id="line5195"></span>    Speech();  // 2018-09-05: speak the word starting at the "aud" time. 
<span id="line5196"></span>  }  // 2018-09-05: end of test of grammatical number of noun.
<span id="line5197"></span>}  // 2019-07-31: EnArticle(); return to EnNounPhrase().
<span id="line5198"></span>
<span id="line5199"></span>
<span id="line5200"></span>function EnAdverb() {  // http://ai.neocities.org/EnAdverb.html
<span id="line5201"></span>  // 2019-03-03: stub only; needs full implementation.
<span id="line5202"></span>} // 2019-03-03: EnAdverb() returns to EnVerbPhrase();
<span id="line5203"></span>
<span id="line5204"></span>
<span id="line5205"></span>function EnAdjective() {  // http://ai.neocities.org/EnAdjective.html
<span id="line5206"></span>  if (tdj &gt; 0) {  // 2019-10-12: positive time-of-adjective?
<span id="line5207"></span>    Psy[tdj].psyExam(); // 2019-10-12: inspect flag-panel of adjective.
<span id="line5208"></span>    if (psi20 &gt; 0) aud = psi20; Speech();  // 2019-10-12: speak the preposition.
<span id="line5209"></span>    if (psi20 &gt; 0) aud = 0;  // 2019-10-12: reset to prevent carry-over. 
<span id="line5210"></span>    if (psi20 &gt; 0) audjuste = 0;  // 2019-10-12: reset to prevent carry-over. 
<span id="line5211"></span>    tdj = 0;   // 2019-10-12: reset to prevent unwarranted call to EnAdjective() 
<span id="line5212"></span>    etc = 0;   // 2019-10-12: suppress use of a conjunction.
<span id="line5213"></span>  }  // 2019-10-12: end of test for a positive time-of-adjective "tdj".
<span id="line5214"></span>} // 2019-10-12: EnAdjective() returns to EnNounPhrase();
<span id="line5215"></span>
<span id="line5216"></span>
<span id="line5217"></span>function SpreadAct() {  // http://ai.neocities.org/SpreadAct.html
<span id="line5218"></span>  PsiDecay();  // 2018-01-23: reduce conceptual activation in general. 
<span id="line5219"></span>  // 2018-11-13: SpreadAct, called from EnVerbPhrase, activates a prepositional phrase.
<span id="line5220"></span>  if (wherecon == 0) {  // 2018-11-13: if not answering a where-query...
<span id="line5221"></span>    if (tselp &gt; 0 &amp;&amp; prep &gt; 0 &amp;&amp; wherecon == 0) {  // 2018-11-13: fpr prep. phrase
<span id="line5222"></span>      Psy[tselp].psyExam();  // 2018-11-13: Examine the Psy concept-array.
<span id="line5223"></span>      tselo = psi14; // 2019-07-31: time of selection of object of preposition.
<span id="line5224"></span>      aud = psi20;   // 2019-07-31: fetch the "aud" recall-tag for sake of Speech()
<span id="line5225"></span>      if (aud &gt; 0) Speech();  // 20-18-11-13: speak the preposition.
<span id="line5226"></span>//    EnArticle();  // 2018-11-13: say "A" or "THE" before object of preposition. 
<span id="line5227"></span>//    EnArticle();  // 2019-09-21: commenting out for the sake of troubleshooting.
<span id="line5228"></span>      Psy[tselo].psyExam();  // 2018-11-13: examine concept-array at time of object.
<span id="line5229"></span>      aud = psi20;  // 2019-07-31: fetch the "aud" tag for the sake of Speech()
<span id="line5230"></span>      if (aud &gt; 0) Speech();  // 2018-11-13: speak the object of the preposition.
<span id="line5231"></span>      aud = 0;    // 2018-11-13: reset for safety. 
<span id="line5232"></span>      prep = 0;   // 2018-11-13: reset for safety. 
<span id="line5233"></span>      tselo = 0;  // 2018-11-13: reset for safety. 
<span id="line5234"></span>      tselp = 0;  // 2018-11-13: reset for safety. 
<span id="line5235"></span>    }  // 2018-11-13: end of test for time-point and concept-number of preposition.
<span id="line5236"></span>  }  // 2018-11-13: end of test for a positive "wherecon".
<span id="line5237"></span>
<span id="line5238"></span>  // 2018-10-28: segment of SpreaAct() responds to where-queries.
<span id="line5239"></span>  if (wherecon==1) {  // 2018-10-28: 
<span id="line5240"></span>    if (qv1psi &gt; 0) {  // 2018-10-28: if there is an activand subject...
<span id="line5241"></span>      for (i=tpu; i&gt;midway; i--) {  // 2018-10-28: search backwards in time.
<span id="line5242"></span>        Psy[i].psyExam(); // 2018-01-23: examine the Psy concept array...
<span id="line5243"></span>        if (psi1 == qv1psi &amp;&amp; psi14 &gt; 0) {  // 2019-07-31: require verblock.
<span id="line5244"></span>          if (psi1 == qv1psi &amp;&amp; psi11 == qv2psi) {  // 2019-07-31: if correct verb
<span id="line5245"></span>            psi3 = (psi3 + 256);  // 2018-10-28: impose an overriding activation.
<span id="line5246"></span>            Psy[i] = new  // 2018-10-28: inserting [psi3]act with higher activation: 
<span id="line5247"></span>            psyNode(psi0,psi1,psi2,psi3,psi4,psi5,psi6,
<span id="line5248"></span>            psi7,psi8,psi9,psi10,psi11,psi12,psi13,
<span id="line5249"></span>            psi14,psi15,psi16,psi17,psi18,psi19,psi20); // 2019-07-31: expanded flag-panel
<span id="line5250"></span>          }  // 2018-10-28: end of test for finding both subject and verb of query.
<span id="line5251"></span>        }  // 2018-10-28: end of test for presence of a psi13 tkb verblock.
<span id="line5252"></span>      }  // 2018-10-28: end of (for loop) searching for qv1psi subject concept.
<span id="line5253"></span>    }  // 2018-10-28: end of test for a positive qv1psi. 
<span id="line5254"></span>    return;  // 2018-10-28: skip the remainder of SpreadAct()
<span id="line5255"></span>  }  // 2018-10-28: end of test for a positive "wherecon".
<span id="line5256"></span>
<span id="line5257"></span>  // 2018-10-02: segment of SpreaAct() responds to WHO-queries.
<span id="line5258"></span>  if (qucon &gt; 0 &amp;&amp; qvdocon == 0) {  // 2018-01-23: only for 800=BE who-queries.
<span id="line5259"></span>    if (qv1psi &gt; 0) {  // 2018-01-28: if there is an activand subject...
<span id="line5260"></span>      for (i=tpu; i&gt;midway; i--) {  // 2018-01-23: search backwards in time.
<span id="line5261"></span>        Psy[i].psyExam(); // 2018-01-23: examine the Psy concept array...
<span id="line5262"></span>        if (psi1 == qv1psi &amp;&amp; psi14 &gt; 0) {  // 2019-07-31: require verblock.
<span id="line5263"></span>          if (psi1 == qv1psi &amp;&amp; psi11 == qv2psi) {  // 2019-07-31: if correct verb
<span id="line5264"></span>            psi3 = (psi3 + 64);  // 2018-01-23: impose an overriding activation.
<span id="line5265"></span>            Psy[i] = new  // 2018-01-23: inserting [psi3]act with higher activation: 
<span id="line5266"></span>            psyNode(psi0,psi1,psi2,psi3,psi4,psi5,psi6,
<span id="line5267"></span>            psi7,psi8,psi9,psi10,psi11,psi12,psi13,
<span id="line5268"></span>            psi14,psi15,psi16,psi17,psi18,psi19,psi20); // 2019-07-31: flag-panel
<span id="line5269"></span>          }  // 2018-01-23: end of test for finding both subject and verb of query.
<span id="line5270"></span>        }  // 2018-01-23: end of test for presence of a psi13 tkb verblock.
<span id="line5271"></span>      }  // 2018-01-23: end of (for loop) searching for qv1psi subject concept.
<span id="line5272"></span>    }  // 2018-01-23: end of test for a positive qv1psi. 
<span id="line5273"></span>    qvdocon = 0;  // 2018-06-16: TEST
<span id="line5274"></span>    return;  // 2018-06-05: skip the remainder of SpreadAct()
<span id="line5275"></span>  }  // 2018-01-23: end of test of qucon to indicate processing of a query.
<span id="line5276"></span>
<span id="line5277"></span>  // 2018-10-02: segment of SpreaAct() responds to WHAT-think-queries.
<span id="line5278"></span>  if (whatcon &gt; 0 &amp;&amp; qv2psi==886) {  // 2018-11-28: for a what-think query... 
<span id="line5279"></span>    // alert("SpreadAct: qv2psi= "+qv2psi);  // 2018-10-01: TEST
<span id="line5280"></span>  }  // 2018-10-01: end of test of whatcon so as to answer a what-think query.
<span id="line5281"></span>
<span id="line5282"></span>  // 2018-10-02: segment of SpreaAct() responds to WHAT-queries
<span id="line5283"></span>  if (whatcon &gt; 0) {  // 2018-10-01: for a what-query... 
<span id="line5284"></span>    dunnocon = 1;  // 2018-10-01: set positive so long as no answer emerges.
<span id="line5285"></span>    for (i=tpu; i&gt;midway; i--) {  // 2018-10-02: search backwards in time.
<span id="line5286"></span>      Psy[i].psyExam(); //  2018-10-02: examine conceptual Psy array;
<span id="line5287"></span>      if (psi1==qv1psi &amp;&amp; psi11==qv2psi) {  // 2019-07-31: subj. with query-verb?
<span id="line5288"></span>        dunnocon = 0;  // 2018-02-10: even one correct answer disables dunnocon.
<span id="line5289"></span>        psi3 = (psi3 + 64);  // 2018-10-02: impose activation on the found subject.
<span id="line5290"></span>        Psy[i] = new  // 2018-10-02: inserting [psi3]act with higher activation: 
<span id="line5291"></span>        psyNode(psi0,psi1,psi2,psi3,psi4,psi5,psi6,
<span id="line5292"></span>        psi7,psi8,psi9,psi10,psi11,psi12,psi13,
<span id="line5293"></span>        psi14,psi15,psi16,psi17,psi18,psi19,psi20); // 2019-07-31: expanded panel.
<span id="line5294"></span>      }  // 2018-10-02: end of test for subject and verb answer-concepts. 
<span id="line5295"></span>    }  // 2018-10-02: end of (for loop) searching for qv1psi subject-noun concept.
<span id="line5296"></span>    catsubj = qv1psi;  // 2019-02-12: chain-subject to be omitted for sake of "AND"
<span id="line5297"></span>    catverb = qv2psi;  // 2019-02-12: chain-verb to be omitted for sake of "AND".
<span id="line5298"></span>    return;  // 2018-10-02: skip the remainder of SpreadAct()
<span id="line5299"></span>  }  // 2018-10-01: end of test of whatcon so as to answer a what-query.
<span id="line5300"></span>
<span id="line5301"></span>  if (whatcon &gt; 0) {  // 2018-01-23: for a what-query... 
<span id="line5302"></span>    for (i=tpu; i&gt;midway; i--) {  // 2018-01-23: search backwards in time.
<span id="line5303"></span>      if (psi1==qv1psi &amp;&amp; psi14==0 &amp;&amp; qv2psi==886) {  // 2019-07-31: if subj of THINK query     
<span id="line5304"></span>        psi3 = (psi3 + 64);   // 2018-06-11: impose activation on the found subject.
<span id="line5305"></span>        Psy[i] = new  // 2018-05-13: inserting [psi3]act with higher activation: 
<span id="line5306"></span>        psyNode(psi0,psi1,psi2,psi3,psi4,psi5,psi6,
<span id="line5307"></span>        psi7,psi8,psi9,psi10,psi11,psi12,psi13,
<span id="line5308"></span>        psi14,psi15,psi16,psi17,psi18,psi19,psi20); // 2019-07-31: expanded flag-panel
<span id="line5309"></span>      }  // 2018-06-03: end of test for WHAT... 886=THINK.  
<span id="line5310"></span>      if (psi1==886 &amp;&amp; qv2psi==886) {  // 2018-11-28: if 886=THINK query...
<span id="line5311"></span>        psi3 = (psi3 + 64);   // 2018-06-11: impose activation on the found verb.
<span id="line5312"></span>        Psy[i] = new  // 2018-05-13: inserting [psi3]act with higher activation: 
<span id="line5313"></span>        psyNode(psi0,psi1,psi2,psi3,psi4,psi5,psi6,
<span id="line5314"></span>        psi7,psi8,psi9,psi10,psi11,psi12,psi13,
<span id="line5315"></span>        psi14,psi15,psi16,psi17,psi18,psi19,psi20); // 2019-07-31: expanded flag-panel.
<span id="line5316"></span>      }  // 2018-11-28: end of test for WHAT... 886=THINK. 
<span id="line5317"></span>
<span id="line5318"></span>    }  // 2018-01-23: end of (for loop) searching for qv1psi subject-noun concept.
<span id="line5319"></span>    for (i = idle; i</span><span>&lt;1</span><span>000; i++) {  // 2018-01-23: delay for user to see question
<span id="line5320"></span>      if (i &gt; 1) { apb = "Ask the AI what it thinks!"; Voice() }  // 2018-05-13
<span id="line5321"></span>    }  // 2018-01-23: end of delay for TEST
<span id="line5322"></span>    return;  // 2018-06-05: skip the remainder of SpreadAct()
<span id="line5323"></span>  }  // 2018-01-23: end of test of whatcon so as to answer a what-query.
<span id="line5324"></span>
<span id="line5325"></span>  if (qvdocon &gt; 0) {  // 2018-01-23: for a who+verb+dir.object query...
<span id="line5326"></span>    dunnocon = 1;  // 2018-01-23: set positive so long as no answer emerges.
<span id="line5327"></span>    for (i=tpu; i&gt;midway; i--) {  // 2018-01-23: search backwards in time.
<span id="line5328"></span>      Psy[i].psyExam(); // 2018-01-23: inspect the Psy concept flag-panel 
<span id="line5329"></span>      if (psi1==qv2psi) {  // 2018-12-23: if query-verb is found...
<span id="line5330"></span>        if (psi10 &gt; 0)  {  // 2018-12-23: if positive "pre" exists...
<span id="line5331"></span>          if (psi11==qv4psi) {  // 2019-07-31: if "seq" is direct object...
<span id="line5332"></span>            if (psi14&gt;0) {  // 2019-07-31: if positive "tkb" for direct object...
<span id="line5333"></span>              qv2num = psi8;  // 2018-01-23: latch onto psi8 "num" of the response-verb.
<span id="line5334"></span>              qv1psi = psi10;  // 2018-01-23: latch onto psi10 "pre" as the subject (answer)
<span id="line5335"></span>              psi3 = (psi3 + 64);   // 2018-06-11: somewhat activate the answer-concept
<span id="line5336"></span>              Psy[i] = new  // 2018-01-23: inserting [psi3]act with higher activation: 
<span id="line5337"></span>              psyNode(psi0,psi1,psi2,psi3,psi4,psi5,psi6,
<span id="line5338"></span>              psi7,psi8,psi9,psi10,psi11,psi12,psi13,
<span id="line5339"></span>              psi14,psi15,psi16,psi17,psi18,psi19,psi20); // 2019-07-31: flag-panel
<span id="line5340"></span>            }  // 2018-12-23: end of test for specific time-point of direct object. 
<span id="line5341"></span>          }  // 2018-12-23: end of test for presence of direct-object "seq".
<span id="line5342"></span>        }  // 2018-12-23: end of test for postive "pre" or subject of query-verb.
<span id="line5343"></span>      }  // 2018-12-23: end of test for query-verb qv2psi.
<span id="line5344"></span>    }  // 2018-01-23: end of (for loop) searching for qv2psi verb concept.
<span id="line5345"></span>    qucon = 0;  // 2018-01-23: prevent infinite loop?
<span id="line5346"></span>    for (i=tpu; i&gt;midway; i--) {  // 2018-01-23: search backwards in time.
<span id="line5347"></span>      Psy[i].psyExam(); // 2018-01-23: inspect the Psy concept flag-panel 
<span id="line5348"></span>      if (psi1==qv1psi) {  // 2018-12-23: if subject is found...
<span id="line5349"></span>        if (psi11==qv2psi) {  // 2019-07-31: if "seq" is the query-verb...
<span id="line5350"></span>          psi3 = (psi3 + 320);  // 2018-12-23: impose an overriding activation.
<span id="line5351"></span>          psi3 = (psi0 + psi3); // 2018-12-23: favor any engram with high "tru" value. 
<span id="line5352"></span>          Psy[i] = new  // 2018-01-23: inserting [psi3]act with higher activation: 
<span id="line5353"></span>          psyNode(psi0,psi1,psi2,psi3,psi4,psi5,psi6,
<span id="line5354"></span>          psi7,psi8,psi9,psi10,psi11,psi12,psi13,
<span id="line5355"></span>          psi14,psi15,psi16,psi17,psi18,psi19,psi20); // 2019-07-31: expanded panel.
<span id="line5356"></span>          dunnocon = 0;  // 2018-12-23: even one correct answer disables "dunnocon".
<span id="line5357"></span>        }  // 2018-12-23: end of test for query-verb as "seq" of the query-subject.
<span id="line5358"></span>      }  // 2018-01-23: end of test for subject answer-concept
<span id="line5359"></span>    }  // 2018-01-23: end of (for loop) searching for the subject answer-concept.
<span id="line5360"></span>    qvdocon = 0;  // 2018-06-16: reset for safety. 
<span id="line5361"></span>    return;  // 2018-06-05: skip the remainder of SpreadAct()
<span id="line5362"></span>  }  // 2018-01-23: end of test for who+verb+direct-object query condition. 
<span id="line5363"></span>
<span id="line5364"></span>  if (qviocon &gt; 0) {  // 2018-01-23: prepare for indirect-object queries...
<span id="line5365"></span>//   alert("SpreadAct has been called.");  // 2018-01-23: for future implementation
<span id="line5366"></span>  }   // 2018-01-23: end of test for who+verb+indirect-object query condition. 
<span id="line5367"></span>
<span id="line5368"></span>
<span id="line5369"></span>  if (nucon &gt; 0) {  // 2018-01-23: if there is a new-concept condition...
<span id="line5370"></span>    moot = 1;  // 2018-01-23: prevent associative tags within question.
<span id="line5371"></span>    output = "";  // 2018-01-23: clear the display of output. 
<span id="line5372"></span>    for (i=tpu; i&gt;midway; i--) {  // 2018-01-23: search backwards in time.
<span id="line5373"></span>      Psy[i].psyExam(); // 2018-01-23: inspect the Psy concept flag-panel 
<span id="line5374"></span>      if (psi1 == 781 &amp;&amp; psi14 == 0) {  // 2019-07-31: WHAT without verblock.
<span id="line5375"></span>        aud = psi20;  // 2019-07-31: fetch auditory recall tag for Speech()
<span id="line5376"></span>        Speech();  // 2018-01-23: speak the 781=WHAT
<span id="line5377"></span>        break;  // 2018-01-23: one utterance is enough.
<span id="line5378"></span>      }  // 2018-01-23: end of test for 781=WHAT with no overriding verblock.
<span id="line5379"></span>    }  // 2018-01-23: end of (for loop) searching for 781=WHAT concept.
<span id="line5380"></span>    if (b1 == "S") qusubnum = 2;  // 2019-07-31: if terminal "-S" in OutBuffer
<span id="line5381"></span>    for (i=vault; i&gt;midway; i--) {  // 2018-01-23: search backwards in "vault"
<span id="line5382"></span>      Psy[i].psyExam(); // 2018-01-23: inspect the Psy concept flag-panel 
<span id="line5383"></span>      if (qusubnum == 0) qusubnum = 1;  // 2018-10-03: default to singular.
<span id="line5384"></span>      if (psi1==800 &amp;&amp; psi7==3 &amp;&amp; psi8==qusubnum) {  // 2018-10-03
<span id="line5385"></span>        aud = psi20;  // 2019-07-31: fetch auditory recall tag for Speech()
<span id="line5386"></span>        Speech();  // 2018-01-23: speak the 800=BE
<span id="line5387"></span>        break;  // 2018-01-23: one utterance is enough.
<span id="line5388"></span>      }  // 2018-01-23: end of test for 800=BE
<span id="line5389"></span>    }  // 2018-01-23: end of (for loop) searching for correct form of 800=BE.
<span id="line5390"></span>    for (i=t; i&gt;midway; i--) {    // 2018-10-03: must include new input.
<span id="line5391"></span>      Psy[i].psyExam(); // 2018-01-23: inspect the Psy concept flag-panel 
<span id="line5392"></span>      if (psi1 == qusub) {  // 2018-01-23: look for the new concept.
<span id="line5393"></span>        aud = psi20;  // 2019-07-31: fetch auditory recall tag for Speech()
<span id="line5394"></span>        Speech();  // 2018-01-23: speak the new concept
<span id="line5395"></span>        qusub = 0;  // 2018-06-11: reset for safety.
<span id="line5396"></span>        break;  // 2018-01-23: one utterance is enough.
<span id="line5397"></span>      }  // 2018-01-23: end of test for engram of new concept.
<span id="line5398"></span>    }  // 2018-01-23: end of (for loop) searching for the new concept.
<span id="line5399"></span>    Voice();  // 2018-09-21: makes the question appear on-screen.
<span id="line5400"></span>    moot = 0;  // 2018-01-23: finish preventing associative tags within question.
<span id="line5401"></span>    return;  // 2018-06-05: skip the remainder of SpreadAct()
<span id="line5402"></span>  }  // 2018-01-23: end of test of nucon so as to cause asking of a question. 
<span id="line5403"></span>
<span id="line5404"></span>  if (actpsi &gt; 0 &amp;&amp; qucon == 0) {  // 2018-01-12: not with who-queries 
<span id="line5405"></span>    for (i=tpu; i&gt;midway; --i) {  // 2018-01-12: search backward from tpu
<span id="line5406"></span>      Psy[i].psyExam(); // 2018-01-12: examine the Psy concept array...
<span id="line5407"></span>      if (psi1 == actpsi &amp;&amp; psi11 &gt; 0) seqpsi = psi11; // 2019-07-131: if seq, seqpsi
<span id="line5408"></span>      if (psi1 ==  actpsi &amp;&amp; psi14 &gt; 0) {  // 2019-07-31: require verblock.
<span id="line5409"></span>      apb = "SpreadAct spreads activation from concept #"+psi1+" to a related idea.";
<span id="line5410"></span>      Voice();  // 2018-12-05: Show the user what SpreadAct() is doing.
<span id="line5411"></span>        psi3 = (psi3 + 256);  // 2018-12-06: impose even higher activation.
<span id="line5412"></span>        Psy[i] = new  // 2018-06-11: moving "new" up from next line: 
<span id="line5413"></span>        psyNode(psi0,psi1,psi2,psi3,psi4,psi5,psi6,
<span id="line5414"></span>        psi7,psi8,psi9,psi10,psi11,psi12,psi13,
<span id="line5415"></span>        psi14,psi15,psi16,psi17,psi18,psi19,psi20); // 2019-07-31: expanded flag-panel
<span id="line5416"></span>      } // 2018-01-12: end of test requiring tkb verblock.
<span id="line5417"></span>    }  // 2018-01-12: end of (for loop) searching for actpsi concept.
<span id="line5418"></span>  }  // 2018-01-12: end of test for a positive actpsi.
<span id="line5419"></span>  qvdocon = 0;  // 2018-06-16: reset for safety. 
<span id="line5420"></span>}  // 2019-07-31: SpreadAct() returns to EnVerbPhrase() or EnThink().
<span id="line5421"></span>
<span id="line5422"></span>
<span id="line5423"></span>function EnPrep() {  // http://ai.neocities.org/EnPrep.html
<span id="line5424"></span>  if (tpr &gt; 0) {  // 2019-08-04: positive time-of-preposition?
<span id="line5425"></span>    Psy[tpr].psyExam(); // 2019-08-04: inspect the Psy concept flag-panel
<span id="line5426"></span>    if (psi14&gt;0) tkb=psi14; // alert(" tkb= "+tkb);; // 2019-08-04
<span id="line5427"></span>    if (psi20 &gt; 0) aud = psi20; Speech();  // 2019-08-04: speak the preposition.
<span id="line5428"></span>    if (psi20 &gt; 0) aud = 0;  // 2019-09-20: reset to prevent carry-over. 
<span id="line5429"></span>    if (psi20 &gt; 0) audjuste = 0;  // 2019-09-20: reset to prevent carry-over. 
<span id="line5430"></span>    if (psi14&gt;0) tkb=psi14; // 2019-08-04 
<span id="line5431"></span>    tpr = 0;   // 2019-09-22: reset to prevent unwarranted call to EnPrep() 
<span id="line5432"></span>    etc = 0;   // 2019-09-22: suppress use of a conjunction.
<span id="line5433"></span>//  return;  // 2019-09-20: abandon rest of module. 
<span id="line5434"></span>  }  // 2019-08-04: end of test for positive time-ofpreposition.
<span id="line5435"></span>  if (tvpr &gt; 0) {  // 2019-10-24: positive time-of-verb-preposition?
<span id="line5436"></span>    Psy[tvpr].psyExam(); // 2019-10-24: inspect the Psy concept flag-panel
<span id="line5437"></span>    if (psi14&gt;0) tkb=psi14; // 2019-10-24: intercept "tkb" for obj. of preposition
<span id="line5438"></span>    if (psi20 &gt; 0) aud = psi20; Speech();  // 2019-10-24: speak the preposition.
<span id="line5439"></span>    tvpr = 0;  // 2019-10-24: prevent carry-over.
<span id="line5440"></span>  }  // 2019-10-24: end of test for preposition linked to verb-phrase
<span id="line5441"></span>  EnArticle();  // 2019-10-24: say "A" or "THE" before object of preposition. 
<span id="line5442"></span>  if (px1&gt;0) {  // 2019-09-20: object of preposition?
<span id="line5443"></span>    Psy[px1].psyExam(); // 2019-09-20: inspect @psy knowledge-nodes.
<span id="line5444"></span>    if (psi20 &gt; 0) aud = psi20;  // 2019-09-20: obtain recall-vector.
<span id="line5445"></span>    if (aud &gt; 0) Speech();  // 2019-09-20: speak the object of the preposition.
<span id="line5446"></span>    return;  // 2019-09-20: abandon rest of module.
<span id="line5447"></span>  }  // 2019-09-20: end of test for "px1" object of preposition. 
<span id="line5448"></span>  px1 = 0;  // 2019-09-20: reset for safety.
<span id="line5449"></span>  if (prep &gt; 0 &amp;&amp; aud &gt; 0) Speech();  // 2019-09-21: reinstating  
<span id="line5450"></span>  if (tkb&gt;0) {  // 2019-10-24: object of preposition?
<span id="line5451"></span>    Psy[tkb].psyExam(); // 2019-10-24: inspect @psy knowledge-nodes.
<span id="line5452"></span>    if (psi20 &gt; 0) aud = psi20;  // 2019-10-24: obtain recall-vector.
<span id="line5453"></span>    if (aud &gt; 0) Speech();  // 2019-10-24: speak the object of the preposition.
<span id="line5454"></span>//  return;  // 2019-10-24: abandon rest of module.
<span id="line5455"></span>  }  // 2019-10-24: end of test for "px1" object of preposition. 
<span id="line5456"></span>  objprep = 0;   // 2019-09-22: reset to prevent carry-over.
<span id="line5457"></span>  prep = 0;      // 2019-09-20: reset to avoid carry-over.
<span id="line5458"></span>  prepgen = 0;   // 2018-10-26: reset to avoid carry-over. 
<span id="line5459"></span>  tselo = 0;     // 2019-09-22: reset to avoid carry-over.
<span id="line5460"></span>  tselp = 0;     // 2019-09-20: reset to avoid carry-over.
<span id="line5461"></span>  wherecon = 0;  // 2018-10-28: reset to avoid carry-over.
<span id="line5462"></span>}  // 2019-09-22: EnPrep(); return to EnNounPhrase() or EnVerbPhrase();
<span id="line5463"></span>
<span id="line5464"></span>
<span id="line5465"></span>function EnPronoun() {  // http://ai.neocities.org/EnPronoun.html
<span id="line5466"></span>}  // 2019-02-18: EnPronoun() returns to EnNounPhrase();
<span id="line5467"></span>
<span id="line5468"></span>
<span id="line5469"></span>function EnAuxVerb() {  // http://ai.neocities.org/EnAuxverb.html
<span id="line5470"></span>  if (subjnum==0 &amp;&amp; snu&gt;0) subjnum = snu;  // 2019-10-25: insurance
<span id="line5471"></span>  if (subjnum==0 &amp;&amp; prsn==3) subjnum = 1;  // 2019-10-25: a guess.
<span id="line5472"></span>  if (subjnum==0 &amp;&amp; prsn != 3) subjnum = 1; // 2019-10-25: "DO"-form
<span id="line5473"></span> tdo = 0;  // 2018-07-12: prevent carry-over. 
<span id="line5474"></span> if (auxverb==818) {  // 2018-11-28: 818=DO; 
<span id="line5475"></span>  if (subjnum == 1 &amp;&amp; prsn == 1) {  // 2018-01-26: first person singular? 
<span id="line5476"></span>    for (i = vault; i&gt;midway; i--) {  // 2018-01-26: "vault" is reliable.
<span id="line5477"></span>      Psy[i].psyExam(); //  2018-01-26: examine conceptual Psy array;
<span id="line5478"></span>      if (psi1==818 &amp;&amp; psi8==1 &amp;&amp; psi7==1) {  // 2018-11-28: 818=DO; 
<span id="line5479"></span>        aud = psi20;  // 2019-07-31: auditory recall-vector; 
<span id="line5480"></span>        break;  // 2018-01-26: one example is enough.
<span id="line5481"></span>      }  // 2018-01-26: end of test for singular #818=DO; 
<span id="line5482"></span>    }  // 2018-01-26: end of backwards loop; 
<span id="line5483"></span>    Speech();  // 2018-01-26:  
<span id="line5484"></span>  }  // 2018-01-26: end of test for 1st person singular; 
<span id="line5485"></span>  if (subjnum == 1 &amp;&amp; prsn == 2) {  // 2018-01-26: second person singular? 
<span id="line5486"></span>    for (i = vault; i&gt;midway; i--) {  // 2018-01-26: "vault" is reliable.
<span id="line5487"></span>      Psy[i].psyExam(); //  2018-01-26: examine conceptual Psy array;
<span id="line5488"></span>      if (psi1==818 &amp;&amp; psi8==1 &amp;&amp; psi7==2) {  // 2018-11-28: 818=DO; 
<span id="line5489"></span>        aud = psi20;  // 2019-07-31: auditory recall-vector; 
<span id="line5490"></span>        break;  // 2018-01-26:
<span id="line5491"></span>      }  // 2018-11-28: end of test for singul;ar 818=DO; 
<span id="line5492"></span>    }  // 2018-01-26: end of backwards loop; 
<span id="line5493"></span>    Speech();  // 2018-01-26: 
<span id="line5494"></span>  }  // 2018-01-26: end of test for 2nd person singular; 
<span id="line5495"></span>  if (subjnum == 1 &amp;&amp; prsn == 3) {  // 2018-01-26: singular num(ber)? 
<span id="line5496"></span>    for (i = vault; i&gt;midway; i--) {  // 2018-01-26: "vault" is reliable.
<span id="line5497"></span>      Psy[i].psyExam(); //  2018-01-26: examine conceptual Psy array;
<span id="line5498"></span>      if (psi1==818 &amp;&amp; psi8==1 &amp;&amp; psi7==3) {  // 2018-11-28: 818=DO; 
<span id="line5499"></span>        aud = psi20;  // 2019-07-31: auditory recall-vector; 
<span id="line5500"></span>        break;  // 2018-01-26: 
<span id="line5501"></span>      }  // 2018-11-28: end of test for 818=DOES; 
<span id="line5502"></span>    }  // 2018-01-26: end of backwards loop; 
<span id="line5503"></span>    Speech();  // 2018-01-26
<span id="line5504"></span>  }  // 2018-01-26: end of test for 3rd person singular;  
<span id="line5505"></span>  if (subjnum == 2 &amp;&amp; prsn == 1) {  // 2018-01-26: plural num(ber)? 
<span id="line5506"></span>    for (i = vault; i&gt;midway; i--) {  // 2018-01-26: "vault" is reliable.
<span id="line5507"></span>      Psy[i].psyExam(); //  2018-01-26: examine conceptual Psy array;
<span id="line5508"></span>      if (psi1==818 &amp;&amp; psi8==2 &amp;&amp; psi7==1) {  // 2018-11-28: 818=DO; 
<span id="line5509"></span>        aud = psi20;  // 2019-07-31: auditory recall-vector; 
<span id="line5510"></span>        break;  // 2018-01-26:
<span id="line5511"></span>      }  // 2018-11-28: end of test for plural 818=DO; 
<span id="line5512"></span>    }  // 2018-01-26: end of backwards loop; 
<span id="line5513"></span>    Speech();  // 2018-01-26:
<span id="line5514"></span>  }  // 2018-01-26: end of test for 1st person plural; 
<span id="line5515"></span>  if (subjnum == 2 &amp;&amp; prsn == 2) {  // 2018-01-26: plural num(ber)? 
<span id="line5516"></span>    for (i = vault; i&gt;midway; i--) {  // 2018-01-26: "vault" is reliable.
<span id="line5517"></span>      Psy[i].psyExam(); //  2018-01-26: examine conceptual Psy array;
<span id="line5518"></span>      if (psi==818 &amp;&amp; psi8==2 &amp;&amp; psi7==2) {  // 2018-11-28: 818=DO; 
<span id="line5519"></span>        aud = psi20;  // 2019-07-31: auditory recall-vector; 
<span id="line5520"></span>        break;  // 2018-01-26: 
<span id="line5521"></span>      }  // 2018-11-28: end of test for plural 818=DO; 
<span id="line5522"></span>    }  // 2018-01-26: end of backwards loop; 
<span id="line5523"></span>    Speech();  // 2018-01-26:
<span id="line5524"></span>  }  // 2018-01-26: end of test for 2nd person plural; 
<span id="line5525"></span>  if (subjnum == 2 &amp;&amp; prsn == 3) {  // 2018-01-26: plural num(ber)? 
<span id="line5526"></span>    for (i = vault; i&gt;midway; i--) {  // 2018-01-26: "vault" is reliable.
<span id="line5527"></span>      Psy[i].psyExam(); //  2018-01-26: examine conceptual Psy array;
<span id="line5528"></span>      if (psi1==818 &amp;&amp; psi8==2 &amp;&amp; psi7==3) {  // 2018-11-28: 818=DO; 
<span id="line5529"></span>        aud = psi20;  // 2019-07-31: auditory recall-vector; 
<span id="line5530"></span>        break;  // 2018-01-26:
<span id="line5531"></span>      }  // 2018-11-28: end of test for plural 818=DO; 
<span id="line5532"></span>    }  // 2018-01-26: end of backwards loop; 
<span id="line5533"></span>    Speech();  // 2018-01-26:
<span id="line5534"></span>  }  // 2018-01-26: end of test for 3rd person plural; 
<span id="line5535"></span> }  // 2018-11-28: end of test for 818=DO auxiliary verb; 
<span id="line5536"></span>// prsn = 0;  // after auxiliary prevent verb-inflection; 17jun2015
<span id="line5537"></span>// verbprsn = 0;  // after auxiliary use infinitive verb-form; 17jun2015
<span id="line5538"></span> infincon = 1;  // 2018-01-26: after auxiliary set infinitive condition; 
<span id="line5539"></span>}  // 2019-07-31: EnAuxVerb(); return to EnVerbPhrase() or AskUser().
<span id="line5540"></span>
<span id="line5541"></span> 
<span id="line5542"></span>function AskUser() {  // http://ai.neocities.org/AskUser.html
<span id="line5543"></span>  output = "";  // 2018-01-27: blank out previous output before question;
<span id="line5544"></span>  pov = 1;  // 2018-01-25: 1=internal; 2=external;  
<span id="line5545"></span>  if (yncon==1) { // 2019-03-03: separate inference-validation from other questions.
<span id="line5546"></span>    tdo = 0;  // 2018-07-12: prevent carry-over.
<span id="line5547"></span>    quobjaud = 0;  // 2018-01-26: safety measure; 
<span id="line5548"></span>    if (posflag==7 || posflag==5) {  // 2018-01-26: noun or pronoun; 
<span id="line5549"></span>    }  // 2018-01-26: end of test of posflag; 
<span id="line5550"></span>    if (ynverb == 0) {  // 2018-01-26: ask y/n question only once; 
<span id="line5551"></span>      ynverb = quverb;  // 2018-01-26: isolate at start; 
<span id="line5552"></span>      moot = 1;  // 2018-01-26: prevent storing of "tkb" and "seq"; 
<span id="line5553"></span>      auxverb = 818;  // 2018-11-28: 818=DO as auxiliary verb; 
<span id="line5554"></span>      prsn = 3;  // 2018-10-03: assumption based on Is-A status.
<span id="line5555"></span>      EnAuxVerb();  // 2018-11-28: Say 818=DO or DOES; 
<span id="line5556"></span>      auxverb = 0;  // 2018-01-26: reset for safety; 
<span id="line5557"></span>      moot = 0;  // 2018-01-26: reset after use;
<span id="line5558"></span>     for (i = inft; i&gt;midway; i--) {  // 2018-01-26: skip silent inference; 
<span id="line5559"></span>        Psy[i].psyExam();  // 2018-01-25: examine conceptual Psy array;
<span id="line5560"></span>        if (psi1 == qusub) {  // 2018-01-25: if query-subject found; 
<span id="line5561"></span>          aud = psi20;  // 2019-07-31: assign auditory recall-tag; 
<span id="line5562"></span>          break;  // 2018-01-25: exit the loop after first find; 
<span id="line5563"></span>        }  // 2018-01-26: end of test for query-subject; 
<span id="line5564"></span>      }  // 2018-01-26: end of loop in search of qusub; 
<span id="line5565"></span>      Speech();  // 2018-01-25: say subject-word starting at "aud" value; 
<span id="line5566"></span>      if (quverb == 0) quverb = 818;  // 2018-11-28: 818=DO default; 
<span id="line5567"></span>      for (i = inft; i&gt;midway; i--) {  // 2018-01-25: skip silent inference; 
<span id="line5568"></span>        Psy[i].psyExam();  // 2018-01-25: examine Psy conceptual array;
<span id="line5569"></span>        if (psi1 == quverb &amp;&amp; psi7==0) {  // 2018-10-04: infinitive dba=0
<span id="line5570"></span>          aud = psi20;  // 2019-07-31: assign most recent recall-tag; 
<span id="line5571"></span>          break;  // 2018-01-25: exit the loop after first find; 
<span id="line5572"></span>        }  // 2018-01-25: end of test for quverb; 
<span id="line5573"></span>      }  // 2018-01-25: end of loop in search of yes-or-no ("yn") quverb; 
<span id="line5574"></span>      verbprsn = 0;  // 2018-01-25: Store the verb as an infinitive form; 
<span id="line5575"></span>      audnum = 0;  // 2018-01-25: infinitive without num(ber); 
<span id="line5576"></span>      holdnum = 0;  // 2018-01-25: infinitive without num(ber); 
<span id="line5577"></span>      infincon = 1;  // 2018-01-25: set flag to positive one; 
<span id="line5578"></span>      nphrnum = 0;  // 2018-01-25: for no influence on infinitive; 
<span id="line5579"></span>      numsubj = 0;  // 2018-01-25: for no influence on infinitive; 
<span id="line5580"></span>      putnum = 0;   // 2018-01-25: for insisting on zero num infinitive; 
<span id="line5581"></span>      Speech();  // 2018-01-25: speak the verb starting at "aud" value; 
<span id="line5582"></span>      if (quobj == 0) quobj = 711;  // 2018-01-25: 711=ANYTHING default; 
<span id="line5583"></span>      for (i = inft; i&gt;midway; i--) {  // 2018-01-25: skip silent inference; 
<span id="line5584"></span>       Psy[i].psyExam();  // 2018-01-25: examine Psy conceptual array;
<span id="line5585"></span>        if (psi1 == quobj) {  // 2018-01-25: if query-object found; 
<span id="line5586"></span>          if (psi7==4) {  // 2018-01-25: dba=4 accusative? 
<span id="line5587"></span>            quobjaud = psi20;  // 2019-07-31: hold thru EnArticle(); 
<span id="line5588"></span>//          EnArticle();  // from German AI; insert "A" or "THE"? 20mar2013//
<span id="line5589"></span>//          EnArticle();  // 2019-09-22: commenting out during troubleshooting.
<span id="line5590"></span>            aud = quobjaud;   // 2018-01-25: restore after EnArticle; 
<span id="line5591"></span>            break; // 2018-01-25: exit the loop after first grammatical find; 
<span id="line5592"></span>          }  // 2018-01-25: end of test for accusative dba=4; 
<span id="line5593"></span>        }  // 2018-01-25: end of test for quobj; 
<span id="line5594"></span>      }  // 2018-01-25: end of loop in search of quobj; 
<span id="line5595"></span>      dirobj = 1;  // 2018-01-25: So OldConcept will set "dba" = 4 (accusative) 
<span id="line5596"></span>      Speech();    // 2018-01-25: say object word starting at "aud" value; 
<span id="line5597"></span>      dirobj = 0;  // 2018-01-25: Reset for safety after asking question; 
<span id="line5598"></span>      yncon = 0;   // 2018-01-25: because question has been asked; 
<span id="line5599"></span>      kbcon = 1;   // 2018-01-25: because waiting for answer; 
<span id="line5600"></span>      ynverb = 0;  // 2018-01-25: zero out; prevent repeat of query; 
<span id="line5601"></span>    }  // 2018-01-25: end of test of ynverb; 
<span id="line5602"></span>    if (subjpsi==701) prsn=1; // 2018-01-25: 1st person "I"; 
<span id="line5603"></span>    if (subjpsi==731) prsn=1; // 2018-01-25: 1st person "WE"; 
<span id="line5604"></span>    if (subjpsi==707) prsn=2; // 2018-01-25: 2nd person YOU; 
<span id="line5605"></span>    if (subjpsi==713) prsn=3; // 2018-01-25: 3rd person HE; 
<span id="line5606"></span>    if (subjpsi==719) prsn=3; // 2018-01-25: 3rd person SHE; 
<span id="line5607"></span>    if (subjpsi==725) prsn=3; // 2018-01-25: 3rd person IT; 
<span id="line5608"></span>    if (subjpsi==743) prsn=3; // 2018-01-25: 3rd person THEY; 
<span id="line5609"></span>    numsubj = 0;  // 2018-01-25: reset for safety; 
<span id="line5610"></span>    qusnum = 0;  // 2018-01-25: reset for safety; 
<span id="line5611"></span>    qusub = 0;   // 2018-06-11: reset for safety; 
<span id="line5612"></span>    recon = 0;  // 2018-01-25: 
<span id="line5613"></span>    bias = 5;  // 2018-01-25: restore expectation of a noun; 
<span id="line5614"></span>    for (i = idle; i</span><span>&lt;1</span><span>000; i++) {  // 2018-01-27: delay for user to see question?
<span id="line5615"></span>      if (i &gt; 1) { apb = "Pausing briefly for your answer..."; Voice() }  // 2018-01-27
<span id="line5616"></span>    }  // 2018-01-27: end of delay
<span id="line5617"></span>  }  // 2019-03-03: end of test to separate inference-questions.
<span id="line5618"></span>  if (whoq == 1) {  // 2019-03-03: test of flag for asking a who-question.
<span id="line5619"></span>    moot = 1;  // 2019-03-03: prevent storage of unwarranted associative tags.
<span id="line5620"></span>    for (i = vault; i&gt;0; i--) {  // 2018-01-25: use solid data in "vault" area.
<span id="line5621"></span>      Psy[i].psyExam();  // 2019-03-03: examine Psy conceptual array;
<span id="line5622"></span>      if (psi1 == 791) {  // 2019-03-03: if 791=WHO is found...
<span id="line5623"></span>        if (psi7 == 1) {  // 2019-03-03: if dba=1 for nominative pronoun...
<span id="line5624"></span>          aud = psi20;  // 2019-07-31: assign auditory recall-tag; 
<span id="line5625"></span>          break;  // 2019-03-03: exit the loop after first find; 
<span id="line5626"></span>        }  // 2019-03-03: end of test for nominative form.
<span id="line5627"></span>      }  // 2019-03-03: end of test for 791=WHO interrogative pronoun.
<span id="line5628"></span>    }  // 2019-03-03: end of loop in search of interrogative pronoun.
<span id="line5629"></span>    Speech();  // 2019-03-03: say pronoun starting at "aud" value in memory.
<span id="line5630"></span>    for (i = vault; i&gt;0; i--) {  // 2018-01-25: use solid data in "vault" area.
<span id="line5631"></span>      Psy[i].psyExam();  // 2019-03-03: examine Psy conceptual array;
<span id="line5632"></span>      if (psi1 == 800) {  // 2019-03-03: if 800=BE is found...
<span id="line5633"></span>        if (psi7 == 2) {  // 2019-03-03: if dba=2 for second person...
<span id="line5634"></span>          if (psi8 == 1) {  // 2019-03-03: if num=1 for singular number...
<span id="line5635"></span>            aud = psi20;  // 2019-07-31: assign auditory recall-tag; 
<span id="line5636"></span>            break;  // 2019-03-03: exit the loop after first find; 
<span id="line5637"></span>          }  // 2019-03-03: end of test for singular number.
<span id="line5638"></span>        }  // 2019-03-03: end of test for second-person verb-form.
<span id="line5639"></span>      }  // 2019-03-03: end of test for 800=BE query-verb
<span id="line5640"></span>    }  // 2019-03-03: end of loop in search of query-verb for question
<span id="line5641"></span>    Speech();  // 2019-03-03: say verb starting at "aud" value in memory.
<span id="line5642"></span>    for (i = vault; i&gt;0; i--) {  // 2018-01-25: use solid data in "vault" area.
<span id="line5643"></span>      Psy[i].psyExam();  // 2019-03-03: examine Psy conceptual array;
<span id="line5644"></span>      if (psi1 == 707) {  // 2019-03-03: if 707=YOU is found...
<span id="line5645"></span>        if (psi7 == 1) {  // 2019-03-03: if dba=1 for nominative subject...
<span id="line5646"></span>          aud = psi20;  // 2019-07-31: assign auditory recall-tag; 
<span id="line5647"></span>          break;  // 2019-03-03: exit the loop after first find; 
<span id="line5648"></span>        }  // 2019-03-03: end of test for nominative form.
<span id="line5649"></span>      }  // 2019-03-03: end of test for 707=YOU personal pronoun.
<span id="line5650"></span>    }  // 2019-03-03: end of loop in search of pronoun for subject of question.
<span id="line5651"></span>    Speech();  // 2019-03-03: say subject-word starting at "aud" value in memory.
<span id="line5652"></span>    moot = 0;  // 2019-03-03: reset after use.
<span id="line5653"></span>    whoq = 0;  // 2019-03-03: 
<span id="line5654"></span>  }  // 2019-03-03: after using, reset to zero. 
<span id="line5655"></span>}  // 2019-07-31: AskUser() returns to EnThink() or Volition()
<span id="line5656"></span>
<span id="line5657"></span>
<span id="line5658"></span>function EnNounPhrase() {  // http://ai.neocities.org/EnNounPhrase.html
<span id="line5659"></span>  act = 0; // 2018-01-12: so comparisons may be higher.
<span id="line5660"></span>  audjuste = 0;  // 2018-01-12: prevent carry-over
<span id="line5661"></span>  defact = -64;  // 2018-01-12: for default comparisons with "701=I"; 
<span id="line5662"></span>  motjuste = 0;   // 2018-01-12:
<span id="line5663"></span>  nphrnum = 0;   // 2018-09-05: prevent carry-over of previous value.
<span id="line5664"></span>  nphrpos = 5;   // 2018-01-12: a default setting of noun for EnArticle(). 
<span id="line5665"></span>  subjpsi = 0;   // 2018-01-12: how can there already be a subject-psi? TEST
<span id="line5666"></span>  tsels = 0;     // 2018-01-12: time of selection of subject
<span id="line5667"></span>  if (whatcon &gt; 0) verblock = 0;  // 2018-06-03: if answering what-query...
<span id="line5668"></span>  if (wherecon &gt; 0) verblock = 0;  // 2018-10-28: if answering where-query... 
<span id="line5669"></span>  if (verblock &gt; 0) {  // 2018-01-12: positive verblock?
<span id="line5670"></span>    Psy[verblock].psyExam(); // 2018-01-12: expose all values during search.
<span id="line5671"></span>    nounlock = psi14;  // 2019-07-31: time-point of "tkb" engram;  
<span id="line5672"></span>    subjnum = psi8;  // 2018-01-11: from number of verb;
<span id="line5673"></span>  }  // 2018-01-12:  end of test for a positive verblock
<span id="line5674"></span>  if (nounlock &gt; 0) {  // 2018-01-12: already a nounlock? 
<span id="line5675"></span>    dirobj = 1;  // 2018-01-12: nounlock is specifically for a direct object.
<span id="line5676"></span>    subjectflag = 0;  // 2018--1-12: needed for conditional tests;
<span id="line5677"></span>    Psy[nounlock].psyExam(); // 2018-01-12: inspect t=nounlock row;
<span id="line5678"></span>    motjuste = psi1;  // 2018-01-12: in case a search is needed for non-zero rv
<span id="line5679"></span>    nphrnum = psi8;   // 2018-09-05: for sake of EnArticle() etc.
<span id="line5680"></span>    if (psi17 &gt; 0) tdj = psi17;  // 2019-10-12: time-of-adjective
<span id="line5681"></span>    if (psi19 &gt; 0) tpr = psi19;  // 2019-09-20: time-of-preposition?
<span id="line5682"></span>    if (quiet == true) actpsi = psi1;  // 2018-06-11: so EnVerbPhrase() calls SpreadAct() 
<span id="line5683"></span>    nphrpos = psi6;  // 2018-05-26: find part-of-speech for EnArticle
<span id="line5684"></span>    if (psi6==5) objnum = psi8;  // 2018-06-16: use only for 5=noun. 
<span id="line5685"></span>    if (psi7 == 4) {  // 2018-01-12: if dba is acc. case as for any nounlock;
<span id="line5686"></span>      if (psi20 &gt; 0) {  // 2019-07-31: if there is a positive recall-vector...
<span id="line5687"></span>        nphrpos = psi6;  // 2018-01-12: find part-of-speech for EnArticle
<span id="line5688"></span>        nphrnum = psi8;  // 2018-09-05: noun-phrase num(ber) for EnArticle()
<span id="line5689"></span>        aud = psi20;  // 2019-07-31: find positive rv; 
<span id="line5690"></span>      } else {  // 2019-07-31: if only a zero "rv" is found...
<span id="line5691"></span>        for (i = tpu; i&gt;midway; --i) {  // 2018-01-12: search backwards
<span id="line5692"></span>          Psy[i].psyExam(); // 2018-01-12: inspect each time-point "i"
<span id="line5693"></span>          if (motjuste == psi1) {  // 2018-01-12: find motjuste for sake of rv
<span id="line5694"></span>            if (subjectflag == 1 &amp;&amp; psi7 == 1) {  // 2018-01-12: dba subject?
<span id="line5695"></span>              if (psi20 &gt; 0) aud = psi20;  // 2019-07-31: find positive rv; 
<span id="line5696"></span>              break;  // 2018-01-14: exit loop after first find; 
<span id="line5697"></span>            } // 2018-01-12: end of test for subject
<span id="line5698"></span>          }  // 2018-01-12: end of test for same concept as motjuste
<span id="line5699"></span>          if (dirobj == 1 &amp;&amp; psi7 == 4) { // 2018-01-12: dba direct object?
<span id="line5700"></span>            if (psi20 &gt; 0) nphrpos = psi6;  // 2019-07-31: for EnArticle.
<span id="line5701"></span>            if (psi20 &gt; 0) nphrnum = psi8;  // 2019-07-31: for EnArticle.
<span id="line5702"></span>            if (psi20 &gt; 0) aud = psi20;  // 2019-07-31: find positive rv; 
<span id="line5703"></span>            if (psi20 &gt; 0) break;  // 2019-07-31: exit loop if rv is found.
<span id="line5704"></span>          }  // 2018-01-12: end of test for direct object and accusative case.
<span id="line5705"></span>          if (psi20 &gt; 0)  nphrpos = psi6;  // 2019-07-31: for EnArticle.
<span id="line5706"></span>          if (psi20 &gt; 0) aud = psi20;  // 2019-07-31: find positive rv; 
<span id="line5707"></span>          if (psi20 &gt; 0) break;  // 2019-07-31: exit loop if rv is found.
<span id="line5708"></span>        }  // 2018-01-12: end of for-loop in search of a positive recall-vector.
<span id="line5709"></span>      }  // 2018-01-12: end of else-clause for typically a pronominal rv.
<span id="line5710"></span>    }  // 2018-01-12: end of dba-test for accusative nounlock. 
<span id="line5711"></span>  }  // 2018-01-12: end of test for a positive nounlock;
<span id="line5712"></span>  if (tpr &gt; 0) {  // 2019-09-20: if noun links to a preposition...
<span id="line5713"></span>    Psy[tpr].psyExam(); // 2019-09-20: inspect psy-array knowledge-nodes.
<span id="line5714"></span>    if (psi14 &gt; 0) px1 = psi14;  // 2019-09-22: intercept "px1" for obj of prep.
<span id="line5715"></span>  }  // 2019-09-20: end of test for a jump-off point to a preposition.
<span id="line5716"></span>  if (nounlock == 0) {  // 2016apr16: if nouns are free to compete...
<span id="line5717"></span>    subjectflag = 1;  // 2018-01-12: a default until countermanded.  
<span id="line5718"></span>    dba = 1;  // 2018-01-12: default nominative until countermanded.  
<span id="line5719"></span>    if (dirobj == 1) subjectflag = 0;  // 2018-01-12: countermanding default
<span id="line5720"></span>    for (i = t; i&gt;midway; --i) {  // 2018-01-12: include input for topical response
<span id="line5721"></span>      Psy[i].psyExam(); // 2018-01-12: inspect each time-point "i"
<span id="line5722"></span>      if (psi6==5 || psi6==7) {  // 2018-01-12: select "pos" noun or pronoun
<span id="line5723"></span>        if (whatcon==1 &amp;&amp; psi1==qv1psi &amp;&amp; psi20&gt;0 &amp;&amp; qv2psi==886) { // 2019-07-31: WHAT...THINK?
<span id="line5724"></span>          svo1 = psi1;  // 2018-05-13: keep track of subject.
<span id="line5725"></span>          tsels = i;  // 2018-05-13: use time-point of subj-selection  for inhibition. 
<span id="line5726"></span>          subjnum = psi8;  // 2018-10-03: for sake of EnAuxVerb()
<span id="line5727"></span>          aud = psi20; // 2019-07-31: temporary recall-vector for Speech
<span id="line5728"></span>          Psy[i] = new  
<span id="line5729"></span>          psyNode(psi0,psi1,psi2,256,psi4,psi5,psi6,
<span id="line5730"></span>          psi7,psi8,psi9,psi10,psi11,psi12,psi13,
<span id="line5731"></span>          psi14,psi15,psi16,psi17,psi18,psi19,psi20); // 2019-07-31: expanded flag-panel
<span id="line5732"></span>          break;  // 2018-05-13: abandon search. 
<span id="line5733"></span>        }  // 2018-05-13: end of test for WHAT...THINK query.
<span id="line5734"></span>        if (psi14 &gt; 0 ) {  // 2019-07-31: retrieve ideas, not single words.
<span id="line5735"></span>          if (psi3 &gt; act) {  // 2018-01-12: psi3 activation as criterion. 
<span id="line5736"></span>            etc++;  // 2019-02-18: implement number of active ideas for ConJoin()
<span id="line5737"></span>            motjuste = psi1;  // 2018-01-12: Select the most active concept.
<span id="line5738"></span>            svo1 = psi1;  // 2018-01-12: keep track of subject.
<span id="line5739"></span>            mjact = psi3;  // 2018-01-12: if too low, motjuste defaults to "I"
<span id="line5740"></span>            posflag = psi5;  // 2018-01-27: AskUser discriminand; 
<span id="line5741"></span>            if (psi8 &gt; 0) snu = psi8;  // 2018-10-10: for sake of EnVerbGen()
<span id="line5742"></span>            subjnum = psi8;  // 2018-10-03: for sake of EnAuxVerb()
<span id="line5743"></span>            if (psi3 &gt; act &amp;&amp; psi11 &gt; 0) {  // 2019-07-31: if psi1 has psi11-seq
<span id="line5744"></span>              verblock = psi14;  // 2019-07-31: assign tkb value to verblock.
<span id="line5745"></span>              if (psi8 &gt; 0) snu = psi8;  // 2018-10-10: for sake of EnVerbGen()
<span id="line5746"></span>              subjnum = psi8;  // 2018-01-27: for AuxVerb DOES or DO; 
<span id="line5747"></span>            } // 2018-01-12: end of test for a psi1-subject with a psi12-seq.
<span id="line5748"></span>            if (psi3 &gt; act &amp;&amp; psi14 &gt; 0) { // 2019-07-31: if psi1 has psi14-tkb
<span id="line5749"></span>              verblock = psi14;  // 2019-07-131: assign tkb value to verblock.
<span id="line5750"></span>              if (psi8 &gt; 0) snu = psi8;  // 2018-10-10: for sake of EnVerbGen()
<span id="line5751"></span>              subjnum = psi8;  // 2018-01-27: for AuxVerb DOES or DO; 
<span id="line5752"></span>            }  // 2018-01-12: end of test for a psi1-subject with a psi13-tkb.
<span id="line5753"></span>            if (dirobj == 1) actpsi = psi1;  // 2018-01-12: 
<span id="line5754"></span>            subjpsi = motjuste;  // 2018-01-12: for selection of verb-form.
<span id="line5755"></span>            nphrnum = psi8;  // 2018-09-05: NounPhrase number for EnArticle() etc.
<span id="line5756"></span>            snu = psi8;  // 2018-01-12: subject-number for verb-selection; 
<span id="line5757"></span>            if (psi20 &gt; 0 &amp;&amp; numreq==0) {  // 2019-07-31: if positive recall-vector...
<span id="line5758"></span>              nphrpos = psi6;  // 2018-01-12: for sake of EnArticle.
<span id="line5759"></span>              aud = psi20; // 2019-07-31: temporary recall-vector for Speech
<span id="line5760"></span>            }  // 2018-01-12: end of test for auditory-engram recall-vector.
<span id="line5761"></span>            if (psi20 &gt; 0 &amp;&amp; numreq &gt; 0 &amp;&amp; psi8==numreq) {  // 2019-07-31
<span id="line5762"></span>              nphrpos = psi6;  // 2018-05-25: for sake of EnArticle.
<span id="line5763"></span>              aud = psi20; // 2019-07-31: temporary recall-vector for Speech
<span id="line5764"></span>            }  // 2018-05-25: end of test for auditory-engram recall-vector.
<span id="line5765"></span>            tseln = i;  // 2018-01-12: use time-point for inhibition. 
<span id="line5766"></span>            tsels = i;  // 2018-01-12: use time-point for inhibition. 
<span id="line5767"></span>            act = psi3;  // 2018-01-12: noun must have higher "act" to win
<span id="line5768"></span>          }  // 2018-01-12: end of test for a higher activation "act"
<span id="line5769"></span>        }  // 2018-01-12: end of test for a psi13 "tkb" verblock.
<span id="line5770"></span>      }  // 2018-01-12: end of test for noun or pronoun as subject
<span id="line5771"></span>    }  // 2018-01-12: End of (for loop) searching for most active "motjuste"
<span id="line5772"></span>  } // 2018-01-12: end of test for absence of a nounlock.
<span id="line5773"></span>  if (whatcon &gt; 0) {  // 2019-02-12: if SpreadAct() answers a what-query...
<span id="line5774"></span>    if (catsubj == motjuste &amp;&amp; conj &gt; 0) { // 2019-02-12: after a conjunction...
<span id="line5775"></span>      return;  // 2019-02-12: omit the subject-noun after the use of a conjunction.
<span id="line5776"></span>    }  // 2019-02-12: end of test for a subject matching a query-subject.
<span id="line5777"></span>  }  // 2019-02-12: end of test for SpreadAct() answering a what-query.
<span id="line5778"></span>  Psy[tsels].psyExam(); // 2018-05-28: inspect subject to be inhibited.
<span id="line5779"></span>  snu = psi8;  // 2018-10-10: for sake of EnVerbGen()
<span id="line5780"></span>  psi3 = (psi3 - 90);  // 2018-05-13: make activation relative, not absolute.  
<span id="line5781"></span>  Psy[tsels] = new 
<span id="line5782"></span>  psyNode(psi0,psi1,psi2,psi3,psi4,psi5,psi6,
<span id="line5783"></span>  psi7,psi8,psi9,psi10,psi11,psi12,psi13,
<span id="line5784"></span>  psi14,psi15,psi16,psi17,psi18,psi19,psi20);  // 20p19-07-31: expanded flag-panel
<span id="line5785"></span>  if (subjectflag == 0) {  // 2018-01-12: i.e., dir.obj or pred.nom;
<span id="line5786"></span>    if (nounlock &gt; 0) {  // 2018-01-12: if verb is locked to a particular seq...
<span id="line5787"></span>      Psy[nounlock].psyExam(); // 2018-01-12: inspect t=nounlock row;
<span id="line5788"></span>      motjuste = psi1;  // 2018-01-12: nounlock psi pre-empts search.
<span id="line5789"></span>      if (psi6 == 5) {  // 2018-01-12: if nounlock part of speech is 5=noun
<span id="line5790"></span>        nphrpos = 5;  // 2018-01-12: for sake of EnArticle.
<span id="line5791"></span>        qv1psi = psi1;  // 2018-01-12: let direct object go to SpreadAct. 
<span id="line5792"></span>        nphrnum = psi8;  // 2018-12-16: for sake of EnArticle()
<span id="line5793"></span>      }  // 2018-01-12: end of test for only a noun to go into SpreadAct.
<span id="line5794"></span>      aud = psi20;  // 2019-07-31: recall-vector to auditory engram.  
<span id="line5795"></span>    }  // 2018-01-12: end of test for a positive nounlock.
<span id="line5796"></span>    if (aud == 0) {  // 2018-05-28: for instance, switching ME and YOU
<span id="line5797"></span>      for (i = tpu; i&gt;midway; --i) {  // 2018-05-28: search backwards from tpu
<span id="line5798"></span>        Psy[i].psyExam(); // 2018-05-28: inspect Psy flag-panel
<span id="line5799"></span>        if (motjuste == psi1) {  // 2018-01-12: find motjuste for sake of rv
<span id="line5800"></span>          if (subjectflag == 1 &amp;&amp; psi7 == 1) {  // 2018-01-12: subject?
<span id="line5801"></span>            if (psi20 &gt; 0) aud = psi20;  // 2019-07-31: find positive rv; 
<span id="line5802"></span>            if (psi20 &gt; 0) break;  // 2019-07-31: exit loop if rv is found.
<span id="line5803"></span>          } // 2018-01-12: end of test for subject and for nominative case.
<span id="line5804"></span>          if (dirobj == 1 &amp;&amp; psi7 == 4) {  // 2018-05-28: direct object?
<span id="line5805"></span>            if (psi1 &gt; 0) qv4psi = psi1;  // 2018-05-28: for inserting "AN".
<span id="line5806"></span>            if (psi1 &gt; 0) nphrpos = psi6; // 2018-05-28: set POS for EnArticle.
<span id="line5807"></span>            if (psi1 &gt; 0) aud = psi20;  // 2019-07-31: find positive rv;
<span id="line5808"></span>            if (psi20 &gt; 0) break;  // 2019-07-31: exit loop if rv is found.
<span id="line5809"></span>          }  // 2018-05-28: end of test for direct object and accusative case.
<span id="line5810"></span>        }  // 2018-06-09: BUGFIX: missing end of if-clause.
<span id="line5811"></span>      } // 2018-05-28: end of for-loop searching for rv.
<span id="line5812"></span>    }  // 2018-05-28: end of test for missing "aud" recall-vector. 
<span id="line5813"></span>  }  // 2018-01-12: end of test for not-a-subject
<span id="line5814"></span>  for (i = tpu; i&gt;midway; --i) {  // 2018-01-12: search backwards from tpu
<span id="line5815"></span>    Psy[i].psyExam(); // 2018-01-12: inspect Psy flag-panel
<span id="line5816"></span>    if (motjuste == psi1) {  // 2018-01-12: find motjuste for sake of rv
<span id="line5817"></span>      if (subjectflag == 1 &amp;&amp; psi7 == 1) {  // 2018-01-12: subject?
<span id="line5818"></span>        if (psi20 &gt; 0) aud = psi20;  // 2019-07-31: find positive rv;  
<span id="line5819"></span>        if (psi20 &gt; 0) break;  // 2019-07-31: exit loop if rv is found.
<span id="line5820"></span>      } // 2018-01-12: end of test for subject and for nominative case.
<span id="line5821"></span>      if (dirobj==1 &amp;&amp; numreq&gt;0 &amp;&amp; psi8==numreq) {  // 2018-05-25: 
<span id="line5822"></span>        if (psi1 &gt; 0) qv4psi = psi1;  // 2018-05-25: for inserting "AN".
<span id="line5823"></span>        if (psi1 &gt; 0) nphrpos = psi6; // 2018-05-25: set POS for EnArticle.
<span id="line5824"></span>        if (psi1 &gt; 0) aud = psi20;  // 2019-07-31: find positive rv; 
<span id="line5825"></span>        if (psi20 &gt; 0) break;  // 2019-07-31: exit loop if rv is found.
<span id="line5826"></span>      }  // 2018-05-25: end for pseud-dir=obj and numreq number.
<span id="line5827"></span>      if (dirobj == 1 &amp;&amp; psi8 == numreq &amp;&amp; numreq&gt;0) {  // 2018-05-25: required number?
<span id="line5828"></span>        if (psi1 &gt; 0) qv4psi = psi1;  // 2018-05-25: for inserting "AN".
<span id="line5829"></span>        if (psi1 &gt; 0) nphrpos = psi6; // 2018-05-25: set POS for EnArticle.
<span id="line5830"></span>        if (psi1 &gt; 0) aud = psi20;  // 2019-07-31: find positive rv;
<span id="line5831"></span>        if (psi20 &gt; 0) break;  // 2019-07-31: exit loop if rv is found.
<span id="line5832"></span>      }  // 2018-05-25: end of test for direct object and accusative case.
<span id="line5833"></span>      if (dirobj == 1 &amp;&amp; numreq &gt; 0) {  // 2018-05-25: direct object?
<span id="line5834"></span>        if (psi1 &gt; 0) qv4psi = psi1;  // 2018-05-25: for inserting "AN".
<span id="line5835"></span>        if (psi1 &gt; 0) nphrpos = psi6; // 2018-05-25: set POS for EnArticle.
<span id="line5836"></span>        break;  // 2018-05-25: exit loop if rv is found.
<span id="line5837"></span>        if (psi1 &gt; 0 &amp;&amp; psi8==numreq &amp;&amp; psi20&gt;0) { // 2019-07-31
<span id="line5838"></span>          aud = psi20;  // 2019-07-31: find positive rv; 
<span id="line5839"></span>          break;  // 2018-05-25: exit loop if rv is found.
<span id="line5840"></span>        }  // 2018-05-25:  
<span id="line5841"></span>      if (psi1 &gt; 0 &amp;&amp; psi8==numreq &amp;&amp; psi20&gt;0) break; // 2019-07-31: TEST
<span id="line5842"></span>      }  // 2018-05-25: end of test for direct object and accusative case.
<span id="line5843"></span>      if (psi1 &gt; 0 &amp;&amp; psi8==numreq &amp;&amp; psi20&gt;0) break; // 2019-07-31: TEST
<span id="line5844"></span>      if (dirobj == 1 &amp;&amp; psi7 == 4) {  // 2018-01-12: direct object?
<span id="line5845"></span>        if (psi1 &gt; 0) qv4psi = psi1;  // 2018-01-12: for inserting "AN".
<span id="line5846"></span>        if (psi1 &gt; 0) nphrpos = psi6; // 2018-01-12: set POS for EnArticle.
<span id="line5847"></span>        if (psi1 &gt; 0) aud = psi20;  // 2019-07-31: find positive rv;
<span id="line5848"></span>        if (psi20 &gt; 0) break;  // 2019-07-31: exit loop if rv is found.
<span id="line5849"></span>      }  // 2018-01-12: end of test for direct object and accusative case.
<span id="line5850"></span>    }  // 2018-01-12: end of test to find motjuste with valid rv.
<span id="line5851"></span>  } // 2018-01-14: end of for-loop as part of else-clause.
<span id="line5852"></span>  for (i=vault; i&gt;midway; --i) {  // 2018-01-23: search backwards within "vault"
<span id="line5853"></span>    Psy[i].psyExam(); // 2018-01-23: examine the Psy concept array...
<span id="line5854"></span>    if (numreq &gt; 0 &amp;&amp; aud &gt; 0);  break;  // 2018-05-25: pre-empt
<span id="line5855"></span>    if (motjuste == psi1) {  // 2018-01-23: find motjuste for sake of rv
<span id="line5856"></span>      if (numreq&gt;0 &amp;&amp; psi8==numreq &amp;&amp; psi20&gt;0) {  // 2019-07-31: 
<span id="line5857"></span>        aud = psi20;  // 2019-07-31:
<span id="line5858"></span>        break;  // 2018-05-25: 
<span id="line5859"></span>      }  // end of test to preempt with numreq
<span id="line5860"></span>      if (subjectflag == 1 &amp;&amp; psi7 == 1) {  // 2018-01-23: subject?
<span id="line5861"></span>        if (psi20 &gt; 0) aud = psi20;  // 2019-07-31: find positive rv; 
<span id="line5862"></span>        if (psi20 &gt; 0) break;  // 2019-07-31: exit loop if rv is found.
<span id="line5863"></span>      }  // 2018-01-23: end of test for subject and for nominative case.
<span id="line5864"></span>      if (dirobj == 1 &amp;&amp; psi7 == 4) {  // 2018-01-23: direct object?
<span id="line5865"></span>        if (psi1 &gt; 0) qv4psi = psi1;  // 2018-01-23: for inserting "AN".
<span id="line5866"></span>        if (psi20 &gt; 0) nphrpos = psi6;  // 2019-07-31: set POS for EnArticle.
<span id="line5867"></span>        if (psi20 &gt; 0) aud = psi20;  // 2019-07-31: find positive rv; 
<span id="line5868"></span>        if (psi20 &gt; 0) break;  // 2019-07-31: exit loop if rv is found.
<span id="line5869"></span>      }  // 2018-01-23: end of test for direct object and accusative case.
<span id="line5870"></span>    }  // 2018-01-23: end of test to find motjuste with valid rv.
<span id="line5871"></span>  }  // 2018-01-23: End of (for loop) searching through Psy conceptual array. 
<span id="line5872"></span>  if (nounlock == 0) {  // 2018-01-12: if no nounlock override; 
<span id="line5873"></span>    if (mjact </span><span>&lt; </span><span>20) {  // 2018-01-12: if no subject active enough for chain-of-thought
<span id="line5874"></span>      if (subjectflag == 1) {  // 2018-01-12: default to "I" only as subject
<span id="line5875"></span>        motjuste = 701;  // 2018-01-12: 701=I default concept of AI Mind
<span id="line5876"></span>        for (i = tpu; i&gt;midway; --i) {  // 2018-01-12: search backwards
<span id="line5877"></span>          Psy[i].psyExam(); // 2018-01-12: inspect Psy flag-panel
<span id="line5878"></span>          if (psi1==701 &amp;&amp; psi14 &gt; 0) {  // 2019-07-31: I=701 with tkb verblock?
<span id="line5879"></span>            if (psi3 &gt; defact) {  // 2018-01-12: if higher psi3 act is found;
<span id="line5880"></span>              tseln = i;  // 2018-01-12: retain time of motjuste; 
<span id="line5881"></span>              tsels = i;  // 2018-01-12: retain time of English subject;
<span id="line5882"></span>              defact = psi3;  // 2018-01-12: dynamic metric;
<span id="line5883"></span>              verblock = psi14; // 2019-07-31: psi14 "tkb" as verblock; 
<span id="line5884"></span>              aud = psi20;  // 2019-07-31: recall-vector for auditory engram
<span id="line5885"></span>            } // 2018-01-12: end of test for higher-act ego-concept;
<span id="line5886"></span>          }  // 2018-01-12:  end of test for "701=I" with seq-check;
<span id="line5887"></span>        }  // 2018-01-12: end of search for least-inhibited "701=I"; 
<span id="line5888"></span>        dba = 1; // 2018-01-12: subject requires nominative case; 
<span id="line5889"></span>        nphrnum = 1;  // 2018-01-12: for EnArticle() and EnVerbPhrase();
<span id="line5890"></span>        nphrpos = 7;  // 2018-01-12: prevent article "A" with "I";
<span id="line5891"></span>        prsn = 1;     // 2018-01-12: for use elsewhere; 
<span id="line5892"></span>        subjnum = 1;  // 2018-01-12: for use elsewhere;
<span id="line5893"></span>        subjpsi = 701; // 2018-01-12: for use elsewhere;
<span id="line5894"></span>        topic = 701;   // 2018-01-12: for question-asking modules; 
<span id="line5895"></span>        for (i = vault; i&gt;midway; --i) {  // 2018-01-12: search backwards
<span id="line5896"></span>          Psy[i].psyExam(); // 2018-01-12: inspect Psy flag-panel
<span id="line5897"></span>          if (psi1 == 701) {  // 2018-01-12: if 701=I is found;
<span id="line5898"></span>            if (psi7 == 1) {  // 2018-01-12: psi7/dba must be nominative=1; 
<span id="line5899"></span>              aud = psi20;  // 2019-07-31: "I" recall-vector for Speech()
<span id="line5900"></span>              if (psi20&gt;0) break;  // 2019-07-31: insurance
<span id="line5901"></span>            }  // 2018-01-12: end of test for nominative "I"; 
<span id="line5902"></span>          }  // 2018-01-12: End of search for 701=I;
<span id="line5903"></span>        }  // 2018-01-12: end of 701=I search in reliable "vault" sequence.
<span id="line5904"></span>      } // 2018-01-12: end of test for "I" to become subj. not obj.
<span id="line5905"></span>    }  // 2018-01-12: end of test for low activation warranting a default
<span id="line5906"></span>  }  // 2018-01-12: end of test for absence of pre-ordained nounlock;
<span id="line5907"></span>  unk = aud;  // 2018-01-14: preserve value across call to EnArticle().
<span id="line5908"></span>  if (nphrpos == 5) {  // 2018-01-14: only nouns, not adjectives or pronouns.
<span id="line5909"></span>    audMemory[aud].audExam();  // 2018-01-14: Inspect memory at "aud";
<span id="line5910"></span>    if (aud0 == "A") anset = 65;  // 2018-01-14: If vowel "A";
<span id="line5911"></span>    if (aud0 == "E") anset = 69;  // 2018-01-14: If vowel "E"; 
<span id="line5912"></span>    if (aud0 == "I") anset = 73;  // 2018-01-14: If vowel "I"; 
<span id="line5913"></span>    if (aud0 == "O") anset = 79;  // 2018-01-14: If vowel "O"; 
<span id="line5914"></span>    if (aud0 == "U") anset = 85;  // 2018-01-14: If vowel "U"; 
<span id="line5915"></span>    if (nphrnum &gt; 0) usx = motjuste;  // 2018-09-07: num(ber) required.
<span id="line5916"></span>    EnArticle();  // 2018-01-14: module for thinking an English article.
<span id="line5917"></span>//  EnArticle();  // 2019-09-22: commenting out during troubleshooting.
<span id="line5918"></span>    anset = 0;  // 2018-06-03: reset for safety. 
<span id="line5919"></span>    usx = 0;    // 2018-09-04: reset for safety.
<span id="line5920"></span>  }  // 2018-01-14: end of test for a 5=noun noun-phrase part-of-speech
<span id="line5921"></span>  aud = unk; // 2018-01-14: restore value after call to EnArticle().
<span id="line5922"></span>  unk = 0;   // 2018-01-14: reset for safety. 
<span id="line5923"></span>  unk = aud;  // 2019-10-12: preserve value across call to EnAdjective().
<span id="line5924"></span>  if (tdj &gt; 0) {  // 2019-10-12: if there is a positive time-of-adjective...
<span id="line5925"></span>    EnAdjective();  // 2019-10-12: for insertion of an adjective
<span id="line5926"></span>    tdj = 0;  // 2019-10-12: reset for safety. 
<span id="line5927"></span>  }  // 2019-10-12: end of test for an adjective linked to the noun.
<span id="line5928"></span>  aud = unk; // 2019-10-12: restore value after call to EnAdjective().
<span id="line5929"></span>  Speech();  // 2018-01-12: speak the word starting at the "aud" time.  
<span id="line5930"></span>  Psy[tsels].psyExam(); // 2018-01-14: inhibit the subject just spoken:
<span id="line5931"></span>  Psy[tsels] = new 
<span id="line5932"></span>  psyNode(psi0,psi1,psi2,-32,psi4,psi5,psi6,
<span id="line5933"></span>  psi7,psi8,psi9,psi10,psi11,psi12,psi13,
<span id="line5934"></span>  psi14,psi15,psi16,psi17,psi18,psi19,psi20); // 2019-07-31: expanded flag-panel. 
<span id="line5935"></span>  if (tpr &gt; 0) {  // 2019-09-20: if there is a positive time-of-preposition
<span id="line5936"></span>    EnPrep();  // 2019-09-20: for a prepositional phrase
<span id="line5937"></span>    tpr = 0;   // 2019-09-22: reset for safety.
<span id="line5938"></span>  }  // 2019-09-20: end of test for a preposition linked to the noun.
<span id="line5939"></span>  dirobj = 0;  // 2018-01-12: reset for safety 
<span id="line5940"></span>  mfn = 0;     // 2019-10-25: prevent carry-over.
<span id="line5941"></span>  mjact = 0;   // 2018-01-12: reset for safety.
<span id="line5942"></span>  motjuste = 0;  // 2018-01-12: reset for safety. 
<span id="line5943"></span>  numreq= 0;  // 2018-05-25: whether used or not in one pass through the module.
<span id="line5944"></span>}  // 2019-10-25: EnNounPhrase() returns to Indicative(). 
<span id="line5945"></span>
<span id="line5946"></span>
<span id="line5947"></span>function EnVerbGen() {  // http://ai.neocities.org/EnVerbgen.html
<span id="line5948"></span>  if (audbase == 0 &amp;&amp; verbpsi &gt; 0) {  // 2018-10-11: for lack of starting point..
<span id="line5949"></span>    for (i = tpu; i&gt;midway; --i) {  // 2018-10-11: search backwards
<span id="line5950"></span>      Psy[i].psyExam(); //  2018-10-11: examine conceptual Psy array at each "i(ndex)"
<span id="line5951"></span>      if (psi1 == verbpsi &amp;&amp; psi20 &gt; 0) {  // 2019-07-31: verb with recall-vectoer?
<span id="line5952"></span>        audbase = psi20;  // 2019-07-31: initial base-time for generating verb-form
<span id="line5953"></span>        break;  // 2018-10-11: one example is enough.
<span id="line5954"></span>      }  // 2018-10-11: end of test for modificand verb and auditory engram
<span id="line5955"></span>    }  // 2018-10-11: end of backwards loop in search of audbase starting point.
<span id="line5956"></span>  }  // 2018-10-11: end of search for "audbase" starting point. 
<span id="line5957"></span>  binc = 0;  // 2018-10-12: "b" buffer-character increment for AudBuffer() 
<span id="line5958"></span>  if (subjpsi==701) prsn = 1;  // 2018-10-11: "701=I" is first-person;
<span id="line5959"></span>  if (subjpsi==707) prsn = 2;  // 2018-10-11: "707=YOU" is second-person;
<span id="line5960"></span>  if (subjpsi==713) prsn = 3;  // 2018-10-11: "713=HE" is third-person;
<span id="line5961"></span>  if (subjpsi==719) prsn = 3;  // 2018-10-11: "719=SHE" is third-person;
<span id="line5962"></span>  if (subjpsi==725) prsn = 3;  // 2018-10-11: "725=IT" is third-person;
<span id="line5963"></span>  if (subjpsi==731) prsn = 1;  // 2018-10-11: "731=WE" is first-person; 
<span id="line5964"></span>  if (subjpsi==743) prsn = 3;  // 2018-10-11: "743=THEY" is third-person;
<span id="line5965"></span>  audMemory[audbase].audExam();  // 2018-10-10: @ear character-engram #01
<span id="line5966"></span>  if (aud0 != " ") { abc = aud0; AudBuffer(); audbase++ }  // 2018-10-10
<span id="line5967"></span>  audMemory[audbase].audExam();  // 2018-10-10: @ear character-engram #02
<span id="line5968"></span>  if (aud0 != " ") { abc = aud0; AudBuffer(); audbase++ }  // 2018-10-10
<span id="line5969"></span>  audMemory[audbase].audExam();  // 2018-10-10: @ear character-engram #03
<span id="line5970"></span>  if (aud0 != " ") { abc = aud0; AudBuffer(); audbase++ }  // 2018-10-10
<span id="line5971"></span>  audMemory[audbase].audExam();  // 2018-10-10: @ear character-engram #04
<span id="line5972"></span>  if (aud0 != " ") { abc = aud0; AudBuffer(); audbase++ }  // 2018-10-10
<span id="line5973"></span>  audMemory[audbase].audExam();  // 2018-10-10: @ear character-engram #05
<span id="line5974"></span>  if (aud0 != " ") { abc = aud0; AudBuffer(); audbase++ }  // 2018-10-10
<span id="line5975"></span>  audMemory[audbase].audExam();  // 2018-10-10: @ear character-engram #06
<span id="line5976"></span>  if (aud0 != " ") { abc = aud0; AudBuffer(); audbase++ }  // 2018-10-10
<span id="line5977"></span>  audMemory[audbase].audExam();  // 2018-10-10: @ear character-engram #07
<span id="line5978"></span>  if (aud0 != " ") { abc = aud0; AudBuffer(); audbase++ }  // 2018-10-10
<span id="line5979"></span>  audMemory[audbase].audExam();  // 2018-10-10: @ear character-engram #08
<span id="line5980"></span>  if (aud0 != " ") { abc = aud0; AudBuffer(); audbase++ }  // 2018-10-10
<span id="line5981"></span>  audMemory[audbase].audExam();  // 2018-10-10: @ear character-engram #09
<span id="line5982"></span>  if (aud0 != " ") { abc = aud0; AudBuffer(); audbase++ }  // 2018-10-10
<span id="line5983"></span>  audMemory[audbase].audExam();  // 2018-10-10: @ear character-engram #10
<span id="line5984"></span>  if (aud0 != " ") { abc = aud0; AudBuffer(); audbase++ }  // 2018-10-10
<span id="line5985"></span>  audMemory[audbase].audExam();  // 2018-10-10: @ear character-engram #11
<span id="line5986"></span>  if (aud0 != " ") { abc = aud0; AudBuffer(); audbase++ }  // 2018-10-10
<span id="line5987"></span>  audMemory[audbase].audExam();  // 2018-10-10: @ear character-engram #12
<span id="line5988"></span>  if (aud0 != " ") { abc = aud0; AudBuffer(); audbase++ }  // 2018-10-10
<span id="line5989"></span>  audMemory[audbase].audExam();  // 2018-10-10: @ear character-engram #13
<span id="line5990"></span>  if (aud0 != " ") { abc = aud0; AudBuffer(); audbase++ }  // 2018-10-10
<span id="line5991"></span>  audMemory[audbase].audExam();  // 2018-10-10: @ear character-engram #14
<span id="line5992"></span>  if (aud0 != " ") { abc = aud0; AudBuffer(); audbase++ }  // 2018-10-10
<span id="line5993"></span>  audMemory[audbase].audExam();  // 2018-10-10: @ear character-engram #15
<span id="line5994"></span>  if (aud0 != " ") { abc = aud0; AudBuffer(); audbase++ }  // 2018-10-10
<span id="line5995"></span>  audMemory[audbase].audExam();  // 2018-10-10: @ear character-engram #16
<span id="line5996"></span>  if (aud0 != " ") { abc = aud0; AudBuffer(); audbase++ }  // 2018-10-10
<span id="line5997"></span>  do {  // 2018-10-11: next loop uses OutBuffer();
<span id="line5998"></span>    OutBuffer();  // 2018-10-11: call OutBuffer with each passage through loop;
<span id="line5999"></span>    if (binc == 1) {  // 2018-10-11: the indicated buffer-character by number
<span id="line6000"></span>      if (b16 != "") output += b6;  // 2019-06-15: concatenate verb-characters
<span id="line6001"></span>      pho = b16;  // 2019-06-15: for ReEntry()
<span id="line6002"></span>      if (pho &gt; "") ReEntry();  // 2018-10-11: for accumulating record of thought
<span id="line6003"></span>    }  // 2018-10-11: end of outputting character and concatenating for ReEntry().
<span id="line6004"></span>    if (binc == 2) {  // 2018-10-11: the indicated buffer-character by number
<span id="line6005"></span>      if (b15 != "") output += b15;  // 2019-06-15: concatenate verb-characters
<span id="line6006"></span>      pho = b15;  // 2019-06-15: for ReEntry()
<span id="line6007"></span>      if (pho &gt; "") ReEntry();  // 2018-10-11: for accumulating record of thought
<span id="line6008"></span>    }  // 2018-10-11: end of outputting character and concatenating for ReEntry().
<span id="line6009"></span>    if (binc == 3) {  // 2018-10-11: the indicated buffer-character by number
<span id="line6010"></span>      if (b14 != "") output += b14;  // 2019-06-15: concatenate verb-characters
<span id="line6011"></span>      pho = b14;  // 2019-06-15: for ReEntry()
<span id="line6012"></span>      if (pho &gt; "") ReEntry();  // 2018-10-11: for accumulating record of thought
<span id="line6013"></span>    }  // 2018-10-11: end of outputting character and concatenating for ReEntry().
<span id="line6014"></span>    if (binc == 4) {  // 2018-10-11: the indicated buffer-character by number
<span id="line6015"></span>      if (b13 != "") output += b13;  // 2019-06-15: concatenate verb-characters
<span id="line6016"></span>      pho = b13;  // 2019-06-15: for ReEntry()
<span id="line6017"></span>      if (pho &gt; "") ReEntry();  // 2018-10-11: for accumulating record of thought
<span id="line6018"></span>    }  // 2018-10-11: end of outputting character and concatenating for ReEntry().
<span id="line6019"></span>    if (binc == 5) {  // 2018-10-11: the indicated buffer-character by number
<span id="line6020"></span>      if (b12 != "") output += b12;  // 2019-06-15: concatenate verb-characters
<span id="line6021"></span>      pho = b12;  // 2019-06-15: for ReEntry()
<span id="line6022"></span>      if (pho &gt; "") ReEntry();  // 2018-10-11: for accumulating record of thought
<span id="line6023"></span>    }  // 2018-10-11: end of outputting character and concatenating for ReEntry().
<span id="line6024"></span>    if (binc == 6) {  // 2018-10-11: the indicated buffer-character by number
<span id="line6025"></span>      if (b11 != "") output += b11;  // 2019-06-15: concatenate verb-characters
<span id="line6026"></span>      pho = b11;  // 2019-06-15: for ReEntry()
<span id="line6027"></span>      if (pho &gt; "") ReEntry();  // 2018-10-11: for accumulating record of thought
<span id="line6028"></span>    }  // 2018-10-11: end of outputting character and concatenating for ReEntry().
<span id="line6029"></span>    if (binc == 7) {  // 2018-10-11: the indicated buffer-character by number
<span id="line6030"></span>      if (b10 != "") output += b10;  // 2019-06-15: concatenate verb-characters
<span id="line6031"></span>      pho = b10;  // 2019-06-15: for ReEntry()
<span id="line6032"></span>      if (pho &gt; "") ReEntry();  // 2018-10-11: for accumulating record of thought
<span id="line6033"></span>    }  // 2018-10-11: end of outputting character and concatenating for ReEntry().
<span id="line6034"></span>    if (binc == 8) {  // 2018-10-11: the indicated buffer-character by number
<span id="line6035"></span>      if (b9 != "") output += b9;  // 2019-06-15: concatenate verb-characters
<span id="line6036"></span>      pho = b9;  // 2019-06-15: for ReEntry()
<span id="line6037"></span>      if (pho &gt; "") ReEntry();  // 2018-10-11: for accumulating record of thought
<span id="line6038"></span>    }  // 2018-10-11: end of outputting character and concatenating for ReEntry().
<span id="line6039"></span>    if (binc == 9) {  // 2018-10-11: the indicated buffer-character by number
<span id="line6040"></span>      if (b8 != "") output += b8;  // 2019-06-15: concatenate verb-characters
<span id="line6041"></span>      pho = b8;  // 2019-06-15: for ReEntry()
<span id="line6042"></span>      if (pho &gt; "") ReEntry();  // 2018-10-11: for accumulating record of thought
<span id="line6043"></span>    }  // 2018-10-11: end of outputting character and concatenating for ReEntry().
<span id="line6044"></span>    if (binc == 10) {  // 2018-10-11: the indicated buffer-character by number
<span id="line6045"></span>      if (b7 != "") output += b7;  // 2019-06-15: concatenate verb-characters
<span id="line6046"></span>      pho = b7;  // 2019-06-15: for ReEntry()
<span id="line6047"></span>      if (pho &gt; "") ReEntry();  // 2018-10-11: for accumulating record of thought
<span id="line6048"></span>    }  // 2018-10-11: end of outputting character and concatenating for ReEntry().
<span id="line6049"></span>    if (binc == 11) {  // 2018-10-11: the indicated buffer-character by number
<span id="line6050"></span>      if (b6 != "") output += b6;  // 2019-06-15: concatenate verb-characters
<span id="line6051"></span>      pho = b6;  // 2019-06-15: for ReEntry()
<span id="line6052"></span>      if (pho &gt; "") ReEntry();  // 2018-10-11: for accumulating record of thought
<span id="line6053"></span>    }  // 2018-10-11: end of outputting character and concatenating for ReEntry().
<span id="line6054"></span>    if (binc == 12) {  // 2018-10-11: the indicated buffer-character by number
<span id="line6055"></span>      if (b5 != "") output += b5;  // 2019-06-15: concatenate verb-characters
<span id="line6056"></span>      pho = b5;  // 2019-06-15: for ReEntry()
<span id="line6057"></span>      if (pho &gt; "") ReEntry();  // 2018-10-11: for accumulating record of thought
<span id="line6058"></span>    }  // 2018-10-11: end of outputting character and concatenating for ReEntry().
<span id="line6059"></span>    if (binc == 13) {  // 2018-10-11: the indicated buffer-character by number
<span id="line6060"></span>      if (b4 != "") output += b4;  // 2019-06-15: concatenate verb-characters
<span id="line6061"></span>      pho = b4;  // 2019-06-15: for ReEntry()
<span id="line6062"></span>      if (pho &gt; "") ReEntry();  // 2018-10-11: for accumulating record of thought
<span id="line6063"></span>    }  // 2018-10-11: end of outputting character and concatenating for ReEntry().
<span id="line6064"></span>    if (binc == 14) {  // 2018-10-11: the indicated buffer-character by number
<span id="line6065"></span>      if (b3 != "") output += b3;  // 2019-06-15: concatenate verb-characters
<span id="line6066"></span>      pho = b3;  // 2019-06-15: for ReEntry()
<span id="line6067"></span>      if (pho &gt; "") ReEntry();  // 2018-10-11: for accumulating record of thought
<span id="line6068"></span>    }  // 2018-10-11: end of outputting character and concatenating for ReEntry().
<span id="line6069"></span>    if (binc == 15) {  // 2018-10-11: the indicated buffer-character by number
<span id="line6070"></span>      if (b2 != "") output += b2;  // 2019-06-15: concatenate verb-characters
<span id="line6071"></span>      pho = b2;  // 2019-06-15: for ReEntry()
<span id="line6072"></span>      if (pho &gt; "") ReEntry();  // 2018-10-11: for accumulating record of thought
<span id="line6073"></span>    }  // 2018-10-11: end of outputting character and concatenating for ReEntry().
<span id="line6074"></span>    if (binc == 16) {  // 2018-10-11: the indicated buffer-character by number
<span id="line6075"></span>      if (b1 != "") output += b1;  // 2019-06-15: concatenate verb-characters
<span id="line6076"></span>      pho = b1;  // 2019-06-15: for ReEntry()
<span id="line6077"></span>      if (pho &gt; "") ReEntry();  // 2018-10-11: for accumulating record of thought
<span id="line6078"></span>    }  // 2018-10-11: end of outputting character and concatenating for ReEntry().
<span id="line6079"></span>    binc++;  // 2018-10-11: TEST; REMOVE
<span id="line6080"></span>    pho = aud0;  // 18oct2012
<span id="line6081"></span>    abc = aud0;  // for AudBuffer(); 18oct2012
<span id="line6082"></span>  }  // 2018-10-11: end of looping through OutBuffer().
<span id="line6083"></span>  while (binc </span><span>&lt; </span><span>17);  // 2018-10-11: while inspecting OutBuffer;
<span id="line6084"></span>  c1="";  c2="";  c3="";  c4="";  c5="";  // 2019-06-15
<span id="line6085"></span>  c6="";  c7="";  c8="";  c9="";  c10=""; // 2019-06-15
<span id="line6086"></span>  c11=""; c12=""; c13=""; c14=""; c15=""; // 2018-10-11
<span id="line6087"></span>  c16="";  // 2018-10-11: clear out the AudBuffer.
<span id="line6088"></span>  if (prsn == 1) {  // 2018-10-12: first person;
<span id="line6089"></span>    if (snu == 1)  {  // 2018-10-12: subject-number parameter;
<span id="line6090"></span>     ReEntry();  // 2018-10-12: for accumulating record of thought
<span id="line6091"></span>    }  // 2018-10-12: end of test for singular subject-number;
<span id="line6092"></span>    if (snu == 2)  {  // 2018-10-12: subject-number parameter;
<span id="line6093"></span>     ReEntry();  // 2018-10-12: for accumulating record of thought
<span id="line6094"></span>    }  // 2018-10-12: end of test for plural subject-number;
<span id="line6095"></span>  }  // 2018-10-12: end of test for first person.
<span id="line6096"></span>  if (prsn == 2) {  // 2018-10-12: second person;
<span id="line6097"></span>    if (snu == 1)  {  // 2018-10-12: subject-number parameter;
<span id="line6098"></span>     ReEntry();  // 2018-10-12: for accumulating record of thought
<span id="line6099"></span>    }  // 2018-10-12: end of test for singular subject-number;
<span id="line6100"></span>    if (snu == 2)  {  // 2018-10-12: subject-number parameter;
<span id="line6101"></span>     ReEntry();  // 2018-10-12: for accumulating record of thought
<span id="line6102"></span>    }  // 2018-10-12: end of test for plural subject-number;
<span id="line6103"></span>  }  // 2018-10-12: end of test for second person.
<span id="line6104"></span>  if (prsn == 3) {  // 2018-10-11: third person;
<span id="line6105"></span>    if (snu == 1)  {  // 2018-10-11: subject-number parameter;
<span id="line6106"></span>      if (b2 == "C" &amp;&amp; b1 == "H") {  // 2019-06-15: last two characters in verb-stem
<span id="line6107"></span>      pho = "E";  // 2018-10-11: add an "E" before "S"
<span id="line6108"></span>      output += pho;  // 2018-10-11: inflection
<span id="line6109"></span>      ReEntry();  // 2018-10-11: for accumulating record of thought
<span id="line6110"></span>      }  // 2018-10-11: end of test for verb ending in "-ch"
<span id="line6111"></span>      if (b2 == "S" &amp;&amp; b1 == "H") {  // 2019-06-15: last two characters in verb-stem
<span id="line6112"></span>      pho = "E";  // 2018-10-11: add an "E" before "S"
<span id="line6113"></span>      output += pho;  // 2018-10-11: inflection
<span id="line6114"></span>      ReEntry();  // 2018-10-11: for accumulating record of thought
<span id="line6115"></span>      }  // 2018-10-11: end of test for verb ending in "-sh" 
<span id="line6116"></span>      pho = "S";  // 2018-10-11: add one single "S" 
<span id="line6117"></span>      output += pho;  // 2018-10-11: inflection
<span id="line6118"></span>      ReEntry();  // 2018-10-11: for accumulating record of thought
<span id="line6119"></span>    }  // 2018-10-11: end of test for singular subject-number;
<span id="line6120"></span>    if (snu == 2)  {  // 2018-10-12: subject-number parameter;
<span id="line6121"></span>      ReEntry();  // 2018-10-11: for accumulating record of thought
<span id="line6122"></span>    }  // 2018-10-12: end of test for plural subject-number;
<span id="line6123"></span>  }  // 2018-10-11: end of test for third-person.
<span id="line6124"></span>  output += " ";  // add a space; 18oct2012
<span id="line6125"></span>  Voice();  // 18oct2012
<span id="line6126"></span>  audbase = 0;  // 2018-10-11: prevent carry-over
<span id="line6127"></span>  gencon = 1;   // 2018-10-10: to prevent unwarranted calling of Speech()
<span id="line6128"></span>  prsn = 0;     // 2018-10-11: prevent carry-over
<span id="line6129"></span>  verbpsi = 0;  // 2018-10-11: prevent carry-over
<span id="line6130"></span>}  // 2019-07-31: EnVerbGen() returns to EnVerbPhrase()
<span id="line6131"></span>
<span id="line6132"></span> 
<span id="line6133"></span>function EnVerbPhrase() {  // http://ai.neocities.org/EnVerbPhrase.html
<span id="line6134"></span>  act = 0;  // 2018-01-14: Start with zero to look for psi1 higher than "act".
<span id="line6135"></span>  audjuste = 0;  // 2018-01-14: prevent carry-over
<span id="line6136"></span>  motjuste = 0;  // 2018-01-14: prevent carry-over
<span id="line6137"></span>  negjux = 0;  // 2018-01-14: flag for 250=NOT juxtaposed to a verb;
<span id="line6138"></span>  vphraud = 0;  // 2018-01-14: initially
<span id="line6139"></span>  if (whatcon==1 &amp;&amp; qv2psi==886) {  // 2018-11-28: if WHAT...886=THINK
<span id="line6140"></span>    svo1 = qv1psi;  // 2018-05-13: try to use subject of query as subject of response.
<span id="line6141"></span>    motjuste = 886;  // 2018-11-28: encourage selection of 886=THINK
<span id="line6142"></span>    verbpsi = 886;  // 2018-11-28: let the concept of the verb be 886=THINK
<span id="line6143"></span>    verblock = 0;  // 2018-11-28 let activated 886=THINK win selection.
<span id="line6144"></span>  }  // 2018-11-28: end of test for WHAT...886=THINK query.
<span id="line6145"></span>  if (verblock &gt; 0 &amp;&amp; motjuste != 886) {  // 2018-11-28: positive verblock? 
<span id="line6146"></span>    if (whatcon &gt; 0) {  // 2019-02-12: if SpreadAct() answers a what-query...
<span id="line6147"></span>      if (catverb == motjuste &amp;&amp; conj &gt; 0) {  // 2019-02-12: after a conjunction...
<span id="line6148"></span>        if (nounlock &gt; 0) dirobj = 1;  // 2019-02-12: for sake of direct object.
<span id="line6149"></span>        etc = 0;  // 2019-02-18: abandon the count of active nouns.
<span id="line6150"></span>        EnNounPhrase();  // 2019-02-12: after omitting verb, output direct-object.
<span id="line6151"></span>        return;  // 2019-02-12: omit the verb after the use of a conjunction.
<span id="line6152"></span>      }  // 2019-02-12: end of test for the chain-flag matching the selected verb.
<span id="line6153"></span>    }  // 2019-02-12: end of test for SpreadAct() answering a what-query.
<span id="line6154"></span>    Psy[verblock].psyExam(); // 2018-01-04: inspect t=verblock row;
<span id="line6155"></span>    verbpsi = psi1;  // 2018-01-04: the concept of the verb. 
<span id="line6156"></span>    if (psi5 == 250) negjux = 250;  // 2018-11-14: for negation of verb.
<span id="line6157"></span>    prsn = psi7;    // 2018-11-14: for sake of EnAuxVerb() or EnVerbGen()
<span id="line6158"></span>    subjnum = psi8;  // 2018-11-14: for sake of EnAuxVerb()
<span id="line6159"></span>    if (psi11 &gt; 0) seq = psi11;  // 2019-07-31: capture seq-tag.
<span id="line6160"></span>    if (psi11 &gt; 0) tselp = verblock;  // 2019-07-31: false at first
<span id="line6161"></span>    nounlock = psi14; // 2019-07-31: psi14 tkb becomes nounlock.
<span id="line6162"></span>//  if (psi19 &gt; 0) tpr = psi19;  // 2019-08-04: time-of-preposition
<span id="line6163"></span>    if (psi19 &gt; 0) tvpr = psi19; // 2019-10-24: trap time-of-verb-preposition
<span id="line6164"></span>    if (psi20 &gt; 0) audbase = psi20;  // 2019-07-31: VerbGen() parameter;  
<span id="line6165"></span>    svo2 = psi1; // 2018-01-04: item #2 of subj - verb - ind.obj - dir.obj
<span id="line6166"></span>    if (seq &gt; 0 &amp;&amp; wherecon == 0) {  // 2018-11-13: if seq-tag is positive...
<span id="line6167"></span>      for (i = t; i&gt;midway; --i) {  // 2018-11-13: search backwards in time.
<span id="line6168"></span>        Psy[i].psyExam();  // 2018-11-14 BUGFIX: Examine the Psy concept-array.
<span id="line6169"></span>        if (psi1==seq &amp;&amp; psi6==6) {  // 2018-11-13: if engram matches seq...
<span id="line6170"></span>          prep = psi1;  // 2018-11-13: identify the preposition as such.
<span id="line6171"></span>          break;  // 2018-11-13: exit the loop upon finding the preposition.
<span id="line6172"></span>        }  // 2018-11-13: end of search for a preposition matching the "seq".
<span id="line6173"></span>      } // 2018-11-13: end of backwards loop.
<span id="line6174"></span>      while (eureka != prep) {  // 2018-11-13:  
<span id="line6175"></span>        tselp++;  // 2018-11-13: increment the not-yet-true "tselp" variable 
<span id="line6176"></span>        Psy[tselp].psyExam(); // 2018-11-13: iterate to find "tselp" row in array.
<span id="line6177"></span>        eureka = psi1;  // 2018-11-13: hold whatever is found as "eureka"   
<span id="line6178"></span>        if (tselp &gt; cns) break;  // 2018-11-13: escape from any runaway-loop.
<span id="line6179"></span>      }  // 2018-11-13: 
<span id="line6180"></span>    }  // 2018-11-13: end of test for positive seq-tag.
<span id="line6181"></span>    if (psi20 &gt; 0) aud = psi20; // 2019-07-31: auditory recall-vector
<span id="line6182"></span>    if (psi20 &gt; 0) vphraud = psi20;  // 2019-07-31: auditory recall-vector
<span id="line6183"></span>    if (psi20 == 0) {  // 2019-07-31: if there is no auditory recall-vector "rv"...
<span id="line6184"></span>      for (i = tpu; i&gt;midway; --i) {  // 2018-01-30: search backwards from tpu
<span id="line6185"></span>        Psy[i].psyExam(); // 2018-01-30: inspect Psy flag-panel
<span id="line6186"></span>        if (psi1 == verbpsi &amp;&amp; psi1 != 800 &amp;&amp; negjux != 250) {  // 2018-10-04: if verb found...
<span id="line6187"></span>          if (qv2num &gt; 0) subjnum = qv2num;  // 2018-10-10: for query-response.
<span id="line6188"></span>          if (psi1 == verbpsi &amp;&amp; psi7 == prsn &amp;&amp; psi8 == snu) {  // 2018-10-10:
<span id="line6189"></span>            if (psi20 &gt; 0) aud = psi20;  // 2019-07-31: find positive rv
<span id="line6190"></span>            if (psi20 &gt; 0) vphraud = psi20;  // 2019-07-31: auditory recall-vector
<span id="line6191"></span>            if (psi20 &gt; 0) break;  // 2019-07-31: exit loop if rv is found.
<span id="line6192"></span>          }  // 2018-10-10: end of test to find regular or irregular verb-form
<span id="line6193"></span>        }  // 2018-10-04: end of search for non-infinitive verb-form.
<span id="line6194"></span>        if (psi1 == verbpsi &amp;&amp; negjux == 250) {  // 2018-10-04: if verb is found...
<span id="line6195"></span>          if (psi7==0 &amp;&amp; psi20 &gt; 0) aud = psi20;  // 2019-07-31: find positive rv; 
<span id="line6196"></span>          if (psi7==0 &amp;&amp; psi20 &gt; 0) vphraud = psi20;  // 2019-07-31: auditory rv;
<span id="line6197"></span>          if (psi7==0 &amp;&amp; psi20 &gt; 0) break;  // 2019-07-31: exit loop if rv is found.
<span id="line6198"></span>        }  // 2018-10-04: end of test for negjux requiring infinitive verb.
<span id="line6199"></span>      }  // 2018-01-30: end of for-loop as part of search for recall-vector "rv".
<span id="line6200"></span>    }  // 2018-01-30: end of test for no recall-vector rv as in InFerence()
<span id="line6201"></span>    if (subjpsi==701 || subjpsi==731) prsn=1;  // 2018-01-14: I or WE
<span id="line6202"></span>    if (svo1==701) prsn=1;     // 2018-01-14: I
<span id="line6203"></span>    if (svo1==701) subjnum=1;  // 2018-01-14: I
<span id="line6204"></span>    if (subjpsi==707 || subjpsi==737) prsn=2;  // 2018-01-14: "YOU"
<span id="line6205"></span>    if (subjpsi==713 || subjpsi==719) prsn=3;  // 2018-01-14: HE; SHE
<span id="line6206"></span>    if (subjpsi==725 || subjpsi==743) prsn=3;  // 2018-01-14: IT THEY
<span id="line6207"></span>    dba = prsn;  // 2018-01-14:  parameter for VerbGen()
<span id="line6208"></span>    for (i=tpu; i&gt;midway; i--) {  // 2018-01-14: search Psy array before I/O
<span id="line6209"></span>      Psy[i].psyExam(); // 2018-01-14: examine the Psy concept array...
<span id="line6210"></span>      if (psi1 == verbpsi &amp;&amp; psi1 == 800) {  // 2018-01-14: special 800=BE-verb
<span id="line6211"></span>        if (psi6 == 8) {  // 2018-01-14: select only pos=8 verbs, even homonyms
<span id="line6212"></span>          // Following code accepts only a verb-form matching three 
<span id="line6213"></span>          // requirements: [ ]same concept; [ ]num(ber); and [ ]person:
<span id="line6214"></span>          if (qv2num &gt; 0) subjnum = qv2num;  // 2018-01-14: for query-response.
<span id="line6215"></span>          if (negjux==250) {  // 2018-10-04: 250=NOT requires AuxVerb + infinitive.
<span id="line6216"></span>            if (psi1==verbpsi &amp;&amp; psi7==0) {  // 2018-10-04: 
<span id="line6217"></span>              if (psi20 &gt; 0) aud = psi20;  // 2019-07-31: find positive rv; 
<span id="line6218"></span>              if (psi20 &gt; 0) vphraud = psi20;  // 2019-07-31: find positive rv; 
<span id="line6219"></span>              if (psi20 &gt; 0) break;  // 2019-07-31: exit loop once rv is found.
<span id="line6220"></span>            }  // 2018-10-04: end of test to find regular or irregular verb-form
<span id="line6221"></span>          }  // 2018-10-04: end of test pre-empting inflected verb with infinitive.
<span id="line6222"></span>          if (psi1==verbpsi &amp;&amp; psi8==subjnum &amp;&amp; psi7==prsn) {  // 2018-01-14
<span id="line6223"></span>            if (psi20 &gt; 0) aud = psi20;  // 2019-07-31: find positive rv; 
<span id="line6224"></span>            if (psi20 &gt; 0) vphraud = psi20;  // 2019-07-31: find positive rv; 
<span id="line6225"></span>            if (psi20 &gt; 0) break;  // 2019-07-21: exit loop once rv is found.
<span id="line6226"></span>          }  // 2018-01-14: end of test to find regular or irregular verb-form
<span id="line6227"></span>        }  // 2018-01-14 end of test for part-of-speech pos == "8" (verb)
<span id="line6228"></span>      }  // 2018-01-14: end of test for correct verb-concept verbpsi. 
<span id="line6229"></span>      if (psi1 == verbpsi &amp;&amp; psi1 != 800) {  // 2018-01-14: other than 800=BE
<span id="line6230"></span>        if (psi6 == 8) {  // 2018-01-14: select only pos=8 verbs, even homonyms
<span id="line6231"></span>          if (psi1==verbpsi &amp;&amp; i==verblock) {  // 2018-01-14: zero in.
<span id="line6232"></span>            if (psi20 &gt; 0) aud = psi20;  // 2019-07-31: find positive rv; 
<span id="line6233"></span>            if (psi20 &gt; 0) vphraud = psi20;  // 2019-07-31: find positive rv; 
<span id="line6234"></span>            if (psi20 &gt; 0) break;  // 2019-07-31: exit loop once rv is found.
<span id="line6235"></span>          }  // 2018-01-14: end of test to find regular or irregular verb-form
<span id="line6236"></span>        }  // 2019-01-14: end of test for part-of-speech pos == "8" (verb)
<span id="line6237"></span>      }  // 2018-01-14: end of test for correct verb-concept "verbpsi".
<span id="line6238"></span>    }  // 2018-01-14: End of (for loop) searching for correct verb-form.
<span id="line6239"></span>  }  // 2018-01-04: end of test for verblock.
<span id="line6240"></span>  if (vphraud &gt; 0) aud = vphraud;  // 2018-01-14: correct form?
<span id="line6241"></span>  if (verblock == 0)  {  // 2018-01-14: prevent false negations;
<span id="line6242"></span>    for (i=tpu; i&gt;midway; i--) {  // 2018-01-14: search backwards in time.
<span id="line6243"></span>      Psy[i].psyExam(); // 2018-01-14: examine the Psy concept array...
<span id="line6244"></span>        if (psi6 == 8) {  // 2019-01-14: select only psi6 pos=8 verbs
<span id="line6245"></span>          if (whatcon==1 &amp;&amp; qv2psi==886 &amp;&amp; psi1==886) {  // 2018-11-28:
<span id="line6246"></span>            aud = psi20;  // 2019-07-31: recall-vector "rv" for Speech()
<span id="line6247"></span>            break;  // 2018-11-28: peremptory retrieval of 886=THINK
<span id="line6248"></span>          }  // 2018-11-28: end of test for WHAT...886=THINK query.
<span id="line6249"></span>          if (psi3 &gt; act) {  // 2018-10-04: if psi3 is higher than "act"...
<span id="line6250"></span>            tselv = i;  // 2018-01-14: retain time of winning verb;
<span id="line6251"></span>            motjuste = psi1;  // 2018-01-14: Select the most active verb.
<span id="line6252"></span>            svo2 = psi1;  // 2018-01-14: for calling VisRecog()
<span id="line6253"></span>            subjnum = psi8;  // 2018-10-03: for sake of EnAuxVerb()
<span id="line6254"></span>            if (psi14 &gt; 0) {  // 2019-07-31: if verb has a positive "tkb" dir.obj. 
<span id="line6255"></span>              nounlock = psi14;  // 2019-07-31: for direct-object noun.
<span id="line6256"></span>            } // 2018-12-23: for direct-object noun.
<span id="line6257"></span>            aud = psi20;  // 2019-07-31: recall-vector "rv" for Speech()
<span id="line6258"></span>            act = psi3;  // 2018-10-04: to test for a higher psi3
<span id="line6259"></span>          }  // 2018-01-14: end of test of activation-level. 
<span id="line6260"></span>        }  // 2018-01-14: end of test for part-of-speech pos == "8" verb
<span id="line6261"></span>    }  // 2018-01-14: End of (for loop) searching for most active "motjuste"
<span id="line6262"></span>  }  // 2018-01-14: end of test for absence of a verblock from subject to verb. 
<span id="line6263"></span>  if (negjux == 250) {  // 2018-01-14: if verb is negated with 250=NOT...
<span id="line6264"></span>    if (svo2 != 800) {  // 2018-01-14: if other than an 800=BE verb...
<span id="line6265"></span>      auxverb = 818;  // 2018-11-28: 818=DO as auxiliary verb; 
<span id="line6266"></span>      if (subjnum==0 &amp;&amp; num != 0) subjnum = num;  // 2018-10-03: assumption.
<span id="line6267"></span>      prsn = 3;  // 2018-10-03: default assumption before contradiction.
<span id="line6268"></span>      if (subjpsi==701) subjnum = 1;  // 2018-10-03: 701=I
<span id="line6269"></span>      if (subjpsi==701) prsn = 1;  // 2018-10-01: 701=I
<span id="line6270"></span>      if (svo1==701) subjnum = 1;  // 2018-10-03: 701=I   
<span id="line6271"></span>      if (svo1==701) prsn = 1;  // 2018-10-01: 701=I   
<span id="line6272"></span>      EnAuxVerb();  // 2018-11-28: to say 818=DO or "DOES";
<span id="line6273"></span>      auxverb = 0;  // 2018-01-14: reset for safety.
<span id="line6274"></span>      for (i=tpu; i&gt;midway; i--) {  // 2018-01-14: search for 250=NOT
<span id="line6275"></span>        Psy[i].psyExam(); // 2018-01-14: examine the Psy concept array...
<span id="line6276"></span>        if (psi1 == 250) {  // 2018-01-14: if 250=NOT is found...
<span id="line6277"></span>          aud = psi20;  // 2019-07-31: "NOT" recall-vector for Speech()
<span id="line6278"></span>          if (psi20 &gt; 0) aud=psi20;  // 2019-07-31: recall-vector
<span id="line6279"></span>          if (psi20 &gt; 0) break;  // 2019-07-31: insurance
<span id="line6280"></span>        }  // 2018-01-14: End of search for 250=NOT;
<span id="line6281"></span>      }  // 2018-01-14: End of search loop back to midway.
<span id="line6282"></span>      Speech();  // 2018-01-14: speak the word starting at the "aud" time. 
<span id="line6283"></span>      aud = 0;     // 2018-06-12: reset for safety.
<span id="line6284"></span>    }  // 2018-01-14: end of test to prevent auxiliary with 800=BE verb.
<span id="line6285"></span>  }  // 2018-01-14: end of test for 250=NOT negjux.
<span id="line6286"></span>  motjuste = verbpsi;    // 2018-10-10: to search for verb-form.
<span id="line6287"></span>  if (vphraud != 0) aud = vphraud;  // 2018-01-14: Accept rv of 3 parameters.
<span id="line6288"></span>  if (subjpsi == 701) dba = 1;  // 2018-01-14: "I" 1st person sing.
<span id="line6289"></span>  if (subjpsi == 707) dba = 2;  // 2018-01-14: "you" 2nd person sing.
<span id="line6290"></span>  if (subjpsi == 713) dba = 3;  // 2018-01-14: "he" 3rd person sing;
<span id="line6291"></span>  if (subjpsi == 719) dba = 3;  // 2018-01-14: "she" 3rd person sing.
<span id="line6292"></span>  if (subjpsi == 725) dba = 3;  // 2018-01-14: "it" 3rd person sing.
<span id="line6293"></span>  if (subjpsi == 731) dba = 1;  // 2018-01-14: "we" 1st person plural
<span id="line6294"></span>  if (subjpsi == 737) dba = 2;  // 2018-01-14: "you" 2nd person plural
<span id="line6295"></span>  if (subjpsi == 743) dba = 3;  // 2018-01-14: "they" 3rd person plural
<span id="line6296"></span>  if (vphraud == 0) {  // 2018-01-14: if not substituted above...
<span id="line6297"></span>    for (i=tpu; i&gt;midway; i--) {  // 2018-01-14: skip current engrams.
<span id="line6298"></span>      svo2 = motjuste;  // 2018-01-14: TEST; REMOVE
<span id="line6299"></span>      if (psi1 == verbpsi &amp;&amp; psi20 &gt; 0) audbase = psi20;  // 2019-07-31: 2nd best
<span id="line6300"></span>      if (psi1 == verbpsi &amp;&amp; psi7 == 0 &amp;&amp; psi20 &gt; 0) audbase = psi20;  // 2019-07-31
<span id="line6301"></span>      if (psi1 == verbpsi &amp;&amp; psi7 == prsn &amp;&amp; psi8 == nphrnum) {  // 2018-10-10
<span id="line6302"></span>        vphraud = psi20;  // 2019-07-31: VerbPhrase auditory engram tag
<span id="line6303"></span>      }  // 2018-10-10: end of test to find regular or irregular verb-form
<span id="line6304"></span>      if (negjux==250) dba=0;  // 2018-10-04: after "NOT" use infinitive
<span id="line6305"></span>      if (psi7 == dba)  {  // 2018-01-14: for proper person;
<span id="line6306"></span>        if (psi8 == snu) {  // 2018-01-14: subject num(ber) parameter; 
<span id="line6307"></span>          vphraud = psi20;  // 2019-07-31: auditory recall-vector; 
<span id="line6308"></span>          break;  // 2018-01-14:  exit the loop after first find. 
<span id="line6309"></span>        }  // 2018-01-14: end of subject number-parameter test; 
<span id="line6310"></span>      }  // 2018-01-14: end of dba-parameter test.
<span id="line6311"></span>    }  // 2018-01-14: end of (for loop) searching through Psy conceptual array.
<span id="line6312"></span>  }  // 2018-01-14: end of test of vphraud.
<span id="line6313"></span>  if (vphraud == 0) EnVerbGen();  // 2018-10-10: if no verb-form, generate it.
<span id="line6314"></span>  if (vphraud &gt; 0) aud = vphraud;  // 2018-01-14: correct form?
<span id="line6315"></span>  if (svo2 == 800) numreq = subjnum;  // 2018-05-25: for fetching predicate nominative. 
<span id="line6316"></span>  Speech();  // 2018-01-14: main call from EnVerbPhrase() to Speech()
<span id="line6317"></span>  aud = 0;  // 2018-01-14: Reset to prevent carry-over. 
<span id="line6318"></span>  Psy[tselv].psyExam(); // 2018-01-14: inspect verb for inhibition at time of selection.
<span id="line6319"></span>  Psy[tselv] = new 
<span id="line6320"></span>  psyNode(psi0,psi1,psi2,-16,psi4,psi5,psi6,
<span id="line6321"></span>  psi7,psi8,psi9,psi10,psi11,psi12,psi13,
<span id="line6322"></span>  psi14,psi15,psi16,psi17,psi18,psi19,psi20); // 2019-07-31: expanded flag-panel
<span id="line6323"></span>  // Above line inserts neural inhibition upon currently selected verb. 
<span id="line6324"></span>  if (tpr &gt; 0) {  // 2019-08-04: if there is a positive time-of-preposition
<span id="line6325"></span>    EnPrep();  // 2019-08-04: for a prepositional phrase
<span id="line6326"></span>    tpr = 0;   // 2019-09-22: reset for safety.
<span id="line6327"></span>  }  // 2019-08-04: end of test for a preposition linked to the verb.
<span id="line6328"></span>  if (tselp &gt; 0 &amp;&amp; prep &gt; 0 &amp;&amp; wherecon == 0) {  // 2018-11-13: preposition?
<span id="line6329"></span>    SpreadAct();  // 2018-11-13: to generate a prepositional phrase
<span id="line6330"></span>    prep = 0;     // 2018-11-13: reset to prevent carry-over.
<span id="line6331"></span>  }  // 2018-11-13: end of test for conditions warranting SpreadAct for preposition.
<span id="line6332"></span>  if (svo2 == 800) {  // 2018-01-14: if the selected verb is a be-verb
<span id="line6333"></span>    if (negjux == 250) {  // 2018-01-14: if there is a 250=NOT negation flag...
<span id="line6334"></span>      for (i=tpu; i&gt;midway; i--) {  // 2018-01-14: search for 250=NOT
<span id="line6335"></span>        Psy[i].psyExam(); // 2018-01-14: examine the Psy concept array...
<span id="line6336"></span>        if (psi1 == 250) {  // 2018-01-14: if 250=NOT is found...
<span id="line6337"></span>          if (psi20 &gt; 0) aud = psi20;  // 2019-07-31: auditory recall vector
<span id="line6338"></span>          Speech();  // 2018-06-12: speak the word starting at the "aud" time. 
<span id="line6339"></span>          aud = 0;  // 2018-06-12: reset for safety.
<span id="line6340"></span>          negjux = 0;  // 2018-01-14: reset for safety. 
<span id="line6341"></span>          if (psi20 &gt; 0) break; // 2019-07-31: insurance
<span id="line6342"></span>        }  // 2018-01-14: End of search for 250=NOT.
<span id="line6343"></span>      }  // 2018-01-14: End of search loop back to midway.
<span id="line6344"></span>      negjux = 0;  // 2018-01-14: reset for safety. 
<span id="line6345"></span>    }  // 2018-01-14: end of test for negated be-verb.
<span id="line6346"></span>  }  // 2018-01-14: end of test for 800=BE verb in case of negation.
<span id="line6347"></span>  if (svo2 != 800) negjux = 0;  // 2018-06-12: reset after one chance to matter.
<span id="line6348"></span>  if (nounlock &gt; 0) dirobj = 1;  // 2018-10-04: for sake of intransitive verbs.
<span id="line6349"></span>  if (subjpsi == 701) {  // 2018-01-14: only for subject 701=I;
<span id="line6350"></span>    if (svo2 == 823) {  // 2019-11-07: only for verb 823=FEEL;
<span id="line6351"></span>      if (svo4 == 0) {  // 2019-11-07: if 823=FEEL has no direct object
<span id="line6352"></span>        TacRecog();  // 2019-11-07: to supply a direct object for 823=FEEL
<span id="line6353"></span>        if (haptac != 755) EnArticle();  // 2019-11-07: insert "A" or "THE"
<span id="line6354"></span>        for (i=tpu; i&gt;midway; i--) {  // 2019-11-07: search backwards in time.
<span id="line6355"></span>          Psy[i].psyExam(); // 2019-11-07: inspect the Psy concept flag-panel 
<span id="line6356"></span>          if (psi1 == haptac) {  // 2019-11-07: if sensation reported by TacRecog()
<span id="line6357"></span>            aud = psi20;  // 2019-11-07: fetch auditory recall tag for Speech()
<span id="line6358"></span>            Speech();  // 2019-11-07: speak the name of the reported sensation.
<span id="line6359"></span>            hap = 0;     // 2019-11-07: reset after use. 
<span id="line6360"></span>            haptac = 0;  // 2019-11-07: reset after use.
<span id="line6361"></span>            break;  // 2019-11-07: one engram is enough.
<span id="line6362"></span>          }  // 2019-11-07: end of test for "haptac" as reported by TacRecog.
<span id="line6363"></span>        }  // 2019-11-07: end of loop searching for object of 823=FEEL.
<span id="line6364"></span>        return;  // 2019-11-07: abandon the rest of EnVerbPhrase()
<span id="line6365"></span>      }  // 2019-11-07: end of test for direct object. 
<span id="line6366"></span>    }  // 2019-11-07: end of test for verb "823=FEEL".
<span id="line6367"></span>    if (svo2 == 870) {   // 2018-12-09: only for verb 870=SEE;
<span id="line6368"></span>      if (svo4 == 0) {  // 2018-01-14: if SEE has no direct object...
<span id="line6369"></span>      // 2018-01-14: i.e., if there is no robot camera for computer vision...
<span id="line6370"></span>        VisRecog();  // 2018-01-14: a challenge for robot AI coders.
<span id="line6371"></span>        svo2 = 0;  // 2018-01-14: reset for safety.
<span id="line6372"></span>        svo4 = 0;  // 2018-01-14: reset for safety.
<span id="line6373"></span>        return;    // 2018-01-14: abandon rest of VerbPhrase()
<span id="line6374"></span>      }  // 2018-01-14: end of test for direct object. 
<span id="line6375"></span>    }  // 2018-12-09: end of test for "870=SEE".
<span id="line6376"></span>  }  // 2018-01-14: end of test for ego-concept 701=I as subject.
<span id="line6377"></span>  if (dirobj==1 &amp;&amp; qv2psi != 886 &amp;&amp; dunnocon != 1) {  // 2018-11-28: 886=THINK
<span id="line6378"></span>    EnNounPhrase();  // 2018-01-04: for direct object or predicate nominative 
<span id="line6379"></span>  }  // 2018-10-06: end of tests for fetching a direct object.
<span id="line6380"></span>  if (tvpr &gt; 0) {  // 2019-10-24: if there is a positive time-of-verb-preposition
<span id="line6381"></span>    EnPrep();  // 2019-09-20: for a prepositional phrase
<span id="line6382"></span>    tvpr = 0;  // 2019-10-24: reset for safety.
<span id="line6383"></span>  }  // 2019-09-20: end of test for a preposition linked to the verb.
<span id="line6384"></span>  if (dirobj==0 &amp;&amp; qv2psi==886) {  // 2018-11-28: special for 886=THINK
<span id="line6385"></span>    conj = 361;  // 2018-11-26: prepare to use 361=THAT conjunction
<span id="line6386"></span>    ConJoin();  // 2018-10-06: use conjunction
<span id="line6387"></span>  }  // 2018-11-28: end of test for 886=THINK 
<span id="line6388"></span>  if (whatcon==0 &amp;&amp; actpsi &gt; 0) {  // 2018-10-02: if there is activation to spread...
<span id="line6389"></span>    SpreadAct();  // 2018-06-03: for a chain of thought.
<span id="line6390"></span>    actpsi = 0;  // 2018-06-03: reset to zero for safety 
<span id="line6391"></span>  }  // 2018-05-13: end of whatcon-test to fetch conjunction instead of object.
<span id="line6392"></span>  dirobj = 0;  // 2018-01-14: reset flag after thinking direct object. 
<span id="line6393"></span>  if (prepgen &gt; 0) EnPrep();  // 2018-01-14: if "Where?" call EnPrep(). 
<span id="line6394"></span>  audbase = 0;  // 2018-01-14: reset for safety.  
<span id="line6395"></span>  negjux - 0;   // 2018-10-04: prevent carry-over.   
<span id="line6396"></span>  num = 0;      // 2017-01-14: reset after output of one query-response.  
<span id="line6397"></span>  qv2num = 0;   // 2017-01-14: reset after output of one query-response. 
<span id="line6398"></span>}  // 2019-10-24: EnVerbPhrase() returns to Indicative() module.
<span id="line6399"></span>
<span id="line6400"></span>
<span id="line6401"></span>function InFerence() {  // http://ai.neocities.org/InFerence.html 
<span id="line6402"></span>  moot = 1;  // prevent interference via tag-forming; 18mar2013
<span id="line6403"></span>  apb = "If silent inference is made, answer question to confirm or refute.";
<span id="line6404"></span>  Voice();  // 23mar2013
<span id="line6405"></span>  if (prednom &gt; 0) {  // positive predicate nominative? 18mar2013
<span id="line6406"></span>    for (i = tpu; i&gt;midway; i--) {  // 2018-01-25: search KB to infer facts.
<span id="line6407"></span>      Psy[i].psyExam(); // 2018-01-25: examine Psy concept-array;
<span id="line6408"></span>      // 20mar2013 Let only plural KB subjects be basis for InFerence:
<span id="line6409"></span>      if (prednom == psi1 &amp;&amp; psi8 == 2) {  // 2018-01-25: plural KB data?
<span id="line6410"></span>        if (psi7 == 1) {  // 2018-01-25: dba nominative for subject?
<span id="line6411"></span>          if (seqverb == 0) {  // only once; 18mar2013
<span id="line6412"></span>            seqtkb = psi14;  // 2019-07-27: hold for fetching same direct object; 
<span id="line6413"></span>            seqverb = psi11;  // 2019-07-27: hold to be the verb of an inference.
<span id="line6414"></span>            quverb = psi11;  // 2019-07-27: query-verb for AskUser; 
<span id="line6415"></span>            ynverb = 0;  // 2018-01-25: since lacking, use quverb for AskUser()
<span id="line6416"></span>            seq = seqverb;  // 2018-01-25: to be inferred as applying to subject. 
<span id="line6417"></span>          }  // 2018-01-25: end of test that no "seqverb" has yet been declared.
<span id="line6418"></span>        }  // 2018-01-25: end of test that "prednom" does occur in nominative.
<span id="line6419"></span>      } // 2018-01-25: end of test for a fact about the "prednom" as plural subject. 
<span id="line6420"></span>    }  // 2018-01-25: end of backwards loop in search of inferrable knowledge. 
<span id="line6421"></span>  }  // 2018-01-25: end of test for positive predicate nominative. 
<span id="line6422"></span>  if (seqverb &gt; 0) {  // verb available for inference? 18mar2013
<span id="line6423"></span>    inft = t;  // for AskUser to find auditory engrams 18mar2013
<span id="line6424"></span>    t = (t+1);  // increment time "t" by one for a gap; 18mar2013
<span id="line6425"></span>    t = (t+1);  // increment time to create an inference; 18mar2013 
<span id="line6426"></span>    Psy[t].psyExam(); // 2018-01-25: expose row where no values are present;
<span id="line6427"></span>    psi7 = 1;  // 2018-10-11: subject noun serves as 1=nominative
<span id="line6428"></span>    psi8 = 1;  // 2018-10-11: assumed singular because of Is-A quality. 
<span id="line6429"></span>    seq = seqverb;  // prevent override? 18mar2013  
<span id="line6430"></span>    psi14 = (t+1);  // 2019-07-27: psi13=tkb, which is one unit later; 
<span id="line6431"></span>    Psy[t] = new  // 2018-01-25: psi1 subjnom; psi3 act; psi6 pos; psi8 qusnum; psi11 seq;
<span id="line6432"></span>    psyNode(psi0,subjnom,psi2,48,psi4,psi5,5,
<span id="line6433"></span>    1,1,0,psi10,seqverb,psi12,psi13,
<span id="line6434"></span>    psi14.psi15,psi16,psi17,psi18,psi19,psi20); // 2019-07-27
<span id="line6435"></span>    tkbn = t;  // 2018-01-28: conceptual array-time for subject-noun of AskUser query. 
<span id="line6436"></span>    t = (t+1);  // 2018-01-25: increment t for storage of inference-verb; 
<span id="line6437"></span>    Psy[seqtkb].psyExam(); // 2018-01-25: obtain dobseq from Psy array; 
<span id="line6438"></span>    dobseq = psi11;  // 2019-07-27: to serve as psi11 "seq" in next insertion; 
<span id="line6439"></span>    quobj = dobseq;  // 2018-01-25: so AskUser() will use the particular dir.obj. 
<span id="line6440"></span>    Psy[t].psyExam(); // 2018-01-25: expose values for change of some; 
<span id="line6441"></span>    Psy[t] = new  // 2018-01-25: psi1 seqverb; 6 pos; 10 pre; 12 dobseq; 13 tkb;
<span id="line6442"></span>// psyNode(psi0,seqverb,psi2,psi3,psi4,psi5,8,3,1,psi9,subjnom,psi11,dobseq,(t+1),psi14);
<span id="line6443"></span>    psyNode(psi0,seqverb,psi2,psi3,psi4,psi5,8,
<span id="line6444"></span>    3,1,psi9,subjnom,psi11,dobseq,psi13,
<span id="line6445"></span>    (t+1),psi15,psi16,psi17,psi18,psi19,psi20); // 2019-07-27
<span id="line6446"></span>    tkbv = t;  // 2018-01-28: conceptual array-time for verb of AskUser query. 
<span id="line6447"></span>    t = (t+1);  // 2018-01-25: increment time to store direct object; 
<span id="line6448"></span>    tkbo = t;   // 2018-01-29: conceptual array-time for object-noun of AskUser query. 
<span id="line6449"></span>    Psy[seqtkb].psyExam(); // 2018-01-25: obtain seqdob from Psy array; 
<span id="line6450"></span>    seqdob = psi11;  // 2019-07-27: to serve as "psi1" in next insertion;
<span id="line6451"></span>    seqrvx = psi20;  // 2019-07-27: to serve as "psi20" in next insertion; 
<span id="line6452"></span>    Psy[t].psyExam(); // 2018-01-25: expose values for change of some; 
<span id="line6453"></span>    psi8 = 2; // 2018-12-16: plural object as required for an inference.
<span id="line6454"></span>    Psy[t] = new  // 2018-01-25: psi1 seqverb; 6 pos; 10 pre; 11 dobseq; 14 tkb;
<span id="line6455"></span>    psyNode(psi0,seqdob,psi2,40,psi4,psi5,psi6,
<span id="line6456"></span>    psi7,psi8,psi9,psi10,psi11,psi12,psi13,
<span id="line6457"></span>    psi14,psi15,psi16,psi17,psi18,psi19,seqrvx); // 2019-07-27
<span id="line6458"></span>    quobj = dobseq;  // 2018-01-25: for transfer to AskUser; 
<span id="line6459"></span>    t = (t+1);  // 2018-01-25: increment time "t" for an ending gap; 
<span id="line6460"></span>    yncon = 1;  // 2018-01-25: for AskUser() to ask yes-or-no question;
<span id="line6461"></span>    qusub = subjnom;  // 2018-01-25: for transfer to AskUser(); 
<span id="line6462"></span>  }  // 2018-01-25: end of test for a verb to be part of inference.
<span id="line6463"></span>  becon = 0;  // 2018-01-25: reset after use; 
<span id="line6464"></span>  dobseq = 0;  // 2018-01-25: reset after use; 18mar2013
<span id="line6465"></span>  moot = 0;  // 2018-01-25: reset after use; 18mar2013
<span id="line6466"></span>  prednom = 0;  // 2018-01-25: reset after use; 18mar2013
<span id="line6467"></span>  seqdob = 0;  // 2018-01-25: reset after use; 18mar2013
<span id="line6468"></span>  seqrvx = 0;  // 2018-01-25: reset after use;
<span id="line6469"></span>  seqtkb = 0;  // 2018-01-25: reset after use;
<span id="line6470"></span>  seqverb = 0;  // 2018-01-25: reset after use; 
<span id="line6471"></span>  subjnom = 0;  // 2018-01-25: reset after use;
<span id="line6472"></span>}  // 2019-07-31: InFerence() returns to EnThink()
<span id="line6473"></span>
<span id="line6474"></span>
<span id="line6475"></span>function Indicative() {  // http://ai.neocities.org/Indicative.html 
<span id="line6476"></span>  moot = 0;  // 2018-01-21: start with no suppression of associative tags. 
<span id="line6477"></span>  pov = 1;      // 2018-01-21: thinking occurs in self or "I" mode.
<span id="line6478"></span>  rv = 0;       // 2018-01-21: lest rv fail to be at zero for AudInput()
<span id="line6479"></span>  tdo = 0;      // 2018-01-21: reset time-of-direct-object for safety. 
<span id="line6480"></span>  tkb = 0;      // 2019-09-20: prevent a persisting value. 
<span id="line6481"></span>  tpr = 0;      // 2019-09-20: prevent a persisting value. 
<span id="line6482"></span>  qucon = 0;    // 2018-01-21: reset for safety. 
<span id="line6483"></span>  verbcon = 0;  // 2019-02-12: reset for safety
<span id="line6484"></span>  verblock = 0; // 2019-09-20: reset for safety.
<span id="line6485"></span>  if (dunnocon == 1) {  // 2018-10-01: if AI cannot answer a query with knowledge
<span id="line6486"></span>    for (i=vault; i&gt;0; i--) {  // 2018-10-01: search backwards in KB "vault"
<span id="line6487"></span>      Psy[i].psyExam(); // 2018-10-01: inspect the Psy concept flag-panel 
<span id="line6488"></span>        if (psi1==701 &amp;&amp; psi12==838) {  // 2018-11-28: if I...KNOW...
<span id="line6489"></span>          psi0 = 32;  // 2018-10-01: elevate activation of truth-value tru
<span id="line6490"></span>          psi3 = 256;  // 2018-10-01: highly activate "I DO NOT KNOW"
<span id="line6491"></span>          psi5 = 250;  // 2018-10-01: make sure "KNOW" is negated.
<span id="line6492"></span>          Psy[i] = new  // 2018-10-01: inserting new values into flag-panel.
<span id="line6493"></span>          psyNode(psi0,psi1,psi2,psi3,psi4,psi5,psi6,
<span id="line6494"></span>          psi7,psi8,psi9,psi10,psi11,psi12,psi13,
<span id="line6495"></span>          psi14,psi15,psi16,psi17,psi18,psi19,psi20); // 2019-07-31: expanded flag-panel
<span id="line6496"></span>          break;  // 2018-10-01: skip rest of KB vault.
<span id="line6497"></span>        }  // 2018-11-28: end of test for 701=I and 838=KNOW.
<span id="line6498"></span>      }  // 2018-10-01: End of search loop from vault down to t=zero.
<span id="line6499"></span>  }  // 2018-10-01: end of test for flag requiring answer "I DO NOT KNOW". 
<span id="line6500"></span>  EnNounPhrase();  // 2018-01-12: fetch noun or pronoun as subject of thought.
<span id="line6501"></span>  EnVerbPhrase();  // 2018-01-01: call the module to select an English verb.
<span id="line6502"></span>  if (dunnocon == 1) {  // 2018-10-02: prepare to change flag after output...
<span id="line6503"></span>    for (i=vault; i&gt;0; i--) {  // 2018-10-02: search KB vault.
<span id="line6504"></span>      Psy[i].psyExam(); // 2018-10-02: inspect the Psy concept flag-panel 
<span id="line6505"></span>        if (psi1==701 &amp;&amp; psi12==838) {  // 2018-11-28: if I...KNOW...
<span id="line6506"></span>          psi0 = 0;  // 2018-10-02: remove activation of truth-value "tru"
<span id="line6507"></span>          psi3 = 0;  // 2018-10-02: remove activation from  "I DO NOT KNOW"
<span id="line6508"></span>          Psy[i] = new  // 2018-10-02: changing the values in the flag-panel.
<span id="line6509"></span>          psyNode(psi0,psi1,psi2,psi3,psi4,psi5,psi6,
<span id="line6510"></span>          psi7,psi8,psi9,psi10,psi11,psi12,psi13,
<span id="line6511"></span>          psi14,psi15,psi16,psi17,psi18i,psi19,psi20); // 2019-07-31: flag-panel.
<span id="line6512"></span>          break;  // 2018-10-02: skip rest of KB vault.
<span id="line6513"></span>        }  // 2018-11-28: end of test for 701=I and 838=KNOW.
<span id="line6514"></span>      }  // 2018-10-02: End of search loop from vault down to t=zero.
<span id="line6515"></span>      dunnocon = 0;  // 2018-10-02: zero out to prevent carry-over.
<span id="line6516"></span>      snu = 0;  // 2018-10-10: prevent carry-over
<span id="line6517"></span>      whatcon = 0;   // 2018-10-02: TEST
<span id="line6518"></span>  }  // 2018-10-01: end of test for "dunnocon" flag after its output.
<span id="line6519"></span>  mri = 0;      // 2019-09-21: reset for safety.
<span id="line6520"></span>  nounlock = 0;  // 2018-01-21: reset for safety. 
<span id="line6521"></span>  qucon = 0;    // 2018-01-21: reset to prevent unwarranted SpreadAct()
<span id="line6522"></span>  qv2num = 0;   // 2018-01-21: reset after output of one query-response. 
<span id="line6523"></span>  qv1psi = 0;   // 2018-01-21: reset SpreadAct subject-psi for safety.
<span id="line6524"></span>  qv2psi = 0;   // 2018-01-21: reset SpreadAct verb-psi for safety.
<span id="line6525"></span>  svo1 = 0;     // 2018-01-21: reset subject-verb-object values for safety.
<span id="line6526"></span>  svo2 = 0;     // 2018-01-21: reset subject-verb-object values for safety.
<span id="line6527"></span>  svo3 = 0;     // 2018-01-21: reset subject-verb-object values for safety.
<span id="line6528"></span>  svo4 = 0;     // 2018-01-21: reset subject-verb-object values for safety.
<span id="line6529"></span>  seqpsi = 0;   // 2018-01-21: reset for the sake of SpreadAct()
<span id="line6530"></span>  tvb = 0;      // 2019-03-14: prevent interference in EnParser()
<span id="line6531"></span>  verblock = 0; // 2018-01-21: reset for safety.
<span id="line6532"></span>  PsiDecay();  // 2018-01--12: Reduce conceptual activation after each thought.
<span id="line6533"></span>  pov = 2;     // 2019-02-12: give human user a "pause" for input...
<span id="line6534"></span>  bias = 5;    // 2018-01-30: expect a noun, in case user inputs unknown word. 
<span id="line6535"></span>}  // 2019-07-31: Indicative() returns to EnThink().  
<span id="line6536"></span>
<span id="line6537"></span>
<span id="line6538"></span>function Imperative() {  // 2018-01-14
<span id="line6539"></span>  // 2018-01-14: mind-module stubbed in for issueing command.
<span id="line6540"></span>  moot = 1;  // 2018-09-21: prevent forming of associative tags.
<span id="line6541"></span>  output = "";  // 2018-09-21: remove any previous output-display.
<span id="line6542"></span>  for (i = vault; i&gt;midway; i--) {  // 2018-09-21: "vault" is reliable.
<span id="line6543"></span>    Psy[i].psyExam(); //  2018-09-21: examine conceptual Psy array;
<span id="line6544"></span>    if (psi1==884) {  // 2018-11-28: 884=TEACH; 
<span id="line6545"></span>      aud = psi20;  // 2019-07-31: auditory recall-vector; 
<span id="line6546"></span>      break;  // 2018-09-21: one example is enough.
<span id="line6547"></span>    }  // 2018-11-28: end of test for #884=TEACH 
<span id="line6548"></span>  }  // 2018-09-21: end of backwards loop; 
<span id="line6549"></span>  Speech();  // 2018-09-21: speak the word "TEACH" 
<span id="line6550"></span>  Voice();  // 2018-09-21: makes the message appear on-screen.
<span id="line6551"></span>  for (i = vault; i&gt;midway; i--) {  // 2018-09-21: "vault" is reliable.
<span id="line6552"></span>    Psy[i].psyExam(); //  2018-09-21: examine conceptual Psy array;
<span id="line6553"></span>    if (psi1==701 &amp;&amp; psi7 == 3) {  // 2018-09-21: dative 701=ME
<span id="line6554"></span>      aud = psi20;  // 2019-07-31: auditory recall-vector; 
<span id="line6555"></span>      break;  // 2018-09-21: one example is enough.
<span id="line6556"></span>    }  // 2018-01-26: end of test for #701=ME 
<span id="line6557"></span>  }  // 2018-09-21: end of backwards loop; 
<span id="line6558"></span>  Speech();  // 2018-09-21: speak the word "ME" 
<span id="line6559"></span>  Voice();  // 2018-09-21: makes the message appear on-screen.
<span id="line6560"></span>  for (i = vault; i&gt;midway; i--) {  // 2018-09-21: "vault" is reliable.
<span id="line6561"></span>    Psy[i].psyExam(); //  2018-09-21: examine conceptual Psy array;
<span id="line6562"></span>    if (psi1==755) {  // 2018-09-21: 755=SOMETHING; 
<span id="line6563"></span>      aud = psi20;  // 2019-07-31: auditory recall-vector; 
<span id="line6564"></span>      break;  // 2018-09-21: one example is enough.
<span id="line6565"></span>    }  // 2018-01-26: end of test for #755=SOMETHING 
<span id="line6566"></span>  }  // 2018-09-21: end of backwards loop; 
<span id="line6567"></span>  Speech();  // 2018-09-21: speak the word "SOMETHING" 
<span id="line6568"></span>  Voice();  // 2018-09-21: makes the message appear on-screen.
<span id="line6569"></span>  moot = 0;  // 2018-09-21: end prevention of associative tags.
<span id="line6570"></span>}  // 2019-07-31: Imperative() returns to the EnThink() module.
<span id="line6571"></span>
<span id="line6572"></span>
<span id="line6573"></span>function EnThink() {  // http://ai.neocities.org/EnThink.html
<span id="line6574"></span>  document.forms[1].elements[0].value = ""; // 2019-11-07: remove visible user input
<span id="line6575"></span>  catsubj = 0;  // 2019-02-12: reset for safety;
<span id="line6576"></span>  catverb = 0;  // 2019-02-12: reset for safety.
<span id="line6577"></span>  prep = 0;  // 2018-11-13: in case "prep" was set by EnParser()
<span id="line6578"></span>  tdo = 0;      // 2018-07-12: reset time-of-direct-object for safety. 
<span id="line6579"></span>  tkb = 0;  // 2018-07-12: reset for safety. 
<span id="line6580"></span>  tpr = 0;  // 2019-08-04: reset after service as flag-panel tag for concepts.
<span id="line6581"></span>  inert = (inert + 1);  // 2018-01-20: but AudListen() resets to zero;
<span id="line6582"></span>  lurk = (lurk + 1);    // 2018-01-20: AudListen() resets to zero; 
<span id="line6583"></span>  if (isolation &gt; 60) {  // 2018-11-14: if no input for arbitrary duration...
<span id="line6584"></span>    Imperative();  // 2018-09-21: Issue a request for input from a human user.
<span id="line6585"></span>    impetus = 0;   // 2018-09-21: reset the trigger for calling Imperative().
<span id="line6586"></span>    isolation = 0; // 2018-10-03: reset the trigger for calling Imperative().
<span id="line6587"></span>    return;  // 2018-09-21: abandon EnThink(); give human user a chance to respond. 
<span id="line6588"></span>  }  // 2018-09-21: end of test for trigger to call Imperative()
<span id="line6589"></span>  if (qucon==1 || whatcon==1 || wherecon==1) SpreadAct();  // 2018-10-28: 
<span id="line6590"></span>  apb = "EnThink() at time = "+t+"; rejuvenations = "+rjc+"; since dob "+dob; // 2018-01-24:
<span id="line6591"></span>  Voice();  // 2018-01-20: speak the all-points-bulletin "apb"; 
<span id="line6592"></span>  if (kbcon &gt; 0) {  // 2018-01-28: if user answers yes-or-no question; 
<span id="line6593"></span>    KbRetro();  // 2018-01-28: retroactively adjust knowledge base; 
<span id="line6594"></span>    kbcon = 0;  // 2018-01-28: reset for safety; 
<span id="line6595"></span>    kbzap = 0;  // 2018-01-28: reset for safety.
<span id="line6596"></span>  }  // 2018-01-28: User has had one chance to answer yes-or-no question.
<span id="line6597"></span>  inft = t;  // 2018-01-25: in case inference-time not otherwise set; 
<span id="line6598"></span>  if (becon == 1) {  // 2018-01-25: if user input includes 800=BE-verb...
<span id="line6599"></span>    InFerence(); // 2018-01-25: make a silent inference; 
<span id="line6600"></span>  }  // 2018-01-25: end of test for incoming be-verb.
<span id="line6601"></span>  if (yncon == 1) {  // 2018-01-25: set in the InFerence() module
<span id="line6602"></span>    tdo = 0;  // 2018-07-12: prevent carry-over. 
<span id="line6603"></span>    AskUser();  // 2018-01-25: for yes-or-no query; 
<span id="line6604"></span>    return;  // 2018-01-25: abandon the rest of EnThink()
<span id="line6605"></span>  }  // 2018-01-25: end of test to trigger asking a question.
<span id="line6606"></span>  abort = false;  // 2018-01-20: 
<span id="line6607"></span>  document.all.cosmos.innerHTML = ""; // 2018-01-04: blank out lower screen.
<span id="line6608"></span>  if (nucon &gt; 0) {  // 2018-01-23: if a new noun is encounter in NewConcept()
<span id="line6609"></span>    SpreadAct();  // 2018-01-23: to activate concepts for a question. 
<span id="line6610"></span>    nucon = 0;    // 2018-01-23: reset for safety.
<span id="line6611"></span>    pov = 2;      // 2018-01-23: give human user a "pause" for input...
<span id="line6612"></span>    return;  // 2018-01-23: after question abandon rest of function.
<span id="line6613"></span>  }  // 2018-01-23: end of test for the condition of input of a new concept.
<span id="line6614"></span>  if (quiet == true || quiet == false) {  // 2018-06-11: temporary laissez-faire...
<span id="line6615"></span>    pov = "1";  // 2018-01-20: internal point-of-view for thinking. 
<span id="line6616"></span>    output = "";  // blank out the output of the previous thought;
<span id="line6617"></span>    outputplus = "";  // blank out the display of the previous thought.
<span id="line6618"></span>    t = (t + 1);  // 2018-10-14: skip one time-point before edge="{"
<span id="line6619"></span>    audMemory[t].audExam();  // 2018-10-12: ReJuvenate test;
<span id="line6620"></span>    audMemory[t] = new audNode("{",aud1,aud2); // 2018-10-12
<span id="line6621"></span>    Indicative();  // 2018-01-20: think in the indicative mood. 
<span id="line6622"></span>  } // 2018-01-20: // 2018-01-20: end of test for absence of user input.
<span id="line6623"></span>  if (etc &gt; 1) {  // 2019-02-18: if multiple thoughts are active...
<span id="line6624"></span>    ConJoin();  // 2019-02-12: insert a conjunction;
<span id="line6625"></span>    Indicative();  // 2019-02-12: think in the indicative mood.
<span id="line6626"></span>  }  // 2019-02-12: join multiple thoughts together.
<span id="line6627"></span>  if (rsvp &gt; -1) {  // 2018-05-20: and if there is no input...
<span id="line6628"></span>    rsvp = (rsvp - 100);  // 2018-05-20: decrement rsvp-wait in absence of input 
<span id="line6629"></span>    if (rsvp </span><span>&lt; </span><span>0) rsvp = 0;  // 2018-05-20: disallow negative "rsvp".
<span id="line6630"></span>  }  // 2018-05-20: end of test for lack of input as reason to speed up thinking. 
<span id="line6631"></span>  for (i = 1; i</span><span>&lt;(</span><span>rsvp+100); i++) {  // 2018-05-20: delay for user to respond to output
<span id="line6632"></span>   if (i &gt; 1) { apb = "Rejuvenations = "+rjc+ "; time = "+t+"; isolation = "+isolation; Voice() }
<span id="line6633"></span>   document.all.mouth.innerHTML = outputplus;  // 2018-12-09: show output while waiting...
<span id="line6634"></span>  }  // 2018-05-20: end of delay to give time for user input. 
<span id="line6635"></span>  conj = 0;  // 2018-06-03: prevent carry-over. 
<span id="line6636"></span>  dunnocon = 0;  // 2019-09-20: reset outside of SpreadAct() to prevent carry-over.
<span id="line6637"></span>  etc = 0;   // 2019-02-18: reset the flag that triggers a conjunction.
<span id="line6638"></span>  quiet = true;  // 2018-06-11: after AI responds to input, things quiet down.
<span id="line6639"></span>  subjnom = 0;  // 2018-06-11: prevent carry-over. 
<span id="line6640"></span>  whatcon = 0;  // 2019-09-20: reset outside of SpreadAct() to prevent carry-over.
<span id="line6641"></span>} // 2018-01-20: EnThink() returns to the FreeWill Volition() module. 
<span id="line6642"></span>
<span id="line6643"></span>
<span id="line6644"></span>function RuThink() {  // http://ai.neocities.org/RuThink.html
<span id="line6645"></span>  RuNounPhrase();  // 2018-06-05: tentative preparation for thinking in Russian.
<span id="line6646"></span>  RuVerbPhrase();  // 2018-06-05: tentative preparation for bilingual AI.
<span id="line6647"></span>}  // End of stub-only RuThink(); return to Volition(); // 2018-06-05
<span id="line6648"></span>
<span id="line6649"></span>
<span id="line6650"></span>function Volition() {  // http://ai.neocities.org/Volition.html
<span id="line6651"></span>  apb = "Volition has been called and life = "+life;  // 2018-01-21: more informative
<span id="line6652"></span>  Voice();
<span id="line6653"></span>// Emotion();  // 2018-03-17: so emotions may influence otherwise rational thought.
<span id="line6654"></span>  if (isolation &gt; 3) whoq = 1; // 2019-03-03: if no input for a long time...
<span id="line6655"></span>  if (whoq == 1) {  // 2019-03-03: if waiting to ask a who-question...
<span id="line6656"></span>//  if (isolation == 0) {  // 2019-03-03: if user ends "isolation"
<span id="line6657"></span>    if (isolation </span><span>&lt; </span><span>2) {  // 2019-03-03: if user ends "isolation"
<span id="line6658"></span>      AskUser();  // 2019-03-03: call module to ask a who-question.
<span id="line6659"></span>      whoq = 0;  // 2019-03-03: reset for safety.
<span id="line6660"></span>      isolation = 0;  // 2019-03-03: reset
<span id="line6661"></span>    }  // end of test for commencement of user input.
<span id="line6662"></span>  }  // 2019-03-03: end of test for a positive flag to ask a question. 
<span id="line6663"></span>  if (life == true) {  // 2018-01-21: when user checks "Halt", stop thinking. 
<span id="line6664"></span>    EnThink(); // 2017-12-31: think in English.
<span id="line6665"></span>  }  // 2018-01-21: end of test for "life" status. 
<span id="line6666"></span>// Motorium();  // 2018-03-17: so that emotion and thought may initiate actions. 
<span id="line6667"></span>} // 2018-01-20: FreeWill Volition() module returns to MainLoop()
<span id="line6668"></span>
<span id="line6669"></span>
<span id="line6670"></span>function MindMeld() {  // 2018-01-14
<span id="line6671"></span>  // 2018-01-14: stubbed in for AI Mind Maintainers to consider.
<span id="line6672"></span>}  // MindMeld() will return to...
<span id="line6673"></span>
<span id="line6674"></span>
<span id="line6675"></span>function MetEmPsychosis() {  // 2018-01-14
<span id="line6676"></span>  // 2018-01-14: stubbed in for AI Mind Maintainers to consider.
<span id="line6677"></span>  // 2018-01-15: feasible in Perl, etc., but not in JavaScript.
<span id="line6678"></span>}  // MetEmPsychosis() will return to...
<span id="line6679"></span>
<span id="line6680"></span>
<span id="line6681"></span>function Motorium() {  // 2018-01-14
<span id="line6682"></span>  // 2018-01-14: stubbed in for AI Mind Maintainers to consider.
<span id="line6683"></span>}  // Motorium() will return to Volition()
<span id="line6684"></span>
<span id="line6685"></span> 
<span id="line6686"></span>function Diagnostic() {
<span id="line6687"></span>  psiList();  // 2019-07-31: show the array of conceptual flag-panels.
<span id="line6688"></span>  audList();  // 2019-07-31: show some contents of the auditory memory channel.
<span id="line6689"></span>  if (trouble == true) {
<span id="line6690"></span>    document.all.tabula.innerHTML = "";
<span id="line6691"></span>    document.all.psicolumn.innerHTML = psidata;
<span id="line6692"></span>    document.all.audcolumn.innerHTML = auddata;
<span id="line6693"></span>   }
<span id="line6694"></span>  html = "";
<span id="line6695"></span>  psidata = ("</span><span>&lt;b</span><span>&gt;" + "Concepts with associative tags for ");  // 2018-01-16
<span id="line6696"></span>  psidata += ("Natural Language Understanding:" + "</span><span>&lt;\</span><span>/b&gt;" + "</span><span>&lt;B</span><span>R&gt;");
<span id="line6697"></span>  psidata += ("krt tru psi hlc act mtx jux pos dba num mfn ");  // 2019-07-26
<span id="line6698"></span>  psidata += ("pre seq tgn tdt tkb tia tcj tdj tdv tpr rv"); // 2019-07-31: expanded
<span id="line6699"></span>  auddata = ("</span><span>&lt;b</span><span>&gt;" + "Auditory memory nodes" + "</span><span>&lt;\</span><span>/b&gt;" + "</span><span>&lt;B</span><span>R&gt;");
<span id="line6700"></span>  auddata += ("krt pho act audpsi"); // 2018-01-16
<span id="line6701"></span>}  // 2019-07-31: Diagnostic() returns to human-computer interface HCI().
<span id="line6702"></span>
<span id="line6703"></span>
<span id="line6704"></span>function HCI() {  // http://mind.sourceforge.net/hci.html 
<span id="line6705"></span>  if (document.all["cb3"].checked == true) {
<span id="line6706"></span>    document.all["cb1"].checked = false;
<span id="line6707"></span>    document.all.souvenir.innerHTML = "";
<span id="line6708"></span>    document.all["cb2"].checked = false;
<span id="line6709"></span>     tutor = false;
<span id="line6710"></span>    trouble = true;
<span id="line6711"></span>    fyi = 3;
<span id="line6712"></span>  }
<span id="line6713"></span>  if (document.all["cb3"].checked == false) {
<span id="line6714"></span>    document.all.tabula.innerHTML = "";
<span id="line6715"></span>    document.all.psicolumn.innerHTML = "";
<span id="line6716"></span>    document.all.audcolumn.innerHTML = "";
<span id="line6717"></span>    trouble = false;
<span id="line6718"></span>  }
<span id="line6719"></span>  if (document.all["cb1"].checked == true) {
<span id="line6720"></span>    document.all["cb2"].checked = false;
<span id="line6721"></span>     document.all["cb3"].checked = false;
<span id="line6722"></span>    document.all.tabula.innerHTML = "";
<span id="line6723"></span>    document.all.psicolumn.innerHTML = "";
<span id="line6724"></span>    document.all.audcolumn.innerHTML = "";
<span id="line6725"></span>    trouble = false;
<span id="line6726"></span>    hardcopy = true;
<span id="line6727"></span>    fyi = 1;
<span id="line6728"></span>    now = new Date(); 
<span id="line6729"></span>    adcopy=("</span><span>&lt;f</span><span>ont size='+2'&gt;AI Mind version "+vrsn+" on " +now+"</span><span>&lt;\</span><span>/b&gt;</span><span>&lt;\</span><span>/font&gt;");
<span id="line6730"></span>    document.all.souvenir.innerHTML = adcopy;
<span id="line6731"></span>  }
<span id="line6732"></span>  if (document.all["cb1"].checked == false) {
<span id="line6733"></span>    document.all.souvenir.innerHTML = "";
<span id="line6734"></span>    hardcopy = false;
<span id="line6735"></span>    document.all.tabula.innerHTML = "";
<span id="line6736"></span>  }
<span id="line6737"></span>  if (hardcopy == true) {
<span id="line6738"></span>    if (userline != "" || output != "" ) {
<span id="line6739"></span>      Transcript();
<span id="line6740"></span>    }
<span id="line6741"></span>  }
<span id="line6742"></span>  if (document.all["cb2"].checked == true) {
<span id="line6743"></span>    document.all["cb1"].checked = false;
<span id="line6744"></span>    document.all.souvenir.innerHTML = "";
<span id="line6745"></span>    hardcopy = false;
<span id="line6746"></span>    document.all["cb3"].checked = false;
<span id="line6747"></span>    document.all.tabula.innerHTML = "";
<span id="line6748"></span>    document.all.psicolumn.innerHTML = "";
<span id="line6749"></span>    document.all.audcolumn.innerHTML = "";
<span id="line6750"></span>    trouble = false;
<span id="line6751"></span>    tutor = true;
<span id="line6752"></span>    fyi = 2;
<span id="line6753"></span>  }
<span id="line6754"></span>  if (document.all["cb2"].checked == false) {
<span id="line6755"></span>    tutor = false;
<span id="line6756"></span>    if (fyi == 2) fyi = 0;
<span id="line6757"></span>  }
<span id="line6758"></span>  if (trouble == true) {
<span id="line6759"></span>    Diagnostic();
<span id="line6760"></span>  }
<span id="line6761"></span>  if (life == true) {
<span id="line6762"></span>    document.forms[1].ear.focus();
<span id="line6763"></span>  }
<span id="line6764"></span>}  // 2018-01-21: HCI() returns to SeCurity module.
<span id="line6765"></span>
<span id="line6766"></span>
<span id="line6767"></span>function SeCurity() {
<span id="line6768"></span>  HCI();  // 2018-01-18: Human Computer Interfact
<span id="line6769"></span>  if (t &gt; 160)  nonce = vault;  // Diagnostic display of all thought.
<span id="line6770"></span>// nonce = 381;  // to view innate KB for testing; 19oct2012
<span id="line6771"></span>// nonce = 1;  // show changes being made to EnBoot; 25oct2012
<span id="line6772"></span>  nonce = vault;  // for quicker loading; 25oct2012
<span id="line6773"></span>  if (t &gt; (cns-64)) ReJuvenate();
<span id="line6774"></span>  if (life == true) {
<span id="line6775"></span>    apb=("AI Mind at t="+t+" is alive on cyc #"+rjc+" since " +dob+ "."); // 2018-09-21
<span id="line6776"></span>    if (t &gt; (cns-32)) {
<span id="line6777"></span>    apb = "WARNING!  Consider clicking Refresh. ";
<span id="line6778"></span>    apb += ("Only " + (cns-t) + " spaces are left."); 
<span id="line6779"></span>  }
<span id="line6780"></span>  Voice();
<span id="line6781"></span>  } else {
<span id="line6782"></span>    apb=("</span><span>&lt;f</span><span>ont color='red'&gt;"+"Mental function suspended."+"</span><span>&lt;\</span><span>/font&gt;");
<span id="line6783"></span>    Voice();
<span id="line6784"></span>  }
<span id="line6785"></span>}
<span id="line6786"></span>
<span id="line6787"></span>
<span id="line6788"></span>function MainLoop() {  // http://ai.neocities.org/MainLoop.html
<span id="line6789"></span>  isolation++;  // 2018-10-03: increment incentive for Imperative()
<span id="line6790"></span>  SeCurity();
<span id="line6791"></span>  tpu = t;  // 2019-02-18: isolate tpu from later input-and-output.
<span id="line6792"></span>  Sensorium();  // 2018-01-18: 
<span id="line6793"></span>  brain = true;
<span id="line6794"></span>  Volition(); // 2018-01-15: in conformance with modern ghost.pl AI
<span id="line6795"></span>  if (life == true) {
<span id="line6796"></span>    TID=window.setTimeout("MainLoop();",10000);
<span id="line6797"></span>  }
<span id="line6798"></span>}  // 2018-01-20: End of MainLoop.
<span id="line6799"></span>
<span id="line6800"></span></span><span>&lt;/<span class="end-tag">script</span>&gt;</span><span></span><span>&lt;/<span class="end-tag">head</span>&gt;</span><span>
<span id="line6801"></span></span><span class="comment">&lt;!--*********AI code is above; visible Mind is below**********--&gt;</span><span>
<span id="line6802"></span></span><span>&lt;<span class="start-tag">body</span> <span class="attribute-name">bgcolor</span>="<a class="attribute-value">white</a>" <span class="attribute-name">onKeyUp</span>="<a class="attribute-value">if(event.keyCode==9) Tab();</a>" <span class="attribute-name">onLoad</span>="<a class="attribute-value">MindBoot()</a>"&gt;</span><span>
<span id="line6803"></span></span><span>&lt;<span class="start-tag">a</span> <span class="attribute-name">name</span>="<a class="attribute-value">top</a>"&gt;</span><span></span><span>&lt;/<span class="end-tag">a</span>&gt;</span><span>
<span id="line6804"></span>
<span id="line6805"></span></span><span>&lt;<span class="start-tag">fieldset</span>&gt;</span><span>
<span id="line6806"></span></span><span>&lt;<span class="start-tag">legend</span>&gt;</span><span></span><span>&lt;<span class="start-tag">font</span> <span class="attribute-name">color</span>="<a class="attribute-value">navy</a>"&gt;</span><span></span><span>&lt;<span class="start-tag">b</span>&gt;</span><span>
<span id="line6807"></span>AI Mind Control Panel (requires 
<span id="line6808"></span> </span><span>&lt;<span class="start-tag">a</span> <span class="attribute-name">href</span>="<a class="attribute-value" href="view-source:http://en.wikipedia.org/wiki/Internet_Explorer">http://en.wikipedia.org/wiki/Internet_Explorer</a>"
<span id="line6809"></span> <span class="attribute-name">title</span>="<a class="attribute-value">Microsoft Internet Explorer</a>"
<span id="line6810"></span> <span class="attribute-name">style</span>="<a class="attribute-value">text-decoration:none;</a>"&gt;</span><span>
<span id="line6811"></span>MSIE</span><span>&lt;/<span class="end-tag">a</span>&gt;</span><span>) - 
<span id="line6812"></span>
<span id="line6813"></span> </span><span>&lt;<span class="start-tag">a</span> <span class="attribute-name">href</span>="<a class="attribute-value" href="view-source:http://ai.neocities.org/perlmind.txt">http://ai.neocities.org/perlmind.txt</a>"
<span id="line6814"></span> <span class="attribute-name">title</span>="<a class="attribute-value">Ghost thinks in English and in Russian.</a>"
<span id="line6815"></span> <span class="attribute-name">style</span>="<a class="attribute-value">text-decoration:none;</a>"&gt;</span><span>
<span id="line6816"></span>bilingual ghost.pl</span><span>&lt;/<span class="end-tag">a</span>&gt;</span><span> - 
<span id="line6817"></span>
<span id="line6818"></span> </span><span>&lt;<span class="start-tag">a</span> <span class="attribute-name">href</span>="<a class="attribute-value" href="view-source:http://ai.neocities.org/NLU.html">http://ai.neocities.org/NLU.html</a>"
<span id="line6819"></span> <span class="attribute-name">title</span>="<a class="attribute-value">Natural Language Understanding</a>"&gt;</span><span>
<span id="line6820"></span>NLU</span><span>&lt;/<span class="end-tag">a</span>&gt;</span><span> - 
<span id="line6821"></span>
<span id="line6822"></span> </span><span>&lt;<span class="start-tag">a</span> <span class="attribute-name">href</span>="<a class="attribute-value" href="view-source:http://ai.neocities.org/theory.html">http://ai.neocities.org/theory.html</a>"
<span id="line6823"></span> <span class="attribute-name">title</span>="<a class="attribute-value">theory of cognitivity for artificial intelligence</a>"
<span id="line6824"></span> <span class="attribute-name">style</span>="<a class="attribute-value">text-decoration:none;</a>"&gt;</span><span>
<span id="line6825"></span>Theory</span><span>&lt;/<span class="end-tag">a</span>&gt;</span><span> - 
<span id="line6826"></span>
<span id="line6827"></span> </span><span>&lt;<span class="start-tag">a</span> <span class="attribute-name">href</span>="<a class="attribute-value" href="view-source:http://www.amazon.com/dp/B08NRQ3HVW">http://www.amazon.com/dp/B08NRQ3HVW</a>"
<span id="line6828"></span> <span class="attribute-name">title</span>="<a class="attribute-value">Artificial Intelligence in Ancient Latin</a>"&gt;</span><span>
<span id="line6829"></span>Latin AI</span><span>&lt;/<span class="end-tag">a</span>&gt;</span><span> - 
<span id="line6830"></span>
<span id="line6831"></span> </span><span>&lt;<span class="start-tag">a</span> <span class="attribute-name">href</span>="<a class="attribute-value" href="view-source:http://ai.neocities.org/Dushka.html">http://ai.neocities.org/Dushka.html</a>"
<span id="line6832"></span> <span class="attribute-name">title</span>="<a class="attribute-value">Requires MSIE and keyboard set to Cyrillic</a>"&gt;</span><span>
<span id="line6833"></span>Russian AI</span><span>&lt;/<span class="end-tag">a</span>&gt;</span><span>
<span id="line6834"></span></span><span>&lt;/<span class="end-tag">b</span>&gt;</span><span>
<span id="line6835"></span></span><span>&lt;/<span class="end-tag">font</span>&gt;</span><span></span><span>&lt;/<span class="end-tag">legend</span>&gt;</span><span>
<span id="line6836"></span></span><span>&lt;<span class="start-tag">form</span> <span class="attribute-name">name</span>="<a class="attribute-value">modes</a>"&gt;</span><span>
<span id="line6837"></span></span><span>&lt;<span class="start-tag">input</span> <span class="attribute-name">type</span>="<a class="attribute-value">checkbox</a>" <span class="attribute-name">name</span>="<a class="attribute-value">cb1</a>" <span class="attribute-name">onClick</span>="<a class="attribute-value">Transcript()</a>" <span class="attribute-name">checked</span>&gt;</span><span> Transcript
<span id="line6838"></span></span><span>&lt;<span class="start-tag">input</span> <span class="attribute-name">type</span>="<a class="attribute-value">checkbox</a>" <span class="attribute-name">name</span>="<a class="attribute-value">cb2</a>" <span class="attribute-name">onClick</span>="<a class="attribute-value">Tutorial();</a>"&gt;</span><span> Tutorial
<span id="line6839"></span></span><span>&lt;<span class="start-tag">input</span> <span class="attribute-name">type</span>="<a class="attribute-value">checkbox</a>" <span class="attribute-name">name</span>="<a class="attribute-value">cb3</a>" <span class="attribute-name">onClick</span>="<a class="attribute-value">HCI();</a>"&gt;</span><span> Diagnostic
<span id="line6840"></span></span><span>&lt;<span class="start-tag">input</span> <span class="attribute-name">type</span>="<a class="attribute-value">checkbox</a>" <span class="attribute-name">name</span>="<a class="attribute-value">cb4</a>" <span class="attribute-name">onClick</span>="<a class="attribute-value">Shutdown();</a>"&gt;</span><span>
<span id="line6841"></span> </span><span>&lt;<span class="start-tag">font</span> <span class="attribute-name">color</span>="<a class="attribute-value">fuchsia</a>"&gt;</span><span></span><span>&lt;<span class="start-tag">b</span>&gt;</span><span>HALT</span><span>&lt;/<span class="end-tag">b</span>&gt;</span><span></span><span>&lt;/<span class="end-tag">font</span>&gt;</span><span>
<span id="line6842"></span></span><span>&lt;<span class="start-tag">input</span> <span class="attribute-name">type</span>="<a class="attribute-value">checkbox</a>" <span class="attribute-name">name</span>="<a class="attribute-value">cb5</a>" <span class="attribute-name">onClick</span>="<a class="attribute-value">Destroy();</a>"&gt;</span><span> 
<span id="line6843"></span> </span><span>&lt;<span class="start-tag">font</span> <span class="attribute-name">color</span>="<a class="attribute-value">red</a>"&gt;</span><span></span><span>&lt;<span class="start-tag">b</span>&gt;</span><span>Terminate</span><span>&lt;/<span class="end-tag">b</span>&gt;</span><span></span><span>&lt;/<span class="end-tag">font</span>&gt;</span><span> (close window)</span><span>&lt;<span class="start-tag">br</span> <span>/</span>&gt;</span><span>
<span id="line6844"></span></span><span>&lt;/<span class="end-tag">form</span>&gt;</span><span>
<span id="line6845"></span></span><span>&lt;/<span class="end-tag">fieldset</span>&gt;</span><span>
<span id="line6846"></span>
<span id="line6847"></span></span><span>&lt;<span class="start-tag">div</span> <span class="attribute-name">id</span>="<a class="attribute-value">mouth</a>" <span class="attribute-name">style</span>="<a class="attribute-value">position:static;
<span id="line6848"></span> background-color:silver; height:35</a>"&gt;</span><span>
<span id="line6849"></span>When thinking begins, enter your input below. </span><span>&lt;<span class="start-tag">br</span> <span>/</span>&gt;</span><span>
<span id="line6850"></span>If this message remains here, the AI has failed to load.
<span id="line6851"></span></span><span>&lt;/<span class="end-tag">div</span>&gt;</span><span>
<span id="line6852"></span>
<span id="line6853"></span></span><span>&lt;<span class="start-tag">form</span> <span class="attribute-name">onSubmit</span>="<a class="attribute-value">if (this.submitted) return true; else {CR(); return false;};</a>"&gt;</span><span>
<span id="line6854"></span></span><span>&lt;<span class="start-tag">b</span>&gt;</span><span>Press any numeric key and ask the Ghost in the Machine: what do you feel</span><span>&lt;/<span class="end-tag">b</span>&gt;</span><span></span><span>&lt;<span class="start-tag">br</span> <span>/</span>&gt;</span><span>
<span id="line6855"></span></span><span>&lt;<span class="start-tag">input</span> <span class="attribute-name">type</span>="<a class="attribute-value">text</a>" <span class="attribute-name">name</span>="<a class="attribute-value">ear</a>" <span class="attribute-name">value</span>="<a class="attribute-value"></a>" <span class="attribute-name">size</span>="<a class="attribute-value">80</a>" <span class="attribute-name">onKeyDown</span>="<a class="attribute-value">AudListen()</a>"&gt;</span><span>
<span id="line6856"></span></span><span>&lt;/<span class="end-tag">form</span>&gt;</span><span>
<span id="line6857"></span>
<span id="line6858"></span></span><span>&lt;<span class="start-tag">div</span> <span class="attribute-name">id</span>="<a class="attribute-value">brain</a>" <span class="attribute-name">style</span>="<a class="attribute-value">position:static;
<span id="line6859"></span> background-color:lightgreen</a>"&gt;</span><span>
<span id="line6860"></span>Informative messages will appear here.
<span id="line6861"></span></span><span>&lt;/<span class="end-tag">div</span>&gt;</span><span>
<span id="line6862"></span>
<span id="line6863"></span></span><span>&lt;<span class="start-tag">noscript</span>&gt;</span><span>
<span id="line6864"></span></span><span>&lt;</span><span>p&gt;The Robot AI Mind requires Microsoft Internet Explorer </span><span>&lt;</span><span>br /&gt;
<span id="line6865"></span>with JavaScript enabled.</span><span>&lt;</span><span>br /&gt;</span><span>&lt;/<span></span>p</span><span>&gt;</span><span>&lt;/<span class="end-tag">noscript</span>&gt;</span><span>
<span id="line6866"></span>
<span id="line6867"></span></span><span>&lt;<span class="start-tag">div</span> <span class="attribute-name">id</span>="<a class="attribute-value">souvenir</a>" <span class="attribute-name">style</span>="<a class="attribute-value">position:static; width:640;
<span id="line6868"></span> background-color:lightyellow</a>"&gt;</span><span>
<span id="line6869"></span>Offer to install the JavaScript Ghost AI on websites and to be the AI Mind Maintainer
<span id="line6870"></span></span><span>&lt;/<span class="end-tag">div</span>&gt;</span><span>
<span id="line6871"></span>
<span id="line6872"></span></span><span>&lt;<span class="start-tag">div</span> <span class="attribute-name">id</span>="<a class="attribute-value">tabula</a>" <span class="attribute-name">style</span>="<a class="attribute-value">position:static; width:640;
<span id="line6873"></span> background-color:clear</a>"&gt;</span><span>
<span id="line6874"></span>Unclick Diagnostic prior to clicking on Transcript.
<span id="line6875"></span></span><span>&lt;/<span class="end-tag">div</span>&gt;</span><span>
<span id="line6876"></span>
<span id="line6877"></span></span><span class="comment">&lt;!-- The Diagnostic columns are present but invisible. --&gt;</span><span>
<span id="line6878"></span></span><span>&lt;<span class="start-tag">div</span> <span class="attribute-name">id</span>="<a class="attribute-value">psicolumn</a>" <span class="attribute-name">style</span>="<a class="attribute-value">position:absolute; left:1; top:310;
<span id="line6879"></span>width:460; height:140; background-color:clear</a>"&gt;</span><span>  </span><span class="comment">&lt;!-- // 2018-01-16: --&gt;</span><span>
<span id="line6880"></span></span><span>&lt;/<span class="end-tag">div</span>&gt;</span><span>
<span id="line6881"></span> 
<span id="line6882"></span></span><span>&lt;<span class="start-tag">div</span> <span class="attribute-name">id</span>="<a class="attribute-value">audcolumn</a>" <span class="attribute-name">style</span>="<a class="attribute-value">position:absolute; left:480; top:310;
<span id="line6883"></span>width:160; height:140; background-color:clear</a>"&gt;</span><span>
<span id="line6884"></span></span><span>&lt;/<span class="end-tag">div</span>&gt;</span><span>
<span id="line6885"></span>
<span id="line6886"></span></span><span>&lt;<span class="start-tag">div</span> <span class="attribute-name">id</span>="<a class="attribute-value">cosmos</a>"&gt;</span><span> 
<span id="line6887"></span></span><span>&lt;<span class="start-tag">font</span> <span class="attribute-name">color</span>="<a class="attribute-value">navy</a>"&gt;</span><span></span><span>&lt;<span class="start-tag">strong</span>&gt;</span><span></span><span>&lt;<span class="start-tag">pre</span>&gt;</span><span>
<span id="line6888"></span>   Subject associates to verb.   Verb associates to object.    Object free-associates.
<span id="line6889"></span>  |--------------------------|  |--------------------------|  |----------------------|
<span id="line6890"></span>  | CATS associates to CHASE |  | EAT associates to  BUGS  |  | FISH activates CATCH |
<span id="line6891"></span>  | CATS associates to LOVE  |  | EAT associates to +FISH  |  | FISH activates LIKE  |
<span id="line6892"></span>  | CATS associates to HATE  |  | EAT associates to  BIRDS |  | FISH activates EAT   |
<span id="line6893"></span>  | CATS associates to EAT   |   --------------------------   | FISH activates CHASE |
<span id="line6894"></span>  | CATS associates to NEED  |                                | FISH activates AVOID |
<span id="line6895"></span>   --------------------------                                   ---------------------
<span id="line6896"></span></span><span>&lt;/<span class="end-tag">pre</span>&gt;</span><span></span><span>&lt;/<span class="end-tag">strong</span>&gt;</span><span></span><span>&lt;/<span class="end-tag">font</span>&gt;</span><span></span><span>&lt;/<span class="end-tag">div</span>&gt;</span><span>
<span id="line6897"></span>
<span id="line6898"></span></span><span>&lt;/<span class="end-tag">body</span>&gt;</span><span></span><span class="comment">&lt;!-- Change Log comments of the HTML variety:
<span id="line6899"></span>Wed.  "4jan12A.html" includes AudBuffer/OutBuffer and "dba" variable.
<span id="line6900"></span>Sat. "27jun15A.html" requires infinitive verb after auxiliary + "NOT".
<span id="line6901"></span>Sun. "31dec17A.html" makes obvious changes in conformance with ghost.pl AI. 
<span id="line6902"></span>Sun. "31dec17C.html" begins accrual of modules by testing for functionality. 
<span id="line6903"></span>Mon.  "1jan18B.html" uses find-and-replace to reformulate MindBoot sequence.
<span id="line6904"></span>Tue.  "2jan18A.html" demonstrates input and storage of keyboard characters. 
<span id="line6905"></span>Wed.  "3jan18A.html" uses the Diagnostic audcolumn to show memory contents. 
<span id="line6906"></span>Thu.  "4jan18A.html" uses EnNounPhrase and EnVerbPhrase to recall an idea. 
<span id="line6907"></span>Fri.  "5jan18A.html" fleshes out the AudRecog() and AudMem() modules. 
<span id="line6908"></span>Sat.  "6jan18B.html" displays in Diagnostic() characters stored in AudMem().
<span id="line6909"></span>Sun.  "7jan18B.html" aims at self-contained AudRecog() reporting "audpsi".
<span id="line6910"></span>Mon.  "8jan18A.html" streamlines but does not fully debug AudRecog() module. 
<span id="line6911"></span>Tue.  "9jan18A.html" has AudRecog() recognize words, but needs improvement.
<span id="line6912"></span>Tue.  "9jan18B.html" troubleshoots AudInput calling OldConcept and NewConcept.
<span id="line6913"></span>Wed. "10jan18A.html" calls OldConcept for known words and NewConcept for new. 
<span id="line6914"></span>Thu. "11jan18A.html" finishes removing obsolete engrams from MindBoot sequence. 
<span id="line6915"></span>Thu. "11jan18B.html" implements OldConcept, NewConcept, EnParser, Instantiate.
<span id="line6916"></span>Fri. "12jan18B.html" fleshes out EnNounPhrase() module in need of debugging. 
<span id="line6917"></span>Sat. "13jan18A.html" troubleshoots and debugs EnNounPhrase() and Speech().
<span id="line6918"></span>Sat. "13jan18C.html" removes alert-boxes used for troubleshooting and debugging. 
<span id="line6919"></span>Sun. "14jan18A.html" debugs EnNounPhrase() and stubs in considerand mind-modules. 
<span id="line6920"></span>Sun. "14jan18B.html" completes the implementation of the EnVerbPhrase() module. 
<span id="line6921"></span>Mon. "15jan18A.html" combines 27jun15A.html with current-day modules. 
<span id="line6922"></span>Tue. "16jan18A.html" removes the obsolete HTML shell and deletes obsolete code. 
<span id="line6923"></span>Tue. "16jan18B.html" fixes AudMem bug of overwriting final character with SPACE. 
<span id="line6924"></span>Wed. "17jan18B.html" accepts user input and stores both old and new concepts. 
<span id="line6925"></span>Thu. "18jan18A.html" has difficulty cycling through the loop of input and output. 
<span id="line6926"></span>Fri. "19jan18A.html" uses "nxt"; routes AudListen and ReEntry through AudInput(). 
<span id="line6927"></span>Sat. "20jan18A.html" finally achieves chain-of-thought looping despite bugs. 
<span id="line6928"></span>Sat. "20jan18B.html" blanks out thought-display before EnThink() calls Indicative().
<span id="line6929"></span>Sun. "21jan18A.html" declares that AI is thinking after user ends input with 13=CR. 
<span id="line6930"></span>Sun. "21jan18B.html" improves assignment of "pre" tags by EnParser and InStantiate. 
<span id="line6931"></span>Sun. "21jan18C.html" finishes implementation of EnParser() ported from ghost.pl AI.
<span id="line6932"></span>Sun. "21jan18D.html" corrects major InStantiate bug to permit generation of thought.
<span id="line6933"></span>Tue. "23jan18A.html" in OldConcept converts input of "you" to internal "701=I" ego.
<span id="line6934"></span>Tue. "23jan18B.html" fleshes out SpreadAct() with query-handling from ghost.pl AI.
<span id="line6935"></span>Wed. "24jan18A.html" eliminates obsolete functions; uses "dob" as AI date-of-birth. 
<span id="line6936"></span>Thu. "25jan18A.html" updates and debugs InFerence() module for automated reasoning. 
<span id="line6937"></span>Fri. "26jan18A.html" updates AskUser() and EnAuxVerb() modules for testing inference.
<span id="line6938"></span>Sat. "27jan18A.html" implements the KbRetro() module for retroactive KB-adjustment. 
<span id="line6939"></span>Sat. "27jan18B.html" debugs AskUser() and pauses briefly for y/n response from user. 
<span id="line6940"></span>Sun. "28jan18A.html" has KbRetro, called by EnThink, use kbzap to modify knowledge.
<span id="line6941"></span>Mon. "29jan18A.html" has KbRetro() adjust engrams for both subject and object nouns. 
<span id="line6942"></span>Tue. "30jan18A.html" augments EnVerbPhrase to find recall-vectors for inference-verbs.
<span id="line6943"></span>Sat.  "3feb18A.html" eliminates obsolete functions and variables to prevent confusion.
<span id="line6944"></span>Sun.  "4feb18A.html" removes old EnArticle and implements new EnArticle from ghost.pl AI.
<span id="line6945"></span>Fri.  "2mar18A.html" eliminates obsolete Tutorial display code called by MainLoop. 
<span id="line6946"></span>Sat. "17mar18A.html" restores missing variable-comments and removes obsolete variables.
<span id="line6947"></span>Sun. "13may18A.html" begins to respond to what-think-query with subject and verb of query.
<span id="line6948"></span>Sun. "13may18B.html" includes "THINK" in first output after input of what-think query. 
<span id="line6949"></span>Sun. "13may18C.html" achieves answering of what-think queries with a compound sentence. 
<span id="line6950"></span>Sun. "20may18A.html" slows down during user input and speeds up in absence of user input. 
<span id="line6951"></span>Tue. "22may18A.html" adds a few new concepts to MindBoot() to demonstrate AI functionality.
<span id="line6952"></span>Fri. "25may18A.html" introduces "numreq" variable for number of a predicate nominative. 
<span id="line6953"></span>Fri. "25may18B.html" uses numreq in EnNounPhrase() to find singular noun as required.
<span id="line6954"></span>Mon. "28may18A.html" arranges the MindBoot() associative tags in memory-array order.
<span id="line6955"></span>Tue. "29may18A.html" in EnNounPhrase() converts an "aud" else-clause into ordinary code.
<span id="line6956"></span>Wed. "30may18A.html" fixes EnParser() bug which was letting tkb values falsely carry over.
<span id="line6957"></span>Sun.  "3jun18A.html" fixes bugs of repeating Indicative() and of SpreadAct() malfunction.
<span id="line6958"></span>Tue.  "5jun18A.html" re-organizes SpreadAct to deal with queries instead of default action.
<span id="line6959"></span>Sat.  "9jun18A.html" fixes EnNounPhrase() bug of misplaced end of if-clause. 
<span id="line6960"></span>Mon. "11jun18A.html" prevents calls to SpreadAct() during each cycle of user input. 
<span id="line6961"></span>Tue. "12jun18A.html" fixes various bugs involving the negation of verbs with 250=NOT. 
<span id="line6962"></span>Sat. "16jun18A.html" fleshes out VisRecog() so that the AI must say it sees only nothing. 
<span id="line6963"></span>Thu. "12jul18A.html" moves MindBoot() ideas to top; uses t++ increment to store words.
<span id="line6964"></span>Fri. "13jul18A.html" debugs new MindBoot() format intended for self-modifying Perl AI.
<span id="line6965"></span>Tue.  "4sep18A.html" does not reliably transfer usx from InStantiate() to EnArticle().
<span id="line6966"></span>Wed.  "5sep18A.html" transfers usx reliably but does not detect prior noun-mentions. 
<span id="line6967"></span>Thu.  "6sep18A.html" uses EnArticle() to insert "the" before nouns under discussion.
<span id="line6968"></span>Fri. "21sep18A.html" improves auditory recognition of singular and plural noun-forms. 
<span id="line6969"></span>Mon.  "1oct18A.html" uses Indicative() to output "I DO NOT KNOW" for query-responses.
<span id="line6970"></span>Wed.  "3oct18A.html" calls SpreadAct from EnThink for immediate influence on thought.
<span id="line6971"></span>Wed.  "3oct18B.html" improves determination of person and number for EnAuxVerb(). 
<span id="line6972"></span>Thur. "4oct18A.html" helps AskUser and EnVerbPhrase to find infinitives when needed.
<span id="line6973"></span>Sat.  "6oct18A.html" enters dba=0 infinitive verbs of logical premises into MindBoot().
<span id="line6974"></span>Thu. "11oct18A.html" implements EnVerbGen() to generate third-person singular verbs. 
<span id="line6975"></span>Fri. "12oct18A.html" fleshes out EnVerbGen() and improves the ReJuvenate() module.
<span id="line6976"></span>Sat. "13oct18A.html" makes ReJuvenate() move memories backwards from "istr" point.
<span id="line6977"></span>Sun. "14oct18A.html" inserts one safety time-point before edge "{" for ReJuvenate(). 
<span id="line6978"></span>Fri. "26oct18A.html" implements EnPrep() module to answer "where-are-you" queries. 
<span id="line6979"></span>Tue. "13nov18A.html" adds most English one-word prepositions to MindBoot sequence.
<span id="line6980"></span>Wed. "14nov18A.html" debugs EnVerbPhrase() glitch preventing retrieval of prepositions.
<span id="line6981"></span>Mon. "26nov18A.html" uses MindBoot() idea "I UNDERSTAND YOU" to think about the "other".
<span id="line6982"></span>Wed. "28nov18A.html" adds words to MindBoot; links to ghost.pl and MindForth source code.
<span id="line6983"></span>Thu. "29nov18A.html" adds more verbs to MindBoot; exposes existence of "wherecon" bug.
<span id="line6984"></span>Thur. "6dec18A.html" uses "apb" to show spread of activation from a concept to ideas. 
<span id="line6985"></span>Sun.  "9dec18A.html" fills in most of one hundred MindBoot() verb; expands "cns" size.
<span id="line6986"></span>Sun. "16dec18A.html" fixes bug in KbRetro() causing wrong nphrnum in silent inference.
<span id="line6987"></span>Sat. "22dec18A.html" in SpreadAct favors who-VERBs-direct-object answers with high "tru".
<span id="line6988"></span>Tue. "12feb19A.html" introduces code for shortening compound query-response sentences.
<span id="line6989"></span>Mon. "18feb19A.html" debugs what-query responses by moving tpu-setting to MainLoop().
<span id="line6990"></span>Sun.  "3mar19A.html" implements artificial curiosity for asking the user "WHO ARE YOU".
<span id="line6991"></span>Wed. "13mar19A.html" fixes a bug of spurious "seq" and "tkb" values stored by EnParser().
<span id="line6992"></span>Sun. "17mar19A.html" lets EnThink() call Indicative() twice if a conjunction is warranted.
<span id="line6993"></span>Tue.  "9apr19A.html" uses InStantiate() to spread activation sideways from a concept. 
<span id="line6994"></span>Sat. "15jun19A.html" reverses OutBuffer() characters for legibility &amp; expandability. 
<span id="line6995"></span>Wed. "31jul19A.html" expands conceptual flag-panel from 15 tags to 21 associative tags.
<span id="line6996"></span>Sun.  "4aug19A.html" has EnVerbPhrase() trap for "tpr" flag to call EnPrep() module. 
<span id="line6997"></span>Fri. "20sep19A.html" begins implementation of prepositional phrases as in ghost.pl AI.
<span id="line6998"></span>Sat. "21sep19A.html" debugs the reduplication of output and assigning of spurious tags.
<span id="line6999"></span>Sun. "22sep19A.html" not only stores but also retrieves thinking with prepositions.
<span id="line7000"></span>Sat. "12oct19A.html" fleshes out the stub of EnAdjective() called from EnNounPhrase().
<span id="line7001"></span>Thu. "24oct19A.html" embeds "I AM (THE) GHOST IN (THE) MACHINE" in knowledge base (KB).
<span id="line7002"></span>Fri. "25oct19A.html" zeroes out the "mfn" gender variable to prevent conceptual confusion.
<span id="line7003"></span>Thur. "7nov19A.html" lets EnVerbPhrase call TacRecog to complete the thought: "I FEEL..." 
<span id="line7004"></span>(end of HTML Change Log comments) --&gt;</span><span>
<span id="line7005"></span></span><span>&lt;/<span class="end-tag">html</span>&gt;</span><span></span></pre><menu type="context" id="actions"><menuitem id="goToLine" label="Go to Line…" accesskey="L"></menuitem><menuitem id="wrapLongLines" label="Wrap Long Lines" type="checkbox"></menuitem><menuitem id="highlightSyntax" label="Syntax Highlighting" type="checkbox" checked="true"></menuitem></menu></body></html>

//


koh5_pano



Your browser does not support the HTML5 canvas element.


Drag mouse to navigate.

Navigation





17.Aug.2010, Martin Wengenmayer