Wr:      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                          !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                                                  !"#$%&'()*+,-./0123456789:;<=>?@ ,Adds a metric at the end of the list (thus, B metrics are printed out in the order in which they were added =Adds a metric that will be printed out at regular intervals A    2BCD-Intermediary type used for alphanumeric sort EFputStr on stderr <Drop all characters up to and including the one in question 0Make the first character of a string upper case 0Make the first character of a string lower case FAn alphanumeric sort is one where you treat the numbers in the string F as actual numbers. An alphanumeric sort would put x2 before x100,  because 2 <6 10, wheraeas a naive sort would put it the other way # around because the characters 1 <$ 2. To sort alphanumerically, just  'sortBy (comparing toAlphaNum)'  !"#$A strict version of G %)A generic version of the Data.List.words ' TODO: replace by version from split &6Makes sure that index s is in the bounds of list l. E Surely there must be some more intelligent way to deal with this. '0True if the intersection of two lists is empty. (Serves the same function as H. It groups together J items by some property they have in common. The difference is that the ; property is used as a key to a Map that you can lookup. )Same as (', except that we let an item appear in A multiple groups. The fn extracts the property from the item, 6 and returns multiple results in the form of a list *+:Convert a list of items into a list of tuples (a,b) where ; a is an item in the list and b is the number of times a  in occurs in the list. ,-.9Return the list, modifying only the first matching item. /Strict version of mapTree! (for non-strict, just use fmap) 0Like I=, except on Trees. Filter might not be a good name, though, 2 because we return a list of nodes, not a tree. 1The leaf nodes of a Tree 2#Return pairs of (parent, terminal) 33  fn filt t returns a version of t in which the first  node which filt matches is transformed using fn. replacement function filtering function 4Like 3+ except that it performs the operations on ! all nodes that match and doesn't care if any nodes match  or not 5Like 3 but on a list of tree nodes replacement function filtering function nodes 6@Replace a node in the tree in-place with another node; keep the C children the same. If the node is not found in the tree, or if C there are multiple instances of the node, this is treated as an  error.  which node? 7>errors specifically in GenI, which is very likely NOT the user' s fault. 8Add two intervals 99 x builds a trivial interval from x to x :;6displays a bit vector, using a minimum number of bits <Using readFile' can be a good idea if you're dealing with not-so-huge  files (i.e. where you don',t want lazy evaluation), because it ensures & that the handles are closed. No more ``too many open files'' J=K>action to run upon timing out main action to run ?Like  exitFailureC, except that we return with a code that we reserve for timing out + !"#$%&'()*+,-./0123456789:;<=>?+<=>? !"#$%&'()*+,-./012345689:;7+ !"#$%&'()*+,-./0123456789:;<=>?@5Note: there are two ways to define the final states. ; 1. you may define them as a list of states in finalStList 3 2. you may define them via the isFinalSt function ) The state list is ignored if you define C ABCDEFGHIJK@Not quite the set of all paths, but the sets of all transitions LM@ABCDEFGHIJKLM@ABCDEFGIHJKLM@ABCDEFABCDEFGHIJKLM~LMNONOPQfor gui RSexpected results (for testing) T8results we actually got, and their traces (for testing) UVWXYZ[\]^_`FHere it is safe to say (X -> Y; Y -> Z) because this would be crushed / down into a final value of (X -> Z; Y -> Z) abcdefghijklmnopqrstuvwx+for TAG, this would be the elementary tree ' that this node originally came from yz{|}~7A lexicon maps semantic predicates to lexical entries. IA null tree which you can use for various debugging or display purposes. A null o> which you can use for various debugging or display purposes. Return the value of the cat attribute, if available 9Attributes recognised as lexemes, in order of preference Given a lexical item s' and a Tree GNode t, returns the tree t' 4 where l has been assigned to the anchor node in t' Given a lexical item l and a tree node n (actually a subtree D with no children), return the same node with the lexical item as I its unique child. The idea is that it converts terminal lexeme nodes I into preterminal nodes where the actual terminal is the given lexical  item @Plug the first tree into the second tree at the specified node. 9 Anything below the second node is silently discarded. @ We assume the trees are pluggable; it is treated as a bug if  they are not! Given two trees auxt and t, splice the tree auxt into  t via the TAG adjunction rule. foot node of the aux tree  aux tree place to adjoin in target tree  target tree PQ(assumes that it' s a GConst!) (assumes that it' s a GVar!) BDefault implementation for replaceOne but not a good idea for the : core stuff; which is why it is not a typeclass default ,Sort an Flist according with its attributes :Given a Semantics, return the string with the proper keys + (propsymbol+arity) to access the agenda RSJSort semantics first according to its predicate, and then to its handles. TUV=Note that the first Subst is assumed to come chronologically % before the second one; so merging  { X -> Y } and  { Y -> 3 }  should give us { X -> 3; Y -> 3 }; See W for a warning! W!Add to variable replacement to a U that logical comes before 6 the other stuff in it. So for example, if we have Y -> foo  and we want to insert X -> Y, we notice that, in fact, Y has  already been replaced by foo , so we add X -> foo instead >Note that it is undefined if you try to append something like  Y -> foo to Y -> bar+, because that would mean that unification  is broken XYZoNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~oopqrstuvwxjnmlkiNOPQRSTYhgcfedz{|}~yXWVU\]^_`abZ[oNOPQRSTOPQRSTUVWXYZ[[\]^_`]^_`abbcfeddefghijnmlkklmno pqrstuvwxpqrstuvwxyz {|}~{|}~ ([ is a generalisation of . An anchored grammar. P The grammar associates a set of semantic predicates to a list of trees each. addTags  tags key elem adds elem( to the the list of elements associated  to the key AGiven a tree(GNode) returns a list of substitution or adjunction H nodes, as well as remaining nodes with a null adjunction constraint. FAssigns a unique id to each element of this list, that is, an integer ' between 1 and the size of the list. \CSorts trees into a Map.Map organised by the first literal of their E semantics. This is useful in at least three places: the polarity M optimisation, the gui display code, and code for measuring the efficiency H of GenI. Note: trees with a null semantics are filed under an empty  predicate, if any.  cs ts' determines if the candidate semantics cs is ) subsumed by the proposition semantics ts. Notice how the proposition I semantics is only a single item where as the candidate semantics is a  list.  We assume  most importantly that cs' has already its semantics instatiated  (all variables assigned)  cs and ts are sorted 9 the list in each element of cs and ts is itself sorted ]3Try in order: lexeme, lexeme attributes, node name ^%b%b$ ;_`a1Just the String representations of the semantics  in the test suite .This is only used by the script genimakesuite bcdefgh<The original string representation of a test case semantics  (for gui) i>The original string representation of the semantics (for gui) jklmnopqrstuvwxyz{|}Like x# but allows for reserved words too ~ DConverts information from a morphological information file into GenI's  internal format. GFilters away from an input semantics any literals whose realisation is K strictly morphological. The first argument tells us helps identify the N morphological literals -- it associates literals with morphological stuff;  if it returns , then it is non-morphological  morphfn sem cands$ does the bulk of the morphological  input processing. We use morphfn to determine which literals in  semF contain morphological information and what information they contain. J Then we attach this morphological information to the relevant trees in  cand:. A tree is considered relevant w.r.t to a morphological L literal if its semantics contains at least one literal whose first index @ is the same as the first index of the morphological literal. ?Actually unify the morphological features into the anchor node  FIXME: we'3ll need to make sure this still works as promised ! when we implement co-anchors. HExtracts the lemmas from a list of uninflected sentences. This is used 9 when the morphological generator is unavailable, doesn' t work, etc. +Return a list of results for each sentence MReturn only n matches, but note any excessive ambiguities or missing matches HConverts a list of uninflected sentences into inflected ones by calling  6 is like Show but it's only used for debugging  TODO: is this true?  3position in the input semantics, extra semantics,  polarity interval   Aintermediate auts, seed aut, final aut, potentially modified sem  9Constructs a polarity automaton from the surface realiser's input: input N semantics, lexical selection, extra polarities and index constraints. For L debugging purposes, it returns all the intermediate automata produced by  the construction algorithm.  KReturns a modified input semantics and lexical selection in which pronouns  are properly accounted for. KBuilds a fake semantic predicate that the index counting mechanism uses to  represent extra columns. 5Given a list of paths (i.e. a list of list of trees) M return a list of trees such that each tree is annotated with the paths it  belongs to. 8Render the list of polarity automaton paths as a string Adds a new polarity item to a ". If there already is a polarity 5 for that item, it is summed with the new polarity. BEnsures that all states and transitions in the polarity automaton < are unique. This is a slight optimisation so that we don' t have to B repeatedly check the automaton for state uniqueness during its C construction, but it is essential that this check be done after  construction 'an initial state for polarity automata )Display a PolMap in human-friendly text. < The advantage is that it displays fewer quotation marks. @EFGJ          JG@EF       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWlexical selection already done X#built into geni, no parsing needed Ygeni's text format Z[\]^_`abcdefgh>Holds the specification for how Geni should be run, its input B files, etc. This is the stuff that would normally be found in  the configuration file. ijklmnopqrstuvw%The default parameters configuration x?Uses the GetOpt library to process the command line arguments. 9 Note that we divide them into basic and advanced usage. yz{flag ;string reader for flag (probably |id| if already a String)  description |flag default value string reader (as in reqArg)  description  advanced }~+Displays the usage text for optimisations. = It shows a table of optimisation codes and their meaning. ?If we do not recognise a code, we output an error message. We 9 also take the liberty of expanding thematic codes like pol - into the respective list of optimisations. #Returns |Left| for any codes we don't recognise, or  |Right| if everything is ok. =Hint: compose with (map toLower) to make it case-insensitive +Is case-insensitive, error if unknown type  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~whijklVYXWZ_^]\[UTRSPQNOLMJKHIFGDEBC@A<=:;896745&'2301./,-*+()$%"# !>?uvtrsmn`gfedcbaqpow}~xyz{|v !!"##$%%&''())*++,--.//011233455677899:;;<==>??@AABCCDEEFGGHIIJKKLMMNOOPQQRSSTUVYXWWXYZ_^]\[[\]^_`gfedcbaabcdefghijklijklmnopqrstuvwxyz{|}~ <for the debugger  tag tree Equivalent to 5 unless the input contains an empty or uninstatiated  semantics NPerforms surface realisation from an input semantics and a lexical selection. ;assign a bit vector value to each literal in the semantics > the resulting map can then be used to construct a bit vector ! representation of the semantics :Return the literals of the semantics (in bit vector form) 1 whose accesibility depends on the given index -Return the handle and arguments of a literal Like  fromGConstG but only for the non-disjoint ones: meant to be used as Maybe or List &Calculate the new set of accessibility/!inaccesible indices, returning a  a tuple of accesible / inaccesible indices JReturn, in bitvector form, the portion of a semantics that is inaccesible  from an item the input semantics the semantics of the item Default implementation for the  function in  Sequence two dispatch filters. /A filter that always fails (i.e. no filtering) BIf the item meets some condition, use the first filter, otherwise  use the second one. <<< m7Things whose only use is within the graphical debugger nodes to highlight actually a set 1 if there are things wrong with this item, what? 2actually: a set of pre-terminals and their leaves 6True if the chart item has no open substitution nodes ,True if the chart item is an auxiliary tree  True if both  and  are True !Creates an initial SimpleStatus. ?Arbitrarily selects and removes an element from the agenda and  returns it. 8Note: returns ONE possible substitution (the head node) B of the first in the second. As all substitutions nodes should 2 be substituted we force substitution in order.       Ignore the next adjunction node  Ignore the next adjunction node ]Retrieves a list of trees from the chart which could be combined with the given agenda tree. 5 The current implementation searches for trees which 5 * do not have overlapping semantics with the given @ * are on the some of the same polarity automaton paths as the  current agenda item 3Helper function for when chart operations succeed. nodes to highlight  !".This is only used for the one-phase algorithm AIf the item (ostensibly a result) does not have the correct root 8 category, return Nothing; otherwise return Just item #$%&'()*)/) |+,-./012345Dnote that the order is always active item, followed by passive item 6789:8the semantics of the item when it was first initialised  unique identifier for this item ;<=     >?@ABCDEFGHIJKLMNOP;is it on the left of the foot node? (yes if there is none) what tree does it belong to the leaf to convert Q4explode a TagElem tree into a bottom-up routing map RSTUVWXYZCKY parent rule CKY subst rules unification for substitution [Areturn True if the first item may be substituted into the second = as long as unification and all the nasty details work out  active item  passive item \]^FCKY adjunction rule: note - we need this split into two rules because M both variants could fire at the same time, for example, the passive variant N to adjoin into the root of an auxiliary tree, and the active variant because ; it is an aux tree itself and it wants to adjoin somewhere CKY adjunction rule: we'1re just a regular node, minding our own business 1 looking for an auxiliary tree to adjoin into us _>return True if the first item may be adjoined into the second = as long as unification and all the nasty details work out  active item  passive item `aNreturn True if the chart items may be combined with each other; for now, this  consists of a semantic check bcdhow did we get the new item? efgindex accessibility filtering hijklFTrivial dispatch filter: always put the item on the agenda and return  Nothing AIf the item can merge with another, merge it with the equivalent  item and return Nothing. < If the item is indeed unique, return (Just $ setId item) 5If it is a result, put the item in the results list. ' Otherwise, return (Just unmodified) @This filter requires another inversion in thinking. It suceeds E if tb unification fails by dispatching to the trash and returning C Nothing. If tb unification suceeds, it returns (Just newItem), 7 where newItem has its top and bottom nodes unified. mnopqrstuvwGMerge two sentence automata together. This essentially calculates the  union of the two automata and pinches their final states together. G FIXME: could be much more sophisticated and produce smaller automata! xGConcatenate two sentence automata. This merges the final state of the A first automaton into the initial state of the second automaton. yCReturns all the derivations trees for this item: note that this is H not a TAG derivation tree but a history of inference rule applications  in tree form z The same as  but calls 7 if not found -     -     ,           F>Only used for instances of GenI where the grammar is compiled  directly into GenI. {|-(node, top, att) (node is Nothing if anchor) }~ !"#$*the current configuration being processed %&'()*names of test case to run +%name, original string (for gui), sem ,simplified traces (optional) ->The program state when you start GenI for the very first time ./01:The macros are stored as a hashing function in the monad. :The results are stored as a lookup function in the monad. 2Stores the results in the tcase and tsuite fields 2&Updates program state the same way as 1 flag flag  file to load  description  parsing cmd  update fn >Load the file if the relevant option is set, otherwise ignore HLoad the file if the relevant option is set, otherwise complain and die 3KReturns a list of sentences, a set of Statistics, and the generator state. S The generator state is mostly useful for debugging via the graphical interface. I Note that we assumes that you have already loaded in your grammar and  parsed your input semantics. 455> performs lexical selection and strips the input semantics of  any morpohological literals - for the moment consists only of running the J morphological generator, but there could conceivably be more involved. 6KShow the sentences produced by the generator, in a relatively compact form 772 is most likely useful for grammars produced by a ; metagrammar system. Given a tree name, we retrieve the `trace' G information from the grammar for all trees that have this name. We I assume the tree name was constructed by GenI; see the source code for  details. &We assume the name was constructed by  combineName 8GSelect and returns the set of entries from the lexicon whose semantics ! subsumes the input semantics.  xs fn organises items (xs) by their semantic key  (retrieved by fn$). An item may have multiple keys. 99  macros lex creates the  repository combining lexical G entries and un-anchored trees from the grammar. It also unifies the M parameters used to specialize un-anchored trees and propagates additional  features given in the z. DGiven a lexical item, looks up the tree families for that item, and ! anchor the item to the trees. any warnings, plus the results HCombine a single tree with its lexical item to form a bonafide TagElem. G This process can fail, however, because of filtering or enrichement lexeme (for debugging info) enrichment eq Split a lex entry'6s path equations into interface enrichement equations  or (co-)anchor modifiers 1Parse a path equation using the GenI conventions : inflects a list of sentences if a morphlogical generator B has been specified. If not, it returns the sentences as lemmas. + !"#$%&'()*+,-./0123456789"#$%&'()*+,!-6+5347 ./01298 !" #$%&'()*+,#$%&'()*+,-./0123456789 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRRSTUVWXYZ[\]^__`abcdefghijklmnopqrstuvwxyz{|}~                           ! " # $ % &''(())**++,,--..//00112233445566778899::;;<<==>>??@@AABBCCDDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                                                       !"#$%&''()*+,-./012334456789:;<=>?@ABCCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijk l m n o p q r s t u v w x y z { | } ~                 E+           O                                                                              M                  ! " # $  % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H IJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnop@qrst GenI-0.17.3NLP.GenI.ConfigurationNLP.GenI.StatisticsNLP.GenI.GeneralNLP.GenI.AutomatonNLP.GenI.Btypes NLP.GenI.TagsNLP.GenI.GeniShowNLP.GenI.GeniParsersNLP.GenI.MorphologyNLP.GenI.PolarityNLP.GenI.BuilderNLP.GenI.Simple.SimpleBuilderNLP.GenI.CkyEarley.CkyBuilder NLP.GenI.GeniNLP.GenI.BtypesBinarybase Data.TypeableTypeableMetric IntMetricStatisticsStateIOStatisticsState Statistics updateMetrics queryMetrics mergeMetrics emptyStatsinitialStatisticsStateFor addMetricaddInspectionMetricsetPrintOutIntervalprintOutAllMetricsprintOutAllMetrics'printOutInspectionMetricsshowFinalStats incrIntMetricqueryIntMetric addIntMetrics BitVectorIntervalePutStr ePutStrLneFlushtrimdropTillIncluding toUpperHead toLowerHead toAlphaNumfst3snd3thd3equating comparingmap'wordsBy boundsCheckisEmptyIntersect groupByFMmultiGroupByFMinsertToListMap groupAndCount combinations mapMaybeMrepListmapTree' filterTree treeLeaves preTerminalsrepNode repAllNode listRepNode repNodeByNodegeniBug!+!ival showInterval showBitVector readFile' lazySlurp withTimeout exitTimeoutNFAstartSt isFinalSt finalStList transitionsstatesfinalSt lookupTransaddTransautomatonPathsautomatonPathSets numStatesnumTransitionsTestCasetcName tcSemStringtcSem tcExpected tcOutputsSubstSemInput LitConstrSemPredIdableidOf Replacablereplace replaceMap replaceOne replaceList CollectablecollectGeniValGAnonGVarGConstAvPairFlistNodeNameGTypeOtherLexFootSubsGNodeGNgnnamegupgdownganchorglexemegtypegaconstrgorigin MorphLexEntry ILexEntryILEiwordifamnameiparams iinterfaceifilters iequationsiptype isemanticsisempolsSemPolsLexiconPtype UnspecifiedAuxiliarInitialTtreeTTparamspfamilypidname pinterfaceptype psemanticsptracetreeMacrosMTtree emptyMacroemptyLE emptyGNodegnnameIs gCategorylexemeAttributes showLexemerootrootUpdfoot setAnchor setLexemeplugTree spliceTreeisConstisVarisAnon fromGConstfromGVarreplaceOneAsMapalphaConvertById alphaConvert sortFlist showFlist showPairsshowAv emptyPredshowSemshowPredtoKeys subsumeSemsortSem unifyFeatunify mergeSubstprop_unify_selfprop_unify_anonprop_unify_symTagItemtgIdNametgIdNum tgSemantics TagDerivationTagElemTEidname ttreenametidnumttypettree tsemantics tpolarities tinterfacettracetsempolsTagSitetsNametsUptsDowntsOriginTags addToTagsemptyTE detectSites setTidnumsmapBySem subsumedBy tagLeaves showTagSitests_synIncompletets_tbUnificationFailurets_rootFeatureMismatchts_semIncompleteGeniShowgeniShowparenssquaresgeniShowKeywordgeniShowSemInput geniTestSuitegeniTestSuiteStringgeniDerivations geniWordsgeniSemanticInputtoSemInputString geniLexicon geniMacros geniTagElemsgeniPolarities geniMorphInfogeniMorphLexicongeniLanguageDef geniFeats geniSemantics geniValuetillEofUninflectedDisjunction MorphLexiconMorphFn readMorph stripMorphSem attachMorphattachMorphHelpersetMorphAnchor sansMorphinflectSentencesUsingLexinflectSentenceUsingLexinflectWordUsingLexinflectSentencesUsingCmd singletonshowLitePolAutPolStatePolStAutDebug PolResultbuildAutomaton makePolAut fixPronounsdetectIdxConstraintsdeclareIdxConstraintsdetectPolFeatures detectSansIdx detectPolsdetectPolPaths showPolPaths showPolPaths' showLitePm ViewCmdFlgVerboseModeFlg TimeoutFlg TestSuiteFlgTestInstructionsFlg TestCaseFlg StatsFileFlgNoLoadTestSuiteFlgRunUnitTestFlgRootFeatureFlgRegressionTestModeFlg PartialFlg OutputFileFlgOptimisationsFlgMorphLexiconFlg MorphInfoFlg MorphCmdFlg MetricsFlg MaxTreesFlg TracesFlg MacrosFlg LexiconFlgInstructionsFileFlgIgnoreSemanticsFlgHelpFlg FromStdinFlgExtraPolaritiesFlg EarlyDeathFlg DisableGuiFlg BatchDirFlgFlag Instruction GrammarType PreAnchored PreCompiledGeniHand BuilderType EarleyBuilder CkyBuilderSimpleOnePhaseBuilder SimpleBuilder NullBuilder OptimisationIaf SemFilteredRootCatFiltered NoConstraints PolarisedAdjOptsPolOptsParamsPrms grammarType builderType geniFlagshasOpt polarisedisIaf semfilteredrootcatfilteredhasFlagP deleteFlagPsetFlagPgetFlagP getListFlagP emptyParamsoptionsForStandardGenI nubBySwitchesnoArgreqArgoptArgtreatStandardArgstreatStandardArgsWithParams treatArgstreatArgsWithParams defineParamsoptionsForBasicStuffoptionsForInputFilesoptionsForOptimisationparseFlagWithParsecoptionsForBuildermainBuilderTypesoptionsForTestingoptionsForMorphologyprocessInstructionshasFlagsetFlaggetFlag NullStateDispatchFilterIafAbleiafAcciafInacc iafSetAcc iafSetInacc iafNewAccIafMap SemBitMap BuilderState SentenceAutUninflectedSentenceUninflectedWordInput inSemInputinLexinCands DerivationOutputBuilderinitstepstepAllfinishedunpackpartialpreInitunlessEmptySemrundefineSemanticBitssemToBitVectorbitVectorToSem dependentSem literalArgs semToIafMap fromUniConstgetIdx ts_iafFailurerecalculateAccesibility iafBadSemdefaultStepAll>--> nullFilter condFilter addCounters modifyStats incrCounter queryCounter initStats namedMetricdefaultMetricNamesnum_iterations chart_sizenum_comparisons nullBuilderinitNullBuilder SimpleGuiItem siHighlightsiNodes siDiagnostic siFullSemsiIdname SimpleItemsiId siSubstnodes siAdjnodes siSemantics siPolpaths siAccesiblesiInaccessiblesiLeaves siDerivedsiRootsiFoot siPendingTb siDerivation siGuiStuff SimpleStatus theAgenda theAuxAgendatheCharttheTrash theResults genconfig SimpleStateChart AuxAgendaAgendasimpleBuilder_2psimpleBuilder_1p simpleBuilder addToAgenda addToChartinitSimpleBuilder unpackResultChartIdCkyItemciNode ciSourceTreeciOrigVariables ciPolpaths ciSemantics ciAdjPoint ciInitialSemciId ciRouting ciPayload ciVariables ciSemBitMap ciTreeSide ciDiagnostic ciDerivation ciAccesibleciInaccessible ciSubstnodes CkyStatusS tsemVector theIafMap gencountertheRules theDispatcher genAutCounter ckyBuilder earleyBuilderciRoot ciAdjDoneunpackItemToAutsemptySentenceAut mJoinAutomatamAutomatonPathsextractDerivationsfindIdSelector GeniResult ProgStateRef ProgStateSTpagrlemorphinfmorphlextstcasetsuitetracesemptyProgStateloadEverything loadLexiconloadGeniMacros loadTestSuiteloadTargetSemStrrunGenirunGeniWithSelectorinitGenishowRealisations getTraces chooseLexCandcombineStatmetricsinspectionMetricscountneedsToPrintOutnoStats printOutListTimeOutAlphaNumNAGHC.Basemap Data.ListgroupByGHC.Listfilterbuf_size timeOutTc GTestString2 GTestStringnmatch findSubTreesubsumeSemHelper subsumePred alignFeat unifySansRep unifyWithRepprependToSubstfromGTestStringfromGTestString2qc_not_empty_GConst setOrigin getLexeme firstMaybeSemInputStringTestCaseOutput geniTestCase geniOutput geniTraces withWhite geniSentencegeniWordgeniTestCaseStringgeniSemanticInputStringgeniIdxConstraints squaresStringgeniLexicalEntryinitTypeauxType geniTreeDefgeniTreegeniNode geniTagElem geniPolarity morphEntrymorphLexiconEntrylexer whiteSpace identifierlooseIdentifier stringLiteralcolonbracesreservedsymbolkeywordkeywordSemantics geniAttVal geniParams geniLiteralgeniLexSemanticsgeniLexLiteral geniPolValue Data.MaybeNothingShowLite PolTransFnPolTransPolMapSemMap PolPathMap SemWeightMapPredLite buildColumns buildSeedAut buildSeedAut'buildSeedAutHelper buildPolAut buildPolAut'buildPolAutHelperpruneprune' indexPred isExtraCol assignIndexshowIdxConstraint detectPols'__cat____idx__getvaltoZero prefixWithpolarisefor substTopsdetectPolPaths' sortSemByFreqaddPolnubAut fakestatepolstartWeirdFlgGrammarTypeFlg BuilderFlgoptionsSections getSwitchesusage usageSectioninstructionsOption macrosOption lexiconOption tracesOption outputOptionoptionsForOutputoptionsForUserInterface noguiOption helpOption verboseOptiondefaultRootFeatcoreOptimisationCodesoptimisationCodespolOptsadjOpts lookupOpt showOptCode describeOptusageForOptimisationsreadOptimisationsparseOptimisationslookupOptimisationmReadBuilderTypereadBuilderTypefromStdinOptiontestSuiteOptionmorphInfoOptionoptionsForIgnoreSeminstructionsFileisFlag deleteFlag getAllFlagsSystem.Console.GetOptgetOpt'getOpt usageInfo RequireOrderPermute ReturnInOrderArgOrderOptionOptDescrNoArgReqArgOptArgArgDescridTbEitherSimpleDispatchFiltertsem semBitMapTrash updateAgendaaddToAuxAgenda addToTrash addToResultsmodifyGuiStuffclosedaux closedAuxadjdone siInitialinitSimpleIteminitSimpleGuiItemrenameNodesWithTidnumgenerateStep_1pgenerateStep_2pgenerateStep_2p'trashIt selectGiven switchToAux semfilterapplySubstitutionapplySubstitution1p iapplySubstapplyAdjunction2ppassiveAdjunction1pactiveAdjunction1pvalidAuxtryAdjsansAdjunction1psansAdjunction2p iapplyAdjNodencopyisRootOf lookupChartcombineSimpleItemscombineSimpleGuiItems constrainAdjaddToDerivationsimpleDispatch_2psimpleDispatch_1psimpleDispatch dpToAgenda dpToResults dpToTrashdpAux dpTbFailuredpRootFeatFailuredpRootFeatFailure2dpRootFeatFailure_ tbUnifyTree tbUnifyNode dpIafFailure unpackResultslistToSentenceAutpartialResultscoverage countBitsSentenceAutPairMaybeCKY_DispatchFilterCKY_InferenceRule InferenceRule RoutingMapTreeSide OnTheSpine RightSideLeftSideChartOperationConstructorChartOperationInitOpKidsToParentOp NullAdjOpAdjOpSubstOpCkyStateckyOrEarleyBuilderciFootciSubs ciCompleteciAuxciInit ciLeftSide ciRightSide ciOnTheSpine initBuilderinitTree leafToItem decompose generateStep generateStep2selectAgendaItemckyRulesnonAdjunctionRule parentRule substRule attemptSubstcompatibleForSubstitutionactiveAdjunctionRulepassiveAdjunctionRuleattemptAdjunctioncompatibleForAdjunctionisLexeme compatiblecombineVectorscombineWithSubst combineWith unifyGNodes unifyPair ckyDispatchdispatchToAgendadispatchRedundantdispatchResultsdispatchTbFailuretbUnifycanMerge mergeItemsdispatchIafFailure unpackItem unpackInitOpunpackNullAdjOp unpackSubstOp unpackAdjOpunpackKidsToParentOpmUnionAutomata unionAutomata joinAutomata incrStates findIdOrBug PathEqPair PathEqLhsLexCombineError OtherError EnrichErroreeMacro eeLexEntry eeLocation BoringErrorUpdateFnmyEMPTY loadMorphInfoloadMorphLexicon loadTracesloadThingOrIgnoreloadThingOrDie loadThingparseFromFileOrFailparseFromFileMaybeBinaryinitGeniWithSelectorfinaliseResults readPidnamerunLexSelection chooseCandI mapBySemKeys mapEither combineList unzipEither combineOneenrichenrichBy pathEqNamemissingCoanchors lexEquations seekCoanchor matchNodeName parsePathEq setLemAnchors _lemanchordefaultSelectorreadPreAnchoredrunMorph