h&N_      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTU 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 { | } ~                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ! ! ! ! " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " # # # # # # # # # # # # # # # # # ###################$$%%%%%%&&&&&&''''''((()))))*****++++++++++++++,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,------............///////////////00000000000000000011111112333333333333333333333334444444444455555555555555555566666666666666666666677778888888888888889999999999999:::::::::::;;;;;;;;;;;;;;;;;;<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<=====================================================>>>>>>>>>>>>>>???????@@@@@AAABCCCDDDDDDDDDDDDDDDDDDDEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGHHHHHHHHHHHHHHHHHHH Safe-Inferred$)*0125689:;<=>?1 Safe-Inferred$)*0125689:;<=>?6  fortran-srcbinary (bitstring)  fortran-srcoctal  fortran-srchex, including nonstandard x  fortran-srcA Fortran BOZ literal constant.8The prefix defines the characters allowed in the string:B: [01]O: [0-7]Z:  [0-9 a-f A-F] fortran-src%Was the prefix actually postfix i.e. '123'z? This is non-standard syntax, disabled by default in gfortran. Syntactic info. fortran-src-UNSAFE. Parses a BOZ literal constant string.Looks for prefix or postfix. Strips the quotes from the string (single quotes only). fortran-srcPretty print a BOZ constant. Uses prefix style (ignores the postfix field), and z over nonstandard x for hexadecimal. fortran-src7Resolve a BOZ constant as a natural (positive integer).Is actually polymorphic over the output type, but you probably want to resolve to  or Natural usually.We assume the  9 is well-formed, thus don't bother with digit predicates. fortran-src5Resolve a BOZ constant as a two's complement integer.?Note that the value will depend on the size of the output type. fortran-src'Ignores conforming/nonconforming flags. fortran-srcTests prefix & strings match, ignoring conforming/nonconforming flags.      Safe-Inferred&%&)*0125689:;<=>?:+ fortran-srcKIND=4 (float), fortran-srcKIND=8 (double)- fortran-src!KIND=16 ("quad", rare? extension). fortran-src>An exponent is an exponent letter (E, D) and a signed integer.2 fortran-srcA Fortran real literal. (Does not include the optional kind parameter.)A real literal is formed of a signed rational significand, and an .."See F90 ISO spec pg.27 / R412-416.Note that we support signed real literals, even though the F90 spec indicates non-signed real literals are the "default" (signed are only used in a "spare" rule). Our parsers should parse explicit signs as unary operators. There's no harm in supporting signed literals though, especially since the exponent *is* signed.4 fortran-src>A string representing a signed decimal. ^ Approximate regex: !-? ( [0-9]+ . [0-9]* | . [0-9]+ )6 fortran-src Prettify a 2 in a Haskell-compatible way.*-,+.10/25436782543.10/*-,+678 Safe-Inferred$)*0125689:;<=>?;N fortran-srcRead a string as either a signed integer, or a BOZ constant (positive).Useful in manual lexing.NN Safe-Inferred%)*0125689:;<=>?;OO Safe-Inferred$)*0125689:;<=>?=R fortran-srcPretty print to default format  00 12 AB FF': space between each byte, all caps.This format I consider most human readable. I prefer caps to draw attention to this being data instead of text (you don't see that many capital letters packed together in prose).T fortran-src!Pretty print to "compact" format 0012abff (often output by hashers).PQRSTPQRST  Safe-Inferred$)*0125689:;<=>??9U fortran-src-Fortran types which use simple integer kinds.V fortran-src9Serialize the kind tag to the shared kind representation.W fortran-src5Parse a kind tag from the shared kind representation.X fortran-src1The internal type used to pass type kinds around.UWVXXUWV  Safe-Inferred%)*0125689:;<=>?@VZ fortran-srcThe Fortran integer type.[ fortran-src  INTEGER(1)\ fortran-src  INTEGER(2)] fortran-src  INTEGER(4)^ fortran-src  INTEGER(8)_ fortran-src  INTEGER(16)YZ_^]\[Z_^]\[Y  Safe-Inferred$)*0125689:;<=>?@ikjikj  Safe-Inferred%)*0125689:;<=>?A"uwvuwv  Safe-Inferred%)*0125689:;<=>?A Safe-Inferred$)*0125689:;<=>?C fortran-srcWhere relevant/possible, values will be checked for correctness (e.g. existence of over/underflow), and adjusted accordingly. fortran-src+Values will not be checked for correctness. fortran-srcRepresentation behaviour intends to match Fortran's. I guess we'll target gfortran. fortran-src0Use "mathematically ideal" representations e.g.  for all  INTEGER(x) types. This enables us to check for correctness issues such as overflow. Safe-Inferred( )*0125689:;<=>?DM Safe-Inferred$)*0125689:;<=>?D Safe-Inferred%")*0125689:;<=>?T\ fortran-src;Represents map of files and replacements that will be done. fortran-srcAs we advance through the [] list, we consider "chunks" as the unit of text written out. A chunk is either: original source text up to a newline character, end of file or  described in 2. a single = that has non-empty replacement string or is deleted. fortran-srcException raised when two  objects overlap () or  points at invalid locations (). fortran-src5Represents the intent to replace content in the file.The content in  will be used in place of what is in the range described. Note that the replacement text can be shorter or larger than the original span, and it can also be multi-line. fortran-srcRepresents a character in the original source text along with any replacement operations applied to the character in place.It expects a character (in case it's empty, Nothing should be used), whether it should be removed, its 1 and a string that should be put in place of it. fortran-src Represents range in source code. fortran-src#Represents location in source code. Note that,  indicates space between characters, i.e the following example:  SourceLocation 0 1indicates position between first and second characters in a file. fortran-src8Parses input string into a list of annotated characters. fortran-srcMarks RChars& in a given range to be removed later. fortran-src>Sets replacement string to be prepended to the given location. fortran-srcSets replacement string to be prepended to the begining of the given range. fortran-src3Applies all deletions and additions and transforms RChars back to a string. fortran-srcIf  is marked as deleted, it'll be evaluated to its replacement string, otherwise original character will be returned. fortran-srcFrom [ ], obtain a (, [RChars ]) where the  is the next  and the [] are the remaining s. fortran-srcSplits [] into s. fortran-srcTransform a list of s into a single string, applying continuation lines when neccessary. fortran-srcThis expands the chunks from the left to right. If the length of what has already been put into the current line exceeds the limit of 72 characters (excluding inline comments starting with ! and implicit comments starting at column 73) then it ends the current line with a continuation, otherwise it simply adds the line as-is. It also calculates if the chunk is inside or outside of a string literal, using that to determine where explicit comments are if any.In either case, we make sure that we are padding implicit comments *from the original source* even if the tail of that line has been moved onto a continuation line. fortran-srcReturn TRUE iff the $ constitutes a character insertion. fortran-srcSets a single  given a list of s. fortran-srcSets a list of s given a list of s. fortran-srcheuristic to wrap line after comma or right parenthesis if applicable fortran-srcMark removal for the input  fortran-src4Append the input character to the replacement string fortran-srcChecks whether two s are not overlapping. fortran-srcChecks whether: ,the start is before the end of the range and1both start and end locations are within the code. fortran-srcApplies s to a string and return it.1Firstly, it transforms the string into a list of s.After that, it validates the  of each .In the end, it splits up s in  s, set the s and evaluates the s.)) Safe-Inferred$)*0125689:;<=>?W fortran-srcObtain a UTF-8 safe % representation of a file's contents.3Invalid UTF-8 is replaced with the space character. fortran-srcList files in directory, with the directory prepended to each entry. fortran-src$List files in directory recursively. fortran-srcRun the C Pre Processor over the file before reading into a bytestring fortran-srcExpand all paths that are directories into a list of Fortran files from a recursive directory listing. fortran-src6Get a list of Fortran files under the given directory. Safe-Inferred%)*0125689:;<=>?X  Safe-Inferred$)*0125689:;<=>?X Safe-Inferred%)*0125689:;<=>?X Safe-Inferred$)*0125689:;<=>?Z fortran-src.line-offset and filename as given by a pragma. fortran-src(line, column) number taking into account any specified line pragmas. fortran-src?ak fortran-srcRemove overlapping items from a list of replacements and return a pair of lists containing disjoint items and overlapping items, respectively.Important notes:Replacements that come first in the list will be given precedence over later items. fortran-srcApply a list of  Replacements to the orginal source file.Important notes:9Source locations specified in replacements are 0-indexed.Rewriting applies continuation lines when lines are longer than 72 characters.Example replacements:$Delete the first character in a file  Replacement (SourceRange (SourceLocation 0 0) (SourceLocation 0 1)) "")Prepend "a" to 1 line, 2 column character  Replacement (SourceRange (SourceLocation 0 1) (SourceLocation 0 1)) "a"8Replace a character located in 2 line, 4 column with "a"  Replacement (SourceRange (SourceLocation 1 3) (SourceLocation 1 4)) "a"Replace string starting in 2 line, 4 column and ending in 2 line, 6 column (inclusive) with "a"  Replacement (SourceRange (SourceLocation 1 3) (SourceLocation 1 6)) "a"  fortran-srcUtility function to convert  to  SourceRange fortran-src Given two Span s, returns a  SourceRange that starts at the starting location of the first span, and ends at the starting location of the second span fortran-src Given two Span s, returns a  SourceRange that starts at the ending location of the first span, and ends at the starting location of the second span Safe-Inferred$)*0125689:;<=>?bS fortran-src [0-9]+ fortran-src[a-z][a-z0-9]+ (case insensitive) Safe-Inferred$)*0125689:;<=>?g fortran-src7A part (either real or imaginary) of a complex literal.Since Fortran 2003, complex literal parts support named constants, which must be resolved in context at compile time (R422, R423).Some compilers also allow constant expressions for the parts, and must evaluate at compile time. That's not allowed in any standard. Apparently, gfortran and ifort don't allow it, while nvfortran does. See: https://fortran-lang.discourse.group/t/complex-constants-and-variables/2909/3We specifically avoid supporting that by defining complex parts without being mutually recursive with  Expression. fortran-srcsigned real lit fortran-srcsigned int lit fortran-srcnamed constant fortran-srcA COMPLEX literal, composed of a real part and an imaginary part.Fortran has lots of rules on how COMPLEX literals are defined and used in various contexts. To support all that, we define the syntactic structure  to wrap all the parsing rules. Then during a analysis pass, you may (attempt to) convert these into a more regular type, like a Haskell (Double, Double) tuple. fortran-srcIs the given COMPLEX literal "pure", i.e. does it have no named constant components?   Safe-Inferred$)*0125689:;<=>?jF fortran-srcA location-tagged list of t as (t decorated with an a annotation).$The AST is polymorphic on some type a, which is used for arbitrary annotations. Since many AST nodes use lists (e.g. executable statements, declarations), we define a dedicated annotated list type to reuse.(Note that the list itself also holds an a annotation. fortran-srcConvert a non-empty list to an . fortran-srcConvert a list to an *, returning Nothing iff the list is empty.5 Safe-Inferred$)*0125689:;<=>?l fortran-srcThe Fortran specification version used (or relevant to its context).The constructor ordering is important, since it's used for the Ord instance (which is used extensively for pretty printing). fortran-src#fairly close to FORTRAN 77 standard fortran-srcF77 with some extensions fortran-srcF77 with most extensions fortran-src Deduce the  from a  using extension.1Defaults to Fortran 90 if suffix is unrecognized.   Safe-Inferred')*0125689:;<=>?mm33 Safe-Inferred&)*0125689:;<=>?n Safe-Inferred%)*0125689:;<=>?q Safe-Inferred&)*0125689:;<=>?rE  Safe-Inferred$)*0125689:;<=>?u} fortran-srcObtain set of intrinsics that are most closely aligned with given version. fortran-srcname => (return-unit, parameter-units) This is an exhaustive list of intrinsics listed in 15.10 of X3.9-1978 Safe-Inferred$)*0125689:;<=>?w fortran-srcDimension declarator stored in  dimension attributes and s. fortran-src0Declarators. R505 entity-decl from F90 ISO spec.Declaration statements can have multiple variables on the right of the double colon, separated by commas. A  identifies a single one of these. In F90, they look like this::VAR_NAME ( OPT_ARRAY_DIMS ) * CHAR_LENGTH_EXPR = INIT_EXPRF77 doesn't standardize so nicely -- in particular, I'm not confident in initializing expression syntax. So no example.Only CHARACTERs may specify a length. However, a nonstandard syntax feature uses non-CHARACTER lengths as a kind parameter. We parse regardless of type and warn during analysis. fortran-srcValues and literals. Note that  kind parameters may only be available on certain Fortran parsers. The fixed form parsers (F77, F66) may not parse them. fortran-src/The string representation of an integer literal fortran-src+The string representation of a real literal fortran-src2The real and imaginary parts of a complex literal  (real, imag). fortran-srcA string literal fortran-srcA BOZ literal constant fortran-srcA Hollerith literal fortran-srcThe name of a variable fortran-srcThe name of a built-in function fortran-srcA boolean value fortran-src$User-defined operators in interfaces fortran-src#Overloaded assignment in interfaces fortran-srcUse a value as an expression. fortran-src-A binary operator applied to two expressions. fortran-src+A unary operator applied to one expression. fortran-srcArray indexing fortran-src%) notation for variables inside data types fortran-src5A function expression applied to a list of arguments. fortran-src$Implied do (i.e. one-liner do loops) fortran-srcArray initialisation fortran-src#Function return value specification fortran-srcGuaranteed to be  fortran-src2Part of the newer (Fortran 2003?) FLUSH statement.See: https://www.ibm.com/docs/en/xl-fortran-aix/15.1.0?topic=attributes-flush-fortran-2003 fortran-srcscalar integer expression fortran-srcscalar integer variable fortran-srcscalar character variable fortran-srcstatement label fortran-src4Field types in pre-Fortran 90 non-standard structurerecordunion extension.>Structures were obsoleted by derived types in later standards.!The outer structure is stored in . fortran-src Regular field fortran-src Union field fortran-srcSubstructure (nested inline record structure) fortran-srcThe part of a DATA statement describing a single set of initializations.The initializer list must be compatible with the name list. Generally, that means either the lengths must be equal, or the name list is the singleton list referring to an array, and the initializer list is compatible with that array's shape. fortran-src!A single COMMON block definition.The 2s here shall not contain initializing expressions. fortran-src(List of names for an IMPLICIT statement. fortran-srcPart of ALLOCATE statement.There are restrictions on how ALLOCATE options can be combined. See F2018 9.7.1, or: https://www.intel.com/content/www/us/en/develop/documentation/fortran-compiler-oneapi-dev-guide-and-reference/top/language-reference/a-to-z-reference/a-to-b/allocate-statement.html fortran-src(output) status of allocation fortran-src#(output) error condition if present fortran-srcExtra data type to disambiguate between plain variable arguments and expression arguments (due to apparent behaviour of some Fortran compilers to treat these differently). Note the  and  instances pass to the inner  for . fortran-srcPart of USE statement. (F2018 14.2.2)&Expressions may be names or operators. fortran-srcname fortran-src5Part of a FORALL statement. Introduced in Fortran 95. fortran-src$Declare variable(s) at a given type. fortran-src,A structure (pre-F90 extension) declaration. fortran-src>SAVE statement: variable retains its value between invocations fortran-src!DIMENSION attribute as statement. fortran-src ALLOCATABLE attribute statement. fortran-src!ASYNCHRONOUS attribute statement. fortran-srcPOINTER attribute statement. fortran-srcTARGET attribute statement. fortran-srcVALUE attribute statement. fortran-srcVOLATILE attribute statement. fortran-src!PARAMETER attribute as statement. fortran-src5A COMMON statement, defining a list of common blocks. fortran-src guaranteed ExpValue ValVariable fortran-srcCASE construct opener. fortran-srcinner CASE clause fortran-srcEND SELECT statement fortran-srcSpecial TYPE "print" statement (~F77 syntactic sugar for PRINT/WRITE)Not to be confused with the TYPE construct in later standards for defining derived data types. fortran-src)ALLOCATE: associate pointers with targets fortran-src+NULLIFY: disassociate pointers from targets fortran-src.DEALLOCATE: disassociate pointers from targets fortran-srcbegin WHERE block fortran-src$WHERE clause. compare to IF, IF ELSE fortran-srcend WHERE block fortran-src6Import definitions (procedures, types) from a module. (F2018 14.2.2)If a module nature isn't provided and there are both intrinsic and nonintrinsic modules with that name, the nonintrinsic module is selected. fortran-srcprocedure names, guaranteed ExpValue ValVariable fortran-src;TYPE ... = begin a DDT (derived data type) definition block fortran-src3END TYPE [ type-name ] = end a DDT definition block fortran-src!FORALL ... = begin a FORALL block fortran-srcEND FORALL [ construct-name ] fortran-src5FORALL statement - essentially an inline FORALL block fortran-src guaranteed ExpValue ValVariable  fortran-src Statement  fortran-srcFORALL array assignment syntax  fortran-srcIF block construct  fortran-srcSELECT CASE construct  fortran-src The first + in the abbreviation tuple is always an ExpValue _ _ (ValVariable id) . Also guaranteed nonempty. TODO  fortran-srcBlock-level comment  fortran-src%A Fortran program unit. _(F2008 2.2)_3A Fortran program is made up of many program units.3Related points from the Fortran 2008 specification:There must be exactly one main program, and any number of other program units.Note 2.3: There may be at most 1 unnamed block data program unit.  fortran-src Main program  fortran-srcModule  fortran-src!Subroutine subprogram (procedure)  fortran-srcFunction subprogram (procedure)  fortran-srcBlock data (named or unnamed).  fortran-srcProgram unit-level comment  fortran-srcThe "kind selector" of a declaration statement. Tightly bound to  .HP's F90 spec (pg.24) actually differentiates between "kind selectors" and "char selectors", where char selectors can specify a length (alongside kind), and the default meaning of an unlabelled kind parameter (the 8 in INTEGER(8)) is length instead of kind. We handle this correctly in the parsers, but place both into this   type.The upshot is, length is invalid for non-CHARACTER types, and the parser guarantees that it will be Nothing. For CHARACTER types, both maybe or may not be present.+Often used with the assumption that when a   term is present, it contains some information (i.e. one of length or kind is  _;), so that the awkward "empty" possibility may be avoided.  fortran-srcThe type specification of a declaration statement, containing the syntactic type name and kind selector.See HP's F90 spec pg.24.  fortran-srcType name referenced in syntax.In many Fortran specs and compilers, certain types are actually "synonyms" for other types with specified kinds. The primary example is DOUBLE PRECISION being equivalent to REAL(8). Type kinds were introduced in Fortran 90, and it should be safe to replace all instances of DOUBLE PRECISION with REAL(8) in Fortran 90 code. However, type kinds weren't present in (standard) Fortran 77, so this equivalence was detached from the user.In any case, it's unclear how strong the equivalence is and whether it can be retroactively applied to previous standards. We choose to parse types directly, and handle those transformations during type analysis, where we assign most scalars a kind (see IJ).  fortran-srcThe empty annotation.  fortran-srcSet a  Declarator'6s initializing expression only if it has none already.+ fortran-src Lower index fortran-src Upper index fortran-srcStride fortran-srcType fortran-src Attributes fortran-src Declarators fortran-src Union fields fortran-srcSubstructure name fortran-src Field name fortran-srcSubstructure fields fortran-srcscalar integer variable fortran-srcscalar character variable fortran-src local name fortran-srcuse name fortran-srcType specification fortran-src Attributes fortran-src Declarators fortran-srcStructure name fortran-srcStructure fields fortran-srcSave the given variables, or all saveable items in the program unit if  fortran-srcname (guaranteed ExpValue ValVariable) fortran-srcargument variables fortran-src%optional result variable (guaranteed ExpValue ValVariable) fortran-src!file name to include. guaranteed ExpValue ValString fortran-srcFirst parsed to 7, then potentially "expanded out" in a post-parse step. fortran-src condition fortran-src&statement (should not further recurse) fortran-src block name fortran-srcCASE expression. Should be one of scalar CHARACTER, INTEGER or LOGICAL. fortran-src.block name (must match a corresponding opener) fortran-srcCASE indices (expressions).  means it's CASE DEFAULT. fortran-src1block name (must match corresponding opener name) fortran-srcformat identifier fortran-srcvariables etc. to print fortran-srcpointers (variables/references) fortran-srcpointers (variables/references) fortran-srcpointers (variables/references) fortran-srcmust be LOGICAL fortran-srcguaranteed to be  fortran-src block name fortran-srcmust be LOGICAL fortran-src block name fortran-srcmust be LOGICAL fortran-src block name fortran-src(name of module to use, guaranteed to be ExpValue ValVariable fortran-srcoptional explicit module nature fortran-src)definitions to import (including renames) fortran-srcattributes (subset permitted) fortran-srcDDT name fortran-src4optional type name (must match corresponding opener) fortran-src block name fortran-srcFORALL header syntax fortran-src block name fortran-srcFORALL header syntax fortran-src guaranteed  or   fortran-srcLabel fortran-srcWrapped statement  fortran-srcLabel fortran-srcConstruct name fortran-srcHeader information fortran-srcBody fortran-srcLabel to END DO  fortran-srcLabel fortran-srcConstruct name fortran-srcIF, ELSE IF clauses fortran-src ELSE block fortran-srcLabel to END IF  fortran-srcLabel fortran-srcConstruct name fortran-src Scrutinee fortran-src CASE clauses fortran-src CASE default fortran-srcLabel to END SELECT  fortran-srcLabel fortran-srcConstruct name fortran-src Target label fortran-srcDo Specification fortran-srcBody fortran-srcLabel to END DO  fortran-srcLabel fortran-srcConstruct name fortran-src Target label fortran-src Condition fortran-srcBody fortran-srcLabel to END DO  fortran-srcLabel fortran-srcConstruct name fortran-srcExpression abbreviations fortran-srcBody fortran-srcLabel  fortran-srcLabel fortran-srcIs this an abstract interface? fortran-srcInterface procedures fortran-srcModule procedures  fortran-src Program name fortran-srcBody fortran-src Subprograms  fortran-src Program name fortran-srcBody fortran-src Subprograms  fortran-srcOptions (elemental, pure etc.) fortran-srcName fortran-src Arguments fortran-srcBody fortran-src Subprograms  fortran-src Return type fortran-srcOptions (elemental, pure etc.) fortran-srcName fortran-src Arguments fortran-srcResult fortran-srcBody fortran-src Subprograms  fortran-srcOptional block          ! Safe-Inferred$)*0125689:;<=>?  fortran-srcMonads which provide functionality to evaluate Fortran expressions in some static context.Actions in this monad may,request the value of a variable (may return  if not in scope)9record some user-facing information concerning evaluationAs usage examples, a simple pure evaluator may use a plain map of  to   m. A more complex type evaluator may allow "defaulting" for variables not in scope via IMPLICIT rules.The associated type family  7 enables using this for both type and value evaluators.  fortran-src Target type that we evaluate to.  fortran-src Request the value of a variable.Returns ! if the variable is not in scope.  fortran-src:Record some user-facing information concerning evaluation.For example, you may want to inform the user when you've made a defaulting decision.  " Safe-Inferred&")*0125689:;<=>?j  fortran-src wrapper to make it easier to swap this out for a monad later.  fortran-src.Note that this instance is tightly bound with   due to  # appending information on where   should have been prettied. By itself, this instance is less sensible.   7 7# Safe-Inferred%)*0125689:;<=>?A  fortran-src/Fortran array dimensions, defined by a list of  $s storing lower and upper bounds.You select the list type t (which should be ,  and ) and the bound type a (e.g. ).$Using a non-empty list type such as KL will disallow representing zero-dimension arrays, providing extra soundness.Note the following excerpt from the F2018 standard (8.5.8.2 Explicit-shape array): If the upper bound is less than the lower bound, the range is empty, the extent in that dimension is zero, and the array is of zero size.Note that the  instance does not provide "dimension-like" access to this type. That is,  (a ::   t a)* will _not_ tell you how many dimensions a represents. Use   for that.  fortran-src/Explicit-shape array. All dimensions are known.  fortran-srcAssumed-size array. The final dimension has no upper bound (it is obtained from its effective argument). Earlier dimensions may be defined like explicit-shape arrays.  fortran-srcAssumed-shape array. Shape is taken from effective argument. We store the lower bound for each dimension, and thus also the rank (via list length).  fortran-src-A single array dimension with bounds of type a. a =>   a# is a static, known-size dimension.  (M ()) is a dimension with unevaluated bounds expressions. Note that these bounds may be constant expressions, or refer to dummy variables, or be invalid. a =>   ( a) is a dimension where some bounds are known, and others are not. This may be useful to record some information about dynamic explicit-shape arrays.  fortran-srcDimension lower bound.  fortran-srcDimension upper bound.  fortran-srcTraverse over the functor in a  ! value with a functor bound type.For example, to turn a   t ( a) into a  (  t a).  fortran-src#How many dimensions does the given   represent?  fortran-srcFortran syntax uses  lower:upper, so only provide an  instance for that style. fortran-srcThis instance is purely for convenience. No definition of ordering is provided, and the implementation may change at any time.  fortran-srclist of all dimensions  fortran-src"list of all dimensions except last fortran-srclower bound of last dimension  fortran-srclist of lower bounds $ Safe-Inferred%)*0125689:;<=>? fortran-src$Helper for forming COMPLEX literals.% Safe-Inferred&)*0125689:;<=>?j9 9 & Safe-Inferred&)*0125689:;<=>?9 9 ' Safe-Inferred&)*0125689:;<=>?r9 9 ( Safe-Inferred%)*0125689:;<=>?ɖ fortran-srcUNSAFE. Must be called with expected token types (see usage sites). Will cause a runtime exception if it doesn't form a valid REAL literal.) Safe-Inferred&)*0125689:;<=>?9 9 * Safe-Inferred&)*0125689:;<=>?ʀ9 9 + Safe-Inferred$)*0125689:;<=>?˵ fortran-src A subset of 8 which can only contain values that can be assigned to. fortran-src=If the expression can be seen as an lvalue, convert it to an ., Safe-Inferred%")*0125689:;<=>?ԗ  fortran-srcspecified with a * fortran-srcspecified with a : (Fortran2003) FIXME, possibly, with a more robust const-exp: fortran-src'specified with a non-trivial expression fortran-src!specified with a constant integer fortran-srcThe main dimension type is a non-empty list of dimensions where each bound is  .  bounds indicate a dynamic bound (e.g. uses a dummy variable). fortran-src$Semantic type assigned to variables. ( stores the "type tag" given in syntax. s add metadata (kind and length), and resolve some "simple" types to a core type with a preset kind (e.g. `DOUBLE PRECISION` -> `REAL(8)`).;Fortran 90 (and beyond) features may not be well supported. fortran-srcA Fortran array type is represented by a type and a set of dimensions. fortran-src/Constructor to use for F77 structures, F90 DDTs fortran-srcConvert + data type to its previous type synonym (Maybe [(Int, Int)]).Drops all information for array dimensions that aren't fully static/known. fortran-srcAttempt to recover the  that generated the given . fortran-srcRecover the most appropriate   for the given , depending on the given .Kinds weren't formalized as a syntactic feature until Fortran 90, so we ask for a context. If possible (>=F90), we prefer the more explicit representation e.g. REAL(8)<. For older versions, for specific type-kind combinations, DOUBLE PRECISION and DOUBLE COMPLEX are used instead. However, we otherwise don't shy away from adding kind info regardless of theoretical version support.Array types don't work properly, due to array type info being in a parent node that holds individual elements. fortran-srcGiven a  ? infer the "default" kind (or size of the variable in memory).Useful when you need a default kind, but gives you an unwrapped type. Consider using Analysis.deriveSemTypeFromBaseType also.Further documentation: https://docs.oracle.com/cd/E19957-01/805-4939/c400041360f5/index.html' N Safe-Inferred%)*0125689:;<=>?w Safe-Inferred%)*0125689:;<=>?- Safe-Inferred%)*0125689:;<=>?֝ fortran-src:Not particularly efficient (but neither is GenericPretty).. Safe-Inferred$)*0125689:;<=>?َ fortran-src The length of a CHARACTER value.3IanH provides a great reference on StackOverflow: ,https://stackoverflow.com/a/25051522/2246637 fortran-srcCHARACTER(LEN=x) (where x is a constant integer expression). Value has the given static length. fortran-srcCHARACTER(LEN=*). F90. Value has assumed length. For a dummy argument, the length is assumed from the actual argument. For a PARAMETER named constant, the length is assumed from the length of the initializing expression. fortran-srcCHARACTER(LEN=:). F2003. Value has deferred length. Must have the ALLOCATABLE or POINTER attribute./ Safe-Inferred$)*0125689:;<=>?f fortran-srcA Fortran scalar type. fortran-src-F77 structure, F90 DDT (non-intrinsic scalar)  0 Safe-Inferred$)*0125689:;<=>? fortran-srcThe shape of a Fortran array is a list of extents. (The rank of the array is length of the list.)Note that the F90 standard limits maximum array rank to 7 (R512).TODO * An empty list here feels nonsensical. Perhaps this should be NonEmpty. * List type is inefficient here, since we don't care about pushing/popping, and list length is important. Use a vector type instead. fortran-srcA Fortran array type.An array type is defined by a scalar type together with a shape.1 Safe-Inferred$)*0125689:;<=>?ݥ fortran-src!A Fortran type (scalar or array).2 Safe-Inferred$)*0125689:;<=>? 3 Safe-Inferred&)*0125689:;<=>? fortran-src Attempt to a  into an  of the given length. fortran-srcLift a  into . fortran-srcThis is a painful instance to define. We cheat by leveraging the instance of the length-hiding type , then asserting length. It's CPU and memory inefficient and has backwards dependencies, but is comfortably safe.  4 Safe-Inferred()*0125689:;<=>?8  fortran-srcA kinded Fortran value. fortran-src9The Haskell type used to record this Fortran type's kind. fortran-src,For every Fortran kind of this Fortran type a#, the underlying representation b has the given constraints. fortran-src#Obtain the kind of a Fortran value. fortran-srcConvenience wrapper which multiple Fortran tag-kinded intrinsic types fit.A type ft takes some type fk of kind k, and we are permitted to move the type between the term and type levels using the included singleton instances.1For example, integers are kinded with type level FTInts. So we can define an integer with an existential ("unknown") kind with the type  FTInt FInt. By pattern matching on it, we recover the hidden kind tag (as well as obtaining the value).>Note that many type classes usually derived generically (e.g. ) instances should be manually derived on this wrapper type. TODO give a better explanation why? fortran-src Recover some TYPE(x) 's kind (the x). fortran-srcFor any Fortran type ft kinded with k, we may derive a 3 instance by leveraging the kind tag's instance  ( k)$ and the kinded value's instance  (ft k)?. (We also have to ferry some singletons instances through.)WARNING: This instance is only sound for types where each kind tag value is used once at most (meaning if you know the fkind, you know the constructor).Note that the  instance works by parsing a kind tag, promoting it to a singleton, then gleaning type information and using that to parse the inner kinded value. Dependent types! TODO if we pack a Data context into SomeFKinded, get can't recover it!! fortran-srcDerive  instances via . fortran-srcGHC can derive stock  instances given some QuantifiedConstraints guarantees (wow!).5 Safe-Inferred$)*0125689:;<=>? fortran-src REAL(4) fortran-src REAL(8)  6 Safe-Inferred$)*0125689:;<=>?! fortran-srcA Fortran integer value, type  INTEGER(k). fortran-src  INTEGER(1) fortran-src  INTEGER(2) fortran-src  INTEGER(4) fortran-src  INTEGER(8)7 Safe-Inferred$)*0125689:;<=>? fortran-src'Retrieve the boolean value stored by a  LOGICAL(x). fortran-srcConvert a bool to its Fortran machine representation in any numeric type. fortran-src5Consume some Fortran logical stored using an integer.O Safe-Inferred$)*0125689:;<=>?P Safe-Inferred$)*0125689:;<=>?s8 Safe-Inferred%)*0125689:;<=>?' fortran-src  COMPLEX(8) fortran-src  COMPLEX(16)9 Safe-Inferred$)*0125689:;<=>? fortran-srcA Fortran scalar value. fortran-src&Recover a Fortran scalar value's type.Q Safe-Inferred$)*0125689:;<=>?|: Safe-Inferred%)*0125689:;<=>?" fortran-src(A Fortran value (scalar only currently).R Safe-Inferred$)*0125689:;<=>?; Safe-Inferred$)*0125689:;<=>?h fortran-srcOperation TODO fortran-src>According to gfortran spec and F2010 spec, same kind required.S Safe-Inferred$)*0125689:;<=>?UVWXYZ_^][\ijkuvw< Safe-Inferred$)*0125689:;<=>?$ fortran-srcoriginal annotation fortran-srcunique name for function/variable, after variable renaming phase fortran-src8original name for function/variable found in source text fortran-srcbasic block graph fortran-src5unique number for each block during dataflow analysis fortran-src+The type of "transformBiM"-family functions fortran-src*The type of "transformBi"-family functions fortran-srcBasic block graph. fortran-srcthe underlying graph fortran-srcthe entry node(s) fortran-srcthe exit node(s) fortran-src Basic block fortran-srcEmpty basic block graph fortran-src%Call function on the underlying graph fortran-src1Monadically call function on the underlying graph fortran-src;True iff the expression can be used with varName or srcName fortran-srcObtain either  or  from an  variable, or an .Precedence is as follows:if  is present, it is returnedelse if  is present, it is returned)else the variable name itself is returned Crashes on  s which don't define a variable. fortran-src1Obtain the source name from an ExpValue variable. fortran-srcObtain either uniqueName or source name from an LvSimpleVar variable. fortran-src4Obtain the source name from an LvSimpleVar variable. fortran-srcGenerate an ExpValue variable with its source name == to its uniqueName. fortran-src?Obtain either ProgramUnit uniqueName or whatever is in the AST. fortran-src?Obtain either ProgramUnit sourceName or whatever is in the AST. fortran-srcCreate analysis annotations for the program, saving the original annotations. fortran-srcRemove analysis annotations from the program, restoring the original annotations. fortran-srcReturn list of expressions used as the left-hand-side of assignment statements (including for-loops and function-calls by reference). fortran-srcReturn list of expressions that are not "left-hand-side" of assignment statements. fortran-src,Is this an expression capable of assignment? fortran-src"Set of names found in an AST node. fortran-srcInitiate (lazy) computation of all LHS variables for each node of the AST so that it may be accessed later. fortran-srcSet of names found in the parts of an AST that are the target of an assignment statement. allLhsVars :: (Annotated b, Data a, Data (b (Analysis a))) => b (Analysis a) -> [Name] fortran-srcSet of names found in the parts of an AST that are the target of an assignment statement. fortran-src:Set of expressions used -- not defined -- by an AST-block. fortran-src7Set of expression used -- not defined -- by a statement fortran-src4Set of names used -- not defined -- by an AST-block. fortran-src%Set of names defined by an AST-block.= Safe-Inferred&)*/0125689:;<=>? fortran-srcA simple pure interpreter for Fortran value evaluation programs. fortran-srcderivingvia helper fortran-srcA convenience constraint tuple defining the base requirements of the  evaluator.The evaluator is formed of combinators returning values in this monad. You may insert your own evaluator which handles monadic actions differently, provided it can fulfill these constraints. fortran-srcError encountered while evaluating a Fortran expression to a value. fortran-srcSyntax which probably should be supported, but (currently) isn't. fortran-src>Special value-like expression that we can't evaluate usefully. fortran-src!Catch-all for non-grouped errors. fortran-srcWrap the output of an operation that returns a scalar value into the main evaluator. fortran-srcEvaluate explicit binary operators (ones denoted as such in the AST).Note that this does not cover all binary operators -- there are many intrinsics which use function syntax, but are otherwise binary operators. fortran-src  INT(a, 1) fortran-src  INT(a, 2) fortran-src INT(a, 4), INT(a) fortran-src  INT(a, 8) fortran-src/Evaluate a constant expression (F2018 10.1.12).++> Safe-Inferred$)*0125689:;<=>?" fortran-src How to handle declarations like  INTEGER x*8. If true, providing a character length for a non-character data type will treat it as a kind parameter. In both cases, a warning is logged (nonstandard syntax). fortran-src$Mapping of structures to field types fortran-src(Information about a detected type error. fortran-src%Mapping of names to type information. fortran-srcAnnotate AST nodes with type information and also return a type environment mapping names to type information. fortran-srcAnnotate AST nodes with type information and also return a type environment mapping names to type information; provided with a starting type environment. fortran-srcAnnotate AST nodes with type information, return a type environment mapping names to type information and return any type errors found; provided with a starting type environment. fortran-src&Records array type information from a /. (Scalar type info is processed elsewhere.) Note that  is rewritten for s in  later. TODO how does this assist exactly? disabling apparently doesn't impact tests fortran-srcAuxiliary function for getting semantic and construct type of a declaration. Used in standard declarations and structures fortran-srcCreate a structure env from the list of fields and add it to the InferState fortran-src+Derive the kind of a REAL literal constant.Logic taken from HP's F90 reference pg.33, written to gfortran's behaviour. Stays in the # monad so it can report type errors fortran-src Combine two  s with a .:No real work done here, no kind combining, just selection. fortran-srcFor all types holding an  (in an  ), set the  field of the . fortran-srcAttempt to derive the = of a variable from the relevant parts of its surrounding .+This is an example of a simple declaration:INTEGER(8) :: var_nameA declaration holds a  0 (left of the double colon; LHS) and a list of s (right of the double colon; RHS). However, CHARACTER variable are allowed to specify their length via special syntax on the RHS:CHARACTER :: string*10so to handle that, this function takes that length as a Maybe Expression (as provided in ).If a length was defined on both sides, the declaration length (RHS) is used. This matches gfortran's behaviour, though even with -Wall they don't warn on this rather confusing syntax usage. We report a (soft) type error. fortran-srcAttempt to derive a  from a  . fortran-src#Attempt to derive a SemType from a   and a  . fortran-srcDerive  directly from  , using relevant default kinds.  ? Safe-Inferred$)*0125689:;<=>?P fortran-srcAnnotate unique names for variable and function declarations and uses. fortran-srcAnnotate unique names for variable and function declarations and uses. With external module map. fortran-srcTake the unique name annotations and substitute them into the actual AST. fortran-src,Take a renamed program and undo the renames. fortran-srcConcat a scope, a variable, and a freshly generated number together to generate a "unique name".GitHub issue #190 showed it was possible to generate the same unique name for two different variables, if using the following unique name schema:scope "_" var n n=3: int1 -> func_int13 n=13: int -> func_int13Instead, we now insert another underscore between the variable and the fresh number, to disambiguate where the fresh number starts.scope "_" var "_" n n=3: int1 -> func_int1_3 n=13: int -> func_int_13@ Safe-Inferred$)*0125689:;<=>?A Safe-Inferred$)*0125689:;<=>?.B Safe-Inferred$)*0125689:;<=>?C Safe-Inferred$)*0125689:;<=>?D Safe-Inferred$)*0125689:;<=>?  fortran-src1A mapping of program unit names to bblock graphs. fortran-src;Insert basic block graphs into each program unit's analysis fortran-srcCreate a mapping of (non-module) program unit names to their associated bblock graph. fortran-src2Show a basic block graph in a somewhat decent way. fortran-src,Show a basic block graph without the clutter fortran-srcShow a basic block supergraph fortran-srcPick out and show the basic block graphs in the program file analysis. fortran-src)Output a graph in the GraphViz DOT format fortran-src.Output a supergraph in the GraphViz DOT format fortran-srcSome helper functions to output some pseudo-code for readability. fortran-src,Fold a function over the graph. Monadically. fortran-src+Map a function over the graph. Monadically. fortran-srcMap a function over the  labels in a graph. Monadically.E Safe-Inferred$)*0125689:;<=>?78 fortran-srcCallMap : program unit name -> { name of function or subroutine } fortran-src7InductionVarMapByASTBlock : AST-block label -> { name } fortran-srcMap of loop header nodes to the induction variables within that loop. fortran-src,LoopNodeMap : bblock node -> { bblock node } fortran-src(BackEdgeMap : bblock node -> bblock node fortran-srcThe map of all expressions and whether they are undecided (not present in map), a constant value (), or probably not constant (). fortran-srcThe map of all parameter variables and their corresponding values fortran-src#Represent "flows" between variables fortran-srcFlowsGraph : nodes as AST-block (numbered by label), edges showing which definitions contribute to which uses. fortran-srcUDMap : use -> { definition } fortran-srcDUMap : definition -> { use } fortran-src-DefMap : variable name -> { AST-block label } fortran-srcBlockMap : AST-block label -> AST-block Each AST-block has been given a unique number label during analysis of basic blocks. The purpose of this map is to provide the ability to lookup AST-blocks by label. fortran-src?OutF, a function that returns the out-dataflow for a given node fortran-src=InF, a function that returns the in-dataflow for a given node fortran-src=InOutMap : node -> (dataflow into node, dataflow out of node) fortran-src>InOut : (dataflow into the bblock, dataflow out of the bblock) fortran-srcAn OrderF is a function from graph to a specific ordering of nodes. fortran-src-IDomMap : node -> immediate dominator of node fortran-src#DomMap : node -> dominators of node fortran-srcCompute dominators of each bblock in the graph. Node A dominates node B when all paths from the start node of that program unit must pass through node A in order to reach node B. That will be represented as the relation (B, [A, ...]) in the DomMap. fortran-srcCompute the immediate dominator of each bblock in the graph. The immediate dominator is, in a sense, the closest dominator of a node. Given nodes A and B, you can say that node A is immediately dominated by node B if there does not exist any node C such that: node A dominates node C and node C dominates node B. fortran-srcThe postordering of a graph outputs the label after traversal of children. fortran-srcReversed postordering. fortran-srcThe preordering of a graph outputs the label before traversal of children. fortran-srcReversed preordering. fortran-srcApply the iterative dataflow analysis method. Forces evaluation of intermediate data structures at each step. fortran-srcBuild a BlockMap from the AST. This can only be performed after analyseBasicBlocks has operated, created basic blocks, and labeled all of the AST-blocks with unique numbers. fortran-srcBuild a DefMap from the BlockMap. This allows us to quickly look up the AST-block labels that wrote into the given variable. fortran-srcDataflow analysis for live variables given basic block graph. Muchnick, p. 445: A variable is "live" at a particular program point if there is a path to the exit along which its value may be used before it is redefined. It is "dead" if there is no such path. fortran-srcIterate KILL" set through a single basic block. fortran-srcIterate GEN" set through a single basic block. fortran-srcKILL set for a single AST-block. fortran-srcGEN set for a single AST-block. fortran-srcReaching definitions dataflow analysis. Reaching definitions are the set of variable-defining AST-block labels that may reach a program point. Suppose AST-block with label A defines a variable named v. Label A may reach another program point labeled P if there is at least one program path from label A to label P that does not redefine variable v. fortran-srcdef-use map: map AST-block labels of defining AST-blocks to the AST-blocks that may use the definition. fortran-srcInvert the DUMap into a UDMap fortran-srcuse-def map: map AST-block labels of variable-using AST-blocks to the AST-blocks that define those variables. fortran-src$Convert a UD or DU Map into a graph. fortran-src6"Flows-To" analysis. Represent def-use map as a graph. fortran-srcCreate a map (A -> Bs) where A "flows" or contributes towards the variables Bs. fortran-srcGenerate a constant-expression map with information about the expressions (identified by insLabel numbering) in the ProgramFile pf (must have analysis initiated & basic blocks generated) . fortran-srcGet constant-expression information and put it into the AST analysis annotation. Must occur after analyseBBlocks. fortran-srcAnnotate AST with constant-expression information based on given ParameterVarMap. fortran-srcFind the edges that 'loop back' in the graph; ones where the target node dominates the source node. If the backedges are viewed as (m -> n) then n is considered the 'loop-header' fortran-srcFor each loop in the program, find out which bblock nodes are part of the loop by looking through the backedges (m, n) where n is considered the 'loop-header', delete n from the map, and then do a reverse-depth-first traversal starting from m to find all the nodes of interest. Intersect this with the strongly-connected component containing m, in case of improper& graphs with weird control transfers. fortran-srcSimilar to loopNodes except it creates a map from loop-header to the set of loop nodes, for each loop-header. fortran-src9The strongly connected component containing a given node. fortran-srcBasic induction variables are induction variables that are the most easily derived from the syntactic structure of the program: for example, directly appearing in a Do-statement. fortran-srcFor each loop in the program, figure out the names of the induction variables: the variables that are used to represent the current iteration of the loop. fortran-srcGenerate an induction variable map that is indexed by the labels on AST-blocks within those loops. fortran-srcFor every expression in a loop, try to derive its relationship to a basic induction variable. fortran-src.Show some information about dataflow analyses. fortran-srcOutputs a DOT-formatted graph showing flow-to data starting at the given AST-Block node in the given Basic Block graph. fortran-src7Create a call map showing the structure of the program. fortran-srcFinds the transitive closure of a directed graph. Given a graph G=(V,E), its transitive closure is the graph: G* = (V,E*) where E*={(i,j): i,j in V and there is a path from i to j in G} tc :: (DynGraph gr) => gr a b -> gr a () tc g = newEdges  insNodes ln empty where ln = labNodes g newEdges = [ toLEdge (u, v) () | (u, _) <- ln, (_, v) <- bfen (outU g u) g ] outU gr = map toEdge . out gr fortran-srcbasic block graph fortran-src'initialisation for in and out dataflows fortran-srcordering function fortran-src.compute the in-flow given an out-flow function fortran-src.compute the out-flow given an in-flow function fortran-srcfinal dataflow for each node fortran-srcresult of reaching definitions<<F Safe-Inferred$)*0125689:;<=>?G" fortran-src,Status of mod-file compared to Fortran file. fortran-srcA set of decoded mod files. fortran-src"The data stored in the "mod files" fortran-src8A map of variables => their constant expression if known fortran-srcA map of aliases => strings, in order to save space and share structure for repeated strings. fortran-srcMap of unique variable name to the unique name of the program unit where it was defined, its source name, and the corresponding SrcSpan. fortran-srcContext of a declaration: the ProgramUnit where it was declared. fortran-src(uniqName, srcName) fortran-src(uniqName, srcName) fortran-src1Standard ending of fortran-src-format "mod files" fortran-srcReturns true for filepaths with an extension that identifies them as a mod file. fortran-srcEmpty set of mod files. (future proof: may not always be a list) fortran-srcStarting point. fortran-srcExtracts the module map, declaration map and type analysis from an analysed and renamed ProgramFile, then inserts it into the ModFile. fortran-srcGenerate a fresh ModFile from the module map, declaration map and type analysis of a given analysed and renamed ProgramFile. fortran-srcLooks up the raw "other data" that may be stored in a ModFile by applications that make use of fortran-src. fortran-srcGet a list of the labels present in the "other data" of a ModFile. More of a meta-programming / debugging feature. fortran-srcAllows modification insertiondeletion of "other data" that may be stored in a ModFile by applications that make use of fortran-src. See TU< for more information about the interface of this function. fortran-src environment) by collecting all of the stored module maps within the PUModule annotation. fortran-srcExtract map of declared variables with their associated program unit and source span. fortran-srcExtract a string map from the given data, leaving behind aliased values in place of strings in the returned version. fortran-srcRewrite the data with the string map aliases replaced by the actual values (implicitly sharing structure). fortran-src7Extract a map of variables assigned to constant values. fortran-srcCompare the source file timestamp to the fsmod file timestamp, if it exists.))G Safe-Inferred$)*0125689:;<=>?L fortran-srcOur common Fortran parser type takes a filename and input, and returns either a normalized error (tokens are printed) or an untransformed  . fortran-src;May be used to lift parse results into IO and force unwrap. fortran-srcObtain a Fortran parser by assuming the version from the filename provided. fortran-srcThe default post-parse AST transformation for each Fortran version./Formed by composing transformations end-to-end.Note that some transformations are noncommutative e.g. labeled DO grouping must be done before block DO grouping. fortran-srcInitialize free-form parser state with the lexer configured for standalone expression parsing.The free-form lexer needs a non-default start code for lexing standaloe expressions. fortran-src4Convenience wrapper to easily use a parser unsafely.This throws a catchable runtime IO exception, which is used in the tests. fortran-srcHelper for preparing initial parser state for the different lexers.H Safe-Inferred$)*0125689:;<=>?N'  VWXYZLYZ[\]^_``abcdeffghijklmnopqrstuvwxyz{|}~                                                                    M_                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ! ! ! ! " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # $ $ % % % % % % & & & & & & ' ' ' ' ' ' ( (( ) ) ) ) ) * * * * * + + + + + + + + + + + + + + , , , , , , ,J,,,,, ,, , , , , , , , , , , , , , ,,,,,,,,,,,,,,,,,------............///////////////00000000000000000011111112333333333333333333333334444444444455555555555555555566666666666666666666677778888888888888889999999999999:::::::::::;;;;;;;;;;;;;;;;;;<I<I<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<=====================================================>>>>>>>>>>>>>>???????@@@@@AAABCCCDDDDDDDDDDDDDDDDDDDEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGHHHHHHHHHHHHHHHHHHHVY YYYYZYYYYY%%&&''))**NNNNNNNNY<<>>>>>>>>>>?DDDEEEEEEEFFGfortran-src-0.16.3-inplace$Language.Fortran.Repr.Compat.NaturalLanguage.Fortran.ASTLanguage.Fortran.AST.Common&Text.PrettyPrint.GenericPretty.ViaShow Language.Fortran.AST.Literal.Boz!Language.Fortran.AST.Literal.Real"Language.Fortran.Parser.LexerUtilsLanguage.Fortran.Repr.Tmp(Language.Fortran.Repr.Type.Scalar.Common%Language.Fortran.Repr.Type.Scalar.Int&Language.Fortran.Repr.Type.Scalar.Real)Language.Fortran.Repr.Type.Scalar.ComplexLanguage.Fortran.Repr.Util"Language.Fortran.Repr.Value.Common0Language.Fortran.Repr.Value.Scalar.Int.Idealized4Language.Fortran.Repr.Value.Scalar.Logical.Idealized"Language.Fortran.Rewriter.InternalLanguage.Fortran.Util.Files$Language.Fortran.Util.FirstParameterLanguage.Fortran.AST.Annotated%Language.Fortran.Util.SecondParameterLanguage.Fortran.Util.PositionLanguage.Fortran.RewriterLanguage.Fortran.AST.Literal$Language.Fortran.AST.Literal.ComplexLanguage.Fortran.AST.AListLanguage.Fortran.VersionLanguage.Fortran.Parser.Monad"Language.Fortran.Parser.Free.Lexer"Language.Fortran.Parser.Free.Utils#Language.Fortran.Parser.Fixed.LexerLanguage.Fortran.Intrinsics!Language.Fortran.Repr.Eval.CommonLanguage.Fortran.PrettyPrintLanguage.Fortran.Common.Array#Language.Fortran.Parser.ParserUtils&Language.Fortran.Parser.Free.Fortran95&Language.Fortran.Parser.Free.Fortran90(Language.Fortran.Parser.Free.Fortran2003#Language.Fortran.Parser.Fixed.Utils'Language.Fortran.Parser.Fixed.Fortran77'Language.Fortran.Parser.Fixed.Fortran66Language.Fortran.LValue'Language.Fortran.Analysis.SemanticTypes&Text.PrettyPrint.GenericPretty.Orphans(Language.Fortran.Repr.Type.Scalar.String!Language.Fortran.Repr.Type.Scalar Language.Fortran.Repr.Type.ArrayLanguage.Fortran.Repr.TypeLanguage.Fortran.Repr.Eval.Type)Language.Fortran.Repr.Value.Scalar.String)Language.Fortran.Repr.Value.Scalar.Common'Language.Fortran.Repr.Value.Scalar.Real.Language.Fortran.Repr.Value.Scalar.Int.Machine2Language.Fortran.Repr.Value.Scalar.Logical.Machine*Language.Fortran.Repr.Value.Scalar.Complex*Language.Fortran.Repr.Value.Scalar.Machine#Language.Fortran.Repr.Value.Machine#Language.Fortran.Repr.Eval.Value.OpLanguage.Fortran.Analysis Language.Fortran.Repr.Eval.ValueLanguage.Fortran.Analysis.Types"Language.Fortran.Analysis.Renaming%Language.Fortran.Transformation.Monad(Language.Fortran.Transformation.Grouping8Language.Fortran.Transformation.Disambiguation.Intrinsic7Language.Fortran.Transformation.Disambiguation.Function!Language.Fortran.Analysis.BBlocks"Language.Fortran.Analysis.DataFlowLanguage.Fortran.Util.ModFileLanguage.Fortran.Parser"Language.Fortran.Analysis.ModGraphAnalysisSemTypeData.List.NonEmptyNonEmpty ExpressionPaths_fortran_src*Language.Fortran.Repr.Value.Scalar.Logical&Language.Fortran.Repr.Value.Scalar.Int"Language.Fortran.Repr.Value.ScalarLanguage.Fortran.Repr.ValueLanguage.Fortran.ReprData.Map.Strictalter ghc-bignumGHC.Num.NaturalNaturalbaseGHC.Base:|NameGnrcPrtty-1.2.2-378a93e0Text.PrettyPrint.GenericPrettyOut Conforming Nonconforming BozPrefix BozPrefixB BozPrefixO BozPrefixZBoz bozPrefix bozStringbozPrefixWasPostfixparseBoz prettyBoz bozAsNatural bozAsTwosComp $fEqBozPrefix$fEqBoz $fShowBoz $fGenericBoz $fDataBoz$fOrdBoz $fNFDataBoz$fOutBoz$fShowBozPrefix$fGenericBozPrefix$fDataBozPrefix$fOrdBozPrefix$fNFDataBozPrefix$fOutBozPrefix$fEqConforming$fOrdConforming$fShowConforming$fGenericConforming$fDataConforming$fNFDataConforming$fOutConformingExponentLetter ExpLetterE ExpLetterD ExpLetterQExponentexponentLetter exponentNumRealLitrealLitSignificandrealLitExponentprettyHsRealLit readRealLit parseRealLit $fEqRealLit $fOrdRealLit $fShowRealLit $fDataRealLit$fGenericRealLit$fNFDataRealLit $fOutRealLit $fEqExponent $fOrdExponent$fShowExponent$fDataExponent$fGenericExponent$fNFDataExponent $fOutExponent$fEqExponentLetter$fOrdExponentLetter$fShowExponentLetter$fDataExponentLetter$fGenericExponentLetter$fNFDataExponentLetter$fOutExponentLetter readIntOrBozNaturalKtestFtestDprettyHexByteString prettyHexByteprettyHexByteStringCompactFKind printFKind parseFKindFKindLit FTIntCombineFTIntFTInt1FTInt2FTInt4FTInt8FTInt16 $fFKindFTInt $fShowFTInt$fGenericFTInt $fDataFTInt $fEnumFTInt $fEqFTInt $fOrdFTInt $fBinaryFTInt $fOutFTIntFTRealFTReal4FTReal8 $fFKindFTReal $fShowFTReal$fGenericFTReal $fDataFTReal $fEnumFTReal $fEqFTReal $fOrdFTReal$fBinaryFTReal $fOutFTRealFTComplexWrapperunFTComplexWrapper$fFKindFTComplexWrapper$fShowFTComplexWrapper$fGenericFTComplexWrapper$fDataFTComplexWrapper$fEnumFTComplexWrapper$fEqFTComplexWrapper$fOrdFTComplexWrapper$fBinaryFTComplexWrapper$fOutFTComplexWrappernatVal''CheckChecked UncheckedPrimReprMachine Idealized SomeFIntIFIntIFIntMRepfIntICheckBoundssomeFIntIBOpWrap $fEqSomeFIntI $fShowFIntI$fGenericFIntI $fDataFIntI $fEqFIntI $fOrdFIntI $fBinaryFIntI $fOutFIntI$fShowSomeFIntIFLogical$fShowFLogical $fEqFLogical $fOrdFLogicalReplacementMapChunkReplacementErrorOverlappingErrorInvalidRangeError ReplacementRChar SourceRangeSourceLocation toRCharList markRChars markRChars_setReplacementStringSLsetReplacementStringSRevaluateRChars evaluateRChar nextChunk nextChunk_ allChunksevaluateChunksevaluateChunks_isMarkedForRemoval isInsertion insertionSRsetReplacementsetReplacementsadjustLineWrapadjustLineWrapAuxdeleteRCappendRC areDisjoint isValidRangeisValidLocation checkRangescheckOverlappingapplyReplacementsapplyReplacements_$fOrdSourceLocation$fShowSourceRange$fOrdReplacement$fExceptionReplacementError$fShowReplacementError$fEqReplacementError$fShowReplacement$fEqReplacement $fShowRChar $fEqRChar$fEqSourceRange$fShowSourceLocation$fEqSourceLocation flexReadFilegetDirContentsrGetDirContentsrunCPP expandDirslistFortranFileslistDirectoryRecursivelyGFirstParametergetFirstParameter'setFirstParameter'FirstParametergetFirstParametersetFirstParameter$fGFirstParameterkU1[]$fGFirstParameterk:*:e$fGFirstParameterk:+:e$fGFirstParameterkM1e$fGFirstParameterkK1e$fGFirstParameterkK1e0 Annotated getAnnotation setAnnotationmodifyAnnotationSecondParametergetSecondParametersetSecondParameter$fGSecondParameterk:+:e$fGSecondParameterkM1e$fGSecondParameterkK1e$fGSecondParameter'kK1e$fGSecondParameter'kK1e0$fGSecondParameter'k:*:e$fGSecondParameter'kM1e$fParameterLeafk:*:$fParameterLeafkM1$fGSecondParameterk:*:e SpannedPair getTransSpanSpannedgetSpansetSpanSrcSpanssFromssToPositionposAbsoluteOffset posColumnposLine posFilePathposPragmaOffsetLocgetPos initPositionlineColapparentLineColapparentFilePathcolumnDistance lineDistance spannedLines initSrcSpan emptySpan$fShowPosition$fNFDataPosition$fBinaryPosition $fOutSrcSpan $fShowSrcSpan$fNFDataSrcSpan$fBinarySrcSpan$fSpannedEither$fSpannedSrcSpan$fSpannedPaira[]$fSpannedPaira[]0$fSpannedPairab $fSpanned(,,)$fSpanned(,,)0$fSpanned(,,)1$fSpanned(,,)2 $fSpanned(,) $fSpanned(,)0 $fSpanned(,)1$fSpannedNonEmpty $fSpanned[] $fEqSrcSpan $fOrdSrcSpan $fDataSrcSpan$fGenericSrcSpan $fEqPosition $fOrdPosition$fDataPosition$fGenericPositionpartitionOverlappingprocessReplacementsspanToSourceRangespanToSourceRange2sourceRangeBetweenTwoSpans KindParam KindParamInt KindParamVar$fSpannedKindParam!$fSecondParameterKindParamSrcSpan$fAnnotatedKindParam$fFirstParameterKindParama $fEqKindParam$fOrdKindParam$fShowKindParam$fDataKindParam$fGenericKindParam$fFunctorKindParam$fNFDataKindParam$fOutKindParam ComplexPartComplexPartRealComplexPartIntComplexPartNamed ComplexLitcomplexLitAnno complexLitPoscomplexLitRealPartcomplexLitImagPartcomplexLitIsPure$fSpannedComplexPart#$fSecondParameterComplexPartSrcSpan$fAnnotatedComplexPart$fFirstParameterComplexParta$fSpannedComplexLit"$fSecondParameterComplexLitSrcSpan$fAnnotatedComplexLit$fFirstParameterComplexLita$fEqComplexLit$fOrdComplexLit$fShowComplexLit$fDataComplexLit$fGenericComplexLit$fFunctorComplexLit$fNFDataComplexLit$fOutComplexLit$fEqComplexPart$fOrdComplexPart$fShowComplexPart$fDataComplexPart$fGenericComplexPart$fFunctorComplexPart$fNFDataComplexPart$fOutComplexPartATuple atupleAnno atupleSpan atupleFst atupleSndAList alistAnno alistSpan alistListfromList fromList'fromReverseListfromReverseList'aConsaEmptyaReverseaStripaStrip'aMap $fNFDataAList $fOutAList$fSpannedAList$fAnnotatedAList$fSecondParameterAListSrcSpan$fFirstParameterALista$fFunctorAList$fNFDataATuple $fOutATuple$fSpannedATuple$fSecondParameterATupleSrcSpan$fFirstParameterATuplea $fEqATuple $fOrdATuple $fShowATuple $fDataATuple$fGenericATuple$fFunctorATuple $fEqAList $fOrdAList $fShowAList $fDataAList$fGenericAListFortranVersion Fortran66 Fortran77Fortran77ExtendedFortran77Legacy Fortran90 Fortran95 Fortran2003 Fortran2008fortranVersionAliasesselectFortranVersiondeduceFortranVersion$fNFDataFortranVersion$fOutFortranVersion$fShowFortranVersion$fOrdFortranVersion$fEqFortranVersion$fDataFortranVersion$fGenericFortranVersionParseunParseTokeofToken LastToken getLastToken ParseResultParseOk ParseFailed ParseErrorerrPos errLastToken errFilenameerrMsg ParseState psAlexInputpsParanthesesCount psVersion psFilename psContextContextConStartConData ConImplicit ConNamelist ConCommonParanthesesCountpcActual pcHasReached0tokenMsgrunParserunParseUnsafe throwIOError evalParse execParse getVersionputAlexgetAlex topContext popContext pushContext getPosition getSrcSpangetParanthesesCountresetParincPardecPar$fExceptionParseError$fShowParseError$fMonadErrorParseErrorParse$fMonadStateParseStateParse$fMonadFailParse $fMonadParse$fApplicativeParse$fFunctorParse$fFunctorParseResult$fShowParseState $fShowContext $fEqContext$fShowParanthesesCount$fEqParanthesesCountTokenTIdTCommentTStringTIntegerLiteral TRealLiteral TBozLiteralTCommaTComma2 TSemiColonTColon TDoubleColon TOpAssignTArrowTPercentTLeftPar TLeftPar2 TRightPar TLeftInitPar TRightInitPar TOpCustomTOpExpTOpPlusTOpMinusTStar TOpDivisionTSlashTOpOrTOpAndTOpNot TOpEquivalentTOpNotEquivalentTOpLTTOpLETOpEQTOpNETOpGTTOpGETLogicalLiteral TUnderscoreTProgram TEndProgram TFunction TEndFunctionTResultTPure TElemental TRecursive TSubroutineTEndSubroutine TBlockData TEndBlockDataTModule TEndModule TContainsTUseTOnlyTImport TAbstract TInterface TEndInterface TProcedureTModuleProcedure TAssignment TOperatorTCallTReturnTEntryTIncludeTBindTCTName TAllocatable TAsynchronous TDimension TExternalTIntent TIntrinsic TNonIntrinsic TOptional TParameterTPointerTPrivateTPublic TProtectedTSaveTTargetTValue TVolatileTInTOutTInOutTData TNamelist TImplicit TEquivalenceTCommonTFormatTBlob TAllocateTStatTErrMsgTSource TDeallocateTNullifyTNoneTGotoTAssignTTo TContinueTStopTPauseTDoTEndDoTWhileTIfTThenTElseTElsifTEndIfTCase TSelectCase TEndSelectTDefaultTCycleTExitTForall TEndForall TAssociate TEndAssociateTWhere TElsewhere TEndWhereTTypeTEndType TSequenceTClassTEnum TEnumeratorTEndEnumTKindTLenTIntegerTRealTDoublePrecisionTLogical TCharacterTComplexTOpenTCloseTReadTWriteTPrint TBackspaceTRewindTInquireTEndfileTEndTNewlineTEOFTFlushTUnitTIOStatTIOMsgTErr LexAction AlexInput aiSourceBytes aiPosition aiEndOffsetaiPreviousCharaiLexeme aiStartCodeaiPreviousTokenaiPreviousTokensInLine StartCodescActualscStatusStartCodeStatusReturnStablescNvanillaAlexInputlexerlexer'$fSpannedLexeme $fTokToken$fSpannedToken$fFirstParameterTokenSrcSpan$fLastTokenAlexInputToken$fLocAlexInput$fSpecifiesType[]$fSpecifiesTypeToken$fShowAlexInput $fEqToken $fShowToken $fDataToken$fGenericToken$fShowStartCode$fShowStartCodeStatus $fShowLexeme unitNameCheck parseErroraiBytesaiWhiteSensitiveCharCountaiCaseSensitive aiInComment aiInFormataiFortranVersion lexemeMatch TLeftArrayParTRightArrayParTDot TStructureTRecordTUnionTMap TEndStructure TEndUnionTEndMapTEndif TCaseDefaultTDoWhile TTypePrintTStatic TAutomaticTInt TExponentTBool TAmpersandTOpXOr THollerithTLabellexN $fOrdTokenIntrinsicsTable IntrinsicTypeITReal ITInteger ITComplexITDouble ITLogical ITCharacterITParamgetVersionIntrinsicsgetIntrinsicReturnTypegetIntrinsicDefsUsesgetIntrinsicNames isIntrinsic allIntrinsics$fShowIntrinsicsEntry$fEqIntrinsicsEntry$fOrdIntrinsicsEntry$fGenericIntrinsicsEntry$fShowIntrinsicType$fEqIntrinsicType$fOrdIntrinsicType$fGenericIntrinsicTypeNamedgetNamesetNameProgramUnitNameNamelessBlockDataNamelessComment NamelessMainLabeledgetLabel getLastLabelsetLabelBinaryOpAddition SubtractionMultiplicationDivisionExponentiation ConcatenationGTGTELTLTEEQNEOrXOrAnd Equivalent NotEquivalent BinCustomUnaryOpPlusMinusNotUnCustomDimensionDeclarator dimDeclAnno dimDeclSpan dimDeclLower dimDeclUpperDeclaratorType ScalarDecl ArrayDecl DeclaratordeclaratorAnnodeclaratorSpandeclaratorVariabledeclaratorTypedeclaratorLengthdeclaratorInitialValue ValIntegerValReal ValComplex ValStringValBoz ValHollerith ValVariable ValIntrinsic ValLogical ValOperator ValAssignmentValTypeValStarValColonIndexIxSingleIxRangeExpValue ExpBinaryExpUnary ExpSubscript ExpDataRefExpFunctionCall ExpImpliedDoExpInitialisation ExpReturnSpecDoSpecification doSpecAnno doSpecSpan doSpecInitial doSpecLimitdoSpecIncrement FlushSpecFSUnitFSIOStatFSIOMsgFSErr FormatItem FIFormatList FIHollerith FIDelimiterFIFieldDescriptorDEFGFIFieldDescriptorAILFIBlankDescriptor FIScaleFactorUnionMap unionMapAnno unionMapSpanunionMapFields StructureItem StructFields StructUnionStructStructure DataGroup dataGroupAnno dataGroupSpandataGroupNamesdataGroupInitializersNamelist namelistAnno namelistSpan namelistName namelistVars CommonGroupcommonGroupAnnocommonGroupSpancommonGroupNamecommonGroupVars ImpElementimpElementAnnoimpElementSpanimpElementFrom impElementToImpList impListAnno impListSpan impListTypeimpListElementsAllocOptAOStatAOErrMsgAOSource ControlPaircontrolPairAnnocontrolPairSpancontrolPairNamecontrolPairExprIntentInInOut AttributeAttrAllocatableAttrAsynchronous AttrDimension AttrExternal AttrIntent AttrIntrinsic AttrOptional AttrParameter AttrPointer AttrPrivate AttrProtected AttrPublicAttrSave AttrSuffix AttrTarget AttrValue AttrVolatileArgumentExpressionArgExpr ArgExprVarArgument argumentAnno argumentSpan argumentName argumentExprUse UseRenameUseID ModuleNature ModIntrinsicModNonIntrinsicOnly Exclusive PermissiveForallHeaderPartforallHeaderPartAnnoforallHeaderPartSpanforallHeaderPartNameforallHeaderPartStartforallHeaderPartEndforallHeaderPartStride ForallHeaderforallHeaderAnnoforallHeaderSpanforallHeaderHeadersforallHeaderScaling ProcInterfaceProcInterfaceNameProcInterfaceTypeProcDecl procDeclAnno procDeclSpanprocDeclEntityNameprocDeclInitName Statement StDeclaration StStructureStIntent StOptionalStPublic StPrivate StProtectedStSave StDimension StAllocatableStAsynchronous StPointerStTargetStValue StVolatileStData StAutomaticStStatic StNamelist StParameter StExternal StIntrinsicStCommon StEquivalenceStFormat StImplicitStEntry StIncludeStDo StDoWhileStEnddoStCycleStExit StIfLogicalStIfArithmetic StSelectCaseStCase StEndcase StFunctionStExpressionAssignStPointerAssign StLabelAssignStGotoUnconditionalStGotoAssignedStGotoComputedStCallStReturn StContinueStStopStPauseStReadStRead2StWriteStPrint StTypePrintStOpenStCloseStFlush StInquireStRewind StRewind2 StBackspace StBackspace2 StEndfile StEndfile2 StAllocate StNullify StDeallocateStWhereStWhereConstruct StElsewhere StEndWhereStUseStModuleProcedure StProcedureStType StEndType StSequenceStForall StEndForallStForallStatementStImportStEnum StEnumerator StEndEnum StFormatBogusBlock BlStatementBlForallBlIfBlCaseBlDo BlDoWhile BlAssociate BlInterface BlCommentCommentSuffixSfxBindPrefix PfxRecursive PfxElementalPfxPure PrefixSuffixSuffixesPrefixes ProgramUnitPUMainPUModule PUSubroutine PUFunction PUBlockData PUComment ProgramFileprogramFileMetaprogramFileProgramUnitsMetaInfo miVersion miFilenameSelector selectorAnno selectorSpanselectorLength selectorKindTypeSpec typeSpecAnno typeSpecSpantypeSpecBaseTypetypeSpecSelectorBaseType TypeIntegerTypeRealTypeDoublePrecision TypeComplexTypeDoubleComplex TypeLogical TypeCharacter TypeCustom ClassStar ClassCustomTypeByteA0 pfSetFilename pfGetFilename emptyPrefixes emptySuffixesemptyPrefixSuffixvalidPrefixSuffixprogramUnitBodyupdateProgramUnitBodyprogramUnitSubprogramsargExprNormalizeargExtractExprsetInitialisationnonExecutableStatementexecutableStatementexecutableStatementBlocknonExecutableStatementBlock $fOutNonEmpty$fNFDataBaseType $fOutBaseType$fNFDataMetaInfo $fOutMetaInfo$fNFDataPrefix $fOutPrefix$fSpannedPrefix$fSecondParameterPrefixSrcSpan$fFirstParameterPrefixa$fNFDataComment $fOutComment $fNFDataOnly $fOutOnly$fNFDataModuleNature$fOutModuleNature$fNFDataIntent $fOutIntent$fNFDataImpElement$fOutImpElement$fSpannedImpElement$fAnnotatedImpElement"$fSecondParameterImpElementSrcSpan$fFirstParameterImpElementa$fNFDataFormatItem$fOutFormatItem$fSpannedFormatItem$fAnnotatedFormatItem"$fSecondParameterFormatItemSrcSpan$fFirstParameterFormatItema$fNFDataUnaryOp $fOutUnaryOp$fBinaryUnaryOp$fNFDataBinaryOp $fOutBinaryOp$fBinaryBinaryOp$fNFDataUnionMap$fNFDataStructureItem$fNFDataSuffix$fNFDataNamelist$fNFDataImpList$fNFDataFlushSpec$fNFDataDeclaratorType$fNFDataDeclarator$fNFDataDimensionDeclarator$fNFDataDataGroup$fNFDataAllocOpt$fNFDataControlPair$fNFDataCommonGroup$fNFDataAttribute $fNFDataUse$fNFDataArgumentExpression$fNFDataArgument$fNFDataForallHeaderPart$fNFDataForallHeader$fNFDataSelector$fNFDataDoSpecification$fNFDataProcInterface$fNFDataProcDecl$fNFDataStatement $fNFDataIndex$fNFDataTypeSpec$fNFDataExpression $fNFDataBlock$fNFDataProgramUnit$fOutForallHeaderPart$fOutForallHeader $fOutAllocOpt$fOutControlPair$fOutDeclaratorType$fOutDimensionDeclarator$fOutDeclarator $fOutSelector $fOutTypeSpec$fOutFlushSpec$fOutDoSpecification $fOutIndex$fOutExpression $fOutNamelist $fOutUnionMap$fOutStructureItem$fOutDataGroup$fOutCommonGroup $fOutBlock $fOutImpList$fOutAttribute$fOutUse$fOutArgumentExpression $fOutArgument$fOutProcInterface $fOutProcDecl$fOutStatement $fOutSuffix$fOutProgramUnit$fSpannedForallHeaderPart$fSpannedForallHeader$fSpannedAllocOpt$fSpannedControlPair$fSpannedDimensionDeclarator$fSpannedDeclarator$fSpannedFlushSpec$fSpannedDoSpecification$fSpannedIndex$fSpannedExpression$fSpannedNamelist$fSpannedUnionMap$fSpannedStructureItem$fSpannedDataGroup$fSpannedCommonGroup$fSpannedBlock$fSpannedImpList$fSpannedSelector$fSpannedProcInterface$fSpannedProcDecl$fSpannedTypeSpec$fSpannedAttribute $fSpannedUse$fSpannedArgument$fSpannedStatement$fSpannedSuffix$fSpannedProgramUnit$fAnnotatedForallHeaderPart$fAnnotatedForallHeader$fAnnotatedAllocOpt$fAnnotatedControlPair$fAnnotatedDimensionDeclarator$fAnnotatedDeclarator$fAnnotatedFlushSpec$fAnnotatedDoSpecification$fAnnotatedIndex$fAnnotatedExpression$fAnnotatedNamelist$fAnnotatedUnionMap$fAnnotatedStructureItem$fAnnotatedDataGroup$fAnnotatedCommonGroup$fAnnotatedImpList$fAnnotatedAttribute$fAnnotatedSelector$fAnnotatedProcInterface$fAnnotatedProcDecl$fAnnotatedTypeSpec$fAnnotatedUse$fAnnotatedArgument$fAnnotatedStatement$fAnnotatedBlock$fAnnotatedProgramUnit($fSecondParameterForallHeaderPartSrcSpan$$fSecondParameterForallHeaderSrcSpan $fSecondParameterAllocOptSrcSpan#$fSecondParameterControlPairSrcSpan+$fSecondParameterDimensionDeclaratorSrcSpan"$fSecondParameterDeclaratorSrcSpan!$fSecondParameterFlushSpecSrcSpan'$fSecondParameterDoSpecificationSrcSpan$fSecondParameterIndexSrcSpan"$fSecondParameterExpressionSrcSpan $fSecondParameterNamelistSrcSpan $fSecondParameterUnionMapSrcSpan%$fSecondParameterStructureItemSrcSpan!$fSecondParameterDataGroupSrcSpan#$fSecondParameterCommonGroupSrcSpan$fSecondParameterImpListSrcSpan!$fSecondParameterAttributeSrcSpan $fSecondParameterSelectorSrcSpan%$fSecondParameterProcInterfaceSrcSpan $fSecondParameterProcDeclSrcSpan $fSecondParameterTypeSpecSrcSpan$fSecondParameterUseSrcSpan $fSecondParameterArgumentSrcSpan!$fSecondParameterStatementSrcSpan$fSecondParameterBlockSrcSpan$fSecondParameterSuffixSrcSpan#$fSecondParameterProgramUnitSrcSpan!$fFirstParameterForallHeaderParta$fFirstParameterForallHeadera$fFirstParameterAllocOpta$fFirstParameterControlPaira$$fFirstParameterDimensionDeclaratora$fFirstParameterDeclaratora$fFirstParameterFlushSpeca $fFirstParameterDoSpecificationa$fFirstParameterIndexa$fFirstParameterExpressiona$fFirstParameterNamelista$fFirstParameterUnionMapa$fFirstParameterStructureItema$fFirstParameterDataGroupa$fFirstParameterCommonGroupa$fFirstParameterImpLista$fFirstParameterAttributea$fFirstParameterSelectora$fFirstParameterProcInterfacea$fFirstParameterProcDecla$fFirstParameterTypeSpeca$fFirstParameterUsea$fFirstParameterArgumenta$fFirstParameterStatementa$fFirstParameterBlocka$fFirstParameterSuffixa$fFirstParameterProgramUnita$fSpannedArgumentExpression$fAnnotatedArgumentExpression$fNFDataProgramFile$fOutProgramFile$fSpannedProgramFile$fLabeledBlock$fNFDataProgramUnitName$fBinaryProgramUnitName$fNamedProgramUnit$fOrdProgramUnitName$fEqProgramUnitName$fShowProgramUnitName$fDataProgramUnitName$fGenericProgramUnitName$fEqProgramFile$fOrdProgramFile$fShowProgramFile$fDataProgramFile$fGenericProgramFile$fFunctorProgramFile$fEqExpression$fOrdExpression$fShowExpression$fDataExpression$fGenericExpression$fFunctorExpression $fEqIndex $fOrdIndex $fShowIndex $fDataIndex$fGenericIndex$fFunctorIndex$fEqDoSpecification$fOrdDoSpecification$fShowDoSpecification$fDataDoSpecification$fGenericDoSpecification$fFunctorDoSpecification $fEqStatement$fOrdStatement$fShowStatement$fDataStatement$fGenericStatement$fFunctorStatement$fEqDeclarator$fOrdDeclarator$fShowDeclarator$fDataDeclarator$fGenericDeclarator$fFunctorDeclarator$fEqDeclaratorType$fOrdDeclaratorType$fShowDeclaratorType$fDataDeclaratorType$fGenericDeclaratorType$fFunctorDeclaratorType$fEqDimensionDeclarator$fOrdDimensionDeclarator$fShowDimensionDeclarator$fDataDimensionDeclarator$fGenericDimensionDeclarator$fFunctorDimensionDeclarator $fEqFlushSpec$fOrdFlushSpec$fShowFlushSpec$fDataFlushSpec$fGenericFlushSpec$fFunctorFlushSpec$fEqStructureItem$fOrdStructureItem$fShowStructureItem$fDataStructureItem$fGenericStructureItem$fFunctorStructureItem $fEqUnionMap $fOrdUnionMap$fShowUnionMap$fDataUnionMap$fGenericUnionMap$fFunctorUnionMap $fEqAttribute$fOrdAttribute$fShowAttribute$fDataAttribute$fGenericAttribute$fFunctorAttribute $fEqSuffix $fOrdSuffix $fShowSuffix $fDataSuffix$fGenericSuffix$fFunctorSuffix $fEqTypeSpec $fOrdTypeSpec$fShowTypeSpec$fDataTypeSpec$fGenericTypeSpec$fFunctorTypeSpec $fEqSelector $fOrdSelector$fShowSelector$fDataSelector$fGenericSelector$fFunctorSelector $fEqDataGroup$fOrdDataGroup$fShowDataGroup$fDataDataGroup$fGenericDataGroup$fFunctorDataGroup $fEqNamelist $fOrdNamelist$fShowNamelist$fDataNamelist$fGenericNamelist$fFunctorNamelist$fEqCommonGroup$fOrdCommonGroup$fShowCommonGroup$fDataCommonGroup$fGenericCommonGroup$fFunctorCommonGroup $fEqImpList $fOrdImpList $fShowImpList $fDataImpList$fGenericImpList$fFunctorImpList $fEqAllocOpt $fOrdAllocOpt$fShowAllocOpt$fDataAllocOpt$fGenericAllocOpt$fFunctorAllocOpt$fEqControlPair$fOrdControlPair$fShowControlPair$fDataControlPair$fGenericControlPair$fFunctorControlPair $fEqArgument $fOrdArgument$fShowArgument$fDataArgument$fGenericArgument$fFunctorArgument$fEqArgumentExpression$fOrdArgumentExpression$fShowArgumentExpression$fDataArgumentExpression$fGenericArgumentExpression$fFunctorArgumentExpression$fEqUse$fOrdUse $fShowUse $fDataUse $fGenericUse $fFunctorUse$fEqForallHeader$fOrdForallHeader$fShowForallHeader$fDataForallHeader$fGenericForallHeader$fFunctorForallHeader$fEqForallHeaderPart$fOrdForallHeaderPart$fShowForallHeaderPart$fDataForallHeaderPart$fGenericForallHeaderPart$fFunctorForallHeaderPart$fEqProcInterface$fOrdProcInterface$fShowProcInterface$fDataProcInterface$fGenericProcInterface$fFunctorProcInterface $fEqProcDecl $fOrdProcDecl$fShowProcDecl$fDataProcDecl$fGenericProcDecl$fFunctorProcDecl $fEqBlock $fOrdBlock $fShowBlock $fDataBlock$fGenericBlock$fFunctorBlock$fEqProgramUnit$fOrdProgramUnit$fShowProgramUnit$fDataProgramUnit$fGenericProgramUnit$fFunctorProgramUnit $fEqBinaryOp $fOrdBinaryOp$fShowBinaryOp$fDataBinaryOp$fGenericBinaryOp $fEqUnaryOp $fOrdUnaryOp $fShowUnaryOp $fDataUnaryOp$fGenericUnaryOp$fEqFormatItem$fOrdFormatItem$fShowFormatItem$fDataFormatItem$fGenericFormatItem$fFunctorFormatItem $fEqValue $fOrdValue $fShowValue $fDataValue$fGenericValue$fFunctorValue $fNFDataValue $fOutValue$fEqImpElement$fOrdImpElement$fShowImpElement$fDataImpElement$fGenericImpElement$fFunctorImpElement $fEqIntent $fOrdIntent $fShowIntent $fDataIntent$fGenericIntent$fEqModuleNature$fOrdModuleNature$fShowModuleNature$fDataModuleNature$fGenericModuleNature$fEqOnly $fOrdOnly $fShowOnly $fDataOnly $fGenericOnly $fEqComment $fOrdComment $fShowComment $fDataComment$fGenericComment$fFunctorComment $fEqPrefix $fOrdPrefix $fShowPrefix $fDataPrefix$fGenericPrefix$fFunctorPrefix $fEqMetaInfo $fOrdMetaInfo$fShowMetaInfo$fDataMetaInfo$fGenericMetaInfo $fOrdBaseType $fEqBaseType$fShowBaseType$fDataBaseType$fGenericBaseType$fBinaryBaseType MonadFEvalEvalTo lookupFVarwarn ReformatStateRefmtStNewlineRefmtStComment RefmtStStmtPrettypprint'IndentablePrettypprint Indentation olderThancontinueOnlyFortooOld printMaybeprintIndentedBlockWithPrenewlineincIndentationindentoverlay fixedFormpprintAndRenderendGen noParensLitcommaSep$reformatMixedFormInsertContinuations prettyError$fIndentablePrettyUnionMap$fIndentablePretty[]$fIndentablePretty[]0$fIndentablePrettyProgramFile$fIndentablePrettyMaybe$fPrettyBinaryOp$fPrettyUnaryOp$fPrettyDimensionDeclarator$fPrettyDeclarator$fIndentablePrettyStructureItem$fPrettyComplexPart$fPrettyKindParam$fPrettyComplexLit $fPrettyValue $fPrettyIndex$fPrettyExpression$fPrettyImpElement$fPrettyDataGroup$fPrettyNamelist$fPrettyCommonGroup$fPrettyImpList$fPrettyAllocOpt$fPrettyControlPair$fPrettyDoSpecification$fPrettyFlushSpec$fPrettyFormatItem$fPrettyIntent$fPrettySuffix$fPrettyAttribute$fPrettyArgumentExpression$fPrettyArgument $fPrettyUse $fPrettyOnly$fPrettyProcDecl$fPrettyProcInterface$fPrettyStatement$fPrettySelector$fPrettyTypeSpec$fPrettyBaseType$fPrettyATuple $fPrettyAList $fPretty[] $fPrettyMaybe$fIndentablePrettyBlock$fIndentablePrettyProgramUnit$fIndentablePrettya$fEqReformatState$fOrdReformatState$fShowReformatStateDimsDimsExplicitShapeDimsAssumedSizeDimsAssumedShapeDimdimLowerdimUpperprettyIntersperse prettyAfter dimsTraverse dimsLength $fPrettyDim$fOutDim $fPrettyDims $fOutDims $fGenericDims $fFunctorDims$fFoldableDims$fTraversableDims $fShowDim $fGenericDim $fDataDim$fEqDim $fFunctorDim $fFoldableDim$fTraversableDim $fNFDataDim $fBinaryDim$fOrdDim $fOrdDims $fBinaryDims$fEqDims $fDataDims $fNFDataDims $fShowDimsexprToComplexLitPart complexLit programParserfunctionParser blockParserstatementParserexpressionParserincludesParser makeRealLitconvCmtsLValue LvSimpleVar LvSubscript LvDataReftoLValue$fSpannedLValue$fAnnotatedLValue$fSecondParameterLValueSrcSpan$fFirstParameterLValuea $fEqLValue $fShowLValue $fDataLValue$fGenericLValue$fFunctorLValue CharacterLen CharLenStar CharLenColon CharLenExp CharLenInt DimensionsTByteTArrayTCustomKinddimensionsToTuplescharLenSelectorcharLenSelector'charLenToValue getTypeKind setTypeKind charLenConcatrecoverSemTypeTypeSpeckindOfBaseType getTypeSize setTypeSize$fPrettySemType $fOrdSemType $fEqSemType $fShowSemType $fDataSemType$fGenericSemType$fNFDataSemType$fBinarySemType $fOutSemType$fOrdCharacterLen$fEqCharacterLen$fShowCharacterLen$fDataCharacterLen$fGenericCharacterLen$fNFDataCharacterLen$fBinaryCharacterLen$fOutCharacterLen OutShowly unOutShowly$fOutOutShowly $fOutNatural $fOutInt64 $fOutInt32 $fOutInt16 $fOutInt8 $fOutTextCharLenCharLenAssumedCharLenDeferred prettyCharLen $fShowCharLen$fGenericCharLen $fDataCharLen $fEqCharLen $fOrdCharLen$fBinaryCharLen $fOutCharLen FScalarTypeFSTIntFSTReal FSTComplex FSTLogical FSTString FSTCustomprettyScalarTypefScalarTypeKind prettyKinded$fGenericFScalarType$fDataFScalarType$fShowFScalarType$fEqFScalarType$fOrdFScalarTypeShapegetShape FArrayType fatScalarfatShapefatSize$fGenericFArrayType$fDataFArrayType$fShowFArrayType$fEqFArrayType$fOrdFArrayType$fGenericShape $fDataShape $fShowShape $fEqShape $fOrdShapeFType MkFScalarType MkFArrayType$fGenericFType $fEqFType $fShowFType $fDataFTypefromExpression SomeFStringFString eqFStringfString fStringLen someFStringsomeFStringLen concatFStringconcatSomeFString fStringBOpsomeFStringBOp$fBinarySomeFString$fDataSomeFString$fEqSomeFString$fBinaryFString$fOutSomeFString$fShowSomeFString $fDataFString $fOrdFString $fEqFString $fShowFStringFKindedFKindedTFKindedCfKind SomeFKindedsomeFKindedKind$fBinarySomeFKinded$fOutSomeFKinded$fShowSomeFKinded$fDataSomeFKindedFRealFReal4FReal8 fRealUOp' fRealBOp'fRealUOpInplace'fRealBOpInplace'fRealUOpfRealUOpInplacefRealBOpfRealBOpInplace $fEqFReal$fFKindedFReal $fShowFReal$fGenericFReal $fDataFReal $fBinaryFReal $fOutFRealFIntFInt1FInt2FInt4FInt8withFIntfIntUOp'fIntBOp'fIntUOpInplace'fIntBOpInplace'fIntUOpfIntUOpInplacefIntBOpfIntBOpInplace$fEqFInt $fFKindedFInt $fShowFInt $fGenericFInt $fDataFInt $fBinaryFInt $fOutFIntfLogicalToBoolfLogicalNumericFromBoolconsumeFLogicalNumeric fLogicalNotFComplex FComplex8 FComplex16fComplexFromReal fComplexBOp'fComplexBOpInplace' fComplexBOpfComplexBOpInplace $fEqFComplex$fFKindedFComplex$fShowFComplex$fGenericFComplex$fDataFComplex$fBinaryFComplex $fOutFComplex FScalarValueFSVIntFSVReal FSVComplex FSVLogical FSVStringfScalarValueType$fShowFScalarValue$fGenericFScalarValue$fDataFScalarValue$fEqFScalarValue$fBinaryFScalarValue$fOutFScalarValueFValueMkFScalarValue fValueType fromConstInt fromConstReal $fShowFValue$fGenericFValue $fDataFValue $fEqFValue$fBinaryFValue $fOutFValueError EBadArgType1 EBadArgType2EGenericopIcDble eBadArgType1 eBadArgType2eGenericopIcNumericBOpopIcNumericBOpRealIntSep opIcNumRelBOpopIcNumericUOpInplaceopIcLogicalBOpopEqopIor'opIor $fShowError $fEqErrorprevAnnotation uniqueName sourceNamebBlocksinsLabel moduleEnvidType allLhsVarsAnnconstExpIDTypeidVTypeidCType ConstructType CTFunction CTSubroutine CTExternal CTVariableCTArray CTParameter CTIntrinsicModEnvNameType NTSubprogram NTVariable NTIntrinsicLocalityLocalImported TransFuncM TransFuncBBNodeBBGrbbgrGr bbgrEntries bbgrExitsBB bbgrEmptybbgrMapbbgrMapMmarkAsImported isImported analysis0isNamedExpressionvarNamesrcName lvVarName lvSrcNamegenVarpuName puSrcName initAnalysis stripAnalysislhsExprsrhsExprsisLExprallVarsanalyseAllLhsVarsanalyseAllLhsVars1 allLhsVars blockRhsExprs blockVarUses blockVarDefs$fDataGr $fOutLocality$fBinaryLocality $fOutNameType$fBinaryNameType$fBinaryConstructType$fOutConstructType$fBinaryIDType $fOutIDType $fOutAnalysis$fFunctorAnalysis$fShowAnalysis$fGenericAnalysis$fDataAnalysis $fEqAnalysis $fOrdIDType $fEqIDType $fShowIDType $fDataIDType$fGenericIDType$fOrdConstructType$fEqConstructType$fShowConstructType$fDataConstructType$fGenericConstructType$fShowNameType $fEqNameType $fOrdNameType$fDataNameType$fGenericNameType$fShowLocality $fEqLocality $fOrdLocality$fDataLocality$fGenericLocality $fDataBBGr $fShowBBGr$fEqBBGr $fGenericBBGrFEvalValuePureunFEvalValuePureFEvalValuePureTMonadFEvalValue ENoSuchVarEKindLitBadTypeENoSuchKindForType EUnsupportedEOp EOpTypeErrorESpecialELazyrunEvalFValuePureevalVarevalExpr forceVarExprevalLiterrevalKpevalMKp evalRealKpevalUOpwrapOpwrapSOpevalBOpboolXor defFLogicalevalFunctionCallevalIntrinsicIntevalIntrinsicInt1evalIntrinsicInt2evalIntrinsicInt4evalIntrinsicInt8evalIntrinsicIntXCoerceevalArg forceScalarforceUnconsArg forceArgsevalIntrinsicIorevalIntrinsicMax evalConstExpr$fMonadFEvalFEvalValuePure$fFunctorFEvalValuePure$fApplicativeFEvalValuePure$fMonadFEvalValuePure$fMonadReaderMapFEvalValuePure$fMonadWriter[]FEvalValuePure$fMonadErrorErrorFEvalValuePure$fGenericError TypeErrorTypeEnv analyseTypesanalyseTypesWithEnvanalyseAndCheckTypesWithEnvextractTypeEnv inferState0runInferderiveSemTypeFromDeclarationderiveSemTypeFromTypeSpecderiveSemTypeFromBaseType$fEqInferConfig$fShowInferConfig$fShowInferState ModuleMapanalyseRenamesanalyseRenamesWithModuleMaprenameunrename$fShowRenameState$fEqRenameState Transform runTransformgetProgramFileputProgramFilemodifyProgramFile groupForallgroupDogroupLabeledDodisambiguateIntrinsicdisambiguateFunction$fIndexedExpression$fIndexedArgument SuperBBGrsuperBBGrGraphsuperBBGrClusterssuperBBGrEntries ASTExprNode ASTBlockNode BBlockMapanalyseBBlocks genBBlockMap genSuperBBGrfindLabeledBBlockshowBBGrshowAnalysedBBGr showSuperBBGr showBBlocks bbgrToDOTsuperBBGrToDOT showBlockCallMapDerivedInductionMap InductionExprIETopIELinearIEBottomInductionVarMapByASTBlockInductionVarMap LoopNodeMap BackEdgeMap ConstExpMapParameterVarMap VarFlowsMap FlowsGraphUDMapDUMapDefMapBlockMapOutFInFInOutMapOrderFIDomMapDomMapASTExprNodeSetASTExprNodeMapASTBlockNodeSetASTBlockNodeMap BBNodeSet BBNodeMap dominators iDominators postOrder revPostOrderpreOrder revPreOrderdataFlowSolver genBlockMap genDefMapliveVariableAnalysisreachingDefinitionsgenDUMap duMapToUdMapgenUDMapgenFlowsToGraphgenVarFlowsToMapgenConstExpMapanalyseConstExpsanalyseParameterVarsgenBackEdgeMap loopNodesgenLoopNodeMapsccWithgenInductionVarMapgenInductionVarMapByASTBlockgenDerivedInductionMap showDataFlow showFlowsDOT genCallMap$fNFDataInductionExpr$fNFDataIEFlow $fShowIEFlow $fEqIEFlow $fOrdIEFlow$fGenericIEFlow $fDataIEFlow$fShowInductionExpr$fEqInductionExpr$fOrdInductionExpr$fGenericInductionExpr$fDataInductionExprTimestampStatus NoSuchFile CompileFile ModFileExistsModFilesModFile ParamVarMap StringMapDeclMap DeclContextDCMain DCBlockDataDCModule DCFunction DCSubroutine modFileSuffix emptyModFiles emptyModFile regenModFile genModFilelookupModFileDatagetLabelsModFileDataalterModFileDataalterModFileDataF encodeModFile decodeModFiledecodeModFilesdecodeModFiles'combinedModuleMaplocalisedModuleMapcombinedTypeEnvcombinedDeclMapcombinedStringMapcombinedParamVarMapmoduleFilenamegenUniqNameToFilenameMapextractModuleMapextractDeclMapextractStringMapextractParamVarMapcheckTimestamps$fBinaryDeclContext$fBinaryModFile $fEqModFile $fShowModFile $fDataModFile$fGenericModFile$fOrdDeclContext$fEqDeclContext$fShowDeclContext$fDataDeclContext$fGenericDeclContext ParserMaker StateInitParseErrorSimpleerrorPos errorFilenameerrorMsgParser throwIOLeftbyVer byVerWithModsf66f77f77ef77lf90f95f2003f66NoTransformf77NoTransformf77eNoTransformf77lNoTransformf90NoTransformf95NoTransformf2003NoTransformf66StmtNoTransformf77StmtNoTransformf77eStmtNoTransformf77lStmtNoTransformf90StmtNoTransformf95StmtNoTransformf2003StmtNoTransform byVerStmtbyVerNoTransformf90ExprbyVerFromFilename transformAsdefaultTransformation makeParsermakeParserFixedmakeParserFreeinitParseStateFixedinitParseStateFreeinitParseStateFreeExprinitParseStateFixedExpr parseUnsafef66InlineIncludesf77lInlineIncludesf77eInlineIncludesf77InlineIncludesf90InlineIncludesf95InlineIncludesf2003InlineIncludesbyVerInlineIncludesf66IncludesNoTransformf77IncludesNoTransformf77eIncludesNoTransformf77lIncludesNoTransformf90IncludesNoTransformf95IncludesNoTransformf2003IncludesNoTransform byVerInclude collectTokenscollectTokensSafe$fShowParseErrorSimple$fExceptionParseErrorSimpleModGraph mgModNodeMapmgGraph mgNumNodes ModOriginMOFileMOFSMod genModGraph modGraphToDOTmodGraphToList takeNextMods delModNodes$fOrdModOrigin $fEqModGraph$fDataModGraph $fEqModOrigin$fDataModOrigin$fShowModOriginGHC.Num.IntegerIntegerbytestring-0.11.3.1Data.ByteString.Internal ByteStringGHC.IOFilePathfortran77intrinsics GHC.MaybeJustNothingGHC.ErrerrorFunctor Data.FoldableFoldableData.Traversable Traversableghc-prim GHC.TypesIntlengthGHC.NumNumMaybeHappyStkversiongetDataFileName getBinDir getLibDir getDynLibDir getDataDir getLibexecDir getSysconfDir text-1.2.5.0Data.Text.InternalTextbinary-0.8.9.0Data.Binary.ClassBinarysngltns-3.0.1-f0da67d4Data.SingletonsDemoteData.Binary.Get.InternalGetGHC.ShowShowcomputeAllLhsVarsstatementRhsExprs$inferConfigAcceptNonCharLengthAsKind StructTypeEnvrecordArrayDeclhandleDeclarationhandleStructurederiveRealLiteralKindInferbinopSimpleCombineSemTypes setSemType$deriveSemTypeFromBaseTypeAndSelectoruniquifyufoldM'gmapM'nmapM'fgl-5.8.2.0-ab9c749aData.Graph.Inductive.GraphNode bblockKill bblockGen blockKillblockGen mapToGraphbasicInductionVarsconvergeinsEdges isModFilerevertStringMapinitParseState