h$ cz      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             ! " " " """""""""" ###$$$$$$$%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%&&&&'((((())))))))))))))))))))))))))))))))****+,,,,,,,,,,,,,,,,,,,,,,,,----------------------------------------------------------------.............///////////////000000000000000000000111111111111111222222222222222222222222222222222222222222222222333333333333333333333333344444455555555566666666778888888999999999999999999::::::::::::::;;;;<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<===========>>>>??@@@@@@@@@@@@@@@@@@@@@@AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEFFFFFFFFFGHHHHHHHHHHHHHIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIJJKKKLMMMNNNNNOOOOOOOOOPPPPPPPPPQQQQRSSTUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUVWXYZ[[[[[[[[[[[[[[[[[[[[[[[[\\YY]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]^___________________________________________________________________________________`aaaaaaaaaaaaaaabcccccdddeeeeeeeeeeeeeeee^^^^^^^fggghhhhhhhhhhhhhhhhhhhiiiijjjjjjjjjjjjjjjjjjjjjjjjjjjjjjkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkllllllllllmmmmmmmnnnnnnnnnnnnnnoooppppppppppqqqrrrrrrrrrrrrrssssssssssssssssssssssssssssssssssssssssssssssssssssssssssttttttttttttttttuvvvvvvvvvvvvvvvvvvvvvvvvwwxyyyyyyyyyyyyyyyyyyyyyyzzz{{|}~~~                                                                                                                                !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!#!!!!!!!""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""############################################# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& & & & & & & & & & & & &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((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+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,--------------------------------------------------------------------------------------------------------------------------------.................................................. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /////00000000000000000000000~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~0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T1T1T1T1T1T1T1T1T1T1T1T1T1T1111111111111111111111111111111111111111111111111111111111111111111W1W1W1W1W1W1W1W1W1W1W1W1W1W1W1W1W1W1W1W1W11111111111111111111111111112222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222233333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444445555555555555555555555 555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555566666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777778888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888899999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::#:#:#:#:::::::::::::::::::::::::::::::::::::::::;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<================================================================================================================================>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>?????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????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@U@U@U@U@U@U@U@U@U@U@U@U@U@U@U@U@U@U@U@U@U@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYAYAYAYAYAYAYAYAXAXAXAXAXAXAXAXAXAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDqDqDqDqDqDqDqDDDDDDDD NoneNone\  Noneñ 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 GHC.Builtin.Names) ghc-libGiven a  lookup its associated ) if it corresponds to a known-key thing. ghc-libIs a  known-key? ghc-libGiven a  lookup any associated arbitrary SDoc's to be displayed by GHCi's ':info' command.  None '(/ ghc-libFunction 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-libReturns 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-libFolds 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.  None'(a None >ȴ  None '(>?  None'(?ə ghc-libThe dataflow lattice ghc-lib'Calculated liveness info for a CmmGraph ghc-libThe dataflow lattice  None'( ghc-libWe make a top-level decl for the string, and return a label pointing to it ghc-libWe make a top-level decl for the embedded binary file, and return a label pointing to it ghc-libBuild a data-segment data block ghc-libUseful for creating an index into an array, with a statically known offset. The type is the element type; used for making the multiplier ghc-libUseful for creating an index into an array, with an unknown offset. ghc-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. ghc-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]. ghc-liblike  (, but the entry block always comes first ghc-libLike  , 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  GHC.Cmm.Node. -GBM ghc-lib1Extract all tick annotations from the given block !None'( ghc-libTraverses the D, making sure that D# are suitable for code generation.  "None'(>?0 $Noneghc-libGiven a list of arguments, and a function that tells their types, return a list showing where each argument is passed%None'( 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  *, with the meaning that control flows from the first to the second.A  can be turned into a D (closed at both ends) by providing a label for the entry point and a tick scope; see .ghc-lib.creates a sequence "goto id; id:" as an AGraphghc-lib(creates an open AGraph from a given nodeghc-lib)creates 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-libA jump where the caller says what the live GlobalRegs are. Used for low-level hand-written Cmm.ghc-lib Construct a D7 node for the given register and unwinding expression.**&None٪'None'((None'(5?)None'(>?Tghc-lib(Expressions, used for unwind informationghc-lib literal valueghc-libregister plus offsetghc-libpointer dereferencingghc-libMaps 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 D= when the register's previous value cannot be reconstructed.ghc-libA label associated with an ghc-libDebug 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-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-libSets 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.*None'(+None'(,(c) Matt Morrow 2009BSD3stableportableNone?ghc-lib Dominators. Complexity as for idomghc-libPost-dominators. Complexity as for idom.ghc-libDominator tree. Complexity as for idom.ghc-libPost-dominator tree. Complexity as for idom.ghc-libImmediate dominators. O(|E|*alpha(|E|,|V|)), where  alpha(m,n)4 is "a functional inverse of Ackermann's function".This Complexity bound assumes O(1) indexing. Since we're using IntMap, it has an additional lg |V|0 factor somewhere in there. I'm not sure where.ghc-libImmediate post-dominators. Complexity as for idom.ghc-lib!Post-dominated depth-first search.ghc-lib)Reverse post-dominated depth-first search.D2D9 -None /ghc-libInformation about edgesghc-libCan we trace back a edge to a specific Cmm Node or has it been introduced during assembly 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-libA control flow graph where edges have been annotated with a weight. Implemented as IntMap (IntMap ) We must uphold the invariant that for each edge A -> B we must have: A entry B in the outer map. A entry B in the map we get when looking up A. Maintaining this invariant is useful as any failed lookup now indicates an actual error in code which might go unnoticed for a while otherwise.ghc-libConvenience function, generate edge info based on weight not originating from cmm.ghc-libAdjust the weight between the blocks using the given function. If there is no such edge returns the original map.ghc-libSet the weight between the blocks to the given weight. If there is no such edge returns the original map.ghc-lib!Is this block part of this graph?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-libFilter 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 => -> Cghc-lib5Adds a new edge, overwrites existing edges if presentghc-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 infoghc-lib5Returns a unordered list of all edges without weightsghc-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-libGenerate weights for a Cmm proc based on some simple heuristics.ghc-libDetermine loop membership of blocks based on SCC analysis This is faster but only gives yes/no answers.ghc-libDetermine loop membership of blocks based on Dominator analysis. This is slower but gives loop levels instead of just loop membership. However it only detects natural loops. Irreducible control flow is not recognized even if it loops. But that is rare enough that we don't have to care about that special case.ghc-libWe take in a CFG which has on its edges weights which are relative only to other edges originating from the same node.We return a CFG for which each edge represents a GLOBAL weight. This means edge weights are comparable across the whole graph.For irreducible control flow results might be imprecise, otherwise they are reliable.The algorithm is based on the Paper "Static Branch Prediction and Program Profile Analysis" by Y Wu, JR Larus The only big change is that we go over the nodes in the body of loops in reverse post order. Which is required for diamond control flow to work probably.We also apply a few prediction heuristics (based on the same paper)The returned result represents frequences. For blocks it's the expected number of executions and for edges is the number of traversals.ghc-libEdges are sorted ascending pointwise by weight, source and destinationghc-libCareful! Since we assume there is at most one edge from A to B the Eq instance does not consider weight.//.None  /Noneghc-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.  0NoneYghc-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-libGet 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-libApply 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-libGive 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-libCheck whether this instruction is some meta thing inserted into the instruction stream for other purposes.Not something that has to be treated as a real machine instruction and have its registers allocated. eg, comments, delta, ldata, etc.ghc-libCopy the value in a register to another one. Must work for all register classes.ghc-libTake 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-libPretty-print an instructionghc-libHolds 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!)As far as we are concerned, the fixed registers simply don't exist (for allocation purposes, anyway).ghc-libNo regs read or written to.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 register1None2Noneghc-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.003None ghc-lib"A subcomponent of another registerghc-libA register of some classghc-libWorst case displacementa 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.This 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-libThe 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 aliased registers don't get counted twice, as per the paper.ghc-libso we can put regs in UniqSets4None Tghc-lib!Determine the class of a registerghc-lib4Determine all the regs that make up a certain class.ghc-libDetermine 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-libOptimised versions of RegColorBase.{worst, squeese} specific to x865None 6None 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 allocated7None 8None,ghc-lib9We need 8 bytes because our largest registers are 64 bit.ghc-libWe (allegedly) put the first six C-call arguments in registers; where do we start putting the rest of them?ghc-lib6Check whether an offset is representable with 13 bits.ghc-libCheck 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.ghc-libSadness.9 Safe-Inferredghc-libBranch condition codes.:Noneghc-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.ghc-lib'Create a ImmLit containing this string.ghc-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.;Noneghc-libRepresents a memory address in an instruction. Being a RISC machine, the SPARC addressing modes are very regular.ghc-lib4Add an integer offset to the address in an AddrMode.<NoneQghc-lib8Get the standard name for the register with this number.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-libAll the allocatable registers in the machine, including register pairs.ghc-lib"Get the regno for this sort of regghc-lib"Get the regno for this sort of regghc-lib"Get the regno for this sort of regghc-lib"Get the regno for this sort of regghc-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-libProduce 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-libThe registers to place arguments for function calls, for some number of arguments.ghc-lib7All the regs that could possibly be returned by argRegsghc-lib$Make a virtual reg with this format.=Nonemghc-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 mghc-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-libThe maximum number of spill slots available on the C stack. If we use up all of the slots, then we're screwed.Why do we reserve 64 bytes, instead of using the whole thing?? -- BL 20090215ghc-lib+stack offset in words, positive or negativeNone   ?None!ghc-libReturns 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).@ Safe-Inferred$8ghc-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 maybeInvertCond 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.ANone'Fghc-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-libGet the name of the register with this number. NOTE: fixme, we dont track which "way" the XMM registers are usedghc-libthese are the regs which we cannot assume stay alive over a C call.ghc-libon 64bit platforms we pass the first 8 float/double arguments in the xmm registers.ghc-lib3desired stack offset in bytes, positive or negativeBNone(CNone(DNone- ghc-libX86 call instructionghc-libReturns which registers are read and written as a (read, written) pair.ghc-libApplies the supplied function to all registers in instructions. Typically used to change virtual registers to real registers.ghc-libMake a spill instruction.ghc-lib Make a spill reload instruction.ghc-lib?See if this instruction is telling us the current C stack deltaghc-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.ghc-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.ghc-lib)Make an unconditional branch instruction.ghc-lib Jump targetghc-lib,Arguments (required for register allocation)ENone6ghc-libSPARC instruction set. Not complete. This is only the ones we need.ghc-libRegister or immediateghc-libCheck if a RI represents a zero value. - a literal zero - register %g0, which is always zero.ghc-libCalculate the effective address which would be used by the corresponding fpRel sequence.ghc-lib+Code to shift the stack pointer by n words.ghc-libAn instruction that will cause the one after it never to be exectutedghc-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).ghc-libApply a given mapping to tall the register references in this instruction.ghc-libMake a spill instruction. On SPARC we spill below frame pointer leaving 2 words/spillghc-lib Make a spill reload instruction.ghc-lib?See if this instruction is telling us the current C stack deltaghc-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.ghc-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.ghc-lib)Make an unconditional branch instruction.ghc-libregister to spillghc-libcurrent stack deltaghc-libspill slot to useghc-libregister to load intoghc-libcurrent stack deltaghc-libspill slot to use==FNone7GNone8!ghc-lib9Expand out synthetic instructions in this top level thingHNone;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.Rules of this simplified insn selection game are therefore that the returned Reg may be modifiedghc-lib#Condition codes passed up the tree.ghc-libs 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  INone5@X ghc-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.ghc-lib is only for printing internal labels. See Note [Internal proc labels] in CLabel.ghc-libThe list of block ids records the redirected jumps to allow us to update the CFG.ghc-libgiven the instruction sequence of a block, produce a list of the block's 2s See Note [What is this unwinding business?] in GHC.Cmm.DebugBlock= and Note [Unwinding information in the NCG] in this module.ghc-libTurn the sequence of jcc l1; jmp l2 into jncc l2;  when possible.ghc-libGet CFG edge weightsghc-lib%Record that we added a block between from and old.ghc-libPlace D after block' and change any edges block -> X to D -> Xghc-lib'Get native code generator configurationghc-lib?F|ghc-lib CoreMap a is a map from D to a3. If you are a client, this is the type you want.  SNoneGghc-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.VNoneGZNoneG[NoneH!\NoneHNoneH  ]NoneIXghc-libA substitution result._NoneJ`NoneLaNonePghc-libDescribes the outer shape of an argument to be unboxed or left as-is Depending on how s is instantiated (e.g., D).ghc-lib/We ran out of strictness info. Leave untouched.ghc-libThe argument is used strictly or the returned product was constructed, so unbox it. The 4 carries the bits necessary for instantiation with dataConRepInstPat. The [s] carries the bits of information with which we can continue unboxing, e.g. s will be D.ghc-libThe information needed to build a pattern for a DataCon to be unboxed. The pattern can be generated from  and  via . The coercion  is for newtype wrappers. If we get DataConPatContext dc tys co for some type ty and *dataConRepInstPat ... dc tys = (exs, flds), thendc exs flds :: T tys@ co :: T tys ~ tyghc-libIf *splitArgType_maybe ty = Just (dc, tys, co) then ,dc @tys @_ex_tys (_args::_arg_tys) :: tc tys and co :: ty ~ tc tys< where underscore prefixes are holes, e.g. yet unspecified.$See Note [Which types are unboxed?].bNoneQ!cNoneRghc-libOptions for the demand analysisghc-libUse strict dictionariesghc-libOutputs a new copy of the Core program in which binders have been annotated with demand and strictness information. Note: use seqBinds on the result to avoid leaks due to lazyness (cf Note [Stamp out space leaks in demand analysis])dNoneReNoneWghc-lib Used to make D for an  1 defined in the module being compiled. See also Dghc-libFind the "top" free names of several expressions. Such names are either: The function finally being applied to in an application chain (if that name is a GlobalId: see GHC.Types.Var#globalvslocal), orThe TyCon if the expression is a This is used for the fast-match-check for rules; if the top names don't match, the rest can'tghc-libGather all the rules for locally bound identifiers from the supplied bindingsghc-libThe main rule matching function. Attempts to apply all (active) supplied rules to this instance of an application in a given context, returning the rule applied and the resulting expression if successful.ghc-lib!Initialize RuleOpts from DynFlagsghc-libReport partial matches for rules beginning with the specified string for the purposes of error reportingghc-lib Rule optionsghc-libRule activation testghc-lib Rule patternghc-libRules for an Idghc-libBindings to check inghc-libResulting check message^NoneXNghc-libSpecialise calls to type-class overloaded functions occurring in a program.NoneXygNoneXhNoneYZghc-lib,True if there is a non-empty intersection. s1  s2 doesn't compute s2 if s1 is emptyiNone]ghc-lib&A bitmap represented by a sequence of D 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.ghc-lib%Make a bitmap from a sequence of bitsghc-lib0Make a bitmap where the slots specified are the zeros in the bitmap. eg. [0,1,3], size 4 ==> 0x4 (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.ghc-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.ghc-lib size in bitsghc-lib*sorted indices of zeros free of duplicatesjNonecghc-libPlatform profileghc-libInsert alignment check (cf -falignment-sanitisation)ghc-libValue of the srt field of an info table when using an StgLargeSRTghc-lib:Takes a closure pointer and returns the info table pointerghc-libTakes an info pointer (the first word of a closure) and returns its entry codeghc-libTakes a closure pointer, and return the *zero-indexed* constructor tag obtained from the info table This lives in the SRT field of the info table (constructors don't need SRTs).ghc-libTakes a closure pointer, and return the closure type obtained from the info tableghc-libTakes an info pointer (the first word of a closure) and returns a pointer to the first word of the standard-form info table, excluding the entry-code word (if present)ghc-libTakes an info table pointer (from infoTable) and returns the constr tag field of the info table (same as the srt_bitmap field)ghc-libTakes an info table pointer (from infoTable) and returns the srt_bitmap field of the info tableghc-libTakes an info table pointer (from infoTable) and returns the closure type field of the info table.ghc-libTakes the info pointer of a function, and returns a pointer to the first word of the StgFunInfoExtra struct in the info table.ghc-libTakes the info pointer of a function, returns the function's arityghc-libByte offset of the SRT bitmap half-word which is in the *higher-addressed* part of the type_litghc-lib)Byte offset of the closure type half-wordkNonejb ghc-libGet 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-libApply 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-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-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-libThe size of a minimal stackframe header including minimal parameter save area.ghc-lib reg move instruction or Nothing if it's not onelNonelmNonelNnNonel  oNone'(nghc-libs 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-libs 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.pNone#'(n  rNoneofghc-libReturn the UnitId of the home-unit. This is used to create labels.  sNoneo99tNonewaghc-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-libThe 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 descending 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.For 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.uNonewvNoneGghc-libLookup a node from the graph.ghc-lib>Get a node from the graph, throwing an error if it's not thereghc-lib-Add a node to the graph, linking up its edgesghc-lib/Delete a node and all its edges from the graph.ghc-libModify 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-libDelete a conflict edge. k1 -> k2 returns Nothing if the node isn't in the graphghc-libAdd some conflicts to the graph, creating nodes if required. All the nodes in the set are taken to conflict with each other.ghc-libAdd 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 required. 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 preferred. The algorithm tries to assign a node it's preferred 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-libCoalesce 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 graphghc-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.We 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-libFreeze all the nodes in the graph for debugging the iterative allocator.ghc-lib7Find all the nodes in the graph that meet some criteriaghc-libvalidate the internal structure of a graph all its edges should point to valid nodes If they don't then throw an errorghc-libSlurp out a map of how many nodes had a certain number of conflict neighboursghc-libSet the color of a certain nodeghc-libIf True, coalesce nodes even if this might make the graph less colorable (aggressive coalescing)ghc-libIf True, coalesce nodes even if this might make the graph less colorable (aggressive coalescing)ghc-lib!keys of the nodes to be coalescedghc-libkey of the node to freezeghc-lib the graphghc-libgraph with that node frozenghc-lib(extra debugging info to display on errorghc-lib-whether this graph is supposed to be colored.ghc-libgraph to validateghc-libvalidated graphghc-lib9(conflict neighbours, num nodes with that many conflicts)wNone>ghc-lib9Pretty print a graph in a somewhat human readable format.ghc-libPretty print a graph in graphviz .dot format. Conflicts get solid edges. Coalescences get dashed edges.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 etcxNoneghc-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-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-libfn to choose a node to potentially leave uncolored if nothing is trivially colorable.ghc-libthe graph to color.+yNone zNone{None| Safe-Inferredgghc-libHandle GHC-specific character encoding flags, allowing us to control how GHC produces output regardless of OS.}None?ghc-libSource StatisticsNone &? ghc-libExtract docs from renamer output. This is monadic since we need to be able to read documentation added from Template Haskell's putDoc, which is stored in D.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-libExtract constructor argument docs from inside constructor decls.ghc-libAll 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-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-libTake all declarations except pragmas, infix decls, rules from an D.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 Haddockghc-libGo through all class declarations and filter their sub-declarationsghc-lib%Was this signature given by the user?ghc-libTake a field of declarations from a data structure and create HsDecls using the given constructorghc-libExtracts out individual maps of documentation added via Template Haskell's putDoc.ghc-libUnions together two  ArgDocMaps (or ArgMaps in haddock-api), such that two maps with values for the same key merge the inner map as well. Left biased so unionArgMaps a b prefers a over b.ghc-lib  Module headerDocs on top level declarationsDocs on argumentsNone  3567> 3ghc-lib's get converted into 's before being written into .hie files. See   and  fromHieName6 for logic on how to convert between these two types.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 fileghc-libtype or data familyghc-lib type synonymghc-libdata declarationghc-libconstructor declarationghc-libpattern synonymghc-libclass declarationghc-libinstance declarationghc-libTypes of imports and exportsghc-libEq/Ord instances compare on the converted HieName, as non-exported names may have different uniques after a roundtripghc-libbound by a pattern matchghc-libbound by a type signatureghc-libbound by a hswrapperghc-libbound by an implicit variableghc-lib%Bound by some instance of given classghc-libA direct let bindingghc-lib0Different contexts under which identifiers existghc-libregular variableghc-lib import/exportghc-lib Value bindingghc-libPattern bindingThis 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 Declarationghc-lib Type variableghc-lib Record fieldghc-lib/Constraint/Dictionary evidence variable bindingghc-libUsage of evidence variableghc-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)ghc-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]).ghc-lib Annotationsghc-lib'The Haskell types of this node, if any.ghc-lib%All the identifiers and their detailsghc-libA node annotationghc-lib name of the AST node constructorghc-libname of the AST node Typeghc-libSource of node info ghc-libNodeInfos grouped by source ghc-lib/Mapping from filepaths to the corresponding AST ghc-libA list of type arguments along with their respective visibilities (ie. is this an argument that would return D for isVisibleArgFlag?). ghc-lib(Roughly isomorphic to the original core Type. ghc-libA flattened version of Type.9See Note [Efficient serialization of redundant type info] ghc-libtype with constraint: t1 => t2 (see  IfaceDFunTy) ghc-libGHC 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. ghc-lib Initial Haskell source file path ghc-libThe module this HIE file is for ghc-libTypes referenced in the  .9See Note [Efficient serialization of redundant type info] ghc-lib$Type-annotated abstract syntax trees ghc-lib"The names that this module exports ghc-lib'Raw bytes of the initial Haskell source ghc-libCurrent version of .hie filesghc-lib3names of the definitions over which the scope spansghc-libthe location of the instance/class declaration for the case where the type variable is declared in a method type signatureghc-lib,whether or not the binding is in an instanceghc-lib#scope over which the value is boundghc-libspan of entire bindingghc-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 bindingghc-libtype of declarationghc-libspan of entire bindingghc-lib!how did this bind come into beingghc-lib#scope over which the value is boundghc-libspan of the binding site     None  &5>!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  are ordered.!ghc-libMerge 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 is 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  '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  (with D)ghc-lib)return an empty list if this is unhelpful!ghc-libhelps fill in  (with D)ghc-lib)return an empty list if this is unhelpful!ghc-libhelps fill in  (with D)ghc-lib)return an empty list if this is unhelpfulghc-libtype to associate with the node!ghc-libhelps fill in  (with D)ghc-lib)return an empty list if this is unhelpfulghc-libtype to associate with the node!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!None ?!ghc-libLook for any identifiers which occur outside of their supposed scopes. Returns a list of error messages. !!!!!!!!!! !!!!!!!!!!None#$]!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 .!!!!!!None #$u!ghc-libUpdate CafInfos and LFInfos of all occurrences (in rules, unfoldings, class instances).See Note [Conveying CAF-info and LFInfo between modules] in GHC.StgToCmm.Types.!ghc-libModDetails to update!! Safe-InferredNone\!ghc-libFind all the link options in these and the preload packages, returning (package hs lib options, extra library options, other flags)!!!!!!!!None!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.!!!!!!!! Safe-Inferred!!!!!! Safe-Inferred!ghc-lib%Read target Arch/OS from the settings!ghc-lib&Settings filepath (for error messages)ghc-libRaw settings file contents!!!!!!!"!!!!!!!"None4"ghc-lib TopDir path""""""""Nonel""None""None 5""None?"ghc-libDependency sort a STG program so that dependencies come before uses.""None"ghc-libAnnotates a top-level STG binding group with its free variables."ghc-lib1Annotates an STG binding with its free variables.""""None 5?"ghc-libmodule being compiledghc-libhave we run Unarise yet?ghc-libwho produced the STG?""None""None "ghc-libA renaming substitution from  s to  s. Like D4, but not maintaining pairs of substitutions. Like , but with the domain being  s instead of entire CoreExpr."ghc-lib  emptySubst = " D"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-libSubstitutes an occurrence of an identifier for its counterpart recorded in the "."ghc-libSubstitutes an occurrence of an identifier for its counterpart recorded in the ". Does not generate a debug warning if the identifier to to substitute wasn't in scope."ghc-libAdd the   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 TyCoSubst Note [The substitution invariant] holds after extending the substitution like this. """"""""""" """""""""""None -"ghc-lib-The analysis monad consists of the following D components:": Reader-like context. Contains a substitution, info about how how lifted identifiers are to be expanded into applications and details such as .D ".: Writer output for the resulting STG program.No pure state componentBut wrapping around D2 for generating fresh lifted binders. (The uniqAway approach could give the same name to two different lifted binders, so this is necessary.)"ghc-libWe need to detect when we are lifting something out of the RHS of a recursive binding (c.f. GHC.Stg.Lift.Monad#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 " and ". Although " will only ever care if the current binding to be lifted (through ") 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."ghc-lib)Environment threaded around in a scoped, Reader-like fashion."ghc-lib Read-only."ghc-lib(We need to track the renamings of local  s to their lifted  , 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."ghc-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  , 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."ghc-lib uncurry " . " = id"ghc-libFlattens an expression in ["] into an STG program, see GHC.Stg.Lift.Monad#floats4. 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-libWrites a plain D to the output."ghc-lib&Starts a recursive binding group. See GHC.Stg.Lift.Monad#floats and "."ghc-lib$Ends a recursive binding group. See GHC.Stg.Lift.Monad#floats and "."ghc-libLifts a binding to top-level. Depending on whether it's declared inside a recursive RHS (see GHC.Stg.Lift.Monad#floats and "), this might be added to an existing recursive top-level binding group."ghc-libTakes a binder and a continuation which is called with the substituted binder. The continuation will be evaluated in a " context in which that binder is deemed in scope. Think of it as a D computation: After the continuation finishes, the new binding won't be in scope anymore."ghc-libSee "."ghc-lib Similarly to ", 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.It takes care of all the details involved with copying and adjusting the binder and fresh name generation."ghc-libSee "."ghc-libSubstitutes a binder  occurrence), which was brought in scope earlier by " / "."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 function for the current set of lifted binders. This expander function will replace any   by their corresponding   and, in addition, will expand any lifted binders by the former free variables it abstracts over.""""""""""""""""""""""""""""""""""""""""""""""""""""""None?""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-libFixup global registers so that they assign to locations within the RegTable if they aren't pinned for the current target.""""""""""None #$>h "ghc-libPlatform profile"ghc-libLoopification enabled (cf -floopification)"ghc-libTicky profiling enabled (cf -ticky)"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 GHC.Stg.Unarise."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 GHC.Stg.Unarise."ghc-lib$Assumes that there is precisely one D of the type. This assumption holds after unarise. See Note [Post-unarisation invariants]"ghc-libAssumes that Ids have one PrimRep, which holds after unarisation. See Note [Post-unarisation invariants]"ghc-libAssumes that arguments have one PrimRep, which holds after unarisation. See Note [Post-unarisation invariants]"ghc-libAssumes that the argument has one PrimRep, which holds after unarisation. See Note [Post-unarisation invariants]#ghc-libReturn the tag in the low order bits of a variable bound to this LambdaForm#ghc-lib Convert from " to D. """""""""""""""""""""""""""""""""""""""""""#######################"""" """""""""" """""""""####""""""""""#"##"""""#"##"""#############Noneާ################################ None '(>#ghc-libThe 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-libGenerate code into a fresh tick (sub-)scope and gather generated code####################################################################################$$$$$$$$$$$$########$$#######$$########$$$$$$$$#############################################################None5#$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-libAn environment of named things.$ghc-lib:The environment contains variable definitions or blockids.$ghc-libHolds CmmLit(CmmLabel ..) which gives the label type, eg, RtsLabel, ForeignLabel, CmmLabel etc.$ghc-libA function name from this unit$ghc-libA blockid of some code or data.$ghc-libTakes the variable declarations 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'$ghc-lib+Get the current environment from the monad.$ghc-lib+Get the current context name from the monad$ghc-lib Set context name for a sub-parse$ghc-lib.Create a fresh local variable of a given type.$ghc-libAllocate a fresh label.$ghc-lib(Add a local function to the environment.$ghc-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.$ghc-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.$ghc-libLookup 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.$ghc-lib1Lift an FCode computation into the CmmParse monad$ghc-lib data typeghc-libname of variableghc-libregister holding the value$ghc-libname of the functionghc-libpackage of the current module $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ $$$$$$$$$$$$$ $$$$$$$$$$$$$$$$$$None#$$$$$$$$$$$$$$#$$$$$$$$$$$$$$Nonev$ghc-lib>Make a global definition for the string, and return its label$$$$$$$$None$ghc-libEmit a data-segment data block$ghc-libEmit a read-only data block$ghc-libEmit code to add an entry to a now-overwritten pointer to the update remembered set.$ghc-libA bare bones InfoProvEnt for things which don't have a good source location$ghc-lib:Convert source information collected about identifiers in  to entries suitable for placing into the info table provenenance table.$ghc-lib&value of pointer which was overwritten$ghc-lib the thunk3 "$$$$$$$$$$$$$$$$$$$$$$$$$3$$$$$$$$$$$$$ $"$$ $$$$$$$$$NoneG$ghc-libstaticghc-lib updateable$ghc-lib updateable$ghc-lib!size of the full header, in bytesghc-libsize of the payload, in bytes$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$None$ghc-libUsed to tell the various mkVirtHeapOffsets functions what kind of header the object has. This will be accounted for in the offsets of the fields returned.%ghc-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;%ghc-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-lib1Just like mkVirtHeapOffsets, but for constructors%ghc-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."############$$$$$%%%%%%%%%%%%%%%%%"%%%%%%%%$%%$$$$%%%%%############%%None/%ghc-lib%The type used in binder positions in Ds.%ghc-libLet(-no-escape)-bound thing with a flag indicating whether it occurs as an argument or in a nullary application (see GHC.Stg.Lift.Analysis#arg_occs).%ghc-libEvery other kind of binder%ghc-libCaptures details of the syntax tree relevant to the cost model, such as closures, multi-shot lambdas and case expressions.%ghc-libGets the bound   out a %.%ghc-libTags every binder with its % and let bindings with their %s.%ghc-libCombines several heuristics to decide whether to lambda-lift a given let-binding to top-level. See GHC.Stg.Lift.Analysis#when for details.%ghc-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 D . Also see GHC.Stg.Lift.Analysis#clogro.%ghc-lib free vars %ghc-libhow often the RHS was entered %ghc-libAn expander function, turning  s into  s. See .ghc-lib Just abs_ids  =) This binding is beneficial to lift and abs_ids* are the variables it would abstract over%ghc-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. D; indicates there was growth under a (multi-shot) lambda.""""%%%%%%%%%%%%%%%%%%%%%%%""""%%%None%ghc-lib=Lambda lifts bindings to top-level deemed worth lifting (see %).(Mostly) textbook instance of the lambda lifting transformation, selecting which bindings to lambda lift by consulting %.%%None ?)%%None?%ghc-lib:A local block label (e.g. identifying a case alternative).%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%None:%ghc-lib;Emit top-level tables for HPC and return code to initialise%%%%None (&ghc-lib File name.&ghc-libFile modification time.&ghc-lib File owner.&ghc-lib File group.&ghc-lib File mode.&ghc-lib File size.&ghc-lib File bytes.%%%%&&&&&&&&&&&&&&&%%&&&&&&&%%&&&&&&&&None'&ghc-libEnable process jobs support on Windows if it can be expected to work (e.g. process >= 1.6.9.0).&ghc-lib Version of &System.Process.readProcessWithExitCode> that takes a key-value tuple to insert into the environment.&ghc-libRun 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/10777&ghc-libBreak a line of an error message into a filename and the rest of the line, taking care to ignore colons in Windows drive letters (as noted in #17786). For instance, "hi.c: ABCD" is mapped to Just ("hi.c", "ABCD")"C:\hi.c: ABCD" is mapped to Just ("C:\hi.c", "ABCD")&ghc-libstdout&ghc-lib program pathghc-lib program argsghc-libaddition to the environmentghc-lib(exit_code, stdout, stderr)&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&None&&&&&&&&&&None &&&&&&&&&&&& &&&&&&&&&&&& None0&&&&None #$>'&ghc-lib*Setup the initial typechecking environment&ghc-libRun a D& action in the context of an existing GblEnv.'ghc-libDo it flag is true'ghc-libUpdate the external package state. Returns the second result of the modifier function.This is an atomic operation and forces evaluation of the modified EPS in order to avoid space leaks.'ghc-lib"Update the external package state.This 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 SDoc a. and throwing an exception if it is an error.'ghc-libDump if the given D is set.'ghc-lib&Unconditionally dump some trace outputCertain tests (T3017, Roles3, T12763 etc.) expect part of the output generated by `-ddump-types` to be in D style. However, generally we want all other debugging output to use D style. We D style if  useUserStyle is True.'ghc-lib*Like logInfoTcRn, but for user consumption'ghc-libAdd a fixed message to the error context. This message should not do any tidying.'ghc-libAdd 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-libtcCollectingUsage thing_inside runs  thing_inside and returns the usage information which was collected as part of the execution of  thing_inside . Careful: tcCollectingUsage thing_inside itself does not report any usage information, it's up to the caller to incorporate the returned usage information into the larger context appropriately.'ghc-lib tcScalingUsage mult thing_inside runs  thing_inside* and scales all the usage information by mult.'ghc-libDrop elements of the input that fail, so the result list can be shorter than the argument list'ghc-libApply the function to all elements on the input list If all succeed, return the list of results Otherwise fail, propagating all errors'ghc-lib2The accumulator is not updated if the action fails(ghc-libDisplay a warning if a condition is met, and the warning is enabled(ghc-lib(Display a warning if a condition is met.(ghc-lib(Display a warning if a condition is met.(ghc-lib+Display a diagnostic if a condition is met.(ghc-lib,Display a diagnostic in the current context.(ghc-lib(Display a diagnostic in a given context.(ghc-lib5Display a diagnostic for the current source location.(ghc-lib1Display a diagnostic for a given source location.(ghc-libDisplay a diagnostic, with an optional flag, for the current source location.(ghc-libCreates an EvBindsVar incapable of holding any bindings. It still tracks covar usages (see comments on ebv_tcvs in GHC.Tc.Types.Evidence!), thus must be made monadically(ghc-lib5Throw out any constraints emitted by the thing_inside(ghc-libThe name says it all. The returned TcLevel is the *inner* TcLevel.(ghc-libAdds 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 mode(ghc-lib9Switch instances to safe instances if we're in Safe mode.(ghc-libRun an D= (top-level interface monad) computation inside an existing D; (typecheck-renaming monad) computation by initializing an D based on D.(ghc-lib.Initialize interface typechecking, but with a ' to apply when typechecking top-level s (see lookupIfaceTop)(ghc-libRun thing_inside in an interleaved thread. It shares everything with the parent thread, so this is DANGEROUS.+It returns Nothing if the computation failsIt's used for lazily type-checking interface signatures, which is pretty benign.,See Note [Masking exceptions in forkM_maybe](ghc-lib&*ghc-libCreate an empty  (i.e., the renaming that would occur with an implementing module with no exports) for a specific hole mod_name.*ghc-lib Create a 7 corresponding to an implementing module for the hole mod_name that exports a list of Gs.*ghc-libGiven an existing , merge it with a list of Gs 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.Note 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  (i.e., what the exports of an implementing module which induces this  would be.)*ghc-libGiven a !, substitute it according to the ! 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. ****** ******NoneB*ghc-libWhat we have is a generalized ModIface, which corresponds to a module that looks like p[A=]:B. We need a *specific* ModIface, e.g. p[A=q():A]:B (or maybe even p[A=]:B) which we load up (either to merge it, or to just use during typechecking).Suppose we have:p[A=]:M ==> p[A=q():A]:MSubstitute all occurrences of 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=]:M, since we just read in the exports of B.hi, which is assumed to be ready now. This function takes an optional , 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.********None1LP*ghc-libA G whose domain is sets of /s, each of which share a common value of type ele. Every such set ("equivalence class") has a distinct representative . Supports merging the entries of multiple such sets in a union-find like fashion.An accurate model is that of [(Set key, Maybe ele)]!: A finite mapping from sets of keys to possibly absent entries ele+, where the sets don't overlap. Example:  m = [({u1,u3}, Just ele1), ({u2}, Just ele2), ({u4,u7}, Nothing)] 9 On this model we support the following main operations:* m u3 == Just ele1, * m u4 == Nothing, * m u5 == Nothing.* m u1 u3 is a no-op, but * m u1 u2 merges {u1,u3} and {u2} to point to  Just ele2 and returns the old entry of {u1,u3},  Just ele1.* m u3 ele4 sets the entry of {u1,u3} to  Just ele4.8As well as a few means for traversal/conversion to list.*ghc-liblookupSUDFM env x looks up an entry for x, looking through all Gs until it finds a shared G.$Examples in terms of the model (see *): >>> lookupUSDFM [({u1,u3}, Just ele1), ({u2}, Just ele2)] u3 == Just ele1 >>> lookupUSDFM [({u1,u3}, Just ele1), ({u2}, Just ele2)] u4 == Nothing >>> lookupUSDFM [({u1,u3}, Just ele1), ({u2}, Nothing)] u2 == Nothing*ghc-libequateUSDFM env x y makes x and y+ point to the same entry, thereby merging x's class with y 's. If both x and y$ are in the domain of the map, then y.'s entry will be chosen as the new entry and x's old entry will be returned.$Examples in terms of the model (see *): >>> equateUSDFM [] u1 u2 == (Nothing, [({u1,u2}, Nothing)]) >>> equateUSDFM [({u1,u3}, Just ele1)] u3 u4 == (Nothing, [({u1,u3,u4}, Just ele1)]) >>> equateUSDFM [({u1,u3}, Just ele1)] u4 u3 == (Nothing, [({u1,u3,u4}, Just ele1)]) >>> equateUSDFM [({u1,u3}, Just ele1), ({u2}, Just ele2)] u3 u2 == (Just ele1, [({u2,u1,u3}, Just ele2)])*ghc-libaddToUSDFM env x a sets the entry x is associated with to a1, thereby modifying its whole equivalence class.$Examples in terms of the model (see *): >>> addToUSDFM [] u1 ele1 == [({u1}, Just ele1)] >>> addToUSDFM [({u1,u3}, Just ele1)] u3 ele2 == [({u1,u3}, Just ele2)]*****+*****+fNone?P+ghc-libLocate 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.+ghc-libLocate a plugin module requested by the user, for a compiler plugin. This consults the same set of exposed packages as + , unless -hide-all-plugin-packages or -plugin-package are specified.+ghc-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-libConstructs the filename of a .o file for a given source file. Does not! check whether the .o file exists+ghc-libConstructs the filename of a .hi file for a given source file. Does not" check whether the .hi file exists!(((((((((((((((+++++++++++++++++!(((((((((((((((+++++++++++++++++None #$?[E)ghc-lib,B=]:B, although the free holes are A and B, B might not depend on A at all!If this is invoked on a signature, this does NOT include the signature itself; e.g. precise free module holes of p[A=,B=]:B never includes B.+ghc-libWrite interface file+ghc-lib readIface tries just the one file.Failed err  => file not found, or unreadable, or illegible Succeeded iface  = successfully found and parsed+ghc-lib'Read binary interface, and print it out+ghc-libShow a ModIface but don't display details; suitable for ModIfaces stored in the EPT.+ghc-libShow a ModIface+The UnitState is used to pretty-print units+ghc-lib/Reason for loading the iface (used for tracing)ghc-lib=The unique identifier of the on-disk module we're looking for ghc-libThe *actual* module we're looking for. We use this to check the consistency of the requirements of the module we read out. ghc-lib Looking for .hi-boot or .hi file)++++++++++++++++++++++++++++++++++++++)++++++++++++++None >?^S+ghc-lib#tcCheckUsage name mult thing_inside runs  thing_inside, checks that the usage of name is a submultiplicity of mult, and removes name from the usage environment. See also Note [Wrapper returned from tcSubMult] in GHC.Tc.Utils.Unify, which applies to the wrapper returned from this function.+ghc-libGet a G 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. &+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++,,,,,,,,,,, ++++++,,,++++++++++++++++++++++++++++++++++++++++++++++++++,,++++&+++++++++,,,,,,None ?`u,ghc-libSee Note [The ZonkEnv] Confused by zonking? See Note [What is zonking?] in GHC.Tc.Utils.TcMType.( ,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,(,,, ,,, ,,,,,,,,,,,,,,,,,,,,,,,,,,,None?f,ghc-lib Used when  is the wired-in name for a wired-in class method, so the caller knows its type for sure, which should be of form forall a. C a => , is supposed to instantiate just the outer type variable and constraint,ghc-libGiven ty::forall k1 k2. k, instantiate all the invisible forall-binders returning ty kk1  kk2 :: k[kk1k1, kk2k1],ghc-libUsed only in *types*,ghc-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 , and ,,ghc-libGive fresh uniques to a bunch of CoVars Used in "GHC.Tc.Instance.Family.newFamInst",ghc-libwhy do we need this?ghc-libname of the methodghc-lib)types with which to instantiate the class,ghc-lib%How to instantiate the type variablesghc-libType to instantiateghc-lib1Result (type vars, preds (incl equalities), rho),ghc-libType to instantiate it atghc-lib(Standard name, user name)ghc-lib(Standard name, suitable expression) USED ONLY FOR CmdTop (sigh) *** See Note [CmdSyntaxTable] in  GHC.Hs.Expr# ))+,,,,,,,,,,,,,,,,,,,,,,,,,,,,,#,,,,,,,)),,,,,,,,,,,,,,,,,+,,,,, Nonej',ghc-libmatchActualFunTySigma does looks for just one function arrow returning an uninstantiated sigma-type,ghc-lib Variant of , that takes an ExpType,ghc-lib-Breaks apart a function kind into its pieces.)ghc-lib'If present, the thing that has type ty1,ghc-libThe wrapper has type: spec_ty ~> expected_ty See Note [Skolemisation] for the differences between tcSkolemiseScoped and tcSkolemise,ghc-libThe wrapper has type: spec_ty ~> expected_ty See Note [Skolemisation] for the differences between tcSkolemiseScoped and tcSkolemise,ghc-libtype, only for errorsghc-libn: number of desired arrowsghc-lib fun_ kindghc-lib-co :: fun_kind ~ (arg1 -> ... -> argn -> res)*)))**,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,*,,,,,,,,,),,,,,)),,*,,*,,,,,,,,,,,,,,,,,,,None #$lf,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.&See Note [Grand plan for Typeable] in GHC.Tc.Instance.Typeable.,ghc-libIs a particular  representable by Typeable.?. These exclude type families and polytypes.,,,,None?t,-ghc-libThrow an error message if a user attempts to quantify an inferred type variable in a place where specificity cannot be observed. For example, forall {a}. [a] -> [a]2 would be rejected to the inferred type variable {a}, but forall a. [a] -> [a] would be accepted. See +Note [Unobservably inferred type variables].-ghc-lib"Examines a non-outermost type for foralls or contexts, which are assumed to be nested. For example, in the following declaration: ,instance forall a. forall b. C (Either a b) The outermost forall a is fine, but the nested forall b is not. We invoke - on the type forall b. C (Either a b) to catch the nested forall' and create a suitable error message. - returns G err_msg if such a forall# or context is found, and returns Nothing otherwise./This is currently used in the following places:In GADT constructor types (in  rnConDecl ). See Note [GADT abstract syntax] (Wrinkle: No nested foralls or contexts) in  GHC.Hs.Type."In instance declaration types (in  rnClsIntDecl and rnSrcDerivDecl in GHC.Rename.Module and  renameSig in GHC.Rename.Bind ). See 6Note [No nested foralls or contexts in instance types] in  GHC.Hs.Type.-ghc-libA common way to invoke -.-ghc-libChecks to see if we need to warn for -Wunused-record-wildcards or -Wredundant-record-wildcards-ghc-libMake a map from selector names to field labels and parent tycon names, to be used when reporting unused record fields.-ghc-lib?Ensure that a boxed or unboxed tuple has arity no larger than G.-ghc-lib8Ensure that a constraint tuple has arity no larger than G.-ghc-libThe error msg if the signature is not allowed to contain manually written inferred variables.6,,,,,-------------------------------------------------6--------------------,,,,,-----------------------------Nonev-ghc-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.(GGGDGGGGGGGGGGGGGGGGFGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG GGGG!GGGGGGGG"GGGG#GGG$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~GGHHHHHDHDHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIGDDDDDDDIIIIIIIIIIIIIIIIIIIDIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJ JJJJJJJJJ J J DJJJJJJJJKKKKKKKKKKKKKKKKKKKKKKKKKKKKK KKKKKKKK KKKKK KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK KKKKKKK KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKLLLLLLLLLLLLLLLLLLLLLLLLDLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLFLLL LL L GL LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN NNNNNNNNNNNNNNNNNNNNNNNNNDNNNOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP P PPPPPPPPPPPPPPPPPP PPPPPPPPPPPPP PPPPPPPPPP P P PPP P PPPPPPPPPPPPPPPPPPPDQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ QQQQQQQQQ QQQQQQQQQQQ QQQQ QQQQQQQQ QQQQQQQQ QQQQQQQQ QQQQQQQQQQQQQQ QQQ QQQQQQQQ QQQQQQQQQQQQQQQQQQQQQQQQQRRRRRRRRRRRRRDRRRR RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS SSSST TTTTTT TTTTTTTTTTTT TTTTTTTTTTTTTTT TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUU UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXYYYYYYDYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]D]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^________________________________________________________________________________________________________________________________````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(()))((((((((((bbbbbbbbcccccccccccccccccccccccccccccccccccccccccccc((cc(ccccccccccccc+ccccccccccc-$%&'[\]^_`abcdefghijklmnopqrstuvwxyz{|}~$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~     -None&-ghc-lib!Replaces all bindings of the form 'b = /\ ... -> makeStatic location valuewith b = /\ ... -> StaticPtr key (StaticPtrInfo "pkg key" "module" location) value3where a distinct key is generated for each binding.It also yields the C stub that inserts these bindings into the static pointer table.-ghc-libsptModuleInitCode module fps. is a C stub to insert the static entries of module into the static pointer table.fps is a list associating each binding corresponding to a static entry with its fingerprint.----None5----None1-ghc-libCreate a function that converts Bignum literals into their final CoreExpr------None&'("-ghc-libIf co :: T ts ~ rep_ty then: +instNewTyCon_maybe T ts = Just (rep_ty, co)Checks for a newtype, and for being saturated Just like Coercion.instNewTyCon_maybe, but returns a TcCoercion-ghc-libLike -, 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- 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 gets 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.It 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 scope-ghc-libReport a list of injectivity errors together with their source locations. Looks only at one equation; does not look for conflicts *among* equations.-ghc-libReport error message for a pair of equations violating an injectivity annotation. No error message if there are no branches.-ghc-lib(Type family for which we generate errorsghc-lib1Currently checked equation (represented by axiom)ghc-libInjectivity annotation ---------- ----------NoneY-ghc-libReport unsolved goals as errors or warnings. We may also turn some into deferred run-time errors if `-fdefer-type-errors` is on.-ghc-libReport *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. NB: Type-level holes are OK, because there are no bindings. See Note [Deferring coercion errors to runtime] Used by solveEqualities for kind equalities (see Note [Fail fast on kind errors] in  GHC.Tc.Solver)-ghc-libReport all unsolved goals as warnings (but without deferring any errors to run-time). See Note [Safe Haskell Overlapping Instances Implementation] in  GHC.Tc.Solver----------None-ghc-lib- returns (True, fixity) if it finds a c 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).-ghc-libLook up the fixity of a (possibly ambiguous) occurrence of a record field selector. We use c so that we can specify the 6 as the field label, which might be different to the  of the selector  if DuplicateRecordFields is in use (#1173). If there are multiple possible selectors with different fixities, generate an error.------------None%f -ghc-libResult of looking up an occurrence that might be an ambiguous field.-ghc-libOccurrence picked out a single name, which may or may not belong to a field (or might be unbound, if an error has been reported already, per Note [ Unbound vs Ambiguous Names ]).-ghc-libOccurrence picked out two or more fields, and no non-fields. For now this is allowed by DuplicateRecordFields in certain circumstances, as the type-checker may be able to disambiguate later.-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] and Note [NoFieldSelectors].-ghc-libLook up an occurrence of a field in a record update, returning the selector name..Unlike construction and pattern matching with -XDisambiguateRecordFields (see -), there is no data constructor to help disambiguate, so this may be ambiguous if the field is in scope multiple times. However we ignore non-fields in scope with the same name if -XDisambiguateRecordFields: is on (see Note [DisambiguateRecordFields for updates]).!Here a field is in scope even if NoFieldSelectors was enabled at its definition site (see Note [NoFieldSelectors]).-ghc-lib,Used in export lists to lookup the children.-ghc-lib5Specialised version of msum for RnM ChildLookupResult-ghc-lib Look up a % used as a variable in an expression.This may be a local variable, global variable, or one or more record selector functions. It will not return record fields created with the NoFieldSelectors0 extension (see Note [NoFieldSelectors]). The c argument controls whether ambiguous fields will be allowed (resulting in an - result being returned).If the name is not in scope at the term level, but its promoted equivalent is in scope at the type level, the lookup will succeed (so that the type-checker can report a more informative error later). See Note [Promotion]..ghc-lib,Lookup a name in relation to the names in a -.ghc-lib,Lookup a name in relation to the names in a -.ghc-lib:description of thing we're looking up, like "type family".ghc-lib:description of thing we're looking up, like "type family".ghc-libThe standard nameghc-libPossibly a non-standard name Lookup a Name that may be subject to Rebindable Syntax (RS).8When RS is off, just return the supplied (standard) NameWhen RS is on, look up the OccName of the supplied Name; return what we find, or the supplied Name if there is nothing in scope.ghc-libThe standard nameghc-libPossibly a non-standard name7--------------------------------------.................7---------------------------------.....----...........-.Nonef.ghc-libExtra 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 scoped6 tyvars of the instance Why scoped? See bind_me in .ghc-libMaps class tyvars to their instance types See Note [Matching in the consistent-instantiation check]................................................ None 5<|.ghc-libSee Note [Safe Haskell Overlapping Instances Implementation] in  GHC.Tc.Solver.ghc-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 GHC.Tc.Solver.Interact.ghc-lib"Remove inert constraints from the .?, for use when a typechecker plugin wishes to discard a given..ghc-libLooks up a family application in the inerts; returned coercion is oriented input ~ output.ghc-libLook up a dictionary inert..ghc-libLook up a solved inert./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./ghc-lib A variant of / that takes and returns an . for later resumption of the . session./ghc-libEqualities only/ghc-lib+Good for both equalities and non-equalities/ghc-lib Make a new   of the given type, bound (in the monad's EvBinds) to the given term/ghc-lib-Emit a new Wanted equality into the work-list/ghc-libMake a new equality CtEvidence/ghc-libChecks if the depth of the given location is too much. Fails if it's too big, with an appropriate error message./ghc-libReplace all type family applications in the RHS with fresh variables, emitting givens that relate the type family application to the variable. See Note [Type variable cycles in Givens] in GHC.Tc.Solver.Canonical./ghc-libtype being reduced ......................................................................................///////////////////////////////////////////////////////////////////////////////////////////////////////////////...............//.///////////////////....... /////////...///////////////////////////..////////////............................//......././/........../////............////////////////////////////////None5D/ghc-libSee Note [Rewriting]. If (xi, co) <- rewrite mode ev ty, then co :: xi ~r ty where r is the role in ev./ghc-libRewrite a type w.r.t. nominal equality. This is useful to rewrite a type w.r.t. any givens. It does not do type-family reduction. This will never emit new constraints. Call this when the inert set contains only givens.////////None5{00000000000000000000000000000000~NoneN0ghc-lib=Perform some IO, typically to interact with an external tool.0ghc-lib)Output useful for debugging the compiler.0ghc-libCreate a new wanted constraint.0ghc-lib Create a new derived constraint.0ghc-libCreate a new given constraint, with the supplied evidence. This must not be invoked from  tcPluginInit or  tcPluginStop, or it will panic.0ghc-lib!Create a fresh evidence variable.0ghc-libCreate a fresh coercion hole.0ghc-lib;Bind an evidence variable. This must not be invoked from  tcPluginInit or  tcPluginStop, or it will panic.((((((((((((00000000000000000000000000(00(((((((((((000000000000000000000000TNone1 0ghc-lib)Represents the head of a match against a c or literal. Really similar to Q.0ghc-libUndecidable semantic equality result. See Note [Undecidable Equality for PmAltCons]0ghc-libLiterals (simple and overloaded ones) for pattern match checking.-See Note [Undecidable Equality for PmAltCons]0ghc-lib A data type that caches for the 0 of x the results of querying dsGetCompleteMatches* and then striking out all occurrences of K for which we already know x D K from these sets.For motivation, see Section 5.3 in Lower Your Guards. See also Note [Implementation of COMPLETE pragmas]0ghc-libThe residual set for the vanilla COMPLETE set from the data defn. Tracked separately from 0, because it might only be known much later (when we have enough type information to see the ? of the match), or not at all even. Until that happens, it is D.0ghc-libThe residual sets for all COMPLETE sets from pragmas that are visible when compiling this module. Querying that set with dsGetCompleteMatches requires DsM, so we initialise it with D until first needed in a DsM context.0ghc-libSee 0.0ghc-libInformation about an  . Stores positive (0) facts, like  x ~ Just 42, and negative (05) facts, like "x is not (:)". Also caches the type (vi_ty), the 0 of a COMPLETE set (0).+Subject to Note [The Pos/Neg invariant] in GHC.HsToCore.Pmc.Solver.0ghc-libThe   in question. Important for adding new constraints relative to this 0 when we don't easily have the   available.0ghc-libPositive info: 0 apps it is (i.e. x ~ [Just y, PatSyn z]), all at the same time (i.e. conjunctive). We need a list because of nested pattern matches involving pattern synonym case x of { Just y -> case x of PatSyn z -> ... } However, no more than one RealDataCon in the list, otherwise contradiction because of generativity.0ghc-libNegative info: A list of 0*s that it cannot match. Example, assuming 0 data T = Leaf Int | Branch T T | Node Int T then x D [Leaf, Node] means that x cannot match a Leaf or Node, and hence can only match Branch!. Is orthogonal to anything from 0, in the sense that 0 returns PossiblyOverlap for any pairing between 0 and 0.0ghc-lib8Can this variable be E? Models (mutually contradicting) x ~ E and x D E constraints. E.g. * 0: Don't know; Neither x ~ E nor x D E. * 0: x ~ E * 0: x D E0ghc-libA cache of the associated COMPLETE sets. At any time a superset of possible constructors of each COMPLETE set. So, if it's not in here, we can't possibly match on it. Complementary to 0. We still need it to recognise completion of a COMPLETE set efficiently for large enums.0ghc-libThe term oracle state. Stores 0 for encountered  s. These entries are possibly shared when we figure out that two variables must be equal, thus represent the same set of values.!See Note [TmState invariants] in GHC.HsToCore.Pmc.Solver.0ghc-libFacts about term variables. Deterministic env, so that we generate deterministic error messages.0ghc-libAn environment for looking up whether we already encountered semantically equivalent expressions that we want to represent by the same   representative.0ghc-libWhich 0 needs to be checked for inhabitants because of new negative constraints (e.g. x D E or x D K).0ghc-libThe type oracle state. An . that we incrementally add local type constraints to, together with a sequence number that counts the number of times we extended it with new facts.0ghc-libA disjunctive bag of 0"s, representing a refinement type.0ghc-libA normalised refinement type D ("nabla"), comprised of an inert set of canonical (i.e. mutually compatible) term and type constraints that form the refinement type's predicate.0ghc-libType oracle; things like a~Int0ghc-lib"Term oracle; things like x~Nothing0ghc-lib Type of a 00ghc-libWhether there is a 0 in the 0 that compares 0 to the given 0 according to 0.0ghc-lib'We can't in general decide whether two 0?s match the same set of values. In addition to the reasons in c and c, a 02 might or might not represent the same value as a 01. See Note [Undecidable Equality for PmAltCons]. Just True ==> Surely equal Just False. ==> Surely different (non-overlapping, even!)Nothing" ==> Equality relation undecidable.Examples (omitting some constructor wrapping):/eqPmAltCon (LitInt 42) (LitInt 1) == Just False: Lit equality is decidable0eqPmAltCon (DataCon A) (DataCon B) == Just False": DataCon equality is decidable4eqPmAltCon (LitOverInt 42) (LitOverInt 1) == Nothing$: OverLit equality is undecidable-eqPmAltCon (PatSyn PA) (PatSyn PB) == Nothing#: PatSyn equality is undecidable-eqPmAltCon (DataCon I#) (LitInt 1) == Nothing: DataCon to Lit comparisons are undecidable without reasoning about the wrapped Int#5eqPmAltCon (LitOverInt 1) (LitOverInt 1) == Just True2: We assume reflexivity for overloaded literals/eqPmAltCon (PatSyn PA) (PatSyn PA) == Just True/: We assume reflexivity for Pattern Synonyms0ghc-lib Type of a 00ghc-libIs a match on this constructor forcing the match variable? True of data constructors, literals and pattern synonyms (#17357), but not of newtypes. See Note [Coverage checking Newtype matches] in GHC.HsToCore.Pmc.Solver.0ghc-libNot user-facing.0ghc-libSyntactic equality.1ghc-libSyntactic equality.1ghc-libNot user-facing.1ghc-libNot user-facing.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000None&51ghc-libUsed as tree payload post-checking. The redundancy info we elaborated.1ghc-lib;Used as tree payload pre-checking. The LYG guards to check.1ghc-lib#Pattern-match coverage check result1ghc-lib,A hole for redundancy info and covered sets.1ghc-libThe set of uncovered values falling out at the bottom. (for -Wincomplete-patterns, but also important state for the algorithm)1ghc-lib&A flag saying whether we ran into the maxPmCheckModels limit for the purpose of suggesting to crank it up in the warning message. Writer state.1ghc-libRedundancy sets, used to determine redundancy of RHSs and bang patterns (later digested into a CIRB).1ghc-libThe Covered= set; the set of values reaching a particular program point.1ghc-libThe  Diverging set; empty if no match can lead to divergence. If it wasn't empty, we have to turn redundancy warnings into inaccessibility warnings for any subclauses.1ghc-libIf any of the 0 is empty, the corresponding 1 pin-points a bang pattern in source that is redundant. See Note [Dead bang patterns].1ghc-lib(A guard tree denoting a pattern binding.1ghc-lib%A guard tree denoting an -XEmptyCase.1ghc-libA guard tree denoting GRHS&: A payload describing the grds and a 1/ useful for printing out in warnings messages.1ghc-libA guard tree denoting GRHSs : A bunch of 1% guards for local bindings from the GRHSss where clauses and the actual list of GRHS=. See Note [Long-distance information for HsLocalBinds] in GHC.HsToCore.Pmc.Desugar.1ghc-libA guard tree denoting Match5: A payload describing the pats and a bunch of GRHS.1ghc-libA guard tree denoting  MatchGroup.1ghc-libA sequence of 1s.1ghc-libMeans by which we identify a source construct for later pretty-printing in a warning message. G for the equation to show,  for the location.1ghc-libA very simple language for pattern guards. Let bindings, bang patterns, and matching variables against flat constructor patterns. The LYG guard language.1ghc-libPmCon x K dicts args corresponds to a K dicts args <- x guard. The args" are bound in this construct, the x0 is just a use. For the arguments' meaning see .1ghc-libPmBang x corresponds to a  seq x True guard. If the extra 1 is present, the bang guard came from a source bang pattern, in which case we might want to report it as redundant. See Note [Dead bang patterns] in GHC.HsToCore.Pmc.Check.1ghc-lib PmLet x expr corresponds to a  let x = expr guard. This actually binds x.1ghc-libShould not be user-facing.1ghc-libFormat LYG guards as | True <- x, let x = 42, !z0000000000000000000000000000000000000000000000000000000000000000000000000111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111WNoneF1ghc-libDesugaring monad. See also TcM.1ghc-lib>Local state of the desugarer, extended as we lexically descend1ghc-libTemplate Haskell bindings1ghc-lib%To put in pattern-matching error msgs1ghc-lib.See Note [Note [Long-distance information] in GHC.HsToCore.Pmc. The set of reaching values Nablas is augmented as we walk inwards, refined through each pattern match in turn1ghc-libGlobal read-only context and state of the desugarer. The statefulness is implemented through Ds.1111111111111111111111111111111111111111None1111Nonet 1ghc-lib8How should we choose which constraints to quantify over?1ghc-libApply the monomorphism restriction, never quantifying over any constraints1ghc-libSee Note [TcRnExprMode] in  GHC.Tc.Module, the :type +d case; this mode refuses to quantify over any defaultable constraint1ghc-lib-Quantify over any constraint that satisfies c1ghc-libType-check a thing that emits only equality constraints, solving any constraints we can and re-emitting constraints that we can't. Use this variant only when we'll get another crack at it later See Note [Failure in local type signatures]Panics if we solve any non-equality constraints. (In runTCSEqualities we use an error thunk for the evidence bindings.)1ghc-libSimplify top-level constraints, but without reporting any unsolved constraints nor unsafe overlapping.1ghc-libReturn (Just new_inerts) if the Givens are satisfiable, Nothing if definitely contradictory1ghc-lib4Return True if the Wanteds are soluble, False if not1ghc-libNormalise a type as much as possible using the given constraints. See Note [tcNormalise].*/111111111111111111111111121111111111111111111111*1112/None}2ghc-libDo validity checks on a type family equation, including consistency with any enclosing class instance head, termination, and lack of polytypes.2ghc-lib.Checks that an associated type family default:  induced by an import of a particular interface, but without F.222222222222222222222222222222None  ?2ghc-libD 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!)2222None /? 2ghc-libShould GHC warn if a quantified type variable goes unused? Usually, the answer is "yes", but in the particular case of binding c$, we avoid emitting warnings. See 8Note [Suppress -Wunused-foralls when binding LHsQTyVars].2ghc-libAlways bind any free tyvars of the given type, regardless of whether we have a forall at the top.For pattern type sigs, we do want to bring those type variables into scope, even if there's a forall at the top which usually stops that happening, e.g: \ (x :: forall a. a -> b) -> eHere we do bring b into scope.RULES can also use 2#, such as in the following example: {-# RULES \"f\" forall (x :: forall a. a -> b). f x = ... b ... #-}This only applies to RULES that do not explicitly bind their type variables. If a RULE explicitly quantifies its type variables, then 2 is used instead. See also ,Note [Pattern signature binders and scoping] in  GHC.Hs.Type.2ghc-libNever bind any free tyvars. This is used for RULES that have both explicit type and term variable binders, e.g.: {-# RULES \"const\" forall a. forall (x :: a) y. const x y = x #-})The presence of the type variable binder  forall a. implies that the free variables in the types of the term variable binders x and y are not bound. In the example above, there are no such free variables, but if the user had written (y :: b) instead of y% in the term variable binders, then b5 would be rejected for being out of scope. See also ,Note [Pattern signature binders and scoping] in  GHC.Hs.Type.2ghc-libCreate new renamed type variables corresponding to source-level ones. Duplicates are permitted, but will be removed. This is intended especially for the case of handling the implicitly bound free variables of a type signature.2ghc-lib2 finds the type/kind variables of a HsType/HsKind. It's used when making the forall6s explicit. See Note [Kind and type-variable binders]2ghc-libExtracts 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. 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].2ghc-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.2ghc-libExtracts free type and kind variables from an argument in a GADT constructor, returning variable occurrences in left-to-right order. See %Note [Ordering of implicit variables].2ghc-libGet type/kind variables mentioned in the kind signature, preserving left-to-right order:data T a (b :: k1) :: k2 -> k1 -> k2 -> Type -- result: [k2,k1] an associated type declghc-libSurface-syntax free vars that we will implicitly bind. May have duplicates, which are removed here.2ghc-libG _ => an associated type decl/22222222222222222222222222222222222222222222222/22222222222222222222222222222222222222222222222None &5?222222222333333333333333323323322223222333None-E--------33333333333333333333333333--------None ?"p3ghc-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  TcMonoType, 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.Brings the binders of the group into scope in the appropriate places; does NOT assume that anything is in scope already333333None#)ghc-lib/Rename a splice pattern. See Note [rnSplicePat]3ghc-libThe splice data to be logged3ghc-liboutputs splice information for 2 flags which have different output formats: `-ddump-splices` and `-dth-dec-file`))))3333333333))3))333333333None -?$!ghc-libRename some Stmts!ghc-lib7How to rename the body of each statement (e.g. rnLExpr)ghc-lib Statementsghc-libif these statements scope over something, this renames it and returns the result.!!!!!!!!None13ghc-libThis 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 (c). 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.)Unfortunately, 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 = C 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.It'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.3ghc-libTypecheck a signature   under the assumption that we have instantiated it under some implementation (recorded in T?) and want to check if the implementation fills the signature.0This needs to operate slightly differently than 3 because (1) we have a , 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])!ghc-libTrue  =# discard IdInfo on IfaceId bindings!!!!!!!+++3333333+++3333!!!!!!!333None &/?B3ghc-lib'A description of whether something is adata or newtype (3) data instance or newtype instance (3) data family (3)/At present, this data type is only consumed by 3.3ghc-lib1Describes the kind expected in a certain context.3ghc-liba specific kind3ghc-libany kind will do3ghc-libsomething of the form TYPE _3ghc-libTypecheck a deriving strategy. For most deriving strategies, this is a no-op, but for the via* strategy, this requires typechecking the via type.3ghc-lib%Type-check a visible type application3ghc-libSkolemise the cs in an c with the supplied c.3ghc-libSkolemise the cs in an c with the supplied c.3ghc-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.3ghc-libGeneralize some of the free variables in the given type. All such variables should be *kind* variables; any type variables should be explicitly quantified (with a forall ) before now.The WantedConstraints are un-solved kind constraints. Generally they'll be reported as errors later, but meanwhile we refrain from quantifying over any variable free in these unsolved constraints. See Note [Failure in local type signatures].But in all cases, generalize only those variables whose TcLevel is strictly greater than the ambient level. This "strictly greater than" means that you likely need to push the level before creating whatever type gets passed here.Any variable whose level is greater than the ambient level but is not selected to be generalized will be promoted. (See [Promoting unification variables] in  GHC.Tc.Solver. and Note [Recipe for checking a signature].)The resulting KindVar are the variables to quantify over, in the correct, well-scoped order. They should generally be Inferred, not Specified, but that's really up to the caller of this function.3ghc-libSpecialised version of 3, but with empty WantedConstraints, so no filtering is needed i.e. kindGeneraliseAll = kindGeneralizeSome emptyWC3ghc-libSpecialized version of 3, but where no variables can be generalized, but perhaps some may need to be promoted. Use this variant when it is unknowable whether metavariables might later be constrained.To see why this promotion is needed, see Note [Recipe for checking a signature], and especially Note [Promotion in signatures].3ghc-libChecks that the return kind in a data declaration's kind signature is permissible. There are three cases:If dealing with a data, newtype,  data instance, or newtype instance- declaration, check that the return kind is Type.If the declaration is a newtype or newtype instance and the UnliftedNewtypes extension is enabled, this check is slightly relaxed so that a return kind of the form TYPE r (for some r) is permitted. See )Note [Implementation of UnliftedNewtypes] in  GHC.Tc.TyCl.If dealing with a  data family declaration, check that the return kind is either of the form: TYPE r (for some r), ork (where k% is a bare kind variable; see #12369))See also Note [Datatype return kinds] in  GHC.Tc.TyCl3ghc-lib2Checks that the result kind of a class is exactly  Constraint<, rejecting type synonyms and type families that reduce to  Constraint . See #16826.3ghc-libMake an appropriate message for an error in a function argument. Used for both expressions and types.3ghc-lib3Add a "In the data declaration for T" or some such.3ghc-libThe deriving strategyghc-libThe typechecked deriving strategy and the tyvars that it binds (if using c).3ghc-libof the thing being checkedghc-lib What sort of  is being checkedghc-libBinders in the headerghc-libThe result kindghc-libA suitably-kinded TcTyCon3ghc-libneedn't be zonked&&&&&&&&&&&&&&&&&&&&&&&&&33333333333333333333333333333333333333333333333333333333333333333333333333333333333333&&&&&&&&&&&&&&&&&&&&&&&&&333333333333333333333333333333333333333333333333333333333333NoneD4ghc-lib0If there are no wildcards, return a LHsSigWcType)33444444444444444)34444444344444444None ?E4ghc-lib A variant of tcPat that takes a custom origin4ghc-lib(origin to use if the type needs inst'ing 444444444444 444444444444NoneFV44None ?F44444444444444None 5G4ghc-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. 444444444 444444444None P 4ghc-lib For a module modname of type c, 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:unit p where signature X signature Y import Xunit q where dependency p[X=,Y=] 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.4ghc-lib4, but in a convenient form for GHC.Driver.Make and  GHC.Tc.Module.4ghc-libLike implicitRequirements', but returns either the module name, if it is a free hole, or the instantiated unit the imported module is from, so that that instantiated unit can be processed and via the batch mod graph (rather than a transitive closure done here) all the free holes are still reachable.4ghc-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.4ghc-libTop-level driver for signature instantiation (run when compiling an hsig file.)4ghc-libTop-level driver for signature merging (run after typechecking an hsig file).4ghc-libGiven a local  ), merge all inherited requirements from b) into this signature, producing a final D? that matches the local signature and all required signatures.4ghc-libTop-level driver for signature instantiation (run when compiling an hsig file.)4ghc-libGiven F, instantiate a   from the indefinite library to use the actual implementations of the relevant entities, checking that the implementation matches the signature. 44444444444 44444444444None ?Q444444NoneQ4ghc-libConstruct default instances for any associated types that aren't given a user definition Returns [] or singleton 444444444444 444444444444None'(/?R4ghc-libThis name really is ambiguous, so add a suitable "ambiguous occurrence" error, then continue/44444444444444444444444444444444444444444444444/44444444444444444444444444444444444444444444444None#$-?Ss&&5555555555555555&5&555555555555555NoneS55None '(/?T555555 None /?V&ghc-lib!Slightly more general version of & that allows the caller to specify the shape of the result of the syntax operator&ghc-libTypecheck a syntax operator The operator is a variable or a lambda at this stage (i.e. renamer output)t&ghc-lib"shape of syntax operator argumentsghc-liboverall result typeghc-libType check any arguments, takes a type per hole and a multiplicity per arrow in the shape.&&&&&&&&&&&&445&&&&&&&&&&&&445NoneV55None &X 5ghc-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.We also check that the Safe Haskell condition of FFI imports having results in the IO monad holds.555555555555555555555555555555555555None 5>?e5ghc-libThis is a value of type a with potentially a CoreExpr-shaped hole in it. This is used to deal with cases where we are potentially handling pattern match failure, and want to later specify how failure is handled.5ghc-libWe represent the case where there is no hole without a function from D, like this, because sometimes we have nothing to put in the hole and so want to be sure there is in fact no hole.5ghc-libThe patterns for an equation NB: We have already applied decideBangHood3 to these patterns. See Note [decideBangHood] in GHC.HsToCore.Utils5ghc-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.5ghc-libWhat to do after match5ghc-libRun a 1 action inside the D monad.5ghc-libRun a 1 action inside the c monad.5ghc-libRun a 1& action in the context of an existing `5ghc-lib0Get the current pattern match oracle state. See 1.5ghc-libSet the pattern match oracle state within the scope of the given action. See 1.5ghc-libEmit a diagnostic for the current source location NB: Warns whether or not -Wxyz is set5ghc-libEmit a warning only if the correct WarningWithoutFlag is set in the DynFlags5ghc-libIssue an error, but return the expression for (), so that we can continue reporting errors.5ghc-libThe COMPLETE pragmas that are in scope.5ghc-lib=Fail with an error message if the type is levity polymorphic.5ghc-libCheck an expression for levity polymorphism, failing if it is levity polymorphic.5ghc-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.5ghc-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) exprWhen 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.5ghc-libSee (.5ghc-libProduct is an "or" on falliblity---the combined match result is infallible only if the left and right argument match results both were.This is useful for combining a bunch of alternatives together and then getting the overall falliblity of the entire group. See  mkDataConCase for an example.5ghc-libheaderghc-libinformation to outputghc-lib expression  ''''''11111555555555555555555555555555555555555555555555555555555555155555 '''' 555555555555' '55555555111155555555555555555555555555555555NonejS5ghc-libGenerate a fresh   of a given type5ghc-lib=All warning flags that need to run the pattern match checker.5ghc-libCheck whether the redundancy checker should run (redundancy only)5ghc-libCheck whether the exhaustiveness checker should run (exhaustiveness only)5ghc-lib6Check whether unnecessary bangs should be warned about5ghc-libDenotes whether an exhaustiveness check is supported, and if so, via which Y it's controlled. Returns D if check is not supported.5ghc-libCheck whether any part of pattern match checking is enabled for this c (does not matter whether it is the redundancy check or the exhaustiveness check).5ghc-lib4Return True when any of the pattern match warnings (5) are enabled, in which case we need to run the pattern match checker. 555555555 555555555None&p 5ghc-libA high-level pattern-match constraint. Corresponds to  from Figure 3 of the LYG paper.5ghc-libA type constraint "T ~ U".5ghc-lib PhiCoreCt x e encodes "x ~ e", equating x with the D e.5ghc-libPhiConCt x K tvs dicts ys encodes K @tvs dicts ys <- x , matching x against the 0 application K @tvs dicts ys , binding tvs, dicts and possibly unlifted fields ys in the process. See Note [Strict fields and fields of unlifted type].5ghc-libPhiNotConCt x K! encodes "x D K", asserting that x can't be headed by K.5ghc-lib PhiBotCt x encodes "x ~ E", equating x to E. by K.5ghc-libPhiNotBotCt x y! encodes "x D E", asserting that x can't be E.5ghc-libAdd a bunch of 5 s to all the 0 s. Lifts c over many 0.5ghc-libaddPmCtsNablas for a single PmCt.5ghc-libTest if any of the 0s is inhabited. Currently this is pure, because we preserve the invariant that there are no uninhabited 0s. But that could change in the future, for example by implementing this function in terms of notNull  $ generateInhabitingPatterns 1 ds.5ghc-lib%generateInhabitingPatterns vs n nabla returns a list of at most n% (but perhaps empty) refinements of nabla that represent inhabited patterns. Negative information is only retained if literals are involved or for recursive GADTs.000055555555555555000055555555555555Noner6ghc-libPretty-print the guts of an uncovered value vector abstraction, i.e., its components and refutable shapes associated to any mentioned variables. Example for )([Just p, q], [p :-> [3,4], q :-> [0,5]]): (Just p) q where p is not one of {3, 4} q is not one of {0, 5} When the set of refutable shapes contains more than 3 elements, the additional elements are indicated by "...".66None '(5>sB6ghc-lib*Coverage checking action. Can be composed c or c.66666666666666None ?u|6ghc-libUse -XStrict to add a ! or remove a ~ See Note [decideBangHood]6ghc-lib Scrutineeghc-lib Type of expghc-lib,Alternatives (bndrs *include* tyvars, dicts)6ghc-libticks to add, possiblyghc-lib The patternghc-lib(Expression to which the pattern is boundghc-libId the rhs is bound to, for desugaring strict binds (see Note [Desugar Strict binds] in GHC.HsToCore.Binds) and all the desugared binds6ghc-libOriginal pattern555555555666666666666666666666666666666666666666666666555555665556666666666666666666666666666666666666666666Nonevt6666666666None ?v66Noney+6ghc-libPost-typechecker, the c field of an c8 contains (an expression for) the literal value itself.6ghc-libEmit warnings on overloaded integral literals which overflow the bounds implied by their type.6ghc-libEmit warnings on integral literals which overflow the bounds implied by their type.6ghc-lib Warns about  [2,3 .. 1] or [b .. a] which return the empty list. For numeric literals, only works for integral types, not floating point.6ghc-lib!Type of the whole case expressionghc-lib All PgLits 666666666666 666666666666Nonez 6ghc-lib Guarded RHSsghc-lib Type of RHSghc-libRefined pattern match checking models, one for the pattern part and one for each GRHS.666666None '(>z6ghc-libDesugar the non-empty ces of a c.66666666None '(>R6ghc-lib8Check a pattern binding (let, where) for exhaustiveness.6ghc-libExhaustive for guard matches, is used for guards in pattern bindings and in MultiIf expressions. Returns the 0 covered by the RHSs.6ghc-libCheck a list of syntactic c1es (part of case, functions, etc.), each with a c and one or more c:  f x y | x == y = 1 -- match on x and y with two guarded RHSs | otherwise = 2 f _ _ = 3 -- clause with a single, un-guarded RHS Returns one non-empty 0 for 1.) each pattern of a c and 2.) each of a ces c& for Note [Long-distance information].Special case: When there are  no matches*, then the functionassumes it checks and  -XEmptyCase with only a single match variable. See Note [Checking EmptyCase].6ghc-libAdd in-scope type constraints if the coverage checker might run and then run the given action.6ghc-libAdd equalities for the D scrutinee to the local 1 environment when checking a case expression: case e of x { matches } When checking matches we record that (x ~ e) where x is the initial uncovered. All matches will have to satisfy this equality.6ghc-lib6, but desugars the c first.6ghc-lib#Match context, for warning messagesghc-libThe GRHSs to checkghc-libCovered 0( for each RHS, for long distance info6ghc-lib$Match context, for warnings messagesghc-lib#Match variables, i.e. x and y aboveghc-libList of matchesghc-lib One covered 0/ per Match and GRHS, for long distance info.56666666665666None ?6ghc-libDesugar top level binds, strict binds are treated like normal binds since there is no good time to force before first usage.6ghc-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] 6666666666 6666666666None/?o6ghc-lib5This is Nothing only when we are dealing with a VarBr66None6666None !_6ghc-lib matchSimply is a wrapper for 6 which deals with the situation where we want to match a single expression against a single pattern. It returns an expression.6ghc-lib&The scrutinee the match id is bound to6ghc-lib Scrutineeghc-lib Match kindghc-libPattern it should matchghc-libReturn this if it matchesghc-libReturn this if it doesn't6ghc-libFor shadowing warning messagesghc-libScrutinee. (Just scrut) for a case expr case scrut of { p1 -> e1 ... } (and in this case the MatchGroup will have all singleton patterns) Nothing for a function definition f p1 q1 = ... -- No "scrutinee" f p2 q2 = ... -- in this caseghc-libMatches being desugaredghc-libResults (usually passed to 6)6ghc-libVariables rep'ing the exprs we're matching with ^ See Note [Match Ids]^ Note that the Match Ids carry not only a name, but ^ also the multiplicity at which each column has been ^ type checked.ghc-libType of the case expressionghc-lib.Info about patterns, etc. (type synonym below)ghc-libDesugared result!666666666666None6666None66None6ghc-libReplace the body of the function with this block to test the hsExprType function in GHC.Tc.Utils.Zonk: putSrcSpanDs loc $ do { core_expr <- dsExpr e ; if debugIsOn && not ( exprType core_expr = hsExprType e -- ) then (assertPprPanic "compilerGHCHsToCore/Expr.hs" 249 ( ppr e  + dcolon  +8 ppr (hsExprType e) $$ -- ppr core_expr  + dcolon  ++ ppr (exprType core_expr) )) else return ()6ghc-lib Variant of 6 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 GHC.HsToCore.Monad/ See Note [Levity polymorphism invariants] in GHC.Core66666666666666None6ghc-lib7everything is up to date, recompilation is not required6ghc-libThe .hs file has been touched, or the .o/.hi file does not exist6ghc-libThe .o/.hi files are up to date, but something else has changed to force recompilation; the String says what (one-line summary)6ghc-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 Nothing means to rebuild the interface file and not use the existing one.6ghc-lib1Add fingerprints for top-level declarations to a  .$See Note [Fingerprinting IfaceDecls]66666666666666None7ghc-libExtract information from the rename and typecheck phases to produce a dependencies information for the module being compiled.;The second argument is additional dependencies from plugins777777None7ghc-libFully instantiate an interface. Adds fingerprints and potentially code generator produced information.CgInfos is not available when not generating code (-fno-code), or when not generating interface pragmas (-fomit-interface-pragmas). See also Note [Conveying CAF-info and LFInfo between modules] in GHC.StgToCmm.Types.7ghc-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 ( ).777777777777None7ghc-libPretty-prints a 8 (type/data family instance) with its defining location.7ghc-libPretty-prints a  with its defining location.7ghc-libPretty-prints the  header. For functions and data constructors the function is equivalent to 7 but for type constructors and classes it prints only the header part of the declaration.7ghc-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.7ghc-libLike 7!, but adds the defining location.7ghc-libPretty-prints a .77777777777777None7ghc-libGenerate a section type (e.g.  @progbits). See #13937.7ghc-libTarget platformghc-lib section typeghc-libpretty assembler fragment77None7ghc-lib8Given a section name, read its contents as a ByteString.If the section isn't found or if there is any parsing error, we return Nothing7ghc-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 returned7ghc-lib.Generate the GAS code to create a Note sectionHeader fields for notes are 32-bit long (see Note [ELF specification]).777777Nonep7ghc-libEmit a ".string" directive7ghc-libEmit a ".incbin" directive+A NULL byte is added after the binary data.7777777777Noneֈ7ghc-libLlvm cast operations.7ghc-libInteger truncate7ghc-libInteger extend (zero fill)7ghc-libInteger extend (sign fill)7ghc-libFloat truncate7ghc-lib Float extend7ghc-libFloat to unsigned Integer7ghc-libFloat to signed Integer7ghc-libUnsigned Integer to Float7ghc-libSigned Int to Float7ghc-libPointer to Integer7ghc-libInteger to Pointer7ghc-lib6Cast between types where no bit manipulation is needed7ghc-libLlvm compare operations.7ghc-libEqual (Signed and Unsigned)7ghc-libNot equal (Signed and Unsigned)7ghc-libUnsigned greater than7ghc-libUnsigned greater than or equal7ghc-libUnsigned less than7ghc-libUnsigned less than or equal7ghc-libSigned greater than7ghc-libSigned greater than or equal7ghc-libSigned less than7ghc-libSigned less than or equal7ghc-lib Float equal7ghc-libFloat not equal7ghc-libFloat greater than7ghc-libFloat greater than or equal7ghc-libFloat less than7ghc-libFloat less than or equal7ghc-lib)Llvm binary operators machine operations.7ghc-lib1add two integer, floating point or vector values.7ghc-libsubtract two ...7ghc-lib multiply ..7ghc-lib$unsigned integer or vector division.7ghc-libsigned integer ..7ghc-lib*unsigned integer or vector remainder (mod)7ghc-lib signed ...7ghc-lib(add two floating point or vector values.7ghc-libsubtract two ...7ghc-lib multiply ...7ghc-lib divide ...7ghc-lib remainder ...7ghc-lib Left shift7ghc-lib3Logical shift right Shift right, filling with zero7ghc-libArithmetic shift right The most significant bits of the result will be equal to the sign bit of the left operand.7ghc-libAND bitwise logical operation.7ghc-libOR bitwise logical operation.7ghc-libXOR bitwise logical operation.7ghc-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.7ghc-libGlobal 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.7ghc-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.7ghc-libweak 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.7ghc-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.7ghc-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.7ghc-libThe symbol participates in linkage and can be used to resolve external symbol references.7ghc-lib Alias for 73 but with explicit textual form in LLVM assembly.7ghc-libSymbol is private to the module and should not appear in the symbol table7ghc-libFunctions can have a fixed amount of parameters, or a variable amount.7ghc-lib1Different calling conventions a function can use.7ghc-libThe 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).7ghc-libThis 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.7ghc-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.7ghc-libThe GHC-specific  registerised calling convention.7ghc-libAny calling convention may be specified by number, allowing target-specific calling conventions to be used. Target specific calling conventions start at 64.7ghc-lib X86 Specific 7 convention. LLVM includes a specific alias for it rather than just using CC_Ncc.7ghc-lib#Different types to call a function.7ghc-lib(Normal call, allocate a new stack frame.7ghc-lib7Tail call, perform the call in the current stack frame.7ghc-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#fnattrs7ghc-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.7ghc-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.7ghc-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.7ghc-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.7ghc-libThis function attribute indicates that the function never returns normally. This produces undefined behavior at runtime if the function ever does dynamically return.7ghc-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.7ghc-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.7ghc-libThis 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.7ghc-libThis 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.7ghc-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.7ghc-libThis attribute indicates that the code generator should not use a red zone, even if the target-specific ABI normally permits it.7ghc-lib>This attributes disables implicit floating point instructions.7ghc-libThis attribute disables prologue / epilogue emission for the function. This can have very system-specific consequences.7ghc-libLLVM Parameter Attributes.Parameter attributes are used to communicate additional information about the result or parameters of a function7ghc-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).7ghc-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).7ghc-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).7ghc-libThis indicates that the pointer parameter should really be passed by value to the function.7ghc-libThis indicates that the pointer parameter specifies the address of a structure that is the return value of the function in the source program.7ghc-libThis indicates that the pointer does not alias any global or any other parameter.7ghc-libThis indicates that the callee does not make any copies of the pointer that outlive the callee itself7ghc-libThis indicates that the pointer parameter can be excised using the trampoline intrinsics.7ghc-libAn LLVM Function7ghc-lib!Unique identifier of the function7ghc-libLinkageType of the function7ghc-lib&The calling convention of the function7ghc-libType of the returned value8ghc-lib'Indicates if this function uses varargs8ghc-libParameter types and attributes8ghc-lib(Function align value, must be power of 28ghc-libLLVM code generator options8ghc-libTarget platform8ghc-lib+Fill undefined literals with garbage values8ghc-libSplit sections8ghc-libLlvm Static Data.These represent the possible global level variables and constants.8ghc-libA comment in a static section8ghc-lib#A static variant of a literal value8ghc-libFor uninitialised data8ghc-libDefines a static 88ghc-libA static array8ghc-libA static structure type8ghc-libA pointer to other data8ghc-libTruncate8ghc-libPointer to Pointer conversion8ghc-libPointer to Integer conversion8ghc-libConstant addition operation8ghc-libConstant subtraction operation8ghc-libLlvm Literal Data.(These can be used inline in expressions.8ghc-lib'Refers to an integer constant (i64 42).8ghc-libFloating point literal8ghc-lib.Literal NULL, only applicable to pointer types8ghc-libVector literal8ghc-lib>Undefined value, random bit pattern. Useful for optimisations.8ghc-libLLVM Variables8ghc-libVariables with a global scope.8ghc-lib,Variables local to a function or parameters.8ghc-libNamed local variables. Sometimes we need to be able to explicitly name variables (e.g for function arguments).8ghc-libA constant variable8ghc-libMutable global variable8ghc-libConstant global variable8ghc-libAlias of another variable8ghc-libAn LLVM section definition. If Nothing then let LLVM decide the section8ghc-lib Llvm Types8ghc-lib&An integer with a given width in bits.8ghc-lib32 bit floating point8ghc-lib64 bit floating point8ghc-lib 80 bit (x86 only) floating point8ghc-lib128 bit floating point8ghc-libA pointer to a 88ghc-lib An array of 88ghc-lib A vector of 88ghc-libA 8 can represent a label (address)8ghc-lib Void type8ghc-libPacked structure type8ghc-libUnpacked structure type8ghc-lib A type alias8ghc-lib LLVM Metadata8ghc-lib3Function type, used to create pointers to functions8ghc-lib A type alias8ghc-libA String in LLVM8ghc-lib4A global mutable variable. Maybe defined or external8ghc-libReturns the variable of the 88ghc-libReturn the value of the 88ghc-libGet LlvmOptions from DynFlags8ghc-lib Return the 8 of the 88ghc-lib Return the 8 of a 88ghc-lib Return the 8 of the 88ghc-lib Return the 7 for a 88ghc-lib0Add a pointer indirection to the supplied type. 8 and 8 cannot be lifted.8ghc-libLift a variable to 8 type.8ghc-lib:Remove the pointer indirection of the supplied type. Only 8 constructors can be lowered.8ghc-libLower a variable of 8 type.8ghc-libTest if the given 8 is an integer8ghc-libTest if the given 8 is a floating point type8ghc-libTest if the given 8 is an 8 construct8ghc-libTest if the given 8 is an 8 construct8ghc-lib Test if a 8 is global.8ghc-libWidth in bits of an 8, returns 0 if not applicable8ghc-lib"The target architectures word size8ghc-lib"The target architectures word size8ghc-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].777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777778887777888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888778887777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777888888Noneۤ8ghc-libMetadata declarations. Metadata can only be declared in global scope.8ghc-libNamed metadata. Only used for communicating module information to LLVM. ('!name = !{ [!] }' form).8ghc-libMetadata node declaration. ('!0 = metadata !{ }' form).8ghc-libAssociates some metadata with a specific label for attaching to an instruction.8ghc-libLLVM metadata expressions9ghc-lib)A reference to an un-named metadata node. 888888888899 998888888888None;9ghc-libLlvm Expressions9ghc-libAllocate amount * sizeof(tp) bytes on the stack * tp: LlvmType to reserve room for * amount: The nr of tp's which must be allocated9ghc-libPerform the machine operator op on the operands left and right * op: operator * left: left operand * right: right operand9ghc-libPerform a compare operation on the operands left and right * op: operator * left: left operand * right: right operand9ghc-libExtract a scalar element from a vector * val: The vector * idx: The index of the scalar within the vector9ghc-libExtract a scalar element from a structure * val: The structure * idx: The index of the scalar within the structure Corresponds to "extractvalue" instruction.9ghc-libInsert a scalar element into a vector * val: The source vector * elt: The scalar to insert * index: The index at which to insert the scalar9ghc-libAllocate amount * sizeof(tp) bytes on the heap * tp: LlvmType to reserve room for * amount: The nr of tp's which must be allocated9ghc-libLoad the value at location ptr9ghc-lib(Atomic load of the value at location ptr9ghc-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.9ghc-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 to9ghc-libAtomic read-modify-write operation * op: Atomic operation * addr: Address to modify * operand: Operand to operation * ordering: Ordering requirement9ghc-libCompare-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.9ghc-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.9ghc-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.9ghc-libMerge 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.9ghc-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.9ghc-lib/A LLVM expression with metadata attached to it.9ghc-libLlvm Statements9ghc-libAssign an expression to a variable: * dest: Variable to assign to * source: Source expression9ghc-libMemory fence operation9ghc-lib!Always branch to the target label9ghc-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 false9ghc-libComment Plain comment.9ghc-libSet a label on this position. * name: Identifier of this label, unique for this module9ghc-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 in9ghc-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.9ghc-libReturn a result. * result: The variable or constant to return9ghc-libAn instruction for the optimizer that the code following is not reachable9ghc-libRaise an expression to a statement (if don't want result or want to use Llvm unnamed values.9ghc-libA nop LLVM statement. Useful as its often more efficient to use this then to wrap LLvmStatement in a Just or [].9ghc-lib.A LLVM statement with metadata attached to it.9ghc-lib'LLVM atomic operations. Please see the  atomicrmw instruction in the LLVM documentation for a complete description.9ghc-libLLVM ordering types for synchronization purposes. (Introduced in LLVM 3.0). Please see the LLVM documentation for a better description.9ghc-lib(Some partial order of operations exists.9ghc-lib?A single total order for operations at a single address exists.9ghc-lib"Acquire synchronization operation.9ghc-lib"Release synchronization operation.9ghc-lib,Acquire + Release synchronization operation.9ghc-lib&Full sequential Consistency operation.9ghc-libAn LLVM Function9ghc-lib(The signature of this declared function.9ghc-libThe functions arguments9ghc-libThe function attributes.9ghc-lib%The section to put the function into,9ghc-lib Prefix data9ghc-libThe body of the functions.9ghc-lib6An LLVM Module. This is a top level container in LLVM.9ghc-lib/Comments to include at the start of the module.9ghc-libLLVM Alias type definitions.9ghc-libLLVM meta data.9ghc-lib*Global variables to include in the module.9ghc-libLLVM Functions used in this module but defined in other modules.9ghc-lib&LLVM Functions defined in this module.9ghc-libA block of LLVM code.9ghc-libThe code label for this block9ghc-libA list of LlvmStatement's representing the code for this block. This list must end with a control flow statement.9ghc-lib Block labels99999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999None~9ghc-libPrint out a whole LLVM module.9ghc-libPrint out a multi-line comment, can be inside a function or on its own9ghc-lib;Print out a comment, can be inside a function or on its own9ghc-lib7Print out a list of global mutable variable definitions9ghc-lib.Print out a global mutable variable definition9ghc-lib&Print out a list of LLVM type aliases.9ghc-libPrint out an LLVM type alias.9ghc-lib"Print out a list of LLVM metadata.9ghc-lib&Print out an LLVM metadata definition.9ghc-lib)Print out a list of function definitions.9ghc-lib Print out a function definition.9ghc-lib)Print out a list of function declaration.9ghc-libPrint out a function declaration. Declarations define the function type but don't define the actual body of the function.9ghc-lib)Return the variable name or value of the 8* in Llvm IR textual representation (e.g. @x, %y or 42).9ghc-lib)Return the variable name or value of the 8* in a plain textual representation (e.g. x, y or 42).9ghc-libPrint a literal value. No type.999999999999999999999999999999999999None7777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777778888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888889999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999988888899999999999999997777778889799999999999999999999999999999999999999977777777779999999999999999999777777777777777777777777777777777777777777777777777777777777777777777777777777777777788888888888888888888888888888888888888888888888888888888888888888888889988888888888888999999999999999999None 9ghc-lib;Get the LlvmVar function variable storing the real register9ghc-lib;Get the LlvmVar function argument storing the real register9ghc-lib>A list of STG Registers that should always be considered alive9ghc-lib'STG Type Based Alias Analysis hierarchy9ghc-libId values The c 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.9ghc-libId values The c 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.9ghc-libId values The c 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.9ghc-libId values The c 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.9ghc-libId values The c 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.9ghc-libThe TBAA metadata identifier9ghc-libGet the correct TBAA metadata information for this register type 99999999999 99999999999None5R-9ghc-libThe Llvm monad. Wraps LlvmEnv state as well as the IO monad9ghc-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.9ghc-lib.Top level LLVM Data (globals and type aliases)9ghc-libUnresolved code. Of the form: (data label, data type, unresolved data)9ghc-lib#Global registers live on proc entry:ghc-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-lib#Llvm Function type for Cmm function:ghc-libLlvm Function signature:ghc-libAlignment to use for functions:ghc-lib Alignment to use for into tables:ghc-libSection to use for a function:ghc-libA Function's arguments:ghc-lib=Return a list of "padding" registers for LLVM function calls.When we generate LLVM function signatures, we can't just make any register alive on function entry. Instead, we need to insert fake arguments of the same register class until we are sure that one of them is mapped to the register we want alive. E.g. to ensure that F5 is alive, we may need to insert fake arguments mapped to F1, F2, F3 and F4.Invariant: Cmm FPR regs with number "n" maps to real registers with number "n" If the calling convention uses registers in a different order or if the invariant doesn't hold, this code probably won't be correct.:ghc-libLlvm standard fun attributes:ghc-libConvert a list of types to a list of function parameters (each with no parameter attributes):ghc-lib Pointer width:ghc-lib-The LLVM Version that is currently supported.:ghc-lib-The LLVM Version that is currently supported.:ghc-libGet target platform:ghc-libGet LLVM options:ghc-libLifting of IO actions. Not exported, as we want to encapsulate IO.:ghc-libGet initial Llvm environment.:ghc-lib9Clear variables from the environment for a subcomputation:ghc-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 stack:ghc-lib2Check whether a register is allocated on the stack:ghc-lib1Allocate a new global unnamed metadata identifier:ghc-lib/Get the LLVM version we are generating code for:ghc-libDumps the document if the corresponding flag has been set by the user:ghc-lib.Prints the given contents to the output handle:ghc-libMarks a variable as "used":ghc-lib,Return all variables marked as "used" so far:ghc-lib%Sets metadata node for a given unique:ghc-lib#Gets metadata node for given unique:ghc-libHere 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 c.: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-libDerive the definition label. It has an identified structure type.:ghc-lib7Generate definitions for aliases forward-referenced by  getGlobalPtr.Must 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.7999999999:::::::::::::::::::::::::::::::::::::::::::::799999999::::::9:::::::::::::::::::::::::::::::::::::::NoneV:ghc-libRun compiler of C-like languages and raw objects (such as gcc or clang).:ghc-lib8Run the linker with some arguments and return the output:ghc-libRun the LLVM Optimiser:ghc-libRun the LLVM Compiler:ghc-libRun 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
&:ghc-lib0Pretty print a format for an instruction suffix.:ghc-lib Pretty print an immediate value.:ghc-libPretty print a data item.:ghc-libPretty print an instruction.::::::::::::::None'<:ghc-libEnforce intra-block invariants.::None'(':ghc-libTop level code generation::::None':ghc-lib"instance for sparc instruction set::None(::::None(q;ghc-lib Instruction instance for powerpc;;None)B;ghc-libLanguage ID used for Haskell.;ghc-lib.Mapping of registers to DWARF register numbers;ghc-lib2Virtual register number to use for return address.;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;None >?4;ghc-libUnwind instructions for a block. Will become part of the containing FDE.;ghc-libthese unwind points must occur in the same order as they occur in the block;ghc-libUnwind instructions for an individual procedure. Corresponds to a "Frame Description Entry" (FDE) in DWARF.;ghc-lib%List of blocks. Order must match asm!;ghc-libInformation 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.;ghc-libIndividual dwarf records. Each one will be encoded as an entry in the  .debug_info section.;ghc-lib)label of DIE belonging to the parent tick;ghc-libAbbreviation declaration. This explains the binary encoding we use for representing ;1. Be aware that this must be updated along with ;.;ghc-lib Generate assembly for DWARF data;ghc-lib4Print assembler directives corresponding to a DWARF .debug_aranges address table entry.;ghc-libHeader for the  .debug_frame section. Here we emit the "Common Information Entry" record that establishes general call frame parameters and the default stack layout.;ghc-lib)Align assembly at (machine) word boundary;ghc-lib1Assembly for a single byte of constant DWARF data<ghc-lib(Assembly for a two-byte constant integer<ghc-lib*Assembly for 4 bytes of dynamic DWARF data<ghc-libAssembly for a DWARF word of dynamic data. This means 32 bit, as we are generating 32 bit DWARF.<ghc-libAssembly for a machine word of dynamic data. Depends on the architecture we are currently generating code for.<ghc-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 number<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./;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;<<<<<< 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 GHC.Tc.Deriv.Infer 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 c9, and whether or the constraint deals in types or kinds.<ghc-libRecords whether a particular class can be derived by way of an  originative deriving strategy (i.e., stock or anyclass).See Note [Deriving strategies] in  GHC.Tc.Deriv.<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 D).A standalone deriving declaration with an extra-constraints wildcard as the context (in which case  mb_wildcard is G 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-lib>What action to take in order to derive a class instance. See &Note [DerivEnv and DerivSpecMechanism], as well as Note [Deriving strategies] in  GHC.Tc.Deriv.<ghc-lib"Standard" classes<ghc-lib GeneralizedNewtypeDeriving<ghc-lib DeriveAnyClass<ghc-lib  DerivingVia<ghc-libInformation about the arguments to the class in the derived instance, including what type constructor the last argument is headed by. See &Note [DerivEnv and DerivSpecMechanism].<ghc-lib"This function returns four things: LHsBinds GhcPs6: The derived instance's function bindings (e.g., !compare (T x) (T y) = compare x y) [LSig GhcPs]: A list of instance specific signatures/pragmas. Most likely INLINE pragmas for class methods. BagDerivStuff: Auxiliary bindings needed to support the derived instance. As examples, derived Generic instances require associated type family instances, and derived c and c! instances require top-level con2tag functions. See Note [Auxiliary binders] in GHC.Tc.Deriv.Generate.[Name]: A list of Names for which -Wunused-binds should be suppressed. This is used to suppress unused warnings for record selectors when deriving c, c, or Generic . See +Note [Deriving and unused record selectors].<ghc-libInformation about the arguments to the class in the derived instance, including what type constructor the last argument is headed by. See &Note [DerivEnv and DerivSpecMechanism].<ghc-libThe newtype rep type.<ghc-lib0All arguments to the class besides the last one.<ghc-libThe last argument to the class.<ghc-libThe via type<ghc-libInformation about the arguments to the class in a stock- or newtype-derived instance. See &Note [DerivEnv and DerivSpecMechanism].<ghc-lib,Other arguments to the class except the last<ghc-libType constructor for which the instance is requested (last arguments to the type class)<ghc-lib!Arguments to the type constructor<ghc-libThe representation tycon for <7 (for data family instances). Otherwise the same as <.<ghc-libThe representation types for <7 (for data family instances). Otherwise the same as <.<ghc-libContains all of the information known about a derived instance when determining what its EarlyDerivSpec should be. See &Note [DerivEnv and DerivSpecMechanism].<ghc-lib Is this an overlapping instance?<ghc-lib5Universally quantified type variables in the instance<ghc-lib-Class for which we need to derive an instance<ghc-libAll arguments to < in the derived instance.<ghc-lib< theta for standalone deriving (where theta( is the context of the instance). < for deriving clauses, or for standalone deriving that uses a wildcard constraint. See %Note [Inferring the instance context].<ghc-libG if user requests a particular deriving strategy. Otherwise, D.<ghc-lib0To avoid having to manually plumb everything in <" throughout various functions in  GHC.Tc.Deriv and GHC.Tc.Deriv.Infer , we use <#, which is a simple reader around D.<ghc-lib4Is GHC processing a standalone deriving declaration?<ghc-libIs 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 c if wc is D, and c if wc is c. Useful for error-reporting.<ghc-lib Convert a < to its corresponding c.<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<NoneV====None X%=ghc-lib%Stuff needed to process a datatype's  `deriving` clauses=ghc-libThe data tycon for normal datatypes, or the *representation* tycon for data families=ghc-lib.Variables that scope over the deriving clause.=ghc-lib error context==============None &Xq3=======================3=======None ?Y=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.======None ?_ &ghc-libCompares 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 inferred quantifiers only (:type)=ghc-libInstantiate all quantifiers, and do eager defaulting (:type +d)=ghc-lib1Top level entry point for typechecker and renamer=ghc-libCompares 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.=ghc-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 ().=ghc-lib:tcRnExpr just finds the type of an expression for :type=ghc-lib)ASSUMES that the module is either in the HomePackageTable 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 GHCi=ghc-lib.Extract the renamed information from TcGblEnv.&ghc-libTrue  =& an hs-boot file (could also be a sig)!&&&4444444=======================!====================4444444=&&&==c0None`=ghc-lib8Traverses the AST, simply to find all joinrecs and call exitify8 on them. The really interesting function is exitifyRec==None`====None 5>?l=ghc-lib(A basic block with liveness information.=ghc-libStash regs live on entry to each basic block in the info part of the cmm code.=ghc-libLiveness 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-libThe register allocator also wants to use SPILL/RELOAD meta instructions, so we'll keep those here.=ghc-libA real machine instruction=ghc-libspill this reg to a stack slot=ghc-lib!reload this reg from a stack slot=ghc-lib5A top level thing which carries liveness information.=ghc-lib$Map from some kind of register to a.While we give the type for keys as Reg which is the common case sometimes we end up using VirtualReq or naked Uniques. See Note [UniqFM and the register allocator]=ghc-lib7map a function across all the basic blocks in this code=ghc-libmap a function across all the basic blocks in this code (monadic version)=ghc-libmap 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 NatCmmDecl=ghc-libPretty-print a ==ghc-libMap over instruction type in ==ghc-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-libPatch registers in this LiveInstr, including the liveness information.=ghc-libConvert a NatCmmDecl to a LiveCmmDecl, with liveness information=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.% ====================================%==== ================================Noneu=ghc-libThe register allocator state=ghc-libthe current mapping from basic blocks to the register assignments at the beginning of that block.=ghc-libfree machine registers=ghc-lib assignment of temps to locations=ghc-libcurrent stack delta=ghc-libfree stack slots for spilling=ghc-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#Native code generator configuration=ghc-lib<(from,fixup,to) : We inserted fixup code between from and to=ghc-lib>Used to carry interesting stats out of the register allocator.=ghc-lib<(from,fixup,to) : We inserted fixup code between from and to=ghc-libReasons why instructions might be inserted by the spiller. Used when generating stats for -ddrop-asm-stats.=ghc-libvreg was spilled to a slot so we could use its current hreg for another vreg=ghc-lib-vreg was moved because its hreg was clobbered=ghc-lib!vreg was loaded from a spill slot=ghc-lib,reg-reg move inserted during join to targets=ghc-lib,reg-mem move inserted during join to targets=ghc-libWhere 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 register=ghc-libvreg is held in a stack slot=ghc-lib0vreg is held in both a register and a stack slot=ghc-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.======================================================Nonex>ghc-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.>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.>>>>Noneys>ghc-libBuild 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 RegAllocStats>>>>>>None5{>ghc-lib"The register allocator monad type.>ghc-lib'Get native code generator configuration>ghc-libghc-lib7Run a computation in the RegM register allocator monad.>ghc-libghc-libRecord a created fixup block===========>>>>>>>>>>>>>>>>>===========>>>>>>>>>>>>>>>>>None}>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.>ghc-libmaps 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.>>None-}A===========================>>>>>None'(7 >ghc-libMap of >>ghc-lib1Records the expected cost to spill some register.>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)>ghc-lib&Choose a node to spill from this graph>ghc-lib+Extract a map of register lifetimes from a >.>ghc-libShow a spill cost record, including the degree from the graph and final calculated spill cost. >>>>>>>>> >>>>>>>>>None>ghc-lib;Clean out unneeded spill/reloads from this top level thing.>>None>ghc-libghc-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-lib:Add a spill/reload count to a stats record for a register.>ghc-libthe codeghc-libavailable stack slotsghc-libcurrent number of spill slots.ghc-libthe regs to spill>>>>>>>>>>None 5>?l>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-libTarget platform>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-libDump a table of how many spill loads / stores were inserted for each vreg.>ghc-libDump a table of how long vregs tend to live for in the initial code.>ghc-libDump a table of how many conflicts vregs tend to have in the initial code.>ghc-libFor every vreg, dump how many conflicts it has, and its lifetime. Good for making a scatter plot.>ghc-lib Count spillreloadreg-reg moves. Lets us see how well the register allocator has done.>ghc-libglobal register conflict graph>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>None >?>ghc-lib7The top level of the graph coloring register allocator.>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-libcode with registers allocated, additional stacks required and stats for each stage of allocation>>None'(5>?A>ghc-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 stats>ghc-libInitialize the native code generator configuration from the DynFlags>ghc-libthe cmm to generate code forghc-lib!sequence number of this top thing>>>>>>None>ghc-lib(Generate code to initialise cost centres>ghc-libGenerate code to initialise info pointer origin See note [Mapping Info Tables to Source Positions]>ghc-lib3additional files to be compiled with the C compiler>>>>>>>>None>ghc-lib.The profiling header words in a static closure>ghc-lib+Profiling header words in a dynamic closure>ghc-lib1Initialise the profiling field of an update frame>ghc-libRecord the allocation of a closure. The CmmExpr is the cost centre stack to which to attribute the allocation.>ghc-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.>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>None>ghc-lib!Low-level heap object allocation.>ghc-liblower-level version for GHC.Cmm.Parser>ghc-librepresentation of the objectghc-lib info pointerghc-lib cost centreghc-libpayloadghc-lib!returns the address of the object###%>>>>>>>>>>>>###%>>>>>>>>>>>>Nonex>>>>>>None>ghc-libEmit code for a foreign call, and return the results to the sequel. Precondition: the length of the arguments list is the same as the arity of the foreign function.?ghc-lib1Produce code to save the current thread state to  CurrentTSO?ghc-libSave STG registersSTG registers must be saved around a C call, just in case the STG register is mapped to a caller-saves machine register. Normally we don't need to worry about this the code generator has already loaded any live STG registers into variables for us, but in hand-written low-level Cmm code where we don't know which registers are live, we might have to save them all.?ghc-libRestore STG registers (see ?)?ghc-lib3Produce code to load the current thread state from  CurrentTSO >>>>???????? >>>>????????None????None#$'(K????Nonew$??$None$?????$???None/??None >??c9 c9 None #$'(2<>?V?ghc-libMaps labels from ? 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-libCurrent module being compiled. Required for calling labelDynamic.?ghc-libprevious 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.?ghc-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 ?-: a mapping from code block to sets of labels?ghc-libGiven ? of a module, returns the set of non-CAFFY names in the module. Any Names not in the set are CAFFY.?ghc-libAttach SRTs to all info tables in the CmmDecls, and add SRT declarations to the ModuleSRTInfo.????????????????????????????None?ghc-lib!Top level driver for C-- pipeline??None?t?ghc-libAn efficient serialiser of c.?ghc-libAn efficient deserialiser of c.????None??Noner?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-libloadDLL 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-libpurgeObj drops the symbols for the dynamic library from the symbol table. Unlike ?, the library will not be dropped memory during a future major GC.??????????????????????????????None #$8?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.Note, 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.??????????????????????????????None #$>??UNone#$-?ghc-lib3Run a command in the interpreter's context. With -fexternal-interpreter, 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-lib$Retrieve the target code interpreter0Fails if no target code interpreter is available?ghc-libGrab a lock on the c 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 s 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-libAllocate 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-libSend a Seq message to the iserv process to force a value #2950@ghc-libloadDLL 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 0 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-libStop the interpreter@ghc-lib Creates a c& that will automatically release the c! when it is no longer referenced.@ghc-lib Convert a c 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 c 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-libInterpreter uses Profiling way@ghc-libInterpreter uses Dynamic waycccccccccdddddddddddddddd????@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@????@@@@@@@@@@@None@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 printer@ghc-libTerm reconstruction"Given a pointer to a heap object () and its type, build a @ 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 @s. 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 () 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:Stopped 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@ghc-lib On macOS we rely on the linkers -dead_strip_dylibs flag to remove unused libraries from the dynamic library. We do this to reduce the number of load commands that end up in the dylib, and has been limited to 32K (32768) since macOS Sierra (10.14).-dead_strip_dylibs does not dead strip -rpath entries, as such passing -l and -rpath to the linker will result in the unnecesasry libraries not being included in the load commands, however the -rpath entries are all forced to be included. This can lead to 100s of -rpath entries being included when only a handful of libraries end up being truly linked.Thus after building the library, we run a fixup phase where we inject the -rpath for each found library (in the given library search paths) into the dynamic library through  -add_rpath.#See Note [Dynamic linking on macOS]@@@@@@@@None@ghc-lib7Some platforms require that we explicitly link against libm if any math-y things are used (which we assume to include all programs). See #14022.@@@@None'@ghc-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.@ghc-lib*Compute the output file name of a program.StaticLink boolean is used to indicate if the program is actually a static library (e.g., on iOS).Use the provided filename (if any), otherwise use "main.exe" (Windows), "a.out (otherwise without StaticLink set), "liba.a". In every case, add the extension if it is missing.@@@@@@@@None 5b@@@@None@ghc-lib"Main entry point to the desugarer.@@@@None '(-/3>?@ghc-lib Construct an  % from the outputs of the typechecker.@ghc-lib Construct an   from the outputs of the typechecker but don't read the source file again from disk.Aghc-lib!This instance tries to construct   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.d, 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.Since the above is quite costly, we just skip cases where computing the expression's type is going to be expensive. See #16233@@@@@@@@NoneAAYNone#$5ŸAghc-libFinds external references. Remember to remove the names defined by this group of BCOs themselvesAAAAAAAAAAXNone #$5AAAANone >9AAAAAAAAAAAAAAAANone#$͏Aghc-libLoad the module containing the given Name and get its associated . Throws a  . if loading fails or the name cannot be found.Aghc-lib"Temporarily extend the loaded env.Aghc-libDisplay the loader state.Aghc-lib,Initialise the dynamic linker. This entails*a) Calling the C initialisation procedure,6b) Loading any packages specified on the command line,c) 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.Aghc-libLoad a single expression,  including first loading packages and modules that this expression depends on.Raises an IO exception ( ) if it can't find a compiled version of the dependents to load.Bghc-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,if 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.Bghc-libLoad exactly the specified packages, and their dependents (unless of course they are already loaded). The dependents are loaded automatically, and it doesn't matter what order you specify the input packages.Bghc-libThe linkables to *keep*.(+++++++++++AAAAAAAAAABBB(++++++++++A+AAABBAABAAAANonebBghc-libLoads 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 G# parameter is used for debugging (-ddump-if-trace) only: it is shown as the reason why the module is being loaded.Bghc-libForce the interface for the module containing the name to be loaded. The G# parameter is used for debugging (-ddump-if-trace) only: it is shown as the reason why the module is being loaded.Bghc-lib Load the  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 moduleBghc-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 failedBghc-libCoerce a value as usual, but:1) Evaluate it immediately to get a segfault early if the coercion was wrong2) Wrap it in some debug messages at verbosity 3 or higher so we can see what happened if it does segfaultBghc-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 moduleCan 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.Need the module as well to record information in the interface file BBBBBBBBB BBBBBBBBBNone\Bghc-lib&ghc-lib(Releases the external interpreter state.&&&&&&&&&&&&&&BB&&&&&&&&&&&BB&&&None#$Bghc-libFailure modes for B.Bghc-libI returned D.Bghc-libD: The module was compiled. c: The module was :loaded.Bghc-libThe  was defined interactively.Bghc-libdefault ExecOptionsBghc-lib3Run a statement in the current interactive context.Bghc-libLike B, but takes a parsed statement as argument. Useful when doing preprocessing on the AST before execution, e.g. in GHCi (see GHCi.UI.runStmt).Bghc-libRun some declarations and return any user-visible names that were brought into scope.Bghc-libLike B, but takes parsed declarations as argument. Useful when doing preprocessing on the AST before execution, e.g. in GHCi (see GHCi.UI.runStmt).Bghc-lib'Set the interactive evaluation context.(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.)Bghc-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.Bghc-libReturns True if the specified module is interpreted, and hence has its full top-level scope available.Bghc-libLooks 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)Bghc-lib=Returns all names in scope in the current interactive contextBghc-lib Returns all s in scope in the current interactive context, excluding any that are internally-generated.Bghc-lib:Parses a string as an identifier, and returns the list of s that the identifier can refer to in the current interactive context.Bghc-libGet the type of an expression Returns the type as described by =Bghc-libGet the kind of a typeBghc-libParse an expression, the parsed expression can be further processed and passed to compileParsedExpr.Bghc-libCompile an expression, run it, and deliver the resulting HValue.Bghc-libCompile an expression, run it, and deliver the resulting HValue.Bghc-libCompile a parsed expression (before renaming), run it, and deliver the resulting HValue.Bghc-libCompile an expression, run it and return the result as a Dynamic.Bghc-lib a statement (bind or expression)"??????????????????????????????????@@@@@@@@@@@@@@@BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBCCCCC"?????????????????BB??????B???????BBBBB????BBBB@BBBBBBBBBBBBBBBBBBBBCCBBBBBB@@@@@@@@@@@@@@CCCNone %Cghc-libJust preprocess a file, put the result in a temp. file (used by the compilation manager during the summary phase).We return the augmented DynFlags, because they contain the result of slurping in the OPTIONS pragmasCghc-libCompileCompile 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.Cghc-lib/Computes the next output filename after we run  next_phase. Like C, but it operates in the (9 monad (which specifies all of the ambient information.)Cghc-libComputes the next output filename for something in the compilation pipeline. This is controlled by several variables: (!: the last phase to be run (e.g.  stopPhase). This is used to tell if we're in the last phase or not, because in that case flags like -o may be important.d: is this intended to be a d or d build output? Temporary files just go in a fresh temporary name.c3: what was the basename of the original input file?: the obvious thing(8: 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?)Cghc-libEach 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.Cghc-libRun CPP1UnitState is needed to compute MIN_VERSION macrosCghc-libWhat phase to run after one of the backend code generators has runCghc-libinput filenameghc-lib8optional buffer to use instead of reading the input fileghc-libstarting phaseCghc-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 successfulCghc-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 successfulCghc-libinteractive or batchghc-libLoggerghc-lib dynamic flagsghc-libunit environmentghc-libattempt linking in batch mode?ghc-lib what to linkCghc-libRun this phaseghc-libname of the input file&())())))))))))))))))))):CCCCCCCCCCCCCC&CCCCCC())()))))))))))))))CC))CC))CCC:CNone #$%567 Cghc-lib>Describes which modules of the module graph need to be loaded.Cghc-lib&Load all targets and its dependencies.Cghc-lib0Load only the given module and its dependencies.Cghc-libLoad only the dependencies of the given module, but not the module itself.Cghc-libPerform a dependency analysis starting from the current targets and update the session with the new module graph.(Dependency analysis entails parsing the import 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 LANGUAGE pragmas of the parsed module. Thus if you want changes to the  to take effect you need to call this function again. In case of errors, just throw them.Cghc-lib$Perform dependency analysis like in C. In case of errors, the errors and an empty module graph are returned.Cghc-lib!Perform dependency analysis like C but return a partial module graph even in the face of problems with some modules.Modules which have parse errors in the module header, failing preprocessors or other issues preventing them from being summarised will simply be absent from the returned module graph.Unlike C this function will not update ` with the new module graph.Cghc-lib5Collect the instantiations of dependencies to create d work graph nodes. These are used to represent the type checking that is done after all the free holes (sigs in current package) relevant to that instantiation are compiled. This is necessary to catch some instantiation errors.In the future, perhaps more of the work of instantiation could be moved here, instead of shoved in with the module compilation nodes. That could simplify backpack, and maybe hs-boot too.Cghc-libTry to load the program. See C 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 backend (see  field) compiling and loading may result in files being created on disk. Calls the B> after each compiling each module, whether successful or not.If errors are encountered during dependency analysis, the module C returns together with the errors an empty ModuleGraph. After processing this empty ModuleGraph, the errors of depanalE are thrown. All other errors are reported using the B.Cghc-libGeneralized version of C which also supports a custom B (for reporting progress) and ! (generally produced by calling C.Cghc-lib Tests if an c9 is a boot file, primarily for constructing elements of d. We conflate signatures and modules because they are bound in the same namespace; only boot interfaces can be disambiguated with `import {- SOURCE -}`.Cghc-lib$Topological sort of the module graphCalculate 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)?False: 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 cyclicCghc-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.Cghc-libexcluded modulesghc-liballow duplicate rootsCghc-libexcluded modulesghc-liballow duplicate rootsCghc-libexcluded modulesghc-liballow duplicate rootsghc-libpossibly empty Bag of errors and a module graph.Cghc-libDrop hi-boot nodes? (see below)ghc-libRoot module name. If Nothing, use the full graph.Cghc-lib Old summariesCghc-libMap of old summaries  ((44CCCCCCCCCCCCCCCCCCCCCCCCC CCCCCCCCCCCC((CC44CCCC CCCCCCCNone %&:z;Cghc-lib?An error thrown if the GHC API is used in an incorrect fashion.Cghc-lib"Container for information about a .Cghc-lib.A CoreModule consists of just the fields of a ` that are needed for the C interface.Cghc-lib Module nameCghc-lib2Type environment for types declared in this moduleCghc-lib DeclarationsCghc-libSafe Haskell modeCghc-libThe result of successful desugaring (i.e., translation to core). Also contains all the information of a typechecked module.Cghc-libThe result of successful typechecking. It also contains the parser result.Cghc-lib!The result of successful parsing.Cghc-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.Cghc-libThis function is no longer necessary, cleanup is now done by runGhc/runGhcT.Cghc-libRun function for the ( monad.0It initialises the GHC session and warnings via C. Each call to this function will create a new session which should not be shared among several threads."Any errors not handled inside the () action are propagated as IO exceptions.Cghc-libRun function for B monad transformer.0It initialises the GHC session and warnings via C. Each call to this function will create a new session which should not be shared among several threads.Cghc-libInitialise a GHC session.If you implement a custom B 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-libdir 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.Cghc-libUpdates 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).Cghc-libSets the program . Note: this invalidates the internal cached module graph, causing more work to be done the next time C is called.Returns a boolean indicating if preload units have changed and need to be reloaded.Cghc-libReturns the program .Cghc-libSet the  used to evaluate interactive expressions. Also initialise (load) plugins.9Note: this cannot be used for changes to packages. Use C, or C and then copy the  unitState into the interactive DynFlags.Cghc-libGet the * used to evaluate interactive expressions.Cghc-libParse command line arguments that look like files. First normalises its arguments and then splits them into source files and object files. A source file can be turned into a  via CCghc-libSets 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 C.Cghc-lib"Returns the current set of targetsCghc-libAdd another target.Cghc-libRemove a targetCghc-libAttempts to guess what Target a string refers to. This function implements the --make(/GHCi command-line syntax for filenames:if the string looks like a Haskell source filename, then interpret it as suchif adding a .hs or .lhs suffix yields the name of an existing file, then use that/otherwise interpret the string as a module nameCghc-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).Cghc-lib Return the (! of a module with the given name.1The module must be part of the module graph (see ` and 9). If this is not the case, this function will throw a C.This function ignores boot modules and requires that there is only one non-boot module with the given name.Cghc-libParse a module. Throws a c on parse error.Cghc-lib%Typecheck and rename a parsed module. Throws a c if either fails.Cghc-libDesugar a typechecked module.Cghc-lib3Load a module. Input doesn't need to be desugared.A module must be loaded before dependent modules can be typechecked. This always includes generating a   and, depending on the DynFlags's #, may also include code generation.This function will always cause recompilation and will always overwrite previous compilation results (potentially files on disk).Cghc-libThis 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.Cghc-libLike compileToCoreModule, but invokes the simplifier, so as to return simplified and tidied Core.Cghc-lib Get the module dependency graph.Cghc-libReturn True <==> module is loaded.Cghc-lib8Return the bindings for the current interactive session.Cghc-lib9Return the instances for the current interactive session.Cghc-lib#Request information about a loaded Cghc-lib2The list of top-level entities defined in a moduleCghc-libReturns the instances defined by the specified module. Warning: currently unimplemented for package modules.Dghc-lib!Retrieve module safe haskell modeDghc-libLooks up a global name: that is, any top-level name in any visible module. Unlike D, lookupGlobalName does not use the interactive context, and therefore does not require a preceding B.Dghc-lib"get the GlobalRdrEnv for a sessionDghc-libRetrieve all type and family instances in the environment, indexed by . Each name's lists will contain every instance in which that name is mentioned in the instance head.Dghc-libprint a 0, adding parentheses if the name is an operator.Dghc-lib9Return module source as token stream, including comments.The module must be in the module graph and its source must be available. Throws a  on parse error.Dghc-lib.Give even more information on the source than D This function allows reconstructing the source completely with D.Dghc-libGiven a source location and a StringBuffer corresponding to this location, return a rich token stream with the source associated to the tokens.Dghc-lib/Take a rich token stream such as produced from D and return source code almost identical to the original code (except for insignificant whitespace.)Dghc-libTakes a  and possibly a G, and consults the filesystem and package database to find the corresponding +, using the algorithm that is used for an import declaration.Dghc-libLike D, but differs slightly when the module refers to a source file, and the file has not been loaded via C. In this case, D/ will throw an error (module not loaded), but D will check to see whether the module can also be found in a package, and if so, that package  will be returned. If not, the usual module-not-found error will be thrown.Dghc-libCheck 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.Dghc-libReturn if a module is trusted and the pkgs it depends on to be trusted.Dghc-lib.Set the monad GHCi lifts user statements into.;Checks that a type (in string form) is an instance of the GHC.GHCi.GHCiSandboxIO type class. Sets it to be the GHCi monad if it is, throws an error otherwise.Dghc-lib.Get the monad GHCi lifts user statements into.Dghc-lib Returns the  for a . The 2 may refer to any entity known to GHC, including s defined using runStmt.Dghc-lib&A pure interface to the module parser.Dghc-lib,Find the package environment (if one exists)We interpret the package environment as a set of package flags; to be specific, if we find a package environment file like clear-package-db global-package-db package-db blah/package.conf.d package-id id1 package-id id2we interpret this as [ -hide-all-packages , -clear-package-db , -global-package-db , -package-db blah/package.conf.d , -package-id id1 , -package-id id2 ]There's also an older syntax alias for package-id, which is just an unadorned package id id1 id2Cghc-libSee argument to C.ghc-libThe action to perform.Cghc-libSee argument to C.ghc-libThe action to perform.Dghc-libvisible modules. An orphan instance will be returned if it is visible from at least one module in the list.ghc-libmodules to load. If this is not specified, we load modules for everything that is in scope unqualified.Dghc-lib6Haskell module source text (full Unicode is supported)ghc-lib the flagsghc-lib#the filename (for source locations)!"#/HM JJJ   ddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddcceeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeceeeeeeeeeeeeeeeceeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeedeeeeeeeeeeeeeeceeeeeeefffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffcfffffffDfffffffffffffffffffffffffffffffffffffcfggggggggggggggggggggggcggggggggggggggggggggggggggggggggggggggggggggggggggggggggggcgggggggggggggggggggggggggggggggggggggggggggggggghhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhchhhhhhchhhhhhchhhhhhhhhhchhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiijjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm mmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmNNNNNNNNNNNNNNmmmmmmmmmmmmmmmmmmnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnoooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooocoooooooooooooooooooooooooooooooooooooooooooopppppppppppppppppppppppppppppppppppppppppppcpppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppqqqqqqqqqqqqq qqqqqqqqqqqqqqqqqqqqq qqqq qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr(((((rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrsssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssss!!!!""""????????????(((((((((((((((((((((()))((+7====????????????????????????BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDDDDDDCC C(BBBBCCCB+( CCBCCCCCDBBBBB(((((((((CCCCCCCCCCCC"""BBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC((((((((((((((((()))(CCCCCCCCCCCCDDDDDDD  BB??????B???????BBBBBBBDDCCCDDDDBBDBBCCDB===BBDBBBBBBBBBBB=!!!!????"???????????????DBBBBDDCD????BBB!"#/HDM D      D  7BB    CCDDDDDCNoneY Dghc-libThe :print & friends commandsDDDDDDNoneY=DDNone  >YDghc-lib'Entry point to compile a Backpack file.DD Safe-InferredZDghc-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.DDNone[:Dghc-libUsed by GHCi to add an SPT entry for a set of interactive bindings.DDNone #$028]Dghc-lib1The exception thrown by "fail" in the GHCiQ monadDghc-libThe implementation of the  message: create a new IORef QState, and return a RemoteRef to it.Dghc-libRuns the mod finalizers.5The references must be created on the caller process.Dghc-libThe implementation of the  messageDghc-libThe TH state, created by Dghc-libThe splice to runghc-libWhat kind of splice it isghc-libThe source locationghc-lib>>>??@@@@@@@@@@@@@@@@@@@@@@AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEFFFFFFFFFGHHHHHHHHHHHHHIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIJJKKKLMMMNNNNNOOOOOOOOOPPPPPPPPPQQQQRSSVZ[[[[[[[[[[[[[[[[[[[[[[[[\\]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]] ]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]] ] ]]]]] ___________________________________________________________________________________`aaaaaaaaaaaaaaabcccccdddeeeeeeeeeeeeeeee^^^^^^^ggghhhhhhhhhhhhhhhhhhhiiiijjjjjjjjjjjjjjjjjjjjjjjjjjjjjjkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkllllllllllmmmmmmmnnnnnnnnnnnnnnooopppppppppprrrrrrrrrrrrrssssssssssssssssssssssssssssssssssssssssssssssssssssssssssttttttttttttttttuvvvvvvvvvvvvvvvvvvvvvvvvwwxyyyyyyyyyyyyyyyyyyyyyyzzz{{|}                                                                                                                                                   !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""########################################################################################################################################$$$$$$$$$$$$$$$$$$$$$$$$$$$$ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $   $  $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $$$#%%%%%%%%%%%%%%$$$$$$$$$$%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&'''''''' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''$''''''(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((()))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))$)))))))))))))))))))))))))))))))))))))))))))))))))********************************************************************** * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +++++++++++++++++++++++++++++)+)))+)+)+)+)+)+)+)+)+f+f+f+f+f+f+f+f+f+f+f+f+f+f+f+f+f+++++++++++++++++,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,--------------------------------------------------------------------------------------------------------------------------------............................................'.................................................................................. . . / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / ( ( ( ( / ) ( ( ( / / / / / ' ' ' , , . . ) / / * * + + + + + + + + + / / / - / * / / . - / 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 000000000000000000000000000~0~0~+~*~,~,~,~,~,~,~'~'~/~/~0~$~*~0~+~+~*~0~0~*~*~0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T0T1T1T1T1T1T1T1T1T1T1T1T1T1T1T1T1T1T1T1T1T1T1T1T1T1T1T1T1T1T1T1111111111111111111111111111111111111111111111111111111111111111111W1W1W1W1W1W1W1W1W1W1W1W1W1W1W1W1W1W1W1W1W111111111111111111111112222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222223333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333334444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444445555555555555555555555 55555555555555555555555555555555555555555555555555555555555555555555555555555,5555555555555555555555555555556666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666677777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777788888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888899999999999999999999999999999$999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::#:#:#:#::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<==============================================================================7=========================================================>>>>>>>>>>>>>>=>>>>>>>>=>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>??&????????????????????????????#?#?#?#?#?#?#?#?#?#?#?#?#?#?#?#?#?#?#?#?#?#?###?#?#?#?#?#?#?#?#?#?#?#?#?#?#?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?U?U?U&U?U?U?U?U?U?U?U?U?U?U?U?U?U?U?U?U?U?????????????????????????????????????@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@AAAAAAAAAAAAAAAYAYAYAYAYAYAYAYAXAXAXAXAXAXAXAXAXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA)A)A)A)A)A)A)A)A)A)AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA)A)B)B)B)B)B)B)B)B)B)B)B)BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCACCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC(BBB%CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCqCqCqCqCqCqCqCCCCCCCCCCCCCCCC,C,CCCCCDDCDDDDDDDDDDD D DDDDDDD#DDDD DD#DDDDDDDDDDDDDDDDD:DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD%DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDEEEEEEEEEEEEEEEEE##EEEEEEEEEEEDEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEDEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF F FFFFF)FFF F F F FFF FFFFFFFFFF FCFFFFFFFFDFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGFGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGHHHHHHHHHHFHFHFHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHFHFHFHFHFHFHFHFHFHFHFHFHFHFHFHFHFHFHFHFHFHFHFHFHFHFHFHFHFHFHFHFHFHFHFHFHFHFHFHFHFHFHFHFHGHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII)IIIIIIIIIIIIIIIIIIIIIII7IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIJJJJJJJJJJJJJJJJJJJJ J J J J J J J J J J J J JJJ J JJJJJJJJJJ JJJJJJJ 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 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 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 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 KHKKK KJK KGKGKGKGKGKGKGKGKGKGKGKGKGLGLGLGLGLGLGLGLGLGLGLGLGLGLGLGLGLGLGLGLGLGLGLGLGLGLGLGLGLGLGLGLGLGLGLGLGLGLGLGLGLGLGLGLGLGLGLGLGLGLGLGLGLGLGLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNNNNNNNNNNNNNNNNNNN N N N N N N N N N N N N N NCNCNCNCNCNCNCNCNCNCNCNCNCNCNCNCNCNCNCNCNCNCNC9CNCNC9CNCNCNCNC C C NNNNNNNNNNNNNNNNNNCNCNCNCNCNCNCNCNCNCNCNCNCNCNCNCNCNCNCNCNCNCNCNCNCNCNCNCNCNCNCNCNGNGNGNGNGNGNGNGNGNGNGNGNGNGNGNGNGNGNGNGNGNGNGNGNGNGNGNGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGOGO 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 P P P P P P P P P P P P P P P P P P P PNPNPNPNPNPNPNPNPNPNPNPNNPNP PCPCPPPPPPPPPPPPPPPPPPPPPPPPPPPCPCPCPCPCPCPCPCPCPCPCP P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P PNPNQNQQQQQQQNQNQNQNQNQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSFSFSFSFSFSFSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSCSCSCSCSCSCSCSCSCSCSCSCSCSCSCSCSCSCSCSCSCSCSCSCSCSCSCSCSCSCSCSCSCSCSCSCSCSCSCSCSCSCSCSCSCSCSCSCSCSCSCSCSCSCSCSCSCSCSCSCTCTCTCTCTCTCTCTCTCTCTCTCTCTCTCTCTCTCTCTCTCTCTCTCTCTCTCTCTCTCTCTCTCTCTCTCTCTCTCTCTCTCTCTCTCTCTCTCCTCTCTCCTCTCCCTCTCTCCTCTCTCTCTCTCTCTCTCTCTCTCTCTCTCTCTCTCTCTCTCTCTCTCTCTCTCTCTCTCTCTCTCTPTPTPTPTPTPTPTPTPTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTUTUTUTUTUTUTUTUTUTUTUTUTUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUVUVUVUVUVUVUVUVUVUVUVUVUVUVUVUVUVUVUVUVUVUVUVUVSVSVSVSVNVNVNVNVNVNVNVNVNVNVNVNVNVNVNVNVNVNVNVNVNVNVNVNVNVNVNVNVNVNVNVNVNVNVNVNVNVNVNVNVNVNVNVNVNVNVNVNVNVNVNVJVHVHVV V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWXWXWXWXWXWXWXWXWXWXWXWXWXWXWXWXWXWXWXWXWXWXWXWXWXWXWXWXWXWXWXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYY Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z ZWZWZWZWZWZWZWZWZWZWZWZWZWZWZWZWZWZWZWZWZWZZZZZTZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ[Z[Z[Z[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[[[[[[Z[Z[Z[Z[T[T[T[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[ [P[P[P[P[P[P[P[P[P[P[P[P[P[P[P[P[P[P[P[P[P[P[P[P[P[P[P[P[P[P[P[P[P[P[P[P[P[P[P[P\P\P\P\P\P\P\P\P\P\P\P\P\P\P\P\P\P\P\P\P\P\P\P\P\P\P\P\P\P\P\P\P\P\P\P\P\P\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ ] ] ] ] ] ] ] ] ] ] ] ] ]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]B]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]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]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^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^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^_^_^______________A_(_(_________________________________________________________N______________________________________________________________________________________`````````_`_`_`_`_`_`_`_`_`_`_```````````````````````````````````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`HHH`H`H`H`H`H`H`H`H`H`H`H`H`H`````````````````````````````````T`T`T`T` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ``````````a`a`a`a`a`a`a`a`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`a`a`a`a`a`a`a`aTaTaTaTaTaTaTaTaTaTaTaTaTaTaTaTaTaTaTaTaTaTaTaTaTaTaTaTaTaTaTaTaTaTaTaTaTaTaTaTaTaTaTaTaTaTaTaTaTaTaTaTaTaTaTaTaTaTaTaTaTaTaTaTaTaTaTaTa)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`Fbb)b)b)b)b)b)b)b)b)b)b)bbbbbbbbbbbbbbbbbbbbbbbbb+b+b+b+b++bbbbbbbbbb bbHbITbTb bDbbDbbCbbbbbbbbbbbbDbbbDDbbbbbbbbbbbbbbbbbbbbbbbbbb bbbbb b bDDbDbbbbbbbbb b bbbbbbbbbbbbbbbbbbbbbbbbbbcbcbcbcbcbcbcbcbcbcbcbcbcCccc)c)c)cccccccccccccccccccccccccbcbcbcbcDcDcDcDcDcDcDcbcbcbcbcbcbcbcbcbcbcbcbcbcbcbcbcbcbcDcDcDcDcDcDcDcDcDcDccccccccccDcDcDcDcDcDcDcDcDcDcDcDcDcDcDcDcbcbcbcbcbcbcbccccccccDcDcDcDcDcDcDcDcDcDcDcDcDcDcDcDcDcDcDcDcDcDcDcDcDcDcDcDdDdDdDdDdDdDdDdDdDdDdDdDdDdDdDdDdDdDdDdDdDdbdbdbdbdbdbdbdcdcdcdDdDdDdDdDdDdDdDdDdDdDdDdDdbbbddbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbbbdbdbdbdbdbdbdbdbdbdbdbdcdcdcdcdcdcdcdcdcdcdcdcecececececececececececececebdbebebebebebebebebebebeDeDeDeDeDeDeDeDeDeDeDeDeDeDeDeDeDeDeDeDeDeDeDeDeDeDeDeDeDeDeDeDeDeDeDebebebebebebebebebebebebeDDDeDeDeDeDeDeDeDeDeDeDeDeDecececebdbebebebebebebebebebebebebebecececececebebebebebebebebebebebeb6bebebebebebebebebebebdbebebebebebfbfbfbfcfcfcfcfbdbfbfbfbfbfbfbfbfbfbfbfbfbfbfbfbfbfbfbfbfbfbfbfbfbfbfbfbfbfbfbfbfbfbfbfbfbfbfbfbfbfbfbfbfbfbfbfbfbfbfbfbfbfbfbfbfbfbfbfbfbfbfbfbfbfbfbfbfbfbfbfbfbfbfbfbfcfcfcfbfbfbfbfbfffffffffffffffffffffcfcfcfffffffffffffffffffffffffffDfDfDfDfDfDfDfDfDfDfDfDfDfDfbgbgbgbgggbbbgbgbgbgbgbgbgbgbgbgggggbgbgbgbgbgbgbgbgbgbgbgbgbgbgbgbgbgbgbgbgbgbgbgcdcgcgcgcgcgcgcgcgcgcgcgcgcgcgcgcgcgcgcgcgcgcgcgcgcgcgcgDgDgDgDgDgDgDgDgDgDgDgDgDgDgDgDgDgDgDgDgDgDgDgcgcgcgcgcgcgcgcgcgcgcgcgcgDgDgDgDgDgDgbgbgbgbgbgbgbgbgbgbgbgbgbgbgbgbgbgbgbgbgbgbgbgbgbgbgcgcgcgchchchchchchDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhchchchchchchchchchchhhhhchchchhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhDhhhhhhhhhhhDhDhDbDhDhDhDhDhDhDhDhDhDhDdDhDdDhDhDhDiDiDiDiDiDiDiDiDiDiDiDiDiDiDiDiDiDiDiDiDiDiDiDiDiDiDiDiDiDiDiDiDiDiDiDiDicicicicicicicccccciiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiigigiiiiiiiiiiiiiibiiiiiiiiiiiiiiiiiiiiiiiiiiiiiijijijijijijijijijijijijijijijijijijjjbjijjjbjbjbjcjcjcjbjcjjjjjjjjjjjjjjjjjjjjbjbjbjbjjjjjjbjbjbfbjbjbjbjbjijijijijijijbjjjjjjjjijijijijjjjjjijijijijijijijijjjjbjcjcjcjgjgjgjgjgjgjgjgjgjgjgjgjgjgjgjgjgjgjgjgjgjgjcjcjcjcjcjckckckckckckckckgkgkgkgkckckceckckckckckckckckckckckckikikikikikikikidikieikikikikikikikigikikikikikikikikikikikikikikikikkkkkkkkkbkbkbkkkkkkkkkbkbkbkbkikikikikikikikikikikikikikieikik 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 l l l l l l l l l l l l l l l l l lblblblblblblblblblblbl l lblblblblblblblblblblblblblblblblblblbfblblblblblblblblclilililililicilililililllllllililililililililililililililililililililililililililililililililililililililillllllclclclclclclcmcmcmcmcmcmcmcmcmcmcmcmcmcmcmcmcmcmcmccmcmcmcmcmcmcmcmcmcmcmcmcmcmcmcmcmcmcmcmcmcmcmcmcmcmcmcmcmcmcmcmcmcmcmcmbmbmbmbmbmbmbmbmbmbmbmbmbmbmbmbmcmcmcmcmcmcmcmcmcmcmcmcmcmcmcmcmcmcmcmcmcmcmcmcmcmcmcmcmcmcmcmcmcmcmcmcmcmcmcmcmcmbmbmbmbmbmbmbmbmbmbmbmbmbmbmbmbmbmbmbmbmbmbmbmbmbmbmbnbnbnbnbnbnbnbnbnbnbnbnbnbnbnbnbnbnbnbnbnbnbninnnnninininnininininininininieinininininininininininininininieinininininininininininininininininininininininininininigininininininininininininininininininininininininininininininininininininininininininfnfnfnfnfnfnfofofofofofofofofofofofofofofofofofof fofofofofofofofofoioioioioioioioioioioiooococococoioioooooooooooooooooooooooooooooooooooooooooooioioioioooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooopppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppDppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq)ghc-lib-0.20210331-FIfjYSo82OcEZswxdLP9BKGHC.HsToCore.MonadGHC.Core.Opt.SpecConstrGHC.Rename.Unbound GHC.PluginsGHCGHC.Driver.MakeGHC.Tc.Utils.EnvGHC.Rename.NamesGHC.StgToCmm.MonadGHC.Builtin.Names.THGHC.Tc.Utils.TcMTypeGHC.Tc.Gen.ExprGHC.Tc.Solver.MonadGHC.StgToCmm.ClosureGHC.Builtin.Types.LiteralsGHC.Tc.Utils.InstantiateGHC.Tc.Utils.ZonkGHC.Tc.Instance.FunDepsGHC.Builtin.UtilsGHC.Core.Opt.Simplify.MonadGHC.Tc.Instance.FamilyGHC.CmmToAsm.TypesGHC.Cmm.DataflowGHC.CmmToAsm.Reg.LivenessGHC.Core.Map.ExprGHC.StgToCmm.ExtCodeGHC.Cmm.LRegSetGHC.Cmm.Ppr.ExprGHC.Cmm.Ppr.DeclGHC.Cmm.LivenessGHC.StgToCmm.Utils GHC.Cmm.UtilsGHC.Cmm.Switch.Implement GHC.Cmm.Ppr GHC.SysToolsGHC.Cmm.CallConv GHC.Cmm.Graph GHC.Cmm.Opt GHC.Cmm.Sink GHC.Cmm.LintGHC.Cmm.DebugBlockGHC.Cmm.ContFlowOptGHC.Cmm.CommonBlockElimGHC.CmmToAsm.CFG.DominatorsGHC.CmmToAsm.CFGGHC.CmmToAsm.CPrimGHC.CmmToAsm.FormatGHC.CmmToAsm.InstrGHC.CmmToAsm.PPC.CondGHC.CmmToAsm.PPC.RegsGHC.CmmToAsm.Reg.Graph.BaseGHC.CmmToAsm.Reg.Graph.X86GHC.CmmToAsm.Reg.Linear.PPC GHC.CmmToAsm.Reg.Linear.StackMapGHC.CmmToAsm.Reg.UtilsGHC.CmmToAsm.SPARC.BaseGHC.CmmToAsm.SPARC.CondGHC.CmmToAsm.SPARC.ImmGHC.CmmToAsm.SPARC.AddrModeGHC.CmmToAsm.SPARC.RegsGHC.CmmToAsm.Reg.Linear.SPARCGHC.CmmToAsm.SPARC.StackGHC.CmmToAsm.UtilsGHC.CmmToAsm.X86.CondGHC.CmmToAsm.X86.RegsGHC.CmmToAsm.X86.RegInfoGHC.CmmToAsm.Reg.TargetGHC.CmmToAsm.X86.InstrGHC.CmmToAsm.SPARC.InstrGHC.CmmToAsm.SPARC.ShortcutJump!GHC.CmmToAsm.SPARC.CodeGen.ExpandGHC.CmmToAsm.SPARC.CodeGen.BaseGHC.CmmToAsm.Monad GHC.CmmToAsm.SPARC.CodeGen.Gen32#GHC.CmmToAsm.SPARC.CodeGen.CondCode GHC.CmmToAsm.SPARC.CodeGen.Amode GHC.CmmToAsm.SPARC.CodeGen.Gen64GHC.CmmToAsm.BlockLayoutGHC.CmmToAsm.Reg.Linear.X86_64GHC.CmmToAsm.Reg.Linear.X86 GHC.CmmToCGHC.CmmToLlvm.ManglerGHC.Core.Opt.CSEGHC.HsToCore.Pmc.Solver.TypesGHC.Runtime.InterpreterGHC.Core.Opt.FloatInGHC.HsToCore.TypesGHC.StgToByteCodeGHC.ByteCode.AsmGHC.Core.Opt.LiberateCaseGHC.Core.Opt.SetLevelsGHC.Core.Opt.FloatOutGHC.Core.Opt.Simplify.EnvGHC.Core.Opt.SpecialiseGHC.Core.Opt.Simplify.UtilsGHC.Core.Opt.StaticArgsGHC.Core.Opt.WorkWrap.UtilsGHC.Core.Opt.WorkWrapGHC.Core.Opt.DmdAnal GHC.Core.TidyGHC.Core.RulesGHC.Unit.FinderGHC.Core.Opt.SimplifyGHC.Core.TyCon.SetGHC.Data.Bitmap GHC.Cmm.InfoGHC.CmmToAsm.PPC.Instr GHC.CmmToAsm.Reg.Linear.FreeRegsGHC.CmmToAsm.PPC.RegInfoGHC.CmmToAsm.PICGHC.CmmToAsm.PPC.CodeGenGHC.Cmm.ProcPointLanguage.Haskell.TH.QuoteGHC.Cmm.Parser.Monad GHC.Cmm.LexerGHC.Data.Graph.Base$GHC.CmmToAsm.Reg.Graph.TrivColorableGHC.Data.Graph.OpsGHC.Data.Graph.PprGHC.Data.Graph.ColorGHC.Data.Graph.UnVarGHC.Core.Opt.CprAnalGHC.Core.Opt.CallArityGHC.HandleEncoding GHC.Hs.Stats GHC.Tc.PluginGHC.Tc.Gen.SigGHC.Types.Name.ShapeGHC.Tc.Errors.HoleGHC.Tc.ValidityGHC.HsToCore.DocsGHC.Iface.BinaryGHC.Iface.Ext.TypesGHC.Iface.Ext.UtilsGHC.Iface.Ext.DebugGHC.Iface.Recomp.FlagsGHC.Iface.UpdateIdInfosGHC.IfaceToCoreGHC.Linker.UnitGHC.Parser.UtilsGHC.Platform.HostGHC.Rename.ExprGHC.Settings.UtilsGHC.Settings.IOGHC.Stg.Lift.Analysis GHC.Stg.CSE GHC.Stg.Debug GHC.CoreToStgGHC.Stg.DepAnal GHC.Stg.FVsGHC.Runtime.Eval GHC.Stg.Lint GHC.Stg.Stats GHC.Stg.SubstGHC.Stg.Lift.MonadGHC.Stg.UnariseGHC.StgToCmm.CgUtilsGHC.StgToCmm.ArgRepGHC.StgToCmm.EnvGHC.StgToCmm.LitGHC.StgToCmm.BindGHC.StgToCmm.TickyGHC.StgToCmm.Layout GHC.Stg.LiftGHC.Stg.PipelineGHC.ByteCode.InstrGHC.StgToCmm.HpcGHC.SysTools.ArGHC.SysTools.ProcessGHC.SysTools.InfoGHC.Tc.Gen.MatchGHC.Tc.Gen.Splice GHC.Tc.ModuleGHC.Tc.Types.EvTermGHC.Tc.Utils.Monad GHC.Iface.EnvGHC.Linker.LoaderGHC.Driver.PipelineGHC.Driver.MainGHC.Tc.Gen.AnnotationGHC.Rename.SpliceGHC.Iface.LoadGHC.Tc.TyCl.BuildGHC.Iface.Ext.BinaryGHC.Tc.Utils.Unify GHC.ThToHsGHC.Iface.RenameGHC.Types.Unique.SDFMGHC.Tc.Instance.TypeableGHC.Rename.UtilsGHC.Iface.Tidy.StaticPtrTableGHC.Iface.TidyGHC.CoreToStg.Prep GHC.Tc.ErrorsGHC.Rename.FixityGHC.Rename.EnvGHC.Tc.Instance.ClassGHC.Tc.Solver.RewriteGHC.Tc.Solver.CanonicalGHC.HsToCore.Pmc.TypesGHC.Tc.Solver.Interact GHC.Tc.SolverGHC.Tc.Deriv.GenerateGHC.Tc.Gen.ExportGHC.Rename.HsTypeGHC.Rename.PatGHC.Rename.BindGHC.Rename.ModuleGHC.Tc.Gen.HsTypeGHC.Tc.TyCl.PatSynGHC.Tc.Gen.PatGHC.Tc.Gen.DefaultGHC.Tc.Gen.BindGHC.Tc.TyCl.UtilsGHC.Tc.Utils.BackpackGHC.Tc.TyCl.ClassGHC.Tc.Gen.HeadGHC.Tc.Gen.ArrowGHC.Tc.Gen.AppGHC.Tc.Gen.RuleGHC.Tc.Gen.ForeignGHC.HsToCore.Pmc.UtilsGHC.HsToCore.Pmc.SolverGHC.HsToCore.Pmc.PprGHC.HsToCore.Pmc.CheckGHC.HsToCore.MatchGHC.HsToCore.ExprGHC.HsToCore.UtilsGHC.HsToCore.Foreign.CallGHC.HsToCore.Foreign.DeclGHC.HsToCore.Match.LiteralGHC.HsToCore.GuardedRHSsGHC.HsToCore.BindsGHC.HsToCore.Pmc.DesugarGHC.HsToCore.PmcGHC.HsToCore.QuoteGHC.HsToCore.Match.ConstructorGHC.HsToCore.ListCompGHC.HsToCore.ArrowsGHC.Iface.RecompGHC.HsToCore.UsageGHC.Iface.MakeGHC.Types.TyThing.Ppr GHC.Utils.AsmGHC.SysTools.ElfGHC.CmmToAsm.PprGHC.Llvm.TypesGHC.Llvm.MetaDataGHC.Llvm.Syntax GHC.Llvm.PprGHC.CmmToLlvm.RegsGHC.CmmToLlvm.BaseGHC.SysTools.TasksGHC.Linker.ExtraObjGHC.Linker.WindowsGHC.CmmToLlvm.DataGHC.CmmToLlvm.PprGHC.CmmToLlvm.CodeGen GHC.CmmToLlvmGHC.CmmToAsm.X86.PprGHC.CmmToAsm.X86.CodeGenGHC.CmmToAsm.X86GHC.CmmToAsm.SPARC.Ppr!GHC.CmmToAsm.SPARC.CodeGen.SanityGHC.CmmToAsm.SPARC.CodeGenGHC.CmmToAsm.SPARCGHC.CmmToAsm.PPC.PprGHC.CmmToAsm.PPCGHC.CmmToAsm.Dwarf.ConstantsGHC.CmmToAsm.Dwarf.TypesGHC.CmmToAsm.DwarfGHC.Utils.Monad.StateGHC.Tc.Deriv.FunctorGHC.Tc.Deriv.GenericsGHC.Tc.Deriv.UtilsGHC.Tc.Deriv.Infer GHC.Tc.DerivGHC.Tc.TyCl.Instance GHC.Tc.TyClGHC.Core.Opt.ExitifyGHC.Core.Opt.PipelineGHC.CmmToAsm.Reg.Linear.BaseGHC.CmmToAsm.Reg.Graph.CoalesceGHC.CmmToAsm.Reg.Linear.StatsGHC.CmmToAsm.Reg.Linear.State%GHC.CmmToAsm.Reg.Linear.JoinToTargetsGHC.CmmToAsm.Reg.Linear GHC.CmmToAsm.Reg.Graph.SpillCost!GHC.CmmToAsm.Reg.Graph.SpillCleanGHC.CmmToAsm.Reg.Graph.SpillGHC.CmmToAsm.Reg.Graph.StatsGHC.CmmToAsm.Reg.Graph GHC.CmmToAsmGHC.Driver.CodeOutputGHC.StgToCmm.ProfGHC.StgToCmm.HeapGHC.StgToCmm.DataConGHC.StgToCmm.ForeignGHC.StgToCmm.PrimGHC.Cmm.LayoutStackGHC.StgToCmm.Expr GHC.StgToCmmGHC.Cmm.ParserGHC.Cmm.Info.BuildGHC.Cmm.PipelineGHCi.BinaryArrayGHCi.InfoTable GHCi.ObjLinkGHCi.ResolvedBCOGHCi.CreateBCOGHC.Runtime.Heap.InspectGHC.Linker.MacOSGHC.Linker.DynamicGHC.Linker.StaticGHC.HsToCore.Coverage GHC.HsToCoreGHC.Iface.Ext.AstGHC.ByteCode.InfoTableGHC.ByteCode.LinkerGHC.Runtime.LoaderGHC.Runtime.DebuggerGHC.Driver.MakeFileGHC.Driver.Backpack GHCi.SignalsGHCi.StaticPtrTableGHCi.THGHCi.RunLanguage.Haskell.TH.CodeDo Paths_ghc_libGHC.Core.UtilsdataConRepInstPat GHC.LinkerGHC.Core.SubstSubstGHC.STGDebugliftedIdsExpander newFamInstcheckConsistentFamInst GHC.Hs.Pat ConPatOutGHC.LlvmDynFlagsbackendGHC.Driver.Env SourceErrorbaseGHC.Base<*>pure*> ApplicativeGHC.ExtsForceSpecConstr NoSpecConstrSpecConstrAnnotation Control.Monad mapAndUnzipMData.TraversablemapM Data.FoldablefoldlMfoldrM Data.Functor<$><*liftA2/ghc-lib-parser-0.20210331-gua7IerhGD6MN419xMoceGHC.Builtin.Names isUnboundName mkUnboundNameGHC.Types.Unique Uniquable getUniqueUniqueGHC.Unit.TypesModuleGHC.Types.Name.ReaderRdrNameGHC.Types.NameNameGHC.Unit.Module.Name ModuleNameGHC.Types.SrcLocSrcSpanGHC.Types.Name.OccurrenceOccName NameSpacemkModule pprModule moduleName moduleUnitIsBootInterfaceIsBootNotBootUnit mkModuleNamemoduleNameStringGHC.Data.FastString.Env emptyFsEnv extendFsEnv lookupFsEnvmkFsEnvgetOccFS getOccString getSrcLoc getSrcSpanisBuiltInSyntax isDataConName isDynLinkNameisExternalName isHoleNameisInternalName isSystemName isTyConName isTyVarName isValName isVarName isWiredIn isWiredInName localiseNamemkClonedInternalNamemkDerivedInternalNamemkExternalName mkFCallNamemkInternalName mkSysTvName mkSystemNamemkSystemNameAtmkSystemVarName mkWiredInNamenameIsFromExternalPackagenameIsHomePackagenameIsHomePackageImportnameIsLocalOrFrom nameModulenameModule_maybe nameNameSpace nameOccName nameSrcLoc nameSrcSpannameStableString nameUnique pprDefinedAt pprInfixNamepprModulePrefixpprNameDefnLocpprNameUnqualified pprPrefixName setNameLoc setNameUnique stableNameCmp tidyNameOccwiredInNameTyThing_maybe alterOccEnvavoidClashesOccEnvclsNamedataName delFromOccEnvdelListFromOccEnvdelTidyOccEnvList demoteOccName elemOccEnv elemOccSet emptyOccEnv emptyOccSetemptyTidyOccEnv extendOccEnvextendOccEnvListextendOccEnv_AccextendOccEnv_C extendOccSetextendOccSetList filterOccEnv filterOccSet foldOccEnvinitTidyOccEnvintersectOccSetisDataConNameSpace isDataOcc isDataSymOccisDefaultMethodOccisDerivedOccName isEmptyOccSetisSymOccisTcClsNameSpaceisTcOcc isTvNameSpaceisTvOccisTypeableBindOccisValNameSpaceisValOccisVarNameSpaceisVarOcc lookupOccEnv mapOccEnv minusOccSet mkBuilderOccmkClassDataConOccmkClassOpAuxOccmkClsOcc mkClsOccFS mkCon2TagOcc mkDFunOcc mkDataCOccmkDataConWorkerOccmkDataConWrapperOcc mkDataOcc mkDataOccFS mkDataTOccmkDefaultMethodOcc mkDictOcc mkEqPredCoOccmkForeignExportOccmkGen1RmkGenRmkIPOcc mkInstTyCoOcc mkInstTyTcOcc mkLocalOcc mkMatcherOcc mkMaxTagOcc mkMethodOcc mkNewTyCoOccmkOccEnv mkOccEnv_C mkOccName mkOccNameFSmkOccSetmkRecFldSelOcc mkRepEqOcc mkSpecOccmkSuperDictAuxOccmkSuperDictSelOcc mkTag2ConOccmkTcOcc mkTcOccFS mkTyConRepOcc mkTyVarOcc mkTyVarOccFSmkVarOcc mkVarOccFS mkWorkerOccnameSpacesRelated occEnvElts occNameString parenSymOcc plusOccEnv plusOccEnv_C pprNameSpacepprNameSpaceBriefpprNonVarNameSpace pprOccEnv pprOccNamepromoteOccNamesetOccNameSpace srcDataNamestartsWithUnderscore tcClsNametcName tidyOccNametvNameunionManyOccSets unionOccSets unitOccEnv unitOccSet FastStringEnv BuiltInSyntax UserSyntax NamedThinggetName getOccName HasOccNameoccNameOccEnv occNameFS occNameSpaceOccSet TidyOccEnvLocatedGHC.Types.TyThingTyThingSrcLoc GenLocatedgresFromAvailsQualUnqualGHC.Types.BasicConTagZtemplateHaskellNamesthSynthLibqqLib mkTHModulelibFunlibTcthFunthTcthClsthConqqFun liftClassNamequoteClassName qTyConName nameTyConNamefieldExpTyConName patTyConNamefieldPatTyConName expTyConName decTyConName decsTyConName typeTyConNamematchTyConNameclauseTyConNamefunDepTyConName predTyConName codeTyConNameinjAnnTyConNameoverlapTyConNamemodNameTyConName returnQName bindQName sequenceQName newNameNameliftNameliftStringName mkNameName mkNameG_vName mkNameG_dNamemkNameG_tcName mkNameLName mkNameSName mkModNameName unTypeNameunTypeCodeNameunsafeCodeCoerceName liftTypedName 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 standaloneDerivWithStrategyDNamesigDName kiSigDNamedefaultSigDName forImpDName pragInlDName pragSpecDNamepragSpecInlDNamepragSpecInstDName pragRuleDNamepragCompleteDName pragAnnDName dataInstDNamenewtypeInstDNametySynInstDNameopenTypeFamilyDNameclosedTypeFamilyDNamedataFamilyDName infixLDName infixRDName infixNDNameroleAnnotDName patSynDNamepatSynSigDNameimplicitParamBindDNamecxtNamenoSourceUnpackednessNamesourceNoUnpackNamesourceUnpackNamenoSourceStrictnessNamesourceLazyNamesourceStrictName normalCNamerecCName infixCName forallCName gadtCName recGadtCNamebangName bangTypeNamevarBangTypeNameunidirPatSynNameimplBidirPatSynNameexplBidirPatSynNameprefixPatSynNameinfixPatSynNamerecordPatSynName forallTNameforallVisTNamevarTNameconTName tupleTNameunboxedTupleTNameunboxedSumTName arrowTName mulArrowTName listTNameappTName appKindTNamesigTName equalityTNamelitTName promotedTNamepromotedTupleTNamepromotedNilTNamepromotedConsTName wildCardTName infixTNameimplicitParamTName numTyLitName strTyLitName charTyLitName plainTVName kindedTVNameplainInvisTVNamekindedInvisTVNamespecifiedSpecNameinferredSpecName nominalRNamerepresentationalRName phantomRName inferRName starKNameconstraintKName noSigName kindSigName tyVarSigNameinjectivityAnnName cCallName stdCallName cApiCallName primCallNamejavaScriptCallName unsafeNamesafeNameinterruptibleName ruleVarNametypedRuleVarName funDepName tySynEqnNamevalueAnnotationNametypeAnnotationNamemoduleAnnotationNamederivClauseNamestockStrategyNameanyclassStrategyNamenewtypeStrategyNameviaStrategyName expQTyConNamedecsQTyConNametypeQTyConName patQTyConName stmtTyConName conTyConNamebangTypeTyConNamevarBangTypeTyConNameruleBndrTyConNametySynEqnTyConName roleTyConNamederivClauseTyConName kindTyConNametyVarBndrUnitTyConNametyVarBndrSpecTyConNamederivStrategyTyConName quoteExpName quotePatName quoteDecName quoteTypeNamenoInlineDataConNameinlineDataConNameinlinableDataConNameconLikeDataConNamefunLikeDataConNameallPhasesDataConNamefromPhaseDataConNamebeforePhaseDataConNameoverlappableDataConNameoverlappingDataConNameoverlapsDataConNameincoherentDataConName liftClassKey quoteClassKey expTyConKey matchTyConKeyclauseTyConKey qTyConKey expQTyConKey patTyConKey stmtTyConKey conTyConKey typeQTyConKey typeTyConKey decTyConKeybangTypeTyConKeyvarBangTypeTyConKeyfieldExpTyConKeyfieldPatTyConKey nameTyConKey patQTyConKeyfunDepTyConKey predTyConKey predQTyConKeytyVarBndrUnitTyConKey decsQTyConKeyruleBndrTyConKeytySynEqnTyConKey roleTyConKeyinjAnnTyConKey kindTyConKeyoverlapTyConKeyderivClauseTyConKeyderivStrategyTyConKey decsTyConKeytyVarBndrSpecTyConKey codeTyConKeymodNameTyConKeynoInlineDataConKeyinlineDataConKeyinlinableDataConKeyconLikeDataConKeyfunLikeDataConKeyallPhasesDataConKeyfromPhaseDataConKeybeforePhaseDataConKeyoverlappableDataConKeyoverlappingDataConKeyoverlapsDataConKeyincoherentDataConKey returnQIdKey bindQIdKeysequenceQIdKey liftIdKey newNameIdKey mkNameIdKeymkNameG_vIdKeymkNameG_dIdKeymkNameG_tcIdKey mkNameLIdKey mkNameSIdKey unTypeIdKeyunTypeCodeIdKeyliftTypedIdKeymkModNameIdKeyunsafeCodeCoerceIdKey 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 patSynDIdKeypatSynSigDIdKeypragCompleteDIdKeyimplicitParamBindDIdKey kiSigDIdKeycxtIdKeynoSourceUnpackednessKeysourceNoUnpackKeysourceUnpackKeynoSourceStrictnessKey sourceLazyKeysourceStrictKey normalCIdKey recCIdKey infixCIdKey forallCIdKey gadtCIdKey recGadtCIdKey bangIdKeybangTKey varBangTKeyunidirPatSynIdKeyimplBidirPatSynIdKeyexplBidirPatSynIdKeyprefixPatSynIdKeyinfixPatSynIdKeyrecordPatSynIdKey forallTIdKeyforallVisTIdKey varTIdKey conTIdKey tupleTIdKeyunboxedTupleTIdKeyunboxedSumTIdKey arrowTIdKey listTIdKey appTIdKey appKindTIdKey sigTIdKeyequalityTIdKey litTIdKeypromotedTIdKeypromotedTupleTIdKeypromotedNilTIdKeypromotedConsTIdKeywildCardTIdKeyimplicitParamTIdKey infixTIdKey numTyLitIdKey strTyLitIdKeycharTyLitIdKey plainTVIdKey kindedTVIdKeyplainInvisTVIdKeykindedInvisTVIdKey nominalRIdKeyrepresentationalRIdKey phantomRIdKey inferRIdKey starKIdKeyconstraintKIdKey noSigIdKey kindSigIdKey tyVarSigIdKeyinjectivityAnnIdKey cCallIdKey stdCallIdKey cApiCallIdKey primCallIdKeyjavaScriptCallIdKey unsafeIdKey safeIdKeyinterruptibleIdKey funDepIdKeymulArrowTIdKey tySynEqnIdKey quoteExpKey quotePatKey quoteDecKey quoteTypeKey ruleVarIdKeytypedRuleVarIdKeyvalueAnnotationIdKeytypeAnnotationIdKeymoduleAnnotationIdKeyderivClauseIdKeystockStrategyIdKeyanyclassStrategyIdKeynewtypeStrategyIdKeyviaStrategyIdKeyspecifiedSpecKeyinferredSpecKeylift_RDR liftTyped_RDRunsafeCodeCoerce_RDR mkNameG_dRDR mkNameG_vRDRconE_RDRlitE_RDRappE_RDR infixApp_RDR stringL_RDR intPrimL_RDR wordPrimL_RDRfloatPrimL_RDRdoublePrimL_RDRstringPrimL_RDR charPrimL_RDRfailedpickLR succeeded LeftOrRightCLeftCRight SuccessFlagFailed SucceededGHC.Builtin.TypesliftedTypeKindunliftedTypeKindunrestrictedFunTyConGHC.Builtin.Types.PrimfunTyConGHC.Core.TyCo.FVsanyFreeVarsOfTypeanyFreeVarsOfTypescloseOverKindscloseOverKindsDSetcloseOverKindsList coVarsOfType coVarsOfTypesnoFreeVarsOfType scopedSort tyCoFVsBndr tyCoFVsOfTypetyCoFVsVarBndrtyCoFVsVarBndrstyCoVarsOfTypetyCoVarsOfTypeDSettyCoVarsOfTypeWellScopedtyCoVarsOfTypestyCoVarsOfTypesWellScopedGHC.Core.TyCo.RepfoldTyCoisInvisibleBinder isNamedBinderisVisibleBinder mkForAllTy mkForAllTysmkFunTymkInvisForAllTys mkInvisFunTymkInvisFunTyManymkInvisFunTysManymkPiTymkPiTys mkTyVarTy mkTyVarTys mkVisFunTymkVisFunTyMany mkVisFunTysmkVisFunTysManytypeSizeGHC.Core.TyCo.SubstcloneTyVarBndrcloneTyVarBndrscomposeTCvSubstcomposeTCvSubstEnv emptyTCvSubstemptyTvSubstEnv extendCvSubstextendTCvInScopeextendTCvInScopeListextendTCvInScopeSetextendTCvSubstextendTCvSubstListextendTCvSubstWithCloneextendTvSubstAndInScopeextendTvSubstBinderAndInScopeextendTvSubstWithClone getTCvInScopegetTCvSubstRangeFVs getTvSubstEnvisEmptyTCvSubst lookupTyVarmkEmptyTCvSubst mkTCvSubst mkTvSubstPrsnotElemTCvSubst setTvSubstEnvsubstCoUncheckedsubstCoWithUnchecked substScaledTysubstScaledTyUncheckedsubstScaledTyssubstScaledTysUnchecked substThetasubstThetaUncheckedsubstTyAddInScope substTyCoBndrsubstTyUnchecked substTyVarsubstTyVarBndrsubstTyVarBndrs substTyVars substTyWithsubstTyWithUncheckedsubstTyssubstTysUnchecked substTysWith substVarBndr substVarBndrs unionTCvSubst zapTCvSubstzipCoEnv zipTCvSubst zipTvSubstzipTyEnvGHC.Core.TyCo.TidytidyFreeTyCoVarstidyKind tidyOpenKindtidyOpenTyCoVartidyOpenTyCoVars tidyOpenType tidyOpenTypes tidyTopTypetidyTyCoVarBindertidyTyCoVarBinderstidyTyCoVarOcctidyType tidyTypes tidyVarBndr tidyVarBndrsGHC.Core.TyConisConstraintKindCon GHC.Core.TypeManyOne appTyArgFlags applyTysXbinderRelevantType_maybe buildSynTyConclassifiesTypeWithValues coAxNthLHScoreView dropForAllsdropRuntimeRepArgseqTypeeqTypeXeqTypes eqVarBndrsexpandTypeSynonymsfilterOutInferredTypesfilterOutInvisibleTypesfunArgTy funResultTygetCastedTyVar_maybe getRuntimeRepgetRuntimeRep_maybegetTyVargetTyVar_maybeinvisibleTyBndrCountirrelevantMult isAlgTypeisAnonTyCoBinder isAtomicTyisBoxedRuntimeRep isBoxedTypeisBoxedTypeKind isCharLitTy isCoVarType isCoercionTyisCoercionTy_maybeisDataFamilyAppType isFamFreeTy isForAllTy isForAllTy_co isForAllTy_tyisFunTy isKindLevPoly isLevityTy isLevityVarisLiftedLevityisLiftedRuntimeRepisLiftedTypeKindisLiftedType_maybe isLinearTypeisLitTyisManyDataConTyisMultiplicityTyisMultiplicityVar isNumLitTyisOneDataConTyisPiTyisPredTyisPrimitiveTypeisRuntimeRepKindedTyisRuntimeRepTyisRuntimeRepVar isStrLitTy isStrictTypeisTauTy isTyVarTy isTypeLevPolyisUnboxedSumTypeisUnboxedTupleTypeisUnliftedLevityisUnliftedRuntimeRepisUnliftedTypeisUnliftedTypeKindisValidJoinPointTypekindRep kindRep_maybelinearmapTyComapTyCoXmightBeUnliftedType mkAnonBindermkAppTymkAppTysmkCastTy mkCharLitTy mkCoercionTymkFamilyTyConApp mkInfForAllTymkInfForAllTys mkNumLitTymkScaledmkSpecForAllTymkSpecForAllTys mkStrLitTymkTyCoInvForAllTymkTyCoInvForAllTys mkTyConAppmkTyConBindersPreferAnon mkTyConTymkVisForAllTysnewTyConInstRhs nonDetCmpTc nonDetCmpTypenonDetCmpTypeXnonDetCmpTypesnonDetCmpTypesXoccCheckExpandpartitionInvisibleTypespartitionInvisibles piResultTy piResultTyspickyIsLiftedTypeKindpprUserTypeErrorTyrepGetTyVar_mayberepSplitAppTy_mayberepSplitAppTysrepSplitTyConApp_mayberesultIsLevPoly scaledSetseqTypeseqTypes splitAppTysplitAppTy_maybe splitAppTyssplitCastTy_maybesplitForAllCoVar_maybesplitForAllInvisTVBinderssplitForAllReqTVBinderssplitForAllTyCoVarsplitForAllTyCoVarBinderssplitForAllTyCoVar_maybesplitForAllTyCoVarssplitForAllTyVar_maybe splitFunTysplitFunTy_maybe splitFunTyssplitInvisPiTyssplitInvisPiTysNsplitListTyConApp_maybe splitPiTysplitPiTy_maybe splitPiTys splitTyConAppsplitTyConApp_maybesplitVisVarsOfTypesplitVisVarsOfTypesstripCoercionTytYPEtcIsBoxedTypeKindtcIsConstraintKindtcIsLiftedTypeKindtcIsRuntimeTypeKindtcRepSplitAppTy_maybetcReturnsConstraintKindtcSplitTyConApp_maybe tcTypeKindtcView tyBinderTypetyCoBinderTypetyCoBinderVar_maybe tyConAppArgN tyConAppArgstyConAppArgs_maybetyConAppNeedsKindSig tyConAppTyContyConAppTyConPicky_maybetyConAppTyCon_maybe tyConArgFlagstyConBindersTyCoBinders tyConsOfTypetymulttypeKind unrestricteduserTypeError_maybe GHC.Types.Var binderArgFlag binderType binderVar binderVarsisInvisibleArgFlagisTyVarisVisibleArgFlagmkTyCoVarBindermkTyCoVarBinders mkTyVarBindermkTyVarBinderssameVis tyVarKindtyVarSpecToBindersKind KindOrTypeKnotTiedMultPredTypeScaled ThetaType TyCoBinder TyCoFolder tcf_covartcf_holetcf_tycobinder tcf_tyvartcf_viewTypeTCvSubst TvSubstEnv TyCoMapper tcm_covartcm_holetcm_tycobinder tcm_tycon tcm_tyvar AnonArgFlagInvisArgVisArgArgFlagInferred InvisibleRequired Specified Specificity InferredSpec SpecifiedSpecTyCoVar TyCoVarBinderTyVar TyVarBinderVarvarTypeCoVarCoercion CoercionHoleTyConGHC.Core.Coercion.AxiomRole CoercionNGHC.Core.TyCo.Ppr pprParendTypepprThetaArrowTy pprTypeAppGHC.Tc.Utils.TcTypemkCheckExpType synKnownType ExpRhoType ExpSigmaTypeExpTypeCheckInfer SyntaxOpTypeSynAnySynFunSynListSynRhoSynTypeTcKindTcLevel TcTauType TcThetaType TcTyVarSetTcTypeTcTyVarGHC.Core.ClassClassGHC.Driver.Session isClassTyCon isFamilyTyCon isFunTyCon isGcPtrRep isNewTyConisOpenFamilyTyConisOpenTypeFamilyTyCon isPrimTyConisTypeFamilyTyConisTypeSynonymTyCon isVoidRepsynTyConDefn_maybesynTyConRhs_maybetyConClass_maybe tyConDataConsNominalPhantomRepresentational tyConArity tyConKind tyConTyVarsGHC.Core.DataConDataConBuiltInSynFamilyGHC.Core.Coercion buildCoercioncastCoercionKindcastCoercionKind1castCoercionKind2coToMCo coVarKindcoVarKindsTypesRole coVarName coVarRole coVarTypescoercionHolesOfCocoercionHolesOfType coercionKindcoercionKindRole coercionKinds coercionLKind coercionRKind coercionRole coercionTypecomposeSteppers decomposeCodecomposeFunCodecomposePiCos downgradeRoleemptyLiftingContext eqCoercion eqCoercionXetaExpandCoAxBranchextendLiftingContextextendLiftingContextAndInScopegetCoVar_maybehasCoercionHoleCohasCoercionHoleTyinstNewTyCon_maybe isCoVar_maybe isGReflCoisGReflCo_maybe isGReflMCo isMappedByLCisReflCoisReflCoVar_maybeisReflCo_maybe isReflMCo isReflexiveCoisReflexiveCo_maybe lcInScopeSet lcSubstLeft lcSubstRight lcTCvSubst liftCoSubstliftCoSubstTyVarliftCoSubstVarBndrUsingliftCoSubstWithliftCoSubstWithExliftEnvSubstLeftliftEnvSubstRightltRole mapStepResultmkAppComkAppCos mkAxInstCo mkAxInstLHS mkAxInstRHS mkAxiomInstCo mkAxiomRuleCo mkCastTyMComkCoCast mkCoVarCo mkCoVarCosmkCoercionTypemkCoherenceLeftComkCoherenceRightComkCoherenceRightMComkFamilyTyConAppCo mkForAllCo mkForAllCosmkFunCo mkGReflCo mkGReflLeftComkGReflLeftMComkGReflRightComkGReflRightMComkHeteroCoercionTypemkHeteroPrimEqPredmkHeteroReprPrimEqPredmkHoleComkHomoForAllCosmkInstComkKindComkLRCo mkNomReflComkNthCo mkNthCoFunCo mkPhantomComkPiComkPiCos mkPrimEqPredmkPrimEqPredRolemkProofIrrelComkReflCo mkRepReflComkReprPrimEqPredmkSubComkSubstLiftingContextmkSymComkSymMCo mkTransCo mkTransMCo mkTransMCoL mkTyConAppComkUnbranchedAxInstComkUnbranchedAxInstLHSmkUnbranchedAxInstRHSmkUnivComultToCo nthCoRolenthRole pprCoAxBranchpprCoAxBranchLHSpprCoAxBranchUser pprCoAxiompromoteCoercionseqCo setCoVarNamesetCoVarUniquesetNominalRole_maybesimplifyArgsWorkersplitAppCo_maybesplitForAllCo_co_maybesplitForAllCo_maybesplitForAllCo_ty_maybesplitFunCo_maybesplitTyConAppCo_maybesubstForAllCoBndrUsingLC substLeftCo substRightCo swapLiftCoEnvtidyCoAxBndrsForUsertopNormaliseNewType_maybetopNormaliseTypeXtyConRolesRepresentational tyConRolesXunwrapNewTypeStepperzapLiftingContextanyFreeVarsOfCo coVarsOfCo tyCoFVsOfCo tyCoFVsOfCos tyCoVarsOfCotyCoVarsOfCoDSet tyCoVarsOfCospprCo pprParendCo coHoleCoVar coercionSizesetCoHoleCoVaremptyCvSubstEnv getCvSubstEnv lookupCoVar substCoVarsubstCoVarBndr substCoVars substCoWithsubstCostidyCotidyCosisCoVarmkCoVarHoleSet LiftCoEnvLiftingContextLCNormaliseStepResultNS_AbortNS_DoneNS_StepNormaliseStepper ch_co_varch_ref CoercionP CoercionR MCoercionMCoMRefl MCoercionN MCoercionRUnivCoProvenance CvSubstEnvGHC.Types.Var.Env InScopeSetGHC.Tc.Types.Constraint tyCoVarsOfCt tyCoVarsOfCts tyCoVarsOfWCQCInstQCIqci_ev qci_pend_scqci_predqci_tvs RealSrcSpansfInteractInert sfInteractTop sfMatchFamId alphaTyVarsGHC.Types.Fixity LexicalFixity GHC.Hs.Type mkHsAppTy typeNatTyConstypeNatAddTyContypeNatSubTyContypeNatMulTyContypeNatDivTyContypeNatModTyContypeNatExpTyContypeNatLogTyContypeNatCmpTyContypeSymbolCmpTyContypeSymbolAppendTyContypeConsSymbolTyContypeUnconsSymbolTyContypeCharToNatTyContypeNatToCharTyContypeNatCoAxiomRulestypeCharCmpTyConclassATs classMethods classSCTheta classTvsFds pprFundeps globaliseId idDetailsidInfo isExportedId isGlobalIdisId isLocalId setIdMultupdateIdTypeAndMultupdateIdTypeAndMultMupdateIdTypeButNotMultInIdInVarJoinIdOutIdOutVarGHC.Core.ConLike conLikeResTyGHC.Core.Opt.ConstantFold builtinRules primOpRulesdataConFieldLabelsdataConIsInfixdataConSrcBangs dataConTyCondataConWrapperTypeisMarkedStrictisVanillaDataConStrictnessMark MarkedStrictNotMarkedStrict GHC.Types.IdasJoinIdasJoinId_maybeclearOneShotLambda hasNoBindingidArity idCafInfo idCallArity idCoreRulesidCprSig idDataCon idDemandInfoidDmdSig idFunRepArity idHasRulesidInlineActivationidInlinePragmaidIsFrom idJoinArityidLFInfo_maybeidMultidName idOccInfo idOneShotInfoidRuleMatchInfo idScaledTypeidSpecialisationidStateHackOneShotInfoidType idUnfoldingidUniqueisClassOpId_maybe isConLikeIdisDFunIdisDataConId_maybeisDataConRecordSelectorisDataConWorkIdisDataConWorkId_maybeisDataConWrapIdisDataConWrapId_maybe isDeadBinder isDeadEndId isFCallIdisFCallId_maybe isImplicitIdisJoinIdisJoinId_maybeisNaughtyRecordSelectorisNeverLevPolyId isOneShotBndrisPatSynRecordSelector isPrimOpIdisPrimOpId_maybeisProbablyOneShotLambdaisRecordSelectorisStateHackType isStrictId localiseIdmaybeModifyIdInfomkExportedLocalIdmkExportedVanillaId mkGlobalId mkLocalCoVar mkLocalIdmkLocalIdOrCoVarmkLocalIdWithInfomkScaledTemplateLocal mkSysLocal mkSysLocalMmkSysLocalOrCoVarmkSysLocalOrCoVarMmkTemplateLocalmkTemplateLocalsmkTemplateLocalsNum mkUserLocalmkUserLocalOrCoVarmkVanillaGlobalmkVanillaGlobalWithInfo mkWorkerId modifyIdInfomodifyInlinePragmarealIdUnfoldingrecordSelectorTyConrecordSelectorTyCon_maybe scaleIdBy scaleVarBysetCaseBndrEvald setIdArity setIdCafInfosetIdCallArity setIdCprSigsetIdDemandInfo setIdDmdSig setIdInfo setIdLFInfo setIdName setIdOccInfosetIdOneShotInfosetIdSpecialisation setIdTypesetIdUnfolding setIdUniquesetInlineActivationsetInlinePragmasetOneShotLambdastateHackOneShottransferPolyIdInfo typeOneShotupdOneShotInfozapFragileIdInfozapIdDemandInfo zapIdDmdSig zapIdOccInfozapIdTailCallInfozapIdUsageEnvInfozapIdUsageInfozapIdUsedOnceInfo zapJoinId zapLamIdInfozapStableUnfoldingGHC.StgToCmm.TypesLambdaFormInfoGHC.Types.Unique.Supply MonadUniqueGHC.Types.Id.Make ghcPrimIds wiredInIdsGHC.Core.FamInstEnv FamInstEnvsACoAxiomAConLikeATyConAnIdGHC.Utils.Outputable alwaysQualifyPrintUnqualifiedGHC.Utils.PanicshowGhcExceptionwithSignalHandlers GhcException CmdLineErrorInstallationErrorPanicPprPanicPprProgramErrorPprSorry ProgramErrorSignalSorry UsageErrorGHC.Unit.Module.ModIfaceModIface ModIface_mi_anns mi_arg_docsmi_complete_matches mi_decl_docsmi_declsmi_deps mi_doc_hdr mi_exports mi_ext_fields mi_fam_insts mi_final_exts mi_fixities mi_globalsmi_hpc mi_hsc_srcmi_insts mi_modulemi_rules mi_sig_ofmi_trust mi_trust_pkg mi_usages mi_used_thmi_warns knownKeyNameslookupKnownKeyNameisKnownKeyNamelookupKnownNameInfoprimOpIdghcPrimExportsghcPrimDeclDocsmaybeCharLikeConmaybeIntLikeConisNumericClassisStandardClassGHC.CmmblockId GenBasicBlock BasicBlock ListGraph RawCmmDecl RawCmmStaticsGHC.Cmm.Dataflow.BlockBlockC getUniqueMgetUniqueSupplyM getUniquesM UniqSupplylastNodeOGHC.Cmm.Dataflow.Graph entryLabelGHC.Cmm.Dataflow.CollectionsmapEmptyGHC.Cmm.Dataflow.LabelFactBaseGHC.Data.TrieMapTrieMapKey RewriteFun TransferFunDataflowLatticefact_bot fact_join JoinedFactChanged NotChangedNewFactOldFactFact changedIf analyzeCmmBwd analyzeCmmFwd rewriteCmmBwdgetFact joinOutFacts joinFacts mkFactBasefoldNodesBwdOOfoldRewriteNodesBwdOOGHC.Cmm.BlockId newBlockIdLRegKeyLRegSet emptyLRegSet nullLRegSet insertLRegSet elemLRegSetdeleteFromLRegSet sizeLRegSet plusLRegSet elemsLRegSetpprExprpprLit$fOutputablePenvGlobalReg$fOutputableGlobalReg$fOutputableArea$fOutputableLocalReg$fOutputablePPlatformCmmLit$fOutputableCmmReg$fOutputablePPlatformCmmExprpprCmms pprCmmGroup pprStatic pprSection$fOutputableForeignHint!$fOutputablePPlatformCmmInfoTable$fOutputablePPlatformCmmStatic"$fOutputablePPlatformGenCmmStatics$fOutputablePPlatformGenCmmDecl CmmLocalLive liveLatticecmmLocalLivenesscmmGlobalLivenessgen_kill liveLatticeLcmmLocalLivenessL gen_killLGHC.Platform.Regs callerSavesprimRepCmmType slotCmmType typeCmmTypeprimRepForeignHintslotForeignHinttypeForeignHint mkIntCLit mkIntExprzeroCLitzeroExpr mkWordCLitmkByteStringCLitmkFileEmbedLit 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 cmmToWord cmmMkAssignisTrivialCmmExprhasNoGlobalRegsisLitisComparisonExprtAG_MASK mAX_PTR_TAG cmmTagMaskcmmPointerMaskcmmUntag cmmIsTagged cmmConstrTag1 regsOverlap regUsedIn mkLiveness modifyGraph toBlockMap ofBlockMap toBlockListtoBlockListEntryFirst%toBlockListEntryFirstFalseFallthrough ofBlockListbodyToBlockList mapGraphNodesmapGraphNodes1foldlGraphBlocks revPostorder blockTicksbaseExprspExpr spLimExprhpExpr hpLimExprcurrentTSOExprcurrentNurseryExprcccsExprStandardFormInfoGHC.Driver.BackendBackend InterpreterLLVMNCG NoBackendViaCcmmImplementSwitchPlans $fOutputablePPlatformGenCmmGraph$fOutputablePPlatformGraph'$fOutputablePPlatformBlock$fOutputablePPlatformBlock0$fOutputablePPlatformBlock1$fOutputablePPlatformBlock2$fOutputableCmmReturnInfo"$fOutputablePPlatformForeignTarget$fOutputableForeignConvention$fOutputableConvention$fOutputablePPlatformCmmNode$fOutputablePPlatformCmmTopInfo$fOutputableCmmStackInfogoptGHC.Driver.Flags GeneralFlagOpt_AbstractRefHoleFitsOpt_AlignmentSanitisationOpt_AsmShortcuttingOpt_AutoLinkPackagesOpt_AutoSccsOnIndividualCafsOpt_BreakOnErrorOpt_BreakOnExceptionOpt_BuildDynamicTooOpt_BuildingCabalPackage Opt_ByteCodeOpt_CSE Opt_CallArityOpt_CaseFolding Opt_CaseMergeOpt_CatchBottomsOpt_CfgBlocklayoutOpt_CmmElimCommonBlocks Opt_CmmSinkOpt_CmmStaticPred Opt_CprAnalOpt_CrossModuleSpecialiseOpt_D_dump_minimal_importsOpt_D_faststring_statsOpt_DeferDiagnosticsOpt_DeferOutOfScopeVariablesOpt_DeferTypeErrorsOpt_DeferTypedHolesOpt_DiagnosticsShowCaretOpt_DictsCheapOpt_DictsStrictOpt_DistinctConstructorTablesOpt_DistrustAllPackagesOpt_DmdTxDictSelOpt_DoAnnotationLintingOpt_DoAsmLintingOpt_DoCmmLintingOpt_DoCoreLintingOpt_DoEtaReductionOpt_DoLambdaEtaExpansionOpt_DoLinearCoreLintingOpt_DoStgLintingOpt_DumpToFileOpt_EagerBlackHolingOpt_EmbedManifestOpt_EnableRewriteRulesOpt_EnableThSpliceWarningsOpt_ErrorSpansOpt_ExcessPrecisionOpt_ExitificationOpt_ExposeAllUnfoldingsOpt_ExposeInternalSymbolsOpt_ExternalDynamicRefsOpt_ExternalInterpreterOpt_FamAppCache Opt_FastLlvm Opt_FloatInOpt_ForceRecompOpt_FullLazinessOpt_FunToThunkOpt_G_NoOptCoercionOpt_G_NoStateHackOpt_GenManifestOpt_GhciHistoryOpt_GhciLeakCheckOpt_GhciSandbox Opt_HaddockOpt_HaddockOptionsOpt_HelpfulErrorsOpt_HexWordLiteralsOpt_HideAllPackagesOpt_HideAllPluginPackagesOpt_HideSourcePathsOpt_HpcOpt_IgnoreAssertsOpt_IgnoreDotGhciOpt_IgnoreHpcChangesOpt_IgnoreInterfacePragmasOpt_IgnoreOptimChangesOpt_ImplicitImportQualifiedOpt_InfoTableMapOpt_InlineGenericsOpt_InlineGenericsAggressivelyOpt_IrrefutableTuples Opt_KeepCAFs Opt_KeepGoingOpt_KeepHcFilesOpt_KeepHiDiffsOpt_KeepHiFilesOpt_KeepHscppFilesOpt_KeepLlvmFilesOpt_KeepOFilesOpt_KeepRawTokenStreamOpt_KeepSFilesOpt_KeepTmpFilesOpt_KillAbsenceOpt_KillOneShotOpt_LateDmdAnalOpt_LateSpecialiseOpt_LiberateCase Opt_LinkRtsOpt_LlvmFillUndefWithGarbage Opt_LlvmTBAAOpt_LocalGhciHistoryOpt_Loopification Opt_NoHsMainOpt_NoItOpt_NoLlvmManglerOpt_NoTypeableBindsOpt_NumConstantFoldingOpt_OmitInterfacePragmasOpt_OmitYieldsOpt_OptimalApplicativeDoOpt_PICOpt_PICExecutableOpt_PIEOpt_PackageTrustOpt_PedanticBottomsOpt_PluginTrustworthyOpt_PpOpt_PprCaseAsLetOpt_PprShowTicksOpt_PrintAxiomIncompsOpt_PrintBindContentsOpt_PrintBindResultOpt_PrintEqualityRelationsOpt_PrintEvldWithShowOpt_PrintExpandedSynonymsOpt_PrintExplicitCoercionsOpt_PrintExplicitForallsOpt_PrintExplicitKindsOpt_PrintExplicitRuntimeRepsOpt_PrintPotentialInstancesOpt_PrintTypecheckerElaborationOpt_PrintUnicodeSyntaxOpt_ProfCountEntries Opt_RPath Opt_RegsGraphOpt_RegsIterativeOpt_RelativeDynlibPathsOpt_SharedImplibOpt_ShowDocsOfHoleFitsOpt_ShowHoleConstraintsOpt_ShowLoadedModulesOpt_ShowMatchesOfHoleFitsOpt_ShowProvOfHoleFitsOpt_ShowTypeAppOfHoleFitsOpt_ShowTypeAppVarsOfHoleFitsOpt_ShowTypeOfHoleFitsOpt_ShowValidHoleFitsOpt_ShowWarnGroupsOpt_SimplPreInliningOpt_SingleLibFolderOpt_SolveConstantDictsOpt_SortBySizeHoleFitsOpt_SortBySubsumHoleFitsOpt_SortValidHoleFitsOpt_SpecConstrOpt_SpecConstrKeenOpt_SpecialiseOpt_SpecialiseAggressivelyOpt_SplitSections Opt_StaticArgumentTransformation Opt_StgCSEOpt_StgLiftLams Opt_StgStatsOpt_StrictnessOpt_SuppressCoercionsOpt_SuppressIdInfoOpt_SuppressModulePrefixesOpt_SuppressStgExtsOpt_SuppressTicksOpt_SuppressTimestampsOpt_SuppressTypeApplicationsOpt_SuppressTypeSignaturesOpt_SuppressUnfoldingsOpt_SuppressUniquesOpt_SuppressVarKinds Opt_TickyOpt_Ticky_AllocdOpt_Ticky_Dyn_Thunk Opt_Ticky_LNEOpt_UnboxSmallStrictFieldsOpt_UnboxStrictFieldsOpt_UnclutterValidHoleFitsOpt_ValidateHieOpt_VersionMacrosOpt_WarnIsErrorOpt_WeightlessBlocklayoutOpt_WholeArchiveHsLibsOpt_WorkerWrapper Opt_WriteHieOpt_WriteInterfaceavxavx2avx512cdavx512eravx512favx512pfbinBlobThreshold bmiVersioncallerCcFilters canUseColor cfgWeightscmdlineFrameworkscmmProcAlignment colScheme debugLeveldepExcludeModsdepIncludeCppDepsdepIncludePkgDeps depMakefile depSuffixesdumpDir dumpFlags dumpPrefixdumpPrefixForcedylibInstallName dynHiSuf_ dynLibLoader dynObjectSuf_dynOutputFile_ dynamicNowdynamicTooFailedenableTimeStatsextensionFlags extensionsfatalWarningFlags fileSettings floatLamArgsflushErrflushOutframeworkPathsfrontendPluginOpts generalFlags ghcHeapSizeghcLinkghcModeghcNameVersionghcVersionFile ghciHistSize ghciScriptshaddockOptionshcSufhiDirhiSuf_hieDirhieSuf historySize homeUnitId_homeUnitInstanceOf_homeUnitInstantiations_hpcDirignorePackageFlags importPaths includePathsincoherentOnLoc initialUnique inlineCheckinteractivePrintlanguageldInputsliberateCaseThreshold libraryPaths liftLamsKnownliftLamsNonRecArgsliftLamsRecArgs llvmConfig mainFunIsmainModuleNameIs maxErrorsmaxInlineAllocSizemaxInlineMemcpyInsnsmaxInlineMemsetInsnsmaxPmCheckModelsmaxRefHoleFitsmaxRelevantBindsmaxSimplIterationsmaxUncoveredPatternsmaxValidHoleFits maxWorkerArgs newDerivOnLocnextWrapperNum objectDir objectSuf_optLevel outputFile_outputHioverlapInstLocpackageDBFlags packageEnv packageFlags parMakeCount pkgTrustOnLoc platformMiscpluginModNameOptspluginModNamespluginPackageFlagspprCols pprUserLengthprofAuto rawSettingsreductionDepthrefLevelHoleFits reverseErrorsrtccInfortldInfortsOptsrtsOptsEnabledrtsOptsSuggestions ruleCheck safeHaskell safeInfer safeInferred simplPhasessimplTickFactorsolverIterationsspecConstrCountspecConstrRecursivespecConstrThreshold splitInfo sseVersionstrictnessBeforestubDirtargetPlatform targetWays_thOnLoc toolSettings trustFlagstrustworthyOnLoc unfoldingOptsuniqueIncrementuseColor useUnicode verbosity warnSafeOnLocwarnUnsafeOnLoc warningFlagsGhcLink LinkBinary LinkDynLib LinkInMemory LinkStaticLibNoLinkGhcMode CompManagerMkDependOneShot getDynFlagsGHC.Utils.CliOptionOption FileOptionGHC.Types.SafeHaskellSafeHaskellMode ParamLocation RegisterParam StackParamassignArgumentsPos assignStackrealArgRegsCover$fOutputableParamLocationTransferCallJumpRetJumpRetCgStmtCgLabelCgLastCgForkCmmAGraphScoped CmmAGraph catAGraphsmkLabelmkMiddlemkLast outOfLinelgraphOfAGraph labelAGraphmkNop mkCommentmkAssignmkStoremkJump mkRawJump mkJumpExtra mkCbranchmkSwitchmkReturnmkBranch mkFinalCallmkCallReturnsTomkJumpReturnsTo mkUnsafeCallmkUnwind stackStubExpr copyInOflow copyOutOflow mkCallEntry noExtraStacktoCall $fEqTransferconstantFoldNodeconstantFoldExpr cmmMachOpFoldcmmMachOpFoldMcmmSinkaddCLoc cmpLocated combineLocs eqLocatedgetLocgetRealSrcSpan isGoodSrcSpan isSubspanOfleftmost_largestleftmost_smallestmkGeneralLocatedmkSrcLoc mkSrcSpannoLocnoSrcLoc noSrcSpanrightmost_smallestspans srcLocCol srcLocFile srcLocLine srcLocSpan srcSpanEnd srcSpanEndColsrcSpanEndLine srcSpanStartsrcSpanStartColsrcSpanStartLineunLoc unRealSrcSpanL RealLocated RealSrcLoc srcSpanFile UnhelpfulLoc UnhelpfulSpancmmLint cmmLintGraph$fMonadCmmLint$fApplicativeCmmLint$fFunctorCmmLintGHC.Unit.Module.Location ModLocation ml_hi_file ml_hie_file ml_hs_file ml_obj_file UnwindExprUwConstUwRegUwDerefUwLabelUwPlusUwMinusUwTimes UnwindTable UnwindPoint DebugBlock dblProceduredblLabel dblCLabel dblHasInfoTbl dblParentdblTicks dblSourceTick dblPosition dblUnwind dblBlocks cmmDebugGencmmDebugLabels cmmDebugLink debugToMap toUnwindExpr$fOutputablePenvUnwindExpr$fOutputablePenvUnwindPoint$fOutputablePenvDebugBlock$fEqUnwindExpr cmmCfgOptscmmCfgOptsProc replaceLabelsremoveUnreachableBlocksProc>.>deleteTMinsertTM|>|>>alterTMemptyTMfilterTMfoldTMlookupTMmapTMelimCommonBlocksRootedGraphEdgePathNodedompdomdomTreepdomTreeidomipdompddfsrpddfsfromAdj fromEdgestoAdjtoEdgesparents ancestorsasGraphasTree$fApplicativeS$fMonadS $fFunctorSEdgeInfotransitionSource edgeWeightTransitionSource CmmSource AsmCodeGen trans_cmmNode trans_infoCfgEdgeedgeFromedgeToedgeInfoCFG EdgeWeightweightToDouble mkWeightInfoadjustEdgeWeight setEdgeWeight getCfgNodeshasNodesanityCheckCfg filterEdgesshortcutWeightMapaddImmediateSuccessoraddEdge addWeightEdgedelEdgedelNodegetSuccEdgesSortedgetSuccessorEdges getEdgeInfo reverseEdges infoEdgeListedgeList getSuccessorspprEdgeWeightsaddNodesBetween getCfgProcgetCfg optimizeCFG loopMembers loopLevelsloopInfomkGlobalWeights$fOutputableEdgeWeight$fOutputableBranchInfo$fOutputableEdgeInfo$fOutputableCfgEdge $fOrdCfgEdge $fEqCfgEdge$fOutputableLoopInfo$fNonLocalBlockNode $fEqEdgeInfo$fEqTransitionSource$fEqBranchInfo$fEqEdgeWeight$fOrdEdgeWeight$fEnumEdgeWeight$fNumEdgeWeight$fRealEdgeWeight$fFractionalEdgeWeight popCntLabel pdepLabel pextLabel bSwapLabel bRevLabelclzLabelctzLabelword2FloatLabelatomicRMWLabel xchgLabel cmpxchgLabelatomicReadLabelatomicWriteLabelFormatII8II16II32II64FF32FF64 intFormat floatFormat isFloatFormat cmmTypeFormat formatToWidth formatInBytes $fShowFormat $fEqFormat InstructionregUsageOfInstrpatchRegsOfInstrisJumpishInstrjumpDestsOfInstrpatchJumpInstr mkSpillInstr mkLoadInstrtakeDeltaInstr isMetaInstrmkRegRegMoveInstrtakeRegRegMoveInstr mkJumpInstrmkStackAllocInstrmkStackDeallocInstrpprInstrRegUsageRUreadswritesnoUsageCondALWAYSEQQGEGEUGTTGULELEULTTLUNE condNegate condUnsigned$fEqCondAddrMode AddrRegReg AddrRegImmImmImmInt ImmIntegerImmCLblImmLitImmIndexImmFloat ImmDoubleImmConstantSumImmConstantDiffLOHIHAHIGHERAHIGHESTAvirtualRegSqueezerealRegSqueeze mkVirtualReg regDotColor strImmLitlitToImm addrOffsetspRelargRegs allArgRegscallClobberedRegs allMachRegNosclassOfRealRegshowRegtoRegNo allFPArgRegs fits16Bits makeImmediatefRegr0sptocr3r4r11r12r30f1allocatableRegstmpRegRegSubSubL16SubL8SubL8HRegRegClassClassG32ClassG16ClassG8ClassF64worstboundsqueese$fUniquableReg $fShowReg$fEqReg $fShowRegSub $fEnumRegSub $fOrdRegSub $fEqRegSub$fShowRegClass $fEqRegClass$fEnumRegClass classOfReg regsOfClassregNameregAliasFreeRegs noFreeRegs releaseReg initFreeRegs getFreeRegs allocateReg$fOutputableFreeRegs$fShowFreeRegsStackMapstackMapNextFreeSlotstackMapAssignment StackSlot emptyStackMapgetStackSlotFor getStackUsetoRegMap toVRegMap wordLengthwordLengthInBits spillSlotSizeextraStackArgsHere fits13Bitsis32BitIntegerlargeOffsetErrorNEGNEVERPOSVCVS allRealRegsgRegoReglRegiRegf6f8f22f26f27g0g1g2fpo0o1f0bitMask showFreeRegsfpRelspillSlotToOffset maxSpillSlots NatBasicBlock NatCmmDeclNatCmm topInfoTable entryBlocksCARRYOFLOPARITY NOTPARITYcondToUnsigned maybeFlipCondmaybeInvertCondEAIndex EAIndexNoneEABase EABaseNone EABaseReg EABaseRip AddrBaseIndexImmAddr addrModeRegsfirstxmmlastxmmlastinteaxebxecxedxesiediebpespraxrbxrcxrdxrsirdirbprspr8r9r10r13r14r15xmm0xmm1xmm2xmm3xmm4xmm5xmm6xmm7xmm8xmm9xmm10xmm11xmm12xmm13xmm14xmm15ripRelxmm allIntArgRegsinstrClobberedRegstargetVirtualRegSqueezetargetRealRegSqueezetargetClassOfRealRegtargetMkVirtualRegtargetRegDotColortargetClassOfRegJumpDest DestBlockIdDestImmOperandOpRegOpImmOpAddrPrefetchVariantNTALvl0Lvl1Lvl2InstrCOMMENTLOCATIONLDATANEWBLOCKUNWINDDELTAMOVCMOVMOVZxLMOVSxLLEAADDADCSUBSBBMULMUL2IMULIMUL2DIVIDIVADD_CCSUB_CCANDORXORNOTNEGIBSWAPSHLSARSHRBTNOPX87StoreCVTSS2SDCVTSD2SS CVTTSS2SIQ CVTTSD2SIQCVTSI2SSCVTSI2SDFDIVSQRTTESTCMPSETCCPUSHPOPJMPJXXJXX_GBLJMP_TBLCALLCLTDFETCHGOTFETCHPCPOPCNTLZCNTTZCNTBSFBSRPDEPPEXTPREFETCHLOCKXADDCMPXCHGXCHGMFENCEarchWordFormatallocMoreStackgetJumpDestBlockId canShortcut shortcutJumpshortcutStatics$fOutputableJumpDestLDSTUMULSMULUDIVSDIVRDYWRYANDNORNXNORSLLSRLSRASETHIFABSFADDFCMPFMOVFMULFNEGFSQRTFSUBFxTOyBIBFRIRIRegRIImmriZerofpRelEAmoveSpisUnconditionalJump shortBlockId expandTopRegisterFixedAnyAmode ChildCode64CondCode InstrBlocksetFormatOfRegistergetRegisterRegmangleIndexTreeNatM DwarfFiles NatM_Statenatm_us natm_delta natm_importsnatm_pic natm_config natm_modloc natm_fileidnatm_debug_mapnatm_cfgNcgImpl ncgConfig cmmTopCodeGengenerateJumpTableForInstr pprNatCmmDecl ncgExpandTopncgAllocMoreStackncgMakeFarBranchesextractUnwindPointsinvertCondBranches mkNatM_StateinitNat mapAccumLNat getUniqueNat getDeltaNat getCfgWeights setDeltaNatgetThisModuleNat addImportNat updateCfgNataddNodeBetweenNataddImmediateSuccessorNat getBlockIdNatgetNewLabelNat getNewRegNatgetNewRegPairNatgetPicBaseMaybeNat getPicBaseNat getModLoc getConfig getPlatform getFileId getDebugBlock$fHasModuleNatM$fMonadUniqueNatM $fMonadNatM$fApplicativeNatM $fFunctorNatM getRegister getSomeReg getCondCode condIntCode condFltCodegetAmodeassignMem_I64CodeassignReg_I64Code iselExpr64 sequenceTopbackendMaintainsCfg$fOutputableBlockChain$fOrdBlockChain$fEqBlockChaincmmToC $fMonadTE$fApplicativeTE $fFunctorTEGHC.Utils.ErrorprettyPrintGhcErrorsGHC.Types.ErrorSeveritySevError SevWarningGHC.Utils.LoggerLogger popLogHook pushLogHook getLogger llvmFixupAsmGHC.Core.Map.Type lkDFreeVarlkDNamed xtDFreeVarxtDNamedCoreMap lookupCoreMap extendCoreMap foldCoreMap emptyCoreMap $fEqDeBruijn $fEqDeBruijn0$fTrieMapAltMap$fTrieMapCoreMapX$fOutputableCoreMap$fTrieMapCoreMap addInScopeSet cloneBndr cloneBndrs cloneIdBndr cloneIdBndrscloneRecIdBndrs deShadowBindsdelBndrdelBndrs emptySubst extendIdSubstextendIdSubstList extendInScopeextendInScopeIdsextendInScopeList extendSubstextendSubstListextendSubstWithVar extendTvSubstextendTvSubstList getTCvSubst isEmptySubst isInScope lookupIdSubstlookupTCvSubst mkEmptySubst mkOpenSubstmkSubst setInScope substBind substBindSC substBndr substBndrssubstCo substDVarSet substExpr substExprSC substIdInfo substIdOcc substIdType substInScope substRecBndrssubstRulesForImportedIds substSpec substTickishsubstTysubstUnfoldingsubstUnfoldingSC zapSubstEnv IdSubstEnvFamInst cseProgram cseOneExprGHC.Core.Opt.MonadisZeroSimplCountplusSimplCount pprSimplCountzeroSimplCount SimplCountGHC.Driver.Env.TypesHscEnvGHC.ByteCode.Types ModBreaksGHC.Core.InstEnvClsInstGHC.Types.CompleteMatch CompleteMatch GHCi.MessageEvalExprEvalAppEvalThis EvalResult EvalException EvalSuccess EvalStatus EvalStatus_ EvalBreak EvalCompleteMessage AbandonStmtAddLibrarySearchPath AddSptEntryBreakpointStatusCostCentreStackInfo CreateBCOsEvalIOEvalStmt EvalStringEvalStringToStringFindSystemLibraryFreeFFIFreeHValueRefsGetBreakpointVar GetClosure InitLinker LoadArchiveLoadDLLLoadObj LookupClosure LookupSymbol MallocData MallocStringsMkConInfoTable MkCostCentres NewBreakArrayPrepFFIRemoveLibrarySearchPath ResolveObjs ResumeSeq ResumeStmt RtsRevertCAFsRunModFinalizersRunTHSeqSetupBreakpointShutdownStartTH UnloadObj floatInwardsinstanceDFunId pprInstancepprInstanceHdrCompleteMatches BreakIndexmodBreaks_breakInfo modBreaks_ccsmodBreaks_declsmodBreaks_flagsmodBreaks_locsmodBreaks_vars UnlinkedBCOGHC.Data.SizedSeqSizedSeq Sf_IgnoreSf_NoneSf_SafeSf_SafeInferredSf_Trustworthy Sf_Unsafe liberateCase FloatSpecFloatMeStayPut LevelTypeBndrLvl JoinCeilLvlLevel LevelledBndr LevelledBind LevelledExprfloatSpecLevel tOP_LEVEL incMinorLvl asJoinCeilLvlltLvlltMajLvlisTopLvl isJoinCeilLvl setLevels $fEqLevel$fOutputableLevel$fOutputableFloatSpec $fEqLevelType floatOutwards$fOutputableFloatBindssizeSSssEltsGHC.Parser.Annotation AnnKeywordId AnnAnyclassAnnAsAnnAt AnnBackquoteAnnBangAnnByAnnCaseAnnClassAnnClose AnnCloseB AnnCloseBU AnnCloseC AnnCloseP AnnClosePH AnnCloseQ AnnCloseQU AnnCloseSAnnColonAnnComma AnnCommaTuple AnnDarrow AnnDarrowUAnnData AnnDcolon AnnDcolonU AnnDefault AnnDerivingAnnDo AnnDollarAnnDollarDollarAnnDot AnnDotdotAnnElseAnnEqual AnnExport AnnFamily AnnForall AnnForallU AnnForeignAnnFunIdAnnGroup AnnHeader AnnHidingAnnIf AnnImportAnnInAnnInfix AnnInstanceAnnLam AnnLarrow AnnLarrowU AnnLarrowtailAnnLarrowtailUAnnLet AnnLollyUAnnMdoAnnMinus AnnModuleAnnName AnnNewtypeAnnOfAnnOpenAnnOpenB AnnOpenBUAnnOpenCAnnOpenE AnnOpenEQ AnnOpenEQUAnnOpenP AnnOpenPHAnnOpenSAnnPackageName AnnPattern AnnPercent AnnPercentOneAnnProc AnnQualified AnnRarrow AnnRarrowU AnnRarrowtailAnnRarrowtailUAnnRecAnnRoleAnnSafeAnnSemi AnnSignatureAnnSimpleQuote AnnStaticAnnStock AnnThTyQuoteAnnThenAnnTildeAnnTypeAnnUnitAnnUsingAnnVal AnnValStrAnnVbarAnnViaAnnWhere AnnlarrowtailAnnlarrowtailU AnnrarrowtailAnnrarrowtailU EpaComment ac_prior_tokac_tokSimplMinitSmpl traceSmpl getSimplRules getFamEnvsgetOptCoercionOptsnewId newJoinId getSimplCounttick checkedTickfreeTick$fMonadIOSimplM$fHasLoggerSimplM$fHasDynFlagsSimplM$fMonadUniqueSimplM $fMonadSimplM$fApplicativeSimplM$fFunctorSimplM JoinFloats JoinFloat LetFloatsSimplSRDoneExDoneIdContEx SimplFloats sfLetFloats sfJoinFloats sfInScopeSimplEnvseMode seTvSubst seCvSubst seIdSubst seInScope seCaseDepth emptyFloats pprSimplEnv mkSimplEnvgetMode seDynFlagsseLoggerseUnfoldingOptssetModeupdMode bumpCaseDepth getInScope setInScopeSetsetInScopeFromEsetInScopeFromFaddNewInScopeIds modifyInScope setSubstEnvmkContExdoFloatFromRhsemptyLetFloatsemptyJoinFloats unitLetFloat unitJoinFloat mkFloatBind extendFloats addLetFloats addJoinFloats addFloats addLetFlts letFloatBinds addJoinFlts mkRecFloats wrapFloatswrapJoinFloatsXwrapJoinFloatsgetTopFloatBinds mapLetFloatssubstIdrefineFromInScope lookupRecBndr simplBinders simplBindersimplNonRecBndr simplRecBndrssimplNonRecJoinBndrsimplRecJoinBndrs$fOutputableSimplSR$fOutputableFloatFlag$fOutputableLetFloats$fOutputableSimplFloats pprForAllGHC.Core.Unfold.Make specUnfoldingArgSpecValArgTyArgCastByas_dmdas_arg as_hole_ty as_arg_tyArgInfoai_funai_argsai_rulesai_enclai_dmdsai_discsDupFlagNoDup SimplifiedOkToDup StaticEnv SimplContStopCastIt ApplyToVal ApplyToTySelect StrictBind StrictArgTickItsc_dup sc_hole_tysc_argsc_envsc_cont sc_arg_tysc_bndrsc_altssc_bndrssc_bodysc_fun sc_fun_ty isSimplified addValArgTo addTyArgTo addCastToisStrictArgInfoargInfoAppArgspushSimplifiedArgs argInfoExpr mkBoringStop mkRhsStop mkLazyArgStopcontIsRhsOrArg contIsStop contIsDupable contIsTrivialcontResultType contHoleTypecontHoleScaling countArgscontArgs mkArgInfolazyArgContextinterestingCallContextsimplEnvForGHCiupdModeForStableUnfoldingsupdModeForRulesactiveUnfoldinggetUnfoldingInRuleMatch activeRulepreInlineUnconditionallypostInlineUnconditionallymkLamtryEtaExpandRhsabstractFloats prepareAltsmkCase isExitJoinId$fOutputableDupFlag$fOutputableArgSpec$fOutputableArgInfo$fOutputableSimplCont doStaticArgsUnboxingDecision StopUnboxingUnboxDataConPatContextdcpc_dc dcpc_tc_argsdcpc_co mkWwBodiesisWorkerSmallEnough mkWorkerArgssplitArgType_maybe wantToUnboxmkWWstr findTypeShape wwTopBinds DmdAnalOptsdmd_strict_dictsdmdAnalProgram$fOutputableAnalEnvtidyExpr tidyRules tidyUnfoldingmkRule roughTopNamespprRulesForUserextendRuleInfo addRuleInfoaddIdSpecialisations rulesOfBindsgetRules emptyRuleBase mkRuleBaseextendRuleBaseList unionRuleBase pprRuleBase lookupRule initRuleOptsruleCheckProgram specProgram$fOutputableSpecEnv$fOutputableDictBind$fOutputableSpecArg$fOutputableCallInfo$fOutputableCallInfoSet$fOutputableUsageDetailsGHC.Types.TargetTargetGHC.Unit.Module.Graph ModuleGraphGHC.Unit.Finder.Types FinderCachespecConstrProgram$fOutputableValue$fOutputableHowBound$fOutputableCall$fOutputableArgOcc$fOutputableScUsage simplTopBinds simplExpr simplRulesTyConSetisEmptyTyConSet emptyTyConSet unitTyConSet mkTyConSetextendTyConSetListextendTyConSet unionTyConSetunionTyConSets minusTyConSet elemTyConSetdelFromTyConSetfilterTyConSetintersectTyConSetdisjointTyConSetdelListFromTyConSetintersectsTyConSet nameSetAny nameSetAllBitmapmkBitmapintsToReverseBitmapmAX_SMALL_BITMAP_SIZEPtrOpts po_profilepo_align_checkmkEmptyContInfoTable cmmToRawCmm srtEscapeclosureInfoPtr entryCode getConstrTagcmmGetClosureType infoTableinfoTableConstrTaginfoTableSrtBitmapinfoTableClosureType infoTablePtrsinfoTableNonPtrs funInfoTable funInfoAritystdInfoTableSizeWfixedInfoTableSizeWprofInfoTableSizeWmaxStdInfoTableSizeWmaxRetInfoTableSizeWstdInfoTableSizeBstdSrtBitmapOffsetstdClosureTypeOffset stdPtrsOffsetstdNonPtrsOffsetconInfoTableSizeBLDFARLDRLASTFARSTUSTCLISLIMRCMPLBCCBCCFARMTCTRBCTRBLBCTRLADDOADDCADDEADDZEADDISSUBFSUBFOSUBFCSUBFEMULLMULLOMFOVMULHUANDCNANDORISXORISEXTSCNTLZSLSRRLWINMCLRLICLRRIFCTIWZFCTIDZFCFIDFRSPCRNORMFCRMFLRHWSYNCISYNCLWSYNCstackFrameHeaderSizemakeFarBranchesFR frAllocateReg frGetFreeRegsfrInitFreeRegs frReleaseReg $fFRFreeRegs $fFRFreeRegs0 $fFRFreeRegs1 $fFRFreeRegs2CmmMakeDynamicReferenceM addImport ReferenceKind DataReference CallReference JumpReferencecmmMakeDynamicReferenceneedImportedSymbolspprGotDeclarationpprImportedSymbolinitializePicBase_ppcinitializePicBase_x86$fCmmMakeDynamicReferenceMNatM$fEqReferenceKindStatus ReachedBy ProcPoint ProcPointSetprocPointAnalysiscallProcPointsminimalProcPointSetsplitAtProcPointsattachContInfoTables$fOutputableStatusGHC.Parser.LexerTokenLanguage.Haskell.TH.Syntax dataToExpQ dataToPatQdataToQaPDunPDliftP failMsgPD getProfile getPtrOpts getHomeUnitId$fHasDynFlagsPD $fMonadPD$fApplicativePD $fFunctorPDCmmToken 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$fShowCmmTokennodeId nodeClass nodeColor nodeConflictsnodeExclusionsnodePreference nodeCoalescegraphMapTriv initGraphgraphMapModifynewNode trivColorable lookupNodegetNodeaddNodemodNodesizeunion addConflict delConflict addConflicts addExclusion addExclusions addCoalesce delCoalesce addPreference coalesceGraph coalesceNodes freezeNodefreezeOneInGraphfreezeAllInGraph scanGraph validateGraphslurpNodeConflictCountsetColor dumpGraphdotGraph colorGraph UnVarGraphUnVarSet emptyUnVarSet elemUnVarSetisEmptyUnVarSet delUnVarSet mkUnVarSet varEnvDomextendUnVarSet unionUnVarSetunionUnVarSetsemptyUnVarGraphunionUnVarGraphunionUnVarGraphscompleteBipartiteGraph completeGraph neighbors hasLoopAt$fOutputableUnVarSet$fOutputableUnVarGraph $fEqUnVarSetcprAnalProgram$fOutputableSigEnvcallArityAnalProgram callArityRHSconfigureHandleEncoding GHC.Hs.UtilsmkHsApp mkHsCaseAlt mkHsDictLet ppSourceStats compareFixity defaultFixity maxPrecedence negateFixityFixityDirectionInfixLInfixNInfixRInfixPrefix GHC.Tc.TypesgetEvBindsTcPluginMhasCompleteSig isPartialSigthLevelunsafeTcPluginTcM NameShape ns_exportsns_map ns_mod_nameTcIdTcIdSet TcIdSigInfo CompleteSig PartialSig psig_hs_ty psig_namesig_bndrsig_ctxtsig_loc TcIdSigInst TcPatSynInfoTPSIpatsig_body_typatsig_ex_bndrspatsig_implicit_bndrs patsig_name patsig_prov patsig_reqpatsig_univ_bndrs TcPluginMTcSigFun TcSigInfoTcIdSig TcPatSynSig TcTyThingAGlobal APromotionErrATcIdATcTyConATyVartct_idtct_infoGHC.Tc.Errors.Hole.FitTypes HoleFitPluginGHC.Tc.Types.Origin UserTypeCtxt extractDocsmkMapsgetMainDeclBinder sigNameNoLoc getInstLoc subordinates conArgDocs h98ConArgDocsgadtConArgDocs con_arg_docsisValD classDecls declTypeDocs nubByNametypeDocs sigTypeDocstopDeclsungroup collectDocs filterDecls filterClasses isUserSigmkDecls extractTHDocs unionArgMapsGHCi.RemoteTypes ForeignHValueHValue candPlugin fitPluginHoleFitPluginR hfPluginInit hfPluginRun hfPluginStopGHC.Utils.Binary putDictionaryHieName ExternalName LocalName KnownKeyName TyVarScopeResolvedScopesUnresolvedScopeScopeNoScope LocalScope ModuleScopeDeclTypeFamDecSynDecDataDecConDec PatSynDecClassDecInstDecBindType RegularBind InstanceBindRecFieldContext RecFieldDeclRecFieldAssign RecFieldMatch RecFieldOccIETypeImportImportAs ImportHidingExport EvBindDeps getEvBindDeps EvVarSource EvPatternBind EvSigBind EvWrapperBindEvImplicitBind EvInstBind EvLetBind isSuperInstcls ContextInfoUse MatchBindIEThingTyDeclValBind PatternBind ClassTyDeclDecl TyVarBindRecFieldEvidenceVarBindEvidenceVarUseIdentifierDetails identType identInfoNodeIdentifiers IdentifierNodeInfonodeAnnotationsnodeTypenodeIdentifiersNodeAnnotationnodeAnnotConstr nodeAnnotType NodeOrigin SourceInfo GeneratedInfoSourcedNodeInfogetSourcedNodeInfoHieASTsourcedNodeInfonodeSpan nodeChildrenHieASTsgetAstsHiePathHieArgs HieTypeFixRoll HieTypeFlatHieTypeHTyVarTyHAppTy HTyConApp HForAllTyHFunTyHQualTyHLitTyHCastTy HCoercionTy TypeIndexHieFile hie_hs_file hie_module hie_typeshie_asts hie_exports hie_hs_srcSpan hieVersion pprNodeIdents pprIdentifier pprBindSpan hieNameOcc toHieName$fBinaryHieArgs$fBinaryHieType$fBinaryNodeOrigin$fOutputableNodeOrigin$fBinaryNodeAnnotation$fOutputableNodeAnnotation$fOrdNodeAnnotation$fBinaryEvBindDeps$fOrdEvBindDeps$fEqEvBindDeps$fOutputableEvVarSource$fBinaryEvVarSource$fBinaryIEType$fOutputableIEType$fBinaryRecFieldContext$fOutputableRecFieldContext$fBinaryBindType$fOutputableBindType$fBinaryDeclType$fOutputableDeclType $fBinaryScope$fOutputableScope$fBinaryTyVarScope$fOutputableTyVarScope$fBinaryContextInfo$fOutputableContextInfo$fBinaryIdentifierDetails$fMonoidIdentifierDetails$fSemigroupIdentifierDetails$fOutputableIdentifierDetails$fOutputableNodeInfo$fBinaryNodeInfo$fOutputableSourcedNodeInfo$fBinarySourcedNodeInfo$fOutputableHieAST$fBinaryHieAST$fOutputableHieASTs$fBinaryHieASTs$fBinaryHieFile$fOutputableHieName $fOrdHieName $fEqHieName$fFunctorHieASTs$fFoldableHieASTs$fTraversableHieASTs$fFunctorHieAST$fFoldableHieAST$fTraversableHieAST$fFunctorSourcedNodeInfo$fFoldableSourcedNodeInfo$fTraversableSourcedNodeInfo$fFunctorNodeInfo$fFoldableNodeInfo$fTraversableNodeInfo$fEqIdentifierDetails$fFunctorIdentifierDetails$fFoldableIdentifierDetails$fTraversableIdentifierDetails$fEqContextInfo$fOrdContextInfo$fEqTyVarScope$fOrdTyVarScope $fEqScope $fOrdScope $fDataScope $fEqDeclType $fOrdDeclType$fEnumDeclType $fEqBindType $fOrdBindType$fEnumBindType$fEqRecFieldContext$fEnumRecFieldContext$fOrdRecFieldContext $fEqIEType $fEnumIEType $fOrdIEType$fEqEvVarSource$fOrdEvVarSource$fOutputableEvBindDeps$fEqNodeAnnotation$fEqNodeOrigin$fEnumNodeOrigin$fOrdNodeOrigin$fFunctorHieType$fFoldableHieType$fTraversableHieType $fEqHieType$fFunctorHieArgs$fFoldableHieArgs$fTraversableHieArgs $fEqHieArgs HieTypeStateHTStyMaphtyTable freshIndex EvidenceInfo evidenceVar evidenceSpan evidenceTypeevidenceDetailsRefMapgenerateReferencesMap renderHieTyperesolveVisibilityfoldType selectPointfindEvidenceUsegetEvidenceTreesAtPointgetEvidenceTreehieTypeToIface initialHTSfreshTypeIndex compressTypesrecoverFullType getTypeIndexresolveTyVarScopesresolveTyVarScopeLocalgetNameBinding getNameScopegetNameBindingInClassgetNameScopeAndBindinggetScopeFromContextgetBindSiteFromContext flattenAstsmallestContainingSatisfyingselectLargestContainedByselectSmallestContaining definedInAstsgetEvidenceBindDepsisEvidenceBindisEvidenceContext isEvidenceUse isOccurrencescopeContainsSpan combineAst insertAstnodeInfo emptyNodeInfosourcedNodeIdentscombineSourcedNodeInfocombineNodeInfo mergeAstsrightOfleftOf startsRightOf mergeSortAstssimpleNodeInfolocOnlymkScopeAmkScopemkLScope mkLScopeA mkLScopeN combineScopesmkSourcedNodeInfo makeNodeAmakeNode makeTypeNodeA makeTypeNode$fOutputableEvidenceInfo$fEqEvidenceInfo$fOrdEvidenceInfo$fFunctorEvidenceInfo DiffIdentDiffdiffFilediffAstsdiffAstnormalizeIdentsdiffListeqDiffvalidAstvalidateScopesfingerprintDynFlagsfingerprintOptFlagsfingerprintHpcFlagsupdateModDetailsIdInfos tcIfaceDeclstcIfaceCompleteMatchestcIfaceAnnotationstcIfaceFamInst tcIfaceInst tcIfaceRules tcIfaceDeclgetUnitLinkOptscollectLinkOptscollectArchivesgetLibsisStmt hasImportisImportisDeclhostPlatformArchhostPlatformOShostPlatformArchOSAnnoBodyrnStmtsrnLExprrnExpr GHC.BaseDir expandTopDir RawSettings maybeReadmaybeReadFuzzygetTargetArchOS getRawSettinggetRawFilePathSettinggetRawBooleanSettingreadRawSetting SettingsErrorSettingsError_MissingDataSettingsError_BadData initSettingsGHC.Stg.SyntaxLlStgAlt LlStgBinding LlStgExprLlStgRhsstgCse$fTrieMapStgArgMap$fTrieMapConAppMapcollectDebugInformation coreToStg$fHasDynFlagsCtsM $fMonadCtsM$fApplicativeCtsM $fFunctorCtsM $fEqHowBound $fEqLetInfo depSortStgPgmannTopBindingsFreeVarsannBindingFreeVarsGHC.Runtime.ContextInteractiveImportIIDeclIIModuleGHC.Runtime.Eval.TypesResumelintStgTopBindings $fMonadLintM$fApplicativeLintM$fFunctorLintM showStgStats$fEqCounterType$fOrdCounterTypenoWarnLookupIdSubstLiftM FloatLangStartBindingGroupEndBindingGroupPlainTopBinding LiftedBindingEnve_dflagse_subst e_expansionsdecomposeStgBinding mkStgBinding collectFloatsrunLiftMaddTopStringLitstartBindingGroupendBindingGroupaddLiftedBinding withSubstBndrwithSubstBndrswithLiftedBndrwithLiftedBndrssubstOccisLiftedformerFreeVars$fOutputableFloatLang$fMonadUniqueLiftM$fHasDynFlagsLiftM$fFunctorLiftM$fApplicativeLiftM $fMonadLiftMunarise$fOutputableUnariseVal baseRegOffsetget_GlobalReg_addrregTableOffsetget_Regtable_addr_from_offsetfixStgRegisters ClosureInfo closureName closureLFInfoclosureInfoLabelCallOpts co_profileco_loopificationco_ticky CallMethodEnterItJumpToItReturnItSlowCall DirectEntryDynTagNonVoid SelfLoopInfoCgLocCmmLocLneLoc isKnownFun fromNonVoid nonVoidIdsassertNonVoidIdsnonVoidStgArgsassertNonVoidStgArgs idPrimRep addIdReps addArgReps argPrimRep mkLFArgumentmkLFLetNoEscape mkLFReEntrant mkLFThunk mkConLFInfomkSelectorLFInfo mkApLFInfo mkLFImported mkLFStringLit isSmallFamily tagForCon tagForAritylfDynTag isLFThunk isLFReEntrantnodeMustPointToIt getCallMethod mkCmmInfo mkClosureInfoblackHoleOnEntryisStaticClosureclosureUpdReqd lfUpdatableclosureReEntrantclosureFunInfofunTagisToplevClosurestaticClosureLabelclosureSlowEntryLabelclosureLocalEntryLabelmkDataConInfoTablecafBlackHoleInfoTableindStaticInfoTablestaticClosureNeedsLink$fOutputablePPlatformCgLoc$fOutputableNonVoid $fEqNonVoid $fShowNonVoidArgRepPNVFDV16V32V64 argRepStringtoArgRepisNonV argRepSizeWidArgRepslowCallPattern$fOutputableArgRepVirtualHpOffset HeapUsagevirtHprealHpCgState MkCgState cgs_stmtscgs_tops cgs_binds cgs_hp_usg cgs_uniqs ReturnKindAssignedDirectly ReturnedToSequelReturnAssignToCgIdInfocg_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 newUniquenewTemp getInfoDown getSelfLoop withSelfLoop getCallOpts getModuleName withSequel getSequelwithUpdFrameOffgetUpdFrameOffgetTickyCtrLabelsetTickyCtrLabel getTickScope tickScopeforkClosureBody forkLneBodycodeOnlyforkAlts forkAltPairgetCodeRgetCode getCodeScoped getHeapUsage emitLabel emitCommentemitTick emitUnwind emitAssign emitStoreemitemitDecl emitOutOfLineemitProcWithStackFrameemitProcWithConventiongetCmmmkCmmIfThenElsemkCmmIfThenElse' mkCmmIfGoto mkCmmIfGoto' mkCmmIfThen mkCmmIfThen'mkCall mkCmmCall aGraphToGraph$fOutputablePPlatformCgIdInfo$fOutputableSequel$fHasDynFlagsFCode$fMonadUniqueFCode $fMonadFCode$fApplicativeFCode$fFunctorFCodeCmmParseunECNamedVarNFunNLabelN loopDeclsgetEnvwithNamenewLocalnewLabelnewFunctionName newImport lookupLabel lookupNamecode$fHasDynFlagsCmmParse$fMonadUniqueCmmParse$fMonadCmmParse$fApplicativeCmmParse$fFunctorCmmParse litIdInfo lneIdInfo rhsIdInfo mkRhsInit idInfoToAmodemaybeLetNoEscapeaddBindC addBindsC getCgIdInfo bindToReg rebindToReg bindArgToRegbindArgsToRegsidToReg newStringCLitnewByteStringCLitcgLit mkSimpleLitcgBind addToMemLbl addToMemLblEaddToMem addToMemEmkTaggedObjectLoad tagToClosure emitRtsCallemitRtsCallWithResultemitRtsCallGencallerSaveVolatileRegscallerSaveGlobalRegcallerRestoreGlobalReg emitDataLitsemitRODataLits emitDataCon assignTempnewUnboxedTupleRegsemitMultiAssign emitSwitchemitCmmLitSwitchwhenUpdRemSetEnabledemitUpdRemSetPushemitUpdRemSetPushThunkcmmInfoTableToInfoProvEntconvertInfoProvMapwithNewTickyCounterFunwithNewTickyCounterLNEwithNewTickyCounterThunkwithNewTickyCounterStdThunkwithNewTickyCounterContickyPushUpdateFrametickyUpdateFrameOmittedtickyEnterDynContickyEnterThunktickyUpdateBhCaf tickyEnterFun tickyEnterLNEtickyReturnOldContickyReturnNewContickyUnboxedTupleReturntickyDirectCall tickySlowCall tickyDynAlloctickyAllocHeaptickyAllocPrimtickyAllocThunk tickyAllocPAPtickyHeapChecktickyStackCheck ClosureHeaderNoHeader StdHeader ThunkHeaderFieldOffOrPaddingFieldOffPadding emitReturnemitCalladjustHpBackwards directCallslowCallgetHpRelOffsetmkVirtHeapOffsetsWithPaddingmkVirtHeapOffsetsmkVirtConstrOffsetsmkVirtConstrSizes mkArgDescr getArgAmodegetNonVoidArgAmodesemitClosureProcAndInfoTableemitClosureAndInfoTable BinderInfo BindsClosure BoringBinderSkeleton ClosureSkRhsSkAltSkBothSkNilSkbinderInfoBndrtagSkeletonTopBind goodToLift closureGrowth$fOutputableSkeleton$fOutputableBndrBinderInfo$fOutputableBinderInfo stgLiftLamsstg2stg$fMonadUniqueStgM $fEqStgToDo $fFunctorStgM$fApplicativeStgM $fMonadStgM $fMonadIOStgMBCInstrSTKCHECKPUSH_LPUSH_LLPUSH_LLLPUSH8PUSH16PUSH32PUSH8_WPUSH16_WPUSH32_WPUSH_G PUSH_PRIMOPPUSH_BCO PUSH_ALTSPUSH_ALTS_UNLIFTEDPUSH_ALTS_TUPLE 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_PCASEFAILCCALLSWIZZLEENTERRETURN RETURN_UBX RETURN_TUPLEBRK_FUN LocalLabel getLocalLabelProtoBCO protoBCONameprotoBCOInstrsprotoBCOBitmapprotoBCOBitmapSize protoBCOArity protoBCOExpr protoBCOFFIs bciStackUse$fOutputableLocalLabel$fOutputableBCInstr$fOutputableProtoBCO$fEqLocalLabel$fOrdLocalLabel mkTickBoxinitHpcArchive ArchiveEntryfilenamefiletimefileownfilegrpfilemodefilesizefiledataafilter isBSDSymdef isGNUSymdefparseAr writeBSDAr writeGNUArloadArloadObj $fEqArchive $fShowArchive$fSemigroupArchive$fMonoidArchive$fEqArchiveEntry$fShowArchiveEntry BuildMessageBuildMsg BuildErrorEOFenableProcessJobs hGetContents'readCreateProcessWithExitCode' replaceVarreadProcessEnvWithExitCode c_locale_env getGccEnv runSomethingrunSomethingResponseFilerunSomethingFilteredrunSomethingWith handleProcbuilderMainLoop readerProc parseError breakColon breakIntColon linesPlatformneededLinkArgs getLinkerInfogetLinkerInfo'getCompilerInfogetCompilerInfo'findValidHoleFits ClassSCCtxt ConArgCtxt DataKindCtxt DataTyCtxtDefaultDeclCtxtDerivClauseCtxt ExprSigCtxt ForSigCtxt FunSigCtxt GenSigCtxtGhciCtxt InfSigCtxt InstDeclCtxt KindSigCtxt PatSigCtxt PatSynCtxt RuleSigCtxt SigmaCtxt SpecInstCtxtStandaloneKindSigCtxtTyFamResKindCtxt TySynCtxt TySynKindCtxtTyVarBndrKindCtxt TypeAppCtxt tcSyntaxOpGen tcSyntaxOp tcInferRho tcInferRhoNCtcExpr tcPolyExprtcCheckMonoExprtcCheckMonoExprNC tcMonoExpr tcMonoExprNCtcCheckPolyExprtcCheckPolyExprNC tcMatchesFun tcGRHSsPatfinishTHrunRemoteModFinalizersrunQuasilookupThName_mayberunMetaDrunMetaTrunMetaPrunMetaEtcTopSpliceExpr runAnnotation runTopSplicetcTypedBrackettcUntypedBracket tcSpliceExpr FunDepEqnFDEqnfd_qtvsfd_eqsfd_pred1fd_pred2fd_locimproveFromAnother pprEquationimproveFromInstEnvcheckInstCoverage checkFunDeps$fOutputableFunDepEqnbadReexportedBootThingmissingBootThingcheckBootDeclMevDelayedError evCallStack tcInitTidyEnvIsExtraConstraintYesExtraConstraintNoExtraConstraintinitTc initTcWithGblinitTcInteractive initTcRnIf discardResult getTopEnv updTopEnv getGblEnv updGblEnv setGblEnv getLclEnv updLclEnv setLclEnvgetEnvssetEnvsxoptMdoptMgoptMwoptMsetXOptM unsetXOptM unsetGOptM unsetWOptM whenDOptM whenGOptM whenWOptM whenXOptM unlessXOptM getGhcModewithoutDynamicNow getEpsVargetEps updateEps updateEps_getHpt getEpsAndHpt withException newArrowScopeescapeArrowScopenewUniqueSupplycloneLocalNamenewName newNameAt newSysName newSysLocalIdnewSysLocalIdsnewTcRef readTcRef writeTcRefupdTcReftraceTctraceRn traceOptTcRn dumpOptTcRndumpTcRngetPrintUnqualifiedprintForUserTcRntraceIf traceOptIf getIsGHCi getGHCiMonadgetInteractivePrintNametcIsHsBootOrSigtcIsHsigtcSelfBootInfogetGlobalRdrEnv getRdrEnvs getImports getFixityEnvextendFixityEnvgetRecFieldEnvgetDeclaredDefaultTysaddDependentFiles getSrcSpanMinGeneratedCode setSrcSpan setSrcSpanAaddLocMaddLocMAwrapLocM wrapLocAM wrapLocMA wrapLocFstM wrapLocFstMA wrapLocSndM wrapLocSndMA wrapLocM_ wrapLocMA_ getErrsVar setErrsVaraddErrfailWithfailAtaddErrAtaddErrscheckErr addMessagesdiscardWarnings mkLongErrAtmkDecoratedSDocAt addLongErrAtreportDiagnosticsreportDiagnostic checkNoErrs whenNoErrsifErrsM failIfErrsM getErrCtxt setErrCtxt addErrCtxt addErrCtxtMaddLandmarkErrCtxtaddLandmarkErrCtxtM popErrCtxt getCtLocM setCtLocM askNoErrstryCaptureConstraintscaptureConstraintstcCollectingUsagetcScalingUsagetcEmitBindingUsageattemptMrecoverMmapAndRecoverM mapAndReportMfoldAndRecoverMtryTc discardErrstryTcDiscardingErrsaddErrTc addErrTcM failWithTc failWithTcMcheckTccheckTcMfailIfTc failIfTcM warnIfFlagwarnIf diagnosticTc diagnosticTcMaddDiagnosticTcaddDiagnosticTcM addDiagnosticaddDiagnosticAtadd_diagnostic mkErrInfodebugTc addTopEvBinds newTcEvBindsnewNoTcEvBindscloneEvBindsVargetTcEvTyCoVarsgetTcEvBindsMapsetTcEvBindsMap addTcEvBindchooseUniqueOccTcgetConstraintVarsetConstraintVaremitStaticConstraintsemitConstraints emitSimple emitSimplesemitImplicationemitImplications emitInsolubleemitHole emitHolesdiscardConstraintspushLevelAndCaptureConstraints pushTcLevelM_ pushTcLevelM pushTcLevelsM getTcLevel setTcLevelisTouchableTcM getLclTypeEnv setLclTypeEnvtraceTcConstraintsemitAnonTypeHoleemitNamedTypeHole recordThUserecordThSpliceUse keepAlivegetStagegetStageAndBindLevelsetStageaddModFinalizersWithLclEnvrecordUnsafeInfer finalSafeModefixSafeInstancesgetLocalRdrEnvsetLocalRdrEnv mkIfLclEnv initIfaceTcRn initIfaceLoadinitIfaceCheck initIfaceLclinitIfaceLclWithSubst getIfModulefailIfM forkM_maybeforkMsetImplicitEnvM getCCIndexM getCCIndexTcMtargetAllowObjCodetargetContentstargetId targetUnitIdTargetId TargetFile TargetModuleGHC.Driver.PhasesPhaseemptyMGmapMGmgLookupModulemgModSummaries mkModuleGraphneedsTemplateHaskellOrQQGHC.Unit.Module.ModSummary ModSummaryGHC.Types.Name.CachelookupOrigNameCache FindResultFound FoundMultiple NoPackageNotFoundfr_mods_hiddenfr_pathsfr_pkgfr_pkgs_hiddenfr_suggestions fr_unusablesInstalledFindResultInstalledFoundInstalledNoPackageInstalledNotFoundGHC.Linker.TypesLoaderGHC.Driver.MonadGhcGHC.Driver.Pipeline.Monad PhasePlus CompPipeline$fMonadUniqueIOEnv$fOutputableIsExtraConstraint ms_home_impsms_home_srcimps ms_mod_name ms_hie_date ms_hs_date ms_hsc_src ms_hspp_buf ms_hspp_file ms_hspp_opts ms_iface_date ms_locationms_mod ms_obj_date ms_parsed_mod ms_srcimpsms_textual_imps getPipeEnv getPipeState setDynFlagssetModLocationunPHscOut RealPhasePipeEnv output_spec src_basename src_filename src_suffix stop_phase PipeState foreign_oshsc_enviface maybe_locGHC.Unit.Module.Status HscStatus tcAnnotationsannCtxt WhereLookingWL_Any WL_Global WL_LocalTop WL_LocalOnlymkUnboundNameRdrreportUnboundName unboundName unboundNameX notInScopeErrunknownNameSuggestions exactNameErrrnTopSpliceDecls rnSpliceDecl rnSplicePat rnSpliceTypeloadSysInterfacenewGlobalBindernewInteractiveBinderallocateGlobalBinderifaceExportNames lookupOrig lookupOrigIOexternaliseName setNameModule tcIfaceLclIdextendIfaceIdEnv tcIfaceTyVarlookupIfaceTyVarlookupIfaceVarextendIfaceTyVarEnvextendIfaceEnvslookupIfaceTop newIfaceName newIfaceNamestrace_iftrace_hi_diffsMethInfo TcMethInfo mkNewTyConRhs buildDataCon buildPatSyn buildClassnewImplicitBindernewTyConRepName BinDictionary bin_dict_next bin_dict_mapBinSymbolTablebin_symtab_nextbin_symtab_map TraceBinIFace QuietBinIFace CheckHiWay IgnoreHiWay readBinIfacegetWithUserData writeBinIfaceputWithUserDataputSymbolTablegetSymbolTableputName getSymtabName putFastStringgetDictFastString$fEqCheckHiWay HieHeader HieFileResulthie_file_result_versionhie_file_result_ghc_versionhie_file_resulthieMagic writeHieFilereadHieFileWithVersion readHieFile tcSubMult unifyKind unifyTypeCandidatesQTvsDVdv_kvsdv_tvsdv_cvsnewMetaKindVarnewMetaKindVars newEvVarsnewEvVar newWanted newWanteds cloneWantedcloneWC emitWantedemitDerivedEqs emitWantedEqemitWantedEvVaremitWantedEvVarsemitNewExprHolenewDictnewImplicationnewCoercionHolefillCoercionHoleisFilledCoercionHoleunpackCoercionHoleunpackCoercionHole_maybecheckCoercionHolenewInferExpTypereadExpType_maybereadScaledExpType readExpTypecheckingExpType_maybecheckingExpTypescaledExpTypeToType expTypeToTypeinferResultToTypetcInferfillInferResult promoteTcTypenewMetaTyVarNamenewAnonMetaTyVarnewSkolemTyVar newTyVarTyVarcloneTyVarTyVarnewPatSigTyVarnewCycleBreakerTyVarnewMetaDetailsnewTauTvDetailsAtLevelcloneMetaTyVar readMetaTyVarisFilledMetaTyVar_maybeisFilledMetaTyVarisUnfilledMetaTyVarwriteMetaTyVarwriteMetaTyVarRefnewMultiplicityVar newFlexiTyVarnewNamedFlexiTyVarnewFlexiTyVarTynewFlexiTyVarTysnewOpenTypeKindnewOpenFlexiTyVarTynewOpenFlexiTyVarnewOpenBoxedTypeKind newMetaTyVarsnewMetaTyVarsX newMetaTyVarXnewMetaTyVarTyVarX newWildCardXnewMetaTyVarTyAtLevelcandidateKindVarspartitionCandidatescandidateQTyVarsOfTypecandidateQTyVarsOfTypescandidateQTyVarsOfKindcandidateQTyVarsOfKinds delCandidatesquantifyTyVarsisQuantifiableTvzonkAndSkolemiseskolemiseQuantifiedTyVar defaultTyVarskolemiseUnboundMetaTyVardoNotQuantifyTyVarspromoteMetaTyVarTopromoteTyVarSetzonkTcTypeAndFVzonkTyCoVarsAndFVzonkDTyCoVarSetAndFVzonkTyCoVarsAndFVList zonkTcTyVarszonkTyCoVarKindzonkTyCoVarKindBinderzonkImplication zonkEvVarzonkWC zonkSimpleszonkCtzonkSkolemInfo zonkTcType zonkTcTypeszonkCo zonkTcTyVarzonkTcTyVarToTyVarzonkInvisTVBinderzonkId zonkCoVarzonkTidyTcTypezonkTidyTcTypeszonkTidyOrigintidyCttidyHole tidyEvVartidySkolemInfoensureNotLevPolycheckForLevPolycheckForLevPolyXformatLevPolyErr$fOutputableCandidatesQTvs$fMonoidCandidatesQTvs$fSemigroupCandidatesQTvsconvertToHsDeclsconvertToHsExpr convertToPatconvertToHsTypethRdrNameGuesses $fMonadCvtM$fApplicativeCvtM$fCvtFlagSpecificitySpecificity $fCvtFlag()() $fFunctorCvtMemptyNameShape mkNameShapeextendNameShapenameShapeExportssubstNameShapemaybeSubstNameShape tcRnModIfacetcRnModExports rnModIface rnModExportsUniqSDFM emptyUSDFM lookupUSDFM equateUSDFM addToUSDFM traverseUSDFM$fOutputableShared$fOutputableUniqSDFMuninitializedLoader loader_state LoaderState bcos_loaded closure_envitbl_env objs_loaded pkgs_loadedtemp_sosinitFinderCacheflushFinderCachesfindImportedModulefindPluginModulefindExactModulefindExposedPackageModuleaddHomeModuleToFinder uncacheModulefindHomeModulemkHomeModLocationmkHomeModLocation2mkHiOnlyModLocation mkObjPathmkHiPath mkStubPathsfindObjectLinkableMaybefindObjectLinkableGHC.Types.SourceErrorhandleSourceErrortcLookupImported_maybe importDeclcheckWiredInTyConifCheckWiredInThingneedWiredInHomeIfaceloadSrcInterfaceloadSrcInterface_maybeloadModuleInterfaceloadModuleInterfacesloadInterfaceForNameloadInterfaceForNameMaybeloadInterfaceForModuleloadWiredInHomeIfaceloadUserInterfaceloadPluginInterface loadInterfacemoduleFreeHolesPrecisefindAndReadIface writeIface readIfaceinitExternalPackageState ifaceStats showIfacepprModIfaceSimple pprModIfacecannotFindModule$fOutputableWarnings InstBindings ib_tyvarsib_binds ib_pragmas ib_extensions ib_derivedInstInfoiSpeciBinds lookupGlobalioLookupDataConaddTypecheckedBindstcLookupLocatedGlobaltcLookupGlobaltcLookupGlobalOnlytcLookupDataContcLookupPatSyntcLookupConLike tcLookupClass tcLookupTyCon tcLookupAxiomtcLookupLocatedGlobalIdtcLookupLocatedClasstcLookupLocatedTyContcLookupInstance tcGetInstEnvssetGlobalTypeEnvtcExtendGlobalEnvImplicittcExtendGlobalEnvtcExtendTyConEnvtcExtendGlobalValEnvtcExtendRecEnvtcLookupLocatedtcLookupLcl_maybetcLookup tcLookupTyVar tcLookupIdtcLookupIdMaybetcLookupLocalIdstcLookupTcTyCongetInLocalScopetcExtendKindEnvListtcExtendKindEnvtcExtendTyVarEnvtcExtendNameTyVarEnvisTypeClosedLetBndrtcExtendRecIdstcExtendSigIdstcExtendLetEnv tcExtendIdEnvtcExtendIdEnv1tcExtendIdEnv2tcExtendLocalTypeEnv tcCheckUsagetcExtendBinderStacktcInitOpenTidyEnvtcAddDataFamConPlaceholderstcAddPatSynPlaceholdersgetTypeSigNames tcExtendRulescheckWellStagedtopIdLvltcMetaTy isBrackStagetcGetDefaultTysiDFunIdpprInstInfoDetailssimpleInstInfoClsTysimpleInstInfoTysimpleInstInfoTyCon newDFunNamenewFamInstTyConNamenewFamInstAxiomNamemkStableIdFromStringmkStableIdFromName mkWrapperName pprBinders wrongThingErr$fMonadThingsIOEnv$fOutputableInstInfo ZonkFlexi DefaultFlexiSkolemiseFlexiRuntimeUnkFlexiNoFlexiZonkEnv hsLPatType hsPatType hsLitType tcShortCutLit shortCutLit hsOverLitName emptyZonkEnvmkEmptyZonkEnv initZonkEnv zonkTopBndrs zonkTyBndrs zonkTyBndrsXzonkTyVarBindersXzonkTyVarBinderX zonkTopExpr zonkTopLExpr zonkTopDecls zonkTcEvBinds zonkEvBinds zonkTyVarOcclookupTyVarOcczonkTcTypeToTypezonkTcTypeToTypeXzonkTcTypesToTypesX zonkCoToCozonkScaledTcTypesToTypesXzonkTcMethInfoToMethInfoX$fOutputableZonkEnvnewMethodFromName topSkolemisetopInstantiateinstantiateSigmainstTyVarsWithinstCallinstCallConstraints instDFunTypeinstStupidThetatcInstInvisibleTyBinderstcInstInvisibleTyBindersNtcInstInvisibleTyBinder tcInstTypetcInstTypeBndrstcSkolDFunTypetcSuperSkolTyVarstcInstSkolTyVarstcInstSkolTyVarsXtcInstSuperSkolTyVarsXtcInstSkolTyVarsAtfreshenTyVarBndrsfreshenCoVarBndrsXnewOverloadedLit mkOverLit tcSyntaxNamegetOverlapFlag tcGetInsts newClsInsttcExtendLocalInstEnvAreTypeFamiliesOKYesTypeFamiliesNoTypeFamiliesCheckTyEqResultCTE_OKCTE_BadCTE_HoleBlocker CTE_OccursmatchActualFunTySigmamatchActualFunTysRhomatchExpectedFunTysmatchExpectedListTymatchExpectedTyConAppmatchExpectedAppTy tcWrapResult tcWrapResultOtcWrapResultMonounifyExpectedType tcSubTypePat tcSubTypetcSubTypeSigmatcSkolemiseScoped tcSkolemise tcSkolemiseETcheckConstraintscheckTvConstraintsemitResidualTvConstraintbuildTvImplicationbuildImplicationForuTypecanSolveByUnificationswapOverTyVarsmatchExpectedFunKindoccCheckForErrors checkTyVarEq checkTyFamEq checkTypeEq$fOutputableCheckTyEqResult$fMonoidCheckTyEqResult$fSemigroupCheckTyEqResult$fOutputableAreTypeFamiliesOK$fEqAreTypeFamiliesOKmkTypeableBindstyConIsTypeable$fFunctorKindRepM$fApplicativeKindRepM$fMonadKindRepM HsDocContext TypeSigCtxStandaloneKindSigCtxPatCtxSpecInstSigCtxDefaultDeclCtxForeignDeclCtx DerivDeclCtxRuleCtx TyDataCtxTySynCtx TyFamilyCtx FamPatCtx ConDeclCtx ClassDeclCtxExprWithTySigCtxTypBrCtx HsTypeCtx HsTypePatCtxGHCiCtx SpliceTypeCtxClassInstanceCtx GenericCtxnewLocalBndrRnnewLocalBndrsRnbindLocalNamesbindLocalNamesFVcheckDupRdrNamescheckDupRdrNamesN checkDupNamescheckShadowedRdrNamescheckDupAndShadowedNamescheckInferredVarsnoNestedForallsContextsErraddNoNestedForallsContextsErraddFvRnmapFvRn mapMaybeFvRnwarnUnusedTopBindscheckUnusedRecordWildcardwarnUnusedLocalBindswarnUnusedMatcheswarnUnusedTypePatterns mkFieldEnvaddNameClashErrRnunknownSubordinateErr dupNamesErrbadQualBndrErr typeAppErr checkTupSize checkCTupSizewithHsDocContextinHsDocContextpprHsDocContextthNameToGhcName$fMonadThingsCoreMsptCreateStaticBindssptModuleInitCodemkBootModDetailsTc tidyProgram $fMonadDFFV$fApplicativeDFFV $fFunctorDFFV corePrepPgm corePrepExprmkConvertNumLiteral$fOutputableFloatingBind$fOutputableOkToSpec$fOutputableFloatscheckFamInstConsistencytcInstNewTyCon_maybetcLookupDataFamInsttcLookupDataFamInst_maybetcTopNormaliseNewTypeTF_maybetcExtendLocalFamInstEnvreportInjectivityErrors reportConflictingInjectivityErrstcGetFamInstEnvsreportUnsolvedreportAllUnsolvedwarnAllUnsolvedwarnDefaultingsolverDepthErrorTcS$fMonoidReport$fSemigroupReport$fOutputableReport$fOutputableReportErrCtxt MiniFixityEnvaddLocalFixitieslookupFixityRnlookupFixityRn_helplookupTyFixityRnlookupFieldFixityRn HsSigCtxt TopSigCtxt LocalBindCtxt ClsDeclCtxt HsBootCtxt RoleAnnotCtxtAmbiguousResultUnambiguousGreAmbiguousFieldsChildLookupResult NameNotFoundIncorrectParent FoundChildnewTopSrcBinderlookupTopBndrRnlookupLocatedTopBndrRnlookupLocatedTopBndrRnNlookupInstDeclBndrlookupFamInstNamelookupConstructorFieldslookupRecFieldOcclookupRecFieldOcc_updatelookupSubBndrOcc_helpercombineChildLookupResultlookupLocatedOccRnlookupLocalOccRn_maybelookupLocalOccThLvl_maybe lookupOccRnlookupLocalOccRnlookupTypeOccRnlookupOccRn_maybelookupExprOccRnlookupGlobalOccRn_maybelookupGlobalOccRnlookupInfoOccRnlookupGreAvailRnaddUsedDataCons addUsedGRE addUsedGREslookupSigOccRnlookupSigOccRnNlookupSigCtxtOccRnNlookupSigCtxtOccRnlookupLocalTcNames dataTcOccslookupIfThenElselookupSyntaxNamelookupSyntaxExpr lookupSyntaxlookupSyntaxNameslookupQualifiedDoExprlookupQualifiedDolookupNameWithQualifierlookupQualifiedDoName$fMonoidDisambigInfo$fSemigroupDisambigInfo$fOutputableDisambigInfo$fOutputableChildLookupResult$fOutputableHsSigCtxt$fEqFieldsOrSelectors InstanceWhatBuiltinInstanceBuiltinEqInstance 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 safeOverlapinstanceReturnsDictConmatchGlobalInst$fOutputableInstanceWhat$fOutputableClsInstResultMaybeNewFreshCachedTcSDictMap EqualCtList InertCansIC inert_eqs inert_funeqs inert_dicts inert_instsinert_safehask inert_irredsinert_given_eq_lvlinert_given_eqsInertSetIS inert_cansinert_cycle_breakersinert_famapp_cacheinert_solved_dictsWorkListWLwl_eqswl_rest wl_implicsappendWorkList workListSizeextendWorkListEqextendWorkListNonEqextendWorkListCtextendWorkListCtsisEmptyWorkList emptyWorkList getWorkListselectNextWorkItem emptyInert isImprovable foldTyEqs findTyEqsfindEqaddInertForAll addInertCankickOutAfterUnificationaddInertSafehaskinsertSafeOverlapFailureTcSgetSafeOverlapFailures addSolvedDictgetSolvedDictssetSolvedDicts updInertTcS getInertCans setInertCans updInertCans updInertDictsupdInertSafehaskupdInertIrreds getInertEqsgetInnermostGivenEqLevelgetInertInsolsgetInertGivensgetPendingGivenScsgetUnsolvedInertsgetHasGivenEqsmatchableGivensmightEqualLaterprohibitedSuperClassSolveremoveInertCtslookupFamAppInertlookupInertDictlookupSolvedDictlookupFamAppCacheextendFamAppCache foldIrreds emptyDictMapfindDictfindDictsByClassdelDictaddDictaddDictsByClass filterDicts foldDicts findFunEqfindFunEqsByTyCon insertFunEqwrapTcS wrapErrTcS wrapWarnTcSfailTcSwarnTcS addErrTcSpanicTcStraceTcSrunTcPluginTcSgetGlobalRdrEnvTcSbumpStepCountTcS csTraceTcS traceFireTcSrunTcSrunTcSDerivedsrunTcSEqualities runTcSInertsrunTcSWithEvBinds setEvBindsTcS nestImplicTcSnestTcSemitImplicationTcSemitTvImplicationTcS getTcSInerts setTcSInertspushLevelNoWorkListupdWorkListTcS emitWorkNCemitWorkgetTcEvBindsVar unifyTyVarreportUnificationsgetDefaultInfo getInstEnvsgetFamInstEnvscheckWellStagedDFunpprEq pprKickedresetUnificationFlagsetUnificationFlag newFlexiTcSTy instFlexi instFlexiXisFresh freshGoals getEvExpr setEvBind setWantedEqsetWantedEvTermsetEvBindIfWanted newGivenEvVarnewBoundEvVarIdnewGivenEvVarsemitNewWantedEq newWantedEqnewWantedEq_SInewWantedEvVarNCnewWantedEvVar newWanted_SI newWantedNCemitNewDerivedsemitNewDerivedEq newDerivedNCcheckReductionDepthmatchFam matchFamTcMbreakTyVarCycle rewriterView$fOutputableWorkList$fOutputableInertCans$fOutputableInertSet$fHasDynFlagsTcS$fMonadThingsTcS$fHasModuleTcS$fMonadUniqueTcS$fMonadFailTcS $fMonadTcS$fApplicativeTcS $fFunctorTcS$fOutputableEqualCtListrewrite rewriteKindrewriteArgsNom rewriteType$fHasDynFlagsRewriteM$fApplicativeRewriteM$fMonadRewriteM$fFunctorRewriteMStopOrContinue ContinueWithUnifyTestResultUnifySameLevelUnifyOuterLevelNoUnify canonicalizesolveCallStackmakeSuperClasses unifyTest continueWithstopWithandWhenContinue unifyDerived$fOutputableUnifyTestResult$fOutputableCanEqOK$fOutputableStopOrContinue$fFunctorStopOrContinue tcPluginIO tcPluginTraceisTouchableTcPluginM newDerivednewGiven PmAltConSetPmAltCon PmAltConLikePmAltLit PmEqualityEqualDisjointPossiblyOverlap PmLitValuePmLitIntPmLitRat PmLitChar PmLitString PmLitOverInt PmLitOverRatPmLitOverStringPmLit pm_lit_ty pm_lit_valResidualCompleteMatchesRCM rcm_vanilla rcm_pragmasBotInfoIsBotIsNotBotMaybeBot PmAltConAppPACApaca_conpaca_tvspaca_idsVarInfoVIvi_idvi_posvi_negvi_botvi_rcmTmStateTmStts_factsts_repsts_dirtyTyStateTyStty_st_n ty_st_inertNablasMkNablasNablaMkNabla nabla_ty_st nabla_tm_st initNablasgetRcmisRcmInitialised pmLitTypeemptyPmAltConSetisEmptyPmAltConSetelemPmAltConSetextendPmAltConSetpmAltConSetElems eqPmAltCon pmAltConTypeisPmAltConMatchStrictpmAltConImplBangsliteralToPmLit negatePmLit overloadPmLitpmLitAsStringLitcoreExprAsPmLit$fOutputableTyState$fOutputableBotInfo#$fOutputableResidualCompleteMatches$fOutputablePmLitValue$fOutputablePmLit$fOutputablePmEquality $fEqPmLit$fOutputablePmAltCon $fEqPmAltCon$fOutputablePmAltConApp$fOutputablePmAltConSet$fOutputableVarInfo$fOutputableTmState$fOutputableNabla$fMonoidNablas$fSemigroupNablas$fOutputableNablas$fEqPmEquality$fShowPmEquality $fEqBotInfoPostPre CheckResultcr_retcr_uncov cr_approxRedSetsrs_covrs_divrs_bangs Precision ApproximatePrecise PmPatBind PmEmptyCasepe_varPmGRHSpg_grdspg_rhsPmGRHSspgs_lcls pgs_grhssPmMatchpm_patspm_grhss PmMatchGroupGrdVecSrcInfoPmGrdPmConPmBangPmLetpm_id pm_con_con pm_con_tvs pm_con_dicts pm_con_args_pm_loc _pm_let_expr$fOutputableSrcInfo$fOutputablePmGrd$fOutputableGrdVec$fOutputablePmGRHS$fOutputablePmGRHSs$fOutputablePmMatch$fOutputablePmMatchGroup$fOutputablePmEmptyCase$fOutputablePmPatBind$fMonoidPrecision$fSemigroupPrecision$fOutputablePrecision$fOutputableRedSets$fOutputableCheckResult$fFunctorCheckResult $fEqPrecision$fShowPrecisionDsM DsMetaValDsBoundDsSplice DsMetaEnvDsLclEnvdsl_metadsl_loc dsl_nablasDsGblEnvds_modds_fam_inst_envds_gbl_rdr_env ds_unqualds_msgs ds_if_envds_complete_matchesds_cc_st$fContainsModuleDsGblEnvsolveSimpleGivenssolveSimpleWanteds$fOutputableInteractResult InferModeApplyMREagerDefaultingNoRestrictionscaptureTopConstraintssimplifyTopImplic simplifyToppushLevelAndSolveEqualitiespushLevelAndSolveEqualitiesXsolveEqualitiessimplifyAndEmitFlatConstraintsreportUnsolvedEqualitiessimplifyTopWantedssimplifyAmbiguityChecksimplifyInteractivesimplifyDefault tcCheckGivenstcCheckWanteds tcNormalise simplifyInferfindInferredDiffgrowThetaTyVarssimplifyWantedsTcMsolveWantedsAndDrop solveWanteds approximateWC$fOutputableInferModeRankcheckValidTypecheckValidMonoType checkTySynRhscheckValidThetaarityErrcheckValidInstHeadvalidDerivPredcheckValidInstancecheckValidCoAxiomcheckValidCoAxBranchcheckValidTyFamEqncheckValidAssocTyFamDefltbadATErrcheckTyConTelescopeallDistinctTyVars$fOutputableRank$fOutputableTypeOrKindCtxt$fOutputableExpandMode$fOutputableValidityEnv$fEqTypeOrKindCtxt DerivStuff DerivAuxBind DerivFamInst 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_ExprgetPossibleDataConstyConInstArgTys$fEqSortingAlg$fOrdSortingAlgImportDeclUsage rnImportscalculateAvailsextendGlobalRdrEnvRngetLocalNonValBindersnewRecordSelector mkChildEnv findChildrenreportUnusedNamesfindImportUsagegetMinimalImportsprintMinimalImportsdodgyMsgdodgyMsgInsert checkConName rnExportsexports_from_avail FreeKiTyVarsWarnUnusedForallsNoWarnUnusedForallsHsPatSigTypeScoping AlwaysBind NeverBind rnHsSigWcTypernHsPatSigType rnHsWcTypernHsPatSigTypeBindingVars rnHsSigTypernImplicitTvOccs rnLHsType rnLHsTypesrnScaledLHsTypernHsType rnLHsKindrnHsKind rnLHsTypeArgs rnContextrnLTyVarbindSigTyVarsFV bindHsQTyVarsbindHsOuterTyVarBndrsbindHsForAllTelescopebindLHsTyVarBndrsbindLHsTyVarBndrnewTyVarNameRnrnConDeclFields lookupField mkOpAppRn mkNegAppRn mkOpFormRn mkConOpPatRncheckPrecMatchcheckSectionPrecextractHsTyArgRdrKiTyVarsextractHsTyRdrTyVarsextractHsTyRdrTyVarsKindVarsextractHsTysRdrTyVarsextractRdrKindSigVarsextractConDeclGADTDetailsTyVarsextractDataDefnKindVarsextractHsOuterTvBndrsnubLnubN$fOutputableRnTyKiWhat$fOutputableRnTyKiEnv$fOutputableWarnUnusedForalls$fOutputableOpNameHsRecFieldContext HsRecFieldCon HsRecFieldPat HsRecFieldUpd NameMakerCpsRnliftCpsliftCpsWithConttopRecNameMakerisTopRecNameMakerlocalRecNameMakerrnPatsrnPatapplyNameMaker rnBindPat rnPatAndThen rnHsRecFieldsrnHsRecUpdFieldsrnLit rnOverLit patSigErr $fMonadCpsRn$fApplicativeCpsRn$fFunctorCpsRn rnTopBindsLHSrnTopBindsBootrnLocalBindsAndThenrnLocalValBindsLHS rnValBindsRHSrnLocalValBindsRHSmakeMiniFixityEnv rnMethodBinds renameSigs rnMatchGrouprnGRHSsrnGRHSrnSrcFixityDecl rnSrcDecls addTcgDUs findSplice SpliceInfospliceDescription spliceSource spliceIsDeclspliceGenerated rnBracket rnSpliceExpr traceSplicecheckThLocalName$fOutputableMonadNames$fOutputableStmtTreetypecheckIfacetypecheckIfacesForMergingtypecheckIfaceForInstantiate tcHiBootIface tcIfaceExprtcIfaceOneShot tcIfaceGlobalDataSort DataDeclSortDataInstanceSortDataFamilySort ContextKindTheKindAnyKindOpenKind SAKS_or_CUSKSAKSCUSKInitialKindStrategyInitialKindCheckInitialKindInferHoleModeHM_Sig HM_FamPatHM_VTA HM_TyAppPat funsSigCtxt addSigCtxt pprSigCtxt tcHsSigWcTypekcClassSigTypetcClassSigType tcHsSigTypetcStandaloneKindSig tcHsDerivtcDerivStrategytcHsClsInstType tcHsTypeApp tcFamTyPats tcHsOpenTypetcHsLiftedTypetcHsOpenTypeNCtcHsLiftedTypeNCtcCheckLHsTypetcInferLHsTypetcInferLHsTypeKindtcInferLHsTypeUnsaturatedtcMult tcHsContext tcLHsPredTypebindNamedWildCardBinders kcDeclHeaderscopedSortOuterbindOuterSigTKBndrs_TvbindOuterFamEqnTKBndrs_Q_TvbindOuterFamEqnTKBndrstcOuterTKBndrstcExplicitTKBndrsbindExplicitTKBndrs_SkolbindExplicitTKBndrs_TvbindExplicitTKBndrs_Q_SkolbindExplicitTKBndrs_Q_TvbindImplicitTKBndrs_SkolbindImplicitTKBndrs_TvbindImplicitTKBndrs_Q_SkolbindImplicitTKBndrs_Q_TvbindTyClTyVarszonkAndScopedSortkindGeneralizeSomekindGeneralizeAllkindGeneralizeNoneetaExpandAlgTyConcheckDataKindSigcheckClassKindSigtcbVisibilitiestcHsPartialSigTypetcHsPatSigType tcLHsKindSig funAppCtxtaddTyConFlavCtxt$fOutputableHoleMode$fOutputableTcTyMode$fOutputableSAKS_or_CUSK TcPragEnv tcIdSigName tcSigInfoNamecompleteSigPolyId_maybetcTySigs tcUserTypeSigcompleteSigFromIdisCompleteHsSig tcInstSig emptyPragEnv lookupPragEnv extendPragEnv mkPragEnvaddInlinePrags tcSpecPrags tcSpecWrapper tcImpPragstcPatSynBuilderBind tcPatSynDecl LetBndrSpec LetLclBndr LetGblBndrtcLetPattcPats tcInferPat tcCheckPat tcCheckPat_O newLetBndraddDataConStupidTheta badFieldCon polyPatSig$fOutputableLetBndrSpec tcDefaults tcTopBinds tcHsBootSigsbadBootDeclErr tcLocalBinds tcValBinds tcPolyCheckchooseInferredQuantifiers$fOutputableGeneralisationPlan RolesInfocheckSynCyclescheckClassCycles inferRolesaddTyConsToGblEnvmkDefaultMethodType tcRecSelBinds mkRecSelBindsmkOneRecordSelector$fMonadSynCycleM$fApplicativeSynCycleM $fMonadRoleM$fApplicativeRoleM$fFunctorRoleM$fFunctorSynCycleMfindExtraSigImports'findExtraSigImportsimplicitRequirementsimplicitRequirements'implicitRequirementsShallow checkUnit tcRnCheckUnittcRnMergeSignaturesmergeSignaturestcRnInstantiateSignatureinstantiateSignaturepatSynBuilderOccHsSigFun tcClassSigs tcClassDecl2tcClassMinimalDefinstantiateMethod mkHsSigFunfindMethodBind badMethodErr instDeclCtxt1 instDeclCtxt2 instDeclCtxt3 tcATDefaultAppCtxt VAExpansionVACallEValArgValArgQLva_exprva_funva_argsva_ty HsExprArgETypeArgEPragEWrapeva_ctxteva_arg eva_arg_ty eva_hs_tyeva_tyTcPassTcpRnTcpInstTcpTc appCtxtLocinsideExpansion addArgWrap splitHsApps rebuildHsApps isHsValArgcountLeadingValArgs isVisibleArgpprHsExprArgTctcInferAppHeadtcInferAppHead_maybeaddAmbiguousNameErr obviousSigtyConOf tyConOfET lookupParentsfieldNotInType notSelector tcCheckId tcInferIdnonBidirectionalErr addFunResCtxt addExprCtxt$fOutputableAppCtxt$fOutputableEWrap$fOutputableEValArg$fOutputableHsExprArg TcStmtCheckerTcCmdStmtCheckerTcExprStmtChecker TcMatchCtxtMCmc_whatmc_body tcMatchesCase tcMatchLambdatcGRHS tcDoStmtstcBodytcStmtstcStmtsAndThen tcGuardStmttcDoStmttcProc tcInferSigmatcApp tcExprPraggetFixedTyVarstcRulesisForeignImportisForeignExportnormaliseFfiTypetcForeignImportstcForeignImports' tcFImport tcCheckFIType checkCTargettcForeignExportstcForeignExports' tcFExport tcCheckFETypecheckForeignArgscheckForeignResnonIOokmustBeIO checkSafe noCheckSafe DsWarning MatchResult MR_Infallible MR_Fallible DsWrapper EquationInfoEqnInfoeqn_patseqn_origeqn_rhsDsMatchContext idDsWrapperrunMatchResultfixDsinitDsTcinitDsinitDsWithModGutsinitTcDsForSolver newUniqueIdduplicateLocalDs newPredVarDsnewSysLocalDsNoLP newSysLocalDsnewFailLocalDsnewSysLocalsDsNoLPnewSysLocalsDs getGhcModeDs getPmNablas updPmNablas getSrcSpanDs putSrcSpanDs putSrcSpanDsA diagnosticDs warnIfSetDserrDs errDsCoreExpr failWithDsfailDs askNoErrsDsmkPrintUnqualifiedDsdsLookupGlobaldsLookupGlobalId dsLookupTyCondsLookupDataCondsLookupConLikedsGetFamInstEnvs dsGetMetaEnvdsGetCompleteMatchesdsLookupMetaEnvdsExtendMetaEnvdiscardWarningsDs dsNoLevPolydsNoLevPolyExpr dsWhenNoErrspprRuntimeTrace getCCIndexDsM$fOutputableDsMatchContext$fApplicativeMatchResult$fOutputableEquationInfo$fFunctorMatchResulttracePmmkPmIdallPmCheckWarnings overlapping exhaustive redundantBangexhaustiveWarningFlagisMatchContextPmCheckedneedToRunPmCheckPhiCtsPhiCtPhiTyCt PhiCoreCtPhiConCt PhiNotConCtPhiBotCt PhiNotBotCtaddPhiCtsNablasaddPhiCtNablas isInhabited lookupRefutslookupSolutiongenerateInhabitingPatterns"$fOutputableTopNormaliseTypeResult$fOutputablePhiCt pprUncovered CheckActionCAunCAcheckMatchGroup checkGRHSscheckEmptyCase checkPatBind$fFunctorCheckActionmatchSinglePatVar matchSimply matchWrappermatch dsLocalBinds dsSyntaxExprdsLExpr dsLExprNoLPdsExprCaseAlt MkCaseAltalt_pat alt_bndrs alt_wrapper alt_resultselectSimpleMatchVarLselectMatchVarsselectMatchVarfirstPat shiftEqns matchCanFailalwaysFailMatchResultcantFailMatchResultextractMatchResultcombineMatchResultsadjustMatchResultDs wrapBindswrapBindseqVarmkCoLetMatchResultmkViewMatchResultmkEvalMatchResultmkGuardedMatchResultmkCoPrimCaseMatchResultmkCoAlgCaseMatchResultmkCoSynCaseMatchResult mkErrorAppDs mkFailExpr mkCoreAppDs mkCoreAppsDsmkCastDsmkSelectorBinds mkLHsPatTupmkVanillaTuplePatmkBigLHsVarTupId mkBigLHsTupIdmkBigLHsVarPatTupIdmkBigLHsPatTupIdshareFailureHandlerdsHandleMonadicFailure mkOptTickBoxmkBinaryTickBoxdecideBangHood isTrueLHsExprdsCCallmkFCallunboxArg boxResult resultWrapper dsForeignsdsLit dsOverLitwarnAboutIdentitieswarnAboutOverflowedOverLitwarnAboutOverflowedLitwarnAboutEmptyEnumerations tidyLitPattidyNPat matchLiteralshsLitKey matchNPatsmatchNPlusKPats dsGuardeddsGRHSs dsHsWrapperdesugarPatBinddesugarEmptyCasedesugarMatches desugarGRHSs pmcPatBindpmcGRHSs pmcMatchesaddTyCsaddCoreScrutTmCsaddHsScrutTmCs $fMonoidCIRB$fSemigroupCIRB dsTopLHsBinds dsLHsBindsdsSpec dsMkUserRuledecomposeRuleLhs dsTcEvBinds_s dsTcEvBinds dsEvBindsdsEvTerm dsBracket$fRepTVSpecificitySpecificity $fRepTV()()matchConFamily matchPatSynmatchEquationsmatchSinglePat dsListComp dsMonadComp dsProcExpr dsValBindsRecompileRequiredUpToDate MustCompile RecompBecauserecompileRequired checkOldIfaceaddFingerprints$fMonoidRecompileRequired$fSemigroupRecompileRequired$fBinaryIfaceIdExtras$fBinaryIfaceDeclExtras$fOutputableIfaceDeclExtras$fEqRecompileRequiredmkDependencies mkUsedNames mkUsageInfomkPartialIface mkFullIface mkIfaceTcmkIfaceExportstyThingToIfaceDeclcoAxiomToIfaceDecl pprFamInst pprTyThingLoc pprTyThingHdrpprTyThingInContextpprTyThingInContextLoc pprTyThingpprTypeForUser sectionTypereadElfSectionByNamereadElfNoteAsString makeElfNote doubleToBytespprASCII pprString pprFileEmbedpprSectionHeader 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 InlineHintNoInlineOptSizeNoReturnNoUnwindReadNoneReadOnlySspSspReq NoRedZoneNoImplicitFloatNaked LlvmParamAttrZeroExtSignExtInRegByValSRetNoAlias NoCaptureNest LlvmParameterLlvmFunctionDeclsLlvmFunctionDecldecName funcLinkagefuncCc decReturnType decVarargs decParams funcAlignLlvmOptsllvmOptsPlatformllvmOptsFillUndefWithGarbagellvmOptsSplitSections LlvmStatic LMComment LMStaticLit LMUninitType LMStaticStr LMStaticArray LMStaticStrucLMStaticPointerLMTruncLMBitcLMPtoILMAddLMSubLlvmLitLMIntLit LMFloatLit LMNullLit LMVectorLit LMUndefLitLlvmVar LMGlobalVar LMLocalVar LMNLocalVarLMLitVarLMConstGlobalConstantAliasLMAlign LMSectionLlvmTypeLMIntLMFloatLMDouble LMFloat80 LMFloat128 LMPointerLMArrayLMVectorLMLabelLMVoidLMStruct LMStructULMAlias LMMetadata LMFunction LlvmAliasLMStringLMGlobal getGlobalVargetGlobalValueppTypeppParams initLlvmOpts garbageLit getVarType getLitType getStatTypegetLinkpLiftpVarLiftpLower pVarLowerisIntisFloat isPointerisVectorisGloballlvmWidthInBitsi128i64i32i16i8i1i8PtrllvmWord llvmWordPtrppDoublenarrowFpwidenFpppFloat ppCommaJoin ppSpaceJoin$fOutputableLlvmParamAttr$fOutputableLlvmFuncAttr$fOutputableLlvmCallConvention$fOutputableLlvmLinkageType$fOutputableLlvmFunctionDecl$fOutputableLlvmType$fOutputableLlvmMachOp$fOutputableLlvmCmpOp$fOutputableLlvmCastOp$fEqLlvmCastOp $fEqLlvmCmpOp$fEqLlvmMachOp $fEqLlvmVar $fEqLlvmLit$fEqLlvmFunctionDecl $fEqLlvmType$fEqLlvmLinkageType$fEqLlvmParameterListType$fShowLlvmParameterListType$fEqLlvmCallConvention$fEqLlvmCallType$fShowLlvmCallType$fEqLlvmFuncAttr$fEqLlvmParamAttr $fEqLMConstMetaDecl MetaNamed MetaUnnamed MetaAnnotMetaExprMetaStrMetaNodeMetaVar MetaStructMetaId$fOutputableMetaId $fEqMetaAnnot $fEqMetaExpr $fEqMetaId $fOrdMetaId $fEnumMetaIdLlvmExpressionAllocaLlvmOpCompareExtractExtractVInsertMallocLoadALoad GetElemPtrCast AtomicRMWCmpXChgCallMPhiAsmMExpr LlvmStatement AssignmentFenceBranchBranchIfCommentMkLabelStoreSwitch 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$fEqLlvmStatement$fEqLlvmExpression$fShowLlvmAtomicOp$fEqLlvmAtomicOp$fShowLlvmSyncOrdering$fEqLlvmSyncOrdering ppLlvmModuleppLlvmComments ppLlvmComment ppLlvmGlobals ppLlvmGlobal ppLlvmAliases ppLlvmAlias ppLlvmMetas ppLlvmMetappLlvmFunctionsppLlvmFunctionppLlvmFunctionDeclsppLlvmFunctionDeclppName ppPlainNameppLitppVar ppTypeLitlmGlobalRegVarlmGlobalRegArg alwaysLivestgTBAAtopNstackNheapNrxNbaseNtbaagetTBAALlvmM LlvmVersion UnresStatic UnresLabelLlvmData LlvmUnresDataLiveGlobalRegsLlvmBasicBlock LlvmCmmDecl cmmToLlvmTypewidthToLlvmFloatwidthToLlvmInt llvmFunTy llvmFunSig llvmFunAlign llvmInfAlignllvmFunSection llvmFunArgsisFPR padLiveArgsllvmStdFunAttrs tysToParams llvmPtrBitsparseLlvmVersionsupportedLlvmVersionMinsupportedLlvmVersionMaxllvmVersionSupportedllvmVersionStrllvmVersionList getLlvmOptsliftIOrunLlvm withClearVars varInsert funInsert varLookup funLookup markStackReg checkStackReggetMetaUniqueId getLlvmVer dumpIfSetLlvm renderLlvm markUsedVar getUsedVars setUniqMeta getUniqMetaghcInternalFunctionsstrCLabel_llvm getGlobalPtr llvmDefLabelgenerateExternDeclsaliasify$fMonadUniqueLlvmM$fHasLoggerLlvmM$fHasDynFlagsLlvmM $fMonadLlvmM$fApplicativeLlvmM$fFunctorLlvmM$fEqLlvmVersion$fOrdLlvmVersionrunUnlitrunCpprunPprunCc isContainedInaskLdrunAs runLlvmOpt runLlvmLlcrunClangfigureLlvmVersionrunLinkrunMergeObjects runLibtoolrunAraskOtoolrunInstallNameTool runRanlib runWindrestouchtraceToolCommand mkExtraObjmkExtraObjToLinkIntoBinarymkNoteObjsToLinkIntoBinary getLinkInfoplatformSupportsSavingLinkOptsghcLinkInfoSectionNameghcLinkInfoNoteName checkLinkInfohaveRtsOptsFlagslazyInitLlvmConfig initSysToolscopycopyWithHeadermaybeCreateManifest genLlvmDatagenData pprLlvmDatapprLlvmCmmDecl infoSection genLlvmProc$fMonoidLlvmAccum$fSemigroupLlvmAccum $fEqSignage $fShowSignage llvmCodeGenpprData pprFormatpprImm pprDataItemncgX86 ncgX86_64$fInstructionInstr pprBasicBlock$fOutputablePPlatformInstr checkBlockncgSPARCncgPPCdW_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_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$fOutputablePenvDwarfFrameBlock$fEqDwarfAbbrev$fEnumDwarfAbbrevdwarfGenState runState'getgetsputmodify evalState execStaterunState $fMonadState$fApplicativeState$fFunctorState 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 dsm_stock_ditdsm_stock_gen_fndsm_newtype_ditdsm_newtype_rep_tydsm_via_cls_tysdsm_via_inst_ty dsm_via_ty DerivInstTys dit_cls_tysdit_tc dit_tc_args dit_rep_tcdit_rep_tc_args DerivSpecDSds_locds_nameds_tvsds_thetads_clsds_tys ds_overlapds_standalone_wildcard ds_mechanismDerivEnvdenv_overlap_modedenv_tvsdenv_cls denv_inst_tys denv_ctxt denv_stratDerivMisStandaloneDerivisStandaloneWildcardDeriv mkDerivOrigin pprDerivSpecderivSpecMechanismToStrategyisDerivSpecStockisDerivSpecNewtypeisDerivSpecAnyClassisDerivSpecVia mkPredOrigin mkThetaOriginmkThetaOriginFromPredssubstPredOriginhasStockDerivingcheckOriginativeSideConditionscanDeriveAnyClassstd_class_via_coerciblenon_coercible_classnewDerivClsInstextendLocalInstEnv$fOutputableDerivInstTys$fOutputableDerivSpecMechanism$fOutputableDerivSpec$fOutputableDerivContext$fOutputableDerivEnv$fOutputablePredOrigin$fOutputableThetaOrigininferConstraintssimplifyInstanceContexts DerivInfo di_rep_tc di_scoped_tvs di_clausesdi_ctxt tcDeriving$fOutputableEarlyDerivSpec tcInstDecls1 DataDeclInfo DDataType DDataInstancetcTyAndClassDecls kcConDeclstcTyFamInstEqnunravelFamInstPatsaddConsistencyConstraintsdataDeclChecks tcConDeclscheckValidTyContcAddTyFamInstCtxttcMkDataFamInstCtxttcAddDataFamInstCtxtwrongKindOfFamilytcInstDeclsDeriv tcInstDecls2 RenamedStuff TcRnExprModeTM_Inst TM_Default tcRnModuletcRnModuleTcRnMcheckHiBootIface' checkBootDecl rnTopSrcDecls tcTopSrcDeclsrunTcInteractivetcRnStmt isGHCiMonadtcRnExprtcRnImportDeclstcRnType tcRnDeclsigetModuleInterfacetcRnLookupRdrNametcRnLookupName tcRnGetInfoloadUnqualIfacesgetRenamedStuffexitifyProgram core2core simplifyExprLiveBasicBlockLiveInfoLivenessliveBorn liveDieRead liveDieWrite LiveInstrInstrSRSPILLRELOAD LiveCmmDeclBlockMapRegMapRegSet emptyRegMap mapBlockTop mapBlockTopMmapSCCMmapGenBlockTopmapGenBlockTopMslurpConflictsslurpReloadCoalesce stripLivepprLiveCmmDeclmapLiveCmmDeclstripLiveBlockeraseDeltasLivepatchEraseLivepatchRegsLiveInstrcmmTopLiveness regLivenessreverseBlocksInTops$fOutputableInstrSR$fInstructionInstrSR$fOutputablePenvLiveInstr$fOutputableLiveInstr$fOutputablePPlatformLiveInfo$fFunctorLiveInstr$fFunctorInstrSRRA_State ra_blockassig ra_freeregsra_assigra_deltara_stackra_us ra_spills ra_config ra_fixups RegAllocStatsra_spillInstrs ra_fixupList SpillReason SpillAlloc SpillClobber SpillLoad SpillJoinRR SpillJoinRMLocInMemInBothBlockAssignment regsOfLoc$fOutputableLoc$fEqLoc $fShowLoc$fOrdLoc$fEqReadingOrWriting$fOrdReadingOrWriting regCoalesce slurpJoinMovsbinSpillReasonscountRegRegMovesNatpprStatsRegMrunRspillRloadR getFreeRegsR setFreeRegsR getAssigR setAssigRgetBlockAssigRsetBlockAssigR setDeltaR getDeltaR getUniqueR recordSpillrecordFixupBlock $fMonadRegM$fApplicativeRegM $fFunctorRegM joinToTargetsregAlloc SpillCostInfoSpillCostRecordzeroSpillCostInfoplusSpillCostInfoplusSpillCostRecordslurpSpillCostInfo chooseSpilllifeMapFromSpillCostInfopprSpillCostRecord cleanSpills$fOutputableStore$fUniquableStore SpillStatsspillStoreLoadregSpill accSpillSL$fOutputableSpillStatsRegAllocStatsStartRegAllocStatsSpillRegAllocStatsColored raLiveCmmraGraph raSpillCosts raPlatformraCode raCoalesced raSpillStats raSpilledraGraphColoredraCodeCoalesced raPatched raSpillCleanraFinalraSRMspprStatsSpillspprStatsLifetimespprStatsConflictpprStatsLifeConflict countSRMsaddSRM$fOutputableRegAllocStats$fFunctorRegAllocStats nativeCodeGen cmmNativeGen initNCGConfig!$fCmmMakeDynamicReferenceMCmmOptM$fMonadCmmOptM$fApplicativeCmmOptM$fFunctorCmmOptM codeOutputoutputForeignStubsprofilingInitCode ipInitCodeccsTypeccType storeCurCCS mkCCostCentremkCCostCentreStackcostCentreFrom staticProfHdr dynProfHdrinitUpdFrameProfsaveCurrentCostCentrerestoreCurrentCostCentre profDynAlloc profAllocenterCostCentreThunkenterCostCentreFuninitCostCentresinitInfoTableProvemitInfoTableProv emitSetCCCldvRecordCreateldvEnterClosureldvEnterallocDynClosureallocDynClosureCmmallocHeapClosure emitSetDynHdrmkStaticClosureFieldsmkStaticClosureentryHeapCheckentryHeapCheck' altHeapCheckaltHeapCheckReturnsTonoEscapeHeapCheckheapStackCheckGen cgTopRhsCon buildDynCon bindConArgs cgForeignCall emitCCall emitPrimCallemitForeignCallemitSaveThreadStatesaveThreadState emitSaveRegsemitRestoreRegsemitCloseNurseryemitLoadThreadStateloadThreadStateemitOpenNurserycgOpAppshouldInlinePrimOpcmmLayoutStacksetInfoTableStackMap$fOutputableStackMap$fOutputableStackSlotcgExprcgTopRhsClosureemitBlackHoleCodepushUpdateFrameemitUpdateFramecodeGen parseCmmFileSRTMap ModuleSRTInfo thisModule dedupSRTsflatSRTs moduleSRTMapCAFEnvCAFSet cafAnalDatacafAnalemptySRT srtMapNonCAFsdoSRTs$fOutputablePenvSomeLabel$fOutputablePenvModuleSRTInfo $fEqSomeLabel$fOrdSomeLabel $fEqSRTEntry $fOrdSRTEntry $fEqCAFLabel $fOrdCAFLabel$fOutputablePenvSRTEntry$fOutputablePenvCAFLabel cmmPipelineputArraygetArraymkConInfoTableShouldRetainCAFs RetainCAFsDontRetainCAFs initObjLinker lookupSymbol lookupClosureloadDLL loadArchive unloadObjpurgeObjaddLibrarySearchPathremoveLibrarySearchPathfindSystemLibrary resolveObjsResolvedBCOPtrResolvedBCORefResolvedBCOStaticPtrResolvedBCOPtrBCOResolvedBCOPtrBreakArray ResolvedBCOresolvedBCOIsLEresolvedBCOArityresolvedBCOInstrsresolvedBCOBitmapresolvedBCOLitsresolvedBCOPtrsisLittleEndian$fBinaryResolvedBCOPtr$fBinaryResolvedBCO$fGenericResolvedBCOPtr$fShowResolvedBCOPtr$fGenericResolvedBCO$fShowResolvedBCO createBCOs BreakInfobreakInfo_modulebreakInfo_number ExecOptionsexecLineNumberexecSingleStepexecSourceFileexecWrap ExecResult ExecBreak ExecComplete breakInfo breakNamesexecAllocation execResultHistoryhistoryApStackhistoryBreakInfohistoryEnclosingDecls resumeApStackresumeBindingsresumeBreakInfo resumeCCS resumeContext resumeDeclresumeFinalIds resumeHistoryresumeHistoryIx resumeSpan resumeStmt SingleStepRunAndLogStepsRunToCompletion interpCmd hscInterp withIServ withIServ_evalStmt abandonStmtevalIO evalStringevalStringToIOString mallocData mkCostCentres addSptEntrycostCentreStackInfo newBreakArraystoreBreakpointbreakpointStatusgetBreakpointVar getClosure seqHValuepurgeLookupSymbolCache iservCall readIServ writeIServ stopInterpmkFinalizedHValuefreeHValueRefswormhole wormholeRef mkEvalOptsfromEvalResult getModBreaksinterpreterProfiledinterpreterDynamicTermFoldfTermfPrim fSuspension fNewtypeWrapfRefWrapTermPrim Suspension NewtypeWrapRefWraptydcvalsubTermsvalRawctypebound_to wrapped_termtermTypeisFullyEvaluatedTermconstrClosToNamefoldTerm mapTermType termTyCoVarscPprTerm cPprTermBase cvObtainTermcvReconstructTypeimproveRTTIType$fOutputableTermrunInjectRPathsgetUnitFrameworkOptsgetFrameworkOpts loadFramework linkDynLib libmLinkOpts linkBinary linkBinary' linkStaticLib exeFileNameaddTicksToBinds hpcInitCode$fHasDynFlagsTM $fMonadTM$fApplicativeTM $fFunctorTM$fEqTickishType$fEqTickDensitydeSugar deSugarExpr mkHieFilemkHieFileWithSourcegetCompressedAsts enrichHie$fModifyStateVar$fModifyStateName$fHasLocHsDataDefn $fHasLocHsArg $fHasLoc[]$fHasLocGenLocated$fHasLocGenLocated0$fHasLocGenLocated1$fHasLocPScoped$fToHieIEContext$fToHieIEContext0$fToHieIEContext1$fToHieGenLocated$fToHieRScoped$fToHieGenLocated0$fToHieGenLocated1$fToHieAnnProvenance$fToHieGenLocated2$fToHieGenLocated3$fToHieGenLocated4$fToHieForeignExport$fToHieForeignImport$fToHieGenLocated5$fToHieGenLocated6$fToHieGenLocated7$fToHieGenLocated8$fToHieGenLocated9$fToHieGenLocated10$fToHieGenLocated11$fToHieGenLocated12$fToHieGenLocated13$fToHieGenLocated14$fToHieGenLocated15$fToHiePendingTcSplice$fToHiePendingRnSplice$fToHieHsBracket$fToHieGenLocated16$fToHieArithSeqInfo$fToHieGenLocated17$fToHieGenLocated18$fToHieTScoped$fToHieTVScoped $fToHieHsArg$fToHieGenLocated19$fToHieTVScoped0$fToHieTScoped0$fToHieStandaloneKindSig$fToHieGenLocated20$fToHieTScoped1$fToHieTScoped2$fToHieGenLocated21$fToHieGenLocated22$fToHieHsScaled$fToHieGenLocated23$fToHieGenLocated24$fToHieGenLocated25$fToHieGenLocated26$fToHieGenLocated27$fToHieHsDataDefn$fToHieGenLocated28 $fToHieFamEqn$fToHieTScoped3$fToHieTScoped4$fToHieGenLocated29$fToHieRScoped0$fToHieFamilyInfo$fToHieGenLocated30$fToHieGenLocated31$fToHieTyClGroup$fToHieHsConDeclGADTDetails$fToHieHsConDetails$fToHieRFContext$fToHieRFContext0$fToHieRFContext1$fToHieRFContext2$fToHieRContext$fToHieTScoped5$fToHieContext$fToHieGenLocated32$fToHieEvBindContext$fToHieContext0$fToHieContext1$fToHieContext2$fToHieContext3$fToHieIEContext2 $fToHieMaybe $fToHieBag $fToHie[] $fToHieVoid$fToHiePatSynFieldContext$fToHieContext4$fToHieGenLocated33$fToHieSigContext$fToHieGenLocated34$fToHieGenLocated35$fToHieRScoped1$fToHieRContext0$fToHieRScoped2$fToHieRScoped3$fToHieRScoped4$fToHieRScoped5$fToHieHsTupArg$fToHieGenLocated36$fToHiePScoped$fToHieHsStmtContext$fToHieHsMatchContext$fToHieHsPatSynDir$fToHieGenLocated37$fToHieBindContext$fHiePassTypechecked$fHiePassRenamed$fHasTypeGenLocated$fHasTypeGenLocated0$fHasTypeGenLocated1$fHasLocFamEqn$fToHieRScoped6$fToHieGenLocated38 $fToHieGRHSs$fToHieGenLocated39$fToHieMatchGroup $fDataPScopedmkITbls bcoFreeNames assembleBCOsassembleOneBCOmkTupleInfoLitiNTERP_STACK_CHECK_THRESH$fMonadAssembler$fApplicativeAssembler$fFunctorAssembler byteCodeGen stgExprToBCOs$fOutputableDiscr$fHasDynFlagsBcM $fMonadBcM$fApplicativeBcM $fFunctorBcM $fEqDiscr $fOrdDiscr ClosureEnvemptyClosureEnvextendClosureEnvlinkBCOlookupStaticPtrlookupIElinkFail nameToCLabelextendLoadedPkgsextendLoadedEnvdeleteFromLoadedEnvloadNamewithExtendedLoadedEnvshowLoaderStateinitLoaderStateloadCmdLineLibsloadExpr loadDecls loadModuleunload loadPackages$fOutputableLibrarySpecinitializePluginsloadFrontendPluginforceLoadModuleInterfacesforceLoadNameModuleInterfaceforceLoadTyCongetValueSafelygetHValueSafelylessUnsafeCoercelookupRdrNameInModuleForPluginsHscNotGeneratingCode HscRecomp HscUpToDate HscUpdateBoot HscUpdateSig hscs_gutshscs_mod_detailshscs_mod_locationhscs_old_iface_hashhscs_partial_ifaceMessager newHscEnv getHscEnv ioMsgMaybehscTcRnLookupRdrNamehscTcRcLookupNamehscTcRnGetInfohscIsGHCiMonadhscGetModuleInterfacehscRnImportDeclshscParse hscParse'hscTypecheckRename tcRnModule' hscDesugar hscDesugar'makeSimpleDetailshscIncrementalCompilehscMaybeWriteIface oneShotMsgbatchMsg hscCheckSafe hscGetSafe hscSimplify hscSimplify'hscSimpleIface'hscGenHardCodehscInteractivehscCompileCmmFile doCodeGenhscStmthscStmtWithLocation hscParsedStmthscDeclshscParseDeclsWithLocationhscDeclsWithLocationhscParsedDeclshscAddSptEntries hscImport hscTcExpr hscKcType hscParseExprhscParseStmtWithLocation hscParseTypehscParseIdentifierhscCompileCoreExprhscCompileCoreExpr'dumpIfaceStatsshowModuleIndexdefaultRunMetarunMeta' $fQuasiIOEnv!$fReifyFlagSpecificitySpecificity$fReifyFlag()()defaultWarnErrLoggergetSessionDynFlags modifyLogger popLogHookMprintException pushLogHookM putLogMsgMputMsgMGhcMonad getSession setSessionGhcT WarnErrLoggerGetDocsFailureNameHasNoModule NoDocsInIfaceInteractiveNamegetResumeContextgetHistoryModulegetHistorySpan execOptionsexecStmt execStmt'runDeclsrunDeclsWithLocationrunParsedDeclsparseImportDecl resumeExecsetupBreakpointbackforwardabandon abandonAll setContext getContextmoduleIsInterpretedgetInfogetNamesInScopegetRdrNamesInScope parseNamegetDocsexprTypegetInstancesForTypeparseInstanceHead parseExpr compileExprcompileExprRemotecompileParsedExprRemotecompileParsedExprdynCompileExpr showModulemoduleIsBootOrNotObjectLinkableobtainTermFromValobtainTermFromIdreconstructType$fOutputableGetDocsFailure preprocess compileOne compileOne'link linkingNeededoneShot compileFilephaseOutputFilenamegetOutputFilenamerunPhase getLocationdoCppwriteInterfaceOnlyModehscPostBackendPhase ModNodeMap unModNodeMap SummaryNode LoadHowMuchLoadAllTargetsLoadUpToLoadDependenciesOfdepanaldepanalEdepanalPartialinstantiationNodesloadload'hscSourceToIsBoottopSortModuleGraphmoduleGraphNodesemptyModNodeMapmodNodeMapInsertmodNodeMapElemsmodNodeMapLookup downsweepsummariseModule noModErrorcyclicModuleErr$fFunctorNodeMap$fTraversableNodeMap$fFoldableNodeMap $fEqNodeKey $fOrdNodeKey$fFunctorModNodeMap$fTraversableModNodeMap$fFoldableModNodeMap$fEqBuildModule$fOrdBuildModule GhcApiError 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_files coreModuleTypecheckedMod renamedSourcetypecheckedSource moduleInfo ParsedMod parsedSourcedefaultErrorHandlerdefaultCleanupHandlerrunGhcrunGhcTwithCleanupSession initGhcMonadsetSessionDynFlagssetProgramDynFlagsgetProgramDynFlagssetInteractiveDynFlagsgetInteractiveDynFlagsparseDynamicFlagsparseTargetFiles setTargets getTargets addTarget removeTarget guessTargetworkingDirectoryChanged getModSummary parseModuletypecheckModule desugarModulecompileToCoreModulecompileToCoreSimplifiedgetModuleGraphisLoaded getBindingsgetInstsgetPrintUnqual getModuleInfomodInfoTyThingsmodInfoTopLevelScopemodInfoExportsmodInfoExportsWithSelectorsmodInfoInstancesmodInfoIsExportedNamemkPrintUnqualifiedForModulemodInfoLookupName modInfoIface modInfoRdrEnv modInfoSafemodInfoModBreaks isDictonaryIdlookupGlobalNamefindGlobalAnnsgetGREgetNameToInstancesIndex dataConTypepprParenSymNamegetTokenStreamgetRichTokenStreamaddSourceToTokensshowRichTokenStream findModule lookupModuleisModuleTrustedmoduleTrustReqs setGHCiMonadparserinterpretPackageEnv$fParsedModParsedModule$fOutputableCoreModule$fParsedModTypecheckedModule$fParsedModDesugaredModule$fTypecheckedModDesugaredModule!$fTypecheckedModTypecheckedModule$fDesugaredModDesugaredModule$fExceptionGhcApiError$fShowGhcApiErrorpprintClosureCommandshowTermpprTypeAndContents doMkDependHS doBackpack$fGhcMonadIOEnv$fHasLoggerIOEnv$fHasDynFlagsIOEnv$fEqSessionTypeinstallSignalHandlers sptAddEntryGHCiQExceptionstartTHrunModFinalizerRefsrunTH$fMonadIOGHCiQ $fMonadGHCiQ$fApplicativeGHCiQ$fFunctorGHCiQ $fQuasiGHCiQ$fMonadFailGHCiQ$fExceptionGHCiQException$fShowGHCiQExceptionrunredirectInterrupts>>=>> QuasiQuoterquoteExpquotePat quoteTypequoteDec quoteFileversion getBinDir getLibDir getDynLibDir getDataDir getLibexecDir getSysconfDirgetDataFileNameCmmGraph GHC.Cmm.Node CmmSwitch CmmUnwind GHC.MaybeNothing.=!:GHC.EnumsuccGHC.CoreCoreExprGHC.Types.DemandDemandCoreRuleGHC.Runtime.Heap.LayoutStgWord tcg_th_docsLanguage.Haskell.Syntax.DeclsHsGroupghc-prim GHC.TypesTrue Data.DataDataRnEnv2emptyInScopeSettransformers-0.5.6.2Control.Monad.Trans.RWS.StrictRWSTGHC.Data.OrdListOrdListUniqSMStgTopStringLitlocalPrimRep CmmInfoTable GenStgExprinfinityTcMDumpFlagPprUserPprDumpIfGTcRnIfGblEnvTcGblEnvControl.Monad.FixMonadFixmfixControl.Monad.IO.ClassMonadIO GHC.IORefIORefGHC.ForeignSrcLang.TypeForeignSrcLang RawObjectLangAsm LangObjcxxLangObjcLangCLangCxxTcLclEnv tcl_usage tcl_th_ctxt tcl_th_bndrs tcl_tclvltcl_rdrtcl_loctcl_lietcl_in_gen_codetcl_errstcl_envtcl_ctxttcl_arrow_ctxt tcl_bndrsGHC.Utils.MonadallManyM concatMapM filterOutM fmapEitherM fmapMaybeMfoldlM_liftFstMliftSndM mapAccumLM mapAndUnzip3M mapAndUnzip4M mapAndUnzip5M mapMaybeMmapSndM maybeMapMorMunlessMwhenM zipWith3M zipWith3M_ zipWith4MzipWithAndUnzipMGHC.Data.IOEnvIOEnvatomicUpdMutVaratomicUpdMutVar'failM failWithMfixM newMutVar readMutVarrunIOEnvsetEnvtryAllMtryMtryMostMuninterruptibleMaskM_unsafeInterleaveMupdEnv updMutVar updMutVarM writeMutVar IOEnvFailureemptyImportAvailsemptyRoleAnnotEnv getLclEnvLocgetLclEnvTcLevel getRoleAnnotsimpLevel lintGblEnvlookupRoleAnnot mkModDepsmkRoleAnnotEnv modDepsElts outerLevel peCategoryplusImportAvails pprPECategorypprTcTyThingCategory pushErrCtxtpushErrCtxtSameOriginremoveBindingShadowing runTcPluginM setLclEnvLocsetLclEnvTcLeveltcTyThingCategorytcVisibleOrphanMods topAnnStagetopSpliceStagetopStage ArrowCtxt NoArrowCtxt ClosedTypeIdDocLocInstDocArgDoc ModuleDocDeclDocenv_umenv_topenv_gblenv_lclErrCtxtFrontendResultFrontendTypecheck IdBindingInfo NotLetBound ClosedLet NonClosedLetif_doc if_rec_typesIfLIfLclEnv if_tv_env if_nsubstif_modif_locif_implicits_envif_boot if_id_envIfM ImportAvailsimp_trust_pkgsimp_trust_own_pkg imp_orphsimp_mods imp_finsts imp_dep_mods imp_dep_pkgs IsGroupClosed PendingStuff TcPendingRnPendingTypedRnPendingUntyped PromotionErrTyConPE RecDataConPEPatSynPE NoDataKindsTC NoDataKindsDC FamDataConPEClassPEConstrainedDataConPE RecFieldEnvRhsNamesRnM RoleAnnotEnv SelfBootInfo NoSelfBootSelfBootsb_mdssb_tcs SpliceTypeTypedUntypedTHDocsTcBinderTcTvBndrTcIdBndrTcIdBndr_ExpType TcBinderStack tcg_warns tcg_used_grestcg_type_env_var tcg_type_env tcg_tr_module tcg_top_loc tcg_th_usedtcg_th_topnamestcg_th_topdecls tcg_th_statetcg_th_splice_usedtcg_th_remote_statetcg_th_modfinalizerstcg_th_foreign_filestcg_th_corepluginstcg_tcstcg_tc_plugins tcg_static_wctcg_srctcg_sigs tcg_self_boot tcg_safeInfer tcg_rulestcg_rn_importstcg_rn_exports tcg_rdr_env tcg_patsynstcg_mod tcg_mergedtcg_main tcg_ksigstcg_keep tcg_inst_env tcg_imports tcg_imp_specstcg_hpctcg_hf_plugins tcg_fords tcg_fix_env tcg_field_envtcg_fam_inst_env tcg_exports tcg_ev_bindstcg_dus tcg_dfun_ntcg_dependent_files tcg_defaulttcg_complete_matches tcg_cc_st tcg_bindstcg_anns tcg_ann_env tcg_doc_hdr tcg_fam_insts tcg_inststcg_semantic_mod tcg_rn_declsTISI sig_inst_wcx sig_inst_wcssig_inst_theta sig_inst_tau sig_inst_sigsig_inst_skolsTcPlugin tcPluginStop tcPluginInit tcPluginSolveTcPluginResultTcPluginContradiction TcPluginOkTcPluginSolverTcRefTcRnIf TcTypeEnvThLevelThStage RunSpliceCompSpliceBrack WhereFrom ImportByUserImportByPluginImportBySystem TyConRepNameUserDataGHC.IOFilePathGHC.Data.FastString FastString NameCache Data.EitherLeft Implicationic_tclvlic_bindsic_infoGHC.Utils.Panic.Plainpanicic_envGHC.Types.Avail AvailInfoGHC.Types.Unique.DFMUniqDFMIndirectEntryGHC.Data.MaybeMaybeErrmoduleFreeHolesTidyEnvJustGHC.Settings.ConstantsmAX_TUPLE_SIZEmAX_CTUPLE_SIZE Debug.TracetracesortWith mkNoRepType Data.VersionVersion versionBranch versionTagsControl.Exception.Basetry GHC.Conc.SyncthrowToGHC.Exception.Type ExceptiondisplayException toException fromExceptionGHC.Listfoldl1'GHC.Stack.Types HasCallStack listTyConKey nilDataConKeyOrigExactuniqn_charsfs_sbsfs_zencbaseUnit baseUnitId bignumUnit bignumUnitIdfsToUnitinteractiveUnitinteractiveUnitId isHoleUnitisInteractiveModulemainUnit mainUnitId mapGenUnitmapInstantiationsmkInstantiatedUnitmkInstantiatedUnitHash mkVirtUnitpprInstantiatedModuleprimUnit primUnitIdrtsUnit rtsUnitId stableUnitCmp stringToUnitstringToUnitIdthUnitthUnitId thisGhcUnit thisGhcUnitIdtoUnitIdunitFreeModuleHoles unitIdStringunitIsDefinite unitString virtualUnitIdwiredInUnitIds DefUnitIdDefinite unDefiniteGenInstantiatedUnitInstantiatedUnit instUnitKey instUnitInstsinstUnitInstanceOf instUnitFS instUnitHolesGenInstantiations GenModuleGenUnitVirtUnitHoleUnitRealUnit GenWithIsBootGWIB gwib_isBootgwib_mod IndefUnitId Indefinite indefUnitInstalledModuleInstantiatedModuleInstantiationsIsUnitIdunitFSModuleNameWithIsBootModuleWithIsBootUnitIdunitIdFSUnitKey OutputablepprSDocmkModuleNameFSmoduleNameColons moduleNameFSmoduleNameSlashesparseModuleName pprModuleNamestableModuleNameCmpOutputableBndrbndrIsJoin_maybe pprInfixOcc pprPrefixOccpprBndrGHC.Utils.MiscHasDebugCallStackPprStylePprCodeGHC.Types.Unique.FMUniqFMGHC.Types.Unique.SetUniqSetgreNameSrcSpan availFromGRE bestImportdelLocalRdrEnvList demoteRdrNameelemLocalRdrEnvemptyGlobalRdrEnvemptyLocalRdrEnvextendGlobalRdrEnvextendLocalRdrEnvextendLocalRdrEnvListgetGRE_NameQualifier_maybes getRdrNameglobalRdrEnvEltsgreDefinitionModulegreDefinitionSrcSpan greFieldLabelgreMangledName greOccNamegreParent_maybegrePrintableNamegreQualModName greRdrNames greSrcSpan gresFromAvailgresToAvailInfo importSpecLocimportSpecModuleinLocalRdrEnvScopeisDuplicateRecFldGREisExact isExact_maybeisExplicitItemisFieldSelectorGRE isLocalGREisNoFieldSelectorGREisOrig isOrig_maybeisQual isQual_maybe isRdrDataConisRdrTc isRdrTyVar isRecFldGRE isSrcRdrNameisUnquallocalGREsFromAvaillocalRdrEnvEltslookupGRE_FieldLabellookupGRE_GreNamelookupGRE_NamelookupGRE_Name_OccNamelookupGRE_RdrNamelookupGRE_RdrName'lookupGlobalRdrEnvlookupLocalRdrEnvlookupLocalRdrOccmkGlobalRdrEnvmkOrigmkQual mkRdrQual mkRdrUnqualmkUnqual mkVarUnqual nameRdrNameopIsAtpickGREspickGREsModExpplusGlobalRdrEnvpprGlobalRdrEnvpprNameProvenancepromoteRdrName qualSpecOK rdrNameOcc rdrNameSpace shadowNamesstarInfo transformGREsunQualOK unQualSpecOKGreName FieldGreName NormalGreName GlobalRdrEltGREgre_pargre_namegre_impgre_lcl GlobalRdrEnv ImpDeclSpecis_qualis_modis_asis_dloc ImpItemSpecImpAllImpSome is_explicitis_iloc ImportSpecImpSpecis_declis_item LocalRdrEnvParentNoParentParentIspar_isGHC.Types.Name.SetNameSetGHC.Types.FieldLabel FieldLabelflLabelflHasFieldSelector flSelectorflHasDuplicateRecordFieldsArityBoxityUnboxedBoxedappendFSbytesFSconcatFSconsFSfastStringToByteStringfastStringToShortByteStringfastZStringToByteStringfsLitgetFastStringTablegetFastStringZEncCounterhPutFShPutFZSheadFSisUnderscoreFSlengthFS lengthFZSlengthPSlexicalCompareFS mkFastString mkFastString#mkFastStringByteListmkFastStringByteStringmkFastStringBytesmkFastStringShortByteString mkPtrString mkPtrString#nilFSnullFSsLitunconsFS uniqCompareFS uniqueOfFSunpackFSunpackPtrStringunsafeMkByteString zEncodeFSzString FastZStringLexicalFastStringNonDetFastString PtrStringabstractConstractivateAfterInitialactivateDuringFinalactiveInFinalPhase alignmentOfalwaysInlinePragmaappPrec bestOneShot boolToRecFlagboxityTupleSort competesWithdefaultInlinePragmadfunInlinePragma fIRST_TAGflipSwapfunPrechasIncoherentFlaghasNoOneShotInfohasOverlappableFlaghasOverlappingFlaginlinePragmaActivationinlinePragmaRuleMatchInfoinlinePragmaSatinlinePragmaSpec intGtLimitisActiveisAlwaysActiveisAlwaysTailCalledisAnyInlinePragmaisBoxed isConLike isDeadOccisDefaultInlinePragma isFunLike isGeneratedisInlinablePragmaisInlinePragma isKindLevel isManyOccs isNeverActive isNoOccInfoisNonRec isNotTopLevelisOneOcc isOneShotInfo isPromotedisRecisStrongLoopBreaker isSwapped isTopLevel isTypeLevelisWeakLoopBreaker maybeParen mkAlignment mkIntWithInfneverInlinePragma noOccInfo noOneShotInfonoUserInlineSpec oneBranchopPrecpprAlternative pprInlinepprInlineDebug pprRuleName seqOccInfosetInlinePragmaActivationsetInlinePragmaRuleMatchInfosetOverlapModeMaybesigPrecstarPrecstrongLoopBreaker successIf sumParens tailCallInfotopPrectreatZeroAsInf tupleParenstupleSortBoxityunSwapweakLoopBreaker worstOneShot zapFragileOcczapOccTailCallInfo Activation NeverActive FinalActive AlwaysActive ActiveAfter ActiveBefore AlignmentalignmentBytes BranchCount CompilerPhase InitialPhase FinalPhaseConTag DefMethSpec GenericDM VanillaDMEPfromEPtoEP FullArgCountFunctionOrDataIsData IsFunction InlinePragmainl_srcinl_satinl_ruleinl_act inl_inline InlineSpecNoUserInlinePrag InlinableInline InsideLam IsInsideLam NotInsideLam IntWithInfInterestingCxt IsInterestingNotInteresting JoinArityOccInfoOneOccManyOccsIAmALoopBreakerIAmDeadocc_tailocc_rules_onlyocc_n_br occ_in_lam occ_int_cxt OneShotInfo NoOneShotInfo OneShotLamOrigin FromSource Generated OverlapFlag isSafeOverlap overlapMode OverlapMode NoOverlap IncoherentOverlaps Overlappable OverlappingPhaseNumPprPrec PromotionFlag IsPromoted NotPromotedRecFlag NonRecursive RecursiveRepArity RuleMatchInfoConLikeFunLikeRuleNameSpliceExplicitFlagExplicitSpliceImplicitSpliceSwapFlag IsSwapped NotSwapped TailCallInfoAlwaysTailCalledNoTailCallInfo TopLevelFlag NotTopLevelTopLevel TupleSort UnboxedTuple BoxedTupleConstraintTuple TypeOrKind KindLevel TypeLevel OutputablePpdocvarMultvarName tyConCTypetcTyConScopedTyVars tcTyConIsPoly famTcResVar algTcFields tyConResKindtyConNullaryTy tyConBinders tyConUnique tyConName TyConBinderGHC.Types.Var.Set TyCoVarSet InvisTVBinder ReqTVBinderconstraintKind GHC.Core.FVs orphNamesOfCoorphNamesOfCoConorphNamesOfTypeorphNamesOfTypes isTauTyCon DTyCoVarSet DTyVarSetTyVarSetEvVar algTyConRhsexpandSynTyCon_maybefamTyConFlav_maybeisAbstractTyCon isAlgTyConisBoxedTupleTyConisBuiltInSynFamTyCon_maybe%isClosedSynFamilyTyConWithAxiom_maybeisDataFamilyTyCon isDataTyConisEnumerationTyConisFamFreeTyConisFamInstTyConisForgetfulSynTyConisGadtSyntaxTyConisGenInjAlgRhsisGenerativeTyConisImplicitTyConisInjectiveTyConisInvisibleTyConBinder isKindTyConisLiftedTypeKindTyConNameisNamedTyConBinder isNoParentisPromotedDataConisPromotedDataCon_maybeisPromotedTupleTyCon isTcLevPoly isTcTyCon isTupleTyCon isTyConAssocisTyConWithSrcDataConsisUnboxedSumTyConisUnboxedTupleTyConisUnliftedTyConisVanillaAlgTyConisVisibleTyConBinderlookupTyConFieldLabel mkAlgTyConmkAnonTyConBindermkAnonTyConBinders mkClassTyConmkDataTyConRhs mkFamilyTyCon mkFunTyCon mkKindTyConmkLiftedPrimTyConmkNamedTyConBindermkNamedTyConBindersmkPrelTyConRepName mkPrimTyConmkPromotedDataConmkRequiredTyConBinder mkSumTyConmkSynonymTyCon mkTcTyCon mkTupleTyCon mkTyConKind mkTyConTagMapmustBeSaturated newTyConConewTyConCo_maybenewTyConDataCon_maybenewTyConEtadAritynewTyConEtadRhs newTyConRhsnoTcTyConScopedTyVarspprPromotionQuoteprimElemRepSizeBprimElemRepToPrimRepprimRepCompatibleprimRepIsFloat primRepSizeBprimRepsCompatiblesetTcTyConKindtcFlavourIsOpentyConATstyConAlgDataCons_maybetyConAssoc_maybetyConBinderArgFlagtyConBndrVisArgFlagtyConCType_maybetyConDataCons_maybetyConFamInstSig_maybetyConFamInst_maybetyConFamilyCoercion_maybetyConFamilyResVar_maybetyConFamilySizetyConFieldLabels tyConFlavourtyConFlavourAssoc_maybetyConInjectivityInfotyConInvisTVBinderstyConRepModOcctyConRepName_maybe tyConRolestyConRuntimeRepInfotyConSingleAlgDataCon_maybetyConSingleDataContyConSingleDataCon_maybe tyConSkolemtyConStupidThetatyConTuple_maybetyConVisibleTyVarsunwrapNewTyConEtad_maybeunwrapNewTyCon_maybevisibleDataCons AlgTyConFlavVanillaAlgTyConUnboxedAlgTyCon ClassTyConDataFamInstTyCon AlgTyConRhs TupleTyConSumTyConNewTyCon AbstractTyCon DataTyContup_sortnt_rhs nt_lev_poly nt_etad_rhsnt_cois_enumdata_cons_sizedata_con data_cons FamTyConFlavOpenSynFamilyTyConDataFamilyTyConClosedSynFamilyTyConBuiltInSynFamTyConAbstractClosedSynFamilyTyCon Injectivity NotInjective Injective PrimElemRep DoubleElemRep FloatElemRep Word64ElemRep Word32ElemRep Word16ElemRep Word8ElemRep Int64ElemRep Int32ElemRep Int8ElemRep Int16ElemRepVoidRep DoubleRepFloatRepAddrRep Word64Rep Word32Rep Word16RepWord8RepWordRepInt64RepInt32RepInt16RepInt8RepIntRep UnliftedRepVecRep LiftedRepRuntimeRepInfo UnliftedInfoNoRRI LiftedInfoVecElem RuntimeRepVecCount TyConBndrVisAnonTCBNamedTCB TyConFlavourTypeSynonymFlavour TupleFlavour SumFlavourPromotedDataConFlavourOpenTypeFamilyFlavourNewtypeFlavourDataTypeFlavourDataFamilyFlavourClosedTypeFamilyFlavour ClassFlavourAbstractTypeFlavourBuiltInTypeFlavourTyConTyCoBinderVarBndrBndrFieldLabelStringGHC.Types.Name.EnvNameEnvVarEnvVarSetEvId addListToUFMaddListToUFM_CaddListToUFM_DirectlyaddToUFM addToUFM_Acc addToUFM_CaddToUFM_Directly adjustUFMadjustUFM_DirectlyallUFMalterUFManyUFM delFromUFMdelFromUFM_DirectlydelListFromUFMdelListFromUFM_Directly disjointUFMelemUFMelemUFM_DirectlyeltsUFMemptyUFM equalKeysUFM filterUFMfilterUFM_DirectlyfoldUFM intersectUFMintersectUFM_C isNullUFMlistToIdentityUFM listToUFM listToUFM_ClistToUFM_Directly lookupUFMlookupUFM_DirectlylookupWithDefaultUFMlookupWithDefaultUFM_DirectlymapUFMmapUFM_DirectlyminusUFM nonDetEltsUFM nonDetKeysUFMnonDetStrictFoldUFMnonDetStrictFoldUFM_DirectlynonDetUFMToList partitionUFM pluralUFMplusMaybeUFM_CplusUFM plusUFMList plusUFM_C plusUFM_CD plusUFM_CD2pprUFMpprUFMWithKeys pprUniqFM seqEltsUFMsizeUFM ufmToIntMapufmToSet_DirectlyunitDirectlyUFMunitUFMunsafeCastUFMKeyunsafeIntMapToUFMzipToUFM NonDetUniqFM getNonDetaddrRepDataConTyanyTyanyTyCon anyTypeOfKindboolTy boolTyCon boolTyConName boolTyCon_RDRboxedRepDataConTyConboxingDataCon_maybe cTupleDataConcTupleDataConNamecTupleDataConNames cTupleSelIdcTupleSelIdName cTupleTyConcTupleTyConNamecTupleTyConNameArity_maybecTupleTyConNames charDataConcharTy charTyCon charTyConName charTyCon_RDRcoercibleClasscoercibleDataConcoercibleTyConcoercibleTyConName consDataConconsDataConNameconsDataCon_RDRconstraintKindTyConconstraintKindTyConName doubleDataCondoubleElemRepDataConTydoubleRepDataConTydoubleTy doubleTyCondoubleTyConNameeqClass eqDataConeqTyCon eqTyConName eqTyCon_RDR falseDataConfalseDataConId false_RDR filterCTuple floatDataConfloatElemRepDataConTyfloatRepDataConTyfloatTy floatTyConfloatTyConNameheqClass heqDataConheqTyCon heqTyConNameint16ElemRepDataConTyint16RepDataConTyint32ElemRepDataConTyint32RepDataConTyint64ElemRepDataConTyint64RepDataConTyint8ElemRepDataConTyint8RepDataConTy intDataConintDataCon_RDRintRepDataConTyintTyintTyCon intTyConName intTyCon_RDRintegerINDataConintegerINDataConNameintegerIPDataConintegerIPDataConNameintegerISDataConintegerISDataConName integerTy integerTyConintegerTyConNameisBuiltInOcc_maybeisCTupleTyConNameisPromotedMaybeTyisPromotedPairType justDataConjustDataConName levityTyConliftedDataConTyliftedDataConTyCon liftedRepTyliftedRepTyConliftedRepTyConNameliftedTypeKindTyConliftedTypeKindTyConName listTyCon listTyConName listTyCon_RDRmakeRecoveryTyCon manyDataConmanyDataConName manyDataConTymanyDataConTyCon maybeTyConmaybeTyConNamemkBoxedTupleTymkListTy mkMaybeTymkPromotedListTymkPromotedMaybeTymkPromotedPairTymkSumTy mkTupleStr mkTupleTy mkTupleTy1mkWiredInIdNamemkWiredInTyConName multMulTyConmultiplicityTymultiplicityTyConmultiplicityTyConNamenaturalNBDataConnaturalNBDataConNamenaturalNSDataConnaturalNSDataConName naturalTy naturalTyConnaturalTyConName nilDataConnilDataConNamenothingDataConnothingDataConName oneDataCononeDataConName oneDataConTyoneDataConTyCon ordEQDataConordEQDataConId ordGTDataConordGTDataConId ordLTDataConordLTDataConId orderingTyCon pairTyConpromotedConsDataConpromotedEQDataConpromotedFalseDataConpromotedGTDataConpromotedJustDataConpromotedLTDataConpromotedNilDataConpromotedNothingDataConpromotedTrueDataConpromotedTupleDataCon runtimeRepTyruntimeRepTyConstringTystringTyCon_RDR sumDataConsumRepDataConTyConsumTyCon trueDataCon trueDataConIdtrue_RDR tupleDataContupleDataConNametupleRepDataConTyCon tupleTyContupleTyConNametypeSymbolKindtypeSymbolKindContypeToTypeKindunboxedSumKindunboxedTupleKindunboxedUnitDataCon unboxedUnitTyunboxedUnitTyCon unitDataCon unitDataConIdunitTy unitTyCon unitTyConKeyunliftedDataConTyunliftedDataConTyCon unliftedRepTyunliftedRepTyConunliftedRepTyConNameunliftedTypeKindTyConunliftedTypeKindTyConNameunrestrictedFunTyConNamevec16DataConTy vec2DataConTyvec32DataConTy vec4DataConTyvec64DataConTy vec8DataConTy vecCountTyCon vecElemTyConvecRepDataConTyCon wiredInTyConsword16ElemRepDataConTyword16RepDataConTyword32ElemRepDataConTyword32RepDataConTyword64ElemRepDataConTyword64RepDataConTy word8DataConword8ElemRepDataConTyword8RepDataConTyword8Ty word8TyCon wordDataConwordRepDataConTywordTy wordTyCon wordTyConName LayoutInfo VirtualBracesExplicitBraces NoLayoutInfo HsImplBangHsUnpackHsLazyHsStrict HsSrcBang SrcStrictness SrcStrict NoSrcStrictSrcLazySrcUnpackedness SrcUnpack NoSrcUnpack SrcNoUnpackAltBindNonRecRec TaggedBndrTBRule BuiltinRuleru_rough ru_orphan ru_originru_localru_autoru_tryru_nargsru_rhsru_nameru_fnru_bndrsru_actru_argsLetLamCaseTickLitAppGHC.Types.Id.InfoIdInfolfInfo unfoldingInforuleInfooccInfoinlinePragInfo dmdSigInfo cprSigInfo demandInfo UnfoldingOtherCon NoUnfolding DFunUnfolding BootUnfolding CoreUnfoldinguf_tmpluf_srcuf_is_work_free uf_is_value uf_is_top uf_is_conlike uf_guidance uf_expandabledf_condf_argsdf_bndrsUnfoldingGuidanceUnfWhen UnfIfGoodArgsUnfNever ug_unsat_okug_sizeug_res ug_boring_okug_argsug_arityUnfoldingSource InlineStableInlineCompulsory InlineRhsCoreBind<&&><||>abstractDataTypeall2 applyWhenatLength capitalise changeLastcharToC chkAppend chunkListcmpList compareLengthcount countWhile debugIsOndoesDirNameExistdropListdropTaildropWhileEndLEeqListBy eqMaybeBy equalLength escapeSpaces exactLog2 expectOnly filterByList filterByLists filterOutfirst3MfirstMfoldl2fst3fstOf3 fuzzyLookup fuzzyMatchgetCmdgetModificationUTCTime ghciSupported hashString isDarwinHostisEqualisIn isSingleton isSortedBy isWindowsHostisn'tInlast2 lastMaybeleLength lengthAtLeast lengthAtMost lengthExceedslengthIs lengthIsNotlengthLessThanliftFstliftSnd listLengthCmplooksLikeModuleNamelooksLikePackageNameltLengthmakeRelativeTo mapAndUnzip mapAndUnzip3mapFstmapLastMmapSnd mergeListsByminWithmodificationTimeIfExistsnTimesnotNullnubSortonlyordNub overrideWithpartitionByList partitionWithreadHexRationalreadHexSignificandExponentPair readRationalreadSignificandExponentPair removeSpacesreslashsecondMseqList singletonsnd3sndOf3snocViewspanEndsplit splitAtListsplitLongestPrefixstretchZipWith strictMaptakeListthdOf3thenCmpthird3toArgs toCmdArgstransitiveClosureuncurry3 unzipWith whenNonEmptywithAtomicRename zipAndUnzipzipEqualzipLazy zipWith3Equal zipWith3Lazy zipWith4EqualzipWithAndUnzip zipWithEqual zipWithLazy Direction BackwardsForwardsOverridingBoolNeverAlwaysAutoSuffixisInferredArgFlag isLocalVar isNonCoVarId isTcTyVar isTyCoVar isTyVarBinder lazySetIdInfo lookupVarBndr mapVarBndr mapVarBndrsmkExportedLocalVar mkGlobalVar mkLocalVar mkTcTyVarmkTyVarmustHaveLocalBinding nonDetCmpVar setIdDetails setIdExportedsetIdNotExportedsetTcTyVarDetails setTyVarKind setTyVarNamesetTyVarUnique setVarName setVarType setVarUniquetcTyVarDetails tyVarNametyVarReqToBindertyVarReqToBinderstyVarSpecToBinderupdateTyVarKindupdateTyVarKindM updateVarTypeupdateVarTypeM varMultMaybe varUniqueDFunIdDictIdEqVarInCoVarInTyVarIpIdKindVarNcIdOutCoVarOutTyVarTKVarTypeVar IdDetails TickBoxOpId VanillaIdRecSelIdPrimOpIdFCallId DataConWrapId DataConWorkIdCoVarId ClassOpId sel_naughty sel_tyconEqSpecArgCoreBndrGHC.Types.Literal LitNumType LitNumWord64 LitNumInt64 LitNumWord8 LitNumWord32 LitNumWord16 LitNumWord LitNumNatural LitNumInteger LitNumInt8 LitNumInt32 LitNumInt LitNumInt16RuleOpts roPlatformroNumConstantFolding roBignumRulesroExcessRationalPrecision InScopeEnvAltConLitAltDataAltDEFAULT classDataCon dataConBoxerdataConCannotMatchdataConDisplayType dataConEqSpecdataConExTyCoVarsdataConFieldTypedataConFieldType_maybedataConFullSigdataConIdentitydataConImplBangsdataConImplicitTyThingsdataConInstArgTysdataConInstOrigArgTysdataConInstSig dataConNamedataConNonlinearTypedataConOrigArgTysdataConOrigResTydataConOrigTyCondataConOtherThetadataConRepArgTysdataConRepAritydataConRepStrictnessdataConRepTypedataConSourceAritydataConStupidTheta dataConTag dataConTagZ dataConThetadataConUnivAndExTyCoVarsdataConUnivTyVarsdataConUserTyVarBindersdataConUserTyVarsdataConUserTyVarsArePermuted dataConWorkId dataConWrapIddataConWrapId_maybeeqHsBang eqSpecPair eqSpecPreds eqSpecTyVar eqSpecType filterEqSpecisBangedisBoxedTupleDataCon isNewDataConisNullaryRepDataConisNullarySrcDataCon isSrcStrict isSrcUnpackedisTupleDataConisUnboxedSumDataConisUnboxedTupleDataCon mkDataConmkEqSpecpromoteDataConspecialPromotedDcsplitDataProductType_maybe substEqSpec DataConRep NoDataConRepDCR dcr_wrap_id dcr_stricts dcr_boxer dcr_arg_tys dcr_bangsCafInfo NoCafRefsMayHaveCafRefs LFUnlifted LFUnknownLFThunk LFReEntrantLFCon LFLetNoEscapeRuleInfo RecSelParent RecSelData RecSelPatSynadjustDNameEnv alterDNameEnv alterNameEnv anyNameEnvdelFromDNameEnvdelFromNameEnvdelListFromNameEnvdepAnaldisjointNameEnv elemNameEnv emptyDNameEnv emptyNameEnvextendDNameEnv extendNameEnvextendNameEnvListextendNameEnvList_CextendNameEnv_AccextendNameEnv_CfilterDNameEnv filterNameEnvisEmptyNameEnvlookupDNameEnv lookupNameEnvlookupNameEnv_NF mapDNameEnv mapNameEnv mkNameEnv mkNameEnvWith nameEnvElts plusNameEnv plusNameEnv_CplusNameEnv_CDplusNameEnv_CD2 unitNameEnvDNameEnv$$$+$<+><>alwaysQualifyModulesalwaysQualifyNamesalwaysQualifyPackages angleBracketsarrowarrowtarrowttasmStyle blankLinebracesbracketsbufLeftRenderSDocbulletcatcharcmdlineParserStyle codeStylecoloncolouredcommacparendarrowdcolondefaultDumpStyledefaultErrStyledefaultSDocContextdefaultUserStyledoOrDoes docToSDocdotdouble doublePrec doubleQuotes dumpStyleemptyequalsfcatfloat forAllLitfsepftext getPprDebug getPprStylehang hangNotEmptyhcathsep ifPprDebugint intWithCommasinteger interpp'SP interpp'SP' interppSPisEmptyisOrAre itsOrTheirkeywordlambdalarrowlarrowtlarrowttlbracelbracklollipoplparen mkDumpStyle mkErrStyle mkUserStylemulArrownest neverQualifyneverQualifyModulesneverQualifyNamesneverQualifyPackagesparenspluralppUnlessppUnlessOptionppWhen ppWhenOptionpprCode pprDeeper pprDeeperListpprFastFilePathpprFilePathString pprHsBytes pprHsChar pprHsString pprInfixVar pprPrefixVar pprPrimChar pprPrimInt pprPrimInt16 pprPrimInt32 pprPrimInt64 pprPrimInt8 pprPrimWord pprPrimWord16 pprPrimWord32 pprPrimWord64 pprPrimWord8 pprQuotedList pprSetDepth pprWithBars pprWithCommasprimCharSuffixprimDoubleSuffixprimFloatSuffixprimInt16SuffixprimInt32SuffixprimInt64SuffixprimInt8Suffix primIntSuffixprimWord16SuffixprimWord32SuffixprimWord64SuffixprimWord8SuffixprimWordSuffix printSDoc printSDocLnptext punctuate qualModulequalName qualPackage queryQualquotequotedListWithNorquotedListWithOrquotesrationalrbracerbrackreallyAlwaysQualifyreallyAlwaysQualifyNamesrenderWithContextrparenrunSDoc sdocOptionsdocWithContextsemisepsetStyleColouredshowSDocOneLinespacespeakNspeakNOfspeakNthtext underscore unicodeSyntaxupdSDocContext userStylevbarvcat whenPprDebug withErrStyle withPprStyle withUserStylewordztext BindingSiteCaseBind CasePatBindLetBind LambdaBindDepthPartWay AllTheWay DefaultDepth LabelStyleAsmStyleCStylePDoc QueryQualifyqueryQualifyPackagequeryQualifyModulequeryQualifyName QualifyName NameUnqualNameQualNameNotInScope1NameNotInScope2QueryQualifyModuleQueryQualifyNameQueryQualifyPackage SDocContextSDCsdocSuppressStgExts sdocStylesdocStarIsTypesdocShouldUseColorsdocPrintUnicodeSyntaxsdocPrintTypeAbbreviationssdocPrintPotentialInstancessdocPrintExplicitRuntimeRepssdocPrintExplicitKindssdocPrintExplicitForallssdocPrintEqualityRelationssdocPrintAxiomIncomps sdocPprDebugsdocLinearTypessdocLineLengthsdocLastColoursdocImpredicativeTypessdocHexWordLiteralssdocErrorSpanssdocDefaultDepth sdocColSchemesdocCanUseUnicodesdocSuppressVarKindssdocSuppressUnfoldingssdocSuppressTypeSignaturessdocSuppressTypeApplicationssdocSuppressTickssdocSuppressIdInfosdocSuppressCoercionssdocPrintCaseAsLetsdocPrintExplicitCoercionssdocPrintTypecheckerElaborationsdocSuppressUniquessdocUnitIdForUsersdocSuppressModulePrefixesGHC.Serialized SerializedassertPprPanic callStackDochandleGhcExceptionpanicDoc pgmErrorDocpprPanicsafeShowException showExceptionshowGhcExceptionUnsafesorryDocthrowGhcExceptionthrowGhcExceptionIOtryMost assertPanic cmdLineErrorcmdLineErrorIOpgmErrorprogNamesorryemptyFullModIfaceemptyIfaceHashCacheemptyPartialModIfacemi_bootmi_fix mi_free_holesmi_semantic_modulemkIfaceHashCacherenameFreeHolesIfaceBackendExts IfaceDeclExts IfaceExportModIfaceBackend mi_warn_fnmi_plugin_hashmi_orphan_hash mi_orphan mi_opt_hash mi_mod_hash mi_iface_hash mi_hpc_hash mi_hash_fn mi_flag_hash mi_fix_fn mi_exp_hash mi_finstsPartialModIfaceWhetherHasFamInstWhetherHasOrphansapplyTypeToArg bindersOfbindersOfBinds bootUnfoldingboringCxtNotOk boringCxtOk canUnfoldchooseOrphanAnchorcmpAlt cmpAltConcollectAnnArgscollectAnnArgsTickscollectAnnBndrs collectArgscollectArgsTickscollectBinderscollectNAnnBndrscollectNBinderscollectTyAndValBinderscollectTyBindersdeAnnAlt deAnnBind deAnnotate deAnnotate' deTagExpr emptyRuleEnvevaldUnfoldingexpandUnfolding_maybeexprToCoercion_maybe exprToType flattenBindshasCoreUnfoldinghasSomeUnfolding isAutoRuleisBootUnfolding isBuiltinRuleisCheapUnfoldingisCoArgisCompulsoryUnfoldingisConLikeUnfoldingisEvaldUnfoldingisExpandableUnfolding isLocalRuleisOrphan isRuntimeArg isRuntimeVarisStableSourceisStableUnfolding isTyCoArg isTypeArgisValArgisValueUnfoldingltAltmaybeUnfoldingTemplatemkApps mkCharLitmkCoAppsmkCoBindmkConApp mkConApp2 mkDoubleLitmkDoubleLitDouble mkFloatLitmkFloatLitFloatmkInt64LitInt64mkIntLit mkIntLitWrapmkLamsmkLet mkLetNonRecmkLetRecmkLets mkOtherCon mkRuleEnv mkStringLitmkTyAppsmkTyArgmkTyBind mkVarAppsmkWord64LitWord64 mkWord8Lit mkWordLit mkWordLitWrap needSaturatedneverUnfoldGuidance noUnfolding notOrphan otherCons rhssOfAlts rhssOfBindruleActivation ruleArity ruleIdName ruleModuleruleName setRuleIdName stripNArgs unSaturatedOkunfoldingTemplate valArgCount valBndrCount varToCoreExprvarsToCoreExprsAnnAltAnnBind AnnNonRecAnnExprAnnExpr'AnnVarAnnTickAnnLit AnnCoercionAnnCastAnnAppCoreAltCoreArg CoreProgramIdUnfoldingFunInAltInArgInBindInBndr InCoercionInExprInKindInTypeIsOrphan NotOrphan MOutCoercionOutAltOutArgOutBindOutBndr OutCoercionOutExprOutKindOutTypeRuleBaseRuleEnvre_basere_visible_orphsRuleFun TaggedAlt TaggedArg TaggedBind TaggedExprLiteral LitRubbish LitNullAddrLitLabel LitString LitNumberLitFloatLitChar LitDoubleGHC.Unit.Module.Env ModuleSetinitUniqSupplyinitUsinitUs_listSplitUniqSupplymkSplitUniqSupplysplitUniqSupplytakeUniqFromSupply uniqFromMaskuniqFromSupplyuniqsFromSupplyGHC.Driver.PprpprDebugAndThen pprSTracepprTrace pprTraceDebugpprTraceException pprTraceIt pprTraceMpprTraceWithFlags printForC printForUsershowPpr showPprUnsafeshowSDoc showSDocDebug showSDocDumpshowSDocForUsershowSDocUnsafe warnPprTraceGHC.Unit.State UnitStatewireMap unwireMap unitInfoMaprequirementContext preloadUnitspreloadClosurepluginModuleNameProvidersMappackageNameMapmoduleNameProvidersMapallowVirtualUnits explicitUnits GHC.Platform PlatformMisc!platformMisc_targetPlatformStringplatformMisc_llvmTargetplatformMisc_libFFIplatformMisc_ghcWithSMPplatformMisc_ghcWithInterpreterplatformMisc_ghcRTSWaysplatformMisc_ghcRtsWithLibdwGHC.Platform.ConstantsPlatformConstants pc_WORD_SIZEpc_TICKY_BIN_COUNT pc_TAG_BITSpc_STD_HDR_SIZEpc_SIZEOF_StgUpdateFrame_NoHdr"pc_SIZEOF_StgSmallMutArrPtrs_NoHdrpc_SIZEOF_StgSMPThunkHeaderpc_SIZEOF_StgMutArrPtrs_NoHdrpc_SIZEOF_StgFunInfoExtraRevpc_SIZEOF_StgArrBytes_NoHdrpc_SIZEOF_CostCentreStackpc_RESERVED_STACK_WORDSpc_RESERVED_C_STACK_BYTESpc_REP_StgFunInfoExtraRev_aritypc_REP_StgFunInfoExtraFwd_aritypc_REP_StgEntCounter_allocspc_REP_StgEntCounter_allocd pc_REP_CostCentreStack_scc_count pc_REP_CostCentreStack_mem_allocpc_PROF_HDR_SIZEpc_OFFSET_stgGCFunpc_OFFSET_stgGCEnter1pc_OFFSET_stgEagerBlackholeInfopc_OFFSET_bdescr_startpc_OFFSET_bdescr_freepc_OFFSET_bdescr_flagspc_OFFSET_bdescr_blocks pc_OFFSET_StgUpdateFrame_updateepc_OFFSET_StgTSO_stackobjpc_OFFSET_StgTSO_cccspc_OFFSET_StgTSO_alloc_limitpc_OFFSET_StgStack_stackpc_OFFSET_StgStack_sp!pc_OFFSET_StgSmallMutArrPtrs_ptrspc_OFFSET_StgRegTable_rZMM6pc_OFFSET_StgRegTable_rZMM5pc_OFFSET_StgRegTable_rZMM4pc_OFFSET_StgRegTable_rZMM3pc_OFFSET_StgRegTable_rZMM2pc_OFFSET_StgRegTable_rZMM1pc_OFFSET_StgRegTable_rYMM6pc_OFFSET_StgRegTable_rYMM5pc_OFFSET_StgRegTable_rYMM4pc_OFFSET_StgRegTable_rYMM3pc_OFFSET_StgRegTable_rYMM2pc_OFFSET_StgRegTable_rYMM1pc_OFFSET_StgRegTable_rXMM6pc_OFFSET_StgRegTable_rXMM5pc_OFFSET_StgRegTable_rXMM4pc_OFFSET_StgRegTable_rXMM3pc_OFFSET_StgRegTable_rXMM2pc_OFFSET_StgRegTable_rXMM1pc_OFFSET_StgRegTable_rSpLimpc_OFFSET_StgRegTable_rSppc_OFFSET_StgRegTable_rR9pc_OFFSET_StgRegTable_rR8pc_OFFSET_StgRegTable_rR7pc_OFFSET_StgRegTable_rR6pc_OFFSET_StgRegTable_rR5pc_OFFSET_StgRegTable_rR4pc_OFFSET_StgRegTable_rR3pc_OFFSET_StgRegTable_rR2pc_OFFSET_StgRegTable_rR10pc_OFFSET_StgRegTable_rR1pc_OFFSET_StgRegTable_rL1pc_OFFSET_StgRegTable_rHpLimpc_OFFSET_StgRegTable_rHpAllocpc_OFFSET_StgRegTable_rHppc_OFFSET_StgRegTable_rF6pc_OFFSET_StgRegTable_rF5pc_OFFSET_StgRegTable_rF4pc_OFFSET_StgRegTable_rF3pc_OFFSET_StgRegTable_rF2pc_OFFSET_StgRegTable_rF1pc_OFFSET_StgRegTable_rD6pc_OFFSET_StgRegTable_rD5pc_OFFSET_StgRegTable_rD4pc_OFFSET_StgRegTable_rD3pc_OFFSET_StgRegTable_rD2pc_OFFSET_StgRegTable_rD1!pc_OFFSET_StgRegTable_rCurrentTSO%pc_OFFSET_StgRegTable_rCurrentNurserypc_OFFSET_StgRegTable_rCCCSpc_OFFSET_StgMutArrPtrs_sizepc_OFFSET_StgMutArrPtrs_ptrspc_OFFSET_StgHeader_ldvwpc_OFFSET_StgHeader_ccs"pc_OFFSET_StgFunInfoExtraRev_arity"pc_OFFSET_StgFunInfoExtraFwd_arity#pc_OFFSET_StgEntCounter_registeredppc_OFFSET_StgEntCounter_link#pc_OFFSET_StgEntCounter_entry_countpc_OFFSET_StgEntCounter_allocspc_OFFSET_StgEntCounter_allocdpc_OFFSET_StgArrBytes_bytes#pc_OFFSET_CostCentreStack_scc_count#pc_OFFSET_CostCentreStack_mem_allocpc_OFFSET_Capability_rpc_MUT_ARR_PTRS_CARD_BITSpc_MIN_PAYLOAD_SIZEpc_MIN_INTLIKEpc_MIN_CHARLIKEpc_MAX_XMM_REGpc_MAX_Vanilla_REGpc_MAX_SPEC_SELECTEE_SIZEpc_MAX_SPEC_AP_SIZEpc_MAX_Real_XMM_REGpc_MAX_Real_Vanilla_REGpc_MAX_Real_Long_REGpc_MAX_Real_Float_REGpc_MAX_Real_Double_REGpc_MAX_Long_REGpc_MAX_INTLIKEpc_MAX_Float_REGpc_MAX_Double_REGpc_MAX_CHARLIKE pc_LDV_SHIFTpc_ILDV_STATE_USEpc_ILDV_STATE_CREATEpc_ILDV_CREATE_MASKpc_DYNAMIC_BY_DEFAULTpc_CONTROL_GROUP_CONST_291 pc_CLONG_SIZEpc_CLONG_LONG_SIZE pc_CINT_SIZE pc_BLOCK_SIZEpc_BLOCKS_PER_MBLOCKpc_AP_STACK_SPLIMpc_BITMAP_BITS_SHIFTdeserializeWithDatafromSerializedserializeWithData toSerialized arityInfocafInfo callArityInfo coVarDetails emptyRuleInfoisCoVarDetailsisEmptyRuleInfoisJoinIdDetails_maybeisNeverLevPolyIdInfo levityInfomayHaveCafRefs noCafIdInfo oneShotInfo ppArityInfo ppCafInfo pprIdDetails pprStrictnessruleInfoFreeVars ruleInfoRules setArityInfo setCafInfosetCallArityInfo setCprSigInfo setDemandInfo setDmdSigInfosetInlinePragInfo setLFInfosetLevityInfoWithTypesetNeverLevPoly setOccInfosetOneShotInfo setRuleInfosetRuleInfoHeadsetUnfoldingInfo unknownArity vanillaIdInfozapCallArityInfo zapDemandInfozapFragileInfo zapLamInfozapTailCallInfo zapUnfoldingzapUsageEnvInfo zapUsageInfozapUsedOnceInfo ArityInfoInlinePragInfo LevityInfo TickBoxId TickBoxOpTickBoxDVarSet NonCaffySetoptimisationFlagsaddGlobalIncludeaddPluginModuleNameaddQuoteIncludeallNonDeprecatedFlags compilerInfodefaultDynFlagsdefaultFatalMessagerdefaultFlushErrdefaultFlushOut defaultWaysdoptdopt_set dopt_unsetdynFlagDependenciesdynamicOutputFiledynamicTooStateextraGccViaCFlagsfFlags fLangFlags flagSpecOfflagsAll flagsDynamicflagsForCompletion flagsPackageflattenIncludesgetOpts getVerbFlags ghcUsagePath ghciUsagePathglasgowExtsFlagsglobalPackageDatabasePathgopt_set gopt_unsethasNoDebugOutputhasNoOptCoercionhasNoStateHack hasPprDebughiSuf impliedGFlagsimpliedOffGFlags impliedXFlagsinitDefaultSDocContext initDynFlagsinitSDocContext isAvx2EnabledisAvx512cdEnabledisAvx512erEnabledisAvx512fEnabledisAvx512pfEnabled isAvxEnabled isBmi2Enabled isBmiEnabledisNoLink isOneShot isSse2EnabledisSse4_2Enabled isSseEnabledlang_setlanguageExtensionsmakeDynFlagsConsistent objectSufopt_Fopt_Lopt_Popt_P_signatureopt_aopt_copt_cxxopt_iopt_lopt_lcopt_lccopt_lmopt_lo opt_windres outputFilepackageFlagsChangedpackageTrustOnparseDynamicFilePragmaparseDynamicFlagsCmdLineparseDynamicFlagsFullpgm_Fpgm_Lpgm_Ppgm_Tpgm_apgm_arpgm_cpgm_dllpgm_ipgm_install_name_toolpgm_lpgm_lcpgm_lcc pgm_libtoolpgm_lmpgm_lo pgm_otool pgm_ranlib pgm_windres picCCOptspicPOptspositionIndependentpprDynFlagsDiff programNameprojectVersionsafeDirectImpsReqsafeHaskellModeEnabled safeHaskellOnsafeImplicitImpsReq safeImportsOn safeInferOnsafeLanguageOnsccProfilingEnabled setDynamicNowsetDynamicTooFailedsetFlagsFromEnvFilesetGeneralFlag' setTmpDir setUnitIdsetUnsafeGlobalDynFlagssettingssmallestGroupssupportedLanguagesAndExtensions targetProfiletmpDirtopDirturnOffturnOnunSetGeneralFlag' unsafeFlagsunsafeFlagsForInfer updOptLevelversionedAppDirversionedFilePath wWarningFlags warningGroupswarningHierarchieswayswopt wopt_fatalwopt_setwopt_set_fatal wopt_unsetwopt_unset_fatal wordAlignmentxFlagsxoptxopt_DuplicateRecordFieldsxopt_FieldSelectorsxopt_setxopt_set_unlessExplSpec xopt_unset GHC.SettingssExtraGccViaCFlagssGccSupportsNoPie sGhcRTSWayssGhcRtsWithLibdw sGhcUsagePathsGhcWithInterpreter sGhcWithSMPsGhciUsagePathsGlobalPackageDatabasePath sLdIsGnuLdsLdSupportsBuildIdsLdSupportsCompactUnwindsLdSupportsFilelistsLibFFIsOpt_FsOpt_LsOpt_PsOpt_P_fingerprintsOpt_asOpt_csOpt_cxxsOpt_isOpt_lsOpt_lcsOpt_lccsOpt_lmsOpt_lo sOpt_windressPgm_FsPgm_LsPgm_PsPgm_TsPgm_asPgm_arsPgm_csPgm_dllsPgm_isPgm_lsPgm_lcsPgm_lcc sPgm_libtoolsPgm_lmsPgm_lo sPgm_ranlib sPgm_windres sProgramNamesProjectVersionsTargetPlatformStringsTmpDirsToolDirsTopDirshowOptOpt_D_verbose_stg2stgOpt_D_verbose_core2coreOpt_D_th_dec_fileOpt_D_source_statsOpt_D_ppr_debugOpt_D_no_debug_outputOpt_D_dump_worker_wrapperOpt_D_dump_vt_trace!Opt_D_dump_view_pattern_commoningOpt_D_dump_typesOpt_D_dump_timingsOpt_D_dump_tickedOpt_D_dump_tc_traceOpt_D_dump_tc_ast Opt_D_dump_tcOpt_D_dump_stranalOpt_D_dump_str_signaturesOpt_D_dump_stg_unarisedOpt_D_dump_stg_from_coreOpt_D_dump_stg_finalOpt_D_dump_splicesOpt_D_dump_specOpt_D_dump_simpl_traceOpt_D_dump_simpl_statsOpt_D_dump_simpl_iterationsOpt_D_dump_simplOpt_D_dump_rulesOpt_D_dump_rule_rewritesOpt_D_dump_rule_firingsOpt_D_dump_rttiOpt_D_dump_rn_traceOpt_D_dump_rn_statsOpt_D_dump_rn_ast Opt_D_dump_rnOpt_D_dump_prepOpt_D_dump_parsed_astOpt_D_dump_parsedOpt_D_dump_opt_cmmOpt_D_dump_occur_analOpt_D_dump_mod_mapOpt_D_dump_mod_cyclesOpt_D_dump_llvmOpt_D_dump_jsonOpt_D_dump_inliningsOpt_D_dump_if_traceOpt_D_dump_hieOpt_D_dump_hi_diffs Opt_D_dump_hiOpt_D_dump_foreignOpt_D_dump_faststringsOpt_D_dump_exitifyOpt_D_dump_ec_traceOpt_D_dump_ds_preopt Opt_D_dump_dsOpt_D_dump_derivOpt_D_dump_debugOpt_D_dump_cseOpt_D_dump_cs_traceOpt_D_dump_cpranalOpt_D_dump_cpr_signaturesOpt_D_dump_core_statsOpt_D_dump_cmm_verbose_by_procOpt_D_dump_cmm_verboseOpt_D_dump_cmm_switchOpt_D_dump_cmm_splitOpt_D_dump_cmm_spOpt_D_dump_cmm_sinkOpt_D_dump_cmm_rawOpt_D_dump_cmm_procmapOpt_D_dump_cmm_procOpt_D_dump_cmm_infoOpt_D_dump_cmm_from_stgOpt_D_dump_cmm_cpsOpt_D_dump_cmm_cfgOpt_D_dump_cmm_cbeOpt_D_dump_cmm_cafOpt_D_dump_cmmOpt_D_dump_cfg_weightsOpt_D_dump_call_arityOpt_D_dump_c_backendOpt_D_dump_asm_statsOpt_D_dump_asm_regalloc_stagesOpt_D_dump_asm_regallocOpt_D_dump_asm_nativeOpt_D_dump_asm_livenessOpt_D_dump_asm_expandedOpt_D_dump_asm_conflictsOpt_D_dump_BCOsOpt_D_dump_asmLanguage Haskell98GHC2021 Haskell2010 WarningFlagOpt_WarnWrongDoBindOpt_WarnWarningsDeprecationsOpt_WarnUnusedTypePatternsOpt_WarnUnusedTopBindsOpt_WarnUnusedRecordWildcardsOpt_WarnUnusedPatternBindsOpt_WarnUnusedPackagesOpt_WarnUnusedMatchesOpt_WarnUnusedLocalBindsOpt_WarnUnusedImportsOpt_WarnUnusedForallsOpt_WarnUnusedDoBind$Opt_WarnUntickedPromotedConstructorsOpt_WarnUnsupportedLlvmVersion%Opt_WarnUnsupportedCallingConventionsOpt_WarnUnsafe Opt_WarnUnrecognisedWarningFlagsOpt_WarnUnrecognisedPragmasOpt_WarnUnbangedStrictPatternsOpt_WarnTypedHolesOpt_WarnTypeDefaultsOpt_WarnTrustworthySafe Opt_WarnTabsOpt_WarnStarIsTypeOpt_WarnStarBinderOpt_WarnSpaceAfterBang$Opt_WarnSimplifiableClassConstraintsOpt_WarnSemigroup Opt_WarnSafe Opt_WarnRedundantRecordWildcardsOpt_WarnRedundantConstraintsOpt_WarnRedundantBangPatterns"Opt_WarnPrepositiveQualifiedModuleOpt_WarnPartialTypeSignaturesOpt_WarnPartialFieldsOpt_WarnOverlappingPatternsOpt_WarnOverflowedLiteralsOpt_WarnOrphans%Opt_WarnOperatorWhitespaceExtConflictOpt_WarnOperatorWhitespace#Opt_WarnNonCanonicalMonoidInstances"Opt_WarnNonCanonicalMonadInstances&Opt_WarnNonCanonicalMonadFailInstancesOpt_WarnNameShadowingOpt_WarnMonomorphismOpt_WarnMissingSignaturesOpt_WarnMissingSafeHaskellMode'Opt_WarnMissingPatternSynonymSignatures!Opt_WarnMissingMonadFailInstancesOpt_WarnMissingMethodsOpt_WarnMissingLocalSignaturesOpt_WarnMissingKindSignaturesOpt_WarnMissingImportListOpt_WarnMissingHomeModulesOpt_WarnMissingFields!Opt_WarnMissingExportedSignaturesOpt_WarnMissingExportList!Opt_WarnMissingDerivingStrategiesOpt_WarnMissedSpecsOpt_WarnMissedExtraSharedLibOpt_WarnInvalidHaddockOpt_WarnInlineRuleShadowingOpt_WarnInferredSafeImportsOpt_WarnIncompleteUniPatterns Opt_WarnIncompletePatternsRecUpdOpt_WarnIncompletePatternsOpt_WarnInaccessibleCodeOpt_WarnImplicitPreludeOpt_WarnImplicitLiftOpt_WarnImplicitKindVarsOpt_WarnIdentitiesOpt_WarnHiShadowsOpt_WarnEmptyEnumerationsOpt_WarnDuplicateExportsOpt_WarnDuplicateConstraintsOpt_WarnDodgyImportsOpt_WarnDodgyForeignImportsOpt_WarnDodgyExportsOpt_WarnDerivingTypeableOpt_WarnDerivingDefaultsOpt_WarnDeprecatedFlagsOpt_WarnDeferredTypeErrors#Opt_WarnDeferredOutOfScopeVariables Opt_WarnCompatUnqualifiedImportsOpt_WarnCPPUndefOpt_WarnAutoOrphansOpt_WarnAmbiguousFieldsOpt_WarnAllMissedSpecs)Opt_WarnAlternativeLayoutRuleTransitional CompilerInfo UnknownCCGCCClang AppleClang AppleClang51ContainsDynFlagsextractDynFlags DynLibLoader DeployableSystemDependentDynamicTooStateDT_OK DT_FailedDT_DontDT_Dyn FatalMessagerFlagSpec flagSpecNameflagSpecGhcModeflagSpecAction flagSpecFlagFlushErrFlushOut HasDynFlagsIgnorePackageFlag IgnorePackage IncludeSpecsincludePathsGlobalincludePathsQuote LinkerInfo UnknownLD SolarisLDLlvmLLDGnuLDGnuGoldAixLDDarwinLD LlvmConfig llvmPasses llvmTargets LlvmTarget lDataLayout lAttributeslCPU ModRenamingmodRenamingWithImplicit modRenamings PackageArg UnitIdArg PackageDBFlag PackageDBNoUserPackageDBClearPackageDBsNoGlobalPackageDB PackageFlag ExposePackage HidePackagePkgDbRef UserPkgDb GlobalPkgDb PkgDbPathProfAuto ProfAutoTopProfAutoExports ProfAutoCalls NoProfAuto ProfAutoAllRtsOptsEnabledRtsOptsSafeOnly RtsOptsNoneRtsOptsIgnoreAll RtsOptsAll RtsOptsIgnore TrustFlagDistrustPackage TrustPackage TurnOnFlag FileSettingsfileSettings_topDirfileSettings_toolDirfileSettings_tmpDir"fileSettings_globalPackageDatabasefileSettings_ghcUsagePathfileSettings_ghciUsagePathGhcNameVersionghcNameVersion_programNameghcNameVersion_projectVersionSettings sToolSettingssTargetPlatform sRawSettings sPlatformMiscsPlatformConstants sFileSettingssGhcNameVersionDiagnosticReasonWarningWithoutFlagErrorWithoutFlagWarningWithFlag ModuleEnv advanceBufPos advancePsLoc advanceSrcLoc cmpBufSpancombineRealSrcSpanscombineSrcSpans containsSpangeneratedSrcLocgeneratedSrcSpan getBufPos getBufSpaninteractiveSrcLocinteractiveSrcSpanisGeneratedSrcSpan isOneLineSpanisRealSubspanOfisZeroWidthSpanleftmostColumnliftL lookupSrcLoc lookupSrcSpanmapLocmkGeneralSrcLocmkGeneralSrcSpanmkPsSpan mkRealSrcLoc mkRealSrcSpan mkSrcSpanPs pprLocatedpprUnhelpfulSpanReasonpprUserRealSpan pprUserSpan psSpanEnd psSpanStartrealSrcLocSpanrealSrcSpanEndrealSrcSpanStart sortLocatedsortRealLocatedsrcSpanFileName_maybesrcSpanFirstCharactersrcSpanToRealSrcSpanunhelpfulSpanFSwiredInSrcSpanBufPosbufPosBufSpan bufSpanEnd bufSpanStartPsLocpsBufPos psRealLoc PsLocatedPsSpan psBufSpan psRealSpanUnhelpfulSpanReasonUnhelpfulWiredInUnhelpfulOtherUnhelpfulNoLocationInfoUnhelpfulGeneratedUnhelpfulInteractiveGHC.Unit.ModulegetModuleInstantiationgetUnitInstantiationsinstalledModuleEq isHoleModule mkHoleModulemoduleIsDefinitemoduleStableStringstableModuleCmpuninstantiateInstantiatedModuleuninstantiateInstantiatedUnitdelInstalledModuleEnv delModuleEnvdelModuleEnvList delModuleSet elemModuleEnv elemModuleSetemptyInstalledModuleEnvemptyModuleEnvemptyModuleSetextendInstalledModuleEnvextendModuleEnvextendModuleEnvListextendModuleEnvList_CextendModuleEnvWithextendModuleSetextendModuleSetListfilterInstalledModuleEnvfilterModuleEnvintersectModuleSetisEmptyModuleEnvlookupInstalledModuleEnvlookupModuleEnvlookupWithDefaultModuleEnv mapModuleEnvminusModuleSet mkModuleEnv mkModuleSet moduleEnvElts moduleEnvKeysmoduleEnvToList moduleSetElts plusModuleEnvplusModuleEnv_CunionModuleSet unitModuleEnv unitModuleSet addBootSuffixaddBootSuffixLocnaddBootSuffixLocnOutaddBootSuffix_mayberemoveBootSuffixContainsModule extractModule HasModule getModuleDModuleNameEnvInstalledModuleEnv ModuleNameEnvaddListToUniqSetaddOneToUniqSetdelListFromUniqSetdelListFromUniqSet_DirectlydelOneFromUniqSetdelOneFromUniqSet_DirectlydisjointUniqSetselemUniqSet_DirectlyelementOfUniqSet emptyUniqSet filterUniqSetfilterUniqSet_Directly getUniqSetintersectUniqSetsisEmptyUniqSet lookupUniqSetlookupUniqSet_Directly mapUniqSet minusUniqSet mkUniqSetnonDetEltsUniqSetnonDetKeysUniqSetnonDetStrictFoldUniqSetpartitionUniqSet pprUniqSetrestrictUniqSetToUFM sizeUniqSetunionManyUniqSets unionUniqSets uniqSetAll uniqSetAnyuniqSetMinusUDFMuniqSetMinusUFM unitUniqSetunsafeUFMToUniqSetDVarEnv charToIntLitdoubleToFloatLitdoubleToIntLit extendIntLit extendWordLitfloatToDoubleLit floatToIntLit inCharRange intToCharLitintToDoubleLit intToFloatLitisLitValue_maybe isMaxBound isMinBoundisOneLit isZeroLit litFitsInChar litIsDupable litIsLifted litIsTriviallitNumCheckRange litNumCoercelitNumIsSigned litNumNarrow litNumWraplitValue literalType mapLitValue mkLitChar mkLitDouble mkLitFloatmkLitInt mkLitInt16mkLitInt16UncheckedmkLitInt16Wrap mkLitInt32mkLitInt32UncheckedmkLitInt32Wrap mkLitInt64mkLitInt64UncheckedmkLitInt64Wrap mkLitInt8mkLitInt8Unchecked mkLitInt8WrapmkLitIntUnchecked mkLitIntWrap mkLitIntWrapC mkLitInteger mkLitNatural mkLitNumbermkLitNumberWrap mkLitRubbish mkLitString mkLitWord mkLitWord16mkLitWord16UncheckedmkLitWord16Wrap mkLitWord32mkLitWord32UncheckedmkLitWord32Wrap mkLitWord64mkLitWord64UncheckedmkLitWord64Wrap mkLitWord8mkLitWord8UncheckedmkLitWord8WrapmkLitWordUnchecked mkLitWordWrapmkLitWordWrapCnarrowInt16LitnarrowInt32Lit narrowInt8LitnarrowWord16LitnarrowWord32LitnarrowWord8Lit nullAddrLit pprLiteraladdRnInScopeSet alterDVarEnv alterVarEnv anyDVarEnv dVarEnvEltsdelBndrLdelBndrR delBndrsL delBndrsR delDVarEnvdelDVarEnvList delInScopeSetdelTidyEnvList delVarEnv delVarEnvListdisjointVarEnv elemDVarEnvelemInScopeSet elemVarEnvelemVarEnvByKey emptyDVarEnv emptyTidyEnv emptyVarEnv extendDVarEnvextendDVarEnvListextendDVarEnv_CextendInScopeSetextendInScopeSetListextendInScopeSetSet extendVarEnvextendVarEnvListextendVarEnv_AccextendVarEnv_C filterDVarEnv filterVarEnv foldDVarEnvgetInScopeVarsinRnEnvLinRnEnvRisEmptyDVarEnv isEmptyVarEnv lookupDVarEnv lookupInScopelookupInScope_DirectlylookupRnInScope lookupVarEnvlookupVarEnv_NFlookupWithDefaultVarEnv mapDVarEnv mapVarEnv minusDVarEnv minusVarEnv mkDVarEnvmkEmptyTidyEnv mkInScopeSetmkRnEnv2mkVarEnvmkVarEnv_Directly modifyDVarEnv modifyVarEnvmodifyVarEnv_DirectlynonDetStrictFoldDVarEnv nukeRnEnvL nukeRnEnvRpartitionDVarEnvpartitionVarEnv plusDVarEnv plusDVarEnv_CplusMaybeVarEnv_C plusVarEnvplusVarEnvList plusVarEnv_C plusVarEnv_CDrestrictVarEnvrnBndr2 rnBndr2_varrnBndrLrnBndrRrnBndrs2rnEnvLrnEnvRrnEtaLrnEtaR rnInScope rnInScopeSetrnOccL rnOccL_maybernOccR rnOccR_maybernSwap unionInScopeuniqAway unitDVarEnv unitVarEnvunsafeGetFreshLocalUnique varSetInScope zipVarEnvCoVarEnvDIdEnv DTyVarEnvIdEnv TyCoVarEnvTyVarEnv addDefaultaltsAreExhaustiveapplyTypeToArgs bindNonRec cheapEqExpr cheapEqExpr'collectMakeStaticArgscombineIdenticalAlts coreAltType coreAltsTypedataConRepFSInstPat diffBindsdiffExprdumpIdInfoOfProgrameqExpr exprIsCheap exprIsCheapX exprIsConLike exprIsDeadEnd exprIsDupableexprIsExpandable exprIsHNFexprIsTickedStringexprIsTickedString_maybeexprIsTopLevelBindable exprIsTrivialexprIsWorkFreeexprOkForSideEffectsexprOkForSpeculation filterAltsfindAlt findDefaultgetIdFromTrivialExprgetIdFromTrivialExpr_maybe isCheapApp isDefaultAlt isEmptyTyisExpandableApp isExprLevPoly isJoinBindisUnsafeEqualityProof mergeAlts mkAltExprmkCast mkDefaultCasemkFunctionType mkLamType mkLamTypesmkSingleAltCasemkTick mkTickNoHNFmkTicksneedsCaseBindingrefineDefaultAlt scaleAltsBy stripTicksE stripTicksT stripTicksTopstripTicksTopEstripTicksTopT tickHNFArgs trimConArgs tryEtaReduce zapLamBndrs CheapAppFun bindFreeVarsbndrRuleAndUnfoldingIdsbndrRuleAndUnfoldingVarsDSet dIdFreeVars exprFreeIdsexprFreeIdsDSetexprFreeIdsList exprFreeVarsexprFreeVarsDSetexprFreeVarsListexprSomeFreeVarsexprSomeFreeVarsListexpr_fvs exprsFreeIdsexprsFreeIdsDSetexprsFreeIdsList exprsFreeVarsexprsFreeVarsListexprsOrphNamesexprsSomeFreeVarsexprsSomeFreeVarsListfreeVars freeVarsBind freeVarsOf freeVarsOfAnnidFVs idFreeVars idRuleVarsidUnfoldingVars mkRuleInfoorphNamesOfAxiomorphNamesOfFamInst ruleFreeVarsruleLhsFreeIdsruleLhsFreeIdsListruleRhsFreeVars rulesFreeVarsrulesFreeVarsDSetrulesRhsFreeIdsstableUnfoldingVarsvarTypeTyCoFVsvarTypeTyCoVarsCoreAltWithFVsCoreBindWithFVsCoreExprWithFVsCoreExprWithFVs'FVAnn GHC.Utils.FVInterestingVarFunIdSetDIdSet allDVarSet allVarSet anyDVarSet anyVarSet dVarSetElemsdVarSetIntersectVarSetdVarSetMinusVarSetdVarSetToVarSet delDVarSetdelDVarSetList delVarSetdelVarSetByKey delVarSetListdisjointDVarSetdisjointVarSet elemDVarSet elemVarSetelemVarSetByKey emptyDVarSet emptyVarSet extendDVarSetextendDVarSetList extendVarSetextendVarSetList filterDVarSet filterVarSet fixVarSetintersectDVarSetintersectVarSetintersectsDVarSetintersectsVarSetisEmptyDVarSet isEmptyVarSet lookupVarSetlookupVarSetByNamelookupVarSet_Directly mapDVarSetmapUnionDVarSetmapUnionVarSet mapVarSet minusDVarSet minusVarSet mkDVarSetmkVarSetnonDetStrictFoldDVarSetnonDetStrictFoldVarSetpartitionDVarSetpartitionVarSet pluralVarSet pprVarSet seqDVarSet seqVarSet sizeDVarSet sizeVarSet subDVarSet subVarSettransCloDVarSettransCloVarSet unionDVarSet unionDVarSets unionVarSet unionVarSets unitDVarSet unitVarSetCoVarSet GHC.Core.MakeaBSENT_ERROR_IDaBSENT_SUM_FIELD_ERROR_IDcastBottomExprerrorIds floatBindingsmkAbsentErrorApp mkBigCoreTupmkBigCoreTupTymkBigCoreVarTupmkBigCoreVarTup1mkBigCoreVarTupTy mkBuildExpr mkCharExpr mkConsExpr mkCoreApp mkCoreApps mkCoreConApps mkCoreLams mkCoreLet mkCoreLets mkCoreTupmkCoreTupBoxity mkCoreUbxSum mkCoreUbxTupmkCoreVarTupTy mkDoubleExpr mkFloatExpr mkFoldrExpr mkIfThenElsemkImpossibleExpr mkIntExprInt mkIntegerExpr mkJustExpr mkListExpr mkNaturalExpr mkNilExpr mkNothingExprmkRuntimeErrorAppmkSmallTupleCasemkSmallTupleSelector mkStringExprmkStringExprFSmkStringExprFSWith mkTupleCasemkTupleSelectormkTupleSelector1mkUncheckedIntExpr mkWildCasemkWildEvBindermkWildValBinder mkWordExprnON_EXHAUSTIVE_GUARDS_ERROR_IDnO_METHOD_BINDING_ERROR_ID pAT_ERROR_IDrEC_CON_ERROR_IDrEC_SEL_ERROR_IDrUNTIME_ERROR_ID sortQuantVars tYPE_ERROR_IDunitExpr wrapFloat FloatBind FloatCaseFloatLet addSimplCount bindsOnlyPass debugTraceMsgdebugTraceMsgSdoFreeSimplTick doSimplTick dumpIfSet_dynerrorMsg errorMsgS fatalErrorMsgfatalErrorMsgSgetAnnotationsgetFirstAnnotationsgetPackageFamInstEnv getRuleBase getUniqMaskgetVisibleOrphanModshasDetailedCountsliftIOWithCountmsgpprPassDetailsputMsgputMsgSrunCoreMrunMayberunWhen simplCountNCoreMCorePluginPassCoreToDo CoreOccurAnalCoreLiberateCaseCoreDoWorkerWrapperCoreDoStaticArgsCoreDoSpecialisingCoreDoSpecConstrCoreDoSimplifyCoreDoRuleCheckCoreDoPrintCoreCoreDoPluginPass CoreDoPasses CoreDoNothingCoreDoFloatOutwardsCoreDoFloatInwards CoreDoExitify CoreDoDemand CoreDoCprCoreDoCallArityCoreDesugarOpt CoreDesugarCoreCSECoreAddCallerCcsCorePrepCoreTidyFloatOutSwitchesfloatToTopLevelOnlyfloatOutOverSatAppsfloatOutConstantsfloatOutLambdas SimplMode sm_uf_optssm_rules sm_pre_inlinesm_phasesm_names sm_logger sm_inline sm_eta_expand sm_case_case sm_dflags UnfoldingDoneSimplifierDone RuleFiredPreInlineUnconditionallyPostInlineUnconditionallyLetFloatFromLet KnownBranchFillInCaseDefault EtaReduction EtaExpansion CaseOfCase CaseMerge CaseIdentityCaseElimAltMerge BetaReductionGHC.Unit.Module.ModGutsModGutsmg_warns mg_used_th mg_usages mg_trust_pkgmg_tcsmg_safe_haskellmg_rules mg_rdr_env mg_patsyns mg_module mg_modBreaksmg_locmg_insts mg_inst_env mg_hsc_src mg_hpc_infomg_foreign_files mg_foreign mg_fix_env mg_fam_instsmg_fam_inst_env mg_exports mg_doc_hdrmg_deps mg_decl_docsmg_complete_matches mg_arg_docsmg_bindsmg_anns hsc_unit_env hsc_unit_dbshsc_type_env_var hsc_tmpfs hsc_targetshsc_static_plugins hsc_plugins hsc_mod_graph hsc_interp hsc_hookshsc_NChsc_IChsc_HPThsc_FChsc_EPS hsc_dflags hsc_loggerCgGuts cg_tyconscg_spt_entries cg_module cg_modBreaks cg_hpc_infocg_foreign_files cg_foreigncg_binds cg_dep_pkgsGHC.Types.Annotations Annotation ann_target ann_valuedeserializeAnns emptyAnnEnvextendAnnEnvListfindAnnsfindAnnsByTypeRepmkAnnEnv plusAnnEnvAnnEnv AnnPayload AnnTarget ModuleTarget NamedTarget CoreAnnTargetaddOneFVallUsesdelFVdelFVsdelFromNameSetdelListFromNameSetdisjointNameSetduDefsduUses elemNameSetemptyDUsemptyFVs emptyNameSet extendNameSetextendNameSetList filterNameSetfindUses intersectFVsintersectNameSetintersectsNameSet isEmptyFVsisEmptyNameSet minusNameSetmkDUsmkFVs mkNameSetnameSetElemsStableplusDUplusFVplusFVs unionNameSet unionNameSetsunitFV unitNameSetusesOnlyDefUseDefUsesDefsFreeVarsUses hptAllThingshptAnnshptCompleteSigs hptInstanceshptRuleshptSomeThingsBelowUshscEPS hsc_home_unit hsc_unitslookupIfaceByModule lookupType mainModIsmkInteractiveHscEnvprepareAnnotationsrunHscrunInteractiveHscHscGHC.Driver.Plugins LoadedPluginlpModulelpPlugin StaticPluginspPlugin UnitDatabaseunitDatabasePathunitDatabaseUnitshfIsLclpprHoleFitCand CandPlugin FitPluginHoleFit RawHoleFithfWraphfTypehfRefLvl hfMatcheshfIdhfCandhfDocHoleFitCandidate NameHFCand GreHFCandIdHFCand TypedHoleth_relevant_ctsth_hole th_implics GHC.Unit.InfocollectExtraCcOptscollectFrameworkscollectFrameworksDirscollectIncludeDirscollectLibraryDirs mapUnitInfomkUnit mkUnitKeyInfo mkUnitPprInfo pprUnitInfo unitHsLibsunitPackageIdStringunitPackageNameStringGHC.Unit.DatabaseGenericUnitInfounitPackageVersionunitPackageName unitPackageId unitLibraries unitIsTrustedunitIsIndefinite unitIsExposedunitInstantiationsunitInstanceOf unitIncludesunitIncludeDirsunitImportDirsunitIdunitHiddenModulesunitHaddockInterfacesunitHaddockHTMLsunitExtDepLibsGhcunitExtDepFrameworksunitExtDepFrameworkDirsunitExposedModules unitDependsunitComponentName unitCcOptions unitAbiHashunitAbiDependsunitLibraryDirsunitLibraryDynDirsunitExtDepLibsSysunitLinkerOptions GenUnitInfo PackageId PackageName unPackageNameUnitInfo UnitKeyInfo closeUnitDepscloseUnitDeps'emptyUnitState getUnitDbRefs improveUnit initUnitsinstModuleToModuleinstUnitToUnit listUnitInfolistVisibleModuleNameslookupModuleInAllUnitslookupModuleWithSuggestionslookupPackageName!lookupPluginModuleWithSuggestions lookupUnit lookupUnit' lookupUnitId lookupUnitId'mayThrowUnitErrpprFlag pprModuleMap pprReasonpprUnitIdForUserpprUnitInfoForUserpprUnitspprUnitsSimplepprWithUnitStatereadUnitDatabasereadUnitDatabasesrenameHoleModulerenameHoleModule'renameHoleUnitrenameHoleUnit'requirementMergesresolveUnitDatabasesearchPackageIdunsafeLookupUnitunsafeLookupUnitId unwireUnit LookupResultLookupUnusableLookupNotFoundLookupMultiple LookupFound LookupHidden ModuleOrigin ModUnusable ModHidden ModOriginfromPackageFlag fromOrigUnitfromExposedReexportfromHiddenReexportModuleSuggestion SuggestHiddenSuggestVisible ShHoleSubstUnitErr TrustFlagErr CloseUnitErrPackageFlagErr UnitInfoMapUnusableUnitReasonShadowedDependenciesIgnoredWithFlagIgnoredDependenciesBrokenDependenciesCyclicDependenciesExtendedModSummaryemsInstantiatedUnits emsModSummarydefaultFrontendPlugin defaultPlugin flagRecompile impurePluginkeepRenamedSource lpModuleName mapPluginspluginRecompile'plugins purePlugin withPlugins withPlugins_CommandLineOption CorePluginFrontendPluginfrontendFrontendPluginActionPlugintypeCheckResultActiontcPluginspliceRunActionrenamedResultActionpluginRecompileparsedResultActioninterfaceLoadAction holeFitPlugininstallCoreToDos driverPluginPluginRecompileNoForceRecompileForceRecompileMaybeRecompilePluginWithArgs paArgumentspaPluginGHC.Types.MetaMetaHookextendModSummaryNoDeps findTarget isBootSummarymsDynObjFilePath msHiFilePath msHsFilePath msObjFilePathms_home_allimpsms_impsms_installed_mod ms_unitid metaRequestAW metaRequestD metaRequestE metaRequestP metaRequestT MetaRequestMetaTMetaPMetaEMetaAWMetaD MetaResultmkSrcErrsrcErrorMessages throwErrors throwOneErrorGHC.Data.FiniteMap deleteList foldRightfoldRightWithKey insertListinsertListWithFixitylookupFixityRn'DuplicateRecordFieldseqPmLit eqConLikepickQuantifiablePreds GHC.ClassesEqOrdEnumSeparateBagsDerivStuff AuxBindSpec rnImportDeclLanguage.Haskell.Syntax.Type LHsQTyVarsmergeIfaceDecl HsTyVarBndrHsForAllTelescopeTcTyMode ViaStrategyGHC.Types.SourceFile HscSourceIOLanguage.Haskell.Syntax.ExprHsMatchContext addPhiCts leftToRight topToBottomHsExprLanguage.Haskell.Syntax.LitOverLitMatch MatchGroupLanguage.Haskell.Syntax.PatPatGRHSsGRHSLHsExprrootNGHC.Cmm.CLabelCLabelStringCtOriginGHC.ReadReadGHC.ShowShowStandAloneDerivOriginDerivClauseOriginFalse DerivStrategy andThenCheckHappyStk array-0.5.4.0Data.Array.BaseUArrayGHC.Runtime.Interpreter.TypesIServ ForeignRef RemoteRefInterpinterpInstance interpLoader IServConfigiservConfTraceiservConfProgramiservConfProfiled iservConfOptsiservConfDynamic iservConfHook IServInstance iservProcess iservPipeiservLookupSymbolCacheiservPendingFrees IServState IServPending IServRunningInterpInstanceExternalInterpHsAppMaybeGHC.Unit.Module.ModDetails ModDetailsPipelineOutput Temporary PersistentInstantiationNode BuildModuleLanguage.Haskell.Syntax.BindsABExportABE XABExportabe_wrap abe_pragsabe_polyabe_extabe_monoGHC.Hs.ExtensionGhcTcGhcRnGhcPsAmbiguousFieldOccXAmbiguousFieldOcc Ambiguous UnambiguousAnnDecl HsAnnotationXAnnDecl AnnProvenanceValueAnnProvenanceModuleAnnProvenanceTypeAnnProvenanceApplicativeArgXApplicativeArgApplicativeArgManyApplicativeArgOnexarg_app_arg_onexarg_app_arg_many stmt_context is_body_stmt final_expr bv_patternarg_exprapp_arg_pattern app_stmts ArithSeqInfoFromTo FromThenToFromFromThen ClsInstDecl XClsInstDeclcid_tyfam_instscid_sigs cid_poly_tycid_overlap_modecid_ext cid_bindscid_datafam_insts GHC.Hs.ExprCmdTopTcCoPat co_pat_ty co_cpt_wrap co_pat_innerConDeclXConDecl ConDeclGADT ConDeclH98 con_res_ty con_namescon_name con_mb_cxt con_g_ext con_g_args con_forallcon_ext con_ex_tvscon_doccon_args con_bndrs ConDeclField XConDeclField cd_fld_type cd_fld_names cd_fld_doc cd_fld_extConPatTccpt_wrapcpt_tvs cpt_dicts cpt_arg_tys cpt_bindsDataFamInstDecldfid_eqn DefaultDecl XDefaultDeclDerivClauseTysXDerivClauseTysDctMulti DctSingle DerivDecl XDerivDecl deriv_typederiv_strategy deriv_extderiv_overlap_modeNewtypeStrategy StockStrategyAnyclassStrategyFamEqnXFamEqn feqn_tyconfeqn_rhs feqn_pats feqn_fixity feqn_bndrsfeqn_ext FamilyDecl XFamilyDeclfdTyVars fdTopLevel fdResultSigfdLNamefdInjectivityAnnfdInfofdExtfdFixity FamilyInfoOpenTypeFamilyClosedTypeFamily DataFamilyFamilyResultSigXFamilyResultSigTyVarSigNoSigKindSigFieldLabelStringsFieldOcc XFieldOcc extFieldOccrdrNameFieldOcc FixitySig XFixitySig ForeignDecl XForeignDecl ForeignExport ForeignImport fd_sig_tyfd_namefd_i_extfd_fifd_e_extfd_feFunDepXFunDepXGRHSLocatedAHsCmdXCmdHsCmdParHsCmdLet HsCmdLamCaseHsCmdLamHsCmdIfHsCmdDo HsCmdCase HsCmdArrFormHsCmdApp HsCmdArrAppXExprSectionRSectionL RecordUpd RecordConOpAppNegApp HsUnboundVarHsTickHsTcBracketOutHsStatic HsSpliceEHsRnBracketOutHsRecFld HsProjectionHsProcHsPragE HsOverLabel HsMultiIfHsLet HsLamCaseHsLamHsIfHsIPVar HsGetFieldHsDo HsConLikeOutHsCase HsBinTick HsAppType ExprWithTySig ExplicitTuple ExplicitSumArithSeq HsOverLitHsLitHsParHsVar HsBracket ExplicitList rupd_fldsrupd_ext rupd_expr rcon_fldsrcon_extrcon_con proj_fldsproj_extgf_fieldgf_exprgf_extXGRHSsgrhssLocalBindsgrhssExt grhssGRHSsHsArgHsValArgHsArgPar HsTypeArgHsArrowHsUnrestrictedArrowHsExplicitMult HsLinearArrowHsBindLR XHsBindsLRVarBindPatBindFunBind PatSynBindAbsBindsvar_rhsvar_idvar_ext pat_tickspat_rhspat_extfun_tick fun_matchesfun_idfun_extabs_tvsabs_sigabs_ext abs_exports abs_ev_vars abs_ev_binds abs_bindspat_lhsXBracketVarBrTypBrTExpBrPatBrExpBrDecBrGDecBrLHsCmdTopXCmdTopHsConDeclGADTDetails PrefixConGADT RecConGADT HsDataDefn XHsDataDefn dd_kindSigdd_ext dd_derivsdd_ctxtdd_consdd_NDdd_cTypeHsDeclXHsDeclWarningDTyClDSpliceDRuleDKindSigDInstDForDDocDDerivDDefDAnnD RoleAnnotDValDSigDHsDerivingClauseXHsDerivingClausederiv_clause_tysderiv_clause_extderiv_clause_strategy HsFieldLabel XHsFieldLabelhflExthflLabelXHsForAllTelescope HsForAllInvis HsForAllVishsf_xvis hsf_xinvishsf_invis_bndrs hsf_vis_bndrsXHsGroup hs_warndshs_valds hs_tyclds hs_splcds hs_ruledshs_fordshs_fixdshs_exths_docs hs_derivdshs_anndshs_defds HsIPBindsIPBinds XHsIPBindsXLit HsWordPrim HsWord64Prim HsStringPrimHsStringHsRat HsInteger HsIntPrim HsInt64PrimHsInt HsFloatPrim HsDoublePrimHsChar HsCharPrimHsLocalBindsLRXHsLocalBindsLR HsValBindsEmptyLocalBinds ThPatSplice ThPatQuoteStmtCtxtRecUpdProcExpr PatBindRhs PatBindGuards LambdaExprIfAltFunRhsPatSyn mc_strictness mc_fixitymc_funHsOuterTyVarBndrsXHsOuterTyVarBndrsHsOuterExplicitHsOuterImplicit hso_ximplicit hso_bndrs hso_xexplicitXOverLit ol_witnessol_extol_val HsPatSigTypeHsPS XHsPatSigType hsps_bodyhsps_ext HsPatSynDirUnidirectionalExplicitBidirectionalImplicitBidirectional HsPragSCCXHsPragE HsRecField' HsRecFieldhsRecPun hsRecFieldLbl hsRecFieldAnn hsRecFieldArg HsRecFields rec_dotdotrec_fldsHsScaled HsSigTypeHsSig XHsSigTypesig_ext sig_bndrssig_bodyHsSpliceXSpliceHsUntypedSplice HsTypedSplice HsQuasiQuote HsSplicedHsSplicedThing HsSplicedTy HsSplicedExpr HsSplicedPat HsStmtContext TransStmtCtxtPatGuard ParStmtCtxt MonadCompMDoExpr GhciStmtCtxtDoExprListComp ArrowExprHsTupArgXTupArgMissingPresent XTyVarBndr KindedTyVar UserTyVarHsTypeXHsType HsWildCardTyHsTyLit HsTupleTyHsSumTyHsStarTy HsSpliceTyHsRecTyHsQualTyHsParTyHsOpTy HsKindSig HsIParamTy HsForAllTyHsExplicitTupleTyHsExplicitListTyHsDocTyHsBangTyHsAppTy HsAppKindTyHsFunTyHsListTyHsTyVar hst_xqual hst_xforallhst_telehst_bodyhst_ctxt HsValBindsLRValBinds XValBindsLRHsWildCardBndrsHsWCXHsWildCardBndrs hswc_bodyhswc_ext GHC.Hs.ImpExpIEXIE IEThingWith IEThingAllIEModuleContentsIEGroup IEDocNamedIEDocIEVar IEThingAbsIPBindXIPBind ImportDecl XImportDeclideclSourceSrc ideclSource ideclSafeideclQualified ideclPkgQual ideclName ideclImplicit ideclHidingideclAsideclExtInjectivityAnnXInjectivityAnnInstDecl XInstDecl TyFamInstDClsInstD DataFamInstD tfid_insttfid_ext dfid_instdfid_ext cid_d_extcid_instHsQTvs XLHsQTyVars hsq_explicithsq_ext ListPatTcXMatchm_patsm_grhssm_ctxtm_extMG XMatchGroup mg_originmg_altsmg_ext GHC.Hs.Binds NHsValBindsLR NValBinds ParStmtBlock XParStmtBlockXPatWildPatViewPatTuplePatSumPat SplicePatSigPatParPat NPlusKPatNPatLitPatListPatLazyPatConPatBangPatVarPatAsPat pat_con_extpat_argspat_conPSB XPatSynBindpsb_idpsb_extpsb_dirpsb_argspsb_defPendingRnSplicePendingTcSplice RecStmtTc recS_ret_ty recS_rec_rets recS_bind_tyrecS_later_retsRecordPatSynFieldrecordPatSynFieldrecordPatSynPatVar RecordUpdTc rupd_wrap rupd_out_tys rupd_cons rupd_in_tys RoleAnnotDeclXRoleAnnotDeclRuleBndr XRuleBndr RuleBndrSigRuleDeclHsRule XRuleDeclrd_tyvsrd_tmvsrd_rhsrd_namerd_lhsrd_actrd_ext RuleDeclsHsRules XRuleDeclsrds_srcrds_ext rds_rulesSigXSigSpecSig SpecInstSig SCCFunSig PatSynSig MinimalSig InlineSigIdSigFixSigCompleteMatchSigTypeSig ClassOpSig SpliceDecl XSpliceDeclStandaloneKindSigXStandaloneKindSigStmtLRXStmtLR TransStmtRecStmtParStmtLetStmtLastStmtBodyStmtApplicativeStmtBindStmt trS_using trS_stmtstrS_rettrS_formtrS_fmaptrS_exttrS_by trS_bndrstrS_bind recS_stmts recS_ret_fn recS_rec_ids recS_mfix_fnrecS_later_ids recS_bind_fnrecS_ext SyntaxExprRnNoSyntaxExprRn SyntaxExprTcNoSyntaxExprTc syn_res_wrap syn_arg_wrapssyn_exprTyClDecl XTyClDeclSynDeclFamDecl ClassDeclDataDecl tcdTyVarstcdSigstcdSExttcdRhstcdMethstcdLName tcdFixitytcdFamtcdFExttcdFDstcdDocs tcdDataDefntcdDExttcdCtxttcdCExt tcdATDefstcdATs TyClGroup XTyClGroup group_tyclds group_roles group_kisigs group_ext group_instds TyFamInstDeclXTyFamInstDecltfid_eqntfid_xtnWarnDeclWarning XWarnDecl WarnDeclsWarnings XWarnDecls wd_warningswd_extwd_src XBindStmtRn xbsrn_bindOp xbsrn_failOp XBindStmtTc xbstc_failOpxbstc_boundResultType xbstc_bindOpxbstc_boundResultMult GHC.Hs.DeclsXViaStrategyPs XXExprGhcTc ExpansionExprWrapExpr appendGroups emptyRdrGroup emptyRnGroupfamResultKindSignaturefamilyDeclLNamefamilyDeclNameflattenRuleDeclsfoldDerivStrategy getConNamesgetRecConArgs_maybehsConDeclTheta hsDeclHasCuskhsGroupTopLevelFixitySigsinstDeclDataFamInstsmapDerivStrategypartitionBindsAndSigspprDataFamInstFlavourpprHsFamInstLHSpprTyClDeclFlavourpprTyFamInstDeclresultVariableNameroleAnnotDeclNamestandaloneKindSigNametcdName tyClDeclLNametyFamInstDeclLNametyFamInstDeclNameannProvenanceName_maybecollectRuleBndrSigTyscountTyClDeclsderivStrategyName docDeclDochsGroupInstDecls isClassDeclisClosedTypeFamilyInfo isDataDeclisDataFamilyDecl isFamilyDeclisOpenTypeFamilyInfo isSynDeclisTypeFamilyDeclnewOrDataToFlavourpprFullRuleNametyClDeclTyVarstyClGroupInstDeclstyClGroupKindSigstyClGroupRoleDeclstyClGroupTyClDecls HsRuleAnn ra_tyannsra_rest ra_tmanns CImportSpecCWrapper CFunction DataDeclRn tcdDataCusktcdFVsDocDeclDocGroupDocCommentPrevDocCommentNamedDocCommentNextCExportCImportHsConDeclH98Details HsDerivingHsRuleRnHsTyPatsLAnnDecl LClsInstDeclLConDeclLDataFamInstDecl LDefaultDeclLDerivClauseTys LDerivDeclLDerivStrategyLDocDecl LFamilyDeclLFamilyResultSig LForeignDeclLHsDeclLHsDerivingClause LHsFunDepLInjectivityAnn LInstDeclLRoleAnnotDecl LRuleBndr LRuleDecl LRuleDecls LSpliceDeclLStandaloneKindSig LTyClDeclLTyFamDefltDeclLTyFamInstDecl LTyFamInstEqn LWarnDecl LWarnDecls NewOrDataDataTypeNewTypeTyFamDefltDecl TyFamInstEqnPass TypecheckedParsedRenamedOutputableBndrIdGhcPass!Language.Haskell.Syntax.ExtensionIdPAnno SrcSpanAnnA SrcSpanAnnP SrcSpanAnnC SrcSpanAnnLXAnnD NoExtFieldXAnyClassStrategyEpAnn XCClsInstDecl AnnSortKey NoAnnSortKey XCDefaultDecl XCDerivDeclXCFamEqn XCFamilyDeclXCFunDep XCHsDataDefnXCHsDerivingClause XCHsGroupXCInjectivityAnn XCKindSigXCRoleAnnotDecl XCRuleBndr XCRuleDecls XCTyClGroupXCTyFamInstDecl XClassDecl XClsInstD XConDeclGADT XConDeclH98 XDataDecl XDataFamInstD XDctMulti XDctSingleXDefDXDerivDXDocDXFamDeclXForDXForeignExportXForeignImport XHsAnnotationEpAnn' EpAnnNotUsedcommentsentryanns AnnPragmaapr_rest apr_closeapr_openXHsRuleXInstD XKindSigDXNewtypeStrategyXNoSig XRoleAnnotD XRuleBndrSigXRuleDXSigDXSpliceDXStockStrategyXSynDeclXTyClD XTyFamInstD XTyVarSigXValD XViaStrategy LHsSigType XWarningDXWarning XWarnings XXAnnDeclNoExtCon XXClsInstDecl XXConDecl XXDefaultDeclXXDerivClauseTys XXDerivDeclXXFamEqn XXFamilyDeclXXFamilyResultSig XXForeignDeclXXFunDep XXHsDataDefnXXHsDeclXXHsDerivingClause XXHsGroupXXInjectivityAnn XXInstDeclXXRoleAnnotDecl XXRuleBndr XXRuleDecl XXRuleDecls XXSpliceDeclXXStandaloneKindSig XXTyClDecl XXTyClGroupXXTyFamInstDecl XXWarnDecl XXWarnDeclsAddEpAnnLHsKindXRecLocatedNLocatedL LConDeclField LHsContextLHsType LFixitySigLHsBindsLSigHsOuterFamEqnTyVarBndrsIdGhcP SrcSpanAnnNcollectEvVarsPatcollectEvVarsPats hsRecFieldIdhsRecUpdFieldIdhsRecUpdFieldOcchsRecUpdFieldRdr isBangedLPatisIrrefutableHsPat isSimplePatlooksLazyPatBind mkCharLitPatmkNilPatmkPrefixConPatparenthesizePatpatNeedsParens pprConArgspprLPat pprParendLPat hsConPatArgs hsRecFieldSel hsRecFieldshsRecFieldsArgs EpAnnSumPatsumPatVbarsBefore sumPatParenssumPatVbarsAfterConLikePHsConPatDetails HsRecUpdField LHsRecField LHsRecField'LHsRecUpdFieldLPatXAsPatXBangPatXConPat XHsRecFieldXLazyPatXListPat SyntaxExprAnnList al_trailingal_restal_open al_anchoral_closeXLitPatXNPat XNPlusKPatXParPatAnnParenap_open ap_adornmentap_closeXSigPat XSplicePatXSumPat XTuplePatXVarPatXViewPatXWildPatXXPat EpaAnchorADAR LFieldOccHsBindIsPassghcPass emptyLHsBindsemptyLocalBindsemptyValBindsInemptyValBindsOuteqEmptyLocalBindsisEmptyIPBindsPRisEmptyIPBindsTcisEmptyLHsBindsisEmptyValBindsplusHsValBinds pprDeclList pprLHsBindspprLHsBindsForUser pprMinimalSigpprSpecpprTcSpecPragspprTicks pprVarSig ppr_monobindppr_sig pragBracketspragSrcBrackets hasSpecPragshsSigDocisCompleteMatchSigisDefaultMethod isFixityLSig isInlineLSig isMinimalLSig isPragLSig isSCCFunSigisSpecInstLSig isSpecLSig isTypeLSig noSpecPragsAnnSigasDcolonasRest HsLocalBindsHsPatSynDetailsLHsBind LHsBindLR LHsBindsLR LHsLocalBindsLHsLocalBindsLRLIPBind LTcSpecPrag TcSpecPragSpecPrag TcSpecPragsIsDefaultMethod SpecPragsXABE XAbsBindsXCIPBind XClassOpSigXCompleteMatchSigXEmptyLocalBindsXFixSigXFunBind XHsValBindsXIPBindsXIdSig XInlineSig XMinimalSigXPSBXPatBind XPatSynSig XSCCFunSig XSpecInstSigXSpecSigXTypeSig XValBindsXVarBind XXABExport XXFixitySig XXHsBindsLR XXHsIPBindsXXHsLocalBindsLRXXIPBind XXPatSynBindXXSig XXValBindsLR GHC.Hs.Lit convertLit overLitType pmPprHsLit pp_st_suffixhsLitNeedsParenshsOverLitNeedsParensnegateOverLitVal OverLitTc ol_rebindableol_type OverLitVal HsIsString HsFractional HsIntegralXHsChar XHsCharPrim XHsDoublePrim XHsFloatPrim XHsInt64PrimXHsInt XHsIntPrim XHsIntegerXHsRat XHsString XHsStringPrim XHsWord64Prim XHsWordPrimXXLit XXOverLitambiguousFieldOcc arrowToHsType dropWildCards emptyLHsQTvsfromMaybeContextgetBangStrictness getBangTypegetLHsInstDeclClass_maybegetLHsInstDeclHeadhsAllLTyVarNameshsExplicitLTyVarNameshsLTyVarLocNamehsLTyVarLocNames hsLTyVarName hsLTyVarNameshsOuterExplicitBndrshsOuterTyVarNames hsScopedTvs hsSigWcTypehsTvbAllKindedhsTyGetAppHead_maybe hsTyKindSighsTyVarBndrFlag hsTyVarNamehsTypeNeedsParens hsWcScopedTvs ignoreParensisUnrestrictedlhsTypeArgSrcSpanmkAmbiguousFieldOccmkAnonWildCardTymkEmptyWildCardBndrs mkFieldOcc mkHsAppKindTy mkHsAppTysmkHsExplicitSigTypemkHsForAllInvisTelemkHsForAllVisTelemkHsImplicitSigTypemkHsOpTymkHsOuterExplicitmkHsOuterImplicitmkHsPatSigTypemkHsQTvsmkHsWildCardBndrsparenthesizeHsContextparenthesizeHsTypepprAnonWildCardpprConDeclFields pprHsForAllpprHsOuterFamEqnTyVarBndrspprHsOuterSigTyVarBndrs pprHsType pprLHsContextrdrNameAmbiguousFieldOccselectorAmbiguousFieldOccsetHsTyVarBndrFlagsplitHsFunTypesplitLHsForAllTyInvissplitLHsForAllTyInvis_KPsplitLHsGadtTysplitLHsInstDeclTysplitLHsPatSynTysplitLHsQualTysplitLHsSigmaTyInvisunambiguousFieldOcc hsIPNameFShsLinearhsMult hsPatSigType hsQTvExplicit hsScaledThinghsUnrestrictedisHsKindedTyVarmapHsOuterImplicit noTypeArgsnumVisibleArgs EpAnnForallTyOutputableBndrFlagBangType HsConDetailsRecConInfixCon PrefixCon HsContextHsCoreTyHsIPNameHsKindHsOuterSigTyVarBndrsHsPSRn hsps_imp_tvs hsps_nwcs HsTupleSortHsBoxedOrConstraintTupleHsUnboxedTupleHsStrTyHsCharTyHsNumTy LBangType LHsSigWcType LHsTyVarBndr LHsTypeArg LHsWcType NoGhcTcPass XAmbiguous XAppKindTyXAppTyXBangTy XCFieldOccXDocTyXExplicitListTyXExplicitTupleTy XForAllTyXFunTy TrailingAnn AddVbarAnn AddSemiAnn AddRarrowAnnU AddCommaAnn AddRarrowAnnXHsForAllInvis XHsForAllVisXHsOuterExplicitXHsOuterImplicitXHsPSXHsQTvsXHsSigXHsWC XIParamTyXKindSig XKindedTyVarXListTyXOpTyXParTyXQualTyXRecTy XSpliceTyXStarTyXSumTyXTupleTyXTyLitXTyVar XUnambiguous XUserTyVar XWildCardTyXXAmbiguousFieldOccXXConDeclField XXFieldOccXXHsForAllTelescopeXXHsOuterTyVarBndrsXXHsPatSigType XXHsSigTypeXXHsWildCardBndrs XXLHsQTyVars XXTyVarBndrXXTypeNoGhcTcUnXRecunXRec EpAnnComments EpaCommentsEpaCommentsBalancedfollowingComments priorCommentshsExprNeedsParens hsLMatchPatsisAtomicHsExprisEmptyMatchGroup isQuietHsCmd isQuietHsExprisSingletonMatchGroupmatchContextErrStringmatchGroupAritymkRnSyntaxExpr mkSyntaxExprnoExpr noSyntaxExprparenthesizeHsExpr pp_dotdotpp_rhspprArg pprBindStmtpprBindspprBypprCmd pprCmdArgpprComppprDebugParendExprpprDo pprFunBindpprGRHSpprGRHSs pprHsBracketpprLCmdpprLExprpprMatchpprMatchInCtxt pprMatches pprParendExprpprParendLExpr pprPatBindpprPendingSplicepprQuals pprSplice pprSpliceDeclpprStmt pprStmtInCtxt pprTransStmtpprTransformStmtppr_appsppr_cmd ppr_do_stmtsppr_exprppr_infix_exprppr_lcmd ppr_lexprppr_module_name_prefix ppr_quasi ppr_spliceppr_splice_declstripParensHsExprstripParensLHsExpr thBrackets thTyBrackets tupArgPresentisComprehensionContext isInfixMatchisMonadCompContextisMonadStmtContext isPatSynCtxtisTypedBracket isTypedSplicematchSeparatorpprAStmtContextpprExternalSrcLocpprFieldLabelStringspprMatchContextpprMatchContextNounpprStmtContextprependQualifiedqualifiedDoModuleName_maybeAnnExplicitSumaesOpenaesClose aesBarsAfter aesBarsBefore AnnFieldLabelafDot AnnProjectionapCloseapOpenAnnsLetalInalLet DelayedSplice EpAnnHsCasehsCaseAnnsRest hsCaseAnnCase hsCaseAnnOfEpAnnUnboundVarhsUnboundBackquotes hsUnboundHoleGrhsAnnga_sepga_vbar HsExpansion HsExpanded HsSplicedTHsWrap PostTcExpr PostTcTable SyntaxExprGhcApplicativeArgStmCtxPassCmdLStmtCmdStmtCmdSyntaxTable ExprLStmtExprStmt FailOperator GhciLStmtGhciStmt GuardLStmt GuardStmt HsArrAppTypeHsFirstOrderAppHsHigherOrderApp HsBracketRnHsDoRn HsRecordBindsLGRHSLHsCmd LHsCmdTop LHsRecProj LHsRecUpdProj LHsTupArgLMatchLStmtLStmtLR MatchGroupTc mg_arg_tys mg_res_tyPendingRnSplice'PendingTcSplice'RecProj RecUpdProjSpliceDecoration BareSplice DollarSpliceSplicePointNameStmtThModFinalizers TransForm GroupFormThenFormUntypedSpliceFlavourUntypedTypeSpliceUntypedPatSpliceUntypedDeclSpliceUntypedExpSpliceXXParStmtBlock SrcSpanAnn' SrcSpanAnnlocAannWrapXRecwrapXRecXAppEpAnnCO XAppTypeEXApplicativeArgManyXApplicativeArgOneXApplicativeStmt XArithSeqXBinTick XBindStmt XBodyStmtXCGRHSXCGRHSsXCHsFieldLabelXCMatchXCaseXCmdApp XCmdArrApp XCmdArrFormXCmdCaseXCmdDoXCmdIf XCmdLamCaseXCmdLamXCmdLetXCmdParXCmdWrap XConLikeOutXDecBrGXDecBrLXDoXExpBr XExplicitList XExplicitSumXExplicitTupleXExprWithTySig XGetFieldXIPVarXIfXLamCaseXLam XLastStmtXLetXLetStmtXLitEXMGXMissingXMultiIfXNegAppXOpApp XOverLabel XOverLitEXParXParStmtXPatBrXPragEXPresentXProc XProjection XQuasiQuoteXRecFldXRecStmt XRecordCon XRecordUpd XRnBracketOutXSCC XSectionL XSectionRXSpliceEXSplicedXStaticXTExpBr XTcBracketOutXTick XTransStmtXTypBr XTypedSplice XUnboundVarXUntypedSpliceXVarBrXVarXXApplicativeArg XXBracketXXCmdXXCmdTopXXExprXXGRHSXXGRHSsXXHsFieldLabelXXMatch XXMatchGroupXXPragEXXSpliceXXStmtLRXXTupArgieLWrappedNameieNameieNamesieWrappedLName ieWrappedNameimportDeclQualifiedStyleisImportDeclQualifiedlieWrappedName pprImpExpreplaceLWrappedNamereplaceWrappedNamesimpleImportDeclEpAnnImportDeclimportDeclAnnSafeimportDeclAnnQualifiedimportDeclAnnPragmaimportDeclAnnPackageimportDeclAnnAsimportDeclAnnImport IEWildcard NoIEWildcard IEWrappedNameIEName IEPatternImportDeclQualifiedStyle QualifiedPre NotQualified QualifiedPostLIELIEWrappedName LImportDecl XCImportDeclXIEDoc XIEDocNamedXIEGroupXIEModuleContents XIEThingAbs XIEThingAll XIEThingWithXIEVarXXIE XXImportDecl GHC.Hs.Doc HsDocStringpprIfPspprIfRnpprIfTc IsSrcSpanAnnMapXRecmapXRec appendDocs concatDocsemptyArgDocMapemptyDeclDocMaphsDocStringToByteStringisEmptyDocString mkHsDocStringmkHsDocStringUtf8ByteString ppr_mbDoc unpackHDS ArgDocMap DeclDocMapExtractedTHDocsethd_mod_headerethd_inst_docs ethd_arg_docsethd_decl_docs LHsDocStringnoExtCon noExtFieldLIdPXCoPataddAnnsaddAnnsAaddCLocA addCLocAAaddCommentsToEpAnnaddCommentsToSrcAnnaddTrailingAnnToAaddTrailingAnnToLaddTrailingCommaToNannParen2AddEpAnncom combineLocsAcombineSrcSpansAcomment epAnnAnns epAnnAnnsL epAnnCommentsepaAnchorRealSrcSpanextraToAnnListgetFollowingCommentsgetLocA getLocAnnl2ll2nla2lala2nala2rmapLocAn2lna2lanoAnn noAnnSrcSpannoCom noCommentsnoLocA noSrcSpanA parenTypeKwsplaceholderRealSpanreAnnreAnnCreAnnLreLocreLocAreLocCreLocLreLocNrealSpanAsAnchor realSrcSpansetCommentsEpAnnsetCommentsSrcAnnsetFollowingCommentssetPriorComments sortLocatedA spanAsAnchortransferComments unicodeAnn widenAnchor widenAnchorRwidenLocatedAn widenSpanAnchoranchor anchor_opAnchorOperation MovedAnchorUnchangedAnchor AnnContextac_openac_close ac_darrow AnnListItem lann_trailingDeltaPosDP deltaColumn deltaLine EpaCommentTokEpaLineComment EpaEofComment EpaDocSection EpaDocOptionsEpaDocCommentPrevEpaDocCommentNextEpaBlockCommentEpaDocCommentNamedHasENoEIsUnicodeSyntax UnicodeSyntax NormalSyntax LEpaComment LocatedAnLocatedCLocatedP NameAdornment NameSquareNameParensHashNameBackquotes NameParensNameAnnNameAnnTrailing NameAnnRArrow NameAnnQuote NameAnnOnly NameAnnCommas nann_trailing nann_quoted nann_quote nann_open nann_name nann_commasnann_adornment nann_closeNoEpAnns ParenTypeAnnParensSquare AnnParens AnnParensHash pprFlavourchunkifycollectHsBindBinderscollectHsBindListBinderscollectHsBindsBinderscollectHsIdBinderscollectHsValBinderscollectLStmtBinderscollectLStmtsBinderscollectLocalBinderscollectMethodBinderscollectPatBinderscollectPatsBinderscollectStmtBinderscollectStmtsBinders emptyRecStmtemptyRecStmtIdemptyRecStmtNameemptyTransStmtgetPatSynBindshsDataFamInstBindershsForeignDeclsBindershsGroupBindershsLTyClDeclBindershsPatSynSelectorshsTyClForeignBindershsTypeToHsSigTypehsTypeToHsSigWcTypehsValBindsImplicitsisBangedHsBindisInfixFunBindisUnliftedHsBind lPatImplicitslStmtsImplicits missingTupArgmkBigLHsPatTup mkBigLHsTupmkBigLHsVarPatTupmkBigLHsVarTup mkBodyStmt mkChunkified mkClassOpSigs mkFunBindmkGroupByUsingStmtmkGroupUsingStmt mkHsAppType mkHsAppTypes mkHsAppWithmkHsApps mkHsAppsWithmkHsCharPrimLit mkHsCmdIf mkHsCmdWrapmkHsComp mkHsCompAnnsmkHsDo mkHsDoAnnsmkHsFractionalmkHsIf mkHsIntegral mkHsIsStringmkHsLammkHsLams mkHsOpAppmkHsParmkHsQuasiQuote mkHsSigEnv mkHsStringmkHsStringPrimLit mkHsVarBindmkHsWrap mkHsWrapCo mkHsWrapCoR mkHsWrapPat mkHsWrapPatCo mkLHsCmdWrapmkLHsParmkLHsTupleExpr mkLHsVarTuple mkLHsWrap mkLHsWrapCo mkLastStmt mkLetStmt mkLocatedListmkMatch mkMatchGroupmkNPat mkNPlusKPatmkParPat mkPatSynBindmkPrefixFunRhs mkPsBindStmt mkRecStmt mkRnBindStmtmkSimpleGeneratedFunBind mkSimpleMatch mkTcBindStmt mkTopFunBindmkTransformByStmtmkTransformStmt mkTypedSplicemkUntypedSplice mkVarBindnlConPat nlConPatName nlConVarPatnlConVarPatNamenlHsApp nlHsAppKindTy nlHsAppTynlHsAppsnlHsCase nlHsDataConnlHsDo nlHsFunTynlHsIf nlHsIntLitnlHsLamnlHsLit nlHsOpAppnlHsPar nlHsParTynlHsSyntaxApps nlHsTyApp nlHsTyApps nlHsTyConApp nlHsTyVarnlHsVar nlHsVarApps nlInfixConPatnlListnlLitPatnlNullaryConPatnlParPat nlTuplePatnlVarPat nlWildConPat nlWildPat nlWildPatNamenl_HsVarspanHsLocaLBindsunguardedGRHSs unguardedRHS unitRecStmtTcGHC.Hs AnnsModuleam_declsam_mainHsModule hsmodName hsmodLayouthsmodHaddockModHeaderhsmodDeprecMessagehsmodAnn hsmodDecls hsmodExports hsmodImportsHsParsedModule hpm_module hpm_src_files CollectFlagCollNoDictBindersCollWithDictBinders CollectPass collectXXPatCode