#include <stdio.h>
#include <string.h>
#define ML 40
#define MAXFORMS 75
#define SYSTEMS 32

int use_files=0;
int use_indices=0;
char **working_list = NULL;
char **nonwords = NULL;
long int index_list[256];
char last_found[MAXFORMS+1][ML];

/*
 * List of reserved words.  Words on this list will not be figured when
 * attempting to fit a word into a conjugation or declension.  Likewise, they
 * will not be fitted into a form either.
 */

const char *reserved[] = {
     "prodesse",
     "prosum", "prodes", "prodest", "prosumus", "prodestis", "prosunt",
     "prosim", "prosis", "prosit", "prosimus", "prositis", "prosint",
     "proderam", "proderas", "proderat", "proderamus", "proderatis",
     "proderat",
     "prodessem", "prodesses", "prodesset", "prodessemus", "prodessetis",
     "prodessent",
     "prodero", "proderis", "proderit", "proderimus", "proderitis",
     "proderint",

     "potesse",
     "possum", "potes", "potest", "possumus", "potestis", "possunt",
     "poteram", "poteras", "poterat", "poteramus", "poteratis", "poterant",
     "potero", "poteris", "poterit", "poterimus", "poteritis", "poterint",
     "possim", "possis", "possit", "possimus", "possitis", "possint",
     "possem", "posses", "posset", "possemus", "possetis", "possent",

     "velle",
     "volo", "vis", "vult", "volumus", "vultis", "volunt",
     "volebam", "volebas", "volebat", "volebamus", "volebatis", "volebant",
     "volam", "voles", "volet", "volemus", "voletis", "volent",
     "velim", "velis", "velit", "velimus", "velitis", "velint",
     "vellem", "velles", "vellet", "vellemus", "velletis", "vellent",

     "nolle",
     "nolo", "nolumus", "nolunt",
     "nolebam", "nolebas", "nolebat", "nolebamus", "nolebatis", "nolebant",
     "nolam", "noles", "nolet", "nolemus", "noletis", "nolent",
     "nolim", "nolis", "nolit", "nolimus", "nolitis", "nolint",
     "nollem", "nolles", "nollet", "nollemus", "nolletis", "nollent",

     "malle",
     "malo", "mavis", "mavult", "malumus", "vultis", "malunt",
     "malebam", "malebas", "malebat", "malebamus", "malebatis", "malebant",
     "malam", "males", "malet", "malemus", "maletis", "malent",
     "malim", "malis", "malit", "malimus", "malitis", "malint",
     "mallem", "malles", "mallet", "mallemus", "malletis", "mallent",

     "edere",
     "edo", "edis", "es", "edit", "est", "edimus", "editis", "edunt",
     "edebam", "edebas", "edebat", "edebamus", "edebatis", "edebant",
     "edam", "edas", "edat", "edamus", "edatis", "edant",
     "edamus", "edatis", "edant", "edint",
     "ederem", "ederes", "esses", "ederet", "esset", "ederemus", "essemus",
     "ederetis", "essetis", "ederent", "essent",

     "dare",
     "do", "das", "dat", "damus", "datis", "dant",
     "dabam", "dabas", "dabat", "dabamus", "dabatis", "dabant",
     "dabo", "dabis", "dabit", "dabimus", "dabitis", "dabunt",
     /* no "dor" */ "daris", "datur", "damur", "damini", "dantur",
     "dabar", "dabaris", "dabatur", "dabamur", "dabamini", "dabantur",
     "dabor", "daberis", "dabetur", "dabemur", "dabemini", "dabentur",
     "dem", "des", "det", "demus", "detis", "dent",
     /* no "der" */ "deris", "detur", "demur", "demini", "dentur",
     "darem", "dares", "daret", "daremus", "daretis", "darent",
     "darer", "dareris", "daretur", "daremur", "daremini", "darentur",

     "fieri",
     "fio", "fis", "fit", /* no "fimus", "fitis", */ "fiunt",
     "fiebam", "fiebas", "fiebat", "fiebamus", "fiebatis", "fiebant",
     "fiam", "fies", "fiet", "fiemus", "fietis", "fient",
     "fiam", "fias", "fiat", "fiamus", "fiatis", "fiant",
     "fierem", "fieres", "fieret", "fieremus", "fieretis", "fierent",

     "ire",
     "eo", "is", "it", "imus", "itis", "eunt",
     "ibam", "ibas", "ibat", "ibamus", "ibatis", "ibant",
     "ibo", "ibis", "ibit", "ibimus", "ibitis", "ibunt",
     "eam", "eas", "eat", "eamus", "eatis", "eant",
     "irem", "ires", "iret", "iremus", "iretis", "irent",

     "abire",
     "abeo", "abis", "abit", "abimus", "abitis", "abeunt",
     "abibam", "abibas", "abibat", "abibamus", "abibatis", "abibant",
     "abibo", "abibis", "abibit", "abibimus", "abibitis", "abibunt",
     "abeam", "abeas", "abeat", "abeamus", "abeatis", "abeant",
     "abirem", "abires", "abiret", "abiremus", "abiretis", "abirent",

     "adire",
     "adeo", "adis", "adit", "adimus", "aditis", "adeunt",
     "adibam", "adibas", "adibat", "adibamus", "adibatis", "adibant",
     "adibo", "adibis", "adibit", "adibimus", "adibitis", "adibunt",
     "adeam", "adeas", "adeat", "adeamus", "adeatis", "adeant",
     "adirem", "adires", "adiret", "adiremus", "adiretis", "adirent",

     "inire",
     "ineo", "inis", "init", "inimus", "initis", "ineunt",
     "inibam", "inibas", "inibat", "inibamus", "inibatis", "inibant",
     "inibo", "inibis", "inibit", "inibimus", "inibitis", "inibunt",
     "ineam", "ineas", "ineat", "ineamus", "ineatis", "ineant",
     "inirem", "inires", "iniret", "iniremus", "iniretis", "inirent",

     "interire",
     "intereo", "interis", "interit", "interimus", "interitis", "intereunt",
     "interibam", "interibas", "interibat", "interibamus", "interibatis",
     "interibant",
     "interibo", "interibis", "interibit", "interibimus", "interibitis",
     "interibunt",
     "inteream", "intereas", "intereat", "intereamus", "intereatis",
     "intereant",
     "interirem", "interires", "interiret", "interiremus", "interiretis",
     "interirent",

     "quire",
     "queo", "quis", "quit", "quimus", "quitis", "queunt",
     "quibam", "quibas", "quibat", "quibamus", "quibatis", "quibant",
     "quibo", "quibis", "quibit", "quibimus", "quibitis", "quibunt",
     "queam", "queas", "queat", "queamus", /* no "queatis", */ "queant",
     /* no "quirem", */ "quires", "quiret", "quiremus", "quiretis", "quirent",

     "nequire",
     "nequeo", "nequis", "nequit", "nequimus", "nequitis", "nequeunt",
     /* no "nequibam", */ "nequibas", "nequibat", "nequibamus", "nequibatis",
     "nequibant",
     "nequibo", "nequibis", "nequibit", "nequibimus", "nequibitis",
     "nequibunt",
     "nequeam", "nequeas", "nequeat", "nequeamus", /* no "nequeatis", */
     "nequeant",
     "nequirem", "nequires", "nequiret", "nequiremus", "nequiretis",
     "nequirent",

     "esse",
     "sum", "esse", "es", "est", "sumus", "estis", "sunt",
     "eram", "eras", "erat", "eramus", "eratis", "erant",
     "ero", "erim", "eris", "erit", "erimus", "eritis", "erint",
     "sim", "sis", "sit", "simus", "sitis", "sint",
     "essem", "esses", "esset", "essemus", "essetis", "essent",

     "abesse",
     "absum", "abes", "abest", "absumus", "abestis", "absunt",
     "aberam", "aberas", "aberat", "aberamus", "aberatis", "aberant",
     "abero", "aberim", "aberis", "aberit", "aberimus", "aberitis", "aberint",
     "absim", "absis", "absit", "absimus", "absitis", "absint",
     "abessem", "abesses", "abesset", "abessemus", "abessetis", "abessent",

     "adesse",
     "adsum", "ades", "adest", "adsumus", "adestis", "adsunt",
     "aderam", "aderas", "aderat", "aderamus", "aderatis", "aderant",
     "adero", "aderim", "aderis", "aderit", "aderimus", "aderitis", "aderint",
     "adsim", "adsis", "adsit", "adsimus", "adsitis", "adsint",
     "adessem", "adesses", "adesset", "adessemus", "adessetis", "adessent",

     "deesse",
     "desum", "dees", "deest", "desumus", "deestis", "desunt",
     "deeram", "deeras", "deerat", "deeramus", "deeratis", "deerant",
     "deero", "deerim", "deeris", "deerit", "deerimus", "deeritis", "deerint",
     "desim", "desis", "desit", "desimus", "desitis", "desint",
     "deessem", "deesses", "deesset", "deessemus", "deessetis", "deessent",

     "inesse",
     "insum", "ines", "inest", "insumus", "inestis", "insunt",
     "ineram", "ineras", "inerat", "ineramus", "ineratis", "inerant",
     "inero", "inerim", "ineris", "inerit", "inerimus", "ineritis", "inerint",
     "insim", "insis", "insit", "insimus", "insitis", "insint",
     "inessem", "inesses", "inesset", "inessemus", "inessetis", "inessent",

     "interesse",
     "intersum", "interes", "interest", "intersumus", "interestis",
     "intersunt",
     "intereram", "intereras", "intererat", "intereramus", "intereratis",
     "intererant",
     "interero", "intererim", "intereris", "intererit", "intererimus", 
     "intereritis", "intererint",
     "intersim", "intersis", "intersit", "intersimus", "intersitis",
     "intersint",
     "interessem", "interesses", "interesset", "interessemus", "interessetis",
     "interessent",

     "obesse",
     "obsum", "obes", "obest", "obsumus", "obestis", "obsunt",
     "oberam", "oberas", "oberat", "oberamus", "oberatis", "oberant",
     "obero", "oberim", "oberis", "oberit", "oberimus", "oberitis", "oberint",
     "obsim", "obsis", "obsit", "obsimus", "obsitis", "obsint",
     "obessem", "obesses", "obesset", "obessemus", "obessetis", "obessent",

     "praeesse",
     "praesum", "praees", "praeest", "praesumus", "praeestis", "praesunt",
     "praeeram", "praeeras", "praeerat", "praeeramus", "praeeratis",
     "praeerant",
     "praeero", "praeerim", "praeeris", "praeerit", "praeerimus", "praeeritis",
     "praeerint",
     "praesim", "praesis", "praesit", "praesimus", "praesitis", "praesint",
     "praeessem", "praeesses", "praeesset", "praeessemus", "praeessetis",
     "praeessent",

     "quaeso", "quaesumus",

     "ovas", "ovat", "ovet", "ovaret",

     "hic", "hunc", "hinc", "hac",
     "ibi", "eo", "inde", "ea",
     "istic", "istuc", "istinc", "ista",
     "illic", "illuc", "illinc", "illac",
     "ubi", "quo", "unde", "qua",
     "alicubi", "aliquo", "alicunde", "aliqua",
     "ibidem", "eodem", "indidem", "eadem",
     "alibi", "alio", "aliunde", "alia",
     "ubiubi", "quoquo", "undecunque", "quaqua",
     "ubivis", "quovis", "undique", "quavis",
     "sicubi", "siquo", "sicunde", "siqua",
     "necubi", "nequo", "necunde", "nequa",

     "usque", "usquam", "nusquam", "citro",
     "intro", "ultro", "porro", "quorsum", "horsum",
     "prorsum", "prorsus", "introrsum", "retrorsum", "sursum",
     "deorsum", "seorsum", "aliorsum",

     "ego", "mei", "mihi", "mi", "me", "nos", "nostrum", "nostri", "nobis",
     "tu", "tui", "tibi", "te", "vos", "vestrum", "vestri", "vostrum",
     "vobis",
     "sui", "sibi", "se", "sese",

     "hic", "haec", "hoc", "huius", "huic", "hunc", "hanc", "hac",
     "hi", "hae", "horum", "harum", "his", "hos", "has",

     "is", "ea", "id", "eius", "ei", "eum", "eam", "eo", "ea",
     "ii", "eae", "eorum", "earum", "eis", "iis", "eos", "eas",

     "ille", "illa", "illud", "illius", "illi", "illum", "illam", "illo",
     "illi", "illae", "illorum", "illarum", "illis", "illos", "illas",

     "ipse", "ipsa", "ipsum", "ipsius", "ipsi", "ipsum", "ipso",
     "ipsi", "ipsae", "ipsorum", "ipsarum", "ipsis", "ipsos", "ipsas",

     "idem", "eadem", "eiusdem", "eidem", "eundem", "eandem", "eodem", "eadem",
     "eidem", "eaedem", "eorundem", "earundem", "eisdem", "isdem",
     "eosdem", "easdem",

     "illic", "illac", "illuc", "illunc", "illanc", "illoc",

     "istic", "istaec", "istuc", "istunc", "istanc", "istoc", "istac",

     "qui", "quae", "quod", "cuius", "cui", "quem", "quam", "quo", "qua",
     "quorum", "quarum", "quibus", "quos", "quas",
     "quis", "quid", "cuius", "cui", "quem", "quo", 

     "ecqui", "ecquae", "ecquod", "eccui", "ecquem", "ecquam", "ecquo",
     "ecqua", "ecquos", "ecquas",
     "ecquis", "ecquid", "eccuius", "eccui", "ecquem", "ecquo", 

     "aliqui", "aliquae", "aliquod", "alicuius", "alicui", "aliquem",
     "aliquam", "aliquo", "aliqua", "aliquorum", "aliquarum", "aliquibus",
     "aliquos", "aliquas",
     "aliquis", "aliquid", "alicuius", "alicui", "aliquem", "aliquo", 

     "duo", "duae", "duorum", "duarum", "duobus", "duos", "duas",

     "ambo", "ambae", "amborum", "ambarum", "ambobus", "ambos", "ambas",

     "alius", "alia", "alium", "aliius", "alii", "aliam", "alio", "alia",
     "nullus", "nulla", "nullum", "nullius", "nulli", "nullam", "nullo", "nulla",
     "solus", "sola", "solum", "solius", "soli", "solam", "solo", "sola",
     "totus", "tota", "totum", "totius", "toti", "totam", "toto", "tota",
     "ullus", "ulla", "ullum", "ullius", "ulli", "ullam", "ullo", "ulla",
     "unus", "una", "unum", "unius", "uni", "unam", "uno", "una",
     "alter", "altera", "alterum", "alterius", "alteri", "alteram", "altero", "altera",
     "neuter", "neutera", "neuterum", "neuterius", "neuteri", "neuteram", "neutero", "neutera",
     "uter", "utera", "uterum", "uterius", "uteri", "uteram", "utero", "utera",

     NULL };

/*
 * The first two entries in eash line are the nom. and gen. cases
 * for the word.  The other enteies are the other entries, in no
 * particular order.  No entries are duplicated, unless the nom.
 * and gen. are the same.
 *
 * Alternatively, the first and second entries are the 1st-singular
 * and infinitive of either the present or perfect system, and the
 * remaining entries the rest of the conjugation.
 *
 */

const char *suffixes[SYSTEMS][MAXFORMS] = {
     { "i", "isse", "isti", "it", "imus", "itis", "erunt", "ere",
            "erim", "eris", "erit", "erimus", "eritis", "erint",
            "eram", "eras", "erat", "eramus", "eratis", "erant",
            "issem", "isses", "isset", "issemus", "issetis", "issent",
            "ero",
            NULL }, /* perfect active indicative system */
     { "fero", "ferre", "fers", "fert", "ferimus", "fertis", "ferunt",
            "ferebam", "ferebas", "ferebat", "ferebamus", "ferebatis",
            "ferant", "feram", "feres", "feret", "feremus", "feretis",
            "ferent",
            "feror", "ferris", "fertur", "ferimur", "feremini", "feruntur",
            "ferebam", "ferebas", "ferebat", "ferebamus", "ferebatis",
            "ferebant",
            "ferebar", "ferebaris", "ferebatur", "ferebamur", "ferebamini",
            "ferebantur",
            "feram", "feres", "feret", "feremus", "feretis", "ferent",
            "ferar", "fereris", "feretur", "feremur", "feremini", "ferentur",
            "feram", "feras", "ferat", "feramus", "feratis", "ferant",
            "ferar", "feraris", "feratur", "feramur", "feramini", "ferantur",
            "ferrem", "ferres", "ferret", "ferremus", "ferretis", "ferrent",
            "ferrer", "ferreris", "ferretur", "ferremur", "ferremini",
            "ferrentur", NULL }, /* fero, ferre: for adfero, subfero, etc. */
     { "o", "are", "as", "at", "amus", "atis", "ant",
            "abo", "abis", "abit", "abimus", "abitis", "abunt",
            "abam", "abas", "abat", "abamus", "abatis", "abant",
            "em","es","et","emus","etis","ent",
            "arem","ares","aret","aremus","aretis","arent",
            "avi","avisti","avit","avimus","avistis","averunt","avere",
            "averim","averis","averit","averimus","averitis","averint",
            "averam","averas","averat","averamus","averatis","averant",
            "avissem", "avisses", "avisset", "avissimus", "avissetis",
            "avissent", "avisse", "avero",
            NULL }, /* 1st conj. active system */
     { "or", "ari", "aris", "atur", "amur", "amini", "antur",
            "abor", "aberis", "abitur", "abimur", "abimini", "abuntur",
            "abar", "abaris", "abatur", "abamur", "abamini", "abantur",
            "er", "eris", "etur", "emur", "emini", "entur",
            "arer", "areris", "aretur", "aremur", "aremini", "arentur",
            NULL }, /* 1st conj. pres. passive system */
     { "eo", "ere", "es", "et", "emus", "etis", "ent",
            "ebo", "ebis", "ebit", "ebimus", "ebitis", "ebunt",
            "ebam", "ebas", "ebat", "ebamus", "ebatis", "ebant",
            "eam","eas","eat","eamus","eatis","eant",
            "erem","eres","eret","eremus","eretis","erent",
            NULL }, /* 2d conj. pres. active system */
     { "eor", "eri", "eris", "etur", "emur", "emini", "entur",
            "ebor", "eberis", "ebitur", "ebimur", "ebimini", "ebuntur",
            "ebar", "ebaris", "ebatur", "ebamur", "ebamini", "ebantur",
            "ear", "earis", "eatur", "eamur", "eamini", "eantur",
            "erer", "ereris", "eretur", "eremur", "eremini", "erentur",
            NULL }, /* 2d conj. pres. passive system */
     { "io", "ere", "is", "it", "imus", "itis", "int",
            "iam","ies","iet","iemus","ietis","ierunt",
            "iebam", "iebas", "iebat", "iebamus", "iebatis", "iebant",
            "am","as","at","amus","atis","ant",
            "erem","eres","eret","eremus","eretis","erent",
            NULL }, /* 3d conj. -io pres. active system */
     {"ior", "i", "eris", "itur", "imur", "imini", "iuntur",
           "iar", "ieris", "ietur", "iemur", "iemini", "ientur",
           "iebar", "iebaris", "iebatur", "iebamur", "iebamini", "iebantur",
           "iar", "iaris", "iantur", "iamur", "iamini", "iantur",
           "erer", "ereris", "eretur", "eremur", "eremini", "erentur",
           NULL }, /* 3d conj. -io pres. passive system */
     { "o", "ere", "is", "it", "imus", "itis", "unt",
            "am","es","et","emus","etis","erunt",
            "iebam", "iebas", "iebat", "iebamus", "iebatis", "iebant",
            "am","as","at","amus","atis","ant",
            "erem","eres","eret","eremus","eretis","erent",
            NULL }, /* 3d conj. pres. active system */
     {"or", "i", "eris", "itur", "imur", "imini", "untur",
           "ar", "eris", "etur", "emur", "emini", "entur",
           "ebar", "ebaris", "ebatur", "ebamur", "ebamini", "ebantur",
           "ar", "aris", "antur", "amur", "amini", "antur",
           "erer", "ereris", "eretur", "eremur", "eremini", "erentur",
           NULL }, /* 3d conj. pres. passive system */
     { "io", "ire", "is", "it", "imus", "itis", "int",
            "iam","ies","iet","iemus","ietis","ierunt",
            "iebam", "iebas", "iebat", "iebamus", "iebatis", "iebant",
            "iam,", "ias", "iat", "iamus", "iatis", "iant",
            "irem","ires","iret","iremus","iretis","irent",
            "ivi", "ivisti", "ivit", "ivimus", "ivitistis", "iverunt",
            "iverim", "iveris", "iverit", "iverimus", "iveritis", "iverint",
            "iveram", "iveras", "iverat", "iveramus", "iveratis", "iverant",
            "ivisse", "ivero",
            NULL }, /* 4th conj. pres. active system */
     {"ior", "iri", "iris", "itur", "imur", "imini", "iuntur",
           "iar", "ieris", "ietur", "iemur", "iemini", "ientur",
           "iebar", "iebaris", "iebatur", "iebamur", "iebamini", "iebantur",
           "iar", "iaris", "iantur", "iamur", "iamini", "iantur",
           "irer", "ireris", "iretur", "iremur", "iremini", "irentur",
           NULL }, /* 4th conj. pres. passive system */
     { "urus", "uri", "uro", "urum", "urorum", "uris",
            "ura", "urae", "uram", "urarum", "uras", NULL }, /* fut. part. */

     { "a","ae","am", NULL },         /* 1st decl. sing. */
     { "ae", "arum","as","is",NULL }, /* 1st decl. plur. */
     { "um","i","o", NULL },    /* 2d decl. neut. sing. */
     { "a","orum","is",NULL },  /* 2d decl. neut. plur. */
     { "us","i","o","um","e",NULL }, /* 2d decl. masc. sing; -e for voc/adv */
     { "er", "ri", "rum", "ro", "re", NULL }, /* 2d decl. "-er" sing. */
     { "ir", "iri", "irum", "iro", NULL }, /* 2d decl. "-ir". sing. */
     { "i","orum","os","is",NULL }, /* 2d decl. masc. plur. */
     { "*", "is", "i", "em", "e", "iter", NULL }, /* simle 3d decl. c. sing. */
     { "es","um","ibus",NULL }, /* simple 3d decl. sex. plur. */
     { "a","ium","ibus",NULL }, /* simple 3d decl. neut. plur. */
     { "ns", "ntis", "nti", "ntem", "nte",
            "nta", "ntes", "ntum", "ntibus", NULL }, /* pres. partciple */
     { "us","us","ui","u","uum","um","ibus",NULL }, /* 4th decl. */
     { "u", "ui", "a", "uum", "ibus", NULL }, /* 4th decl. neut. */
     { "es","ei","em","e","erum","ebus",NULL },   /* 5th decl. */
     { NULL }
};

void nonewlines(char *s)
{
     int i;

     for(i=0;s[i]!='\0';i++)
          if(s[i]=='\n' || s[i]=='\r')
               s[i]='\0';

     if(endcmp(s,"que")==0)    /* get rid of -que too */
          s[strlen(s)-3]='\0'; /* (leave -ve and -ne, not as common) */

     return;
}

int read_nonwords(void)
{
     int n, i;
     char s[ML];
     FILE *ip;

     if((ip = fopen("non_words","r"))==NULL)
         return;
     for(n=0;fgets(s,ML,ip)!=NULL;n++)
          ;
     rewind(ip);
     if((nonwords = (char **)malloc(sizeof(char *)*n))==NULL)
     {
          printf("Not enough memory.  Sorry.\n");
          exit(0);
     }
     for(i=0;i<n;i++)
     {
          if((nonwords[i]=(char *)malloc(sizeof(char)*ML))==NULL)
          {
               printf("Not enough memory.  Sorry.\n");
               exit(0);
          }
          fgets(nonwords[i],ML,ip);
          nonewlines(nonwords[i]);
     }
     nonwords[i]=NULL;
     return;
}
          

int is_nonword(char *s)
{
     int i;

     if(nonwords==NULL)
          return 0;
     for(i=0;nonwords[i]!=NULL;i++)
     {
          if(strcmp(s,nonwords[i])==0)
               return 1;
     }
     return 0;
}

int endcmp(const char *s, const char *t)
{
     if(strlen(s)<strlen(t))
          return -1;
     return strcmp(s+(strlen(s)-strlen(t)),t);
}
              
int contains(int n, char *s)
{
     int i;

     for(i=0;suffixes[n][i]!=NULL;i++)
          if(endcmp(s,suffixes[n][i])==0)
               return 1;
     return 0;
}

int isreserved(char *t)
{
     int i=0;

     if(isupper(t[0]))
          return 1;

     while(reserved[i]!=NULL)
     {
          if(strcmp(reserved[i],t)==0)
               return 1;
          i++;
     }
     return 0;
}

void print_reserved(FILE *op)
{
     int i=0;

     while(reserved[i]!=NULL)
     {
          fprintf(op,"%s\n",reserved[i]);
          i++;
     }
     return;
}     

FILE *list_init(char *file, FILE *fp, int *count)
{
     int n=0, i;
     long int lg;
     static int have_init;
     char s[ML], c='\0';

     *count=0;

     if(use_files==0 && have_init)
          return (FILE *)!(void *)0;

     have_init = 1;
     if((fp = fopen(file,"r"))==NULL)
          return NULL;

     lg = 0;
     while(fgets(s,ML,fp)!=NULL)
     {
          if(tolower(c)!=tolower(s[0]))
          {
               index_list[c=tolower(s[0])] = lg;
#ifdef DEBUG
               printf("index of %c: %ld\n",c,lg);
#endif
          }
          lg = ftell(fp);
          n++;
     }

     rewind(fp);

     if((working_list = (char **)malloc(sizeof(char *)*n))==NULL)
     {
          printf("Not enough memory (1).  Using files instead.\n");
          use_files = 1;
          return fp;
     }
     for(i=0;i<n;i++)
          if((working_list[i]=(char *)malloc(sizeof(char)*ML))==NULL)
          {
               printf("Not enough memory (2).  Using files instead.\n");
               use_files=1;
               return fp;
          }
     for(i=0;i<n && fgets(s,ML,fp)!=NULL; i++)
     {
          nonewlines(s);
          if(!isreserved(s))
          {
               if(tolower(c)!=tolower(s[0]))
               {
                    index_list[c=tolower(s[0])] = i;
#ifdef DEBUG
                    printf("Letter %c: #%d (%s)\n",c,i,s);
#endif
               }
               strcpy(working_list[i],s);
          }
          else
               i--;
     }
     working_list[i]=NULL;
     close(fp);
     use_files=0;
     return fp;
}

char *goto_letter(char c, FILE *fp, int *n)
{
     if(use_files)
          fseek(fp,index_list[c],SEEK_SET);
     else
          *n = index_list[c];
}
          
          
char *get_next(char *s, FILE *fp, int *n)
{
     if(use_files)
     {
        top:
          if(fgets(s,ML,fp)==NULL)
               return NULL;
          nonewlines(s);
#ifdef DEBUG
          printf("nonewlines: got %s\n",s);
#endif
          if(isreserved(s))
               goto top;
          return s;
     }
     else
     {
          if(working_list[*n]==NULL)
               return NULL;
          strcpy(s,working_list[(*n)++]);
          return s;
     }
}

void list_close(FILE *fp)
{
     if(use_files)
          fclose(fp);
     return;
}

int check_decl(char *s, int n, char *file)
{
     int i,j,k,restrict[SYSTEMS],count=0, tmpi;
     char t[ML], forms[MAXFORMS][ML];
     FILE *ip;
     int wcount=0;

     if(s[0]=='\0' || s[1]=='\0') /* reject empty stem and stems */
          return 0;               /* of only one letter          */

#ifdef DEBUG
     printf("check_decl: %s -> %s%s, -%s ?\n",s,s,suffixes[n][0],
            suffixes[n][1]);
#endif

     for(i=0;suffixes[i][0]!=NULL;i++)
          restrict[i]=1;
     for(i=0;i<MAXFORMS;i++)
     {
          forms[i][0]='\0';
     }

     list_init(file,ip, &wcount);

     count=0;

     goto_letter(s[0],ip,&wcount);

     while(get_next(t,ip,&wcount)!=NULL && (tmpi=strncmp(s,t,strlen(s)))>=0)
     {
          if(tmpi<0)
          {
               printf("skipping: %s\n",t);
               continue;
          }
#ifdef DEBUG
          printf("trying word: %s (to match %s-)\n",t,s);
#endif
          if(s[0]=='\0' || strncmp(s,t,strlen(s))==0)
          {
               for(j=0;suffixes[n][j]!=NULL;j++)
               {
                    if(strcmp(t+strlen(s),suffixes[n][j])==0)
                    {
                         strcpy(forms[j],t);
                         count++;
                    }
               }
          }
     }
     list_close(ip);

     for(i=0;suffixes[i][0]!=NULL;i++)
          if(i!=n)
               for(k=0;suffixes[n][k]!=NULL;k++)
                    if(forms[k][0] && !contains(i,forms[k]))
                    {
                         restrict[i]=0;
                    }
     for(i=0;suffixes[i][0]!=NULL;i++)
          if(restrict[i] && i!=n)
          {
#ifdef DEBUG
               printf("Vetoed: by -%s, -%s.\n",suffixes[i][0],
                      suffixes[i][1]);
#endif
               return 0;
          }
#ifdef DEBUG
     printf("sufficient set for system %d (-%s, -%s):\n", n,
            suffixes[n][0], suffixes[n][1]);
     count=0;
     for(i=0;suffixes[n][i]!=NULL;i++)
          if(forms[i][0])
          {
               count++;
               printf("%s, ",forms[i]);
          }
     if(count==0)
          printf("hey! where did that basis go?!\n");
     else
          printf("\n");
#endif
     return 1;
}

          
char *wordcheck(char *s, char *file)
{
     static char t[ML];
     char u[ML];
     int i,j, biggest=0, current;

     if(s[0]=='\0')
          return NULL;

     for(i=0;suffixes[i][0]!=NULL;i++)
     {
          for(j=0;suffixes[i][j]!=NULL;j++)
          {
               if(endcmp(s,suffixes[i][j])==0)
               {
#ifdef DEBUG
                    printf("candidate: -%s for %s\n",suffixes[i][j],s);
#endif
                    if(strlen(suffixes[i][j])>biggest)
                    {
                         biggest=strlen(suffixes[i][j]);
                         current=i;
                         strcpy(t,s);
                         t[strlen(t)-strlen(suffixes[i][j])]='\0';
                    }
               }
          }
          if(biggest)
          {
               sprintf(u,"%s%s, -%s",t,suffixes[current][0],
                       suffixes[current][1]);
               if(is_nonword(u))
               {
                    printf("NON-WORD: %s\n",u);
                    return NULL;
               }
          
               if(check_decl(t,current,file))
               {
                    for(i=0;suffixes[current][i]!=NULL;i++)
                         sprintf(last_found[i],"%s%s",t,suffixes[current][i]);
                    last_found[i][0]='\0';
                    strcpy(t,u);
                    return t;
               }
          }
     }
     return NULL;
}

void expand(char *tempfile, char *file)
{
     char s[ML], t[ML], u[ML], sorts[ML], nom[ML], *gen;
     int i,j;
     FILE *ip, *op;

     if((ip=fopen(file,"r"))==NULL)
     {
          printf("cannot open: %s\n",file);
          exit(0);
     }

#ifndef DOS
     sprintf(sorts,"sort | uniq > %s.new",file);
     op = popen(sorts,"w");
#else
     sprintf(sorts,"%s.new",file);
     op = fopen(sorts,"w");
#endif
     while(fgets(s,ML,ip)!=NULL)
     {
          nonewlines(s);
          /*
           * Non-inflected words sometimes can't have -que on them.
           * For example, "etque" is not a word.
           */
          if(!is_nonword(s))
               fprintf(op,"%s\n",s);
          if(endcmp(s,"que") && endcmp(s,"ve") && endcmp(s,"ne")
             && endcmp(s,"ue"))
          {
               sprintf(u,"%sque",s);
               if(!is_nonword(u))
                    fprintf(op,"%s\n",u);
          }
     }
     print_reserved(op);      /* and the reserved words */
     fclose(ip);
     if((ip=fopen(tempfile,"r"))==NULL)
     {
          printf("cannot open: %s\n",s);
          exit(0);
     }
     while(fgets(s,ML,ip)!=NULL)
     {
          nonewlines(s);
          if(strcmp(s,t)==0)
               continue;
          if(strchr(s,',')==NULL)
          {
               printf("warning: odd entry in .dict file: \"%s\"\n",s);
          }
          else
          {
               strcpy(nom,s);
               *(strchr(nom,','))='\0';
               gen = strchr(s,'-')+1;
               nonewlines(gen);

               for(i=0;suffixes[i][0]!=NULL;i++)
                    if(strcmp(suffixes[i][1],gen)==0 &&
                       endcmp(nom,suffixes[i][0])==0)
                    {
                         nom[strlen(nom)-strlen(suffixes[i][0])]='\0';
                         for(j=0;suffixes[i][j]!=NULL;j++)
                         {
                              if(suffixes[i][j][0]!='*')
                              {
                                   fprintf(op,"%s%s\n",nom,suffixes[i][j]);
                                   fprintf(op,"%s%sque\n",nom,suffixes[i][j]);
                              }
                         }
                    }
          }
     }
     fclose(ip);
     fclose(op);
     return;
}

int already(char *s)
{
     int i;

     for(i=0;last_found[i][0]!='\0';i++)
     {
          if(strcmp(s,last_found[i])==0)
               return 1;
     }
     return 0;
}

int main(int argc, char **argv)
{
     FILE *ip, *op;
     char s[ML], *t, tname[ML];
     int wcount;

     if(argc>3 || argc<2 || (argc==3 && strcmp(argv[1],"-e")))
     {
          printf("usage: %s [-e] <filename>\n",argv[0]);
          exit(1);
     }
     if(argc==3)
     {
          sprintf(tname,"%s.dict",argv[2]);
          expand(tname,argv[2]);
          exit(0);
     }
     if(list_init(argv[1],ip,&wcount)==NULL)
     {
          printf("error opening file %s\n",argv[1]);
          exit(1);
     }
     read_nonwords();

     sprintf(tname,"%s.dict",argv[1]);
     if((op=fopen(tname,"w"))==NULL)
     {
          printf("error: cannot open temporary file %s\n",tname);
          exit(1);
     }

     last_found[0][0]='\0';

     while(get_next(s, ip, &wcount)!=NULL)
     {
#ifdef DEBUG
          printf("word:----> %s\n",s);
#endif
          fflush(stdout);

          if(already(s))     /* if we just saw this form, don't do it again */
               continue;

          if((t=wordcheck(s,argv[1]))!=NULL)
          {
               fprintf(op,"%s\n",t);
               printf("%s                          \n",t);
          }
     }
     list_close(ip);
     fclose(op);
/*   unlink(tname); */
     return;
}