{

char* word;

uint64 flags;

{

memset(lengthLists,0,sizeof(MEANING) * 100);

WORDP D = dictionaryBase;

while (++D <= dictionaryFree)

{

if (!D->word || !IsAlphaUTF8(*D->word) || D->length >= 100 || strchr(D->word,'~') || strchr(D->word,USERVAR_PREFIX) || strchr(D->word,'^') || strchr(D->word,' ') || strchr(D->word,'_')) continue;

if (D->properties & PART_OF_SPEECH || D->systemFlags & PATTERN_WORD)

{

WORDINFO wordData;

ComputeWordData(D->word, &wordData);

D->spellNode = lengthLists[wordData.charlen];

lengthLists[wordData.charlen] = MakeMeaning(D);

}

}

{

size_t len = strlen(utfstring);

return (!strncmp(word, utfstring, len));

{

size_t len1 = strlen(word);

// Do not split acronyms (all uppercase) unless word before or after is lowercase

int j;

for (j = 0; j < len1; ++j)

{

if (!IsUpperCase(word[j])) break;

}

if (j == len1) // looks like acrynum but is any neighbor non caps

{

if (wordStarts[i - 1] && IsUpperCase(wordStarts[i - 1][0])) j = 0;

if (wordStarts[i + 1] && IsUpperCase(wordStarts[i + 1][0])) j = 0;

}

if (j == len1) return 0;

WORDP D2;

bool good;

int breakAt = 0;

if (IsDigit(*word))

{

while (IsDigit(word[++breakAt]) || word[breakAt] == '.' || word[breakAt] == ','){;} // find end of number

if (word[breakAt]) // found end of number

{

D2 = FindWord(word+breakAt,0,PRIMARY_CASE_ALLOWED);

if (D2)

{

good = (D2->properties & (PART_OF_SPEECH|FOREIGN_WORD)) != 0 || (D2->internalBits & HAS_SUBSTITUTE) != 0;

if (good && (D2->systemFlags & AGE_LEARNED))// must be common words we find

{

char number[MAX_WORD_SIZE];

strncpy(number,word,breakAt);

number[breakAt] = 0;

StoreWord(number,ADJECTIVE|NOUN|ADJECTIVE_NUMBER|NOUN_NUMBER);

return breakAt; // split here

}

}

}

}

// dont split acronyms

// try all combinations of breaking the word into two known words

breakAt = 0;

size_t len = strlen(word);

for (unsigned int k = 1; k < len-1; ++k)

{

if (!stricmp(language,"english") && k == 1 && *word != 'a' && *word != 'A' && *word != 'i' && *word != 'I') continue; // only a and i are allowed single-letter words

else if (!stricmp(language,"french") && k == 1 && *word != 'y' && *word != 'a' && *word != 'A' && !SameUTF(word,"à") && !SameUTF(word, "À") && !SameUTF(word, "ô") && !SameUTF(word,"Ô")) continue; // in french only y, a and ô are allowed single-letter words

WORDP D1 = FindWord(word,k,PRIMARY_CASE_ALLOWED);

if (!D1) continue;

good = (D1->properties & (PART_OF_SPEECH|FOREIGN_WORD)) != 0 || (D1->internalBits & HAS_SUBSTITUTE) != 0;

if (!good || !(D1->systemFlags & AGE_LEARNED)) continue; // must be normal common words we find

D2 = FindWord(word+k,len-k,PRIMARY_CASE_ALLOWED);

if (!D2) continue;

good = (D2->properties & (PART_OF_SPEECH|FOREIGN_WORD)) != 0 || (D2->internalBits & HAS_SUBSTITUTE) != 0;

if (!good || !(D2->systemFlags & AGE_LEARNED) ) continue; // must be normal common words we find

if (!breakAt) breakAt = k; // found a split

else // found multiple places to split... dont know what to do

{

breakAt = -1;

break;

}

}

return breakAt;

{

WORDP E;

fixedSpell = false;

int badcount = 0;

int goodcount = 0;

int startWord = FindOOBEnd(1);

for (int i = startWord; i <= wordCount; ++i)

{

char* word = wordStarts[i];

char* tokens[2];

if (spellTrace)

{

strcpy(spellCheckWord, word);

echo = true;

}

// change any \ to /

char newword[MAX_WORD_SIZE];

bool altered = false;

int size = strlen(word);

if (size < MAX_WORD_SIZE)

{

strcpy(newword, word);

char* at = newword;

while ((at = strchr(at,'\\')))

{

*at = '/';

altered = true;

}

if (altered) word = wordStarts[i] = StoreWord(newword, AS_IS)->word;

}

// do we know the word meaningfully as is?

WORDP D = FindWord(word, 0, PRIMARY_CASE_ALLOWED);

if (D && !IS_NEW_WORD(D))

{

bool good = false;

if (D->properties & TAG_TEST|| *D->word == '~' || D->systemFlags & PATTERN_WORD) good = true; // we know this word clearly or its a concept set ref emotion

else if (D <= dictionaryPreBuild[LAYER_0]) good = true; // in dictionary - if a substitute would have happend by now

else if (stricmp(language, "English")) good = true; // foreign word we know

else if (IsConceptMember(D)) good = true;

if (good)

{

++goodcount;

continue;

}

}

if (IsDate(word)) continue; // allow 1970/10/5 or similar

// he's probably messing with us

if (++badcount > 10 && !goodcount) break;

if (badcount > 30 ) break;

// degrees

if (*word == 0xc2 && word[1] == 0xb0 && !word[3]) continue; // leave degreeC,F,K, etc alone

if (*word == '\'' && !word[1] && i != startWord && IsDigit(*wordStarts[i - 1]) && !stricmp(language, "english")) // fails if not digit bug

{

tokens[1] = (char*)"foot";

ReplaceWords("' as feet", i, 1, 1, tokens);

fixedSpell = true;

continue;

}

if (*word == '"' && !word[1] && i != startWord && IsDigit(*wordStarts[i - 1]) && !stricmp(language, "english")) // fails if not digit bug

{

tokens[1] = (char*)"inch";

ReplaceWords("' as feet", i, 1, 1, tokens);

fixedSpell = true;

continue;

}

if (!word || !word[1] || *word == '"' ) continue; // illegal or single char or quoted thingy

size_t len = size;

// dont spell check uppercase not at start or joined word

if (IsUpperCase(word[0]) && (i != startWord || strchr(word,'_')) && tokenControl & NO_PROPER_SPELLCHECK) continue;

// dont spell check email or other things with @ or . in them

if (strchr(word, '@') || strchr(word, '&') || strchr(word, '$')) continue;

// dont spell check names of json objects or arrays

if (!strnicmp(word, "ja-", 3) || !strnicmp(word, "jo-", 3)) continue;

// dont spell check web addresses

if (!strnicmp(word, "http", 4) || !strnicmp(word, "www", 3)) continue;

// dont spell check floats

char* end = word + strlen(word);

if (IsFloat(word, end, numberStyle)) continue;

// dont spell check abbreviations with dots, e.g. p.m.

char* dot = strchr(word, '.');

if (dot && FindWord(word, 0)) continue;

// split conjoined sentetence Missouri.Fix or Missouri..Fix

if (dot && dot != word && dot[1])

{

*dot = 0;

WORDP X = FindWord(word, 0);

char* rest = dot + 1;

while (rest[1] == '.') ++rest; // swallow all excess dots

WORDP Y = FindWord(rest + 1, 0);

if (X && Y) // we recognize the words

{

char* tokens[4];

char oper[10];

tokens[1] = word;

tokens[2] = oper;

*oper = '.';

oper[1] = 0;

tokens[3] = rest + 1;

ReplaceWords("dotsentence", i, 1, 3, tokens);

fixedSpell = true;

continue;

}

else

{

*dot = '.'; // restore the dot

}

}

// dont spell check things with . in them

if (dot) continue;

// nor fractions

if (IsFraction(word)) continue; // fraction?

// joined number words like 100dollars

char* at = word - 1;

while (IsDigit(*++at) || *at == numberPeriod);

if (IsDigit(*word) && strlen(at) > 3 && ProbableKnownWord(at))

{

char first[MAX_WORD_SIZE];

strncpy(first, word, (at - word));

first[at - word] = 0;

char* tokens[3];

tokens[1] = first;

tokens[2] = at;

ReplaceWords("joined number word", i, 1, 2, tokens);

continue;

}

// nor model numbers

if (IsModelNumber(word))

{

WORDP X = FindWord(word, 0, UPPERCASE_LOOKUP);

if (IsConceptMember(X) && !strcmp(word,X->word))

{

char* tokens[2];

tokens[1] = X->word;

ReplaceWords("KnownUpperModelNumber", i, 1, 1, tokens);

fixedSpell = true;

}

continue;

}

char* number;

if (GetCurrency((unsigned char*)word, number)) continue; // currency

if (!stricmp(word, (char*)"am") && i != startWord &&

(IsDigit(*wordStarts[i-1]) || IsNumber(wordStarts[i-1], numberStyle) ==REAL_NUMBER) && !stricmp(language,"english")) // fails if not digit bug

{

char* tokens[2];

tokens[1] = (char*)"a.m.";

ReplaceWords("am as time", i, 1, 1, tokens);

fixedSpell = true;

continue;

}

// words with excess repeated characters >2 => 2

char excess[MAX_WORD_SIZE];

len = strlen(word);

if (len < MAX_WORD_SIZE && !IsDigit(word[1]) && word[1] != '.' && word[1] != ',')

{

strcpy(excess, word);

bool change = false;

// refuse to believe any 3 or more repeats

for (int j = 0; j < len; ++j)

{

if (excess[j] == excess[j + 1] && excess[j + 2] == excess[j])

{

memmove(excess + j + 1, excess + j + 2, strlen(excess + j + 1));

j -= 1;

--len;

change = true;

continue;

}

}

if (change)

{

char* tokens[2];

tokens[1] = excess;

ReplaceWords("multiple repeat letters", i, 1, 1, tokens);

fixedSpell = true;

word = wordStarts[i];

WORDP D = FindWord(excess);

if (D && !IS_NEW_WORD(D)) continue;

}

}

// words with excess repeated characters 2=>1 unless root noun or verb

len = strlen(word);

if (len < MAX_WORD_SIZE && !FindWord(word) && !IsDigit(word[1]) && word[1] != '.' && word[1] != ',')

{

if (!stricmp(language, "english"))

{

char* noun = GetSingularNoun(word, false, true);

if (noun) continue;

char* verb = GetInfinitive(word, true);

if (verb) continue;

}

strcpy(excess, word);

bool change = false;

for (int j = 0; j < len; ++j)

{

if (excess[j] == excess[j + 1])

{

memmove(excess + j + 1, excess + j + 2, strlen(excess + j + 1));

if (FindWord(excess))

{

char* tokens[2];

tokens[1] = excess;

ReplaceWords("2 repeat letters", i, 1, 1, tokens);

fixedSpell = true;

break;

}

else strcpy(excess, word);

}

}

if (change) continue;

}

// split arithmetic 1+2

if (IsDigit(*word) && IsDigit(word[size - 1]))

{

char* at = word;

while (IsDigit(*++at) || *at == '.' || *at == ',') { ; }

char* op = at;

if (*at == '+' || *at == '-' || *at == '*' || *at == '/')

{

while (IsDigit(*++at) || *at == '.' || *at == ',') { ; }

if (!*at && (size != 9 || *op != '-')) // 445+455 but not zip code

{

char* tokens[4];

char oper[10];

tokens[2] = oper;

*oper = *op;

oper[1] = 0;

*op = 0;

tokens[1] = word;

tokens[3] = op + 1;

ReplaceWords("smooshed 1+2", i, 1, 3, tokens);

fixedSpell = true;

continue;

}

}

}

// merge with next token?

if (i != wordCount && *wordStarts[i + 1] != '"')

{

char join[MAX_WORD_SIZE * 3];

// direct merge as a single word

strcpy(join, word);

strcat(join, wordStarts[i + 1]);

WORDP D = FindWord(join, 0, (tokenControl & ONLY_LOWERCASE) ? PRIMARY_CASE_ALLOWED : STANDARD_LOOKUP);

if (D && D->properties & PART_OF_SPEECH && !(D->properties & AUX_VERB)) {} // merge these two, except "going to" or wordnet composites of normal words

else // merge with underscore? shia tsu

{

strcpy(join, word);

strcat(join, "_");

strcat(join, wordStarts[i + 1]);

D = FindWord(join, 0, (tokenControl & ONLY_LOWERCASE) ? PRIMARY_CASE_ALLOWED : STANDARD_LOOKUP);

if (D && D->properties & PART_OF_SPEECH && !(D->properties & AUX_VERB)) // allow these two, except "going to" or wordnet composites of normal words

{

++i;

continue;

}

}

if (D && D->properties & PART_OF_SPEECH && !(D->properties & AUX_VERB)) // merge these two, except "going to" or wordnet composites of normal words

{

WORDP P1 = FindWord(word, 0, LOWERCASE_LOOKUP);

WORDP P2 = FindWord(wordStarts[i + 1], 0, LOWERCASE_LOOKUP);

if (!P1 || !P2 || !(P1->properties & PART_OF_SPEECH) || !(P2->properties & PART_OF_SPEECH))

{

char* tokens[2];

tokens[1] = D->word;

ReplaceWords("merge", i, 2, 1, tokens);

fixedSpell = true;

continue;

}

}

}

// sloppy omitted g in lookin

if (word[len - 1] == 'n' && word[len - 2] == 'i')

{

WORDP D = FindWord(word, len - 2);

if (D && D->properties & BASIC_POS)

{

char test[MAX_WORD_SIZE];

strcpy(test, word);

strcat(test, "g");

char* tokens[2];

tokens[1] = test;

ReplaceWords("omitg", i, 1, 1, tokens);

fixedSpell = true;

continue;

}

}

char* known = ProbableKnownWord(word);

if (known && !strcmp(known,word)) continue; // we know it

if (known && strcmp(known,word))

{

WORDP D = FindWord(known);

char* tokens[2];

if ((!D || !(D->internalBits & UPPERCASE_HASH)) && !IsUpperCase(*known)) // revised the word to lower case (avoid to upper case like "fields" to "Fields"

{

WORDP X = FindWord(known,0,LOWERCASE_LOOKUP);

if (X)

{

tokens[1] = X->word;

ReplaceWords("KnownWord",i,1,1,tokens);

fixedSpell = true;

continue;

}

}

else // is uppercase a concept member? then revise upwards

{

WORDP X = FindWord(known,0,UPPERCASE_LOOKUP);

if (IsConceptMember(X) || stricmp(language,"english")) // all german nouns are uppercase

{

tokens[1] = X->word;

ReplaceWords("KnownUpper",i,1,1,tokens);

fixedSpell = true;

continue;

}

}

}

char* p = word -1;

unsigned char c;

char* hyphen = 0;

while ((c = *++p) != 0)

{

++len;

if (c == '-') hyphen = p; // note is hyphenated - use trailing

}

if (len == 0 || GetTemperatureLetter(word)) continue; // bad ignore utf word or llegal length - also no composite words

if (c && c != '@' && c != '.') // illegal word character

{

if (IsDigit(word[0]) || len == 1){;} // probable numeric?

// accidental junk on end of word we do know immedately?

else if (i > 1 && !IsAlphaUTF8OrDigit(wordStarts[i][len-1]) )

{

WORDP entry,canonical;

char word[MAX_WORD_SIZE];

strcpy(word,wordStarts[i]);

word[len-1] = 0;

uint64 sysflags = 0;

uint64 cansysflags = 0;

WORDP revise;

GetPosData(i,word,revise,entry,canonical,sysflags,cansysflags,true,true); // dont create a non-existent word

if (entry && entry->properties & PART_OF_SPEECH)

{

wordStarts[i] = entry->word;

fixedSpell = true;

continue; // not a legal word character, leave it alone

}

}

}

// see if we know the other case

if (!(tokenControl & (ONLY_LOWERCASE|STRICT_CASING)) || (i == startSentence && !(tokenControl & ONLY_LOWERCASE)))

{

WORDP E = FindWord(word,0,SECONDARY_CASE_ALLOWED);

bool useAlternateCase = false;

if (E && E->systemFlags & PATTERN_WORD) useAlternateCase = true;

if (E && E->properties & (PART_OF_SPEECH|FOREIGN_WORD))

{

// if the word we find is UPPER case, and this might be a lower case noun plural, don't change case.

size_t len = size;

if (word[len-1] == 's' )

{

WORDP F = FindWord(word,len-1);

if (!F || !(F->properties & (PART_OF_SPEECH|FOREIGN_WORD))) useAlternateCase = true;

else continue;

}

else useAlternateCase = true;

}

else if (E) // does it have a member concept fact

{

if (IsConceptMember(E))

{

useAlternateCase = true;

break;

}

}

if (useAlternateCase)

{

char* tokens[2];

tokens[1] = E->word;

ReplaceWords("Alternatecase",i,1,1,tokens);

fixedSpell = true;

continue;

}

}

// break apart slashed pair like eat/feed

char* slash = strchr(word,'/');

if (slash && !slash[1] && len < MAX_WORD_SIZE) // remove trailing slash

{

strcpy(newword, word);

newword[slash - word] = 0;

word = wordStarts[i] = StoreWord(newword, AS_IS)->word;

}

char* slash1 = NULL;

if (slash) slash1 = strchr(slash + 1, '/');

if (slash && slash != word && slash[1] && !slash1) // break apart word/word unless date

{

if ((wordCount + 2 ) >= REAL_SENTENCE_LIMIT) continue; // no room

*slash = 0;

D = StoreWord(word);

*slash = '/';

E = StoreWord(slash+1);

char* tokens[4];

tokens[1] = D->word;

tokens[2] = "/";

tokens[3] = E->word;

ReplaceWords("Split",i,1,3,tokens);

fixedSpell = true;

--i;

continue;

}

// see if hypenated word should be separate or joined (ignore obvious adjective suffix)

if (hyphen && !stricmp(hyphen,(char*)"-like"))

{

StoreWord(word,ADJECTIVE_NORMAL|ADJECTIVE); // accept it as a word

continue;

}

else if (hyphen && (hyphen-word) > 1 && !IsPlaceNumber(word,numberStyle)) // dont break up fifty-second

{

char test[MAX_WORD_SIZE];

char first[MAX_WORD_SIZE];

// test for split

*hyphen = 0;

strcpy(test,hyphen+1);

strcpy(first,word);

*hyphen = '-';

WORDP E = FindWord(test,0,LOWERCASE_LOOKUP);

WORDP D = FindWord(first,0,LOWERCASE_LOOKUP);

if (*first == 0)

{

wordStarts[i] = AllocateHeap(wordStarts[i] + 1); // -pieces want to lose the leading hypen (2-pieces)

fixedSpell = true;

}

else if (D && E) // 1st word gets replaced, we added another word after

{

if ((wordCount + 1 ) >= REAL_SENTENCE_LIMIT) continue; // no room

char* tokens[3];

tokens[1] = D->word;

tokens[2] = E->word;

ReplaceWords("Pair",i,1,2,tokens);

fixedSpell = true;

--i;

}

else if (!stricmp(test,(char*)"old") || !stricmp(test,(char*)"olds")) // break apart 5-year-old

{

if ((wordCount + 1 ) >= REAL_SENTENCE_LIMIT) continue; // no room

D = StoreWord(first);

E = StoreWord(test);

char* tokens[3];

tokens[1] = D->word;

tokens[2] = E->word;

ReplaceWords("Break old",i,1,2,tokens);

fixedSpell = true;

--i;

}

else // remove hyphen entirely?

{

strcpy(test,first);

strcat(test,hyphen+1);

D = FindWord(test,0,(tokenControl & ONLY_LOWERCASE) ? PRIMARY_CASE_ALLOWED : STANDARD_LOOKUP);

if (D)

{

wordStarts[i] = D->word;

fixedSpell = true;

--i;

}

}

continue; // ignore hypenated errors that we couldnt solve, because no one mistypes a hypen

}

// see if number in front of unit split like 10mg

if (IsDigit(*word))

{

char* at = word;

while (*++at && IsDigit(*at)) {;}

WORDP E = FindWord(at);

if (E && strlen(at) > 2 && *at != 'm') // number in front of known word ( but must be longer than 2 char, 5th) but allow mg

{

char token1[MAX_WORD_SIZE];

int len = at - word;

strncpy(token1,word,len);

token1[len] = 0;

D = StoreWord(token1);

char* tokens[4];

tokens[1] = D->word;

tokens[2] = E->word;

ReplaceWords("Split",i,1,2,tokens);

fixedSpell = true;

continue;

}

}

// leave uppercase in first position if not adjusted yet... but check for lower case spell error

if (IsUpperCase(word[0]) && tokenControl & NO_PROPER_SPELLCHECK)

{

char lower[MAX_WORD_SIZE];

MakeLowerCopy(lower,word);

WORDP D = FindWord(lower,0,LOWERCASE_LOOKUP);

if (!D && i == startWord)

{

char* okword = SpellFix(lower,i,PART_OF_SPEECH);

if (okword)

{

char* tokens[2];

WORDP E = StoreWord(okword);

tokens[1] = E->word;

ReplaceWords("Spell",i,1,1,tokens);

fixedSpell = true;

}

}

continue;

}

// see if smooshed word pair

if (*word != '\'' && (!FindCanonical(word, i,true) || IsUpperCase(word[0]))) // dont check quoted or findable words unless they are capitalized

{

word = SpellCheck(i);

// dont spell check proper names to improper, if word before or after is lower case originally

// unless a substitute like g-mail-> Gmail

if (word && i != 1 && originalCapState[i] && !IsUpperCase(*word))

{

WORDP X = FindWord(word);

if (X && X->internalBits & HAS_SUBSTITUTE) {}

else if (!originalCapState[i-1]) continue;

else if (i != wordCount && !originalCapState[i+1]) continue;

}

if (word && !*word) // performed substitution on prior word, restart this one

{

fixedSpell = true;

--i;

continue;

}

if (word)

{

char* tokens[2];

tokens[1] = word;

ReplaceWords("Nearest real word",i,1,1,tokens);

fixedSpell = true;

continue;

}

}

}

return fixedSpell;

{

unsigned char c = (unsigned char)*str;

if (!(c & 0x80)) return c;

unsigned char c1 = (unsigned char)str[1];

// can we change an accented lowercase letter to unaccented?

if (c == 0xc3)

{// b0? be

if ((c1 >= 0xa0 && c1 <= 0xa5)) return 'a';

else if ((c1 == 0xa7)) return 'c';

else if ((c1 >= 0xa8 && c1 <= 0xab)) return 'e';

else if ((c1 >= 0xac && c1 <= 0xaf)) return 'i';

else if ((c1 == 0xb1)) return 'n';

else if ((c1 >= 0xb2 && c1 <= 0xb6)) return 'o';

else if ((c1 == 0xb8 )) return 'o';

else if ((c1 >= 0xb9 && c1 <= 0xbc)) return 'u';

else if ((c1 == 0xbd || (unsigned char)str[2] == 0xbf)) return 'y';

// not doing ae else if (*currentCharReal == 'a' && *nextCharReal == 'e' && *nextCharDict == 0xa6)

}

else if (c == 0xc4)

{

if ((c1 == 0x81 || c1 == 0x83 || c1 == 0x85)) return 'a';

else if ((c1 == 0x87 || c1 == 0x89 || c1 == 0x8b || c1 == 0x8d)) return 'c';

else if ((c1 == 0x8f) || c1 == 0x91) return 'd';

else if ((c1 == 0x93 || c1 == 0x95 || c1 == 0x97 || c1 == 0x99 || c1 == 0x9b)) return 'e';

else if ((c1 == 0x9d || c1 == 0x9f|| c1 == 0xa1 || c1 == 0xa3)) return 'g';

else if ((c1 == 0xa5 || c1 == 0xa7)) return 'h';

else if ((c1 == 0xa9 || c1 == 0xab || c1 == 0xad || c1 == 0xaf || c1 == 0xb1)) return 'i';

else if ((c1 == 0xb5)) return 'j';

else if ((c1 == 0xb7)) return 'k';

else if ((c1 == 0xba || c1 == 0xbc || c1 == 0xbe)) return 'l';

}

else if (c == 0xc5)

{

if ((c1 == 0x80 || c1 == 0x82 || c1 == 0x86 || c1 == 0x88)) return 'l';

else if ((c1 == 0x80 || c1 == 0x82)) return 'n';

else if ((c1 == 0x8d || c1 == 0x8f || c1 == 0x91)) return 'o';

else if ((c1 == 0x97 || c1 == 0x99)) return 'r';

else if ((c1 == 0x9b || c1 == 0x9d || c1 == 0x9f || c1 == 0xa1)) return 's';

else if ((c1 == 0xa3 || c1 == 0xa5 || c1 == 0xa7)) return 't';

else if ((c1 == 0xa9 || c1 == 0xab || c1 == 0xad || c1 == 0xaf || c1 == 0xb1 || c1 == 0xb3)) return 'u';

else if ((c1 == 0xb5 )) return 'w';

else if ((c1 == 0xb7)) return 'y';

else if ((c1 == 0xba || c1 == 0xbc || c1 == 0xbe)) return 'z';

}

else if (c == 0xc7)

{

if ((c1 == 0x8e || c1 == 0xa1)) return 'a';

else if ((c1 == 0x90)) return 'i';

else if ((c1 == 0x92)) return 'o';

else if ((c1 == 0x94 || c1 == 0x96 || c1 == 0x98 || c1 == 0x9a || c1 == 0x9c)) return 'u';

else if ((c1 == 0xa5 || c1 == 0xa7|| c1 == 0x98 )) return 'g';

else if ((c1 == 0xa9)) return 'k';

else if ((c1 == 0xab || c1 == 0xad)) return 'o';

else if ((c1 == 0xb0)) return 'j';

else if ((c1 == 0xb5)) return 'g';

else if ((c1 == 0xb9)) return 'n';

else if ((c1 == 0xbb)) return 'a';

else if ((c1 == 0xbf)) return 'o';

}

return 0;

{// dictword has no underscores, inputSet is already lower case

char dictw[MAX_WORD_SIZE];

MakeLowerCopy(dictw, dictWordData.word);

char* dictinfo = dictw;

char* realinfo = realWordData.word;

char* dictstart = dictinfo;