7      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$ % & ' ( ) * + , - . / 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 DEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmno p q r s t u v w x y z { | } ~        I(c) Niklas Broberg 2004-2009, (c) The GHC Team, 1997-2000$BSD-style (see the file LICENSE.txt)$Niklas Broberg, d00nibro@chalmers.sestableportable Safe-Inferred+-./0X OAST nodes are annotated, and this class allows manipulation of the annotations. 'Retrieve the annotation of an AST node. Change the annotation of an AST node. Note that only the annotation of the node itself is affected, and not the annotations of any child nodes. if all nodes in the AST tree are to be affected, use .An alt alternative in a case expression.An fbind0 in a labeled construction or update expression.record field wildcardrecord field punordinary label-expresion pair A general  transqualp in a list comprehension, which could potentially be a transform of the kind enabled by TransformListComp.then group by exp using expthen group using expthen group by expthen exp by expthen expan ordinary statement!A statement, representing both a stmt in a do-expression, an ordinary qual' in a list comprehension, as well as a stmt in a pattern guard.$a recursive binding group for arrowslocal bindingsan exp by itself: in a dox-expression, an action whose result is discarded; in a list comprehension and pattern guard, a guard expression a generator: pat <- exp An fpat in a labeled record pattern.!record field wildcard"record field pun#ordinary label-pattern pair$An entity in a regular pattern.%an ordinary pattern& parenthesised pattern, e.g. (2*)')linear variable binding, e.g. foo@(1 | 2)(1non-linear variable binding, e.g. (foo@:(1 | 2))*)%guarded pattern, e.g. (| p | p < 3 |)*$sequence pattern, e.g. (| 1, 2, 3 |)+choice pattern, e.g. (1 | 2),operator pattern, e.g. pat*-A regular pattern operator..?! = 0 or 1, greedy/? = 0 or 10+! = 1 or more, greedy1+ = 1 or more2*! = 0 or more, greedy3* = 0 or more4An XML attribute in a pattern.6)A pattern, to be matched against a value.7strict (bang) pattern:  f !x = ...8quasi quote pattern: [$name| string |]9XML regular list pattern:XML embedded pattern;XML PCDATA pattern<XML singleton element pattern=XML element pattern>regular list pattern?view patterns of the form (exp -> pat)@pattern with type signatureAirrefutable pattern: ~patBwildcard pattern: _C@-patternDlabelled pattern, record styleEparenthesized patternF list patternG tuple patternH&data constructor and argument patternsI&pattern with an infix data constructorJ n+k patternKliteral constantLvariableMSWarning text to optionally use in the module header of e.g. a deprecated module.PAVariables used in a RULES pragma, optionally annotated with typesSThe body of a RULES pragma.U$Activation clause of a RULES pragma.X(Recognised overlaps for overlap pragmas.YINCOHERENT pragmaZOVERLAP pragma[NO_OVERLAP pragma\%Recognised tools for OPTIONS pragmas.c8A top level options pragma, preceding the module header.dANN pragma with module scopee@OPTIONS pragma, possibly qualified with a tool, e.g. OPTIONS_GHCfLANGUAGE pragmag2The calling convention of a foreign function call.o&The safety of a foreign function call.p interruptibleqsafe () or threadsafe ()runsafes$A template haskell splice expressiont!parenthesised expression splice: $(exp)uvariable splice: $varv&A template haskell bracket expression.wdeclaration bracket:  [d| ... |]xtype bracket:  [t| ... |]ypattern bracket:  [p| ... |]zexpression bracket:  [| ... |]{2An xml attribute, which is a name-expression pair.}PThe name of an xml element or attribute, possibly qualified with a namespace.Haskell expressions.case alts-higher-order arrow application (from right): exp >>- exp,higher-order arrow application (from left): exp -<< exp arrow application (from right): exp >- exparrow application (from left): exp -< exp arrows proc: proc pat -> expGENERATED pragma SCC pragma CORE pragmachildren of an xml element%escaped haskell expression inside xmlPCDATA child element"empty xml element, with attributes)xml element, with attributes and childrenquasi-quotaion: [$name| string |]"template haskell splice expression#template haskell bracket expression''T' for template haskell reifying of types'x- for template haskell reifying of expressions'expression with explicit type signatureparallel array comprehensionparallel list comprehensionordinary list comprehension>bounded arithmetic sequence, with first two elements given [:from, then .. to:]AParallel array bounded arithmetic sequence, incrementing by 1 [:from .. to:]>bounded arithmetic sequence, with first two elements given [from, then .. to]@unbounded arithmetic sequence, with first two elements given [from, then ..]2bounded arithmetic sequence, incrementing by 1  [from .. to]5unbounded arithmetic sequence, incrementing by 1:  [from ..]record update expressionrecord construction expressionright section (qop exp) left section (exp qop)parenthesised expressionparallel array expressionlist expressiontuple section expression, e.g. (,,3)tuple expressionmdo -expressiondoJ-expression: the last statement in the list should be an expression.case exp of altsif | stmts -> exp ...if exp then exp else explocal declarations with let ... in ...lambda expressionnegation expression -exp (unary minus)ordinary applicationinfix applicationliteral constantdata constructorimplicit parameter variablevariable@An indication whether a literal pattern has been negated or not.literal Values of this type hold the abstract value of the literal, along with the precise string representation used. For example, 10, 0o12 and 0xaW have the same value representation, but each carry a different string representation.unboxed string literalunboxed character literalunboxed double literalunboxed float literalunboxed word literalunboxed integer literalfloating point literalinteger literalstring literalcharacter literal<Class assertions. In Haskell 98, the argument would be a tyvarK, but this definition allows multiple parameters, and allows them to be typeRs. Also extended with support for implicit parameters and equality constraints.parenthesised class assertiontype equality constraintimplicit parameter assertion3class assertion where the class name is given infixconstraint kind assertion, Dict :: cxt => Dict cxtordinary class assertion A context is a set of assertionsIA functional dependency, given on the form l1 l2 ... ln -> r2 r3 .. rnAn explicit kind annotation. '[k1,k2,k3], a promoted list literal '(k1,k2,k3), a promoted tuple k1 k2k, a kind variable (-XPolyKinds)a parenthesised kind-> , the kind of a type constructor!, the kind of unboxed types*, the kind of typesIA type variable declaration, optionally with an explicit kind annotation.ordinary variable binding%variable binding with kind annotation2Flag denoting whether a tuple is boxed or unboxed.UBools here are True if there was a leading quote which may be left out. For example '[k1,k2] means the same thing as [k1,k2].parsed value and raw stringparsed value and raw stringMA type qualified with a context. An unqualified type has an empty context.Strict type marked with "!$" or type marked with UNPACK pragma.template haskell splice type2type equality predicate enabled by ConstraintKinds'K%, a promoted data type (-XDataKinds).!type with explicit kind signatureinfix type constructortype surrounded by parenthesesnamed type or type constructor type variable!application of a type constructor!parallel array syntax, e.g. [:a:])list syntax, e.g. [a], as opposed to [] atuple type, possibly boxed function typequalified typeA guarded right hand side | stmts = exp, or | stmts -> exp for case alternatives. The guard is a series of statements when using pattern guards, otherwise it will be a single qualifier expression.UThe right hand side of a function binding, pattern binding, or a case alternative.guarded right hand side (gdrhs)unguarded right hand side (exp)]The type of a constructor argument or field, optionally including a strictness annotation./unboxed component, marked with an UNPACK pragmastrict component, marked with "!",Declarations inside an instance declaration.4an associated data type implemented using GADT style&an associated data type implementationan associated type definitionordinary declaration(Declarations inside a class declaration.default signature-default choice for an associated type synonym)declaration of an associated type synonym&declaration of an associated data typeordinary declaration AA single constructor declaration in a GADT data type declaration.5If the GADT is declared using the record syntax, e.g. ?data Ty where TCon :: { field1 :: Int, field2 :: Bool } -> Ty(then the fields are stored as a list of  s, and the final type (Ty- in the above example) is stored in the last  field.7If the GADT is declared using the ordinary syntax, e.g. )data Ty where TCon :: Int -> Bool -> Tythen  [  l] is -, and the whole constructor's type (such as Int -> Bool -> Ty) is stored in the last  field. *Declaration of a (list of) named field(s). ,Declaration of an ordinary data constructor.record constructorinfix data constructorordinary data constructoryA single constructor declaration within a data type declaration, which may have an existential quantification binding.Clauses of a function binding.0A clause defined with infix notation, i.e. first its first argument pattern, then the function name, then its following argument(s), the right-hand side and an optional where clause. Note that there can be more than two arguments to a function declared infix, hence the list of pattern arguments.A clause defined with prefix notation, i.e. the function name followed by its argument patterns, the right-hand side and an optional where clause.#A binding of an implicit parameter.A binding group inside a let or where clause.'A binding group for implicit parametersAn ordinary binding group4A deriving clause following a data type declaration.FThe instance head. The split between rule/head allow us to represent )instance (Bounded a => Bounded [a]) where faithfully.The structure of  follows one of %. For example, instance C (Maybe a) Int where is represented as IHApp () (IHApp () (IHCon () (UnQual () (Ident () "C"))) (TyParen () (TyApp () (TyCon () (UnQual () (Ident () "Maybe"))) (TyVar () (Ident () "a"))))) (TyCon () (UnQual () (Ident () "Int")))))application to one more typeparenthesized instance head <infix application of the type/class name to the left operand!type or class name"bThe instance declaration rule, which is, roughly, the part of the instance declaration before the where keyword. Example: instance Ord a => Ord (Maybe a) is represented as qIRule () Nothing (Just (CxSingle () (ClassA () (UnQual () (Ident () "Ord")) [ TyVar () (Ident () "a") ]))) (IHApp () (IHCon () (UnQual () (Ident () "Ord"))) (TyParen () (TyApp () (TyCon () (UnQual () (Ident () "Maybe"))) (TyVar () (Ident () "a")))))"An optional explicit forall after instance is supported: 0instance forall a . Ord a => Ord (Maybe a) where becomes >IRule () (Just [ UnkindedVar () (Ident () "a") ]) ...%qThe head of a type or class declaration, which consists of the type or class name applied to some type variables class C a b is represented as |DHApp () (DHApp () (DHead () (Ident () "C")) (UnkindedVar () (Ident () "a"))) (UnkindedVar () (Ident () "b"))(where the annotation type l is instantiated with ())class (a :< b) c is represented as DHApp () (DHParen () (DHApp () (DHInfix () (UnkindedVar () (Ident () "a")) (Symbol () ":<")) (UnkindedVar () (Ident () "b")))) (UnkindedVar () (Ident () "c"))&%application to one more type variable'parenthesized declaration head(<infix application of the type/class name to the left operand)type or class name*FA flag stating whether a declaration is a data or newtype declaration.-&A boolean formula for MINIMAL pragmas..Parenthesized boolean formulas./Or boolean formulas.0And boolean formulas.1 A variable.2$An annotation through an ANN pragma.3&An annotation for the defining module.4"An annotation for a declared type.5"An annotation for a declared name.61A type equation as found in closed type families.8A top-level declaration.9A MINIMAL pragma: An ANN pragma;A SPECIALISE instance pragma<A SPECIALISE INLINE pragma=A SPECIALISE pragma>An INLINE CONLIKE pragma?An INLINE pragma@A WARNING pragmaAA DEPRECATED pragmaBA RULES pragmaCA foreign export declarationDA foreign import declarationEA pattern bindingF!A set of function binding clausesGA type signature declarationH'A Template Haskell splicing declarationIA declaration of default typesJ A declaration of operator fixityK!A standalone deriving declarationL'An declaration of a type class instanceMA declaration of a type classN.A data family instance declaration, GADT styleO"A data family instance declarationP"A type family instance declarationQA data family declarationR)A data OR newtype declaration, GADT styleSA data OR newtype declarationT A closed type family declarationUA type family declarationVA type declarationWAssociativity of an operator.X*right-associative operator (declared with infixr)Y)left-associative operator (declared with infixl).Z(non-associative operator (declared with infix)[cAn import specification, representing a single explicit item imported (or hidden) from a module.\T(C_1,...,C_n)h: a class imported with some of its methods, or a datatype imported with some of its constructors.]T(..)f: a class imported with all of its methods, or a datatype imported with all of its constructors.^T3: the name of a class, datatype or type synonym._variable`&An explicit import specification list.bAn import declaration.d/annotation, used by parser for position of the import keyword.ename of the module imported.f imported  qualified?gimported with {-# SOURCE #-}?hImport safe?i#imported with explicit package namejoptional alias name in an as clause.k'optional list of import specifications.lNamespaces for imports/exports.o+An item in a module's export specification.pmodule M: re-export a module.qT(C_1,...,C_n)h: a class exported with some of its methods, or a datatype exported with some of its constructors.rT(..)f: a class exported with all of its methods, or a datatype exported with all of its constructors.sTC: a class or datatype exported abstractly, or a type synonym.t variable.u!An explicit export specification.wBThe head of a module, including the name and export specification.y!A complete Haskell source module.zAa hybrid module combining an XML document with an ordinary module{a module consisting of a single XML document. The ModuleName never appears in the source but is needed for semantic purposes, it will be the same as the file name.|an ordinary Haskell module}A name (cname/) of a component of a class or data type in an import or export specification.~name of a data constructorname of a method or fieldOperators appearing in infix" declarations are never qualified.constructor operator (conop)variable operator (varop)$Possibly qualified infix operators (qop), appearing in expressions.constructor operator (qconop)variable operator (qvarop)An implicit parameter name.%ident, linear implicit parameter?ident, non-linear implicit parameter@This type is used to represent variables, and also constructors.varsym or consymvarid or conid.UThis type is used to represent qualified variables, and also qualified constructors.(built-in constructor with special syntaxunqualified local name!name qualified with a module name{Constructors with special syntax. These names are never qualified, and always refer to builtin type or data constructors.$unboxed singleton tuple constructor (# #)list data constructor (:)n)-ary tuple type and data constructors (,) etc, possibly boxed (#,#)function type constructor ->list type constructor []unit type and data constructor ()The name of a Haskell module.6Test if two AST elements are equal modulo annotations.  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~y|{zwxMONuvotsrqpbcdefghijk`a[_^]\WZYXlnm8VUTSRQPONMLKJIHGFEDCBA@?>=<;:9%)('&"$#! *,+     67{|6LKJIHGFEDCBA@?>=<;:987 #"!45$,+*)('&%-3210/.}~}~vzyxwsutorqpgnmlkjihcfed\ba`_^]X[ZYSTPRQUWV2543-10/.    #"!$,+*)('&%-3210/.456LKJIHGFEDCBA@?>=<;:987MONPRQSTUWVX[ZY\ba`_^]cfedgnmlkjihorqpsutvzyxw{|}~4      ! "$#%)('&*,+-10/.2543678VUTSRQPONMLKJIHGFEDCBA@?>=<;:9WZYX[_^]\`ab cdefghijklnmotsrqpuvwxy|{z}~ Safe-Inferred-HStrict type marked with "!$" or type marked with UNPACK pragma.template haskell splice typepromoted data type!type with explicit kind signatureinfix type constructor"assertion of an implicit parametertype surrounded by parenthesesnamed type or type constructor type variable!application of a type constructor!parallel array syntax, e.g. [:a:])list syntax, e.g. [a], as opposed to [] atuple type, possibly boxed function typecase altse >>- ee -<< ee >- ee -< e proc p -> do f !a = ...{- GENERATED ...  -} pragma{- SCC  -} pragma{- CORE  -} pragma [... ] % ... /% %... %PCDATA Name/ Name... /Name $...|...''T'xregular patterns onlyregular patterns onlyregular patterns onlyregular patterns only  patterns only pre-ops post-ops  patterns only  patterns only patterns onlyexpression type signatureparallel array comprehensionparallel list comprehension=bounded arithmetic sequence, with first two elements given1bounded arithmetic sequence, incrementing by 1=bounded arithmetic sequence, with first two elements given?unbounded arithmetic sequence, with first two elements given1bounded arithmetic sequence, incrementing by 13unbounded arithmetic sequence, incrementing by 1record update expressionrecord construction expressionVparenthesized expression RightSection QOp PExp -- ^ right section (qop exp)parallel array expressionlist expressiontuple section expression, e.g. (,,3)mdoK-expression | Tuple [PExp] -- ^ tuple expressiondoJ-expression: the last statement in the list should be an expression. case exp of alts!if | stmts -> exp ..."if exp then exp else exp#local declarations with let$lambda expression%negation expression - exp&ordinary application'infix application(literal constant)data constructor*implicit parameter variable+variablel,-./0123456789:;<=>?@A      !"#$%&'()*+BCDEFGHIJKLMNOf,-./0123456789:;<=>?@A      !"#$%&'()*+BCDEFGHI,210/.-3458769:;>=<?<+*)('&%$#"!      A@BCDEFGHIJKLMNOD(c) The GHC Team, 1997-2000, (c) Niklas Broberg 2004$BSD-style (see the file LICENSE.txt)$Niklas Broberg, d00nibro@chalmers.se experimentalportable Safe-Inferred1dAn identifier with the given string as its name. The string should be a valid Haskell identifier.OA symbol identifier. The string should be a valid Haskell symbol identifier.A local variable as expression.(Use the given identifier as an operator.#A qualified variable as expression.A pattern variable.,Application of expressions by juxtaposition.Apply an operator infix.(Apply a function to a list of arguments..A constructor pattern, with argument patterns.A tuple expression.A tuple pattern.0A tuple expression consisting of variables only.-A tuple pattern consisting of variables only.A function with a given name.A literal string expression.A literal character expression.A literal integer expression.A literal string pattern.A literal character pattern.A literal integer pattern.\A do block formed by the given statements. The last statement in the list should be a  expression.PLambda abstraction, given a list of argument patterns and an expression body.A let ... in block.A case expression.An unguarded alternative in a case expression.(An alternative with a single guard in a case expression.P!An unguarded righthand side of a case alternative.Q)An list of guarded righthand sides for a case alternative.R&A single guarded righthand side for a case alternative.A list expression.The empty list expression.The empty list pattern.%Put parentheses around an expression.!Put parentheses around a pattern.!A qualifier expression statement.A generator statement: pat <- expA let binding group as a statement./Hoist a set of declarations to a binding group.An empty binding group.The wildcard pattern: _DGenerate k names by appending numbers 1 through k to a given string.A function with a single clauseXA function with a single clause, a single argument, no guards and no where declarationsVA pattern bind where the pattern is a variable, and where there are no guards and no 'where' clause.[A pattern bind where the pattern is a variable, and where there are no guards, but with a 'where' clause.$Bind an identifier to an expression.6Apply function of a given name to a list of arguments.eApply a constructor of a given name to a list of pattern arguments, forming a constructor pattern.1PQR..1PQR(c) Niklas Broberg 2009$BSD-style (see the file LICENSE.txt)$Niklas Broberg, d00nibro@chalmers.sestableportable Safe-Inferred+0>A class to work over all kinds of source location information._A portion of the source, extended with information on the position of entities within the span. An entity located in the source.MA portion of the source, spanning one or more lines and zero or more columns. A single position in the source. Returns  and  in a pair.Returns  and  in a pair.5Combine two locations in the source to denote a span.Merge two source spans into a single span from the start of the first to the end of the second. Assumes that the two spans relate to the same source file.:Test if a given span starts and ends at the same location. Generate a - with no positional information for entities. Generate a 7 with the supplied positional information for entities. Combine two ms into one that spans the combined source area of the two arguments, leaving positional information blank.Short name for kOptionally combine the first argument with the second, or return it unchanged if the second argument is .jOptionally combine the second argument with the first, or return it unchanged if the first argument is .7Add more positional information for entities of a span. Merge two s and lift them to a  SrcInfoSpan0 with no positional information for entities./     *     /           Safe-Inferred+ An unknown pragma."A Haskell comment. The S is $ if the comment is multi-line, i.e. {- -}. !"# !"#"# ! !"#(c) Niklas Broberg 2009$BSD-style (see the file LICENSE.txt)$Niklas Broberg, d00nibro@chalmers.sestableportable Safe-Inferred-%NPrint an AST exactly as specified by the annotations on the nodes in the tree.TUVW$XYZ[\]^_`abcdefghi%jklmnopqrstuvwxyz{|}~$%%$TUVW$XYZ[\]^_`abcdefghi%jklmnopqrstuvwxyz{|}~(c) Niklas Broberg 2009$BSD-style (see the file LICENSE.txt)*Niklas Broberg, niklas.broberg@chalmers.se transientportable Safe-Inferred+e'  GHC 7.40Allow type classimplicit parameterequality constraints to be used as types with the special kind Constraint. Also generalise the (ctxt => ty) syntax so that any type of kind Constraint can occur before the arrow.(  GHC 7.6.1.4iAllow default signatures in class definitions. They apply to default methods implemented in this class.)  GHC 7.20Compile a module in the Trustworthy, Safe Haskell mode -- no restrictions apply but the module is marked as trusted as long as the package the module resides in is trusted.*  GHC 7.20uCompile a module in the Safe, Safe Haskell mode -- a restricted form of the Haskell language to ensure type safety.+  GHC 7.20.3Allow imports to be qualified with a safe keyword that requires the imported module be trusted as according to the Safe Haskell definition of trust. import safe Network.Socket,  GHC 7.3.16hEnable the multi-way if-expressions extension to accept conditional expressions with multiple branches./  GHC 7.3.27,Enable explicit namespaces in import/export.0  GHC 8.1.5 Enable the capi7 calling convention in the foreign function interface.1  GHC 8.1.4Enable interruptible FFI.2&Enable non-decreasing indentation for 'do' blocks.3Enable deriving for the Data.Foldable.Foldable class.4Enable deriving for the Data.Traversable.Traversable class.5  GHC 7.5.3Enable deriving for the Generic and Generic1 classes.6Enable deriving for the Data.Functor.Functor class.7Local (let and where) bindings are monomorphic.80Allow contexts to be put on datatypes, e.g. the Eq a in /data Eq a => Set a = NilSet | ConsSet a (Set a).9Make forallN a keyword in types, which can be used to give the generalisation explicitly.:qMakes much of the Haskell sugar be desugared into calls to the function with a particular name that is in scope.;Improve the layout rule when if expressions are used in a do block.<!Support for patterns of the form n + k, where k is an integer literal.=HAllows GHC primops, written in C--, to be imported into a Haskell file.>(Enables the use of tuple sections, e.g. (, True) desugars into x -> (x, True).?Allow regular pattern matching over lists, as discussed in the paper "Regular Expression Patterns" by Niklas Broberg, Andreas Farre and Josef Svenningsson, from ICFP '04.@xAllow concrete XML syntax to be used in expressions and patterns, as per the Haskell Server Pages extension language:  &http://www.haskell.org/haskellwiki/HSP. The ideas behind it are discussed in the paper "Haskell Server Pages through Dynamic Loading" by Niklas Broberg, from Haskell Workshop '05.A  GHC 7.3.6]Enable view patterns, which match a value by applying a function and matching on the result.B  GHC 7.3.10\Enable generalized list comprehensions, supporting operations such as sorting and grouping.C  GHC 7.9.5cEnable quasi-quotation, a mechanism for defining new concrete syntax for expressions and patterns.D  GHC 7.3.12URelax the interpretation of left operator sections to allow unary postfix operators.E  GHC 7.3.31Change the syntax for qualified infix operators.F  GHC 7.8.6wDeprecated in GHC 6.12 and will be removed in GHC 7. Allow a type variable to be instantiated at a polymorphic type.H  GHC 7.3.18cAllow imports to be qualified by the package name the module is intended to be imported from, e.g. import "network" Network.SocketI  GHC 7.6.1.3VAllow a class method's type to place additional constraints on a class type variable.J  GHC 7.5.3Enable deriving for classes Data.Typeable.Typeable and Data.Generics.Data.K  GHC 7.2.2Enable unboxed tuples.L  GHC 2.4.5EAllow default instantiation of polymorphic types in more situations.M  GHC 7.8.8DRelax the requirements on mutually-recursive polymorphic functions.N  GHC 7.17.2"Make pattern bindings monomorphic.O  GHC 7.4.6Enable generalized algebraic data types, in which type variables may be instantiated on a per-constructor basis. Implies GADTSyntax.P  GHC 7.6.4VEnable overloading of string literals using a type class, much like integer literals.Q  GHC 7.3.14QAllow a record field name to be disambiguated by the type of the record it's in.RDeprecated, use b instead.S  GHC 7.3.16Enable syntax for implicitly binding local names corresponding to the field names of a record. A wildcard binds all unmentioned names, unlike b.T  GHC 7.26.5*Parallel arrays for Data Parallel Haskell.U  GHC 7.4.2\Allow the name of a type constructor, type class, or type variable to be an infix operator.V  GHC 7.4.3}Defer validity checking of types until after expanding type synonyms, relaxing the constraints on how synonyms may be used.W  GHC 8.1.1:Allow the use of unboxed types as foreign types, e.g. in foreign import and foreign export.X  GHC 7.3.1pAllow certain Unicode characters to stand for certain ASCII character sequences, e.g. keywords and punctuation.Y  GHC 7.5.2=Allow a standalone declaration which invokes the type class deriving mechanism.Z  GHC 7.7cAllow data types and type synonyms which are indexed by types, i.e. ad-hoc polymorphism for types.[Binary integer literals\  GHC 7.3.2Allow the character #X as a postfix modifier on identifiers. Also enables literal syntax for unboxed values.]  Hugs 7.3HEnable an alternate syntax for string literals, with string templating.^  Hugs 7.2Enable type synonyms which are transparent in some definitions and opaque elsewhere, as a way of implementing abstract datatypes._  Hugs 7.1,Enable the "Trex" extensible records system.`  GHC 7.5.4Allow a type declared with newtype to use deriving8 for any class with an instance for the underlying type.a  GHC 7.3.5DEnable a form of guard which matches a pattern and binds variables.b  GHC 7.3.15Enable syntax for implicitly binding local names corresponding to the field names of a record. Puns bind specific names, unlike S.c  GHC 7.3.11-Enable the implicit importing of the module Prelude. When disabled, when desugaring certain built-in syntax into ordinary identifiers, use whatever is in scope rather than the Prelude -- version.d  GHC 7.16kEnable generic type classes, with default instances defined in terms of the algebraic structure of a type.e  GHC 7.10Enable arrow notation.f GHC 8Enable the Foreign Function Interface. In GHC, implements the standard Haskell 98 Foreign Function Interface Addendum, plus some GHC-specific extensions.g  GHC 7.9DEnable Template Haskell, a system for compile-time metaprogramming.h  GHC 7.6.3.1&Allow type synonyms in instance heads.i  GHC 7.11bEnable a form of pattern which forces evaluation before an attempted match, and a form of strict let/where binding.j  GHC 7.8.4]Allow an explicit kind signature giving the kind of types over which a type variable ranges.k  GHC 4.10.3.Run the C preprocessor on Haskell source code.l  GHC 7.4.12Allow data type declarations with no constructors.m  GHC 7.6.3.2ORelax some restrictions on the form of the context of an instance declaration.n  GHC 7.8.2HRelax some restrictions on the form of the context of a type signature.o  GHC 7.8.38Enable implicit function parameters with dynamic scope.pDeprecated, use q instead.q  GHC 7.8.7=Cause a type variable in a signature, which has an explicit forallQ quantifier, to scope over the definition of the accompanying value declaration.r  GHC 7.4.41Allow existentially-quantified data constructors.s  GHC 7.8.5@Allow data constructors to have polymorphic arguments. Unlike t., does not allow this for ordinary functions.t  GHC 7.8.5NAllow a universally-quantified type to occur on the left of a function arrow.u  GHC 7.8.5Like tZ but does not allow a higher-rank type to itself appear on the left of a function arrow.v  GHC 7.6.2$Allow a specification attached to a multi-parameter type class which indicates that some parameters are entirely determined by others. The implementation will check that this property holds for the declared instances, and will use this property to reduce ambiguity in instance resolution.w  GHC 7.17,Enable the dreaded monomorphism restriction.x  GHC 7.6.1.1*Allow multiple parameters in a type class.y  GHC 7.3.9eProvide syntax for writing list comprehensions which iterate over several lists together, like the  family of functions.z  GHC 7.3.8.25Deprecated in GHC. Allows recursive bindings using mdo, a variant of do. DoRec) provides a different, preferred syntax.{  GHC 7.3.8Allows recursive bindings in do blocks, using the rec keyword.|  GHC 7.6.3.5#Allow type signatures in instances.}  GHC 7.6.3.4Implies . Allow the implementation to choose an instance even when it is possible that further instantiation of types will lead to a more specific instance being applicable.~  GHC 7.6.3.3Ignore structural rules guaranteeing the termination of class instance resolution. Termination is guaranteed by a fixed-depth recursion stack, and compilation may fail if this depth is exceeded.  GHC 7.6.3.4cAllow overlapping class instances, provided there is a unique most specific instance for each use.2This represents language extensions beyond a base  definition (such as L) that are supported by some implementations, usually in some special mode.4An unknown extension, identified by the name of its LANGUAGE pragma.Disable a known extensionEnable a known extension,An unknown language, identified by its name.The minimal language resulting from disabling all recognized extensions - including ones that are part of all known language definitions e.g. MonomorphismRestriction.BThe Haskell 2010 language as defined by the Haskell 2010 report. /http://www.haskell.org/onlinereport/haskell2010>The Haskell 98 language as defined by the Haskell 98 report. http://haskell.org/onlinereport/Certain extensions imply other extensions, and this function makes the implication explicit. This also handles deprecated extensions, which imply their replacements. The returned value is the transitive closure of implied extensions.KThe list of extensions enabled by GHC's portmanteau -fglasgow-exts flag.;List of all known extensions, both "yes" and "no" versions._Extensions that have been deprecated, possibly paired with another extension that replaces it.)A clever version of read that returns an $ if the string is not recognised.1Parse an enabled or disabled extension; returns  if the parse fails.GPretty print an extension. Disabled extensions are prefixed with 'No'.s&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~o&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~o&~}|{zyxwvutsrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONMLKJIHGFEDCBA@?>=<;:9876543210/.-,+*)('&Y~}|{zyxwvutsrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONMLKJIHGFEDCBA@?>=<;:9876543210/.-,+*)('(c) Niklas Broberg 2009$BSD-style (see the file LICENSE.txt)$Niklas Broberg, d00nibro@chalmers.sestableportable Safe-Inferred I(c) Niklas Broberg 2004-2009, (c) The GHC Team, 1997-2000$BSD-style (see the file LICENSE.txt)$Niklas Broberg, d00nibro@chalmers.sestableportable Safe-Inferred+0;An alt alternative in a case expression.An fbind0 in a labeled construction or update expression.record field wildcardrecord field punordinary label-expresion pair A general  transqualp in a list comprehension, which could potentially be a transform of the kind enabled by TransformListComp.then group by exp using expthen group using expthen group by expthen exp by expthen expan ordinary statement!A statement, representing both a stmt in a do-expression, an ordinary qual' in a list comprehension, as well as a stmt in a pattern guard.$a recursive binding group for arrowslocal bindingsan exp by itself: in a dox-expression, an action whose result is discarded; in a list comprehension and pattern guard, a guard expression a generator: pat <- expAn fpat in a labeled record pattern.record field wildcardrecord field punordinary label-pattern pairAn entity in a regular pattern.an ordinary pattern parenthesised pattern, e.g. (2*))linear variable binding, e.g. foo@(1 | 2)1non-linear variable binding, e.g. (foo@:(1 | 2))*%guarded pattern, e.g. (| p | p < 3 |)$sequence pattern, e.g. (| 1, 2, 3 |)choice pattern, e.g. (1 | 2)operator pattern, e.g. pat*A regular pattern operator.?! = 0 or 1, greedy? = 0 or 1+! = 1 or more, greedy+ = 1 or more*! = 0 or more, greedy* = 0 or moreAn XML attribute in a pattern.)A pattern, to be matched against a value.strict (bang) pattern:  f !x = ...quasi quote patter: [$name| string |]XML regular list patternXML embedded patternXML PCDATA patternXML singleton element patternXML element patternregular list patternview patterns of the form (exp -> pat)pattern with type signatureirrefutable pattern: ~patwildcard pattern: _@-patternlabelled pattern, record styleparenthesized pattern list pattern tuple pattern&data constructor and argument patterns&pattern with an infix data constructor n+k patternliteral constantvariableSWarning text to optionally use in the module header of e.g. a deprecated module.AVariables used in a RULES pragma, optionally annotated with typesThe body of a RULES pragma.$Activation clause of a RULES pragma.(Recognised overlaps for overlap pragmas.INCOHERENT pragmaOVERLAP pragmaNO_OVERLAP pragma8A top level options pragma, preceding the module header.ANN pragma with module scope@OPTIONS pragma, possibly qualified with a tool, e.g. OPTIONS_GHCLANGUAGE pragma2The calling convention of a foreign function call.&The safety of a foreign function call. interruptiblesafe () or threadsafe ()unsafe$A template haskell splice expression!parenthesised expression splice: $(exp)variable splice: $var&A template haskell bracket expression.declaration bracket:  [d| ... |]type bracket:  [t| ... |]pattern bracket:  [p| ... |]expression bracket:  [| ... |]2An xml attribute, which is a name-expression pair.PThe name of an xml element or attribute, possibly qualified with a namespace.Haskell expressions.case alts-higher-order arrow application (from right): exp >>- exp,higher-order arrow application (from left): exp -<< exp arrow application (from right): exp >- exparrow application (from left): exp -< exp arrows proc: proc pat -> expGENERATED pragma  SCC pragma  CORE pragma children of an xml element %escaped haskell expression inside xml PCDATA child element"empty xml element, with attributes)xml element, with attributes and childrenquasi-quotaion: [$name| string |]"template haskell splice expression#template haskell bracket expression''T' for template haskell reifying of types'x- for template haskell reifying of expressions'expression with explicit type signatureparallel array comprehensionparallel list comprehensionordinary list comprehension>bounded arithmetic sequence, with first two elements given [from, then .. to]2bounded arithmetic sequence, incrementing by 1  [from .. to]>bounded arithmetic sequence, with first two elements given [from, then .. to]@unbounded arithmetic sequence, with first two elements given [from, then ..]2bounded arithmetic sequence, incrementing by 1  [from .. to]5unbounded arithmetic sequence, incrementing by 1:  [from ..]record update expression record construction expression!right section (qop exp)" left section (exp qop)#parenthesised expression$parallel array expression%list expression&tuple section expression, e.g. (,,3)'tuple expression(mdo -expression)doJ-expression: the last statement in the list should be an expression.*case exp of alts+if | exp -> exp ...,if exp then exp else exp-local declarations with let ... in ....lambda expression/negation expression -exp (unary minus)0ordinary application1infix application2literal constant3data constructor4implicit parameter variable5variable6@An indication whether a literal pattern has been negated or not.9literaly Values of this type hold the abstract value of the literal, not the precise string representation used. For example, 10, 0o12 and 0xa have the same representation.:unboxed string literal;unboxed character literal<unboxed double literal=unboxed float literal>unboxed word literal?unboxed integer literal@floating point literalAinteger literalBstring literalCcharacter literalD<Class assertions. In Haskell 98, the argument would be a tyvarK, but this definition allows multiple parameters, and allows them to be typeRs. Also extended with support for implicit parameters and equality constraints.Eparenthesised class assertionFtype equality constraintGimplicit parameter assertionH3class assertion where the class name is given infixIconstraint kind assertion, Dict :: cxt => Dict cxtJordinary class assertionK A context is a set of assertionsLIA functional dependency, given on the form l1 l2 ... ln -> r2 r3 .. rnNAn explicit kind annotation.O '[k1,k2,k3], a promoted list literalP '(k1,k2,k3), a promoted tupleQ k1 k2R4a kind variable (as of yet unsupported by compilers)S a kind surrounded by parenthesesT-> , the kind of a type constructorU!, the kind of unboxed typesV*, the kind of typesWIA type variable declaration, optionally with an explicit kind annotation.Xordinary variable bindingY%variable binding with kind annotationaMA type qualified with a context. An unqualified type has an empty context.bStrict type marked with "!$" or type marked with UNPACK pragma.ctemplate haskell splice typed2type equality predicate enabled by ConstraintKindse promoted data type (-XDataKinds)f!type with explicit kind signatureginfix type constructorhtype surrounded by parenthesesinamed type or type constructorj type variablek!application of a type constructorl!parallel array syntax, e.g. [:a:]m)list syntax, e.g. [a], as opposed to [] antuple type, possibly boxedo function typepqualified typeqA guarded right hand side | stmts = exp, or | stmts -> exp for case alternatives. The guard is a series of statements when using pattern guards, otherwise it will be a single qualifier expression.sUThe right hand side of a function binding, pattern binding, or a case alternative.tguarded right hand side (gdrhs)uunguarded right hand side (exp)v]The type of a constructor argument or field, optionally including a strictness annotation.w/unboxed component, marked with an UNPACK pragmaxstrict component, marked with "!"y,Declarations inside an instance declaration.z4an associated data type implemented using GADT style{&an associated data type implementation|an associated type definition}ordinary declaration~(Declarations inside a class declaration.default signature-default choice for an associated type synonym)declaration of an associated type synonym&declaration of an associated data typeordinary declarationAA single constructor declaration in a GADT data type declaration.,Declaration of an ordinary data constructor.record constructorinfix data constructorordinary data constructoryA single constructor declaration within a data type declaration, which may have an existential quantification binding.Clauses of a function binding.#A binding of an implicit parameter.A binding group inside a let or where clause.'A binding group for implicit parametersAn ordinary binding groupFA flag stating whether a declaration is a data or newtype declaration.&A boolean formula for MINIMAL pragmas.Parenthesized boolean formulas.Or boolean formulas.And boolean formulas. A variable.$An annotation through an ANN pragma.&An annotation for the defining module."An annotation for a declared type."An annotation for a declared name.A type equation of the form  rhs = lhs used in closed type families.A top-level declaration.A MINIMAL pragma An ANN pragmaA SPECIALISE instance pragmaA SPECIALISE INLINE pragmaA SPECIALISE pragmaAn INLINE CONLIKE pragmaAn INLINE pragmaA WARNING pragmaA DEPRECATED pragmaA RULES pragmaA foreign export declarationA foreign import declarationA pattern binding!A set of function binding clausesA type signature declaration'A Template Haskell splicing declarationA declaration of default types A declaration of operator fixity!A standalone deriving declaration'An declaration of a type class instanceA declaration of a type class.A data family instance declaration, GADT style"A data family instance declaration"A type family instance declarationA data family declaration)A data OR newtype declaration, GADT styleA data OR newtype declaration A closed type family declarationA type family declarationA type declarationKA single derived instance, which may have arguments since it may be a MPTC.Associativity of an operator.*right-associative operator (declared with infixr))left-associative operator (declared with infixl).(non-associative operator (declared with infix)cAn import specification, representing a single explicit item imported (or hidden) from a module.T(C_1,...,C_n)h: a class imported with some of its methods, or a datatype imported with some of its constructors.T(..)f: a class imported with all of its methods, or a datatype imported with all of its constructors.T3: the name of a class, datatype or type synonym. variable.An import declaration.position of the import keyword.name of the module imported. imported  qualified?imported with {-# SOURCE #-}?Import safe?#imported with explicit package nameoptional alias name in an as clause.-optional list of import specifications. The S is  if the names are excluded by hiding.Namespaces for imports/exports.+An item in a module's export specification.module M: re-export a module.T(C_1,...,C_n)h: a class exported with some of its methods, or a datatype exported with some of its constructors.T(..)f: a class exported with all of its methods, or a datatype exported with all of its constructors.TC: a class or datatype exported abstractly, or a type synonym. variable.!A complete Haskell source module.A name (cname/) of a component of a class or data type in an import or export specification.name of a data constructorname of a method or fieldOperators appearing in infix" declarations are never qualified.constructor operator (conop)variable operator (varop)$Possibly qualified infix operators (qop), appearing in expressions.constructor operator (qconop)variable operator (qvarop)An implicit parameter name.%ident, linear implicit parameter?ident, non-linear implicit parameter@This type is used to represent variables, and also constructors.varsym or consymvarid or conid.WThis type is used to represent qualified variables, and also qualified constructors.(built-in constructor with special syntaxunqualified local name!name qualified with a module name{Constructors with special syntax. These names are never qualified, and always refer to builtin type or data constructors.$unboxed singleton tuple constructor (# #)list data constructor (:)n)-ary tuple type and data constructors (,) etc, possibly boxed (#,#)function type constructor ->list type constructor []unit type and data constructor ()The name of a Haskell module.      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#\]^_`ab         !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#~y}|{zvxwsutqrKLMDJIHGFEaponmlkjihgfedcbNVUTSRQPOWYXZ`_^]\[543210/.-,+*)('&%$#"!      9CBA@?>=<;:687\ba`_^]      !#"   g4543210/.-,+*)('&%$#"!      6879 CBA@?>=<;:DJIHGFEKLMNVUTSRQPOWYXZ`_^]\[aponmlkjihgfedcbqrsutvxwy}|{z~       !"# D(c) The GHC Team, 1997-2000, (c) Niklas Broberg 2004$BSD-style (see the file LICENSE.txt)$Niklas Broberg, d00nibro@chalmers.se experimentalportable Safe-Inferred1$dAn identifier with the given string as its name. The string should be a valid Haskell identifier.%OA symbol identifier. The string should be a valid Haskell symbol identifier.&A local variable as expression.'(Use the given identifier as an operator.(#A qualified variable as expression.)A pattern variable.*,Application of expressions by juxtaposition.+Apply an operator infix.,(Apply a function to a list of arguments.-.A constructor pattern, with argument patterns..A tuple expression./A tuple pattern.00A tuple expression consisting of variables only.1-A tuple pattern consisting of variables only.2A function with a given name.3A literal string expression.4A literal character expression.5A literal integer expression.6A literal string pattern.7A literal character pattern.8A literal integer pattern.9\A do block formed by the given statements. The last statement in the list should be a  expression.:PLambda abstraction, given a list of argument patterns and an expression body.;A let ... in block.<A case expression.=An unguarded alternative in a case expression.>(An alternative with a single guard in a case expression.!An unguarded righthand side of a case alternative.)An list of guarded righthand sides for a case alternative.&A single guarded righthand side for a case alternative.?A list expression.@The empty list expression.AThe empty list pattern.B%Put parentheses around an expression.C!Put parentheses around a pattern.D!A qualifier expression statement.EA generator statement: pat <- expFA let binding group as a statement.G/Hoist a set of declarations to a binding group.HAn empty binding group.IThe wildcard pattern: _JDGenerate k names by appending numbers 1 through k to a given string.KA function with a single clauseLXA function with a single clause, a single argument, no guards and no where declarationsMVA pattern bind where the pattern is a variable, and where there are no guards and no 'where' clause.N[A pattern bind where the pattern is a variable, and where there are no guards, but with a 'where' clause.O$Bind an identifier to an expression.P6Apply function of a given name to a list of arguments.QeApply a constructor of a given name to a list of pattern arguments, forming a constructor pattern.1$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQ.$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQ.$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQ1$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQ (c) Niklas Broberg 2009$BSD-style (see the file LICENSE.txt)$Niklas Broberg, d00nibro@chalmers.sestableportable Safe-Inferred+RxAll AST elements that may include expressions which in turn may need fixity tweaking will be instances of this class.STweak any expressions in the element to account for the fixities given. Assumes that all operator expressions are fully left associative chains to begin with.TmOperator fixities are represented by their associativity (left, right or none) and their precedence (0-9).V Built-in fixity for prefix minusW$All fixities defined in the Prelude.X)All fixities defined in the base package.Note that the +++h operator appears in both Control.Arrows and Text.ParserCombinators.ReadP. The listed precedence for ++++ in this list is that of Control.Arrows.'RSThe fixities to account for.The element to tweak.FThe same element, but with operator expressions updated, or a failure.TUVWXYZ[ RSTUVWXYZ[ TU[ZYWXVRS%RSTUVWXYZ[RNiklas Broberg (c) 2004-2009, Original (c) The GHC Team, 1997-2000/BSD-style (see the file libraries/base/LICENSE)$Niklas Broberg, d00nibro@chalmers.sestableportable Safe-InferredMonad for parsing\QStatic parameters governing a parse. Note that the various parse functions in Language.Haskell.Exts.Parser> never look at LANGUAGE pragmas, regardless of what the ignoreLanguagePragmas% flag is set to. Only the various  parseFile functions in Language.Haskell.Exts will act on it, when set to .^&original name of the file being parsed_+base language (e.g. Haskell98, Haskell2010)`&list of extensions enabled for parsingaif W, the parser won't care about further extensions in LANGUAGE pragmas in source filesbif V, the parser won't read line position information from LINE pragmas in source filesclist of fixities to be aware ofdThe result of a parse.eJThe parse failed at the specified source location, with an error message.f&The parse succeeded, yielding a value.ghRetrieve the result of a successful parse, throwing an error if the parse is actually not successful.hDefault parameters for a parse. The default is an unknown filename, no extensions (i.e. Haskell 98), don't ignore LANGUAGE pragmas, do ignore LINE pragmas, and be aware of fixities from the Prelude.HDiscard some input characters (these must not include tabs or newlines).4Discard the next character, which must be a newline. 0Discard the next character, which must be a tab. "lexWhile without the return value. .Add an extension to the current configuration. -Save the current configuration of extensions. 6Return to the previous saved extensions configuration.]\]^_`abc !"#$%&defg'h()*+,-./0123456 789 :;<=>?@ABCDEFGH   IJKLMNOPQRSTU>\]^_`abc !"#defgh)*+,-./236 9 :;<=>?@ABCDEFGH   IJKB\]^_`abc !#"$&%dfeg'h()*+,-./0123456 789 :;<=>?@ABCDEFGH   IJKLMNOPQRSTUI(c) The GHC Team, 1997-2000 (c) Niklas Broberg, 2004-2009$BSD-style (see the file LICENSE.txt)$Niklas Broberg, d00nibro@chalmers.sestableportable Safe-Inferred)]VVChecks whether the character would be legal in some position of a qvar. Means that '..' and AAA will pass the test.W'lexWhiteSpace without the return value.X"Selects ASCII binary digits, i.e. '0'..'1'.ijklmnopqrstuvwxyz{|}~YZ[\]^_`VabcdWefghijklmnopqrstuvwxyz{|}~Xijklmnopqrstuvwxyz{|}~bc-i~}|{zyxwvutsrqponmlkjYZ[\]^_`VabcdWefghijklmnopqrstuvwxyz{|}~X I(c) The GHC Team, 1997-2000 (c) Niklas Broberg, 2004-2012$BSD-style (see the file LICENSE.txt)*Niklas Broberg, niklas.broberg@chalmers.sestableportable Safe-Inferred7Lex a string into a list of Haskell 2010 source tokens.JLex a string into a list of Haskell source tokens, using an explicit mode.ijklmnopqrstuvwxyz{|}~i~}|{zyxwvutsrqponmlkj (c) Niklas Broberg 2009$BSD-style (see the file LICENSE.txt)$Niklas Broberg, d00nibro@chalmers.se experimentalportable Safe-InferredTranslate an annotated AST node representing a Haskell module, into a simpler version that retains (almost) only abstract information. In particular, XML and hybrid XML pages enabled by the XmlSyntax extension are translated into standard Haskell modules with a page function.Translate an annotated AST node representing a Haskell declaration into a simpler version. Note that in the simpler version, all declaration nodes are still annotated by s.F      !"#$%&'()*+,-./0123456789:;<=>?@ABCF      !"#$%&'()*+,-./0123456789:;<=>?@ABCF      !"#$%&'()*+,-./0123456789:;<=>?@ABCF      !"#$%&'()*+,-./0123456789:;<=>?@ABCY(c) Niklas Broberg 2004-2009, (c) The GHC Team, Noel Winstanley 1997-2000$BSD-style (see the file LICENSE.txt)$Niklas Broberg, d00nibro@chalmers.sestableportable Safe-InferredDKThings that can be pretty-printed, including all the syntactic objects in Language.Haskell.Exts.Syntax and &Language.Haskell.Exts.Annotated.Syntax.$Pretty-print something in isolation./Pretty-print something in a precedence context.;The document type produced by these pretty printers uses a E environment.Pretty printing monadEPretty-printing parameters.Note: the M2 must be positive and less than all other indents.G"indentation of a class or instanceHindentation of a do -expressionIindentation of the body of a case expressionJ$indentation of the body of a multi-if expressionK&indentation of the declarations in a let expressionL&indentation of the declarations in a where clauseMIindentation added for continuation lines that would otherwise be offsideNblank lines between statements?OPretty-printing style to usePadd GHC-style LINE pragmas to output?RVarieties of layout we can use.Severything on a single lineT(inline decls, with newlines between themUclassical layout made explicitVclassical layoutWMThe default mode: pretty-print using the offside rule and sensible defaults.0render the document with a given style and mode.X}render the document with a given mode. renderWithMode :: PPHsMode -> Doc -> String renderWithMode = renderStyleMode P.stylerender the document with W?. render :: Doc -> String render = renderWithMode defaultMode)pretty-print with a given style and mode.Y5pretty-print with the default style and a given mode.Z(pretty-print with the default style and W.7Indent without braces. Useful for deriving clauses etc.DEFGHIJKLMNOPQRSTUVWXYZ      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ" DEFGHIJKLMNOPQRSTUVWXYZ"DXYZ  EFGHIJKLMNOPQRVUTSWDE FGHIJKLMNOPQRVUTSWXYZ      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZI(c) Niklas Broberg 2004-2009, (c) The GHC Team, 1997-2000$BSD-style (see the file LICENSE.txt)$Niklas Broberg, d00nibro@chalmers.sestableportable Safe-Inferred[|Checks whether the parameter is a symbol, and gives a nice warning for "." if ExplicitForAll/TypeOperators are not enabled.\-Add a strictness/unpack annotation on a type.M]^_`abcdef[ghijklmnopqrstuvwxyz{|}~\,-./0123459:;<=>?@A      !"#$%&'()*+BCD_`abcdehklorsz\M]^_`abcdef[ghijklmnopqrstuvwxyz{|}~\(c) Niklas Broberg 2009$BSD-style (see the file LICENSE.txt)$Niklas Broberg, d00nibro@chalmers.sestableportable Safe-Inferred[xAll AST elements that may include expressions which in turn may need fixity tweaking will be instances of this class.\Tweak any expressions in the element to account for the fixities given. Assumes that all operator expressions are fully left associative chains to begin with. [\The fixities to account for.The element to tweak.FThe same element, but with operator expressions updated, or a failure. TUWXYZ[[\ TU[ZYWX[\[\](c) Niklas Broberg 2004-2009, Original (c) Simon Marlow, Sven Panne 1997-2000$BSD-style (see the file LICENSE.txt)$Niklas Broberg, d00nibro@chalmers.sestableportableNone! *+-./02345689:;<=?BCDFGHJKM]BParse of a string, which should contain a complete Haskell module.^OParse of a string containing a complete Haskell module, using an explicit mode._cParse of a string containing a complete Haskell module, using an explicit mode, retaining comments.`2Parse of a string containing a Haskell expression.aJParse of a string containing a Haskell expression, using an explicit mode.bcParse of a string containing a complete Haskell module, using an explicit mode, retaining comments.c/Parse of a string containing a Haskell pattern.dGParse of a string containing a Haskell pattern, using an explicit mode.ecParse of a string containing a complete Haskell module, using an explicit mode, retaining comments.f=Parse of a string containing a Haskell top-level declaration.gUParse of a string containing a Haskell top-level declaration, using an explicit mode.hcParse of a string containing a complete Haskell module, using an explicit mode, retaining comments.i,Parse of a string containing a Haskell type.jDParse of a string containing a Haskell type, using an explicit mode.kcParse of a string containing a complete Haskell module, using an explicit mode, retaining comments.l1Parse of a string containing a Haskell statement.mDParse of a string containing a Haskell type, using an explicit mode.ncParse of a string containing a complete Haskell module, using an explicit mode, retaining comments.MPartial parse of a string starting with a series of top-level option pragmas.BParse of a string, which should contain a complete Haskell module.OParse of a string containing a complete Haskell module, using an explicit mode.cParse of a string containing a complete Haskell module, using an explicit mode, retaining comments.                           ! " # $ % & ' ( ) * + , - . / 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 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 { | } ~        !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0]^_`abcdefghijklmn123456789:;<=>?@ABCDEFGH#\]^_`abcdefgh]^_`abcdefghijklmn                           ! " # $ % & ' ( ) * + , - . / 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 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 { | } ~        !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0]^_`abcdefghijklmn123456789:;<=>?@ABCDEFGH  . I(c) The GHC Team, 1997-2000 (c) Niklas Broberg, 2004-2012$BSD-style (see the file LICENSE.txt)*Niklas Broberg, niklas.broberg@chalmers.sestableportableNoneo:Class to reuse the parse function at many different types.p!Parse a string with default mode.q%Parse a string with an explicit mode.rJParse a string with an explicit mode, returning all comments along the ASTtBParse of a string, which should contain a complete Haskell module.uOParse of a string containing a complete Haskell module, using an explicit mode.vcParse of a string containing a complete Haskell module, using an explicit mode, retaining comments.w2Parse of a string containing a Haskell expression.xJParse of a string containing a Haskell expression, using an explicit mode.ycParse of a string containing a complete Haskell module, using an explicit mode, retaining comments.z/Parse of a string containing a Haskell pattern.{GParse of a string containing a Haskell pattern, using an explicit mode.|cParse of a string containing a complete Haskell module, using an explicit mode, retaining comments.}=Parse of a string containing a Haskell top-level declaration.~UParse of a string containing a Haskell top-level declaration, using an explicit mode.cParse of a string containing a complete Haskell module, using an explicit mode, retaining comments.,Parse of a string containing a Haskell type.DParse of a string containing a Haskell type, using an explicit mode.cParse of a string containing a complete Haskell module, using an explicit mode, retaining comments.,Parse of a string containing a Haskell type.DParse of a string containing a Haskell type, using an explicit mode.cParse of a string containing a complete Haskell module, using an explicit mode, retaining comments."opqrstuvwxyz{|}~IJKLMNOPQRS$\]^_`abcdefghopqrstuvwxyz{|}~$opqr\]^_`abchdfegtuvwxyz{|}~sopqrstuvwxyz{|}~IJKLMNOPQRS(c) Niklas Broberg 2004-2009$BSD-style (see the file LICENSE.txt)$Niklas Broberg, d00nibro@chalmers.sestableportableNone:Parse a source file on disk, using the default parse mode.vParse a source file on disk, with an extra set of extensions to know about on top of what the file itself declares.;Parse a source file on disk, supplying a custom parse mode.?Parse a source file from a string using the default parse mode.|Parse a source file from a string, with an extra set of extensions to know about on top of what the file itself declares.<Parse a source file from a string using a custom parse mode.VGather the extensions declared in LANGUAGE pragmas at the top of the file. Returns & if the parse of the pragmas fails. TUp  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~TUWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~DEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqr]^_`ablmncdefghijk TU(c) Niklas Broberg 2004-2009$BSD-style (see the file LICENSE.txt)$Niklas Broberg, d00nibro@chalmers.sestableportableNone :Parse a source file on disk, using the default parse mode.vParse a source file on disk, with an extra set of extensions to know about on top of what the file itself declares.;Parse a source file on disk, supplying a custom parse mode.SParse a source file on disk, supplying a custom parse mode, and retaining comments.pParse a source file on disk, supplying a custom parse mode, and retaining comments as well as unknown pragmas.?Parse a source file from a string using the default parse mode.|Parse a source file from a string, with an extra set of extensions to know about on top of what the file itself declares.<Parse a source file from a string using a custom parse mode.SParse a source file from a string using a custom parse mode and retaining comments.mParse a source file from a string using a custom parse mode retaining comments as well as unknown pragmas.VGather the extensions declared in LANGUAGE pragmas at the top of the file. Returns & if the parse of the pragmas fails.V]Converts a parse result with comments to a parse result with comments and unknown pragmas.WXV3 \]^_`ab    !"#&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~DEFGHIJKLMNOPQRSTUVWXYZopqrstuvwxyz{|}~ WXVY !"#$%&&'()'*+,-./*0123456789:;<=>?@ABCDEFGHIIJKLMNOPQRSTUVWXYZ[\]^_`abcdedffghijkjlmnopqrstuvwxyz{|}~      !!"#$%&'()*+,-./0123456789:;;<=>?@ABCDEFGHIJKLMNO PQRSTUVWXYZ[\]^_`abbccdefghijklmnopqrstuuvvwxywz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~&&'()'*+,-./*0123456789:;<=>?@ABCDEFGHIIJKLMNOPQRSTUVWXYZ[\]^_`abcdedffghijkjltuvwxyz{|}~      /0123456789:;;<=>?@ABCDEFGHIJKLMNO PQRSTUVWX!YZ[\]^_`accefghijklmnopqrstwwz{|}~                                                              !"#$%&'()*+,-./01234 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:;<=>?@ABCDEFGHIJKLMNO$$%%MPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~MNC@      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnoopqrsstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                  ! " # $ % & ' ( ) * + , - . / 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 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 { | } ~                                                                              f                               haskell-src-exts-1.16.0.1Language.Haskell.Exts.Pretty&Language.Haskell.Exts.Annotated.Syntax%Language.Haskell.Exts.Annotated.BuildLanguage.Haskell.Exts.SrcLocLanguage.Haskell.Exts.Comments*Language.Haskell.Exts.Annotated.ExactPrintLanguage.Haskell.Exts.ExtensionLanguage.Haskell.Exts.SyntaxLanguage.Haskell.Exts.BuildLanguage.Haskell.Exts.FixityLanguage.Haskell.Exts.ParserLanguage.Haskell.Exts.Lexer(Language.Haskell.Exts.Annotated.Simplify&Language.Haskell.Exts.Annotated.FixityLanguage.Haskell.Exts.AnnotatedLanguage.Haskell.Exts!Language.Haskell.Exts.ParseSyntaxLanguage.Haskell.Exts.ExtScheme Language.Haskell.Exts.ParseMonad#Language.Haskell.Exts.InternalLexer Language.Haskell.Exts.ParseUtils$Language.Haskell.Exts.InternalParserpretty-1.1.1.1Text.PrettyPrint.HughesPJstyleribbonsPerLine lineLengthmodeStylePageMode ZigZagModeLeftMode OneLineModeMode AnnotatedannamapAlt FieldUpdate FieldWildcardFieldPunQualStmt GroupByUsing GroupUsingGroupByThenBy ThenTransStmtRecStmtLetStmt Qualifier GeneratorPatFieldPFieldWildcard PFieldPun PFieldPatRPatRPPatRPParenRPAsRPCAsRPGuardRPSeqRPEitherRPOpRPatOpRPOptGRPOptRPPlusGRPPlusRPStarGRPStarPXAttrPatPBangPat PQuasiQuotePXRPatsPXPatTagPXPcdataPXETagPXTagPRPatPViewPat PatTypeSigPIrrPat PWildCardPAsPatPRecPParenPListPTuplePApp PInfixAppPNPlusKPLitPVar WarningTextWarnTextDeprTextRuleVar TypedRuleVarRule Activation ActiveUntil ActiveFromOverlap Incoherent NoOverlapTool UnknownToolHADDOCKYHCNHC98HUGSGHC ModulePragmaAnnModulePragma OptionsPragmaLanguagePragmaCallConvCApiJsJvmDotNet CPlusPlusCCallStdCallSafetyPlayInterruptiblePlaySafe PlayRiskySplice ParenSpliceIdSpliceBracket DeclBracket TypeBracket PatBracket ExpBracketXAttrXNameXDomNameExpLCaseRightArrHighAppLeftArrHighApp RightArrApp LeftArrAppProc GenPragma SCCPragma CorePragma XChildTagXExpTagXPcdataXETagXTag QuasiQuote SpliceExp BracketExpTypQuoteVarQuote ExpTypeSig ParArrayCompParCompListCompParArrayFromThenToParArrayFromToEnumFromThenTo EnumFromThen EnumFromToEnumFrom RecUpdate RecConstr RightSection LeftSectionParenParArrayList TupleSectionTupleMDoDoCaseMultiIfIfLetLambdaNegAppAppInfixAppLitConIPVarVarSignNegativeSignlessLiteral PrimStringPrimChar PrimDouble PrimFloatPrimWordPrimIntFracIntStringCharAsstParenAEqualPIParamInfixAVarAClassAContextCxEmptyCxTupleCxSingleFunDepKindKindList KindTupleKindAppKindVar KindParenKindFnKindBangKindStar TyVarBind UnkindedVar KindedVarBoxedUnboxedPromoted PromotedUnit PromotedTuple PromotedList PromotedConPromotedStringPromotedIntegerTypeTyBangTySpliceTyEquals TyPromotedTyKindTyInfixTyParenTyConTyVarTyApp TyParArrayTyListTyTupleTyFunTyForall GuardedRhsRhs GuardedRhss UnGuardedRhsBangType UnpackedTyBangedTyInstDeclInsGDataInsDataInsTypeInsDecl ClassDecl ClsDefSigClsTyDefClsTyFam ClsDataFamClsDeclGadtDecl FieldDeclConDeclRecDecl InfixConDecl QualConDeclMatch InfixMatchIPBindBindsIPBindsBDeclsDerivingInstHeadIHAppIHParenIHInfixIHConInstRuleIParenIRuleDeclHeadDHAppDHParenDHInfixDHead DataOrNewNewTypeDataTypeBooleanFormula ParenFormula OrFormula AndFormula VarFormula Annotation ModuleAnnTypeAnnAnnTypeEqnDecl MinimalPragma AnnPragmaInstSig SpecInlineSigSpecSigInlineConlikeSig InlineSigWarnPragmaDeclDeprPragmaDeclRulePragmaDeclForExpForImpPatBindFunBindTypeSig SpliceDecl DefaultDecl InfixDecl DerivDecl GDataInsDecl DataInsDecl TypeInsDecl DataFamDecl GDataDeclDataDeclClosedTypeFamDecl TypeFamDeclTypeDeclAssoc AssocRight AssocLeft AssocNone ImportSpec IThingWith IThingAllIAbsIVarImportSpecList ImportDecl importAnn importModuleimportQualified importSrc importSafe importPkgimportAs importSpecs Namespace TypeNamespace NoNamespace ExportSpecEModuleContents EThingWith EThingAllEAbsEVarExportSpecList ModuleHeadModule XmlHybridXmlPageCNameConNameVarNameOpConOpVarOpQOpQConOpQVarOpIPNameIPLinIPDupNameSymbolIdentQNameSpecialUnQualQual SpecialConUnboxedSingleConConsTupleConFunConListConUnitCon ModuleName prelude_modmain_mod main_name unit_con_nametuple_con_namelist_cons_nameunboxed_singleton_con_nameunit_con tuple_conunboxed_singleton_conas_namequalified_name hiding_name minus_name bang_namedot_name star_name export_name safe_name unsafe_nameinterruptible_namethreadsafe_name stdcall_name ccall_namecplusplus_name dotnet_namejvm_namejs_name capi_name forall_name family_nameunit_tycon_namefun_tycon_namelist_tycon_nameunboxed_singleton_tycon_nametuple_tycon_name unit_tycon fun_tycon list_tyconunboxed_singleton_tycon tuple_tycon=~=namesymvaropqvarpvarappinfixAppappFunpApptuplepTuplevarTuple pvarTuplefunctionstrEcharEintEstrPcharPintPdoElamEletEcaseEaltaltGWlistEeListpeListparenpParenqualStmtgenStmtletStmtbindsnoBindswildcardgenNamessfun simpleFunpatBind patBindWherenameBind metaFunction metaConPatSrcInfo toSrcInfo fromSrcInfo getPointLocfileName startLine startColumn SrcSpanInfo srcInfoSpan srcInfoPointsLoclocunLocSrcSpansrcSpanFilenamesrcSpanStartLinesrcSpanStartColumnsrcSpanEndLinesrcSpanEndColumnSrcLoc srcFilenamesrcLine srcColumnnoLoc srcSpanStart srcSpanEnd mkSrcSpan mergeSrcSpan isNullSpanspanSize noInfoSpaninfoSpan combSpanInfo<++><+?><**<^^>$fSrcInfoSrcSpanInfo$fSrcInfoSrcSpan$fSrcInfoSrcLoc $fShowSrcSpan $fShowSrcLoc UnknownPragmaCommentExactP exactPrintKnownExtensionConstraintKindsDefaultSignatures TrustworthySafe SafeImports MultiWayIf PolyKinds DataKindsExplicitNamespacesCApiFFIInterruptibleFFINondecreasingIndentationDeriveFoldableDeriveTraversable DeriveGeneric DeriveFunctorMonoLocalBindsDatatypeContextsExplicitForAllRebindableSyntaxDoAndIfThenElseNPlusKPatternsGHCForeignImportPrim TupleSectionsRegularPatterns XmlSyntax ViewPatternsTransformListComp QuasiQuotesPostfixOperatorsNewQualifiedOperatorsImpredicativeTypes LambdaCasePackageImportsConstrainedClassMethodsDeriveDataTypeable UnboxedTuplesExtendedDefaultRulesRelaxedPolyRec MonoPatBindsGADTsOverloadedStringsDisambiguateRecordFields RecordPunsRecordWildCardsParallelArrays TypeOperatorsLiberalTypeSynonymsUnliftedFFITypes UnicodeSyntaxStandaloneDeriving TypeFamiliesBinaryLiterals MagicHash HereDocumentsRestrictedTypeSynonymsExtensibleRecordsGeneralizedNewtypeDeriving PatternGuardsNamedFieldPunsImplicitPreludeGenericsArrowsForeignFunctionInterfaceTemplateHaskellTypeSynonymInstances BangPatternsKindSignaturesCPPEmptyDataDeclsFlexibleInstancesFlexibleContextsImplicitParamsPatternSignaturesScopedTypeVariablesExistentialQuantificationPolymorphicComponents RankNTypes Rank2TypesFunctionalDependenciesMonomorphismRestrictionMultiParamTypeClassesParallelListComp RecursiveDoDoRec InstanceSigsIncoherentInstancesUndecidableInstancesOverlappingInstances ExtensionUnknownExtensionDisableExtensionEnableExtensionLanguageUnknownLanguageHaskellAllDisabled Haskell2010 Haskell98knownLanguagesclassifyLanguageprettyLanguage impliesExts glasgowExts ghcDefaultknownExtensionsdeprecatedExtensionsclassifyExtensionparseExtensionprettyExtensiontoExtensionList AlwaysActive importLoc AppFixity applyFixitiesFixityprefixMinusFixitypreludeFixities baseFixitiesinfixr_infixl_infix_ ParseMode parseFilename baseLanguage extensionsignoreLanguagePragmasignoreLinePragmasfixities ParseResult ParseFailedParseOkfromParseResultdefaultParseModeTokenEOFKW_CApiKW_JsKW_Jvm KW_DotNet KW_CPlusPlusKW_CCall KW_StdCallKW_Interruptible KW_Threadsafe KW_UnsafeKW_Safe KW_Export KW_Foreign KW_QualifiedKW_WhereKW_UsingKW_TypeKW_ThenKW_RecKW_ProcKW_Of KW_NewType KW_ModuleKW_Let KW_Instance KW_InfixR KW_InfixLKW_InfixKW_In KW_ImportKW_If KW_HidingKW_Group KW_Forall KW_FamilyKW_ElseKW_MDoKW_Do KW_Deriving KW_DefaultKW_DataKW_ClassKW_CaseKW_ByKW_As INCOHERENTOVERLAP NO_OVERLAPMINIMALANNLANGUAGEOPTIONSUNPACKCORE GENERATEDSCCWARNING DEPRECATEDSOURCESPECIALISE_INLINE SPECIALISEINLINE_CONLIKEINLINERULES PragmaEnd XRPatClose XRPatOpenXPCDATA XChildTagOpenXEmptyTagClose XCloseTagOpen XStdTagClose XStdTagOpen XCodeTagClose XCodeTagOpenRPCAt RPGuardClose RPGuardOpen THQuasiQuote THTyQuote THVarQuote THParenEscape THIdEscape THCloseQuote THTypQuote THDecQuote THPatQuote THExpQuoteRightDblArrowTailLeftDblArrowTailRightArrowTail LeftArrowTailStar ExclamationMinus DoubleArrowTildeAt RightArrow LeftArrowBar BackslashEquals DoubleColon QuoteColonColonDotDotDot BackQuote UnderscoreCommaParArrayRightSquareParArrayLeftSquare RightSquare LeftSquare VRightCurly RightCurly LeftCurly SemiColonRightHashParen LeftHashParen RightParen LeftParen StringHash CharacterHash DoubleTokHash FloatTokHash WordTokHash IntTokHash StringTok CharacterFloatTokIntTokQConSymQVarSymConSymVarSymDVarIdQConIdConId ILinVarId IDupVarIdQVarIdVarId showTokenlexTokenStreamlexTokenStreamWithModesModulesDeclsTypeEqn sAnnotationsBooleanFormula sModuleName sSpecialConsQNamesNamesIPNamesQOpsOpsCName sModuleHeadsExportSpecList sExportSpec sImportDeclsImportSpecList sNamespace sImportSpecsAssoc sDeclHead sInstRule sInstHead sDataOrNew sDerivingsBindssIPBindsMatch sQualConDeclsConDecl sFieldDecl sGadtDecl sClassDecl sRecFields sInstDecl sBangTypesRhs sGuardedRhssType sPromoted sTyVarBindsKindsFunDepsContextsAsstsLiteralsSignsExpsXNamesXAttrsBracketsSplicesSafety sCallConv sModulePragmasOverlap sActivationsRulesRuleVar sWarningTextsPatsPXAttrsRPatOpsRPat sPatFieldsStmt sQualStmt sFieldUpdatesAltPrettyPPHsMode classIndentdoIndent multiIfIndent caseIndent letIndent whereIndent onsideIndentspacinglayout linePragmasIndentPPLayout PPNoLayoutPPInLine PPSemiColon PPOffsideRule defaultModeprettyPrintStyleModeprettyPrintWithMode prettyPrint parseModuleparseModuleWithModeparseModuleWithCommentsparseExpparseExpWithModeparseExpWithCommentsparsePatparsePatWithModeparsePatWithComments parseDeclparseDeclWithModeparseDeclWithComments parseTypeparseTypeWithModeparseTypeWithComments parseStmtparseStmtWithModeparseStmtWithComments Parseableparse parseWithModeparseWithComments getTopPragmas parseFileparseFileWithExtsparseFileWithModeparseFileWithCommentsparseFileContentsparseFileContentsWithExtsparseFileContentsWithModeparseFileContentsWithCommentsreadExtensionsparseFileWithCommentsAndPragmas'parseFileContentsWithCommentsAndPragmasbaseGHC.Basefmapghc-prim GHC.TypesFalseTrue Data.MaybeMaybeNothing$fAnnotatedPromoted$fAnnotatedAlt$fAnnotatedFieldUpdate$fAnnotatedQualStmt$fAnnotatedStmt$fAnnotatedPatField$fAnnotatedRPat$fAnnotatedRPatOp$fAnnotatedPXAttr$fAnnotatedPat$fAnnotatedWarningText$fAnnotatedRuleVar$fAnnotatedRule$fAnnotatedActivation$fAnnotatedOverlap$fAnnotatedModulePragma$fAnnotatedCallConv$fAnnotatedSafety$fAnnotatedSplice$fAnnotatedBracket$fAnnotatedXAttr$fAnnotatedXName$fAnnotatedExp$fAnnotatedSign$fAnnotatedLiteral$fAnnotatedAsst$fAnnotatedContext$fAnnotatedFunDep$fAnnotatedKind$fAnnotatedTyVarBind$fAnnotatedType$fAnnotatedGuardedRhs$fAnnotatedRhs$fAnnotatedBangType$fAnnotatedInstDecl$fAnnotatedClassDecl$fAnnotatedGadtDecl$fAnnotatedFieldDecl$fAnnotatedConDecl$fAnnotatedQualConDecl$fAnnotatedMatch$fAnnotatedIPBind$fAnnotatedBinds$fAnnotatedInstHead$fAnnotatedInstRule$fAnnotatedDeclHead$fAnnotatedDataOrNew$fAnnotatedBooleanFormula$fAnnotatedAnnotation$fAnnotatedDecl$fAnnotatedTypeEqn$fAnnotatedDeriving$fAnnotatedAssoc$fAnnotatedImportSpec$fAnnotatedImportSpecList$fAnnotatedImportDecl$fAnnotatedNamespace$fAnnotatedExportSpec$fAnnotatedExportSpecList$fAnnotatedModuleHead$fAnnotatedModule$fAnnotatedCName $fAnnotatedOp$fAnnotatedQOp$fAnnotatedIPName$fAnnotatedName$fAnnotatedQName$fAnnotatedSpecialCon$fAnnotatedModuleNameTyPredBangPatXRPatsCAsRPEitherRPGuardRPSeqRPViewPatPreOpPostOpIrrPatWildCardAsPatPAsstPTypePContext ParseXAttr PFieldUpdatePExp p_unit_con p_tuple_conp_unboxed_singleton_con$fAnnotatedPAsst$fAnnotatedPType$fAnnotatedPContext$fAnnotatedParseXAttr$fAnnotatedPFieldUpdate$fAnnotatedPExpunGAltgAltsgAltBool GuardedAlt GuardedAltsexactPEPPosposrunEPgetPossetPos printString getComment dropCommentnewLinepadUntilmPrintComments printCommentprintWhitespace printStringAterrorEPexactPCprintSeq printStrs printPointsprintInterleavedprintInterleaved' printStreams interleavemaybeEP bracketListpListpList' parenList squareListsquareColonList curlyList parenHashList layoutListlListlList' printSemiisSymbolgetName specialNameepQName epInfixQNameepName epInfixNameprintWarndeprs sepFunBindssepClassFunBindssepInstFunBinds printContext internalError$fExactPIPBind$fExactPFieldDecl$fExactPActivation$fExactPOverlap$fExactPRuleVar $fExactPRule$fExactPSafety$fExactPCallConv $fExactPBinds $fExactPXName$fExactPPXAttr$fExactPRPatOp $fExactPRPat$fExactPPatField $fExactPPat$fExactPGuardedAlt$fExactPGuardedAlts$fAnnotatedGuardedAlt$fAnnotatedGuardedAlts$fExactPGuardedRhs $fExactPRhs $fExactPMatch $fExactPAlt $fExactPXAttr$fExactPBracket$fExactPQualStmt $fExactPStmt$fExactPFieldUpdate $fExactPExp$fExactPSplice$fExactPBangType$fExactPGadtDecl$fExactPConDecl$fExactPQualConDecl$fExactPFunDep$fExactPInstDecl$fExactPClassDecl$fExactPDeriving $fExactPAsst$fExactPContext$fExactPPromoted $fExactPType $fExactPKind$fExactPTyVarBind$fExactPInstHead$fExactPInstRule$fExactPDeclHead$fExactPBooleanFormula$fExactPAnnotation $fExactPDecl$fExactPTypeEqn$fExactPDataOrNew $fExactPAssoc$fExactPWarningText$fExactPModulePragma$fExactPModuleHead$fExactPModule$fExactPImportDecl$fExactPImportSpec$fExactPImportSpecList$fExactPExportSpecList$fExactPExportSpec$fExactPNamespace $fExactPCName $fExactPOp $fExactPQOp$fExactPIPName $fExactPName $fExactPQName$fExactPSpecialCon$fExactPModuleName $fExactPSign$fExactPLiteral $fMonadEP$fApplicativeEP $fFunctorEPGHC.ListzipWithallLangDefaultclassifyKnownExtensionknownExtensionTablereadMayEnabled isEnabled MExtScheme ExtSchemeAllAny$fEnabledMaybe$fEnabledExtScheme$fEnabledKnownExtension askFixity askFixityPaskFixfixity appFixDeclsleafFixleafFixP$fAppFixityXAttr$fAppFixitySplice$fAppFixityBracket$fAppFixityQualStmt$fAppFixityAlt$fAppFixityFieldUpdate$fAppFixityIPBind$fAppFixityBinds$fAppFixityStmt$fAppFixityPXAttr$fAppFixityRPat$fAppFixityPatField$fAppFixityGuardedRhs$fAppFixityRhs$fAppFixityMatch$fAppFixityInstDecl$fAppFixityClassDecl$fAppFixityAnnotation$fAppFixityDecl$fAppFixityModule$fAppFixityPat$fAppFixityExpPdiscard lexNewlinelexTab lexWhile_ addExtensionLsaveExtensionsLrestoreExtensionsLLexrunLrunPInternalParseMode IParseModeiParseFilename iExtensionsiIgnoreLinePragmas ParseStateCtxtFlag ExtContext CodeTagCtxt CloseTagCtxt ChildCtxtTagCtxtHarpCtxtCodeCtxt LexContextLayoutNoLayout ParseStatusFailedOkindentOfParseStatetoInternalParseModerunParserWithMode runParserrunParserWithModeCommentsatSrcLoc getSrcLoc getModuleNamepushCurrentContext currentIndent pushContext popContext getExtensions pushCtxtFlag pullDoStatusgetInputnextTab tAB_LENGTHlexWhile alternativecheckBOLsetBOL startToken getOffside getSrcLocL setSrcLineL pushContextL popContextL pullCtxtFlagflagDo getExtContextpushExtContextLpopExtContextLgetExtensionsLignoreLinePragmasLsetLineFilenameL pushComment $fMonadLex$fApplicativeLex $fFunctorLex$fMonadP$fApplicativeP $fFunctorP$fMonoidParseResult$fMonadParseResult$fApplicativeParseResult$fFunctorParseResultisPossiblyQvarlexWhiteSpace_ isBinDigit reserved_opsspecial_varops reserved_idsspecial_varidspragmasisIdent isHSymbol isPragmaChar matchCharlexertopLexer lexWhiteSpaceisRecognisedPragma isLinePragma lexLinePragmalexNestedCommentlexBOLlexToken lexChildCtxt lexPCDATAlexCodeTagCtxtlexCloseTagCtxt lexTagCtxt lexHarpToken lexStdTokenlookupKnownPragmalexPragmaStart lexRawPragmalexDecimalOrFloatlexHashlexConIdOrQual lexCharacter lexString lexEscapelexOctal lexBinarylexHexadecimal lexDecimal parseIntegerflagKWpretty prettyPrecDocDocMrenderStyleModeppIndentthenDocM then_DocMretDocMunDocMgetPPEnvemptynesttextcharintintegerfloatdoubleparensbracketsbraces doubleQuotesparensIfsemicommaspaceequals<><+>$$hcathsepvcatfsep punctuateppModuleHeader ppWarnTxtppWhereppSig ppWarnDepr ppRuleVarsppField ppDerivingppBTypeppAType prec_btype prec_atypeppForall ppOptKind ppFunDepsppLetExp ppBracket ppLetStmt ppQNameInfixppQName ppNameInfixppName isSymbolNamegetSpecialName ppContext colonFollowmaybePP hashParenList braceListbracketColonList flatBlock prettyBlock blanklinetopLevelppBody$$$mySepmyVcat myFsepSimplemyFsep layoutChoicemarkLine $fPrettyPType $fPrettyPAsst$fPrettyPContext$fPrettyParseXAttr$fPrettyPFieldUpdate $fPrettyPExp $fPrettyAsst$fPrettyContext $fPrettyCName$fPrettyIPBind$fPrettyIPName $fPrettyName $fPrettyOp $fPrettyQName $fPrettyQOp$fPrettyFieldUpdate$fPrettyQualStmt $fPrettyStmt $fPrettyAlt$fPrettyRPatOp $fPrettyRPat$fPrettyPatField$fPrettyPXAttr $fPrettyPat$fPrettySplice$fPrettyBracket $fPrettyXName $fPrettyXAttr $fPrettyExp$fPrettyLiteral$fPrettyGuardedRhs $fPrettyRhs$fPrettyFunDep $fPrettyKind$fPrettyTyVarBind $fPrettyType$fPrettyDeriving$fPrettyBangType$fPrettyFieldDecl$fPrettyConDecl$fPrettyGadtDecl$fPrettyQualConDecl$fPrettyAnnotation$fPrettyModulePragma$fPrettyRuleVar$fPrettyActivation $fPrettyRule$fPrettyCallConv$fPrettySafety$fPrettyInstDecl$fPrettyClassDecl $fPrettyMatch $fPrettyAssoc$fPrettyDataOrNew$fPrettyInstHead$fPrettyInstRule$fPrettyDeclHead $fPrettyDecl$fPrettyImportSpec$fPrettyImportSpecList$fPrettyImportDecl$fPrettyExportSpec$fPrettyExportSpecList$fPrettyModuleName$fPrettyWarningText$fPrettyModuleHead$fPrettyModule$fPrettySrcSpan$fPrettySrcLoc $fPrettyAsst0$fPrettySpecialCon$fPrettyCName0$fPrettyIPBind0$fPrettyIPName0 $fPrettyName0 $fPrettyOp0$fPrettyQName0 $fPrettyQOp0$fPrettyFieldUpdate0$fPrettyQualStmt0 $fPrettyStmt0 $fPrettyAlt0$fPrettyRPatOp0 $fPrettyRPat0$fPrettyPatField0$fPrettyPXAttr0 $fPrettyPat0$fPrettySplice0$fPrettyBracket0$fPrettyXName0$fPrettyXAttr0 $fPrettyExp0$fPrettyLiteral0$fPrettyGuardedAlt$fPrettyGuardedAlts$fPrettyGuardedRhs0 $fPrettyRhs0$fPrettyFunDep0 $fPrettyKind0$fPrettyTyVarBind0$fPrettyPromoted $fPrettyType0$fPrettyBangType0$fPrettyConDecl0$fPrettyGadtDecl0$fPrettyQualConDecl0 $fPrettyTool$fPrettyModulePragma0$fPrettyRuleVar0$fPrettyOverlap$fPrettyActivation0 $fPrettyRule0$fPrettyCallConv0$fPrettySafety0$fPrettyInstDecl0$fPrettyClassDecl0$fPrettyMatch0$fPrettyAssoc0$fPrettyDataOrNew0$fPrettyBooleanFormula$fPrettyAnnotation0 $fPrettyDecl0$fPrettyTypeEqn$fPrettyImportSpec0$fPrettyImportDecl0$fPrettyExportSpec0$fPrettyModuleName0$fPrettyModule0 $fMonadDocM$fApplicativeDocM $fFunctorDocMcheckAndWarnTypeOperatorsbangTypeSL splitTyConApp checkEnabledcheckEnabledOneOfcheckPatternGuards checkToplevel checkPContextcheckAssertion getSymbol checkSContext checkContext checkAsstcheckAsstParamcheckDataHeadercheckClassHeader checkSimple mkTyVarBindcheckInstHeader checkInstscheckInstsGuts checkDeriving checkPatterncheckPatisNegatableLiteral splitBang checkPatField checkPAttrpatFail checkRPattern checkRPatOprpOpFail fixRPOpPrec mkChildrenPat checkExpr checkAttrcheckDo check1Expr check2Exprs check3ExprscheckManyExprs mCheckExpr checkRuleExprreadTool checkField getGConName checkValDefisFunLhs checkSigVarcheckClassBody checkInstBodycheckMethodDefcheckDefSigDef checkUnQualcheckQualOrUnQual checkEqNames checkPrecmkRecConstrOrUpdateupdateQNameLoc checkRevDeclscheckRevClsDeclscheckRevInstDeclscheckDataOrNewcheckDataOrNewGcheckSimpleType checkTypecheckT check1Type check2Types checkTypes checkKindcheckPageModulecheckHybridModulemkDVar mkTyForall getFixities getFixity parseModulesparseModulesWithModeparseModulesWithComments HappyAddrHappyA#HappyStk Happy_IntList HappyConsHappyAny HappyAbsSyn 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 happyIn100 happyOut100 happyIn101 happyOut101 happyIn102 happyOut102 happyIn103 happyOut103 happyIn104 happyOut104 happyIn105 happyOut105 happyIn106 happyOut106 happyIn107 happyOut107 happyIn108 happyOut108 happyIn109 happyOut109 happyIn110 happyOut110 happyIn111 happyOut111 happyIn112 happyOut112 happyIn113 happyOut113 happyIn114 happyOut114 happyIn115 happyOut115 happyIn116 happyOut116 happyIn117 happyOut117 happyIn118 happyOut118 happyIn119 happyOut119 happyIn120 happyOut120 happyIn121 happyOut121 happyIn122 happyOut122 happyIn123 happyOut123 happyIn124 happyOut124 happyIn125 happyOut125 happyIn126 happyOut126 happyIn127 happyOut127 happyIn128 happyOut128 happyIn129 happyOut129 happyIn130 happyOut130 happyIn131 happyOut131 happyIn132 happyOut132 happyIn133 happyOut133 happyIn134 happyOut134 happyIn135 happyOut135 happyIn136 happyOut136 happyIn137 happyOut137 happyIn138 happyOut138 happyIn139 happyOut139 happyIn140 happyOut140 happyIn141 happyOut141 happyIn142 happyOut142 happyIn143 happyOut143 happyIn144 happyOut144 happyIn145 happyOut145 happyIn146 happyOut146 happyIn147 happyOut147 happyIn148 happyOut148 happyIn149 happyOut149 happyIn150 happyOut150 happyIn151 happyOut151 happyIn152 happyOut152 happyIn153 happyOut153 happyIn154 happyOut154 happyIn155 happyOut155 happyIn156 happyOut156 happyIn157 happyOut157 happyIn158 happyOut158 happyIn159 happyOut159 happyIn160 happyOut160 happyIn161 happyOut161 happyIn162 happyOut162 happyIn163 happyOut163 happyIn164 happyOut164 happyIn165 happyOut165 happyIn166 happyOut166 happyIn167 happyOut167 happyIn168 happyOut168 happyIn169 happyOut169 happyIn170 happyOut170 happyIn171 happyOut171 happyIn172 happyOut172 happyIn173 happyOut173 happyIn174 happyOut174 happyIn175 happyOut175 happyIn176 happyOut176 happyIn177 happyOut177 happyIn178 happyOut178 happyIn179 happyOut179 happyIn180 happyOut180 happyIn181 happyOut181 happyIn182 happyOut182 happyIn183 happyOut183 happyIn184 happyOut184 happyIn185 happyOut185 happyIn186 happyOut186 happyIn187 happyOut187 happyIn188 happyOut188 happyIn189 happyOut189 happyIn190 happyOut190 happyIn191 happyOut191 happyIn192 happyOut192 happyIn193 happyOut193 happyIn194 happyOut194 happyIn195 happyOut195 happyIn196 happyOut196 happyIn197 happyOut197 happyIn198 happyOut198 happyIn199 happyOut199 happyIn200 happyOut200 happyIn201 happyOut201 happyIn202 happyOut202 happyIn203 happyOut203 happyIn204 happyOut204 happyIn205 happyOut205 happyIn206 happyOut206 happyIn207 happyOut207 happyIn208 happyOut208 happyIn209 happyOut209 happyIn210 happyOut210 happyIn211 happyOut211 happyIn212 happyOut212 happyIn213 happyOut213 happyIn214 happyOut214 happyIn215 happyOut215 happyIn216 happyOut216 happyIn217 happyOut217 happyIn218 happyOut218 happyIn219 happyOut219 happyIn220 happyOut220 happyIn221 happyOut221 happyIn222 happyOut222 happyIn223 happyOut223 happyIn224 happyOut224 happyIn225 happyOut225 happyIn226 happyOut226 happyIn227 happyOut227 happyIn228 happyOut228 happyIn229 happyOut229 happyIn230 happyOut230 happyIn231 happyOut231 happyIn232 happyOut232 happyIn233 happyOut233 happyIn234 happyOut234 happyIn235 happyOut235 happyIn236 happyOut236 happyIn237 happyOut237 happyIn238 happyOut238 happyIn239 happyOut239 happyIn240 happyOut240 happyIn241 happyOut241 happyIn242 happyOut242 happyIn243 happyOut243 happyIn244 happyOut244 happyIn245 happyOut245 happyIn246 happyOut246 happyIn247 happyOut247 happyIn248 happyOut248 happyIn249 happyOut249 happyIn250 happyOut250 happyIn251 happyOut251 happyInTok happyOutTokhappyActOffsetshappyGotoOffsetshappyDefActions happyCheck happyTablehappyReduceArr happy_n_termshappy_n_nonterms 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_272happyReduce_273happyReduction_273happyReduce_274happyReduction_274happyReduce_275happyReduction_275happyReduce_276happyReduction_276happyReduce_277happyReduction_277happyReduce_278happyReduction_278happyReduce_279happyReduction_279happyReduce_280happyReduction_280happyReduce_281happyReduction_281happyReduce_282happyReduction_282happyReduce_283happyReduction_283happyReduce_284happyReduction_284happyReduce_285happyReduction_285happyReduce_286happyReduction_286happyReduce_287happyReduction_287happyReduce_288happyReduction_288happyReduce_289happyReduction_289happyReduce_290happyReduction_290happyReduce_291happyReduction_291happyReduce_292happyReduction_292happyReduce_293happyReduction_293happyReduce_294happyReduction_294happyReduce_295happyReduction_295happyReduce_296happyReduction_296happyReduce_297happyReduction_297happyReduce_298happyReduction_298happyReduce_299happyReduction_299happyReduce_300happyReduction_300happyReduce_301happyReduction_301happyReduce_302happyReduction_302happyReduce_303happyReduction_303happyReduce_304happyReduction_304happyReduce_305happyReduction_305happyReduce_306happyReduction_306happyReduce_307happyReduction_307happyReduce_308happyReduction_308happyReduce_309happyReduction_309happyReduce_310happyReduction_310happyReduce_311happyReduction_311happyReduce_312happyReduction_312happyReduce_313happyReduction_313happyReduce_314happyReduction_314happyReduce_315happyReduction_315happyReduce_316happyReduction_316happyReduce_317happyReduction_317happyReduce_318happyReduction_318happyReduce_319happyReduction_319happyReduce_320happyReduction_320happyReduce_321happyReduction_321happyReduce_322happyReduction_322happyReduce_323happyReduction_323happyReduce_324happyReduction_324happyReduce_325happyReduction_325happyReduce_326happyReduction_326happyReduce_327happyReduction_327happyReduce_328happyReduction_328happyReduce_329happyReduction_329happyReduce_330happyReduction_330happyReduce_331happyReduction_331happyReduce_332happyReduction_332happyReduce_333happyReduction_333happyReduce_334happyReduction_334happyReduce_335happyReduction_335happyReduce_336happyReduction_336happyReduce_337happyReduction_337happyReduce_338happyReduction_338happyReduce_339happyReduction_339happyReduce_340happyReduction_340happyReduce_341happyReduction_341happyReduce_342happyReduction_342happyReduce_343happyReduction_343happyReduce_344happyReduction_344happyReduce_345happyReduction_345happyReduce_346happyReduction_346happyReduce_347happyReduction_347happyReduce_348happyReduction_348happyReduce_349happyReduction_349happyReduce_350happyReduction_350happyReduce_351happyReduction_351happyReduce_352happyReduction_352happyReduce_353happyReduction_353happyReduce_354happyReduction_354happyReduce_355happyReduction_355happyReduce_356happyReduction_356happyReduce_357happyReduction_357happyReduce_358happyReduction_358happyReduce_359happyReduction_359happyReduce_360happyReduction_360happyReduce_361happyReduction_361happyReduce_362happyReduction_362happyReduce_363happyReduction_363happyReduce_364happyReduction_364happyReduce_365happyReduction_365happyReduce_366happyReduction_366happyReduce_367happyReduction_367happyReduce_368happyReduction_368happyReduce_369happyReduction_369happyReduce_370happyReduction_370happyReduce_371happyReduction_371happyReduce_372happyReduction_372happyReduce_373happyReduction_373happyReduce_374happyReduction_374happyReduce_375happyReduction_375happyReduce_376happyReduction_376happyReduce_377happyReduction_377happyReduce_378happyReduction_378happyReduce_379happyReduction_379happyReduce_380happyReduction_380happyReduce_381happyReduction_381happyReduce_382happyReduction_382happyReduce_383happyReduction_383happyReduce_384happyReduction_384happyReduce_385happyReduction_385happyReduce_386happyReduction_386happyReduce_387happyReduction_387happyReduce_388happyReduction_388happyReduce_389happyReduction_389happyReduce_390happyReduction_390happyReduce_391happyReduction_391happyReduce_392happyReduction_392happyReduce_393happyReduction_393happyReduce_394happyReduction_394happyReduce_395happyReduction_395happyReduce_396happyReduction_396happyReduce_397happyReduction_397happyReduce_398happyReduction_398happyReduce_399happyReduction_399happyReduce_400happyReduction_400happyReduce_401happyReduction_401happyReduce_402happyReduction_402happyReduce_403happyReduction_403happyReduce_404happyReduction_404happyReduce_405happyReduction_405happyReduce_406happyReduction_406happyReduce_407happyReduction_407happyReduce_408happyReduction_408happyReduce_409happyReduction_409happyReduce_410happyReduction_410happyReduce_411happyReduction_411happyReduce_412happyReduction_412happyReduce_413happyReduction_413happyReduce_414happyReduction_414happyReduce_415happyReduction_415happyReduce_416happyReduction_416happyReduce_417happyReduction_417happyReduce_418happyReduction_418happyReduce_419happyReduction_419happyReduce_420happyReduction_420happyReduce_421happyReduction_421happyReduce_422happyReduction_422happyReduce_423happyReduction_423happyReduce_424happyReduction_424happyReduce_425happyReduction_425happyReduce_426happyReduction_426happyReduce_427happyReduction_427happyReduce_428happyReduction_428happyReduce_429happyReduction_429happyReduce_430happyReduction_430happyReduce_431happyReduction_431happyReduce_432happyReduction_432happyReduce_433happyReduction_433happyReduce_434happyReduction_434happyReduce_435happyReduction_435happyReduce_436happyReduction_436happyReduce_437happyReduction_437happyReduce_438happyReduction_438happyReduce_439happyReduction_439happyReduce_440happyReduction_440happyReduce_441happyReduction_441happyReduce_442happyReduction_442happyReduce_443happyReduction_443happyReduce_444happyReduction_444happyReduce_445happyReduction_445happyReduce_446happyReduction_446happyReduce_447happyReduction_447happyReduce_448happyReduction_448happyReduce_449happyReduction_449happyReduce_450happyReduction_450happyReduce_451happyReduction_451happyReduce_452happyReduction_452happyReduce_453happyReduction_453happyReduce_454happyReduction_454happyReduce_455happyReduction_455happyReduce_456happyReduction_456happyReduce_457happyReduction_457happyReduce_458happyReduction_458happyReduce_459happyReduction_459happyReduce_460happyReduction_460happyReduce_461happyReduction_461happyReduce_462happyReduction_462happyReduce_463happyReduction_463happyReduce_464happyReduction_464happyReduce_465happyReduction_465happyReduce_466happyReduction_466happyReduce_467happyReduction_467happyReduce_468happyReduction_468happyReduce_469happyReduction_469happyReduce_470happyReduction_470happyReduce_471happyReduction_471happyReduce_472happyReduction_472happyReduce_473happyReduction_473happyReduce_474happyReduction_474happyReduce_475happyReduction_475happyReduce_476happyReduction_476happyReduce_477happyReduction_477happyReduce_478happyReduction_478happyReduce_479happyReduction_479happyReduce_480happyReduction_480happyReduce_481happyReduction_481happyReduce_482happyReduction_482happyReduce_483happyReduction_483happyReduce_484happyReduction_484happyReduce_485happyReduction_485happyReduce_486happyReduction_486happyReduce_487happyReduction_487happyReduce_488happyReduction_488happyReduce_489happyReduction_489happyReduce_490happyReduction_490happyReduce_491happyReduction_491happyReduce_492happyReduction_492happyReduce_493happyReduction_493happyReduce_494happyReduction_494happyReduce_495happyReduction_495happyReduce_496happyReduction_496happyReduce_497happyReduction_497happyReduce_498happyReduction_498happyReduce_499happyReduction_499happyReduce_500happyReduction_500happyReduce_501happyReduction_501happyReduce_502happyReduction_502happyReduce_503happyReduction_503happyReduce_504happyReduction_504happyReduce_505happyReduction_505happyReduce_506happyReduction_506happyReduce_507happyReduction_507happyReduce_508happyReduction_508happyReduce_509happyReduction_509happyReduce_510happyReduction_510happyReduce_511happyReduction_511happyReduce_512happyReduction_512happyReduce_513happyReduction_513happyReduce_514happyReduction_514happyReduce_515happyReduction_515happyReduce_516happyReduction_516happyReduce_517happyReduction_517happyReduce_518happyReduction_518happyReduce_519happyReduction_519happyReduce_520happyReduction_520happyReduce_521happyReduction_521happyReduce_522happyReduction_522happyReduce_523happyReduction_523happyReduce_524happyReduction_524happyReduce_525happyReduction_525happyReduce_526happyReduction_526happyReduce_527happyReduction_527happyReduce_528happyReduction_528happyReduce_529happyReduction_529happyReduce_530happyReduction_530happyReduce_531happyReduction_531happyReduce_532happyReduction_532happyReduce_533happyReduction_533happyReduce_534happyReduction_534happyReduce_535happyReduction_535happyReduce_536happyReduction_536happyReduce_537happyReduction_537happyReduce_538happyReduction_538happyReduce_539happyReduction_539happyReduce_540happyReduction_540happyReduce_541happyReduction_541happyReduce_542happyReduction_542happyReduce_543happyReduction_543happyReduce_544happyReduction_544happyReduce_545happyReduction_545happyReduce_546happyReduction_546happyReduce_547happyReduction_547happyReduce_548happyReduction_548happyReduce_549happyReduction_549happyReduce_550happyReduction_550happyReduce_551happyReduction_551happyReduce_552happyReduction_552happyReduce_553happyReduction_553happyReduce_554happyReduction_554happyReduce_555happyReduction_555happyReduce_556happyReduction_556happyReduce_557happyReduction_557happyReduce_558happyReduction_558happyReduce_559happyReduction_559happyReduce_560happyReduction_560happyReduce_561happyReduction_561happyReduce_562happyReduction_562happyReduce_563happyReduction_563happyReduce_564happyReduction_564happyReduce_565happyReduction_565happyReduce_566happyReduction_566happyReduce_567happyReduction_567happyReduce_568happyReduction_568happyReduce_569happyReduction_569happyReduce_570happyReduction_570happyReduce_571happyReduction_571happyReduce_572happyReduction_572happyReduce_573happyReduction_573happyReduce_574happyReduction_574happyReduce_575happyReduction_575happyReduce_576happyReduction_576happyReduce_577happyReduction_577happyReduce_578happyReduction_578happyReduce_579happyReduction_579happyReduce_580happyReduction_580happyReduce_581happyReduction_581happyReduce_582happyReduction_582happyReduce_583happyReduction_583happyReduce_584happyReduction_584happyReduce_585happyReduction_585happyReduce_586happyReduction_586happyReduce_587happyReduction_587happyReduce_588happyReduction_588happyReduce_589happyReduction_589happyReduce_590happyReduction_590happyReduce_591happyReduction_591happyReduce_592happyReduction_592happyReduce_593happyReduction_593happyReduce_594happyReduction_594happyReduce_595happyReduction_595happyReduce_596happyReduction_596happyReduce_597happyReduction_597happyReduce_598happyReduction_598happyReduce_599happyReduction_599happyReduce_600happyReduction_600happyReduce_601happyReduction_601happyReduce_602happyReduction_602happyReduce_603happyReduction_603happyReduce_604happyReduction_604happyReduce_605happyReduction_605happyReduce_606happyReduction_606happyReduce_607happyReduction_607happyReduce_608happyReduction_608happyReduce_609happyReduction_609happyReduce_610happyReduction_610happyReduce_611happyReduction_611happyReduce_612happyReduction_612happyReduce_613happyReduction_613happyReduce_614happyReduction_614happyReduce_615happyReduction_615happyReduce_616happyReduction_616happyReduce_617happyReduction_617happyReduce_618happyReduction_618happyReduce_619happyReduction_619happyReduce_620happyReduction_620happyReduce_621happyReduction_621happyReduce_622happyReduction_622happyReduce_623happyReduction_623happyReduce_624happyReduction_624happyReduce_625happyReduction_625happyReduce_626happyReduction_626happyReduce_627happyReduction_627happyReduce_628happyReduction_628happyReduce_629happyReduction_629happyReduce_630happyReduction_630happyReduce_631happyReduction_631happyReduce_632happyReduction_632happyReduce_633happyReduction_633happyReduce_634happyReduction_634happyReduce_635happyReduction_635happyReduce_636happyReduction_636happyReduce_637happyReduction_637happyReduce_638happyReduction_638happyReduce_639happyReduction_639happyReduce_640happyReduction_640happyReduce_641happyReduction_641happyReduce_642happyReduction_642happyReduce_643happyReduction_643happyReduce_644happyReduction_644happyReduce_645happyReduction_645happyReduce_646happyReduction_646happyReduce_647happyReduction_647happyReduce_648happyReduction_648happyReduce_649happyReduction_649happyReduce_650happyReduction_650happyReduce_651happyReduction_651happyReduce_652happyReduction_652happyReduce_653happyReduction_653happyReduce_654happyReduction_654happyReduce_655happyReduction_655happyReduce_656happyReduction_656happyReduce_657happyReduction_657happyReduce_658happyReduction_658happyReduce_659happyReduction_659happyReduce_660happyReduction_660happyReduce_661happyReduction_661happyReduce_662happyReduction_662happyReduce_663happyReduction_663happyReduce_664happyReduction_664happyReduce_665happyReduction_665happyReduce_666happyReduction_666happyReduce_667happyReduction_667happyReduce_668happyReduction_668happyReduce_669happyReduction_669happyReduce_670happyReduction_670happyReduce_671happyReduction_671happyReduce_672happyReduction_672happyReduce_673happyReduction_673happyReduce_674happyReduction_674happyReduce_675happyReduction_675happyReduce_676happyReduction_676happyReduce_677happyReduction_677happyReduce_678happyReduction_678happyReduce_679happyReduction_679happyReduce_680happyReduction_680happyReduce_681happyReduction_681happyReduce_682happyReduction_682happyReduce_683happyReduction_683happyReduce_684happyReduction_684happyReduce_685happyReduction_685happyReduce_686happyReduction_686happyReduce_687happyReduction_687happyReduce_688happyReduction_688happyReduce_689happyReduction_689happyReduce_690happyReduction_690happyReduce_691happyReduction_691happyReduce_692happyReduction_692happyReduce_693happyReduction_693 happyNewToken happyError_ happyThen happyReturn happyThen1 happyReturn1 happyError' mparseModule mparseExp mparsePat mparseDecl mparseType mparseStmt mparseModulesmfindOptPragmashappySeq parseErrornISiS simpleParse modeParse commentParseapplyFixities' happyParse happyAccept happyDoActionindexShortOffAddr happyShifthappySpecReduce_0happySpecReduce_1happySpecReduce_2happySpecReduce_3 happyReducehappyMonadReducehappyMonad2Reduce happyDrop happyDropStk happyGoto happyFail notHappyAtAll happyTcHack happyDoSeq happyDontSeq$fParseableType$fParseableDecl$fParseablePat$fParseableExp$fParseableModule$fParseableStmt$fParseableType0$fParseableDecl0$fParseablePat0$fParseableExp0$fParseableModule0 ppContentsdelitseparatePragmas