Ar      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopq Safe/rstuvwxyz{|}~/rstuvwxyz{|}~rstuvwxyz{|}~ Safe  1 SafeGCreate a new cache that uses the given function to read and parse filesForget all cached objectsJForget cached objects that have been unused for longer than the given timeList currently cached files_Lookup a cached object (or read the file if it is not in the cache or if it has been modified)Like 8, but also return the last modification time of the file   SafeDecode hexadecimal escapes(Decode application/x-www-form-urlencoded"Decode "+" and hexadecimal escapes   Bjorn Bringert (stability) (portability)SafeRun an IO action, and allow it to be interrupted by a SIGINT to the current process. Returns an exception if the process did not complete normally. NOTES: * This will replace any existing SIGINT handler during the action. After the computation has completed the existing handler will be restored. * If the IO action is lazy (e.g. using readFile, unsafeInterleaveIO etc.) the lazy computation will not be interruptible, as it will be performed after the signal handler has been removed.Like A, but always returns (), whether the computation fails or not."Run an action with SIGINT blocked.BB(stable) (portable)Safe Create a new empty graph.Get all the nodes in the graph.Get all the edges in the graph.$Map a function over the node labels.$Map a function over the edge labels.Add a node to the graph.2Remove a node and all edges to and from that node.<Remove a set of nodes and all edges to and from those nodes.0Get a map of node names to info about each node.Add the nodes from the second graph to the first graph. The nodes in the second graph will be renamed using the name supply in the first graph. This function is more efficient when the second graph is smaller than the first.Rename the nodes in the graph. A strict ! Node labelNode graph and name of new nodeGets the node to group byrThe new graph and a function translating the old names of nodes in the second graph to names in the new graph.renaming functionOinfinite supply of fresh node names, to use when adding nodes in the future. SafeNoneSafe*     *           Safe !"#$%&'()*+,-./0123 !"#$%&'()*+,-./0123PL(stable) (portable)Safe9;<=OT456789:;<=>?@ABCDEFGHIJ46789:;<=456789:;<=>?@ABCAR(stable) (portable)SafeSafeKLMNOPQRSTUVWXYZ[\]^_`SKLMNOPQRSTUVWXYZ[\]^_`AR(stable) (portable)Safeata variant can itself be a token list, but for simplicity only a list of strings i.e. not itself containing variantsbLnotice that having both pre and post would leave to inconsistent situations: /pre {"x" ; "y" / "a"} ++ post {"b" ; "a" / "x"}=always violates a condition expressed by the one or the otherc"variants depending on next string dCabstract token list type. AR 2001, revised and simplified 20/4/2003abecdfghijklmnopbdijkmno abecdfghijklmnopSafe!qrstuvwxyz{|}~wxy{|qrstuvwxyz{|}~SafeSafe(c) Sven Panne 2002-2005/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimentalportableSafe sDescribes whether an option takes an argument or not, and if so how the argument is injected into a value of type a.no argument expectedoption requires argumentoptional argumentEach  describes a single option.The arguments to  are:list of short option characters*list of long option strings (without "--")argument descriptorexplanation of option for user-What to do with options following non-options+no option processing after first non-option*freely intersperse options and non-optionswrap non-options into optionsReturn a string describing the usage of a command, derived from the header (first argument) and the options described by the second argument.pProcess the command-line, and return the list of values that matched (and those that didn't). The arguments are:The order requirements (see )The option descriptions (see ):The actual command line arguments (presumably got from ).j returns a triple consisting of the option arguments, a list of non-options, and a list of error messages.This is almost the same as , but returns a quadruple consisting of the option arguments, a list of non-options, a list of unrecognized options, and a list of error messages. SafeoAccording to comments in cabal-install cbits/getnumprocessors.c this function is part of the RTS of GHC>=6.12.MSet parallelism to a given number, or use the number of processors. Returns Z if compiled with GHC<7.6 and the desired number of threads hasn't already been set with +RTS -Nn -RTS./Returns the number of processors in the system.None Bjorn Bringert (stability) (portability)Safe Safe 6 !Safe        "Safe   #Safe      $AR(stable) (portable)SafeLike  type with error msgs Analogue of  Analogue of  fromMaybe added by KJadded 2/10/2003 by PEB %Safe !"#$%&'() !"#$%&'() !"#$%&'()Safe  !"#$%&*+,-./01234567  %$#"!    !"#$% 5 566&Safe+JSet the console encoding (for Windows, has no effect on Unix-like systems) &'()*+,89-&'*()+,-&'()*+,89-'Safe./././(Safe:=Feed some input to a shell process and read the output lazily: shell commandinput to shell commandoutput from shell command::)Safe0Attaching location information0123456789:;;<= 0123456789:; 0123456789:;;<=Safe9;<=? <-Haskell representation of the GF record type {s:t}>#Overloaded function to project the s field from any record typeATokensI4Token sequences, output form linearization functionsJ/For enumerating parameter values used in tablesLTablesMRender a token sequence as a >NCoerce from any record type  {...,s:t,...} to the supertype {s:t}OConcatenation with variantsP#Selection from tables with variants<=>?@2To be matched with the prefix of a following tokenABCDEFGHIJKLMNOPQRST<=>?@ABCDEFGHIJKLMNOPQRJKLIABCDEFGH@M>?<=TSNOPQR<=>?@ABCDEFGHIJKLMNOPQRSTO5Safebnormalize = change grave accent on sentence internal words to acute, and shift inherited acutes to the following enclitic (where they are visible only as shown in the list of enclitics above)dde-normalize = change acute accent of end syllables in sentence internal (non-enclitic) words to grave accent, and move accents of enclitics to the previous word to produce ordinary ancient greekf-Change accent on the final syllable of a wordi1Accent moves for enclitics and proclitics (atona)qAccent manipulationt Accent checking on end syllables[\]^_`abcdefghijklmnopqrstuvwxy[\]^_`abcdefghijklmnopqrstuvwxy[\]^_`abcdefghijklmnopqrstuvwxy[\]^_`abcdefghijklmnopqrstuvwxySafe zQText lexing with standard word capitalization of the first word of every sentence{FText lexing with custom treatment of the first word of every sentence.}.Bind tokens separated by Prelude.BIND, i.e. &+~#Haskell lexer, usable for much codeILaTeX lexer in the math mode: should not be separated from the next wordCLaTeX style lexer, with "math" environment using Code between $...$Capitalize first letterUncapitalize first letter,Unquote each string wrapped in double quotesz{|}~z{|}~z{|}~z{|}~*Safe?@ABC?@?@ABCSafeLike +,, but O(n log n) instead of O(n^2), since it uses a set to lookup previous things. The result list is stable (the elements are returned in the order they occur), and lazy. Requires that the list elements can be compared by Ord. Code ruthlessly taken from http://hpaste.org/544118Replace all occurences of an element by another element.-PL(stable) (portable)Safe DLike E5, but returns the empty list when the input is empty.FESorts and then groups elements given an ordering of the elements.G"Take the union of a list of lists.HLike IJ, but fails if the argument is not found, instead of returning Nothing.JLike K , but fails if nothing is found.LSet a value in a lookup table.M%Group tuples by their first elements.N2Use an ordering function as an equality predicate.O:Return the given value if the boolean is true, els return P.Q2Returns true if the argument is Nothing or Just []R4Apply all the functions in the list to the argument.SFixpoint iteration.TDJoin a number of lists by using the given glue between the lists.(UVWXYZ[\]^DFGHJLMN_`abcdefOghQRSTglue lists to joinijklmno*UVWXYZ[\]^DFGHJLMN_`abcdefOghQRSTijklmno(UVWXYZ[\]^DFGHJLMN_`abcdefOghQRSTijklmno.BB(stable) (portable)Safep'Keeps both incoming and outgoing edges.q0Creates a relation from a list of related pairs.rUCreates a relation from a list pairs of elements and the elements related to them.sAdd a pair to the relation.t$Add a list of pairs to the relation.u+Checks if an element is related to another.v<Get the set of elements to which a given element is related.w!Get all elements in the relation.x=Keep only pairs for which both elements are in the given set.yUses wz8Get the set of elements which are related to themselves.{7Keep the related pairs for which the predicate is true.|$Remove keys that map to no elements.}:Get the equivalence classes from an equivalence relation. ~Returns  if there are cycles, and  if there are cycles.Removes an element from a relation. Returns the new relation, and the set of incoming and outgoing edges of the removed element.#pqrstuvwx+The set over which the relation is defined.yz{|}~qruvyz}~#pqrstuvwxyz{|}~/AR(stable) (portable)Safe  Add msg s to  failures@this is what happens when matching two values in the same moduleThomas Hallgren's wrap lines is the same as !!! peb 30/5-04*Topological sorting with test of cyclicityFTopological sorting with test of cyclicity, new version /TH 2012-06-26KFix point iterator (for computing e.g. transitive closures or reachability)#chop into separator-separated parts  return ()(if the first check fails try another one9<655550BB(stable) (portable)SafeKGraph type, graph ID, graph attirbutes, graph nodes, graph edges, subgraphs 1BB(stable) (portable)Safe Type parameters: node id type, state label type, edge label type Data constructor arguments: nodes and edges, start state, final states@Create a new finite automaton with an initial and a final state.\Gets all incoming transitions to a given state, excluding transtions from the state itself.Give new names to all nodes.Insert an NFA into anotherMake the finite automaton have a single final state by adding a new final state and adding an edge from the old final states to the new state.Transform a standard finite automaton with labelled edges to one where the labels are on the nodes instead. This can add up to one extra node per edge.tRemove empty nodes which are not start or final, and have exactly one outgoing edge or exactly one incoming edge.sMove edges to empty nodes to point to the next node(s). This is not done if the pointed-to node is a final node.IRemove all internal nodes with no incoming edges or no outgoing edges.EGet all the nodes reachable from a list of nodes by only empty edges.Get a map of labels to sets of all nodes reachable from a the set of nodes by one edge with the given label and then any number of empty edges..Start node labelInfinite supply of new namesNFA to insert intoStates to insert betweenNFA to insert.Label to give the new nodeLabel to give the new edgesThe old networkThe new networkA node and its incoming edges-Replacement nodes with their incoming edges.%-2Safe  3SafeREUnion [] is nullREConcat [] is epsilon              4SafeWAn abstract data type that represents identifiers for functions and categories in PGF.Creates a new identifier from >+Creates an identifier from a UTF-8-encoded  ByteStringReads an identifier from >. The function returns ' if the string is not valid identifier.Renders the identifier as > 5Safestring constantinteger constantfloating point constant) !"#$%&'()*+,-./0123456789:;<=>?@A& !"#$%&'()*+,-./0123456789:;<=>  !"#$%&'()*+,-./0123456789:;<=>?@A6SafeO represents a hypothesis in a type i.e. in the type A -> B, A is the hypothesisTo read a type from a >, use .Reads a  from a >.renders type as >z. The list of identifiers is the list of all free variables in the expression in order reverse to the order of binding.mcreates a type from list of hypothesises, category and list of arguments for the category. The operation $mkType [h_1,...,h_n] C [e_1,...,e_m] will create "h_1 -> ... -> h_n -> C e_1 ... e_m0creates hypothesis for non-dependent type i.e. A2creates hypothesis for dependent type i.e. (x : A)Kcreates hypothesis for dependent type with implicit argument i.e. ({x} : A)BCDEFGBCFGBCDEFG7Safe An expression in the abstract syntax of the grammar. It could be both parameter of a dependent type or an abstract syntax tree for for some sentence.HnThe equation is used to define lambda function as a sequence of equations with pattern matching. The list of ) represents the patterns and the second ) is the function body for this equation.INThe pattern is used to define equations in the abstract syntax of the grammar.JDapplication. The identifier should be constructor i.e. defined with 'data'KliteralLvariableMvariable@patternNwildcardOimplicit argument in patternPlambda abstractionQ applicationRliteralS meta variableTfunction or data constructorUvariable with de Bruijn indexVlocal type signatureWimplicit argument in expressioneTree is the abstract syntax representation of a given sentence in some concrete syntax. Technically  is a type synonym of .parses > as an expressionrenders expression as >z. The list of identifiers is the list of all free variables in the expression in order reverse to the order of binding.HConstructs an expression by applying a function to a list of expressions5Decomposes an expression into application of functionXbDecomposes an expression into an application of a constructor such as a constant or a metavariable,Constructs an expression from string literal,Decomposes an expression into string literal-Constructs an expression from integer literal-Decomposes an expression into integer literal1Constructs an expression from real number literal1Decomposes an expression into real number literal/Constructs an expression which is meta variable/Checks whether an expression is a meta variableY$Compute an expression to normal formGZ[\]^_`abcdefghiHjIJKLMNOkPQRSTUVWlXmnopqrsYtuvwxyGRTUPQSVWZ[\]^;<_`afbdegchiHjIJKLMNOklXopqrYtuvw-PQRSTUVWZ[\]^_`abcdefghiHjIJKLMNOklXmnopqrsYtuvwxy8SafeThis is just a  with the language name. A language name is the identifier that you write in the top concrete or abstract module in GF after the concrete/abstract keyword. Example: 2abstract Lang = ... concrete LangEng of Lang = ...zvalue of a flag{5type, arrity and definition of function + probability| context of a categoryXfunctions of a category. The functions are stored in decreasing probability order. probabilityTAn abstract data type representing multilingual grammar in Portable Grammar Format.B}~z{|RTUPQSVWZ[\]^;<BCFGfbdegchiHjIJKLMNOklXopqrY}~{|z}~  z{|9SafecBracketedString represents a sentence that is linearized as usual but we also want to retain the ' brackets': that mark the beginning and the end of each constituent.$this is the leaf i.e. a single tokenthis is a bracket. The % is the category of the phrase. The  is an unique identifier for every phrase in the sentence. For context-free grammars i.e. without discontinuous constituents this identifier is also unique for every bracket. When there are discontinuous phrases then the identifiers are unique for every phrase but not for every bracket since the bracket represents a constituent. The different constituents could still be distinguished by using the constituent index i.e. . If the grammar is reduplicating then the constituent indices will be the same for all brackets that represents the same constituent.AList of functions that lack linearizations in the given language.*Show the printname of function or categoryIRenders the bracketed string as string where the brackets are shown as (S ...) where S is the category.7The length of the bracketed string in number of tokens.00':Safe:5Linearizes given expression as string in the language The same as # but does not return the language.QLinearizes given expression as string in all languages available in the grammar.ALinearizes given expression as a bracketed string in the language\Creates a table from feature name to linearization. The outher list encodes the variations;Krasimir Angelov(stable) (portable)Safe9;<=OTmIf an error occurs in the typechecking phase the type checker returns not a plain text error message but a % structure which describes the error. Unknown category name was found. Unknown function name was found.A category was applied to wrong number of arguments. The first integer is the number of expected arguments and the second the number of given arguments. The [CId]P argument is the list of free variables in the type. It should be used for the  function.yThe expression is not of the expected type. The first type is the expected type, while the second is the inferred. The [CId]j argument is the list of free variables in both the expression and the type. It should be used for the  and  functions.BSomething that is not of function type was applied to an argument.6It is not possible to infer the type of an expression.QSome metavariables have to be instantiated in order to complete the typechecking.<Implicit argument was passed where the type doesn't allow it %There is a goal that cannot be solved<returns the type and the De Bruijn index of a local variable1returns the type and the name of a local variable 3Renders the type checking error to a document. See <=. RCheck whether a given type is consistent with the abstract syntax of the grammar. .Checks an expression against a specified type. Tries to infer the type of a given expression. Note that even if the expression is type correct it is not always possible to infer its type in the GF type system. In this case the function returns the  error.M          1        ;           >SafeOGenerates an exhaustive possibly infinite list of abstract syntax expressions. A variant of X which also takes as argument the upper limit of the depth of the generated expression.EGenerates a list of abstract syntax expressions in a way similar to [ but instead of generating all instances of a given type, this function uses a template.  A variant of \ which also takes as argument the upper limit of the depth of the generated subexpressions.Generates an infinite list of random abstract syntax expressions. This is usefull for tree bank generation which after that can be used for grammar testing. A variant of X which also takes as argument the upper limit of the depth of the generated expression.#Random generation based on templateCRandom generation based on template with a limitation in the depth.    ?KA(stable) (portable)Safe$>Renders abstract syntax tree in Graphviz format. The pair of !  (funs,cats)_ lets you control whether function names and category names are included in the rendered tree.%Visualize word dependency tree.&JPrepare lines obtained from a configuration file for labels for use with %. Format per line fun label*."Render LaTeX pictures as SVGY#$%&'()*+,-./0123456789:;<=>?@ABC !"#$%Output format: "latex", "conll",  "malt_tab",  "malt_input" or "dot"!Include extra information (debug) Label information obtained with &not used (was:  Maybe String)The language of analysis'Rendered output in the specified format&'()DEF*GHIJ+KLM,NOPQRSTUVWXYZ[\]^_`ab"c !"#$%&'()*+,>#$%&'()*+,-./0123456789:;<=>?@ABC  !"#$%&'()DEF*GHIJ+KLM,NOPQRSTUVWXYZ[\]^_`ab"c@Safe-hAn abstract data structure which represents the probabilities for the different functions in a grammar..+Renders the probability structure as string/Reads the probabilities from a file. This should be a text file where on every line there is a function name followed by a real number. The number represents the probability mass allocated for that function. The function name and the probability should be separated by a whitespace.0Builds probability tables. The second argument is a map which contains the know probabilities. If some function is not in the map then it gets assigned some probability based on the even distribution of the unallocated probability mass for the result category.1%Returns the default even distibution.3'compute the probability of a given tree4'rank from highest to lowest probabilityd-efg./01h234ijklmn -efg./01h234id-efg./01h234ijklmnASafe 5o678p9:;<=qr 56789:;<=qr 5o678p9:;<=qrBKrasimir Angelov stable  portable Safe9sThis function extracts the list of all completed parse trees that spans the whole input consumed so far. The trees are also limited by the category specified, which is usually the same as the startup category. tuvwxyz{|s}~ tuvywxzstuvwxyz{|s}~CNone:OT`An abstract data type whose values represent the state in an incremental parser after an error.>YAn abstract data type whose values represent the current state in an incremental parser.?RThis data type encodes the different outcomes which you could get from the parser.@HThe integer is the position in number of tokens where the parser failed.ASThe parsing was successful but none of the trees is type correct. The forest id () points to the bracketed string from the parser where the type checking failed. More than one error is returned if there are many analizes for some phrase but they all are not type correct.BzIf the parsing and the type checking are successful we get a list of abstract syntax trees. The list should be non-empty.C=The sentence is not complete. Only partial output is producedD@The input to the parser is a pair of predicates. The first one F selects a token from a list of suggestions from the grammar, actually appears at the current position in the input string. The second one G- recognizes whether a literal with forest id + could be matched at the current position.HLCreates an initial parsing state for a given language and startup category.I{This function constructs the simplest possible parser input. It checks the tokens for exact matching and recognizes only String, Int and Float literals. The Int and Float> literals match only if the token passed is some number. The StringL literal always match but the length of the literal could be only one token.K+From the current state and the next token K computes a new state, where the token is consumed and the current position is shifted by one. If the new token cannot be accepted then an error state is returned.LUIf the next token is not known but only its prefix (possible empty prefix) then the L function can be used to calculate the possible next words and the consequent states. This is used for word completions in the GF interpreter.NThis function extracts the list of all completed parse trees that spans the whole input consumed so far. The trees are also limited by the category specified, which is usually the same as the startup category.OSReturn the Continuation of a Parsestate with exportable types Used by PGFService5>?@ABCDEFGHIJKLMNO>?A@BCDEFGHIJKLMNO">?@ABCDEFGHIJKLMNODNoneESafe:FSafeThe tree is an evaluated expression in the abstract syntax of the grammar. The type is especially restricted to not allow unapplied lambda abstractions. The tree is used directly from the linearizer and is produced directly from the parser.6lambda abstraction. The list of variables is non-emptyvariablefunction applicationliteral meta variableaConverts a tree to expression. The conversion is always total, every tree is a valid expression.Converts an expression to tree. The conversion is only partial. Variables and meta variables of function type and beta redexes are not allowed.  GAR(stable) (portable)SafeConverts a pattern to tree. PP PHSafeINone'JNone0              KNoneLLennart Kolmodin, Ross PatersonBSD3-style (see LICENSE),Lennart Kolmodin <kolmodin@dtek.chalmers.se> experimentalportable to Hugs and GHCNoneBA # is an efficient way to build lazy 1s. There are several functions for constructing Xs, but only one to inspect them: to extract any data, you have to turn them into lazy s using .Internally, a  constructs a lazy MN by filling byte arrays piece by piece. As each buffer is filled, it is 'popped' off, to become a new chunk of the resulting lazy +. All this is hidden from the user of the .O(1). The empty Builder, satisfying   = O(1).+ A Builder taking a single byte, satisfying  ( b) =  bO(1).L The concatenation of two Builders, an associative operation with identity  , satisfying  ( x y) =  ( x) ( y) O(1). A Builder taking a ! , satisfying  (  bs) = " [bs]#O(1). A Builder taking a lazy  , satisfying  (# bs) = bsO(n). Extract a lazy  from a P. The construction work takes place if and when the relevant part of the lazy  is demanded.$O(1). Pop the !N we have constructed so far, if any, yielding a new chunk in the result lazy .%&Sequence an IO operation on the buffer&Get the size of the buffer'&Map the resulting list of bytestrings.(Ensure that there are at least n many bytes available.) Ensure that n( many bytes are available, and then use f& to write some bytes into the memory.* Ensure that n( many bytes are available, and then use f0 to write some storable values into the memory.+#Write a Word16 in big endian format,&Write a Word16 in little endian format-#Write a Word32 in big endian format.&Write a Word32 in little endian format/#Write a Word64 in big endian format0&Write a Word64 in little endian format1O(1).; A Builder taking a single native machine word. The word is written in host order, host endian form, for the machine you're on. On a 64 bit machine the Word is an 8 byte value, on a 32 bit machine, 4 bytes. Values written this way are not portable to different endian or word sized machines, without conversion.2]Write a Word16 in native host order and host endianness. 2 bytes will be written, unaligned.3]Write a Word32 in native host order and host endianness. 4 bytes will be written, unaligned.4Write a Word64 in native host order. On a 32 bit machine we write two host order Word32s, in big endian form. 8 bytes will be written, unaligned.$5678 #$9%&'():;*<+,-./01234=>?@ #$+,-./01234!5678 #$9%&'():;*<+,-./01234=>?@OLennart KolmodinBSD3-style (see LICENSE),Lennart Kolmodin <kolmodin@dtek.chalmers.se> experimentalportable to Hugs and GHC.NoneBAHThe Get monad is just a State monad carrying around the input ByteStringBThe parse stateCRun the Get monad applies a D%-based parser on the input ByteStringERun the Get monad applies a D-based parser on the input ByteString. Additional to the result of get it returns the number of consumed bytes and the rest of the input.F Skip ahead n bytes. Fails if fewer than n bytes are available.G Skip ahead n- bytes. No error if there isn't enough bytes.HRun ga4, but return without consuming its input. Fails if ga fails.ILike H, but consume the input if gma returns 'Just _'. Fails if gma fails.JLike H, but consume the input if gea returns 'Right _'. Fails if gea fails.KGet the next up to n5 bytes as a lazy ByteString, without consuming them. L1Get the total number of bytes read to this point.MGet the number of remaining unparsed bytes. Useful for checking whether all input has been consumed. Note that this forces the rest of the input.NVTest whether all input has been consumed, i.e. there are no remaining unparsed bytes.O An efficient D5 method for strict ByteStrings. Fails if fewer than n bytes are left in the input.P An efficient D; method for lazy ByteStrings. Does not fail if fewer than n bytes are left in the input.QvGet a lazy ByteString that is terminated with a NUL byte. Fails if it reaches the end of input without hitting a NUL.R,Get the remaining bytes as a lazy ByteStringS importantPull n. bytes from the input, as a strict ByteString.TlSplit a ByteString. If the first result is consumed before the -- second, this runs in constant heap space.8You must force the returned tuple for that to work, e.g. >case splitAtST n xs of (ys,zs) -> consume ys ... consume zsU importantV!Read a Word8 from the monad stateW"Read a Word16 in big endian formatX%Read a Word16 in little endian formatY"Read a Word32 in big endian formatZ%Read a Word32 in little endian format["Read a Word64 in big endian format\%Read a Word64 in little endian format]O(1). Read a single native machine word. The word is read in host order, host endian form, for the machine you're on. On a 64 bit machine the Word is an 8 byte value, on a 32 bit machine, 4 bytes.^O(1).? Read a 2 byte Word16 in native host order and host endianness._O(1).8 Read a Word32 in native host order and host endianness.`O(1).7 Read a Word64 in native host order and host endianess.0AabBcDdefCEgFGHIJKLMNOPQRShTUiVWXYZ[\]^_`jklmnopACEFGHIJKLMNOPQRSVWXYZ[\]^_`-AabBcDdefCEgFGHIJKLMNOPQRShTUiVWXYZ[\]^_`jklmnopPLennart KolmodinBSD3-style (see LICENSE),Lennart Kolmodin <kolmodin@dtek.chalmers.se>stable(Portable to Hugs and GHC. Requires MPTCsNoneq<Put merely lifts Builder into a Writer monad, applied to ().r@The PutM type. A Writer monad over the efficient Builder monoid.sRun the q monadtRun the q monad with a serialiseruRun the q+ monad with a serialiser and get its resultvfPop the ByteString we have constructed so far, if any, yielding a new chunk in the result ByteString.w/Efficiently write a byte into the output bufferxAn efficient primitive to write a strict ByteString into the output buffer. It flushes the current buffer, and writes the argument into a new chunk.yfWrite a lazy ByteString efficiently, simply appending the lazy ByteString chunks to the output bufferz#Write a Word16 in big endian format{&Write a Word16 in little endian format|#Write a Word32 in big endian format}&Write a Word32 in little endian format~#Write a Word64 in big endian format&Write a Word64 in little endian formatO(1).0 Write a single native machine word. The word is written in host order, host endian form, for the machine you're on. On a 64 bit machine the Word is an 8 byte value, on a 32 bit machine, 4 bytes. Values written this way are not portable to different endian or word sized machines, without conversion.O(1).V Write a Word16 in native host order and host endianness. For portability issues see  putWordhost.O(1).V Write a Word32 in native host order and host endianness. For portability issues see  putWordhost.O(1). Write a Word64 in native host order On a 32 bit machine we write two host order Word32s, in big endian form. For portability issues see  putWordhost.qrstuvwxyz{|}~qrstuvwxyz{|}~qrstuvwxyz{|}~QNoneI3 &RLennart KolmodinBSD3-style (see LICENSE),Lennart Kolmodin <kolmodin@dtek.chalmers.se>unstableFportable to Hugs and GHC. Requires the FFI and some flexible instancesNone9:;QThe Binary class provides  and , methods to encode and decode a Haskell value to a lazy ByteString. It mirrors the Read and Show classes for textual representation of Haskell types, and is suitable for serialising Haskell values to disk, over the network.For parsing and generating simple external binary formats (e.g. C structures), Binary may be used, but in general is not suitable for complex protocols. Instead use the Put and Get primitives directly.:Instances of Binary should satisfy the following property: decode . encode == id That is, the  and j methods should be the inverse of each other. A range of instances are provided for basic Haskell types.  Encode a value in the Put monad.Decode a value in the Get monadR?Encode a value using binary serialisation to a lazy ByteString.SMDecode a value from a lazy ByteString, reconstructing the original structure.T"Lazily serialise a value to a file<This is just a convenience function, it's defined simply as: %encodeFile f = B.writeFile f . encode@So for example if you wanted to compress as well, you could use: !B.writeFile f . compress . encodeU8Lazily reconstruct a value previously written to a file.<This is just a convenience function, it's defined simply as: /decodeFile f = return . decode =<< B.readFile fBSo for example if you wanted to decompress as well, you could use: -return . decode . decompress =<< B.readFile f4QRSTUAVqwQRSTU2QRSTUSNone&                        &                        TNone   ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 "   ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7Krasimir AngelovstableportableNoneV+A type for tries of plain applicative treesY"A type for plain applicative trees\4Reads file in Portable Grammar Format and produces . structure. The file is usually produced with: $ gf -make <grammar file name>]eTries to parse the given string in the specified language and to produce abstract syntax expression.^ The same as _# but does not return the language._Tries to parse the given string with all available languages. The returned list contains pairs of language and list of abstract syntax expressions (this is a list, since grammars can be ambiguous). Only those languages for which at least one parsing is possible are listed.` The same as ]& but returns more detailed informationa9This is an experimental function. Use it on your own riskcHThe abstract language name is the name of the top-level abstract moduled5List of all languages available in the given grammar.eGets the RFC 4646 language tag of the language which the given concrete syntax implements, if this is listed in the source grammar. Example language tags include "en" for English, and "en-UK" for British English.fList of all categories defined in the given grammar. The categories are defined in the abstract syntax with the 'cat' keyword.hThe start category is defined in the grammar with the 'startcat' flag. This is usually the sentence category but it is not necessary. Despite that there is a start category defined you can parse with any category. The start category definition is just for convenience.i4List of all functions defined in the abstract syntaxj2List of all functions defined for a given categorykThe type of a given functionl%Converts an expression to normal formn Convert a  to an Yo#Combine a list of trees into a trieVWXYZ[\]^_`abcdefghijklmno      !"#$%&'()*+,-./0123456789:;<=>?A@BCDEFGHIJKLMNOPVWXYZ[\]^_`abcdefghijklmno\dcefghijkb]_^`alP     >HKLMDEFGIJ?@ABCNO76598;<=:$'(%)+* !"#,&-01./324mYZ[VWXnoVWXYZ[\]^_`abcdefghijklmnoUNone 8*an abstract syntax function with arguments 91A lambda abstraction. The Int is the variable id. : Application ;-The result of the n:th (0-based) non-terminal <A lambda-bound variable =A metavariable >Removes all directly and indirectly cyclic productions. FIXME: this may be too aggressive, only one production needs to be removed to break a given cycle. But which one should we pick? FIXME: Does not (yet) remove productions which are cyclic because of empty productions. ?VBetter bottom-up filter that also removes categories which contain no finite strings. @FRemoves categories which are not reachable from any external category. AOMerges categories with identical right-hand-sides. FIXME: handle probabilities B6Keeps only the start category as an external category. C?Get the sets of mutually recursive non-terminals for a grammar. DGets all rules in a CFG. E9Gets all rules in a CFG, grouped by their LHS categories. F%Gets all categories which have rules. G7Gets all categories which have rules or occur in a RHS. H&Gets all rules for the given category. I/Gets all rules for categories in the given set. J+Clean up CFG after rules have been removed. KCombine two CFGs. LbCheck if any of the categories used on the right-hand side are in the given list of categories. MoCheck if all the rules are right-linear, or all the rules are left-linear, with respect to given categories. N.Checks if a context-free rule is right-linear. O-Checks if a context-free rule is left-linear. PDChecks if a symbol is a non-terminal of one of the given categories.F Q R S T U V W X 8 9 : ; < = Y Z [ \ ] ^ _ ` a b c d e f > ? @ A B g CeIf true, all categories will be in some set. If false, only recursive categories will be included. h i j k l D E F G H I m n J K o p q r s t u v L w x M NThe categories to consider%The rule to check for right-linearity OThe categories to consider$The rule to check for left-linearity y z { | P }F Q R S T U V W X 8 9 : ; < = Y Z [ \ ] ^ _ ` a b c e d f > ? @ A B g C h i j k l D E F G H I m n J K o p q r s t u v L w x M N O y z { | P }6 Q R S T U V W X 8 9 : ; < = Y Z [ \ ] ^ _ ` a b c d e f > ? @ A B g C h i j k l D E F G H I m n J K o p q r s t u v L w x M N O y z { | P }V Gleb Lobanov (experimental) (portable)None ~   X 8 9 : ; < = c e d  ~   WAR(stable) (portable)None    XNone    YAR(stable) (portable)None Ncompare answer to the list of right answers, increase score and give feedback    ZNone   [None KLexers with a text lexer that tries to be a more clever with the first word Standard lexers 8Unlexing for the C runtime system, &+ is already applied ?Unlex text, skipping the quality marker used by the App grammar AUnlexing for the Haskell run-time, applying the &+ operator first ,Render trees as JSON with numbered functions %tabulate all variants and their formsZ                           ! " # $ % & ' (  U                             ! " # $ % & ' ( "2 #2\None% ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M ) : ; < D J K L ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M]unstableNone9RTUPQSVWZ[\]^ !"#$%&'()*+,-./0123456789:;<=>BCFGfbdegchiHjIJKLMNOklXopqrY}~{|zACEFGHIJKLMNOPQRSVWXYZ[\]^_`qrstuvwxyz{|}~QRSTU "^AR(stable) (portable)None rbIdentifiers are stored as UTF-8-encoded bytestrings. (It is also possible to use regular Haskell >@s, with somewhat reduced performance and increased memory use.)sthe constructors labelled INTERNAL: are internal representation never returned by the parser N0raw identifier after parsing, resolved in Rename OwildcardLbelow this constructor: internal representation never returned by the parser PINTERNAL variable QINTERNAL argument of cat at position RINTERNAL* argument of cat with bindings at positiont Module names|XThis function should be used with care, since the returned ByteString is UTF-8-encoded.to mark argument variablesused in lin defaultsrefreshing variables)r S Ts N O P Q Rtuv U Vwxyz{|}~ W X Y Z [rstuvwxyz{|}~!r S Ts N O P Q Rtuv U Vwxyz{|}~ W X Y Z [_NoneB \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~  Y k t u v w x y z { | } ~  2 \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u vN w x y z { | } ~  ` kr.angelov(stable) (portable)None9                           ! " # $ %9                           ! " # $ %9                           ! " # $ %aNone2 &BPretty print atomically (i.e. wrap it in parentheses if necessary) 'Patterns ( Expressions )Type expressions *,A type constructor applied to some arguments +Top-level declarations6 & , ' - . / 0 1 2 ( 3 4 5 6 7 8 9 : ) ; < = > ? @ A * B + C D E F G H I J K L M N O P Q R S T U V W X Y Z [- & , ' . 0 1 - / 2 ( 3 8 4 : 7 5 6 9 ) > = ; < ? @ A * B + F D E C G H I J K L M N O P Q R & , ' - . / 0 1 2 ( 3 4 5 6 7 8 9 : ) ; < = > ? @ A * B + C D E F G H I J K L M N O P Q R S T U V W X Y Z [bNone#SISR Working draft 1 April 2003 >http://www.w3.org/TR/2003/WD-semantic-interpretation-20030401/:Pretty-print the options that are preserved in .gfo files.:Pretty-print the options that are preserved in .pgf files. \Option descriptionsThis is for bacward compatibility. Since GHC 6.12 we started using the native Unicode support in GHC but it uses different names for the code pages. ] ^ _ ` alist of string argumentslist of string arguments      b \ c d e f g h i j k l m n o p q r s t u     = ]& ^ _ ` a      b \ c d e f g h i j k l m n o p q r s t ucAR(stable) (portable)None[& record label)0to guide computation and type checking of tables*%received from parser; can be anything+$type annontated, but can be anything,expanded-.just one wild card pattern, no need to expand v<Measured pattern (paired with the min & max matching length).Patterns/constructor pattern:  C p1 ... pn C 0package constructor pattern:  P.C p1 ... pn P.C 1variable pattern: x2wild card pattern: _3record pattern:  {r = p ; ...} -- only concrete4string literal pattern: "foo" -- only abstract5integer literal pattern: 12 -- only abstract6float literal pattern: 1.2 -- only abstract7type-annotated pattern8as-pattern: x@p9.placeholder for pattern for implicit argument {p}:inaccessible pattern;negated pattern: -p<disjunctive pattern: p1 | p2=sequence of token parts: p + q>sequence of token parts: p + q?repetition of token part: p*@string of length one: ?Acharacter list: ["aeiou"]EvariableFconstantG constructorH basic typeIinteger literalJfloating point literalKstring literal or token: "foo"Lthe empty string []M application: f aN abstraction: x -> bOmetavariable: ?i (only parsable: ? = ?0)P"placeholder for implicit argument {t}Qfunction type:  (x : A) -> B, A -> B, ({x} : A) -> BRtype-annotated term9below this, the constructors are only for concrete syntaxS!example-based term: @in M.C "foo"T record type: { p : A ; ...}U record: { p = a ; ...}V projection: r.pW extension:  R ** {x : A} (both types and terms)X table type: P => AY table: table {p => c ; ...}Z!table given as course of values: table T [c1 ; ... ; cn][ selection: t ! p\local definition: let {t : T = a} in b]!qualified constant from a package^$qualified constructor from a package_concatenation: s ++ t`agglutination: s + ta"pattern (in macro definition): # pbpattern type: pattern Tc!boxed linearization type of Identd!boxed linearization of type Idente&ad hoc overloading generated in Renamef alternatives in free variation: variants { s ; ... }galternatives by prefix: pre {t ; s/c ; ...}hconditioning prefix strings: strs {s ; ...}i%error values returned by Predef.errorn#the constructors are judgements in abstract syntax (ABS) resource (RES)concrete syntax (CNC)and indirection to module (INDIR)o(ABS) context of a categoryp(ABS+) type, arrity and definition of a functionq(RES5) the second parameter is list of all possible valuesr(RES+) to mark parameter constructors for lookups(RES)t(RES) idents: modules inheritedu(CNC) lindef ini'zed, v(CNC) type info added at TCw(INDIR) the ! says if canonicalencoding the type of the moduleModules;A grammar is a self-contained collection of grammar modulesinitial dependency listall dependenciesGselect just those modules that a given one depends on, including itselfIall modules that a module extends, directly or indirectly, with restricts the same as , plus that an instance extends its interface,we store the module type with the identifier=don't generate code for interfaces and for incomplete modules-interface and "incomplete M" are not complete8all abstract modules sorted from least to most dependent4the last abstract in dependency order (head of list)all resource modules)the greatest resource in dependency order"all concretes for a given abstract%all concrete modules for any abstract !"#$%&'()*+,- v./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ w x01234589:;t !"#$%&'()*+,-.089:/1234567;<=>?@ABCDfU_[]OVLXiYGINMEFHJKPQRSTWZ\^`abcdeghjklmnuvopqrstwxyz{|}~B !"#$%&'()*+,- v./0123456789:;<=>?@ABCD%EFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmn opqrstuvwxyz{|}~  w xdNone y z { | } ~  D y z { | } ~   y z { | } ~    eAR(stable) (portable)None     fNone   gKrasimir Angelov  (stable)  (portable) None:$      !      hAR(stable) (portable)None  default linearization type refreshing variables!trying to preserve a given symbol*quick hack for refining with var in editor%create a terminal for concrete syntax!create a terminal from identifier&to define compositional term functions&to define compositional term functions%;to gather ultimate cases in a table; preserves pattern list&Cto get a string from a term that represents a sequence of terminals'Vto print an Str-denoting term as a string; if the term is of wrong type, the error msg* to find the word items in a term.Hdependency check, detecting circularities and returning topo-sorted liste      !"#$%&'()*+,-./0e      !"#$%&'()*+,-./0e      !"#$%&'()*+,-./0iAR(stable) (portable)NoneU01234589:;rstuvwxyz{|}~  !"#$%&'()*+,-.089:/1234567;<=>?@ABCDfU_[]OVLXiYGINMEFHJKPQRSTWZ\^`abcdeghjklmnuvopqrstwxyz{|}~       !"#$%&'()*+,-./0jAR(stable) (portable)None   kAR(stable) (portable)None%    lNone   mAR(stable) (portable)None CEstimate the minimal length of the string that a pattern will match CEstimate the maximal length of the string that a pattern will match                   nAR(stable) (portable)None   oAR(stable) (portable)None returns the original n" and the module where it was found this is needed at compile time this is needed at compile time                  !              !                  !pAR(stable) (portable)None: " # $ % & ' ( ) * + $ % " # $ % & ' ( ) * +qNone , - . / 0 1 2 3 4 5 6 7 8 , 1 3 4 6 7 8 , - . / 0 1 2 3 4 5 6 7 8rNone 9 : ; < = > ? @ 9 : ; < = > ? @ 9 : ; < = > ? @sAR(stable) (portable)None6Was: ,newtype IOE a = IOE { appIOE :: IO (Err a) }?"extends the search path with the ; and <5 environment variables. Returns only existing paths.I$Catch exceptions caused by calls to  or  A in the  B monad. To catch all  B exceptions, use / instead.JGPrint the error message and return a default value if the IO operation  AsNRBecause GHC adds the confusing text "user error" for failures caused by calls to  A. C:Make raise and handle mimic behaviour of the old IOE monad%12345678#the directory portion of a pathname9:;<=>?@ABCDEFGHIJKLMNOPQR D E C%154236789:;<=>?@ABCDEFGHIJKLMNOPQR!123456789:;<=>?@ABCDEFGHIJKLMNOPQR D E CtKrasimir Angelov  (stable)  (portable) NoneX*Read just the module header, the returned  will have an empty body Flike U: but adds file name to error message if there was an error GgAdds file name to error message if there was an error, | but laziness can cause errors to slip through STUV H IWXY F G J K L M N O P Q R S T U V W X Y Z [ \ ] ^STUVWXYSTUV H IWXY F G J K L M N O P Q R S T U V W X Y Z [ \ ] ^None &'*()+,-./0123456789:;QRSTU     154236789:;<=>?@ABCDEFGHIJKLMNOPQR 6723450189:;     :987;<=>?@ABCDEFGH6IJKL12345MNOPQR./+,&'()*-QRSTUuNone _ ` a b c _ c _ ` a b cv (Maintainer)(stable) (portable)None dReport a fatal error e&warnings should be reversed in the end f%Report a nonfatal (accumulated) error g6Turn a fatal error into a nonfatal (accumulated) error h*Turn accumulated errors into a fatal error i.Run an error check, report errors and warnings j;Run an error check, report errors and (optionally) warnings klAugment error messages with a relative path to the source module and an contextual hint (which can be left 6) l m n o p q r s t u v w d x e y f g h i j z { | } k ~   l o v d x e y f g h i j z { | } k l m n o p q r s t u v w d x e y f g h i j z { | } k ~  wAR(stable) (portable)None Dthis gives top-level access to renaming term input in the cc command Avars not needed in env, since patterns always overshadow old vars   xAR(stable) (portable)None @combine a list of definitions into a balanced binary search tree Orebuilding instance + interface, and "with" modules, prior to renaming. AR 24102003 When extending a complete module: new information is inserted, and the process is interrupted if unification fails. If the extended module is incomplete, its judgements are just copied. @this is what happens when matching two values in the same module   yNone (light-weight substitution for dep. types .compositional check/infer of binary operations   zAR(stable) (portable)None ,invariant way of creating TCEnv from context   {None /023459:;<=?@ABDFIJKNOQRT                           ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~        !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ k                                ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~        !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ 9  9 |None  }AR(stable) (portable)NoneReturns a list of all files to be compiled in topological order i.e. the low level (leaf) modules are first. getAllFiles :: (MonadIO m,ErrorMonad m) => Options -> [InitPath] -> ModEnv -> FileName -> m [FullPath]5options can be passed to the compiler by comments in --#Z, in the main file getOptionsFromFile :: (MonadIO m,ErrorMonad m) => FilePath -> m OptionsSTUV~AR(stable) (portable)NoneZWRead a source file and parse it (after applying preprocessors specified in the options)Z[\Z[\ Z[\None:None!    !         None 8macro definition applications: replace ?i by (exps !! i)return the trees to be sent in pipe, and the output possibly printed interpret :: CommandEnv -> [Expr] -> Command -> SIO CommandOutputLanalyse command parse tree to a uniform datastructure, normalizing comm name    None !" !" !"None#$%&'()*+,-./012'( #$%&'()*+,-./012None3456789:;<=>?@ABCDE3453456789:;<=>?@ABCDENone FGHIJKLMNGHK FGHIJKLMNNoneOPredefined functionsP%Show | Read | ToStr | MapStr | EqVal Q3Self-contained (not quite) representation of values<ORSTUVWXYZ[\]^_P`abcdefghijklmnopQqrstuvwxyz{|}~;OdPR`ghijk\STUVWXYZ[]^_abceflmnopQsq}t{wruvxyz|~ORSTUVWXYZ[\]^_P`abcdefghijklmnopQqrstuvwxyz{|}~None9;None9Convert operators once, not every time they are looked up?Insert a call to the trace function under the top-level lambdas'Computing the value of a top-level termComputing the value of a termDto get a string from a value that represents a sequence of terminalsConvert a value back to a termC&lmnQsq}t{wruvxyz|~<11NonetGenerate Haskell code for the all concrete syntaxes associated with the named abstract syntax in given the grammar.cGenerate Haskell code for the given concrete module. The only options that make a difference are -haskell=noprefix and -haskell=variants.AR(stable) (portable)NoneJpartial evaluation of concrete syntax. AR 6/2001 -- 16/5/2003 -- 5/2/2005..the main function for compiling linearizations&auxiliaries for compiling the resource  Krasimir Angelov(stable) (portable)None9;<=OTThe ProtoFCat represents a linearization type as term schema. The annotations are as follows: the strings are annotated with their index in the PMCFG tuple, the parameters are annotated with their value both as term and as index.Path into a term or term schema Term schemabacktracking for all variants@backtracking for all parameter values that a variable could take[the argument should be a parameter type and then the function returns all possible values.G      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHI!$9      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHINone J]Invariant: if the third argument is (Just rho), then rho is in weak-prenex formK5Invariant: the second argument is in weak-prenex formL*Invariant: tv1 is a flexible type variableM=Instantiate the topmost implicit arguments with metavariablesNBBuild fresh lambda abstractions for the topmost implicit argumentsO9Quantify over the specified type variables (all flexible)PiThis function takes account of zonking, and returns a set (no duplicates) of unbound meta-type variablesQaThis function takes account of zonking, and returns a set (no duplicates) of free type variablesR%Eliminate any substitutions in a term?STUVWXYZ[\]^_`abcdefghijklmnopqrJKstuvwLMNOxyz{|}~PQRab9STUVWXYZ[\]^_`abcdefghijklmnopqrJKstuvwLMNOxyz{|}~PQRAR(stable) (portable)None8checking is performed in the dependency order of moduleslGeneral Principle: only Just-values are checked. A May-value has always been checked in its origin module.=for grammars obtained otherwise than by parsing ---- update!! linearization types and defaultsNone_ACompile a given source file (or just load a .gfo file), given a - containing everything it depends on. Calls ` or a.``Read a compiled GF module. Also undo common subexp optimization, to enable normal computations.aNCompile GF module from source. It both returns the result and stores it in a .gfo, file (or a tags file, if running with the -tags option) ]^_`a]^_`a ]^_`aNonebECompile the given grammar files and everything they depend on, like  batchCompileL. This function compiles modules in parallel. It keeps modules compiled in present and  alltenses mode apart, storing the .gfo files in separate subdirectories to avoid creating the broken PGF files that can result from mixing different modes in the same concrete syntax.The first argument controls the number of jobs to run in parallel. This works if GF was compiled with GHC>=7.6, otherwise you have to use the GHC run-time flag  +RTS -N -RTS to enable parallelism.bbb Aarne Ranta(stable) (portable)Nonethe main function-Gets the element category of a list category. Module name.Peter LjunglfNone&#NoneNone          Peter LjunglfNone: ! !None"#$%Concrete syntax name#%"#$%None&the main function'(&)*+,-./0123456789:;<=>?@A&'(&)*+,-./0123456789:;<=>?@ANoneBCDEFGHIJKLMNOPBBCDEFGHIJKLMNOPNone:QRSTUVWXYZ[\]^QQRSTUVWXYZ[\]^None_The environmentc/Compiles a number of source files and builds a / structure for them. This is a composition of d and f.dLink a grammar into a  that can be used to  and  with the PGF run-time system.eRReturns the name of the abstract syntax corresponding to the named concrete syntaxf_Compile the given grammar files and everything they depend on. Compiled modules are stored in .gfo files (unless the -tagsL option is used, in which case tags files are produced instead). Existing .gfo= files are reused if they are up-to-date (unless the option -src aka  -force-recomp is used).`compile with one module as starting point command-line options override options (marked by --#) in the file As for path: if it is read from file, the file path is prepended to each name. If from command line, it is used as it is. _cdef`4Options from program command line and shell command.abccdef _cdef`abcNonedefgdfdefgNone9:;hIf the Monad m superclass is included, then the generic instance for monad transformers below would require UndecidableInstancesi Run normallyj Redirect k to the given handlelCapture k!hmnopqijlrstuvwxyz{|}~hmnijlrswyz{|}~hmnopqijlrstuvwxyz{|}~NoneNoneNoneThe make_fa algorithm from "Regular approximation of CFLs: a grammatical view", Mark-Jan Nederhof, Advances in Probabilistic and other Parsing Technologies, 2000.,Build a DFA by building and expanding an MFA Sort sub-networks topologically.Convert a strongly regular grammar to a number of finite automata, one for each non-terminal. The edges in the automata accept tokens, or name another automaton to use.=The make_fa algorithm from "Regular approximation of CFLs: a grammatical view", Mark-Jan Nederhof, Advances in Probabilistic and other Parsing Technologies, 2000, adapted to build a finite automaton for a single (mutually recursive) set only. Categories not in the set will result in category-labelled edges.Add a state for the given NFA for each of the categories in the given set. Returns a map of categories to their corresponding states.*A map of non-terminals and their automata.VThe set of (mutually recursive) categories for which we are building the automaton.State to come fromSymbols to acceptState to end up in FA to add to. hNoneAAn SRG non-terminal. Category name and its number in the profile.<maybe a probability, a rule name and an EBNF right-hand side grammar namestart category name>The language for which the grammar is intended, e.g. en-UK2Create a compact filtered non-left-recursive SRG. zRenames all external cats C to C_cat, and all internal cats C_X (where X is any string), to C_N where N is an integer.VMerges a list of right-hand sides which all have the same sequence of non-terminals.Concrete syntax name. XNone  None BB(stable) (portable)NoneNone rootlanguage   None         None:+An SLF word is a word, or the empty string.&Make a network with subnetworks in SLF@Check if a word should not correspond to a word in the SLF file.' !"#$%&'()*+,-./0123456789:;<=>013 !"#$%&$'()*+,-./0123456789:;<=>None?@AB?@?@ABNonegExport a PGF to the given '. For many output formats, additional # can be used to control the output.CnGet the name of the concrete syntax to generate output from. FIXME: there should be an option to change this.g,List of recommended file names and contents.CgCgCNoneh>Compile the given GF grammar files. The result is a number of .gfo) files and, depending on the options, a .pgf file. ( gf-batch, gf-make)i Create a .pgfA file (and possibly files in other formats, if specified in the ) from the output of b. If a .pgfj file by the same name already exists and it is newer than the source grammar files (as indicated by the UTCTime( argument), it is not recreated. Calls k and j.jExport the PGF to the s specified in the  . Calls g.k3Write the result of compiling a grammar (e.g. with  compileToPGF or d) to a .pgf* file. A split PGF file is output if the  -split-pgf option is used.hDiEFjkGHIJKLMhijkhDiEFjkGHIJKLMNone9;N/the maximal number of precompiled quiz problemsOPQRSTUVWXYZN[\]^_`abc OPQTSUVOPQRSTUVWXYZN[\]^_`abcNonedefghijklmnopqrstuvwxyz{|}dgefhijklmnopqrstuvwxyz{|}defghijklmnopqrstuvwxyz{|}None~ Handler monad Combined FastCGI and HTTP serverHTTP request handler6Check that a path is not outside the current directory'Only delete files with these extensions;Remove a directory and the files in it, but not recursively4~4~1None9;T l Run the GF Shell in quiet mode (gf-run).mRun the interactive GF ShellnRun the GF Server ( gf-server). The 2 argument is the port number for the HTTP service.2Read end execute commands until it is time to quit(Read and execute one command, returning  to continue execution, |  when it is time to quitRead a command>Optionally show how much CPU time was used to run an IO action(Execute a given command line, returning  to continue execution, |  when it is time to quit>Execute a given command line, without adding it to the history(Execute a given command line, returning  to continue execution, |  when it is time to quitCommands that work on +lmnlmn!lmnNoneoLRun the GF main program, taking arguments from the command line. (It calls + and p, then q.) Run  gf --help for usage info.pDGet and parse GF command line arguments. Fix relative paths. Calls  and .q_Run the GF main program with the given options and files. Depending on the options it invokes h, mainGFI,  mainRunGFI,  mainServerGFI(, or it just prints version/usage info.opqopqopqNonec01234589:;rstuvwxyz{|}~ !"#$%&'()*+,-.089:/1234567;<=>?@ABCDfU_[]OVLXiYGINMEFHJKPQRSTWZ\^`abcdeghjklmnuvopqrstwxyz{|}~      !"#$%&'()*+,-./0STUVWXYZ[\]^_`abcdefghijklmnopqfopqmlnhikjcdfebg^]_`aZ[\t|}~nopqrstuvwDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghimlkj./0123456789:;<=>?@ABC)*+,-&'(%$#"! 23450189:;xyz{      !"#$%&'()*+,-./0tuvs|~rwx}z{ySTUVXWY$$$$$&&&&&&&&'')M)M))))))))))      !"#$%&'()*+,-./0123456789:/;/</=/>/?/@/A/B/C/D/E/F/G/H/I/J/K/L/M/N/O/P/Q/R/S/T//U/V/W/X/Y/Z/[/\/]/^/_/`/a/b/c/d/e/f/g/h/i/j/k/l/m/n/o/p4q4r4s4t4u4v4w4x7y7z7{7|6}6~66666667777777777777777788888888889999999:::::;;;;;;;;;;;;;;>>>>>>>>???????????????????????@@@@@@@@AAAAAAAAACCCCCCCCCCCCCCCCCCGRRRRR     ^^^^^^^ ^!^"^#^$^%^&^'^(^)^*^+^,^-^.^/^0^1^2^3^4b5b6b6b7b8b9b:b;b<b=b>b?b@bAbBbCbDbEbFbGbHbIbJbKbLbMbNbObPbQbRbSbTbUbVbWbXbYbZb[b\b]b^b_b`babbbcbdbebfbgbhbibibjbkblbmbnbobpbqbrbsbtbubvbwbxbybzb{b|b}b~bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbcccccccccc}ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc c c c c cccc~cccccccccccccccccc c!c"c#c$c%c&c'c(c)c*c+c,c-c.c/c0c1c2c3c4c5c6c7c8c9c:c;c<c=c>c?c@cAcBcCcDcEcFcGcHcIcJcKcLcMcNcOcPcQcRcScTcUcVcWcXcYcZc[c\c]c^c_g`gagbgcgdgegfggghgigjgkglhmhnhohphqhrhshthuhvhwhxhyhzh{h|h}hhh~hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhssssssssssssssssssssssssssssssssssttttttt~~~                              ! "   # $ % % & ' ( = = ) @ * + ~   , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ?   @ A B C D  E F G H I J K L M N O P QRSTUVWXYZ[\]^_`abccdefghijklmnopqrstuvwxyz{|}~|      !"#$%&'()*+,-./01234566789:;<=>?@ABCDEFEGHIJK L M N O P Q R S T UVWXVWYVWZVW[VW\VW]VW^VW_VW`VWaVWbVWcVWdVWeVWfVWgVWhVWiVWjVWkVWlVWmVWnVWoVWpVWqVWrVWsVWtVWuVWvVWwVWxVWyVWzVW{VW|VW}VW~VWVWVWVWV!!!!!!!!!!!!!"####^$$$$$%%%%%%%%%%%%%%%%%%_%&&()))^*****---------^-------------------------------................. . . . . ..............//0c0 0a0a0b0b0!0"0#0c0$0%0&0'0(0)0*0+0,0-0.0/000102030405060708091:1;1<1=1>1?1@1A1B1C1D1E1F1G1:1H1I11J1K1L1M1N1O1P1Q1R1S1T1U1V1W1X1Y1Z1[1\1]1^1_1`1a1b1c1d1e2 2f2g2h2i2j2k22l2m2n2o2p2q2r2s3t3u3v3w3x3y3z3{3|3}3~3333333333333333^4q44444455555555555555555555555555555555555555555666666777777777777777777777777777777777777777777g7777777788(8'8888888888888888888888888888888888 8 8 8 8 8 8888*8+88888888899999999 9!9"9#9$9%9&9'9(9)9*9+9,9-9.9/909192939s9r9o94959h969798999:9;9<9=:>:?;@;A;B;C;;D;D;E;F;G;H;I;J;K;K;L;M;N;O;P;Q;R;S;T;U;V;W;X;Y;Z;[;\;];^;_;`;a;b;c;d;e;f;g;h;i;j;k;l;m;n;o;p;;;;;q;r;s;t;u;v;w>x>y>z>{>|23}?~???????????<???????k????????????? ??????????????????????????????????@@@@@@@@@@@AAAABBBBBBBBBBBBCCCCCCCCCCCCCCCCCCCCCCC CCCCCCCCCCCCDDDDDDDEEEEEEEEEEEEEEEEEEE E FFF FF FF FFGGGGGGGGGHHHHHH !"#$%&'()*)+)),-,.,/,I01010203040505060708090:0;<=><=><=?<=@<=A<=B<=B<=CJDJDJEJFJGJHJIJJJKJLJMJNJOJPJQJRJSJTJUJVK5K5KWKXKYKZK[K\L]^_`LaL^bL^bLc^bcLd^e`^bfLgLhLiLjLkLlLmLnLoLpLqLrLsLtLuLvLwLxLyLyL]LzL{L|L}L~LLLLOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOPPPPPPhPPPPoPpPqPrPsPtPuPvPwPxPPPPPPPPPPQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQRRRRRRRRRRRRRRRRRRRRRRRRRR R R R R R R R R R R R R R R R R R R R R R 23               SS S S !S "S #S $S %S &S 'S (S )S *S +S ,S -S .S /S 0S 1S 2S 3S 4S 5S 6S 7S 8S 9S :S ;S <S =S >S ?S @S AS BS CTT T T "T DT ET 9T FT GT CT HT IT JT KT LT MT NT OT PT QT RT ST TT UT VT WU XU YU ZU [U \U ]U ^UUU _U `U aU bU cU dU eU fU gU hU iU jU kU lU mU nU oU pU qUU rU sU tU uU=U=U vU wU xU yU yU zU {U |UU }U ~UU U U U U U U U U U U U U U U U U U U U U U U V V V V V V V V V V V {V |V V V V V V V V V V V V V V V V V W W W W W W W W W W W W WW W W W W W W W W W W W W W W W W W W X X X X X X X X X X Y Y Y Y Y Y Y Z Z Z [ [ [ [ [ [ [ [ [ [[ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [1[ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ ![ "[ #[ $[ %[ &[ '[ ([ )[ *[ +[ ,[ -[ .[ /[ 0[ 1[0[ 2[ 3[ 4[ 5[ 6[ 7[ 8\ 9\\ :\ ;\ <\ =\ >\ ?\ @\ @\ A\ ,\ B\ C\ D\ E\ F\*\ G\ H\ I\ J\ K\ L\ M\ N\ O\ P\ Q\ )\ R\ S\ T\ U\ V\ W\ X^ Y^ Z^ [^ \^ ]^-^ ^^ _^ `^ a^ b^ c^ d^ e_ f_ g_ f_ h_ i_ j_ i_ k_ l_ m_ n_ o_ p_ q_ r___ s_ t_ u_ v_ w_ x_ y_ z_ {__ |_ }_ ~_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ `_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` !` "` #` $` %` &` '` (a )a *a +a ,a -a .a /a 0a 1a a 2a 3a 4a a 4aa 5a 6a 7a 8a 9a :a ;aa <aa =a >a -aka~aga ?a @a Aa Ba Ca Da Ea Fa Ga Ha Ia Ja Ka La Ma Na Oa Pa Qa Ra Sa Tb Ub5b Vb Wb Xb Yb Zb [b \b ]b ^b _b `b abb bb cb db eb fbb gb hb ib jb kc lc mc nd od pd qd rd sdd td ud vdd wd xd yd yd zd {dd |d }d ~d d d d d d d d e e e ee eee e e e e e e e e f f f f f f f f f f f f f f g g g g gg g g g g gg g gg g g g g g g g g j j j j j j j j j j j k k k k k k k k k k k k k k k k k k k k k k k@k kkk kk k k k k k k k k l l m m m m m m m m m m m m m m n n n n n o oUo o o o o o o o o o o o o o o o o p p p p p p p p p p q q q q q q q q q q q q q r r r !r "r #r $r %r &^ '23 (s )s *s +t ,t -t .t /t Ct 0t 1t 2t 3t Rt 4t 5t 6t 7t 8t It 9t :t ;t <t =t >t ?t @t Au Bu Cu Du Eu Fv Gv Hv Iv Jv Kv Lv Mv Nv Ov Ov Pv Qv Rv Sv Tv Uv Vv v Vv Wv Xv Yv Zv [v \v ]v ^v _v `v aw bw cw dw ew fw gw hw iw jw kw lw mw nw ow pw qx rx sx tx ux vx wx xx yx zy {y |y }y ~y y y y y y yy z z z z z z z z z z z { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { !{ "{ #{ ${ %{ &{ '{ ({ ){ *{ +{ ,{ -{ .{ /{ 0{ 1{ 2{ 3{ 4{ 5{ 6{ 7{ 8{ 9{ :{ ;{ <{ ={ >{ ?{ @{ A{ B{ C{ D{ E{ F{ G{ H{ I{ J{ K{ L{ M{ N{ O{ P{ Q{ R{ S{ T{ U{ V{ W{ X{ Y{ Z{ [{ \{ ]{ ^{ _{ `{ a{ b{ c{ d{ e{ f{ g{ h{ i{ j{ k{ l{ m{ n{ o{ p{ q{ r{ s{ t{ u{ v{ w{ x{ y{ z{ {{ |{ }{ ~{ { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { {{{{{{{{{{ { { { { {{{{{{{{{{{{{{{{{{{ {!{"{#{${%{&{'{({){*{+{,{-{.{/{0{1{2{3{4{5{6{7{8{9{:{;{<{={>{?{@{A{B{C{D{E{F{G{H{I{J{K{L{M{N{O{P{Q{R{S{T{U{V{W{X{Y{Z{[{\{]{^{_{`{a{b{c{d{e{f{g{h{i{j{k{l{m{n{o{p{q{r{s{t{u{v{w{x{y{z{{{|{}{~{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{ { { { { {{{{{{{{{{{{{{{{{{{ {!{"{#{${%{&{'{({){*{+{,{-{.{/{0{1{2{3{4{5{6{7{8{9{:{;{<{={>{?{@{A{B{C{D{E{F{G{H{I{J{K{L{M{N{O{P{Q{R{S{T{U{V{W{X{Y{Z{[{\{]{^{_{`{a{b{c{d{e{f{g{h{i{j{k{l{m{n{o{p{q{r{s{t{u{v{w{x{y{z{{{|{}{~{{{{{{{{{{{{{{{{{{{{{{{{{{|||||||||||}}}0}}}}}}}g}}}}}}}}}}~~a~~c~~~~~~~~~      # 5 6 .  !"#$%&'()*+,-./0123345678 u9:;< =>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrst uvwxyz{|}~ 2z:DDEJFK ~      SXZ[ PQ!"#qwv$%&'()*+,-./012334556789:;< D=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~vVARL        !""#$%&'()*+,-./0123456789:;<=>?7@@AABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdevfghRijklWUV4mno[p\qrs|tuYvwoxRyzWUV4Zmn[p\{|}~4 [ 5=023023      !"#$%&'()*+,-gf-3.8-JALltykdXQs32L0AVVDYEJ GF.SupportGF.Text.Pretty PGF.HaskellPGF.LexingAGreek PGF.Lexing PGF.UtilitiesPGFGFSimpleEditor.SyntaxSimpleEditor.JSONCache URLEncodingGF.System.UseSignal GF.Data.GraphGF.Compile.TypeCheck.ConcreteGF.Text.CodingGF.JavaScript.AbsJSGF.JavaScript.PrintJSGF.Data.BacktrackM GF.Compile.Compute.AppPredefinedGF.Compile.Multi GF.Data.StrGF.Text.TransliterationsGF.Text.CliticsDarcsVersion_gfGF.Infra.GetOptSystem.EnvironmentgetArgsGF.System.ConcurrencyGF.Infra.ConcurrencyGF.System.SignalGF.System.DirectoryPaths_gfGF.Infra.BuildInfoGF.Command.Messages GF.Data.ErrM PGF.TrieMapGF.System.ConsoleGF.System.CatchGF.System.ProcessGF.Infra.LocationGF.Text.Lexing Data.ListnubGF.Data.UtilitiesGF.Data.RelationGF.Data.OperationsGF.Data.GraphvizGF.Speech.FiniteState GF.Data.XMLGF.Speech.RegExpPGF.CId PGF.ByteCodePGF.TypePGF.ExprPGF.Data PGF.Macros PGF.Linearize PGF.TypeCheckText PrettyPrint PGF.GeneratePGF.VisualizeTreePGF.ProbabilisticPGF.Morphology PGF.Forest PGF.Parse PGF.Optimize PGF.PrinterPGF.TreePGF.Paraphrase PGF.SortTopCGICGIUtilsRunHTTPData.Binary.BuilderL BytestringData.Binary.GetData.Binary.PutData.Binary.IEEE754 Data.Binary PGF.OldBinary PGF.BinaryGF.Grammar.CFGGF.Grammar.BNFCGF.Grammar.EBNFGF.Compile.ExampleBasedGF.QuizFold PGFService ExampleDemo PGF.InternalGF.Infra.IdentGF.Grammar.LexerGF.Grammar.Predef GF.HaskellGF.Infra.OptionGF.Grammar.GrammarGF.Command.AbstractGF.Grammar.ValuesGF.Infra.DependenciesGF.Grammar.PrinterGF.Grammar.Macros GF.GrammarGF.Grammar.UnifyGF.Compile.TypeCheck.TCGF.Compile.TypeCheck.PrimitivesGF.Grammar.PatternMatchGF.Grammar.LockfieldGF.Grammar.LookupGF.Compile.SubExOptGF.Grammar.AnalyseGF.Grammar.ShowTermGF.Infra.UseIOGF.Grammar.BinaryGF.Compile.TagsGF.Infra.CheckMGF.Compile.RenameGF.Compile.UpdateGF.Compile.TypeCheck.RConcreteGF.Compile.TypeCheck.AbstractGF.Grammar.ParserGF.Command.ParseGF.Compile.ReadFilesGF.Compile.GetGrammarGF.Compile.CFGtoPGFGF.Command.CommandInfoGF.Command.InterpreterGF.Command.HelpGF.Compile.ToAPIExampleServiceGF.Command.TreeOperationsGF.Compile.Compute.ValueGF.Compile.Compute.PredefGF.Compile.Compute.ConcreteNewGF.Compile.ConcreteToHaskellGF.Compile.OptimizeGF.Compile.GeneratePMCFG GF.Compile.TypeCheck.ConcreteNewGF.Compile.CheckGrammar GF.CompileOneGF.CompileInParallelGF.Compile.PGFtoHaskellGF.Compile.PGFtoPrologGF.Compile.PGFtoLPrologGF.Compile.PGFtoJSGF.Compile.PGFtoPythonGF.Speech.PGFToCFGGF.Speech.VoiceXMLGF.Compile.GenerateBCGF.Compile.GrammarToPGF GF.Compile linearizeparseGF.Command.Importing GF.Infra.SIOGF.Command.CommonCommandsGF.Command.SourceCommandsGF.Speech.CFGToFA GF.Speech.SRG GF.Speech.GSLGF.Speech.SISRGF.Speech.SRGS_ABNFGF.Speech.SRGS_XMLGF.Speech.JSGF GF.Speech.SLFGF.Speech.PrRegExpGF.Compile.Export GF.CompilerGF.Command.CommandsSimpleEditor.Convert GF.ServerGF.InteractiveGF.MainbaseControl.Monad.IO.ClassliftIOMonadIOErrOkBaderrfromErrPrettyppppListrender renderStyle$$$+$<+><>bracesbracketscat doubleQuotesfcatfsephanghcathsepnestparens punctuatequotessepvcat $fPretty[] $fPrettyChar$fPrettyDouble $fPrettyFloat$fPrettyInteger $fPrettyInt $fPrettyDoc TermColorsredFgblueFgrestoresetConsoleEncodingchangeConsoleEncoding getTermColorscatchtryLocationNoLocLocalExternal HasSourcePath sourcePathunLocnoLoc ppLocationppLR_sHas_sproj_sPrefixTokTKTPBIND SOFT_BIND SOFT_SPACECAPIT ALL_CAPITStrEnumAllenumAlltablefromStrto_R_s+++!!$!* $fHas_sR_st $fEnumAllR_s$fEqTok$fOrdTok $fShowTok$fEqR_s$fOrdR_s $fShowR_s lexTextAGreeklexTextAGreek2unlexTextAGreek isAGreekPunct lexAGreek lexAGreek2 unlexAGreek normalize fromAGreek denormalizetoAGreektoGravetoAcute isAGreekVowel enclitics proclitics isEnclitic isProclitic wasEnclitic wasProclitic getEnclitic getProclitic dropAccentdropLastAccentaddAcute hasEndAcute hasEndCircumhasPrefinalAcutehasSingleAccent hasAccentenclitics_explslexTextlexText' unlexTextbindToklexCode unlexCode lexLatexCodelexMixed unlexMixed capitInit uncapitInitunquoteisPunct isMajorPunct isMinorPunctisParen isClosingnub'replace ErrorMonadraisehandlehandle_BinTreeifNullmaybeErrtestErrerrIn lookupErr mapPairListM mapPairsMpairM checkUnique unifyMaybe unifyMaybeBy emptyBinTree isInBinTree lookupTreelookupTreeManyAll updateTree buildTreemapTree filterBinTree tree2listindent++-+++++++-+++++prUpper prReplicateprTListprQuotedString prParenthprCurly prBracket prArgList prSemicList prCurlyListrestoreEscapesnumberedParagraphs prConjList prIfEmpty wrapLines combinationstopoTest topoTest2iterFixchunks readIntArgdoneliftErrchecksCIdwildCIdmkCIdutf8CIdreadCIdshowCIdpIdentppCIdBindTypeExplicitImplicitExprHypoTypereadTypeshowTypemkTypemkHypo mkDepHypo mkImplHypounTypeTreereadExprshowExprmkAbsunAbsmkAppunAppmkStrunStrmkIntunIntmkDoubleunDoublemkMetaunMetapExprppMetaLanguageSeqIdFunIdSequenceLIndexFIdToken readLanguage showLanguageBracketedStringLeafBracket missingLins showPrintNameshowBracketedStringflattenBracketedString linearizeAlllinearizeAllLangbracketedLinearizetabularLinearizesTcError UnknownCat UnknownFun WrongCatArgs TypeMismatch NotFunTypeCannotInferTypeUnresolvedMetaVarsUnexpectedImplArgUnsolvableGoal ppTcError checkType checkExpr inferExpr generateAllgenerateAllDepth generateFromgenerateFromDepthgenerateRandomgenerateRandomDepthgenerateRandomFromgenerateRandomFromDepthLabelsGraphvizOptionsnoLeavesnoFunnoCatnoDepnodeFontleafFont nodeColor leafColor nodeEdgeStyle leafEdgeStylegraphvizDefaultsgraphvizAbstractTreegraphvizDependencyTree getDepLabelsgraphvizParseTreegraphvizParseTreeDepgraphvizBracketedString gizaAlignmentgraphvizAlignmentconlls2latexDoc ProbabilitiesshowProbabilitiesreadProbabilitiesFromFilemkProbabilitiesdefaultProbabilitiessetProbabilitiesprobTreerankTreesByProbsMorphoAnalysisLemma buildMorpho lookupMorpho isInMorphofullFormLexicon morphoMissing morphoKnown ParseState ParseOutput ParseFailed TypeErrorParseOkParseIncomplete ParseInputpiToken piLiteral initStatesimpleParseInput mkParseInput nextStategetCompletionsrecoveryStatesgetParseOutputgetContinuationInfo paraphraseBinaryencodedecode encodeFile decodeFileTrieOthApATreeOtherAppreadPGFparseAll parseAllLangparse_parseWithRecovery groupResults abstractName languages languageCode categoriescategoryContextstartCat functionsfunctionsByCat functionTypecomputebrowsetoATreetoTrie $fShowATree $fShowTrieRawIdentIdent ModuleNameMN moduleNameS rawIdentS rawIdentC showRawIdentprefixRawIdent isPrefixOf ident2utf8 ident2raw showIdentidentS prefixIdentidentCidentVidentAidentAVidentWargIdent isArgIdent getArgIndexvarStrvarX isWildIdentvarIndexOptionsFlagsoptModeoptStopAfterPhase optVerbosityoptShowCPUTimeoptOutputFormatsoptSISRoptHaskellOptionsoptLexicalCatsoptLiteralCats optGFODir optOutputDir optGFLibPathoptDocumentRoot optRecomp optProbsFileoptRetainResourceoptNameoptPreprocessors optEncodingoptPMCFGoptOptimizationsoptOptimizePGF optSplitPGFoptCFGTransformsoptLibraryPath optStartCatoptSpeechLanguageoptLexer optUnlexer optWarningsoptDump optTagsOnlyoptHeuristicFactoroptCaseSensitive optPlusAsBindoptJobsoptTraceRecomp AlwaysRecomp RecompIfNewer NeverRecompPassSourceRebuildExtendRename TypeCheckRefreshOptimizeCanonDump HaskellOptionHaskellNoPrefix HaskellGADTHaskellLexicalHaskellConcreteHaskellVariants CFGTransformCFGNoLR CFGRegularCFGTopDownFilterCFGBottomUpFilterCFGStartCatOnlyCFGMergeIdenticalCFGRemoveCycles OptimizationOptStemOptCSE OptExpandOptParametrize SISRFormatSISR_WD20030401SISR_1_0 OutputFormat FmtPGFPretty FmtJavaScript FmtPython FmtHaskell FmtPrologFmtLambdaProlog FmtByteCodeFmtBNFFmtEBNF FmtRegularFmtNoLR FmtSRGS_XMLFmtSRGS_XML_NonRec FmtSRGS_ABNFFmtSRGS_ABNF_NonRecFmtJSGFFmtGSL FmtVoiceXMLFmtSLF FmtRegExpFmtFAPhasePreprocConvertCompileLink VerbosityQuietNormalVerboseDebugMode ModeVersionModeHelpModeInteractiveModeRunModeInteractive2ModeRun2 ModeCompiler ModeServer helpMessage parseOptionsparseModuleOptionsfixRelativeLibPaths optionsGFO optionsPGFflag addOptions noOptions concatOptions modifyFlags getEncodingdefaultEncodingoutputFormatsExplrenameEncodingreadOutputFormat verbAtLeastdump cfgTransform haskellOption isLiteralCat isLexicalCatsetOptimizationsetCFGTransform SubstitutionAlternParamLocalDefCaseAssign LabellingEquationContextMetaIdLabelLIdentLVarTInfoTRawTTypedTCompTWildPattPCPPPVPWPRPStringPIntPFloatPTPAsPImplArgPTildePNegPAltPSeqPMSeqPRepPCharPCharsPMacroPMTermVrCnConSortEIntEFloatKEmptyAbsMetaImplArgProdTypedExampleRecTypeRPExtRTableTVSLetQQCCGlueEPatt EPattTypeELincatELin AdHocOverloadFVAltsStrsErrorQIdentFunCatInfoAbsCatAbsFunResParamResValueResOper ResOverloadCncCatCncFunAnyIndPMCFG Production ModuleStatus MSComplete MSIncompleteOpenSpecOSimpleOQualifMIncludeMIAllMIOnlyMIExcept ModuleType MTAbstract MTResource MTConcrete MTInterface MTInstance SourceModInfo SourceModule SourceGrammar ModuleInfoModInfomtypemstatusmflagsmextendmwithmopensmexdepsmsrcmseqsjmentsModuleGrammar moduleMapmodulesextends isInherited inheritAll openedModule depPathModule allDepsModule partOfGrammar allExtendsallExtendsPlus prependModule emptyGrammarmGrammarabstractOfConcrete lookupModuleisModAbsisModResisModCnc sameMTypeisCompilableModuleisCompleteModule allAbstractsgreatestAbstract allResourcesgreatestResource allConcretesallConcreteModulesvarLabel tupleLabellinLabel theLinLabel ident2label label2ident TermPrintQual Unqualified QualifiedInternalppModule ppJudgementppTermppPattppValue ppConstrsppQIdentppParamsgetAbstypeForm typeFormCncvalCatvalType valTypeCnc typeSkeleton catSkeleton funsToAndFromisRecursiveTypeisHigherOrderType contextOfTypetermForm termFormCncappForm mkProdSimplemkProdmkTermappConsmkLet mkLetUntyped isVariableuTypeassignassignTunzipRmkAssign projectRec zipAssign mapAssignM mkRecordNmkRecord mkRecTypeN mkRecType record2substtypeType typePTypetypeStrtypeToktypeStrs typeStringtypeInt typeFloattypeInts typePBool typeError isTypeIntsisPredefConstantcheckPredefErrorcnPredef mkSelectsmkTablemkCTable eqStrIdent tuple2recordtuple2recordTypetuple2recordPattmkCases mkWildCases mkFunType plusRecType plusRecord defLinType mkFreshVar mkFreshVarX maxVarIndex mkFreshVars freshAsTerm string2termint2term float2termident2terminal symbolOfIdentsymid justIdentOf linTypeStrlinAsStr term2patt patt2term composSafeOpcomposOpcomposSafePattOp composPattOp collectOp mconcatMap collectPattOp redirectTerm allCaseValues strsFromTermstringFromTerm getTableTypechangeTableType wordsInTermnoExistdefaultLinTypesortRecallDependenciestopoSortJmentstopoSortJments2OutputePutStr ePutStrLnputStrE putStrLnEIOEFullPathInitPathFileName putIfVerb gfLibraryPathgfGrammarPathVargetLibraryDirectorygetGrammarPath extendPathEnv getSubdirsjustModuleNameisGFisGFOgfFilegfoFilegf2gfogf2gfo'splitInModuleSearchPathtryIOEuseIOEmaybeIOdie putPointE ioErrorTexttimeIt writeUTF8FilereadBinaryFilewriteBinaryFile VersionTaggedTagged WrongVersionunV decodeModuledecodeModuleHeader encodeModulegetSourceModule getBNFCRules getEBNFRulesCompiledModule OneOutput compileOnereuseGFO useTheSourceparallelBatchCompile compileToPGFlink srcAbsName batchCompile exportPGFmainGFC linkGrammars writeOutputswritePGF mainRunGFImainGFI mainServerGFImain getOptionsmainOptsLhsLinfunargslinOperonameorhsLincatlintypepnameprhsConcretelangcodeopensparamslincatsoperslinsfnameftypeAbstractstartcatcatsfunsbasenameabstract concretesModIdId signature definition.= $fJSONLin $fJSONLincat$fJSONConcrete $fJSONOper $fJSONParam $fJSONFun$fJSONAbstract $fJSONGrammarnewCache flushCache expireCache listCache readCache readCache'FileInfo cacheLoad cacheObjectsfst3urlDecodeUnicode decodeQueryQueryabothfromhex4fromhex2unfoldrchopListbreakAtrunInterruptiblyrunInterruptibly_blockInterruptmyInstallHandlermyCatchmyIgnorenewGraphnodesedgesnmapemapnewNode removeNode removeNodesnodeInfo mergeGraphs renameNodesmap'GHC.BasemapNodeInfoEdgeNodeGraphnewNodesnewEdgenewEdgesinsertEdgeWith groupEdgesBy lookupNode getIncoming getOutgoinginDegree outDegree getNodeLabel nodeLabeledgeFromedgeTo edgeLabel reverseGraph encodeUnicode decodeUnicodedecodeUnicodeIOioe_invalidCharacter1ioe_invalidCharacter2 PropertyName IdentPropNameStringPropName IntPropNamePropertyPropEAssignENewEMemberEIndexECallEVarEDblEStrETrueEFalseENullEThisEFunEArrayEObjESeqDeclVarDVarDInit DeclOrExprDeclDExprStmt SCompound SReturnVoidSReturn SDeclOrExprElementFunDefElStmtProgramPrintprtprtListDoc printTreedoc spaceAfter spaceBeforeparenthconcatSconcatDmkEscprPrec$fPrintPropertyName$fPrintProperty $fPrintExpr$fPrintDeclVar$fPrintDeclOrExpr $fPrintStmt$fPrintElement$fPrintProgram $fPrintIdent $fPrintDouble $fPrintInt $fPrintChar $fPrint[] BacktrackMBMrunBMfoldBM foldSolutions solutionsfoldFinalStates finalStatesmembercut$fMonadStatesBacktrackM$fMonadPlusBacktrackM$fAlternativeBacktrackM$fFunctorBacktrackM$fMonadBacktrackM$fApplicativeBacktrackM mtl-2.2.1-6qsR1PHUy5lL47Hpoa4jCMControl.Monad.State.Classgetsmodify'modify MonadStategetputstateMulti rawModulesabsNamecncNamesabsRulescncRules readMulti emptyMultiabsCodecncCodegetMultiaddMultigetRuleschopunspacequoteidCharisModulemodlinesSsTN matchPrefixunmarkup str2stringssstrstritSstrTokplusStrglueStrgluesTransliterationTranstrans_to_unicodetrans_from_unicodeinvisible_chars printname transliteratetransliterateWithFiletransliterationallTransliterationstransliterationPrintNamescharacterTableappTransToUnicodeappTransFromUnicodemkTransliterationgetTransliterationFileunchar transThaitransDevanagariallTransUrduHindi transUrdu transSindhi transArabic transPersian transNepali transHebrew transTelugu transGreektransAncientGreek transAmharicallTransallCodes transSanskrit getCliticsgetCliticsText darcs_infoArgDescrNoArgReqArgOptArgOptDescrOptionArgOrder RequireOrderPermute ReturnInOrder usageInfogetOptgetOpt'OptKindOptUnreqOptNonOpt EndOfOptsOptErrfmtOptfmtShortfmtLonggetNextlongOpterrAmbigerrReqerrUnrecerrNoArgc_getNumberOfProcessorssetNumCapabilitiesghc-prim GHC.TypesFalsegetNumberOfProcessorsFuturenowspawnparMapMnewLognewMVarreadMVarputMVar newEmptyMVarnewChangetChanContents writeChanlazyIOControl.Concurrent.ChanChanControl.Concurrent.MVar modifyMVar modifyMVar_ GHC.Conc.SyncforkIOGHC.MVarMVarcanonicalizePathcreateDirectoryIfMissingdoesDirectoryExist doesFileExistgetModificationTimegetDirectoryContentsgetCurrentDirectorygetPermissions removeFile renameFiledirectory-1.2.6.2System.DirectorygetTemporaryDirectorygetUserDocumentsDirectorygetAppUserDataDirectorygetXdgDirectorygetHomeDirectorysetModificationTime setAccessTime getAccessTimeisSymbolicLinkwithCurrentDirectorysetCurrentDirectory listDirectory findFilesWith findFileWith findFilesfindFilefindExecutablesInDirectoriesfindExecutablesfindExecutablemakeRelativeToCurrentDirectory makeAbsolutecopyFileWithMetadatacopyFilerenameDirectoryremoveDirectoryRecursiveremoveDirectorycreateDirectorycopyPermissionssetPermissionssetOwnerSearchablesetOwnerExecutablesetOwnerWritablesetOwnerReadableemptyPermissions Permissionsreadablewritable executable searchable XdgDirectoryXdgData XdgConfigXdgCache System.Directory.Internal.Config exeExtensioncatchIOversionbindirlibdirdatadir libexecdir sysconfdir getBinDir getLibDir getDataDir getLibexecDir getSysconfDirgetDataFileName buildInfowelcome licenseMsg codingMsg changesMsgMaybe Data.Maybemaybe$fMonadPlusErr $fFunctorErr$fAlternativeErr$fApplicativeErr $fMonadErrTrieMapTrempty singletonlookupnullcompose decompose insertWithunion unionWithunions unionsWithelemstoList fromListWithfromList mapWithKeypretty-1.1.3.3#Text.PrettyPrint.Annotated.HughesPJPageMode ZigZagModeLeftMode OneLineModeStylemode lineLengthribbonsPerLinestyleText.PrettyPrint.HughesPJisEmpty setEncoding noTermColorsreadShellProcess $fPrettyL$fPrettyLocation $fFunctorLStringstringOpopInEnvappLexer appUnlexerwrapHTMLsafeInitGHC.Listinit sortGroupByunionAlllookup'find' Data.FoldablefindtableSet buildMultiMap compareEqwhenMPmzero nothingOrNullfoldFunsfixjoin sameLength notLongerThan longerThan lookupListsplitsplitBy foldMergeselect updateNth updateNthM compareBybothapFstapSndapBothmapFstmapSndmapBothwhenMrepeatMnlspwrapunwordsSunlinesSjoinSRel'mkRelmkRel'relaterelates isRelatedTo allRelateddomainintersectSetRelreflexiveClosurereflexiveElements filterRel purgeEmptyequivalenceClassestopologicalSort Data.EitherLeftRightremoveRel relToList reverseReltransitiveClosurereflexiveClosure_symmetricClosuresymmetricSubrelationreflexiveSubrelation isTransitive isReflexive isSymmetric isEquivalenceisSubRelationOftsort findCyclesisEmpty' relToRel' rel'ToRelincomingData.Traversablesequence checkAgain$fErrorMonadErrAttr GraphTypeDirected UndirectedgTypegIdgAttrsgNodesgEdges gSubgraphs addSubGraphssetNamesetAttr prGraphviz prSubGraphprGraph graphtypeprNodeprEdgeedgeop prAttrListprAttrescneedEsc isIDFirstisIDCharFAnewFA_nonLoopTransitionsTo renameStates insertNFA oneFinalStatemoveLabelsToNodesremoveTrivialEmptyNodesskipSimpleEmptyNodes pruneUnusableclosure reachableDFANFAState startStatestates transitionsnewFA addFinalStatenewState newStates newTransitionnewTransitionsinsertTransitionWithinsertTransitionsWith mapStatesmapTransitionsmodifyTransitions removeStateminimize unusedNamesnonLoopTransitionsFromloopsonGraph isInternalisFinal fixIncoming determinize reachable1 reverseNFAdfa2nfa prFAGraphviz faToGraphvizXMLDataCDataTagETagCommentcomments showXMLDoc showsXMLDocshowsXML showsAttrs showsAttrescape bottomUpXMLREUnionREConcatRERERepeatRESymboldfa2re elimStates epsilonREnullREisNull isEpsilonunionREconcatREseqRErepeatREfinalRE reverseRE minimizeRE mergeForwardfirstREmapREmapRE'joinRE symbolsREprREprRE'pNothingpCId insideChar isIdentFirst isIdentRest $fReadCId $fShowCIdLStrLIntLFltTailInfoRecCallTailCall UpdateCallIValHEAPARG_VARFREE_VARGLOBALInstr CHECK_ARGSCASECASE_LITSAVEALLOC PUT_CONSTR PUT_CLOSUREPUT_LITSETSET_PAD PUSH_FRAMEPUSHTUCKEVALDROPJUMPFAIL PUSH_ACCUM POP_ACCUMADD CodeLabelLiteralppLitppCodeppInstrppIVal ppTailInfoppLabelDTyppType pHypoBindspAtomppTypeppHypoPAppPLitPVarPWildEAbsEAppELitEMetaETypedEImplArg unAppForm normalFormppParens freshNameppExprpBindspArgEnvSigValueVAppVLitVMetaVSuspVGenVConstVClosureVImplArgEqupFactorpTypedpMetapLit pattScopeppBind value2exprevalapply applyValuematch $fReadExpraflagsPArgPApplyPCoercePConstSymbolSymCatSymLitSymVarSymKSSymKPSymBINDSymNE SymSOFT_BIND SymSOFT_SPACESymCAPIT SymALL_CAPITDotPosConcrcflags printnamescncfunslindefslinrefs sequences productions pproductions lproductionscnccatslexicon totalCatsAbstrgflagsabsnameunionPGF msgUnionPGFemptyPGFhaveSameFunsPGF fidStringfidIntfidFloatfidVar isPredefFIdlengthBracketedStringCncTypeLinTable BracketedToknBracket_LeafKSLeafNELeafBIND LeafSOFT_BIND LeafCAPITLeafKP mapConcreteslookTypeisData lookValCat lookStartCatlookGlobalFlag lookAbsFlag lookConcrlookConcrComplete lookConcrFlagfunctionsToCathasLin restrictPGFdepthcftype typeOfHypo contextLengthlookMap cidStringcidIntcidFloatcidVarppBracketedStringuntokn mkLinTable computeSeqfirstLinlinTree lookupVargetVarSelector splitSelectorTcMunTcM MetaValueMUnboundMBoundMGuarded MetaStoreScopeTTypeTTyp emptyScope addScopedVarscopeEnv scopeVars scopeSizerunTcM lookupCatHyps lookupFunTypetypeGeneratorsemptyMetaStorenewMetanewGuardedMetagetMetasetMeta lookupMeta addConstrainttcTypetcHypostcHypo tcCatArgstcExprinfExprtcArg appImplArgeqTypeeqExpreqValuecheckResolvedMetaStoregenerateForMetasgenerateForForestevalType refineExpr refineExpr_ refineType refineType_ $fFunctorTcM$fMonadErrorTcErrorTcM$fMonadStatesTcM$fMonadPlusTcM$fAlternativeTcM $fMonadTcM$fApplicativeTcMgenerateproverestart$fSelectorIdentity $fSelector()BooltoSVGAttrsTagNameSVGCharDataElemLengthPositionSize UnitLengthMMObjectTinyTextOvalTop ArrowDownDrawingCommandPutLaTeXPictureCoNLLDep wordLengthtokensdepsrootPreAlignLangSeq IndexedSeqNumTreegetArgumentPlace expr2numtreegenPreAlignment showIndSeqshowRelsgetOffsetIndex computeOffsetstruct tbracketstag conll2latex conll2latex'defaultWordLength defaultUnit spaceLength charWidthwsizewposwdist labelheight labelstartarcbase arcfactorxyratioputArc dep2latex parseCoNLL conll2dep'ppLaTeXapplatexDocppSVGCStateProbsfunProbscatProbsgetProbabilities mkProbDefscomputeConstrsp_fp_ik_fk_i collectWordsmorphoClassifymissingWordMsg getAbsTreesForestabstrconcrforestlinearizeWithBrackets bracketedTokn isLindefCId foldForest $fSelectorInt ErrorStateEState ContinuationChartactiveactivespassivenextIdoffsetPState PassiveChart PassiveKeyPK ActiveChart ActiveSet ActiveKeyAKActive getPartialSeqprocesspredictupdateAtemptyAClookupAClookupACByFCatlabelsACinsertACemptyPClookupPCinsertPC optimizePGFupdateProductionIndices topDownFilterbottomUpFilterfilterProductionssplitLexicalRulesupdateConcreteppPGFppAbsppFlagppCatppFunppCncppCncArg ppProductionppCncFun ppFunListppSeqppCncCat ppPrintNameppSymbolppAltppStrsppFIdppFunIdppSeqIdppAllVarLit tree2expr expr2treeprTree patt2treeSubst paraphraseN paraphraseN'fromDefsubstisClosedisLinear arguments showInOrderisArg typesInterm returnCat forExample%cgi-3001.3.0.1-IS6fyqDHm0yAyXLMNF6GkI Network.CGI setHeader readInputgetInputrequestAcceptLanguagegetVarWithDefault outputError handleErrors outputFPSoutputNetwork.CGI.Accept negotiateAcceptNetwork.CGI.MonadcatchCGIthrowCGIrunCGITNetwork.CGI.Protocol CGIRequestcgiVars cgiInputscgiRequestBodyInput inputValue inputFilenameinputContentType CGIResult CGIOutput CGINothing&multipart-0.1.2-6gTlfshYeN9D1beoXxTayVNetwork.Multipart.Header ContentType ctParameters ctSubtypectType HeaderNameHeadersCGIError cgiErrorCodecgiErrorMessage cgiErrorTextlogError stderrToFile throwCGIErrorhandleCGIErrors outputJSONPoutputEncodedJSONP outputPNG outputBinary outputBinary' outputHTML outputPlain outputText outputStrictsetXO$fExceptionCGIError documentRootportrunHTTP cgiHandlerhttpRespcgiReqBuilderbytestring-0.10.8.1Data.ByteString.Lazy.Internal ByteStringtoLazyByteStringData.ByteString.LazyappendfromByteStringData.ByteString.Internal fromChunksfromLazyByteStringflush unsafeLiftIOwithSize mapBuilder ensureFreewriteN writeNbytes putWord16be putWord16le putWord32be putWord32le putWord64be putWord64le putWordhost putWord16host putWord32host putWord64hostBuffer runBuilder defaultSize writeNBuffer newBufferwriteNBufferBytes shiftr_w16 shiftr_w32 shiftr_w64$fMonoidBuilderGetrunGet runGetStateskip uncheckedSkip lookAhead lookAheadM lookAheadEuncheckedLookAhead bytesRead remaining getByteStringgetLazyByteStringgetLazyByteStringNulgetRemainingLazyByteStringgetBytes splitAtSTreadNgetWord8 getWord16be getWord16le getWord32be getWord32le getWord64be getWord64le getWordhost getWord16host getWord32host getWord64hostunGetmkStatefailDescjoinBSgetPtr shiftl_w16 shiftl_w32 shiftl_w64 $fMonadFixGet $fMonadGet$fApplicativeGet $fFunctorGetPutMexecPutrunPutrunPutMputWord8 putByteStringputLazyByteStringunPutPairSsndStell putBuilder $fMonadPutM$fApplicativePutM $fFunctorPutM ByteCountBitCount SignificandExponentSignPositiveNegativeRawFloatrawWidthrawSign rawExponentrawSignificandrawExponentWidthrawSignificandWidth getFloat16be getFloat16le getFloat32be getFloat32le getFloat64be getFloat64le splitBytesmerge normalised denormalisedgetFloat putFloat32be putFloat32le putFloat64be putFloat64le splitFloat rawToBytesclampmashBitsintegerToBytesputFloat exponentWidthbiasunbiasbitCount bitsInWord8 bitShiftL bitShiftRbitSlicesliceIntpow isNegativeNaNSmallInt encodeFile_ decodeFile_unrollroll$fBinaryUArray $fBinaryArray $fBinaryTree $fBinaryFloat$fBinaryDouble $fBinarySeq$fBinaryIntMap$fBinaryIntSet $fBinaryMap $fBinarySet$fBinaryByteString$fBinaryByteString0$fBinaryEither $fBinaryMaybe $fBinary[]$fBinary(,,,,,,,,,)$fBinary(,,,,,,,,)$fBinary(,,,,,,,)$fBinary(,,,,,,)$fBinary(,,,,,)$fBinary(,,,,) $fBinary(,,,) $fBinary(,,) $fBinary(,) $fBinaryChar $fBinaryRatio$fBinaryInteger $fBinaryInt $fBinaryWord $fBinaryInt64 $fBinaryInt32 $fBinaryInt16 $fBinaryInt8$fBinaryWord64$fBinaryWord32$fBinaryWord16 $fBinaryWord8$fBinaryOrdering $fBinaryBool $fBinary()WordGHC.WordWord8Word16Word32Word64 byteSwap64 byteSwap32 byteSwap16pgfMajorVersionpgfMinorVersiongetPGFgetPGF'getCId getAbstractgetFungetCatgetFlagsgetConcrgetExprgetPatt getEquationgetTypegetHypo getBindType getCncFun getCncCat getSequence getSymbols getSymbolgetAlternativesgetTokenSymbolgetPArg getProduction getLiteralgetArraytoArray listToArraygetListgetList'getMaybegetMap getIntMapgetSetgetPair decodingError putSplitAbsputArray putArray2 getArray2$fBinaryLiteral$fBinaryProduction $fBinaryPArg$fBinarySymbol$fBinaryCncCat$fBinaryCncFun$fBinaryBindType $fBinaryType $fBinaryInstr$fBinaryEquation $fBinaryPatt $fBinaryExpr $fBinaryConcr $fBinaryAbstr $fBinaryCId $fBinaryPGFCFObjCFAbsCFAppCFResCFVarCFMeta removeCyclesmergeIdenticalpurgeExternalCats mutRecCatsallRulesallRulesGroupedallCatsallCats'catRules catSetRulescleanCFGunionCFG anyUsedBy allXLinear isRightLinear isLeftLinearcatElemParamCFG ParamCFRule ParamCFSymbolCFGCFRuleCFSymbolCFTerm cfgStartCatcfgExternalCatscfgRulesRuleruleLhsruleRhsruleName NonTerminalTerminalremoveLeftRecursionmakeSimpleRegular makeRegularmkCFG groupProds uniqueFuns mapCFGCatsonRules filterCFG filterCFGCats countCats countRulesprCFG prProductionsprCFTermruleFunmkCFTermruleIsNonRecursivesymbol mapSymbol filterCats filterToks noCatsInSetSepMap SepTermSymb IsSeparator IsNonemptyBNFCRule BNFCCoercionsBNFCTerminator BNFCSeparatorlhsCatcoerCatcoerNum termNonEmptytermCattermSep sepNonEmptysepCatsepSep BNFCSymbolIsListbnfc2cf isSepTermtransformRulesfRules transformSymbcreateListRulescreateListRules'EItemEITerm EINonTermEIStarEIPlusEIOpt NormERule CFJustRuleCFRHSERHSETermENonTermEAltEStarEPlusEOptEEmptyETokECatERuleEBNFebnf2cfnormEBNF pickERules eitem2cfitem normERulemkEItemmkECatprECatmkCFCatE mkNewECatExConfigurationExConf resource_pgfresource_morphoverboselanguageprintExpparseExamplesInGrammar convertFileconfigureExBasedmkAnswerQuestionsAndAnswersmkQuiztranslationListmorphologyListnorml teachDialoguefoldablefoldappFoldilexerlexerunlexerC unlexText'unlexerHjsonExprlinearizeTabularToATreeshowTreeTreeOptsToFromUnlexerCachespgfCache labelsCachecatchIOEwithQSemlogFile newPGFCache flushPGFCache listPGFCache newCache'getPathcgiMaincgiMain'optionalCpgfMain serverErrorgetFilelexer'pgfMainout getInput1nonEmpty textInput getLangs'getLang'limitstarttreeoptsgetBooltoBoolmissingerrorMissingIdnotFound badRequestthrowformat doExternaldoLookupMorpho doTranslatejsonTypeErrorsdoTranslateGroupdoParseaddTrieaddTree doCompletecompletionInfo doLinearize doLinearizesdoLinearizeTabulardoRandom doGenerate doGrammaroutputGraphviz abstrTree parseTree doDepTree getLabels alignmentpipeIt2graphviz browse1jsondoBrowseparse' complete'transferlinearizeAndUnlexselectLanguagelangCodeLanguage#%$fJSONBracketedString $fJSONExpr $fJSONCId $fJSONTrie $fToATreeExprEnviron getTypeMap getConcMapgetSigsgetAllConcMapTypeMap FuncWithArggetName getTypeArgs InterInstrMyFuncConcTypeMyTypeprovideExampletestThisllinreplaceConcArg replaceOne findExprWhich mapToResource embedInStartmkSigssearchGoodTree getNameExprisGeneralizationOfdebugReplaceArgsdebugReplaceConcisMeta mkFuncWithArginitial startCategICIWIVIAIAV rawId2utf8packunpackwild $fPrettyIdent$fBinaryRawIdent$fPrettyModuleName$fShowModuleNameAlexAcc AlexAccNone AlexAccSkip AlexLastAccAlexNone AlexLastSkip AlexReturnAlexEOF AlexErrorAlexSkip AlexTokenAlexAddrAlexA#unP ParseResultPOkPFailed AlexInput2 AlexInputAIPosnPn T_exclmarkT_patt T_int_labelT_oparenT_cparenT_tildeT_star T_starstarT_plus T_plusplusT_commaT_minusT_rarrowT_dotT_altT_colon T_semicolonT_lessT_equal T_big_rarrowT_great T_questmarkT_obrackT_lamT_lamlamT_cbrackT_ocurlyT_barT_ccurly T_underscoreT_at T_cfarrowT_PTypeT_StrT_StrsT_TokT_Type T_abstractT_caseT_cat T_concreteT_dataT_defT_flagsT_fnT_funT_in T_incomplete T_instance T_interfaceT_letT_linT_lincatT_lindefT_linrefT_ofT_openT_operT_param T_patternT_pre T_printname T_resourceT_strsT_table T_transfer T_variantsT_whereT_with T_coercions T_terminator T_separator T_nonemptyT_String T_IntegerT_DoubleT_IdentT_EOF alex_tab_size alex_base alex_table alex_check alex_deflt alex_acceptidenttokreseitherResIdentisReservedWordresWordsunescapeInitTailalexMove alexGetByterunP runPartialrunP'dupfailLoctokengetPosn alex_action_3 alex_action_4 alex_action_5 alex_action_6 alex_action_7 alex_action_8alexIndexInt16OffAddralexIndexInt32OffAddr quickIndexalexScan alexScanUser alex_scan_tkn$fFunctorAlexLastAcc$fMonadP$fApplicativeP $fFunctorPcTypecPTypecTokcStrcStrs cPredefAbs cPredefCnccPredefcIntcFloatcStringcVarcIntscPBool cErrorType cOverloadcUndefinedType cNonExistcBIND cSOFT_BIND cSOFT_SPACEcCAPIT cALL_CAPIT isPredefCatcPTruecPFalsecLengthcDropcTakecTkcDpcToUppercToLowercIsUppercEqStrcEqValcOccurcOccurscEqIntcLessIntcPluscShowcReadcToStrcMapStrcErrorcTracecMetacAscCharcCharscSeqcAltcRepcNegcCNC cConflictPPAPatExpTyConApDecppAWildPVarPConPAsPConstOpListPairLets LambdaCaseTIdTApListTFunDepsDerivingClassInstanceTypeSigEqnconap0tsyn0lhs0tvartcon0tconlet1singleplusplus$fPPAPat $fPrettyPat$fPPAExp $fPrettyExp$fPPATy $fPrettyTy $fPrettyConAp $fPrettyDec $fPPAIdentoptDescrWarningWarnMissingLincat usageHeadererrors defaultFlags outputFormatsoptimizationPackagescfgTransformNameshaskellOptionNames lookupShowlookupReadsPreconOffsetOptimization'setCFGTransform'toggle readMaybe toEnumBounded$fFunctorArgDescr$fFunctorOptDescr$fReadOutputFormat$fShowOutputFormat $fShowOptionsMPattMGrammar$fHasSourcePathModuleInfoArgumentAExprATermANoArgAMacroVIdVIntVStrOOptOFlagCommandPipe CommandLine valCIdOpts valIntOpts valStrOpts listFlags valueStringisOptisFlag optsAndFlagsprOptmkOpt getCommandOp MetaSubst ConstraintsBindsValVCnVRecTypeVTypeVClos valAbsInt valAbsFloat valAbsStringvTypeeTypeModDepsmodtypeofs extendedsopenedsextradsfunctors interfaces instancesdepGraph prDepGraph noModDepsgrammar2moddeps ppOptions ppEquationppCaseppEnvppDeclppDDecl ppOpenSpec ppInstSpecppLocDefppAlternppParam ppSequences commaPunctprec getCTablegetLet $fPrettyLabel $fPrettyPatt $fPrettyTerm$fPrettyGrammarConstrsUnifierunifyValunifyAllunifyextend subst_all substMetas substTermoccCheckval2termTCEnvTheoryAAssign ALabellingAExpAVrACnATypeAIntAFloatAStrAMetaALetAAppAAbsAProdARecTypeARAPAGlueAData lookupConstwhnfeqValcheckExp checkInferExpinferExpcheckLabelling checkAssign checkBranch checkPattnoConstrmkAnnot typPredefined primitives minLength maxLength matchPatterntestOvershadow findMatchtryMatch matchPMSeq matchPSeq matchPSeq' matchLength lengthBoundsmPatt measurePattisInConstantForm lockRecType unlockRecord lockLabel isLockLabel lockPrefixlookupOrigInfolookupCatContextlockunlock lookupIdentlookupIdentInfolookupQIdentInfo lookupResDeflookupResDefLoc lookupResTypelookupOverload allOrigInfoslookupParamValuesallParamValues lookupAbsDef lookupLincatallOpers allOpersToTermMTermList subexpModuleunsubexpModuleaddSubexpConstsgetSubtermsModcollectSubterms operIdent isOperIdent operPrefixstripSourceGrammar stripInfoconstantsInTerm constantDeps getIdTermconstantDepsTermtermsOfConstant sizeConstantsizeTermsizeInfo sizesModule sizesGrammarprintSizesGrammarTermPrintStyleTermPrintTable TermPrintAll TermPrintList TermPrintOneTermPrintDefaultshowTerm ppTermTabularfailIO$fErrorMonadIO$fOutputStateT $fOutputIO decodeFile'addFPath gfoVersion gfoBinVersion$fFunctorVersionTagged$fBinaryVersionTagged $fBinaryLabel $fBinaryTInfo $fBinaryTerm $fBinaryL$fBinaryLocation $fBinaryInfo $fBinaryPMCFG$fBinaryOptions$fBinaryModuleStatus$fBinaryOpenSpec$fBinaryMInclude$fBinaryModuleType$fBinaryModuleInfo$fBinaryGrammar$fBinaryModuleName $fBinaryIdent writeTags getLocalTags getImports gftagsFile gf2gftags checkError checkWarncheckAccumErroraccumulateError commitCheckrunCheck runCheck' checkInModuleCheckunCheck CheckResultFailSuccess AccumulateNonFatalMessagehandle' checkCond checkWarnings parallelCheckcheckMapcheckMapRecovercheckIn$fErrorMonadCheck$fApplicativeCheck $fMonadCheck$fFunctorCheckrenameSourceTerm renamePattern StatusInfo StatusTreeStatus renameModulerenameIdentTermrenameIdentTerm' info2status tree2status buildStatusmodInfo2status self2status renameInfo renameTerm renameContext buildAnyTree rebuildModule extendMod unifyMaybeL extendModule globalizeLoc unifyAnyInfo unifAbsArrity unifAbsDefssubstituteLTypecheck2 computeLType inferLType getOverload checkLType pattContext checkEqLTypecheckIfEqLTypetermWith checkLookup initTCEnvtype2valcont2expcont2val justTypeCheck notJustMetagrammar2theory checkContextcheckTypcheckDef checkConstrs HappyAddrHappyA#HappyStk Happy_IntList HappyConsHappyAny HappyAbsSyn happyIn10 happyOut10 happyIn11 happyOut11 happyIn12 happyOut12 happyIn13 happyOut13 happyIn14 happyOut14 happyIn15 happyOut15 happyIn16 happyOut16 happyIn17 happyOut17 happyIn18 happyOut18 happyIn19 happyOut19 happyIn20 happyOut20 happyIn21 happyOut21 happyIn22 happyOut22 happyIn23 happyOut23 happyIn24 happyOut24 happyIn25 happyOut25 happyIn26 happyOut26 happyIn27 happyOut27 happyIn28 happyOut28 happyIn29 happyOut29 happyIn30 happyOut30 happyIn31 happyOut31 happyIn32 happyOut32 happyIn33 happyOut33 happyIn34 happyOut34 happyIn35 happyOut35 happyIn36 happyOut36 happyIn37 happyOut37 happyIn38 happyOut38 happyIn39 happyOut39 happyIn40 happyOut40 happyIn41 happyOut41 happyIn42 happyOut42 happyIn43 happyOut43 happyIn44 happyOut44 happyIn45 happyOut45 happyIn46 happyOut46 happyIn47 happyOut47 happyIn48 happyOut48 happyIn49 happyOut49 happyIn50 happyOut50 happyIn51 happyOut51 happyIn52 happyOut52 happyIn53 happyOut53 happyIn54 happyOut54 happyIn55 happyOut55 happyIn56 happyOut56 happyIn57 happyOut57 happyIn58 happyOut58 happyIn59 happyOut59 happyIn60 happyOut60 happyIn61 happyOut61 happyIn62 happyOut62 happyIn63 happyOut63 happyIn64 happyOut64 happyIn65 happyOut65 happyIn66 happyOut66 happyIn67 happyOut67 happyIn68 happyOut68 happyIn69 happyOut69 happyIn70 happyOut70 happyIn71 happyOut71 happyIn72 happyOut72 happyIn73 happyOut73 happyIn74 happyOut74 happyIn75 happyOut75 happyIn76 happyOut76 happyIn77 happyOut77 happyIn78 happyOut78 happyIn79 happyOut79 happyIn80 happyOut80 happyIn81 happyOut81 happyIn82 happyOut82 happyIn83 happyOut83 happyIn84 happyOut84 happyIn85 happyOut85 happyIn86 happyOut86 happyIn87 happyOut87 happyIn88 happyOut88 happyIn89 happyOut89 happyIn90 happyOut90 happyIn91 happyOut91 happyIn92 happyOut92 happyIn93 happyOut93 happyIn94 happyOut94 happyIn95 happyOut95 happyIn96 happyOut96 happyIn97 happyOut97 happyIn98 happyOut98 happyIn99 happyOut99 happyInTok happyOutTokhappyActOffsetshappyGotoOffsetshappyDefActions happyCheck happyTablehappyReduceArr happy_n_termshappy_n_nonterms happyReduce_7happyReduction_7 happyReduce_8happyReduction_8 happyReduce_9happyReduction_9happyReduce_10happyReduction_10happyReduce_11happyReduction_11happyReduce_12happyReduction_12happyReduce_13happyReduction_13happyReduce_14happyReduction_14happyReduce_15happyReduction_15happyReduce_16happyReduction_16happyReduce_17happyReduction_17happyReduce_18happyReduction_18happyReduce_19happyReduction_19happyReduce_20happyReduction_20happyReduce_21happyReduction_21happyReduce_22happyReduction_22happyReduce_23happyReduction_23happyReduce_24happyReduction_24happyReduce_25happyReduction_25happyReduce_26happyReduction_26happyReduce_27happyReduction_27happyReduce_28happyReduction_28happyReduce_29happyReduction_29happyReduce_30happyReduction_30happyReduce_31happyReduction_31happyReduce_32happyReduction_32happyReduce_33happyReduction_33happyReduce_34happyReduction_34happyReduce_35happyReduction_35happyReduce_36happyReduction_36happyReduce_37happyReduction_37happyReduce_38happyReduction_38happyReduce_39happyReduction_39happyReduce_40happyReduction_40happyReduce_41happyReduction_41happyReduce_42happyReduction_42happyReduce_43happyReduction_43happyReduce_44happyReduction_44happyReduce_45happyReduction_45happyReduce_46happyReduction_46happyReduce_47happyReduction_47happyReduce_48happyReduction_48happyReduce_49happyReduction_49happyReduce_50happyReduction_50happyReduce_51happyReduction_51happyReduce_52happyReduction_52happyReduce_53happyReduction_53happyReduce_54happyReduction_54happyReduce_55happyReduction_55happyReduce_56happyReduction_56happyReduce_57happyReduction_57happyReduce_58happyReduction_58happyReduce_59happyReduction_59happyReduce_60happyReduction_60happyReduce_61happyReduction_61happyReduce_62happyReduction_62happyReduce_63happyReduction_63happyReduce_64happyReduction_64happyReduce_65happyReduction_65happyReduce_66happyReduction_66happyReduce_67happyReduction_67happyReduce_68happyReduction_68happyReduce_69happyReduction_69happyReduce_70happyReduction_70happyReduce_71happyReduction_71happyReduce_72happyReduction_72happyReduce_73happyReduction_73happyReduce_74happyReduction_74happyReduce_75happyReduction_75happyReduce_76happyReduction_76happyReduce_77happyReduction_77happyReduce_78happyReduction_78happyReduce_79happyReduction_79happyReduce_80happyReduction_80happyReduce_81happyReduction_81happyReduce_82happyReduction_82happyReduce_83happyReduction_83happyReduce_84happyReduction_84happyReduce_85happyReduction_85happyReduce_86happyReduction_86happyReduce_87happyReduction_87happyReduce_88happyReduction_88happyReduce_89happyReduction_89happyReduce_90happyReduction_90happyReduce_91happyReduction_91happyReduce_92happyReduction_92happyReduce_93happyReduction_93happyReduce_94happyReduction_94happyReduce_95happyReduction_95happyReduce_96happyReduction_96happyReduce_97happyReduction_97happyReduce_98happyReduction_98happyReduce_99happyReduction_99happyReduce_100happyReduction_100happyReduce_101happyReduction_101happyReduce_102happyReduction_102happyReduce_103happyReduction_103happyReduce_104happyReduction_104happyReduce_105happyReduction_105happyReduce_106happyReduction_106happyReduce_107happyReduction_107happyReduce_108happyReduction_108happyReduce_109happyReduction_109happyReduce_110happyReduction_110happyReduce_111happyReduction_111happyReduce_112happyReduction_112happyReduce_113happyReduction_113happyReduce_114happyReduction_114happyReduce_115happyReduction_115happyReduce_116happyReduction_116happyReduce_117happyReduction_117happyReduce_118happyReduction_118happyReduce_119happyReduction_119happyReduce_120happyReduction_120happyReduce_121happyReduction_121happyReduce_122happyReduction_122happyReduce_123happyReduction_123happyReduce_124happyReduction_124happyReduce_125happyReduction_125happyReduce_126happyReduction_126happyReduce_127happyReduction_127happyReduce_128happyReduction_128happyReduce_129happyReduction_129happyReduce_130happyReduction_130happyReduce_131happyReduction_131happyReduce_132happyReduction_132happyReduce_133happyReduction_133happyReduce_134happyReduction_134happyReduce_135happyReduction_135happyReduce_136happyReduction_136happyReduce_137happyReduction_137happyReduce_138happyReduction_138happyReduce_139happyReduction_139happyReduce_140happyReduction_140happyReduce_141happyReduction_141happyReduce_142happyReduction_142happyReduce_143happyReduction_143happyReduce_144happyReduction_144happyReduce_145happyReduction_145happyReduce_146happyReduction_146happyReduce_147happyReduction_147happyReduce_148happyReduction_148happyReduce_149happyReduction_149happyReduce_150happyReduction_150happyReduce_151happyReduction_151happyReduce_152happyReduction_152happyReduce_153happyReduction_153happyReduce_154happyReduction_154happyReduce_155happyReduction_155happyReduce_156happyReduction_156happyReduce_157happyReduction_157happyReduce_158happyReduction_158happyReduce_159happyReduction_159happyReduce_160happyReduction_160happyReduce_161happyReduction_161happyReduce_162happyReduction_162happyReduce_163happyReduction_163happyReduce_164happyReduction_164happyReduce_165happyReduction_165happyReduce_166happyReduction_166happyReduce_167happyReduction_167happyReduce_168happyReduction_168happyReduce_169happyReduction_169happyReduce_170happyReduction_170happyReduce_171happyReduction_171happyReduce_172happyReduction_172happyReduce_173happyReduction_173happyReduce_174happyReduction_174happyReduce_175happyReduction_175happyReduce_176happyReduction_176happyReduce_177happyReduction_177happyReduce_178happyReduction_178happyReduce_179happyReduction_179happyReduce_180happyReduction_180happyReduce_181happyReduction_181happyReduce_182happyReduction_182happyReduce_183happyReduction_183happyReduce_184happyReduction_184happyReduce_185happyReduction_185happyReduce_186happyReduction_186happyReduce_187happyReduction_187happyReduce_188happyReduction_188happyReduce_189happyReduction_189happyReduce_190happyReduction_190happyReduce_191happyReduction_191happyReduce_192happyReduction_192happyReduce_193happyReduction_193happyReduce_194happyReduction_194happyReduce_195happyReduction_195happyReduce_196happyReduction_196happyReduce_197happyReduction_197happyReduce_198happyReduction_198happyReduce_199happyReduction_199happyReduce_200happyReduction_200happyReduce_201happyReduction_201happyReduce_202happyReduction_202happyReduce_203happyReduction_203happyReduce_204happyReduction_204happyReduce_205happyReduction_205happyReduce_206happyReduction_206happyReduce_207happyReduction_207happyReduce_208happyReduction_208happyReduce_209happyReduction_209happyReduce_210happyReduction_210happyReduce_211happyReduction_211happyReduce_212happyReduction_212happyReduce_213happyReduction_213happyReduce_214happyReduction_214happyReduce_215happyReduction_215happyReduce_216happyReduction_216happyReduce_217happyReduction_217happyReduce_218happyReduction_218happyReduce_219happyReduction_219happyReduce_220happyReduction_220happyReduce_221happyReduction_221happyReduce_222happyReduction_222happyReduce_223happyReduction_223happyReduce_224happyReduction_224happyReduce_225happyReduction_225happyReduce_226happyReduction_226happyReduce_227happyReduction_227happyReduce_228happyReduction_228happyReduce_229happyReduction_229happyReduce_230happyReduction_230happyReduce_231happyReduction_231happyReduce_232happyReduction_232happyReduce_233happyReduction_233happyReduce_234happyReduction_234happyReduce_235happyReduction_235happyReduce_236happyReduction_236happyReduce_237happyReduction_237happyReduce_238happyReduction_238happyReduce_239happyReduction_239happyReduce_240happyReduction_240happyReduce_241happyReduction_241happyReduce_242happyReduction_242happyReduce_243happyReduction_243happyReduce_244happyReduction_244happyReduce_245happyReduction_245happyReduce_246happyReduction_246happyReduce_247happyReduction_247happyReduce_248happyReduction_248happyReduce_249happyReduction_249happyReduce_250happyReduction_250happyReduce_251happyReduction_251happyReduce_252happyReduction_252happyReduce_253happyReduction_253happyReduce_254happyReduction_254happyReduce_255happyReduction_255happyReduce_256happyReduction_256happyReduce_257happyReduction_257happyReduce_258happyReduction_258happyReduce_259happyReduction_259happyReduce_260happyReduction_260happyReduce_261happyReduction_261happyReduce_262happyReduction_262happyReduce_263happyReduction_263happyReduce_264happyReduction_264happyReduce_265happyReduction_265happyReduce_266happyReduction_266happyReduce_267happyReduction_267happyReduce_268happyReduction_268happyReduce_269happyReduction_269happyReduce_270happyReduction_270happyReduce_271happyReduction_271happyReduce_272happyReduction_272 happyNewToken happyError_ happyThen happyReturn happyThen1 happyReturn1 happyError'pModDefpTopDef pModHeaderpTermpExp pBNFCRules pEBNFRuleshappySeq happyErrormkListIdmkConsIdmkBaseId listCatDeftryLocmkR mkOverload isOverloading checkInfoTypemkAltsmkL happyParse happyAccept happyDoActionindexShortOffAddr happyShifthappySpecReduce_0happySpecReduce_1happySpecReduce_2happySpecReduce_3 happyReducehappyMonadReducehappyMonad2Reduce happyDrop happyDropStk happyGoto happyFail notHappyAtAll happyTcHack happyDoSeq happyDontSeqreadCommandLine pCommandLinepPipepCommandpOptionpValue pFilename pArgumentpArgTermpSystemCommandpTheRest getAllFilesgetOptionsFromFile CompStatusCSCompCSReadCSEnvModEnvModName gfImports gfoImports selectFormatimportsOfModuleparseModHeader parseSourcetoUTF8 recodeToUTF8 getPragmas getFilePath TemporaryTemprunPreprocessorbuiltin_preprocessors mkPresent mkMinimal omit_lines writeTempreadTempkeepTemp removeTempcf2pgfcf2abstrcf2concr mkRuleName CommandOutputPipedCommandArgumentsExprsStrings TypeCheckArg typeCheckArg CommandInfoexecsynopsissyntax explanationlongnameoptionsflagsexamplesneedsTypeCheckmapCommandExecemptyCommandInfo fromStrings fromExprs fromStringpipeWithMessage pipeMessage pipeExprsvoid stringAsExpr toStringstoExprstoTermmkEx appCommand interpret getCommand CommandEnvcommands commandmacros expmacros mkCommandEnvinterpretCommandLine interpretPipegetCommandInfo checkOptsgetCommandTreescommandHelpAll' commandHelp' commandHelpcommandHelpTagssection optionallycompact helpCommandAPIfunc BasicFuncAppFuncNoAPI exprToAPI stringToAPI exprToFuncmkAPI computeAPIoptimize optimizeNP hiddenCats optimizable rephraseable printAPIfunc syntaxFuncsdoPossibilitiesdoProvideExampledoAbstractExampleabstractExampledoTestFunction readParsePGF parseEnvirongetInpm2r readResultenviron instExpMetainstMetaTreeOptreeOp allTreeOpslargestsmallest treeChunkssubtreesfunNodes PredefinedDropTakeTkDpEqStrOccurOccursToUpperToLowerIsUpperPlusEqIntLessIntTracePBoolPFalsePTrueIntIntsNonExistBindBindingWildVCAppVAbsVProdVFloatVStringVSortVTblTypeVRecVVVTVCVSVPVPatt VPattTypeVFVVAltsVStrsVError$fEqBindPredeftoValue fromValueverrorpredefpredefs predefName predefNames predefListdeltaboolVnormstringswap$fPredefPredefined $fPredefValue $fPredef[] $fPredefBool $fPredefIntresourceValues traceResourcevalue0value strsFromValue value2term OpenValueStack LocalScope GLocation CompleteEnvCEsrcgrrvsoptsgloclocal GlobalEnvGEResourceValuesnfxgeLoc geGrammarextglobalvarpickresourcevconcatprojok1ok2ok2p unlockVRecplusVRecextRgluevfv valueMatch valueTable paramValues paramValues' paramValues''push'pushapply'vapplyvbetavaryvaryListvtrace value2term' linPattVarspattVars allPattVarsix<#buglocbugppbugconcretes2haskellconcrete2haskell haskPreamble toHaskellcon tableTypes paramTypesrecordscoerceconvertconvert'patVarsconvTypeproj'rconrcon' rcon_nameto_rconto_rcon' recordType labelClass paramTypeenumConqualoptimizeModulepartEval mkLinDefaultevalInfo partEvalNewmkLinReference evalPrintnamefactor ProtoFCatPathSchemavariantschoicesgetAllParamValuesFunSetProdSetPMCFGEnvSeqSetPFCatCProjCSelCNilCRecCTblCStrCParCnvMonadCMunCMBranchVariantReturn generatePMCFGmapAccumWithKeyMaddPMCFGfloc pgfCncCat runCnvMonad protoFCatgetFIds catFactorcomputeCatRangeppPath reversePath convertTerm convertArg convertRec convertTblgoBgoV addSequencesB addSequencesV mapAccumL' addSequenceevalTerm getVarIndex emptyPMCFGEnv addFunctiongetPMCFG restrictArg restrictHeadrestrictProtoFCatmkArray mkSetArrayppU $fShowSchema$fFunctorCnvMonad$fMonadState(,)CnvMonad$fMonadCnvMonad$fApplicativeCnvMonad instSigma subsCheckRhounifyVar instantiate skolemisequantify getMetaVars getFreeVarszonkTermTcResultTcOkTcFailUnboundBoundTauRhoSigma inferSigma checkSigmavtypeInt vtypeFloat vtypeIntsvtypeStr vtypeStrs vtypeType vtypePTypetcRhotcCasestcPattinferRecFieldscheckRecFields tcRecFieldtcRecTypeFields subsCheckFun subsCheckTblunifyFununifyTbl allBinderstcErrortcWarn unimplementednewVar scopeTypes tc_value2term$fErrorMonadTcM checkModule checkInfocheckReservedId linTypeOfTypecheckRestrictedInheritancecheckCompleteGrammar CompileSourcecompileSourceModulewriteGFO intermOutidumpwarnOut CollectOutputCOunCOHiderevealIOCacheopcachesetJobs batchCompile1 splitEither canonicalgetPathFromFile relativeTo newIOCache readIOCache$fErrorMonadCollectOutput$fOutputCollectOutput$fMonadIOCollectOutput$fMonadCollectOutput$fApplicativeCollectOutput$fFunctorCollectOutput $fOrdHide$fEqHidegrammar2haskellelemCat HSkeletonOIdent predefInst datatypes gfinstances hDatatypenonLexicalRuleslexicalConstructorpredefTypeSkel datatypesGADT hCatTypeGADT hDatatypeGADThEqGADTprCompos gfInstance hInstancemkVarsmkSVars fInstance hSkeleton isListCatbaseSize composClass AlphaConvert alphaConvert ConvertEnvPLPrintplpplpsgrammar2prolog plAbstract plConcreteplCatplFunplSeqplHeaderplFactsplTermplListplOperplVarplAtomisAlphaNumUnderscorecreateLogicalVariableisLogicalVariablelogicalVariablePrefixemptyEnvalphaConvertHypo$fAlphaConvertEquation$fAlphaConvertExpr$fAlphaConvertType$fAlphaConvert[] $fPLPrint[] $fPLPrintChar$fPLPrintSymbol$fPLPrintLiteral $fPLPrintCId$fPLPrintEquation $fPLPrintPatt $fPLPrintExpr $fPLPrintTypegrammar2lambdaprolog_modgrammar2lambdaprolog_sigppExport ppFunPredppClausemkVarppPredppKinddotdepTypedepHypodepExprequation2clause patt2expr expr2goalpgf2js abstract2js absdef2jslit2js concrete2jschildrenfrule2jsfarg2jsffun2jsseq2jssym2jsalt2jsnew mapToJSObj pgf2pythonpyAbsdef pyLiteral pyConcrete pyProductionpySymbolpyDictpyListpyTuplepyCatpyFunpySeqpyStrpyCIdpyIndentProfile bnfPrintertoBNFpgfToCFG grammar2vxml CatQuestionsSkeleton pgfSkeleton catQuestions catQuestiongetCatQuestion skel2vxml grammarURIcatFormscat2formfun2sub catFormIdvxmlformfield subdialogfilled vxmlGrammarprompt promptStringreturn_block blockCondparamgenerateByteCodecompileEquationsmkFail compileBody compileFun compileArg compileLambda shiftIValpushArgstuckArgssetArgsfreeVarsi2ipush_is mkCanon2pgfmi2imkExpmkPatt mkContextmkDefmkArity genCncCats genCncFuns genPrintNames mkMapArray CompileEnv compileModule compileOne'emptyCompileEnvextendCompileEnv importGrammar ioUnionPGF importSourceimportCFMonadSIOrunSIOhRunSIOGHC.IO.Handle.FDstdout captureSIOliftSIOSIOunSPutStr restrictedrestrictedSystem restrictedIOlift0lift1putStr putStrFlushputStrLn putStrLnFlushprint getCPUTime newStdGenlazySIO $fMonadSIOt $fMonadSIOSIO $fOutputSIO $fMonadSIO$fApplicativeSIO $fFunctorSIOcommonCommands stringOpsenvFlagstringOpOptionstrietoStringtoLines HasGrammar getGrammarsourceCommandscheckComputeTermmake_facfgToFA' sortSubLatscompileAutomatamake_fa1addStatesForCatsMFA MutRecSets MutRecSetmrCats mrNonRecRules mrRecRulesmrRec RecursivityRightRLeftRNotRcfgToFAcompileAutomatoncfgToMFAbuildMFA mfaStartDFAmfaToDFAremoveUnusedSubLats subLatUseMap usedSubLats mutRecSets revMultiMapSRGNTSRGAltsrgName srgStartCat srgLanguagemakeNonLeftRecursiveSRG renameCats mergeItems SRGSymbolSRGItemSRGRuleSRGsrgExternalCatssrgRules ebnfPrintermakeSRGsetDefaultCFGTransformmaybeTransformmakeNonRecursiveSRGmkSRGcfRulesToSRGRule srgLHSCat isExternalCatsrgItem groupTokens ungroupTokensprSRG lookupFM_width gslPrinterprGSLprItemprSymbolprCat firstToUpper showTokencomment emptyLine$++$SISRTagprSISR topCatSISRprofileInitSISRusedArgscatSISRprofileFinalSISRfmtOutfmtRefasstreeobjsrgsAbnfPrintersrgsAbnfNonRecursivePrintershowDocprABNFaltsrulemeta prepunctuatesrgsXmlPrintersrgsXmlNonRecursivePrinter prSrgsXmlmkItemsymItemoneOfgrammar optimizeSRGS jsgfPrinterprJSGFSLFWord slfSubPrinter isNonWordSLF_FASLFEdgeeIdeStarteEndSLFNode SLFSubLatnIdnWordnTagnLatSLFslfNodesslfEdgesSLFsmkFAs slfStyleFAslfGraphvizPrinterslfSubGraphvizPrintergvSLFFA slfPrinterautomatonToSLFmfaNodeToSLFNode mkSLFNode mkSLFSubLat mkSLFEdgeprSLFsprSLFprOneSLFshowWordprFields regexpPrintermultiRegexpPrinterprREsmfa2res outputConcrcompileSourceFilescompileCFFiles unionPGFFiles writeOutput grammarName grammarName' outputJustPGF outputPathwritinginfinity HasPGFEnv getPGFEnvPGFEnvpgfmospgfEnv pgfCommands treeOpOptions treeOpFlagstranslationQuizmorphologyQuiz prLexcLexiconprFullFormLexicon prAllWordsprMorphoAnalysis viewGraphviz viewLatexstanzas$fTypeCheckArgmCncJmentPaLCLiIgnored parseModule convModule convAbstract convExtends convExtend convAbsJments convAbsJmentconvSimpleTypeconvId convModId convConcrete convOpensconvOpen convCncJments convCncJmentconvBind jmentList jmentLocationlocHMserver ok_access ok_to_delete removeDirdebug gf_versionrunget_qs get_stateput_qs put_state hmbracket_ jsonresultserveStaticFileserveStaticFile' logPutStrLnjsonpok200ok200'json200json200' jsonp200'html200resp204resp301resp400resp404resp500resp501plain plainUTF8jsonUTF8 jsonpUTF8htmlUTF8ctcsutf8xolocationcontentTypeFromExt updateFile newDirectorysetDir utf8inputsdecodedrawinputs$fErrorResponseloopreadAndExecute1True readCommandoptionallyShowCPUTimeexecute1 execute1' moreCommandsGFEnvCompletionTypeCmplCmdCmplStrCmplOpt CmplIdent startOptsretainpgfenv commandenvhistoryCmdEnvShellMbeQuietshellpwordsimport_printException fetchCommand importInEnv tryGetLine emptyGFEnv emptyCmdEnvemptyCommandEnv multigrammar allCommandswordCompletionwc_type$fHasPGFEnvStateT$fHasGrammarStateT