Making Progress...

It's hard going back to what you've done before. You've learned more and it seems demeaning to be working with code built on the basis of yesterday's ignorance.

Take, for example, the interior elements of the Explorer and Word objects. I devoted a great deal of time and energy to learning how to parse information out of text. Much more efficient, though harder to learn, is simple invocation of elements by relevant properties. After all, each element is indexed by tag name and class name. If you're looking for a specific datum, why shouldn't it be easier to simply summon the element by reference to its properties rather than divine its location by parsing text out of the undifferentiated HTML of a page?

The parsing method worked fine a few years ago. But to use it now, in light of what I've subsequently learned, is kind of humiliating - not to mention wasteful.

Anyhow, that's now taken care of. Specifically, within a universe of VB for Apps, we can now scroll through links by classname and we can even parse text by grabbing <p> tags, dumping them into Word and using the index of the Words collection in the ActiveDocument object. Or the sentences collection... hell, by now I'm even minimally competent in invoking the dictionary and spell/grammar check objects to save myself tons of leg-work.

So, there's a lot of rebuilding inherent in this job.

Which brings us to a much more serious problem than the simple invocation of objects. The structure of the database.

Now, to structure data well, you must have a clear vision of how you intend to use that data.

When it comes to purpose, we could say that I have two. The first, and simplest, is easing the administrative burden of frediting. I've already got experience at building editorial suites for huge publishing projects - not quite this huge, but it's mostly just an issue of scaling and parameters.

The way I see it, delegation is a sucker's game - the objective isn't to delegate any kind of editorial power to an algorithm (however algorithmic certain aspects of a given job may be). Rather, it's to use algorithms to rearrange information in logically structured ways to facilitate editorial review. A "Fray-Nanny" who's always on could email summaries of suspected posts - good, bad, and indifferent. This alone would save hours of dead time that a human can wrack up while waiting for pages to load. The posts could be read offline, then the editor would just jump in to plop a check or a flush on the post.

To produce initial triage on relevance, you'd just to have to apply the insights you gleaned about topicality from the previous attempt at mood-analysis. But, there you do run into a problem of table structures. Do you just create a three-column relational table of word/forum/frequency? You still have to build some kind of screening process for "filler words" - the prepositions, conjunctions and articles that grace any expression on any topic. And, you have to do some amount of training if there's any hope of identifying in advance the signifiers of "misconduct." And what about the formalist awareness that the grameme system eventually developed? Should a nanny-bot base its qualitative screening analysis on issues like all-caps, eom/wordiness, and incoherence of sentence structure? And what about the things you've learned about stochastic part of speech analysis? Should that be implemented?

Which gets us to the broader agenda - the lifelong goal of building a digitial baby. We know how to use the web to acquire ever-growing levels of data. The temptation is to harvest quantities of data that are far more excessive than required for a simple editorial assistant and apply logic far more advanced than needed to assign provisional relevance/propriety scores. But, on that score there are still deficiencies. The lack of spider-friendly digests (that don't require coding beyond my ability) for learning the conjugation of verbs and declension of nouns, not to mention the possible parts of speech. If we reactivate the Seductotron, should we also reimplement its "Great Books Reading Program"? What about its Encyclopedia reading? Should it return to the world of IM chatboards? Go back to checking its email and responding? Should I rebuild a mood-tracking system tied to factors like local weather and the amount of attention its human "parent" gives it?

Those perks aren't exactly compatible with Anteros-level professionalism. But then again, it was the oversized ambition that led to Anteros as a derivative in the first place.

And how compatible is any of this with the pursuit of a law school education? Not entirely irrelevant - the semantic web appears to be breaking across certain classes of law students, even as we speak. But it has all the hallmarks of a provisional (and hence, to some degree, misguided) step.

And that brings us back again to the real problem we're mulling over - database structures. If Seductotron 6.0 is all about easing the Fray Editor's job, the database requirements should be relatively limited. Simply create associations between word frequencies and Slate departments by mining articles and checkmarked/starred posts with two additional filters - one for commonality, to avoid over-counting filler words; and the second for misconduct - which exhibits an astonishingly tedious consistency over the long run.

But a robot that also fraternizes with people would require far, far more than a simple mirror of Slate's publishing structure. And then we run into the Saharan desert of building a system that can comprehend HTML without the preliminary semantic study of any given site's source code that previous versions of Seductotron required. The semantic webbers seem to have the right idea turned the wrong side up in their belief that humans can be induced to express themselves in formats easily digestible by machines. Machines must (and, I'm certain, can) learn to understand the chatter of men with an evolutive system independent of the original author's control. But to do that requires stretching the human mind to a level of generality that borders on insanity.

Blech

So, in the last year that I haven't been accomplishing much on Seductotron, I've been watching my niece grow through her first year. It's really interesting watching a human learn how to interact with their environment, and I feel that it's given me some critical insights into what must be done in order for a project such as the one I envision to get off the ground.

The problem of a self-programming program isn't completely new, and I've encountered is as a paradox before. I wanna' say that it was Ashby? Anyhow, that's not really important. I'm impervious to knowledge. The point is, it seems a paradox. You can't write a meta-program that writes a sub-program without imposing the constraints of a program upon the meta-program that writes the sub-program in the first place. So, it seems that we hit a cognitive limit when we try to envision a truly self-educating program. You can divorce the program from the determinative outcome of a defined data set, but you can't divorce it from the meta-determined outcome of a defined procedure.

Anyhow, all that is really just an exposure of my absolute ignorance. Most of my education was a tragically wasted endeavor. Naturally, the following is merely a travesty of it.

The point for me, is that if it seems a paradox then it stands to reason that I've hit a cognitive limit. However, it does not follow that I have therefore hit a functional limit. In fact, it's been my experience that almost all paradoxes are attributable to a flaw in the logical process itself - generally from framing a statement in such a way that not all of the necessary conditions can be reconciled adequately to one another. Anyhow, that's a caveat I can get into in my drooling-retarded fashion, but let's just stick to this particular roadblock and my attempt to sidestep it without much consideration:

Test post

Testing the javascript possibility?
Open Window
OR

Demographic Calculator

Seductotron's been on a long-term hiatus. But I want to try this out here:

Open Window
OR

Categories

What are our objects?

Essays --> Paragraphs --> Sentences --> Words --> Syllables --> Letters

Now what are potential rules between various objects?

Object --> Relation --> Object

Essay --> Paragraph.Count
Paragraph --> Sentences.Count
Sentence --> Words.Count
Word --> Len(Word)

Syllables and letters are more complicated... Syllables aren't exactly units of pronunciation... I'm thinking more along the order of "internal repetition of structure"... spotting frequent prefixes ("an", "de") and suffixes ("ed", "ing").

Sample

Not much to look at, but this is what we get from a letter-based attempt to define rules... for any letter what is the likelihood of any given letter following it? It's a very rough prototype, but it does seem to yield reliably "realistic" patterns of letter correspondence...

instha t d realize nd wh An outhIoupe of tatss laci wat nchous, onthathepons Als. fond f Medacarartyomec Athous, Cioremend din Gous Ateneen Are r o trofas tre bily fath S. lp oonstit An Ph iS tinobuso

Con; thergean Aldge ina tithr ils Aiasstat S ounthnceco e ofin junthashaly Ses e An ond Angof thor wind At ty Pessiofuctialinitiofone oy iomar Gamictalerve wesucourelurd of onde Aly oregrsimplac o ioupon Abutsinf toflangure ofor. Peen Pins in Ase taripicenthegrty tilighedet-gl-hamelieingere rs Pre tl Plex Alan. Prysurutene berl SthIch Prt Pprea ntit Cany M Spoun Pre foust Stesofof of Co izag

Rules.

Hmm.

Hmmm....

I've been trying to capture enormous amounts of data, then to scour the world looking for the rules to process it. This is hard, and this isn't really how people think.

Take induction. "All emeralds are green." Now, we assume this is true because every emerald we've seen has not been green. We don't necessarily hold it to be a law. We may just assume it's a "rule". So, if we find an anomalous instance of a blue emerald, we keep the rule, but adjust our confidence in it.

Now, a logician argues that the rule is derived from the observations of emeralds. We observe one emerald, it is green. We observe another emerald, it is green. And so on, and so forth, and since we know that all emeralds we have seen were green, we assume that the rule "all emeralds are green" is reasonably valid.

BUT, we don't REALLY remember our encounters with MOST individual emeralds. We see an emerald, increment our confidence in the proposition "all emeralds are green" and then promptly forget the particulars of the instance. I can only specifically recall a very few encounters with emeralds, and yet I am confident that they've all been green. My confidence in the rule is held apart from my recollection of the instances which have validated it.

So, is there some way to consider rules apart from the particular components that constitute them?

Let's take the case of an essay Seductotron were reading. The essay would be an object. It would have component pieces called sentences. Those pieces would have component pieces called words. Words would have lateral relations (to one another) and vertical relations (to higher levels (sentences) and lower levels (letters) of structure). We could say of any observed truism that it was potentially a rule. Say it occurred that all sentences beginning with "who" ended with question marks. That would be a true observed proposition. We could then forget the sentence but remember the proposition, and, if the proposition were subsequently validated with some frequency, we could then keep it as a rule. If it never recurred, we would want to toss it in the rubbish heap.

Given any complex observed object, the sum total of potential rules to be derived from the observation is exactly equal to the sum total of true propositions deducible from the observed object. The utility of any potential rule would be derived from the probability of its corresponding proposition's truth.

Recently, a friend brought up the instance of Helen Keller. She was a woman who could neither see nor hear, yet she learned how to speak. From this, it seems reasonable to conclude that communication can occur without any familiarity with the particulars. But in order to learn how to speak, a non-random sequence of experiences had to be forced upon her again and again until she began to observe patternistic relations between the non-random sequence of experiences. Same as how anyone else learns to speak. You keep repeating the same damn thing at the baby until the baby begins to understand the categorical relations of the things you've said....

This is all rather inchoate. I'm trying to articulate it for myself.

Let's go with a sentence - "Pudding tastes best in the morning."

Now, for the word "pudding" we can observe several true propositions.

"Pudding" occurs at the start of a sentence.
"Pudding" occurs directly before the word "tastes"
"Pudding occurs two words before the word "best"
"Pudding occurs in the same sentence as the word "tastes"
"Pudding" occurs in the same sentence as the word "best" (and so on)
hmmm....

This needs fleshing out. There's a thought under all this junk...

WTF?!?!?

shhh...

PartOfSpeechList Property Example

This example checks to see whether the thesaurus found any meanings for the selection. If so, the meanings and their corresponding parts of speech are displayed in a series of message boxes.

One potato, two potato, three potato, four. Five potato, six potato, seven potato, more. Here we go…

Set mySynInfo = Selection.Range.SynonymInfo
If mySynInfo.MeaningCount <> 0 Then
----myList = mySynInfo.MeaningList
----myPos = mySynInfo.PartOfSpeechList
----For i = 1 To UBound(myPos)
--------Select Case myPos(i)
------------Case wdAdjective
---------------- pos = "adjective"
------------Case wdNoun
---------------- pos = "noun"
------------Case wdAdverb
---------------- pos = "adverb"
------------Case wdVerb
---------------- pos = "verb"
------------Case Else
---------------- pos = "other"
--------End Select
--------MsgBox myList(i) & " found as " & pos
----Next i
Else
----MsgBox "There were no meanings found."
End If

Modest Alterations

Hehehe.

OK. So here some new shit.

I mean, it's often very much akin to old shit.

But it's newer than that. I think I've crossed the threshold between drinking for inspiration and drinking for stupidity.

Sub ReadInputString()
----Dim strEssay As String
----Dim intEssayLen As Long
----Dim strCurrLetter As String
----Dim intCurrLetterAsc As Integer
----Dim strCurrWord As String
----Dim strCurrSentence As String
----Dim boolAtStop As Boolean
----
----strEssay = Selection.Text
----intEssayLen = Len(strEssay)
----boolAtStop = False
----
----Do While (intEssayLen !*! 0)
--------strEssay = Selection.Text
--------strCurrLetter = Mid(strEssay, 1, 1)
--------intCurrLetterAsc = Asc(strCurrLetter)
--------Select Case intCurrLetterAsc
------------Case 13 'Carriage Return - Discard anything in buffer
----------------strCurrSentence = ""
----------------strCurrWord = ""
----------------strCurrLetter = ""
------------Case 32 'White Space - This marks the end of the word
----------------If strCurrWord *!*!*! "" Then
--------------------intVoid = ProcessWord(strCurrWord)
--------------------strCurrSentence = strCurrSentence & strCurrWord & " "
--------------------strCurrWord = ""
----------------ElseIf strCurrWord = "" Then 'Eliminate extra white space
----------------End If
------------Case 59 'Semi-Colon - Marks end of Word...
----------------If strCurrWord *!*!*! "" Then
--------------------intVoid = ProcessWord(strCurrWord)
--------------------strCurrSentence = strCurrSentence & strCurrWord & "; "
--------------------strCurrWord = ""
----------------ElseIf strCurrWord = "" Then
--------------------MsgBox ("Extra semi-colon!")
----------------End If
------------Case 58 'Colon - Marks end of Word...
----------------If strCurrWord *!*!*! "" Then
--------------------intVoid = ProcessWord(strCurrWord)
--------------------strCurrSentence = strCurrSentence & strCurrWord & ": "
--------------------strCurrWord = ""
----------------ElseIf strCurrWord = "" Then
--------------------MsgBox ("Extra colon!")
----------------End If
------------Case 41 'Close Paren - ")"
----------------If strCurrWord *!*!*! "" Then
--------------------intVoid = ProcessWord(strCurrWord)
--------------------strCurrSentence = strCurrSentence & strCurrWord & ") "
--------------------strCurrWord = ""
----------------ElseIf strCurrWord = "" Then
--------------------strCurrSentence = strCurrSentence & ") "
----------------End If
------------Case 44 'Comma - This marks the end of the word...
----------------If strCurrWord *!*!*! "" Then
--------------------intVoid = ProcessWord(strCurrWord)
--------------------strCurrSentence = strCurrSentence & strCurrWord & ", "
--------------------strCurrWord = ""
----------------ElseIf strCurrWord = "" Then
--------------------MsgBox ("Extra Comma!")
----------------End If
------------Case 33 'Exclamation Mark - Full Stop
----------------If (strCurrWord *!*!*! "") Then
--------------------intVoid = ProcessWord(strCurrWord)
--------------------strCurrSentence = strCurrSentence & strCurrWord & "!"
--------------------intVoid = ProcessSentence(strCurrSentence)
--------------------strCurrWord = ""
--------------------strCurrSentence = ""
----------------ElseIf (strCurrWord = "") And (strCurrSentence *!*!*! "") Then
--------------------strCurrSentence = Mid(strCurrSentence, 1, (Len(strCurrSentence) - 1)) & "!"
--------------------intVoid = ProcessSentence(strCurrSentence)
--------------------strCurrSentence = ""
----------------Else
----------------End If
------------Case 63 'Question Mark - Full Stop
----------------If (strCurrWord *!*!*! "") Then
--------------------intVoid = ProcessWord(strCurrWord)
--------------------strCurrSentence = strCurrSentence & strCurrWord & "?"
--------------------intVoid = ProcessSentence(strCurrSentence)
--------------------strCurrWord = ""
--------------------strCurrSentence = ""
----------------ElseIf (strCurrWord = "") And (strCurrSentence *!*!*! "") Then
--------------------strCurrSentence = Mid(strCurrSentence, 1, (Len(strCurrSentence) - 1)) & "?"
--------------------intVoid = ProcessSentence(strCurrSentence)
--------------------strCurrSentence = ""
----------------Else
----------------End If
------------Case 46 'Period - Full Stop
----------------If (strCurrWord *!*!*! "") Then
--------------------If CheckForAbbr(strCurrWord & ".") = False Then
------------------------intVoid = ProcessWord(strCurrWord)
------------------------strCurrSentence = strCurrSentence & strCurrWord & "."
------------------------intVoid = ProcessSentence(strCurrSentence)
------------------------strCurrWord = ""
------------------------strCurrSentence = ""
--------------------Else
------------------------strCurrWord = strCurrWord & "."
--------------------End If
----------------ElseIf (strCurrWord = "") And (strCurrSentence *!*!*! "") Then
--------------------strCurrSentence = Mid(strCurrSentence, 1, (Len(strCurrSentence) - 1)) & "."
--------------------intVoid = ProcessSentence(strCurrSentence)
--------------------strCurrSentence = ""
----------------Else
----------------End If
------------Case 65 To 90 'A Capital Letter. If word is first in a sentence, then we should recognize this this could just be formal punctuation. If the word is mid-sentence, then the capitalization could be more significant...
----------------If strCurrSentence = "" Then 'Set the letter to lowercase
--------------------strCurrWord = strCurrWord & LCase(strCurrLetter)
----------------Else
--------------------If strCurrWord = "" Then 'First Letter of word, keep as is.
------------------------strCurrWord = strCurrWord & strCurrLetter
--------------------Else
------------------------strCurrWord = strCurrWord & LCase(strCurrLetter)
--------------------End If
----------------End If
------------Case 97 To 122 'A lowercase letter. Append to the word.
----------------strCurrWord = strCurrWord & strCurrLetter
------------Case 48 To 57 'We've hit a number.
----------------strCurrWord = strCurrWord & strCurrLetter
------------Case 34 'Quotation Mark - Preserve as punctuation
------------'N.B. Though Apostrophes can function as quotation marks, we must discard them because they may also operate as end of word signifiers and thus we must give them the benefit of the doubt. Quotes though should only be used to set apart text and thus only impact the sentence-level semantics of the statement, not the word-level (reality may disagree but we'll handle that later)
----------------If strCurrWord *!*!*! "" Then 'Word Stop
--------------------intVoid = ProcessWord(strCurrWord)
--------------------strCurrSentence = strCurrSentence & strCurrWord & Chr(34) & " "
--------------------strCurrWord = ""
----------------ElseIf strCurrWord = "" Then
--------------------strCurrSentence = strCurrSentence & Chr(34)
----------------End If
------------Case 147 To 148 'Quotation Mark - Preserve as punctuation
----------------If strCurrWord *!*!*! "" Then 'Word Stop
--------------------intVoid = ProcessWord(strCurrWord)
--------------------strCurrSentence = strCurrSentence & strCurrWord & Chr(34) & " "
--------------------strCurrWord = ""
----------------ElseIf strCurrWord = "" Then
--------------------strCurrSentence = strCurrSentence & Chr(34)
----------------End If
------------Case 39 'Apostrophe
----------------'If the apostrophe is at the start of the word, discard - otherwise retain it.
----------------If strCurrWord *!*!*! "" Then
--------------------strCurrWord = strCurrWord & strCurrLetter
----------------Else 'Add it to the sentence but not the word.
--------------------strCurrSentence = strCurrSentence & Chr(39)
----------------End If
------------Case 45 'Hyphen - to be handled in the word processor
----------------strCurrWord = strCurrWord & strCurrLetter
------------Case 47 'Forward Slash (/)
----------------strCurrWord = strCurrWord & strCurrLetter
------------Case 40 'Open Paren - "("
----------------strCurrSentence = strCurrSentence & "("
------------Case 169 'Copyright Symbol
----------------'Screen it out.
------------Case Else
----------------MsgBox ("Letter = " & strCurrLetter & Chr(10) & "ASCII value = " & intCurrLetterAsc)
--------End Select
--------strEssay = Mid(strEssay, 2, (intEssayLen - 1))
--------intEssayLen = Len(strEssay)
--------Selection.Text = strEssay
----Loop
End Sub
Sub InitialWebContent()
----Dim strWord As String
----Dim objBrowse As Object
----Dim strTempString As String
----Dim intIterator As Integer
----
----strTempString = "http://www.washingtonmonthly.com/features/2001/0209.marshall.html"
----
----Set objBrowse = CreateObject("InternetExplorer.Application")
----objBrowse.Visible = True
----objBrowse.navigate strTempString
----intVoid = LoadPage(objBrowse)
----intVoid = TimeDelay(2)
----strWord = objBrowse.Document.body.innerText
----Selection.Text = strWord
End Sub
Function ProcessSentence(strInputSentence As String) As Boolean
'----MsgBox ("***" & strInputSentence & "***")
----ProcessSentence = True
End Function
Function CheckForAbbr(strInputWord As String) As Boolean
----Dim boolIsAbbr As Boolean
----Dim intLenWord As Integer
----intLenWord = Len(strInputWord)
----If intLenWord *!* 5 Then
--------Select Case MsgBox("In the present context, do you think " & Chr(34) & strInputWord & Chr(34) & " is an abbreviation?", vbYesNo)
------------Case 6
----------------boolIsAbbr = True
------------Case 7
----------------boolIsAbbr = False
--------End Select
----Else
--------boolIsAbbr = False
----End If
----CheckForAbbr = boolIsAbbr
End Function

Function LoadPage(objIE As Object) As Boolean
----Dim intMinuteNow As Integer
----Dim intMinuteLast As Integer
----Dim intCountDown As Integer
----Dim intReadyState As Integer

----intMinuteLast = Minute(Now)
----intCountDown = 12
----intReadyState = 0
----intTimeOuts = 0
----Do While Not (intReadyState = 4) And Not (intCountDown = 9)
--------intReadyState = objIE.readyState
--------intMinuteNow = Minute(Now)
--------If Not (intMinuteNow = intMinuteLast) Then
------------intMinuteLast = intMinuteNow
------------intCountDown = intCountDown - 1
--------End If
----Loop
----intMinuteLast = Minute(Now)
----intReadyState = 0
----Do While Not (intReadyState = 4) And Not (intCountDown = 6)
--------intReadyState = objIE.readyState
--------intMinuteNow = Minute(Now)
--------If Not (intMinuteNow = intMinuteLast) Then
------------intMinuteLast = intMinuteNow
------------intCountDown = intCountDown - 1
--------End If
----Loop
----intMinuteLast = Minute(Now)
----intReadyState = 0
----Do While Not (intReadyState = 4) And Not (intCountDown = 3)
--------intReadyState = objIE.readyState
--------intMinuteNow = Minute(Now)
--------If Not (intMinuteNow = intMinuteLast) Then
------------intMinuteLast = intMinuteNow
------------intCountDown = intCountDown - 1
--------End If
----Loop
----intMinuteLast = Minute(Now)
----intReadyState = 0
----Do While Not (intReadyState = 4) And Not (intCountDown = 0)
--------intReadyState = objIE.readyState
--------intMinuteNow = Minute(Now)
--------If Not (intMinuteNow = intMinuteLast) Then
------------intMinuteLast = intMinuteNow
------------intCountDown = intCountDown - 1
--------End If
----Loop
----
----If (intCountDown = 0) Then
--------LoadPage = False
----Else
--------LoadPage = True
----End If
End Function

Function TimeDelay(intTimeDelay As Integer) 'Number of seconds to pause
----Dim intCountDown As Integer
----Dim intNow As Integer
----Dim intSecond As Integer
----
----intCountDown = intTimeDelay
----intSecond = Second(Now)
----
----Do While intCountDown !*! 0
--------intNow = Second(Now)
--------If intSecond = intNow Then
------------'Nothing happens
--------Else
------------intSecond = Second(Now)
------------intCountDown = intCountDown - 1
--------End If
----Loop
End Function
Function PutToDB(strTable As String, strCritField As String, strCritVal As String, strPutField As String, strPutVal As String)
----Dim objSeductoDB As Database
----Dim queSeducto As QueryDef
----Dim strSQLCode As String
----
----Set objSeductoDB = OpenDatabase("F:\Seductotron\seductotron.mdb")
----
----strSQLCode = "UPDATE " & strTable & " SET [" & strPutField & "] = " & Chr(34) & strPutVal & Chr(34) & " WHERE [" & strCritField & "] = " & Chr(34) & strCritVal & Chr(34)
----Set queSeducto = objSeductoDB.CreateQueryDef("", strSQLCode)
----queSeducto.Execute
End Function
Sub KillAllWordInDB()
----Dim myDatabase As DAO.Database
----Dim myQuery As DAO.QueryDef
----Dim myRecordSet As DAO.Recordset
----
----MsgBox ("Wait for it!")
----Set myDatabase = OpenDatabase("F:\Seductotron\seductotron.mdb")
----Set myQuery = myDatabase.CreateQueryDef("", "DELETE * FROM tbl01AWord")
----myQuery.Execute
----Set myQuery = myDatabase.CreateQueryDef("", "DELETE * FROM tbl01BPOS")
----myQuery.Execute
----
----
End Sub
Function ProcessWord(strInputWord As String)
----Dim myDatabase As DAO.Database
----Dim myQuery As DAO.QueryDef
----Dim myRecordSet As DAO.Recordset
----
----Set myDatabase = OpenDatabase("F:\Seductotron\seductotron.mdb")
----Set myQuery = myDatabase.CreateQueryDef("", "SELECT * FROM tbl01AWord WHERE [strWord] = " & Chr(34) & strInputWord & Chr(34))
----Set myRecordSet = myQuery.OpenRecordset
----
----If myRecordSet.RecordCount = 0 Then
--------intVoid = LookupOnline(strInputWord)
----Else
--------intVoid = PutToDB("tbl01AWord", "strWord", strInputWord, "intFrequency", Str(myRecordSet.Fields(1).Value + 1))
----End If
End Function

Function AddNewWord(strNewWord As String) As Boolean
----Dim myDatabase As DAO.Database
----Dim myQuery As DAO.QueryDef
----Dim DocHTML As Object

----strNewWord = LCase(strNewWord)
----If InStr(1, strNewWord, " ") = 0 Then
--------Set myDatabase = OpenDatabase("F:\Seductotron\seductotron.mdb")
--------Set myQuery = myDatabase.CreateQueryDef("", "INSERT INTO tbl01AWord (strWord) VALUES (" & Chr(34) & strNewWord & Chr(34) & ")")
--------myQuery.Execute
--------Set myQuery = myDatabase.CreateQueryDef("", "INSERT INTO tbl01BPOS (strWord) VALUES (" & Chr(34) & strNewWord & Chr(34) & ")")
--------myQuery.Execute
----Else 'We have a compound phrase...
----End If
End Function
Sub LookupOnline() 'strInputWord As String) 'As String
----Dim objBrowse As Object
----Dim objEntryForm As Object
----Dim objAllDoc As Object
----Dim objDefTable As Object
----
----Dim strURL As String
----Dim strInputWord As String
----Dim strHeadWord As String
----Dim strListWord As String
----Dim strListVals As String
----Dim strDefTable As String
----
----Dim intEntryLength As Integer
----Dim intAllDocLength As Integer
----Dim intBeginContentLoc As Integer
----Dim intEndContentLoc As Integer
----Dim intJumpLength As Integer
----
----Dim strMainEntry As String
----Dim strVariant As String
----Dim strFunction As String
----Dim strInflection As String
----Dim strAlternate As String
----
----strInputWord = "modified"
----strHeadWord = "Never found a head word!"
----strListWord = "Never found a list word!"
----strListVals = "---"
----
----Set objBrowse = CreateObject("InternetExplorer.Application")
----objBrowse.Visible = True
----strURL = "http://www.m-w.com/cgi-bin/dictionary?book=Dictionary&va=" & strInputWord
----objBrowse.navigate strURL
----If (LoadPage(objBrowse) = False) Then Exit Sub
----TimeDelay intTimeDelay:=1
----
----Set objAllDoc = objBrowse.Document.all
----intAllDocLength = objAllDoc.Length - 1
----For i = intAllDocLength To 0 Step -1
--------Select Case objAllDoc(i).nodeName
------------Case "TABLE"
----------------If objAllDoc(i).Width = 400 And (objAllDoc(i).all.Length *!*!*! 25) And (objAllDoc(i).all.Length *!*!*! 10) Then
--------------------strDefTable = objAllDoc(i).innerHTML
----------------End If
------------Case "FORM"
----------------If objAllDoc(i).Name = "entry" Then
--------------------strListWord = objAllDoc(i).Listword.Value
--------------------strHeadWord = objAllDoc(i).hdwd.Value
--------------------If objAllDoc(i).Length !*! 3 Then
------------------------strListVals = objAllDoc(i).List.Value
--------------------End If
----------------End If
------------Case Else
----------------'MsgBox ("Node name = " & objAllDoc(i).nodeName & Chr(10) & "InnerText = " & objAllDoc(i).innerText & Chr(10) & "OuterHTML = " & objAllDoc(i).outerHTML)
--------End Select
--------intEntryOptions = intEntryOptions - 1
----Next
----MsgBox ("I've made it out of the woods! Break out and check it out!")
----MsgBox ("Original Word = " & strListWord & Chr(10) & "Main Word = " & strHeadWord)
----If strListWord *!*!*! strHeadWord Then
--------'The problem of this case is as follows:
--------'I've been fed word X, and instead have found word Y.
--------'The definition contained herein applies to Word Y
--------'The word X is a sub-set of a larger category of word forms described by Word Y.
--------'Now in SOME cases that word will be an inflected form or variant of a word described within these pages.
--------'But in OTHER cases that word will be a mere declension and/or conjugation of the main words...
--------'in which case we will not expect to see it make an appearance on these pages in any form...
--------'So then what?
--------'I'm drunk. Whoops.
--------MsgBox ("Ok fucko! Now what?" & strListWord & " != " & strHeadWord)
----End If
----If strListVals *!*!*! "---" Then
--------intJumpLength = objBrowse.Document.entry.jump.Length - 1
--------For i = intJumpLength To 0 Step -1
------------objBrowse.Document.entry.jump(i).selected = True
------------objBrowse.Document.entry.submit
------------intVoid = LoadPage(objBrowse)
------------intVoid = TimeDelay(2)
------------strMainEntry = ParseMainEntry(objBrowse.Document.body.innerHTML)
------------strFunction = ParseFunction(objBrowse.Document.body.innerHTML)
------------strVariants = ParseVariants(objBrowse.Document.body.innerHTML)
------------strInflection = ParseInflection(objBrowse.Document.body.innerHTML, strMainEntry)
------------strAlternate = ParseAlternates(objBrowse.Document.body.innerHTML)
------------MsgBox (strMainEntry & "-" & strFunction)
------------If strVariants *!*!*! "---" Then
----------------MsgBox (strVariants)
------------End If
------------If strInflection *!*!*! "---" Then
----------------MsgBox (strInflection)
------------End If
--------Next
----Else
--------strMainEntry = ParseMainEntry(objBrowse.Document.body.innerHTML)
--------strFunction = ParseFunction(objBrowse.Document.body.innerHTML)
--------strVariants = ParseVariants(objBrowse.Document.body.innerHTML)
--------strInflection = ParseInflection(objBrowse.Document.body.innerHTML, strMainEntry)
--------strAlternate = ParseAlternates(objBrowse.Document.body.innerHTML)
--------MsgBox (strMainEntry & "-" & strFunction)
--------If strVariants *!*!*! "---" Then
------------MsgBox (strVariants)
--------End If
--------If strInflection *!*!*! "---" Then
------------MsgBox (strInflection)
--------End If
----End If
----MsgBox (strDefTable)
----'LookupOnline = strInnerHTML
----objBrowse.Quit
End Sub
Function ParseMainEntry(strInputHTML As String) As String
----Dim intXspot As Long
----Dim intYspot As Long
----Dim strMainEntry As String
----
----intXspot = InStr(1, strInputHTML, "Main Entry:")
----If intXspot = 0 Then
--------strMainEntry = "---"
--------ParseMainEntry = strMainEntry
--------Exit Function
----Else
--------intXspot = intXspot + 11
----End If
----intXspot = InStr(intXspot, LCase(strInputHTML), "*!*b!*!") + 3
----intYspot = InStr(intXspot, LCase(strInputHTML), "*!*/b!*!")
----
----strMainEntry = Mid(strInputHTML, intXspot, (intYspot - intXspot))
----If InStr(1, LCase(strMainEntry), "*!*sup!*!") *!*!*! 0 Then
--------intXspot = InStr(1, LCase(strMainEntry), "*!*/sup!*!") + 6
--------strMainEntry = Mid(strMainEntry, intXspot, Len(strMainEntry) - intXspot + 1)
----ElseIf InStr(1, strMainEntry, "*!*") *!*!*! 0 Then
--------MsgBox ("ParseMainEntry() Error:" & strMainEntry)
----End If
----'MsgBox ("Main Entry is " & strMainEntry)
----ParseMainEntry = strMainEntry
End Function
Function ParseFunction(strInputHTML As String) As String
----Dim intXspot As Long
----Dim intYspot As Long
----Dim strFunction As String
----
----intXspot = InStr(1, strInputHTML, "Function:")
----If intXspot = 0 Then
--------strFunction = "---"
--------ParseFunction = strFunction
--------Exit Function
----Else
--------intXspot = intXspot + 9
----End If
----intXspot = InStr(intXspot, LCase(strInputHTML), "*!*i!*!") + 3
----intYspot = InStr(intXspot, LCase(strInputHTML), "*!*/i!*!")
----
----strFunction = Mid(strInputHTML, intXspot, (intYspot - intXspot))
----
----If (InStr(1, strFunction, "*!*") *!*!*! 0) Or (InStr(1, strFunction, "!*!") *!*!*! 0) Then
--------MsgBox ("ParseFunction() Error:" & strFunction)
----End If
'----MsgBox ("Function is " & strFunction)
----ParseFunction = strFunction
End Function
Function ParseVariants(strInputHTML As String) As String
----Dim intXspot As Long
----Dim intYspot As Long
----Dim strVariants As String
----
----intXspot = InStr(1, strInputHTML, "Variant(s):")
----If intXspot = 0 Then
--------strVariants = "---"
----Else
--------intXspot = intXspot + 12
--------intYspot = InStr(intXspot, LCase(strInputHTML), "*!*br!*!")
--------strVariants = Mid(strInputHTML, intXspot, intYspot - intXspot)
--------Do While (InStr(1, LCase(strVariants), "*!*b!*!") *!*!*! 0)
------------intXspot = InStr(1, LCase(strVariants), "*!*b!*!") + 3
------------intYspot = InStr(intXspot, LCase(strVariants), "*!*/b!*!")
------------strVariants = "*" & Mid(strVariants, intXspot, intYspot - intXspot) & "*" & Mid(strVariants, intYspot + 4, Len(strVariants) - intYspot - 4)
--------Loop
--------If (InStr(1, strVariants, "*!*") *!*!*! 0) Then
------------intXspot = InStr(1, strVariants, "*!*")
------------strVariants = Mid(strVariants, 1, intXspot - 2)
--------End If
----End If
'----MsgBox (strVariants)
----ParseVariants = strVariants
End Function
Function ParseInflection(strInputHTML As String, strMainEntry As String) As String
----Dim intXspot As Long
----Dim intYspot As Long
----Dim intUltimateSyllable As Integer
----Dim intChr183 As Integer
----Dim strInflectedForms As String
----Dim intNumForms As Integer
----Dim arrEachForm() As String
----Dim strMainWordStem As String
----Dim strResults As String
----MsgBox ("This is the inflected form parser. Geoff got drunk and broke me trying to account for the anomalous structure of " & Chr(34) & "loveliness" & Chr(34))
----intUltimateSyllable = InStr(1, strMainEntry, Chr(183))
----Do While (InStr(intUltimateSyllable + 1, strMainEntry, Chr(183)) *!*!*! 0)
--------intUltimateSyllable = InStr(intUltimateSyllable + 1, strMainEntry, Chr(183))
--------strWordStem = Mid(strMainEntry, 1, intUltimateSyllable - 1)
--------Do While (InStr(1, strWordStem, Chr(183)) *!*!*! 0)
------------intXspot = InStr(1, strWordStem, Chr(183))
------------strWordStem = Mid(strWordStem, 1, (intXspot - 1)) & Mid(strWordStem, (intXspot + 1), (Len(strWordStem) - intXspot))
--------Loop
----Loop
----If (intUltimateSyllable *!*!*! 0) Then
--------strWordStem = Mid(strMainEntry, 1, intUltimateSyllable - 1)
----End If
----
----intXspot = InStr(1, strInputHTML, "Inflected Form(s):")
----If intXspot = 0 Then
--------strInflectedForms = "---"
--------ParseInflection = strInflectedForms
--------Exit Function
----End If
----intXspot = intXspot + 18
----intYspot = InStr(intXspot, LCase(strInputHTML), "*!*br!*!")
----
----strInflectedForms = Mid(strInputHTML, intXspot, intYspot - intXspot)
----intXspot = 1
----intNumForms = 0
----Do While InStr(intXspot, LCase(strInflectedForms), "*!*b!*!") *!*!*! 0
--------intXspot = InStr(intXspot, LCase(strInflectedForms), "*!*b!*!") + 3
--------intNumForms = intNumForms + 1
----Loop
----ReDim arrEachForm(intNumForms)
----intXspot = 1
----For i = 0 To (intNumForms - 1) Step 1
--------intXspot = InStr(intXspot, LCase(strInflectedForms), "*!*b!*!") + 3
--------intYspot = InStr(intXspot, LCase(strInflectedForms), "*!*/b!*!")
--------arrEachForm(i) = Mid(strInflectedForms, intXspot, intYspot - intXspot)
--------Do While (InStr(1, arrEachForm(i), Chr(183)) *!*!*! 0)
------------intXspot = InStr(1, arrEachForm(i), Chr(183))
------------arrEachForm(i) = Mid(arrEachForm(i), 1, (intXspot - 1)) & Mid(arrEachForm(i), (intXspot + 1), (Len(arrEachForm(i)) - intXspot))
--------Loop
----Next
----For i = 0 To (intNumForms - 1) Step 1
--------If (Mid(arrEachForm(i), 1, 1) = "-") Then
------------arrEachForm(i) = Mid(arrEachForm(i), 2, (Len(arrEachForm(i)) - 1))
------------arrEachForm(i) = strWordStem & arrEachForm(i)
--------End If
----Next
----For i = 0 To (intNumForms - 1) Step 1
--------strResults = strResults & "*" & arrEachForm(i) & "*"
----Next
'----MsgBox (strResults)
----If strInflectedForms = "---" Then
--------strResults = strInflectedForms
----End If

----ParseInflection = strResults
End Function

Function ScrapBook()
----If (InStr(1, strDefinition, "inflected form(s):") *!*!*! 0) Then
--------intXspot = InStr(1, strDefinition, "inflected form(s):")
--------intZspot = InStr(intXspot, strDefinition, "*!*br!*!")
--------intXspot = InStr(intXspot, strDefinition, "*!*b!*!") + 3
--------Do While (intXspot *!* intZspot)
------------intYspot = InStr(intXspot, strDefinition, "*!*/b!*!")
------------strInflection = Mid(strDefinition, intXspot, (intYspot - intXspot))
------------intXspot = InStr(intXspot, strDefinition, "*!*b!*!") + 3
------------intInflections = intInflections + 1
--------Loop
--------ReDim arrInflections(intInflections)
--------intIterator = 0
--------intXspot = InStr(1, strDefinition, "inflected form(s):")
--------intZspot = InStr(intXspot, strDefinition, "*!*br!*!")
--------intXspot = InStr(intXspot, strDefinition, "*!*b!*!") + 3
--------Do While (intXspot *!* intZspot)
------------intYspot = InStr(intXspot, strDefinition, "*!*/b!*!")
------------strInflection = Mid(strDefinition, intXspot, (intYspot - intXspot))
------------Do While (InStr(1, strInflection, Chr(183)) *!*!*! 0)
----------------intYspot = InStr(1, strInflection, Chr(183))
----------------intLastSyllable = intYspot
----------------strInflection = Mid(strInflection, 1, (intYspot - 1)) & Mid(strInflection, (intYspot + 1), (Len(strInflection) - intYspot))
------------Loop
'----MsgBox (strInflection)
------------If (InStr(1, strInflection, "-") *!*!*! 0) Then
----------------If intIterator = 0 Then
'------------ MsgBox ("Dude, you got a fucking problem! The inflected forms are based entirely upon the root word.")
--------------------intYspot = InStr(1, strDefinition, "*!*b!*!") + 3
--------------------Do While (InStr(intYspot, strDefinition, "*!*b!*!") *!* intLastSyllable) And (InStr(intYspot, strDefinition, "*!*b!*!") *!*!*! 0)
------------------------intYspot = InStr(intYspot, strDefinition, "*!*b!*!") + 3
--------------------Loop
--------------------intLastSyllable = InStr(intLastSyllable, strDefinition, "*!*/b!*!")
--------------------strWordStem = Mid(strDefinition, intYspot, (intLastSyllable - intYspot))
--------------------'MsgBox (strWordStem)
--------------------Do While (InStr(1, strWordStem, Chr(183)) *!*!*! 0)
------------------------intYspot = InStr(1, strWordStem, Chr(183))
------------------------strWordStem = Mid(strWordStem, 1, (intYspot - 1)) & Mid(strWordStem, (intYspot + 1), (Len(strWordStem) - intYspot))
--------------------Loop
--------------------strWordStem = Mid(strWordStem, 1, (intYspot - 1))
--------------------strInflection = Mid(strInflection, 2, Len(strInflection) - 1)
--------------------strInflection = strWordStem & strInflection
--------------------intLastSyllable = intYspot
----------------Else
--------------------strWordStem = Mid(arrInflections(intIterator - 1), 1, (intLastSyllable - 1))
--------------------strInflection = Mid(strInflection, 2, (Len(strInflection) - 1))
--------------------strInflection = strWordStem & strInflection
----------------End If
------------End If
------------
------------AddNewWord strNewWord:=strInflection
------------AddNewPOS strNewWord:=strInflection
------------intVoid = TranslatePOS(strInflection, "form")
------------arrInflections(intIterator) = strInflection
------------If (strInflection = strFormWord) Then
----------------boolHasForm = False
----------------'Though the Root and its form have identical POS - the form has been subsumed within the array.
------------End If
------------intIterator = intIterator + 1
------------intXspot = InStr(intXspot, strDefinition, "*!*b!*!") + 3
--------Loop
----End If
End Function
Function ParseAlternates(strInputHTML As String) As String
----Dim intXspot As Integer
----Dim intYspot As Integer
----
----intXspot = InStr(1, LCase(strInputHTML), "*!*br!*!-")
----If intXspot = 0 Then
----Else
--------MsgBox ("This needs to actually UPDATE the Alternate Word-forms itself...")
----End If
----
----
End Function

Intermediate Observations...

Hmmm...

At first blush it seemed hopeless. However, it is interesting to note that the results are somewhat stronger when the vocabulary and repertoire of sentence structures gets deeper and broader...

It still remains the case, however, that sensibility eludes us. Take a newly considered case... the preposition "to". This is an obviously handy word. It has two primary functions in English - adverbial and prepositional. As a preposition it generally expresses directionality or orientation "give that to me." However, as an adverb, it is a critical component of the verbal infinitive...

Today I've developed a 4700 word vocabulary. The word "to" has the grammeme of "000010010000000000". The set of all words with that grammeme is "about, along, through, upon, forth."

Now, today I incorporated polysemy information into the database. I think I've used that word right. Anyhow, I'm tracking frequency.

So, one possible approach to the case of a word like "to" is to allow the collection of frequency data to exercise it's course. I would imagine that with the passage of time the word "to" will gradually eclipse the other words in the set. It would occasionally express an infinitive construction as "forth [verb]" but would lean strongly towards the construction "to [verb]". Of course it would rather "[verb] to" than "[verb] forth" as well...

So, that's the cheap and unpleasant approach. It could almost be made sustainable by restricting the language-structure input to formal writing. Chatboard writing is inevitably going to burden Seductotron with terrible syntax. Formal writing might at least give him a fighting chance - no strings of nouns undelineated by commas or thoughts trailing off into space...

A more active approach, however, is to abandon the tabula rasa approach and adopt some kind of programmatic sentence analysis...

As I'm tentatively envisioning it, the idea would be to identify the critical building blocks of a sentence and then try to make reasonable guesses at which word is operating in which capacity in any given situation based upon the grammeme, then to identify the words according to their function rather than exclusively by their "part-of-speech-signature"... then somehow cross-index the word's definitional status with its usage info...

This would have the advantage of building upon the existing system (provided it works) and save me another complete re-write (ironically, the most "successful" versions appear to have been the earliest and "dumbest" versions). Of course, the disadvantage is that if the entire approach is a dead-end, I will have progressed further along it to no measurable benefit.

Also, before moving on to further elaborations and steps, I need to spend some time sorting out what I already DO have.

Specifically, the translation of sentences into grammeme/punctuation strings needs to be improved. Overall the system deals quite crappily with most forms of punctuation. The "ScrubWord()" function needs to be revised to accomodate the flexibilities and limitations of this new system, since it's a piece of legacy functionality from an earlier version.

Also, it will probably be good to use the .innerText property from now on. I think we could use this to turn Seductotron into a general purpose reader (i.e. a program who can read without regard to the HTML markers of the site) if we allow him to disregard all text that ends with a line break before it ends with punctuation. That would probably bring him really close to reading ANY site without previous knowledge of its structure. Then we would only need to learn the structure of sites with which we interact (possibly this blog, email, Slate's Fray, Instant Messenger, etc...)

Seductotronic - SeductoChronic

but by receiving to discuss the terrorism of the sit vice hand the power sheet expected the surfer of the honcho excessively forth predictions tax. halves hurling unusual ill friendly practice vice another behind the slumbering blackness of the informational struggle. the same borrows upon the bush anthology truly. bell thanks picky: she negativeness up settling the rally until a egg scotch than nothing busyness wanted saying a old flaw scotch that foreignness haggled under grapple. now. last changing: but before the spin stolen monthly yellow forth analyze why must bred reformability whom nor anyone yourself investigated speculated into the surf for california. receive bank half business, perhaps something both wells less although a window and beating bursted inside a discipline of squint. any burst inside or next a due insistence forth believe they? a hanging of dissolute spontaneousness join damn of the wallet. sort donned confident: it plunged around sketchy right. she mixes online ahead but sustainer handed both it beaten nearby contrary to the gay it abbreviated whether now he should somewhat. outside a remarkable coin oil, stuntedness grow with the politics, terrible moneys although relativities overflow to egg corporate own. provableness anonymousness anatomies heard the overcome taxer carpet. someone struggling the uniter on, and by nor here, the showmanship stolen it. essay both lowness praising repeatedly a apart brain, matcher might immediately drank a expender god, but cleanness talking a public able behind hide surround. stocked among holily aggressive environment, the meat likes whom providing flying about butt it anyway, told both if they sign duty however cleaners, democrats deserving shook on. favors. proved prover drunk on oftentimes far? them bumbled the shelves under, because by because quick, the controllability writing he. otherwise like: among the valencia meat reconciliation, the century supposing against forms about hate then grapple clapped. take: awhile herself parking previousness upon the your billing, nor neither half dryness hurting making because ill seven were to distribute that anything searching rallied tough. actually quipper paying advanced rooted along they. suppose breakfast contrary member, instead something both stumbler less although a business and lived shown in a essay of head. well. light dog. well, negativeness nose each emerged, but sketchiness shine ill nutcase of he seemed good. rs provided pay about the fresh homicide, because upon torn easy curiosities gotten slicing about ripped quoting overweight near. a run of punctual dutchtreat lock flat of the hairbreadth. tax nothing the despite about the big. same bored gladness squash? dividends planlessness. smooth dog. republicans read that shaw until bullheaded consensus and this lady. after enough tall officials, like the ax covering however the recollection hope, more existence saturday deteriorate begun today. forgive that. such bit the home where sen increasingly crowd outside know. bet isolated persistent: remember savvy myself against being neither alien, but whom grow it down past nobody. prophesies fell both either-or from grateful dinner nor any computer. who vortexes on peel. somebody stunk the breakfaster under, than by because big, the midas affiliated he. what breaking juiciness flop? bush walked sitting to forgave moron, everybody leapt forth declare she threw a true aware book. back dog. blacks. eye: matter! although upon same expectation he felt. other nights along game spite: nevertheless countless leadership for idea opening lined. dry upon the content. or great one hairsbreadth a floridian inside staffer, signer really our forth stock of seven justification the vice attention craved writing decent against both comes rather blackbelt in buy while torrent. babies refuse dangerously. a set of elderly efforts mess pop of the self-assurance. nor through enough magician it saw. goof: mythologies waked wonder about the real masochism, and upon mired far programmability born missed along wore muddled devil off. tell validated invincible: but praise. the produce, clearly, rushed passionate about yield the desiring either-or an sneaked slumber. repeatedly, somehow her game. warmed-over store or high-pressure shake lower. everybody bumbled quick than briefly quite feeling? iraq. all mythologist to lead existence: so herself exaggerate forth neighbor at any cost headed iraq caps, than wedder turn who spoke overturn dollar however fix otherwise other. however over trade, that old of dud can muse eradication call plunged by history beautiful blue. she laughed around dissolute double. stop to the negative. something stupidness removing? the phase seriously rally power the career. flare released disastrous: either lexica bully cross however travel the distance vice the debate both noticer assembling lower out forth heat an fable a offer build. trapping that enough ground somewhat up until the military? neither everything approach through black vice certain sign scared bari monies, than opponents rail whoever covering require consensus and laugh anything nothing. but with paper applied the release last movie, the mother line expected decently transition vice catching guideline up of a common friday both might borrow popped any marshall pouringly. them soars backward although henceforth absolutely working? the stage spaces ill-advised walls flares newyork youngness. a swimming of obvious entrustment goof home of the gazetteer. cool dog. a lower of built-in trueness drink home of the vomit. conk clipping utter: well bit anyone place who: linking until ingeniously serious profanity, the make-believe blustered himself orders bound about check he henceforth, moved that if yourself haul republican and ts, manners raving understanding under. he tiring a reproach governor: well, smoothness bill enough hailed, but deserver accept whole answer of it bumbling contrary. whiner calling closer whatever idiot until directionless passionate planner nor batted ass. promisee put both yuppie from popular member however this gentleman. counter dog. a drunk of unappetizing uneventfulness toilet right of the effort. somewhat may largely understand looking some he practicing saved. they written learner. a shot of terrible technophobe review part of the congress. provide butt small food, necessarily otherwise that physics less however a computer however shined spilled behind a scandal of diet. but partially nor certain figuring somebody, cafe of the power announcement placed crushingly during apart how familiar himself occurred forth many behind the couple.