!w$g      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefg h i j k l m n o p q r s tuvwxy z{ | } ~         !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~          !"#$%&'()*+,-./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#RSTUVW$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 }1 ~2 2 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 5 6 7 8 8 8 8 8 8 8 8 8 8 8 8 8 9 9 " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " : : : : : : : : ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; < < < < < < < < < < < < < < < < < < < < < < < < = = > ? ? ? ? ? ? @ @ @ @ @ @ @ @ @ !@ "@ #@ $@ %@ &@ '@ (@ )@ *@ +@ ,@ -@ .@ /@ 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@ {@ |@ }@ ~@ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A B B B B B B B B B B B B B B B B B B B B B B B B B B B B B B B B B B B B B B B B C C C C C C C C C C C C C C C C C C C C C C C C C C C C !C "C #C $C %C &C 'C (C )C *C +C ,C -C .C /C 0C 1C 2C 3C 4C 5C 6C 7C 8C 9C :C ;C <C =C >C ?C @C AC BC CC DC EC FC GC HC IC JC KC LD MD ND OD PD QD RD SD TD UD VD WD XD YD ZD [D \D ]D ^D _D `D aD bD cD dD eD fD gE hE iE jE kE lE mE nE oE pE qE rE sE tE uE vE wE xF yF zF {F |F }F ~F F F F F F F F F F F F F F F G G H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H I I I I I I I I G G G J J J J J J J J J J J J J J J J J J J J J J J J J J J J !J "J #J $J %J &J 'J (J )J *J +J ,J -J .J /J 0J 1J 2J 3J 4J 5J 6J 7J 8J 9J :J ;J <J =J >J ?J @J AJ BJ CJ DJ EJ FJ GJ HJ IJ JJ KJ LJ MJ NJ OJ PJ QJ RJ SJ TJ UJ VJ WJ XJ YJ ZJ [J \J ]J ^J _J `J aJ bJ cJ dJ eJ fJ gJ hJ iJ jJ kJ lJ mJ nJ oJ pJ qJ rJ sJ tJ uJ vK wK xK yK zK {K |K }K ~K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K L L L L L L M # # # # # # # N O O O O O O O O O O O O P Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q R R R R R R R R S S S S S S S S T U U U U U U U U U U U U U U U U U U U U U U U U U V V V V V V W W W W W W W W X X X X X X X X Y Y Y Y !Y "Y #Y $Y %Y &Y 'Y (Y )Y *Y +Y ,Y -Y .Y /Y 0Y 1Y 2Y 3Y 4Y 5Y 6Y 7Y 8Y 9Y :Y ;Y <Y =Y >Y ?Y @Y AY BY CY DY EZ 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` fa ga ha ia ja kb lb mb nb ob pc qc rd sd td ue vf wf xf yf zf {f |f }f ~f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g gggggggggg g g g g ggggggggghhhhhhhhhh h!h"h#h$h%h&h'h(h)h*h+h,h-h.h/h0h1h2h3h4h5h6h7h8h9h:h;h<h=h>h?h@hAhBhChDhEhFhGhHhIhJhKhLhMhNhOhPhQhRhShTiUiViWiXiYiZi[i\i]i^j_j`jajbjcjdjekfkgkhkikjkkklkmknkokpkqkrksktkukvkwkxkykzk{k|k}k~kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk k k k k kkkkkkkkkkkkkkkkkkk k!k"k#k$k%k&k'k(k)k*k+k,k-k.k/k0k1k2k3k4k5k6k7k8k9k:k;k<k=k>k?k@kAkBkClDlElFlGlHlIlJlKlLlMlNlOlPlQlRlSlTlUlVmWmXmYmZm[m\m]m^m_m`mambmcmdmemfmgmhmimjmkmlmmmnmompmqmrmsmtmumvmwmxmymzm{m|m}m~mmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmnnnnnnnnnnnnnooooooooooopppppppppppppppppppppppqqqqqqqqqqqqqqqqqqqqqqqqrrrrrrrrrrrrrrrrssssssssss s s s s sssssssssssssssssss s!s"s#s$s%s&s's(s)s*s+s,s-s.t/t0t1t2t3t4t5t6u7u8u9u:u;u<u=u>u?u@uAuBuCuDuEuFuGuHuIuJuKuLuMuNuOuPuQuRuSuTuUuVuWuXuYuZu[u\u]u^u_u`uaubucudueufuguhuiujukulumunuoupuqurusutuuuvuwuxuyuzu{u|u}u~uuuuuuuuuuuuuvvvvvvvvvvvvvwwwwwxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxyyyyzzzzz{||||||}~~~~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~!!!!!!!      !"#$%& ' ( ) * + , - ./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEF GHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~            !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~     cc !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                         !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmn o p q r s t u v w x y z { | } ~      !"#$%&'()*+,-./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"0"0"0"0"0"0"0"0"0"0"0"0"0"0"1"1"1"1"1"2"2"3"3"3"4"4"4"4"4"4"4"4"5"5"5"5"5"5"5"5"6"6"6"6"6"6"6"6"7"7"7"7"7"7"7"7"7"7"8"9":":":":":":":":":":":":":":":":":":":":":":":":":":":":":":":":":":":":":":":":#:#:#:#:#:#:#:#:#:# :# :# :# :# :#:#:#:#:#:#:#:#:#:#:#:#:#:#:#:#:#:#:# :#!:#":##:#$:#%:#&:#':#(:#):#*:#+:#,:#-:#.;#/;#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$aA$bA$cB$dB$eB$fBD$NoneM> [ghc-lib File name.\ghc-libFile modification time.]ghc-lib File owner.^ghc-lib File group._ghc-lib File mode.`ghc-lib File size.aghc-lib File bytes.$gghc-lib)Archives have numeric values padded with '\x20' to the right.$hghc-libGNU Archives feature a special //D entry that contains the extended names. Those are referred to as / num$, where num is the offset into the //4 entry. In addition, filenames are terminated with $i in the archive.$jghc-libput an Archive Entry. This assumes that the entries have been preprocessed to account for the extenden file name table section "//" e.g. for GNU Archives. Or that the names have been move into the payload for BSD Archives.$kghc-lib@Take a filePath and return (mod time, own, grp, mode in decimal)$kghc-lib%mod time, own, grp, mode (in decimal)WXYZ[\]^_`abcdefghiYZ[\]^_`aWXbehifgcd%Nonepghc-libGenerate a section type (e.g.  @progbits). See #13937.pghc-lib section typeghc-libpretty assembler fragmentpp&None$lghc-libGiven a binding of in_id to in_rhs , and a fresh name to refer to in_id (out_id>, created from addBinder or addRecBinders), first try to CSE in_rhs>, and then add the resulting (possibly CSE'd) binding to the $m@, so that we attempt to CSE any expressions which are equal to out_rhs.$nghc-libbGiven a binder `let x = e`, this function determines whether we should add `e -> x` to the cs_maprghc-lib Runs CSE on a single expression.{This entry point is not used in the compiler itself, but is provided as a convenient entry point for users of the GHC API.$oghc-libAdd clones to the substitution to deal with shadowing. See Note [Shadowing] for more details. You should call this whenever you go under a binder.qrqr'None sghc-lib$The operation to perform atomically.ghc-libeMachine-level primops; ones which we can reasonably delegate to the native code generators to handle.)Most operations are parameterised by the $pr that they operate on. Some operations have separate signed and unsigned versions, and float and integer versions. "ghc-libReturns $qe if the MachOp has commutable arguments. This is used in the platform-independent Cmm optimisations.If in doubt, return $rM. This generates worse code on the native routes, but is otherwise harmless. #ghc-libReturns $q$ if the MachOp is associative (i.e. (x+y)+z == x+(y+z)=) This is used in the platform-independent Cmm optimisations.If in doubt, return $rM. This generates worse code on the native routes, but is otherwise harmless. $ghc-libReturns $q if the MachOp is a comparison.fIf in doubt, return False. This generates worse code on the native routes, but is otherwise harmless. %ghc-libReturns Just w6 if the operation is an integer comparison with width w, or Nothing otherwise. (ghc-lib.Returns the MachRep of the result of a MachOp. )ghc-libThis function is used for debugging only: we can check whether an application of a MachOp is "type-correct" by checking that the MachReps of its arguments are the same as the MachOp expects. This is used when linting a CmmExpr. ,ghc-libThe alignment of a memcpy-ish operation.stuvwxyz{|}~                           ! " # $ % & ' ( ) * + , " # $ % ( ) ' &                       !    z{|}~ + * ,stuvwxy(None 3 4 5 6 7 8 9 : ; < = > = > ; < 3 4 5 6 7 8 9 :)None8 ? @ A B ? @ A B*None%>HVX7 $sghc-libcvtOpApp x op y converts op and y' and produces the operator application x op yG. The produced tree of infix expressions will be left-biased, provided x is.We can see that cvtOpApp9 is correct as follows. The inductive hypothesis is that cvtOpApp x op y is left-biased, provided x7 is. It is clear that this holds for both branches (of cvtOpApp:), provided we assume it holds for the recursive calls to cvtOpApp. When we call cvtOpApp from cvtlJ, the first argument will always be left-biased since we have already run cvtl on it.$tghc-libcvtOpAppP x op y converts op and y' and produces the operator application x op yD. The produced tree of infix patterns will be left-biased, provided x is.See the cvtOpApp+ documentation for how this function works.$ughc-libBConstructs an application of a type to arguments passed in a list.$vghc-lib5Constructs an arrow type with a specified return type$wghc-libcvtOpAppT x op y converts op and y' and produces the operator application x op yB. The produced tree of infix types will be right-biased, provided y is.See the cvtOpApp+ documentation for how this function works.$xghc-libConvert Maybe Kind to a type family result signature. Used with data families where naming of the result is not possible (thus only kind or no signature is possible).$yghc-libTConvert type family result signature. Used with both open and closed type families.$zghc-lib0Convert injectivity annotation of a type family.${ghc-libIf passed an empty list of $|/s, this simply returns the third argument (an $}). Otherwise, return an $~ using the provided $ and $}.$ghc-libIf passed an empty $., this simply returns the third argument (an $}). Otherwise, return an $ using the provided $ and $}.${ghc-lib3The original Template Haskell type variable bindersghc-libThe location of the returned $}" if it needs an explicit forallghc-libWhether this is forall is visible (e.g.,  forall a ->) or invisible (e.g.,  forall a.)ghc-lib#The converted type variable bindersghc-libThe converted rho typeghc-lib8The complete type, quantified with a forall if necessary$ghc-lib%The original Template Haskell contextghc-libThe location of the returned $}# if it needs an explicit contextghc-libThe converted contextghc-libThe converted tau typeghc-lib8The complete type, qualified with a context if necessary H I J K L I J H K L+NoneJ&$ghc-libAllow  makeStatic to occur anywhere.$ghc-libAllow  makeStatic calls at the top-level only.$ghc-lib Reject any  makeStatic occurrence.$ghc-libSee Note [Checking StaticPtrs]$ghc-lib,See Note [Linting type synonym applications]$ghc-lib1Checks the RHS of bindings. It only differs from $8 in that it doesn't reject occurrences of the function  makeStatic( when they appear at the top level and 'lf_check_static_ptrs == AllowAtTopLevelZ, and for join points, it skips the outer lambdas that take arguments to the join point.See Note [Checking StaticPtrs]. Zghc-libGThis checks whether a pass correctly looks through debug annotations ( SourceNote). This works a bit different from other consistency checks: We check this by running the given task twice, noting all differences between the results.$ghc-libRun the given pass without annotations. This means that we both set the debugLevel setting to 0 in the environment as well as all annotations from incoming modules.$ghc-lib>What sort of casted thing this is ("expression" or "type").ghc-lib:What sort of coercion is being used ("type" or "kind").ghc-libThe thing being casted. P Q R S T U V W X Y Z V W T U X Z Y P Q S R,Nonen$ghc-lib A section$ghc-libName of the section$ghc-libContent of the section$ghc-lib Description of the section table$ghc-lib'offset of the table describing sections$ghc-lib%size of an entry in the section table$ghc-libnumber of sections$ghc-lib<index of a special section which contains section's names$ghc-lib ELF headerThe ELF header indicates the native word size (32-bit or 64-bit) and the endianness of the target machine. We directly store getters for words of different sizes as it is more convenient to use. We also store the word size as it is useful to skip some uninteresting fields.Other information such as the target machine and OS are left out as we don't use them yet. We could add them in the future if we ever need them.$ghc-lib(Get a Word16 with the correct endianness$ghc-lib(Get a Word32 with the correct endianness$ghc-lib7Get a Word with the correct word size and endianness$ghc-libWord size in bytes$ghc-libRead the ELF header$ghc-libRead the ELF section table$ghc-libRead a ELF section$ghc-lib:Find a section from its name. Return the section contents.0We do not perform any check on the section type. aghc-lib8Given a section name, read its contents as a ByteString.OIf the section isn't found or if there is any parsing error, we return Nothing$ghc-libread a Note as a ByteStringIf you try to read a note from a section which does not support the Note format, the parsing is likely to fail and Nothing will be returned bghc-libread a Note as a StringIf you try to read a note from a section which does not support the Note format, the parsing is likely to fail and Nothing will be returned cghc-lib.Generate the GAS code to create a Note sectionGHeader fields for notes are 32-bit long (see Note [ELF specification]).It seems there is no easy way to force GNU AS to generate a 32-bit word in every case. Hence we use .int directive to create them: however "The byte order and bit size of the number depends on what kind of target the assembly is for." (https:/sourceware.orgbinutilsdocsas/Int.html#Int)If we add new target platforms, we need to check that the generated words are 32-bit long, otherwise we need to use platform specific directives to force 32-bit .int in asWord32.$ghc-lib8runGet in IO monad that throws an IOException on failure a b c a b c-None%>HV_^ dghc-lib!Extract docs from renamer output.$ghc-libCreate decl and arg doc-maps by looping through the declarations. For each declaration, find its names, its subordinates, and its doc strings.$ghc-libGet all subordinate declarations inside a declaration, and their docs. A subordinate declaration is something like the associate type or data family of a type class.$ghc-lib@Extract constructor argument docs from inside constructor decls.$ghc-lib|All the sub declarations of a class (that we handle), ordered by source location, with documentation attached if it exists.$ghc-lib;Extract function argument docs from inside top-level decls.$ghc-lib1Extract function argument docs from inside types.$ghc-libThe top-level declarations of a module that we care about, ordered by source location, with documentation attached if it exists.$ghc-libATake all declarations except pragmas, infix decls, rules from an $.$ghc-libSort by source location$ghc-lib7Collect docs and attach them to the right declarations.;A declaration may have multiple doc strings attached to it.This is an example.$ghc-lib7Filter out declarations that we don't handle in Haddock$ghc-libCGo through all class declarations and filter their sub-declarations$ghc-lib%Was this signature given by the user?$ghc-libbTake a field of declarations from a data structure and create HsDecls using the given constructor dghc-lib  Module headerDocs on top level declarationsDocs on arguments d dNoneX fghc-lib+Locate a module that was imported by the user. We have the module's name, and possibly a package name. Without a package name, this function will use the search path and the known exposed packages to find the module, if a package is specified then only that package is searched for the module. gghc-libzLocate a plugin module requested by the user, for a compiler plugin. This consults the same set of exposed packages as  f , unless -hide-all-plugin-packages or -plugin-package are specified. hghc-libLocate a specific 0. The purpose of this function is to create a  for a given , that is to find out where the files associated with this module live. It is used when reading the interface for a module mentioned by another interface, for example (a "system import").$ghc-libGiven a monadic actions this and or_this, first execute this. If the returned / is successful, return it; otherwise, execute or_this[. If both failed, this function also combines their failure messages in a reasonable way.$ghc-libHelper function for  l8: this function wraps an IO action which would look up mod_name@ in the file system (the home package), and first consults the $ cache to see if the lookup has already been done. Otherwise, do the lookup (with the IO action) and save the result in the finder cache and the module location cache (if it was successful.)$ghc-libImplements the search for a module name in the home package only. Calling this function directly is usually *not* what you want; currently, it's used as a building block for the following operations: When you do a normal package lookup, we first check if the module is available in the home module, before looking it up in the package database.dWhen you have a package qualified import with package name "this", we shortcut to the home module.When we look up an exact i, if the unit id associated with the module is the current home module do a look up in the home module.PSome special-case code in GHCi (ToDo: Figure out why that needs to call this.)$ghc-lib.Search for a module in external packages only.$ghc-lib2Look up the interface file associated with module modB. This function requires a few invariants to be upheld: (1) the  in question must be the module identifier of the *original* implementation of a module, not a reexport (this invariant is upheld by  Packages.hs) and (2) the $, must be consistent with the unit id in the _. The redundancy is to avoid an extra lookup in the package state for the appropriate config. pghc-libDConstructs the filename of a .o file for a given source file. Does not! check whether the .o file exists qghc-libEConstructs the filename of a .hi file for a given source file. Does not" check whether the .hi file exists$ghc-libFConstructs the filename of a .hie file for a given source file. Does not# check whether the .hie file exists e f g h i j k l m n o p q r s t u v e f g h l i m n o q p j k r s t u v.None%P wghc-lib~Extract information from the rename and typecheck phases to produce a dependencies information for the module being compiled.:The first argument is additional dependencies from plugins w x y y x w/None$ghc-lib7True if it's a bad idea to float bindings into this RHS z z0Safe. {ghc-liboHandle GHC-specific character encoding flags, allowing us to control how GHC produces output regardless of OS.$ghc-lib~Change the character encoding of the given Handle to transliterate on unsupported characters instead of throwing an exception { {1None>F |ghc-libAn efficient serialiser of $. }ghc-libAn efficient deserialiser of $. | } | }2NoneFX8 ~ ~3NoneFq ghc-libRetain CAFs unconditionally in linked Haskell code. Note that this prevents any code from being unloaded. It should not be necessary unless you are GHCi or hs-plugins, which needs to be able call any function in the compiled code. ghc-libDo not retain CAFs. Everything reachable from foreign exports will be retained, due to the StablePtrs created by the module initialisation code. unloadObj frees these StablePtrs, which will allow the CAFs to be GC'd and the code to be removed. ghc-lib8loadDLL loads a dynamic library using the OS's native linker (i.e. dlopen() on Unix, LoadLibrary() on Windows). It takes either an absolute pathname to the file, or a relative filename (e.g. "libfoo.so" or "foo.dll"). In the latter case, loadDLL searches the standard locations for the appropriate library. ghc-lib unloadObj drops the given dynamic library from the symbol table as well as enables the library to be removed from memory during a future major GC. ghc-libpurgeObjJ drops the symbols for the dynamic library from the symbol table. Unlike  C, the library will not be dropped memory during a future major GC.  4None"#7M8 ghc-lib+reference to the Nth BCO in the current set ghc-lib%reference to a previously created BCO ghc-libreference to a static ptr ghc-lib a nested BCO ghc-lib3Resolves to the MutableArray# inside the BreakArray ghc-libA   is one in which all the Name7 references have been resolved to actual addresses or  RemoteHValues.RNote, all arrays are zero-indexed (we assume this when serializing/deserializing) ghc-lib%The Binary instance for ResolvedBCOs.Note, that we do encode the endianness, however there is no support for mixed endianness setups. This is primarily to ensure that ghc and iserv share the same endianness.  5None "#=?@AF.  6Safe  ghc-libInstall standard signal handlers for catching ^C, which just throw an exception in the target thread. The current target thread is the thread at the head of the list in the MVar passed to installSignalHandlers.  7NoneP ghc-libCUsed by GHCi to add an SPT entry for a set of interactive bindings.  8None "#/17PX ghc-lib1The exception thrown by "fail" in the GHCiQ monad$ghc-lib7The monad in which we run TH computations on the server$ghc-libCreate a new instance of $$ghc-libSend a $ to GHC and return the result. ghc-libThe implementation of the "C message: create a new IORef QState, and return a RemoteRef to it. ghc-libRuns the mod finalizers.5The references must be created on the caller process. ghc-libThe implementation of the ! message$ghc-libRun a Q computation. ghc-libThe TH state, created by  ghc-libThe splice to runghc-libWhat kind of splice it isghc-libThe source locationghc-lib<Returns an (encoded) result that depends on the THResultType  9None "#&'FXH  "None"#X I ghc-lib3Run a command in the interpreter's context. With -fexternal-interpreterq, the command is serialized and sent to an external iserv process, and the response is deserialized (hence the Binary constraint). With -fno-external-interpreter' we execute the command directly here. ghc-libGrab a lock on the $S and do something with it. Overloaded because this is used from TcM as well as IO. ghc-libExecute an action of type IO [a] , returning Vs for each of the results. ghc-libExecute an action of type IO () ghc-libExecute an action of type  IO String ghc-libExecute an action of type String -> IO String ghc-libgAllocate and store the given bytes in memory, returning a pointer to the memory in the remote process. ghc-lib4Create a set of BCOs that may be mutually recursive. ghc-lib8loadDLL loads a dynamic library using the OS's native linker (i.e. dlopen() on Unix, LoadLibrary() on Windows). It takes either an absolute pathname to the file, or a relative filename (e.g. "libfoo.so" or "foo.dll"). In the latter case, loadDLL searches the standard locations for the appropriate library.Returns:0Nothing => success Just err_msg => failure ghc-libSend a D0 and receive the response from the iserv process ghc-lib#Read a value from the iserv process ghc-lib!Send a value to the iserv process ghc-lib Creates a $& that will automatically release the $! when it is no longer referenced. ghc-lib Convert a $ to the value it references directly. This only works when the interpreter is running in the same process as the compiler, so it fails when -fexternal-interpreter is on. ghc-lib Convert an $ to the value it references directly. This only works when the interpreter is running in the same process as the compiler, so it fails when -fexternal-interpreter is on.ZDCBA@?>=<;:9876543210/.-,+*)('&%$#"! GFEHKJINML Z KJIHNMLGFE DCBA@?>=<;:9876543210/.-,+*)('&%$#"!  :None=?@AF  ;None)I ghc-libGraph nodes. Represents a thing that can conflict with another thing. For the register allocater the nodes represent registers. ghc-lib"A unique identifier for this node. ghc-libLThe class of this node, determines the set of colors that can be used. ghc-libThe color of this node, if any. ghc-lib9Neighbors which must be colored differently to this node. ghc-lib(Colors that cannot be used by this node. ghc-lib=Colors that this node would prefer to be, in decending order. ghc-lib>Neighbors that this node would like to be colored the same as. ghc-libThe Interference graph. There used to be more fields, but they were turfed out in a previous revision. maybe we'll want more later.. ghc-libAll active nodes in the graph. ghc-libA fn to check if a node is trivially colorable For graphs who's color classes are disjoint then a node is 'trivially colorable' when it has less neighbors and exclusions than available colors for that node.hFor graph's who's color classes overlap, ie some colors alias other colors, then this can be a bit more tricky. There is a general way to calculate this, but it's likely be too slow for use in the code. The coloring algorithm takes a canned function which can be optimised by the user to be specific to the specific graph being colored.for details, see "A Generalised Algorithm for Graph-Coloring Register Allocation" Smith, Ramsey, Holloway - PLDI 2004. ghc-libAn empty graph. ghc-lib5Modify the finite map holding the nodes in the graph. ghc-libAn empty node.  <Nonef ghc-libLookup a node from the graph. ghc-lib>Get a node from the graph, throwing an error if it's not there ghc-lib-Add a node to the graph, linking up its edges ghc-lib/Delete a node and all its edges from the graph. ghc-libLModify a node in the graph. returns Nothing if the node isn't present. ghc-libGet the size of the graph, O(n) ghc-libUnion two graphs together. ghc-libAdd a conflict between nodes to the graph, creating the nodes required. Conflicts are virtual regs which need to be colored differently. ghc-libUDelete a conflict edge. k1 -> k2 returns Nothing if the node isn't in the graph ghc-libAdd some conflicts to the graph, creating nodes if required. All the nodes in the set are taken to conflict with each other. ghc-libqAdd an exclusion to the graph, creating nodes if required. These are extra colors that the node cannot use. ghc-libAdd a coalescence edge to the graph, creating nodes if requried. It is considered adventageous to assign the same color to nodes in a coalesence. ghc-lib4Delete a coalescence edge (k1 -> k2) from the graph. ghc-libAdd a color preference to the graph, creating nodes if required. The most recently added preference is the most prefered. The algorithm tries to assign a node it's prefered color if possible. ghc-libDo aggressive coalescing on this graph. returns the new graph and the list of pairs of nodes that got coalesced together. for each pair, the resulting node will have the least key and be second in the pair. ghc-libsCoalesce this pair of nodes unconditionally / aggressively. The resulting node is the one with the least key.returns: Just the pair of keys if the nodes were coalesced the second element of the pair being the least one3Nothing if either of the nodes weren't in the graph ghc-libFreeze a node This is for the iterative coalescer. By freezing a node we give up on ever coalescing it. Move all its coalesce edges into the frozen set - and update back edges from other nodes. ghc-libFreeze one node in the graph This if for the iterative coalescer. Look for a move related node of low degree and freeze it.4We probably don't need to scan the whole graph looking for the node of absolute lowest degree. Just sample the first few and choose the one with the lowest degree out of those. Also, we don't make any distinction between conflicts of different classes.. this is just a heuristic, after all.IDEA: freezing a node might free it up for Simplify.. would be good to check for triv right here, and add it to a worklist if known triv/non-move nodes. ghc-libNFreeze all the nodes in the graph for debugging the iterative allocator. ghc-lib7Find all the nodes in the graph that meet some criteria ghc-libvalidate the internal structure of a graph all its edges should point to valid nodes If they don't then throw an error$ghc-libeIf this node is colored, check that all the nodes which conflict with it have different colors. ghc-libMSlurp out a map of how many nodes had a certain number of conflict neighbours ghc-libSet the color of a certain node ghc-libfIf True, coalesce nodes even if this might make the graph less colorable (aggressive coalescing) ghc-libfIf True, coalesce nodes even if this might make the graph less colorable (aggressive coalescing)ghc-lib!keys of the nodes to be coalesced ghc-libkey of the node to freezeghc-lib the graphghc-libgraph with that node frozen ghc-lib(extra debugging info to display on errorghc-lib-whether this graph is supposed to be colored.ghc-libgraph to validateghc-libvalidated graph$ghc-libTrue if this node is ok ghc-lib9(conflict neighbours, num nodes with that many conflicts)                   =NonepD ghc-lib9Pretty print a graph in a somewhat human readable format. ghc-libsPretty print a graph in graphviz .dot format. Conflicts get solid edges. Coalescences get dashed edges.$ghc-libNodes in the graph are doubly linked, but we only want one edge for each conflict if the graphviz graph. Traverse over the graph, but make sure to only print the edges for each node once. ghc-libWhat graphviz color to use for each node color It's usually safe to return X11 style colors here, ie "red", "green" etc or a hex triplet #aaff55 etc    >Nonem ghc-libTry to color a graph with this set of colors. Uses Chaitin's algorithm to color the graph. The graph is scanned for nodes which are deamed 'trivially colorable'. These nodes are pushed onto a stack and removed from the graph. Once this process is complete the graph can be colored by removing nodes from the stack (ie in reverse order) and assigning them colors different to their neighbors.$ghc-libuScan through the conflict graph separating out trivially colorable and potentially uncolorable (problem) nodes.Checking whether a node is trivially colorable or not is a reasonably expensive operation, so after a triv node is found and removed from the graph it's no good to return to the starte of the graph and recheck a bunch of nodes that will probably still be non-trivially colorable.@To ward against this, during each pass through the graph we collect up a list of triv nodes that were found, and only remove them once we've finished the pass. The more nodes we can delete at once the more likely it is that nodes we've already checked will become trivially colorable for the next pass.TODO: add work lists to finding triv nodes is easier. If we've just scanned the graph, and removed triv nodes, then the only nodes that we need to rescan are the ones we've removed edges from.$ghc-lib)Try to assign a color to all these nodes.$ghc-libSelect a color for a certain node taking into account preferences, neighbors and exclusions. returns Nothing if no color can be assigned to this node. ghc-lib"whether to do iterative coalescingghc-lib6how many times we've tried to color this graph so far.ghc-lib>map of (node class -> set of colors available for this class).ghc-lib3fn to decide whether a node is trivially colorable.ghc-libUfn to choose a node to potentially leave uncolored if nothing is trivially colorable.ghc-libthe graph to color.$ghc-lib"whether to do iterative coalescingghc-lib2fn to decide whether a node is trivially colorableghc-libUfn to choose a node to potentially leave uncolored if nothing is trivially colorable.ghc-libthe graph to scan$ghc-lib>map of (node class -> set of colors available for this class).ghc-lib the graphghc-libnodes to assign a color to.$ghc-lib>map of (node class -> set of colors available for this class).ghc-lib the graphghc-lib&key of the node to select a color for.+             ?None%HV ghc-lib#Parse the imports of a source file. Throws a $ if parsing fails. ghc-lib6Parse OPTIONS and LANGUAGE pragmas of the source file. Throws a $5 if flag parsing fails (including unsupported flags.) ghc-lib6Parse OPTIONS and LANGUAGE pragmas of the source file. Throws a $5 if flag parsing fails (including unsupported flags.) ghc-lib4Complain about non-dynamic flags in OPTIONS pragmas. Throws a $K if the input list is non-empty claiming that the input flags are unknown. ghc-lib Parse this.ghc-libLFilename the buffer came from. Used for reporting parse error locations.ghc-libKThe original source filename (used for locations in the function result)ghc-lib8The source imports, normal imports, and the module name. ghc-lib Input fileghc-libParsed options, if any. ghc-lib Input Bufferghc-lib)Source filename. Used for location info.ghc-libParsed options.            @None2456=?Xy& ghc-libScope of a type variable.%This warrants a data type apart from  6 because of complexities introduced by features like -XScopedTypeVariables and -XInstanceSigs. For example, consider: "foo, bar, baz :: forall a. a -> a Here a' is in scope in all the definitions of foo, bar, and baz, so we need a list of scopes to keep track of this. Furthermore, this list cannot be computed until we resolve the binding sites of foo, bar, and baz.Consequently, a starts with an   [foo, bar, baz] Nothing# which later gets resolved into a  . ghc-lib4Unresolved scopes should never show up in the final .hie file ghc-libtype or data family !ghc-lib type synonym "ghc-libdata declaration #ghc-libconstructor declaration $ghc-libpattern synonym %ghc-libclass declaration &ghc-libinstance declaration /ghc-libTypes of imports and exports 4ghc-lib0Different contexts under which identifiers exist 5ghc-libregular variable 7ghc-lib import/export 9ghc-lib Value binding :ghc-libPattern binding{This case is tricky because the bound identifier can be used in two distinct scopes. Consider the following example (with -XViewPatterns) 'do (b, a, (a -> True)) <- bar foo a The identifier a% has two scopes: in the view pattern  (a -> True) and in the rest of the do -block in foo a. <ghc-lib Declaration =ghc-lib Type variable >ghc-lib Record field ?ghc-lib,Information associated with every identifierWe need to include types with identifiers because sometimes multiple identifiers occur in the same span(Overloaded Record Fields and so on) Eghc-lib'The information stored in one AST node.The type parameter exists to provide flexibility in representation of types (see Note [Efficient serialization of redundant type info]). Gghc-lib=(name of the AST node constructor, name of the AST node Type) Hghc-lib'The Haskell types of this node, if any. Ighc-lib%All the identifiers and their details Oghc-lib*Mapping from filepaths (represented using $) to the corresponding AST Rghc-libnA list of type arguments along with their respective visibilities (ie. is this an argument that would return $q for isVisibleArgFlag?). Tghc-lib(Roughly isomorphic to the original core Type. Wghc-libA flattened version of Type.9See Note [Efficient serialization of redundant type info] ]ghc-libtype with constraint: t1 => t2 (see  IfaceDFunTy) bghc-libNGHC builds up a wealth of information about Haskell source as it compiles it. .hie files are a way of persisting some of this information to disk so that external tools that need to work with haskell source don't need to parse, typecheck, and rename all over again. These files contain:a simplified AST3nodes are annotated with source positions and types0identifiers are annotated with scope information+the raw bytes of the initial Haskell source#Besides saving compilation cycles, .hie; files also offer a more stable interface than the GHC API. dghc-libversion of the HIE format eghc-lib&Version of GHC that produced this file fghc-lib Initial Haskell source file path gghc-libThe module this HIE file is for hghc-libTypes referenced in the  i.9See Note [Efficient serialization of redundant type info] ighc-lib$Type-annotated abstract syntax trees jghc-lib"The names that this module exports kghc-lib'Raw bytes of the initial Haskell source mghc-libCurrent version of .hie files ghc-lib3names of the definitions over which the scope spansghc-lib|the location of the instance/class declaration for the case where the type variable is declared in a method type signature 9ghc-lib,whether or not the binding is in an instanceghc-lib#scope over which the value is boundghc-libspan of entire binding :ghc-libscope in the pattern9 (the variable bound can be used further in the pattern)ghc-lib%rest of the scope outside the patternghc-libspan of entire binding <ghc-libtype of declarationghc-libspan of entire bindingV         & % $ # " ! ' ) ( * . - , + / 3 2 1 0 4 > = < ; : 9 8 7 6 5 ? @ B A C D E F I H G J K N M L O P Q R S T U V W ` _ ^ ] \ [ Z Y X a b c k j h g f e d i l mV l m b c k j h g f e d i a W ` _ ^ ] \ [ Z Y X V T U R S O P Q J K N M L E F I H G D C ? @ B A 4 > = < ; : 9 8 7 6 5 / 3 2 1 0 * . - , + ' ) (  & % $ # " !       ANone=?PXw ghc-lib>One must contain the other. Leaf nodes cannot contain anything ghc-lib/Insert an AST in a sorted list of disjoint Asts ghc-libMerge two nodes together.,Precondition and postcondition: elements in  H are ordered. ghc-libCMerge two sorted, disjoint lists of ASTs, combining when necessary.1In the absence of position-altering pragmas (ex: # line "file.hs" 3), different nodes in an AST tree should either have disjoint spans (in which case you can say for sure which one comes first) or one span should be completely contained in the other (in which case the contained span corresponds to some child node).>However, since Haskell does have position-altering pragmas it isT possible for spans to be overlapping. Here is an example of a source file in which foozball and quuuuuux have overlapping spans: ~module Baz where # line 3 "Baz.hs" foozball :: Int foozball = 0 # line 3 "Baz.hs" bar, quuuuuux :: Int bar = 1 quuuuuux = 2 8In these cases, we just do our best to produce sensible  J~'s. The blame should be laid at the feet of whoever wrote the line pragmas in the first place (usually the C preprocessor...). ghc-lib*combines and sorts ASTs using a merge sort ghc-libhelps fill in  G (with $)ghc-lib)return an empty list if this is unhelpful ghc-libhelps fill in  G (with $)ghc-lib)return an empty list if this is unhelpfulghc-libtype to associate with the node- - BSafe &'HSVX ghc-lib2A sequence of nodes. May be any of four shapes (OO, OC, CO, COC). Open at the entry means single entry, mutatis mutandis for exit. A closedclosed block is a basic/ block and can't be extended further. Clients should avoid manipulating blocks and should stick to either nodes or graphs.$ghc-lib!Maybe type indexed by closed/open ghc-lib!Maybe type indexed by open/closed ghc-lib6Either type indexed by closed/open using type families ghc-libUsed at the type level to indicate a "closed" structure which supports control transfer only through the use of named labels---no "fallthrough" is permitted. The number of control-flow edges is unconstrained. ghc-libuUsed at the type level to indicate an "open" structure with a unique, unnamed control-flow edge flowing in or out.  Fallthrough2 and concatenation are permitted at an open point. ghc-libLSplit a closed block into its entry node, open middle block, and exit node. ghc-lib#map a function over the nodes of a  ghc-lib A strict  ghc-libmap over a block, with different functions to apply to first nodes, middle nodes and last nodes respectively. The map is strict.$ghc-libFold a function over every node in a block, forward or backward. The fold function must be polymorphic in the shape of the nodes.&  &   CNone456HMV8:     #                   ! " $ % & ' ( * ) + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = >: ' ( * ) + , - . / 0 1 2 3 4 5 6 7 8 9 : ;   #                   ! " $ % & < = >  DNone456HMV~ L M N O P Q O M N L Q PENone &'=?HSVX6 gghc-libGraph' is abstracted over the block type, so that we can build graphs of annotated blocks for example (Compiler.Hoopl.Dataflow needs this). kghc-lib@A control-flow graph, which may take any of four shapes (O/O, OC, CO, C/C). A graph open at the entry has a single, distinguished, anonymous entry point; if a graph is closed at the entry, its entry point(s) are supplied by a context. lghc-libUGives access to the anchor points for nonlocal edges as well as the edges themselves$ghc-libBody abstracted over block oghc-lib5A (possibly empty) collection of closed/closed blocks sghc-libMaps over all nodes in a graph. tghc-lib Function  t enables a change of representation of blocks, nodes, or both. It lifts a polymorphic block transform into a polymorphic graph transform. When the block representation stabilizes, a similar function should be provided for blocks. vghc-libVReturns a list of blocks reachable from the provided Labels in the reverse postorder.(This is the most important traversal over this data structure. It drops unreachable code and puts blocks in an order that is good for solving forward dataflow problems quickly. The reverse order is good for solving backward dataflow problems quickly. The forward order is also reasonably good for emitting instructions, except that it will not usually exploit Forrest Baskett's trick of eliminating the unconditional branch from a loop. For that you would need a more serious analysis, probably based on dominators, to identify loop headers.FFor forward analyses we want reverse postorder visitation, consider: - A -> [B,C] B -> D C -> D  Postorder: [D, C, B, A] (or [D, B, C, A]) Reverse postorder: [A, B, C, D] (or [A, C, B, D]) This matters for, e.g., forward analysis, because we want to analyze *both* B and C before we analyze D. mghc-lib"The label of a first node or block nghc-libGives control-flow successors g h i j k l m n o p q r s t u v o k g h i j l m n r q p u s t vFNone&'^$ghc-libA FlatSwitchPlan is a list of SwitchPlans, with an integer inbetween every two entries, dividing the range. So if we have (abusing list syntax) [plan1,n,plan2], then we use plan1 if the expression is < n, and plan2 otherwise. xghc-libnA SwitchPlan abstractly describes how a Switch statement ought to be implemented. See Note [createSwitchPlan] }ghc-lib>A value of type SwitchTargets contains the alternatives for a  CmmSwitch value, and knows whether the value is signed, the possible range, an optional default value and a map from values to jump labels.$ghc-libtNumber of consecutive default values allowed in a jump table. If there are more of them, the jump tables are split.}Currently 7, as it costs 7 words of additional code when a jump table is split (at least on x64, determined experimentally).$ghc-libMinimum size of a jump table. If the number is smaller, the switch is implemented using conditionals. Currently 5, because an if-then-else tree of 4 values is nice and compact.$ghc-libGMinimum non-zero offset for a jump table. See Note [Jump Table Offset]. ~ghc-libThe smart constructor mkSwitchTargets normalises the map a bit: * No entries outside the range * No entries equal to the default * No default if all elements have explicit values ghc-lib7Changes all labels mentioned in the SwitchTargets value ghc-libCReturns the list of non-default branches of the SwitchTargets value ghc-lib3Return the default label of the SwitchTargets value ghc-lib+Return the range of the SwitchTargets value ghc-lib.Return whether this is used for a signed value ghc-libLswitchTargetsToTable creates a dense jump table, usable for code generation.`Also returns an offset to add to the value; the list is 0-based on the result of that addition.The conversion from Integer to Int is a bit of a wart, as the actual scrutinee might be an unsigned word, but it just works, due to wrap-around arithmetic (as verified by the CmmSwitchTest test case). ghc-lib;The list of all labels occuring in the SwitchTargets value. ghc-libxGroups cases with equal targets, suitable for pretty-printing to a c-like switch statement with fall-through semantics. ghc-lib#Custom equality helper, needed for CmmCommonBlockElim ghc-libNDoes the target support switch out of the box? Then leave this to the target! ghc-libThis function creates a SwitchPlan from a SwitchTargets value, breaking it down into smaller pieces suitable for code generation. x y z { | } ~   } ~  x y z { | HNone;$ghc-libWhat type of Cmm label we're dealing with. Determines the suffix appended to the name when a CLabel.CmmLabel is pretty printed.$ghc-lib'misc rts info tables, suffix _info$ghc-lib(misc rts entry points, suffix _entry$ghc-lib'misc rts ret info tables, suffix _info$ghc-lib&misc rts return points, suffix _ret$ghc-lib'misc rts data bits, eg CHARLIKE_closure$ghc-lib misc rts code$ghc-libclosures eg CHARLIKE_closure$ghc-lib)a prim call to some hand written Cmm code$ghc-libSelector thunks$ghc-lib AP thunks$ghc-lib_fast versions of generic apply$ghc-libLabel for closure$ghc-lib*Info tables for closures; always read-only$ghc-lib Entry point$ghc-libSlow entry point$ghc-lib)Like InfoTable but not externally visible$ghc-lib%Like Entry but not externally visible$ghc-lib4Label of place to keep Ticky-ticky info for this Id$ghc-libConstructor entry point$ghc-libCorresponding info table$ghc-lib!Table of closures for Enum tycons$ghc-lib5Content of a string literal. See Note [Bytes label].$ghc-libLike LocalInfoTable but for a proc-point block instead of a closure entry-point. See Note [Proc-point local block entry-point]. ghc-lib'Record where a foreign label is stored. ghc-libLabel is in a named package ghc-libLabel is in some external, system package that doesn't also contain compiled Haskell code, and is not associated with any .hi files. We don't have to worry about Haskell code being inlined from external packages. It is safe to treat the RTS package as "external". ghc-lib$Label is in the package currenly being compiled. This is only used for creating hacky tmp labels during code generation. Don't use it in any code that might be inlined across a package boundary (ie, core code) else the information will be wrong relative to the destination module. ghc-lib < is an abstract type that supports the following operations:Pretty printingIn a C file, does it need to be declared before use? (i.e. is it guaranteed to be already in scope in the places we need to refer to it?)WIf it needs to be declared, what type (code or data) should it be declared to have?.Is it visible outside this object file or not?#Is it "dynamic" (see details below)Eq and Ord, so that we can make sets of CLabels (currently only used in outputting C as far as I can tell, to avoid generating more than one declaration for any given label).3Converting an info table label into an entry label.XCLabel usage is a bit messy in GHC as they are used in a number of different contexts:!By the C-- AST to identify labels(By the unregisterised C code generator (PprC+) for naming functions (hence the name  )9By the native and LLVM code generators to identify labelsVFor extra fun, each of these uses a slightly different subset of constructors (e.g. $ and $/ are used only in the NCG and LLVM backends).In general, we use $ to represent Haskell things early in the pipeline. However, later optimization passes will often represent blocks they create with $ where there is no obvious  to hang off the label.$ghc-libJA label related to the definition of a particular Id or Con in a .hs file.$ghc-libDA label from a .cmm file that is not associated with a .hs level Id.$ghc-lib A label with a baked-in / algorithmically generated name that definitely comes from the RTS. The code for it must compile into libHSrts.a / libHSrts.so If it doesn't have an algorithmically generated name then use a CmmLabel instead and give it an appropriate UnitId argument.$ghc-libA label associated with a block. These aren't visible outside of the compilation unit in which they are defined. These are generally used to name blocks produced by Cmm-to-Cmm passes and the native code generator, where we don't have a 4 to associate the label to and therefore can't use $.$ghc-libA C (or otherwise foreign) label.$ghc-libLocal temporary label used for native (or LLVM) code generation; must not appear outside of these contexts. Use primarily for debug information$ghc-libA label "derived" from another  Y by the addition of a suffix. Must not occur outside of the NCG or LLVM code generators.$ghc-libThese labels are generated and used inside the NCG only. They are special variants of a label used for dynamic linking see module PositionIndependentCode for details.$ghc-libThis label is generated and used inside the NCG only. It is used as a base for PIC calculations on some platforms. It takes the form of a local numeric assembler label '1'o; and is pretty-printed as 1b, referring to the previous definition of 1: in the assembler source file.$ghc-libJA label before an info table to prevent excessive dead-stripping on darwin$ghc-lib"Per-module table of tick locations$ghc-libStatic reference table$ghc-lib"A bitmap (function or case return) ghc-libFor debugging problems with the CLabel representation. We can't make a Show instance for CLabel because lots of its components don't have instances. The regular Outputable instance only shows the label name, and not its other info. ghc-libMake a foreign label ghc-lib-Update the label size field in a ForeignLabel ghc-lib+Whether label is a top-level string literal ghc-lib8Whether label is a non-haskell label (defined in C code) ghc-libFWhether label is a static closure label (can come from haskell or cmm) ghc-lib Whether label is a .rodata label ghc-lib2Whether label is points to some kind of info table ghc-lib1Whether label is points to constructor info table ghc-lib,Get the label size field from a ForeignLabel ghc-libXConstruct a label for a DWARF Debug Information Entity (DIE) describing another symbol. ghc-lib7If a label is a local block label then return just its   , otherwise $. ghc-libCheck whether a label corresponds to a C function that has a prototype in a system header somehere, or is built-in to the C compiler. For these labels we avoid generating our own C prototypes. ghc-libIs a CLabel visible outside this object file or not? From the point of view of the code generator, a name is externally visible if it has to be declared as exported in the .o file's symbol table; that is, made non-static.$ghc-libqWork out the general type of data at the address of this label whether it be code, data, or static GC object. ghc-libIs a  . defined in the current module being compiled?Sometimes we can optimise references within a compilation unit in ways that we couldn't for inter-module references. This provides a conservative estimate of whether a   lives in the current module. ghc-libDoes a   need dynamic linkage?kWhen referring to data in code, we need to know whether that data resides in a DLL or not. [Win32 only.]  labelDynamic returns TrueB if the label is located in a DLL, be it a data reference or not.\ \ INone"#%HV\ $ghc-lib1Decide whether to add a tick to a binding or not.$ghc-lib A let body is treated differently from addTickLHsExprEvalInner above with TickForBreakPoints, because for breakpoints we always want to tick the body, even if it is not a redex. See test break012. This gives the user the opportunity to inspect the values of the let-bound variables.$ghc-libTickishs that only make sense when their source code location refers to the current file. This might not always be true due to LINE pragmas in the code - which would confuse at least HPC.$ghc-lib:Get the next HPC cost centre index for a given centre name  GNone=Z      JNone=>?@AZ %ghc-libSets of registers 'ghc-lib'Parameters: 1. Identifier 2. Type 1ghc-libA stack area is either the stack slot where a variable is spilled or the stack space where function arguments and results are passed.Y$$$%%%%%%%%%% % % % % %%%%%%%%%%%%%%%%%%% %!%"%#%$%%%&%'%(%)%*%+%,%-%.%/%0%1%2%3$p%4%5%6%7%8%9%:%;%<%=%>%?%@stuvwxyz{|}~                           ! " # $ % & ' ( ) * + ,                       ! " # $ % & ' ( / , ) * + - . 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 [ \ ] ^Z 7 ; : 8 9 < = > @ A 4 5 6 B C ( / , ) * + - . 0 ? & ' D                   ^ ] S T V U W X Y Z [ \ R     ! " Q P % $ # E G H I J L K M N F O 1 2 3KNoneFp9 v w x y z { | } ~  9 v w x y z { | } ~  LNoneSX %Aghc-lib The type constructor for queries ghc-libShow a GHC syntax tree. This parameterised because it is also used for comparing ASTs in ppr roundtripping tests, where the SrcSpan's are blanked out, to avoid comparing locations, only structure%Bghc-lib.Extend a generic query by a type-specific case%Cghc-lib/Type extension of queries for type constructors%Dghc-lib/Type extension of queries for type constructors%Eghc-libFlexible type extension%Fghc-libFlexible type extension  MNone%>HV ghc-libSource Statistics  #*Quasi-quoting support for Template HaskellSafeSX ghc-libThe   type, a value q) of this type can be used in the syntax [q| ... string to parse ...|] . In fact, for convenience, a   actually defines multiple quasiquoters to be used in different splice contexts; if you are only interested in defining a quasiquoter to be used for expressions, you would define a   with only  6, and leave the other fields stubbed out with errors. ghc-lib5Quasi-quoter for expressions, invoked by quotes like lhs = $[q|...] ghc-lib2Quasi-quoter for patterns, invoked by quotes like f $[q|...] = rhs ghc-lib/Quasi-quoter for types, invoked by quotes like  f :: $[q|...] ghc-lib:Quasi-quoter for declarations, invoked by top-level quotes ghc-lib  takes a  P and lifts it into one that read the data out of a file. For example, suppose asmqr is an assembly-language quoter, so that you can write [asmq| ld r1, r2 |] as an expression. Then if you define asmq_f = quoteFile asmq<, then the quote [asmq_f|foo.s|] will take input from file "foo.s" instead of the inline text OPQ QPONNone  O (c) Dan DoelBSD3dan.doel@gmail.com experimental+non-portable (multi-parameter type classes)Safe=?@ASX ghc-libYA monad transformer for performing backtracking computations layered over another monad m ghc-libWRuns a ListT computation with the specified initial success and failure continuations.  PNoneE ghc-lib!Read in assembly file and process%Gghc-lib4These are the rewrites that the mangler will perform%Hghc-libbRewrite a line of assembly source with the given rewrites, taking the first rewrite that applies.%Ighc-libThis rewrites .type$ annotations of function symbols to %object+. This is done as the linker can relocate  %functions through the Procedure Linking Table (PLT). This is bad since we expect that the info table will appear directly before the symbol's location. In the case that the PLT is used, this will be not an info table but instead some random PLT garbage.%Jghc-libThis rewrites aligned AVX instructions to their unaligned counterparts on x86-64. This is necessary because the stack is not adequately aligned for aligned AVX spills, so LLVM would emit code that adjusts the stack pointer and disable tail call optimization. Both would be catastrophic here so GHC tells LLVM that the stack is 32-byte aligned (even though it isn't) and then rewrites the instructions in the mangler.%Kghc-libreplaceOnce match replace bs1 replaces the first occurrence of the substring match in bs with replace.%Lghc-libVThis function splits a line of assembly code into the label and the rest of the code.  QNone  RSafeA  SNone  TNone  UNone) ghc-lib"A subcomponent of another register ghc-libA register of some class ghc-libWorst case displacementTa node N of classN has some number of neighbors, all of which are from classC.(worst neighbors classN classC) is the maximum number of potential colors for N that can be lost by coloring its neighbors.pThis should be hand coded/cached for each particular architecture, because the compute time is very long.. ghc-libFor a node N of classN and neighbors of classesC (bound classN classesC) is the maximum number of potential colors for N that can be lost by coloring its neighbors. ghc-lib@The total squeese on a particular node with a list of neighbors.A version of this should be constructed for each particular architecture, possibly including uses of bound, so that alised registers don't get counted twice, as per the paper.%Mghc-libpowerset (for lists)%Nghc-libpowersetLS (list of sets) ghc-libso we can put regs in UniqSets  VNone/c ghc-lib!Determine the class of a register ghc-lib4Determine all the regs that make up a certain class. ghc-lib`Determine the common name of a reg returns Nothing if this reg is not part of the machine. ghc-lib!Which regs alias what other regs. ghc-libCOptimised versions of RegColorBase.{worst, squeese} specific to x86      WNone6 ghc-lib3The slots that are still available to be allocated. ghc-lib#Assignment of vregs to stack slots. ghc-libIdentifier for a stack slot. ghc-lib-An empty stack map, with all slots available. ghc-libIf this vreg unique already has a stack assignment then return the slot number, otherwise allocate a new slot, and update the map. ghc-lib4Return the number of stack slots that were allocated              XNone8 ghc-libThe class of a register. Used in the register allocator. We treat all registers in a class as being interchangable.          YNoneDi ghc-lib"A register, either virtual or real ghc-libRealRegs are machine regs which are available for allocation, in the usual way. We know what class they are, because that's part of the processor's architecture.RealRegPairs are pairs of real registers that are allocated together to hold a larger value, such as with Double regs on SPARC. )ghc-lib4An identifier for a primitive real machine register. 6ghc-libThe patch function supplied by the allocator maps VirtualReg to RealReg regs, but sometimes we want to apply it to plain old Reg. <ghc-libPrint a reg in a generic manner If you want the architecture specific names, then use the pprReg function from the appropriate Ppr module.    ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 )    1 0 2 3 4 5 # $ % & ' ( * + , - ! " . / 6ZNoneEw E E[NoneE F G H I J K F G H I J K\NoneF+ L M N O P Q L M N O P Q]NoneF R S T U V R S T U V^NoneF W X Y Z [ W X Y Z [_NoneGe \ ] ^ _ ` \ ] ^ _ ``NoneG a b c d e a b c d eaNoneH1 f g h i j f g h i jbNoneOD kghc-libReturns $qG if this global register is stored in a caller-saves machine register. lghc-libHHere is where the STG register map is defined for each target arch. The order matters (for the llvm backend anyway)! We must make sure to maintain the order here with the order used in the LLVM calling conventions. Note that also, this isn't all registers, just the ones that are currently possbily mapped to real registers. k l m n o k l m n odNone%O r s t t s reNoneP u ufNoneMgN ghc-libTrue  = This is a static closure. Affects how we garbage-collect it. Static closure have an extra static link field at the end. Constructors do not have a static variant; see Note [static constructors] ghc-libaA description of the layout of a closure. Corresponds directly to the closure types in includesrtsstorage/ClosureTypes.h. ghc-libByte offset, or byte count ghc-libWord offset, or word count ghc-libcRound up the given byte count to the next byte count that's a multiple of the machine's word size. ghc-lib Round up base to a multiple of size. ghc-lib7Convert the given number of words to a number of bytes.This function morally has type WordOff -> ByteOff , but uses Num a to allow for overloading. ghc-libsFirst round the given byte count up to a multiple of the machine's word size and then convert the result to words. ghc-lib/Size of a closure header (StgHeader in includesrtsstorage/Closures.h) ghc-libJSize of the profiling part of a closure header (StgProfHeader in includesrtsstorage/Closures.h)%Oghc-libPThe garbage collector requires that every closure is at least as big as this. ghc-lib(The total size of the closure, in words. ghc-libCThe byte offset into the card table of the card for a given element ghc-lib>Convert a number of elements to a number of cards, rounding up ghc-lib"The size of a card table, in bytes ghc-lib"The size of a card table, in words ghc-lib%Derives the RTS closure type from an  H v w x y z { } | ~  H { } | ~  v w x y z gNone&'1=>?@AX ghc-libTick scope identifier, allowing us to reason about what annotations in a Cmm block should scope over. We especially take care to allow optimisations to reorganise blocks without losing tick association in the process. ghc-libThe global scope is the "root" of the scope graph. Every scope is a sub-scope of the global scope. It doesn't make sense to add ticks to this scope. On the other hand, this means that setting this scope on a block means no ticks apply to it. ghc-liblConstructs a new sub-scope to an existing scope. This allows us to translate Core-style scoping rules (see  tickishScoped2) into the Cmm world. Suppose the following code:tick 1# case ... of A -> tick 2 ... B -> tick 3 ...We want the top-level tick annotation to apply to blocks generated for the A and B alternatives. We can achieve that by generating tick 1~ into a block with scope a, while the code for alternatives A and B gets generated into sub-scopes a/b and a/c respectively. ghc-libA combined scope scopes over everything that the two given scopes cover. It is therefore a sub-scope of either scope. This is required for optimisations. Consider common block elimination: A -> tick 2, case ... of C -> [common] B -> tick 3 case ... of D -> [common]We will generate code for the C and D alternatives, and figure out afterwards that it's actually common code. Scoping rules dictate that the resulting common block needs to be covered by both tick 2 and tick 3z, therefore we need to construct a scope that is a child to *both* scope. Now we can do that - if we assign the scopes ac and bOd to the common-ed up blocks, the new block could have a combined tick scope ac+bd, which both tick 2 and tick 3 apply to. ghc-lib)Tickish in Cmm context (annotations only) ghc-libjA convention maps a list of values (function arguments or return values) to registers or stack locations. ghc-lib top-level Haskell functions use NativeDirectCall, which maps arguments to registers starting with R2, according to how many registers are available on the platform. This convention ignores R1, because for a top-level function call the function closure is implicit, and doesn't need to be passed. ghc-libnon-top-level Haskell functions, which pass the address of the function closure in R1 (regardless of whether R1 is a real register or not), and the rest of the arguments in registers or on the stack. ghc-lib%a native return. The convention for returns depends on how many values are returned: for just one value returned, the appropriate register is used (R1, F1, etc.). regardless of whether it is a real register or not. For multiple values returned, they are mapped to registers or the stack. ghc-lib/Slow entry points: all args pushed on the stack ghc-lib\Entry to the garbage collector: uses the node reg! (TODO: I don't think we need this --SDM)%Pghc-libOutput all scope paths.%Qghc-libRReturns the head uniques of the scopes. This is based on the assumption that the Unique of SubScope` identifies the underlying super-scope. Used for efficient equality and comparison, see below.ghc-lib_Checks whether two tick scopes are sub-scopes of each other. True if the two scopes are equal.ghc-libCombine two tick scopes. The new scope should be sub-scope of both parameters. We simplfy automatically if one tick scope is a sub-scope of the other already.B B    hNone&'.ghc-lib!Info table as a haskell data typeFghc-libA top-level chunk, abstracted over the type of the contents of the basic blocks (Cmm or instructions are the likely instantiations).Nghc-lib4Should a data in this section be considered constantOghc-libaThe branch block id is that of the first block in the branch, which is that branch's entry point$$$%%%%%%%%%% % % % % %%%%%%%%%%%%%%%%%%% %!%"%#%$%%%&%'%(%)%*%+%,%-%.%/%0%1%2%3$p%4%5%6%7%8%9%:%;%<%=%>%?%@stuvwxyz{|}~                           ! " # $ % & ' ( ) * + ,                       ! " # $ % & ' ( / , ) * + - . 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 [ \ ] ^ z { } | ~   !"$#)%&'(*+-,./0123456789:;<=>?@ABCDEFHGIJKLMNOPCLJKEFHGC?@AB>DI !"$#)%&'(*NOP:;<=56789./01234M { } | ~  +-, ziNoneTUVWXUTVXWjNoneFcghc-libPretty print binary data.eUse either the ".string" directive or a ".incbin" directive. See Note [Embedding large binary blobs]+A NULL byte is added after the binary data.^_`abcd^_`abcdkNoneMeghc-libLlvm cast operations.fghc-libInteger truncategghc-libInteger extend (zero fill)hghc-libInteger extend (sign fill)ighc-libFloat truncatejghc-lib Float extendkghc-libFloat to unsigned Integerlghc-libFloat to signed Integermghc-libUnsigned Integer to Floatnghc-libSigned Int to Floatoghc-libPointer to Integerpghc-libInteger to Pointerqghc-lib6Cast between types where no bit manipulation is neededrghc-libLlvm compare operations.sghc-libEqual (Signed and Unsigned)tghc-libNot equal (Signed and Unsigned)ughc-libUnsigned greater thanvghc-libUnsigned greater than or equalwghc-libUnsigned less thanxghc-libUnsigned less than or equalyghc-libSigned greater thanzghc-libSigned greater than or equal{ghc-libSigned less than|ghc-libSigned less than or equal}ghc-lib Float equal~ghc-libFloat not equalghc-libFloat greater thanghc-libFloat greater than or equalghc-libFloat less thanghc-libFloat less than or equalghc-lib)Llvm binary operators machine operations.ghc-lib1add two integer, floating point or vector values.ghc-libsubtract two ...ghc-lib multiply ..ghc-lib$unsigned integer or vector division.ghc-libsigned integer ..ghc-lib*unsigned integer or vector remainder (mod)ghc-lib signed ...ghc-lib(add two floating point or vector values.ghc-libsubtract two ...ghc-lib multiply ...ghc-lib divide ...ghc-lib remainder ...ghc-lib Left shiftghc-lib3Logical shift right Shift right, filling with zeroghc-libsArithmetic shift right The most significant bits of the result will be equal to the sign bit of the left operand.ghc-libAND bitwise logical operation.ghc-libOR bitwise logical operation.ghc-libXOR bitwise logical operation.ghc-libLinkage type of a symbol.`The description of the constructors is copied from the Llvm Assembly Language Reference Manual  -http://www.llvm.org/docs/LangRef.html#linkage5, because they correspond to the Llvm linkage types.ghc-libjGlobal values with internal linkage are only directly accessible by objects in the current module. In particular, linking code into a module with an internal global value may cause the internal to be renamed as necessary to avoid collisions. Because the symbol is internal to the module, all references can be updated. This corresponds to the notion of the static keyword in C.ghc-lib Globals with linkonce linkage are merged with other globals of the same name when linkage occurs. This is typically used to implement inline functions, templates, or other code which must be generated in each translation unit that uses it. Unreferenced linkonce globals are allowed to be discarded.ghc-libweakI linkage is exactly the same as linkonce linkage, except that unreferenced weak globals may not be discarded. This is used for globals that may be emitted in multiple translation units, but that are not guaranteed to be emitted into every translation unit that uses them. One example of this are common globals in C, such as int X; at global scope.ghc-lib appending linkage may only be applied to global variables of pointer to array type. When two global variables with appending linkage are linked together, the two global arrays are appended together. This is the Llvm, typesafe, equivalent of having the system linker append together sections/ with identical names when .o files are linked.ghc-libThe semantics of this linkage follow the ELF model: the symbol is weak until linked, if not linked, the symbol becomes null instead of being an undefined reference.ghc-lib[The symbol participates in linkage and can be used to resolve external symbol references.ghc-lib Alias for 3 but with explicit textual form in LLVM assembly.ghc-libISymbol is private to the module and should not appear in the symbol tableghc-libFFunctions can have a fixed amount of parameters, or a variable amount.ghc-lib1Different calling conventions a function can use.ghc-libHThe C calling convention. This calling convention (the default if no other calling convention is specified) matches the target C calling conventions. This calling convention supports varargs function calls and tolerates some mismatch in the declared prototype and implemented declaration of the function (as does normal C).ghc-lib/This calling convention attempts to make calls as fast as possible (e.g. by passing things in registers). This calling convention allows the target to use whatever tricks it wants to produce fast code for the target, without having to conform to an externally specified ABI (Application Binary Interface). Implementations of this convention should allow arbitrary tail call optimization to be supported. This calling convention does not support varargs and requires the prototype of al callees to exactly match the prototype of the function definition.ghc-libThis calling convention attempts to make code in the caller as efficient as possible under the assumption that the call is not commonly executed. As such, these calls often preserve all registers so that the call does not break any live ranges in the caller side. This calling convention does not support varargs and requires the prototype of all callees to exactly match the prototype of the function definition.ghc-libThe GHC-specific  registerised calling convention.ghc-libAny calling convention may be specified by number, allowing target-specific calling conventions to be used. Target specific calling conventions start at 64.ghc-lib X86 Specific R convention. LLVM includes a specific alias for it rather than just using CC_Ncc.ghc-lib#Different types to call a function.ghc-lib(Normal call, allocate a new stack frame.ghc-lib7Tail call, perform the call in the current stack frame.ghc-libLlvm Function Attributes.)Function attributes are set to communicate additional information about a function. Function attributes are considered to be part of the function, not of the function type, so functions with different parameter attributes can have the same function type. Functions can have multiple attributes.Descriptions taken from )http://llvm.org/docs/LangRef.html#fnattrsghc-libThis attribute indicates that the inliner should attempt to inline this function into callers whenever possible, ignoring any active inlining size threshold for this caller.ghc-libThis attribute indicates that the source code contained a hint that inlining this function is desirable (such as the "inline" keyword in C/C++). It is just a hint; it imposes no requirements on the inliner.ghc-libThis attribute indicates that the inliner should never inline this function in any situation. This attribute may not be used together with the alwaysinline attribute.ghc-libThis attribute suggests that optimization passes and code generator passes make choices that keep the code size of this function low, and otherwise do optimizations specifically to reduce code size.ghc-libThis function attribute indicates that the function never returns normally. This produces undefined behavior at runtime if the function ever does dynamically return.ghc-libThis function attribute indicates that the function never returns with an unwind or exceptional control flow. If the function does unwind, its runtime behavior is undefined.ghc-libThis attribute indicates that the function computes its result (or decides to unwind an exception) based strictly on its arguments, without dereferencing any pointer arguments or otherwise accessing any mutable state (e.g. memory, control registers, etc) visible to caller functions. It does not write through any pointer arguments (including byval arguments) and never changes any state visible to callers. This means that it cannot unwind exceptions by calling the C++ exception throwing methods, but could use the unwind instruction.ghc-lib4This attribute indicates that the function does not write through any pointer arguments (including byval arguments) or otherwise modify any state (e.g. memory, control registers, etc) visible to caller functions. It may dereference pointer arguments and read state that may be set in the caller. A readonly function always returns the same value (or unwinds an exception identically) when called with the same set of arguments and global state. It cannot unwind an exception by calling the C++ exception throwing methods, but may use the unwind instruction.ghc-libRThis attribute indicates that the function should emit a stack smashing protector. It is in the form of a "canary" a random value placed on the stack before the local variables that's checked upon return from the function to see if it has been overwritten. A heuristic is used to determine if a function needs stack protectors or not.If a function that has an ssp attribute is inlined into a function that doesn't have an ssp attribute, then the resulting function will have an ssp attribute.ghc-libThis attribute indicates that the function should always emit a stack smashing protector. This overrides the ssp function attribute.If a function that has an sspreq attribute is inlined into a function that doesn't have an sspreq attribute or which has an ssp attribute, then the resulting function will have an sspreq attribute.ghc-libThis attribute indicates that the code generator should not use a red zone, even if the target-specific ABI normally permits it.ghc-lib>This attributes disables implicit floating point instructions.ghc-libxThis attribute disables prologue / epilogue emission for the function. This can have very system-specific consequences.ghc-libLLVM Parameter Attributes.qParameter attributes are used to communicate additional information about the result or parameters of a functionghc-libThis indicates to the code generator that the parameter or return value should be zero-extended to a 32-bit value by the caller (for a parameter) or the callee (for a return value).ghc-libThis indicates to the code generator that the parameter or return value should be sign-extended to a 32-bit value by the caller (for a parameter) or the callee (for a return value).ghc-libThis indicates that this parameter or return value should be treated in a special target-dependent fashion during while emitting code for a function call or return (usually, by putting it in a register as opposed to memory).ghc-lib\This indicates that the pointer parameter should really be passed by value to the function.ghc-libThis indicates that the pointer parameter specifies the address of a structure that is the return value of the function in the source program.ghc-libRThis indicates that the pointer does not alias any global or any other parameter.ghc-libfThis indicates that the callee does not make any copies of the pointer that outlive the callee itselfghc-libZThis indicates that the pointer parameter can be excised using the trampoline intrinsics.ghc-libAn LLVM Functionghc-lib!Unique identifier of the functionghc-libLinkageType of the functionghc-lib&The calling convention of the functionghc-libType of the returned valueghc-lib'Indicates if this function uses varargsghc-libParameter types and attributesghc-lib(Function align value, must be power of 2ghc-libLlvm Static Data.BThese represent the possible global level variables and constants.ghc-libA comment in a static sectionghc-lib#A static variant of a literal valueghc-libFor uninitialised dataghc-libDefines a static ghc-libA static arrayghc-libA static structure typeghc-libA pointer to other dataghc-libTruncateghc-libPointer to Pointer conversionghc-libPointer to Integer conversionghc-libConstant addition operationghc-libConstant subtraction operationghc-libLlvm Literal Data.(These can be used inline in expressions.ghc-lib'Refers to an integer constant (i64 42).ghc-libFloating point literalghc-lib.Literal NULL, only applicable to pointer typesghc-libVector literalghc-lib>Undefined value, random bit pattern. Useful for optimisations.ghc-libLLVM Variablesghc-libVariables with a global scope.ghc-lib,Variables local to a function or parameters.ghc-liboNamed local variables. Sometimes we need to be able to explicitly name variables (e.g for function arguments).ghc-libA constant variableghc-libMutable global variableghc-libConstant global variableghc-libAlias of another variableghc-libGAn LLVM section definition. If Nothing then let LLVM decide the sectionghc-lib Llvm Typesghc-lib&An integer with a given width in bits.ghc-lib32 bit floating pointghc-lib64 bit floating pointghc-lib 80 bit (x86 only) floating pointghc-lib128 bit floating pointghc-libA pointer to a ghc-lib An array of ghc-lib A vector of ghc-libA  can represent a label (address)ghc-lib Void typeghc-libPacked structure typeghc-libUnpacked structure typeghc-lib A type aliasghc-lib LLVM Metadataghc-lib3Function type, used to create pointers to functionsghc-lib A type aliasghc-libA String in LLVMghc-lib4A global mutable variable. Maybe defined or externalghc-libReturns the variable of the ghc-libReturn the value of the ghc-lib)Return the variable name or value of the * in Llvm IR textual representation (e.g. @x, %y or 42).ghc-lib)Return the variable name or value of the * in a plain textual representation (e.g. x, y or 42).ghc-libPrint a literal value. No type. ghc-lib Return the  of the  ghc-lib Return the  of a  ghc-lib Return the  of the  ghc-lib Return the  for a  ghc-lib0Add a pointer indirection to the supplied type.  and  cannot be lifted.ghc-libLift a variable to  type.ghc-lib:Remove the pointer indirection of the supplied type. Only  constructors can be lowered.ghc-libLower a variable of  type.ghc-libTest if the given  is an integerghc-libTest if the given  is a floating point typeghc-libTest if the given  is an  constructghc-libTest if the given  is an  constructghc-lib Test if a  is global.ghc-libWidth in bits of an , returns 0 if not applicableghc-lib"The target architectures word sizeghc-lib"The target architectures word size ghc-libConvert a Haskell Double to an LLVM hex encoded floating point form. In Llvm float literals can be printed in a big-endian hexadecimal format, regardless of underlying architecture.See Note [LLVM Float Types].$ghc-libBReverse or leave byte data alone to fix endianness on this target.eqponmlkjihgfr~}|{zyxwvuts      !"#$%&     r~}|{zyxwvutseqponmlkjihgf !"#$%&lNoneMCghc-libEMetadata declarations. Metadata can only be declared in global scope.Dghc-libXNamed metadata. Only used for communicating module information to LLVM. ('!name = !{ [! n ] }' form).Eghc-lib/Metadata node declaration. ('!0 = metadata !{  metadata expression }' form).Fghc-libPAssociates some metadata with a specific label for attaching to an instruction.Hghc-libLLVM metadata expressionsMghc-lib)A reference to an un-named metadata node. CEDFGHLKJIMN MNHLKJIFGCEDmNone;Vghc-libLlvm ExpressionsWghc-libAllocate amount * sizeof(tp) bytes on the stack * tp: LlvmType to reserve room for * amount: The nr of tp's which must be allocatedXghc-libPerform the machine operator op on the operands left and right * op: operator * left: left operand * right: right operandYghc-libPerform a compare operation on the operands left and right * op: operator * left: left operand * right: right operandZghc-libuExtract a scalar element from a vector * val: The vector * idx: The index of the scalar within the vector[ghc-libExtract a scalar element from a structure * val: The structure * idx: The index of the scalar within the structure Corresponds to "extractvalue" instruction.\ghc-libInsert a scalar element into a vector * val: The source vector * elt: The scalar to insert * index: The index at which to insert the scalar]ghc-libAllocate amount * sizeof(tp) bytes on the heap * tp: LlvmType to reserve room for * amount: The nr of tp's which must be allocated^ghc-libLoad the value at location ptr_ghc-lib(Atomic load of the value at location ptr`ghc-libNavigate in a structure, selecting elements * inbound: Is the pointer inbounds? (computed pointer doesn't overflow) * ptr: Location of the structure * indexes: A list of indexes to select the correct value.aghc-libCast the variable from to the to type. This is an abstraction of three cast operators in Llvm, inttoptr, ptrtoint and bitcast. * cast: Cast type * from: Variable to cast * to: type to cast tobghc-libAtomic read-modify-write operation * op: Atomic operation * addr: Address to modify * operand: Operand to operation * ordering: Ordering requirementcghc-lib Compare-and-exchange operation * addr: Address to modify * old: Expected value * new: New value * suc_ord: Ordering required in success case * fail_ord: Ordering required in failure case, can be no stronger than suc_ord Result is an i1, true if store was successful.dghc-libCall a function. The result is the value of the expression. * tailJumps: CallType to signal if the function should be tail called * fnptrval: An LLVM value containing a pointer to a function to be invoked. Can be indirect. Should be LMFunction type. * args: Concrete arguments for the parameters * attrs: A list of function attributes for the call. Only NoReturn, NoUnwind, ReadOnly and ReadNone are valid here.eghc-libCall a function as above but potentially taking metadata as arguments. * tailJumps: CallType to signal if the function should be tail called * fnptrval: An LLVM value containing a pointer to a function to be invoked. Can be indirect. Should be LMFunction type. * args: Arguments that may include metadata. * attrs: A list of function attributes for the call. Only NoReturn, NoUnwind, ReadOnly and ReadNone are valid here.fghc-lib^Merge variables from different basic blocks which are predecessors of this basic block in a new variable of type tp. * tp: type of the merged variable, must match the types of the predecessor variables. * predecessors: A list of variables and the basic block that they originate from.gghc-libInline assembly expression. Syntax is very similar to the style used by GCC. * assembly: Actual inline assembly code. * constraints: Operand constraints. * return ty: Return type of function. * vars: Any variables involved in the assembly code. * sideeffect: Does the expression have side effects not visible from the constraints list. * alignstack: Should the stack be conservatively aligned before this expression is executed.hghc-lib/A LLVM expression with metadata attached to it.ighc-libLlvm Statementsjghc-libkAssign an expression to a variable: * dest: Variable to assign to * source: Source expressionkghc-libMemory fence operationlghc-lib!Always branch to the target labelmghc-libBranch to label targetTrue if cond is true otherwise to label targetFalse * cond: condition that will be tested, must be of type i1 * targetTrue: label to branch to if cond is true * targetFalse: label to branch to if cond is falsenghc-libComment Plain comment.oghc-lib\Set a label on this position. * name: Identifier of this label, unique for this modulepghc-libStore variable value in pointer ptr. If value is of type t then ptr must be of type t*. * value: Variable/Constant to store. * ptr: Location to store the value inqghc-libMultiway branch * scrutinee: Variable or constant which must be of integer type that is determines which arm is chosen. * def: The default label if there is no match in target. * target: A list of (value,label) where the value is an integer constant and label the corresponding label to jump to if the scrutinee matches the value.rghc-libCReturn a result. * result: The variable or constant to returnsghc-libIAn instruction for the optimizer that the code following is not reachabletghc-lib`Raise an expression to a statement (if don't want result or want to use Llvm unnamed values.ughc-libtA nop LLVM statement. Useful as its often more efficient to use this then to wrap LLvmStatement in a Just or [].vghc-lib.A LLVM statement with metadata attached to it.wghc-lib'LLVM atomic operations. Please see the  atomicrmwC instruction in the LLVM documentation for a complete description.ghc-libLLVM ordering types for synchronization purposes. (Introduced in LLVM 3.0). Please see the LLVM documentation for a better description.ghc-lib(Some partial order of operations exists.ghc-lib?A single total order for operations at a single address exists.ghc-lib"Acquire synchronization operation.ghc-lib"Release synchronization operation.ghc-lib,Acquire + Release synchronization operation.ghc-lib&Full sequential Consistency operation.ghc-libAn LLVM Functionghc-lib(The signature of this declared function.ghc-libThe functions argumentsghc-libThe function attributes.ghc-lib%The section to put the function into,ghc-lib Prefix dataghc-libThe body of the functions.ghc-lib6An LLVM Module. This is a top level container in LLVM.ghc-lib/Comments to include at the start of the module.ghc-libLLVM Alias type definitions.ghc-libLLVM meta data.ghc-lib*Global variables to include in the module.ghc-lib@LLVM Functions used in this module but defined in other modules.ghc-lib&LLVM Functions defined in this module.ghc-libA block of LLVM code.ghc-libThe code label for this blockghc-librA list of LlvmStatement's representing the code for this block. This list must end with a control flow statement.ghc-lib Block labelsLVhgfedcb`_^]\[ZXWYaivusrqponmlkjtw~}|{zyxLw~}|{zyxivusrqponmlkjtVhgfedcb`_^]\[ZXWYanNone,ghc-libPrint out a whole LLVM module.ghc-libFPrint out a multi-line comment, can be inside a function or on its ownghc-lib;Print out a comment, can be inside a function or on its ownghc-lib7Print out a list of global mutable variable definitionsghc-lib.Print out a global mutable variable definitionghc-lib&Print out a list of LLVM type aliases.ghc-libPrint out an LLVM type alias.ghc-lib"Print out a list of LLVM metadata.ghc-lib&Print out an LLVM metadata definition.ghc-lib)Print out a list of function definitions.ghc-lib Print out a function definition.%Rghc-lib'Print out a function definition header.ghc-lib)Print out a list of function declaration.ghc-lib{Print out a function declaration. Declarations define the function type but don't define the actual body of the function.%Sghc-lib Print out a list of LLVM blocks.%Tghc-libCPrint out an LLVM block. It must be part of a function definition.%Ughc-libPrint out an LLVM block label.%Vghc-libPrint out an LLVM statement.%Wghc-libPrint out an LLVM expression.%Xghc-libShould always be a function pointer. So a global var of function type (since globals are always pointers) or a local var of pointer function type.%Yghc-lib Blank line.%Zghc-libExclamation point.  CNone-aefghijklmnopqrstuvwxyz{|}~     CDEFGHIJKLMNVaYWXZ[\]^_`bcdefghitjklmnopqrsuvwxyz{|}~itjklmnopqrsuvVaYWXZ[\]^_`bcdefghwxyz{|}~rstuvwxyz{|}~efghijklmnopqHIJKLFGCDEMN     oNoneP ghc-lib;Get the LlvmVar function variable storing the real registerghc-lib;Get the LlvmVar function argument storing the real registerghc-lib>A list of STG Registers that should always be considered aliveghc-lib'STG Type Based Alias Analysis hierarchy%[ghc-libId values The %[ node is the root (there can be more than one) of the TBAA hierarchy and as of LLVM 4.0 should *only* be referenced by other nodes. It should never occur in any LLVM instruction statement.ghc-libId values The %[ node is the root (there can be more than one) of the TBAA hierarchy and as of LLVM 4.0 should *only* be referenced by other nodes. It should never occur in any LLVM instruction statement.ghc-libId values The %[ node is the root (there can be more than one) of the TBAA hierarchy and as of LLVM 4.0 should *only* be referenced by other nodes. It should never occur in any LLVM instruction statement.ghc-libId values The %[ node is the root (there can be more than one) of the TBAA hierarchy and as of LLVM 4.0 should *only* be referenced by other nodes. It should never occur in any LLVM instruction statement.ghc-libId values The %[ node is the root (there can be more than one) of the TBAA hierarchy and as of LLVM 4.0 should *only* be referenced by other nodes. It should never occur in any LLVM instruction statement.ghc-libId values The %[ node is the root (there can be more than one) of the TBAA hierarchy and as of LLVM 4.0 should *only* be referenced by other nodes. It should never occur in any LLVM instruction statement.ghc-libThe TBAA metadata identifierghc-lib@Get the correct TBAA metadata information for this register type  pNone~\ghc-libCommon things that we can do with instructions, on all architectures. These are used by the shared parts of the native code generator, specifically the register allocators.ghc-libIGet the registers that are being used by this instruction. regUsage doesn't need to do any trickery for jumps and such. Just state precisely the regs read and written by that insn. The consequences of control flow transfers, as far as register allocation goes, are taken care of by the register allocator.ghc-libOApply a given mapping to all the register references in this instruction.ghc-libChecks whether this instruction is a jump/branch instruction. One that can change the flow of control in a way that the register allocator needs to worry about.ghc-liblGive the possible destinations of this jump instruction. Must be defined for all jumpish instructions.ghc-libChange the destination of this jump instruction. Used in the linear allocator when adding fixup blocks for join points.ghc-lib5An instruction to spill a register into a spill slot.ghc-lib6An instruction to reload a register from a spill slot.ghc-lib?See if this instruction is telling us the current C stack deltaghc-libpCheck whether this instruction is some meta thing inserted into the instruction stream for other purposes.jNot something that has to be treated as a real machine instruction and have its registers allocated. eg, comments, delta, ldata, etc.ghc-libVCopy the value in a register to another one. Must work for all register classes.ghc-libfTake the source and destination from this reg -> reg move instruction or Nothing if it's not oneghc-libMake an unconditional jump instruction. For architectures with branch delay slots, its ok to put a NOP after the jump. Don't fill the delay slot with an instruction that references regs or you'll confuse the linear allocator.ghc-libXHolds a list of source and destination registers used by a particular instruction.Machine registers that are pre-allocated to stgRegs are filtered out, because they are uninteresting from a register allocation standpoint. (We wouldn't want them to end up on the free list!)kAs far as we are concerned, the fixed registers simply don't exist (for allocation purposes, anyway).ghc-libNo regs read or written to.ghc-libJReturns the info table associated with the CmmDecl's entry point, if any.ghc-libReturn the list of BlockIds in a CmmDecl that are entry points for this proc (i.e. they may be jumped to from outside this proc).ghc-libthe reg to spillghc-libthe current stack deltaghc-libspill slot to useghc-libthe reg to reload.ghc-libthe current stack deltaghc-libthe spill slot to useghc-libsource registerghc-libdestination registerOOqNone &'@AHSVXg ghc-lib@Function for rewrtiting and analysis combined. To be used with  rewriteCmm.Currently set to work with UniqSM monad, but we could probably abstract that away (if we do that, we might want to specialize the fixpoint algorithms to the particular monads through SPECIALIZE).ghc-lib*The result of joining OldFact and NewFact.ghc-lib!Result is different than OldFact.ghc-libResult is the same as OldFact.%\ghc-libSort the blocks into the right order for analysis. This means reverse postorder for a forward analysis. For the backward one, we simply reverse that (see Note [Backward vs forward analysis]).%]ghc-libConstruct a mapping from a LabelG to the block indexes that should be re-analyzed if the facts at that Label change.7Note that we're considering here the entry point of the block, so if the facts change at the entry: * for a backward analysis we need to re-analyze all the predecessors, but * for a forward analysis, we only need to re-analyze the current block (and that will in turn propagate facts into its successors).%^ghc-libAfter some new facts have been generated by analysing a block, we fold this function over them to generate (a) a list of block indices to (re-)analyse, and (b) the new FactBase.ghc-lib_Returns the result of joining the facts from all the successors of the provided node or block.ghc-lib(Returns the joined facts for each label.ghc-libPFolds backward over all nodes of an open-open block. Strict in the accumulator.ghc-libFolds backward over all the nodes of an open-open block and allows rewriting them. The accumulator is both the block of nodes and f> (usually dataflow facts). Strict in both accumulated parts. L m m LrNoneghc-lib%Get the integer format of this width.ghc-lib#Get the float format of this width.ghc-lib4Check if a format represents a floating point value.ghc-libConvert a Cmm type to a Format.ghc-libGet the Width of a Format.sNoneghc-libregSqueeze_class reg Calculate the maximum number of register colors that could be denied to a node of this class due to having this reg as a neighbour./      !"#$%&'()*+,-/      !"#$%&'()*-+,tNoneI./01234./01234uNone&'SXLghc-libUseful for creating an index into an array, with a statically known offset. The type is the element type; used for making the multiplierMghc-libCUseful for creating an index into an array, with an unknown offset.sghc-libReturns True if the two STG registers overlap on the specified platform, in the sense that writing to one will clobber the other. This includes the case that the two registers are the same STG register. See Note [Overlapping global registers] for details.tghc-libReturns True if the STG register is used by the expression, in the sense that a store to the register might affect the value of the expression.We must check for overlapping registers and not just equal registers here, otherwise CmmSink may incorrectly reorder assignments that conflict due to overlap. See #10521 and Note [Overlapping global registers].zghc-liblike y(, but the entry block always comes first{ghc-libLike z!, but we strive to ensure that we order blocks so that the false case of a conditional jumps to the next block in the output list of blocks. This matches the way OldCmm blocks were output since in OldCmm the false case was a fallthrough, whereas in Cmm conditional branches have both true and false successors. Block ordering can make a big difference in performance in the LLVM backend. Note that we rely crucially on the order of successors returned for CmmCondBranch by the NonLocal instance for CmmNode defined in cmm/CmmNode.hs. -GBMghc-lib1Extract all tick annotations from the given blockU6789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~U67:8;9><@EABCD=?FIHKJGOPRSQVUXWTLMNYg^_`ba\]Z[dcefijklmhnopqrstuvxw|y}z{~vNone &'=>?HV  TUVWXwNone&'xNone&'0ghc-lib(Expressions, used for unwind informationghc-lib literal valueghc-libregister plus offsetghc-libpointer dereferencingghc-libzMaps registers to expressions that yield their "old" values further up the stack. Most interesting for the stack pointer Sp_, but might be useful to document saved registers, too. Note that a register's value will be $= when the register's previous value cannot be reconstructed.ghc-libA label associated with an %_ghc-libVIntermediate data structure holding debug-relevant context information about a block.ghc-libIDebug information about a block of code. Ticks scope over nested blocks.ghc-libEntry label of containing procghc-lib Hoopl labelghc-lib Output labelghc-libHas an info table?ghc-lib9The parent of this proc. See Note [Splitting DebugBlocks]ghc-libTicks defined in this blockghc-libBest source tick covering blockghc-lib+Output position relative to other blocks. Nothing# means the block was optimized outghc-lib Nested blocksghc-libIs this the entry block?ghc-libExtract debug data from a group of procedures. We will prefer source notes that come from the given module (presumably the module that we are currently compiling).%`ghc-lib1Build a map of blocks sorted by their tick scopesThis involves a pre-order traversal, as we want blocks in rough control flow order (so ticks have a chance to be sorted in the right order).ghc-libbSets position and unwind table fields in the debug block tree according to native generated code.ghc-lib9Converts debug blocks into a label map for easier lookupsghc-libConversion of Cmm expressions to unwind expressions. We check for unsupported operator usages and simplify the expression as far as possible.yNoneNzNone&'>X.%aghc-lib:A mapping from block labels to the variables live on entry%bghc-lib&The variables live on entry to a blockghc-libThe dataflow latticeghc-lib'Calculated liveness info for a CmmGraph%cghc-libJOn entry to the procedure, there had better not be any LocalReg's live-in.{None&'%dghc-libconflicts (r,e) node is False if and only if the assignment r = e' can be safely commuted past statement node.|None&'}None&'ghc-libTraverses the C, making sure that  # are suitable for code generation.~None&'None&'X{%eghc-lib$Ignore these node types for equality%fghc-libGiven a block map, ensure that all "target" blocks are covered by the same ticks as the respective "source" blocks. This not only means copying ticks, but also adjusting tick scopes where necessary.Noneghc-libvGiven a list of arguments, and a function that tells their types, return a list showing where each argument is passedNone&' ghc-libUnlabeled graph with tick scopeghc-lib+CmmAGraph is a chunk of code consisting of:.ordinary statements (assignments, stores etc.)jumpslabelsout-of-line labelled blocksThe semantics is that control falls through labels and out-of-line blocks. Everything after a jump up to the next label is by definition unreachable code, and will be discarded.*Two CmmAGraphs can be stuck together with  *D, with the meaning that control flows from the first to the second.A  can be turned into a CX (closed at both ends) by providing a label for the entry point and a tick scope; see .ghc-lib.created a sequence "goto id; id:" as an AGraphghc-lib(creates an open AGraph from a given nodeghc-lib)created a closed AGraph from a given nodeghc-lib0A labelled code block; should end in a last nodeghc-lib*allocate a fresh label for the entry pointghc-lib5use the given BlockId as the label of the entry pointghc-libaA jump where the caller says what the live GlobalRegs are. Used for low-level hand-written Cmm.ghc-lib Construct a  7 node for the given register and unwinding expression.**None&'ghc-libWe map STG registers onto appropriate CmmExprs. Either they map to real machine registers or stored as offsets from BaseReg. Given a GlobalReg, get_GlobalReg_addr always produces the register table address for it. ghc-libzFixup global registers so that they assign to locations within the RegTable if they aren't pinned for the current target.    None HMPVX. ghc-libInformation about edgesghc-libCan we trace back a edge to a specific Cmm Node or has it been introduced for codegen. We use this to maintain some information which would otherwise be lost during the Cmm  -@ asm transition. See also Note [Inverting Conditional Branches]ghc-libCA control flow graph where edges have been annotated with a weight.ghc-libUConvenience function, generate edge info based on weight not originating from cmm.ghc-libtAdjust the weight between the blocks using the given function. If there is no such edge returns the original map.ghc-libCheck if the nodes in the cfg and the set of blocks are the same. In a case of a missmatch we panic and show the difference.ghc-libPFilter the CFG with a custom function f. Paramaeters are `f from to edgeInfo`!ghc-libSometimes we insert a block which should unconditionally be executed after a given block. This function updates the CFG for these cases. So we get A -> B => A -> A' -> B -- -> C => -> C"ghc-lib5Adds a new edge, overwrites existing edges if present#ghc-libAdds a edge with the given weight to the cfg If there already existed an edge it is overwritten. `addWeightEdge from to weight cfg`%ghc-lib4Destinations from bid ordered by weight (descending)&ghc-lib1Get successors of a given node with edge weights.)ghc-lib/Returns a unordered list of all edges with info*ghc-lib=Unordered list of edges with weight as Tuple (from,to,weight)+ghc-lib5Returns a unordered list of all edges without weights,ghc-lib4Get successors of a given node without edge weights..ghc-libInsert a block in the control flow between two other blocks. We pass a list of tuples (A,B,C) where * A -> C: Old edge * A -> B -> C : New Arc, where B is the new block. It's possible that a block has two jumps to the same block in the assembly code. However we still only store a single edge for these cases. We assign the old edge info to the edge A -> B and assign B -> C the weight of an unconditional jump./ghc-lib@Generate weights for a Cmm proc based on some simple heuristics.2ghc-libDetermine loop membership of blocks based on SCC analysis Ideally we would replace this with a variant giving us loop levels instead but the SCC code will do for now.6ghc-libFEdges are sorted ascending pointwise by weight, source and destination7ghc-libkCareful! Since we assume there is at most one edge from A to B the Eq instance does not consider weight.(    !"#$%&'()*+,-./012(   #"$. (!)+&,%*'20/-1NoneA@ghc-lib&A bitmap represented by a sequence of   s on the target architecture. These are used for bitmaps in info tables and other generated code which need to be emitted as sequences of StgWords.Aghc-lib%Make a bitmap from a sequence of bitsBghc-lib0Make a bitmap where the slots specified are the ones in the bitmap. eg. [0,1,3], size 4 ==> 0xb. The list of Ints must be already sorted.Cghc-lib0Make a bitmap where the slots specified are the zeros in the bitmap. eg. [0,1,3], size 4 ==> 0x4X (we leave any bits outside the size as zero, just to make the bitmap easier to read). The list of Ints must& be already sorted and duplicate-free.Dghc-libMagic number, must agree with BITMAP_BITS_SHIFT in InfoTables.h. Some kinds of bitmap pack a size/bitmap into a single word if possible, or fall back to an external pointer when the bitmap is too large. This value represents the largest size of bitmap that can be packed into a single word.Bghc-lib size in bitsghc-libsorted indices of onesCghc-lib size in bitsghc-lib*sorted indices of zeros free of duplicates@ABCDE@ABCDENoneJqIghc-lib9We need 8 bytes because our largest registers are 64 bit.Jghc-libqWe (allegedly) put the first six C-call arguments in registers; where do we start putting the rest of them?Kghc-lib6Check whether an offset is representable with 13 bits.Lghc-lib Check whether an integer will fit in 32 bits. A CmmInt is intended to be truncated to the appropriate number of bits, so here we truncate it to Int64. This is important because e.g. -1 as a CmmInt might be either -1 or 18446744073709551615.Mghc-libSadness.FGHIJKLMFGHIJKLMSafeKiNghc-libBranch condition codes.NYUOPQRSTVWXZ[\]^_`aNYUOPQRSTVWXZ[\]^_`aNoneRcghc-libAn immediate value. Not all of these are directly representable by the machine. Things like ImmLit are slurped out and put in a data segment instead.oghc-lib'Create a ImmLit containing this string.pghc-libConvert a CmmLit to an Imm. Narrow to the width: a CmmInt might be out of range, but we assume that ImmInteger only contains in-range values. A signed value should be fine here.cdefghijklmnopcdefghijklmnopNoneVqghc-libwRepresents a memory address in an instruction. Being a RISC machine, the SPARC addressing modes are very regular.tghc-lib4Add an integer offset to the address in an AddrMode.qrstqrstNonequghc-lib8Get the standard name for the register with this number.wghc-libregSqueeze_class reg Calculate the maximum number of register colors that could be denied to a node of this class due to having this reg as a neighbour.yghc-libMAll the allocatable registers in the machine, including register pairs.zghc-lib"Get the regno for this sort of reg{ghc-lib"Get the regno for this sort of reg|ghc-lib"Get the regno for this sort of reg}ghc-lib"Get the regno for this sort of reg~ghc-lib"Get the regno for this sort of regghc-lib.Some specific regs used by the code generator.ghc-lib.Some specific regs used by the code generator.ghc-lib.Some specific regs used by the code generator.ghc-lib.Some specific regs used by the code generator.ghc-lib.Some specific regs used by the code generator.ghc-lib.Some specific regs used by the code generator.ghc-lib.Some specific regs used by the code generator.ghc-lib.Some specific regs used by the code generator.ghc-lib.Some specific regs used by the code generator.ghc-lib.Some specific regs used by the code generator.ghc-lib.Some specific regs used by the code generator.ghc-lib.Some specific regs used by the code generator.ghc-lib.Some specific regs used by the code generator.ghc-lib.Some specific regs used by the code generator.ghc-libBProduce the second-half-of-a-double register given the first half.`All the regs that the register allocator can allocate to, with the fixed use regs removed.ghc-libXThe registers to place arguments for function calls, for some number of arguments.ghc-lib;All all the regs that could possibly be returned by argRegsghc-lib$Make a virtual reg with this format.uvwxyz{|}~uwxvyz}|{~NonexEghc-lib1A reg map where no regs are free to be allocated.ghc-libThe initial set of free regs.ghc-lib)Get all the free registers of this class.ghc-libGrab a register.ghc-libRelease a register from allocation. The register liveness information says that most regs die after a C call, but we still don't want to allocate to some of them.  None ghc-libGet an AddrMode relative to the address in sp. This gives us a stack relative addressing mode for volatile temporaries and for excess call arguments.ghc-libGet an address relative to the frame pointer. This doesn't work work for offsets greater than 13 bits; we just hope for the bestghc-lib=Convert a spill slot number to a *byte* offset, with no sign.ghc-libtThe maximum number of spill slots available on the C stack. If we use up all of the slots, then we're screwed.WWhy do we reserve 64 bytes, instead of using the whole thing?? -- BL 20090215ghc-lib+stack offset in words, positive or negativeNone`sNoneQNoneDEFGGDEFNoneghc-libA substitution result.H     H     NoneiK !"#$%&'()*+0,-./123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`aK\`_]Z[WYXTUV+0,-./123456789:;<=>?&'()*@KLNOMQPGHIJS !"#$%RACBFDE^aNone%gghc-libPush a TickIt context outwards past applications and cases, as long as this is a non-scoping tick, to let case and application optimisations apply.%hghc-lib.A "friendly name" to build the new binder fromghc-lib/This expression satisfies the let/app invariant%ighc-lib.a "friendly name" to build the new binder fromghc-lib/This expression satisfies the let/app invariantefgefgSafei hijklmnopq hijklmnopqNone%jghc-libA %jk is a binding along with a cached set containing its free variables (both type variables and dictionaries)ughc-libJSpecialise calls to type-class overloaded functions occuring in a program.%kghc-lib.Specialise a set of calls to imported bindings%lghc-lib Construct a %j from a %m%nghc-lib!Identify the free variables of a %m%oghc-libFlatten a set of "dumped" %jBs, and some other binding pairs, into a single recursive binding.uuNone>HVXghc-lib(A basic block with liveness information.ghc-libNStash regs live on entry to each basic block in the info part of the cmm code.ghc-lib*Liveness information. The regs which die are ones which are no longer live in the *next* instruction in this sequence. (NB. if the instruction is a jump, these registers might still be live at the jump target(s) - you have to check the liveness at the destination block to find out).ghc-lib=registers that died because they were clobbered by something.ghc-lib?registers born in this instruction (written to for first time).ghc-lib=registers that died because they were read for the last time.ghc-lib)An instruction with liveness information.ghc-libeThe register allocator also wants to use SPILL/RELOAD meta instructions, so we'll keep those here.ghc-libA real machine instructionghc-libspill this reg to a stack slotghc-lib!reload this reg from a stack slotghc-lib5A top level thing which carries liveness information.ghc-lib7map a function across all the basic blocks in this codeghc-libImap a function across all the basic blocks in this code (monadic version)ghc-libImap a function across all the basic blocks in this code (monadic version)ghc-libSlurp out the list of register conflicts and reg-reg moves from this top level thing. Slurping of conflicts and moves is wrapped up together so we don't have to make two passes over the same code when we want to build the graph.ghc-libFor spill/reloads+SPILL v1, slot1 ... RELOAD slot1, v2If we can arrange that v1 and v2 are allocated to the same hreg it's more likely the spill/reload instrs can be cleaned and replaced by a nop reg-reg move.ghc-lib4Strip away liveness information, yielding NatCmmDeclghc-libStrip away liveness information from a basic block, and make real spill instructions out of SPILL, RELOAD pseudos along the way.ghc-libErase Delta instructions.ghc-libPatch the registers in this code according to this register mapping. also erase reg -> reg moves when the reg is the same. also erase reg -> reg moves when the destination dies in this instr.ghc-libFPatch registers in this LiveInstr, including the liveness information.ghc-lib@Convert a NatCmmDecl to a LiveCmmDecl, with liveness information%pghc-libHCheck ordering of Blocks The computeLiveness function requires SCCs to be in reverse dependent order. If they're not the liveness information will be wrong, and we'll get a bad allocation. Better to check for this precondition explicitly or some other poor sucker will waste a day staring at bad assembly code..ghc-libIf we've compute liveness info for this code already we have to reverse the SCCs in each top to get them back to the right order so we can do it again.%qghc-libComputing livenessnOn entry, the SCCs must be in "reverse" order: later blocks may transfer control to earlier ones only, else %r.aThe SCCs returned are in the *opposite* order, which is exactly what we want for the next pass.%sghc-lib:Annotate a basic block with register liveness information.%tghc-libCCalculate liveness going forwards, filling in when regs are born%ughc-liboCalculate liveness going backwards, filling in when regs die, and what regs are live across each instruction%pghc-libDSCCs of blocks that we're about to run the liveness determinator on.ghc-lib$BlockIds that fail the test (if any)# # Noneghc-libThe register allocator stateghc-libgthe current mapping from basic blocks to the register assignments at the beginning of that block.ghc-libfree machine registersghc-lib assignment of temps to locationsghc-libcurrent stack deltaghc-libfree stack slots for spillingghc-lib?unique supply for generating names for join point fixup blocks.ghc-libRecord why things were spilled, for -ddrop-asm-stats. Just keep a list here instead of a map of regs -> reasons. We don't want to slow down the allocator if we're not going to emit the stats.ghc-lib<(from,fixup,to) : We inserted fixup code between from and toghc-lib>Used to carry interesting stats out of the register allocator.ghc-lib<(from,fixup,to) : We inserted fixup code between from and toghc-libqReasons why instructions might be inserted by the spiller. Used when generating stats for -ddrop-asm-stats.ghc-libRvreg was spilled to a slot so we could use its current hreg for another vregghc-lib-vreg was moved because its hreg was clobberedghc-lib!vreg was loaded from a spill slotghc-lib,reg-reg move inserted during join to targetsghc-lib,reg-mem move inserted during join to targetsghc-lib_Where a vreg is currently stored A temporary can be marked as living in both a register and memory (InBoth), for example if it was recently loaded from a spill location. This makes it cheap to spill (no save instruction required), but we have to be careful to turn this into InReg if the value in the register is changed.ghc-libvreg is in a registerghc-libvreg is held in a stack slotghc-lib0vreg is held in both a register and a stack slotghc-libUsed to store the register assignment on entry to a basic block. We use this to handle join points, where multiple branch instructions target a particular label. We have to insert fixup code to make the register assignments from the different sources match up.ghc-lib'Get the reg numbers stored in this Loc.Nonevghc-lib.Do register coalescing on this top level thingFor Reg -> Reg moves, if the first reg dies at the same time the second reg is born then the mov only serves to join live ranges. The two regs can be renamed to be the same and the move instruction safely erased.%vghc-lib|Add a v1 = v2 register renaming to the map. The register with the lowest lexical name is set as the canonical version.%wghc-libZDetermine the canonical name for a register by following v1 = v2 renamings in this map.ghc-lib?Slurp out mov instructions that only serve to join live ranges.During a mov, if the source reg dies and the destination reg is born then we can rename the two regs to the same thing and eliminate the move.None~ghc-libJBuild a map of how many times each reg was alloced, clobbered, loaded etc.ghc-lib+Count reg-reg moves remaining in this code.ghc-libPretty print some RegAllocStatsNone "ghc-lib"The register allocator monad type.ghc-lib7Run a computation in the RegM register allocator monad.%xghc-lib3Make register allocator stats from its final state.ghc-lib<Record that a spill instruction was inserted, for profiling.ghc-libRecord a created fixup blockNoneX # %yghc-libBlock membership in a loopghc-libMap of ghc-lib0Records the expected cost to spill some regster.ghc-libAn empty map of spill costs.ghc-libAdd two spill cost infos.ghc-libAdd two spill cost records.ghc-lib7Slurp out information used for determining spill costs.For each vreg, the number of times it was written to, read from, and the number of instructions it was live on entry to (lifetime)%zghc-lib-Take all the virtual registers from this set.ghc-lib&Choose a node to spill from this graph%{ghc-lib Chaitins spill cost function is:cost = sum loadCost * freq (u) + sum storeCost * freq (d) u <- uses (v) d <- defs (v)LThere are no loops in our code at the moment, so we can set the freq's to 1.If we don't have live range splitting then Chaitins function performs badly if we have lots of nested live ranges and very few registers.v1 v2 v3 def v1 . use v1 . def v2 . . def v3 . . . use v1 . . . use v3 . . . use v2 . . use v1 .defs uses degree cost v1: 1 3 3 1.5 v2: 1 2 3 1.0 v3: 1 1 3 0.666v3 has the lowest cost, but if we only have 2 hardregs and we insert spill code for v3 then this isn't going to improve the colorability of the graph.When compiling SHA1, which as very long basic blocks and some vregs with very long live ranges the allocator seems to try and spill from the inside out and eventually run out of stack slots.zWithout live range splitting, its's better to spill from the outside in so set the cost of very long live ranges to zeroghc-lib+Extract a map of register lifetimes from a .%|ghc-libUDetermine the degree (number of neighbors) of this node which have the same class.ghc-lib`Show a spill cost record, including the degree from the graph and final calulated spill cost.  None V%}ghc-libCleaner state.%~ghc-lib0Regs which are valid at the start of each block.%ghc-libCollecting up what regs were valid across each jump. in the next pass we can collate these and write the results to sJumpValid.%ghc-libMap of (slot -> blocks which reload from this slot) used to decide if whether slot spilled to will ever be reloaded from on this path.%ghc-lib6Spills and reloads cleaned each pass (latest at front)%ghc-lib>Spills and reloads that have been cleaned in this pass so far.%ghc-libCleaner monad.%ghc-libThe identification number of a spill slot. A value is stored in a spill slot when we don't have a free register to hold it.ghc-lib;Clean out unneeded spill/reloads from this top level thing.%ghc-libDo one pass of cleaning.%ghc-libOClean out unneeded reload instructions, while walking forward over the code.%ghc-lib'Clean out unneeded reload instructions.Walking forwards across the code On a reload, if we know a reg already has the same value as a slot then we don't need to do the reload.%ghc-lib?Try and rewrite a reload instruction to something more pleasing%ghc-libPClean out unneeded spill instructions, while walking backwards over the code.If there were no reloads from a slot between a spill and the last one then the slot was never read and we don't need the spill.SPILL r0 -> s1 RELOAD s1 -> r2 SPILL r3 -> s1 <--- don't need this spill SPILL r4 -> s1 RELOAD s1 -> r5WMaintain a set of "slots which were spilled to but not reloaded from yet"]Walking backwards across the code: a) On a reload from a slot, remove it from the set.a) On a spill from a slot If the slot is in set then we can erase the spill, because it won't be reloaded from until after the next spill.Cotherwise keep the spill and add the slot to the setnTODO: This is mostly inter-block we should really be updating the noReloads set as we cross jumps also..TODO: generate noReloads from liveSlotsOnEntry%ghc-lib@Combine the associations from all the inward control flow edges.%ghc-libOSee if we have a reg with the same value as this slot in the association table.%ghc-lib$Construct the initial cleaner state.%ghc-lib(Remember the associations before a jump.%ghc-libCheck if this is a reg store.%ghc-libAn empty association%ghc-lib,Add an association between these two things.%ghc-lib"Delete all associations to a node.%ghc-lib*Delete a single association edge (a -> b).%ghc-lib)Check if these two things are associated.%ghc-libAFind the refl. trans. closure of the association from this point.%ghc-libIntersect two associations.%ghc-lib!Iteration number for the cleaner.ghc-lib!Liveness annotated code to clean.%ghc-lib!the block that we're currently inghc-libCtwo store locations are associated if they have the same valueghc-libaccghc-lib$instrs to clean (in backwards order)ghc-lib$cleaned instrs (in forward order)%ghc-lib!Slots live on entry to each blockghc-lib3Slots that have been spilled, but not reloaded fromghc-libaccghc-lib#Instrs to clean (in forwards order)ghc-lib$Cleaned instrs (in backwards order)None xghc-lib<Spiller statistics. Tells us what registers were spilled.%ghc-libSpill code generator state.%ghc-lib)Unique supply for generating fresh vregs.%ghc-lib:Spilled vreg vs the number of times it was loaded, stored.%ghc-lib)State monad for the spill code generator.ghc-lib,Spill all these virtual regs to stack slots.5Bumps the number of required stack slots if required.TODO: See if we can split some of the live ranges instead of just globally spilling the virtual reg. This might make the spill cleaner's job easier.TODO: On CISCy x86 and x86_64 we don't necessarily have to add a mov instruction when making spills. If an instr is using a spilled virtual we may be able to address the spill slot directly.%ghc-lib9Spill some registers to stack slots in a top-level thing.%ghc-lib5Spill some registers to stack slots in a basic block.%ghc-libSpill some registers to stack slots in a single instruction. If the instruction uses registers that need to be spilled, then it is prefixed (or postfixed) with the appropriate RELOAD or SPILL meta instructions.%ghc-libqAdd a RELOAD met a instruction to load a value for an instruction that writes to a vreg that is being spilled.%ghc-libpAdd a SPILL meta instruction to store a value for an instruction that writes to a vreg that is being spilled.%ghc-lib}Add both RELOAD and SPILL meta instructions for an instruction that both reads and writes to a vreg that is being spilled.%ghc-libORewrite uses of this virtual reg in an instr to use a different virtual reg.%ghc-libCreate a new spiller state.%ghc-lib+Allocate a new unique in the spiller monad.ghc-lib:Add a spill/reload count to a stats record for a register.%ghc-lib2Extract spiller statistics from the spiller state.ghc-libthe codeghc-libavailable stack slotsghc-libcurrent number of spill slots.ghc-libthe regs to spill%ghc-lib/map of vregs to slots they're being spilled to.ghc-libthe top level thing.%ghc-lib/map of vregs to slots they're being spilled to.%ghc-lib/map of vregs to slots they're being spilled to.None }%ghc-libState Monad used inside exitifyghc-lib8Traverses the AST, simply to find all joinrecs and call exitify8 on them. The really interesting function is exitifyRec%ghc-libsGiven a recursive group of a joinrec, identifies exit paths  and binds them as join-points outside the joinrec.None ghc-libA renaming substitution from s to s. Like %4, but not maintaining pairs of substitutions. Like  CoreSubst.DE, but with the domain being s instead of entire CoreExpr.ghc-lib  emptySubst =  %ghc-libConstructs a new % assuming the variables in the given  are in scope.ghc-libSubstitutes an " for another one according to the + given in a way that avoids shadowing the ', returning the result and an updated 1 that should be used by subsequent substitutions.ghc-lib 4substBndrs = runState . traverse (state . substBndr)ghc-libPSubstitutes an occurrence of an identifier for its counterpart recorded in the .ghc-libPSubstitutes an occurrence of an identifier for its counterpart recorded in the X. Does not generate a debug warning if the identifier to to substitute wasn't in scope.ghc-libAdd the C to the in-scope set and remove any existing substitutions for it.ghc-libAdd a substitution for an  to the : you must ensure that the in-scope set is such that TyCORep Note [The substitution invariant] holds after extending the substitution like this.  None ,.2>HMV *ghc-libLike FG, but with an % instance that returns %.+ghc-lib,Used as a data type index for the stgSyn ASTBghc-libA top-level binding.Eghc-libzDoes this constructor application refer to anything in a different *Windows* DLL? If so, we can't allocate it staticallyFghc-lib Type of an StgArg8Very half baked because we have lost the type arguments.Gghc-lib2Strip ticks of a given type from an STG expressionHghc-libcGiven an alt type and whether the program is unarised, return whether the case binder is in scope.Case binders of unboxed tuple or unboxed sum type always dead after the unariser has run. See Note [Post-unarisation invariants].Ighc-libuUsed when constructing a term with an unused extension point that should not appear in pretty-printed output at all.%ghc-lib,Code gen needs to track non-global free vars0ghc-lib<Extension point for non-global free var list just before ..ghc-lib*CCS to be attached (default is CurrentCCS)ghc-lib |  | ghc-libJarguments; if empty, then not a function; as above, order is important.ghc-libbodyHghc-lib unarised? U      #$"!%&'()*+.,-/012;3456789:<=>?@ABCDEFGHIJKLMNOPU<=>BCD?@A2;3456789:/01% #$"!+.,-)('&*IM     KLJEFGHONPNone \\None>HVX %ghc-libhave we run the unariser yet?%ghc-lib\Top-level bindings can't inherit the cost centre stack from their (static) allocation site._ghc-libmodule being compiledghc-libhave we run Unarise yet?ghc-libwho produced the STG?__NoneHMV scghc-lib-The analysis monad consists of the following % components:i: Reader-like context. Contains a substitution, info about how how lifted identifiers are to be expanded into applications and details such as  I and a flag helping with determining if a lifted binding is caffy.% d.: Writer output for the resulting STG program.No pure state componentBut wrapping around %2 for generating fresh lifted binders. (The uniqAwaya approach could give the same name to two different lifted binders, so this is necessary.)dghc-lib]We need to detect when we are lifting something out of the RHS of a recursive binding (c.f. StgLiftLams.LiftM#floats), in which case that binding needs to be added to the same top-level recursive group. This requires we detect a certain nesting structure, which is encoded by e and f. Although qC will only ever care if the current binding to be lifted (through hz) will occur inside such a binding group or not, e.g. doesn't care about the nesting level as long as its greater than 0.ighc-lib)Environment threaded around in a scoped, Reader-like fashion.kghc-lib Read-only.lghc-lib(We need to track the renamings of local  s to their lifted  f, because shadowing might make a closure's free variables unavailable at its call sites. Consider: * let f y = x + y in let x = 4 in f x  Here, f9 can't be lifted to top-level, because its free variable x# isn't available at its call site.mghc-libLifted s don't occur as free variables in any closure anymore, because they are bound at the top-level. Every occurrence must supply the formerly free variables of the lifted o, so they in turn become free variables of the call sites. This environment tracks this expansion from lifted s to their free variables. s to  s. Invariant: /s not present in this map won't be substituted.nghc-lib[Are we currently analysing within a caffy context (e.g. the containing top-level binder's  is %P)? If not, we can safely assume that functions we lift out aren't caffy either.oghc-lib uncurry p . o = idqghc-libFlattens an expression in [d]U into an STG program, see #floats. Important pre-conditions: The nesting of opening StartBindinGroups and closing EndBindinGroups is balanced. Also, it is crucial that every binding group has at least one recursive binding inside. Otherwise there's no point in announcing the binding group in the first place and an ASSERT will trigger.%ghc-libNOmitting this makes for strange closure allocation schemes that crash the GC.sghc-libXAssumes a given caffyness for the execution of the passed action, which influences the % of lifted bindings.tghc-libWrites a plain D to the output.ughc-lib&Starts a recursive binding group. See floats and q.vghc-lib$Ends a recursive binding group. See floats and q.wghc-lib^Lifts a binding to top-level. Depending on whether it's declared inside a recursive RHS (see floats and qI), this might be added to an existing recursive top-level binding group.xghc-libxTakes a binder and a continuation which is called with the substituted binder. The continuation will be evaluated in a cD context in which that binder is deemed in scope. Think of it as a %Z computation: After the continuation finishes, the new binding won't be in scope anymore.yghc-libSee x.zghc-lib Similarly to x, this function takes a set of variables to abstract over, the binder to lift (and generate a fresh, substituted name for) and a continuation in which that fresh, lifted binder is in scope.vIt takes care of all the details involved with copying and adjusting the binder, fresh name generation and caffyness.{ghc-libSee z.|ghc-libSubstitutes a binder  occurrence), which was brought in scope earlier by !'withSubstBndr'\/'withLiftedBndr'.}ghc-lib:Whether the given binding was decided to be lambda lifted.~ghc-libReturns an empty list for a binding that was not lifted and the list of all local variables the binding abstracts over (so, exactly the additional arguments at adjusted call sites) otherwise.ghc-lib Creates an expander functionQ for the current set of lifted binders. This expander function will replace any   by their corresponding  c and, in addition, will expand any lifted binders by the former free variables it abstracts over.cdefghijklmnopqrstuvwxyz{|}~opijklmndefghqcrsuvtwxyz{|}~None ghc-lib@Annotates a top-level STG binding group with its free variables.ghc-lib1Annotates an STG binding with its free variables.%ghc-libKThis makes sure that only local, non-global free vars make it into the set.NoneHV M%ghc-lib.The CSE environment. See note [CseEnv Example]%ghc-libiThe main component of the environment is the trie that maps data constructor applications (with their   arguments) to an in-scope name that can be used instead. This name is always either a let-bound variable or a case binder.%ghc-lib_This substitution is applied to the code as we traverse it. Entries have one of two reasons:vThe input might have shadowing (see Note [Shadowing]), so we have to rename some binders as we traverse the tree.cIf we remove `let x = Con z` because `let y = Con z` is in scope, we note this here as x ! y.%ghc-libIf we come across a case expression case x as b of & with a trivial binder, we add b ! x to this. This map is *only* used when looking something up in the ce_conAppMap. See Note [Trivial case scrutinee]%ghc-libOThe third component is an in-scope set, to rename away any shadowing binders%ghc-libNote [CseEnv Example] ~~~~~~~~~~~~~~~~~~~~~ The following tables shows how the CseEnvironment changes as code is traversed, as well as the changes to that code.'InExpr OutExpr conAppMap subst in_scope %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -- empty {} {} case & as a of {Con x y -> case & as a of {Con x y -> -- Con x y ! a {} {a,x,y} let b = Con x y (removed) -- Con x y ! a b!a {a,x,y,b} let c = Bar a let c = Bar a -- Con x y ! a, Bar a ! c b!a {a,x,y,b,c} let c = some expression let c' = some expression -- Con x y ! a, Bar a ! c b!a, c!c', {a,x,y,b,c,c'} let d = Bar b (removed) -- Con x y ! a, Bar a ! c b!a, c!c', d!c {a,x,y,b,c,c',d} (a, b, c d) (a, a, c' c)%ghc-lib;This function short-cuts let-bindings that are now obsoleteNone"# ghc-libUsed in places where some invariant ensures that all these Ids are non-void; e.g. constructor field binders in case expressions. See Note [Post-unarisation invariants] in UnariseStg.ghc-libUsed in places where some invariant ensures that all these arguments are non-void; e.g. constructor arguments. See Note [Post-unarisation invariants] in UnariseStg.ghc-lib Convert from  to ..BBNone&'  ghc-lib@The current tick scope. We will assign this to generated blocks. ghc-libPlaces blocks generated by the given code into a fresh (sub-)scope. This will make sure that Cmm annotations in our scope will apply to the Cmm blocks generated therein - but not the other way around.ghc-libEGenerate code into a fresh tick (sub-)scope and gather generated code_E      !"#$%&'()*+_! "+#'%$(&)* E    None #%ghc-lib0lower bound (inclusive), upper bound (exclusive)%ghc-libUse signed comparisons4 k@BCOPQRSTUVWXYZ[\]`bcdeghpqr3456789:;<=>?@ABCDEFGH434?B@C;<=CDEFHG:9 k>[Zg]\`decbTQVOXRUPWSYrpq7865@ABhNone /Oghc-lib.The profiling header words in a static closurePghc-lib+Profiling header words in a dynamic closureQghc-lib1Initialise the profiling field of an update frameTghc-libpRecord the allocation of a closure. The CmmExpr is the cost centre stack to which to attribute the allocation.Ughc-libRecord the allocation of a closure (size is given by a CmmExpr) The size must be in words, because the allocation counter in a CCS counts in words.[ghc-libCalled when a closure is entered, marks the closure as having been "used". The closure is not an "inherently used" one. The closure is not IND2 because that is not considered for LDV profiling.IJKLMNOPQRSTUVWXYZ[\XJILMPTUOQVWNKYRS\[ZNone 0}]^^]None R-_ghc-libDoes a computation in the FCode monad, with a current environment and a list of local declarations. Returns the resulting list of declarations.%ghc-lib<Local declarations that are in scope during code generation.aghc-libAn environment of named things.bghc-lib:The environment contains variable definitions or blockids.cghc-libeHolds CmmLit(CmmLabel ..) which gives the label type, eg, RtsLabel, ForeignLabel, CmmLabel etc.dghc-lib!A function name from this packageeghc-libA blockid of some code or data.fghc-libOTakes the variable decarations and imports from the monad and makes an environment, which is looped back into the computation. In this way, we can have embedded declarations that scope over the whole procedure, and imports that scope over the entire module. Discards the local declaration contained within decl'gghc-lib+Get the current environment from the monad.hghc-lib+Get the current context name from the monadighc-lib Set context name for a sub-parse%ghc-libgAdd a new variable to the list of local declarations. The CmmExpr says where the value is stored.%ghc-lib2Add a new label to the list of local declarations.jghc-lib.Create a fresh local variable of a given type.kghc-libAllocate a fresh label.lghc-lib,Add add a local function to the environment.mghc-libAdd an imported foreign label to the list of local declarations. If this is done at the start of the module the declaration will scope over the whole module.nghc-libLookup the BlockId bound to the label with this name. If one hasn't been bound yet, create a fresh one based on the Unique of the name.oghc-lib]Lookup the location of a named variable. Unknown names are treated as if they had been 'import'ed from the runtime system. This saves us a lot of bother in the RTS sources, at the expense of deferring some errors to link time.pghc-lib1Lift an FCode computation into the CmmParse monadjghc-lib data typeghc-libname of variableghc-libregister holding the valuelghc-libname of the functionghc-libpackage of the current module _`abcdefghijklmnopqrstuvwxyz_`bcdeafgihjk lmnopqrstuvwxyzNone SSNone TNone Wghc-libstaticghc-lib updateableghc-lib updateableghc-lib!size of the full header, in bytesghc-libsize of the payload, in bytes!!None Y%ghc-lib(Precondition: argument expression is an %, and there is a  at the head of the % chain.Safe oghc-lib Stream m a b is a computation in some Monad m/ that delivers a sequence of elements of type a followed by a result of type b.!More concretely, a value of type  Stream m a b can be run using  runStream in the Monad m, and it delivers eitherthe final result: Left b, or Right (a,str), where a( is the next element in the stream, and str4 is a computation to get the rest of the stream.4Stream is itself a Monad, and provides an operation { that produces a new element of the stream. This makes it convenient to turn existing monadic computations into streams.The idea is that Stream is useful for making a monadic computation that produces values from time to time. This can be used for knitting together two complex monadic operations, so that the producer does not have to produce all its values before the consumer starts consuming them. We make the producer into a Stream, and the consumer pulls on the stream each time it wants a new value.ghc-libCTurn a Stream into an ordinary list, by demanding all the elements.ghc-libTurn a list into a #, by yielding each element in turn.ghc-lib&Apply a function to each element of a , lazilyghc-lib/Apply a monadic operation to each element of a , lazilyghc-libanalog of the list-based Z on Streams. This is a simple way to map over a Stream while carrying some state around.  None ;ghc-libThe Llvm monad. Wraps LlvmEnv state as well as the IO monad%ghc-lib LLVM version%ghc-lib Dynamic flags%ghc-lib Output buffer%ghc-libSupply of unique values%ghc-libSupply of fresh metadata IDs%ghc-libGlobal metadata nodes%ghc-lib"Global functions so far, with type%ghc-lib;Globals that we had to alias, see [Llvm Forward References]%ghc-lib'Pointers to be added to llvm.used (see cmmUsedLlvmGens)%ghc-lib!Local variables so far, with type%ghc-lib9Non-constant registers (alloca'd in the function prelude)ghc-libLLVM Version Numberghc-libAn unresolved Label.Labels are unresolved when we haven't yet determined if they are defined in the module we are currently compiling, or an external one.ghc-lib.Top level LLVM Data (globals and type aliases)ghc-libGUnresolved code. Of the form: (data label, data type, unresolved data)ghc-lib#Global registers live on proc entryghc-lib)Translate a basic CmmType to an LlvmType.ghc-lib*Translate a Cmm Float Width to a LlvmType.ghc-lib(Translate a Cmm Bit Width to a LlvmType.%ghc-libGHC Call Convention for LLVMghc-lib#Llvm Function type for Cmm functionghc-libLlvm Function signatureghc-libAlignment to use for functionsghc-lib Alignment to use for into tablesghc-libSection to use for a functionghc-libA Function's argumentsghc-libLlvm standard fun attributesghc-lib]Convert a list of types to a list of function parameters (each with no parameter attributes)ghc-lib Pointer widthghc-lib-The LLVM Version that is currently supported.%ghc-libBLifting of IO actions. Not exported, as we want to encapsulate IO.ghc-libGet initial Llvm environment.%ghc-libGet environment (internal)%ghc-libModify environment (internal)ghc-lib"Lift a stream into the LlvmM monadghc-lib9Clear variables from the environment for a subcomputationghc-lib3Insert variables or functions into the environment.ghc-lib3Insert variables or functions into the environment.ghc-lib1Lookup variables or functions in the environment.ghc-lib1Lookup variables or functions in the environment.ghc-lib(Set a register as allocated on the stackghc-lib2Check whether a register is allocated on the stackghc-lib1Allocate a new global unnamed metadata identifierghc-lib/Get the LLVM version we are generating code forghc-lib+Get the platform we are generating code forghc-lib+Get the platform we are generating code forghc-libEDumps the document if the corresponding flag has been set by the userghc-lib.Prints the given contents to the output handleghc-libMarks a variable as "used"ghc-lib,Return all variables marked as "used" so far%ghc-libsSaves that at some point we didn't know the type of the label and generated a reference to a type variable insteadghc-lib%Sets metadata node for a given uniqueghc-lib#Gets metadata node for given uniqueghc-lib Here we pre-initialise some functions that are used internally by GHC so as to make sure they have the most general type in the case that user code also uses these functions but with a different type than GHC internally. (Main offender is treating return type as void) instead of 'void *'). Fixes trac #5486.ghc-libPretty print a  .ghc-libCreate/get a pointer to a global value. Might return an alias if the value in question hasn't been defined yet. We especially make no guarantees on the type of the returned pointer.ghc-lib7Generate definitions for aliases forward-referenced by  getGlobalPtr.fMust be called at a point where we are sure that no new global definitions will be generated anymore!ghc-lib=Here we take a global variable definition, rename it with a $def, suffix, and generate the appropriate alias.22None <%ghc-libIThe string appended to a variable name to create its structure type alias ghc-lib4Pass a CmmStatic section to an equivalent Llvm code.%ghc-lib-Format the section type part of a Cmm Section%ghc-lib-Format a Cmm Section into a LLVM section name ghc-libHandle static data%ghc-lib(Generate Llvm code for a static literal.@Will either generate the code or leave it unresolved if it is a   which isn't yet known.    None ghc-libPretty print LLVM data codeghc-libPretty print LLVM codeghc-libThe section we are putting info tables and their entry code into, should be unique since we process the assembly pattern matching this.None&' B:%ghc-libGA more convenient way of accumulating LLVM statements and declarations.%ghc-libValues which can be passed to %6 to configure its behaviour in certain circumstances.Currently just used for determining if a comparison should return a boolean (i1) or a word. See Note [Literals and branch conditions].%ghc-libAn expression conversion return data: * LlvmVar: The var holding the result of the expression * LlvmStatements: Any statements needed to evaluate the expression * LlvmCmmDecl: Any global data needed for this expressionghc-lib)Top-level of the LLVM proc Code generator%ghc-libGenerate code for a list of blocks that make up a complete procedure. The first block in the list is expected to be the entry point and will get the prologue.%ghc-libGenerate code for one block%ghc-lib.Convert a list of CmmNode's to LlvmStatement's%ghc-lib.Convert a CmmStmt to a list of LlvmStatement's%ghc-libBWrapper function to declare an instrinct function by function type%ghc-lib<Declares an instrinct function by return and parameter types%ghc-lib*Memory barrier instruction for LLVM >= 3.0%ghc-lib Foreign Calls%ghc-libLGenerate a call to an LLVM intrinsic that performs arithmetic operation with overflow bit (i.e., returns a struct containing the actual result of the operation and an overflow bit). This function will also extract the overflow bit and zero-extend it (all the corresponding Cmm PrimOps represent the overflow "bit" as a usual Int or Word).%ghc-libA helper function for genCallWithOverflow that handles generating the call to the LLVM intrinsic and extracting the result from the struct to LlvmVars.%ghc-lib(Create a function pointer from a target.%ghc-lib(Create a function pointer from a target.%ghc-libConversion of call arguments.%ghc-libConversion of call arguments.%ghc-lib6Cast a collection of LLVM variables to specific types.%ghc-lib6Cast a collection of LLVM variables to specific types.%ghc-libGCast an LLVM variable to a specific type, panicing if it can't be done.%ghc-lib:Decide what C function to use to implement a CallishMachOp%ghc-libTail function calls%ghc-libCmmAssign operationlWe use stack allocated variables for CmmReg. The optimiser will replace these with registers when possible.%ghc-libCmmStore operation%ghc-libnCmmStore operation This is a special case for storing to a global register pointer offset such as I32[Sp+8].%ghc-libNCmmStore operation Generic case. Uses casts and pointer arithmetic if needed.%ghc-libUnconditional branch%ghc-libConditional branch%ghc-libHGenerate call to llvm.expect.x intrinsic. Assigning result to a new var.%ghc-lib Switch branch%ghc-lib'i1 type expected (condition scrutinee).%ghc-libWord type expected (usual).%ghc-libvConvert a CmmExpr to a list of LlvmStatements with the result of the expression being stored in the returned LlvmVar.%ghc-libHandle CmmMachOp expressions%ghc-libHandle CmmMachOp expressions This is a specialised method that handles Global register manipulations like 'Sp - 16', using the getelementptr instruction.%ghc-libfHandle CmmMachOp expressions This handles all the cases not handle by the specialised genMachOp_fast.%ghc-libHandle CmmLoad expression.%ghc-libxHandle CmmLoad expression. This is a special case for loading from a global register pointer offset such as I32[Sp+8].%ghc-libWHandle Cmm load expression. Generic case. Uses casts and pointer arithmetic if needed.%ghc-libHandle CmmReg expression. This will return a pointer to the stack location of the register. Throws an error if it isn't allocated on the stack.&ghc-lib]Return the value of a given register, as well as its type. Might need to be load from stack.&ghc-lib$Allocate a local CmmReg on the stack&ghc-libGenerate code for a literal&ghc-lib=Find CmmRegs that get assigned and allocate them on the stackAny register that gets written needs to be allcoated on the stack. This avoids having to map a CmmReg to an equivalent SSA form and avoids having to deal with Phi node insertion. This is also the approach recommended by LLVM developers.On the other hand, this is unnecessarily verbose if the register in question is never written. Therefore we skip it where we can to save a few lines in the output and hopefully speed compilation up a bit.&ghc-libhFunction epilogue. Load STG variables to use as argument for call. STG Liveness optimisation done here.&ghc-lib6A series of statements to trash all the STG registers.In LLVM we pass the STG registers around everywhere in function calls. So this means LLVM considers them live across the entire function, when in reality they usually aren't. For Caller save registers across C calls the saving and restoring of them is done by the Cmm code generator, using Cmm local vars. So to stop LLVM saving them as well (and saving all of them since it thinks they're always live, we trash them just before the call by assigning the undefy value to them. The ones we need are restored from the Cmm local var and the ones we don't need are fine to be trashed.&ghc-lib/Get a function pointer to the CLabel specified.aThis is for Haskell functions, function type is assumed, so doesn't work with foreign functions.&ghc-libCreate a new local var&ghc-lib0Execute an expression, assigning result to a var& ghc-libExpand CmmRegOff& ghc-lib0Convert a block id into a appropriate Llvm label& ghc-libCreate Llvm int Literal& ghc-lib1Convert int type to a LLvmVar of word or i32 size& ghc-libError functions&ghc-lib Returns TBAA meta data by unique&ghc-lib)Returns TBAA meta data for given register&ghc-lib'Return element of single-element list; & % if list is not a single-element list%ghc-libPrimOpghc-libWidth of the operands.ghc-libActual arguments.ghc-lib"LLVM types of the returned struct.None M&ghc-libBIs the SRT offset field inline in the info table on this platform?bSee the section "Referring to an SRT from the info table" in Note [SRTs] in CmmBuildInfoTables.hsghc-libAValue of the srt field of an info table when using an StgLargeSRT&ghc-libWrap a  7 in an alignment check when -falignment-sanitisation is enabled.&ghc-libWReturns: 1. The bitmap (literal value or label) 2. Large bitmap CmmData if needed !"#$%&'()*+,-./0 !"#$%&'()*+0,-./None +1ghc-libUsed to tell the various mkVirtHeapOffsetss functions what kind of header the object has. This will be accounted for in the offsets of the fields returned.8ghc-lib$Return multiple values to the sequelIf the sequel is Return  return (x,y)If the sequel is AssignTo [p,q]  p=x; q=y;9ghc-libemitCall conv fun args# makes a call to the entry-code of fun$, using the call/return convention conv , passing args3, and returning the results to the current sequel.&ghc-lib*emitCallWithExtraStack conv fun args stack$ makes a call to the entry-code of fun#, using the call/return convention conv , passing args0, pushing some extra stack frames described by stack2, and returning the results to the current sequel.&ghc-lib& takes a list of function arguments and prepares them for pushing on the stack for "extra" arguments to a function which requires fewer arguments than we currently have.@ghc-lib1Just like mkVirtHeapOffsets, but for constructorsAghc-libJust like mkVirtConstrOffsets, but used when we don't have the actual arguments. Useful when e.g. generating info tables; we just need to know sizes of pointer and non-pointer fields. 123457689:;<=>?@ABCD B98:CD<;5761234?>@A=None.HV Y Eghc-lib%The type used in binder positions in 2s.Fghc-lib~Let(-no-escape)-bound thing with a flag indicating whether it occurs as an argument or in a nullary application (see StgLiftLams.Analysis#arg_occs).Gghc-libEvery other kind of binderHghc-lib{Captures details of the syntax tree relevant to the cost model, such as closures, multi-shot lambdas and case expressions.Nghc-libGets the bound  out a E.&ghc-libReturns $ for Gs and &U the flag indicating occurrences as argument or in a nullary applications otherwise.Oghc-libTags every binder with its E and let bindings with their Hs.&ghc-libTags binders of an  with its E and let bindings with their Hs. Additionally, returns its HW and the set of binder occurrences in argument and nullary application position (cf. StgLiftLams.Analysis#arg_occs).&ghc-libHow many times will the lambda body of the RHS bound to the given identifier be evaluated, relative to its defining context? This function computes the answer in form of a &.Pghc-libFCombines several heuristics to decide whether to lambda-lift a given let-binding to top-level. See StgLiftLams.Analysis#when for details.&ghc-lib?The size in words of a function closure closing over the given s, including the header.&ghc-libThe number of words a single  adds to a closure's size. Note that this can't handle unboxed tuples (which may still be present in let-no-escapes, even after Unarise), in which case  will crash.Qghc-lib"closureGrowth expander sizer f fvs> computes the closure growth in words as a result of lifting f_ to top-level. If there was any growing closure under a multi-shot lambda, the result will be  . Also see StgLiftLams.Analysis#clogro.Ighc-lib free vars Jghc-libhow often the RHS was entered &ghc-libIs the binding a let-no-escape?ghc-libLet bodyghc-lib Binding groupghc-lib9RHS skeletons, argument occurrences and annotated binding&ghc-libIs the binding a let-no-escape?ghc-libLet body skeletonghc-lib Argument occurrences in the bodyghc-lib Binding groupghc-libZLet skeleton, argument occurrences, scope skeleton of binding and the annotated bindingPghc-libAn expander function, turning  s into  s. See H.ghc-lib Just abs_ids  =) This binding is beneficial to lift and abs_ids* are the variables it would abstract overQghc-lib:Expands outer free ids that were lifted to their free varsghc-lib/Computes the closure footprint of an identifierghc-lib0Binding group for which lifting is to be decidedghc-libFree vars of the whole binding group prior to lifting it. These must be available at call sites if we decide to lift the binding group.ghc-lib(Abstraction of the scope of the functionghc-libClosure growth. ; indicates there was growth under a (multi-shot) lambda.EFGHIJKLMNOPQHIJKLMEFGNOPQNone ]Ughc-lib=Lambda lifts bindings to top-level deemed worth lifting (see P).&ghc-libJust former_fvs  =( this RHS was lifted and we have to add  former_fvs. as lambda binders, discarding all free vars.UUINone ]UUNone cXghc-lib!Low-level heap object allocation.]ghc-lib lower-level version for CmmParse& ghc-lib/The generic GC procedure; no params, no results&!ghc-lib;Create a CLabel for calling a garbage collector entry pointXghc-librepresentation of the objectghc-lib info pointerghc-lib cost centreghc-libpayloadghc-lib!returns the address of the object=VWXYZ[\]^_`a=\^`_a]Z[VWXYNone "#&'MP\ a&"ghc-libMaps labels from eT to the final CLabel that will appear in the SRT. - closures with singleton SRTs resolve to their single entry - closures with larger SRTs map to the label for that SRT - CAFs must not map to anything! - if a labels maps to Nothing, we found that this label's SRT is empty, so we don't need to refer to it from other SRTs.&#ghc-libACurrent module being compiled. Required for calling labelDynamic.&$ghc-libbprevious SRTs we've emitted, so we can de-duplicate. Used to implement the [Common] optimisation.&%ghc-libThe reverse mapping, so that we can remove redundant entries. e.g. if we have an SRT [a,b,c], and we know that b points to [c,d], we can omit c and emit [a,b]. Used to implement the [Filter] optimisation.eghc-libFor each code block: - collect the references reachable from this code block to FUN, THUNK or RET labels for which hasCAF == TrueThis gives us a c-: a mapping from code block to sets of labels&&ghc-libReturn a (Label,CLabel) pair for each labelled block of a CmmDecl, where the label is - the info label for a continuation or dynamic closure - the closure label for a top-level function (not a CAF)&'ghc-libPut the labelled blocks that we will be annotating with SRTs into dependency order. This is so that we can process them one at a time, resolving references to earlier blocks to point to their SRTs. CAFs themselves are not included here; see getCAFs below.&(ghc-libGet (Label, CAFLabel, Set CAFLabel) for each block that represents a CAF. These are treated differently from other labelled blocks: - we never shortcut a reference to a CAF to the contents of its SRT, since the point of SRTs is to keep CAFs alive. - CAFs therefore don't take part in the dependency analysis in depAnalSRTs. instead we generate their SRTs after everything else.&)ghc-libGet the list of blocks that correspond to the entry points for FUN_STATIC closures. These are the blocks for which if we have an SRT we can merge it with the static closure. [FUN]&*ghc-lib3resolve a CAFLabel to its SRTEntry using the SRTMapgghc-lib_Attach SRTs to all info tables in the CmmDecls, and add SRT declarations to the ModuleSRTInfo.&+ghc-lib:Build the SRT for a strongly-connected component of blocks&,ghc-lib Build an SRT for a set of blocks&-ghc-libMbuild a static SRT object (or a chain of objects) from a list of SRTEntries.&.ghc-libvUpdate info tables with references to their SRTs. Also generate static closures, splicing in SRT fields as necessary.bcdefgdcegbfNone Soghc-libCemit code for a foreign call, and return the results to the sequel.tghc-lib1Produce code to save the current thread state to  CurrentTSO&/ghc-libcloseNursery dflags tsoK produces code to close the nursery. A local register holding the value of  CurrentTSO is expected for efficiency.6Closing the nursery corresponds to the following code:  tso = CurrentTSO; cn = CurrentNuresry; // Update the allocation limit for the current thread. We don't // check to see whether it has overflowed at this point, that check is // made when we run out of space in the current heap block (stg_gc_noregs) // and in the scheduler when context switching (schedulePostRunThread). tso->alloc_limit -= Hp + WDS(1) - cn->start; // Set cn->free to the next unoccupied word in the block cn->free = Hp + WDS(1); wghc-lib3Produce code to load the current thread state from  CurrentTSO&0ghc-libopenNursery dflags tsoJ produces code to open the nursery. A local register holding the value of  CurrentTSO is expected for efficiency.6Opening the nursery corresponds to the following code:  tso = CurrentTSO; cn = CurrentNursery; bdfree = CurrentNursery->free; bdstart = CurrentNursery->start; // We *add* the currently occupied portion of the nursery block to // the allocation limit, because we will subtract it again in // closeNursery. tso->alloc_limit += bdfree - bdstart; // Set Hp to the last occupied word of the heap block. Why not the // next unocupied word? Doing it this way means that we get to use // an offset of zero more often, which might lead to slightly smaller // code on some architectures. Hp = bdfree - WDS(1); // Set HpLim to the end of the current nursery block (note that this block // might be a block group, consisting of several adjacent blocks. HpLim = bdstart + CurrentNursery->blocks*BLOCK_SIZE_W - 1; opqrstuvwx oqprstvwxuNone &1ghc-libtInterpret the argument as an unsigned value, assuming the value is given in two-complement form in the given width. Example: asUnsigned W64 (-1) is 18446744073709551615.This function is used to work around the fact that many array primops take Int# arguments, but we interpret them as unsigned quantities in the code gen. This means that we have to be careful every time we work on e.g. a CmmInt literal that corresponds to the array size, as it might contain a negative Integer value if the user passed a value larger than 2^(wORD_SIZE_IN_BITS-1) as the Int# literal.zghc-libDecide whether an out-of-line primop should be replaced by an inline implementation. This might happen e.g. if there's enough static information, such as statically know arguments, to emit a more efficient implementation inline.Returns $S if this primop should use its out-of-line implementation (defined elsewhere) and &^ together with a code generating function that takes the output regs as arguments otherwise.&2ghc-lib1Implements branchless recovery of the carry flag c/ by checking the leftmost bits of both inputs a and b and result  r = a + b:  c = a&b | (a|b)&~r  Ehttps://brodowsky.it-sky.net/2015/04/02/how-to-recover-the-carry-bit/&3ghc-lib1Implements branchless recovery of the carry flag c/ by checking the leftmost bits of both inputs a and b and result  r = a - b:  c = ~a&b | (~a|b)&r  Ehttps://brodowsky.it-sky.net/2015/04/02/how-to-recover-the-carry-bit/&4ghc-lib?Translate byte array prefetch operations into proper primcalls.&5ghc-libGTranslate mutable byte array prefetch operations into proper primcalls.&6ghc-lib<Translate address prefetch operations into proper primcalls.&7ghc-lib:Translate value prefetch operations into proper primcalls.&8ghc-lib%helper to generate prefetch primcalls&9ghc-librTakes a register to return the newly allocated array in and the size of the new array in bytes. Allocates a new 'MutableByteArray#'.&:ghc-libTakes a source  'ByteArray#'0, an offset in the source array, a destination 'MutableByteArray#', an offset into the destination array, and the number of bytes to copy. Copies the given number of bytes from the source array to the destination array.&;ghc-libTakes a source 'MutableByteArray#'0, an offset in the source array, a destination 'MutableByteArray#', an offset into the destination array, and the number of bytes to copy. Copies the given number of bytes from the source array to the destination array.&<ghc-libTakes a source  'ByteArray#'0, an offset in the source array, a destination 'Addr#'}, and the number of bytes to copy. Copies the given number of bytes from the source array to the destination memory region.&=ghc-libTakes a source 'MutableByteArray#'0, an offset in the source array, a destination 'Addr#'}, and the number of bytes to copy. Copies the given number of bytes from the source array to the destination memory region.&>ghc-libTakes a source 'Addr#', a destination 'MutableByteArray#', an offset into the destination array, and the number of bytes to copy. Copies the given number of bytes from the source memory region to the destination array.&?ghc-libTakes a 'MutableByteArray#'v, an offset into the array, a length, and a byte, and sets each of the selected bytes in the array to the character.&@ghc-libAllocate a new array.&Aghc-libTakes a source 'Array#'0, an offset in the source array, a destination 'MutableArray#', an offset into the destination array, and the number of elements to copy. Copies the given number of elements from the source array to the destination array.&Bghc-libTakes a source 'MutableArray#'0, an offset in the source array, a destination 'MutableArray#', an offset into the destination array, and the number of elements to copy. Copies the given number of elements from the source array to the destination array.&Cghc-libTakes an info table label, a register to return the newly allocated array in, a source array, an offset in the source array, and the number of elements to copy. Allocates a new array and initializes it from the source array.&Dghc-libTakes an info table label, a register to return the newly allocated array in, a source array, an offset in the source array, and the number of elements to copy. Allocates a new array and initializes it from the source array.&Eghc-libTakes and offset in the destination array, the base address of the card table, and the number of elements affected (*not* the number of cards). The number of elements may not be zero. Marks the relevant cards as dirty.&Fghc-libEmit an atomic modification to a byte array element. The result reg contains that previous value of the element. Implies a full memory barrier.&Gghc-libBEmit an atomic read to a byte array that acts as a memory barrier.&Hghc-libCEmit an atomic write to a byte array that acts as a memory barrier.&Ighc-libEmit a call to memcpy.&Jghc-libEmit a call to memmove.&Kghc-libEmit a call to memset9. The second argument must fit inside an unsigned char.zghc-lib The primopghc-libThe primop arguments&@ghc-libreturn registerghc-librepresentation of the arrayghc-lib info pointerghc-libheader payloadghc-lib array sizeghc-libinitial element&Lghc-lib copy functionghc-lib source arrayghc-liboffset in source arrayghc-libdestination arrayghc-liboffset in destination arrayghc-libnumber of elements to copy&Mghc-lib copy functionghc-lib source arrayghc-liboffset in source arrayghc-libdestination arrayghc-liboffset in destination arrayghc-libnumber of elements to copy&Fghc-lib Result regghc-libAtomic op (e.g. add)ghc-libMutableByteArray#ghc-libIndexghc-lib(Type of element by which we are indexingghc-lib Op argument (e.g. amount to add)&Gghc-lib Result regghc-libMutableByteArray#ghc-libIndexghc-lib(Type of element by which we are indexing&Hghc-libMutableByteArray#ghc-libIndexghc-lib(Type of element by which we are indexingghc-libValue to write&Nghc-lib Result regghc-libMutableByteArray#ghc-libIndexghc-lib(Type of element by which we are indexingghc-lib Old valueghc-lib New valueyz{y{zNoneFX o||NoneF G}~G}~!None"#F ghc-libbFinds external references. Remember to remove the names defined by this group of BCOs themselvesNone"#FM &Oghc-libcMaps Ids to their stack depth. This allows us to avoid having to mess with it after each push/pop.&Pghc-libePush an atom for constructor (i.e., PACK instruction) onto the stack. This is slightly different to pushAtomE due to the fact that we allow packing constructor fields. See also  mkConAppCode and  pushPadding.&Qghc-lib/Indicate if the calling convention is supported&Rghc-lib]Let szsw be the sizes in bytes of some items pushed onto the stack, which has initial depth original_depthL. Return the values which the stack environment should map these items to.EENone"&' )  None"#&' 4 &Sghc-lib>the offset of Sp relative to the base on entry to this block.&Tghc-libthe number of bytes of arguments in the area for this block Defn: the offset of young(L) relative to the base is given by (sm_sp - sm_args) of the StackMap for block L.&Ughc-libjNumber of words of stack that we do not describe with an info table, because it contains an update frame.&Vghc-libregs on the stack&Wghc-libXcreate a sequence of assignments to establish the new StackMap, given the old StackMap.&Xghc-libGiven a set of live registers and a StackMap, save all the registers on the stack and return the new StackMap and the assignments to do the saving.&Yghc-lib[Manifest Sp: turn all the CmmStackSlots into CmmLoads from Sp. The block looks like this:zmiddle_pre -- the middle nodes Sp = Sp + sp_off -- Sp adjustment goes here last -- the last nodeEAnd we have some extra blocks too (that don't contain Sp adjustments)qThe adjustment for middle_pre will be different from that for middle_post, because the Sp adjustment intervenes.&Zghc-lib,Determine whether a stack check cannot fail.&[ghc-libEliminate stores of the formSp[area+n] = r when we know that r is already in the same slot as Sp[area+n]. We could do this in a later optimisation pass, but that would involve a separate analysis and we already have the information to hand here. It helps clean up some extra stack stores in common cases.Note that we may have to modify the StackMap as we walk through the code using procMiddle, since an assignment to a variable in the StackMap will invalidate its mapping there.None 5ghc-lib!Top level driver for C-- pipelineNone Aghc-lib Version of &System.Process.readProcessWithExitCode> that takes a key-value tuple to insert into the environment.ghc-libBRun a command, placing the arguments in an external response file.This command is used in order to avoid overlong command line arguments on Windows. The command line arguments are first written to an external, temporary response file, and then passed to the linker via @filepath. response files for passing them in. See: 'https://gcc.gnu.org/wiki/Response_Files /https://gitlab.haskell.org/ghc/ghc/issues/10777ghc-libstdoutghc-lib program pathghc-lib program argsghc-libaddition to the environmentghc-lib(exit_code, stdout, stderr)NoneX A  NoneX Gghc-lib8Run the linker with some arguments and return the outputghc-libRun the LLVM Optimiserghc-libRun the LLVM Compilerghc-lib~Run the clang compiler (used as an assembler for the LLVM backend on OS X as LLVM doesn't support the OS X system assembler)ghc-lib<Figure out which version of LLVM we are running this session        None I` ghc-libReturn the "link info" stringSee Note [LinkInfo section]  !"#$% $ "#!% NoneX` Lw+ghc-lib7Some platforms require that we explicitly link against libmV if any math-y things are used (which we assume to include all programs). See #14022.$     &'()*+,- '&*()+,-None%HV U.ghc-lib$Top-level of the LLVM Code generator&\ghc-lib8Do LLVM code generation on all these Cmms data sections.&]ghc-libLLVM can't handle entry blocks which loop back to themselves (could be seen as an LLVM bug) so we rearrange the code to keep the original entry label which branches to a newly generated second label that branches back to itself. See: #11649&^ghc-libHComplete LLVM code generation phase for a single top-level chunk of Cmm.&_ghc-libGenerate meta data nodes&`ghc-lib'Marks variables as used where necessary .. None V/0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDE/0123456789:;<=>?@ABCDEFGHIJKLMNOQRSTUVPWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFSGHIJKLMNOPQRTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDENone gGHGHNone"#%=?X )^ghc-libEnvironments which track &a`ghc-lib*Setup the initial typechecking environmentaghc-libRun a &b& action in the context of an existing GblEnv.wghc-libDo it flag is trueghc-libXUpdate the external package state. Returns the second result of the modifier function.eThis is an atomic operation and forces evaluation of the modified EPS in order to avoid space leaks.ghc-lib"Update the external package state.eThis is an atomic operation and forces evaluation of the modified EPS in order to avoid space leaks.ghc-lib"A convenient wrapper for taking a MaybeErr MsgDoc a. and throwing an exception if it is an error.&cghc-lib3Trace when a certain flag is enabled. This is like J but accepts a string as a label and formats the trace message uniformly.ghc-libOutput a doc if the given &d is set.0By default this logs to stdout However, if the `-ddump-to-file`3 flag is set, then this will dump output to a fileJust a wrapper for &eghc-libA wrapper around  which uses PprDump style.ghc-libA wrapper around  which uses PprUser style.ghc-lib&Unconditionally dump some trace outputThe DumpFlag is used only to set the output filename for --dump-to-file, not to decide whether or not to output That part is done by the callerghc-lib*Like logInfoTcRn, but for user consumptionghc-libRAdd a fixed message to the error context. This message should not do any tidying.ghc-lib@Add a message to the error context. This message may do tidying.ghc-libAdd a fixed landmark message to the error context. A landmark message is always sure to be reported, even if there is a lot of context. It also doesn't count toward the maximum number of contexts reported.ghc-lib Variant of 1 that allows for monadic operations and tidying.ghc-lib_Drop elements of the input that fail, so the result list can be shorter than the argument listghc-libApply the function to all elements on the input list If all succeed, return the list of results Othewise fail, propagating all errorsghc-lib2The accumulator is not updated if the action failsghc-libFDisplay a warning if a condition is met, and the warning is enabledghc-lib(Display a warning if a condition is met.ghc-lib(Display a warning if a condition is met.ghc-lib(Display a warning if a condition is met.ghc-lib)Display a warning in the current context.ghc-lib%Display a warning in a given context.ghc-lib2Display a warning for the current source location.ghc-lib.Display a warning for a given source location.ghc-libKDisplay a warning, with an optional flag, for the current source location.&fghc-lib?Display a warning, with an optional flag, for a given location.ghc-libCreates an EvBindsVar incapable of holding any bindings. It still tracks covar usages (see comments on ebv_tcvs in TcEvidence), thus must be made monadicallyghc-lib5Throw out any constraints emitted by the thing_insideghc-libBThe name says it all. The returned TcLevel is the *inner* TcLevel.ghc-libWhen generating an out-of-scope error message for a variable matching a binding in a later inter-splice group, the typechecker uses the splice locations to provide details in the message about the scope of that binding.ghc-libjAdds the given modFinalizers to the global environment and set them to use the current local environment.ghc-libMark that safe inference has failed See Note [Safe Haskell Overlapping Instances Implementation] although this is used for more than just that failure case.ghc-lib.Figure out the final correct safe haskell modeghc-lib9Switch instances to safe instances if we're in Safe mode.!ghc-libRun an &g= (top-level interface monad) computation inside an existing &h; (typecheck-renaming monad) computation by initializing an &i based on &j.%ghc-lib.Initialize interface typechecking, but with a s' to apply when typechecking top-level s (see lookupIfaceTop)+ghc-lib<Get the next cost centre index associated with a given name.;&k&l &m&n&o &p&q&r&sgh&t&u&v&w&x&y&z&{&|&}&~&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&i&j&k&&&&&&&&&&&&&&&lm&&&&&&n&''''''srqpo'&h'&g't' &b' ' ' ' ''&i''''''''''''''''' '!'"'#'$'%'&'''(')'*'+uxwv','-&j'.'/'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'oyz'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({(|(}(~(((((((((((((((((^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+`abcdefghijklmnopqrstuvwxyz{|}~      !#$%"&'()*^_+NoneP` c=ghc-lib Create a new ' '.@ghc-libBEmits a new Wanted. Deals with both equalities and non-equalities.Bghc-libEmits a new equality constraintCghc-libWCreates a new EvVar and immediately emits it as a Wanted. No equality predicates here.Gghc-libPut a value in a coercion holeHghc-libIs a coercion hole filled in?Ighc-libIRetrieve the contents of a coercion hole. Panics if the hole is unfilledJghc-lib9Retrieve the contents of a coercion hole, if it is filledKghc-libCheck that a coercion is appropriate for filling a hole. (The hole itself is needed only for printing. Always returns the checked coercion, but this return value is necessary so that the input coercion is forced only when the output is forced.Lghc-libMake an . suitable for inferring a type of kind * or #.Oghc-libExtract a type out of an ExpType, if one exists. But one should always exist. Unless you're quite sure you know what you're doing.Pghc-lib4Extract a type out of an ExpType. Otherwise, panics.Qghc-lib0Returns the expected type when in checking mode.Rghc-libNReturns the expected type when in checking mode. Panics if in inference mode.Sghc-lib[Turn a (Infer hole) type into a (Check alpha), where alpha is a fresh unification variableTghc-libUExtracts the expected type if there is one, or generates a new TauTv if there isn't.Yghc-libGiven a list of [], skolemize the type variables, returning a substitution mapping the original tyvars to the skolems, and the list of newly bound skolems.]ghc-libGive fresh uniques to a bunch of TyVars, but they stay as TyVars, rather than becoming TcTyVars Used in FamInst.newFamInst, and Inst.newClsInst^ghc-libCGive fresh uniques to a bunch of CoVars Used in FamInst.newFamInstpghc-libxCreate a tyvar that can be a lifted or unlifted type. Returns alpha :: TYPE kappa, where both alpha and kappa are freshyghc-lib@Gathers free variables to use as quantification candidates (in ~). This might output the same var in both sets, if it's used in both a type and a kind. See Note [CandidatesQTvs determinism and order] See Note [Dependent type variables]zghc-libLike splitDepVarsOfType, but over a list of types{ghc-libLike y, but consider every free variable to be dependent. This is appropriate when generalizing a *kind*, instead of a type. (That way, -XNoPolyKinds will default the variables to Type.)ghc-libtcGetGlobalTyCoVars returns a fully-zonked set of *scoped* tyvars free in the environment. To improve subsequent calls to the same function it writes the zonked set back into the environment. Note that this returns all variables free in anything (term-level or type-level) in scope. We thus don't have to worry about clashes with things that are not in scope, because if they are reachable, then they'll be returned here. NB: This is closed over kinds, so it can return unification variables mentioned in the kinds of in-scope tyvars.(ghc-libbA suitable TyCoMapper for zonking a type during type-checking, before all metavars are filled in.ghc-libZonk: a coercion -- really, just zonk any types in the coercionghc-lib@According to the rules around representation polymorphism (see  6https://gitlab.haskell.org/ghc/ghc/wikis/no-sub-kinds), no binder can have a representation-polymorphic type. This check ensures that we respect this rule. It is a bit regrettable that this error occurs in zonking, after which we should have reported all errors. But it's hard to see where else to do it, because this can be discovered only after all solving is done. And, perhaps most importantly, this isn't really a compositional property of a type system, so it's not a terrible surprise that the check has to go in an awkward spot.Vghc-lib%How to instantiate the type variablesghc-libType to instantiateghc-lib1Result (type vars, preds (incl equalities), rho)| 23456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~|lmnpo78wecbfjkdghi NMLPOTQRSU:9E;<=>?@BCDAFGHIJKqsrtu`a_vVYZ\WX[]^y{z|23456}x~None ghc-libGCalled from the typechecker (TcErrors) when we find an unbound variable(ghc-libIGenerate helpful suggestions if a qualified name Mod.foo is not in scope.  NoneSX `ghc-libA function that atomically updates the name cache given a modifier function. The second result of the modifier function will be the result of the IO action.ghc-lib Look up the  for a given  and  . Consider alternatively using  if you're in the ' monad and  is simply that of the  you are typechecking.ghc-libSet the  of a .ghc-lib6Look up a top-level name from the current Iface modulevwwv None ,-(ghc-libSubstitution on {A.T}&. We enforce the invariant that the  of keys of this map have  hole (meaning that if we have a hole substitution, the keys of the map are never affected.) Alternatively, this is isomorphic to Map (, ) .ghc-libCreate an empty si (i.e., the renaming that would occur with an implementing module with no exports) for a specific hole mod_name.ghc-lib Create a s7 corresponding to an implementing module for the hole mod_name that exports a list of (s.ghc-libGiven an existing s, merge it with a list of (s with Backpack style mix-in linking. This is used solely when merging signatures together: we successively merge the exports of each signature until we have the final, full exports of the merged signature.What makes this operation nontrivial is what we are supposed to do when we want to merge in an export for M.T when we already have an existing export {H.T}. What should happen in this case is that {H.T} should be unified with M.T@: we've determined a more *precise* identity for the export at  T.FNote that we don't do unrestricted unification: only name holes from ns_mod_name ns are flexible. This is because we have a much more restricted notion of shaping than in Backpack'14: we do shaping *as* we do type-checking. Thus, once we shape a signature, its exports are *final* and we're not allowed to refine them further,ghc-lib%The export list associated with this sG (i.e., what the exports of an implementing module which induces this s would be.)ghc-libGiven a !, substitute it according to the s! implied substitution, i.e. map {A.T} to M.T&, if the implementing module exports M.T.ghc-libLike , but returns Nothing if no substitution works.(ghc-libThe  of any s a s has action over.(ghc-libSubstitute names in a .(ghc-libSubstitute names in an (^. This has special behavior for type constructors, where it is sufficient to substitute the ( to induce a substitution on (.(ghc-libSet the  of a  FieldSelector(ghc-lib Merges to ( lists together, assuming the (s have already been unified (().(ghc-libUnify two lists of ("s, given an existing substitution subst, with only name holes from flexi( unifiable (all other name holes rigid.)(ghc-lib Unify two ("s, given an existing substitution subst, with only name holes from flexi( unifiable (all other name holes rigid.)(ghc-lib Unify two "s, given an existing substitution subst, with only name holes from flexi( unifiable (all other name holes rigid.)(ghc-lib Unify a name h which 4 with another name, given an existing substitution subst, with only name holes from flexi) unifiable (all other name holes rigid.) srqpo srqpoNone_ S(ghc-libEnvironment for ( monads.ghc-lib[What we have is a generalized ModIface, which corresponds to a module that looks like p[A= AK]:B. We need a *specific* ModIface, e.g. p[A=q():A]:B (or maybe even p[A= BP]:B) which we load up (either to merge it, or to just use during typechecking).Suppose we have:p[A= A]:M ==> p[A=q():A]:MSubstitute all occurrences of  A with q():A (renameHoleModule). Then, for any Name of form {A.T}, replace the Name with the Name according to the exports of the implementing module. This works even for p[A= BR]:M, since we just read in the exports of B.hi, which is assumed to be ready now. This function takes an optional s, which can be used to further refine the identities in this interface: suppose we read a declaration for {H.T} but we actually know that this should be Foo.T; then we'll also rename this (this is used when loading an interface to merge it into a requirement.)ghc-libRename just the exports of a ?. Useful when we're doing shaping prior to signature merging.(ghc-libRun a computation in the ( monad.(ghc-libThe key function. This gets called on every Name embedded inside a ModIface. Our job is to take a Name from some generalized unit ID p[A= A, B= Ba], and change it to the correct name for a (partially) instantiated unit ID, e.g. p[A=q[]:A, B= B].%There are two important things to do:If a hole is substituted with a real module implementation, we need to look at that actual implementation to determine what the true identity of this name should be. We'll do this by loading that module's interface and looking at the mi_exports.However, there is one special exception: when we are loading the interface of a requirement. In this case, we may not have the "implementing" interface, because we are reading this interface precisely to "merge it in".External case: p[A= B]:A (and thisUnitId is something else) We are loading this in order to determine B.hi! So don't load B.hi to find the exports.Local case: p[A= A]:A (and thisUnitId is p[A= A}]) This should not happen, because the rename is not necessary in this case, but if it does we shouldn't load A.hi!Compare me with  tcIfaceGlobal!(ghc-libRename an implicit name, e.g., a DFun or coercion axiom. Here is where we ensure that DFuns have the correct module as described in Note [rnIfaceNeverExported].(ghc-lib Rename an (?, with special handling for an associated dictionary function.None Z*ghc-libMonadic because it makes a Name for the coercion TyCon We pass the Name of the parent TyCon, as well as the TyCon itself, because the latter is part of a knot, whereas the former is not.ghc-lib Make the ( for this ghc-lib Univ and reqghc-lib Ex and provghc-libArgument typesghc-lib Result typeghc-lib,Field labels for a record pattern synonymNone>HV ZNone_ g(ghc-libSubtract two natural numbers.(ghc-lib\Compute the exact logarithm of a natural number. The logarithm base is the second argument.(ghc-libDivide two natural numbers.(ghc-libgCompute the exact root of a natural number. The second argument specifies which root we are computing.(ghc-libCompute the n-th root of a natural number, rounded down to the closest natural number. The boolean indicates if the result is exact (i.e., True means no rounding was done, False means rounded down). The second argument specifies which root we are computing. (ghc-libCompute the logarithm of a number in the given base, rounded down to the closest integer. The boolean indicates if we the result is exact (i.e., True means no rounding happened, False means we rounded down). The logarithm base is the second argument. None p$ghc-libThis list is used to ensure that when you say "Prelude.map" in your source code, or in an interface file, you get a Name with the correct known key (See Note [Known-key names] in PrelNames)(ghc-lib.Check the known-key names list of consistency.ghc-libGiven a  lookup its associated ) if it corresponds to a known-key thing.ghc-libIs a  known-key?ghc-libGiven a C lookup any associated arbitrary SDoc's to be displayed by GHCi's ':info' command.  None pNone t (ghc-libGenerate Cmm code for a tick. Depending on the type of Tickish, this will either generate actual Cmm instrumentation code, or simply pass on the annotation as a  CmmTickish.None tK  None=?Fh z9(ghc-libGiven an info table, decide what the entry convention for the proc is. That is, for an INFO_TABLE_RET we want the return convention, otherwise it is a NativeNodeCall.(ghc-libGenerate a source note spanning from "a" to "b" (inclusive), then proceed with parsing. This allows debugging tools to reason about locations in Cmm code.  (9 (9 None. z  NoneXa ghc-libRead an interface fileghc-libThis performs a get action after reading the dictionary and symbol table. It is necessary to run this before trying to deserialise any Names or FastStrings.ghc-libWrite an interface fileghc-lib(Put a piece of data with an initialised ( field. This is necessary if you want to serialise Names or FastStrings. It also writes a symbol table and the dictionary. This segment should be read using .(ghc-lib:Initial ram buffer to allocate for writing interface files      None"#\ Gghc-lib<Loads a system interface and throws an exception if it failsghc-lib'Load the interface corresponding to an importS directive in source code. On a failure, fail in the monad with an error message. ghc-libLike , but returns a (.!ghc-lib.Load interface directly for a fully qualified . (This is a fairly rare operation, but in particular it is used to load orphan modules in order to pull their instances into the global package table and to handle some operations in GHCi)."ghc-lib,Load interfaces for a collection of modules.#ghc-libLoads the interface for a given Name. Should only be called for an imported name; otherwise loadSysInterface may not find the interface$ghc-lib6Only loads the interface for external non-local names.%ghc-lib'Loads the interface for a given Module.&ghc-libAn ' function to load the home interface for a wired-in thing, so that we're sure that we see its instance declarations and rules See Note [Loading instances for wired-in things]'ghc-libLoads a user interface and throws an exception if it fails. The first parameter indicates whether we should import the boot variant of the module(ghc-libA wrapper for )% that throws an exception if it fails(ghc-libReturns True if a  comes from an external package. In this case, we should NOT load it into the EPS; the entities should instead come from the local merged signature interface.(ghc-libThis is an improved version of ,6 which can also handle the case when a user requests p[A= B]:M$ but we only have an interface for p[A= A]:M (the indefinite interface. If we are not trying to build code, we load the interface we have, *instantiating it* according to how the holes are specified. (Of course, if we're actually building code, this is a hard error.)In the presence of holes, ( has an important invariant: to load module M, its set of transitively reachable requirements must have an up-to-date local hi file for that requirement. Note that if we are loading the interface of a requirement, this does not apply to the requirement itself; e.g., p[A= A]:A does not require A.hi to be up-to-date (and indeed, we MUST NOT attempt to read A.hi, unless we are actually typechecking p.)*ghc-libTCompute the signatures which must be compiled in order to load the interface for a 6. The output of this function is always a subset of (+; it is more precise because in signature p[A= A,B= B]:BG, although the free holes are A and B, B might not depend on A at all!sIf this is invoked on a signature, this does NOT include the signature itself; e.g. precise free module holes of p[A= A,B= B]:B never includes B.0ghc-lib'Read binary interface, and print it out !"#$%&'()*+,-./012!" #$%)'(,-+.*&1/20None\ (ghc-libReturns true if an ( is for data T (an abstract data type)(ghc-lib Merge two (s together, preferring a non-abstract one. If both are non-abstract we pick one arbitrarily (and check for consistency later.)(ghc-lib Merge two Ts of (s by .5ghc-libOThis is a very interesting function. Like typecheckIface, we want to type check an interface file into a ModDetails. However, the use-case for these ModDetails is different: we want to compare all of the ModDetails to ensure they define compatible declarations, and then merge them together. So in particular, we have to take a different strategy for knot-tying: we first speculatively merge the declarations to get the "base" truth for what we believe the types will be (this is "type computation.") Then we read everything in relative to this truth and check for compatibility.During the merge process, we may need to nondeterministically pick a particular declaration to use, if multiple signatures define the declaration ((). If, for all choices, there are no type synonym cycles in the resulting merged graph, then we can show that our choice cannot matter. Consider the set of entities which the declarations depend on: by assumption of acyclicity, we can assume that these have already been shown to be equal to each other (otherwise merging will fail). Then it must be the case that all candidate declarations here are type-equal (the choice doesn't matter) or there is an inequality (in which case merging will fail.)YUnfortunately, the choice can matter if there is a cycle. Consider the following merge:{signature H where { type A = C; type B = A; data C } signature H where { type A = (); data B; type C = B } If we pick  type A = CU as our representative, there will be a cycle and merging will fail. But if we pick  type A = () as our representative, no cycle occurs, and we instead conclude that all of the types are unit. So it seems that we either (a) need a stronger acyclicity check which considers *all* possible choices from a merge, or (b) we must find a selection of declarations which is acyclic, and show that this is always the "best" choice we could have made (ezyang conjectures this is the case but does not have a proof). For now this is not implemented.mIt's worth noting that at the moment, a data constructor and a type synonym are never compatible. Consider:signature H where { type Int=C; type B = Int; data C = Int} signature H where { export Prelude.Int; data B; type C = B; }:This will be rejected, because the reexported Int in the second signature (a proper data type) is never considered equal to a type synonym. Perhaps this should be relaxed, where a type synonym in a signature is considered implemented by a data type declaration which matches the reference of the type synonym.6ghc-libTypecheck a signature [ under the assumption that we have instantiated it under some implementation (recorded in (?) and want to check if the implementation fills the signature.0This needs to operate slightly differently than 4 because (1) we have a sr, from the exports of the implementing module, which we will use to give our top-level declarations the correct s even when the implementor provided them with a reexport, and (2) we have to deal with DFun silliness (see Note [rnIfaceNeverExported])Xghc-libTrue  =# discard IdInfo on IfaceId bindings(ghc-lib,For associated type/data family declarationsghc-libTrue  =# discard IdInfo on IfaceId bindingsSTUVWX4567897456XVUWTS89None%=>?Cghc-libThe patterns for an equation NB: We have already applied decideBangHood3 to these patterns. See Note [decideBangHood] in DsUtilsDghc-lib-Was this equation present in the user source?=This helps us avoid warnings on patterns that GHC elaborated.For instance, the pattern  -1 :: Word gets desugared into W -1 # :: Word9, but we shouldn't warn about an overflowed literal for both of these cases.Eghc-libWhat to do after matchKghc-libRun a t action inside the &b monad.Lghc-libRun a t action inside the ( monad.(ghc-lib5Build a set of desugarer environments derived from a &j.Mghc-libRun a t& action in the context of an existing (Xghc-lib(Get in-scope type constraints (pm check)Yghc-lib(Add in-scope type constraints (pm check)Zghc-lib(Get in-scope term constraints (pm check)[ghc-lib(Add in-scope term constraints (pm check)\ghc-libxIncrease the counter for elapsed pattern match check iterations. If the current counter is already over the limit, fail]ghc-lib<Reset the counter for pattern match check iterations to zero`ghc-libUEmit a warning for the current source location NB: Warns whether or not -Wxyz is setaghc-libDEmit a warning only if the correct WarnReason is set in the DynFlagscghc-lib\Issue an error, but return the expression for (), so that we can continue reporting errors.oghc-libThe COMPLETE* pragmas provided by the user for a given .sghc-lib=Fail with an error message if the type is levity polymorphic.tghc-libRCheck an expression for levity polymorphism, failing if it is levity polymorphic.ughc-libRuns the thing_inside. If there are no errors, then returns the expr given. Otherwise, returns unitExpr. This is useful for doing a bunch of levity polymorphism checks and then avoiding making a core App. (If we make a core App on a levity polymorphic argument, detecting how to handle the let/app invariant might call isUnliftedType, which panics on a levity polymorphic type.) See #12709 for an example of why this machinery is necessary.vghc-libInject a trace message into the compiled program. Whereas pprTrace prints out information *while compiling*, pprRuntimeTrace captures that information and causes it to be printed *at runtime* using Debug.Trace.trace.pprRuntimeTrace hdr doc expr*will produce an expression that looks liketrace (hdr + doc) expr\When using this to debug a module that Debug.Trace depends on, it is necessary to import {- SOURCE -} Debug.Trace () in that module. We could avoid this inconvenience by wiring in Debug.Trace.trace, but that doesn't seem worth the effort and maintenance cost.vghc-libheaderghc-libinformation to outputghc-lib expressionT  tuxwvouvx:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvTtLKNMJxuvo PRSUVOTQ^_gWmhijkluxwvnpqXYZ[\]o:`abcderfFGABCDE>?@H;<=Istuv None =>?HV4ghc-libGet a (] that includes mappings for all vars free in the given type. Useful when tidying open types.ghc-libMake a name for the dict fun for an instance decl. It's an *external* name, like other top-level names, and hence must be made with newGlobalBinder.ghc-libSpecial case of . to generate dict fun name for a single TyCon._ny~}|{F_~}|{yFnNone%>HPVghc-libTSee Note [The ZonkEnv] Confused by zonking? See Note [What is zonking?] in TcMType.(ghc-lib!Extend the knot-tied environment.(yzO(OyzNone%>HV(Jghc-lib@Use -XStrict to add a ! or remove a ~ See Note [decideBangHood] ghc-libUnconditionally make a ( strict.ghc-libticks to add, possiblyghc-lib The patternghc-lib(Expression to which the pattern is boundghc-lib~Id the rhs is bound to, for desugaring strict binds (see Note [Desugar Strict binds] in DsBinds) and all the desugared bindsghc-libOriginal pattern ghc-libOriginal patternghc-libBanged pattern7;<=>?ABCDE      !7ABCDE>?;<=      !None%X7W#ghc-libPost-typechecker, the ( field of an (8 contains (an expression for) the literal value itself.%ghc-lib_Emit warnings on overloaded integral literals which overflow the bounds implied by their type.&ghc-libTEmit warnings on integral literals which overflow the boudns implied by their type.(ghc-libTEmit warnings on integral literals which overflow the bounds implied by their type.'ghc-lib Warns about  [2,3 .. 1]R which returns the empty list. Only works for integral types, not floating point.(ghc-libSee if the expression is an (K literal. Remember to look through automatically-added tick-boxes! (#8384)(ghc-libIf (<, extract the value and type name of the overloaded literal.(ghc-libIf (A, extract the value and type name of the non-overloaded literal.(ghc-lib'the literal value and name of its tycon "#$%&'()*+,- "#+()*-,$%&'None%>HVDo (ghc-lib+Represent result signature of a type family(ghc-libRepresent result signature using a Maybe Kind. Used with data families, where the result signature can be either missing or a kind but never a named result variable.(ghc-lib1Represent injectivity annotation of a type family(ghc-lib Represent a type variable binder(ghc-lib#Represent a type wrapped in a Maybe(ghc-lib:Construct Core expression for Nothing of a given type name(ghc-lib5Construct Core expression for Nothing of a given type(ghc-lib:Store given Core expression in a Just of a given type name(ghc-lib5Store given Core expression in a Just of a given type(ghc-lib%Name of the TyCon of the element type(ghc-libThe element type(ghc-lib%Name of the TyCon of the element type(ghc-libThe element type..NoneD/0123/0123None%PMR4ghc-lib!Replaces all bindings of the form 'b = /\ ... -> makeStatic location valuewith Ob = /\ ... -> StaticPtr key (StaticPtrInfo "pkg key" "module" location) value3where a distinct key is generated for each binding.UIt also yields the C stub that inserts these bindings into the static pointer table.5ghc-libsptModuleInitCode module fps. is a C stub to insert the static entries of module into the static pointer table.fpsZ is a list associating each binding corresponding to a static entry with its fingerprint.4545None%>HVYXghc-lib_Checks to see if we need to warn for -Wunused-record-wildcards or -Wredundant-record-wildcards(ghc-libProduce a warning when the `..`! pattern binds no new variables. 0 data P = P { x :: Int } foo (P{x, ..}) = x The `..`$ here doesn't bind any variables as x is already bound.(ghc-lib/Produce a warning when no variables bound by a `..` pattern are used. . data P = P { x :: Int } foo (P{..}) = () The `..` pattern binds x6 but it is not used in the RHS so we issue a warning.\ghc-libwMake a map from selector names to field labels and parent tycon names, to be used when reporting unused record fields.(ghc-lib$Should we report the fact that this  is unused? The  may differ from  due to DuplicateRecordFields.06789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcde0PRQS_bTUVZ[WYX\^`a6789:;<=>?@ABCDEFGHIJedcKLMN]ONoneabfghc-libAttempt to convert a Template Haskell name to one that GHC can understand. Original TH names such as those you get when you use the 'foo syntax will be translated to their equivalent GHC name exactly. Qualified or unqualified TH names will be dynamically bound to names in the module being compiled, if possible. Exact TH names will be bound to the name they represent, exactly.C(((&n(((((((((((((((((((((( !"#$%&'()*+,-./0123456789:;<=>?@BAC(((((((((((((()))))))))) ) ) ) ) ))))))))))))))))))) )!)")#)$)%)&)')()))*)+),)-).)/)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){)|)})~)))))))DE)))FG)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))(F(G))))))))))))))))))))))))))))))))))))))))))))))))))))))********** * * * * ******************* (*!*"*#*$*%*&*'*(*)***+*,*-*.*/*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*{*|*}*~*****(****************************************************************************************************************************++++++++++ + + + + ++++++++++++(H(I(J(K(L+++++++ +!+"+#+$+%+&+'+(+)+*+++,+-+.+/+0+1+2+3+4+5+6+7+8+9+:+;+<+=+>+?+@+A+B+C+D+E+F+G+H+I+J+KNMLKJIHG+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+{+|+}+~++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++xyz{|}~++++++++++++++++++++++++++++++++++++++++++%+++++++++++++++++++++,,,,,,,,,, , , , , ,,,,,,,,,,,,,,,,,,, ,!,",#,$,%,&,',(,),*,+,,,-,.,/,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,{,|,},~,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,%m,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,---------- - - - - ------------------- -!-"-#-$-%-&-'-(-)-*-+-,      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLPONMR---.-/-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-rSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~     !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~-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.{.|.}.~..................%%(................................................................................Q...............................////////// / / / / //////////////  //  // / /!/"/#/$/%/&/'/(/)/*/+/,/-/.///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/{/|/}/~/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////0000000000 0 0 0 0 0000000000000000000 0!0"0#0$0%0&0'0(0)0*0+0,0-0.0/000102030405060708090:0;0<0=0>0?0@0A0B0C0D0E0F0G0H0I0J0K0L0M0N0O0P0Q0R0S0T0U0V0W0X0Y0Z0[0\0]0^0_0`0a0b0c0d0e0f0g0h0i0j0k      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOSRTUV0l0m0n0o0p0q0r0s0t0u0v0w0x0y0z0{0|0}0~0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001111111111 1 1 1 1 1111111111111111111 1!1"1#1$1%1&1'1(1)1*1+1,1-1.1/101112131415161718191:1;1<W1=1>1?1@1A1B1C1D1E1F1G1H1I1J1K1L1M1N1O1P1Q1R1S1T1U1V1W1X1YX1Z1[1\1]1^1_1`1a1b1c1d1e1f1g1h1i1j1k1l1m1n1o1p1q1r1s1t1u1v1w1x1y1z1{1|1}1~111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111 1111111111111111111111111111112222222222 2 2 2 2 2222222222222222222 2!2"2#2$2%2&2'2(2)2*2+2,2-2.2/202122232425262728292:2;2<2=2>2?2@2A2B2C2D2E2F2G2H2I2J2K2L2M2N2O2P2Q2R2S2T2U2V2W2X2Y2Z2[2\2]2^2_2`2a2b2c2d2e2f2g2h2i2j2k2l2m2n2o2p2q2r2s2t2u2v2w2x2y2z2{2|2}2~22$222222222222222222222222222222222222222222222222222222222222222222222222222222222222222(22222222222222222222222222222222222222223333333333 3 3 3 3 3333333333333333333 3!3"3#3$3%3&3'3(3)3*3+3,3-3.3/303132333435363738393:3;3<3=3>3?3@3A3B3C3D3E3F3G3H3I3J3K3L3M3N3O3P3Q3R3S3T3U3V3W3X3Y3Z3[3\3]3^3_3`3a3b3c3d3e3f3g3h3i3j3k3l%      !"#$%&'()*+,-./0123456789:;<=@?>ABCDEFIHGLKJONMRQPVUTSYXWZ\[`_^]cbafedihglkjonmsrqpywvutx{z~}|3m3n3o3p3q3r3s3t%3u3v3w3x3y3z3{3|3}3~3333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333334444444444 4 4 4 4 44%44444444444444444 4!4"4#4$4%4&4'4(4)4*4+4,4-4.4/404142434445464748494:4;4<4=4>4?4@4A4B4C4D4E4F4G4H4I4J4K4L4M4N4O4P4Q4R4S4T4U4V4W4X4Y4Z4[4\%4]4^4_4`4a4b4c4d4e4f4g4h4i4j4k4l4m4n4o4p4q4r4s4t4u4v4w4x4y4z4{4|4}4~444444444444444444444444444444444$4444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444445555555555 5 5 5 5 5555555555555555555 5!5"5#5$5%5&5'5(5)5*5+5,5-5.5/505152535455565758595:5;5<5=5>5?5@5A5B5C5D5E5F5G5H5I5J5K5L5M5N5O5P5Q5R5S5T5U5V5W5X5Y5Z5[5\5]5^5_5`5a5b5c5d5e5f5g5h5i5j5k5l5m5n5o5p5q5r5s5t5u5v5w5x5y5z5{5|5}5~55555555555555555555555555555555555555555555555555555555555555555555555555555555555   ~}|{zyxwvutsrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONMLKJIHGFEDCBA@?>=<;:9876543210/.-,+*)('&%$#"! &d55555555555555555555555555555555555555555555556666666666 6 6 6 6 6666666666666666666 6!6"6#     ~}|{zyxwvutsrqponmlkjihgfedcba`_^]\[ZY6$6%6&%r6'6(6)6*6+QP((((6,6-6.6/606162636465666768696:6;6<6=6>6?6@6A6B6C6D6E6F6G6H6I6J6K6L6M6N6O6P6Q6R6S6T6U(((((((f      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOSRTUVQP      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOSRTUVQPxyz{|}~     !"#$%&'()*+,-./0123456789:;<=>?@BACTSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~  !"#$%&'(+,-./12349:;<=>?@ABCDFGHIJKLMNOPQRSTUVWXYZ[\^_`abcdfgijnopqruvyz{|}~ {z      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLPONMR   )*05678EO]ehklmstwxQ =@?>      !"#$%&'()*+,-./0123456789:;<=@?>ABCDEFIHGLKJONMRQPVUTSYXWZ\[`_^]cbafedihglkjonmsrqpywvutx{z~}|fNone%>HVƔhhNone`G 6Vghc-lib.This environment is used for three operations: fTo support cloning of local Ids so that they are all unique (see item (6) of CorePrep overview).VTo support beta-reduction of runRW, see Note [runRW magic] and Note [runRW arg].To let us inline trivial RHSs of non top-level let-bindings, see Note [lazyId magic], Note [Inlining in CorePrep] and Note #12076(CorePrep inlines trivial CoreExpr not Id6Wghc-lib%See Note [Floating Ticks in CorePrep]6Xghc-lib Convert a , so it satisfies 6YW, without producing any floats (any generated floats are immediately let-bound using 6Z). Generally you want this, esp. when you've reached a binding form (e.g., a lambda) and floating any further would be incorrect.6[ghc-lib Convert a , so it satisfies 6Y; also produce a list of 6\g which are being propagated upwards. In fact, this function is used in only two cases: to implement 6X~ (which is what you usually want), and in the case when a let-binding is in a case scrutinee--here, we can always float out:Acase (let x = y in z) of ... ==> let x = y in case z of ...6]ghc-libIs an argument okay to CPE?6^ghc-lib Helper for m, o6_ghc-lib Helper for n, p+Just like we can't use Integer literals in  `integer-*`$, we can't use Natural literals in base;. If we do, we get interface loading error for GHC.Natural.6`ghc-lib+Like wrapFloats, but only wraps tick floats6aghc-libSCollect cost centres defined in the current module, including those in unfoldings.ijklmnopijklmonpNone%wghc-libw returns (True, fixity) if it finds a \K in a local environment or from an interface file. Otherwise, it returns (False, fixity) (e.g., for unbound s or .s without user-supplied fixity declarations).yghc-lib]Look up the fixity of a (possibly ambiguous) occurrence of a record field selector. We use 6b so that we can specifiy the 6 as the field label, which might be different to the  of the selector  if DuplicateRecordFieldsi is in use (#1173). If there are multiple possible selectors with different fixities, generate an error.tuvwxytuvwyxNone$`ghc-lib Lookup an Exact RdrNameX. See Note [Looking up Exact RdrNames]. This adds an error if the name cannot be found.6cghc-lib Lookup an Exact RdrNameY. See Note [Looking up Exact RdrNames]. This never adds an error, but it may return one.ghc-libLook up an occurrence of a field in record construction or pattern matching (but not update). When the -XDisambiguateRecordFields flag is on, take account of the data constructor name to disambiguate which field to use.$See Note [DisambiguateRecordFields].ghc-lib,Used in export lists to lookup the children.ghc-lib5Specialised version of msum for RnM ChildLookupResultghc-libLike -, but with a more informative result if the ! happens to be a record selector:8Nothing -> name not in scope (no error reported)iJust (Left x) -> name uniquely refers to x, or there is a name clash (reported)Just (Right xs) -> name refers to one or more record selectors; if overload_ok was False, this list will be a singleton.ghc-lib,Lookup a name in relation to the names in a zghc-lib:description of thing we're looking up, like "type family"ghc-libThe standard nameghc-libPossibly a non-standard name.z~{|}.z~{|}None%HVX*6dghc-libA 6e+ list that contains no duplicate variables.6fghc-libA 6e2 list that is allowed to have duplicate variables.6gghc-lib9Name of an operator in an operator application or section6hghc-libA normal identifier6ighc-libPrefix negation6jghc-libAn unbound indentifier6kghc-lib.A (possibly ambiguous) record field occurrenceghc-libcAlways bind any free tyvars of the given type, regardless of whether we have a forall at the topghc-lib:Unless there's forall at the top, do the same thing as ghc-libNever bind any free tyvars6lghc-libFinds free type and kind variables in a type, without duplicates, and without variables that are already in scope in LocalRdrEnv NB: this includes named wildcards, which look like perfectly ordinary type variables at this point6mghc-libFinds free type and kind variables in a type, with duplicates, but without variables that are already in scope in LocalRdrEnv NB: this includes named wildcards, which look like perfectly ordinary type variables at this point6nghc-lib8When the NamedWildCards extension is enabled, partition_nwcs removes type variables that start with an underscore from the FreeKiTyVars in the argument and returns them in a separate list. When the extension is disabled, the function returns the argument and empty list. See Note [Renaming named wild cards]6oghc-lib(In what contexts are wildcards permitted6pghc-lib>Ensures either that we're in a type or that -XPolyKinds is setghc-libSimply bring a bunch of RdrNames into scope. No checking for validity, at all. The binding location is taken from the location on each name.6qghc-lib=Look up the fixity for an operator name. Be careful to use y6 for (possibly ambiguous) record fields (see #13132).ghc-libh finds the type/kind variables of a HsType/HsKind. It's used when making the foralls explicit. When the same name occurs multiple times in the types, only the first occurrence is returned. See Note [Kind and type-variable binders]6rghc-lib6rl finds the type/kind variables of a HsType/HsKind. It's used when making the forallbs explicit. When the same name occurs multiple times in the types, all occurrences are returned.ghc-libwExtracts the free type/kind variables from the kind signature of a HsType. This is used to implicitly quantify over k in type T = Nothing :: Maybe k,. When the same name occurs multiple times in the type, only the first occurrence is returned, and the left-to-right order of variables is preserved. See Note [Kind and type-variable binders] and Note [Ordering of implicit variables] and Note [Implicit quantification in type synonyms].ghc-libExtracts free type and kind variables from types in a list. When the same name occurs multiple times in the types, all occurrences are returned.6pghc-libtype''None %>HSVX,bbNone $>HSVX\`=ghc-libProcess Import Decls. See 6s for a description of what the return types represent. Note: Do the non SOURCE ones first, so that we get a helpful warning for SOURCE ones that are unnecessary6sghc-lib#Given a located import declaration decl from this_mod1, calculate the following pieces of information:  An updated 6t, where all unresolved 2 in the entity lists have been resolved into s,A /} representing the new identifiers that were brought into scope (taking into account module qualification and hiding),'M summarizing the identifiers that were imported by this declaration, and A boolean +4 which is true if the imported module used HPC.ghc-libCalculate the '> induced by an import of a particular interface, but without '.6ughc-lib7Given an import/export spec, construct the appropriate /~s.6vghc-libIWarn the user about top level binders that lack type signatures. Called afterI type inference, so that we can report the inferred type of the functionNone $%>HSVXG*6wghc-libGiven a resolved name in the children export list and a parent. Decide whether we are allowed to export the child with the parent. Invariant: gre_par == NoParent See note [Typing Pattern Synonym Exports]ghc-lib$ means no explicit export listghc-lib-Imported modules; this is used to test if a  module Foo6 export is valid (it's not valid if we didn't import Foo!)6wghc-lib5Alleged parent type constructor User wrote T( P, Q )ghc-libKEither a a) Pattern Synonym Constructor b) A pattern synonym selectorNoneHVXGtz~{|}      tz~{|}None %>HVXD 6xghc-lib0'InstDeclFreeVarsMap is an association of an InstDecl with FreeVars. The FreeVarsr are the tycon names that are both a) free in the instance declaration b) bound by this group of typeclassinstance decls6yghc-libNTracks whether we are renaming an equation in a closed type family equation (6z ) or not (6{). ghc-lib rnSourceDecl "renames" declarations. It simultaneously performs dependency analysis and precedence parsing. It also does the following error checks:Checks that tyvars are used properly. This includes checking for undefined tyvars, and tyvars in contexts that are ambiguous. (Some of this checking has now been moved to module  TcMonoTypeI, since we don't have functional dependency information at this point.)1Checks that all variable occurrences are defined. Checks the (..)$ etc constraints in the export list.wBrings the binders of the group into scope in the appropriate places; does NOT assume that anything is in scope already6|ghc-libFor Windows DLLs we need to know what packages imported symbols are from to generate correct calls. Imported symbols are tagged with the current package, so if they get inlined across a package boundary we'll still know where they're from.6}ghc-lib8Warn about non-canonical typeclass instance declarationsA "non-canonical" instance definition can occur for instances of a class which redundantly defines an operation its superclass provides as well (c.f. 6~/). In such cases, a canonical instance is one where the subclass inherits its method implementation from its superclass instance (usually the subclass has a default method implementation to that effect). Consequently, a non-canonical instance occurs when this is not the case.See also descriptions of checkCanonicalMonadInstances and checkCanonicalMonoidInstances6ghc-libRenames role annotations, returning them as the values in a NameEnv and checks for duplicate role annotations. It is quite convenient to do both of these in the same place. See also Note [Role annotations in the renamer]6ghc-lib Construct an InstDeclFreeVarsMap by eliminating any Names from the FreeVars" which are *not* the binders of a TyClDecl.6ghc-libGet the  LInstDecls which have empty FreeVars sets, and the InstDeclFreeVarsMapj with these entries removed. We call (getInsts tcs instd_map) when we've completed the declarations for tcs. The call returns (inst_decls, instd_map'), where inst_decls are the instance declarations all of whose free vars are now defined instd_map' is the inst-decl map with tcs- removed from the free-var set6ghc-lib Errors if a via. type binds any floating type variables. See Note [Floating via type variables]6ghc-libRename injectivity annotation. Note that injectivity annotation is just the part after the "|". Everything that appears before it is renamed in rnFamDecl.6ghc-libiBrings pattern synonym names and also pattern synonym selectors from record pattern synonyms into scope.6ghc-lib The bound type variables from a via type.ghc-lib+The source span (for error reporting only).ghc-libThe pretty-printed via! type (for error reporting only).ghc-libA description of what the via0 type scopes over (for error reporting only).ghc-libThe thing the via type scopes over.6ghc-lib.Type variables declared in type family headghc-libResult signatureghc-libInjectivity annotation    None%HVghc-lib/Rename a splice pattern. See Note [rnSplicePat]ghc-libThe splice data to be logged6ghc-lib]Returns the result of running a splice and the modFinalizers collected during the execution.5See Note [Delaying modFinalizers in untyped splices].ghc-libMoutputs splice information for 2 flags which have different output formats: `-ddump-splices` and `-dth-dec-file`cNone %HVX`4 pghc-libRename some Stmts6ghc-libHA tree of statements using a mixture of applicative and bind constructs.6ghc-libThe s of return and pure. These may not be  returnName and pureName due to RebindableSyntax.6ghc-liblike  p8 but applies a post-processing step to the renamed Stmts6ghc-libHmaybe rearrange statements according to the ApplicativeDo transformation6ghc-lib.strip the FreeVars annotations from statements6ghc-libIs this a context where we respect RebindableSyntax? but ListComp are never rebindable Neither is ArrowExpr, which has its own desugarer in DsArrows6ghc-libSrearrange a list of statements using ApplicativeDoStmt. See Note [ApplicativeDo].6ghc-libRTurn a sequence of statements into an ExprStmtTree using a heuristic algorithm. O(n^2)6ghc-lib[Turn a sequence of statements into an ExprStmtTree optimally, using dynamic programming. O(n^3)6ghc-libaTurn the ExprStmtTree back into a sequence of statements, using ApplicativeStmt where necessary.6ghc-libDivide a sequence of statements into segments, where no segment depends on any variables defined by a statement in another segment.6ghc-libFind a "good" place to insert a bind in an indivisible segment. This is the only place where we use heuristics. The current heuristic is to peel off the first group of independent statements and put the bind after those.6ghc-libMBuild an ApplicativeStmt, and strip the "return" from the tail if necessary.nFor example, if we start with do x <- E1; y <- E2; return (f x y) then we get do (E1[x] | E2[y]); f x yKthe LastStmt in this case has the return removed, but we set the flag on the LastStmt to indicate this, so that we can print out the original statement correctly in error messages. It is easier to do it this way rather than try to ignore the return later in both the typechecker and the desugarer (I tried it that way first!).6ghc-libPGiven the statements following an ApplicativeStmt, determine whether we need a join or not, and remove the return if necessary.6ghc-libJust e, if the expression is return e or  return $ e , otherwise Nothing pghc-lib7How to rename the body of each statement (e.g. rnLExpr)ghc-lib Statementsghc-libRif these statements scope over something, this renames it and returns the result.6ghc-lib7How to rename the body of each statement (e.g. rnLExpr)ghc-libpostprocess the statementsghc-lib Statementsghc-libRif these statements scope over something, this renames it and returns the result.6ghc-lib'How to rename the body of the statementghc-lib The statementghc-lib0Rename the stuff that this statement scopes over6ghc-lib the "tail"ghc-libfree variables of the tail6ghc-libThe argsghc-libTrue  = need a joinghc-libThe body statements p q q pNone"#P\] ghc-libGet the U associated with the given name.4May cause loading the module that contains the name. Throws a . if loading fails or the name cannot be found.ghc-lib$Temporarily extend the linker state. ghc-lib$Display the persistent linker state.!ghc-lib,Initialise the dynamic linker. This entails*a) Calling the C initialisation procedure,6b) Loading any packages specified on the command line,Lc) Loading any packages specified on the command line, now held in the -l options in v_Opt_l,d) Loading any .o/.dll7 files specified on the command line, now held in ldInputs, e) Loading any MacOS frameworks.NOTE: This function is idempotent; if called more than once, it does nothing. This is useful in Template Haskell, where we call it before trying to link.#ghc-libLink a single expression,  includingE first linking packages and modules that this expression depends on.Raises an IO exception (A) if it can't find a compiled version of the dependents to link.6ghc-lib!Useful to apply to the result of 6&ghc-lib8Unloading old objects ready for a new compilation sweep.The compilation manager provides us with a list of linkables that it considers "stable", i.e. won't be recompiled this time around. For each of the modules current linked in memory,zif the linkable is stable (and it's the same one -- the user may have recompiled the module on the side), we keep it,otherwise, we unload it.?we also implicitly unload all temporary bindings at this point.'ghc-libLink exactly the specified packages, and their dependents (unless of course they are already linked). The dependents are linked automatically, and it doesn't matter what order you specify the input packages.6ghc-libRetrieve the list of search directory GCC and the System use to find libraries and components. See Note [Fork/Exec Windows].6ghc-libCache for the GCC search directories as this can't easily change during an invocation of GHC. (Maybe with some env. variable but we'll) deal with that highly unlikely scenario then.6ghc-lib`Get a list of system search directories, this to alleviate pressure on the findSysDll function.6ghc-libMerge the given list of paths with those in the environment variable given. If the variable does not exist then just return the identity.&ghc-libThe linkables to *keep*.  !"#$%&'  #$&'!%"None&'6ghc-libType of functions that use error message and a list of axioms to build full error message (with a source location) for injective type families.*ghc-libIf co :: T ts ~ rep_ty then: +instNewTyCon_maybe T ts = Just (rep_ty, co)nChecks for a newtype, and for being saturated Just like Coercion.instNewTyCon_maybe, but returns a TcCoercion+ghc-libLike ,l, but returns the arguments back if there is no data family to unwrap. Returns a Representational coercion,ghc-libConverts a data family type (eg F [a]) to its representation type (eg FList a) and returns a coercion between the two: co :: F [a] ~R FList a.-ghc-lib-F gets rid of top-level newtypes, potentially looking through newtype  instances.It is only used by the type inference engine (specifically, when solving representational equality), and hence it is careful to unwrap only if the relevant data constructor is in scope. That's why it get a GlobalRdrEnv argument.It is careful not to unwrap data/newtype instances if it can't continue unwrapping. Such care is necessary for proper error messages.TIt does not look through type families. It does not normalise arguments to a tycon.If the result is Just (rep_ty, (co, gres), rep_ty), then co : ty ~R rep_ty gres are the GREs for the data constructors that had to be in scope6ghc-libCheck whether a new open type family equation can be added without violating injectivity annotation supplied by the user. Returns True when this is possible and False if adding this equation would violate injectivity annotation./ghc-libHBuild a list of injectivity errors together with their source locations.6ghc-libReturn a list of type variables that the function is injective in and that do not appear on injective positions in the RHS of a family instance declaration. The returned Pair includes invisible vars followed by visible ones6ghc-lib,Is type headed by a type family application?6ghc-lib`If a RHS is a bare type variable return a set of LHS patterns that are not bare type variables.6ghc-lib?Build injecivity error herald common to all injectivity errors.6ghc-libQBuild error message for a pair of equations violating an injectivity annotation.6ghc-libRBuild error message for equation with injective type variables unused in the RHS.6ghc-libUBuild error message for equation that has a type family call at the top level of RHS6ghc-libwBuild error message for equation that has a bare type variable in the RHS but LHS pattern is not a bare type variable./ghc-lib(Type family for which we generate errorsghc-lib1Currently checked equation (represented by axiom)ghc-libInjectivity annotationghc-libList of injectivity conflicts D()*+,-./012 D2).+,*-(/01NoneQ 3456789:;<=> 3456789;<:=>NoneF&@ghc-lib Loads the plugins specified in the pluginModNames field of the dynamic flags. Should be called after command line arguments are parsed, but before actual compilation starts. Idempotent operation. Should be re-called if pluginModNames or pluginModNameOpts changes.Bghc-lib=Force the interfaces for the given modules to be loaded. The 6*# parameter is used for debugging (-ddump-if-traceA) only: it is shown as the reason why the module is being loaded.Cghc-libIForce the interface for the module containing the name to be loaded. The 6*# parameter is used for debugging (-ddump-if-traceA) only: it is shown as the reason why the module is being loaded.Dghc-lib Load the C associated with the given name, come hell or high water. Fails if:!The interface could not be loadedThe name is not that of a +The name did not exist in the loaded moduleEghc-lib#Loads the value corresponding to a  if that value has the given . This only provides limited safety in that it is up to the user to ensure that that type corresponds to the type you try to use the return value at!8If the value found was not of the correct type, returns Nothing.. Any other condition results in an exception:%If we could not load the names module(If the thing being loaded is not a value(If the Name does not exist in the moduleIf the link failedGghc-libCoerce a value as usual, but:L1) Evaluate it immediately to get a segfault early if the coercion was wronga2) Wrap it in some debug messages at verbosity 3 or higher so we can see what happened if it does segfaultHghc-lib Finds the  corresponding to the given  in the context of the  . Returns Nothing if no such > could be found. Any other condition results in an exception: If the module could not be found3If we could not determine the imports of the module=Can only be used for looking up names while loading plugins (and is *not* suitable for use within plugins). The interface file is loaded very partially: just enough that it can be used, without its rules and instances affecting (and being linked from!) the module being compiled. This was introduced by 57d6798.CNeed the module as well to record information in the interface file @ABCDEFGH @ABCDHEFGNoneX)oIghc-lib's get converted into I's before being written into .hie files. See O and 66 for logic on how to convert between these two types.IJKLMNONMIJKLONone1>+_ghc-libiLook for any identifiers which occur outside of their supposed scopes. Returns a list of error messages. STUVWXYZ[\]^_ UVWTXYZS[\]^_None"#0`ghc-libProduce a fingerprint of a DynFlags> value. We only base the finger print on important fields in DynFlags= so that the recompilation checker can use this fingerprint.NB: The  parameter is the 3 recorded by the *interface* file, not the actual  according to our  .`ab`abNone\`e]dghc-lib7everything is up to date, recompilation is not requiredeghc-lib@The .hs file has been touched, or the .o/.hi file does not existfghc-libThe .o/.hi files are up to date, but something else has changed to force recompilation; the String says what (one-line summary)hghc-libmake an interface from the results of typechecking only. Useful for non-optimising compilation, or where we aren't generating any object code at all ().6ghc-lib1Add fingerprints for top-level declarations to a .$See Note [Fingerprinting IfaceDecls]6ghc-libRetrieve the orphan hashes s for a list of modules (in particular, the orphan modules which are transitively imported by the current module).eQ: Why do we need the hash at all, doesn't the list of transitively imported orphan modules suffice?A: If one of our transitive imports adds a new orphan instance, our export hash must change so that modules which import us rebuild. If we just hashed the [Module], the hash would not change even when a new instance was added to a module that already had an orphan instance.iQ: Why don't we just hash the orphan hashes of our direct dependencies? Why the full transitive closure?!A: Suppose we have these modules:module A where instance Show (a -> b) where module B where import A -- ** module C where import A import B)Whether or not we add or remove the import to A in B affects the orphan hash of B. But it shouldn't really affect the orphan hash of C. If we hashed only direct dependencies, there would be no way to tell that the net effect was a wash, and we'd be forced to recompile C and everything else.6ghc-libCreates cached lookup for the \ field of ModIface Hackily, we use "module" as the OccName for any module-level annotationslghc-libTop level function to check if the version of an old interface file is equivalent to the current source file the user asked us to compile. If the same, we can avoid recompilation. We return a tuple where the first element is a bool saying if we should recompile the object file and the second is maybe the interface file, where Nothng means to rebuild the interface file not use the exisitng one.6ghc-lib$Check if a module is still the same version..This function is called in the recompilation checker after we have determined that the module M being checked hasn't had any changes to its source file since we last compiled M. So at this point in general two things may have changed that mean we should recompile M: * The interface export by a dependency of M has changed. * The compiler flags specified this time for M have changed in a manner that is significant for recompilation. We return not just if we should recompile the object file but also if we should rebuild the interface file.6ghc-lib1Check if any plugins are requesting recompilation6ghc-libWCheck if an hsig file needs recompilation because its implementing module has changed.6ghc-lib Check if .hie file is out of date or missing.6ghc-libCheck the flags haven't changed6ghc-lib,Check the optimisation flags haven't changed6ghc-lib#Check the HPC flags haven't changed6ghc-libGiven the usage information extracted from the old M.hi file for the module being compiled, figure out whether M needs to be recompiled. cdefghijklmn ghilcdefkjnmNoneoughc-libPretty-prints a C8 (type/data family instance) with its defining location.vghc-libPretty-prints a  with its defining location.wghc-libPretty-prints the L header. For functions and data constructors the function is equivalent to zZ but for type constructors and classes it prints only the header part of the declaration.xghc-libPretty-prints a  in context: that is, if the entity is a data constructor, record selector, or class method, then the entity's parent declaration is pretty-printed with irrelevant parts omitted.yghc-libLike x!, but adds the defining location.zghc-libPretty-prints a .uvwxyz{zxvyw{u None>P`zghc-libRInstantiate all outer type variables and any context. Never looks through arrows.ghc-libInstantiate all outer v binders and any context. Never looks through arrows or specified type variables. Used for visible type application.ghc-libVInstantiates up to n invisible binders Returns the instantiating types, and body kindghc-libUsed only in *types*6ghc-lib This takes a ~# b and returns a ~~ b.6ghc-lib This takes a ~# b and returns a ~ b.ghc-libType to instantiate it atghc-lib(Standard name, user name)ghc-libj(Standard name, suitable expression) USED ONLY FOR CmdTop (sigh) *** See Note [CmdSyntaxTable] in HsExprijk;<~;<~ikjNone6ghc-libOIndicates if Instance met the Safe Haskell overlapping instances safety check.See Note [Safe Haskell Overlapping Instances] in TcSimplify See Note [Safe Haskell Overlapping Instances Implementation] in TcSimplifyghc-libjExtra information about the parent instance declaration, needed when type-checking associated types. The . is the enclosing class, the [TyVar] are the scoped* type variable of the instance decl. The  VarEnv Type. maps class variables to their instance types.ghc-libThe scopedW tyvars of the instance Why scoped? See bind_me in TcValidity.checkConsistentFamInstghc-libMaps classY tyvars to their instance types See Note [Matching in the consistent-instantation check]6ghc-lib,Assumes that we've checked that this is the Typeable4 class, and it was applied to the correct argument.6ghc-libRepresentation for a type ty of the form  arg -> ret.6ghc-lib<Representation for type constructor applied to some kinds. 6{ has ensured that this application results in a type of monomorphic kind (e.g. all kind variables have been instantiated).6ghc-libRepresentation for TyCon applications of a concrete kind. We just use the kind itself, but first we must make sure that we've instantiated all kind- polymorphism, but no more.NonePX`<ghc-lib Variant of e that works when supplied only part (that is, to the right of some arrows) of the full function typeghc-libqCall this variant when you are in a higher-rank situation and you know the right-hand type is deeply skolemised.ghc-libSometimes we don't have a  HsExpr Name' to hand, and this is more convenient.ghc-libyInfer a type using a fresh ExpType See also Note [ExpType] in TcMType Does not attempt to instantiate the inferred typeghc-librTake an "expected type" and strip off quantifiers to expose the type underneath, binding the new skolems for the  thing_inside. The returned 6 has type specific_ty -> expected_ty.ghc-lib Variant of  that takes an ExpTypeghc-lib-Breaks apart a function kind into its pieces.}ghc-libIf present, has type ty1ghc-libof the actual typeghc-lib!If present, it has type ty_actualghc-libof the actual typeghc-libof the expected typeghc-lib3These are only ever used for scoped type variables.ghc-lib/The expression has type: spec_ty -> expected_tyghc-libtype, only for errorsghc-libn: number of desired arrowsghc-lib fun_ kindghc-lib-co :: fun_kind ~ (arg1 -> ... -> argn -> res)#|}#}|None%XQ 6ghc-libhAn error Report collects messages categorised by their importance. See Note [Error report] for details.ghc-libeReport unsolved goals as errors or warnings. We may also turn some into deferred run-time errors if `-fdefer-type-errors` is on.ghc-lib`Report *all* unsolved goals as errors, even if -fdefer-type-errors is on However, do not make any evidence bindings, because we don't have any convenient place to put them. See Note [Deferring coercion errors to runtime] Used by solveEqualities for kind equalities (see Note [Fail fast on kind errors] in TcSimplify] and for simplifyDefault.ghc-libReport all unsolved goals as warnings (but without deferring any errors to run-time). See Note [Safe Haskell Overlapping Instances Implementation] in TcSimplify6ghc-lib,Report unsolved goals as errors or warnings.6ghc-lib(Put a doc into the important msgs block.6ghc-lib+Put a doc into the relevant bindings block.6ghc-lib)Put a doc into the valid hole fits block.6ghc-lib Returns True  =7 the ReportErrCtxt indicates that something is deferred6ghc-lib Transforms a 63 into one that does not defer any bindings at all.6ghc-libVThis function tries to reconstruct why a "Coercible ty1 ty2" constraint is left over.6ghc-libPrints explicit kinds (with -fprint-explicit-kinds) in an 6*> when a type mismatch occurs to due invisible kind arguments.)This function first checks to see if the (  argument is a (, and if so, uses the expected/actual types from that to check for a kind mismatch (as these types typically have more surrounding types and are likelier to be able to glean information about whether a mismatch occurred in an invisible argument position or not). If the (  is not a (7, fall back on the actual mismatched types themselves.6ghc-libExpand type synonyms in given types only enough to make them as similar as possible. Returned types are the same in terms of used type synonyms.To expand all synonyms, see .See ExpandSynsFail tests in tests testsuitetestsAtypecheck/should_fail for some examples of how this should work.NoneHVghc-libKSee Note [Safe Haskell Overlapping Instances Implementation] in TcSimplifyghc-libReturns Given constraints that might, potentially, match the given pred. This is used when checking to see if a Given might overlap with an instance. See Note [Instance and Given overlap] in TcInteract. ghc-lib"Remove inert constraints from the ?, for use when a typechecker plugin wishes to discard a given."ghc-lib-Look up a dictionary inert. NB: the returned 'I might not match the input exactly. Note [Use loose types in inert set].#ghc-lib)Look up a solved inert. NB: the returned 'M might not match the input exactly. See Note [Use loose types in inert set].=ghc-libThis variant of <} will keep solving, even when only Deriveds are left around. It also doesn't return any evidence, as callers won't need it.>ghc-lib-This can deal only with equality constraints.6ghc-lib.Mark variables as used filling a coercion hole}ghc-libEqualities only~ghc-lib+Good for both equalities and non-equalitiesghc-lib Make a new E of the given type, bound (in the monad's EvBinds) to the given termghc-lib-Emit a new Wanted equality into the work-listghc-libMake a new equality CtEvidenceghc-libqChecks if the depth of the given location is too much. Fails if it's too big, with an appropriate error message.ghc-libtype being reducedB      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~G<=?234>BA@DC7^]w56;9:01zy{SnT|}~  VWXYZNOPQR[\EF /HI  %"')*(,+& #$!mlpq-.rsuvtoxBabcfghedijkJKLMU8_` None ghc-lib=Perform some IO, typically to interact with an external tool.ghc-lib)Output useful for debugging the compiler.ghc-libCreate a new wanted constraint.ghc-lib Create a new derived constraint.ghc-lib[Create a new given constraint, with the supplied evidence. This must not be invoked from  tcPluginInit or  tcPluginStop, or it will panic.ghc-lib!Create a fresh evidence variable.ghc-libCreate a fresh coercion hole.ghc-lib;Bind an evidence variable. This must not be invoked from  tcPluginInit or  tcPluginStop, or it will panic.(gh(hgNone% 6ghc-lib,The result of flattening a tyvar "one step".6ghc-lib;The inert set doesn't make the tyvar equal to anything else6ghc-libThe tyvar flattens to a not-necessarily flat other type. co :: new type ~r old type, where the role is determined by the FlattenEnv6ghc-libThe 6 monad is a wrapper around C with the following extra capabilities: (1) it offers access to a 6V; and (2) it maintains the flattening worklist. See Note [The flattening work list].6ghc-lib Change the  in a 6.6ghc-lib Change the  in a 6.6ghc-libMake sure that flattening actually produces a coercion (in other words, make sure our flavour is not Derived) Note [No derived kind equalities]6ghc-lib%fast path flatten_args, in which none of the binders are named and therefore we can avoid tracking a lifting context. There are many bang patterns in here. It's been observed that they greatly improve performance of an optimized build. The T9872 test cases are good witnesses of this fact.6ghc-libYSlow path, compared to flatten_args_fast, because this one must track a lifting context.6ghc-libFlattenM a coercion. Really, just zonk it so we can uphold (F1) of Note [Flattening]6ghc-libLike  splitPiTys' but comes with a 6 which is $q) iff there is at least one named binder.6ghc-libLike  but you also get a 67 which is true iff there is at least one named binder.Noneh6ghc-libCompare types for equality, while zonking as necessary. Gives up as soon as it finds that two types are not equal. This is quite handy when some unification has made two types in an inert Wanted to be equal. We can discover the equality without flattening, which is sometimes very expensive (in the case of type functions). In particular, this function makes a ~20% improvement in test case perfcompilerT5030.Returns either the (partially zonked) types in the case of inequality, or the one type in the case of equality. canEqReflexive is a good next step in the 6 case. Returning 6 is always safe.NB: This does *not* look through type synonyms. In fact, it treats type synonyms as rigid constructors. In the future, it might be convenient to look at only those arguments of type synonyms that actually appear in the synonym RHS. But we're not there yet.6ghc-libDecompose a type application. All input types must be flat. See Note [Canonicalising type applications] Nominal equality only!<We're able to unwrap a newtype. Update the bits accordingly.6ghc-libdBreak apart an equality over a casted type looking like (ty1 |> co1) ~ ty2 (modulo a swap-flag)6ghc-libCall when canonicalizing an equality fails, but if the equality is representational, there is some hope for the future. Examples in Note [Use canEqFailure in canDecomposableTyConApp]6ghc-lib@Call when canonicalizing an equality fails with utterly no hope.6ghc-libCanonicalise a CFunEqCan. We know that the arg types are already flat, and the RHS is a fsk, which we must *not* substitute. So just substitute in the LHS6ghc-lib%Solve a reflexive equality constraint6ghc-lib :: ty1 ~ ty2ghc-libty1ghc-lib :: ty1 ~ ty1'ghc-libty2ghc-libty2, with type synonyms  60None9 6ghc-libGRepresents collections of constraints generated by typechecker plugins6ghc-lib]Original inputs to the plugins with solved/bad constraints removed, but otherwise unmodified6ghc-libConstraints solved by plugins6ghc-lib,Constraints reported as insoluble by plugins6ghc-lib"New constraints emitted by plugins6ghc-lib9A solved triple of constraints, with evidence for wanteds6ghc-libCA triple of (given, derived, wanted) constraints to pass to plugins6ghc-libExtract the (inert) givens and invoke the plugins on them. Remove solved givens from the inert set and emit insolubles, but return new work produced so that ( can feed it back into the main solver.6ghc-libGiven a bag of (flattened, zonked) wanteds, invoke the plugins on them and produce an updated bag of wanteds (possibly with some new work) and a bag of insolubles. The boolean indicates whether < should feed the updated wanteds back into the main solver.6ghc-libzStarting from a triple of (given, derived, wanted) constraints, invoke each of the typechecker plugins in turn and return%the remaining unmodified constraints,"constraints that have been solved,#constraints that are insoluble, and new work.FNote that new work generated by one plugin will not be seen by other plugins on this pass (but the main constraint solver will be re-invoked and they will see it later). There is no check that new work differs from the original constraints supplied to the plugin: the plugin itself should perform this check if necessary.6ghc-libIf a class is "naturally coherent", then we needn't worry at all, in any way, about overlapping/incoherent instances. Just solve the thing! See Note [Naturally coherent classes] See also Note [The equality class story] in TysPrim.NoneL ghc-lib8How should we choose which constraints to quantify over?ghc-libKApply the monomorphism restriction, never quantifying over any constraintsghc-libySee Note [TcRnExprMode] in TcRnDriver, the :type +d case; this mode refuses to quantify over any defaultable constraintghc-libIQuantify over any constraint that satisfies TcType.pickQuantifiablePredsghc-libType-check a thing that emits only equality constraints, solving any constraints we can and re-emitting constraints that we can't. The thing_inside should generally bump the TcLevel to make sure that this run of the solver doesn't affect anything lying around.ghc-libType-check a thing that emits only equality constraints, then solve those constraints. Fails outright if there is trouble. Use this if you're not going to get another crack at solving (because, e.g., you're checking a datatype declaration)ghc-libgSimplify top-level constraints, but without reporting any unsolved constraints nor unsafe overlapping.6ghc-libDefault any remaining  CallStack constraints to empty  CallStacks.ghc-libGNormalise a type as much as possible using the given constraints. See Note [tcNormalise].6ghc-libLike , but in the TcS monad.==Noneq.ghc-lib~HoleFit is the type we use for valid hole fits. It contains the element that was checked, the Id of that element as found by , and the refinement level of the fit, which is the number of extra argument holes that this fit uses (e.g. if hfRefLvl is 2, the fit is for `Id _ _`).ghc-libXHoleFitCandidates are passed to the filter and checked whether they can be made to fit.ghc-libtcFilterHoleFits filters the candidates by whether, given the implications and the relevant constraints, they can be made to match the type by running the type checker. Stops after finding limit matches.6ghc-lib.Checks whether a MetaTyVar is flexible or not.ghc-libkTakes a list of free variables and restores any Flexi type variables in free_vars after the action is run.ghc-libReports whether first type (ty_a) subsumes the second type (ty_b), discarding any errors. Subsumption here means that the ty_b can fit into the ty_a, i.e. `tcSubsumes a b == True` if b is a subtype of a.ghc-libvA tcSubsumes which takes into account relevant constraints, to fix trac #14273. This makes sure that when checking whether a type fits the hole, the type has to be subsumed by type of the hole as well as fulfill all constraints on the type of the hole. Note: The simplifier may perform unification, so make sure to restore any free type variables to avoid side-effects.Rghc-libThe tidy_env for zonkingghc-lib!Enclosing implications for givensghc-libBThe unsolved simple constraints in the implication for the hole.ghc-libThe hole constraint itselfghc-lib%How many we should output, if limitedghc-lib!Enclosing implications for givensghc-lib(Any relevant unsolved simple constraintsghc-libThe type to check for fits and a list of refinement variables (free type variables in the type) for emulating additional holes.ghc-lib$The candidates to check whether fit.ghc-libTWe return whether or not we stopped due to hitting the limit and the fits we found.ghc-libAny relevant Cts to the hole.ghc-libJThe nested implications of the hole with the innermost implication first.ghc-libThe type of the hole.ghc-libThe type to check whether fits.ghc-lib;Whether it was a match, and the wrapper from hole_ty to ty.RRNoneFX/ghc-libTakes a list of custom printers with a explicit recursion knot and a term, and returns the output of the first successful printer, or the default printer6ghc-libTerm Reconstruction trace6ghc-libuReturns the instantiated type scheme ty', and the mapping from new (instantiated) -to- old (skolem) type variables ghc-libTerm reconstruction"Given a pointer to a heap object (U) and its type, build a  b representation of the object. Subterms (objects in the payload) are also built up to the given  max_depth. After  max_depth any subterms will appear as  Is. Any thunks found while traversing the object will be forced based on force parameter.^Types of terms will be refined based on constructors we find during term reconstruction. See !3 for an overview of how type reconstruction works.!ghc-lib'Fast, breadth-first Type reconstructionGiven a heap object (U) and its (possibly polymorphic) type (usually obtained in GHCi), try to reconstruct a more monomorphic type of the object. This is used for improving type information in debugger. For example, if we have a polymorphic function:`sumNumList :: Num a => [a] -> a sumNumList [] = 0 sumNumList (x : xs) = x + sumList xsand add a breakpoint to it:@ghci> break sumNumList ghci> sumNumList ([0 .. 9] :: [Int])+ghci shows us more precise types than just as:nStopped in Main.sumNumList, debugger.hs:3:23-39 _result :: Int = _ x :: Int = 0 xs :: [Int] = _ ghc-lib&How many times to recurse for subtermsghc-lib Force thunksghc-lib!Type of the object to reconstructghc-libObject to reconstruct!ghc-lib&How many times to recurse for subtermsghc-libType to refineghc-lib Refine the type using this value       !"  !"     None%P6ghc-lib_Check a list of binders to see if they make a valid telescope. See Note [Bad TyCon telescopes]6ghc-lib0Information about a type being validity-checked.6ghc-libWhen validity-checking an application of a type synonym, should we check the arguments, check the expanded type, or both? See Note [Correctness and performance of type synonym validity checking]6ghc-libOnly check the expanded type.6ghc-libOnly check the arguments.6ghc-lib/Check both the arguments and the expanded type.6ghc-libReturns $q if the supplied A| is unambiguously not the context for the type of a term, where visible, dependent quantification is currently disallowed.IAn example of something that is unambiguously the type of a term is the forall a -> a -> a in foo :: forall a -> a -> a'. On the other hand, the same type in %type family Foo :: forall a -> a -> aR is unambiguously the kind of a type, not the type of a term, so it is permitted.For more examples, see  testsuitetests dependentshould_compileT16326_Compile*.hs+ (for places where VDQ is permitted) and  testsuitetests dependent should_failT16326_Fail*.hs' (for places where VDQ is disallowed).6ghc-libIf LiberalTypeSynonyms is enabled, we start in 6$ mode for the reasons explained in Note [Liberal type synonyms]. Otherwise, we start in 6 mode.6ghc-libJReject type variables that would escape their escape through a kind. See ,Note [Type variables escaping through kinds].6ghc-libHReject a use of visible, dependent quantification in the type of a term.6ghc-lib2See Note [Validity checking of HasField instances]/ghc-libDo validity checks on a type family equation, including consistency with any enclosing class instance head, termination, and lack of polytypes.6ghc-lib}Checks that a list of type patterns is valid in a matching (LHS) position of a class instances or type/data family instance.CSpecifically: * All monotypes * No type-family applications6ghc-libWhen this says True:, ignore this class constraint during a termination check6ghc-libTidy before printing a type6ghc-lib'Is this the argument to a type synonym?/ghc-libof the type familyghc-libBound variables in the equationghc-lib Type patternsghc-libRhs1ghc-lib Family tycon+A@?>=<;:9876543210/.-,+*)('$%&'()*+,-./0123+$A@?>=<;:9876543210/.-,+*)('%&(,*+'-./10)23None HPSVX` 7ghc-lib1Describes the kind expected in a certain context.8ghc-liba specific kind9ghc-libany kind will do:ghc-libsomething of the form TYPE _6ghc-libInfo about the context in which we're checking a type. Currently, differentiates only between types and kinds, but this will likely grow, at least to include the distinction between patterns and not-patterns./To find out where the mode is used, search for 6Cghc-libTypecheck something within the context of a deriving strategy. This is of particular importance when the deriving strategy is via. For instance: $deriving via (S a) instance C (T a) We need to typecheck S a>, and moreover, we need to extend the tyvar environment with a before typechecking C (T a), since S a quantified the type variable a.Eghc-lib%Type-check a visible type application6ghc-lib`Check and desugar a type, returning the core type and its possibly-polymorphic kind. Much like  tcInferRho at the expression level.7ghc-libCall 7/ and check its result against an expected kind.7ghc-libxInfer the kind of a type and desugar. This is the "up" type-checker, as described in Note [Bidirectional type checking]Oghc-libApply a type of a given kind to a list of arguments. This instantiates invisible parameters as necessary. Always consumes all the arguments, using matchExpectedFunKind as necessary. This takes an optional  VarEnv Kind which maps kind variables to kinds.- These kinds should be used to instantiate invisible kind variables; they come from an enclosing class for an associated type/data family.tcInferApps also arranges to saturate any trailing invisible arguments of a type-family application, which is usually the right thing to do tcInferApps_nosat does not do this saturation; it is used only by ":kind" in GHCi7ghc-libApply a type of a given kind to a list of arguments. This instantiates invisible parameters as necessary. Always consumes all the arguments, using matchExpectedFunKind as necessary. This takes an optional  VarEnv Kind which maps kind variables to kinds.- These kinds should be used to instantiate invisible kind variables; they come from an enclosing class for an associated type/data family.tcInferApps also arranges to saturate any trailing invisible arguments of a type-family application, which is usually the right thing to do tcInferApps_nosat does not do this saturation; it is used only by ":kind" in GHCi7ghc-libThis instantiates invisible arguments for the type being checked if it must be saturated and is not yet saturated. It then calls and uses the result from checkExpectedKindX to build the final type7ghc-lib'New unification variable for a wildcardUghc-lib Kind-check a $x. If the decl under consideration has a complete, user-supplied kind signature (CUSK), generalise the result. Used in getInitialKind (for tycon kinds and other kinds) and in kind-checking (but not for tycon kinds, which are checked with tcTyClDecls). See Note [CUSKs: complete user-supplied kind signatures] in HsDecls.-This function does not do telescope checking.7ghc-libiUsed during the "kind-checking" pass in TcTyClsDecls only, and even then only for data-con declarations.^ghc-libUsed for the type variables of a type or class decl in the "kind checking" and "type checking" pass, but not in the initial-kind run.7ghc-libThis variant of a refuses to generalize over any variables free in the given WantedConstraints. Instead, it promotes these variables into an outer TcLevel. See also Note [Promoting unification variables] in TcSimplifyhghc-libkWhenever a type is about to be added to the environment, it's necessary to make sure that any free meta-tyvars in the type are promoted to the current TcLevel. (They might be at a higher level due to the level-bumping in tcExplicitTKBndrs, for example.) This function both zonks *and* promotes. Why at the same time? See Note [Recipe for checking a signature]jghc-libIf the inner action emits constraints, report them as errors and fail; otherwise, propagates the return value. Useful as a wrapper around tcImplicitTKBndrs[, which uses solveLocalEqualities, when there won't be another chance to solve constraintskghc-libfMake an appropriate message for an error in a function argument. Used for both expressions and types.lghc-lib3Add a "In the data declaration for T" or some such. Cghc-libThe deriving strategyghc-libzThe thing to typecheck within the context of the deriving strategy, which might quantify some type variables of its own.ghc-libdThe typechecked deriving strategy, all quantified tyvars, and the payload of the typechecked thing.7ghc-libargument typesghc-libof these kindsghc-lib expected kind of the whole tupleOghc-libFunction (for printing only)ghc-libFunctionghc-libArgsghc-lib(f args, args, result kind)7ghc-libFunction (for printing only)ghc-libFunctionghc-libArgsghc-lib(f args, args, result kind)7ghc-lib"type we're checking (for printing)ghc-libtype we're checkingghc-libthe known kind of that typeghc-libthe expected kindPghc-libThe thing we are checkingghc-libtype we're checkingghc-libthe known kind of that typeghc-libthe expected kindUghc-libof the thing being checkedghc-lib What sort of  is being checkedghc-libTrue  =" the decl being checked has a CUSKghc-libThe result kindghc-libA suitably-kinded TcTyCon7ghc-libof the thing being checkedghc-lib What sort of  is being checkedghc-libThe result kindghc-libA suitably-kinded TcTyCon7 ghc-libof the thing being checkedghc-lib What sort of  is being checkedghc-libThe result kindghc-libA suitably-kinded TcTyConRA@?>=<;:9876543210/.-,+*)('789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklR?@A>e;<=DBCEA@?>=<;:9876543210/.-,+*)('WVYX[Z]\789:_^bd`UTGFIHKLJQRSOjMNaPichfgkl NoneHV7 ghc-lib.If there are no wildcards, return a LHsSigType(lmnopqrstuvwxyz{|}(mlopqrstunvwxy{|}zNone %>HPSVXOghc-lib A variant of  that takes a custom origin7 ghc-lib:Convenient wrapper for calling a matchExpectedXXX functionghc-lib(origin to use if the type needs inst'ing ~ ~None>HVX(9 7 ghc-libshowString :: String -> ShowS7 ghc-lib(showsPrec :: Show a => Int -> a -> ShowS7ghc-libshows :: Show a => a -> ShowS7ghc-libyMake a function binding. If no equations are given, produce a function with the given arity that produces a stock error.7ghc-libMake a function binding. If no equations are given, produce a function with the given arity that uses an empty case expression for the last argument that is passes to the given function to produce the right-hand side.ghc-libProduces a function binding. When no equations are given, it generates a binding of the given arity and an empty case expression for the last argument that it passes to the given function to produce the right-hand side.ghc-libProduces a function binding. When there are no equations, it generates a binding with the given arity that produces an error based on the name of the type of the last argument.7ghc-lib0A table of postfix modifiers for unboxed values.7ghc-libLookup  in an association list.7ghc-libLookup  in an association list.7ghc-libeMake a top-level binder name for an auxiliary binding for a parent name See Note [Auxiliary binders]None>HVX_.ghc-libDoes not contain variableghc-libThe variable itselfghc-lib$The variable itself, contravariantlyghc-lib Function typeghc-lib Tuple typeghc-lib(Type app, variable only in last argumentghc-lib.Type app, variable other than in last argumentghc-lib Forall typeghc-libVariable to look forghc-lib How to foldghc-libType to processNone >HPVXF7ghc-libSee documentation of 7; that function uses the fields of this type to interpret the structure of a type when that type is considered as an argument to a constructor that is being represented with Rep1.7ghc-lib argTyFold3 implements a generalised and safer variant of the arg function from Figure 3 in  (http://dreixel.net/research/pdf/gdmh.pdf. arg is conceptually equivalent to: arg t = case t of _ | isTyVar t -> if (t == argVar) then Par1 else Par0 t App f [t'] | representable1 f && t' == argVar -> Rec1 f App f [t'] | representable1 f && t' has tyvars -> f :.: (arg t') _ -> Rec0 twhere argVar_ is the last type variable in the data type declaration we are finding the representation for. argTyFold is more general than arg because it uses 7. to abstract out the concrete invocations of Par0, Rec0, Par1, Rec1, and :.:. argTyFold is safer than arg because argN would lead to a GHC panic for some data types. The problematic case is when t0 is an application of a non-representable type f to argVar: App f [argVar] is caught by the _% pattern, and ends up represented as Rec0 t. This type occurs free in the RHS of the eventual Rep1s instance, which is therefore ill-formed. Some representable1 checks have been relaxed, and others were moved to canDoGenerics1.7ghc-lib.Variant of foldr1 for producing balanced listsNoneHVghc-libA list of wanted  constraints () to simplify when inferring a derived instance's context. These are used in all deriving strategies, but in the particular case of DeriveAnyClass5, we need extra information. In particular, we need:h, the list of type variables bound by a class method's regular type signature, which should be rigid.t, the list of type variables bound by a class method's default type signature. These can be unified as necessary., the list of constraints from a class method's regular type signature, which can be used to help solve constraints in the . (Note that p will likely contain type variables from the derived type class or data type, neither of which will appear in  or .)?For all other deriving strategies, it is always the case that , , and  are empty.&Here is an example to illustrate this: 8class Foo a where bar :: forall b. Ix b => a -> b -> String default bar :: forall y. (Show a, Ix y) => a -> y -> String bar x y = show x ++ show (range (y, y)) baz :: Eq a => a -> a -> Bool default baz :: Ord a => a -> a -> Bool baz x y = compare x y == EQ data Quux q = Quux deriving anyclass Foo Then it would generate two s, one for each method: [ ThetaOrigin { to_anyclass_skols = [b] , to_anyclass_metas = [y] , to_anyclass_givens = [Ix b] , to_wanted_origins = [ Show (Quux q), Ix y , (Quux q -> b -> String) ~ (Quux q -> y -> String) ] } , ThetaOrigin { to_anyclass_skols = [] , to_anyclass_metas = [] , to_anyclass_givens = [Eq (Quux q)] , to_wanted_origins = [ Ord (Quux q) , (Quux q -> Quux q -> Bool) ~ (Quux q -> Quux q -> Bool) ] } ] (Note that the type variable q is bound by the data type Quux", and thus it appears in neither  nor .)See ?Note [Gathering and simplifying constraints for DeriveAnyClass] in  TcDerivInfer for an explanation of how  are determined in DeriveAnyClass, as well as how , , and  are used.ghc-libA - annotated with the origin of the constraint ( 9, and whether or the constraint deals in types or kinds.ghc-lib@Records whether a particular class can be derived by way of an  originative deriving strategy (i.e., stock or anyclass).See Note [Deriving strategies] in TcDeriv.ghc-libWhether GHC is processing a deriving. clause or a standalone deriving declaration.ghc-lib'InferContext mb_wildcard is either:A deriving clause (in which case  mb_wildcard is $).iA standalone deriving declaration with an extra-constraints wildcard as the context (in which case  mb_wildcard is & loc, where loc$ is the location of the wildcard.GHC should infer the context.ghc-lib theta. is a standalone deriving declaration, where theta& is the context supplied by the user.ghc-libZContains all of the information known about a derived instance when determining what its EarlyDerivSpec should be.ghc-lib Is this an overlapping instance?ghc-lib5Universally quantified type variables in the instanceghc-lib-Class for which we need to derive an instanceghc-lib,Other arguments to the class except the lastghc-libZType constructor for which the instance is requested (last arguments to the type class)ghc-lib!Arguments to the type constructorghc-libThe representation tycon for  (for data family instances)ghc-libThe representation types for  (for data family instances)ghc-lib theta for standalone deriving (where theta( is the context of the instance).  for derivingP clauses, or for standalone deriving that uses a wildcard constraint. See %Note [Inferring the instance context].ghc-lib&@ if user requests a particular deriving strategy. Otherwise, $.ghc-lib0To avoid having to manually plumb everything in " throughout various functions in TcDeriv and  TcDerivInfer , we use #, which is a simple reader around &h.ghc-lib4Is GHC processing a standalone deriving declaration?ghc-libpIs GHC processing a standalone deriving declaration with an extra-constraints wildcard as the context? (e.g., !deriving instance _ => Eq (Foo a))ghc-lib wc returns (# if wc is $q, and (  if wc is $r. Useful for error-reporting.ghc-lib Convert a  to its corresponding 7.7ghc-lib~Some common validity checks shared among stock derivable classes. One check that absolutely must hold is that if an instance C (T a) is being derived, then Tc must be a tycon for a data type or a newtype. The remaining checks are only performed if using a deriving) clause (i.e., they're ignored if using StandaloneDeriving): UThe data type must have at least one constructor (this check is ignored if using EmptyDataDeriving).0The data type cannot have any GADT constructors.\The data type cannot have any constructors with existentially quantified type variables.+The data type cannot have a context (e.g., data Foo a = Eq a => MkFoo).8The data type cannot have fields with higher-rank types.7ghc-libThe data type's ). For data families, this is the family .ghc-lib.For data families, this is the representation ,. Otherwise, this is the same as the other  argument.ghc-lib7" if deriving an instance for this  is possible. Otherwise, it's 7 err, where err explains what went wrong.7ghc-lib? if this is standalone deriving with a user-supplied context, y if not. If it is the former, we relax some of the validity checks we would otherwise perform (i.e., "just go for it").ghc-lib$q  = allow higher rank arguments and empty data types (with no data constructors) even in the absence of the -XEmptyDataDeriving extension.BBNone`X7ghc-libLike , but used only in the case of deriving strategies where the constraints are inferred by inspecting the fields of each data constructor (i.e., stock- and newtype-deriving).7ghc-libLike , but used only in the case of DeriveAnyClass, which gathers its constraints based on the type signatures of the class's methods instead of the types of the data constructor's field.See Note [Gathering and simplifying constraints for DeriveAnyClass] for an explanation of how these constraints are used to determine the derived instance context.7ghc-libGiven instance (wanted) => C inst_ty , simplify wanted, as much as possible. Fail if not possible.7ghc-lib C inst_tyC, head of the instance we are deriving. Only used for SkolemInfo.ghc-libThe tyvars bound by inst_ty.ghc-libGiven and wanted constraintsghc-lib1Needed constraints (after simplification), i.e. [].NoneHVNone %>HSVX7 ghc-libHWarn the user about polymorphic local binders that lack type signatures.        None"#HMV7!ghc-lib&A monad within which we will generate KindRep+s. Here we keep an environment containing KindRepIs which we've already generated so we can re-use them opportunistically.7"ghc-libMaps kinds to KindRepW bindings. This binding may either be defined in some other module (in which case the Maybe (LHsExpr Id will be $T) or a binding which we generated in the current module (in which case it will be & the RHS of the binding).7#ghc-libof TyCon7$ghc-lib To construct TrName,s The various TyCon and DataCons of KindRep7%ghc-lib A group of s in need of type-rep bindings.7&ghc-libBuild exported KindRep% bindings for the given set of kinds.7'ghc-libModule's typerep binding7(ghc-libPackage name fingerprint7)ghc-libModule name fingerprint7*ghc-libThe s in need of bindings kinds7+ghc-libInformation we need about a / to generate its representation. We carry the 4 in order to share it between the generation of the TyCon and KindRep bindings.ghc-libGenerate the Typeable bindings for a module. This is the only entry-point of this module and is invoked by the typechecker driver in  tcRnSrcDecls.1See Note [Grand plan for Typeable] in TcTypeable.7,ghc-lib6Generate TyCon bindings for a set of type constructors7-ghc-lib<Generate bindings for the type representation of a wired-in s defined by the virtual GHC.Prim] module. This is where we inject the representation bindings for these primitive types into  GHC.Types2See Note [Grand plan for Typeable] in this module.7.ghc-libThis is the list of primitive *s for which we must generate bindings in  GHC.Types+. This should include all types defined in GHC.Prim.8The majority of the types we need here are contained in 7/. However, not all of them: in particular unboxed tuples are absent since we don't want to include them in the original name cache. See Note [Built-in syntax and the OrigNameCache] in IfaceEnv for more.70ghc-libKCollect various tidbits which we'll need to generate TyCon representations.71ghc-lib-Lookup the necessary pieces to construct the  trNameLiti. We do this so we can save the work of repeating lookups when constructing many TyCon representations.72ghc-lib%Make Typeable bindings for the given .73ghc-lib^Here is where we define the set of Typeable types. These exclude type families and polytypes.74ghc-libIs a particular  representable by Typeablef? Here we look for polytypes and types containing casts (which may be, for instance, a type family).75ghc-lib We generate KindReps for a few common kinds in  GHC.Types, so that they can be reused across modules.76ghc-libPerformed while compiling  GHC.Types to generate the built-in KindReps.77ghc-libRun a 7! and add the produced KindRep#s to the typechecking environment.78ghc-libProduce or find a KindRep for the given kind.79ghc-lib%Construct the right-hand-side of the KindRep for the given ! and in-scope kind variable set.7:ghc-lib!Produce the right-hand-side of a TyCon representation.76ghc-lib"the kinds to generate bindings for78ghc-libin-scope kind variablesghc-libthe kind we want a KindRep for79ghc-libin-scope kind variablesghc-libthe kind we want a KindRep forghc-libRHS expression7:ghc-libthe  we are producing a binding forghc-libits KindRepNone%HV7;ghc-libA monad for type synonym cycle checking, which keeps track of the TyCons which are known to be acyclic, or a failure message reporting that a cycle was found.7<ghc-lib Test if a 8 is acyclic, short-circuiting if we've seen it already.ghc-libChecks if any of the passed in s have cycles. Takes the  of the home package (as we can avoid checking those TyCons: cycles never go through foreign packages) and the corresponding LTyClDecl Name for each (, so we can give better error messages.  None HMVX\_% 7=ghc-libGiven a *o. of an instantiated signature (note that the *oG must be knot-tied consistently with the actual implementation) and a /} constructed from the implementor of this interface, verify that the actual implementation actually matches the original interface.Note that it is already assumed that the implementation *exports* a sufficient set of entities, since otherwise the renaming and then typechecking of the signature  would have failed.7>ghc-lib Checks if a  is "defined". In general, for hsig files we can't assume that the implementing file actually implemented the instances (they may be reexported from elsewhere). Where should we look for the instances? We do the same as we would otherwise: consult the EPS. This isn't perfect (we might conclude the module exports an instance when it doesn't, see #9422), but we will never refuse to compile something.7?ghc-libKReturn this list of requirement interfaces that need to be merged to form mod_name, or [] if this is not a requirement.!ghc-lib For a module modname of type 2u , determine the list of extra "imports" of other requirements which should be considered part of the import of the requirement, because it transitively depends on those requirements by imports of modules from other packages. The situation is something like this:Ounit p where signature A signature B import A&unit q where dependency p[A= A,B= B-] signature A signature BAlthough q's B does not directly import A, we still have to make sure we process A first, because the merging process will cause B to indirectly import A. This function finds the TRANSITIVE closure of all such imports we need to make."ghc-lib", but in a convenient form for GhcMake and  TcRnDriver.%ghc-libGiven a , make sure it is well typed. This is because unit IDs come from Cabal, which does not know if things are well-typed or not; a component may have been filled with implementations for the holes that don't actually fulfill the requirements..INVARIANT: the UnitId is NOT a InstalledUnitId&ghc-libETop-level driver for signature instantiation (run when compiling an hsig file.)'ghc-libCTop-level driver for signature merging (run after typechecking an hsig file).7@ghc-lib The list of s of *non-exported* (s which this ( may refer to. A non-exported (1 should be kept after thinning if an *exported* ( (or , perhaps) refers to it; we can't decide to keep it by looking at the exports of a module after thinning. Keep this synchronized with  rnIfaceDecl.(ghc-libGiven a local ), merge all inherited requirements from 7?) into this signature, producing a final &j? that matches the local signature and all required signatures.)ghc-libETop-level driver for signature instantiation (run when compiling an hsig file.)7Aghc-libCheck if module implements a signature. (The signature is always un-hashed, which is why its components are specified explicitly.)*ghc-libGiven '0, instantiate a  from the indefinite library to use the actual implementations of the relevant entities, checking that the implementation matches the signature. !"#$%&'()* !"$#%&'()*None%>HV+27Bghc-lib PatSyn Nameghc-libPatSyn type (UniBidirExplicitBidir)ghc-lib Whether infixghc-libPattern of the PatSynghc-libPattern arguments and typesghc-lib Pattern typeghc-lib<Selector names ^ Whether fields, empty if not record PatSyn7Cghc-libVisible field labels/01+10+/None >HPSVX`.7Dghc-libWhen the MatchGroup has multiple RHSs, convert an Infer ExpType in the expected type into TauTvs. See Note [Case branches must never infer a non-tau type]7Eghc-libType-check a MatchGroup.YZ,-./0123456789:;Y5Z34/012,.-8967;:NoneHV1Ighc-librConstruct default instances for any associated types that aren't given a user definition Returns [] or singleton<=>?@ABCDEFGHI=>B@?<ACDEFGHINoneHV9FJghc-lib%Stuff needed to process a datatype's  `deriving` clausesLghc-libUThe data tycon for normal datatypes, or the *representation* tycon for data familiesNghc-lib error contextOghc-libExtract  `deriving`2 clauses of proper data type (skips data families)7Fghc-libProcess a single class in a  `deriving` clause.7Gghc-lib7Derive an instance for a data type (i.e., non-newtype).7Hghc-lib!Derive an instance for a newtype.JKLMNOPPJKLMNONone%HPV`LD7Ighc-libCMaybe return a list of Bools that say whether a type family was declared injective in the corresponding type arguments. Length of the list is equal to the number of arguments (including implicit kind/coercion arguments). True on position N means that a function is injective in its Nth argument. False means it is not.7Jghc-libFrom information about a source datacon definition, extract out what the universal variables and the GADT equalities should be. See Note [mkGADTVars].7Kghc-libProduce an error for oversaturated type family equations with too many required arguments. See Note [Oversaturated type family equations] in TcValidity.7Lghc-libTrue  = cuskghc-lib Just cls  =* this is an associated family of class cls7Mghc-libTrue  = cuskghc-lib Just cls  =* this is an associated family of class cls7Nghc-libFamily TyCon (not knot-tied)ghc-libDefaultsghc-libType checked RHS7Oghc-libThe tycon varsghc-libThe datacon varsghc-libIThe matching between the template result type and the actual result typeghc-libiThe univ. variables, the GADT equalities, and a subst to apply to the GADT equalities and existentials. STUVWXYZ[\]^_ STZY[VU\]^WX_None>HVPp`ghc-libUse DerivInfo for data family instances (produced by tcInstDecls1), datatype declarations (TyClDecl), and standalone deriving declarations (DerivDecl) to check and process all derived class instances.R`aR`aNoneHPSVXPbbNone >HPVXe[Jghc-lib!Slightly more general version of KR that allows the caller to specify the shape of the result of the syntax operatorKghc-libhTypecheck a syntax operator The operator is a variable or a lambda at this stage (i.e. renamer output)7Pghc-lib5A data type to describe why a variable is not closed.7Qghc-libUType-check the arguments to a function, possibly including visible type applications7Rghc-lib=Checks if the given name is closed and emits an error if not.%See Note [Not-closed error messages].Kghc-lib"shape of syntax operator argumentsghc-liboverall result typeghc-libType check any arguments7Qghc-lib'The function itself (for err msgs only)ghc-lib)the (uninstantiated) type of the functionghc-lib"the origin for the function's typeghc-libthe argsghc-lib the herald for matchActualFunTysghc-lib8(a wrapper for the function, the tc'd args, result type)7Sghc-libshape it is expected to haveghc-libcheck the argumentsghc-lib@returns a wrapper :: (type of right shape) "->" (type passed in)7Tghc-libargument shapesghc-lib result shapeghc-libcheck the argumentsghc-libreturns a wrapper to be applied to the original function, wrappers to be applied to arguments and a wrapper to be applied to the overall expression&%$#"!IJKLMNOPQcdeQOPMNLcKJ&%$#"!IedNone%HVfQffNoneHVktghc-libCheck that the type has the form (IO t) or (t) , and that t satisfies the given predicate. When calling this function, any newtype wrappers (should) have been already dealt with by normaliseFfiType.cWe also check that the Safe Haskell condition of FFI imports having results in the IO monad holds.ghijklmnopqrstuvwxjoghlqkmnstiuvwxprNone%lsyz{y{zNone %>HMVX\_]ghc-librCompares two things for equivalence between boot-file and normal code, reporting an error if they don't match up.ghc-lib3How should we infer a type? See Note [TcRnExprMode]ghc-lib"Instantiate the type fully (:type)ghc-lib&Do not instantiate the type (:type +v)ghc-lib#Default the type eagerly (:type +d)7Ughc-lib9A plan is an attempt to lift some code into the IO monad.ghc-lib1Top level entry point for typechecker and renamer7Vghc-lib:Remove accumulated bindings, rules and so on from TcGblEnv7Wghc-libdRuns TH finalizers and renames and typechecks the top-level declarations that they could introduce.ghc-libTCompares the two things for equivalence between boot-file and normal code. Returns Nothing on success or !Just "some helpful info for user"; failure. If the difference will be apparent to the user,  Just empty is perfectly suitable.7Xghc-lib%Combines two potential error messages7Yghc-lib9If the test in the first parameter is True, succeed with Nothing'; otherwise, return the provided check7Zghc-libRun the check provided for every pair of elements in the lists. The provided SDoc should name the element type, in the plural.7[ghc-lib9If the test in the first parameter is True, succeed with Nothing'; otherwise, fail with the given SDoc.7\ghc-libA more perspicuous name for Nothing, for  checkBootDecl and friends.7]ghc-libRWarn on local definitions of names that would clash with future Prelude elements.A name clashes if the following criteria are met: 1. It would is imported (unqualified) from Prelude 2. It is locally defined in the current module 3. It has the same literal name as the reference function 4. It is not identical to the reference function7^ghc-libGet the unqualified name of the function to use as the "main" for the main module. Either returns the default name or the one configured on the command line with -main-isghc-libThe returned [Id] is the list of new Ids bound by this statement. It can be used to extend the InteractiveContext via extendInteractiveContext.`The returned TypecheckedHsExpr is of type IO [ () ], a list of the bound values, coerced to ().7_ghc-libbTry the plans in order. If one fails (by raising an exn), try the next. If one succeeds, take it.7`ghc-libTypecheck (and lift4) a stmt entered by the user in GHCi into the GHCi  environment.By lift and 'environment we mean that the code is changed to execute properly in an IO monad. See Note [Interactively-bound Ids in GHCi] in HscTypes for more details. We do this lifting by trying different ways (plansX) of lifting the code into the IO monad and type checking each plan until one succeeds.7aghc-libcTypecheck the statements given and then return the results of the statement in the form 'IO [()]'.7bghc-libAGenerate a typed ghciStepIO expression (ghciStep :: Ty a -> IO a)ghc-lib-tcRnExpr just finds the type of an expressionghc-lib)ASSUMES that the module is either in the *Z or is a package module with an interface on disk. If neither of these is true, then the result will be an error indicating the interface could not be found.ghc-lib8Find all the Names that this RdrName could mean, in GHCighc-lib.Extract the renamed information from TcGblEnv.]ghc-libTrue  =& an hs-boot file (could also be a sig)7cghc-libInstances of this ...ghc-lib should also be instances of this"[\]"#%'()*""#%('*)[]\7X0None`ghc-libqThe state of the term oracle (includes complex constraints that cannot progress unless we get more information).7dghc-libThe environment of the oracle contains 1. A Bool (are there any constraints we cannot handle? (PmExprOther)). 2. A substitution we extend with every step and return as a result.ghc-libThe type of substitutions.ghc-lib`Check whether a constraint (x ~ BOT) can succeed, given the resulting state of the term oracle.7eghc-libBCheck whether a variable is in the free variables of an expressionghc-lib=Flatten the DAG (Could be improved in terms of performance.).ghc-libInitial state of the oracle.ghc-lib%Solve a complex equality (top-level).7fghc-libSolve a complex equality. Nothing => definitely unsatisfiable Just tms => I have added the complex equality and added it to the tmstate; the result may or may not be satisfiable7gghc-libEExtend the substitution and solve the (possibly updated) constraints.ghc-libWhen we know that a variable is fresh, we do not actually have to check whether anything changes, we know that nothing does. Hence, / simply extends the substitution, unlike what 7g does.7hghc-libSimplify a complex equality.7ighc-libtSimplify an expression. The boolean indicates if there has been any simplification or if the operation was a no-op.7jghc-lib@Simplify an equality expression. The equality is given in parts.7kghc-lib:Apply an (un-flattened) substitution to a simple equality.7lghc-lib3Apply an (un-flattened) substitution to a variable.ghc-lib6Apply an (un-flattened) substitution to an expression.ghc-lib&External interface to the term oracle.ghc-libType of a PmLit           None%&'.HPoR7mghc-lib^The arity of a pattern/pattern vector is the number of top-level patterns that are not guards7nghc-libInformation about a conlike that is relevant to coverage checking. It is called an "inhabitation candidate" since it is a value which may possibly inhabit some type, but only if its term constraint (7o) and type constraints (7p<) are permitting, and if all of its strict argument types (7q) are inhabitable. See +Note [Extensions to GADTs Meet Their Match].7rghc-libEither a list of patterns that are not covered, or their type, in case we have no patterns at hand. Not having patterns at hand can arise when handling EmptyCase expressions, in two cases:JThe type of the scrutinee is a trivially inhabited type (like Int or Char)4The type of the scrutinee cannot be reduced to WHNF.-In both these cases we have no inhabitation candidates for the type at hand, but we don't want to issue just a wildcard as missing. Instead, we print a type annotated wildcard, so that the user knows what kind of patterns is expected (e.g. (_ :: Int), or (_ :: F Int), where F Int does not reduce).7sghc-libPattern check resultRedundant clauses?Not-covered clauses (or their type, if no pattern is available)Clauses with inaccessible RHSMore details about the classification of clauses into useful, redundant and with inaccessible right hand side can be found here: <https://gitlab.haskell.org/ghc/ghc/wikis/pattern-match-check7tghc-lib4When we learned that a given match group is complete7ughc-lib9From the original definition of the type constructor.7vghc-libFrom a user-provided COMPLETE pragma7wghc-libTerm and type constraints to accompany each value vector abstraction. For efficiency, we store the term oracle state instead of the term constraints. TODO: Do the same for the type constraints?7xghc-libValue Vector Abstractions7yghc-libThe empty pattern check result7zghc-lib:Non-exhaustive empty case with unknown/trivial inhabitantsghc-lib$Check a single pattern binding (let)7{ghc-lib$Check a single pattern binding (let)ghc-libMExhaustive for guard matches, is used for guards in pattern bindings and in MultiIf expressions.ghc-lib*Check a matchgroup (case, functions, etc.)7|ghc-libCheck a matchgroup (case, functions, etc.). To be called on a non-empty list of matches. For empty case expressions, use checkEmptyCase' instead.7}ghc-libCheck an empty case expression. Since there are no clauses to process, we only compute the uncovered set. See Note [Checking EmptyCase Expressions] for details.7~ghc-libReturns $q if the argument @ is a fully saturated application of a closed type constructor.Closed type constructors are those with a fixed right hand side, as opposed to e.g. associated types. These are of particular interest for pattern-match coverage checking, because GHC can exhaustively consider all possible forms that values of a closed type can take on.qNote that this function is intended to be used to check types of value-level patterns, so as a consequence, the = supplied as an argument to this function should be of kind Type.7ghc-libkGet rid of *outermost* (or toplevel) * type function redex * data family redex * newtypesBehaves exactly like 7, but instead of returning a coercion, it returns useful information for issuing pattern matching warnings. See Note [Type normalisation for EmptyCase] for details.NB: Normalisation can potentially change kinds, if the head of the type is a type family with a variable result kind. I (Richard E) can't think of a way to cause trouble here, though.7ghc-libDetermine suitable constraints to use at the beginning of pattern-match coverage checking by consulting the sets of term and type constraints currently in scope. If one of these sets of constraints is unsatisfiable, use an empty set in its place. (See ANote [Recovering from unsatisfiable pattern-matching constraints] for why this is done.)7ghc-libGiven a conlike's term constraints, type constraints, and strict argument types, check if they are satisfiable. (In other words, this is the "_Sat oracle judgment from the GADTs Meet Their Match paper.)For the purposes of efficiency, this takes as separate arguments the ambient term and type constraints (which are known beforehand to be satisfiable), as well as the new term and type constraints (which may not be satisfiable). This lets us implement two mini-optimizations:wIf there are no new type constraints, then don't bother initializing the type oracle, since it's redundant to do so.Since the new term constraint is a separate argument, we only need to execute one iteration of the term oracle (instead of traversing the entire set of term constraints).Taking strict argument types into account is something which was not discussed in GADTs Meet Their Match. For an explanation of what role they serve, see +Note [Extensions to GADTs Meet Their Match].7ghc-libLike 7, but only checks if term and type constraints are satisfiable, and doesn't bother checking anything related to strict argument types.7ghc-libnImplements two performance optimizations, as described in the "Strict argument type constraints" section of +Note [Extensions to GADTs Meet Their Match].7ghc-lib^Checks if a strict argument type of a conlike is inhabitable by a terminating value (i.e, an 7n). See +Note [Extensions to GADTs Meet Their Match].7ghc-lib7 ty returns $q if ty has at least one constructor C such that: C has no equality constraints.C has no strict argument types.7See the "Strict argument type constraints" section of +Note [Extensions to GADTs Meet Their Match].7ghc-lib Generate all 7n*s for a given type. The result is either 6 tyf, if the type cannot be reduced to a closed algebraic type (or if it's one trivially inhabited, like 7), or 6 candidates, if it can. In this case, the candidates are the signature of the tycon, each one accompanied by the term- and type- constraints it gives rise to. See also Note [Checking EmptyCase Expressions]7ghc-libIA fake guard pattern (True <- _) used to represent cases we cannot handle7ghc-libECheck whether a guard pattern is generated by the checker (unhandled)7ghc-lib Generate a canFail" pattern vector of a specific type7ghc-lib,Create an empty list pattern of a given type7ghc-lib)Create a (non-overloaded) literal pattern7ghc-lib{Translate a list of patterns (Note: each pattern is translated to a pattern vector but we do not concatenate the results).7ghc-libTranslate a constructor pattern7ghc-lib8Translate a list of guard statements to a pattern vector7ghc-lib)Check whether a pattern can fail to match7ghc-lib&Translate a guard statement to Pattern7ghc-libTranslate let-bindings7ghc-libTranslate a pattern guard7ghc-libTranslate a boolean guard7ghc-libGet the type out of a PmPat. For guard patterns (ps <- e) we use the type of the first (or the single -WHEREVER IT IS- valid to use?) pattern7ghc-lib Generate an 7nV for a given conlike (generate fresh variables of the appropriate type for arguments)7ghc-libCreate a guard pattern7ghc-lib9Create a term equality of the form: `(False ~ (x ~ lit))`7ghc-lib/Create a term equality of the form: `(x ~ lit)`7ghc-libUCreate a term equality of the form: `(x ~ x)` (always discharged by the term oracle)7ghc-lib+Generate a variable pattern of a given type7ghc-lib6Generate many variable patterns, given a list of types7ghc-libGenerate a fresh  of a given type7ghc-libtGenerate a fresh term variable of a given and return it in two forms: * A variable pattern * A variable expression7ghc-lib)Convert a value abstraction an expression7ghc-libuConvert a pattern vector to a list of value abstractions by dropping the guards (See Note [Translating As Patterns])7ghc-libConvert a pattern to a list of value abstractions (will be either an empty list if the pattern is a guard pattern, or a singleton list in all other cases) by dropping the guards (See Note [Translating As Patterns])7ghc-libKCheck whether a data constructor is the only way to construct a data type.7ghc-lib{For a given conlike, finds all the sets of patterns which could be relevant to that conlike by consulting the result type.lThese come from two places. 1. From data constructors defined with the result type constructor. 2. From COMPLETE] pragmas which have the same type as the result type constructor. Note that we only use COMPLETE< pragmas *all* of whose pattern types match. See #141357ghc-lib7Check whether a set of type constraints is satisfiable.7ghc-lib%Compute the arity of a pattern vector7ghc-libCompute the arity of a pattern7ghc-libLift a pattern matching action from a single value vector abstration to a value set abstraction, but calling it on every vector and the combining the results.7ghc-libjGenerate the initial uncovered set. It initializes the delta with all term and type constraints in scope.7ghc-libfIncrease the counter for elapsed algorithm iterations, check that the limit is not exceeded and call 77ghc-libfIncrease the counter for elapsed algorithm iterations, check that the limit is not exceeded and call 77ghc-libfIncrease the counter for elapsed algorithm iterations, check that the limit is not exceeded and call 77ghc-libMatching function: Check simultaneously a clause (takes separately the patterns and the list of guards) for exhaustiveness, redundancy and inaccessibility.7ghc-libCheck the list of guards7ghc-libWWorker function: Implements all cases described in the paper for all three functions (covered,  uncovered and  divergent) apart from the Guard cases which are handled by 77ghc-libFInitialise with default values for covering and divergent information.7ghc-libCTake the tail of all value vector abstractions in the uncovered set7ghc-libRPrepend a value abstraction to all value vector abstractions in the uncovered set7ghc-lib"Given a data constructor of arity a^ and an uncovered set containing value vector abstractions of length `(a+n)`, pass the first nj value abstractions to the constructor (Hence, the resulting value vector abstractions will have length `n+1`)7ghc-libGet the union of two covered, uncovered and divergent value set abstractions. Since the covered and divergent sets are represented by a boolean, union means computing the logical or (at least one of the two is non-empty).7ghc-libFAdd a value vector abstraction to a value set abstraction (uncovered).7ghc-lib"Set the divergent set to not empty7ghc-lib2Set the divergent set to non-empty if the flag is $qghc-libGenerate equalities when checking a case expression: case x of { p1 -> e1; ... pn -> en } When we go deeper to check e.g. e1 we record two equalities: (x ~ y), where y is the initial uncovered when checking (p1; .. ; pn) and (x ~ p1).ghc-libGenerate a simple equality when checking a case expression: case x of { matches } When checking matches we record that (x ~ y) where y is the initial uncovered. All matches will have to satisfy this equality.ghc-libCheck whether any part of pattern match checking is enabled (does not matter whether it is the redundancy check or the exhaustiveness check).7ghc-libApply a term substitution to a value vector abstraction. All VAs are transformed to PmExpr (used only before pretty printing).7ghc-libWrap up the term oracle's state once solving is complete. Drop any information about unhandled constraints (involving HsExprs) and flatten (height 1) the substitution.7ghc-libBIssue all the warnings (coverage, exhaustiveness, inaccessibility)7ghc-libcIssue a warning when the predefined number of iterations is exceeded for the pattern match checker7ghc-libICheck whether the exhaustiveness checker should run (exhaustiveness only)7ghc-libLDenotes whether an exhaustiveness check is supported, and if so, via which 1 it's controlled. Returns $ if check is not supported.7ghc-libValue Set Abstractions7ghc-libPattern Vectors7ghc-libValue Abstractions7ghc-libPatterns7ghc-libCThe ambient term and type constraints (known to be satisfiable).ghc-libThe new term constraint.ghc-libThe new type constraints.ghc-libThe strict argument types.ghc-lib& delta if the constraints (deltaC) are satisfiable, and each strict argument type is inhabitable. $ otherwise.7ghc-libCThe ambient term and type constraints (known to be satisfiable).ghc-libThe new term constraint.ghc-libThe new type constraints.ghc-lib& delta if the constraints (delta) are satisfiable. $ otherwise.7ghc-libThe per- recursion depth limit.ghc-lib?The ambient term/type constraints (known to be satisfiable).ghc-libThe strict argument type.ghc-lib$qT if the strict argument type might be inhabited by a terminating value (i.e., an 7n). $rB if it is definitely uninhabitable by anything (except bottom). None%!! None%>HVghc-lib}Desugar top level binds, strict binds are treated like normal binds since there is no good time to force before first usage.ghc-libDesugar all other kind of bindings, Ids of strict binds are returned to later be forced in the binding group body, see Note [Desugar Strict binds]7ghc-lib7Desugar a single binding (or group of recursive binds).7ghc-libyThis is where we apply INLINE and INLINABLE pragmas. All we need to do is to attach the unfolding information to the Id.5Other decisions about whether to inline are made in calcUnfoldingGuidance_ but the decision about whether to then expose the unfolding in the interface file is made in J using this information.7ghc-lib Returns a CoreExpr :: TypeRep ty7ghc-libThe Ids of strict binds, to be forced in the body of the binding group see Note [Desugar Strict binds] and all bindings and their desugared right hand sides.7ghc-lib EvTerm for  Typeable tyghc-lib The type tyghc-libReturn CoreExpr :: TypeRep ty namely  typeRep# dictI Remember that typeRep# :: forall k (a::k). Typeable k a -> TypeRep a   None%HV<None%HV{ghc-lib Scrutineeghc-lib Match kindghc-libPattern it should matchghc-libReturn this if it matchesghc-libReturn this if it doesn't|ghc-libFor shadowing warning messagesghc-lib"Scrutinee, if we check a case exprghc-libMatches being desugaredghc-libResults (usually passed to })}ghc-libGVariables rep'ing the exprs we're matching with ^ See Note [Match Ids]ghc-libType of the case expressionghc-lib.Info about patterns, etc. (type synonym below)ghc-libDesugared result!z{|}}|{z None$%HV7ghc-lib'the desugared rhs of the bind statementghc-lib S in (>>=) :: Q -> (R -> S) -> TNone%HV5None%HV`Eghc-lib Variant of  that ensures that the result is not levity polymorphic. This should be used when the resulting expression will be an argument to some other function. See Note [Levity polymorphism checking] in DsMonad See Note [Levity polymorphism invariants] in CoreSyn7ghc-lib4The longest list length which we will desugar using build.This is essentially a magic number and its setting is unfortunate rather arbitrary. The idea here, as mentioned in Note [Desugaring explicit lists], is to avoid deforesting large static data into large(r) code. Ideally we'd want a smaller threshold with larger consumers and vice-versa, but we have no way of knowing what will be consuming our list in the desugaring impossible to set generally correctly.0The effect of reducing this number will be that buildP fusion is applied less often. From a runtime performance perspective, applying build more liberally on "moderately" sized lists should rarely hurt and will often it can only expose further optimization opportunities; if no fusion is possible it will eventually get rule-rewritten back to a list). We do, however, pay in compile time.7ghc-libTakes an expression and its instantiated type. If the expression is an HsVar with a hasNoBinding primop and the type has levity-polymorphic arguments, issue an error. See Note [Detecting forced eta expansion]7ghc-libIs this a hasNoBinding Id with a levity-polymorphic type? Returns the arguments that are levity polymorphic if they are bad; or an empty list otherwise See Note [Detecting forced eta expansion]~"~"None%HVghc-lib"Main entry point to the desugarer.None%2=>?HVXkC7ghc-libUsed to collect type info7ghc-libThe main worker class7ghc-libkdefined so that HsImplicitBndrs and HsWildCardBndrs can know what their implicit bindings are scoping over7ghc-libzFirst scope remains constant Second scope is used to build up the scope of a tyvar over things to its right, ala RScoped7ghc-lib Pattern scope7ghc-libScope spans over everything to the right of a, (mostly) not including a itself (Includes a in a few special cases like recursive do bindings) or let/where bindings7ghc-libcontext for type signatures7ghc-lib#context for pattern synonym fields.7ghc-libcontext for imports/exports7ghc-libcontext for imports/exports7ghc-libcontext for record fieldsghc-lib Construct an  b% from the outputs of the typechecker.7ghc-lib2Each element scopes over the elements to the right7ghc-lib7 specialised to 7 things7ghc-lib7 specialised to 7 things 6ghc-libDummy instances - never called Cghc-lib!This instance tries to construct  J nodes which include the type of the expression. It is not yet possible to do this efficiently for all expression forms, so we skip filling in the type for those inputs.7, for example, doesn't have any type information available directly on the node. Our next recourse would be to desugar it into a CoreExpr then query the type of that. Yet both the desugaring call and the type query both involve recursive calls to the function and argument! This is particularly problematic when you realize that the HIE traversal will eventually visit those nodes too and ask for their types again.tSince the above is quite costly, we just skip cases where computing the expression's type is going to be expensive. See #162337ghc-libuse site of the patternghc-lib*pattern to the right of a, not including aNoneށ J K L M N O P Q R S T U V W X Y Z [ K L P Q R S O M N J T U V X W Y Z [NoneG ` a ` aNoneP%7ghc-lib@A mapping from binders to the Ids they were expanded/renamed to.x :-> MultiVal [a,b,c] in rhoiiff x's typePrimRep is not a singleton, or equivalently x's type is an unboxed tuple, sum or void.x :-> UnaryVal x'\iff x's RepType is UnaryRep or equivalently x's type is not unboxed tuple, sum or void.MSo x :-> MultiVal [a] in rho means x is represented by singleton tuple.*x :-> MultiVal [] in rho means x is void.mINVARIANT: OutStgArgs in the range only have NvUnaryTypes (i.e. no unboxed tuples, sums or voids)7ghc-lib:Extend the environment, checking the UnariseEnv invariant.7ghc-libUMake alternatives that match on the tag of a sum (i.e. generate LitAlts for the tag)7ghc-lib:Build a unboxed sum term from arguments of an alternative.Example, for ( x | ) :: ( ( ) | Int  ) we call mkUbxSum ( _ | ) [ ( ), Int ] [ voidPrimId ] which returns  1#, rubbish 7ghc-lib:MultiVal a function argument. Never returns an empty list.7ghc-libIMultiVal a DataCon argument. Returns an empty list when argument is void. b bNone>HMV7ghc-libOptional Stg-to-Stg passes.7ghc-lib Common subexpression elimination7ghc-libXLambda lifting closure variables, trading stack/register allocation for heap allocation7ghc-lib@Mandatory unarise pass, desugaring unboxed tuple and sum binders7ghc-libUseful for building up 77ghc-lib;Which Stg-to-Stg passes to run. Depends on flags, ways etc. d dNone24IP kghc-libMaps indexed by  keys k l m n o p q r s t u v w x y z { | } ~   k l m n o p q r s t u v w x y z { | } ~  None7ghc-libJTries to find a suitable dummy RHS to bind the given absent identifier to.If mk_absent_let _ id == Just wrap, then wrap e will wrap a let binding for id with that RHS around e[. Otherwise, there could no suitable RHS be found (currently only happens for bindings of . representation).  None]  None  None7ghc-lib(If given the RHS of a let-binding, this 7c determines whether we should process the binding up (body before rhs) or down (rhs before body).We use LetDown if there is a chance to get a useful strictness signature. This is the case when there are manifest value lambdas or the binding is a join point (hence always acts like a function, not a value).7ghc-lib@Extend an environment with the strictness IDs attached to the id  None  Safe ~ ghc-libmaybeFlipCond c returns Just c'= if it is possible to flip the arguments to the conditional c", and the new condition should be c'. ghc-lib If we apply maybeInvertCondU to the condition of a jump we turn jumps taken into jumps not taken and vice versa.Careful! If the used comparison and the conditional jump don't match the above behaviour will NOT hold. When used for FP comparisons this does not consider unordered numbers. Also inverting twice might return a synonym for the original condition.  None ghc-libregSqueeze_class reg Calculate the maximum number of register colors that could be denied to a node of this class due to having this reg as a neighbour. ghc-lib&The complete set of machine registers. ghc-libTake the class of a register. ghc-lib.Get the name of the register with this number.! ghc-libCthese are the regs which we cannot assume stay alive over a C call. ghc-lib3desired stack offset in bytes, positive or negativeY !!!!!!!!!! ! ! ! ! !!!!Y ! !! ! !!!!!!!!!! ! ! !!None!!!!None!!!!!!!!!!!!NoneHV9Q 7ghc-libHReturns which registers are read and written as a (read, written) pair.7ghc-lib8Is this register interesting for the register allocator?7ghc-lib~Applies the supplied function to all registers in instructions. Typically used to change virtual registers to real registers.7ghc-libMake a spill instruction.7ghc-lib Make a spill reload instruction.7ghc-lib?See if this instruction is telling us the current C stack delta7ghc-libMake a reg-reg move instruction. On SPARC v8 there are no instructions to move directly between floating point and integer regs. If we need to do that then we have to go via memory.7ghc-libCheck whether an instruction represents a reg-reg move. The register allocator attempts to eliminate reg->reg moves whenever it can, by assigning the src and dest temporaries to the same real register.7ghc-lib)Make an unconditional branch instruction.7ghc-libUOn most OSes the kernel will place a guard page after the current stack page. If you allocate larger than a page worth you may jump over this guard page. Not only is this a security issue, but on certain OSes such as Windows a new page won't be allocated if you don't hit the guard. This will cause a segfault or access fault.This function defines if the current allocation amount requires a probe. On Windows (for now) we emit a call to _chkstk for this. For other OSes this is not yet implemented. See  Ghttps://docs.microsoft.com/en-us/windows/desktop/DevNotes/-win32-chkstk& The Windows stack looks like this: SP ; GUARD PAGE c UNMAPPED In essense each allocation larger than a page size needs to be chunked and a probe emitted after each page allocation. You have to hit the guard page so the kernel can map in the next page, otherwise you'll segfault.!ghc-lib-Instruction instance for x86 instruction set.n!!!!!!! !!!"!#!$!%!&!l!'!(!)!*!+!,!-!.!/!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!m!n!o!p!q!r!s!t!u!v!w!x!y!z!{!|!}!~!!!!!!!!!n!&!l!'!(!)!*!+!,!-!.!/!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!m!n!o!p!q!r!s!t!u!v!w!x!y!z!{!|!}!~!!!!! !!!"!#!$!%!!!!!!!!!!!None?7ghc-libOutput the ELF .size directive.7ghc-lib@Print section header and appropriate alignment for that section.7ghc-lib7Print appropriate alignment for the given section type.!!!!!!!!!!!! None_m!ghc-libISPARC instruction set. Not complete. This is only the ones we need.!ghc-libRegister or immediate!ghc-libiCheck if a RI represents a zero value. - a literal zero - register %g0, which is always zero.!ghc-lib^Calculate the effective address which would be used by the corresponding fpRel sequence.!ghc-lib+Code to shift the stack pointer by n words.!ghc-libEAn instruction that will cause the one after it never to be exectuted7ghc-libregUsage returns the sets of src and destination registers used by a particular instruction. Machine registers that are pre-allocated to stgRegs are filtered out, because they are uninteresting from a register allocation standpoint. (We wouldn't want them to end up on the free list!) As far as we are concerned, the fixed registers simply don't exist (for allocation purposes, anyway).7ghc-lib\Interesting regs are virtuals, or ones that are allocatable by the register allocator.7ghc-libJApply a given mapping to tall the register references in this instruction.7ghc-lib[Make a spill instruction. On SPARC we spill below frame pointer leaving 2 words/spill7ghc-lib Make a spill reload instruction.7ghc-lib?See if this instruction is telling us the current C stack delta7ghc-libMake a reg-reg move instruction. On SPARC v8 there are no instructions to move directly between floating point and integer regs. If we need to do that then we have to go via memory.7ghc-libCheck whether an instruction represents a reg-reg move. The register allocator attempts to eliminate reg->reg moves whenever it can, by assigning the src and dest temporaries to the same real register.7ghc-lib)Make an unconditional branch instruction.!ghc-lib"instance for sparc instruction set7ghc-libregister to spillghc-libcurrent stack deltaghc-libspill slot to use7ghc-libregister to load intoghc-libcurrent stack deltaghc-libspill slot to use1!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!1!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!Nonea+!!!!!!!!!!!!!!!!"Noneqg7ghc-libPretty print a register.8ghc-libPretty print a register name, based on this register number. The definition has been unfolded so we get a jump-table in the object code. This function is called quite a lot when emitting the asm file..!ghc-lib0Pretty print a format for an instruction suffix.8ghc-libbPretty print a format for an instruction suffix. eg LD is 32bit on sparc, but LDD is 64 bit.8ghc-libPretty print a condition code.8ghc-libPretty print an address mode.!ghc-lib Pretty print an immediate value.8ghc-libPretty print a section / segment header. On SPARC all the data sections must be at least 8 byte aligned incase we store doubles in them.8ghc-lib7Print appropriate alignment for the given section type.!ghc-libPretty print a data item.!ghc-libPretty print an instruction.8ghc-libPretty print a RI8ghc-lib#Pretty print a two reg instruction.8ghc-lib%Pretty print a three reg instruction.8 ghc-lib1Pretty print an instruction of two regs and a ri.!!!!!!!!!!!!!!#Nonerw!ghc-libEnforce intra-block invariants.!!$Nonez!ghc-lib9Expand out synthetic instructions in this top level thing8 ghc-lib/Expand out synthetic instructions in this block8 ghc-libExpand out some instructions8 ghc-libIn the SPARC instruction set the FP register pairs that are used to hold 64 bit floats are refered to by just the first reg of the pair. Remap our internal reg pairs to the appropriate reg.-For example: ldd [%l1], (%f0 | %f1)'gets mapped to ldd [$l1], %f08 ghc-lib$The high partner for this float reg.!!%None!ghc-libCode to produce a result into a register. If the result must go in a specific register, it comes out as Fixed. Otherwise, the parent can decide which register to put it in.!ghc-lib,Holds code that references a memory address.!ghc-liba.k.a  Register64{ Reg is the lower 32-bit temporary which contains the result. Use getHiVRegFromLo to find the other VRegUnique.fRules of this simplified insn selection game are therefore that the returned Reg may be modified!ghc-lib#Condition codes passed up the tree.!ghc-lib!s are the insn sequences generated by the insn selectors. They are really trees of insns to facilitate fast appending, where a left-to-right traversal yields the insns in the correct order.!ghc-lib&Change the format field in a Register.!ghc-libGrab the Reg for a CmmReg !!!!!!!!!!!!! !!!!!!!!!!!!!&None!ghc-lib9Holds interesting statistics from the register allocator.!ghc-libInitial code, with liveness.!ghc-libThe initial, uncolored graph.!ghc-lib/Information to help choose which regs to spill.!ghc-lib(Code we tried to allocate registers for.!ghc-libThe regs that were coalesced.!ghc-libSpiller stats.!ghc-lib#Code with spill instructions added.!ghc-libCoalesced and colored graph.!ghc-libCode with coalescings applied.!ghc-lib"Code with vregs replaced by hregs.!ghc-lib-Code with unneeded spill/reloads cleaned out.!ghc-lib Final code.!ghc-lib0Spill/reload/reg-reg moves present in this code.!ghc-lib;Do all the different analysis on this list of RegAllocStats!ghc-libJDump a table of how many spill loads / stores were inserted for each vreg.!ghc-libDDump a table of how long vregs tend to live for in the initial code.!ghc-libJDump a table of how many conflicts vregs tend to have in the initial code.!ghc-libgFor every vreg, dump how many conflicts it has, and its lifetime. Good for making a scatter plot.!ghc-lib Count spillreloadJreg-reg moves. Lets us see how well the register allocator has done.!ghc-libglobal register conflict graph!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!'NoneX88ghc-lib5The maximum number of build/spill cycles we'll allow.It should only take 3 or 4 cycles for the allocator to converge. If it takes any longer than this it's probably in an infinite loop, so it's better just to bail out and report a bug.!ghc-lib7The top level of the graph coloring register allocator.8ghc-lib;Perform solver iterations for the graph coloring allocator.We extract a register confict graph from the provided cmm code, and try to colour it. If that works then we use the solution rewrite the code with real hregs. If coloring doesn't work we add spill code and try to colour it again. After 8 iterations we give up.8ghc-libFBuild a graph from the liveness and coalesce information in this code.8ghc-liblAdd some conflict edges to the graph. Conflicts between virtual and real regs are recorded as exclusions.8ghc-libpAdd some coalesence edges to the graph Coalesences between virtual and real regs are recorded as preferences.8ghc-libCPatch registers in code using the reg -> reg mapping in this graph.!ghc-lib#registers we can use for allocationghc-libset of available spill slots.ghc-libcurrent number of spill slotsghc-lib)code annotated with liveness information.ghc-lib CFG of basic blocks if availableghc-libacode with registers allocated, additional stacks required and stats for each stage of allocation8ghc-lib4Number of solver iterations we've already performed.ghc-libGFunction for calculating whether a register is trivially colourable.ghc-lib$Free registers that we can allocate.ghc-lib!Free stack slots that we can use.ghc-libNumber of spill slots in useghc-lib!Current regalloc stats to add to.ghc-lib$Liveness annotated code to allocate.!!(None֎8ghc-lib5Get the registers that are being used by this instruction. regUsage doesn't need to do any trickery for jumps and such. Just state precisely the regs read and written by that insn. The consequences of control flow transfers, as far as register allocation goes, are taken care of by the register allocator.8ghc-libJApply a given mapping to all the register references in this instruction.8ghc-libChecks whether this instruction is a jump/branch instruction. One that can change the flow of control in a way that the register allocator needs to worry about.8ghc-libChecks whether this instruction is a jump/branch instruction. One that can change the flow of control in a way that the register allocator needs to worry about.8ghc-libyChange the destination of this jump instruction. Used in the linear allocator when adding fixup blocks for join points.8ghc-lib5An instruction to spill a register into a spill slot."Mghc-libOThe size of a minimal stackframe header including minimal parameter save area.8ghc-lib&The maximum number of bytes required to spill a register. PPC32 has 32-bit GPRs and 64-bit FPRs, while PPC64 has 64-bit GPRs and 64-bit FPRs. So the maximum is 8 regardless of platforms unlike x86. Note that AltiVec's vector registers are 128-bit wide so we must not use this to spill them."Nghc-lib<The number of spill slots available without allocating more.8ghc-libThe number of bytes that the stack pointer should be aligned to. This is 16 both on PPC32 and PPC64 ELF (see ELF processor specific supplements).8ghc-lib=Convert a spill slot number to a *byte* offset, with no sign.8ghc-lib?See if this instruction is telling us the current C stack delta8ghc-libQCopy the value in a register to another one. Must work for all register classes.8ghc-lib'Make an unconditional jump instruction.8 ghc-libaTake the source and destination from this reg -> reg move instruction or Nothing if it's not one"Pghc-lib Instruction instance for powerpcT!""-"!!!"""#"$"'")"."G"8" "C""1"9"5";"7":"6""""""""""" " " " """"""""""""" "!"""%"&"("*"+","/"0"2"3"4"<"=">"?"@"A"B"D"E"F"H"I"J"K"L"M"N"OT"K"H"I"J!""-"!!!"""#"$"'")"."G"8" "C""1"9"5";"7":"6""""""""""" " " " """"""""""""" "!"""%"&"("*"+","/"0"2"3"4"<"=">"?"@"A"B"D"E"F"M"N"L"O)Nonel"Q"R"S"T"U"V"Q"R"S"T"U"V*None8!ghc-lib7Print appropriate alignment for the given section type."X"X+Nonem"gghc-libHaving a CFG with additional information is essential for some operations. However we can't reconstruct all information once we generated instructions. So instead we update the CFG as we go."ughc-libRThe list of block ids records the redirected jumps to allow us to update the CFG."wghc-libJgiven the instruction sequence of a block, produce a list of the block's ts See Note [What is this unwinding business?] in Debug and Note [Unwinding information in the NCG] in this module."xghc-lib5Turn the sequence of `jcc l1; jmp l2` into `jncc l2;  block_l1` when possible."ghc-lib%Record that we added a block between from and old."ghc-libPlace 8" after block' and change any edges block -> X to 8" -> X4"Z"["\"]"^"_"`"a"b"c"d"e"f"g"h"i"j"k"q"p"l"m"o"n"r"w"x"s"t"u"v"y"z"{"|"}"~""""""""""""""4"h"i"j"k"q"p"l"m"o"n"r"w"x"s"t"u"v"\"]"^"_"`"a"b"c"d"e"f"g"y"Z"z"""""|"{"~"}"""""""""""[-NoneC"""""".None"ghc-lib,Generate code to reference a memory address."ghc-libexpr producing an address""/Nonex"ghc-lib(Code to assign a 64 bit value to memory."ghc-lib,Code to assign a 64 bit value to a register."ghc-lib6Get the value of an expression into a 64 bit register."ghc-lib&expr producing the destination addressghc-lib expr producing the source value."ghc-libthe destination registerghc-libexpr producing the source value"""""",None "ghc-lib*Make code to evaluate a 32 bit expression."ghc-libfThe dual to getAnyReg: compute an expression into a register, but we don't mind which one it is.8#ghc-libsign extend and widen8$ghc-libFor nop word format conversions we set the resulting value to have the required size, but don't need to generate any actual code.8%ghc-lib)Generate an integer division instruction.8&ghc-libDo an integer remainder.NOTE: The SPARC v8 architecture manual says that integer division instructions _may_ generate a remainder, depending on the implementation. If so it is _recommended_ that the remainder is placed in the Y register.@The UltraSparc 2007 manual says Y is _undefined_ after division.The SPARC T2 doesn't store the remainder, not sure about the others. It's probably best not to worry about it, and just generate our own remainders.8'ghc-lib(Coerce a integer value to floating point8(ghc-lib(Coerce a floating point value to integerNOTE: On sparc v9 there are no instructions to move a value from an FP register directly to an int register, so we have to use a load/store.8)ghc-libCCoerce a double precision floating point value to single precision.8*ghc-libBCoerce a single precision floating point value to double precision8#ghc-libwidth of source expressionghc-libwidth of resultghc-libsource expression""""0None8+ghc-libaSays what we have to add to our 'PIC base register' in order to get the address of a label. """"""""""""" """""""""""""1None&'\*~8,ghc-lib+Memory addressing modes passed up the tree.8-ghc-libRegister's passed up the tree. If the stix code forces the register to live in a pre-decided machine register, it comes out as Fixed#; otherwise, it comes out as Any>, and the parent can decide which register to put it in.8.ghc-liba.k.a  Register64{ Reg is the lower 32-bit temporary which contains the result. Use getHiVRegFromLo to find the other VRegUnique.fRules of this simplified insn selection game are therefore that the returned Reg may be modified8/ghc-lib#Condition codes passed up the tree."ghc-lib"s are the insn sequences generated by the insn selectors. They are really trees of insns to facilitate fast appending, where a left-to-right traversal yields the insns in the correct order.80ghc-libConvert !, instructions into !+) instructions to capture changes in the spM register. See Note [What is this unwinding business?] in Debug for details.81ghc-libbidm refers to the current block and is used to update the CFG if new blocks are inserted in the control flow.82ghc-libGrab the Reg for a CmmReg83ghc-lib Check whether an integer will fit in 32 bits. A CmmInt is intended to be truncated to the appropriate number of bits, so here we truncate it to Int64. This is important because e.g. -1 as a CmmInt might be either -1 or 18446744073709551615.84ghc-lib(Convert a BlockId to some CmmStatic data85ghc-libfThe dual to getAnyReg: compute an expression into a register, but we don't mind which one it is.86ghc-libLike 87, but on 32-bit use simple register addressing (i.e. no index register). This stops us from running out of registers on x86 when using instructions such as cmpxchg, which can use up to three virtual registers and one fixed register.88ghc-libGiven a 8-, produce a new 8-O with an instruction block which will check the value for alignment. Used for -falignment-sanitisation.89ghc-lib%We return the instructions generated."ghc-libThis works on the invariant that all jumps in the given blocks are required. Starting from there we try to make a few more jumps redundant by reordering them.""""""""""2None&'8 "ghc-libTop level code generation8:ghc-libDo code generation on a single block of CMM code. code generation may introduce new basic block boundaries, which are indicated by the NEWBLOCK instruction. We must split up the instruction stream into basic blocks again. Also, we extract LDATAs here too.8;ghc-lib2Convert some Cmm statements to SPARC instructions.8<ghc-lib(Convert a BlockId to some CmmStatic data8=ghc-libXGenerate code to calculate an argument, and move it into one or two integer vregs.8>ghc-libzMove args from the integer vregs into which they have been marshalled, into %o0 .. %o5, and the rest onto the stack.8?ghc-libHAssign results returned from the call into their destination regs.8@ghc-libDGenerate a call to implement an out-of-line floating point operation8Aghc-lib:Decide what C function to use to implement a CallishMachOp!""""!3None&'F8Bghc-libRegister's passed up the tree. If the stix code forces the register to live in a pre-decided machine register, it comes out as Fixed#; otherwise, it comes out as Any>, and the parent can decide which register to put it in."ghc-lib"s are the insn sequences generated by the insn selectors. They are really trees of insns to facilitate fast appending, where a left-to-right traversal yields the insns in the correct order."ghc-lib"s are the insn sequences generated by the insn selectors. They are really trees of insns to facilitate fast appending, where a left-to-right traversal (pre-order?) yields the insns in the correct order.8Cghc-libGrab the Reg for a CmmReg8Dghc-lib(Convert a BlockId to some CmmStatic data8Eghc-libOCompute an expression into a register, but we don't mind which one it is.""""""4NoneHVXZh8Fghc-lib`A non empty ordered sequence of basic blocks. It is suitable for serialization in this order.YWe use OrdList instead of [] to allow fast append on both sides when combining chains.8Gghc-libMaps blocks near the end of a chain to it's chain AND the other blocks near the end. [A,B,C,D,E] Gives entries like (B -> ([A,B], [A,B,C,D,E])) where [A,B] are blocks in the end region of a chain. This is cheaper then recomputing the ends multiple times.8Hghc-libRLook at X number of blocks in two chains to determine if they are "neighbours".8Ighc-libYOnly edges heavier than this are considered for fusing two chains into a single chain.8Jghc-libgGiven the Chain A -> B -> C -> D and we break at C we get the two Chains (A -> B, C -> D) as result.8Kghc-libFor a given list of chains try to fuse chains with strong edges between them into a single chain. Returns the list of fused chains together with a set of used edges. The set of edges is indirectly encoded in the chains so doesn't need to be considered for later passes.8Lghc-lib]For a given list of chains and edges try to combine chains with strong edges between them."ghc-lib=Non deterministic! (Uniques) Sorts edges by weight and nodes.""5NoneZ""""""""""""""6None[""""""""""""""7None[""""""""""""8Nones"ghc-libFor a jump instruction at the end of a block, generate fixup code so its vregs are in the correct regs for its destination.8Mghc-lib.Construct a graph of register/spill movements.1Cyclic components seem to occur only very rarely.We cut some corners by not handling memory-to-memory moves. This shouldn't happen because every temporary gets its own stack slot.8Nghc-libdExpand out the destination, so InBoth destinations turn into a combination of InReg and InMem.8Oghc-libGenerate fixup code for a particular component in the move graph This component tells us what values need to be moved to what destinations. We have eliminated any possibility of single-node cycles in expandNode above.8Pghc-lib(Move a vreg between these two locations."ghc-libnmaps the unique of the blockid to the set of vregs that are known to be live on the entry to each block.ghc-libid of the current blockghc-lib,branch instr on the end of the source block.8Qghc-libnmaps the unique of the blockid to the set of vregs that are known to be live on the entry to each block.ghc-libacc blocks of fixup code.ghc-libid of the current blockghc-lib,branch instr on the end of the source block.ghc-lib&branch destinations still to consider.8Nghc-libsource of moveghc-libdestination of move8Pghc-libcurrent C stack delta.ghc-lib%unique of the vreg that we're moving.ghc-libsource location.ghc-libdestination location.ghc-libmove instruction.""9NoneX;8Rghc-libDo register allocation on some basic blocks. But be careful to allocate a block in an SCC only if it has an entry in the block map or it is the first block.8Sghc-lib*Do register allocation on this basic block8Tghc-libmLoad the freeregs and current reg assignment into the RegM state for the basic block with this BlockId.8Ughc-lib-Do allocation for a sequence of instructions.8Vghc-lib'Do allocation for a single instruction.8Wghc-libQMark all these real regs as allocated, and kick out their vreg assignments.8Xghc-lib:Calculate a new location after a register has been loaded.8Yghc-lib=Load up a spilled temporary if we need to (read from memory).8Rghc-lib entry pointsghc-lib&live regs on entry to each basic blockghc-lib$instructions annotated with "deaths"8Zghc-lib entry pointsghc-lib&live regs on entry to each basic blockghc-lib$instructions annotated with "deaths"8Sghc-lib&live regs on entry to each basic blockghc-lib"block to do register allocation onghc-libblock with registers allocated8Ughc-lib2map of what vregs are live on entry to each block.ghc-lib/accumulator for instructions already processed.ghc-lib%accumulator for blocks of fixup code.ghc-lib'id of the current block, for debugging.ghc-lib.liveness annotated instructions in this block.8Vghc-lib2map of what vregs are love on entry to each block.ghc-lib/accumulator for instructions already processed.ghc-lib*the id of the current block, for debuggingghc-lib9the instr to have its regs allocated, with liveness info."":NoneW"ghc-libLanguage ID used for Haskell.#,ghc-lib.Mapping of registers to DWARF register numbers#-ghc-lib2Virtual register number to use for return address.V""""""""""""""""""""""""""""""""""""""""########## # # # # ################### #!#"###$#%#&#'#(#)#*#+#,#-V""""""""""""""""""""""""""""""""""""""""########## # # # # ################### #!#"###$#%#&#'#(#)#*#+#,#-;NoneԳ&#.ghc-libIUnwind instructions for a block. Will become part of the containing FDE.#1ghc-libLthese unwind points must occur in the same order as they occur in the block#2ghc-liblUnwind instructions for an individual procedure. Corresponds to a "Frame Description Entry" (FDE) in DWARF.#6ghc-lib%List of blocks. Order must match asm!#7ghc-libxInformation about unwind instructions for a procedure. This corresponds to a "Common Information Entry" (CIE) in DWARF.#<ghc-libA DWARF address range. This is used by the debugger to quickly locate which compilation unit a given address belongs to. This type assumes a non-segmented address-space.8[ghc-lib;Abbreviation codes used for encoding above records in the  .debug_info section.8\ghc-lib)Pseudo, used for marking the end of lists#@ghc-libGIndividual dwarf records. Each one will be encoded as an entry in the  .debug_info section.#Mghc-lib)label of DIE belonging to the parent tick8]ghc-lib1Generate assembly for the given abbreviation code#Pghc-libUAbbreviation declaration. This explains the binary encoding we use for representing #@1. Be aware that this must be updated along with #Q.#Qghc-lib Generate assembly for DWARF data8^ghc-libtPrints assembler data corresponding to DWARF info records. Note that the binary format of this is parameterized in  abbrevDecls and has to be kept in synch.8_ghc-lib'Close a DWARF info record with children#Rghc-lib4Print assembler directives corresponding to a DWARF .debug_aranges address table entry.#Sghc-libHeader for the  .debug_frame section. Here we emit the "Common Information Entry" record that etablishes general call frame parameters and the default stack layout.8`ghc-libWrites a "Frame Description Entry" for a procedure. This consists mainly of referencing the CIE and writing state machine instructions to describe how the frame base (CFA) changes.8aghc-libGenerates unwind information for a block. We only generate instructions where unwind information actually changes. This small optimisations saves a lot of space, as subsequent blocks often have the same unwind information.8bghc-lib+Get DWARF register ID for a given GlobalReg8cghc-lib~Generate code for setting the unwind information for a register, optimized using its known old value in the table. Note that Sp/ is special: We see it as synonym for the CFA.8dghc-lib'Print the register number of the given  ' as an unsigned LEB128 encoded number.8eghc-libBGenerates a DWARF expression for the given unwind expression. If spIsCFA is true, we see Sp0 as the frame base CFA where it gets mentioned.8fghc-libGGenerate code for re-setting the unwind information for a register to  undefined#Tghc-lib)Align assembly at (machine) word boundary#Ughc-lib1Assembly for a single byte of constant DWARF data#Vghc-lib(Assembly for a two-byte constant integer8gghc-lib"Assembly for a constant DWARF flag#Wghc-lib*Assembly for 4 bytes of dynamic DWARF data8hghc-lib+Assembly for 4 bytes of constant DWARF data#Xghc-libaAssembly for a DWARF word of dynamic data. This means 32 bit, as we are generating 32 bit DWARF.#Yghc-liboAssembly for a machine word of dynamic data. Depends on the architecture we are currently generating code for.#Zghc-libPrints a number in "little endian base 128" format. The idea is to optimize for small numbers by stopping once all further bytes would be 0. The highest bit in every byte signals whether there are further bytes to read.#[ghc-libSame as  pprLEBWord, but for a signed number8ighc-lib{Generates a dynamic null-terminated string. If required the caller needs to make sure that the string is escaped properly.8jghc-lib>Generate a string constant. We take care to escape the string.8kghc-lib%Escape a single non-unicode character#\ghc-libGenerate an offset into another section. This is tricky because this is handled differently depending on platform: Mac Os expects us to calculate the offset using assembler arithmetic. Linux expects us to just reference the target directly, and will figure out on their own that we actually need an offset. Finally, Windows has a special directive to refer to relative offsets. Fun.8cghc-lib4the register to produce an unwinding table entry forghc-lib&the old and new values of the register/#.#/#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#Q#P#<#=#>#?#R#7#8#9#:#;#2#3#4#5#6#.#/#0#1#S#U#V#W#X#Y#Z#[#T#\<None{ #`ghc-lib Generate DWARF/debug information8lghc-libBuild an address range entry for one proc. With split sections, each proc needs its own entry, since they may get scattered in the final binary. Without split sections, we could make a single arange based on the first/last proc.8mghc-libEHeader for a compilation unit, establishing global format parameters8nghc-libCCompilation unit footer, mainly establishing size of debug sections8oghc-libSplits the blocks by procedures. In the result all nested blocks will come from the same procedure as the top-level block. See Note [Splitting DebugBlocks] for details.8pghc-lib/Generate DWARF info for a procedure debug block8qghc-libGenerate DWARF info for a block8rghc-librGenerates the data for the debug frame section, which encodes the desired stack unwind behaviour for the debugger8sghc-lib8Generates unwind information for a procedure debug block#`#`=None&'X?8tghc-libuData accumulated during code generation. Mostly about statistics, but also collects debug data for DWARF generation.8ughc-libNative code generated, for statistics. This might hold a lot of data, so it is important to clear this field as early as possible if it isn't actually required.8vghc-libbsee Note [Unwinding information in the NCG] and Note [What is this unwinding business?] in Debug.8wghc-lib,Do native code generation on all these cmms.#cghc-libComplete native code generation phase for a single top-level chunk of Cmm. Dumping the output of each stage along the way. Global conflict graph and NGC stats8xghc-libLMake sure all blocks we want the layout algorithm to place have been placed.8yghc-lib6Compute unwinding tables for the blocks of a procedure8zghc-lib Build a doc for all the imports.#cghc-libthe cmm to generate code forghc-lib!sequence number of this top thing8yghc-lib+the native code generated for the procedureghc-lib?unwinding tables for all points of all blocks of the procedure"h"i"j"k"q"p"l"m"o"n"r"w"x"s"t"u"v#a#b#c#a#c"h"i"j"k"q"p"l"m"o"n"r"w"x"s"t"u"v#b>None,#ighc-lib8additional files to be compiled with with the C compiler#i#j#i#jNoneF\H8{ghc-libVlog warning in the monad, and if there are errors then throw a SourceError exception.8|ghc-libkLog warnings and throw errors, assuming the messages contain at least one error (e.g. coming from PFailed)#nghc-lib<Deal with errors and warnings returned by a compilation stepIn order to reduce dependencies to other parts of the compiler, functions outside the "main" parts of GHC return warnings and errors as a parameter and signal success via by wrapping the result in a 8}_ type. This function logs the returned warnings and propagates errors as exceptions (of type $)./This function assumes the following invariants: {If the second result indicates success (is of the form 'Just x'), there must be no error messages in the first result.If there are no error messages, but the second result indicates failure there should be warnings in the first result. That is, if the action failed, it must have been due to the warnings (i.e., -Werror).8~ghc-libBlike ioMsgMaybe, except that we ignore error messages and return $ instead.#oghc-lib+Lookup things in the compiler's environment#tghc-libRename some import declarations#ughc-lib+parse a file, returning the abstract syntax8ghc-libFIf the renamed source has been kept, extract it. Dump it if requested.#wghc-libHRename and typecheck a module, additionally returning the renamed syntax8ghc-libBRename and typecheck a module, but don't return the renamed syntax#yghc-lib$Convert a typechecked module to Core#{ghc-libMake a *o` from the results of typechecking. Used when typechecking only, as opposed to full compilation.8ghc-libThis function runs GHC's frontend with recompilation avoidance. Specifically, it checks if recompilation is needed, and if it is, it parses and typechecks the input module. It does not write out the results of typechecking (See compileOne and hscIncrementalCompile).#ghc-libGiven a +, parses and typechecks it, returning the &j resulting from type-checking.8ghc-libCheck that the safe imports of the module being compiled are valid. If not we either issue a compilation error if the module is explicitly using Safe Haskell, or mark the module as unsafe if we're in safe inference mode.8ghc-libValidate that safe imported modules are actually safe. For modules in the HomePackage (the package the module we are compiling in resides) this just involves checking its trust type is Safe or  Trustworthy. For modules that reside in another package we also must check that the external package is trusted. See the Note [Safe Haskell Trust Check] above for more information.WThe code for this is quite tricky as the whole algorithm is done in a few distinct phases in different parts of the code base. See RnNames.rnImportDecl for where package trust dependencies for a module are collected and unioned. Specifically see the Note [RnNames . Tracking Trust Transitively] and the Note [RnNames . Trust Own Package].#ghc-lib&Check that a module is safe to import.We return True to indicate the import is safe and False otherwise although in the False case an exception may be thrown first.#ghc-libGReturn if a module is trusted and the pkgs it depends on to be trusted.8ghc-lib.Is a module trusted? If not, throw or log errors depending on the type. Return (regardless of trusted or not) if the trust type requires the modules own package be trusted and a list of other packages required to be trusted (these later ones haven't been checked) but the own package trust has been.8ghc-lib'Check the list of packages are trusted.8ghc-lib>Set module to unsafe and (potentially) wipe trust information.Make sure to call this method to set a module to inferred unsafe, it should be a central and single failure method. We only wipe the trust information when we aren't in a specific Safe Haskell mode.While we only use this for recording that a module was inferred unsafe, we may call it on modules using Trustworthy or Unsafe flags so as to allow warning flags for safety to function correctly. See Note [Safe Haskell Inference].8ghc-lib.Figure out the final correct safe haskell mode#ghc-libCompile to hard-code.#ghc-lib9Compile a stmt all the way to an HValue, but don't run itWWe return Nothing to indicate an empty statement (or comment only), not a parse error.#ghc-lib9Compile a stmt all the way to an HValue, but don't run itWWe return Nothing to indicate an empty statement (or comment only), not a parse error.#ghc-libCompile a decls#ghc-libCompile a decls#ghc-lib|Load the given static-pointer table entries into the interpreter. See Note [Grand plan for static forms] in StaticPtrTable.#ghc-lib*Typecheck an expression (but don't run it)#ghc-lib-Find the kind of a type, after generalisation 8ghc-libKeep renamed source?8ghc-libKeep renamed source?#ghc-libJust f  = _stub.c is f#ghc-lib The statementghc-lib The sourceghc-lib Starting line#ghc-libThe parsed statement#ghc-lib The statement#ghc-lib The statementghc-lib The sourceghc-lib Starting line#ghc-libThe expression#ghc-libNormalise the typeghc-libThe type as a stringghc-lib-Resulting type (possibly normalised) and kind;#k#l#m#n#o#p#q#r#s#t#u#v#w#x#y#z#{#|#}#~#############################;#l#k##}####u#w#y#{#####p#q#r#s#t#o###############v##z#x#m###~##|##n##None"#&'/=?FHVX`[ghc-lib(Releases the external interpreter state.8ghc-libSForce the contents of the Serialized value so weknow it doesn't contain any bottoms8ghc-lib8Adds a mod finalizer reference to the local environment.8ghc-libvcommunicate with a remotely-running TH computation until it finishes. See Note [Remote Template Haskell] in librariesghci GHCi/TH.hs.8ghc-lib+Read a value of type QResult from the iserv8ghc-libRetrieve (or create, if it hasn't been created already), the remote TH state. The TH state is a remote reference to an IORef QState living on the server, and we have to pass this to each RunTH call we make.>The TH state is stored in tcg_th_remote_state in the TcGblEnv.8ghc-libAnnotate (with TH.SigT) a type if the first parameter is True and if the type contains a free variable. This is used to annotate type patterns for poly-kinded tyvars in reifying class and type instances. See #8953 and th/T8953.8ghc-libzFor every type variable in the input, report whether or not the tv is poly-kinded. This is used to eventually feed into 8.####None"#F\!#ghc-libFailure modes for #.#ghc-lib returned $.#ghc-lib$q: The module was compiled. $r: The module was :loaded.#ghc-libThe  was defined interactively.8ghc-lib,Finds the enclosing top level function name 8ghc-lib=Update fixity environment in the current interactive context.#ghc-libdefault ExecOptions#ghc-lib3Run a statement in the current interactive context.#ghc-libLike #, but takes a parsed statement as argument. Useful when doing preprocessing on the AST before execution, e.g. in GHCi (see GHCi.UI.runStmt).#ghc-libVRun some declarations and return any user-visible names that were brought into scope.#ghc-libLike #, but takes parsed declarations as argument. Useful when doing preprocessing on the AST before execution, e.g. in GHCi (see GHCi.UI.runStmt).#ghc-lib'Set the interactive evaluation context.m(setContext imports) sets the ic_imports field (which in turn determines what is in scope at the prompt) to imports>, and constructs the ic_rn_glb_env environment to reflect it.We retain in scope all the things defined at the prompt, and kept in ic_tythings. (Indeed, they shadow stuff from ic_imports.)#ghc-libGet the interactive evaluation context, consisting of a pair of the set of modules from which we take the full top-level scope, and the set of modules from which we take just the exports respectively.#ghc-libReturns True[ if the specified module is interpreted, and hence has its full top-level scope available.#ghc-lib9Looks up an identifier in the current interactive context (for :info) Filter the instances by the ones whose tycons (or clases resp) are in scope (qualified or otherwise). Otherwise we list a whole lot too many! The exact choice of which ones to show, and which to hide, is a judgement call. (see #1581)#ghc-lib=Returns all names in scope in the current interactive context#ghc-lib Returns all \s in scope in the current interactive context, excluding any that are internally-generated.#ghc-lib:Parses a string as an identifier, and returns the list of Gs that the identifier can refer to in the current interactive context.#ghc-libReturns True! if passed string is a statement.#ghc-libReturns True, if passed string has an import declaration.#ghc-libReturns True+ if passed string is an import declaration.#ghc-libReturns True' if passed string is a declaration but  not a splice.#ghc-lib@Get the type of an expression Returns the type as described by #ghc-libGet the kind of a type#ghc-libeParse an expression, the parsed expression can be further processed and passed to compileParsedExpr.#ghc-lib@Compile an expression, run it, and deliver the resulting HValue.#ghc-lib@Compile an expression, run it, and deliver the resulting HValue.#ghc-libYCompile a parsed expression (before renaming), run it, and deliver the resulting HValue.#ghc-libACompile an expression, run it and return the result as a Dynamic.#ghc-lib a statement (bind or expression)_UTSRQPYWXV`_^]\[Zponmlkjihgfedutsrq    ##############################################_ponmlkjihgfedutsrq##UTSRQP#`_^]\[Z#########YWXV###############################    ###None$\`G #ghc-libsJust preprocess a file, put the result in a temp. file (used by the compilation manager during the summary phase).eWe return the augmented DynFlags, because they contain the result of slurping in the OPTIONS pragmas#ghc-libCompileFCompile a single module, under the control of the compilation manager.This is the interface between the compilation manager and the compiler proper (hsc), where we deal with tedious details like reading the OPTIONS pragma from the source file, converting the C or assembly that GHC produces into an object file, and compiling FFI stub files.@NB. No old interface can also mean that the source has changed.8ghc-lib:Run a compilation pipeline, consisting of multiple phases.This is the interface to the compilation pipeline, which runs a series of compilation steps on a single source file, specifying at which stage to stop.The DynFlags can be modified by phases in the pipeline (eg. by OPTIONS_GHC pragmas), and the changes affect later phases in the pipeline.8ghc-lib2pipeLoop runs phases until we reach the stop phase#ghc-lib/Computes the next output filename after we run  next_phase. Like #, but it operates in the W9 monad (which specifies all of the ambient information.)#ghc-libwComputes the next output filename for something in the compilation pipeline. This is controlled by several variables: !: the last phase to be run (e.g.  stopPhasen). This is used to tell if we're in the last phase or not, because in that case flags like -o may be important.8: is this intended to be a 8 or 8K build output? Temporary files just go in a fresh temporary name.83: what was the basename of the original input file? : the obvious thing8: the phase we want to determine the output filename of.Maybe ModLocation: the  of the module we're compiling; this can be used to override the default output of an object file. (TODO: do we actually need this?)8ghc-lib`The fast LLVM Pipeline skips the mangler and assembler, emitting object code directly from llc.Eslow: opt -> llc -> .s -> mangler -> as -> .o fast: opt -> llc -> .ohidden flag: -ffast-llvmhif keep-s-files is specified, we need to go through the slow pipeline (Kavon Farvardin requested this).8ghc-libLLVM Options. These are flags to be passed to opt and llc, to ensure consistency we list them in pairs, so that they form groups.#ghc-libwEach phase in the pipeline returns the next phase to execute, and the name of the file in which the output was placed.We must do things dynamically this way, because we often don't know what the rest of the phases will be until part-way through the compilation: for example, an {- OPTIONS -fasm -} at the beginning of a source file can change the latter stages of the pipeline from taking the LLVM route to using the native code generator.8ghc-libLinking a static lib will not really link anything. It will merely produce a static archive of all dependent static libraries. The resulting library will still need to be linked with any remaining link flags.8ghc-libFigure out if a source file was modified after an output file (or if we anyways need to consider the source file modified since the output is gone).#ghc-libBWhat phase to run after one of the backend code generators has run8ghc-libFind out path to  ghcversion.h file#ghc-libfilename and starting phase#ghc-lib!summary for module being compiledghc-lib module N ...ghc-lib... of Mghc-libold interface, if we have oneghc-libold linkable, if we have oneghc-lib'the complete HomeModInfo, if successful#ghc-lib!summary for module being compiledghc-lib module N ...ghc-lib... of Mghc-libold interface, if we have oneghc-libold linkable, if we have one ghc-lib'the complete HomeModInfo, if successful8ghc-lib When to stopghc-libCompilation environmentghc-lib$Input filename (and maybe -x suffix)ghc-lib)original basename (if different from ^^^)ghc-libOutput filenameghc-lib*A ModLocation, if this is a Haskell moduleghc-libforeign objectsghc-lib(final flags, output filename)8ghc-lib When to startghc-libCompilation environmentghc-libInput filenameghc-lib*A ModLocation, if this is a Haskell moduleghc-libforeign objects, if we have oneghc-lib(final flags, output filename)8ghc-libpairs of (opt, llc) arguments#ghc-libRun this phaseghc-libname of the input fileghc-lib.for convenience, we pass the current dflags in8ghc-lib#destination file we are looking forghc-lib(last time of modification of source fileghc-lib$do we need to regenerate the output?'QRSTWVUZYXa`_^]\[fedcb$################'#######ZYXWVUa`_^]\[fedcb##ST##QR####$#?None$X\z#ghc-lib6 indicating if a module is a boot module or not. We need to treat boot modules specially when building compilation graphs, since they break cycles. Regular source files and signature files are treated equivalently.8ghc-lib?The graph of modules to compile and their corresponding result 8 and 8.8ghc-libEach module is given a unique 8) to redirect compilation messages to. A $U value contains the result of compilation, and denotes the end of the message queue.8ghc-lib|Stability tells us which modules definitely do not need to be recompiled. There are two main reasons for having stability:zavoid doing a complete upsweep of the module graph in GHCi when modules near the bottom of the tree have not changed.to tell GHCi when it can load object code: we can only load object code for a module when we also load object code fo all of the imports of the module. So we need to know that we will definitely not be recompiling any of these modules, and we can use the object code.nThe stability check is as follows. Both stableObject and stableBCO are used during the upsweep phase later.  stable m = stableObject m || stableBCO m stableObject m = all stableObject (imports m) && old linkable does not exist, or is == on-disk .o && date(on-disk .o) > date(.hs) stableBCO m = all stable (imports m) && date(BCO) > date(.hs) ,These properties embody the following ideas:if a module is stable, then:pif it has been compiled in a previous pass (present in HPT) then it does not need to be compiled or re-linked.~if it has not been compiled in a previous pass, then we only need to read its .hi file from disk and link it to produce a *o.uif a modules is not stable, we will definitely be at least re-linking, and possibly re-compiling it during the 8W. All non-stable modules can (and should) therefore be unlinked before the 8.Note that objects are only considered stable if they only depend on other objects. We can't link object code against byte code.Note that even if an object is stable, we may end up recompiling if the interface is out of date because an *external* interface has changed. The current code in GhcMake handles this case fairly poorly, so be careful.#ghc-lib>Describes which modules of the module graph need to be loaded.#ghc-lib&Load all targets and its dependencies.#ghc-lib0Load only the given module and its dependencies.#ghc-libKLoad only the dependencies of the given module, but not the module itself.#ghc-librPerform a dependency analysis starting from the current targets and update the session with the new module graph.(Dependency analysis entails parsing the importE directives and may therefore require running certain preprocessors.Note that each  in the module graph caches its   . These   are determined by the current session   and the OPTIONS and LANGUAGEA pragmas of the parsed module. Thus if you want changes to the  6 to take effect you need to call this function again.#ghc-libTry to load the program. See # for the different modes.+This function implements the core of GHC's --make mode. It preprocesses, compiles and loads the specified modules, avoiding re-compilation wherever possible. Depending on the target (see C) compiling and loading may result in files being created on disk. Calls the H> after each compiling each module, whether successful or not.Throw a $ if errors are encountered before the actual compilation starts (e.g., during dependency analysis). All other errors are reported using the H.#ghc-libGeneralized version of # which also supports a custom #k (for reporting progress) and ! (generally produced by calling #.8ghc-libFinish up after a load.8ghc-libDForget the current program, but retain the persistent info in HscEnv8ghc-libDiscard the contents of the InteractiveContext, but keep the DynFlags. It will also keep ic_int_print and ic_monad if their names are from external packages.8ghc-libmIf there is no -o option, guess the name of target executable by using top-level source file name as a base.8ghc-libPrune the HomePackageTable+Before doing an upsweep, we can throw away:For non-stable modules:all ModDetails, all linked codeJall unlinked code that is out of date with respect to the source fileThis is VERY IMPORTANT otherwise we'll end up requiring 2x the space at the end of the upsweep, because the topmost ModDetails of the old HPT holds on to the entire type environment from the previous compilation.8ghc-libXReturn (names of) all those in modsDone who are part of a cycle as defined by theGraph.8ghc-lib Unloading8ghc-libBuild a 8j out of a list of strongly-connected modules, also returning the first, if any, encountered module cycle.#ghc-lib Tests if an 2u9 is a boot file, primarily for constructing elements of 8.8ghc-lib(The entry point to the parallel upsweep.!See also the simpler, sequential 8.8ghc-lib The upsweepmThis is where we compile each module in the module graph, in a pass from the bottom to the top of the graph.DThere better had not be any cyclic groups here -- we check for them.8ghc-libCompile a single module. Always produce a Linkable for it if successful. If no compilation happened, return the old Linkable.8ghc-libGiven a non-boot ModSummary msC of a module, for which there exists a corresponding boot file in graph, return the set of modules which transitively depend on this boot file. This function is slightly misnamed, but its name "getModLoop" alludes to the fact that, when getModLoop is called with a graph that does not contain ms (non-parallel case) or is an SCC with hs-boot nodes dropped (parallel-case), the modules which depend on the hs-boot file are typically (but not always) the modules participating in the recursive module loop. The returned list includes the hs-boot file.Example: let g represent the module graph: C.hs A.hs-boot imports C.hs B.hs imports A.hs-boot A.hs imports B.hs genModLoop A.hs g == Just [A.hs-boot, B.hs, A.hs]mIt would also be permissible to omit A.hs from the graph, in which case the result is [A.hs-boot, B.hs]Example: A counter-example to the claim that modules returned by this function participate in the loop occurs here:let g represent the module graph: C.hs A.hs-boot imports C.hs B.hs imports A.hs-boot A.hs imports B.hs D.hs imports A.hs-boot genModLoop A.hs g == Just [A.hs-boot, B.hs, A.hs, D.hs]iArguably, D.hs should import A.hs, not A.hs-boot, but a dependency on the boot file is not illegal.#ghc-lib$Topological sort of the module graph Calculate SCCs of the module graph, possibly dropping the hi-boot nodes The resulting list of strongly-connected-components is in topologically sorted order, starting with the module(s) at the bottom of the dependency graph (ie compile them first) and ending with the ones at the top.'Drop hi-boot nodes (first boolean arg)?Falsea: treat the hi-boot summaries as nodes of the graph, so the graph must be acyclicTrue: eliminate the hi-boot nodes, and instead pretend the a source-import of Foo is an import of Foo The resulting graph has no hi-boot nodes, but can be cyclic8ghc-libIf there are {- SOURCE -} imports between strongly connected components in the topological sort, then those imports can definitely be replaced by ordinary non-SOURCE imports: if SOURCE were necessary, then the edge would be part of a cycle.8ghc-libDownsweep (dependency analysis)Chase downwards from the specified root set, returning summaries for all home modules encountered. Only follow source-import links.We pass in the previous collection of summaries, which is used as a cache to avoid recalculating a module summary if the source is unchanged.The returned list of [ModSummary] nodes has one node for each home-package module, plus one for any hs-boot files. The imports of these nodes are all there, including the imports of non-home-package modules.8ghc-libUpdate the every ModSummary that is depended on by a module that needs template haskell. We enable codegen to the specified target, disable optimization and change the .hi and .o file locations to be temporary files. See Note [-fno-code mode]8ghc-libIReturns the dependencies of the ModSummary s. A wrinkle is that for a {- SOURCE 8-} import we return *both* the hs-boot file *and* the source file as "dependencies". That ensures that the list of all relevant modules always contains B.hs if it contains B.hs-boot. Remember, this pass isn't doing the topological sort. It's just gathering the list of all relevant ModSummaries#ghc-libLike #, but for SOURCE imports.#ghc-lib2All of the (possibly) home module imports from a ; that is to say, each of these module names could be a home import if an appropriately named file existed. (This is in contrast to package qualified imports, which are guaranteed not to be home imports.)#ghc-libexcluded modulesghc-liballow duplicate roots8ghc-lib0The number of workers we wish to run in parallel8 ghc-libThe module we wish to compileghc-lib-The map of home modules and their result MVarghc-lib:The list of all module loops within the compilation graph.ghc-libThe thread-local DynFlagsghc-lib The messagerghc-lib/The callback for cleaning up intermediate filesghc-lib>The semaphore for limiting the number of simultaneous compilesghc-lib7The MVar that synchronizes updates to the global HscEnvghc-lib The old HPT ghc-libSets of stable objects and BCOs ghc-libThe index of this module ghc-libThe total number of modules ghc-libThe result of this compile8ghc-lib!HPT from last time round (pruned)ghc-lib#stable modules (see checkStability)ghc-lib"How to clean up unwanted tmp filesghc-libMods to do (the worklist)ghc-libReturns: 3A flag whether the complete upsweep was successful.The  in the monad has an updated HPT*A list of modules which succeeded loading.#ghc-libDrop hi-boot nodes? (see below)ghc-libRoot module name. If Nothing, use the full graph.8ghc-libStarting phase"###################################"#####None $%HPVX\ >;#ghc-lib"Container for information about a .#ghc-lib.A CoreModule consists of just the fields of a ( that are needed for the $/ interface.#ghc-lib Module name#ghc-lib2Type environment for types declared in this module#ghc-lib Declarations#ghc-libSafe Haskell mode#ghc-lib~The result of successful desugaring (i.e., translation to core). Also contains all the information of a typechecked module.$ghc-libNThe result of successful typechecking. It also contains the parser result.$ ghc-lib!The result of successful parsing.$ghc-libInstall some default exception handlers and run the inner computation. Unless you want to handle exceptions yourself, you should wrap this around the top level of your program. The default handlers output the error message(s) to stderr and exit cleanly.$ghc-libMThis function is no longer necessary, cleanup is now done by runGhc/runGhcT.$ghc-libRun function for the N monad.0It initialises the GHC session and warnings via $k. Each call to this function will create a new session which should not be shared among several threads."Any errors not handled inside the N) action are propagated as IO exceptions.$ghc-libRun function for O monad transformer.0It initialises the GHC session and warnings via $k. Each call to this function will create a new session which should not be shared among several threads.$ghc-libInitialise a GHC session.If you implement a custom Mz you must call this function in the monad run function. It will initialise the session variable and clear all warnings.The first argument should point to the directory where GHC's library files reside. More precisely, this should be the output of ghc --print-libdirj of the version of GHC the module using this API is compiled with. For portability, you should use the  ghc-paths package, available at  ,http://hackage.haskell.org/package/ghc-paths.8ghc-libThe binutils linker on ARM emits unnecessary R_ARM_COPY relocations which breaks tables-next-to-code in dynamically linked modules. This check should be more selective but there is currently no released version where this bug is fixed. See  5https://sourceware.org/bugzilla/show_bug.cgi?id=16177 and 9https://gitlab.haskell.org/ghc/ghc/issues/4210#note_78333$ghc-lib#Updates both the interactive and program DynFlags in a Session. This also reads the package database (unless it has already been read), and prepares the compilers knowledge about packages. It can be called again to load new packages: just add new package flags to (packageFlags dflags).\Returns a list of new packages that may need to be linked in using the dynamic linker (see  linkPackages) as a result of new package flags. If you are not doing linking or doing static linking, you can ignore the list of packages returned.$ghc-libSets the program  i. Note: this invalidates the internal cached module graph, causing more work to be done the next time # is called.$ghc-libaSet the action taken when the compiler produces a message. This can also be accomplished using $ , but using $- avoids invalidating the cached module graph.$ ghc-libReturns the program  .$!ghc-libSet the  e used to evaluate interactive expressions. Note: this cannot be used for changes to packages. Use $, or $ and then copy the P into the interactive DynFlags.$"ghc-libGet the  * used to evaluate interactive expressions.8ghc-libYChecks the set of new DynFlags for possibly erroneous option combinations when invoking $@ and friends, and if found, returns a fixed copy (if possible).$$ghc-lib Sets the targets for this session. Each target may be a module name or a filename. The targets correspond to the set of root modules for the program/library. Unloading the current program is achieved by setting the current set of targets to be empty, followed by #.$%ghc-lib"Returns the current set of targets$&ghc-libAdd another target.$'ghc-libRemove a target$(ghc-libQAttempts to guess what Target a string refers to. This function implements the --make(/GHCi command-line syntax for filenames:Rif the string looks like a Haskell source filename, then interpret it as suchVif adding a .hs or .lhs suffix yields the name of an existing file, then use that/otherwise interpret the string as a module name$)ghc-libInform GHC that the working directory has changed. GHC will flush its cache of module locations, since it may no longer be valid.Note: Before changing the working directory make sure all threads running in the same session have stopped. If you change the working directory, you should also unload the current program (set targets to empty, followed by load).$*ghc-lib Return the ! of a module with the given name.1The module must be part of the module graph (see *N and 9). If this is not the case, this function will throw a *J.lThis function ignores boot modules and requires that there is only one non-boot module with the given name.$+ghc-libParse a module. Throws a $ on parse error.$,ghc-lib%Typecheck and rename a parsed module. Throws a $ if either fails.$-ghc-libDesugar a typechecked module.$.ghc-lib3Load a module. Input doesn't need to be desugared.iA module must be loaded before dependent modules can be typechecked. This always includes generating a  and, depending on the #, may also include code generation.This function will always cause recompilation and will always overwrite previous compilation results (potentially files on disk).$/ghc-libOThis is the way to get access to the Core bindings corresponding to a module.  compileToCore parses, typechecks, and desugars the module, then returns the resulting Core module (consisting of the module name, type declarations, and function declarations) if successful.$0ghc-libbLike compileToCoreModule, but invokes the simplifier, so as to return simplified and tidied Core.$1ghc-lib Get the module dependency graph.$2ghc-libReturn True  == module is loaded.$3ghc-lib8Return the bindings for the current interactive session.$4ghc-lib9Return the instances for the current interactive session.$6ghc-lib#Request information about a loaded $7ghc-lib2The list of top-level entities defined in a module$;ghc-libmReturns the instances defined by the specified module. Warning: currently unimplemented for package modules.$@ghc-lib!Retrieve module safe haskell mode$Cghc-libTLooks up a global name: that is, any top-level name in any visible module. Unlike $Vf, lookupGlobalName does not use the interactive context, and therefore does not require a preceding #.$Eghc-lib"get the GlobalRdrEnv for a session$Fghc-libGRetrieve all type and family instances in the environment, indexed by f. Each name's lists will contain every instance in which that name is mentioned in the instance head.$Hghc-libprint a 0, adding parentheses if the name is an operator.$Ighc-lib9Return module source as token stream, including comments.SThe module must be in the module graph and its source must be available. Throws a $ on parse error.$Jghc-lib.Give even more information on the source than $IB This function allows reconstructing the source completely with $L.$Kghc-libGiven a source location and a StringBuffer corresponding to this location, return a rich token stream with the source associated to the tokens.$Lghc-lib/Take a rich token stream such as produced from $Jf and return source code almost identical to the original code (except for insignificant whitespace.)$Mghc-libTakes a  and possibly a N, and consults the filesystem and package database to find the corresponding +, using the algorithm that is used for an import declaration.$Nghc-libLike $Mf, but differs slightly when the module refers to a source file, and the file has not been loaded via #. In this case, $M/ will throw an error (module not loaded), but $N_ will check to see whether the module can also be found in a package, and if so, that package M will be returned. If not, the usual module-not-found error will be thrown.$Oghc-libBCheck that a module is safe to import (according to Safe Haskell).{We return True to indicate the import is safe and False otherwise although in the False case an error may be thrown first.$Pghc-libGReturn if a module is trusted and the pkgs it depends on to be trusted.$Qghc-lib.Set the monad GHCi lifts user statements into.;Checks that a type (in string form) is an instance of the GHC.GHCi.GHCiSandboxIOO type class. Sets it to be the GHCi monad if it is, throws an error otherwise.$Rghc-lib.Get the monad GHCi lifts user statements into.$Vghc-lib Returns the  for a . The 2 may refer to any entity known to GHC, including s defined using runStmt.$Wghc-lib&A pure interface to the module parser.$ghc-libSee argument to $.ghc-libThe action to perform.$ghc-libSee argument to $.ghc-libThe action to perform.$Fghc-liblvisible modules. An orphan instance will be returned if it is visible from at least one module in the list.ghc-libhmodules to load. If this is not specified, we load modules for everything that is in scope unqualified.$Wghc-lib6Haskell module source text (full Unicode is supported)ghc-lib the flagsghc-lib#the filename (for source locations) HIJMLKNOP88888888888888888888888888888888888888888888888888888888888888888888888889999999999 9 9 9 9 9999999999999999999 9!9"9#9$9%9&9'9(9)9*9+9,9-9.9/909192939495969798999:9;9<9=9>9?9@9A9B9C9D9E9F9G9H9I9J9K9L9M9N9O9P9Q9R9S9T9U9V9W9X9Y9Z9[9\9]9^9_9`9a9b9c9d9e9f9g9h9i9j9k9l9m9n9o9p9q9r9s9t9u9v9w9x9y9z9{9|9}9~999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999:::::::::: : : : : ::::::::::::::::::: :!:":#:$:%:&:':(:):*:+:,:-:.:/: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:{:|:}:~:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::;;;;;;;;;; ; ; ; ; ;;7;;;;;;;;;;;;;;;;; ;!;";#;$;%;&;';(;);*;+;,;-;.;/;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;{;|;};~;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;<<<<<<<<<< < < < < <<<<<<<<<CFNMLKJIHG<<<<<<<<<< =?=@=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>{>|>}>~>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>N}_-01BitR\;@C^:odjr?/mZY+gW)a<bfl6QpeGw~5`.U=(&$"M|XO]h[kSJIyA7u{zxvsqncVTPLKHFED>98432,*'%#! >>>>>>>>>>>>>>>WX )+,.\`_^]cba   ~}|{zyxwvutsrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONMLKJIHGFEDCBA@?>=<;:9876543210/.-,+*)('&%$#"!      ~}|{zyxwvutsrqponmlkjihgfedcba`_^]\[ZY RSTUVu############################################################$$$$$$$$$$ $ $ $ $ $$$$$$$$$$$$$$$$$$$ $!$"$#$$$%$&$'$($)$*$+$,$-$.$/$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$$ $NOMLK$$$TSRI   ~}|{zyxwvutsrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONMLKJIHGFEDCBA@?>=<;:9876543210/.-,+*)('&%$#"!      ~}|{zyxwvutsrqponmlkjihgfedcba`_^]\[ZYWX$#J$$ $$$"$!$$$%$&$'$(######HP$)$+$,$-$.$ $ $ $ $$$$$$$$$ #$$$###$$$$$$$######$/$0$*$1$2##$6$7$8$9$:$;$<$>$?$@$C$D$= ##UTSRQP#`_^]\[Z#######$Q$R$3$4$5$M$N$O$P##$E####$F###$VU####V###########YWXVponmlkjihgfedurq$S####$U$T#$ANMLKJIHGFcab##$H$B $GuC-$&`_^],.+)cba$I$J$L$K$WN}_-01BitR\;@C^:odjr?/mZY+gW)a<bfl6QpeGw~5`.U=(&$"M|XO]h[kSJIyA7u{zxvsqncVTPLKHFED>98432,*'%#! #@NoneC$_$_ANoneFF$`ghc-libThe :print & friends commands>ghc-liboGive names, and bind in the interactive environment, to all the suspensions included (inductively) in a term$`$a$b$`$a$bBNone=?\w>ghc-lib&Backpack environment. NB: this has a > and not an &, because we are going to update the  as we go.>ghc-lib The session>ghc-lib,The filename of the bkp file we're compiling>ghc-lib2Table of source units which we know how to compile>ghc-lib{When a package we are compiling includes another package which has not been compiled, we bump the level and compile that.>ghc-libBackpack monad is a M7 which also maintains a little extra state beyond the >, c.f. >.>ghc-lib9Tiny enum for all types of Backpack operations we may do.>ghc-libSA compilation operation which will result in a runnable executable being produced.>ghc-libPA type-checking operation which produces only interface files, no object files.?ghc-libNA compilation operation which produces both interface files and object files.$cghc-lib'Entry point to compile a Backpack file.?ghc-libLCreate a temporary Session to do some sort of type checking or compilation.?ghc-lib\Compute the dependencies with instantiations of a syntactic HsUnit; e.g., wherever you see dependency p[A= A] in a unit file, return the  corresponding to p[A= A]. The  include_sigs4 parameter controls whether or not we also include dependency signature" declarations in this calculation..Invariant: this NEVER returns InstalledUnitId.?ghc-libGet the current >.?ghc-lib:Get the nesting level, when recursively compiling modules.?ghc-libApply a function on   on an ?ghc-libRun a >0 computation, with the nesting level bumped one.?ghc-libUpdate the EPS from a M(. TODO move to appropriate library spot.?ghc-libGet the EPS from a M.? ghc-libRun > in N.? ghc-libIPrint a compilation progress message, but with indentation according to level (for nested compilation).? ghc-lib Creates a #k? for Backpack compilation; this is basically a carbon copy of # but calling ? , which handles indentation.? ghc-lib4J for Backpack messages; here we usually want the module to be qualified (so we can tell how it was instantiated.) But we try not to qualify packages so we can use simple names for them.? ghc-lib2Message when we initially process a Backpack unit.?ghc-lib,Message when we instantiate a Backpack unit.?ghc-lib(Message when we include a Backpack unit.?ghc-libGThis is our version of GhcMake.downsweep, but with a few modifications: Every module is required to be mentioned, so we don't do any funny business with targets or recursively grabbing dependencies. (We could support this in principle).GWe support inline modules, whose summary we have to synthesize ourself.iWe don't bother trying to support GhcMake for now, it's more trouble than it's worth for inline modules.?ghc-lib\Up until now, GHC has assumed a single compilation target per source file. Backpack files with inline modules break this model, since a single file may generate multiple output files. How do we decide to name these files? Should there only be one output file? This function our current heuristic, which is we make a "fake" module and use that.?ghc-lib>Create a new, externally provided hashed unit id from a hash.$c$c?KLMKLNKLOKLPKQRKQSKQTKUVKWXKYZKL[KL\]^_]^`]ab]ac]de]Df]Dg]Dh]Di]Dj]Dk]Dl]Dm]Dn]Do]Dp]Dq]Dr]Ds]Dt]Du]Dv]Dw]Dx]Dy]Dz]D{]D|]D}]D~]D]D]D]D]D]D]D]D]D]D]D]D]D]D]D]D]D]D]D]D]D]D]D]DE]DE]D]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]] ] ]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]] ]]]]]]]]]]]]]]]]]]]]]]]]] ] ] ] ] ]]]]]]]]]]]]]]]]]]] ]!]"]#]$]%]&]'](])]*]+],]-].]/]0]1]2]3]4]5]6]6]7]8]9]:];]<]=]>]?]@]A]B]C]D]E]F]G]H]H]IJ]IK]IL]IM]IN]IO]IP]IQ]IR]IS]IT]IU]IV]IW]II]IX]IY]IZ]I[]I\]]^]]_]]`]ab]ac]ad]a]ef]eg]ee]eh]ei]ej]ek]el]e ]em]en]eo]ep]eq]er]es]et]eu]ev]ew]ex]ey]ez]e{]e|]e}]e~]e]e]e]e]e]e]e]e]e]e]e]e]e]e]e]e]e]e]e]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]] ] ] ] ] ]]]]]]]]]]]]]]]]]]] ]!]"]#]$]%]&]'](])]*]+],]-].]/]0]1]2]3]4]5]6]78]9:]9;]9<]9=]9>]9?]9@]9A]9B]CD]CE]CF]CG]CH]CI]CJ]CK]CL]CM]CN]CO]CP]CQ]CR]CS]CT]CU]CV]CW]CX]CY]CZ]C[]C\]C]]C^]C_]C`]Ca]Cb]Cc]Cd]Ce]Cf]Cg]Ch]Ci]Cj]Ck]Cl]Cm]Cn]Co]Cp]Cq]Cr]Cs]Ct]Cu]Cv]Cw]Cx]Cy]Cz]C{]C|]C}]C~]C]C]C]C]C]C]C]C]C]C]C]C]C]C]C]C]C]C]C]C]C]C]C]C]C]C]C]C]C]C]C]C]C]C]C]C]C]C]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]] ] ] ] ] ]]]]]]]]]]]]]]]]]]] ]!]"]#]$]%]&]'](])]*]+],]-].]/]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]Q]R]S]T]U]V]W]X]Y]Z[]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]]{]]|]]}]]~]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]] ] ] ] ] ]]]]]]]]C]C]C]C]C]C]C]C]C]C]C ]C!]C"]C#]C$]C%]C&]C']C(]C)]C*]C+]C,]C-]C.]C/]C0]C1]C2]C3]C4]C5]C6]78]79]7:]7;]7<]7=]7>]7?]7?]9@]9A]99]BC]BD]BE]BF]BG]BH]BI]BJ]BK]BL]BM]BN]BO]BP]BQ]BR]BS]BT]BU]BV]BW]B]BX]BY]BZ]B[]B\]B]]B^]B_]B`]Ba]Bb]Bc]Bd]Be]Bf]Bg]Bh]Bi]Bj]Bk]Bl]mn]op]oq]or]os]ot]ou]ov]ow]ox]oy]oz]o{]o|]o}]o~]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]o]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]] ] ] ] ] ]]]]]]]]]]]]]]]]]]]] ]!]"#]]$]]%]]&]]']]]](]]C]])]]]]*]]+]],]]-]].]]/]B0]B1]BB]23]4]56]57]58]59]5:]5;]5<]5=]5>]5?]5@]5A]5B]5C]5D]5E]5F]5G]5H]5I]5J]5K]5L]5M]5N]5O]5P]5Q]5R]5S]5T]5U]5V]5W]5X]5Y]5Z]5[]5\]5]]5^]5_]5`]5a]5b]5c]5d]5e]5f]5g]5h]5i]5j]5k]5l]5m]5n]5o]5p]5q]5r]5s]5t]5u]5v]5w]5x]5y]5z]5{]5|]5}]5~]5]5]5]5]5]5]5]5]5]5]5]5]5]5]5]5]5]5]5]5]5]5]5]5]5]5]5]5]5]5]5]5]5]5]5]5]5]5]5]5]5]5]5]5]5]5]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]] ] ] ] ] ]]]]]]]]]]]]]]]]]]] ]!]"]#]$]%]&]'](])]*]+],]-].]/]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]{]|]}]~]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]] ] ] ] ] ]]]]]]]]]]]]]]]]]] ]!]"]"]#$]#%]#&]#']##]((]()](*](+](,]--]-.]-/]01]02]03]04]05]06]07]08]09]0:]0;]0<]0=]0>]0?]0@]0A]0B]0C]0D]0E]0F]0G]0H]0I]0J]0K]0L]0M]0N]0O]0P]0Q]0R]0S]0T]0U]0V]0W]0X]0Y]0Z]0[]0\]0]]0^]0_]0`]0a]0b]0c]0d]0e]0f]0g]0h]0i]0j]0k]0l]0m]0n]0o]0p]0q]0r]0s]0t]0u]0v]0w]0x]0y]0z]0{]0|]0}]0~]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]07]0]0]0]0]0]0]0]0]0]0]0]0 ]0 ]0 ]0 ]0 ]0 ]0 ]0 ]0 ]0 ]0 ]0 ]0 ]0 ]0 ]0 ]2 ]2 ]2 ]2 ]2 ]2 ]2 ]2 ]  ]  ]  ]  ]  ]  ]  ]  ]  !]  "]  #]  $]  %]  &]  ']  (]  )]  *]  +]  ,]  -]  .]  /]  0]  1]  2]  3]  4]  5]  6]  7]  8]  9]  :]  9]  ]  ;]  <]  =]  <]  >]  ?]  @]  A]  B]  C]  D]  E] F G] F H] I] J]] K] L] M]] N O] P Q] P R] P P] S] T] U]] V] W X] W Y] W Z] W [] W \] W ]] W ^] W _] W W] W `] W a] W b] W c]55]] d e] d f] g h] g i] g j] g k] g l] g m] g n] g o] g p] g q] g r] g s] g t] g u] g v] g w] g x] g y] g z] g {] g |] g }] g ~] g ] g ] g ] g ] g ] g ] g ] g ] g ] g ] g ] g ] g ] g ] g ] g ] g ] g ] g ] g ] g ] g ] g ] g ] g ] g ] ] ] ] ] ] ]  ]  $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ % & & ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' !' "' #' $' %' &' '' (' )' *' +' ,' -' .' /' 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 1 2 2 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 5 6 7 8 8 8 8 8 8 8 8 8 8 8 8 8 9 9 " " " "" " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " : : : : : : : : ; ; ; !; "; #; $; %; &; '; (; (; ); *; +; ,; -< .< /< 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@ v@ w@ x@ y@ z@ {@ {@ |@ }@ ~@ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A B B B B B B B B B B B B B B B B B B B B !B "B #B $B %B &B 'B (B )B *B +B ,B -B .B /B 0B 1B 2B 3B 4B 5C 6C 7C 8C 9C :C ;C <C =C >C ?C @C AC BC CC DC EC FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC YC ZC [C \C ]C ^C _C `C aC bC cC dC eC fC gC hC iC jC kC lC mC nC oC pC qC rC sC tC uC vC wC xC yC zC {C |D }D ~D D D D D D D D D D D D D D D D D D D D D D D D D E E E E E (E E E E E E E E E E E E F F F F F F F F F F F F F F F F F F F F F GGG H H H H H H H H H HHH H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H !H "H #H $H %H &H 'I (I )I *I +I ,I -I .I /G 0G 1G 2J 3J 4J 5J 6J 7J 8J 9J :J ;J <J =J >J ?J @J AJ BJ CJ DJ EJ FJ GJ HJ IJ JJ JJ KJ LJ MJ NJ OJ PJ QJ RJ SJ SJ TJ UJ VJ WJ XJ YJ ZJ [J \J ]J ^J _J `J aJ bJJJ TJ cJ `J'J dJ eJ fJ gJ hJ iJ jJ kJ lJ mJ nJ oJ pJ qJ rJ sJ tJ uJ vJ wJ xJ yJ zJ {J |J }J ~J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K L L L L L L M # # # # # # # N OOOOO O O O O O O O O O P Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q QRRRRRRRRS S S S S SSSTUUUUUYUYUUXUUUUUUUUUUU U!U"U#U$U%U&V'V(V)V*VVW+W+W,W-W.W/W0W1XXX2X3X4X5X6X7XYYY8Y9Y:Y;Y<Y=Y>Y?Y@YAYBYCYDYEYFYGYHYIYJYKYLYMYNYOYPYQYRYSYTYUYVYYWYXYYYZY[Y&Y\Z][^[_[`[a[b[c\^\_\`\a\b\c]^]_]`]a]b^^^_^`^a^b_^___`_a_b`^`_```a`ba^a_a`aaabb^b_b`babbcdcedfdgdheifjfkflfmfnfofpfqfrfsftfufvfffwfxfyfzf{f|f}f~ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffggggggggggggggggggggggggggggggggggFggggggggggggggggggggggggggggggggggggggggggggggghhhhhh h h h h hhhhhhhhhhhhhhhhhhhhhh h!h"h#h$h%h&h'h(h [h)h*h+h,h*h-h.h/h0h1h2h3h4h5h6h7h8h9h:h;h<i=i>i?i@iAiBiCiDiEiFjGjHjIjJjKjLjMkNkOkPkQkRkSkTkUkVkWkXkYkZk[k\k]k^k_k`kakbkckdkekfkgkhkikjkkklkmknkokpkqkrksktkukvkwkxkykzk{k|k}k~kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk k k k k kkkkkkkkkkkkkkkkkkk k!k"k#k$k%k&k'k(l)l*l+l,l,l-l.l/l0l1l2l2l3l4l5l6l7l8l9m:m;m<m=m>m?m@mAmBmCmDmEmFmGmHmImJmKmLmMmNmOmPmQmRmSmTmUmVmWmXmYmZm[m\m]m^m_m`mambmcmdmemfmgmhmimjmkmlmmmnmompmpmqmrmsmtmumvmwmwmxmymzm{m|m}m~mmmmmmmmmmmnnnnnnnnnnnnnoooooooooooppppppppppppppppppppppp6pqqqqqqqqqqqqqqqqqqqqqqqqrrrrrrrrrrrrrrrrrssssssssssssssssssssssssssssssssssssssssssssssst t t t t t ttuuuuuuuuuuuuuuuuu u!u"u#u$u%u&u'u(u)u*u+u,u-u.u/u0u1u2u3u4u5u6u7u8u9u:u;u<u=u>u?u@uAuBuCuDuEuFuGuHuIuJuKuLuMuNuOuPuQuRuSuTuUuVuWuXuYuZu[u\u]u^u_u`uaubucudvevfvgvhvivjvkvlvmvnvovpvqwrwswtwuwvxwxxxyxzx{x|x}x~xxxxxxxxxxxxxxxxxxxxxxxxxyyyyzzzzz{||||||}~~~~HM=                  ! "#$%&'()*+,-./012      3456789:;<=>>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghiijklmnopqrstuvwxyz{|}~opnkmm       R !"#$%&'(()*+,-./01223456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghhijklmEExwnopqrstuvwxyz{|}~ H      !"#$%&'()*+,-./0123456789:;<==>?@ABCDEFGHIJVKLLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~}|~qr ?      !"#$%&'()X*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~     !!!! !!!"!#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{| } ~            !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ i I      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~         ! " #$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`aabccdefghijklmnopqrstuvwxyz{|}~                                                                                 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdcecfghijklmnopqrstuvwxyz{|}~                         !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~`MNOJK               i                !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXXYZ[\]^_`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 1 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!W7!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 !G ! ! ! ! ! ! ! !_! ! ! !!Z!![!!\!!]!!!!^"!`"!"!a"!b"!c"!d"!e"!f#!$!%!%!%!%!%!%!%!%!%!%!%!%!%!&2&!&!&!&!&!&!&!&!&!&!&!&!&!&!&!&!&H&!&!&!&!&!&!&!'!(( (!(!(!(!g(!(!(!(!h(!(!(!(!(!(!(!@(!(!(!( (!(!(!(!(! (!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!((!(!(!(!t(!(!(!(!w(!}(!z(!=(!v(!{(!x(!(!(!(!(!(!(!(!J(!(!(!(! (!(!(!(!W(!Y(!(7(!(!_) ) )!Z)![)!\)!])!^*!`*!f+!+!+!+!+!+!+!+!+!+!+!+!+!+!+!+!+!+!+!Z+![+!]+!\+!`+7++!+!+!+!+!+!+!+!+!+!+!+!+!+!+"+"+"+"+"+"+"+"+"+" +" +" +" +" +"+"+",","-"-"-"."/"/"/"0"0"0"0"0"0"0" 0"!0""0"#0"$0"%0"&0"'0"(1!1!1!1!1!2!2!3!3!3!4")4"*4"+4",4"-4".4"/4"05 5 5 5 5 5 556 6 6 6 6 6 667"17"27"37"47"5777"67"77"87"98":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#S#T#U#V#W#X#Y#Z#[#[#\#]#^#^#_#`#a#b#c#d#d#e#f#g#h#i#j#k#l#m#n#o#p#q#r#s#t#u#v#w#x#y#z#{#|#}#~##############################################(#)########@#A#A#A#B#B#B#B#$#$#K##$#$#&#&#&#&#]########*#*#*#*#*#*#*#*#*#] #]#]#]#*#] #]#]#+#+#+#+#+#+#+#+#+#,,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#-#-#-#-#-#-#-#-#]#$-$-$-$-$-$-$$$]$ $ $ $ ]$ $ $/$0$$$$8$8$] g$8$] g$8$]$] $] $<$=$>$>$ >$!]$"]$#$#K$$B$%B$&E$'F$(F$)F$*F$+H$,HHH$-H$.H1H$/H$0H$1H$2H$3H$4H$5H$6H$7HH$8H$9H$:H$;H$<H$=H$>H$?H$@H$AH$BH$CH XH$DH$EH$FH$GH$HH$IH$JH$KK$L$MH$NI$OI$PI$QI]#$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]#${]#$|]#$}]#$~]#$]#$]#$]#$]#$]#$]#$]#$]#$]##]#$]#$]#$]#$]#$]#$]#$]#$]#$]#$]#$]#$]#$L$L$L$L$L$L$P$P$P$P$P$P$U$U$f$g$g$n$n$n$n$n$n$n$n$n$o$q$q$q$x$x$z$zzz${$$$$$$$$$]$$$$$$] W$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$i$$$]$]$] F F] F$$$$%%%]%%](%]%%%]%%%%% % % % % %%%%%%%%%%]$%%%%%%%%% %!%"%#%$&%%%&%'%(%)%*%+%,%-%.%/%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%hK$L%i%j%k]%l%m%n%o%p%q%r%s%t%u%v%w%x%y%z%{%|%}%~%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%]%%]%%]%]2%%]%]%]%]%K%%K%%K%%K%&K%%]%]%]%]%]%]%]%]%]%]%]%]%]%]%]%]%]%]%]%]%]%]%]%]%]%]%]%]%]%]%]%]%]%]%]%]%]%]%]%]%]%]%]%]%]%]%]%]%]%]%]%]%]%]%]%]%]%]%]%]&]&]&]&]&]&]&]&]&]& ]& ]& ]& ]& ]&]&]&]&]&]&]&]&]&]&]&]&]&]&]&]&]&]&]& ]&!]&"]&#]&$]&%]&&]&']&(]&)]&*]&+]&,]&-]&.]&/]&0]&1]&2]&3]&4]&5]&6]&7]&8]&9]&:]&;]&<]&=]&>]&?]&@]&A]&B]&C]&D]&E]&F]&G]&H]&I]&J]&K]&L]&M]&N]&O]&P]&Q]&R]&S]&T]&U]&V]&W]&X]&Y]&Z]&[]&\]&]]&^]]]&_]&`]&a]&b]%]&c]&d]&e]&e]&f]&g]&h]&i]&j]&k]&l]&m]&m]&n]&o]&p]&q]&r]&s]&t]&u]&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]'{]'|]'}]'~]']']']']']']']']']']']']']']']']']']']']']']']']'']'']']'']'']'']'']'']'']'']'']'']'']'']'']'']'']'']'']'']'']']']']']']']']']']']']']']'] d'] d'] d'] d'] d'] d'] d'] d'] d'] d'] d'] d'] d'] d'] d'] d'] d'] d'] d'] d'] d'] d'] d'] d'] d']'']'']'']'']'']'']'''' ']'' ' ' ']'']'' ' ' ' ' ' ''''''']'']''''''''''''']''']'''((]((]'(((]((##( ( ]( ]( ( ]((]((]((((K#(((((((((((( (!("(#K($(%KQ(&K$$('K((()K((()K(((*K(((+K(,(-K(.(/](0(1](0(2](0(3](0(4](0(5](0(6](0(7](0(8](0(9](0(:](0(;](0(<](0(=](0(>](0(?](0(@](A(B](A(C](A(D](A(E](A(F](A(G](A(H](A(I](A(J](A(K](A(L](A(M](A(N](A(O](A(P](A(Q](A(R](A(S](A(T](A(U](A(V](A](A(W](A(X](A(Y](A(Z](A([](A(\](A(]](A(^](A(_](A(`](A(a](A(b](A(c](A(d](A(e](A(f](A(g](A(h](A(i](A(j](A(k](A(l](A(m](A(n](A(o](A(p](A(q](A(r](A](A(s](A(t](A(u](A(v](A(w](A(x](A(y](A(z](A({](A(|](A(}](A(~](A(](A(](A(]((]((]((]((]((]((]((]((]((]((]((]((]((]((]((]((]((]((]((]((]((]((]((]((]((]((]((]((]((]((]((]((]((]((]((]((]((]((]((]((]((]((]((]((]((]((]((]((]((]((]((]((]((]((]((]((]((]((](#]((](](](](](](](](](](](](](](](]]](](]"](](](](](](](](](](](](](](](](](](](](](](](](](](](](](](](](](](](](](](](](](](](]((]((]((]((]((]((]((]()]()]()]()]()]()]()]()]()]()]() ]() ]() ]() ]() ](']()]()]()]()])])])])])])])])])])])])])])])]) ])!])"])#])$])%])&])'])(]))])*])+]),])-]).])/])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]*0]*1]*2]*3]*4]*5]*6]*7]*8]*8]*9]*:]*;]*;]*<]*=]*>]*?]*@]*A]*B]*C]*C]*D]*E]*F]*G]*H]*I]*J]*K]*L]*M]*N]*O]*P]*Q*R]*Q*S]*Q*T]*Q*U]*Q*V]*Q*W]*Q*X]*Q*Y]*Q*Z]*Q*[]*Q*\]*Q*]]*Q*^]*Q*_]*Q*`]*Q*a]*Q*b]*Q*c]*Q*d]*Q*e]*Q*f]*Q*g]*Q*h]*Q*i]*Q*j]*Q*k]*Q*l]*Q*m]*Q*n]*Q*o]*Q*p]*Q*q]*Q*r]*Q*s]*Q*t]*Q*u]*Q*v]*Q*w]*Q*x]*Q*y]*Q*z]*Q*{]*Q*|]*Q*}]*Q*~]*Q*]*Q*]*Q*]*]*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]"*]%*]%*]%*]%*]%*]%*]%*]%+]%+]%+]%+]%+]%+]%+]%+]%+]%+ ]%+ ]%+ ]%+ ]%+ ]%+]%+]%+]%+]%+]%+]%+]%+]%+]%+]%+]%+]%+]%+]%+]%+]%+]%+]%+ ]%+ ]%+!]%+"]%+#]%+$]%+%]%+&]$+']$+(]$+)]$+*]$++]$+,]$+-]$+.]$+/]$+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]$+{]$+|]$+}]$+~]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$X]$C]$]$B]$+]$+]$+]$+]$E]$(]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$ S]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$+]$,]$,]$,]$,]$,]$,]$,]$,]$,]$, ]$, ]$, ]$, ]$, ]$]$]$]$]$,]$,]$,]$,]$,]$,]$,]$,]$]$,]9,]9,]9,]9,]9,]9,]9,]9,]9,]9, ]9,!]9,"]9,#]9,$]9,%]9,&]9,']9,(]9,)]9,*]9,+]9,,]9,-]9,.]9,/]9,0]9,1]9,2]9,3]9,4]9,5]9,6]9,7]9,8]9,9]9,:]9,;]9,<]9,=]9,>]9,?]9,@]9,A]9,B]9,C]9,D]9,E]9,F]9,G]9,G]9,H]9,I]9,J]9,K]9,L]9,M]9,N]9,O]9,P]9,Q]9,R]9,S],T,U],T,V],T,W],T,X],T,Y],T,Z],T,[],T,\],T,]],T,^],T,_],T,`],T,a],T,b],T,c],T,d],T,e],T,f],T,g],T,h],T,i],T,j],T,k],T,l],T,m],T,n],T,o],T,p],T,q],T,r],T,s],T,t],T,u],T,v],T,w],T,x],T,y],T,z],T,{],T,|],T,}],T,~],T,],T,],T,],T,],T,],T,],T,],T,],T,],T,],T,],T,],T,T],T,],T,],T,],T,],T,],T,],T,],T,],T,],T,],T,],T,],T,],T,],T,],,],],],],],],],],],],],],],],],],],],],],],],],],],],],],],],],],],],],],],],],],],],],],],],],],],],],],],],],],],],],],],],],],],],],],],],],],],],],],],],],],],],],],],],],],],],],],],],],],],],],],]-]-]-]-]-]-]-]-]-]- ]- ]- ]- ]- ]-]-]-]-]-]-]-]-]-]-]-]-]-]-]-]-]-]-]- ]-!]-"]-#]-$]-%]-&]-']-(]-)]-*]-+]-,]--]-.]-/]-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]-{]-|]-}]-~]-]-]-]-]-]-]-]-]-]-]-]-]-]-]-]-]-]-]-]-]-]-]-]-]-]-]-]-]-]-]-]-]-]-]-]-]-]-]-]-]-]-]-]-]-]-]-]-]-]-]-]-]-]-]-]-]-]-]]-]-]-]-]-]-]-]--]--]--]--]--]--]--]--]--]--]--]--]--]--]--]--]--]--]--]--]--]--]--]--]--]--]--]--]--]--]--]--]--]--]--]--]--]--]--]--]--]--]--]--]--]--]--]--]--]--]--]--]--]--]--]--]--]--]--]--]--]--]--]--]-.]-.]-.]-.]-.]-.]-.]-.]9.]9. ]9. ]9. ]9. ]9. ]9.]9.]9.]9.]9.]9.]9.]9.]9.]9.]9.]9.]B.]B.]B.]B.]B.]B.]B. ]B.!]B."]B.#]B%Z]B.$]B.%]B.&]B.']B.(]B.)]B.*]B.+]B.,]B.-]B..]B./]B.0]B.1]B.2]B.3]B.4]B.5]B.6]B.7]B.8]B.9]B.:]B.;]B.<]B.=]B.>]B.?]B.@]B.A]B.B]B.C]B.D]B.E]B.F]B.G].H.I].H.J].H.K].H.L].H.M].H.N].H.O].H.P].H.Q].H.Q].H.R].H.S].H.T].H.U].H.V].H.W].H.X].H.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]B/x]/y]/z]]/{]/|]/}]/~]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]/]0]0]0]0]0]0]0]0]0]0 ]0 ]0 ]0 ]0 ]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0 ]0!]0"]0#]0$]0%]0&]0']0(]0)]0*]0+]0,]0-]0.]0/]00]01]02]03]04]05]06]07]08]09]0:]0;]0<]0=]0>]0?]0@]0A]0B]0C]0D]0E]0F]0G]0H]0I]0J]0K]0L]0M]0N]0O]0P]0Q]0R]0S]0T]0U]0V]0W]0X]0Y]0Z]0[]0\]0]]0^]0_]0`]0a]0b]0c]0d]0e]0f]0g]0h]0i]0j]0k]0l]0m]0n]0o]0p]0q]0r]0s]0t]0u]0v]0w]0x]0y]0z]0{]0|]0}]0~]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]0]1]1]1]1]1]1]1]1]1]1 ]1 ]1 ]1 ]1 ]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1 ]1!]1"]1#]1$]1%]1&]1']1(]1)]1*]1+]1,]1-]1.]1/]10]11]12]13]14]15]16]17]18]19]1:]1;]1<]1=]1>]1?]1@]1A]1B]1C]1D]1E]1F]1G]1H]1I]1J]1K]1L]1M]1M]1N]1O]1O]1P]1Q]1R]1S]1T]1U]1V]1W]1X]1Y]1Z]1[]1\]1]]1^]1_]1`]1a]1b]1c]1d]1e]1f]1g]1h]1i]1j]1k]1l]1m]1n]1o]1p]1q]1q]1r]1r]1s]1s]1t]1u]1v]1w]1x]1y]1z]1{]1|]1}]1~]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]$ 1]$ 1]$ 1]$ 1]$ 1]$ 1]$ 1]$ 1]$ 1]$ 1]$ 1]$ 1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]1]2]2]2]2]2]2]2]2]2]2]2]2 ]2 ]2 ]2 ]2 ]2 ]2 ]2]2]2]2]2]2]22]22]22]22]22]22]22]22]22]22]22]22 ]22!]22"]22#]22$]22%]22&]22']22(]22)]22*]22+]22,]22-]22.]22/]220]221]222]223]224]225]226]22]2728]2729]272:]272;]272<]272=]272>]272?]272@]272A]272B]272C]272D]272E]272F]272G]272H]272I]272J]272K]272L]272M]272N]272O]272P]272Q]272R]272S]272T]272U]272V]272W]272X]272Y]272Z]272[]272\]272]]272^]272_]272`]272a]272b]272c]272d]272e]272f]272g]272h]272i]272j]272k]272l]272m]272n]272o]272p]272q]272r]2727](2s](2t](2u](2v](2w](2x](2y](2z](2{](2|](2}](2~](2](2](2]%2]%2]%2]%2]%%]%2]%2]%2]%2]%2]%2]%2]%2]%2]%2]%2]%\]%.?]%2]%2]%2]%2]%2]%2]%2]%2]%2]%2]%2] 2] 2] 2] 2] 2] 2] 2] 2] 2] 2] 2] 2] 2] 2] 2] 2] 2] 2] 2] 2] 2] 2] 2] 2] F2] F2] F2] F2] F2] F2] F2] F2] F2] F2] F2] F2] F2] F2] F2] F2] F2] F2] F2] F2] F2] F2] F2] F2] F2] F2] F2] F2] F2] F2] F2] F2] F2] F2] F2] F2] F2] F2] F2] F2] F2] F2] F2] F2] F2] F2] F2] F2] F2] F2] F2] F2] F2] F2] F2] F2] F2] F2] F2] F2] F2] F2] F2] F2] F2] F2] F2] F2] F2] F2] F2] F2] F2] F2] F2] F2] F3] F3] F3] F3] F3] F3] F3] F3] F3] F3 ] F3 ] F3 ] F3 ] F3 ] F3] F3] F3] F3] F3] F3] F3] F3] F3] F3] F3] F3] F3] F3] F3] F3] F3] F3] F3 ] F3!] F3"] F3#] F3$] F3%] F3&] F3'] F3(] F3)] F3*] F3+] F3,] F3-] F3.] F3/] F30] F31] F32] F33] F34] F35] F36] F37] F38] F39] F3:] F3;] F3<] F3=] F3>] F3?] F3@] F3A] F3B] F3C] F3D] F3E] F3F] F3G] F3H] F3I] F3J] F3K] F3L] F3M] F3N] F3O] F3P] F3Q] F3R] F3S] F3T] F3U] F3V] F3W] F3X] F3Y] F3Z] F3[] F3\] F3]] F3^] F3_] F3`] F3a] F3b] F3c] F3d] F3e] F3f] F3g] F3h] F3i] F3j] F3k] F3l] F3m] F3n] F3o] F3p] F3q] F3r] F3s] F3t] F3u] F3v] F3w] F3x] F3y] F3z]/ 3{]/ 3|]/ 3}]/ 3~]/ 3]/ 3]/ 3]/ 3]/ 3]/ 3]/ 3]3]]3]3]3]3]3]3]3]$#3]$#3]$#3]$#3]$#3]$#3]$#3]$#3]$#3]$#3]$#3]$#3]$#3]$#3]$#3]$#3]$#3]$#3]$#3]$#3]$#3]$#3]$#3]$#3]$#3]$#3]$#3]$#3]$#3]$#3]$#3]$#3]$#3]$#3]$#3]$#$#]$#3]$#3]$#3]$#3]$#3]$#3]33]33]33]33]33]33]33]33]33]33]33]33]33]33]33]33]33]33]33]33]33]33]33]33]33]33]33]33]33]33]33]33]33]33]33]33]33]33]33]33]33]33]33]33]33]33]33]33]33]33]33]33]33]33]33]33]33]33]33]33]33]33]33]33]33]33]33]33]33]33]33]33]33]33]33]34]34]34]34]34]34]34]34]34]34 ]34 ]34 ]34 ]34 ]34]34]34]34]34]34]34]34]34]34]34]34]34]34]34]34]34]34]34 ]34!]34"]34#]34$]34%]34&]34']34(]34)]34*]34+]34,]34-]34.]34/]340]341]342]343]344]345]46]47]48]49]4:]4;]4<]4=]4>]4?]4@](4A](4A](4B](4C](4D](4E](4F](4G](4H](4I](4J](4J](4K](4L](4M](4M](4N]4O4O]4O4O]4O4P]4O4Q]4O4R]4O4S]4O4T]4O4U]4O4V]4O4W]4O4X]4O4Y]4O4Z]4O4[]4O4\]4O4]]4O4^]4O4_]4O4`]4O4a]4O4b]4O4c]4O4d]4O4e]4O4f]4O4g]4O4h]4O4i]4O4j]4O4k]4O4l]4O4m]4O4n]4O4o]4O4p]4O4q]4O4r]4O4s]4O4t]4O4u]4O4v]4O4w]4O4x]4O4y]4O4z]4O4{]4O4|]4O4}]4O4~]4O4]4O4]4O4]4O4]4O4]4O4]4O4]4O4]4O4]4O4]4O4]4O4]4O4]4O4]4O4]4O4]4O4]4O4]4O4]4O4]4O4]4O4]4O4]4O4]4O4]4O4]4O4]4O4]4O4]4O4]4O4]4O4]4O4]4O4]4O4]4O4]4O4]4O4]4O4]4O4]4O4]4O4]4O4]4O4]4O4]4O4]4O4]4O4]4O4]4O4]4O4]4O4]4O4]4O4]4O4]4O4]4O4]4O4]4O4]4O4]4O4]4O4]4O4]4O4]4O4]4O4]4O4]4O4]4O4]4O4]4O4]4O4]4O4]4O4]4O4]4O4]4O4]4O4]4O4]4O4]4O4]4O4]4O4]4O4]4O4]4]4]4]4]4]4]4]4]4]4]4]4]4]4]4]4]4]4]4]4]4]4]4]4]4]4]4]4]4]4]4]4]4]4]4]4]4]4]4]4]4]4]4]4]5]5]5]5]5]5]5]5]5]5 ]5 ]5 ]5 ]5 ]5]5]5]5]5]5]5]5]5]5]5]5]5]5]5]5]5]5]5 ]5!]5"]5#]5$]5%]5&]5']5(]5)]5*]5+]5,]5-] W5.] W5/] W50] F51] F52] F53] F54] F55]5657]5658]5659]565:]565;]5<5=]5<5>]5<5?]5<5@]5<5A]5<5A]5B5C]5B5C]5B5D]5B5E]5B5F]5B5G]5B5H]5B5I]5B5J]5B5K]5B5L]5B5M]5B5N]5B5O]5B5P]5B5Q]5B5R]5B5S]5B5T]5B5U]5B5V]5B5W]5B5X]5B5Y]5B5Z]5B5[]5B5\]5B5]]5B5^]5B5_]5B5`5a5b5c5dU5e5f5g5h5i5j5k5l5m5n5o5p5q5r5s5t5u5v5w5x5y5z5{5|5}]5~5555555555KL555#5555c5c5c5c5c5c5c5c5c5c5c5c5c5c5c5c55555555555555555555555555555 5 555555]55555555555555555555w55555##555K55K555555555555555555555555555555556666666666 6 6 6 6 6666666 666666666666 6!6"]#6#6$6%]26&]26'6(6)6*6+6,6-6.6/60616263646566676869]Z6:6;6<6=6>6?6@6A6B6C6D6E6F6G6H6I6J6K6L6M6N6O6P6Q6R6S6T6U6V6W6X6Y6Z6[6\6]6^6_6`6a6b6c6d6e6f6g6h6i6j6k6l6m6n6o6p6q6r6s6t6u6v6w 6x 6y 6z 6{ 6| 6} 6~ 6 6 6 6 6 6 6 6 6 6 6 6]6 6 6 6 6 6 6 6##6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 666666666666666666](6666666666I6666666666666666666 7 6 7 7 7 7 7 7 7"7"7 "7 "7 "7 "6"6"7 "7"7"7$7$7$7$7'7'7'7'7'7'7(7(7(7(7(7(7 ((7!(6(7"(7#(7$(7%*6K7&,7',7(,7),7*,7+,7,,7-,7.07/1!1!1!1!1701%21!11711"1721"1731742%02%12712752762772782793!3!3713"47:47;47<47=47>47?47@87A87B87C87D87E97F97G97H97I97J97K97L97M97N;7O;7P;7Q;7R;7S;7T;7U;7V;7W;7X;7Y;7Z;/#;7[;7\;7];7^<7_<7`<7a<7b<7c<7d<7e<7f=7g=7h=7i=7j=7k=7l=7m7n7oK$L7p7q7r7s7t7u7v7w7x7y7z7{7|7}7~77777777]7]7]7KL7777777?7K77?7?7?7?7?7?7?7?7?7?r?7?7?7?7?7?7?7?7?7?7?777]77]77]77]77]77]77]77]77]]7]]7]]7]]7]]7]]7]]7]]7]]7]]7]]7]]7]]7]]7]]7]]7]]7]]7]]7]]7]]7]]7]]7]]7]]7]]7]]7]]7]]7]]7]]7]]7]]7]]7]]7]]7]]7]]7]]7]]7]]7]]7]]7]]7]]7]]7]]7]]7]]7]]7]]7]]7]]7]]7]]7]]7]]7]]7]]7]]7]]7]]7]]7]]7]]7]]7]]7]]7]]7]]7]]7]]7]]7]]7]]7]]7]]7]]7]]8]]8]]8]]8]]8]]8]]8]]8]]8]]8 ]]8 ]]8 ]]8 ]]8 ]]8]]8]]8]]8]]8]]8]]8]]8]]8]]8]]8]]8]]8]]8]]8]]8]]8]]8]]8 ]]8!]]8"]]8#]]8$]]8%]]8&]]8']]8(]]8)]]8*]]8+]]8,]]8-]]8.]]8/]]80]]81]]82]]83]]84]]85]]86]]87]]88]]89](8:](8;](8<](8=](8>](8?](8@](8A](8B](8C](8D](8E](8F](8G](8H](8I](8J](8K](8L](8M](8N](8O](8P](8Q](8R](8S](8T](8U](8V](8W](8X](8Y](8Z](8[](8\](8]](8^](8_](8`](8a](8b](8c](8d](8e](8f](8g](8h](8i](8j](8k](8l](8m](8n](8o](8p](8q](8r](8s](8t](8u](8v](8w](8x](8y](8z](8{](8|](8}](8~](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](](](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](8](C](8](8](8](8](8](8](8](9](9](9](9](9](9](9](9](9](9 ](9 ](9 ](9 ](9 ]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9 ]#9!]#9"]#9#]#9$]#9%]#9&]#9']#9(]#9)]#9*]#9+]#9,]#9-]#9.]#9/]#90]#91]#92]#93]#94]#95]#96]#97]#98]#99]#9:]#9;]#9<]#9=]#9>]#9?]#9@]#9A]#9B]#9C]#9D]#9E]#9F]#9G]#$]#9H]#9I]#9J]#9K]#9L]#9M]#9N]#9O]#9P]#9Q]#9R]#9S]#9T]#9U]#9V]#9W]#9V]#9X]#9Y]#9Z]#9[]#9\]#9]]#9^]#9_]#9`]#9a]#9b]#9c]#9d]#9e]#9f]#9g]#9h]#9i]#9j]#9k]#9l]#9m]#9n]#9o]#9p]#9q]#9q]#9r]#9s]#9t]#9t]#9u]#9v]#9w]#9x]#9y]#9z]#9{]#9|]#9}]#9~]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#9]#H]#9]#9]#9]#9]#9]#9]#:]#:]#:]#:]#:]#:]#:]#:]#:]#: ]#: ]#: ]#: ]#: ]#:]#:]#:]#:]#:]#:]#:]#:]#:]#:]#:]#:]#:]#:]#:]#:]#:]#*]#:]#:]#:]#: ]#:!]#:"]#:#]#:$]#:%]#:&]#:']#:(]#:)]#:*]#:+]#:,]#:-]#:.]#:.]#:/](:0](:1](:2](:3](:4](:5](:6](:7](:8](:9](::](:;](:<](:=](:>](:?](:@](:A](:B](:C](:D](:E](:F](:F](:G](:H](:H](:I](:J](:K](:L](:M](:N](:O](:P](:N](:Q](:R](:S]:T:U]:T:V]:T:W]:T:X]:T:Y]:T:Z]:T:[]:T:\]:T:]]:T:^]:T:_]:T:`]:T:a]:T:b]:T:c]:T:d]:T:e]:T:f]:T:g]:T:h]:T:i]:T:j]:T:k]:T:l]:T:m]:T:n]:T:o]:T:p]:T:q]:T:r]:T:s]:T:t]:T:u]:T:v]:T:w]:T:x]:T:y]:T:z]:T:{]:T:|]:T:}]:T:~]:T:]:T:]:T:]:T:~]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:}]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:T:]:]:]:]:]:]:]:]:]:]:]:]:]:]:]:]:]:]:]:]:]:]:]:]:]:]:]:]:]:]:]:]:]:]:]:];];];];];];];];];]; ]; ]; ]; ]; ];];];];];];];];];];];];];];];];];];]; ];!];"];#];$];%];&];'];(];)];*];+];,];-];.];/];0];1];2];3];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];9];V];W];X];Y];Z];[];\];]];^];_];^];`];a];b];c];d];e];f];g];h];i];j];k];l];m];n];n];o];p];q];r];s];t];u](;v](;w](;x](;y](;z](;{](;|]((](;}](;~](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;]( ](;](;](;](;]((](;](8](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;](;]5~;]5~;]5~;]5~;]5~;]5~;]5~;]5~;]5~;]5~;]5~;]5~;]5~;]5~;]5~;]5~;]5~;]5~;]5~<]5~<]5~<]5~<]5~<]5~<]5~<]5~ f]5~<]5~<]5~< ]5~< ]5~< ]5~< ]5~< ]5~<]5~<]5~<]5~<]5~<]5~<]5~<]5~<](<](<](<](<](<](<](<](<](<](<](<](< ](]<0]<0;]<0=?]<0=@]<0=A]<0=B]<0=C]<0=D]<0=E]<0=F]<0=G]<0=H]<0=I]<0=J]<0=K]<0=L]<0=M]<0=N]<0=O]<0=P]<0=Q]<0=R]<0=S]<0=T]<0=U]<0=V]<0=W]<0=X]<0=Y]<0=Z]<0=[]<0=\]<0=]]<0=^]<0=_]<0=`]<0=a]<0=b]<0=c]<0=d]<0=e]<0=f]<0=g]<0=h]<0=i]<0=j]<0=k]<0=l]<0=m]<0=n]<0=o]<0=p]<0=q]<0=r]<0=s]<0=t]<0=u]<0=v]<0=w]<0=x]<0;_]<0=y]<0=z]<0={]<0=|]<0=}]<0=~]<0=]<0=]<0=]<0=]<0=]<0=]<0=]<0=]<0=]<0=]<0=]<0=]<0=]<0=]<0=]<0=]<0=]==]==]==]==]==]==]==]==]==]==]==]==]==]==]==]==]==A=B=]=B=B=B=B=B=B=B=B=B=B=B=B=B=B=B=B=B=B=B=B=B=B=B=B=B=B=B==)ghc-lib-0.20190402-HnXkzhLcc2y4RINYwA146VDsMonad SpecConstrPrelInfo Specialise GhcPlugins SimplMonadGHCDriverPipeline TcPluginMInstTcSigsTcEnv NameShapeTcHsSynTcSMonadHscMainFinderTmOracleTcExprTcMType TcValidityFamInst ByteCodeGenInteractiveEvalIfaceEnv StgCmmClosureFunDeps TcTypeNats RnUnboundRnNames StgCmmMonadSysTools ByteCodeAsmGHCiLanguage.Haskell.TH.QuoteArAsmUtilsCSE CmmMachOpCPrimCmmMonadConvertCoreLintElf ExtractDocsDsUsageFloatInGHC.HandleEncodingGHCi.BinaryArrayGHCi.InfoTable GHCi.ObjLinkGHCi.ResolvedBCOGHCi.CreateBCO GHCi.SignalsGHCi.StaticPtrTableGHCi.THGHCi.Run ByteCodeLink GraphBaseGraphOpsGraphPpr GraphColor HeaderInfoHieTypesHieUtils Hoopl.BlockHoopl.Collections Hoopl.Label Hoopl.Graph CmmSwitchBlockIdCLabelCoverageCmmExprCmmLex HsDumpAstHscStats LiberateCaseListT LlvmManglerPPC.Cond Paths_ghc_lib PprCmmExprProfInitRegAlloc.Graph.ArchBaseRegAlloc.Graph.ArchX86RegAlloc.Linear.StackMapRegClassRegRegAlloc.Graph.TrivColorableCodeGen.Platform.X86_64CodeGen.Platform.X86CodeGen.Platform.SPARCCodeGen.Platform.PPCCodeGen.Platform.NoRegsCodeGen.Platform.ARM64CodeGen.Platform.ARMCodeGen.PlatformRnExprRnHsDocSATSMRepCmmNodeCmm PprCmmDeclPprBase Llvm.Types Llvm.MetaData Llvm.AbsSyn Llvm.PpLlvmLlvmCodeGen.Regs InstructionHoopl.DataflowFormatPPC.RegsRegAlloc.Linear.PPC.FreeRegsCmmUtilsPprCmmPprCDebugCmmOptCmmLiveCmmSinkCmmLintCmmImplementSwitchPlansCmmContFlowOptCmmCommonBlockElim CmmCallConvMkGraphCgUtilsCFGBitmap SPARC.Base SPARC.Cond SPARC.ImmSPARC.AddrMode SPARC.RegsRegAlloc.Linear.SPARC.FreeRegs SPARC.Stack SetLevelsFloatOutSimplEnv SimplUtilsSimplifyStateRegAlloc.LivenessRegAlloc.Linear.BaseRegAlloc.Graph.CoalesceRegAlloc.Linear.StatsRegAlloc.Linear.StateRegAlloc.Graph.SpillCostRegAlloc.Graph.SpillCleanRegAlloc.Graph.SpillExitifyStgSubstStgSynStgStatsStgLintStgLiftLams.LiftMStgFVsStgCse StgCmmUtils StgCmmProf StgCmmHpc StgCmmExtCode StgCmmEnv StgCmmArgRep StgCmmTicky StgCmmBind CoreToStgStreamLlvmCodeGen.BaseLlvmCodeGen.DataLlvmCodeGen.PprLlvmCodeGen.CodeGenCmmInfo StgCmmLayoutStgLiftLams.AnalysisStgLiftLams.Transformation StgCmmHeapCmmBuildInfoTables StgCmmForeign StgCmmPrim ByteCodeItbls ByteCodeInstr CmmProcPointCmmLayoutStack CmmPipelineSysTools.Process SysTools.InfoSysTools.TasksSysTools.ExtraObj LlvmCodeGenTHNamesTcEvTerm TcHoleErrorsTcIface TcMatches TcRnDriver TcRnMonadTcPatSynRnSplice LoadIface RnModIface BuildTyClTcSplice TcAnnotations StgCmmCon StgCmmExprCmmParseStgCmmBinIfaceMatchDsExprDsUtilsMatchLitDsMetaDsCCallStaticPtrTableRnUtils DsForeignCorePrepRnFixityRnEnvRnTypesRnPat TcRnExportsRnBindsRnSourceLinkerDynamicLoadingHieBinHieDebug FlagCheckerMkIface PprTyThingTcUnifyClsInstTcErrors TcFlatten TcCanonical TcInteract TcSimplifyRtClosureInspectTcHsTypeTcPat TcGenDeriv TcGenFunctor TcGenGenerics TcDerivUtils TcDerivInfer TcDefaultsTcBinds TcTypeable TcTyDecls TcBackpack TcClassDclTcDeriv TcInstDcls TcTyClsDeclsTcArrowsTcRules TcForeignTidyPgmCheckDsGRHSsDsBindsMatchCon DsListCompDsArrowsDesugarHieAst UnVarGraph CallArity UnariseStgSimplStgUniqMapWwLibWorkWrapDmdAnal SimplCoreX86.CondX86.Regs X86.RegInfo TargetReg X86.InstrX86.Ppr SPARC.InstrSPARC.ShortcutJump SPARC.PprSPARC.CodeGen.SanitySPARC.CodeGen.ExpandSPARC.CodeGen.BaseRegAlloc.Graph.StatsRegAlloc.Graph.Main PPC.Instr PPC.RegInfoPPC.PprNCGMonadSPARC.CodeGen.Gen32SPARC.CodeGen.CondCodeSPARC.CodeGen.AmodeSPARC.CodeGen.Gen64PIC X86.CodeGen SPARC.CodeGen PPC.CodeGen BlockLayoutRegAlloc.Linear.X86_64.FreeRegsRegAlloc.Linear.X86.FreeRegsRegAlloc.Linear.FreeRegsRegAlloc.Linear.JoinToTargetsRegAlloc.Linear.MainDwarf.Constants Dwarf.TypesDwarf AsmCodeGen CodeOutputGhcMakeDriverMkDependDebugger DriverBkpLlvm CoreSubstSubst HsExpressionNoExtliftedIdsExpander StgLiftLams addExternalbaseGHC.Base<*>pure*> ApplicativeGHC.ExtsForceSpecConstr NoSpecConstrSpecConstrAnnotation Control.Monad mapAndUnzipMData.TraversablemapM Data.Functor<$><*liftA20ghc-lib-parser-0.20190402-CHUgcK2EeWYFOM9TVidF0RMkId ghcPrimIds wiredInIds PrelRules builtinRules primOpRules CoreUnfold specUnfolding substTickish substDVarSetsubstRulesForImportedIds substSpec substIdOccsubstUnfoldingsubstUnfoldingSC substIdInfosubstCo getTCvSubstsubstTycloneRecIdBndrs cloneBndr cloneBndrs cloneIdBndrs cloneIdBndr substRecBndrs substBndrs substBndr deShadowBinds substBind substBindSC substExpr substExprSC setInScopeextendInScopeIdsextendInScopeList extendInScope addInScopeSet isInScope mkOpenSubstdelBndrsdelBndrlookupTCvSubst lookupIdSubstextendSubstListextendSubstWithVar extendSubstextendTvSubstList extendTvSubstextendIdSubstList extendIdSubst zapSubstEnv substInScopemkSubst mkEmptySubst emptySubst isEmptySubst IdSubstEnv CoreMonad pprSimplCountplusSimplCountisZeroSimplCountzeroSimplCountGhcMonaddefaultWarnErrLoggerprintExceptiongetSessionDynFlags setSession getSessionGhcGhcT WarnErrLogger PipelineMonadsetModLocation setDynFlags getPipeState getPipeEnvunPP CompPipelineHscOut RealPhase PhasePlus output_spec src_suffix src_basename src_filename stop_phasePipeEnv foreign_os maybe_lochsc_env PipeState TcRnTypesgetEvBindsTcPluginMunsafeTcPluginTcM tyCoVarsOfWC tyCoVarsOfCts tyCoVarsOfCthasCompleteSig isPartialSigthLevelns_map ns_exports ns_mod_nameDsM DsMetaEnvDsSpliceDsBound DsMetaValTcIdTcIdSettct_infotct_id APromotionErrATcTyConATyVarATcIdAGlobal TcTyThingTcSigFun TcPatSynSigTcIdSig TcSigInfo psig_hs_ty psig_namesig_locsig_ctxtsig_bndr PartialSig CompleteSig TcIdSigInfo TcIdSigInstpatsig_body_ty patsig_provpatsig_ex_bndrs patsig_reqpatsig_univ_bndrspatsig_implicit_bndrs patsig_nameTPSI TcPatSynInfo qci_pend_scqci_predqci_tvsqci_evQCIQCInstHscTypes ms_mod_name mkModuleGraphemptyMGmgLookupModulemgModSummariesmapMGneedsTemplateHaskellOrQQhandleSourceError HscRecomp HscUpdateSig HscUpdateBoot HscUpToDateHscNotGeneratingCode HscStatusHscEnvtargetContentstargetAllowObjCodetargetIdTarget TargetFile TargetModuleTargetIdfr_suggestions fr_unusablesfr_pkgs_hiddenfr_mods_hiddenfr_pkgfr_pathsNotFound FoundMultiple NoPackageFound FindResult mi_arg_docs mi_decl_docs mi_doc_hdrmi_complete_sigs mi_trust_pkgmi_trustmi_hpc mi_hash_fn mi_fix_fn mi_warn_fnmi_orphan_hashmi_rules mi_fam_instsmi_insts mi_globalsmi_declsmi_annsmi_warns mi_fixities mi_used_th mi_exp_hash mi_exports mi_usagesmi_deps mi_hsc_src mi_finsts mi_orphanmi_plugin_hash mi_hpc_hash mi_opt_hash mi_flag_hash mi_mod_hash mi_iface_hash mi_sig_of mi_moduleModIfaceIIModuleIIDeclInteractiveImport ModuleGraph ms_hspp_buf ms_hspp_opts ms_hspp_file ms_parsed_modms_textual_imps ms_srcimps ms_hie_date ms_iface_date ms_obj_date ms_hs_date ms_location ms_hsc_srcms_mod ModSummaryPmExprpprPmExprWithParens runPmPprM filterComplexhsExprToPmExprlhsExprToPmExprisNotPmExprOther falsePmExpr toComplexeqPmLit PmExprOtherPmExprEq PmExprLit PmExprCon PmExprVarPmOLitPmSLitPmLitSimpleEq ComplexEqHsUtils mkHsDictLet mkHsCaseAltmkHsAppInstEnvpprInstanceHdr pprInstanceinstanceDFunIdTcType synKnownTypemkCheckExpType TcThetaType TcTauTypeTcKind TcTyVarSetInferExpType ExpSigmaType ExpRhoTypeSynTypeSynFunSynListSynRhoSynAny SyntaxOpTypeTyFamResKindCtxt TySynKindCtxt DataKindCtxtTyVarBndrKindCtxtDerivClauseCtxt DataTyCtxt SigmaCtxt ClassSCCtxtGhciCtxt GenSigCtxt ThBrackCtxt SpecInstCtxt InstDeclCtxtDefaultDeclCtxt ForSigCtxt ResSigCtxt RuleSigCtxt PatSigCtxt PatSynCtxt TySynCtxt ConArgCtxt TypeAppCtxt KindSigCtxt ExprSigCtxt InfSigCtxt FunSigCtxt UserTypeCtxtTcLevel FamInstEnv FamInstEnvs ByteCodeTypes UnlinkedBCO BreakIndexmodBreaks_breakInfo modBreaks_ccsmodBreaks_declsmodBreaks_varsmodBreaks_locsmodBreaks_flags ModBreaksHsTypes mkHsAppTyInteractiveEvalTypesexecWrapexecLineNumberexecSourceFileexecSingleStep ExecOptionsRunAndLogSteps SingleStepRunToCompletion breakInfo breakNamesexecAllocation execResult ExecBreak ExecComplete ExecResultbreakInfo_numberbreakInfo_module BreakInforesumeHistoryIx resumeHistory resumeCCS resumeDecl resumeSpanresumeBreakInfo resumeApStackresumeFinalIdsresumeBindings resumeContext resumeStmtResumehistoryEnclosingDeclshistoryBreakInfohistoryApStackHistory NameCacheextendNameCachelookupOrigNameCacheIdisNeverLevPolyIdtransferPolyIdInfozapStableUnfoldingzapIdTailCallInfozapIdUsedOnceInfozapIdUsageEnvInfozapIdUsageInfozapIdDemandInfozapFragileIdInfo zapLamIdInfoupdOneShotInfosetIdOneShotInfoclearOneShotLambdasetOneShotLambdaisProbablyOneShotLambdaisStateHackType typeOneShotstateHackOneShot isOneShotBndridStateHackOneShotInfo idOneShotInfo isConLikeIdidRuleMatchInfosetInlineActivationidInlineActivationmodifyInlinePragmasetInlinePragmaidInlinePragma zapIdOccInfo setIdOccInfo idOccInfo setIdCafInfo idCafInfosetIdSpecialisation idHasRules idCoreRulesidSpecialisationsetCaseBndrEvaldsetIdDemandInfo idDemandInfosetIdUnfoldingrealIdUnfolding idUnfolding isStrictIdzapIdStrictnesssetIdStrictness idStrictness isBottomingId idFunRepAritysetIdCallArity idCallArity setIdArityidArityasJoinId_maybe zapJoinIdasJoinId idJoinArityisDictIdisEvVar isDeadBinderidIsFrom isImplicitId hasNoBinding idDataConisJoinId_maybeisJoinIdisDataConId_maybeisDataConWrapId_maybeisDataConWrapIdisDataConWorkId_maybeisDataConWorkIdisFCallId_maybe isFCallIdisPrimOpId_maybeisDFunId isPrimOpIdisClassOpId_maybeisNaughtyRecordSelectorisPatSynRecordSelectorisDataConRecordSelectorisRecordSelectorrecordSelectorTyConmkTemplateLocalsNummkTemplateLocalsmkTemplateLocal mkWorkerIdmkUserLocalOrCoVar mkUserLocalmkSysLocalOrCoVarM mkSysLocalMmkSysLocalOrCoVar mkSysLocalmkExportedVanillaIdmkExportedLocalIdmkLocalIdWithInfomkLocalIdOrCoVarWithInfomkLocalIdOrCoVar mkLocalCoVar mkLocalIdmkVanillaGlobalWithInfomkVanillaGlobal mkGlobalIdmaybeModifyIdInfo modifyIdInfo setIdInfo localiseId setIdType setIdUnique setIdNameidTypeidUniqueidNameConLike conLikeResTyDataConisVanillaDataCondataConUserType dataConSigdataConSrcBangsdataConIsInfixisMarkedStrictNotMarkedStrict MarkedStrictStrictnessMarkCoercionsimplifyArgsWorker buildCoercion coercionRolecoercionKindRole coercionKinds lcInScopeSet lcTCvSubstliftEnvSubstRightliftEnvSubstLeft lcSubstRight lcSubstLeft swapLiftCoEnv substRightCo substLeftCo isMappedByLCliftCoSubstVarBndrUsingliftCoSubstTyVarsubstForAllCoBndrUsingLCzapLiftingContextextendLiftingContextAndInScopeextendLiftingContextmkSubstLiftingContextemptyLiftingContextliftCoSubstWithliftCoSubstWithEx eqCoercionX eqCoerciontopNormaliseNewType_maybetopNormaliseTypeXunwrapNewTypeSteppercomposeSteppers mapStepResultinstNewTyCon_maybemkCoCastmkPiComkPiCoscastCoercionKindIcastCoercionKindpromoteCoercionltRolenthRoletyConRolesRepresentational tyConRolesXsetNominalRole_maybe maybeSubCo downgradeRolemkCoherenceRightComkCoherenceLeftCo mkGReflLeftComkGReflRightCo nthCoRole mkTransMComkHoleComkUnbranchedAxInstLHS mkAxInstLHSmkUnbranchedAxInstRHS mkAxInstRHSmkUnbranchedAxInstCo mkAxInstCo isCoVar_maybe mkCoVarCosmkHomoForAllCos mkForAllCosmkAppCos mkRepReflCoisReflexiveCo_maybeisReflCo_maybeisGReflCo_maybeisReflCoVar_maybemkHeteroCoercionType coVarKind coVarTypessplitForAllCo_co_maybesplitForAllCo_ty_maybesplitForAllCo_maybesplitFunCo_maybesplitAppCo_maybesplitTyConAppCo_maybegetCoVar_maybedecomposeFunCo decomposeCotidyCoAxBndrsForUser pprCoAxBranchpprCoAxBranchLHSpprCoAxBranchUser pprCoAxiometaExpandCoAxBranch setCoVarNamesetCoVarUnique coVarNameNormaliseStepperNS_StepNS_AbortNS_DoneNormaliseStepResultLC LiftCoEnvType pprWithTYPE setJoinResTymodifyJoinResTysplitVisVarsOfTypessplitVisVarsOfTypesynTyConResKind tyConsOfTypeoccCheckExpandresultIsLevPoly isTypeLevPoly tcTypeKindtypeKind nonDetCmpTcnonDetCmpTypesXnonDetCmpTypeXnonDetCmpTypes nonDetCmpType eqVarBndrseqTypeseqTypeXseqTypesseqTypeisValidJoinPointTypeisPrimitiveType isStrictTypeisDataFamilyAppType isAlgTypeisUnboxedSumTypeisUnboxedTupleType getRuntimeRepgetRuntimeRep_maybedropRuntimeRepArgsisRuntimeRepKindedTyisUnliftedTypeisLiftedType_maybe isFamFreeTypprSourceTyCon coAxNthLHSmkFamilyTyConAppcloseOverKindsDSetcloseOverKindsListcloseOverKindsFVcloseOverKindstyCoVarsOfBindersWellScopeddVarSetElemsWellScoped predTypeEqRel getEqPredRolegetEqPredTys_maybe getEqPredTysgetClassPredTys_maybegetClassPredTysclassifyPredType eqRelRole isDictLikeTyisDictTy mkClassPred equalityTyConmkReprPrimEqPredsplitCoercionType_maybemkHeteroReprPrimEqPredmkHeteroPrimEqPred mkPrimEqPredmkPrimEqPredRoleisIPPred_maybe isCTupleClass isIPClass isIPTyConisIPPred isEqPrimPredisEqPred isClassPred isEqPredClass isCoVarType isEvVarTypetcReturnsConstraintKindtcIsLiftedTypeKindtcIsConstraintKindtcSplitTyConApp_maybebinderRelevantType_maybe tyBinderTypetyCoBinderTypetyCoBinderVar_maybeisAnonTyCoBinder mkAnonBinderisTauTy appTyArgFlags tyConArgFlagspartitionInvisiblespartitionInvisibleTypesfilterOutInferredTypesfilterOutInvisibleTypessplitPiTysInvisibleNsplitPiTysInvisibleinvisibleTyBndrCountsplitForAllVarBndrs splitPiTys splitPiTysplitPiTy_maybesplitForAllTy_co_maybesplitForAllTy_ty_maybesplitForAllTy_maybe dropForAlls splitForAllTyisFunTyisPiTy isForAllTy_co isForAllTy_ty isForAllTysplitForAllTysSameVissplitForAllTysmkTyConBindersPreferAnon mkLamTypes mkLamTypemkVisForAllTysmkSpecForAllTysmkSpecForAllTymkInvForAllTysmkTyCoInvForAllTys mkInvForAllTymkTyCoInvForAllTystripCoercionTyisCoercionTy_maybe mkCoercionTytyConBindersTyCoBinderssplitCastTy_maybenewTyConInstRhsnextRolesplitListTyConApp_mayberepSplitTyConApp_maybe splitTyConApp tyConAppArgN tyConAppArgstyConAppArgs_maybe tyConAppTyContyConAppTyCon_maybetyConAppTyConPicky_maybe mkTyConApp applyTysX piResultTysfunArgTy funResultTy splitFunTyssplitFunTy_maybe splitFunTypprUserTypeErrorTyuserTypeError_maybeisLitTy isStrLitTy mkStrLitTy isNumLitTy mkNumLitTyrepSplitAppTys splitAppTys splitAppTytcRepSplitAppTy_mayberepSplitAppTy_maybesplitAppTy_maybemkAppTysrepGetTyVar_maybegetCastedTyVar_maybegetTyVar_maybe isTyVarTygetTyVar mapCoercionmapTypeexpandTypeSynonyms tcm_tycontcm_tycobindertcm_hole tcm_covar tcm_tyvar TyCoMapperReprEqNomEqEqRel ForAllPred IrredPredEqPred ClassPredPredTreeTysPrimfunTyCon alphaTyVarsTyCoRep coercionSizetypeSizetidyCostidyCotidyKind tidyOpenKind tidyTopType tidyOpenType tidyOpenTypestidyType tidyTypestidyTyCoVarOcctidyOpenTyCoVartidyOpenTyCoVarstidyFreeTyCoVarstidyTyCoVarBinderstidyTyCoVarBinder tidyVarBndr tidyVarBndrspprWithExplicitKindsWhen pprTypeApppprTyVar pprTyVars pprTCvBndr pprTCvBndrs pprUserForAll pprForAll pprSigmaTypepprThetaArrowTypprTheta pprClassPred pprParendCopprCo pprParendKind pprPrecType pprParendTypecloneTyVarBndrscloneTyVarBndrsubstCoVarBndr substVarBndrs substVarBndrsubstTyVarBndrssubstTyVarBndr lookupCoVar substCoVars substCoVarsubstCossubstCoUnchecked lookupTyVar substTyVars substTyVarsubstThetaUnchecked substThetasubstTysUncheckedsubstTyssubstTyUncheckedsubstTyAddInScope substTysWithsubstCoWithUnchecked substCoWithsubstTyWithUnchecked substTyWithzipCoEnvzipTyEnv mkTvSubstPrs zipTCvSubst zipTvSubst unionTCvSubstextendTCvSubstListextendTvSubstAndInScope extendCvSubstextendTvSubstWithCloneextendTvSubstBinderAndInScopeextendTCvSubstWithCloneextendTCvSubstextendTCvInScopeSetextendTCvInScopeListextendTCvInScope zapTCvSubst setTvSubstEnvnotElemTCvSubstgetTCvSubstRangeFVs getTCvInScope getCvSubstEnv getTvSubstEnv mkTCvSubstisEmptyTCvSubstmkEmptyTCvSubst emptyTCvSubstcomposeTCvSubstcomposeTCvSubstEnvemptyCvSubstEnvemptyTvSubstEnvnoFreeVarsOfType coVarsOfCo coVarsOfTypes coVarsOfType tyCoFVsOfCos tyCoFVsOfCotyCoVarsOfCoDSettyCoFVsVarBndrtyCoFVsVarBndrs tyCoFVsBndr tyCoFVsOfTypetyCoVarsOfTypeDSet tyCoVarsOfCos tyCoVarsOfCotyCoVarsOfTypestyCoVarsOfTypesetCoHoleCoVar coHoleCoVarisRuntimeRepVar kindRep_maybekindRep mkTyConTymkPiTysmkPiTy mkForAllTys mkInvisFunTys mkVisFunTys mkInvisFunTy mkVisFunTy mkTyVarTys mkTyVarTy isNamedBinderisVisibleBinderisInvisibleBinderpprTyThingCategorypprShortTyThingACoAxiomATyConAConLikeAnId KindOrTypeKnotTied CoercionR CoercionPMCoMRefl MCoercionRch_ref ch_co_var CoercionHoleTCvSubst TvSubstEnv CvSubstEnvisPredTy isCoercionTymkAppTymkCastTy piResultTyeqTypecoreViewtcViewtyCoVarsOfTypesWellScopedtyCoVarsOfTypeWellScoped scopedSortsplitTyConApp_maybeTyContyConClass_maybe isClassTyConsynTyConRhs_maybesynTyConDefn_maybe tyConDataConsisOpenTypeFamilyTyConisTypeFamilyTyConisOpenFamilyTyCon isFamilyTyConisTypeSynonymTyCon isNewTyCon isPrimTyCon isGcPtrRep isVoidRep tyConTyVars tyConArity tyConKindVarEnv InScopeSetClass pprFundeps classTvsFds classSCThetaclassATs classMethodsmkReflCo mkTyConAppComkAppCo mkForAllComkFunCo mkCoVarCo mkAxiomInstCo mkPhantomCo mkUnsafeComkUnivComkSymCo mkTransComkNthComkLRComkInstCo mkGReflCo mkNomReflComkKindComkSubComkProofIrrelCo mkAxiomRuleCo isGReflCoisReflCo isReflexiveCodecomposePiCoscoVarKindsTypesRole coVarRolemkCoercionType liftCoSubstseqCo coercionKind coercionTypeLiftingContextCoAxiomPhantomRepresentationalNominalRolesfInteractInert sfInteractTop sfMatchFamBuiltInSynFamily dataConTyCondataConFieldLabelsVar isExportedId isGlobalId isLocalIdisCoVarisIdisTyVar globaliseIdmkCoVar idDetailsidInfo tyVarKindmkTyVarBindersmkTyCoVarBindersmkTyCoVarBinder binderType binderArgFlag binderVars binderVarsameVisisInvisibleArgFlagisVisibleArgFlagCoVarTyVarTcTyVarDictIdJoinIdTyCoVarInVarInIdOutVarOutIdvarTypeRequired SpecifiedInferredInvisArgVisArg ForallInvis ForallVis ForallVisFlag TyCoVarBinder TyVarBinderLexerToken ApiAnnotation unicodeAnngetAndRemoveAnnotationCommentsgetAnnotationCommentsgetAndRemoveAnnotation getAnnotationApiAnns AnnEofPosAnnRarrowtailU AnnRarrowtailAnnLarrowtailU AnnLarrowtailAnnrarrowtailU AnnrarrowtailAnnlarrowtailU AnnlarrowtailAnnWhereAnnViaAnnVbar AnnValStrAnnValAnnUsingAnnUnitAnnTypeAnnTilde AnnThTyQuoteAnnThIdTySplice AnnThIdSpliceAnnThenAnnStock AnnStatic AnnSignatureAnnSimpleQuoteAnnSemiAnnSafeAnnRoleAnnRec AnnRarrowU AnnRarrow AnnQualifiedAnnProc AnnPatternAnnPackageNameAnnOpenS AnnOpenPTE AnnOpenPEAnnOpenP AnnOpenEQU AnnOpenEQAnnOpenEAnnOpenC AnnOpenBUAnnOpenBAnnOpenAnnOfAnnName AnnNewtype AnnModuleAnnMinusAnnMdoAnnLet AnnLarrowU AnnLarrowAnnLam AnnInstanceAnnInfixAnnIn AnnImportAnnIf AnnHiding AnnHeaderAnnGroupAnnFunId AnnForeign AnnForallU AnnForall AnnFamily AnnExportAnnEqualAnnElse AnnDotdotAnnDotAnnDo AnnDeriving AnnDefault AnnDcolonU AnnDcolonAnnData AnnDarrowU AnnDarrow AnnCommaTupleAnnCommaAnnColon AnnCloseS AnnCloseP AnnCloseQU AnnCloseQ AnnCloseC AnnCloseBU AnnCloseBAnnCloseAnnClassAnnCaseAnnBy AnnBackquoteAnnBangAnnAtAnnAs AnnAnyclass AnnKeywordIdAnnBlockCommentAnnLineComment AnnDocOptions AnnDocSectionAnnDocCommentNamedAnnDocCommentPrevAnnDocCommentNextAnnotationComment PrelNames isUnboundName mkUnboundNameRdrNamegresFromAvailsQualUnqualName pprPrefixName pprInfixNamegetOccFS getOccString getSrcSpan getSrcLocnameStableStringpprNameDefnLoc pprDefinedAtpprModulePrefixpprNameUnqualified stableNameCmp localiseName tidyNameOcc setNameLoc setNameUnique mkFCallName mkSysTvNamemkSystemVarNamemkSystemNameAt mkSystemName mkWiredInNamemkExternalNamemkDerivedInternalNamemkClonedInternalNamemkInternalName isSystemName isVarName isValName isDataConName isTyConName isTyVarNamenameIsFromExternalPackagenameIsHomePackageImportnameIsHomePackagenameIsLocalOrFromnameModule_maybe nameModule isHoleNameisInternalNameisExternalNameisBuiltInSyntaxwiredInNameTyThing_maybe isWiredInName nameSrcSpan nameSrcLoc nameOccName nameUnique UserSyntax BuiltInSyntaxgetName getOccName NamedThing TysWiredInliftedTypeKindpprKindpprType mkForAllTyisRuntimeRepTyTyThingUnivCoProvenance TyCoBinder MCoercionPredTypeKind ThetaType CoercionNArgFlag AnonArgFlagErrUtilsprettyPrintGhcErrors SimplCountOccName tidyOccNameavoidClashesOccEnvinitTidyOccEnvemptyTidyOccEnv mkMethodOcc mkDataCOcc mkDataTOcc mkDFunOcc mkInstTyTcOcc mkLocalOccmkSuperDictSelOccmkSuperDictAuxOccmkDataConWorkerOccmkRecFldSelOccmkGen1RmkGenR mkTyConRepOcc mkMaxTagOcc mkTag2ConOcc mkCon2TagOcc mkEqPredCoOcc mkInstTyCoOcc mkNewTyCoOccmkClassDataConOcc mkRepEqOccmkForeignExportOcc mkSpecOccmkIPOcc mkDictOccmkClassOpAuxOccmkDefaultMethodOcc mkBuilderOcc mkMatcherOcc mkWorkerOccmkDataConWrapperOccisTypeableBindOccisDefaultMethodOccisDerivedOccNamestartsWithUnderscore parenSymOccisSymOcc isDataSymOcc isDataOccisValOccisTcOccisTvOccisVarOccsetOccNameSpace occNameString filterOccSetintersectsOccSetintersectOccSet isEmptyOccSet elemOccSet minusOccSetunionManyOccSets unionOccSetsextendOccSetList extendOccSetmkOccSet unitOccSet emptyOccSet pprOccEnv alterOccEnv filterOccEnvdelListFromOccEnv delFromOccEnv mkOccEnv_C mapOccEnvextendOccEnv_AccextendOccEnv_C plusOccEnv_C plusOccEnv occEnvElts foldOccEnv elemOccEnvmkOccEnv lookupOccEnvextendOccEnvList extendOccEnv unitOccEnv emptyOccEnvnameSpacesRelated demoteOccName mkClsOccFSmkClsOcc mkTcOccFSmkTcOcc mkTyVarOccFS mkTyVarOcc mkDataOccFS mkDataOcc mkVarOccFSmkVarOcc mkOccNameFS mkOccName pprOccNamepprNameSpaceBriefpprNonVarNameSpace pprNameSpaceisValNameSpaceisVarNameSpace isTvNameSpaceisTcClsNameSpaceisDataConNameSpacetvName srcDataNamedataName tcClsNameclsNametcName NameSpace occNameFS occNameSpaceoccName HasOccNameOccEnvOccSet TidyOccEnvDynFlagsgoptdefaultObjectTargetOpt_G_NoOptCoercionOpt_G_NoStateHackOpt_PluginTrustworthyOpt_PackageTrustOpt_DistrustAllPackagesOpt_BuildDynamicTooOpt_KeepOFilesOpt_KeepHiFilesOpt_KeepLlvmFilesOpt_KeepRawTokenStreamOpt_KeepTmpFilesOpt_KeepSFilesOpt_KeepHcFilesOpt_KeepHiDiffsOpt_KeepHscppFilesOpt_ImplicitImportQualifiedOpt_AutoLinkPackagesOpt_SuppressTimestampsOpt_SuppressTicksOpt_SuppressStgExtsOpt_SuppressUniquesOpt_SuppressTypeSignaturesOpt_SuppressUnfoldingsOpt_SuppressIdInfoOpt_SuppressTypeApplicationsOpt_SuppressModulePrefixesOpt_SuppressVarKindsOpt_SuppressCoercionsOpt_HexWordLiteralsOpt_ShowLoadedModulesOpt_ShowMatchesOfHoleFitsOpt_ShowProvOfHoleFitsOpt_ShowTypeOfHoleFitsOpt_ShowDocsOfHoleFitsOpt_ShowTypeAppVarsOfHoleFitsOpt_ShowTypeAppOfHoleFitsOpt_UnclutterValidHoleFitsOpt_AbstractRefHoleFitsOpt_SortBySubsumHoleFitsOpt_SortBySizeHoleFitsOpt_SortValidHoleFitsOpt_ShowValidHoleFitsOpt_ShowHoleConstraintsOpt_PprShowTicksOpt_PprCaseAsLetOpt_DiagnosticsShowCaretOpt_DeferDiagnosticsOpt_ErrorSpans Opt_KeepCAFsOpt_SingleLibFolderOpt_WholeArchiveHsLibsOpt_VersionMacrosOpt_OptimalApplicativeDoOpt_ExternalInterpreter Opt_FlatCacheOpt_HpcOpt_RelativeDynlibPaths Opt_RPathOpt_Ticky_Dyn_Thunk Opt_Ticky_LNEOpt_Ticky_Allocd Opt_TickyOpt_SccProfilingOnOpt_ExternalDynamicRefsOpt_PICExecutableOpt_PIEOpt_PICOpt_DeferOutOfScopeVariablesOpt_DeferTypedHolesOpt_DeferTypeErrorsOpt_HelpfulErrorsOpt_NoItOpt_LocalGhciHistoryOpt_ValidateHieOpt_GhciLeakCheckOpt_GhciHistoryOpt_GhciSandboxOpt_IgnoreDotGhciOpt_BuildingCabalPackageOpt_SharedImplibOpt_EmbedManifestOpt_GenManifestOpt_PrintBindContentsOpt_PrintEvldWithShowOpt_BreakOnErrorOpt_BreakOnExceptionOpt_HaddockOptions Opt_HaddockOpt_PrintBindResultOpt_HideAllPluginPackagesOpt_HideAllPackages Opt_StgStatsOpt_SplitSections Opt_NoHsMainOpt_EagerBlackHolingOpt_ExcessPrecisionOpt_IgnoreHpcChangesOpt_IgnoreOptimChangesOpt_ForceRecompOpt_PpOpt_ProfCountEntriesOpt_AutoSccsOnIndividualCafs Opt_WriteHieOpt_WriteInterfaceOpt_ExposeAllUnfoldingsOpt_OmitInterfacePragmasOpt_IgnoreInterfacePragmasOpt_SimplPreInliningOpt_NumConstantFoldingOpt_CatchBottomsOpt_AlignmentSanitisationOpt_SolveConstantDictsOpt_WorkerWrapper Opt_CprAnalOpt_WeightlessBlocklayoutOpt_CfgBlocklayoutOpt_LoopificationOpt_DmdTxDictSelOpt_DictsStrictOpt_FunToThunkOpt_OmitYieldsOpt_AsmShortcuttingOpt_CmmElimCommonBlocks Opt_CmmSinkOpt_IrrefutableTuplesOpt_LlvmFillUndefWithGarbage Opt_LlvmTBAAOpt_PedanticBottomsOpt_RegsIterative Opt_RegsGraphOpt_EnableRewriteRulesOpt_DictsCheapOpt_UnboxSmallStrictFieldsOpt_UnboxStrictFieldsOpt_CaseFolding Opt_CaseMergeOpt_DoEtaReductionOpt_IgnoreAssertsOpt_DoLambdaEtaExpansionOpt_SpecConstrKeenOpt_SpecConstrOpt_LiberateCaseOpt_StgLiftLams Opt_StgCSEOpt_CSE Opt_StaticArgumentTransformationOpt_CrossModuleSpecialiseOpt_SpecialiseAggressivelyOpt_SpecialiseOpt_LateSpecialise Opt_FloatInOpt_FullLazinessOpt_KillOneShotOpt_KillAbsenceOpt_LateDmdAnalOpt_StrictnessOpt_Exitification Opt_CallArityOpt_PrintTypecheckerElaborationOpt_PrintPotentialInstancesOpt_PrintExpandedSynonymsOpt_PrintUnicodeSyntaxOpt_PrintEqualityRelationsOpt_PrintExplicitRuntimeRepsOpt_PrintExplicitCoercionsOpt_PrintExplicitKindsOpt_PrintExplicitForallsOpt_HideSourcePathsOpt_ShowWarnGroupsOpt_WarnIsError Opt_FastLlvmOpt_NoLlvmManglerOpt_DoAnnotationLintingOpt_DoAsmLintingOpt_DoCmmLintingOpt_DoStgLintingOpt_DoCoreLintingOpt_D_dump_minimal_importsOpt_D_faststring_statsOpt_DumpToFile Sf_IgnoreSf_SafeSf_Trustworthy Sf_UnsafeSf_NoneSafeHaskellMode cfgWeightInfouniqueIncrement initialUnique maxErrors reverseErrorsmaxInlineMemsetInsnsmaxInlineMemcpyInsnsmaxInlineAllocSizertccInfortldInfoavx512pfavx512favx512eravx512cdavx2avx bmiVersion sseVersionnextWrapperNuminteractivePrintprofAuto colScheme canUseColoruseColor ghciScriptshaddockOptionsghcVersionFileflushErrflushOut log_action ghciHistSize maxWorkerArgsufVeryAggressiveufDearOpufKeenessFactorufDictDiscountufFunAppDiscountufUseThresholdufCreationThresholdextensionFlags extensionstrustworthyOnLocwarnUnsafeOnLoc warnSafeOnLoc pkgTrustOnLocincoherentOnLocoverlapInstLoc newDerivOnLocthOnLoc safeInferred safeInfer safeHaskelllanguagefatalWarningFlags warningFlags generalFlags dumpFlagsgeneratedDumpsnextTempSuffix dirsToClean filesToCleanpkgState pkgDatabase packageEnv trustFlagspluginPackageFlags packageFlagsignorePackageFlagspackageDBFlags depSuffixesdepExcludeModsdepIncludePkgDeps depMakefilehooks staticPlugins cachedPluginsfrontendPluginOptspluginModNameOptspluginModNameshpcDirrtsOptsSuggestionsrtsOptsEnabledrtsOptscmdlineFrameworksframeworkPaths libraryPaths includePathsldInputsdumpPrefixForce dumpPrefix dynLibLoaderoutputHi dynOutputFile outputFiledynHiSuf dynObjectSufcanGenerateDynamicToohieSufhiSufhcSuf objectSufdumpDirstubDirhieDirhiDirdylibInstallName objectDir splitInfobuildTagwaysthisUnitIdInsts_thisComponentId_thisInstalledUnitIdsolverIterationsreductionDepth mainFunIs mainModIs importPaths historySizecmmProcAlignment liftLamsKnownliftLamsNonRecArgsliftLamsRecArgs floatLamArgsliberateCaseThresholdbinBlobThresholdspecConstrRecursivespecConstrCountspecConstrThresholdsimplTickFactormaxUncoveredPatternsrefLevelHoleFitsmaxRefHoleFitsmaxValidHoleFitsmaxRelevantBinds ghcHeapSizeenableTimeStats parMakeCountstrictnessBefore inlineCheck ruleCheckmaxPmCheckIterationsmaxSimplIterations simplPhases debugLeveloptLevel verbosity llvmPasses llvmTargetsintegerLibrarysettings hscTargetghcLinkghcMode getDynFlags HscNothingHscInterpretedHscLlvmHscAsmHscC HscTargetMkDependOneShot CompManagerGhcMode LinkStaticLib LinkDynLib LinkInMemory LinkBinaryNoLinkGhcLinkOption FileOption DriverPhasesPhaseModule pprModulemkModule mkModuleNamemoduleNameString ml_hie_file ml_obj_file ml_hi_file ml_hs_file ModLocation FastStringEnvmkFsEnv lookupFsEnv extendFsEnv emptyFsEnv UniqSupply getUniquesM getUniqueMgetUniqueSupplyM MonadUniqueUnique getUnique Uniquable BasicTypes mkIntWithInftreatZeroAsInf intGtLimitinfinityintegralFractionalLitnegateFractionalLitmkFractionalLitnegateIntegralLit mkIntegralLit isEarlyActiveisAlwaysActive isNeverActive competesWith isActiveInisActivepprInlineDebug pprInlinesetInlinePragmaRuleMatchInfosetInlinePragmaActivationinlinePragmaRuleMatchInfoinlinePragmaActivationinlinePragmaSatisAnyInlinePragmaisInlinablePragmaisInlinePragmaisDefaultInlinePragmadfunInlinePragmainlinePragmaSpecneverInlinePragmaalwaysInlinePragmadefaultInlinePragmanoUserInlineSpec isFunLike isConLikeactiveDuringFinalactiveAfterInitialpprWithSourceTextfailed succeeded successIf zapFragileOccisOneOcc isDeadOccisStrongLoopBreakerisWeakLoopBreakerweakLoopBreakerstrongLoopBreakerisAlwaysTailCalledzapOccTailCallInfo tailCallInfo notOneBranch oneBranch notInsideLam insideLam seqOccInfo isManyOccs noOccInfopprAlternative sumParens tupleParensboxityTupleSorttupleSortBoxity maybeParenappPrecopPrecfunPrecsigPrectopPrechasOverlappingFlaghasOverlappableFlaghasIncoherentFlagsetOverlapModeMaybe isGenerated boolToRecFlagisNonRecisRecisBoxed isTopLevel isNotTopLevel compareFixity funTyFixity negateFixity defaultFixity minPrecedence maxPrecedence pprRuleNamepprWarningTxtForMsginitialVersion bumpVersion isPromotedunSwap isSwappedflipSwap bestOneShot worstOneShothasNoOneShotInfo isOneShotInfo noOneShotInfo fIRST_TAGpickLRCRightCLeft LeftOrRightArityRepArity JoinArityConTagConTagZ Alignment OneShotLam NoOneShotInfo OneShotInfo IsSwapped NotSwappedSwapFlag IsPromoted NotPromoted PromotionFlagIsData IsFunctionFunctionOrDatasl_fssl_st StringLiteral DeprecatedTxt WarningTxtRuleNameFixityInfixNInfixRInfixLFixityDirectionInfixPrefix LexicalFixity NotTopLevelTopLevel TopLevelFlagUnboxedBoxedBoxity NonRecursive RecursiveRecFlag Generated FromSourceOrigin isSafeOverlap overlapMode OverlapFlag IncoherentOverlaps Overlapping Overlappable NoOverlap OverlapModePprPrecConstraintTuple UnboxedTuple BoxedTuple TupleSorttoEPfromEPEPocc_rules_only occ_int_cxt occ_one_br occ_in_lamocc_tailIAmALoopBreakerOneOccIAmDeadManyOccsOccInfoInterestingCxt InsideLam OneBranchNoTailCallInfoAlwaysTailCalled TailCallInfo GenericDM VanillaDM DefMethSpecFailed Succeeded SuccessFlag NoSourceText SourceTextPhaseNum InitialPhase CompilerPhase ActiveAfter ActiveBefore AlwaysActive NeverActive ActivationFunLike RuleMatchInfoinl_ruleinl_actinl_sat inl_inlineinl_src InlinePragma NoUserInlineNoInline InlinableInline InlineSpecil_valueil_negil_textIL IntegralLitfl_valuefl_negfl_textFL FractionalLit IntWithInfImplicitSpliceExplicitSpliceSpliceExplicitFlagSevError SevWarningSevInfoSevDumpSevInteractiveSevFatal SevOutputSeveritySrcLoc unRealSrcSpangetRealSrcSpancLdL isSubspanOfspansleftmost_largestleftmost_smallest rightmost cmpLocated eqLocatedaddCLoc combineLocsmkGeneralLocatednoLocgetLocunLoc srcSpanEnd srcSpanStart srcSpanEndColsrcSpanStartColsrcSpanEndLinesrcSpanStartLine isGoodSrcSpan mkSrcSpan srcLocSpan noSrcSpan srcLocCol srcLocLine srcLocFilenoSrcLocmkSrcLoc RealSrcLoc UnhelpfulLoc srcSpanFile RealSrcSpan UnhelpfulSpanSrcSpanL GenLocatedLocated SrcSpanLessdecomposeSrcSpancomposeSrcSpan HasSrcSpan Outputable alwaysQualifyPrintUnqualified moduleName moduleUnitId ModuleNameUnitId isFunTyConSysTools.BaseDir expandTopDirSizedSeqsizeSSssElts pprUserLengthpprCols useUnicode GeneralFlagPanicwithSignalHandlersshowGhcExceptionPprProgramError ProgramErrorInstallationErrorPprSorrySorryPprPanic CmdLineError UsageErrorSignal GhcException MonadUtilsfoldrMfoldlM GHCi.MessageSeq GetClosureRunModFinalizersRunTHStartTHGetBreakpointVarBreakpointStatusEnableBreakpoint NewBreakArrayCostCentreStackInfo MkCostCentresEvalIOEvalStringToString EvalString AbandonStmt ResumeStmtEvalStmtMkConInfoTableFreeFFIPrepFFI MallocStrings MallocData AddSptEntryFreeHValueRefs CreateBCOsFindSystemLibrary ResolveObjsRemoveLibrarySearchPathAddLibrarySearchPath UnloadObjLoadObj LoadArchiveLoadDLL LookupClosure LookupSymbol InitLinker RtsRevertCAFsShutdownMessageEvalAppEvalThisEvalExpr EvalStatus EvalBreak EvalComplete EvalStatus_ EvalSuccess EvalException EvalResultLanguage.Haskell.TH.Syntax dataToPatQ dataToExpQdataToQa ExceptiongfinallygbracketgcatchGHCi.RemoteTypesHValue ForeignHValueArchive ArchiveEntryfilenamefiletimefileownfilegrpfilemodefilesizefiledataafilter isBSDSymdef isGNUSymdefparseAr writeBSDAr writeGNUArloadArloadObj$fEqArchiveEntry$fShowArchiveEntry $fEqArchive $fShowArchive$fSemigroupArchive$fMonoidArchive sectionType cseProgram cseOneExpr AtomicMachOpAMO_AddAMO_SubAMO_AndAMO_NandAMO_OrAMO_Xor CallishMachOp MO_F64_Pwr MO_F64_Sin MO_F64_Cos MO_F64_Tan MO_F64_Sinh MO_F64_Cosh MO_F64_Tanh MO_F64_Asin MO_F64_Acos MO_F64_Atan MO_F64_Asinh MO_F64_Acosh MO_F64_Atanh MO_F64_Log MO_F64_Exp MO_F64_Fabs MO_F64_Sqrt MO_F32_Pwr MO_F32_Sin MO_F32_Cos MO_F32_Tan MO_F32_Sinh MO_F32_Cosh MO_F32_Tanh MO_F32_Asin MO_F32_Acos MO_F32_Atan MO_F32_Asinh MO_F32_Acosh MO_F32_Atanh MO_F32_Log MO_F32_Exp MO_F32_Fabs MO_F32_Sqrt MO_UF_Conv MO_S_QuotRem MO_U_QuotRem MO_U_QuotRem2MO_Add2 MO_AddWordC MO_SubWordC MO_AddIntC MO_SubIntC MO_U_Mul2MO_WriteBarrierMO_TouchMO_Prefetch_Data MO_Memcpy MO_Memset MO_Memmove MO_Memcmp MO_PopCntMO_PdepMO_PextMO_ClzMO_CtzMO_BSwapMO_BRev MO_AtomicRMW MO_AtomicReadMO_AtomicWrite MO_CmpxchgMachOpMO_AddMO_SubMO_EqMO_NeMO_MulMO_S_MulMayOflo MO_S_QuotMO_S_RemMO_S_NegMO_U_MulMayOflo MO_U_QuotMO_U_RemMO_S_GeMO_S_LeMO_S_GtMO_S_LtMO_U_GeMO_U_LeMO_U_GtMO_U_LtMO_F_AddMO_F_SubMO_F_NegMO_F_Mul MO_F_QuotMO_F_EqMO_F_NeMO_F_GeMO_F_LeMO_F_GtMO_F_LtMO_AndMO_OrMO_XorMO_NotMO_ShlMO_U_ShrMO_S_Shr MO_SF_Conv MO_FS_Conv MO_SS_Conv MO_UU_Conv MO_XX_Conv MO_FF_Conv MO_V_Insert MO_V_ExtractMO_V_AddMO_V_SubMO_V_Mul MO_VS_Quot MO_VS_Rem MO_VS_Neg MO_VU_Quot MO_VU_Rem MO_VF_Insert MO_VF_Extract MO_VF_Add MO_VF_Sub MO_VF_Neg MO_VF_Mul MO_VF_QuotMO_AlignmentCheck pprMachOp mo_wordAdd mo_wordSub mo_wordEq mo_wordNe mo_wordMul mo_wordSQuot mo_wordSRem mo_wordSNeg mo_wordUQuot mo_wordURem mo_wordSGe mo_wordSLe mo_wordSGt mo_wordSLt mo_wordUGe mo_wordULe mo_wordUGt mo_wordULt mo_wordAnd mo_wordOr mo_wordXor mo_wordNot mo_wordShl mo_wordSShr mo_wordUShr mo_u_8To32 mo_s_8To32 mo_u_16To32 mo_s_16To32 mo_u_8ToWord mo_s_8ToWord mo_u_16ToWord mo_s_16ToWord mo_s_32ToWord mo_u_32ToWord mo_WordTo8 mo_WordTo16 mo_WordTo32 mo_WordTo64mo_32To8 mo_32To16isCommutableMachOpisAssociativeMachOpisComparisonMachOpmaybeIntComparisonisFloatComparisonmaybeInvertComparisonmachOpResultType machOpArgRepspprCallishMachOpcallishMachOpHintsmachOpMemcpyishAlign $fEqMachOp $fShowMachOp$fEqAtomicMachOp$fShowAtomicMachOp$fEqCallishMachOp$fShowCallishMachOp popCntLabel pdepLabel pextLabel bSwapLabel bRevLabelclzLabelctzLabelword2FloatLabelatomicRMWLabel cmpxchgLabelatomicReadLabelatomicWriteLabelPDunPDliftP$fHasDynFlagsPD $fMonadFailPD $fMonadPD$fApplicativePD $fFunctorPDconvertToHsDeclsconvertToHsExpr convertToPatconvertToHsTypethRdrNameGuesses $fMonadCvtM$fApplicativeCvtM $fFunctorCvtMendPass endPassIO dumpIfSetdumpPassResultlintPassResultlintInteractiveExprlintCoreBindings lintUnfoldinglintExpr lintTypes lintAnnots$fHasDynFlagsLintM$fMonadFailLintM $fMonadLintM$fApplicativeLintM$fFunctorLintM$fEqStaticPtrCheckreadElfSectionByNamereadElfNoteAsString makeElfNote extractDocsflushFinderCachesfindImportedModulefindPluginModulefindExactModulefindExposedPackageModuleaddHomeModuleToFinder uncacheModulefindHomeModulemkHomeModLocationmkHomeModLocation2mkHiOnlyModLocation mkObjPathmkHiPath mkStubPathsfindObjectLinkableMaybefindObjectLinkablecannotFindModulecannotFindInterfacemkDependencies mkUsedNames mkUsageInfo floatInwardsconfigureHandleEncodingputArraygetArraymkConInfoTable $fShowArchShouldRetainCAFs RetainCAFsDontRetainCAFs initObjLinker lookupSymbol lookupClosureloadDLL loadArchive unloadObjpurgeObjaddLibrarySearchPathremoveLibrarySearchPathfindSystemLibrary resolveObjsResolvedBCOPtrResolvedBCORefResolvedBCOStaticPtrResolvedBCOPtrBCOResolvedBCOPtrBreakArray ResolvedBCOresolvedBCOIsLEresolvedBCOArityresolvedBCOInstrsresolvedBCOBitmapresolvedBCOLitsresolvedBCOPtrsisLittleEndian$fBinaryResolvedBCOPtr$fBinaryResolvedBCO$fGenericResolvedBCOPtr$fShowResolvedBCOPtr$fGenericResolvedBCO$fShowResolvedBCO createBCOsinstallSignalHandlers sptAddEntryGHCiQExceptionstartTHrunModFinalizerRefsrunTH$fMonadIOGHCiQ $fMonadGHCiQ$fApplicativeGHCiQ$fFunctorGHCiQ $fQuasiGHCiQ$fMonadFailGHCiQ$fExceptionGHCiQException$fShowGHCiQExceptionrunredirectInterruptsiservCmd withIServevalStmt abandonStmtevalIO evalStringevalStringToIOString mallocData mkCostCentres addSptEntrycostCentreStackInfo newBreakArrayenableBreakpointbreakpointStatusgetBreakpointVar getClosure seqHValuepurgeLookupSymbolCache iservCall readIServ writeIServ stopIServmkFinalizedHValuefreeHValueRefswormhole wormholeRef mkEvalOptsfromEvalResult ClosureEnvemptyClosureEnvextendClosureEnvlinkBCOlookupStaticPtrlookupIElinkFail nameToCLabelNodenodeId nodeClass nodeColor nodeConflictsnodeExclusionsnodePreference nodeCoalesceGraphgraphMapTriv initGraphgraphMapModifynewNode lookupNodegetNodeaddNodedelNodemodNodesizeunion addConflict delConflict addConflicts addExclusion addExclusions addCoalesce delCoalesce addPreference coalesceGraph coalesceNodes freezeNodefreezeOneInGraphfreezeAllInGraph scanGraph validateGraphslurpNodeConflictCountsetColor dumpGraphdotGraph colorGraph getImports mkPrelImportsgetOptionsFromFile getOptionscheckProcessArgsResultoptionsErrorMsgs TyVarScopeResolvedScopesUnresolvedScopeScopeNoScope LocalScope ModuleScopeDeclTypeFamDecSynDecDataDecConDec PatSynDecClassDecInstDecBindType RegularBind InstanceBindRecFieldContext RecFieldDeclRecFieldAssign RecFieldMatch RecFieldOccIETypeImportImportAs ImportHidingExport ContextInfoUse MatchBindIEThingTyDeclValBind PatternBind ClassTyDeclDecl TyVarBindRecFieldIdentifierDetails identType identInfoNodeIdentifiers IdentifierNodeInfonodeAnnotationsnodeTypenodeIdentifiersHieASTnodeInfonodeSpan nodeChildrenHieASTsgetAstsHieArgs HieTypeFixRoll HieTypeFlatHieTypeHTyVarTyHAppTy HTyConApp HForAllTyHFunTyHQualTyHLitTyHCastTy HCoercionTy TypeIndexHieFile hie_versionhie_ghc_version hie_hs_file hie_module hie_typeshie_asts hie_exports hie_hs_srcSpan curHieVersion$fBinaryHieArgs$fBinaryHieType$fBinaryIEType$fBinaryRecFieldContext$fBinaryBindType$fBinaryDeclType $fBinaryScope$fOutputableScope$fBinaryTyVarScope$fShowTyVarScope$fBinaryContextInfo$fOutputableContextInfo$fBinaryIdentifierDetails$fMonoidIdentifierDetails$fSemigroupIdentifierDetails$fOutputableIdentifierDetails$fBinaryNodeInfo$fBinaryHieAST$fBinaryHieASTs$fBinaryHieFile$fFunctorHieArgs$fFoldableHieArgs$fTraversableHieArgs $fEqHieArgs$fFunctorHieType$fFoldableHieType$fTraversableHieType $fEqHieType $fEqIEType $fEnumIEType $fOrdIEType $fShowIEType$fEqRecFieldContext$fEnumRecFieldContext$fOrdRecFieldContext$fShowRecFieldContext $fEqBindType $fOrdBindType$fShowBindType$fEnumBindType $fEqDeclType $fOrdDeclType$fShowDeclType$fEnumDeclType $fEqScope $fOrdScope $fShowScope $fDataScope$fEqTyVarScope$fOrdTyVarScope$fEqContextInfo$fOrdContextInfo$fShowContextInfo$fEqIdentifierDetails$fFunctorIdentifierDetails$fFoldableIdentifierDetails$fTraversableIdentifierDetails$fFunctorNodeInfo$fFoldableNodeInfo$fTraversableNodeInfo$fFunctorHieAST$fFoldableHieAST$fTraversableHieAST$fFunctorHieASTs$fFoldableHieASTs$fTraversableHieASTs HieTypeStateHTStyMaphtyTable freshIndexgenerateReferencesMap renderHieTyperesolveVisibilityfoldTypehieTypeToIface initialHTSfreshTypeIndex compressTypesrecoverFullType getTypeIndexresolveTyVarScopesresolveTyVarScopeLocalgetNameBinding getNameScopegetNameBindingInClassgetNameScopeAndBindinggetScopeFromContextgetBindSiteFromContext flattenAstsmallestContainingSatisfyingselectLargestContainedByselectSmallestContaining definedInAsts isOccurrencescopeContainsSpan combineAst insertAstcombineNodeInfo mergeAstsrightOfleftOf startsRightOf mergeSortAstssimpleNodeInfolocOnlymkScopemkLScope combineScopesmakeNode makeTypeNodeBlockBlockCOBlockCCBlockOCBNilBMiddleBCatBSnocBConsMaybeOJustONothingO IndexedCOCO isEmptyBlock emptyBlock blockCons blockSnoc blockJoinHead blockJoinTail blockJoin blockAppend firstNodelastNodeblockSplitHeadblockSplitTail blockSplit blockToList blockFromListreplaceFirstNodereplaceLastNodemapBlock mapBlock' mapBlock3'foldBlockNodesFfoldBlockNodesB3foldBlockNodesB$fFunctorMaybeO$fFunctorMaybeC UniqueMap UniqueSetIsMapKeyOfmapNullmapSize mapMember mapLookupmapFindWithDefaultmapEmpty mapSingleton mapInsert mapInsertWith mapDeletemapAlter mapAdjustmapUnionmapUnionWithKey mapDifferencemapIntersection mapIsSubmapOfmapMap mapMapWithKeymapFoldlmapFoldrmapFoldlWithKeymapFoldMapWithKey mapFiltermapFilterWithKeymapElemsmapKeys mapToList mapFromListmapFromListWithIsSetElemOfsetNullsetSize setMembersetEmpty setSingleton setInsert setDeletesetUnion setDifferencesetIntersection setIsSubsetOf setFiltersetFoldlsetFoldrsetElems setFromList setInsertList setDeleteList setUnions mapInsertList mapDeleteList mapUnions$fIsSetUniqueSet$fIsMapUniqueMap $fEqUniqueSet$fOrdUniqueSet$fShowUniqueSet$fSemigroupUniqueSet$fMonoidUniqueSet $fEqUniqueMap$fOrdUniqueMap$fShowUniqueMap$fFunctorUniqueMap$fFoldableUniqueMap$fTraversableUniqueMapFactBaseLabelMapLabelSetLabel mkHooplLabel lookupFact$fOutputableLabel$fUniquableLabel $fShowLabel$fOutputableLabelSet$fIsSetLabelSet$fTrieMapLabelMap$fOutputableLabelMap$fIsMapLabelMap $fEqLabel $fOrdLabel $fEqLabelSet $fOrdLabelSet$fShowLabelSet$fMonoidLabelSet$fSemigroupLabelSet $fEqLabelMap $fOrdLabelMap$fShowLabelMap$fFunctorLabelMap$fFoldableLabelMap$fTraversableLabelMapGraph'GNilGUnitGManyNonLocal entryLabel successorsBody emptyBodybodyListaddBlockmapGraphmapGraphBlocks labelsDefinedrevPostorderFrom$fNonLocalBlock SwitchPlanUnconditionallyIfEqualIfLT JumpTable SwitchTargetsmkSwitchTargetsmapSwitchTargetsswitchTargetsCasesswitchTargetsDefaultswitchTargetsRangeswitchTargetsSignedswitchTargetsToTableswitchTargetsToListswitchTargetsFallThrougheqSwitchTargetWithtargetSupportsSwitchcreateSwitchPlan$fShowSwitchTargets$fEqSwitchTargets$fShowSwitchPlan mkBlockIdDynamicLinkerLabelInfoCodeStub SymbolPtr GotSymbolPtrGotSymbolOffsetForeignLabelSourceForeignLabelInPackageForeignLabelInExternalPackageForeignLabelInThisPackagepprDebugCLabel mkSRTLabelmkRednCountsLabelmkLocalClosureLabelmkLocalInfoTableLabelmkLocalClosureTableLabelmkClosureLabelmkInfoTableLabel mkEntryLabelmkClosureTableLabelmkConInfoTableLabel mkBytesLabelmkBlockInfoTableLabelmkDirty_MUT_VAR_LabelmkUpdInfoLabelmkBHUpdInfoLabelmkIndStaticInfoLabelmkMainCapabilityLabelmkMAP_FROZEN_CLEAN_infoLabelmkMAP_FROZEN_DIRTY_infoLabelmkMAP_DIRTY_infoLabelmkTopTickyCtrLabelmkCAFBlackHoleInfoTableLabelmkArrWords_infoLabelmkSMAP_FROZEN_CLEAN_infoLabelmkSMAP_FROZEN_DIRTY_infoLabelmkSMAP_DIRTY_infoLabelmkBadAlignmentLabelmkSRTInfoLabelmkCmmInfoLabelmkCmmEntryLabelmkCmmRetInfoLabel mkCmmRetLabelmkCmmCodeLabelmkCmmDataLabelmkCmmClosureLabelmkLocalBlockLabelmkRtsPrimOpLabelmkSelectorInfoLabelmkSelectorEntryLabelmkApInfoTableLabelmkApEntryLabelmkPrimCallLabelmkForeignLabel addLabelSize isBytesLabelisForeignLabelisStaticClosureLabelisSomeRODataLabelisInfoTableLabelisConInfoTableLabelforeignLabelStdcallInfo mkBitmapLabel mkCCLabel mkCCSLabelmkRtsApFastLabelmkRtsSlowFastTickyCtrLabelmkHpcTicksLabelmkDynamicLinkerLabeldynamicLinkerLabelInfomkPicBaseLabelmkDeadStripPreventermkStringLitLabelmkAsmTempLabelmkAsmTempDerivedLabelmkAsmTempEndLabelmkAsmTempDieLabel toClosureLbltoSlowEntryLbl toEntryLbl toInfoLblhasHaskellNamehasCAF needsCDeclmaybeLocalBlockLabel isMathFunexternallyVisibleCLabelisCFunctionLabel isGcPtrLabel isLocalCLabel labelDynamic pprCLabel$fOutputableForeignLabelSource$fOutputableCLabel $fOrdCLabel$fEqForeignLabelSource$fOrdForeignLabelSource$fEqIdLabelInfo$fOrdIdLabelInfo$fShowIdLabelInfo$fEqRtsLabelInfo$fOrdRtsLabelInfo$fEqCmmLabelInfo$fOrdCmmLabelInfo$fEqDynamicLinkerLabelInfo$fOrdDynamicLinkerLabelInfo $fEqCLabeladdTicksToBinds hpcInitCode$fHasDynFlagsTM $fMonadTM$fApplicativeTM $fFunctorTM$fEqTickDensity$fEqTickishType newBlockIdblockLbl infoTblLbl GlobalReg VanillaRegFloatReg DoubleRegLongRegXmmRegYmmRegZmmRegSpSpLimHpHpLimCCCS CurrentTSOCurrentNurseryHpAllocEagerBlackholeInfoGCEnter1GCFunBaseRegMachSpUnwindReturnReg PicBaseRegVGcPtr VNonGcPtr DefinerOfRegs foldRegsDefd UserOfRegs foldRegsUsed GlobalRegSet LocalRegSetRegSetLocalRegCmmLitCmmIntCmmFloatCmmVecCmmLabel CmmLabelOffCmmLabelDiffOffCmmBlockCmmHighStackMarkAreaOldYoungCmmRegCmmLocal CmmGlobalCmmLoad CmmStackSlot CmmRegOff cmmExprType cmmLitType cmmExprWidthmaybeInvertCmmExpr cmmRegType cmmRegWidth localRegType emptyRegSet nullRegSet elemRegSet extendRegSetdeleteFromRegSetmkRegSet minusRegSet plusRegSet timesRegSet sizeRegSet regSetToListfoldLocalRegsUsedfoldLocalRegsDefdbaseRegspReghpReghpLimRegspLimRegnodeReg currentTSORegcurrentNurseryReg hpAllocRegcccsRegnode globalRegTypeisArgReg$fUniquableLocalReg $fOrdLocalReg $fEqLocalReg$fUserOfRegsr[]$fUserOfRegsrr$fDefinerOfRegsr[]$fDefinerOfRegsrr$fOrdGlobalReg $fEqGlobalReg$fDefinerOfRegsGlobalRegCmmReg$fUserOfRegsGlobalRegCmmReg$fDefinerOfRegsLocalRegCmmReg$fUserOfRegsLocalRegCmmReg$fUserOfRegsrCmmExpr $fEqCmmExpr$fEqArea $fOrdArea $fEqCmmLit $fEqVGcPtr $fShowVGcPtr$fShowGlobalReg $fEqCmmReg $fOrdCmmRegCmmToken CmmT_SpecChar CmmT_DotDotCmmT_DoubleColonCmmT_ShrCmmT_ShlCmmT_GeCmmT_LeCmmT_EqCmmT_Ne CmmT_BoolAnd CmmT_BoolOr CmmT_CLOSURECmmT_INFO_TABLECmmT_INFO_TABLE_RETCmmT_INFO_TABLE_FUNCmmT_INFO_TABLE_CONSTRCmmT_INFO_TABLE_SELECTOR CmmT_else CmmT_export CmmT_section CmmT_gotoCmmT_if CmmT_call CmmT_jump CmmT_foreign CmmT_never CmmT_prim CmmT_reserve CmmT_return CmmT_returns CmmT_import CmmT_switch CmmT_case CmmT_default CmmT_push CmmT_unwind CmmT_bits8 CmmT_bits16 CmmT_bits32 CmmT_bits64 CmmT_bits128 CmmT_bits256 CmmT_bits512 CmmT_float32 CmmT_float64 CmmT_gcptrCmmT_GlobalReg CmmT_Name CmmT_StringCmmT_Int CmmT_FloatCmmT_EOF CmmT_False CmmT_True CmmT_likelycmmlex$fShowCmmToken BlankSrcSpanNoBlankSrcSpan showAstData$fEqBlankSrcSpan$fShowBlankSrcSpan ppSourceStats QuasiQuoterquoteExpquotePat quoteTypequoteDec quoteFile liberateCaseunListTselectfoldrunListT$fMonadPlusListT$fMonadFailListT $fMonadListT$fAlternativeListT$fApplicativeListT$fFunctorListT llvmFixupAsmCondALWAYSEQQGEGEUGTTGULELEULTTLUNE condNegate condUnsigned condToSignedcondToUnsigned$fEqCondversion getBinDir getLibDir getDynLibDir getDataDir getLibexecDir getSysconfDirgetDataFileNamepprExprpprLit$fOutputableGlobalReg$fOutputableArea$fOutputableLocalReg$fOutputableCmmLit$fOutputableCmmReg$fOutputableCmmExprprofilingInitCodeRegSubSubL16SubL8SubL8HClassG32ClassG16ClassG8ClassF64worstboundsqueese$fUniquableReg$fShowRegClass $fEqRegClass$fEnumRegClass $fShowRegSub $fEnumRegSub $fOrdRegSub $fEqRegSub $fShowReg$fEqReg classOfReg regsOfClassregNameregAliasStackMapstackMapNextFreeSlotstackMapAssignment StackSlot emptyStackMapgetStackSlotFor getStackUse RcIntegerRcFloatRcDouble RcDoubleSSE$fOutputableRegClass$fUniquableRegClass RegVirtualRegRealRealReg RealRegSingle RealRegPair VirtualReg VirtualRegI VirtualRegHi VirtualRegF VirtualRegD VirtualRegSSERegNorenameVirtualRegclassOfVirtualReggetHiVirtualRegFromLogetHiVRegFromLoregNosOfRealReg realRegsAlias regSingleregPair isRealReg takeRealReg isVirtualRegtakeVirtualRegliftPatchFnToRegReg$fOutputableVirtualReg$fUniquableVirtualReg$fOrdVirtualReg$fOutputableRealReg$fUniquableRealReg$fOutputableReg$fEqVirtualReg$fShowVirtualReg $fEqRealReg $fShowRealReg $fOrdRealReg$fOrdReg trivColorable callerSaves activeStgRegs haveRegBaseglobalRegMaybefreeReg freeRegBasernStmtsrnLExpr rnMbLHsDocrnLHsDocrnHsDoc doStaticArgsArgDescrArgSpecArgGenLivenessConstrDescriptionClosureTypeInfoConstrFunThunk ThunkSelector BlackHole IndStaticIsStaticHeapRep ArrayPtrsRepSmallArrayPtrsRep ArrayWordsRepStackRepRTSRep StgHalfWordStgWordByteOffWordOffroundUpToWords roundUpTo wordsToBytesbytesToWordsRoundUp fromStgWord toStgWordfromStgHalfWord toStgHalfWordhALF_WORD_SIZEhALF_WORD_SIZE_IN_BITS mkHeapRepmkRTSRep mkStackRep blackHoleRep indStaticRep arrPtrsRepsmallArrPtrsRep arrWordsRep isStaticRep isStackRepisConRep isThunkRepisFunRepisStaticNoCafCon fixedHdrSize fixedHdrSizeW profHdrSizearrWordsHdrSizearrWordsHdrSizeWarrPtrsHdrSizearrPtrsHdrSizeWsmallArrPtrsHdrSizesmallArrPtrsHdrSizeW thunkHdrSizehdrSizehdrSizeW nonHdrSize nonHdrSizeWheapClosureSizeWcard cardRoundUpcardTableSizeBcardTableSizeWrtsClosureType rET_SMALLrET_BIGaRG_GEN aRG_GEN_BIG$fOutputableStgWord$fOutputableStgHalfWord$fOutputableArgDescr$fOutputableClosureTypeInfo$fOutputableSMRep $fEqStgWord $fBitsStgWord$fEqStgHalfWord CmmTickScope GlobalScopeSubScope CombinedScope CmmTickish ForeignTarget PrimTarget CmmReturnInfo CmmMayReturnCmmNeverReturnsForeignConvention ConventionNativeDirectCallNativeNodeCall NativeReturnSlowGCUpdFrameOffset CmmFormal CmmActualCmmEntry CmmCommentCmmTick CmmUnwind CmmAssignCmmStoreCmmUnsafeForeignCall CmmBranch CmmCondBranchCmmCallCmmForeignCallcml_predcml_true cml_false cml_likely cml_targetcml_cont cml_args_regscml_args cml_ret_args cml_ret_offtgtresargssuccret_argsret_offintrblforeignTargetHints wrapRecExpmapExp mapExpDeep wrapRecExpMmapExpM mapExpDeepM wrapRecExpffoldExp foldExpDeep mapSuccessorsmapCollectSuccessorsisTickSubScopecombineTickScopes$fUserOfRegsrForeignTarget$fOutputableCmmTickScope$fOrdCmmTickScope$fEqCmmTickScope$fDefinerOfRegsGlobalRegCmmNode$fDefinerOfRegsLocalRegCmmNode$fUserOfRegsGlobalRegCmmNode$fUserOfRegsLocalRegCmmNode$fNonLocalCmmNode$fEqConvention$fEqCmmReturnInfo$fEqForeignConvention$fEqForeignTarget $fEqCmmNode ListGraph GenBasicBlock BasicBlock CmmStaticsStatics CmmStatic CmmStaticLitCmmUninitialised CmmStringSection SectionTypeTextData ReadOnlyDataRelocatableReadOnlyDataUninitialisedDataReadOnlyData16CString OtherSection ProfilingInfoNoProfilingInfo CmmInfoTablecit_lblcit_repcit_profcit_srtcit_clo CmmStackInfo StackInfo arg_space updfr_space do_layout CmmTopInfoTopInfo info_tbls stack_info GenCmmGraphCmmGraphg_entryg_graph RawCmmDeclCmmDecl GenCmmDeclCmmProcCmmData RawCmmGroupCmmGroup GenCmmGroup CmmProgram topInfoTable isSecConstantblockId pprBBlock$fOutputableGenBasicBlock$fOutputableListGraph$fShowSectionTypepprCmms writeCmms pprCmmGroup pprStatic pprSection$fOutputableForeignHint$fOutputableCmmInfoTable$fOutputableCmmStatic$fOutputableCmmStatics$fOutputableGenCmmDeclcastFloatToWord8ArraycastDoubleToWord8Array floatToBytes doubleToBytespprASCIIpprBytespprSectionHeader LlvmCastOpLM_TruncLM_ZextLM_Sext LM_FptruncLM_Fpext LM_Fptoui LM_Fptosi LM_Uitofp LM_Sitofp LM_Ptrtoint LM_Inttoptr LM_Bitcast LlvmCmpOp LM_CMP_Eq LM_CMP_Ne LM_CMP_Ugt LM_CMP_Uge LM_CMP_Ult LM_CMP_Ule LM_CMP_Sgt LM_CMP_Sge LM_CMP_Slt LM_CMP_Sle LM_CMP_Feq LM_CMP_Fne LM_CMP_Fgt LM_CMP_Fge LM_CMP_Flt LM_CMP_Fle LlvmMachOp LM_MO_Add LM_MO_Sub LM_MO_Mul LM_MO_UDiv LM_MO_SDiv LM_MO_URem LM_MO_SRem LM_MO_FAdd LM_MO_FSub LM_MO_FMul LM_MO_FDiv LM_MO_FRem LM_MO_Shl LM_MO_LShr LM_MO_AShr LM_MO_AndLM_MO_Or LM_MO_XorLlvmLinkageTypeInternalLinkOnceWeak Appending ExternWeakExternallyVisibleExternalPrivateLlvmParameterListType FixedArgsVarArgsLlvmCallConventionCC_Ccc CC_Fastcc CC_ColdccCC_GhcCC_Ncc CC_X86_Stdcc LlvmCallTypeStdCallTailCall LlvmFuncAttr AlwaysInline InlineHintOptSizeNoReturnNoUnwindReadNoneReadOnlySspSspReq NoRedZoneNoImplicitFloatNaked LlvmParamAttrZeroExtSignExtInRegByValSRetNoAlias NoCaptureNest LlvmParameterLlvmFunctionDeclsLlvmFunctionDecldecName funcLinkagefuncCc decReturnType decVarargs decParams funcAlign LlvmStatic LMComment LMStaticLit LMUninitType LMStaticStr LMStaticArray LMStaticStrucLMStaticPointerLMTruncLMBitcLMPtoILMAddLMSubLlvmLitLMIntLit LMFloatLit LMNullLit LMVectorLit LMUndefLitLlvmVar LMGlobalVar LMLocalVar LMNLocalVarLMLitVarLMConstGlobalConstantAliasLMAlign LMSectionLlvmTypeLMIntLMFloatLMDouble LMFloat80 LMFloat128 LMPointerLMArrayLMVectorLMLabelLMVoidLMStruct LMStructULMAlias LMMetadata LMFunction LlvmAliasLMStringLMGlobal getGlobalVargetGlobalValueppParamspprSpecialStaticpprStaticArithppName ppPlainNameppLit garbageLit getVarType getLitType getStatTypegetLinkpLiftpVarLiftpLower pVarLowerisIntisFloat isPointerisVectorisGloballlvmWidthInBitsi128i64i32i16i8i1i8PtrllvmWord llvmWordPtrppDoublenarrowFpwidenFpppFloat fixEndian ppCommaJoin ppSpaceJoin$fOutputableLlvmParamAttr$fOutputableLlvmFuncAttr$fOutputableLlvmCallConvention$fOutputableLlvmLinkageType$fOutputableLlvmFunctionDecl$fOutputableLlvmType$fOutputableLlvmLit$fOutputableLlvmVar$fOutputableLlvmStatic$fOutputableLlvmMachOp$fOutputableLlvmCmpOp$fOutputableLlvmCastOp $fEqLMConst$fEqLlvmParamAttr$fEqLlvmFuncAttr$fEqLlvmCallType$fShowLlvmCallType$fEqLlvmCallConvention$fEqLlvmParameterListType$fShowLlvmParameterListType$fEqLlvmLinkageType$fEqLlvmFunctionDecl $fEqLlvmType $fEqLlvmLit $fEqLlvmVar$fEqLlvmMachOp $fEqLlvmCmpOp$fEqLlvmCastOpMetaDecl MetaNamed MetaUnnamed MetaAnnotMetaExprMetaStrMetaNodeMetaVar MetaStructMetaId$fOutputableMetaId$fOutputableMetaExpr $fEqMetaId $fOrdMetaId $fEnumMetaId $fEqMetaExpr $fEqMetaAnnotLlvmExpressionAllocaLlvmOpCompareExtractExtractVInsertMallocLoadALoad GetElemPtrCast AtomicRMWCmpXChgCallCallMPhiAsmMExpr LlvmStatement AssignmentFenceBranchBranchIfCommentMkLabelStoreSwitchReturn UnreachableExprNopMetaStmt LlvmAtomicOpLAO_XchgLAO_AddLAO_SubLAO_AndLAO_NandLAO_OrLAO_XorLAO_MaxLAO_MinLAO_UmaxLAO_UminLlvmSyncOrdering SyncUnord SyncMonotonic SyncAcquire SyncRelease SyncAcqRel SyncSeqCstSingleThreaded LlvmFunctions LlvmFunctionfuncDeclfuncArgs funcAttrsfuncSect funcPrefixfuncBody LlvmModule modComments modAliasesmodMeta modGlobals modFwdDeclsmodFuncs LlvmBlocks LlvmBlock blockLabel blockStmts LlvmBlockId$fShowLlvmSyncOrdering$fEqLlvmSyncOrdering$fShowLlvmAtomicOp$fEqLlvmAtomicOp$fEqLlvmExpression$fEqLlvmStatement ppLlvmModuleppLlvmComments ppLlvmComment ppLlvmGlobals ppLlvmGlobal ppLlvmAliases ppLlvmAlias ppLlvmMetas ppLlvmMetappLlvmFunctionsppLlvmFunctionppLlvmFunctionDeclsppLlvmFunctionDecllmGlobalRegVarlmGlobalRegArg alwaysLivestgTBAAtopNstackNheapNrxNbaseNtbaagetTBAAregUsageOfInstrpatchRegsOfInstrisJumpishInstrjumpDestsOfInstrpatchJumpInstr mkSpillInstr mkLoadInstrtakeDeltaInstr isMetaInstrmkRegRegMoveInstrtakeRegRegMoveInstr mkJumpInstrmkStackAllocInstrmkStackDeallocInstr NatBasicBlock NatCmmDeclNatCmmRegUsageRUnoUsage entryBlocks RewriteFun TransferFunDataflowLatticefact_bot fact_join JoinedFactChanged NotChangedNewFactOldFactFact changedIf analyzeCmmBwd analyzeCmmFwd rewriteCmmBwdgetFact joinOutFacts joinFacts mkFactBasefoldNodesBwdOOfoldRewriteNodesBwdOOII8II16II32II64FF32FF64FF80 intFormat floatFormat isFloatFormat cmmTypeFormat formatToWidth formatInBytes $fShowFormat $fEqFormatAddrMode AddrRegReg AddrRegImmImmImmInt ImmIntegerImmCLblImmLitImmIndexImmFloat ImmDoubleImmConstantSumImmConstantDiffLOHIHAHIGHERAHIGHESTAvirtualRegSqueezerealRegSqueeze mkVirtualReg regDotColor strImmLitlitToImm addrOffsetspRelargRegs allArgRegscallClobberedRegs allMachRegNosclassOfRealRegshowReg allFPArgRegs fits16Bits makeImmediatefRegr0sptocr3r4r11r12r30f1allocatableRegstmpRegFreeRegs noFreeRegs releaseReg initFreeRegs getFreeRegs allocateReg$fShowFreeRegsprimRepCmmType slotCmmType typeCmmTypeprimRepForeignHintslotForeignHinttypeForeignHint mkIntCLit mkIntExprzeroCLitzeroExpr mkWordCLitmkByteStringCLit mkDataLits mkRODataLits mkStgWordCLitpackHalfWordsCLit mkLblExpr cmmOffsetExpr cmmOffset cmmRegOff cmmOffsetLit cmmLabelOffcmmIndex cmmIndexExpr cmmLoadIndex cmmRegOffB cmmOffsetBcmmOffsetExprB cmmLabelOffB cmmOffsetLitBcmmOffsetExprW cmmOffsetW cmmRegOffW cmmOffsetLitW cmmLabelOffW cmmLoadIndexW cmmOrWord cmmAndWord cmmNeWord cmmEqWord cmmULtWord cmmUGeWord cmmUGtWord cmmSLtWord cmmUShrWord cmmAddWord cmmSubWord cmmMulWord cmmQuotWord cmmNegate blankWord cmmToWordisTrivialCmmExprhasNoGlobalRegsisLitisComparisonExpr cmmTagMaskcmmPointerMaskcmmUntag cmmIsTagged cmmConstrTag1 regsOverlap regUsedIn mkLiveness modifyGraph toBlockMap ofBlockMap toBlockListtoBlockListEntryFirst%toBlockListEntryFirstFalseFallthrough ofBlockListbodyToBlockList mapGraphNodesmapGraphNodes1foldlGraphBlocks revPostorder blockTicksbaseExprspExpr spLimExprhpExpr hpLimExprcurrentTSOExprcurrentNurseryExprcccsExpr$fOutputableGenCmmGraph$fOutputableGraph'$fOutputableBlock$fOutputableBlock0$fOutputableBlock1$fOutputableBlock2$fOutputableCmmReturnInfo$fOutputableForeignTarget$fOutputableForeignConvention$fOutputableConvention$fOutputableCmmNode$fOutputableCmmTopInfo$fOutputableCmmStackInfowriteCspprStringInCStyle $fMonadTE$fApplicativeTE $fFunctorTE UnwindExprUwConstUwRegUwDerefUwLabelUwPlusUwMinusUwTimes UnwindTable UnwindPoint DebugBlock dblProceduredblLabel dblCLabel dblHasInfoTbl dblParentdblTicks dblSourceTick dblPosition dblUnwind dblBlocks dblIsEntry cmmDebugGencmmDebugLabels cmmDebugLink debugToMap toUnwindExpr$fOutputableUnwindExpr$fOutputableUnwindPoint$fOutputableDebugBlock$fEqUnwindExprconstantFoldNodeconstantFoldExpr cmmMachOpFoldcmmMachOpFoldM CmmLocalLive liveLatticecmmLocalLivenesscmmGlobalLivenessgen_killcmmSinkcmmLint cmmLintGraph$fHasDynFlagsCmmLint$fMonadCmmLint$fApplicativeCmmLint$fFunctorCmmLintcmmImplementSwitchPlans cmmCfgOptscmmCfgOptsProc replaceLabelsremoveUnreachableBlocksProcelimCommonBlocks ParamLocation RegisterParam StackParamassignArgumentsPos assignStackrealArgRegsCover$fOutputableParamLocationTransferJumpRetJumpRetCgStmtCgLabelCgLastCgForkCmmAGraphScoped CmmAGraph catAGraphsmkLabelmkMiddlemkLast outOfLinelgraphOfAGraph labelAGraphmkNop mkCommentmkAssignmkStoremkJump mkRawJump mkJumpExtra mkCbranchmkSwitchmkReturnmkBranch mkFinalCallmkCallReturnsTomkJumpReturnsTo mkUnsafeCallmkUnwind stackStubExpr copyInOflow copyOutOflow mkCallEntry noExtraStacktoCall $fEqTransfer baseRegOffsetget_GlobalReg_addrregTableOffsetget_Regtable_addr_from_offsetfixStgRegistersEdgeInfotransitionSource edgeWeightTransitionSource CmmSourceCfgEdgeedgeFromedgeToedgeInfo EdgeWeight mkWeightInfoadjustEdgeWeight getCfgNodeshasNodesanityCheckCfg filterEdgesshortcutWeightMapaddImmediateSuccessoraddEdge addWeightEdgedelEdgegetSuccEdgesSortedgetSuccessorEdges getEdgeInfo reverseEdges infoEdgeListweightedEdgeListedgeList getSuccessorspprEdgeWeightsaddNodesBetween getCfgProcgetCfg optimizeCFG loopMembers$fOutputableEdgeWeight$fOutputableEdgeInfo$fOutputableCfgEdge $fOrdCfgEdge $fEqCfgEdge$fEqEdgeWeight$fOrdEdgeWeight$fEnumEdgeWeight$fNumEdgeWeight$fRealEdgeWeight$fIntegralEdgeWeight$fEqTransitionSource $fEqEdgeInfomkBitmap intsToBitmapintsToReverseBitmapmAX_SMALL_BITMAP_SIZE seqBitmap wordLengthwordLengthInBitsspillAreaLength spillSlotSizeextraStackArgsHere fits13Bitsis32BitIntegerlargeOffsetErrorNEGNEVERPOSVCVS allRealRegsgRegoReglRegiRegf6f8f22f26f27g0g1g2fpo0o1f0bitMask showFreeRegsfpRelspillSlotToOffset maxSpillSlots FloatSpecFloatMeStayPut LevelTypeBndrLvl JoinCeilLvlLevel LevelledBndr LevelledBind LevelledExprfloatSpecLevel tOP_LEVEL incMinorLvl asJoinCeilLvlltLvlltMajLvlisTopLvl isJoinCeilLvl setLevels $fEqLevel$fOutputableLevel$fOutputableFloatSpec $fEqLevelType floatOutwards$fOutputableFloatBindsSimplMinitSmpl traceSmpl getSimplRules getFamEnvsnewId newJoinId getSimplCounttick checkedTickfreeTick$fMonadIOSimplM$fHasDynFlagsSimplM$fMonadUniqueSimplM $fMonadSimplM$fApplicativeSimplM$fFunctorSimplM JoinFloats JoinFloat LetFloatsSimplSRDoneExDoneIdContEx SimplFloats sfLetFloats sfJoinFloats sfInScopeseMode seTvSubst seCvSubst seIdSubst seInScope emptyFloats pprSimplEnv mkSimplEnvgetMode seDynFlagssetModeupdMode getInScope setInScopeSetsetInScopeFromEsetInScopeFromFaddNewInScopeIds modifyInScope setSubstEnvmkContExdoFloatFromRhsemptyLetFloatsemptyJoinFloats unitLetFloat unitJoinFloat mkFloatBind extendFloats addLetFloats addJoinFloats addFloats addLetFlts letFloatBinds addJoinFlts mkRecFloats wrapFloatswrapJoinFloatsXwrapJoinFloatsgetTopFloatBinds mapLetFloatssubstIdrefineFromInScope lookupRecBndr simplBinders simplBindersimplNonRecBndrsimplNonRecJoinBndr simplRecBndrssimplRecJoinBndrs$fOutputableSimplSR$fOutputableFloatFlag$fOutputableLetFloats$fOutputableSimplFloatsValArgTyArgCastBy as_arg_ty as_hole_tyArgInfoai_funai_argsai_typeai_rulesai_enclai_strsai_discsDupFlagNoDup SimplifiedOkToDup StaticEnv SimplContStopCastIt ApplyToVal ApplyToTySelect StrictBind StrictArgTickItsc_dupsc_argsc_envsc_cont sc_arg_ty sc_hole_tysc_bndrsc_altssc_bndrssc_bodysc_funsc_cci isSimplified addValArgTo addTyArgTo addCastToargInfoAppArgspushSimplifiedArgs argInfoExpr mkBoringStop mkRhsStop mkLazyArgStopcontIsRhsOrArg contIsStop contIsDupable contIsTrivialcontResultType contHoleType countArgscontArgs mkArgInfointerestingCallContextsimplEnvForGHCiupdModeForStableUnfoldingsupdModeForRulesactiveUnfoldinggetUnfoldingInRuleMatch activeRulepreInlineUnconditionallypostInlineUnconditionallymkLamtryEtaExpandRhsabstractFloats prepareAltsmkCase isExitJoinId$fOutputableDupFlag$fOutputableArgSpec$fOutputableSimplCont simplTopBinds simplExpr simplRules runState'getgetsputmodify evalState execStaterunState $fMonadState$fApplicativeState$fFunctorState specProgram$fOutputableCallKey$fOutputableCallInfo$fOutputableCallInfoSet$fOutputableUsageDetails$fHasModuleSpecM$fHasDynFlagsSpecM$fMonadUniqueSpecM$fMonadFailSpecM $fMonadSpecM$fApplicativeSpecM$fFunctorSpecMLiveBasicBlockLiveInfoliveBorn liveDieRead liveDieWrite LiveInstrInstrSRInstrSPILLRELOAD LiveCmmDeclBlockMapRegMap emptyRegMap mapBlockTop mapBlockTopMmapSCCMmapGenBlockTopmapGenBlockTopMslurpConflictsslurpReloadCoalesce stripLivestripLiveBlockeraseDeltasLivepatchEraseLivepatchRegsLiveInstrcmmTopLiveness regLivenessreverseBlocksInTops$fOutputableInstrSR$fInstructionInstrSR$fOutputableLiveInstr$fOutputableLiveInfoRA_State ra_blockassig ra_freeregsra_assigra_deltara_stackra_us ra_spills ra_DynFlags ra_fixups RegAllocStatsra_spillInstrs ra_fixupList SpillReason SpillAlloc SpillClobber SpillLoad SpillJoinRR SpillJoinRMLocInMemInBothBlockAssignment regsOfLoc$fOutputableLoc$fEqLoc $fShowLoc$fOrdLoc regCoalesce slurpJoinMovsbinSpillReasonscountRegRegMovesNatpprStatsRegMrunRspillRloadR getFreeRegsR setFreeRegsR getAssigR setAssigRgetBlockAssigRsetBlockAssigR setDeltaR getDeltaR getUniqueR recordSpillrecordFixupBlock$fHasDynFlagsRegM $fMonadRegM$fApplicativeRegM $fFunctorRegM SpillCostInfoSpillCostRecordzeroSpillCostInfoplusSpillCostInfoplusSpillCostRecordslurpSpillCostInfo chooseSpilllifeMapFromSpillCostInfopprSpillCostRecord cleanSpills$fOutputableStore$fUniquableStore SpillStatsspillStoreLoadregSpill accSpillSL$fOutputableSpillStatsexitifyProgramnoWarnLookupIdSubstOutputablePassStgOp StgPrimOp StgPrimCallOp StgFCallOp UpdateFlag ReEntrant Updatable SingleEntry OutStgAlt OutStgRhs OutStgExpr OutStgArg OutStgBindingOutStgTopBindingInStgAltInStgRhs InStgExprInStgArg InStgBindingInStgTopBindingCgStgAltCgStgRhs CgStgExpr CgStgBindingCgStgTopBindingLlStgAltLlStgRhs LlStgExpr LlStgBindingLlStgTopBindingStgAltStgRhsStgExpr StgBinding StgTopBindingAltTypePolyAlt MultiValAltAlgAltPrimAlt GenStgAlt XLetNoEscapeXLet XRhsClosureBinderP NoExtSilentStgPassVanillaLiftLamsCodeGen GenStgRhs StgRhsClosure StgRhsCon GenStgExprStgAppStgLit StgConAppStgOpAppStgLamStgCaseStgLetStgLetNoEscapeStgTickStgArg StgVarArg StgLitArg GenStgBinding StgNonRecStgRecGenStgTopBinding StgTopLiftedStgTopStringLit isDllConApp stgArgTypestripStgTicksTopstgCaseBndrInScope noExtSilent stgRhsAritytopStgBindHasCafRefsstgArgHasCafRefs isUpdatablepprGenStgTopBindings pprStgBindingpprStgTopBindings$fOutputableStgArg$fOutputableNoExtSilent$fOutputableAltType$fOutputableUpdateFlag$fOutputableGenStgRhs$fOutputableGenStgExpr$fOutputableGenStgBinding$fOutputableGenStgTopBinding$fDataNoExtSilent$fEqNoExtSilent$fOrdNoExtSilent showStgStats$fEqCounterType$fOrdCounterTypelintStgTopBindingsLiftM FloatLangStartBindingGroupEndBindingGroupPlainTopBinding LiftedBindingEnve_dflagse_subst e_expansionse_in_caffy_contextdecomposeStgBinding mkStgBinding collectFloatsrunLiftM withCaffynessaddTopStringLitstartBindingGroupendBindingGroupaddLiftedBinding withSubstBndrwithSubstBndrswithLiftedBndrwithLiftedBndrssubstOccisLiftedformerFreeVars$fOutputableFloatLang$fMonadUniqueLiftM$fHasDynFlagsLiftM$fFunctorLiftM$fApplicativeLiftM $fMonadLiftMannTopBindingsFreeVarsannBindingFreeVarsstgCse$fTrieMapStgArgMap$fTrieMapConAppMap ClosureInfo closureName closureLFInfoclosureInfoLabel CallMethodEnterItJumpToItReturnItSlowCall DirectEntryDynTagStandardFormInfoLambdaFormInfoNonVoid SelfLoopInfoCgLocCmmLocLneLoc isKnownFun fromNonVoid nonVoidIdsassertNonVoidIdsnonVoidStgArgsassertNonVoidStgArgs idPrimRep addIdReps addArgReps argPrimRep mkLFArgumentmkLFLetNoEscape mkLFReEntrant mkLFThunk mkConLFInfomkSelectorLFInfo mkApLFInfo mkLFImported mkLFStringLit isSmallFamily tagForCon tagForAritylfDynTag isLFThunk isLFReEntrantnodeMustPointToIt getCallMethod mkCmmInfo mkClosureInfoblackHoleOnEntryisStaticClosureclosureUpdReqd lfUpdatableclosureSingleEntryclosureReEntrantclosureFunInfofunTagisToplevClosurestaticClosureLabelclosureSlowEntryLabelclosureLocalEntryLabelmkDataConInfoTablecafBlackHoleInfoTableindStaticInfoTablestaticClosureNeedsLink$fOutputableCgLoc$fOutputableNonVoid $fEqNonVoid $fShowNonVoidVirtualHpOffset HeapUsagevirtHprealHpCgState MkCgState cgs_stmtscgs_tops cgs_binds cgs_hp_usg cgs_uniqs ReturnKindAssignedDirectly ReturnedToSequelAssignToCgIdInfocg_idcg_lfcg_locCgInfoDownwards MkCgInfoDown cgd_dflagscgd_mod cgd_updfr_off cgd_ticky cgd_sequel cgd_self_loopcgd_tick_scopeFCodeinitCrunCfixCinitUpdFrameOffheapHWM initHpUsagegetStatesetState getHpUsage setHpUsage setVirtHp getVirtHp setRealHpgetBindssetBinds newUnique getInfoDown getSelfLoop withSelfLoopgetThisPackage getModuleName withSequel getSequelwithUpdFrameOffgetUpdFrameOffgetTickyCtrLabelsetTickyCtrLabel getTickScope tickScopeforkClosureBody forkLneBodycodeOnlyforkAlts forkAltPairgetCodeRgetCode getCodeScoped getHeapUsage emitLabel emitCommentemitTick emitUnwind emitAssign emitStoreemitemitDecl emitOutOfLineemitProcWithStackFrameemitProcWithConventionemitProcgetCmmmkCmmIfThenElsemkCmmIfThenElse' mkCmmIfGoto mkCmmIfGoto' mkCmmIfThen mkCmmIfThen'mkCall mkCmmCall aGraphToGraph$fOutputableCgIdInfo$fOutputableSequel$fHasDynFlagsFCode$fMonadUniqueFCode $fMonadFCode$fApplicativeFCode$fFunctorFCodecgLit mkSimpleLit addToMemLbl addToMemLblEaddToMem addToMemEmkTaggedObjectLoad tagToClosure emitRtsCallemitRtsCallWithResultemitRtsCallGencallerSaveVolatileRegs emitDataLitsemitRODataLits newStringCLitnewByteStringCLit assignTempnewTempnewUnboxedTupleRegsemitMultiAssign emitSwitchemitCmmLitSwitchccsTypeccType storeCurCCS mkCCostCentremkCCostCentreStackcostCentreFrom staticProfHdr dynProfHdrinitUpdFrameProfsaveCurrentCostCentrerestoreCurrentCostCentre profDynAlloc profAllocenterCostCentreThunkenterCostCentreFuninitCostCentres emitSetCCCldvRecordCreateldvEnterClosureldvEnter mkTickBoxinitHpcunECNamedVarNFunNLabelN loopDeclsgetEnvwithNamenewLocalnewLabelnewFunctionName newImport lookupLabel lookupNamecode$fHasDynFlagsCmmParse$fMonadUniqueCmmParse$fMonadCmmParse$fApplicativeCmmParse$fFunctorCmmParse litIdInfo lneIdInfo rhsIdInfo mkRhsInit idInfoToAmodemaybeLetNoEscapeaddBindC addBindsC getCgIdInfo getArgAmodegetNonVoidArgAmodes bindToReg rebindToReg bindArgToRegbindArgsToRegsidToRegArgRepNVFDV16V32V64 argRepStringtoArgRepisNonV argRepSizeWidArgRepslowCallPattern$fOutputableArgRepwithNewTickyCounterFunwithNewTickyCounterLNEwithNewTickyCounterThunkwithNewTickyCounterStdThunkwithNewTickyCounterContickyPushUpdateFrametickyUpdateFrameOmittedtickyEnterDynContickyEnterStaticContickyEnterViaNodetickyEnterThunktickyEnterStdThunktickyBlackHoletickyUpdateBhCaf tickyEnterFun tickyEnterLNEtickyReturnOldContickyReturnNewContickyUnboxedTupleReturntickyDirectCalltickyKnownCallTooFewArgstickyKnownCallExacttickyKnownCallExtraArgstickyUnknownCall tickySlowCalltickySlowCallPat tickyDynAlloctickyAllocHeaptickyAllocPrimtickyAllocThunk tickyAllocPAPtickyHeapChecktickyStackCheckcgBind coreToStg $fMonadCtsM$fApplicativeCtsM $fFunctorCtsM $fEqLetInfo $fEqHowBound runStreamyieldliftIOcollectfromListmap mapAccumL $fMonadStream$fApplicativeStream$fFunctorStreamLlvmM LlvmVersion UnresStatic UnresLabelLlvmData LlvmUnresDataLiveGlobalRegsLlvmBasicBlock LlvmCmmDecl cmmToLlvmTypewidthToLlvmFloatwidthToLlvmInt llvmFunTy llvmFunSig llvmFunAlign llvmInfAlignllvmFunSection llvmFunArgsllvmStdFunAttrs tysToParams llvmPtrBitssupportedLlvmVersionllvmVersionStrrunLlvm liftStream withClearVars varInsert funInsert varLookup funLookup markStackReg checkStackReggetMetaUniqueId getLlvmVer getDynFlaggetLlvmPlatform dumpIfSetLlvm renderLlvm markUsedVar getUsedVars setUniqMeta getUniqMetaghcInternalFunctionsstrCLabel_llvmstrDisplayName_llvmstrProcedureName_llvm getGlobalPtrgenerateExternDeclsaliasify$fMonadUniqueLlvmM$fHasDynFlagsLlvmM $fMonadLlvmM$fApplicativeLlvmM$fFunctorLlvmM genLlvmDatagenData pprLlvmDatapprLlvmCmmDecl infoSection genLlvmProc$fMonoidLlvmAccum$fSemigroupLlvmAccum $fEqSignage $fShowSignagemkEmptyContInfoTable cmmToRawCmm mkInfoTable srtEscapeclosureInfoPtr entryCode getConstrTagcmmGetClosureType infoTableinfoTableConstrTaginfoTableSrtBitmapinfoTableClosureType infoTablePtrsinfoTableNonPtrs funInfoTable funInfoAritystdInfoTableSizeWfixedInfoTableSizeWprofInfoTableSizeWmaxStdInfoTableSizeWmaxRetInfoTableSizeWstdInfoTableSizeBstdSrtBitmapOffsetstdClosureTypeOffset stdPtrsOffsetstdNonPtrsOffsetconInfoTableSizeB ClosureHeaderNoHeader StdHeader ThunkHeaderFieldOffOrPaddingFieldOffPadding emitReturnemitCalladjustHpBackwards directCallslowCallgetHpRelOffsetmkVirtHeapOffsetsWithPaddingmkVirtHeapOffsetsmkVirtConstrOffsetsmkVirtConstrSizes mkArgDescremitClosureProcAndInfoTableemitClosureAndInfoTable BinderInfo BindsClosure BoringBinderSkeleton ClosureSkRhsSkAltSkBothSkNilSkbinderInfoBndrtagSkeletonTopBind goodToLift closureGrowth$fOutputableSkeleton$fOutputableBndrBinderInfo$fOutputableBinderInfo stgLiftLamsallocDynClosureallocDynClosureCmmallocHeapClosure emitSetDynHdrmkStaticClosureFieldsmkStaticClosureentryHeapCheckentryHeapCheck' altHeapCheckaltHeapCheckReturnsTonoEscapeHeapCheckheapStackCheckGen ModuleSRTInfoCAFEnvCAFSetcafAnalemptySRTdoSRTs$fOutputableModuleSRTInfo $fEqCAFLabel $fOrdCAFLabel$fOutputableCAFLabel $fEqSRTEntry $fOrdSRTEntry$fOutputableSRTEntry cgForeignCall emitCCall emitPrimCallemitForeignCallemitSaveThreadStatesaveThreadStateemitCloseNurseryemitLoadThreadStateloadThreadStateemitOpenNurserycgOpAppshouldInlinePrimOpcgPrimOpmkITblsBCInstrSTKCHECKPUSH_LPUSH_LLPUSH_LLLPUSH8PUSH16PUSH32PUSH8_WPUSH16_WPUSH32_WPUSH_G PUSH_PRIMOPPUSH_BCO PUSH_ALTSPUSH_ALTS_UNLIFTED PUSH_PAD8 PUSH_PAD16 PUSH_PAD32 PUSH_UBX8 PUSH_UBX16 PUSH_UBX32PUSH_UBX PUSH_APPLY_N PUSH_APPLY_V PUSH_APPLY_F PUSH_APPLY_D PUSH_APPLY_L PUSH_APPLY_P PUSH_APPLY_PPPUSH_APPLY_PPPPUSH_APPLY_PPPPPUSH_APPLY_PPPPPPUSH_APPLY_PPPPPPSLIDEALLOC_APALLOC_AP_NOUPD ALLOC_PAPMKAPMKPAPUNPACKPACKLABELTESTLT_ITESTEQ_ITESTLT_WTESTEQ_WTESTLT_FTESTEQ_FTESTLT_DTESTEQ_DTESTLT_PTESTEQ_PCASEFAILJMPCCALLSWIZZLEENTERRETURN RETURN_UBXBRK_FUNProtoBCO protoBCONameprotoBCOInstrsprotoBCOBitmapprotoBCOBitmapSize protoBCOArity protoBCOExpr protoBCOFFIs bciStackUse$fOutputableBCInstr$fOutputableProtoBCO bcoFreeNames assembleBCOsassembleOneBCOiNTERP_STACK_CHECK_THRESH$fMonadAssembler$fApplicativeAssembler$fFunctorAssembler byteCodeGencoreExprToBCOs$fOutputableDiscr$fHasDynFlagsBcM $fMonadBcM$fApplicativeBcM $fFunctorBcM $fEnumByteOff $fEqByteOff$fIntegralByteOff $fNumByteOff $fOrdByteOff $fRealByteOff $fEnumWordOff $fEqWordOff$fIntegralWordOff $fNumWordOff $fOrdWordOff $fRealWordOff $fEqDiscr $fOrdDiscrStatus ReachedBy ProcPoint ProcPointSetprocPointAnalysiscallProcPointsminimalProcPointSetsplitAtProcPointsattachContInfoTables$fOutputableStatuscmmLayoutStacksetInfoTableStackMap$fOutputableStackMap$fOutputableStackSlot cmmPipeline BuildMessageBuildMsg BuildErrorEOFreadCreateProcessWithExitCode' replaceVarreadProcessEnvWithExitCode c_locale_env getGccEnv runSomethingrunSomethingResponseFilerunSomethingFilteredrunSomethingWith handleProcbuilderMainLoop readerProc parseError breakColon breakIntColon linesPlatformneededLinkArgs getLinkerInfogetLinkerInfo'getCompilerInfogetCompilerInfo'runUnlitrunCpprunPprunCc isContainedInaskLdrunAs runLlvmOpt runLlvmLlcrunClangfigureLlvmVersionrunLink runLibtoolrunAraskAr runRanlibrunMkDLL runWindrestouch mkExtraObjmkExtraObjToLinkIntoBinarymkNoteObjsToLinkIntoBinary getLinkInfoplatformSupportsSavingLinkOptsghcLinkInfoSectionNameghcLinkInfoNoteName checkLinkInfohaveRtsOptsFlagsinitLlvmConfig initSysToolscopycopyWithHeader linkDynLib libmLinkOptsgetPkgFrameworkOptsgetFrameworkOpts llvmCodeGentemplateHaskellNamesthSynthLibqqLib mkTHModulelibFunlibTcthFunthTcthClsthConqqFun liftClassName qTyConName nameTyConNamefieldExpTyConName patTyConNamefieldPatTyConName expTyConName decTyConName typeTyConNamematchTyConNameclauseTyConNamefunDepTyConName predTyConName tExpTyConNameinjAnnTyConNameoverlapTyConName returnQName bindQName sequenceQName newNameNameliftNameliftStringName mkNameName mkNameG_vName mkNameG_dNamemkNameG_tcName mkNameLName mkNameSName unTypeName unTypeQNameunsafeTExpCoerceName charLName stringLName integerLName intPrimLName wordPrimLNamefloatPrimLNamedoublePrimLName rationalLNamestringPrimLName charPrimLNamelitPNamevarPNametupPNameunboxedTupPNameunboxedSumPNameconPName infixPName tildePName bangPNameasPName wildPNamerecPName listPNamesigPName viewPName fieldPatName matchName clauseNamevarENameconENamelitENameappEName appTypeEName infixEName infixAppName sectionLName sectionRNamelamEName lamCaseENametupENameunboxedTupENameunboxedSumEName condEName multiIfENameletEName caseENamedoENamemdoEName compEName fromEName fromThenEName fromToENamefromThenToEName listENamesigEName recConEName recUpdEName staticENameunboundVarEName labelENameimplicitParamVarEName fieldExpName guardedBName normalBName normalGEName patGEName bindSNameletSName noBindSNameparSNamerecSNamefunDNamevalDName dataDName newtypeDName tySynDName classDNameinstanceWithOverlapDName standaloneDerivWithStrategyDNamesigDNamedefaultSigDName forImpDName pragInlDName pragSpecDNamepragSpecInlDNamepragSpecInstDName pragRuleDNamepragCompleteDName pragAnnDName dataInstDNamenewtypeInstDNametySynInstDNameopenTypeFamilyDNameclosedTypeFamilyDNamedataFamilyDName infixLDName infixRDName infixNDNameroleAnnotDName patSynDNamepatSynSigDNameimplicitParamBindDNamecxtNamenoSourceUnpackednessNamesourceNoUnpackNamesourceUnpackNamenoSourceStrictnessNamesourceLazyNamesourceStrictName normalCNamerecCName infixCName forallCName gadtCName recGadtCNamebangName bangTypeNamevarBangTypeNameunidirPatSynNameimplBidirPatSynNameexplBidirPatSynNameprefixPatSynNameinfixPatSynNamerecordPatSynName forallTNameforallVisTNamevarTNameconTName tupleTNameunboxedTupleTNameunboxedSumTName arrowTName listTNameappTName appKindTNamesigTName equalityTNamelitTName promotedTNamepromotedTupleTNamepromotedNilTNamepromotedConsTName wildCardTName infixTNameimplicitParamTName numTyLitName strTyLitName plainTVName kindedTVName nominalRNamerepresentationalRName phantomRName inferRNamevarKNameconKName tupleKName arrowKName listKNameappKName starKNameconstraintKName noSigName kindSigName tyVarSigNameinjectivityAnnName cCallName stdCallName cApiCallName primCallNamejavaScriptCallName unsafeNamesafeNameinterruptibleNametExpDataConName ruleVarNametypedRuleVarName funDepName tySynEqnNamevalueAnnotationNametypeAnnotationNamemoduleAnnotationNamederivClauseNamestockStrategyNameanyclassStrategyNamenewtypeStrategyNameviaStrategyNamematchQTyConNameclauseQTyConName expQTyConNamestmtQTyConName decQTyConNamedecsQTyConName conQTyConNamebangTypeQTyConNamevarBangTypeQTyConNametypeQTyConNamefieldExpQTyConName patQTyConNamefieldPatQTyConNamepredQTyConNameruleBndrQTyConNametySynEqnQTyConName roleTyConNamederivClauseQTyConNamekindQTyConNametyVarBndrQTyConNamederivStrategyQTyConName quoteExpName quotePatName quoteDecName quoteTypeNamenoInlineDataConNameinlineDataConNameinlinableDataConNameconLikeDataConNamefunLikeDataConNameallPhasesDataConNamefromPhaseDataConNamebeforePhaseDataConNameoverlappableDataConNameoverlappingDataConNameoverlapsDataConNameincoherentDataConName liftClassKey expTyConKey matchTyConKeyclauseTyConKey qTyConKey expQTyConKey decQTyConKey patTyConKeymatchQTyConKeyclauseQTyConKey stmtQTyConKey conQTyConKey typeQTyConKey typeTyConKey decTyConKeybangTypeQTyConKeyvarBangTypeQTyConKeyfieldExpTyConKeyfieldPatTyConKey nameTyConKey patQTyConKeyfieldPatQTyConKeyfieldExpQTyConKeyfunDepTyConKey predTyConKey predQTyConKeytyVarBndrQTyConKey decsQTyConKeyruleBndrQTyConKeytySynEqnQTyConKey roleTyConKey tExpTyConKeyinjAnnTyConKey kindQTyConKeyoverlapTyConKeyderivClauseQTyConKeyderivStrategyQTyConKeynoInlineDataConKeyinlineDataConKeyinlinableDataConKeyconLikeDataConKeyfunLikeDataConKeyallPhasesDataConKeyfromPhaseDataConKeybeforePhaseDataConKeytExpDataConKeyoverlappableDataConKeyoverlappingDataConKeyoverlapsDataConKeyincoherentDataConKey returnQIdKey bindQIdKeysequenceQIdKey liftIdKey newNameIdKey mkNameIdKeymkNameG_vIdKeymkNameG_dIdKeymkNameG_tcIdKey mkNameLIdKey mkNameSIdKey unTypeIdKey unTypeQIdKeyunsafeTExpCoerceIdKey charLIdKey stringLIdKey integerLIdKey intPrimLIdKeywordPrimLIdKeyfloatPrimLIdKeydoublePrimLIdKeyrationalLIdKeystringPrimLIdKeycharPrimLIdKeyliftStringIdKey litPIdKey varPIdKey tupPIdKeyunboxedTupPIdKeyunboxedSumPIdKey conPIdKey infixPIdKey tildePIdKey bangPIdKeyasPIdKey wildPIdKey recPIdKey listPIdKey sigPIdKey viewPIdKey fieldPatIdKey matchIdKey clauseIdKey varEIdKey conEIdKey litEIdKey appEIdKey appTypeEIdKey infixEIdKey infixAppIdKey sectionLIdKey sectionRIdKey lamEIdKey lamCaseEIdKey tupEIdKeyunboxedTupEIdKeyunboxedSumEIdKey condEIdKey multiIfEIdKey letEIdKey caseEIdKeydoEIdKey compEIdKey fromEIdKeyfromThenEIdKey fromToEIdKeyfromThenToEIdKey listEIdKey sigEIdKey recConEIdKey recUpdEIdKey staticEIdKeyunboundVarEIdKey labelEIdKeyimplicitParamVarEIdKey mdoEIdKey fieldExpIdKey guardedBIdKey normalBIdKey normalGEIdKey patGEIdKey bindSIdKey letSIdKey noBindSIdKey parSIdKey recSIdKey funDIdKey valDIdKey dataDIdKey newtypeDIdKey tySynDIdKey classDIdKeyinstanceWithOverlapDIdKeyinstanceDIdKey sigDIdKey forImpDIdKey pragInlDIdKeypragSpecDIdKeypragSpecInlDIdKeypragSpecInstDIdKeypragRuleDIdKey pragAnnDIdKeydataFamilyDIdKeyopenTypeFamilyDIdKeydataInstDIdKeynewtypeInstDIdKeytySynInstDIdKeyclosedTypeFamilyDIdKey infixLDIdKey infixRDIdKey infixNDIdKeyroleAnnotDIdKey!standaloneDerivWithStrategyDIdKeydefaultSigDIdKey patSynDIdKeypatSynSigDIdKeypragCompleteDIdKeyimplicitParamBindDIdKeycxtIdKeynoSourceUnpackednessKeysourceNoUnpackKeysourceUnpackKeynoSourceStrictnessKey sourceLazyKeysourceStrictKey normalCIdKey recCIdKey infixCIdKey forallCIdKey gadtCIdKey recGadtCIdKey bangIdKeybangTKey varBangTKeyunidirPatSynIdKeyimplBidirPatSynIdKeyexplBidirPatSynIdKeyprefixPatSynIdKeyinfixPatSynIdKeyrecordPatSynIdKey forallTIdKeyforallVisTIdKey varTIdKey conTIdKey tupleTIdKeyunboxedTupleTIdKeyunboxedSumTIdKey arrowTIdKey listTIdKey appTIdKey appKindTIdKey sigTIdKeyequalityTIdKey litTIdKeypromotedTIdKeypromotedTupleTIdKeypromotedNilTIdKeypromotedConsTIdKeywildCardTIdKeyimplicitParamTIdKey infixTIdKey numTyLitIdKey strTyLitIdKey plainTVIdKey kindedTVIdKey nominalRIdKeyrepresentationalRIdKey phantomRIdKey inferRIdKey varKIdKey conKIdKey tupleKIdKey arrowKIdKey listKIdKey appKIdKey starKIdKeyconstraintKIdKey noSigIdKey kindSigIdKey tyVarSigIdKeyinjectivityAnnIdKey cCallIdKey stdCallIdKey cApiCallIdKey primCallIdKeyjavaScriptCallIdKey unsafeIdKey safeIdKeyinterruptibleIdKey funDepIdKey tySynEqnIdKey quoteExpKey quotePatKey quoteDecKey quoteTypeKey ruleVarIdKeytypedRuleVarIdKeyvalueAnnotationIdKeytypeAnnotationIdKeymoduleAnnotationIdKeyderivClauseIdKeystockStrategyIdKeyanyclassStrategyIdKeynewtypeStrategyIdKeyviaStrategyIdKeylift_RDR mkNameG_dRDR mkNameG_vRDRconE_RDRlitE_RDRappE_RDR infixApp_RDR stringL_RDR intPrimL_RDR wordPrimL_RDRfloatPrimL_RDRdoublePrimL_RDRstringPrimL_RDR charPrimL_RDR tcInitTidyEnvevDelayedError evCallStack tcCheckId tcSyntaxOpGen tcSyntaxOp tcInferRho tcInferSigmatcInferSigmaNC tcMonoExpr tcMonoExprNC tcPolyExprfindValidHoleFitstcIfaceCompleteSigstcIfaceAnnotationstcIfaceFamInst tcIfaceInst tcIfaceRules tcIfaceDecl tcMatchesFun tcGRHSsPatbadReexportedBootThingmissingBootThingcheckBootDeclMContainsCostCentreStateextractCostCentreStateinitTc initTcWithGblinitTcInteractive initTcRnIf discardResult getTopEnv updTopEnv getGblEnv updGblEnv setGblEnv getLclEnv updLclEnv setLclEnvgetEnvssetEnvsxoptMdoptMgoptMwoptMsetXOptM unsetXOptM unsetGOptM unsetWOptM whenDOptM whenGOptM whenWOptM whenXOptM unlessXOptM getGhcModewithDoDynamicToo getEpsVargetEps updateEps updateEps_getHpt getEpsAndHpt withException newArrowScopeescapeArrowScopenewUniqueSupplycloneLocalNamenewName newNameAt newSysName newSysLocalIdnewSysLocalIdsnewTcRef readTcRef writeTcRefupdTcReftraceTctraceRn traceOptTcRn traceTcRntraceTcRnForUsertraceTcRnWithStylegetPrintUnqualifiedprintForUserTcRntraceIf traceHiDiffs traceOptIf getIsGHCi getGHCiMonadgetInteractivePrintNametcIsHsBootOrSigtcIsHsigtcSelfBootInfogetGlobalRdrEnv getRdrEnvs getFixityEnvextendFixityEnvgetRecFieldEnvgetDeclaredDefaultTysaddDependentFiles getSrcSpanM setSrcSpanaddLocMwrapLocM wrapLocFstM wrapLocSndM wrapLocM_ getErrsVar setErrsVaraddErrfailWithfailAtaddErrAtaddErrscheckErr addMessagesdiscardWarnings mkLongErrAt mkErrDocAt addLongErrAt reportErrors reportError reportWarning checkNoErrs whenNoErrsifErrsM failIfErrsMcheckTHfailTH getErrCtxt setErrCtxt addErrCtxt addErrCtxtMaddLandmarkErrCtxtaddLandmarkErrCtxtMupdCtxt popErrCtxt getCtLocM setCtLocM askNoErrstryCaptureConstraintscaptureConstraintsattemptMrecoverMmapAndRecoverM mapAndReportMfoldAndRecoverMtryTc discardErrstryTcDiscardingErrsaddErrTc addErrsTc addErrTcMmkErrTcMmkErrTc failWithTc failWithTcMcheckTccheckTcMfailIfTc failIfTcM warnIfFlagwarnIfwarnTcwarnTcM addWarnTc addWarnTcMaddWarn addWarnAtadd_warn mkErrInfodebugTc addTopEvBinds newTcEvBindsnewNoTcEvBindscloneEvBindsVargetTcEvTyCoVarsgetTcEvBindsMapsetTcEvBindsMap addTcEvBindchooseUniqueOccTcgetConstraintVarsetConstraintVaremitStaticConstraintsemitConstraints emitSimple emitSimplesemitImplicationemitImplications emitInsolublediscardConstraintspushLevelAndCaptureConstraints pushTcLevelM_ pushTcLevelM pushTcLevelsM getTcLevel setTcLevelisTouchableTcM getLclTypeEnv setLclTypeEnvtraceTcConstraintsemitWildCardHoleConstraints recordThUserecordThSpliceUserecordTopLevelSpliceLocgetTopLevelSpliceLocs keepAlivegetStagegetStageAndBindLevelsetStageaddModFinalizersWithLclEnvrecordUnsafeInfer finalSafeModefixSafeInstancesgetLocalRdrEnvsetLocalRdrEnv mkIfLclEnv initIfaceTcRn initIfaceLoadinitIfaceCheck initIfaceLclinitIfaceLclWithSubst getIfModulefailIfM forkM_maybeforkMsetImplicitEnvM getCCIndexM$fMonadUniqueIOEnv!$fContainsCostCentreStateDsGblEnv!$fContainsCostCentreStateTcGblEnvnonBidirectionalErrtcPatSynBuilderBind tcPatSynDeclCandidatesQTvsDVdv_kvsdv_tvsdv_cvsnewMetaKindVarnewMetaKindVars newEvVarsnewEvVar newWanted newWanteds newHoleCt cloneWantedcloneWC emitWantedemitDerivedEqs emitWantedEqemitWantedEvVaremitWantedEvVarsnewDictnewCoercionHolefillCoercionHoleisFilledCoercionHoleunpackCoercionHoleunpackCoercionHole_maybecheckCoercionHolenewInferExpTypeNoInstnewInferExpTypeInstnewInferExpTypereadExpType_maybe readExpTypecheckingExpType_maybecheckingExpType tauifyExpType expTypeToTypeinferResultToType tcInstTypetcSkolDFunTypetcSuperSkolTyVarstcInstSkolTyVarstcInstSkolTyVarsXtcInstSuperSkolTyVarsXtcInstSkolTyVarsAtfreshenTyVarBndrsfreshenCoVarBndrsXnewSkolemTyVar newTyVarTyVarnewPatSigTyVar newFskTyVar newFmvTyVarnewMetaDetailscloneMetaTyVar readMetaTyVarisFilledMetaTyVar_maybeisFilledMetaTyVarisUnfilledMetaTyVarwriteMetaTyVarwriteMetaTyVarRef newFlexiTyVarnewFlexiTyVarTynewFlexiTyVarTysnewOpenTypeKindnewOpenFlexiTyVarTy newMetaTyVarsnewMetaTyVarsX newMetaTyVarXnewMetaTyVarTyVarsnewMetaTyVarTyVarX newWildCardXnewMetaTyVarTyAtLevelcandidateKindVarscandidateQTyVarsOfTypecandidateQTyVarsOfTypescandidateQTyVarsOfKindcandidateQTyVarsOfKinds delCandidatesquantifyTyVarszonkAndSkolemiseskolemiseQuantifiedTyVar defaultTyVartcGetGlobalTyCoVarszonkTcTypeAndFVzonkTyCoVarsAndFVzonkTyCoVarsAndFVList zonkTcTyVarszonkTyCoVarKind zonkTcTypes zonkEvVarzonkWC zonkSimpleszonkCtzonkSkolemInfozonkId zonkCoVar zonkTcTypezonkCo zonkTcTyVarzonkTcTyVarToTyVarzonkTyVarTyVarPairszonkTidyTcTypezonkTidyTcTypeszonkTidyOrigintidyCt tidyEvVartidySkolemInfoensureNotLevPolycheckForLevPolycheckForLevPolyXformatLevPolyErr$fOutputableCandidatesQTvs$fMonoidCandidatesQTvs$fSemigroupCandidatesQTvs WhereLookingWL_Any WL_Global WL_LocalTop WL_LocalOnlymkUnboundNameRdrreportUnboundName unboundName unboundNameX notInScopeErrunknownNameSuggestionsrnTopSpliceDecls rnSpliceDecl rnSplicePat rnSpliceTypeloadSysInterfaceNameCacheUpdaterNCUupdateNameCachenewGlobalBindernewInteractiveBinderallocateGlobalBinderifaceExportNamesmkNameCacheUpdaterupdNameCacheTc lookupOrig lookupOrigIOexternaliseName setNameModule tcIfaceLclIdextendIfaceIdEnv tcIfaceTyVarlookupIfaceTyVarlookupIfaceVarextendIfaceTyVarEnvextendIfaceEnvslookupIfaceTop newIfaceName newIfaceNamesemptyNameShape mkNameShapeextendNameShapenameShapeExportssubstNameShapemaybeSubstNameShape tcRnModIfacetcRnModExports rnModIface rnModExportsMethInfo TcMethInfo mkNewTyConRhs buildDataCon buildPatSyn buildClassnewImplicitBindernewTyConRepNamefinishTHrunRemoteModFinalizersrunQuasilookupThName_mayberunMetaDrunMetaTrunMetaPrunMetaEtcTopSpliceExpr runAnnotation runTopSplicetcTypedBrackettcUntypedBracket tcSpliceExpr tcAnnotationsannCtxt typeNatTyConstypeNatAddTyContypeNatSubTyContypeNatMulTyContypeNatDivTyContypeNatModTyContypeNatExpTyContypeNatLogTyContypeNatLeqTyContypeNatCmpTyContypeSymbolCmpTyContypeSymbolAppendTyContypeNatCoAxiomRules knownKeyNameslookupKnownKeyNameisKnownKeyNamelookupKnownNameInfoprimOpIdghcPrimExportsmaybeCharLikeConmaybeIntLikeConisNumericClassisStandardClass cgTopRhsCon buildDynCon bindConArgscgExprcgTopRhsClosureemitBlackHoleCodepushUpdateFrameemitUpdateFrame parseCmmFilecodeGenTraceBinIFaceReadingQuietBinIFaceReading CheckHiWay IgnoreHiWay readBinIfacegetWithUserData writeBinIfaceputWithUserData getSymtabNamegetDictFastString$fEqCheckHiWay$fEqTraceBinIFaceReadingtcLookupImported_maybe importDeclcheckWiredInTyConifCheckWiredInThingneedWiredInHomeIfaceloadSrcInterfaceloadSrcInterface_maybeloadModuleInterfaceloadModuleInterfacesloadInterfaceForNameloadInterfaceForNameMaybeloadInterfaceForModuleloadWiredInHomeIfaceloadUserInterfaceloadPluginInterface loadInterfacemoduleFreeHolesPrecise loadDeclsfindAndReadIface readIfaceinitExternalPackageState ifaceStats showIfacepprModIfaceSimple pprModIface$fOutputableWarningstypecheckIfacetypecheckIfacesForMergingtypecheckIfaceForInstantiate tcHiBootIface tcIfaceExpr tcIfaceGlobal DsWarning CanItFailCanFailCantFail MatchResult DsWrapper EquationInfoEqnInfoeqn_patseqn_origeqn_rhsDsMatchContext idDsWrapperorFailfixDsinitDsTcinitDsinitDsWithModGutsinitTcDsForSolver newUniqueIdduplicateLocalDs newPredVarDsnewSysLocalDsNoLP newSysLocalDsnewFailLocalDsnewSysLocalsDsNoLPnewSysLocalsDs getGhcModeDs getDictsDs addDictsDs getTmCsDs addTmCsDsincrCheckPmIterDs resetPmIterDs getSrcSpanDs putSrcSpanDswarnDs warnIfSetDserrDs errDsCoreExpr failWithDsfailDs askNoErrsDsmkPrintUnqualifiedDsdsLookupGlobaldsLookupGlobalId dsLookupTyCondsLookupDataCondsLookupConLikedsGetFamInstEnvs dsGetMetaEnvdsGetCompleteMatchesdsLookupMetaEnvdsExtendMetaEnvdiscardWarningsDs dsNoLevPolydsNoLevPolyExpr dsWhenNoErrspprRuntimeTrace$fMonadThingsIOEnv$fOutputableDsMatchContext$fOutputableEquationInfomatchSinglePatVar matchSimply matchWrappermatch dsLocalBinds dsSyntaxExprdsLExpr dsLExprNoLPdsExpr InstBindings ib_tyvarsib_binds ib_pragmas ib_extensions ib_derivedInstInfoiSpeciBinds lookupGlobalioLookupDataContcLookupLocatedGlobaltcLookupGlobaltcLookupGlobalOnlytcLookupDataContcLookupPatSyntcLookupConLike tcLookupClass tcLookupTyCon tcLookupAxiomtcLookupLocatedGlobalIdtcLookupLocatedClasstcLookupLocatedTyContcLookupInstance tcGetInstEnvssetGlobalTypeEnvtcExtendGlobalEnvImplicittcExtendGlobalEnvtcExtendTyConEnvtcExtendGlobalValEnvtcExtendRecEnvtcLookupLocatedtcLookupLcl_maybetcLookup tcLookupTyVar tcLookupIdtcLookupIdMaybetcLookupLocalIdsgetInLocalScopetcExtendKindEnvListtcExtendKindEnvtcExtendTyVarEnvtcExtendNameTyVarEnvisTypeClosedLetBndrtcExtendRecIdstcExtendSigIdstcExtendLetEnv tcExtendIdEnvtcExtendIdEnv1tcExtendIdEnv2tcExtendLocalTypeEnvtcExtendBinderStacktcInitOpenTidyEnvtcAddDataFamConPlaceholderstcAddPatSynPlaceholdersgetTypeSigNames tcExtendRulescheckWellStagedtopIdLvltcMetaTy isBrackStagetcGetDefaultTysiDFunIdpprInstInfoDetailssimpleInstInfoClsTysimpleInstInfoTysimpleInstInfoTyCon newDFunName newDFunName'newFamInstTyConNamenewFamInstAxiomNamemkStableIdFromStringmkStableIdFromName mkWrapperName pprBinders wrongThingErr$fOutputableInstInfo ZonkFlexi DefaultFlexiSkolemiseFlexiRuntimeUnkFlexiZonkEnv hsLPatType hsPatType hsLitType shortCutLit hsOverLitName emptyZonkEnvmkEmptyZonkEnv initZonkEnv zonkTopBndrs zonkTyBndrs zonkTyBndrsXzonkTyVarBinderszonkTyVarBindersXzonkTyVarBinderXzonkRecTyVarBndrs zonkTopExpr zonkTopLExpr zonkTopDecls zonkTcEvBinds zonkEvBinds zonkTyVarOcclookupTyVarOcczonkTcTypeToTypezonkTcTypeToTypeXzonkTcTypesToTypeszonkTcTypesToTypesX zonkCoToCozonkTcMethInfoToMethInfoX$fOutputableZonkEnvCaseAlt MkCaseAltalt_pat alt_bndrs alt_wrapper alt_resultselectSimpleMatchVarLselectMatchVarsselectMatchVarfirstPat shiftEqns matchCanFailalwaysFailMatchResultcantFailMatchResultextractMatchResultcombineMatchResultsadjustMatchResultadjustMatchResultDs wrapBindswrapBindseqVarmkCoLetMatchResultmkViewMatchResultmkEvalMatchResultmkGuardedMatchResultmkCoPrimCaseMatchResultmkCoAlgCaseMatchResultmkCoSynCaseMatchResult mkErrorAppDs mkCoreAppDs mkCoreAppsDsmkCastDsmkSelectorBinds mkLHsPatTupmkLHsVarPatTupmkVanillaTuplePatmkBigLHsVarTupId mkBigLHsTupIdmkBigLHsVarPatTupIdmkBigLHsPatTupId mkOptTickBoxmkBinaryTickBoxdecideBangHoodaddBang isTrueLHsExprdsLit dsOverLitwarnAboutIdentitieswarnAboutOverflowedOverLitwarnAboutOverflowedLitwarnAboutEmptyEnumerations tidyLitPattidyNPat matchLiteralshsLitKey matchNPatsmatchNPlusKPats dsBracketdsCCallmkFCallunboxArg boxResult resultWrappersptCreateStaticBindssptModuleInitCode HsDocContext TypeSigCtxPatCtxSpecInstSigCtxDefaultDeclCtxForeignDeclCtx DerivDeclCtxRuleCtx TyDataCtxTySynCtx TyFamilyCtx FamPatCtx ConDeclCtx ClassDeclCtxExprWithTySigCtxTypBrCtx HsTypeCtxGHCiCtx SpliceTypeCtxClassInstanceCtx GenericCtxnewLocalBndrRnnewLocalBndrsRnbindLocalNamesbindLocalNamesFVextendTyVarEnvFVRncheckDupRdrNames checkDupNamescheckShadowedRdrNamescheckDupAndShadowedNamesaddFvRnmapFvRn mapMaybeFvRnwarnUnusedTopBindscheckUnusedRecordWildcardwarnUnusedLocalBindswarnUnusedMatcheswarnUnusedTypePatterns mkFieldEnvaddNameClashErrRnunknownSubordinateErr dupNamesErrbadQualBndrErr typeAppErr checkTupSizewithHsDocContextinHsDocContextpprHsDocContextthNameToGhcName$fMonadThingsCoreM dsForeigns corePrepPgm corePrepExpr cvtLitInteger cvtLitNaturallookupMkIntegerNamelookupMkNaturalNamelookupIntegerSDataConNamelookupNaturalSDataConName$fOutputableFloatingBind$fOutputableOkToSpec$fOutputableFloats MiniFixityEnvaddLocalFixitieslookupFixityRnlookupFixityRn_helplookupTyFixityRnlookupFieldFixityRn HsSigCtxt TopSigCtxt LocalBindCtxt ClsDeclCtxt HsBootCtxt RoleAnnotCtxtChildLookupResult NameNotFoundIncorrectParent FoundNameFoundFLnewTopSrcBinderlookupTopBndrRnlookupLocatedTopBndrRnlookupExactOcclookupInstDeclBndrlookupFamInstNamelookupConstructorFieldslookupRecFieldOcclookupSubBndrOcc_helpercombineChildLookupResultlookupLocatedOccRnlookupLocalOccRn_maybelookupLocalOccThLvl_maybe lookupOccRnlookupLocalOccRnlookupTypeOccRnlookupOccRn_maybelookupOccRn_overloadedlookupGlobalOccRn_maybelookupGlobalOccRnlookupInfoOccRnlookupGlobalOccRn_overloadedlookupGreAvailRnaddUsedDataCons addUsedGRE addUsedGREslookupSigOccRnlookupSigCtxtOccRnlookupLocalTcNames dataTcOccslookupIfThenElselookupSyntaxName'lookupSyntaxNamelookupSyntaxNames$fMonoidDisambigInfo$fSemigroupDisambigInfo$fOutputableDisambigInfo$fOutputableChildLookupResult$fOutputableHsSigCtxtHsSigWcTypeScoping AlwaysBindBindUnlessForall NeverBind rnHsSigWcTypernHsSigWcTypeScoped rnHsWcType rnHsSigTypernImplicitBndrs rnLHsType rnLHsTypesrnHsType rnLHsKindrnHsKind rnLHsTypeArgs rnContextrnLTyVarbindSigTyVarsFV bindLRdrNames bindHsQTyVarsbindLHsTyVarBndrsbindLHsTyVarBndrnewTyVarNameRnrnConDeclFields mkOpAppRn mkNegAppRn mkOpFormRn mkConOpPatRncheckPrecMatchcheckSectionPrecextractHsTyArgRdrKiTyVarsDupextractHsTyRdrTyVarsextractHsTyRdrTyVarsKindVarsextractHsTysRdrTyVarsDupsextractRdrKindSigVarsextractDataDefnKindVarsextractHsTvBndrsnubLelemRdr$fOutputableRnTyKiWhat$fOutputableRnTyKiEnv$fOutputableOpNameHsRecFieldContext HsRecFieldCon HsRecFieldPat HsRecFieldUpd NameMakerCpsRnliftCpstopRecNameMakerisTopRecNameMakerlocalRecNameMakerrnPatsrnPatapplyNameMaker rnBindPat rnPatAndThen rnHsRecFieldsrnHsRecUpdFieldsrnLit rnOverLit patSigErr $fMonadCpsRn$fApplicativeCpsRn$fFunctorCpsRnImportDeclUsage rnImportscalculateAvailsextendGlobalRdrEnvRngetLocalNonValBindersnewRecordSelector mkChildEnv findChildrenreportUnusedNamesfindImportUsagegetMinimalImportsprintMinimalImportsdodgyMsgdodgyMsgInsert checkConName tcRnExportsexports_from_avail rnTopBindsLHSrnTopBindsBootrnLocalBindsAndThenrnLocalValBindsLHS rnValBindsRHSrnLocalValBindsRHSmakeMiniFixityEnv rnMethodBinds renameSigs rnMatchGrouprnGRHSsrnGRHSrnSrcFixityDecl rnSrcDecls addTcgDUs findSplice SpliceInfospliceDescription spliceSource spliceIsDeclspliceGenerated rnBracket rnSpliceExpr traceSplicecheckThLocalNamernExpr$fOutputableStmtTreeextendLoadedPkgs extendLinkEnvdeleteFromLinkEnv getHValuewithExtendedLinkEnvshowLinkerState initDynLinkerlinkCmdLineLibslinkExpr linkDecls linkModuleunload linkPackages newFamInstcheckFamInstConsistencytcInstNewTyCon_maybetcLookupDataFamInsttcLookupDataFamInst_maybetcTopNormaliseNewTypeTF_maybetcExtendLocalFamInstEnvmakeInjectivityErrorsinjTyVarsOfTypeinjTyVarsOfTypestcGetFamInstEnvs FunDepEqnFDEqnfd_qtvsfd_eqsfd_pred1fd_pred2fd_locimproveFromAnother pprEquationimproveFromInstEnvcheckInstCoverage checkFunDeps$fOutputableFunDepEqninitializePluginsloadFrontendPluginforceLoadModuleInterfacesforceLoadNameModuleInterfaceforceLoadTyCongetValueSafelygetHValueSafelylessUnsafeCoercelookupRdrNameInModuleForPluginsHieName ExternalName LocalName KnownKeyName writeHieFile readHieFile toHieName$fOutputableHieName $fOrdHieName $fEqHieName DiffIdentDiffppHiesppHieppInfodiffFilediffAstsdiffAstnormalizeIdentsdiffListeqDiffvalidAstvalidateScopesfingerprintDynFlagsfingerprintOptFlagsfingerprintHpcFlagsRecompileRequiredUpToDate MustCompile RecompBecausemkIface mkIfaceTcwriteIfaceFilemkIfaceExportsrecompileRequired checkOldIfacetyThingToIfaceDeclcoAxiomToIfaceDecl$fBinaryIfaceIdExtras$fBinaryIfaceDeclExtras$fOutputableIfaceDeclExtras$fMonoidRecompileRequired$fSemigroupRecompileRequired$fEqRecompileRequired pprFamInst pprTyThingLoc pprTyThingHdrpprTyThingInContextpprTyThingInContextLoc pprTyThingpprTypeForUser unifyKind unifyTypenewMethodFromNamedeeplySkolemisetopInstantiatetopInstantiateInferreddeeplyInstantiateinstTyVarsWithinstCallinstCallConstraints instDFunTypeinstStupidThetatcInstInvisibleTyBinderstcInstInvisibleTyBindernewOverloadedLit mkOverLit tcSyntaxNamegetOverlapFlag tcGetInsts newClsInsttcExtendLocalInstEnv InstanceWhatBuiltinInstance LocalInstanceTopLevInstance iw_dfun_id iw_safe_over ClsInstResult NoInstanceOneInstNotSure cir_new_theta cir_mk_evcir_what AssocInstInfo NotAssociated InClsInstai_class ai_tyvars ai_inst_envisNotAssociated safeOverlapmatchGlobalInst$fOutputableInstanceWhat$fOutputableClsInstResultMetaTyVarUpdateResultMTVU_OKMTVU_Bad MTVU_OccursmatchExpectedFunTysmatchActualFunTysmatchActualFunTysPartmatchExpectedListTymatchExpectedTyConAppmatchExpectedAppTy tcSubTypeHR tcSubTypeET tcSubTypeO tcSubType_NC tcSubTypeDStcSubTypeDS_NC_O tcWrapResult tcWrapResultO tcInferNoInst tcInferInst promoteTcType tcSkolemise tcSkolemiseETcheckConstraintscheckTvConstraintsemitResidualTvConstraintbuildImplicationForuTypeswapOverTyVarscanSolveByUnificationmatchExpectedFunKindoccCheckForErrorsmetaTyVarUpdateOK$fMonadMetaTyVarUpdateResult"$fApplicativeMetaTyVarUpdateResult$fFunctorMetaTyVarUpdateResultreportUnsolvedreportAllUnsolvedwarnAllUnsolvedwarnDefaultingsolverDepthErrorTcS$fMonoidReport$fSemigroupReport$fOutputableReport$fOutputableTypeErrorChoice$fOutputableHoleChoice$fOutputableReportErrCtxtMaybeNewFreshCachedTcSDictMap EqualCtList InertCansIC inert_eqs inert_funeqs inert_dicts inert_instsinert_safehask inert_irreds inert_countInertSetIS inert_cans inert_fsksinert_flat_cacheinert_solved_dictsWorkListWLwl_eqs wl_funeqswl_rest wl_implicsappendWorkList workListSizeworkListWantedCountextendWorkListEqextendWorkListFunEqextendWorkListNonEqextendWorkListImplicextendWorkListCtextendWorkListCtsisEmptyWorkList emptyWorkList getWorkListselectNextWorkItem isImprovable foldTyEqs findTyEqslookupInertTyVarlookupFlattenTyVaraddInertForAll addInertCankickOutAfterUnificationaddInertSafehaskinsertSafeOverlapFailureTcSgetSafeOverlapFailures addSolvedDictgetSolvedDictssetSolvedDicts updInertTcS getInertCans setInertCans updInertCans updInertDictsupdInertSafehaskupdInertFunEqsupdInertIrreds getInertEqsgetInertInsolsgetInertGivensgetPendingGivenScsgetUnsolvedInerts isInInertEqs getNoGivenEqsmatchableGivensmightMatchLaterprohibitedSuperClassSolveremoveInertCtslookupFlatCachelookupInertDictlookupSolvedDict foldIrreds emptyDictMapfindDictfindDictsByClassdelDictaddDictaddDictsByClass filterDicts foldDicts findFunEqfindFunEqsByTyCon insertFunEq wrapErrTcS wrapWarnTcSfailTcSwarnTcS addErrTcSpanicTcStraceTcSrunTcPluginTcSgetGlobalRdrEnvTcSbumpStepCountTcS csTraceTcS traceFireTcSrunTcSrunTcSDerivedsrunTcSEqualitiesrunTcSWithEvBinds setEvBindsTcS nestImplicTcSnestTcScheckTvConstraintsTcScheckConstraintsTcS getTcSInerts setTcSInertsupdWorkListTcS emitWorkNCemitWorkgetTcEvBindsVar unifyTyVarreportUnificationsgetDefaultInfo getInstEnvsgetFamInstEnvscheckWellStagedDFunpprEqnewFlattenSkolemextendFlatCache unflattenFmvdemoteUnfilledFmvdischargeFunEq pprKicked newFlexiTcSTy instFlexi instFlexiXisFresh freshGoals getEvExpr setEvBind setWantedEqsetWantedEvTermsetEvBindIfWanted newGivenEvVarnewBoundEvVarIdnewGivenEvVarsemitNewWantedEq newWantedEqnewWantedEvVarNCnewWantedEvVar newWantedNCemitNewDerivedsemitNewDerivedEq newDerivedNCcheckReductionDepthmatchFam matchFamTcM$fOutputableWorkList$fOutputableInertCans$fOutputableInertSet$fHasDynFlagsTcS$fMonadThingsTcS$fHasModuleTcS$fMonadUniqueTcS$fMonadFailTcS $fMonadTcS$fApplicativeTcS $fFunctorTcS tcPluginIO tcPluginTraceisTouchableTcPluginM newDerivednewGiven FlattenMode FM_FlattenAll FM_SubstOnlyflatten flattenKindflattenArgsNomunflattenWanteds$fOutputableFlattenMode$fApplicativeFlatM$fFunctorFlatM $fMonadFlatMStopOrContinue ContinueWith canonicalizesolveCallStackmakeSuperClasses continueWithstopWith unifyDerivedmaybeSym$fOutputableStopOrContinue$fFunctorStopOrContinuesolveSimpleGivenssolveSimpleWanteds$fOutputableInteractResult InferModeApplyMREagerDefaultingNoRestrictionscaptureTopConstraintssimplifyTopImplic simplifyTopsolveLocalEqualitiessolveLocalEqualitiesXsolveEqualities simpl_topsimplifyAmbiguityChecksimplifyInteractivesimplifyDefaulttcCheckSatisfiability tcNormalise simplifyInfergrowThetaTyVarssimplifyWantedsTcMsolveWantedsAndDrop solveWanteds promoteTyVarpromoteTyVarSet approximateWC$fOutputableInferModeHoleFithfIdhfCandhfTypehfRefLvlhfWrap hfMatcheshfDocHoleFitCandidateIdHFCand NameHFCand GreHFCandtcFilterHoleFitswithoutUnification tcSubsumestcCheckHoleFit$fHasOccNameHoleFitCandidate$fOutputableHoleFitCandidate$fOutputableHoleFit $fOrdHoleFit $fEqHoleFit$fEqSortingAlg$fOrdSortingAlg$fEqHoleFitCandidateTermFoldfTermfPrim fSuspension fNewtypeWrapfRefWrapTermPrim Suspension NewtypeWrapRefWraptydcvalsubTermsvalRawctypebound_to wrapped_termtermTypeisFullyEvaluatedTermconstrClosToNamefoldTerm mapTermType termTyCoVarscPprTerm cPprTermBase cvObtainTermcvReconstructTypeimproveRTTIType$fOutputableTermRankcheckValidTypecheckValidMonoType checkTySynRhscheckValidThetaarityErrcheckValidInstHeadvalidDerivPredcheckValidInstancecheckValidCoAxiomcheckValidCoAxBranchcheckValidTyFamEqnbadATErrcheckConsistentFamInstcheckTyConTelescopeallDistinctTyVars$fOutputableRank$fOutputableExpandMode$fOutputableValidityEnv ContextKindTheKindAnyKindOpenKind funsSigCtxt addSigCtxt pprSigCtxt tcHsSigWcType kcHsSigTypetcClassSigType tcHsSigType tcHsDerivtcDerivStrategytcHsClsInstType tcHsTypeApp tcHsOpenTypetcHsLiftedTypetcHsOpenTypeNCtcHsLiftedTypeNCtcCheckLHsType tcLHsTypetcLHsTypeUnsaturated typeLevelMode kindLevelMode tcInferAppscheckExpectedKind_pp tcHsMbContext tcHsContext tcLHsPredTypetcWildCardBinders kcLHsQTyVarsbindImplicitTKBndrs_SkolbindImplicitTKBndrs_TvbindImplicitTKBndrs_Q_SkolbindImplicitTKBndrs_Q_TvbindExplicitTKBndrs_SkolbindExplicitTKBndrs_TvbindExplicitTKBndrs_Q_SkolbindExplicitTKBndrs_Q_TvbindTyClTyVarskcLookupTcTyConzonkAndScopedSortkindGeneralizeetaExpandAlgTyCon badKindSigtcbVisibilitiestcHsPartialSigTypetcHsPatSigTypetcPatSigzonkPromoteType tcLHsKindSigfailIfEmitsConstraints funAppCtxtaddTyConFlavCtxt$fOutputableTcTyMode TcPragEnv tcIdSigName tcSigInfoNamecompleteSigPolyId_maybetcTySigs tcUserTypeSigcompleteSigFromId tcInstSig emptyPragEnv lookupPragEnv extendPragEnv mkPragEnvaddInlinePrags tcSpecPrags tcSpecWrapper tcImpPrags LetBndrSpec LetLclBndr LetGblBndrtcLetPattcPatstcPattcPat_O newLetBndraddDataConStupidTheta badFieldCon polyPatSig$fOutputableLetBndrSpec DerivStuff DerivAuxBind DerivFamInst DerivHsBind BagDerivStuff gen_Eq_binds gen_Ord_bindsgen_Enum_bindsgen_Bounded_binds gen_Ix_bindsgen_Read_bindsgen_Show_bindsgen_Data_bindsgen_Lift_bindsgen_Newtype_bindsmkCoerceClassMethEqn genAuxBinds mkRdrFunBindmkRdrFunBindECmkRdrFunBindSEordOpTbl boxConTbl litConTbl error_Expr$fEqAuxBindSpec FFoldTypeFTft_trivft_var ft_co_varft_funft_tup ft_ty_app ft_bad_app ft_forallgen_Functor_bindsfunctorLikeTraversedeepSubtypesContainingfoldDataConArgsgen_Foldable_bindsgen_Traversable_binds GenericKindGen0Gen1gen_Generic_bindsget_gen1_constrained_tys canDoGenericscanDoGenerics1 ThetaOriginto_anyclass_skolsto_anyclass_metasto_anyclass_givensto_wanted_origins PredOriginOriginativeDerivStatusCanDeriveStockStockClassErrorCanDeriveAnyClassNonDerivableClass DerivContext InferContext SupplyContextDerivSpecMechanismDerivSpecStockDerivSpecNewtypeDerivSpecAnyClass DerivSpecVia DerivSpecDSds_locds_nameds_tvsds_thetads_clsds_tysds_tc ds_overlapds_standalone_wildcard ds_mechanismDerivEnvdenv_overlap_modedenv_tvsdenv_cls denv_cls_tysdenv_tc denv_tc_args denv_rep_tcdenv_rep_tc_args denv_ctxt denv_stratDerivMisStandaloneDerivisStandaloneWildcardDeriv mkDerivOrigin pprDerivSpecderivSpecMechanismToStrategyisDerivSpecStockisDerivSpecNewtypeisDerivSpecAnyClassisDerivSpecVia mkPredOrigin mkThetaOriginmkThetaOriginFromPredssubstPredOriginhasStockDerivingcheckOriginativeSideConditionscanDeriveAnyClassstd_class_via_coerciblenon_coercible_classnewDerivClsInstextendLocalInstEnv$fOutputableDerivSpecMechanism$fOutputableDerivSpec$fOutputableDerivContext$fOutputableDerivEnv$fOutputablePredOrigin$fOutputableThetaOrigininferConstraintssimplifyInstanceContexts tcDefaultsaddTypecheckedBinds tcTopBinds tcHsBootSigsbadBootDeclErr tcLocalBinds tcValBinds tcPolyCheckchooseInferredQuantifiers$fOutputableGeneralisationPlanmkTypeableBinds$fFunctorKindRepM$fApplicativeKindRepM$fMonadKindRepM RolesInfocheckSynCyclescheckClassCycles inferRolesaddTyConsToGblEnvmkDefaultMethodType tcRecSelBinds mkRecSelBindsmkOneRecordSelector$fMonadSynCycleM$fApplicativeSynCycleM$fFunctorSynCycleM $fMonadRoleM$fApplicativeRoleM$fFunctorRoleMfindExtraSigImports'findExtraSigImportsimplicitRequirementsimplicitRequirements' checkUnitIdtcRnCheckUnitIdtcRnMergeSignaturesmergeSignaturestcRnInstantiateSignatureinstantiateSignaturetcPatSynBuilderOcc TcStmtCheckerTcCmdStmtCheckerTcExprStmtChecker TcMatchCtxtMCmc_whatmc_body tcMatchesCase tcMatchLambdatcGRHS tcDoStmtstcBodytcStmtstcStmtsAndThen tcGuardStmttcDoStmtHsSigFun tcClassSigs tcClassDecl2tcClassMinimalDefinstantiateMethod mkHsSigFunfindMethodBind tcMkDeclCtxt tcAddDeclCtxt badMethodErr instDeclCtxt1 instDeclCtxt2 instDeclCtxt3 tcATDefault DerivInfo di_rep_tc di_clausesdi_ctxt mkDerivInfos tcDeriving$fOutputableEarlyDerivSpec tcInstDecls1tcTyAndClassDecls kcConDecltcTyFamInstEqn tcFamTyPatsunravelFamInstPatsaddConsistencyConstraintsdataDeclChecks tcConDeclscheckValidTyContcAddTyFamInstCtxttcMkDataFamInstCtxttcAddDataFamInstCtxtwrongKindOfFamilytcInstDeclsDeriv tcInstDecls2tcProc tcInferRhoNCgetFixedTyVarsaddExprErrCtxttcRulesisForeignImportisForeignExportnormaliseFfiTypetcForeignImportstcForeignImports' tcFImport tcCheckFIType checkCTargettcForeignExportstcForeignExports' tcFExport tcCheckFETypecheckForeignArgscheckForeignResnonIOokmustBeIO checkSafe noCheckSafemkBootModDetailsTcglobaliseAndTidyId tidyProgram $fMonadDFFV$fApplicativeDFFV $fFunctorDFFV RenamedStuff TcRnExprModeTM_Inst TM_NoInst TM_Default tcRnModuletcRnModuleTcRnMcheckHiBootIface' checkBootDecl rnTopSrcDecls tcTopSrcDeclsrunTcInteractivetcRnStmt isGHCiMonadtcRnExprtcRnImportDeclstcRnType tcRnDeclsigetModuleInterfacetcRnLookupRdrNametcRnLookupName tcRnGetInfoloadUnqualIfacesgetRenamedStuffTmStatePmVarEnv canDivergeflattenPmVarEnvinitialTmState solveOneEqexprDeepLookuptmOracle pmLitType checkSinglecheckGuardMatches checkMatches genCaseTmCs2 genCaseTmCs1isAnyPmCheckEnabled$fOutputablePmPat$fOutputableValVec$fMonoidCovered$fSemigroupCovered$fOutputableCovered$fMonoidDiverged$fSemigroupDiverged$fOutputableDiverged$fMonoidProvenance$fSemigroupProvenance$fOutputableProvenance$fMonoidPartialResult$fSemigroupPartialResult$fOutputablePartialResult!$fOutputableInhabitationCandidate $fShowCovered$fShowDiverged$fShowProvenance$fEqProvenance$fOrdProvenance dsGuardeddsGRHSsdsGRHS dsTopLHsBinds dsLHsBindsdsSpec dsMkUserRuledecomposeRuleLhs dsHsWrapper dsTcEvBinds_s dsTcEvBinds dsEvBindsmatchConFamily matchPatSynmatchEquationsmatchSinglePat dsListComp dsMonadComp dsProcExpr dsValBindsdeSugar deSugarExpr mkHieFile$fModifyStateVar$fModifyStateName$fProtectSigGhcPass$fProtectSigGhcPass0 $fHasLocPat$fHasLocHsDataDefn $fHasLocHsArg$fHasLocFamEqn $fHasLoc[]$fHasLocGenLocated$fHasLocHsWildCardBndrs$fHasLocHsImplicitBndrs$fHasLocLHsQTyVars$fHasLocPScoped$fHasLocTScoped$fHasLocShielded$fToHieIEContext$fToHieIEContext0$fToHieIEContext1$fToHieGenLocated$fToHieRScoped$fToHieGenLocated0$fToHieGenLocated1$fToHieAnnProvenance$fToHieGenLocated2$fToHieGenLocated3$fToHieGenLocated4$fToHieForeignExport$fToHieForeignImport$fToHieGenLocated5$fToHieGenLocated6$fToHieGenLocated7$fToHieGenLocated8$fToHiePatSynFieldContext$fToHieGenLocated9$fToHieGenLocated10$fToHieGenLocated11$fToHieGenLocated12$fToHieGenLocated13$fToHieGenLocated14$fToHieGenLocated15$fToHieGenLocated16$fToHiePendingTcSplice$fToHiePendingRnSplice$fToHieHsBracket$fToHieGenLocated17$fToHieArithSeqInfo$fToHieGenLocated18$fToHieGenLocated19$fToHieTScoped$fToHieTVScoped $fToHieHsArg$fToHieTScoped0$fToHieGenLocated20$fToHieSigContext$fToHieTScoped1$fToHieTScoped2$fToHieGenLocated21$fToHieGenLocated22$fToHieGenLocated23$fToHieGenLocated24$fToHieGenLocated25$fToHieGenLocated26$fToHieHsDataDefn$fToHieGenLocated27 $fToHieFamEqn$fToHieTScoped3$fToHieGenLocated28$fToHieRScoped0$fToHieFamilyInfo$fToHieGenLocated29$fToHieGenLocated30$fToHieTyClGroup$fToHieGenLocated31$fToHieGenLocated32$fToHieHsConDetails$fToHieRScoped1$fToHieRFContext$fToHieRFContext0$fToHieRFContext1$fToHieRFContext2$fToHieRContext$fToHieRContext0$fToHieRScoped2$fToHieRScoped3$fToHieRScoped4$fToHieRScoped5$fToHieRScoped6$fToHieGenLocated33$fToHieGenLocated34 $fToHieGRHSs$fToHieHsStmtContext$fToHieHsMatchContext$fToHieGenLocated35$fToHieHsPatSynDir$fToHieGenLocated36$fToHieMatchGroup$fToHieTScoped4$fToHieSigContext0$fToHieTScoped5$fToHieTScoped6$fToHieContext$fToHieContext0$fToHieIEContext2$fToHieTScoped7$fToHieContext1 $fToHieMaybe $fToHieBag $fToHie[]$fToHieTScoped8$fToHieGenLocated37$fToHiePScoped$fToHieBindContext$fHasTypeGenLocated$fHasTypeGenLocated0 $fHasTypePat $fHasTypePat0$fHasTypeGenLocated1$fHasTypeGenLocated2 $fDataPScopedUnVarSet emptyUnVarSet elemUnVarSetisEmptyUnVarSet delUnVarSet mkUnVarSet varEnvDom unionUnVarSetunionUnVarSetsemptyUnVarGraphunionUnVarGraphunionUnVarGraphscompleteBipartiteGraph completeGraph neighbors hasLoopAt$fOutputableUnVarSet$fOutputableGen$fOutputableUnVarGraph $fEqUnVarSetcallArityAnalProgram callArityRHSunarise$fOutputableUnariseValstg2stg$fMonadUniqueStgM $fFunctorStgM$fApplicativeStgM $fMonadStgM $fMonadIOStgM $fEqStgToDo emptyUniqMap isNullUniqMap unitUniqMap listToUniqMaplistToUniqMap_C addToUniqMapaddListToUniqMapaddToUniqMap_CaddToUniqMap_Acc alterUniqMapaddListToUniqMap_C adjustUniqMapdelFromUniqMapdelListFromUniqMap plusUniqMap plusUniqMap_CplusMaybeUniqMap_CplusUniqMapList minusUniqMapintersectUniqMapdisjointUniqMap mapUniqMap filterUniqMappartitionUniqMap sizeUniqMap elemUniqMap lookupUniqMaplookupWithDefaultUniqMap anyUniqMap allUniqMap$fOutputableUniqMap$fMonoidUniqMap$fSemigroupUniqMap $fDataUniqMap $fEqUniqMap$fFunctorUniqMap mkWwBodiesisWorkerSmallEnough mkWorkerArgsmkWWstrdeepSplitProductType_maybe findTypeShape wwTopBindsspecConstrProgram$fOutputableValue$fOutputableHowBound$fOutputableCall$fOutputableArgOcc$fOutputableScUsagedmdAnalProgram$fOutputableAnalEnv core2core simplifyExprCARRYOFLOPARITY NOTPARITY maybeFlipCondmaybeInvertCondEAIndex EAIndexNoneEABase EABaseNone EABaseReg EABaseRip AddrBaseIndexImmAddr addrModeRegs firstfakefirstxmmlastxmmlastinteaxebxecxedxesiediebpespfake0fake1fake2fake3fake4fake5raxrbxrcxrdxrsirdirbprspr8r9r10r13r14r15xmm0xmm1xmm2xmm3xmm4xmm5xmm6xmm7xmm8xmm9xmm10xmm11xmm12xmm13xmm14xmm15ripRelxmm allIntArgRegsinstrClobberedRegstargetVirtualRegSqueezetargetRealRegSqueezetargetClassOfRealRegtargetMkVirtualRegtargetRegDotColortargetClassOfRegJumpDest DestBlockIdDestImmOperandOpRegOpImmOpAddrPrefetchVariantNTALvl0Lvl1Lvl2COMMENTLOCATIONLDATANEWBLOCKUNWINDDELTAMOVCMOVMOVZxLMOVSxLLEAADDADCSUBSBBMULMUL2IMULIMUL2DIVIDIVADD_CCSUB_CCANDORXORNOTNEGIBSWAPSHLSARSHRBTNOPGMOVGLDGSTGLDZGLD1GFTOIGDTOIGITOFGITODGDTOFGADDGDIVGSUBGMULGCMPGABSGNEGGSQRTGSINGCOSGTANGFREECVTSS2SDCVTSD2SS CVTTSS2SIQ CVTTSD2SIQCVTSI2SSCVTSI2SDFDIVSQRTTESTCMPSETCCPUSHPOPJXXJXX_GBLJMP_TBLCALLCLTDFETCHGOTFETCHPCPOPCNTLZCNTTZCNTBSFBSRPDEPPEXTPREFETCHLOCKXADDCMPXCHGMFENCEarchWordFormati386_insert_ffreesallocMoreStackgetJumpDestBlockId canShortcut shortcutJumpshortcutStatics$fOutputableJumpDest$fInstructionInstr pprNatCmmDeclpprData pprFormatpprImm pprDataItempprInstr$fOutputableInstrLDSTUMULSMULUDIVSDIVRDYWRYANDNORNXNORSLLSRLSRASETHIFABSFADDFCMPFMOVFMULFNEGFSQRTFSUBFxTOyBIBFRIRIRegRIImmriZerofpRelEAmoveSpisUnconditionalJump shortBlockId pprBasicBlock checkBlock expandTopRegisterFixedAnyAmode ChildCode64CondCode InstrBlocksetFormatOfRegistergetRegisterRegmangleIndexTreeRegAllocStatsStartRegAllocStatsSpillRegAllocStatsColored raLiveCmmraGraph raSpillCostsraCode raCoalesced raSpillStats raSpilledraGraphColoredraCodeCoalesced raPatched raSpillCleanraFinalraSRMspprStatsSpillspprStatsLifetimespprStatsConflictpprStatsLifeConflict countSRMsaddSRM$fOutputableRegAllocStatsregAllocLDFARLDRLASTFARSTUSTCLISLIMRCMPLBCCBCCFARMTCTRBCTRBLBCTRLADDOADDCADDEADDZEADDISSUBFSUBFOSUBFCSUBFEMULLMULLOMFOVMULHUANDCNANDORISXORISEXTSCNTLZSLSRRLWINMCLRLICLRRIFCTIWZFCTIDZFCFIDFRSPCRNORMFCRMFLRHWSYNCISYNCLWSYNCstackFrameHeaderSizemakeFarBranchesNatM DwarfFiles NatM_Statenatm_us natm_delta natm_importsnatm_pic natm_dflagsnatm_this_module natm_modloc natm_fileidnatm_debug_mapnatm_cfgNcgImpl cmmTopCodeGengenerateJumpTableForInstrncg_x86fp_kludge ncgExpandTopncgAllocMoreStackncgMakeFarBranchesextractUnwindPointsinvertCondBranches mkNatM_StateinitNat mapAccumLNat getUniqueNat getDeltaNat setDeltaNatgetThisModuleNat addImportNat updateCfgNataddNodeBetweenNataddImmediateSuccessorNat getBlockIdNatgetNewLabelNat getNewRegNatgetNewRegPairNatgetPicBaseMaybeNat getPicBaseNat getModLoc getFileId getDebugBlock$fHasDynFlagsNatM$fMonadUniqueNatM $fMonadNatM$fApplicativeNatM $fFunctorNatM getRegister getSomeReg getCondCode condIntCode condFltCodegetAmodeassignMem_I64CodeassignReg_I64Code iselExpr64CmmMakeDynamicReferenceM addImport getThisModule ReferenceKind DataReference CallReference JumpReferencecmmMakeDynamicReferenceneedImportedSymbolspprGotDeclarationpprImportedSymbolinitializePicBase_ppcinitializePicBase_x86$fCmmMakeDynamicReferenceMNatM$fEqReferenceKind sequenceTop$fOutputableBlockChain$fOrdBlockChain$fEqBlockChain$fOutputableWeightedEdge$fOrdWeightedEdge$fNonLocalBlockNode$fEqWeightedEdgeFR frAllocateReg frGetFreeRegsfrInitFreeRegs frReleaseReg $fFRFreeRegs $fFRFreeRegs0 $fFRFreeRegs1 $fFRFreeRegs2 joinToTargetsdW_LANG_HaskelldW_TAG_array_typedW_TAG_lexical_blockdW_TAG_pointer_typedW_TAG_compile_unitdW_TAG_structure_typedW_TAG_typedefdW_TAG_subroutine_typedW_TAG_subrange_typedW_TAG_base_typedW_TAG_file_typedW_TAG_subprogramdW_TAG_variabledW_TAG_auto_variabledW_TAG_arg_variabledW_TAG_ghc_src_note dW_AT_namedW_AT_stmt_list dW_AT_low_pc dW_AT_high_pcdW_AT_languagedW_AT_comp_dirdW_AT_producerdW_AT_externaldW_AT_frame_basedW_AT_use_UTF8dW_AT_MIPS_linkage_namedW_AT_ghc_tick_parentdW_AT_ghc_span_filedW_AT_ghc_span_start_linedW_AT_ghc_span_start_coldW_AT_ghc_span_end_linedW_AT_ghc_span_end_coldW_CHILDREN_nodW_CHILDREN_yes dW_FORM_addr dW_FORM_data2 dW_FORM_data4dW_FORM_string dW_FORM_flagdW_FORM_block1dW_FORM_ref_addr dW_FORM_ref4dW_FORM_flag_presentdW_ATE_addressdW_ATE_boolean dW_ATE_float dW_ATE_signeddW_ATE_signed_chardW_ATE_unsigneddW_ATE_unsigned_chardW_CFA_set_locdW_CFA_undefineddW_CFA_same_valuedW_CFA_def_cfadW_CFA_def_cfa_offsetdW_CFA_def_cfa_expressiondW_CFA_expressiondW_CFA_offset_extended_sfdW_CFA_def_cfa_sfdW_CFA_def_cfa_offset_sfdW_CFA_val_offsetdW_CFA_val_expression dW_CFA_offset dW_OP_addr dW_OP_deref dW_OP_consts dW_OP_minus dW_OP_mul dW_OP_plus dW_OP_lit0 dW_OP_breg0dW_OP_call_frame_cfadwarfInfoSectiondwarfAbbrevSectiondwarfLineSectiondwarfFrameSectiondwarfGhcSectiondwarfARangesSection dwarfSectiondwarfInfoLabeldwarfAbbrevLabeldwarfLineLabeldwarfFrameLabel dwarfRegNodwarfReturnRegNoDwarfFrameBlockdwFdeBlkHasInfo dwFdeUnwindDwarfFrameProc dwFdeProc dwFdeHasInfo dwFdeBlocks DwarfFrame dwCieLabel dwCieInit dwCieProcs DwarfARangedwArngStartLabeldwArngEndLabel DwarfInfoDwarfCompileUnitDwarfSubprogram DwarfBlock DwarfSrcNote dwChildrendwName dwProducer dwCompDir dwLowLabel dwHighLabel dwLineLabeldwLabeldwParentdwMarker dwSrcSpanpprAbbrevDecls pprDwarfInfopprDwarfARanges pprDwarfFrame wordAlignpprBytepprHalf pprData4' pprDwWordpprWord pprLEBWord pprLEBInt sectionOffset$fOutputableDwarfFrameBlock$fEqDwarfAbbrev$fEnumDwarfAbbrevdwarfGen nativeCodeGen x86NcgImpl cmmNativeGen$fHasDynFlagsCmmOptM!$fCmmMakeDynamicReferenceMCmmOptM$fMonadCmmOptM$fApplicativeCmmOptM$fFunctorCmmOptM codeOutputoutputForeignStubsMessager newHscEnv getHscEnv ioMsgMaybehscTcRnLookupRdrNamehscTcRcLookupNamehscTcRnGetInfohscIsGHCiMonadhscGetModuleInterfacehscRnImportDeclshscParse hscParse'hscTypecheckRename tcRnModule' hscDesugar hscDesugar'makeSimpleDetailsgenericHscFrontendhscIncrementalCompile oneShotMsgbatchMsghscFileFrontEnd hscCheckSafe hscGetSafe hscSimplify hscSimplify'hscSimpleIface'hscNormalIface'hscGenHardCodehscInteractivehscCompileCmmFilehscStmthscStmtWithLocation hscParsedStmthscDeclshscParseDeclsWithLocationhscDeclsWithLocationhscParsedDeclshscAddSptEntries hscImport hscTcExpr hscKcType hscParseExprhscParseStmtWithLocationhscParseIdentifierhscCompileCoreExprhscCompileCoreExpr'dumpIfaceStatsshowModuleIndexdefaultRunMetarunMeta' $fQuasiIOEnvGetDocsFailureNameHasNoModule NoDocsInIfaceInteractiveNamegetResumeContextgetHistoryModulegetHistorySpan getModBreaks execOptionsexecStmt execStmt'runDeclsrunDeclsWithLocationrunParsedDeclsparseImportDecl resumeExecbackforwardabandon abandonAll setContextavailsToGlobalRdrEnv getContextmoduleIsInterpretedgetInfogetNamesInScopegetRdrNamesInScope parseNameisStmt hasImportisImportisDeclgetDocsexprType parseExpr compileExprcompileExprRemotecompileParsedExprRemotecompileParsedExprdynCompileExpr showModulemoduleIsBootOrNotObjectLinkableobtainTermFromValobtainTermFromIdreconstructType$fOutputableGetDocsFailure preprocess compileOne compileOne'link linkingNeededoneShot compileFilephaseOutputFilenamegetOutputFilenamerunPhase getLocation linkBinary exeFileNamemaybeCreateManifestwriteInterfaceOnlyModehscPostBackendPhase SummaryNodeIsBootNotBoot LoadHowMuchLoadAllTargetsLoadUpToLoadDependenciesOfdepanalloadload'hscSourceToIsBoottopSortModuleGraphmoduleGraphNodesms_home_srcimps ms_home_impssummariseModule noModErrorcyclicModuleErr $fOrdIsBoot $fEqIsBoot $fShowIsBoot $fReadIsBoot ModuleInfo CoreModule cm_modulecm_typescm_bindscm_safeTypecheckedSource RenamedSource ParsedSourceDesugaredModuledm_typechecked_moduledm_core_moduleTypecheckedModuletm_parsed_moduletm_renamed_sourcetm_typechecked_sourcetm_checked_module_info tm_internals_ ParsedModulepm_mod_summarypm_parsed_sourcepm_extra_src_filespm_annotations coreModuleTypecheckedMod renamedSourcetypecheckedSource moduleInfo ParsedMod parsedSourcedefaultErrorHandlerdefaultCleanupHandlerrunGhcrunGhcTwithCleanupSession initGhcMonadsetSessionDynFlagssetProgramDynFlags setLogActiongetProgramDynFlagssetInteractiveDynFlagsgetInteractiveDynFlagsparseDynamicFlags setTargets getTargets addTarget removeTarget guessTargetworkingDirectoryChanged getModSummary parseModuletypecheckModule desugarModule loadModulecompileToCoreModulecompileToCoreSimplifiedgetModuleGraphisLoaded getBindingsgetInstsgetPrintUnqual getModuleInfomodInfoTyThingsmodInfoTopLevelScopemodInfoExportsmodInfoExportsWithSelectorsmodInfoInstancesmodInfoIsExportedNamemkPrintUnqualifiedForModulemodInfoLookupName modInfoIface modInfoSafemodInfoModBreaks isDictonaryIdlookupGlobalNamefindGlobalAnnsgetGREgetNameToInstancesIndex dataConTypepprParenSymNamegetTokenStreamgetRichTokenStreamaddSourceToTokensshowRichTokenStream findModule lookupModuleisModuleTrustedmoduleTrustReqs setGHCiMonadparser$fParsedModParsedModule$fOutputableCoreModule$fParsedModTypecheckedModule$fParsedModDesugaredModule$fTypecheckedModDesugaredModule!$fTypecheckedModTypecheckedModule$fDesugaredModDesugaredModule doMkDependHSpprintClosureCommandshowTermpprTypeAndContents doBackpack$fGhcMonadIOEnv$fHasDynFlagsIOEnv$fEqSessionType getPaddedIntgetGNUArchEntriesGHC.Real/ putArchEntryfileInfocse_bindCSEnvnoCSE addBinderCmmTypeWidthghc-prim GHC.TypesTrueFalsecvtOpApp cvtOpAppPmk_apps mk_arr_apps cvtOpAppTcvtMaybeKindToFamilyResultSigcvtFamilyResultSigcvtInjectivityAnnotation mkHsForAllTy TyVarBndrLHsType HsForAllTy LHsQTyVars mkHsQualTyCxtHsQualTy LHsContext AllowAnywhereAllowAtTopLevelRejectEverywherelf_check_static_ptrslf_report_unsat_synslintRhs lintCoreExpr withoutAnnots mk_cast_err entryNameentryBS SectionTablesectionTableOffsetsectionEntrySizesectionEntryCountsectionNameIndex ElfHeadergw16gw32gwNwordSize readElfHeaderreadElfSectionTablereadElfSectionByIndexfindSectionFromName readElfNoteBS runGetOrThrowmkMaps subordinates conArgDocs classDecls declTypeDocstypeDocstopDeclsungroupHsDeclsHsGroup sortByLoc collectDocs filterDecls filterClasses isUserSigmkDecls orIfNotFoundhomeSearchCachehsc_FCfindInstalledHomeModulefindPackageModulefindPackageModule_ PackageConfig mkHiePathnoFloatIntoRhs hSetTranslit array-0.5.3.0Data.Array.BaseUArrayGHCiQ initQStateQStateghcCmd THMessagerunTHQIServ ForeignRef RemoteRef checkNode dotNodeEdges colorScan assignColors selectColor SourceError FastString Data.DataMaybeCfoldBlockNodesF3Body'FlatSwitchPlanmaxJumpTableHoleminJumpTableSizeminJumpTableOffset CmmLabelInfo CmmRetInfoCmmRetCmmCode CmmClosure CmmPrimCallRtsSelectorInfoTableRtsApInfoTable RtsApFastClosure InfoTableEntryLocalInfoTable LocalEntry RednCountsConEntry ConInfoTable ClosureTableBytesBlockInfoTable AsmTempLabelAsmTempDerivedLabelIdLabelLocalBlockLabelRtsLabel ForeignLabelDynamicLinkerLabel PicBaseLabelDeadStripPreventer HpcTicksLabelSRTLabelLargeBitmapLabel GHC.MaybeNothing labelTypeshouldTickBindaddTickLHsExprLetBodytickSameFileOnlyrEP_StgEntCounter_allocdrEP_StgEntCounter_allocsrEP_CostCentreStack_scc_countrEP_CostCentreStack_mem_alloc isVecType vecElemType vecLengthcmmVecvec16b8vec8b16vec4b32vec4f32vec2b64vec2f64vec16vec8vec4vec2vecnarrowSnarrowU widthInLogwidthFromBytes widthInBytes widthInBits cIntWidth halfWordMask halfWordWidth wordWidth isFloat64 isFloat32isWord32isWord64 isBitsType isGcPtrType isFloatTypecIntgcWord bHalfWordbWordf64f32b512b256b128b64b32b16b8cmmFloatcmmBits typeWidthcmmEqType_ignoring_ptrhood cmmEqTypeW8W16W32W64W80W128W256W512Length ForeignHintNoHintAddrHint SignedHintQextQext1Qext2Qext1ext2rewrites rewriteLinerewriteSymType rewriteAVX replaceOnce splitLine powersetL powersetLSminClosureSize scopeToPaths scopeUniquesppLlvmFunctionHeader ppLlvmBlocks ppLlvmBlockppLlvmBlockLabelppLlvmStatementppLlvmExpressionppCallnewLine exclamationrootN sortBlocks mkDepBlocks updateFact BlockContext blockContextsBlockEntryLiveness noLiveOnEntry conflicts dont_care copyTicks simplTick makeTrivialmakeTrivialWithInfoDictBind specImportsmkDBCoreSynCoreBindbind_fvsrecWithDumpedDictscheckIsReverseDependentcomputeLivenesspanic livenessBlocklivenessForward livenessBack buildAllocsinkReg makeRAStats LoopMember takeVirtualsspillCost_length nodeDegreeCleanS sJumpValid sJumpValidAcc sReloadedBy sCleanedCountsCleanedSpillsAccCleanMSlot cleanSpincleanBlockForward cleanForward cleanReloadcleanTopBackwardcollateJoinPoints findRegOfSlot initCleanS accJumpValid isStoreReg emptyAssocaddAssocdelAssoc delAssoc1 elemAssoc closeAssocintersectAssoc cleanBackwardSpillSstateUS stateSpillSLSpillM regSpill_topregSpill_blockregSpill_instr spillRead spillWrite spillModify patchInstr initSpillSmakeSpillStatsExitifyM exitifyRecRnEnv2emptyInScopeSetemptyD:R:XRhsClosureCodeGen lf_unarisedcheckNoCurrentCCStransformers-0.5.5.0Control.Monad.Trans.RWS.StrictRWSTOrdListUniqSMIdInfoMayHaveCafRefs removeRhsCCCScafInfolocal mkFreeVarSetCseEnv ce_conAppMapce_subst ce_bndrMap ce_in_scopeinitEnvmkStgLetLitBoundmk_discrete_switchDecls addVarDecladdLabel myCollectArgsApp envVersion envDynFlags envOutputenvUniq envFreshMeta envUniqMeta envFunMap envAliases envUsedVars envVarMap envStackRegs llvmGhcCC modifyEnv saveAlias structStrllvmSectionType llvmSection genStaticLit LlvmAccumEOption exprToVarExprDatabasicBlocksCodeGenbasicBlockCodeGen stmtsToInstrs stmtToInstrs getInstrinct2 getInstrinctbarriergenCallgenCallWithOverflowgenCallExtract getFunPtrW getFunPtr arg_varsWarg_vars castVarsWcastVarscastVarcmmPrimOpFunctionsgenJump genAssigngenStore genStore_fast genStore_slow genBranch genCondBranch genExpectLit genSwitchi1Option wordOption genMachOpgenMachOp_fastgenMachOp_slowgenLoad genLoad_fast genLoad_slow getCmmReg getCmmRegValallocReggenLit funPrologue funEpilogue getTrashStmts getHsFunc mkLocalVardoExpr expandCmmReg blockIdToLlvmmkIntLittoI32 getTBAAMetagetTBAARegMetasingletonPanic inlineSRT wordAlignedmkLivenessBitsemitCallWithExtraStackslowArgsbinderInfoOccursAsArgJusttagSkeletonExpr rhsDmdShellDemandDmdShell closureSizeidClosureFootprinttagSkeletonLettagSkeletonBindingliftRhs generic_gc mkGcLabelSRTMap thisModule dedupSRTsflatSRTsgetLabelledBlocks depAnalSRTsgetCAFs getStaticFuns resolveCAFdoSCConeSRT buildSRTChain updInfoSRTs closeNursery openNursery asUnsignedgenericWordAddCOpgenericWordSubCOpdoPrefetchByteArrayOpdoPrefetchMutableByteArrayOpdoPrefetchAddrOpdoPrefetchValueOpmkBasicPrefetchdoNewByteArrayOpdoCopyByteArrayOpdoCopyMutableByteArrayOpdoCopyByteArrayToAddrOpdoCopyMutableByteArrayToAddrOpdoCopyAddrToByteArrayOpdoSetByteArrayOp doNewArrayOp doCopyArrayOpdoCopyMutableArrayOpemitCloneArrayemitCloneSmallArray emitSetCards doAtomicRMWdoAtomicReadByteArraydoAtomicWriteByteArrayemitMemcpyCallemitMemmoveCallemitMemsetCall emitCopyArrayemitCopySmallArraydoCasByteArrayBCEnvpushConstrAtomisSupportedCConvmkStackOffsetssm_spsm_args sm_ret_offsm_regs fixupStackallocate manifestSpfalseStackCheckelimStackStorescmmDataLlvmGens fixBottom cmmLlvmGencmmMetaLlvmPreludecmmUsedLlvmGensCostCentreStateTcMlabelledTraceOptTcRnDumpFlagdumpSDoc add_warn_atIfGTcRnIfGblEnvTcGblEnvControl.Monad.FixMonadFixmfixControl.Monad.IO.ClassMonadIO GHC.IORefIORef getRoleAnnotslookupRoleAnnotemptyRoleAnnotEnvmkRoleAnnotEnv runTcPluginM pprCtOriginpprCtLoc grhssCtOriginmatchesCtOrigin exprCtOrigin lexprCtOrigintoInvisibleOriginisVisibleOrigin isKindLevel isTypeLevelpprSigSkolInfo pprSkolInfopushErrCtxtSameOrigin pushErrCtxt setCtLocEnvupdateCtLocOriginsetCtLocOriginbumpCtLocDepth setCtLocSpanctLocTypeOrKind_maybe ctLocSpan ctLocOrigin ctLocDepth ctLocLevelctLocEnv mkGivenLoc toKindLoc mkKindLocsubGoalDepthExceededmaxSubGoalDepthbumpSubGoalDepthinitialSubGoalDeptheqCanDischargeFRfunEqCanDischargeFfunEqCanDischargeeqMayRewriteFReqCanRewriteFR eqCanRewrite ctFlavourRolectEvFlavourRole ctEvFlavourisGivenOrWDeriv isDerivedisGivenisWantedctEvEvId ctEvCoercionctEvExprctEvTermctEvRole ctEvEqRel ctEvOriginctEvLocctEvPredwrapTypewrapTypeWithImplicationpprEvVarWithType pprEvVarTheta pprEvVarsimplicDynFlags implicLclEnvimplicationPrototypenewImplication insolubleEqCt insolubleCt insolubleWCinsolubleImplicisInsolubleStatusisSolvedStatusinsolublesOnly addInsols addImplics addSimplesunionsWCandWC isSolvedWC isEmptyWC mkImplicWC mkSimpleWCemptyWCpprCts isEmptyCtsemptyCts andManyCts extendCtsListsnocCtsconsCtsctsElts listToCtsandCtssingleCtgetPendingWantedScssuperClassesMightHelpisPendingScInstisPendingScDictisUserTypeErrorCtgetUserTypeErrorMsg isTypeHoleCt isExprHoleCtisOutOfScopeCtisHoleCtisCNonCanonical isCFunEqCanisCFunEqCan_maybeisCDictCan_Maybe isCTyEqCan isDerivedCt isGivenCt isWantedCt isGivenLocarisesFromGivens isDroppableCtdropDerivedSimples dropDerivedWCtyCoVarsOfWCListtyCoVarsOfCtsListtyCoVarsOfCtListctEqRel ctFlavourmkTcEqPredLikeEvctEvIdctPredctOriginsetCtLocctLoc ctEvidencemkGivens mkInsolubleCt mkIrredCtmkNonCanonicalCtmkNonCanonicalholeOccplusImportAvailsemptyImportAvails modDepsElts mkModDeps pprPECategorypprTcTyThingCategory outerLevelimpLeveltopSpliceStage topAnnStagetopStageremoveBindingShadowingtcVisibleOrphanModsTcRnIfIfMIfLRnMenv_topenv_usenv_gblenv_lclif_doc if_rec_typesIfLclEnvif_modif_bootif_loc if_nsubstif_implicits_env if_tv_env if_id_envDsGblEnvds_modds_fam_inst_env ds_unqualds_msgs ds_if_envds_complete_matchesds_cc_stDsLclEnvdsl_metadsl_loc dsl_dicts dsl_tm_cs dsl_pm_iterFrontendResultFrontendTypechecktcg_type_env_vartcg_modtcg_semantic_modtcg_src tcg_rdr_env tcg_default tcg_fix_env tcg_field_env tcg_type_env tcg_inst_envtcg_fam_inst_env tcg_ann_env tcg_exports tcg_importstcg_dus tcg_used_grestcg_keep tcg_th_usedtcg_th_splice_usedtcg_th_top_level_locs tcg_dfun_n tcg_mergedtcg_rn_exportstcg_rn_imports tcg_rn_declstcg_dependent_filestcg_th_topdeclstcg_th_foreign_filestcg_th_topnamestcg_th_modfinalizerstcg_th_coreplugins tcg_th_statetcg_th_remote_state tcg_ev_binds tcg_tr_module tcg_bindstcg_sigs tcg_imp_specs tcg_warnstcg_annstcg_tcs tcg_insts tcg_fam_insts tcg_rules tcg_fords tcg_patsyns tcg_doc_hdrtcg_hpc tcg_self_boottcg_main tcg_safeInfertcg_tc_plugins tcg_top_loc tcg_static_wctcg_complete_matches tcg_cc_st RecFieldEnv SelfBootInfo NoSelfBootSelfBootsb_mdssb_tcsErrCtxt TcTypeEnvTcRef TcBinderStackTcBinderTcIdBndrTcIdBndr_ExpTypeTcTvBndr SpliceTypeTypedUntypedThStageSplice RunSpliceCompBrack PendingStuffRnPendingUntypedRnPendingTyped TcPendingThLevel ArrowCtxt NoArrowCtxt PromotionErrTyConPEClassPE FamDataConPEConstrainedDataConPEPatSynPE RecDataConPE NoDataKindsTC NoDataKindsDC IdBindingInfo NotLetBound ClosedLet NonClosedLet IsGroupClosedRhsNames ClosedTypeId ImportAvails imp_dep_modsimp_mods imp_dep_pkgsimp_trust_pkgsimp_trust_own_pkg imp_orphs imp_finsts WhereFrom ImportByUserImportBySystemImportByPluginTISI sig_inst_sigsig_inst_skolssig_inst_theta sig_inst_tau sig_inst_wcs sig_inst_wcxXiCtsCtCDictCan CIrredCanCTyEqCan CFunEqCan CNonCanonicalCHoleCan CQuantCancc_evcc_class cc_tyargs cc_pend_sccc_insolcc_tyvarcc_rhs cc_eq_relcc_funcc_fskcc_holeHoleExprHoleTypeHoleWantedConstraintsWC wc_simplewc_impl ImplicationImplicic_tclvlic_skolsic_info ic_telescopeic_given ic_no_eqsic_env ic_wantedic_binds ic_need_inner ic_need_outer ic_status ImplicStatus IC_Solved IC_InsolubleIC_BadTelescope IC_Unsolvedics_deadTcEvDest EvVarDestHoleDest CtEvidenceCtGivenCtWanted CtDerived ctev_pred ctev_evarctev_loc ctev_dest ctev_nosh CtFlavourGivenWantedDerived ShadowInfoWDerivWOnly CtFlavourRole SubGoalDepthCtLoc ctl_originctl_env ctl_t_or_k ctl_depth SkolemInfoSigSkol SigTypeSkol ForAllSkol DerivSkolInstSkolInstSC FamInstSkolPatSkol ArrowSkolIPSkolRuleSkol InferSkol BracketSkolUnifyForAllSkol TyConSkol DataConSkol ReifySkol QuantCtxtSkolUnkSkolCtOrigin GivenOrigin OccurrenceOfOccurrenceOfRecSel AppOriginSpecPragOrigin TypeEqOrigin KindEqOrigin IPOccOriginOverLabelOrigin LiteralOrigin NegateOriginArithSeqOriginAssocFamPatOrigin SectionOrigin TupleOrigin ExprSigOrigin PatSigOrigin PatOriginProvCtxtOriginRecordUpdOrigin ViewPatOriginScOriginDerivClauseOrigin DerivOriginDCDerivOriginCoerceStandAloneDerivOrigin DefaultOriginDoOrigin DoPatOrigin MCompOriginMCompPatOriginIfOrigin ProcOrigin AnnOrigin FunDepOrigin1 FunDepOrigin2 HoleOriginUnboundOccurrenceOf ListOrigin StaticOriginFailablePatternShouldn'tHappenOriginInstProvidedOrigin uo_actual uo_expecteduo_thing uo_visible TypeOrKind TypeLevel KindLevelTcPluginSolverTcPlugin tcPluginInit tcPluginSolve tcPluginStopTcPluginResultTcPluginContradiction TcPluginOk RoleAnnotEnvextendCompleteMatchMapmkCompleteMatchMap CompleteMatchcompleteMatchConLikescompleteMatchTyConCompleteMatchMapIOEnvupdEnvsetEnvatomicUpdMutVar'atomicUpdMutVar updMutVar readMutVar writeMutVar newMutVaruninterruptibleMaskM_unsafeInterleaveMtryMostMtryAllMtryMfixMrunIOEnv failWithMfailM IOEnvFailureTcLclEnvtcl_loctcl_ctxt tcl_tclvl tcl_th_ctxt tcl_th_bndrstcl_arrow_ctxttcl_rdrtcl_env tcl_bndrs tcl_tyvarstcl_lietcl_errs filterOutMunlessMwhenM maybeMapMfoldlM_orMallManyM fmapEitherM fmapMaybeM mapMaybeM concatMapMmapSndM mapAccumLM mapAndUnzip5M mapAndUnzip4M mapAndUnzip3MzipWithAndUnzipM zipWith4M zipWith3M_ zipWith3MliftIO4liftIO3liftIO2liftIO1GHC.ForeignSrcLang.TypeForeignSrcLangLangCLangCxxLangObjc LangObjcxxLangAsm RawObjectzonkTcTypeMapperimportSuggestions ShNameSubstAvail AvailInfo ns_module substNamesubstNameAvailInfo availName availNamessetNameFieldSelector mergeAvails uAvailInfos uAvailInfouName uHoleNameShIfEnvShIfM initRnIface rnIfaceGlobalrnIfaceNeverExportedrnIfaceClsInstIfaceSyn IfaceClsInst TyConRepNameminuslogExactdivide rootExactgenRootgenLogknownKeyNamesOkaycgTickinfoConvwithSourceNoteHappyStkBinaryUserDatainitBinMemSizeMaybesMaybeErrloadInterfaceWithExceptionis_external_sigcomputeInterfacemoduleFreeHolesisAbstractIfaceDecl IfaceDeclmergeIfaceDeclmergeIfaceDeclsmi_semantic_module tc_iface_declIOmkDsEnvsFromTcGblModGutsTidyEnvextendIdZonkEnvRecHsPatPatHsExprHsLitOverLitwarnAboutOverflowedLiteralsgetLHsIntegralLitIntegralgetIntegralLitgetSimpleIntegralLitrepFamilyResultSigrepFamilyResultSigToMaybeKindrepInjectivityAnn repTyVarBndr repMaybeLTy coreNothing coreNothing'coreJust coreJust'warnRedundantRecordWildcardwarnUnusedRecordWildcard reportable Debug.TracetracesortWith mkNoRepType Data.VersionVersion versionBranch versionTagsGHC.Listfoldl1'GHC.Stack.Types HasCallStackRulesruleCheckProgram lookupRule pprRuleBase unionRuleBaseextendRuleBaseList mkRuleBase emptyRuleBasegetRules rulesOfBindsaddIdSpecialisations addRuleInfoextendRuleInfo mkRuleInfopprRulesForUser roughTopNamesmkRuleMkCoremkAbsentErrorAppaBSENT_ERROR_IDaBSENT_SUM_FIELD_ERROR_ID tYPE_ERROR_IDnON_EXHAUSTIVE_GUARDS_ERROR_IDnO_METHOD_BINDING_ERROR_ID pAT_ERROR_IDrEC_CON_ERROR_IDrUNTIME_ERROR_IDrEC_SEL_ERROR_IDerrorIdsmkImpossibleExprmkRuntimeErrorApp mkJustExpr mkNothingExpr mkBuildExpr mkFoldrExpr mkListExpr mkConsExpr mkNilExpr floatBindings wrapFloatmkSmallTupleCase mkTupleCasemkSmallTupleSelectormkTupleSelector1mkTupleSelectorunitExprmkBigCoreTupTy mkBigCoreTupmkBigCoreVarTupTymkBigCoreVarTup1mkBigCoreVarTupmkCoreTupBoxity mkCoreUbxTup mkCoreTupmkCoreVarTupTy mkCoreVarTupmkStringExprFSWithmkStringExprFS mkStringExpr mkCharExpr mkDoubleExpr mkFloatExpr mkNaturalExpr mkIntegerExprmkWordExprWord mkWordExpr mkIntExprInt mkCoreLamscastBottomExpr mkIfThenElse mkWildCasemkWildValBindermkWildEvBinder mkCoreConApps mkCoreApps mkCoreApp mkCoreLets mkCoreLet sortQuantVars FloatBindFloatLet FloatCase CoreUtils isJoinBindcollectMakeStaticArgs isEmptyTy rhsIsStatic tryEtaReduce diffBindsdiffExpreqExpr exprIsBig cheapEqExpr' cheapEqExprdataConRepFSInstPatdataConRepInstPatexprIsTickedString_maybeexprIsTickedStringexprIsTopLevelBindable exprIsConLike exprIsHNFaltsAreExhaustiveexprOkForSideEffectsexprOkForSpeculationisExpandableApp isCheapAppexprIsExpandable exprIsCheapX exprIsCheapexprIsWorkFree exprIsDupable exprIsBottomgetIdFromTrivialExpr_maybegetIdFromTrivialExpr exprIsTrivialcombineIdenticalAltsrefineDefaultAlt filterAlts trimConArgs mergeAltsfindAlt isDefaultAlt addDefault findDefault mkAltExprneedsCaseBinding bindNonRec stripTicksT stripTicksEstripTicksTopTstripTicksTopE stripTicksTop tickHNFArgs mkTickNoHNFmkTicksmkTickmkCastapplyTypeToArgs isExprLevPoly coreAltsType coreAltType CheapAppFun dumpIfSet_dyn debugTraceMsgdebugTraceMsgS fatalErrorMsgfatalErrorMsgSwarnMsgerrorMsg errorMsgSputMsgputMsgSgetFirstAnnotationsgetAnnotationsgetPackageFamInstEnvgetOrigNameCache addSimplCountgetVisibleOrphanMods getRuleBaseliftIOWithCountrunCoreM doSimplTickdoFreeSimplTickhasDetailedCounts simplCountN bindsOnlyPassrunMayberunWhenpprPassDetails SimplModesm_namessm_phase sm_dflagssm_rules sm_inline sm_case_case sm_eta_expandFloatOutSwitchesfloatOutLambdasfloatOutConstantsfloatOutOverSatAppsfloatToTopLevelOnlyCorePluginPassTickPreInlineUnconditionallyPostInlineUnconditionally UnfoldingDone RuleFiredLetFloatFromLet EtaExpansion EtaReduction BetaReduction CaseOfCase KnownBranch CaseMergeAltMergeCaseElim CaseIdentityFillInCaseDefaultSimplifierDonePluginsdefaultFrontendPlugin withPlugins_ mapPlugins withPluginspluginskeepRenamedSource defaultPlugin flagRecompile impurePlugin purePluginpluginRecompile' lpModuleNameCommandLineOptionPluginWithArgspaPlugin paArgumentsPluginRecompileForceRecompileNoForceRecompileMaybeRecompile CorePluginFrontendPluginActionFrontendPluginfrontendbyteCodeOfObject nameOfObjectisInterpretableisObject linkableObjsisObjectLinkablenumToTrustInfotrustInfoToNumnoIfaceTrustInfo setSafeMode getSafeMode isHpcUsed emptyHpcInfo showModMsg isBootSummary msObjFilePath msHiFilePath msHsFilePathms_impsms_installed_modextendMGisTemplateHaskellOrQQNonBoot mgElemModule mgBootModulessoExt mkHsSONamemkSOName updNameCache addEpsInStatsnoDependencies lookupFixityemptyFixityEnvmkIfaceFixCache plusWarnsemptyIfaceWarnCachemkIfaceWarnCache tyThingIdtyThingConLiketyThingDataContyThingCoAxiom tyThingTyConlookupTypeHscEnv lookupType plusTypeEnvextendTypeEnvWithIdsextendTypeEnvList extendTypeEnv lookupTypeEnvtypeEnvFromEntitiesmkTypeEnvWithImplicits mkTypeEnvtypeEnvClassestypeEnvDataConstypeEnvPatSyns typeEnvIdstypeEnvCoAxioms typeEnvTyCons typeEnvElts emptyTypeEnvtyThingAvailInfotyThingsTyCoVarstyThingParent_maybeisImplicitTyThingimplicitTyConThingsimplicitClassThingsimplicitTyThingspkgQual mkQualPackage mkQualModulemkPrintUnqualifiedsubstInteractiveContexticExtendGblRdrEnvsetInteractivePrintNamesetInteractivePackageextendInteractiveContextWithIdsextendInteractiveContext icPrintUnqual icInScopeTTsicInteractiveModuleemptyInteractiveContext appendStubCimportedByUseremptyModDetailsmkIfaceHashCache emptyModIfacerenameFreeHoles mi_free_holesmi_fixmi_bootprepareAnnotations metaRequestAW metaRequestD metaRequestT metaRequestP metaRequestEhptRules hptInstanceshptCompleteSigslookupIfaceByModulelookupHptByModule listToHpt addListToHptaddToHpt delFromHptmapHptallHpt filterHpteltsHptlookupHptDirectly lookupHptpprHPTemptyPackageIfaceTableemptyHomePackageTable pprTargetId pprTargethscEPShandleFlagWarningsprintOrThrowWarnings throwOneError throwErrorsmkApiErrsrcErrorMessagesmkSrcErrrunInteractiveHscmkInteractiveHscEnvrunHscHsc GhcApiError hsc_dflags hsc_targets hsc_mod_graphhsc_IChsc_HPThsc_EPShsc_NChsc_type_env_var hsc_iserv iservPipe iservProcessiservLookupSymbolCacheiservPendingFreesHomePackageTablePackageIfaceTable HomeModInfohm_iface hm_details hm_linkable MetaRequestMetaEMetaPMetaTMetaDMetaAW MetaResultMetaHook FinderCacheInstalledFindResultInstalledFoundInstalledNoPackageInstalledNotFound IfaceExport ModDetails md_exportsmd_typesmd_insts md_fam_instsmd_rulesmd_annsmd_complete_sigs ImportedMods ImportedByImportedByUserImportedBySystemImportedModsValimv_nameimv_span imv_is_safe imv_is_hidingimv_all_exports imv_qualified mg_module mg_hsc_srcmg_loc mg_exportsmg_deps mg_usages mg_used_th mg_rdr_env mg_fix_envmg_tcsmg_insts mg_fam_insts mg_patsynsmg_rulesmg_binds mg_foreignmg_foreign_filesmg_warnsmg_annsmg_complete_sigs mg_hpc_info mg_modBreaks mg_inst_envmg_fam_inst_envmg_safe_haskell mg_trust_pkg mg_doc_hdr mg_decl_docs mg_arg_docsCgGuts cg_module cg_tyconscg_binds cg_foreigncg_foreign_files cg_dep_pkgs cg_hpc_info cg_modBreakscg_spt_entries ForeignStubsNoStubsSptEntryInteractiveContext ic_dflags ic_mod_index ic_imports ic_tythings ic_rn_gbl_env ic_instances ic_fix_env ic_default ic_resumeic_monad ic_int_printic_cwdTypeEnv MonadThings lookupThinglookupId lookupDataCon lookupTyConWarnings NoWarningsWarnAllWarnSome FixityEnvFixItemWhetherHasOrphansIsBootInterface DependenciesDepsdep_modsdep_pkgs dep_orphs dep_finsts dep_plginsUsageUsagePackageModuleUsageHomeModule UsageFileUsageMergedRequirementusg_mod usg_mod_hashusg_safe usg_mod_name usg_entities usg_exports usg_file_path usg_file_hashPackageTypeEnvPackageRuleBasePackageInstEnvPackageFamInstEnvPackageCompleteMatchMapExternalPackageStateEPS eps_is_booteps_PITeps_free_holeseps_PTE eps_inst_enveps_fam_inst_env eps_rule_base eps_ann_enveps_complete_matcheseps_mod_fam_inst_env eps_statsEpsStats n_ifaces_in n_decls_in n_decls_out n_rules_in n_rules_out n_insts_in n_insts_outSourceModifiedSourceUnmodifiedSourceUnmodifiedAndStableHpcInfo NoHpcInfohpcInfoTickCount hpcInfoHashhpcUsed AnyHpcUsage IsSafeImportIfaceTrustInfoHsParsedModule hpm_module hpm_src_fileshpm_annotationsLinkableLM linkableTimelinkableModulelinkableUnlinkedUnlinkedDotODotADotDLLBCOsCoreFVsfreeVars freeVarsBindstableUnfoldingVarsidUnfoldingVars idRuleVarsbndrRuleAndUnfoldingVarsDSetidFVs dIdFreeVars idFreeVarsvarTypeTyCoFVsvarTypeTyCoVars freeVarsOfAnn freeVarsOfruleLhsFreeIdsListruleLhsFreeIds rulesFreeVars idRuleRhsVarsrulesFreeVarsDSet ruleFreeVarsruleRhsFreeVarsorphNamesOfFamInstorphNamesOfAxiomorphNamesOfCoCon orphNamesOfCoorphNamesOfTypesorphNamesOfTypeexprsOrphNamesexpr_fvsexprsSomeFreeVarsListexprsSomeFreeVarsexprSomeFreeVarsListexprSomeFreeVars bindFreeVarsexprsFreeVarsList exprsFreeVarsexprsFreeIdsListexprsFreeIdsDSetexprFreeIdsListexprFreeIdsDSet exprFreeIdsexprFreeVarsListexprFreeVarsDSet exprFreeVarsFVAnnCoreBindWithFVsCoreExprWithFVsCoreExprWithFVs'CoreAltWithFVsemptyModBreaksCompiledByteCodepromotedNilDataConpromotedConsDataConpromotedGTDataConpromotedEQDataConpromotedLTDataConpromotedJustDataConpromotedNothingDataConpromotedFalseDataConpromotedTrueDataConmkSumTy mkTupleTy justDataConnothingDataCon maybeTyCon consDataCon nilDataConmkListTyordGTDataConIdordEQDataConIdordLTDataConId ordGTDataCon ordEQDataCon ordLTDataCon orderingTyCon trueDataConIdfalseDataConId trueDataCon falseDataCon boolTyConboolTy doubleDataCon doubleTyCondoubleTy floatDataCon floatTyConfloatTy word8DataCon word8TyConword8Ty wordDataCon wordTyConwordTy intDataConintTyConintTystringTy charDataCon charTyConcharTyboxingDataCon_maybe liftedRepTyliftedRepDataConsumRepDataConTyConliftedTypeKindTyConcoercibleDataConcoercibleClass heqDataConheqClass eqDataConeqClasseqTyConunboxedSumKind sumDataConsumTyConunboxedUnitDataConunboxedUnitTyCon pairTyCon unitDataConId unitDataCon unitTyConKey unitTyCon tupleDataConpromotedTupleDataContupleTyConName tupleTyConcTupleDataConNamescTupleDataConNamecTupleTyConNameArity_maybeisCTupleTyConNamecTupleTyConNamescTupleTyConNameisBuiltInOcc_maybeconstraintKindTyContypeSymbolKindContypeNatKindConconsDataCon_RDR listTyCon_RDRintDataCon_RDR charTyCon_RDR intTyCon_RDRtrue_RDR false_RDR boolTyCon_RDRliftedTypeKindTyConNamemakeRecoveryTyConanyTyanyTyCondoubleTyConNamefloatTyConNameword8TyConName wordTyConNamejustDataConNamenothingDataConNamemaybeTyConNameconsDataConNamenilDataConName listTyConName boolTyConName intTyConName charTyConNamecoercibleTyConName heqTyConName eqTyCon_RDR eqTyConNamemkWiredInIdNamemkWiredInTyConName wiredInTyConsisNeverLevPolyIdInfosetLevityInfoWithTypesetNeverLevPolyzapCallArityInfozapTailCallInfo zapUnfoldingzapFragileInfozapUsedOnceInfozapUsageEnvInfo zapUsageInfo zapDemandInfo zapLamInfo ppCafInfomayHaveCafRefssetRuleInfoHead ruleInfoRulesruleInfoFreeVarsisEmptyRuleInfo emptyRuleInfo pprStrictness ppArityInfo unknownArity noCafIdInfosetStrictnessInfo setDemandInfosetOneShotInfo setCafInfosetCallArityInfo setArityInfosetUnfoldingInfo setOccInfosetInlinePragInfo setRuleInfoisJoinIdDetails_maybe RecSelParent RecSelData RecSelPatSyn ArityInfoInlinePragInfoRuleInfoCafInfo NoCafRefs TickBoxId TickBoxOpTickBox LevityInfocollectNAnnBndrscollectAnnBndrs deAnnBinddeAnnAlt deAnnotate' deAnnotatecollectAnnArgsTickscollectAnnArgs valArgCount valBndrCount isTypeArgisCoArg isTyCoArgisValArg isRuntimeArg isRuntimeVarcollectArgsTicks stripNArgs collectArgscollectNBinderscollectTyAndValBinderscollectTyBinderscollectBinders flattenBinds rhssOfAlts rhssOfBindbindersOfBinds bindersOfexprToCoercion_maybe exprToTypeapplyTypeToArgvarsToCoreExprs varToCoreExprmkCoBindmkTyBindmkLetRec mkLetNonRecmkLetmkLetsmkLamsmkDoubleLitDouble mkDoubleLitmkFloatLitFloat mkFloatLit mkStringLit mkCharLitmkInt64LitInt64mkWord64LitWord64 mkWordLitWord mkWordLit mkIntLitIntmkTyArg mkConApp2mkTyAppsmkConApp mkVarAppsmkCoAppsmkApps deTagExpr cmpAltConltAltcmpAlt canUnfoldisFragileUnfoldingneverUnfoldGuidanceisBootUnfoldinghasSomeUnfoldingisStableUnfoldingisCompulsoryUnfoldingexpandUnfolding_maybeisExpandableUnfoldingisCheapUnfoldingisConLikeUnfoldingisEvaldUnfoldingisValueUnfolding otherConsmaybeUnfoldingTemplateunfoldingTemplateisStableSource mkOtherCon bootUnfoldingevaldUnfolding noUnfoldingboringCxtNotOk boringCxtOk unSaturatedOk needSaturated setRuleIdName isLocalRule ruleIdNameruleActivation ruleModuleruleName ruleArity isAutoRule isBuiltinRule emptyRuleEnv mkRuleEnvchooseOrphanAnchor notOrphanisOrphantickishContains tickishPlace tickishIsCode mkNoScope mkNoCounttickishCanSplittickishFloatabletickishScopesLike tickishScoped tickishCountsLitLamLetCaseArgAltAltConDataAltLitAltDEFAULTBindNonRecRecInBndrInTypeInKindInBindInExprInAltInArg InCoercionOutBndrOutTypeOutKind OutCoercionOutBindOutExprOutAltOutArg MOutCoercionTickishProfNoteHpcTick Breakpoint SourceNote profNoteCC profNoteCount profNoteScope tickModuletickId breakpointId breakpointFVs sourceSpan sourceNameTickishScoping SoftScopeCostCentreScopeTickishPlacement PlaceRuntime PlaceNonLamPlaceCostCentreIsOrphan NotOrphanRuleBaseRuleEnvre_basere_visible_orphsCoreRuleRule BuiltinRuleru_nameru_actru_fnru_roughru_bndrsru_argsru_rhsru_auto ru_origin ru_orphanru_localru_nargsru_tryRuleFun InScopeEnvIdUnfoldingFun Unfolding NoUnfolding BootUnfoldingOtherCon DFunUnfolding CoreUnfoldingdf_bndrsdf_condf_argsuf_tmpluf_src uf_is_top uf_is_value uf_is_conlikeuf_is_work_free uf_expandable uf_guidanceUnfoldingSource InlineRhs InlineStableInlineCompulsoryUnfoldingGuidanceUnfWhen UnfIfGoodArgsUnfNeverug_arity ug_unsat_ok ug_boring_okug_argsug_sizeug_res CoreProgramCoreBndrCoreExprCoreArgCoreAlt TaggedBndrTB TaggedBind TaggedExpr TaggedArg TaggedAltAnnExprAnnExpr'AnnVarAnnLitAnnAppAnnCastAnnTick AnnCoercionAnnAltAnnBind AnnNonRec buildSynTyCon buildAlgTyConsplitDataProductType_maybepromoteDataCondataConUserTyVarsArePermuteddataConCannotMatch classDataConspecialPromotedDcisUnboxedTupleConisTupleDataCondataConIdentitydataConRepArgTysdataConOrigArgTysdataConInstArgTysdataConOrigResTydataConInstSig dataConBoxerdataConImplBangsdataConRepStrictnessisNullaryRepDataConisNullarySrcDataCondataConRepAritydataConFieldType_maybedataConFieldTypedataConImplicitTyThings dataConWrapIddataConWrapId_maybe dataConWorkId dataConTheta dataConEqSpecdataConUnivAndExTyCoVarsdataConUnivTyVarsdataConRepTypedataConOrigTyCon dataConTagZ dataConTag mkDataCon isSrcUnpacked isSrcStrictisBangedeqHsBang filterEqSpec substEqSpec eqSpecPreds eqSpecPair eqSpecType eqSpecTyVarmkEqSpec HsSrcBang HsImplBangHsLazyHsStrictHsUnpack SrcStrictnessSrcLazy SrcStrict NoSrcStrictSrcUnpackedness SrcUnpack SrcNoUnpack NoSrcUnpackLiteral pprLiteralabsentLiteralOf literalType litIsLifted litFitsInChar litIsDupable litIsTrivial rubbishLit nullAddrLitdouble2FloatLitfloat2DoubleLit int2DoubleLit double2IntLit int2FloatLit float2IntLit int2CharLit char2IntLitnarrow32WordLitnarrow16WordLitnarrow8WordLitnarrow32IntLitnarrow16IntLit narrow8IntLit narrowLit int2WordLit word2IntLit isLitValue mapLitValueisLitValue_maybelitValue isZeroLit inCharRange inWordRange inIntRange mkLitNatural mkLitInteger mkLitString mkLitChar mkLitDouble mkLitFloatmkLitWord64Wrap mkLitWord64mkLitInt64Wrap mkLitInt64mkLitWordWrapC mkLitWordWrap mkLitWord mkLitIntWrapC mkLitIntWrapmkLitInt mkLitNumberlitNumCheckRangemkLitNumberWraplitNumIsSignedLitChar LitNumber LitString LitNullAddr LitRubbishLitFloat LitDoubleLitLabel LitNumType LitNumInteger LitNumNatural LitNumInt LitNumInt64 LitNumWord LitNumWord64FVInterestingVarFun tyConSkolem checkRecTcsetRecTcMaxBounddefaultRecTcMaxBound initRecTcpprPromotionQuotetcFlavourIsOpen tyConFlavour mkTyConTagMaptyConRuntimeRepInfotyConFamilyCoercion_maybetyConFamInst_maybetyConFamInstSig_maybeisFamInstTyContyConATsfamTyConFlav_maybetyConStupidThetanewTyConDataCon_maybe newTyConConewTyConCo_maybenewTyConEtadRhsnewTyConEtadArity newTyConRhs tyConRolestyConFamilyResVar_maybe algTyConRhstyConFamilySizetyConSingleAlgDataCon_maybetyConSingleDataContyConSingleDataCon_maybetyConDataCons_maybeisTyConWithSrcDataConsexpandSynTyCon_maybe isTcLevPolysetTcTyConKind isTcTyContyConCType_maybeisImplicitTyConisLiftedTypeKindTyConName isKindTyConisPromotedDataCon_maybeisPromotedDataConisPromotedTupleTyConisUnboxedSumTyConisBoxedTupleTyContyConTuple_maybetyConFlavourAssoc_maybetyConAssoc_maybe isTyConAssocisBuiltInSynFamTyCon_maybetyConInjectivityInfo%isClosedSynFamilyTyConWithAxiom_maybeisDataFamilyTyConisEnumerationTyConisGadtSyntaxTyConmustBeSaturatedisFamFreeTyCon isTauTyConisDataSumTyCon_maybeisDataProductTyCon_maybeisProductTyConunwrapNewTyConEtad_maybeunwrapNewTyCon_maybeisGenInjAlgRhsisGenerativeTyConisInjectiveTyCon isDataTyConisVanillaAlgTyCon isAlgTyConisUnliftedTyConisAbstractTyConmkPromotedDataCon mkFamilyTyConmkSynonymTyConmkLiftedPrimTyCon mkKindTyCon mkPrimTyCon mkTcTyCon mkSumTyCon mkTupleTyCon mkClassTyCon mkAlgTyCon mkFunTyConlookupTyConFieldLabeltyConFieldLabelsprimRepIsFloatprimElemRepSizeB primRepSizeBtyConRepModOccmkPrelTyConRepNametyConRepName_maybe isNoParentvisibleDataConsmkDataTyConRhstyConVisibleTyVarstyConTyVarBinders mkTyConKindisInvisibleTyConBinderisVisibleTyConBinderisNamedTyConBindertyConBndrVisArgFlagtyConBinderArgFlagmkRequiredTyConBindermkNamedTyConBindersmkNamedTyConBindermkAnonTyConBindersmkAnonTyConBinder TyConBinderTyConTyCoBinder TyConBndrVisNamedTCBAnonTCB AlgTyConRhs AbstractTyCon DataTyCon TupleTyConSumTyConNewTyCon data_consdata_cons_sizeis_enumdata_contup_sortnt_rhs nt_etad_rhsnt_coRuntimeRepInfo RuntimeRepVecCountVecElemNoRRI AlgTyConFlavVanillaAlgTyConUnboxedAlgTyCon ClassTyConDataFamInstTyCon Injectivity NotInjective Injective FamTyConFlavDataFamilyTyConOpenSynFamilyTyConClosedSynFamilyTyConAbstractClosedSynFamilyTyConBuiltInSynFamTyConPrimRepVecRep LiftedRep UnliftedRepIntRepWordRepInt64Rep Word64RepAddrRepFloatRep DoubleRepVoidRepInt8RepInt16RepWord8Rep Word16Rep PrimElemRep Int8ElemRep Int16ElemRep Int32ElemRep Int64ElemRep Word8ElemRep Word16ElemRep Word32ElemRep Word64ElemRep FloatElemRep DoubleElemRep TyConFlavour ClassFlavour TupleFlavour SumFlavourDataTypeFlavourNewtypeFlavourAbstractTypeFlavourDataFamilyFlavourOpenTypeFamilyFlavourClosedTypeFamilyFlavourTypeSynonymFlavourBuiltInTypeFlavourPromotedDataConFlavour RecTcChecker anyDVarEnvextendDVarEnvListpartitionDVarEnv modifyDVarEnvextendDVarEnv_C elemDVarEnvisEmptyDVarEnvdelDVarEnvList delDVarEnv unitDVarEnv plusDVarEnv_C plusDVarEnv alterDVarEnv filterDVarEnv mapDVarEnv foldDVarEnv lookupDVarEnv minusDVarEnv extendDVarEnv mkDVarEnv dVarEnvElts emptyDVarEnvmodifyVarEnv_Directly modifyVarEnvlookupVarEnv_NF zipVarEnvrestrictVarEnvpartitionVarEnvdelVarEnv_DirectlyfilterVarEnv_DirectlylookupVarEnv_Directly isEmptyVarEnv unitVarEnv emptyVarEnvmkVarEnv_DirectlymkVarEnv mapVarEnvlookupWithDefaultVarEnv filterVarEnv lookupVarEnvplusVarEnvList plusVarEnvintersectsVarEnv minusVarEnv delVarEnv delVarEnvListplusMaybeVarEnv_C plusVarEnv_CD plusVarEnv_CextendVarEnvListextendVarEnv_DirectlyextendVarEnv_AccextendVarEnv_C extendVarEnv alterVarEnvdisjointVarEnvelemVarEnvByKey elemVarEnvmkEmptyTidyEnv emptyTidyEnvrnSwap nukeRnEnvR nukeRnEnvLlookupRnInScopeinRnEnvRinRnEnvL rnOccR_maybe rnOccL_maybernOccRrnOccL delBndrsR delBndrsLdelBndrRdelBndrLrnEtaRrnEtaLrnBndrRrnBndrL rnBndr2_varrnBndr2rnBndrs2rnEnvRrnEnvL rnInScopeSet rnInScopeaddRnInScopeSetmkRnEnv2uniqAway varSetInScope unionInScopelookupInScope_Directly lookupInScopeelemInScopeSet delInScopeSetextendInScopeSetSetextendInScopeSetListextendInScopeSet mkInScopeSetgetInScopeVarsIdEnvTyVarEnv TyCoVarEnvCoVarEnvDVarEnvDIdEnv DTyVarEnvVarSettransCloDVarSetdVarSetToVarSetextendDVarSetList seqDVarSetdelDVarSetListpartitionDVarSet sizeDVarSet filterDVarSet mapDVarSet allDVarSet anyDVarSet foldDVarSetdVarSetMinusVarSet minusDVarSet delDVarSetisEmptyDVarSetintersectsDVarSetdisjointDVarSetdVarSetIntersectVarSetintersectDVarSetmapUnionDVarSet unionDVarSets unionDVarSet subDVarSet dVarSetElems elemDVarSet extendDVarSet mkDVarSet unitDVarSet emptyDVarSet pprVarSet pluralVarSet seqVarSettransCloVarSet fixVarSet mapVarSet allVarSet anyVarSet subVarSetdisjointVarSetintersectsVarSetmapUnionVarSetpartitionVarSetelemVarSetByKeydelVarSetByKey filterVarSet sizeVarSetlookupVarSetByName lookupVarSetlookupVarSet_DirectlymkVarSet isEmptyVarSet delVarSetList delVarSet minusVarSet elemVarSet unionVarSets unionVarSetintersectVarSetextendVarSetList extendVarSet unitVarSet emptyVarSetIdSetTyVarSetCoVarSet TyCoVarSetDVarSetDIdSet DTyVarSet DTyCoVarSet dataConNamedataConExTyCoVarsdataConUserTyVarsdataConUserTyVarBindersdataConSourceAritydataConInstOrigArgTysdataConStupidThetadataConFullSigisUnboxedSumCon DataConRep NoDataConRepDCR dcr_wrap_id dcr_boxer dcr_arg_tys dcr_stricts dcr_bangsEqSpecmustHaveLocalBinding isLocalVar isNonCoVarId isTyCoVar isTcTyVarsetIdNotExported setIdExported setIdDetails lazySetIdInfomkExportedLocalVar mkGlobalVarsetTcTyVarDetailstcTyVarDetails mkTcTyVarmkTyVarupdateTyVarKindMupdateTyVarKind setTyVarKind setTyVarNamesetTyVarUnique tyVarName isTyVarBinder mkTyVarBinderargToForallVisFlagupdateVarTypeM updateVarType setVarType setVarName setVarUnique varUnique nonDetCmpVarNcIdTKVarTypeVarKindVarEvIdEvVarDFunIdIpIdEqVarInTyVarInCoVarOutTyVarOutCoVarVarBndrBndr AnnotationsdeserializeAnnsfindAnnsByTypeRepfindAnns plusAnnEnvextendAnnEnvListmkAnnEnv emptyAnnEnvgetAnnTargetName_maybe Annotation ann_target ann_value AnnPayload AnnTarget NamedTarget ModuleTarget CoreAnnTargetAnnEnv nilDataConKey listTyConKeystarInfopprNameProvenanceisExplicitItemimportSpecModule importSpecLoc qualSpecOK unQualSpecOK bestImport shadowNamesextendGlobalRdrEnv transformGREsmkGlobalRdrEnvplusGlobalRdrEnvpickGREsModExppickGREsunQualOKgreLabel isRecFldGRE isLocalGREgetGRE_NameQualifier_maybeslookupGRE_Name_OccNamelookupGRE_FieldLabellookupGRE_NamelookupGRE_RdrName greOccNamelookupGlobalRdrEnvpprGlobalRdrEnvglobalRdrEnvEltsemptyGlobalRdrEnv availFromGREgresToAvailInfogreParent_maybe greSrcSpan greRdrNamesgreQualModName gresFromAvaillocalGREsFromAvaildelLocalRdrEnvListinLocalRdrEnvScopelocalRdrEnvEltselemLocalRdrEnvlookupLocalRdrOcclookupLocalRdrEnvextendLocalRdrEnvListextendLocalRdrEnvemptyLocalRdrEnv isExact_maybeisExact isOrig_maybeisOrig isQual_maybeisQualisUnqual isSrcRdrNameisRdrTc isRdrTyVar isRdrDataCon nameRdrName getRdrNamemkQual mkVarUnqualmkUnqualmkOrig mkRdrQual mkRdrUnqual demoteRdrName rdrNameSpace rdrNameOccOrigExact LocalRdrEnv GlobalRdrEnv GlobalRdrEltGREgre_namegre_pargre_lclgre_impParentNoParentParentIs FldParentpar_ispar_lbl ImportSpecImpSpecis_declis_item ImpDeclSpecis_modis_asis_qualis_dloc ImpItemSpecImpAllImpSome is_explicitis_iloc FieldLabelFieldLabelStringFieldLblflLabelflIsOverloaded flSelectorNameEnv alterDNameEnv mapDNameEnvlookupDNameEnv emptyDNameEnvlookupNameEnv_NFdisjointNameEnv anyNameEnv filterNameEnvdelListFromNameEnvdelFromNameEnvextendNameEnvList_CextendNameEnv_Acc mapNameEnvextendNameEnv_C plusNameEnv_C plusNameEnv elemNameEnv mkNameEnv alterNameEnv lookupNameEnvextendNameEnvList extendNameEnv unitNameEnvisEmptyNameEnv emptyNameEnv nameEnvEltsdepAnalDNameEnvNameSetfindUsesduUsesallUsesduDefsplusDUmkDUsusesOnlyemptyDUs intersectFVsdelFVsdelFVunitFVaddOneFVmkFVsplusFVplusFVsemptyFVs isEmptyFVsnameSetElemsStable nameSetAll nameSetAnyintersectsNameSetdelListFromNameSetintersectNameSet filterNameSetdelFromNameSet elemNameSet minusNameSet unionNameSets unionNameSet extendNameSetextendNameSetList mkNameSet unitNameSet emptyNameSetisEmptyNameSetFreeVarsDefsUsesDefUseDefUsesPackages pprModuleMappprPackagesSimple pprPackages isDllNamegetPreloadPackagesAndlistVisibleModuleNames!lookupPluginModuleWithSuggestionslookupModuleWithSuggestionslookupModuleInAllPackagesgetPackageFrameworksgetPackageFrameworkPathgetPackageExtraCcOpts packageHsLibsgetLibscollectArchivescollectLinkOptsgetPackageLinkOptscollectLibraryPathsgetPackageLibraryPathcollectIncludeDirsgetPackageIncludePath unwireUnitId pprReasonpprFlag isIndefinitereadPackageConfigresolvePackageConfiggetPackageConfRefsreadPackageConfigs initPackageslistPackageConfigMapgetInstalledPackageDetailslookupInstalledPackagegetPackageDetailssearchPackageIdlookupPackageNamelookupPackage' lookupPackage ModuleOrigin ModHidden ModUnusable ModOriginfromOrigPackagefromExposedReexportfromHiddenReexportfromPackageFlagUnusablePackageReasonIgnoredWithFlagBrokenDependenciesCyclicDependenciesIgnoredDependenciesShadowedDependencies LookupResult LookupFoundLookupMultiple LookupHiddenLookupUnusableLookupNotFoundModuleSuggestionSuggestVisible SuggestHidden listTyContypeSymbolKind typeNatKindmkBoxedTupleTyheqTyConcoercibleTyConunitTyconstraintKind vecElemTyCon vecCountTyConruntimeRepTyCon runtimeRepTytupleRepDataConTyConvecRepDataConTyConliftedRepDataConTyCondoubleRepDataConTyfloatRepDataConTyaddrRepDataConTyword64RepDataConTyword8RepDataConTyint64RepDataConTywordRepDataConTyword16RepDataConTyint16RepDataConTyint8RepDataConTyintRepDataConTyunliftedRepDataConTyliftedRepDataConTyvec64DataConTyvec32DataConTyvec16DataConTy vec8DataConTy vec4DataConTy vec2DataConTydoubleElemRepDataConTyfloatElemRepDataConTyword64ElemRepDataConTyword32ElemRepDataConTyword16ElemRepDataConTyword8ElemRepDataConTyint64ElemRepDataConTyint32ElemRepDataConTyint16ElemRepDataConTyint8ElemRepDataConTy anyTypeOfKindunboxedTupleKindmkPromotedListTyvarNameCoreMCoreToDoCoreTidyCoreDoSimplifyCoreDoPluginPassCoreDoFloatInwardsCoreDoFloatOutwardsCoreLiberateCaseCoreDoPrintCoreCoreDoStaticArgsCoreDoCallArity CoreDoExitifyCoreDoStrictnessCoreDoWorkerWrapperCoreDoSpecialisingCoreDoSpecConstrCoreCSECoreDoRuleCheck CoreDoNothing CoreDoPasses CoreDesugarCoreDesugarOpt CoreOccurAnalemptyFilesToClean isBmi2Enabled isBmiEnabledisAvx512pfEnabledisAvx512fEnabledisAvx512erEnabledisAvx512cdEnabled isAvx2Enabled isAvxEnabledisSse4_2Enabled isSse2Enabled isSseEnabledsetUnsafeGlobalDynFlagsmakeDynFlagsConsistenttARGET_MAX_WORDtARGET_MAX_INTtARGET_MIN_INT mAX_PTR_TAGtAG_MASKwORD_SIZE_IN_BITS bLOCK_SIZE_WiLDV_STATE_USEiLDV_STATE_CREATEiLDV_CREATE_MASK lDV_SHIFTdYNAMIC_BY_DEFAULTwORDS_BIGENDIANtAG_BITSbITMAP_BITS_SHIFTcLONG_LONG_SIZE cLONG_SIZE cINT_SIZE dOUBLE_SIZE wORD_SIZEaP_STACK_SPLIMrESERVED_STACK_WORDSrESERVED_C_STACK_BYTESmAX_Real_Long_REGmAX_Real_XMM_REGmAX_Real_Double_REGmAX_Real_Float_REGmAX_Real_Vanilla_REG mAX_XMM_REG mAX_Long_REGmAX_Double_REG mAX_Float_REGmAX_Vanilla_REGmUT_ARR_PTRS_CARD_BITS mAX_CHARLIKE mIN_CHARLIKE mAX_INTLIKE mIN_INTLIKEmIN_PAYLOAD_SIZEmAX_SPEC_AP_SIZEmAX_SPEC_SELECTEE_SIZEoFFSET_StgFunInfoExtraRev_aritysIZEOF_StgFunInfoExtraRevoFFSET_StgFunInfoExtraFwd_arityoFFSET_StgUpdateFrame_updateeoFFSET_StgStack_stackoFFSET_StgStack_spoFFSET_StgTSO_stackobjoFFSET_StgTSO_cccsoFFSET_StgTSO_alloc_limitoFFSET_StgArrBytes_bytessIZEOF_StgArrBytes_NoHdroFFSET_StgSmallMutArrPtrs_ptrssIZEOF_StgSmallMutArrPtrs_NoHdroFFSET_StgMutArrPtrs_sizeoFFSET_StgMutArrPtrs_ptrssIZEOF_StgMutArrPtrs_NoHdrsIZEOF_StgUpdateFrame_NoHdr oFFSET_StgEntCounter_entry_countoFFSET_StgEntCounter_link oFFSET_StgEntCounter_registeredpoFFSET_StgEntCounter_allocdoFFSET_StgEntCounter_allocssIZEOF_StgSMPThunkHeaderoFFSET_StgHeader_ldvwoFFSET_StgHeader_ccs oFFSET_CostCentreStack_scc_count oFFSET_CostCentreStack_mem_allocsIZEOF_CostCentreStackoFFSET_bdescr_flagsoFFSET_bdescr_blocksoFFSET_bdescr_freeoFFSET_bdescr_startoFFSET_Capability_roFFSET_stgGCFunoFFSET_stgGCEnter1oFFSET_stgEagerBlackholeInfooFFSET_StgRegTable_rHpAlloc"oFFSET_StgRegTable_rCurrentNurseryoFFSET_StgRegTable_rCurrentTSOoFFSET_StgRegTable_rCCCSoFFSET_StgRegTable_rHpLimoFFSET_StgRegTable_rHpoFFSET_StgRegTable_rSpLimoFFSET_StgRegTable_rSpoFFSET_StgRegTable_rL1oFFSET_StgRegTable_rZMM6oFFSET_StgRegTable_rZMM5oFFSET_StgRegTable_rZMM4oFFSET_StgRegTable_rZMM3oFFSET_StgRegTable_rZMM2oFFSET_StgRegTable_rZMM1oFFSET_StgRegTable_rYMM6oFFSET_StgRegTable_rYMM5oFFSET_StgRegTable_rYMM4oFFSET_StgRegTable_rYMM3oFFSET_StgRegTable_rYMM2oFFSET_StgRegTable_rYMM1oFFSET_StgRegTable_rXMM6oFFSET_StgRegTable_rXMM5oFFSET_StgRegTable_rXMM4oFFSET_StgRegTable_rXMM3oFFSET_StgRegTable_rXMM2oFFSET_StgRegTable_rXMM1oFFSET_StgRegTable_rD6oFFSET_StgRegTable_rD5oFFSET_StgRegTable_rD4oFFSET_StgRegTable_rD3oFFSET_StgRegTable_rD2oFFSET_StgRegTable_rD1oFFSET_StgRegTable_rF6oFFSET_StgRegTable_rF5oFFSET_StgRegTable_rF4oFFSET_StgRegTable_rF3oFFSET_StgRegTable_rF2oFFSET_StgRegTable_rF1oFFSET_StgRegTable_rR10oFFSET_StgRegTable_rR9oFFSET_StgRegTable_rR8oFFSET_StgRegTable_rR7oFFSET_StgRegTable_rR6oFFSET_StgRegTable_rR5oFFSET_StgRegTable_rR4oFFSET_StgRegTable_rR3oFFSET_StgRegTable_rR2oFFSET_StgRegTable_rR1tICKY_BIN_COUNTbLOCKS_PER_MBLOCK bLOCK_SIZE pROF_HDR_SIZE sTD_HDR_SIZEcONTROL_GROUP_CONST_291 compilerInfopicPOpts picCCOpts setTmpDirinterpretPackageEnvcanonicalizeModuleIfHomecanonicalizeHomeModule setUnitIdunSetGeneralFlag'setGeneralFlag'addWay' dynamicGhc rtsIsProfiledglasgowExtsFlagswarningHierarchies warningGroupsxFlagssupportedLanguagesAndExtensions fLangFlagsfFlags wWarningFlagsflagsForCompletion flagsPackage flagsDynamicflagsAllallNonDeprecatedFlags updateWays putLogMsgparseDynamicFlagsFullparseDynamicFilePragmaparseDynamicFlagsCmdLine updOptLevelshowOptaddPluginModuleName thisPackagethisUnitIdInststhisComponentId getVerbFlagsgetOptsunsafeFlagsForInfer unsafeFlagssafeImplicitImpsReqsafeDirectImpsReq safeImportsOn safeInferOnsafeLanguageOnsafeHaskellModeEnabled safeHaskellOnpackageTrustOndynFlagDependencieslang_setxopt_set_unlessExplSpec xopt_unsetxopt_setxoptwopt_unset_fatalwopt_set_fatal wopt_fatal wopt_unsetwopt_setwopt gopt_unsetgopt_set dopt_unsetdopt_setdopthasNoOptCoercionhasNoStateHacklanguageExtensionsdefaultFlushErrdefaultFlushOutdefaultLogActionHPutStrDocdefaultLogActionHPrintDocdefaultLogActiondefaultFatalMessagerinterpreterDynamicinterpreterProfiled interpWays defaultWaysdefaultDynFlags initDynFlagsdynamicTooMkDynamicDynFlagswhenCannotGenerateDynamicTooifGeneratingDynamicToowhenGeneratingDynamicToowayUnsetGeneralFlagswayGeneralFlags wayRTSOnly mkBuildTagpositionIndependentmkTablesNextToCodetablesNextToCodepackageFlagsChangedisNoLink isOneShottargetRetainsAllBindingsisObjectTargetversionedAppDiropt_iopt_lcopt_loopt_lcc opt_windresopt_lopt_aopt_copt_Fopt_P_signatureopt_Popt_Lpgm_ipgm_lcpgm_lo pgm_ranlibpgm_arpgm_lcc pgm_libtool pgm_windrespgm_Tpgm_dllpgm_lpgm_apgm_cpgm_Fpgm_Ppgm_LsystemPackageConfigextraGccViaCFlags rawSettingstmpDirtopDir ghciUsagePath ghcUsagePathprojectVersion programNamebackendMaintainsCfgflattenIncludesaddQuoteIncludeaddGlobalIncludeoptimisationFlags WarnReasonNoReasonReason ErrReason IncludeSpecsincludePathsQuoteincludePathsGlobal WarningFlagOpt_WarnDuplicateExportsOpt_WarnDuplicateConstraintsOpt_WarnRedundantConstraintsOpt_WarnHiShadowsOpt_WarnImplicitPreludeOpt_WarnIncompletePatternsOpt_WarnIncompleteUniPatterns Opt_WarnIncompletePatternsRecUpdOpt_WarnOverflowedLiteralsOpt_WarnEmptyEnumerationsOpt_WarnMissingFieldsOpt_WarnMissingImportListOpt_WarnMissingMethodsOpt_WarnMissingSignaturesOpt_WarnMissingLocalSignaturesOpt_WarnNameShadowingOpt_WarnOverlappingPatternsOpt_WarnTypeDefaultsOpt_WarnMonomorphismOpt_WarnUnusedTopBindsOpt_WarnUnusedLocalBindsOpt_WarnUnusedPatternBindsOpt_WarnUnusedImportsOpt_WarnUnusedMatchesOpt_WarnUnusedTypePatternsOpt_WarnUnusedForallsOpt_WarnUnusedRecordWildcards Opt_WarnRedundantRecordWildcardsOpt_WarnWarningsDeprecationsOpt_WarnDeprecatedFlags!Opt_WarnMissingMonadFailInstancesOpt_WarnSemigroupOpt_WarnDodgyExportsOpt_WarnDodgyImportsOpt_WarnOrphansOpt_WarnAutoOrphansOpt_WarnIdentities Opt_WarnTabsOpt_WarnUnrecognisedPragmasOpt_WarnDodgyForeignImportsOpt_WarnUnusedDoBindOpt_WarnWrongDoBind)Opt_WarnAlternativeLayoutRuleTransitionalOpt_WarnUnsafe Opt_WarnSafeOpt_WarnTrustworthySafeOpt_WarnMissedSpecsOpt_WarnAllMissedSpecs%Opt_WarnUnsupportedCallingConventionsOpt_WarnUnsupportedLlvmVersionOpt_WarnMissedExtraSharedLibOpt_WarnInlineRuleShadowingOpt_WarnTypedHolesOpt_WarnPartialTypeSignatures!Opt_WarnMissingExportedSignatures$Opt_WarnUntickedPromotedConstructorsOpt_WarnDerivingTypeableOpt_WarnDeferredTypeErrors#Opt_WarnDeferredOutOfScopeVariables"Opt_WarnNonCanonicalMonadInstances&Opt_WarnNonCanonicalMonadFailInstances#Opt_WarnNonCanonicalMonoidInstances'Opt_WarnMissingPatternSynonymSignatures Opt_WarnUnrecognisedWarningFlags$Opt_WarnSimplifiableClassConstraintsOpt_WarnCPPUndefOpt_WarnUnbangedStrictPatternsOpt_WarnMissingHomeModulesOpt_WarnPartialFieldsOpt_WarnMissingExportListOpt_WarnInaccessibleCodeOpt_WarnStarIsTypeOpt_WarnStarBinderOpt_WarnImplicitKindVarsOpt_WarnSpaceAfterBang!Opt_WarnMissingDerivingStrategiesLanguage Haskell98 Haskell2010 CfgWeights CFGWeights uncondWeightcondBranchWeight switchWeight callWeightlikelyCondWeightunlikelyCondWeightinfoTablePenalty backEdgeBonus HasDynFlagsContainsDynFlagsextractDynFlagsProfAuto NoProfAuto ProfAutoAll ProfAutoTopProfAutoExports ProfAutoCalls LlvmTarget lDataLayoutlCPU lAttributes LlvmTargets LlvmPasses LlvmConfigSettingssTargetPlatform sGhcUsagePathsGhciUsagePathsToolDirsTopDirsTmpDir sProgramNamesProjectVersion sRawSettingssExtraGccViaCFlagssSystemPackageConfigsLdSupportsCompactUnwindsLdSupportsBuildIdsLdSupportsFilelist sLdIsGnuLdsGccSupportsNoPiesPgm_LsPgm_PsPgm_FsPgm_csPgm_asPgm_lsPgm_dllsPgm_T sPgm_windres sPgm_libtoolsPgm_ar sPgm_ranlibsPgm_losPgm_lcsPgm_lccsPgm_isOpt_LsOpt_PsOpt_P_fingerprintsOpt_FsOpt_csOpt_asOpt_l sOpt_windressOpt_losOpt_lcsOpt_lccsOpt_isPlatformConstants PackageArg UnitIdArg ModRenamingmodRenamingWithImplicit modRenamingsIgnorePackageFlag IgnorePackage TrustFlag TrustPackageDistrustPackage PackageFlag ExposePackage HidePackage PackageDBFlag PackageDBNoUserPackageDBNoGlobalPackageDBClearPackageDBs DynLibLoader DeployableSystemDependentRtsOptsEnabled RtsOptsNone RtsOptsIgnoreRtsOptsIgnoreAllRtsOptsSafeOnly RtsOptsAllWay WayCustom WayThreadedWayDebugWayProf WayEventLogWayDyn FatalMessager LogActionFlushOutFlushErrFlagSpec flagSpecName flagSpecFlagflagSpecActionflagSpecGhcMode PkgConfRef GlobalPkgConf UserPkgConf PkgConfFile LinkerInfoGnuLDGnuGoldLlvmLLDDarwinLD SolarisLDAixLD UnknownLD CompilerInfoGCCClang AppleClang AppleClang51 UnknownCC FilesToClean ftcGhcSessionftcCurrentModule isHsigFile isHsBootOrSighscSourceString HscSource HsSrcFile HsBootFileHsigFiledefinitePackageConfigIdexpandedPackageConfigIdpackageConfigIdinstalledPackageConfigIdpprPackageConfigpackageNameStringsourcePackageIdStringdefaultPackageConfigSourcePackageId PackageName unitModuleSetunionModuleSet delModuleSetminusModuleSetintersectModuleSet elemModuleSet moduleSetEltsemptyModuleSetextendModuleSetListextendModuleSet mkModuleSetisEmptyModuleEnv unitModuleEnvmoduleEnvToList moduleEnvElts moduleEnvKeysemptyModuleEnv mkModuleEnv mapModuleEnvlookupWithDefaultModuleEnvlookupModuleEnv plusModuleEnv delModuleEnvdelModuleEnvListplusModuleEnv_CextendModuleEnvList_CextendModuleEnvListextendModuleEnvWithextendModuleEnv elemModuleEnvfilterModuleEnvwiredInUnitIds isHoleModuleisInteractiveModule mainUnitIdinteractiveUnitId thisGhcUnitIdthUnitId rtsUnitId baseUnitId integerUnitId primUnitId parseModSubst parseModuleIdparseComponentId parseUnitIdparseModuleNamegeneralizeIndefModulegeneralizeIndefUnitIdsplitUnitIdInstssplitModuleInstsrenameHoleUnitId'renameHoleModule'renameHoleUnitIdrenameHoleModulestringToUnitId fsToUnitIdnewSimpleUnitIdstableUnitIdCmp newUnitId hashUnitIdunitIdIsDefiniteunitIdFreeHolesdelInstalledModuleEnvfilterInstalledModuleEnvextendInstalledModuleEnvlookupInstalledModuleEnvemptyInstalledModuleEnvinstalledUnitIdEqinstalledModuleEqstringToInstalledUnitIdcomponentIdToInstalledUnitIdfsToInstalledUnitIdinstalledUnitIdStringtoInstalledUnitIdindefModuleToModuleindefUnitIdToUnitIdnewIndefUnitId unitIdKeyunitIdFSstableModuleCmp mkHoleModulemoduleIsDefinitemoduleNameColonsmoduleNameSlashesmkModuleNameFSmoduleStableString moduleNameFS pprModuleNamestableModuleNameCmpaddBootSuffixLocnOutaddBootSuffixLocnaddBootSuffix_maybe addBootSuffixContainsModule extractModule HasModule getModule IndefUnitId indefUnitIdFSindefUnitIdKeyindefUnitIdComponentIdindefUnitIdInstsindefUnitIdFreeHoles IndefModuleindefModuleUnitIdindefModuleNameInstalledModuleinstalledModuleUnitIdinstalledModuleName DefUnitId unDefUnitIdInstalledModuleEnv ShHoleSubst ModuleEnv ModuleSet ModuleNameEnvDModuleNameEnvUniqSet pprUniqSetunsafeUFMToUniqSet getUniqSet mapUniqSetnonDetFoldUniqSet_DirectlynonDetFoldUniqSetnonDetKeysUniqSetnonDetEltsUniqSetlookupUniqSet_Directly lookupUniqSetisEmptyUniqSet sizeUniqSet uniqSetAll uniqSetAnypartitionUniqSetfilterUniqSet_Directly filterUniqSetelemUniqSet_DirectlyelementOfUniqSetuniqSetMinusUFMrestrictUniqSetToUFMintersectUniqSets minusUniqSetunionManyUniqSets unionUniqSetsdelListFromUniqSet_DirectlydelListFromUniqSetdelOneFromUniqSet_DirectlydelOneFromUniqSetaddListToUniqSetaddOneToUniqSet mkUniqSet unitUniqSet emptyUniqSetUniqFM pluralUFMpprUFMWithKeyspprUFM pprUniqFM equalKeysUFM ufmToIntMapnonDetUFMToListnonDetFoldUFM_Directly nonDetFoldUFM nonDetKeysUFM nonDetEltsUFM seqEltsUFMallUFManyUFMufmToSet_DirectlyeltsUFMlookupWithDefaultUFM_DirectlylookupWithDefaultUFMlookupUFM_Directly lookupUFMelemUFM_DirectlyelemUFMsizeUFM partitionUFMfilterUFM_Directly filterUFMmapUFM_DirectlymapUFMfoldUFM disjointUFMintersectUFM_C intersectUFMminusUFM plusUFMListplusMaybeUFM_C plusUFM_CD plusUFM_CplusUFMdelFromUFM_DirectlydelListFromUFM_DirectlydelListFromUFM delFromUFMadjustUFM_Directly adjustUFMaddListToUFM_CalterUFM addToUFM_Acc addToUFM_CaddToUFM_DirectlyaddListToUFM_Directly addListToUFMaddToUFM listToUFM_ClistToUFM_Directly listToUFMunitDirectlyUFMunitUFM isNullUFMemptyUFM lazyMapUsliftUsgetUniqueSupplyM3 lazyThenUsinitUs_initUssplitUniqSupply4splitUniqSupply3takeUniqFromSupplyuniqsFromSupplyuniqFromSupplylistSplitUniqSupplysplitUniqSupplymkSplitUniqSupplyinitUniqSupply vanillaIdInfo coVarDetailsisCoVarDetails pprIdDetails arityInforuleInfo unfoldingInfo oneShotInfoinlinePragInfooccInfostrictnessInfo demandInfo callArityInfo levityInfo IdDetails VanillaIdRecSelId DataConWorkId DataConWrapId ClassOpIdPrimOpIdFCallId TickBoxOpIdCoVarId sel_tycon sel_naughtyliftL onHasSrcSpanmapLocpprUserRealSpansrcSpanFileName_mayberealSrcSpanEndrealSrcSpanStart containsSpan isOneLineSpansrcSpanFirstCharactercombineSrcSpans mkRealSrcSpanrealSrcLocSpanmkGeneralSrcSpaninteractiveSrcSpanwiredInSrcSpan sortLocated advanceSrcLocmkGeneralSrcLocinteractiveSrcLocgeneratedSrcLoc mkRealSrcLocLL RealLocatedpprDebugAndThenassertPprPanic pprSTracepprTraceException pprTraceIt pprTraceMpprTrace pprTraceDebug pprPgmErrorpprSorrypprPanic callStackDocdoOrDoesisOrArepluralspeakNOfspeakNspeakNth intWithCommasquotedListWithNorquotedListWithOr pprQuotedList interpp'SP interppSP pprWithBars pprWithCommaspprFilePathStringpprFastFilePath pprInfixVar pprPrefixVar pprPrimWord64 pprPrimInt64 pprPrimWord pprPrimInt pprPrimCharprimWord64SuffixprimInt64SuffixprimWordSuffixprimDoubleSuffix primIntSuffixprimFloatSuffixprimCharSuffix pprHsBytes pprHsString pprHsCharkeywordcolouredppUnlessppWhen punctuate hangNotEmptyhangfcatfsepcatsepvcathsephcat$+$$$<+><>nest unicodeSyntaxbulletkindType forAllLitrbracelbracerbracklbrackrparenlparenvbardot underscorespaceequalscoloncommasemilarrowttarrowttlarrowtarrowtdarrowlarrowarrowdcolon blankLinequotescparen angleBrackets doubleQuotesquotebracketsbracesparens doublePrecwordrationaldoublefloatintegerintztextptextftextchar docToSDocisEmptyshowSDocDumpOneLineshowSDocOneLinerenderWithStyle showSDocDebug showSDocDumpshowSDocForUsershowSDocUnqualshowPprshowSDoc mkCodeStylepprCodebufLeftRenderSDoc printForCprintForUserPartWay printForUser printSDocLn printSDoc whenPprDebug ifPprDebug getPprDebug userStyle debugStyle dumpStyleasmStyle codeStyle queryQual qualPackage qualModulequalNameupdSDocDynFlagssdocWithPlatformsdocWithDynFlags getPprStyle pprSetDepth pprDeeperList pprDeeperwithPprStyleDoc withPprStyleinitSDocContextsetStyleColoured mkUserStylecmdlineParserStyle mkErrStyledefaultErrStyle mkDumpStyledefaultDumpStyledefaultUserStyle neverQualifyreallyAlwaysQualifyneverQualifyPackagesalwaysQualifyPackagesneverQualifyModulesalwaysQualifyModulesneverQualifyNamesalwaysQualifyNamesreallyAlwaysQualifyNamesPprStyle CodeStyleCStyleAsmStyleDepth AllTheWayPartWay QueryQualifyqueryQualifyNamequeryQualifyModulequeryQualifyPackageQueryQualifyNameQueryQualifyModuleQueryQualifyPackage QualifyName NameUnqualNameQualNameNotInScope1NameNotInScope2pprpprPrec BindingSite LambdaBindCaseBind CasePatBindLetBindOutputableBndr pprPrefixOccpprBndr pprInfixOccbndrIsJoin_maybeemptyPackageStatecomponentIdStringdisplayInstalledUnitId improveUnitIdgetPackageConfigMap PackageStatepreloadPackagesexplicitPackagesmoduleToPkgConfAllrequirementContextPackageConfigMap unitIdStringIndefiniteUnitIdDefiniteUnitIdInstalledUnitIdinstalledUnitIdFS ComponentIdfsLitsLitlengthPSunpackPtrString mkPtrString mkPtrString#hPutFSgetFastStringTableisUnderscoreFSnilFS uniqueOfFSconsFStailFSheadFSconcatFSappendFS zEncodeFSunpackFSnullFS hasZEncodinglengthFSmkFastStringByteList mkFastStringmkFastStringByteStringmkFastStringForeignPtrmkFastStringBytes mkFastString# lengthFZSzStringhPutFZSunsafeMkByteStringfastZStringToByteStringfastStringToByteStringbytesFS FastZStringuniqn_charsfs_bsfs_ref PtrStringUtil overrideWith hashStringcharToCabstractDataTypeabstractConstrmakeRelativeToreslash escapeSpacessplitLongestPrefixwithAtomicRenamemodificationTimeIfExistsgetModificationUTCTimedoesDirNameExistmaybeReadFuzzy maybeReadreadHexRational readRational exactLog2toArgs toCmdArgsgetCmdlooksLikePackageNamelooksLikeModuleName sharedGlobalM sharedGlobalglobalM consIORefglobalseqList unzipWith fuzzyLookup fuzzyMatch<||><&&> removeSpacescmpList eqMaybeByeqListBythenCmpisEqual capitalisesplitsnocView lastMaybelast2spanEnddropWhileEndLEdropTail splitAtListdropListtakeList countWhilecountall2foldl2transitiveClosureordNubnubSortminWith changeLast chunkListisn'tInisInonlynotNull isSingleton singletonltLengthleLength compareLengthneLength equalLength listLengthCmplengthLessThan lengthAtMost lengthIsNotlengthIs lengthAtLeast lengthExceedsatLength mapAccumL2 zipAndUnzipzipWithAndUnzip mapAndUnzip3 mapAndUnzipmapSndmapFststretchZipWithpartitionByList filterByLists filterByList zipWith3Lazy zipWithLazyzipLazy zipWith4Equal zipWith3Equal zipWithEqualzipEqual chkAppend partitionWith filterOutsecondMfirst3MfirstMliftSndliftFstuncurry3third3snd3fst3thdOf3sndOf3fstOf3nTimes isDarwinHost isWindowsHostghciTablesNextToCode ncgDebugIsOn debugIsOn ghciSupportedSuffix DirectionForwards BackwardsHasDebugCallStackOverridingBoolAutoAlwaysNever isTupleTyConisUnboxedTupleTyCon tyConName tyConUnique tyConBinders tyConResKind tyConCType algTcFields famTcResVartcTyConScopedTyVars tcTyConIsPolyPlugininstallCoreToDostcPluginpluginRecompileparsedResultActionrenamedResultActiontypeCheckResultActionspliceRunActioninterfaceLoadAction LoadedPluginlpPluginlpModule StaticPluginspPluginPlatformConstantspc_platformConstantspc_CONTROL_GROUP_CONST_291pc_STD_HDR_SIZEpc_PROF_HDR_SIZE pc_BLOCK_SIZEpc_BLOCKS_PER_MBLOCKpc_TICKY_BIN_COUNTpc_OFFSET_StgRegTable_rR1pc_OFFSET_StgRegTable_rR2pc_OFFSET_StgRegTable_rR3pc_OFFSET_StgRegTable_rR4pc_OFFSET_StgRegTable_rR5pc_OFFSET_StgRegTable_rR6pc_OFFSET_StgRegTable_rR7pc_OFFSET_StgRegTable_rR8pc_OFFSET_StgRegTable_rR9pc_OFFSET_StgRegTable_rR10pc_OFFSET_StgRegTable_rF1pc_OFFSET_StgRegTable_rF2pc_OFFSET_StgRegTable_rF3pc_OFFSET_StgRegTable_rF4pc_OFFSET_StgRegTable_rF5pc_OFFSET_StgRegTable_rF6pc_OFFSET_StgRegTable_rD1pc_OFFSET_StgRegTable_rD2pc_OFFSET_StgRegTable_rD3pc_OFFSET_StgRegTable_rD4pc_OFFSET_StgRegTable_rD5pc_OFFSET_StgRegTable_rD6pc_OFFSET_StgRegTable_rXMM1pc_OFFSET_StgRegTable_rXMM2pc_OFFSET_StgRegTable_rXMM3pc_OFFSET_StgRegTable_rXMM4pc_OFFSET_StgRegTable_rXMM5pc_OFFSET_StgRegTable_rXMM6pc_OFFSET_StgRegTable_rYMM1pc_OFFSET_StgRegTable_rYMM2pc_OFFSET_StgRegTable_rYMM3pc_OFFSET_StgRegTable_rYMM4pc_OFFSET_StgRegTable_rYMM5pc_OFFSET_StgRegTable_rYMM6pc_OFFSET_StgRegTable_rZMM1pc_OFFSET_StgRegTable_rZMM2pc_OFFSET_StgRegTable_rZMM3pc_OFFSET_StgRegTable_rZMM4pc_OFFSET_StgRegTable_rZMM5pc_OFFSET_StgRegTable_rZMM6pc_OFFSET_StgRegTable_rL1pc_OFFSET_StgRegTable_rSppc_OFFSET_StgRegTable_rSpLimpc_OFFSET_StgRegTable_rHppc_OFFSET_StgRegTable_rHpLimpc_OFFSET_StgRegTable_rCCCS!pc_OFFSET_StgRegTable_rCurrentTSO%pc_OFFSET_StgRegTable_rCurrentNurserypc_OFFSET_StgRegTable_rHpAllocpc_OFFSET_stgEagerBlackholeInfopc_OFFSET_stgGCEnter1pc_OFFSET_stgGCFunpc_OFFSET_Capability_rpc_OFFSET_bdescr_startpc_OFFSET_bdescr_freepc_OFFSET_bdescr_blockspc_OFFSET_bdescr_flagspc_SIZEOF_CostCentreStack#pc_OFFSET_CostCentreStack_mem_alloc pc_REP_CostCentreStack_mem_alloc#pc_OFFSET_CostCentreStack_scc_count pc_REP_CostCentreStack_scc_countpc_OFFSET_StgHeader_ccspc_OFFSET_StgHeader_ldvwpc_SIZEOF_StgSMPThunkHeaderpc_OFFSET_StgEntCounter_allocspc_REP_StgEntCounter_allocspc_OFFSET_StgEntCounter_allocdpc_REP_StgEntCounter_allocd#pc_OFFSET_StgEntCounter_registeredppc_OFFSET_StgEntCounter_link#pc_OFFSET_StgEntCounter_entry_countpc_SIZEOF_StgUpdateFrame_NoHdrpc_SIZEOF_StgMutArrPtrs_NoHdrpc_OFFSET_StgMutArrPtrs_ptrspc_OFFSET_StgMutArrPtrs_size"pc_SIZEOF_StgSmallMutArrPtrs_NoHdr!pc_OFFSET_StgSmallMutArrPtrs_ptrspc_SIZEOF_StgArrBytes_NoHdrpc_OFFSET_StgArrBytes_bytespc_OFFSET_StgTSO_alloc_limitpc_OFFSET_StgTSO_cccspc_OFFSET_StgTSO_stackobjpc_OFFSET_StgStack_sppc_OFFSET_StgStack_stack pc_OFFSET_StgUpdateFrame_updatee"pc_OFFSET_StgFunInfoExtraFwd_aritypc_REP_StgFunInfoExtraFwd_aritypc_SIZEOF_StgFunInfoExtraRev"pc_OFFSET_StgFunInfoExtraRev_aritypc_REP_StgFunInfoExtraRev_aritypc_MAX_SPEC_SELECTEE_SIZEpc_MAX_SPEC_AP_SIZEpc_MIN_PAYLOAD_SIZEpc_MIN_INTLIKEpc_MAX_INTLIKEpc_MIN_CHARLIKEpc_MAX_CHARLIKEpc_MUT_ARR_PTRS_CARD_BITSpc_MAX_Vanilla_REGpc_MAX_Float_REGpc_MAX_Double_REGpc_MAX_Long_REGpc_MAX_XMM_REGpc_MAX_Real_Vanilla_REGpc_MAX_Real_Float_REGpc_MAX_Real_Double_REGpc_MAX_Real_XMM_REGpc_MAX_Real_Long_REGpc_RESERVED_C_STACK_BYTESpc_RESERVED_STACK_WORDSpc_AP_STACK_SPLIM pc_WORD_SIZEpc_DOUBLE_SIZE pc_CINT_SIZE pc_CLONG_SIZEpc_CLONG_LONG_SIZEpc_BITMAP_BITS_SHIFT pc_TAG_BITSpc_WORDS_BIGENDIANpc_DYNAMIC_BY_DEFAULT pc_LDV_SHIFTpc_ILDV_CREATE_MASKpc_ILDV_STATE_CREATEpc_ILDV_STATE_USEtargetPlatformunsafeGlobalDynFlagsuseUnicodeSyntax useStarIsTypeshouldUseColorshouldUseHexWordLiterals hasPprDebughasNoDebugOutputOpt_D_dump_cmmOpt_D_dump_cmm_from_stgOpt_D_dump_cmm_rawOpt_D_dump_cmm_verboseOpt_D_dump_cmm_cfgOpt_D_dump_cmm_cbeOpt_D_dump_cmm_switchOpt_D_dump_cmm_procOpt_D_dump_cmm_spOpt_D_dump_cmm_sinkOpt_D_dump_cmm_cafOpt_D_dump_cmm_procmapOpt_D_dump_cmm_splitOpt_D_dump_cmm_infoOpt_D_dump_cmm_cpsOpt_D_dump_cfg_weightsOpt_D_dump_asmOpt_D_dump_asm_nativeOpt_D_dump_asm_livenessOpt_D_dump_asm_regallocOpt_D_dump_asm_regalloc_stagesOpt_D_dump_asm_conflictsOpt_D_dump_asm_statsOpt_D_dump_asm_expandedOpt_D_dump_llvmOpt_D_dump_core_statsOpt_D_dump_deriv Opt_D_dump_dsOpt_D_dump_ds_preoptOpt_D_dump_foreignOpt_D_dump_inliningsOpt_D_dump_rule_firingsOpt_D_dump_rule_rewritesOpt_D_dump_simpl_traceOpt_D_dump_occur_analOpt_D_dump_parsedOpt_D_dump_parsed_ast Opt_D_dump_rnOpt_D_dump_rn_astOpt_D_dump_shapeOpt_D_dump_simplOpt_D_dump_simpl_iterationsOpt_D_dump_specOpt_D_dump_prepOpt_D_dump_stgOpt_D_dump_call_arityOpt_D_dump_exitifyOpt_D_dump_stranalOpt_D_dump_str_signatures Opt_D_dump_tcOpt_D_dump_tc_astOpt_D_dump_typesOpt_D_dump_rulesOpt_D_dump_cseOpt_D_dump_worker_wrapperOpt_D_dump_rn_traceOpt_D_dump_rn_statsOpt_D_dump_opt_cmmOpt_D_dump_simpl_statsOpt_D_dump_cs_traceOpt_D_dump_tc_traceOpt_D_dump_ec_traceOpt_D_dump_if_traceOpt_D_dump_vt_traceOpt_D_dump_splicesOpt_D_th_dec_fileOpt_D_dump_BCOsOpt_D_dump_tickedOpt_D_dump_rttiOpt_D_source_statsOpt_D_verbose_stg2stg Opt_D_dump_hiOpt_D_dump_hi_diffsOpt_D_dump_mod_cyclesOpt_D_dump_mod_mapOpt_D_dump_timings!Opt_D_dump_view_pattern_commoningOpt_D_verbose_core2coreOpt_D_dump_debugOpt_D_dump_jsonOpt_D_ppr_debugOpt_D_no_debug_output assertPanicpgmErrorsorryshowSDocUnsafe warnPprTracetextSDocrunSDoc FiniteMapfoldRightWithKey foldRight deleteListinsertListWith insertListGHC.SerializeddeserializeWithDataserializeWithDatafromSerialized toSerialized Serialized GHC.PackageDbInstalledPackageInfo packageNameunitId componentIdinstantiatedWithsourcePackageIdpackageVersion sourceLibNameabiHashdepends abiDepends importDirs hsLibrariesextraLibrariesextraGHCiLibraries libraryDirslibraryDynDirs frameworks frameworkDirs ldOptions ccOptionsincludes includeDirshaddockInterfaces haddockHTMLsexposedModules hiddenModules indefiniteexposedtrustedcpe_env FloatTick cpeBodyNFCpeBodycpeBodyFloatsokCpeArgguardIntegerUseguardNaturalUse wrapTickscollectCostCentreslookupFixityRn'lookupExactOcc_eitherFreeKiTyVarsNoDups FreeKiTyVarsFreeKiTyVarsWithDupsOpNameNormalOpNegateOp UnboundOpRecFldOpextractFilteredRdrTyVarsextractFilteredRdrTyVarsDupspartition_nwcswildCardsAllowedcheckPolyKindslookupFixityOpextractHsTyRdrTyVarsDups rnImportDeclHsImpExp LImportDecl gresFromIEwarnMissingSignaturescheckPatSynParentInstDeclFreeVarsMapClosedTyFamInfo ClosedTyFamNotClosedTyFampatchForeignImportcheckCanonicalInstancesreturn rnRoleAnnotsmkInstDeclFreeVarsMaprnAndReportFloatingViaTvsrnInjectivityAnnextendPatSynEnv runRnSpliceStmtTree MonadNamesrnStmtsWithPostProcessing postProcessStmtsForApplicativeDonoPostProcessStmtsrebindableContextrearrangeForApplicativeDomkStmtTreeHeuristicmkStmtTreeOptimalstmtTreeToStmtssegments splitSegmentmkApplicativeStmtneedJoin isReturnApprnStmtmakeForeignNamedHValueRefs linkSomeBCOs getGCCPathsgccSearchDirCachegetSystemDirectories addEnvPathsInjErrorBuildercheckForInjectivityConflictsunusedInjTvsInRHS isTFHeadedbareTvInRHSViolatedinjectivityErrorHeraldconflictInjInstErrunusedInjectiveVarsErr tfHeadedErrbareVariableInRHSErr fromHieNameaddFingerprintsgetOrphanHashesmkIfaceAnnCache checkVersions checkPlugins checkHsigcheckHie checkFlagHashcheckOptimHash checkHpcHash checkModUsage mkHEqBoxTy mkEqBoxTySafeOverlapping matchTypeabledoFunTy doTyConApponlyNamedBndrsApplied TcEvidence HsWrapperReportreport_unsolved importantrelevant_bindingsvalid_hole_fitsdeferringAnyBindingsnoDeferredBindings ReportErrCtxtmkCoercibleExplanation pprWithExplicitKindsWhenMismatchexpandSynonymsToMatchuseVarsFlattenTvResultFTRNotFollowed FTRFollowedFlatM FlattenEnvsetEqRelnoBogusCoercionsflatten_args_fastflatten_args_slow flatten_co split_pi_tys'Boolty_con_binders_ty_binders' zonk_eq_types Data.EitherRightLeftcan_eq_newtype_nc canEqCast canEqFailurecanEqHardFailure canCFunEqCancanEqReflexiveandWhenContinueTcPluginProgresspluginInputCtspluginSolvedCts pluginBadCts pluginNewCts SolvedCtsSplitCtsrunTcPluginsGivenrunTcPluginsWanted runTcPluginsnaturallyCoherentClassdefaultCallStacksdefaultTyVarTcS isFlexiTyVartraceTR instScheme TelescopeAcc ValidityEnv ExpandModeExpandNoExpandBoth vdqAllowedinitialExpandModecheckEscapingKindillegalVDQTyErrcheckHasFieldInstcheckValidTypePatsisTerminatingClassppr_tidycheck_arg_typeTcTyMode mode_leveltc_infer_lhs_typetc_infer_hs_type_ektc_infer_hs_typetcInferApps_nosatcheckExpectedKind newWildTyVarbindExplicitTKBndrsXkindGeneralizeLocal finish_tuplekcLHsQTyVars_CuskkcLHsQTyVars_NonCuskisCompleteHsSigmatchExpectedPatTymk_showString_appmk_showsPrec_app mk_shows_app mkFunBindSE mkFunBindEC postfixModTbl assoc_ty_idassoc_ty_id_maybemkAuxBinderNameArgTyAlg argTyFoldfoldBal DerivStrategy cond_stdOK ConditionIsValidNotValidinferConstraintsDataConArgsinferConstraintsDAC simplifyDeriv localSigWarnKindRepM KindRepEnvtrTyConDataCon trNameLit TypeRepTodoExportedKindRepsTodo mod_rep_exprpkg_fingerprintmod_fingerprint todo_tycons TypeableTyConmkTypeRepTodoBindsmkPrimTypeableTodosghcPrimTypeableTyCons primTyCons collect_stuff mkTrNameLitmkTyConRepBindstyConIsTypeabletypeIsTypeablebuiltInKindRepsmkExportedKindReps runKindRepM getKindRep mkKindRepRhsmkTyConRepTyConRHS SynCycleMcheckNameIsAcycliccheckHsigIface check_instrequirementMergesifaceDeclNeverExportedRefscheckImplementstc_patsyn_finishmkPatSynRecSelBindstauifyMultipleMatches tcMatches deriveClause mkDataTypeEqn mkNewTypeEqn tcInjectivity rejigConReswrongNumberOfParmsErrgetFamDeclInitialKindsgetFamDeclInitialKindtcDefaultAssocDecl mkGADTVarsNotClosedReasontcArgscheckClosedInStaticForm tcSynArgE tcSynArgA PlanResult clearTcGblEnvrun_th_modfinalizers andThenCheck checkUnless checkListBycheck checkSuccesstcPreludeClashWarn getMainFunrunPlans tcUserStmt tcGhciStmts getGhciStepIOtcMissingParentClassWarn TmOracleEnvvarInsolveComplexEqextendSubstAndSolvesimplifyComplexEqsimplifyPmExprsimplifyEqExprapplySubstComplexEq varDeepLookupPmArityInhabitationCandidateic_tm_ctic_ty_csic_strict_arg_tysUncoveredCandidatesPmResult Provenance FromBuiltin FromCompleteDeltaValVec emptyPmResultuncoveredWithTy checkSingle' checkMatches'checkEmptyCase'pmIsClosedTypepmTopNormaliseType_maybetopNormaliseType_maybepmInitialTmTyCspmIsSatisfiabletmTyCsAreSatisfiablecheckAllNonVoidnonVoiddefinitelyInhabitedTypeinhabitationCandidatesIntfake_pat isFakeGuardmkCanFailPmPat nilPattern mkLitPatterntranslatePatVectranslateConPatVectranslateGuardscantFailPatterntranslateGuard translateLet translateBindtranslateBoolGuard pmPatType mkOneConFullmkGuardmkNegEqmkPosEqmkIdEqmkPmVarmkPmVarsmkPmId mkPmId2Forms vaToPmExpr coercePatVec coercePmPatsingleConstructorallCompleteMatchestyOracle patVecArity patternArityrunManymkInitialUncoveredpmcheckIpmcheckpmcheckGuardsI pmcheckGuards pmcheckHdI pmcheckHdusimpleutailuconkconmkUnionmkConsforcesforce_if substInValAbs wrapUpTmStatedsPmWarn warnPmIters exhaustiveexhaustiveWarningFlag ValSetAbsPatVecValAbsPatterndsHsBind makeCorePairds_ev_typeablegetRep dsMcBindStmtmaxBuildLengthcheckForcedEtaExpansionbadUseOfLevPolyPrimopHasTypeToHielocTVScopedPScopedRScoped SigContextPatSynFieldContext BindContext IEContext RFContext listScopes patScopestvScopesHsAppPS UnariseEnv extendRhounariseSumAltsmkUbxSum unariseFunArg unariseConArgStgToDoStgCSE StgUnarise StgDoNothing getStgToDo mk_absent_letuseLetUpextendAnalEnvsx86_regUsageOfInstr interestingx86_patchRegsOfInstrx86_mkSpillInstrx86_mkLoadInstrx86_takeDeltaInstrx86_mkRegRegMoveInstrx86_takeRegRegMoveInstrx86_mkJumpInstrneeds_probe_call pprSizeDeclpprSectionAlignpprAlignForSectionsparc_regUsageOfInstrsparc_patchRegsOfInstrsparc_mkSpillInstrsparc_mkLoadInstrsparc_takeDeltaInstrsparc_mkRegRegMoveInstrsparc_takeRegRegMoveInstrsparc_mkJumpInstrpprRegpprReg_ofRegNo pprStFormatpprCondpprAddrpprRIpprFormatRegRegpprFormatRegRegReg pprRegRIReg expandBlockexpandBlockInstrs remapRegPairfRegHi maxSpinCount regAlloc_spin buildGraphgraphAddConflictSetgraphAddCoalescepatchRegsFromGraphppc_regUsageOfInstrppc_patchRegsOfInstrppc_isJumpishInstrppc_jumpDestsOfInstrppc_patchJumpInstrppc_mkSpillInstr stackAlignppc_takeDeltaInstrppc_mkRegRegMoveInstrppc_mkJumpInstrppc_takeRegRegMoveInstrGHC.Enum integerExtend conversionNopidivirem coerceInt2FP coerceFP2Int coerceDbl2Flt coerceFlt2Dbl picRelativeaddSpUnwindingsjumpTableEntrygetSimpleAmodeaddAlignmentCheckgenCondBranch'arg_to_int_vregs move_final assign_codeoutOfLineMachOpoutOfLineMachOp_table BlockChain FrontierMapneighbourOverlappfuseEdgeThreshold breakChainAt fuseChainscombineNeighbourhoodmakeRegMovementGraph expandNodehandleComponentmakeMovejoinToTargets'linearRegAlloc processBlock initBlocklinearRAraInsn clobberRegs newLocationloadTemplinearRegAlloc' DwarfAbbrev DwAbbrNull pprAbbrevpprDwarfInfoOpenpprDwarfInfoClose pprFrameProc pprFrameBlockdwarfGlobalRegNo pprSetUnwind pprLEBRegNo pprUnwindExprpprUndefUnwindpprData4 pprString' pprString escapeChar mkDwarfARangecompileUnitHeadercompileUnitFooterdebugSplitProcs procToDwarf blockToDwarf debugFrame procToFrame NativeGenAcc ngs_natives ngs_unwinds cmmNativeGens checkLayoutcomputeUnwindingmakeImportsDoclogWarningsReportErrorshandleWarningsThrowErrorsMaybe ioMsgMaybe'extract_renamed_stuff hscTypecheckhscIncrementalFrontendhscCheckSafeImportscheckSafeImports hscCheckSafe' checkPkgTrustmarkUnsafeInferhscGetSafeMode hsc_typecheck seqSerializedaddModFinalizerRef runRemoteTH readQResult getTHState annotThType mkIsPolyTvsfindEnclosingDeclsupdateFixityEnv runPipelinepipeLoopPipelineOutput Temporary PersistentStringfastLlvmPipeline llvmOptions linkStaticLibsourceModifiedgetGhcVersionPathName runPipeline'CompilationGraphGHC.MVarMVarLogQueue StableModulesupsweep loadFinish discardProg discardICguessOutputFilepruneHomePackageTablefindPartiallyCompletedCyclesbuildCompGraph BuildModule parUpsweep upsweep_mod getModLoopwarnUnnecessarySourceImports downsweepenableCodeGenForTHmsDepsparUpsweep_onepreprocessFilecheckBrokenTablesNextToCodecheckNewDynFlagsHsSynHsModule hsmodName hsmodExports hsmodImports hsmodDeclshsmodDeprecMessagehsmodHaddockModHeader lPatImplicitshsValBindsImplicitslStmtsImplicitshsDataFamInstBindersgetPatSynBindshsPatSynSelectorshsForeignDeclsBindershsLTyClDeclBindershsTyClForeignBindershsGroupBinderscollectPatsBinderscollectPatBinderscollectStmtBinderscollectLStmtBinderscollectStmtsBinderscollectLStmtsBinderscollectMethodBinderscollectHsBindListBinderscollectHsBindsBinderscollectHsBindBinderscollectHsValBinderscollectHsIdBinderscollectLocalBindersisBangedHsBindisUnliftedHsBindmkMatchmkPrefixFunRhsmk_easy_FunBindisInfixFunBind mkPatSynBind mkVarBind mkHsVarBind mkTopFunBind mkFunBind mkHsWrapPatCo mkHsWrapPat mkLHsCmdWrap mkHsCmdWrap mkLHsWrapCo mkHsWrapCoR mkHsWrapComkHsWrap mkLHsWrap typeToLHsType mkClassOpSigs mkHsSigEnvmkLHsSigWcType mkLHsSigTypechunkify mkChunkifiedmkBigLHsPatTupmkBigLHsVarPatTup mkBigLHsTupmkBigLHsVarTup missingTupArg nlTuplePat mkLHsVarTuplemkLHsTupleExpr nlHsAppKindTy nlHsTyConApp nlHsParTy nlHsFunTy nlHsTyVar nlHsAppTynlListnlHsCasenlHsIfnlHsParnlHsLam nlHsOpAppnlHsDo nlWildPatName nlWildPat nlWildConPatnlNullaryConPat nlConPatNamenlConPat nlInfixConPatnlConVarPatName nlConVarPat nlHsVarAppsnlHsAppsnlHsSyntaxAppsnlHsAppnlLitPatnlVarPat nlHsIntLitnlHsLit nlHsDataConnlHsVaruserHsTyVarBndrsuserHsLTyVarBndrsmkHsStringPrimLit mkHsStringunqualQuasiQuotemkHsQuasiQuote mkTypedSplicemkUntypedSplice mkHsOpApp mkRecStmtemptyRecStmtIdemptyRecStmtName emptyRecStmt unitRecStmtTc mkTcBindStmt mkBindStmt mkBodyStmt mkLastStmtmkGroupByUsingStmtmkGroupUsingStmtmkTransformByStmtmkTransformStmtemptyTransStmt mkNPlusKPatmkNPat mkHsCmdIfmkHsIfmkHsCompmkHsDo mkHsIsStringmkHsFractional mkHsIntegralnlParPatmkParPatmkLHsPar nlHsTyApps nlHsTyAppmkHsLamsmkHsLam mkHsAppTypes mkHsAppType mkMatchGroup unguardedRHSunguardedGRHSs mkSimpleMatchmkHsPar pprStmtInCtxtpprMatchInCtxtmatchContextErrStringpprStmtContextpprAStmtContextpprMatchContextNounpprMatchContextmatchSeparatorisMonadCompContextisMonadFailStmtContextisComprehensionContext isPatSynCtxt pp_dotdot thTyBrackets thBrackets pprHsBracketisTypedBracket ppr_splice ppr_quasippr_splice_declpprPendingSplice isTypedSplicepprQualspprComp ppr_do_stmtspprDopprBy pprTransStmtpprTransformStmtpprStmtpp_rhspprGRHSpprGRHSspprMatch pprMatches hsLMatchPatsmatchGroupArityisSingletonMatchGroupisEmptyMatchGroup isInfixMatch pprCmdArgppr_cmdppr_lcmd isQuietHsCmdpprCmdpprLCmdisAtomicHsExprparenthesizeHsExprhsExprNeedsParens pprParendExprpprParendLExprpprDebugParendExprpprExternalSrcLocppr_appsppr_expr ppr_lexprpprBinds isQuietHsExpr tupArgPresent unboundVarOccmkRnSyntaxExpr mkSyntaxExpr noSyntaxExprnoExpr PostTcExpr PostTcTableCmdSyntaxTable UnboundVar OutOfScope TrueExprHole RecordConTc rcon_con_like rcon_con_expr RecordUpdTc rupd_cons rupd_in_tys rupd_out_tys rupd_wrap LHsTupArgHsTupArgPresentMissingXTupArgLHsCmd HsArrAppTypeHsHigherOrderAppHsFirstOrderApp LHsCmdTopHsCmdTopXCmdTopCmdTopTc HsRecordBinds MatchGroupTc mg_arg_tys mg_res_tyLMatchXMatchm_extm_ctxtm_patsm_grhssLGRHSGRHSXGRHSLStmtLStmtLRStmtCmdLStmtCmdStmt ExprLStmtExprStmt GuardLStmt GuardStmt GhciLStmtGhciStmtStmtLRLastStmtBindStmtApplicativeStmtBodyStmtLetStmtParStmt TransStmtRecStmtXStmtLRtrS_exttrS_form trS_stmts trS_bndrs trS_usingtrS_bytrS_rettrS_bindtrS_fmaprecS_ext recS_stmtsrecS_later_ids recS_rec_ids recS_bind_fn recS_ret_fn recS_mfix_fn RecStmtTc recS_bind_tyrecS_later_rets recS_rec_rets recS_ret_ty TransFormThenForm GroupForm ParStmtBlock XParStmtBlockApplicativeArgApplicativeArgOneApplicativeArgManyXApplicativeArgSpliceDecoration HasParens HasDollarNoParensThModFinalizers DelayedSpliceHsSplicedThing HsSplicedExpr HsSplicedTy HsSplicedPatSplicePointNamePendingRnSpliceUntypedSpliceFlavourUntypedExpSpliceUntypedPatSpliceUntypedTypeSpliceUntypedDeclSplicePendingTcSplice HsBracketXBracketExpBrPatBrDecBrLDecBrGTypBrVarBrTExpBr ArithSeqInfoFromFromThenFromTo FromThenToHsMatchContextPatSynFunRhs LambdaExprIfAltProcExpr PatBindRhs PatBindGuardsRecUpdStmtCtxt ThPatSplice ThPatQuotemc_fun mc_fixity mc_strictness HsStmtContextListComp MonadCompDoExprMDoExpr ArrowExpr GhciStmtCtxtPatGuard ParStmtCtxt TransStmtCtxtroleAnnotDeclNameannProvenanceName_maybe docDeclDocpprFullRuleNamecollectRuleBndrSigTysflattenRuleDeclsderivStrategyNameinstDeclDataFamInstspprHsFamInstLHSpprDataFamInstFlavourhsConDeclThetahsConDeclArgTys getConArgs getConNamesnewOrDataToFlavourresultVariableNamefamDeclHasCusk mkTyClGrouptyClGroupRoleDeclstyClGroupInstDeclstyClGroupTyClDeclsemptyTyClGrouppprTyClDeclFlavour hsDeclHasCuskcountTyClDeclstyClDeclTyVarstcdName tyClDeclLNametyFamInstDeclLNametyFamInstDeclNameisDataFamilyDeclisClosedTypeFamilyInfoisOpenTypeFamilyInfoisTypeFamilyDecl isFamilyDecl isClassDecl isSynDecl isDataDecl appendGroupshsGroupInstDecls emptyRnGroup emptyRdrGroupLHsDeclHsDeclValDSigD RoleAnnotDTyClDInstDDerivDDefDForDWarningDAnnDRuleDSpliceDDocDXHsDeclXHsGrouphs_exths_valds hs_splcds hs_tyclds hs_derivdshs_fixdshs_defdshs_fords hs_warndshs_annds hs_ruledshs_docs LSpliceDecl SpliceDecl XSpliceDecl LTyClDeclTyClDeclFamDeclSynDeclDataDecl ClassDecl XTyClDecltcdFExttcdFamtcdSExttcdLName tcdTyVars tcdFixitytcdRhstcdDExt tcdDataDefntcdCExttcdCtxttcdFDstcdSigstcdMethstcdATs tcdATDefstcdDocs LHsFunDep DataDeclRn tcdDataCusktcdFVs TyClGroup XTyClGroup group_ext group_tyclds group_roles group_instdsLFamilyResultSigFamilyResultSigNoSigKindSigTyVarSigXFamilyResultSig LFamilyDecl FamilyDecl XFamilyDeclfdExtfdInfofdLNamefdTyVarsfdFixity fdResultSigfdInjectivityAnnLInjectivityAnnInjectivityAnn FamilyInfo DataFamilyOpenTypeFamilyClosedTypeFamily HsDataDefn XHsDataDefndd_extdd_NDdd_ctxtdd_cType dd_kindSigdd_cons dd_derivs HsDerivingLHsDerivingClauseHsDerivingClauseXHsDerivingClausederiv_clause_extderiv_clause_strategyderiv_clause_tys NewOrDataDataTypeNewTypeLConDeclConDecl ConDeclGADT ConDeclH98XConDecl con_g_ext con_names con_forall con_qvars con_mb_cxtcon_args con_res_tycon_doccon_extcon_name con_ex_tvsHsConDeclDetails LTyFamInstEqnLTyFamDefltEqnHsTyPats TyFamInstEqn TyFamDefltEqnLTyFamInstDecl TyFamInstDecltfid_eqnLDataFamInstDeclDataFamInstDecldfid_eqn LFamInstEqn FamInstEqnFamEqnXFamEqnfeqn_ext feqn_tycon feqn_bndrs feqn_pats feqn_fixityfeqn_rhs LClsInstDecl ClsInstDecl XClsInstDeclcid_ext cid_poly_ty cid_bindscid_sigscid_tyfam_instscid_datafam_instscid_overlap_mode LInstDeclInstDeclClsInstD DataFamInstD TyFamInstD XInstDecl cid_d_extcid_instdfid_ext dfid_insttfid_ext tfid_inst LDerivDecl DerivDecl XDerivDecl deriv_ext deriv_typederiv_strategyderiv_overlap_modeLDerivStrategy StockStrategyAnyclassStrategyNewtypeStrategy ViaStrategy LDefaultDecl DefaultDecl XDefaultDecl LForeignDecl ForeignDecl ForeignExport ForeignImport XForeignDeclfd_i_extfd_name fd_sig_tyfd_fifd_e_extfd_feCImport CImportSpec CFunctionCWrapperCExport LRuleDecls RuleDeclsHsRules XRuleDeclsrds_extrds_src rds_rules LRuleDeclRuleDeclHsRule XRuleDeclrd_extrd_namerd_actrd_tyvsrd_tmvsrd_lhsrd_rhsHsRuleRn LRuleBndrRuleBndr RuleBndrSig XRuleBndrLDocDeclDocDeclDocCommentNextDocCommentPrevDocCommentNamedDocGroup LWarnDecls WarnDecls XWarnDeclswd_extwd_src wd_warnings LWarnDeclWarnDeclWarning XWarnDeclLAnnDeclAnnDecl HsAnnotationXAnnDecl AnnProvenanceValueAnnProvenanceTypeAnnProvenanceModuleAnnProvenanceLRoleAnnotDecl RoleAnnotDeclXRoleAnnotDeclcollectEvVarsPatcollectEvVarsPatsparenthesizePatpatNeedsParensisIrrefutableHsPatlooksLazyPatBind isBangedLPat mkCharLitPatmkNilPatmkPrefixConPat pprConArgs pprParendLPathsRecUpdFieldOcchsRecUpdFieldIdhsRecUpdFieldRdr hsRecFieldId hsRecFieldSelhsRecFieldsArgs hsRecFields hsConPatArgsInPatOutPat ListPatTcHsConPatDetails HsRecFieldsrec_flds rec_dotdot LHsRecField' LHsRecFieldLHsRecUpdField HsRecField HsRecUpdField HsRecField' hsRecFieldLbl hsRecFieldArghsRecPunHsBinds pprMinimalSigpprTcSpecPragspprSpec pprVarSigpragSrcBrackets pragBracketsppr_sighsSigDocisCompleteMatchSig isSCCFunSig isMinimalLSig isInlineLSig isPragLSigisSpecInstLSig isSpecLSig isTypeLSig isFixityLSigisDefaultMethod hasSpecPrags noSpecPragsisEmptyIPBindsTcisEmptyIPBindsPRpprTicks ppr_monobindplusHsValBindsisEmptyLHsBinds emptyLHsBindsemptyValBindsOutemptyValBindsInisEmptyValBindseqEmptyLocalBindsisEmptyLocalBindsPRisEmptyLocalBindsTcemptyLocalBinds pprDeclListpprLHsBindsForUser pprLHsBinds HsLocalBinds LHsLocalBindsHsLocalBindsLR HsIPBinds HsValBindsEmptyLocalBindsXHsLocalBindsLRLHsLocalBindsLR HsValBindsLRValBinds XValBindsLR NHsValBindsLR NValBindsLHsBindLHsBindsHsBind LHsBindsLR LHsBindLRHsBindLR PatSynBindFunBindPatBindVarBindAbsBinds XHsBindsLRfun_extfun_id fun_matches fun_co_fnfun_tickpat_extpat_lhspat_rhs pat_ticksvar_extvar_idvar_rhs var_inlineabs_extabs_tvs abs_ev_vars abs_exports abs_ev_binds abs_bindsabs_sig NPatBindTcpat_fvs pat_rhs_tyABExportABE XABExportabe_extabe_polyabe_monoabe_wrap abe_prags XPatSynBindPSBpsb_extpsb_idpsb_argspsb_defpsb_dir XHsIPBindsIPBindsLIPBindIPBindXIPBindLSigSigTypeSig PatSynSig ClassOpSigIdSigFixSig InlineSigSpecSig SpecInstSig MinimalSig SCCFunSigCompleteMatchSigXSig LFixitySig FixitySig XFixitySig TcSpecPragsIsDefaultMethod SpecPrags LTcSpecPrag TcSpecPragSpecPragHsPatSynDetailsRecordPatSynFieldrecordPatSynSelectorIdrecordPatSynPatVar HsPatSynDirUnidirectionalImplicitBidirectionalExplicitBidirectionalparenthesizeHsContextparenthesizeHsTypehsTypeNeedsParens pprHsTypepprConDeclFields pprLHsContextpprHsExplicitForAllpprHsForAllExtra pprHsForAllpprAnonWildCardambiguousFieldOccunambiguousFieldOccselectorAmbiguousFieldOccrdrNameAmbiguousFieldOccmkAmbiguousFieldOcc mkFieldOccgetLHsInstDeclClass_maybegetLHsInstDeclHeadsplitLHsInstDeclTysplitLHsQualTysplitLHsForAllTyInvissplitLHsForAllTysplitLHsSigmaTyInvissplitLHsSigmaTysplitLHsPatSynTynumVisibleArgshsTyGetAppHead_maybesplitHsFunType mkHsAppKindTy mkHsAppTysmkHsOpTymkAnonWildCardTy isLHsForAllTy ignoreParenshsLTyVarBndrsToTypeshsLTyVarBndrToTypehsLTyVarLocNameshsLTyVarLocNamehsAllLTyVarNameshsExplicitLTyVarNames hsLTyVarNames hsLTyVarName hsTyVarName hsScopedTvs hsWcScopedTvshsTvbAllKindedisHsKindedTyVar hsIPNameFSmkEmptyWildCardBndrsmkEmptyImplicitBndrsmkHsWildCardBndrsmkHsImplicitBndrs dropWildCards hsSigWcType hsSigTypehsImplicitBodyisEmptyLHsQTvs emptyLHsQTvs hsQTvExplicitmkHsQTvs noLHsContextgetBangStrictness getBangType LBangTypeBangType HsContextHsKindLHsKind LHsTyVarBndrHsQTvs XLHsQTyVarshsq_ext hsq_explicitHsImplicitBndrsHsIBXHsImplicitBndrshsib_ext hsib_bodyHsWildCardBndrsHsWCXHsWildCardBndrshswc_ext hswc_body LHsSigType LHsWcType LHsSigWcTypeHsIPName HsTyVarBndr UserTyVar KindedTyVar XTyVarBndrHsTypeHsTyLitHsTyVarHsAppTy HsAppKindTyHsFunTyHsListTy HsTupleTyHsSumTyHsOpTyHsParTy HsIParamTyHsStarTy HsKindSig HsSpliceTyHsDocTyHsBangTyHsRecTyHsExplicitListTyHsExplicitTupleTy HsWildCardTyXHsType hst_xforallhst_fvf hst_bndrshst_body hst_xqualhst_ctxt NewHsTypeX NHsCoreTyHsNumTyHsStrTy HsTupleSortHsUnboxedTuple HsBoxedTupleHsConstraintTupleHsBoxedOrConstraintTuple LConDeclField ConDeclField XConDeclField cd_fld_ext cd_fld_names cd_fld_type cd_fld_doc HsConDetails PrefixConRecConInfixConHsArgHsValArg HsTypeArgHsArgPar LHsTypeArg LFieldOccFieldOcc XFieldOcc extFieldOccrdrNameFieldOccAmbiguousFieldOcc Unambiguous AmbiguousXAmbiguousFieldOcchsOverLitNeedsParenshsLitNeedsParens pmPprHsLit pp_st_suffix convertLit overLitTypenegateOverLitValHsChar HsCharPrimHsString HsStringPrimHsInt HsIntPrim HsWordPrim HsInt64Prim HsWord64Prim HsIntegerHsRat HsFloatPrim HsDoublePrimXLit HsOverLitXOverLitol_extol_val ol_witness OverLitTc ol_rebindableol_type OverLitVal HsIntegral HsFractional HsIsStringpprLExpr pprSplice pprSpliceDecl pprPatBind pprFunBindHsVar HsUnboundVar HsConLikeOutHsRecFld HsOverLabelHsIPVarHsLam HsLamCase HsAppTypeOpAppNegAppHsParSectionLSectionR ExplicitTuple ExplicitSumHsCaseHsIf HsMultiIfHsLetHsDo ExplicitList RecordCon RecordUpd ExprWithTySigArithSeqHsSCC HsCoreAnnHsRnBracketOutHsTcBracketOut HsSpliceEHsProcHsStaticHsTick HsBinTick HsTickPragmaEWildPatEAsPatEViewPatELazyPatHsWrapXExprrcon_ext rcon_con_name rcon_fldsrupd_ext rupd_expr rupd_fldsHsCmd HsCmdArrApp HsCmdArrFormHsCmdAppHsCmdLamHsCmdPar HsCmdCaseHsCmdIfHsCmdLetHsCmdDo HsCmdWrapXCmdHsSplice HsTypedSpliceHsUntypedSplice HsQuasiQuote HsSpliced HsSplicedTXSplice MatchGroupMG XMatchGroupmg_extmg_alts mg_originGRHSsXGRHSsgrhssExt grhssGRHSsgrhssLocalBinds SyntaxExprsyn_expr syn_arg_wraps syn_res_wrapLHsExpr pprImpExpreplaceLWrappedNamereplaceWrappedNameieLWrappedNamelieWrappedName ieWrappedNameieNamesieNamesimpleImportDecl ImportDecl XImportDeclideclExtideclSourceSrc ideclName ideclPkgQual ideclSource ideclSafeideclQualified ideclImplicitideclAs ideclHiding IEWrappedNameIEName IEPatternLIEWrappedNameLIEIEIEVar IEThingAbs IEThingAll IEThingWithIEModuleContentsIEGroupIEDoc IEDocNamedXIE IEWildcard NoIEWildcardWildPatVarPatLazyPatAsPatParPatBangPatListPatTuplePatSumPatConPatIn ConPatOutViewPat SplicePatLitPatNPat NPlusKPatSigPatCoPatXPatpat_con pat_arg_tyspat_tvs pat_dicts pat_bindspat_argspat_wrapLPat HsExtensionnoExtGhcPassPassParsedRenamed TypecheckedGhcPsGhcRnGhcTcGhcTcIdIdPLIdPNoGhcTc NoGhcTcPass XHsValBindsXEmptyLocalBindsXXHsLocalBindsLRForallXHsLocalBindsLR XValBinds XXValBindsLRForallXValBindsLRXFunBindXPatBindXVarBind XAbsBinds XXHsBindsLRForallXHsBindsLRXABE XXABExportForallXABExportXPSB XXPatSynBindForallXPatSynBindXIPBinds XXHsIPBindsForallXHsIPBindsXCIPBindXXIPBind ForallXIPBindXTypeSig XPatSynSig XClassOpSigXIdSigXFixSig XInlineSigXSpecSig XSpecInstSig XMinimalSig XSCCFunSigXCompleteMatchSigXXSig ForallXSig XXFixitySigForallXFixitySigXTyClDXInstDXDerivDXValDXSigDXDefDXForD XWarningDXAnnDXRuleDXSpliceDXDocD XRoleAnnotDXXHsDecl ForallXHsDecl XCHsGroup XXHsGroupForallXHsGroup XXSpliceDeclForallXSpliceDeclXFamDeclXSynDecl XDataDecl XClassDecl XXTyClDeclForallXTyClDecl XCTyClGroup XXTyClGroupForallXTyClGroupXNoSig XCKindSig XTyVarSigXXFamilyResultSigForallXFamilyResultSig XCFamilyDecl XXFamilyDeclForallXFamilyDecl XCHsDataDefn XXHsDataDefnForallXHsDataDefnXCHsDerivingClauseXXHsDerivingClauseForallXHsDerivingClause XConDeclGADT XConDeclH98 XXConDeclForallXConDeclXCFamEqnXXFamEqn ForallXFamEqn XCClsInstDecl XXClsInstDeclForallXClsInstDecl XClsInstD XDataFamInstD XTyFamInstD XXInstDeclForallXInstDecl XCDerivDecl XXDerivDeclForallXDerivDecl XViaStrategy XCDefaultDecl XXDefaultDeclForallXDefaultDeclXForeignImportXForeignExport XXForeignDeclForallXForeignDecl XCRuleDecls XXRuleDeclsForallXRuleDeclsXHsRule XXRuleDeclForallXRuleDecl XCRuleBndr XRuleBndrSig XXRuleBndrForallXRuleBndr XWarnings XXWarnDeclsForallXWarnDeclsXWarning XXWarnDeclForallXWarnDecl XHsAnnotation XXAnnDeclForallXAnnDeclXCRoleAnnotDeclXXRoleAnnotDeclForallXRoleAnnotDeclXVar XUnboundVar XConLikeOutXRecFld XOverLabelXIPVar XOverLitEXLitEXLamXLamCaseXApp XAppTypeEXOpAppXNegAppXPar XSectionL XSectionRXExplicitTuple XExplicitSumXCaseXIfXMultiIfXDo XExplicitList XRecordCon XRecordUpdXExprWithTySig XArithSeqXSCCXCoreAnn XRnBracketOut XTcBracketOutXSpliceEXProcXStaticXTickXBinTick XTickPragma XEWildPatXEAsPat XEViewPat XELazyPatXWrapXXExpr ForallXExpr XUnambiguous XAmbiguousXXAmbiguousFieldOccForallXAmbiguousFieldOccXPresentXMissingXXTupArg ForallXTupArg XTypedSpliceXUntypedSplice XQuasiQuoteXSplicedXXSplice ForallXSpliceXExpBrXPatBrXDecBrLXDecBrGXTypBrXVarBrXTExpBr XXBracketForallXBracketXXCmdTop ForallXCmdTopXMG XXMatchGroupForallXMatchGroupXCMatchXXMatch ForallXMatchXCGRHSsXXGRHSs ForallXGRHSsXCGRHSXXGRHS ForallXGRHS XLastStmt XBindStmtXApplicativeStmt XBodyStmtXLetStmtXParStmt XTransStmtXRecStmtXXStmtLR ForallXStmtLR XCmdArrApp XCmdArrFormXCmdAppXCmdLamXCmdParXCmdCaseXCmdIfXCmdLetXCmdDoXCmdWrapXXCmd ForallXCmdXXParStmtBlockForallXParStmtBlockXApplicativeArgOneXApplicativeArgManyXXApplicativeArgForallXApplicativeArgXHsChar XHsCharPrim XHsString XHsStringPrimXHsInt XHsIntPrim XHsWordPrim XHsInt64Prim XHsWord64Prim XHsIntegerXHsRat XHsFloatPrim XHsDoublePrimXXLit ForallXHsLit XXOverLitForallXOverLitXWildPatXVarPatXLazyPatXAsPatXParPatXBangPatXListPat XTuplePatXSumPatXConPatXViewPat XSplicePatXLitPatXNPat XNPlusKPatXSigPatXCoPatXXPat ForallXPatXHsQTvs XXLHsQTyVarsForallXLHsQTyVarsXHsIBXXHsImplicitBndrsForallXHsImplicitBndrsXHsWCXXHsWildCardBndrsForallXHsWildCardBndrs XForAllTyXQualTyXTyVarXAppTy XAppKindTyXFunTyXListTyXTupleTyXSumTyXOpTyXParTy XIParamTyXStarTyXKindSig XSpliceTyXDocTyXBangTyXRecTyXExplicitListTyXExplicitTupleTyXTyLit XWildCardTyXXType ForallXType XUserTyVar XKindedTyVar XXTyVarBndrForallXTyVarBndrXXConDeclFieldForallXConDeclField XCFieldOcc XXFieldOccForallXFieldOcc XCImportDecl XXImportDeclForallXImportDeclXIEVar XIEThingAbs XIEThingAll XIEThingWithXIEModuleContentsXIEGroupXIEDoc XIEDocNamedXXIE ForallXIE Convertableconvert ConvertIdX OutputableXOutputableBndrId PlaceHolderplaceHolderNamesTc NameOrRdrNameHsDocemptyArgDocMapemptyDeclDocMap concatDocs appendDocs ppr_mbDochsDocStringToByteString unpackHDSmkHsDocStringUtf8ByteString mkHsDocString HsDocString LHsDocString DeclDocMap ArgDocMapbindSuspensionsBkpEnvSession bkp_session bkp_filename bkp_table bkp_levelBkpM SessionType ExeSession TcSession CompSessionwithBkpSession hsunitDeps getBkpEnv getBkpLeveloverHscDynFlags innerBkpM updateEpsGhc_ getEpsGhcinitBkpMbackpackProgressMsg mkBackpackMsg backpackStyle msgTopPackage msgUnitId msgIncludehsunitModuleGraphhsModuleToModSummarynewInstalledUnitId