h$ݣFr      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          !!!"""""""###########################################$$$$%&&&&&''''''''''''''''''''''''''''''''(((()************************++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++,,,,,,,,,,,,,---------------.....................///////////////000000000000000000000000000000000000000000000000111111111111111111111111122222233333333344444444556666666777777777777777777888888888888889999::::::::::::::::::::::::::::::;;;;;;;;;;;<<<<==>>>>>>>>>>>>>>>>>>>>>>??????????????????????????????????????????????????????????????????????????????????@@AAAAAABBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDEFFFFFFFFFFFFFGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGHHIIIJKKKLLLLLMMMMMMMMMNNNNNNNNNOOOOPQQRSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSTUVWXYYYYYYYYYYYYYYYYYYYYYYYYZZ[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[\]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]^_____________`aaaaabbcccddddddddddddddddef\\\\\\\gggggghhhiiiiiiiiiiiiiiiiiiijjjjkkklllllllmmmmnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnoooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooppppppppppqqqqqqqrrrrrrrrrrrrrrsssttttttttttuuuuuuuuuuuuuvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvwwwwwwwwwwwwwwwwxyyyyyyyyyyyyyyyyyyyyyyyyzz{||||||||||||||||||||||}}~                                                                                                                                !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""################################################################################################################################$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$j$j$j$j$j$j$j$j$j$j$j$j$j$j$j$j$$$$$$$$$W$W$$$$$$%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& & & & & & & & & & & &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((e(e(e(e(e(e(e(e(e(e(e(e(e(e(e(f(f(f(f(f(f(f(f(f(f(f((((((((((((((((((((((((()))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *****************************e*e*e*e*e*e*e*e*e*e*e*e*e*e*e*e*e*e*********************++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,--------------------------------------------------------------------------------------------------------------------------------... . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / ////////////////////////////////////////////////////R/R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0000000000000000000000000000000000000111111111111111111111111111111U1U1U1U1U1U1U1U1U1U1U1U1U1U1U1U1U1U1U1U11111111111111111111111111111111111111111111111111111111111111111111111111111112222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222233333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333444444444444444444444444444444444444444444444444444444444444444444444444444444444444444 444444444444444444444444444444444444444445555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555566666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777778888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888899999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<================================================================================================================================>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>S>S>S>S>S>S>S>S>S>S>S>S>S>S>S>S>S>S>S>S>S>S>S>S>S>S>S>S>S>S?S?S?S?S?S?S?S?S?S?S?S?S?S?S?S?S?S?????????????????????????????????????????????????!?!?!?!???????????????????????????????????????????????????????????@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@W@W@W@W@W@W@W@V@V@V@V@V@V@V@V@V@V@V@V@V@V@V@V@V@V@V@V@V@@@@@@@@@f@f@f@f@f@f@f@f@fAfAfAfAfAfAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCkCkCkCkCkCkCkCCCCCCCC NoneB NoneNone   None3 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 '(/G 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 >  None '(>?  None'(?Ƭ ghc-libThe dataflow lattice ghc-lib'Calculated liveness info for a CmmGraph  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 C, making sure that C# are suitable for code generation.  None'(>?7 "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 C (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 C7 node for the given register and unwinding expression.**$Noneֱ%None'(&None'(5?'None'(>?[ghc-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 C= 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.C2C9 +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.  .None`ghc-libCommon things that we can do with instructions, on all architectures. These are used by the shared parts of the native code generator, specifically the register allocators.ghc-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 register/None0Noneghc-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.001Noneghc-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 alised registers don't get counted twice, as per the paper.ghc-libso we can put regs in UniqSets2NoneZghc-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 x863None4None 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 allocated5None 6None 2ghc-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.7 Safe-Inferred ghc-libBranch condition codes.8Noneghc-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.9Noneghc-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.:NoneWghc-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.;Nonesghc-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.  <Nonesghc-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   =Noneghc-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!>ghc-libmaybeFlipCond c returns Just c'= if it is possible to flip the arguments to the conditional c", and the new condition should be c'.ghc-lib If we apply 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.?None$Lghc-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 negative@None%ANone%BNone* 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)CNone3ghc-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==DNone4ENone5'ghc-lib9Expand out synthetic instructions in this top level thingFNone8ghc-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  GNone5=^ 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 C after block' and change any edges block -> X to C -> Xghc-lib'Get native code generator configurationghc-libTJNone>ghc-lib,Generate code to reference a memory address.ghc-libexpr producing an addressKNone@ghc-lib(Code to assign a 64 bit value to memory.ghc-lib,Code to assign a 64 bit value to a register.ghc-lib6Get the value of an expression into a 64 bit register.ghc-lib&expr producing the destination addressghc-lib expr producing the source value.ghc-libthe destination registerghc-libexpr producing the source valueHNoneA\ghc-lib*Make code to evaluate a 32 bit expression.ghc-libThe dual to getAnyReg: compute an expression into a register, but we don't mind which one it is.LNone /?Aghc-libCFG if we have one.ghc-libFunction to serializeMNoneBNNoneBCONone '(5BPNoneBghc-lib!Read in assembly file and processQNoneCghc-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.TNoneCXNoneDYNoneD.ZNoneDNone5D  [NoneEfghc-libA substitution result.]NoneF^NoneH_NoneIghc-libContext for a  application with a hole for every field, including surrounding coercions. The result of  and C.Example: DataConAppContext Just [Int] [(Lazy, Int)] (co :: Maybe Int ~ First Int) represents (Just @Int (_1 :: Int) |> co :: First Intwhere _1 is a hole for the first argument. The number of arguments is determined by the length of arg_tys.  `NoneJ/aNoneKghc-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])bNoneKcNoneL dNonePghc-lib Used to make C for an  1 defined in the module being compiled. See also Cghc-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\NoneQghc-libSpecialise calls to type-class overloaded functions occurring in a program.gNoneQhNoneQiNoneRghc-lib,True if there is a non-empty intersection. s1  s2 doesn't compute s2 if s1 is emptylNone5RmNoneVghc-lib&A bitmap represented by a sequence of C 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 duplicatesnNone]Ighc-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-wordoNonec 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 onepNoneeeqNoneerNonee  sNone'(gghc-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.tNone#'(h  uNonehghc-libReturn the UnitId of the home-unit. This is used to create labels.  vNonei99wNonepghc-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.xNoneqyNoneghc-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)zNoneghc-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 etc{Noneghc-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.+|Noner}None~ Safe-Inferredghc-libHandle GHC-specific character encoding flags, allowing us to control how GHC produces output regardless of OS.None?ghc-libSource StatisticsNone &?Ughc-lib!Extract docs from renamer output.ghc-libCreate decl and arg doc-maps by looping through the declarations. For each declaration, find its names, its subordinates, and its doc strings.ghc-libGet all subordinate declarations inside a declaration, and their docs. A subordinate declaration is something like the associate type or data family of a type class.ghc-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 C.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-lib  Module headerDocs on top level declarationsDocs on argumentsNone  3567>L3ghc-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 infoghc-libNodeInfos grouped by sourceghc-lib/Mapping from filepaths to the corresponding ASTghc-libA list of type arguments along with their respective visibilities (ie. is this an argument that would return C 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 pathghc-libThe module this HIE file is forghc-libTypes referenced in the .9See Note [Efficient serialization of redundant type info]ghc-lib$Type-annotated abstract syntax treesghc-lib"The names that this module exportsghc-lib'Raw bytes of the initial Haskell sourceghc-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 siteNone  &5>K!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 C)ghc-lib)return an empty list if this is unhelpful!ghc-libhelps fill in  (with C)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 #$!ghc-libUpdate CafInfos and LFInfos of all occurences (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)!ghc-lib "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 C 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 C. """""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" """"""""""""""""""""""""""""""""""""""""""""""""""""NoneV""""""""""""""""""""""""""""""""None '(5>B#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$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-lib&value of pointer which was overwritten$ghc-lib the thunk6 "##############$$$$$$$$$$$$$$6##$$$###$$$$$$## #"## ####$$$$$None#$ghc-libstaticghc-lib updateable$ghc-lib updateable$ghc-lib!size of the full header, in bytesghc-libsize of the payload, in bytes$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$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;Emit top-level tables for HPC and return code to initialise$$$$NoneF"$$$$$$$$$$$$$$$$"$$$$$$$$$$$$$$$$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. """"""""""""$$$$$$$$$$$$$$$$$$$$ $$$$$$$$$$$$$$$$$$$$""""""""""""jNone/$ghc-lib%The type used in binder positions in Cs.$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 C . 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. C; 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 ?$$Nonet%ghc-lib:A local block label (e.g. identifying a case alternative).$%$$$$$%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%$%$$$$$%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%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###$%%%%%%%%%%%%###$%%%%%%%%%%%%NoneO%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%%%%%%None%%None(#%%%%%#%%%None/a%%None >%%C9 C9 None#$'(%%%%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)&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&None3&&&&&&&&&&Nonej &&&&&&&&&&&& &&&&&&&&&&&& None&&&&None #$>'&ghc-lib*Setup the initial typechecking environment&ghc-libRun a C& 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 MsgDoc a. and throwing an exception if it is an error.'ghc-libDump if the given C 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 C style. However, generally we want all other debugging output to use C style. We C 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 warning if a condition is met.'ghc-lib)Display a warning in the current context.'ghc-lib%Display a warning in a given context.'ghc-lib2Display a warning for the current source location.'ghc-lib.Display a warning for a given source location.(ghc-libDisplay a warning, 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 C= (top-level interface monad) computation inside an existing C; (typecheck-renaming monad) computation by initializing an C based on C.(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]: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.********None1H*ghc-libA F 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 Fs until it finds a shared F.$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)]************eNone?Mn*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 #$U, (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'Read binary interface, and print it out(********************+++++************(*****+***++++None >?X6+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 F 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 ?ZX+ghc-libSee Note [The ZonkEnv] Confused by zonking? See Note [What is zonking?] in GHC.Tc.Utils.TcMType.( +++++++++++++++++++++++++++++++++(+++ ++ ++++++++++++++++++++++++++++None?`+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-libInstantiate all outer type variables and any context. Never looks through arrows.,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# ))+++++++,,,,,,,,,,,,,,,,,,,,,,,#++++,,+)),,,,,,,,,,,,,,,,,+,,,+, None5dk,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 #$f,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?nX,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 F 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 F.,ghc-lib8Ensure that a constraint tuple has arity no larger than F.,ghc-libThe error msg if the signature is not allowed to contain manually written inferred variables.5,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,5,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,Nonep-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.'FFFCFFFFFFFFFFFFFF FFEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF FFF!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~FFFFFFGCGCGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGHHHHHHHHHHHHHHHHHHHHHHHHHHHFCCCDDDDHHHHHHHHHHHHHHHHHHHCHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII IIIIIIIIIICIIIIIIIIIIIIIIIIIIIIIIIIIIIIIJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJKKKCKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKEKKKK K F K KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMCMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO OOOOOOOOOOOOOOOOOO OOOOOOOOOOOOO OOOOOOOOOO O O OOO O OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOPPPPP PPPPPPPPP PPPPPPPPPPP PPPP PPPPPPPP PPPPPPPP PPPPPPPP PPPPPPPPPPPPPP PPP PPPPPPPP PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPCPPPP PPPPPPPPQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR RRRRR RRRRRR RRRRRRRRRRRR RRRRRRRRRRRRRSS SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWCWWWWWWWWWWWWWWWWWWWWXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[C[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^________________________________________________________________________________________________________________________________```````````````````````````````````````````````````````````````````````````````````````````````````!,----,,,,,,,,-`````````````````````````````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa*aaaaaaabbbbbbbbbbbbbbbbbb,,bb,bbbbbb-!"#$XYZ[\]^_`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-----None-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 get a GlobalRdrEnv argument.It is careful not to unwrap data/newtype instances if it can't continue unwrapping. Such care is necessary for proper error messages.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 ---------- ----------None-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) and for simplifyDefault.-ghc-libReport all unsolved goals as warnings (but without deferring any errors to run-time). See Note [Safe Haskell Overlapping Instances Implementation] in  GHC.Tc.Solver----------None-ghc-lib- returns (True, fixity) if it finds a b 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 b 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%-ghc-libLook up an occurrence of a field in record construction or pattern matching (but not update). When the -XDisambiguateRecordFields flag is on, take account of the data constructor name to disambiguate which field to use.$See Note [DisambiguateRecordFields].-ghc-lib,Used in export lists to lookup the children.-ghc-lib5Specialised version of msum for RnM ChildLookupResult-ghc-libLike --, but with a more informative result if the ! happens to be a record selector:8Nothing -> name not in scope (no error reported)Just (Left x) -> name uniquely refers to x, or there is a name clash (reported)Just (Right xs) -> name refers to one or more record selectors; if overload_ok was False, this list will be a singleton.-ghc-lib,Lookup a name in relation to the names in a --ghc-lib Lookup an  ifThenElse binding (see b).-ghc-lib:description of thing we're looking up, like "type family"-ghc-libThe standard nameghc-libPossibly a non-standard name-ghc-libThe standard nameghc-libPossibly a non-standard name3---------------------------------------------------3---------------------------------------------------None-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-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. Crucially, it doesn't b when done./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-libUnflatten types afterwards? Don't if you want to reuse the InertSet./ghc-libtype being reduced -------..............................................................................................................................////////////////////////////////////////////////////////////////...................................////------- ..........///////////////././/////////../////.....//................................................................////...//////////////////...././///None5/ghc-libSee Note [Flattening]. If (xi, co) <- flatten mode ev ty, then co :: xi ~r ty where r is the role in ev. If mode is /, then xi: is almost function-free (Note [Almost function-free] in  GHC.Tc.Types)./ghc-libFlatten 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. ///////// /////////None5b ////////// //////////b0None"/ghc-lib=Perform some IO, typically to interact with an external tool./ghc-lib)Output useful for debugging the compiler./ghc-libCreate a new wanted constraint./ghc-lib Create a new derived constraint./ghc-libCreate a new given constraint, with the supplied evidence. This must not be invoked from  tcPluginInit or  tcPluginStop, or it will panic./ghc-lib!Create a fresh evidence variable./ghc-libCreate a fresh coercion hole./ghc-lib;Bind an evidence variable. This must not be invoked from  tcPluginInit or  tcPluginStop, or it will panic.((((((((((((//////////////////////////(//(((((((((((////////////////////////RNone1 /ghc-lib)Represents the head of a match against a b or literal. Really similar to N.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 C.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 C 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: / 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 /*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 / in the / that compares 0 to the given / according to 0.0ghc-lib'We can't in general decide whether two /?s match the same set of values. In addition to the reasons in b and b, 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 /0ghc-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.0ghc-libSyntactic equality.0ghc-libNot user-facing.0ghc-libNot user-facing.//0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000/000000/000000000000000None&5~0ghc-libUsed as tree payload post-checking. The redundancy info we elaborated.0ghc-lib;Used as tree payload pre-checking. The LYG guards to check.0ghc-lib#Pattern-match coverage check result0ghc-lib,A hole for redundancy info and covered sets.0ghc-libThe set of uncovered values falling out at the bottom. (for -Wincomplete-patterns, but also important state for the algorithm)0ghc-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.0ghc-libRedundancy sets, used to determine redundancy of RHSs and bang patterns (later digested into a CIRB).0ghc-libThe Covered= set; the set of values reaching a particular program point.0ghc-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.0ghc-libIf any of the 0 is empty, the corresponding 0 pin-points a bang pattern in source that is redundant. See Note [Dead bang patterns].0ghc-lib(A guard tree denoting a pattern binding.0ghc-lib%A guard tree denoting an -XEmptyCase.0ghc-libA guard tree denoting GRHS&: A payload describing the grds and a 0/ useful for printing out in warnings messages.0ghc-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.0ghc-libA guard tree denoting Match5: A payload describing the pats and a bunch of GRHS.0ghc-libA guard tree denoting  MatchGroup.0ghc-libA sequence of 1s.0ghc-libMeans by which we identify a source construct for later pretty-printing in a warning message. F 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 0 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, !z//00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011111111111110111111111111000000000000000000000000000000000000UNone1ghc-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 Cs.11111111111111111111111111111111111111None1111None1ghc-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 b1ghc-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-libNormalise a type as much as possible using the given constraints. See Note [tcNormalise].*.11111111111111111111111111111111111111111111*1111.None1ghc-libDo validity checks on a type family equation, including consistency with any enclosing class instance head, termination, and lack of polytypes.1ghc-lib.Checks that an associated type family default:  induced by an import of a particular interface, but without D.112222222222222122222222222221None  ?2ghc-libC 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!)2222None2ghc-libShould GHC warn if a quantified type variable goes unused? Usually, the answer is "yes", but in the particular case of binding b$, 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-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-libF _ => an associated type decl,22222222222222222222222222222222222222222222,22222222222222222222222222222222222222222222None &5?2222222222222222222222222222222222222222NoneR--------22222222222222222222222222--------None ?}2ghc-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 already222222None(ghc-lib/Rename a splice pattern. See Note [rnSplicePat]2ghc-libThe splice data to be logged2ghc-liboutputs splice information for 2 flags which have different output formats: `-ddump-splices` and `-dth-dec-file`((((2222222222((2((222222222None ?!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.!!2!2!None"2ghc-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 (b). 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.2ghc-libTypecheck a signature   under the assumption that we have instantiated it under some implementation (recorded in R?) and want to check if the implementation fills the signature.0This needs to operate slightly differently than 2 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!!!!!!!***2222222***2222!!!!!!!222None &32ghc-lib'A description of whether something is adata or newtype (2) data instance or newtype instance (2) data family (2)/At present, this data type is only consumed by 3.2ghc-lib1Describes the kind expected in a certain context.2ghc-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 bs in an b with the supplied b.3ghc-libSkolemise the bs in an b with the supplied b.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 verison 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 neeed 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 b).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&&&&&&&&&&&&&&&&&&&&&&&&&2222223333333333333333333333333333333333333333333333333333333333333333333333333333&&&&&&&&&&&&&&&&&&&&&&&&&33333333333333333333333333223333333333333333333222233333None53ghc-lib0If there are no wildcards, return a LHsSigWcType)33333333333333333)33333333333333333None ?63ghc-lib A variant of tcPat that takes a custom origin3ghc-lib(origin to use if the type needs inst'ing 333333333333 333333333333None7N33None ?7~33333333333333None 583ghc-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. 333333333 333333333None @\3ghc-lib For a module modname of type b, 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 A signature B import Aunit q where dependency p[A=,B=] signature A signature BAlthough q's B does not directly import A, we still have to make sure we process A first, because the merging process will cause B to indirectly import A. This function finds the TRANSITIVE closure of all such imports we need to make.3ghc-lib3, but in a convenient form for GHC.Driver.Make and  GHC.Tc.Module.3ghc-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.3ghc-libTop-level driver for signature instantiation (run when compiling an hsig file.)3ghc-libTop-level driver for signature merging (run after typechecking an hsig file).3ghc-libGiven a local  ), merge all inherited requirements from b) into this signature, producing a final C? that matches the local signature and all required signatures.4ghc-libTop-level driver for signature instantiation (run when compiling an hsig file.)4ghc-libGiven E, instantiate a   from the indefinite library to use the actual implementations of the relevant entities, checking that the implementation matches the signature. 3333333344 3333333344None ?@((4((4NoneAe4ghc-libConstruct default instances for any associated types that aren't given a user definition Returns [] or singleton 444444444444 444444444444None'(/?B24ghc-libThis name really is ambiguous, so add a suitable "ambiguous occurrence" error, then continue04444444444444444444444444444444444444444444444440444444444444444444444444444444444444444444444444None #$?C"&&4444444444444444&4&444444444444444NoneC44None '(/?C44444444 None /?E&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.&&&&&&&&&&&444&&&&&&&&&&&444NoneFC44None &G4ghc-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.444444444444444444444444444444444444None 5>?UM4ghc-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.4ghc-libWe represent the case where there is no hole without a function from O, like this, because sometimes we have nothing to put in the hole and so want to be sure there is in fact no hole.4ghc-libThe patterns for an equation NB: We have already applied decideBangHood3 to these patterns. See Note [decideBangHood] in GHC.HsToCore.Utils4ghc-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.4ghc-libWhat to do after match4ghc-libRun a 1 action inside the C monad.4ghc-libRun a 1 action inside the E monad.4ghc-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 warning for the current source location NB: Warns whether or not -Wxyz is set5ghc-libEmit a warning only if the correct WarnReason 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  ''''''1111144444444444444444444445555555555555555555555555555555555144444'''' 45555454555' '55555555111155555545555555544444444444445555NoneY5ghc-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 X it's controlled. Returns C if check is not supported.5ghc-libCheck whether any part of pattern match checking is enabled for this b (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&`Q 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 O e.5ghc-libPhiConCt x K tvs dicts ys encodes K @tvs dicts ys <- x , matching x against the / 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 b 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.000055555555555555000055555555555555Nonebf5ghc-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 "...".55None '(5>b5ghc-lib*Coverage checking action. Can be composed b or b.55555555555555None ?e5ghc-libUse -XStrict to add a ! or remove a ~ See Note [decideBangHood]5ghc-lib Scrutineeghc-lib Type of expghc-lib,Alternatives (bndrs *include* tyvars, dicts)5ghc-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 binds5ghc-libOriginal pattern4444444445555555555555555555555555555555555555555555544444455444555555555555555555555555555555555555555555Nonef5566655666None ?fN66Noneh6ghc-libPost-typechecker, the b field of an b8 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 666666666666Nonei6ghc-lib Guarded RHSsghc-lib Type of RHSghc-libRefined pattern match checking models, one for the pattern part and one for each GRHS.566665None '(>j,6ghc-libDesugar the non-empty bes of a b.66666666None '(>p6ghc-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 b1es (part of case, functions, etc.), each with a b and one or more b:  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 b and 2.) each of a bes b& 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 O 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 b 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 ?r_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] 666666666 666666666None/?s6ghc-lib5This is Nothing only when we are dealing with a VarBr66Nones/6666None !w5ghc-lib matchSimply is a wrapper for 5 which deals with the situation where we want to match a single expression against a single pattern. It returns an expression.5ghc-lib&The scrutinee the match id is bound to5ghc-lib Scrutineeghc-lib Match kindghc-libPattern it should matchghc-libReturn this if it matchesghc-libReturn this if it doesn't5ghc-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 5)5ghc-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!555566565565Nonex36666Nonexd66None{5ghc-libReplace the body of the fucntion 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 ()5ghc-lib Variant of 5 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.Core55555665555665None"6ghc-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]66666666666666None/6ghc-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 plugins666666Nonej6ghc-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.6ghc-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 ( ).666666666666Nonec6ghc-libPretty-prints a 8 (type/data family instance) with its defining location.6ghc-libPretty-prints a  with its defining location.6ghc-libPretty-prints the  header. For functions and data constructors the function is equivalent to 6 but for type constructors and classes it prints only the header part of the declaration.6ghc-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.6ghc-libLike 6!, but adds the defining location.6ghc-libPretty-prints a .66666666666666NoneN6ghc-libGenerate a section type (e.g.  @progbits). See #13937.6ghc-libTarget platformghc-lib section typeghc-libpretty assembler fragment66NoneP6ghc-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 Nothing6ghc-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 returned6ghc-lib.Generate the GAS code to create a Note sectionHeader fields for notes are 32-bit long (see Note [ELF specification]).666666None6ghc-libEmit a ".string" directive6ghc-libEmit a ".incbin" directive+A NULL byte is added after the binary data.6666666666None6ghc-libLlvm cast operations.6ghc-libInteger truncate6ghc-libInteger extend (zero fill)6ghc-libInteger extend (sign fill)6ghc-libFloat truncate6ghc-lib Float extend6ghc-libFloat to unsigned Integer6ghc-libFloat to signed Integer6ghc-libUnsigned Integer to Float6ghc-libSigned Int to Float6ghc-libPointer to Integer6ghc-libInteger to Pointer6ghc-lib6Cast between types where no bit manipulation is needed6ghc-libLlvm compare operations.6ghc-libEqual (Signed and Unsigned)6ghc-libNot equal (Signed and Unsigned)6ghc-libUnsigned greater than6ghc-libUnsigned greater than or equal6ghc-libUnsigned less than6ghc-libUnsigned less than or equal6ghc-libSigned greater than6ghc-libSigned greater than or equal6ghc-libSigned less than6ghc-libSigned less than or equal6ghc-lib Float equal6ghc-libFloat not equal6ghc-libFloat greater than6ghc-libFloat greater than or equal6ghc-libFloat less than6ghc-libFloat less than or equal6ghc-lib)Llvm binary operators machine operations.6ghc-lib1add two integer, floating point or vector values.6ghc-libsubtract two ...6ghc-lib multiply ..6ghc-lib$unsigned integer or vector division.6ghc-libsigned integer ..6ghc-lib*unsigned integer or vector remainder (mod)6ghc-lib signed ...6ghc-lib(add two floating point or vector values.6ghc-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 value7ghc-lib'Indicates if this function uses varargs7ghc-libParameter types and attributes7ghc-lib(Function align value, must be power of 27ghc-libLLVM code generator options7ghc-libTarget platform7ghc-lib+Fill undefined literals with garbage values7ghc-libSplit sections7ghc-libLlvm Static Data.These represent the possible global level variables and constants.7ghc-libA comment in a static section7ghc-lib#A static variant of a literal value7ghc-libFor uninitialised data7ghc-libDefines a static 77ghc-libA static array7ghc-libA static structure type7ghc-libA pointer to other data7ghc-libTruncate7ghc-libPointer to Pointer conversion7ghc-libPointer to Integer conversion7ghc-libConstant addition operation7ghc-libConstant subtraction operation7ghc-libLlvm Literal Data.(These can be used inline in expressions.7ghc-lib'Refers to an integer constant (i64 42).7ghc-libFloating point literal7ghc-lib.Literal NULL, only applicable to pointer types7ghc-libVector literal7ghc-lib>Undefined value, random bit pattern. Useful for optimisations.7ghc-libLLVM Variables7ghc-libVariables with a global scope.7ghc-lib,Variables local to a function or parameters.7ghc-libNamed local variables. Sometimes we need to be able to explicitly name variables (e.g for function arguments).7ghc-libA constant variable7ghc-libMutable global variable7ghc-libConstant global variable7ghc-libAlias of another variable7ghc-libAn LLVM section definition. If Nothing then let LLVM decide the section7ghc-lib Llvm Types7ghc-lib&An integer with a given width in bits.7ghc-lib32 bit floating point7ghc-lib64 bit floating point7ghc-lib 80 bit (x86 only) floating point7ghc-lib128 bit floating point7ghc-libA pointer to a 77ghc-lib An array of 77ghc-lib A vector of 77ghc-libA 7 can represent a label (address)7ghc-lib Void type7ghc-libPacked structure type7ghc-libUnpacked structure type7ghc-lib A type alias7ghc-lib LLVM Metadata7ghc-lib3Function type, used to create pointers to functions7ghc-lib A type alias7ghc-libA String in LLVM7ghc-lib4A global mutable variable. Maybe defined or external7ghc-libReturns the variable of the 77ghc-libReturn the value of the 77ghc-libGet LlvmOptions from DynFlags7ghc-lib Return the 7 of the 77ghc-lib Return the 7 of a 78ghc-lib Return the 7 of the 78ghc-lib Return the 7 for a 78ghc-lib0Add a pointer indirection to the supplied type. 7 and 7 cannot be lifted.8ghc-libLift a variable to 7 type.8ghc-lib:Remove the pointer indirection of the supplied type. Only 7 constructors can be lowered.8ghc-libLower a variable of 7 type.8ghc-libTest if the given 7 is an integer8ghc-libTest if the given 7 is a floating point type8ghc-libTest if the given 7 is an 7 construct8ghc-libTest if the given 7 is an 7 construct8ghc-lib Test if a 7 is global.8ghc-libWidth in bits of an 7, 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].666666666666666666666666666666677777777766666666677777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777888888888888888888888888888777777777777777777777777777777777777777777777777777777777777777888888888888888888888777777777777777777777777777777777777777777777777777777776777777777666666666666666666666666666666666666666888888None78ghc-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 expressions8ghc-lib)A reference to an un-named metadata node. 888888888888 888888888888None2;8ghc-libLlvm Expressions8ghc-libAllocate amount * sizeof(tp) bytes on the stack * tp: LlvmType to reserve room for * amount: The nr of tp's which must be allocated8ghc-libPerform the machine operator op on the operands left and right * op: operator * left: left operand * right: right operand8ghc-libPerform a compare operation on the operands left and right * op: operator * left: left operand * right: right operand8ghc-libExtract a scalar element from a vector * val: The vector * idx: The index of the scalar within the vector8ghc-libExtract a scalar element from a structure * val: The structure * idx: The index of the scalar within the structure Corresponds to "extractvalue" instruction.8ghc-libInsert a scalar element into a vector * val: The source vector * elt: The scalar to insert * index: The index at which to insert the scalar8ghc-libAllocate amount * sizeof(tp) bytes on the heap * tp: LlvmType to reserve room for * amount: The nr of tp's which must be allocated8ghc-libLoad the value at location ptr8ghc-lib(Atomic load of the value at location ptr8ghc-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.8ghc-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 to8ghc-libAtomic read-modify-write operation * op: Atomic operation * addr: Address to modify * operand: Operand to operation * ordering: Ordering requirement8ghc-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.8ghc-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.8ghc-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.8ghc-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.8ghc-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.8ghc-lib/A LLVM expression with metadata attached to it.8ghc-libLlvm Statements8ghc-libAssign an expression to a variable: * dest: Variable to assign to * source: Source expression8ghc-libMemory fence operation8ghc-lib!Always branch to the target label8ghc-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 false8ghc-libComment Plain comment.8ghc-libSet a label on this position. * name: Identifier of this label, unique for this module8ghc-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 in8ghc-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.8ghc-libReturn a result. * result: The variable or constant to return8ghc-libAn instruction for the optimizer that the code following is not reachable8ghc-libRaise an expression to a statement (if don't want result or want to use Llvm unnamed values.8ghc-libA nop LLVM statement. Useful as its often more efficient to use this then to wrap LLvmStatement in a Just or [].8ghc-lib.A LLVM statement with metadata attached to it.8ghc-lib'LLVM atomic operations. Please see the  atomicrmw instruction in the LLVM documentation for a complete description.8ghc-libLLVM ordering types for synchronization purposes. (Introduced in LLVM 3.0). Please see the LLVM documentation for a better description.8ghc-lib(Some partial order of operations exists.8ghc-lib?A single total order for operations at a single address exists.8ghc-lib"Acquire synchronization operation.8ghc-lib"Release synchronization operation.8ghc-lib,Acquire + Release synchronization operation.8ghc-lib&Full sequential Consistency operation.8ghc-libAn LLVM Function8ghc-lib(The signature of this declared function.8ghc-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 labels88888888888888888888888888888888888888888888888888888888999988999999999999999999999999999988999988888888888888888888888888888888888888888888888888888888None9ghc-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 7* in Llvm IR textual representation (e.g. @x, %y or 42).9ghc-lib)Return the variable name or value of the 7* in a plain textual representation (e.g. x, y or 42).9ghc-libPrint a literal value. No type.999999999999999999999999999999999999None|6666666666666666666666666666666666666666777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777778888888888888888888888888888888888888888888888888888888888888888888888888888888888888888899999999999999999999999999999999999977777799999999888899997777777778788888888888888888888888888888888899999977777777778888888888888888888777777777777777777777777777777777777666666666666666666666666666777777777666666666666677777777777777777777777777777777777777777777777777778888888888888888888887788888888888999999999999999999None5 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 b 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 b 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 b 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 b 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 b 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 99999999999None5 ,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 entry9ghc-lib)Translate a basic CmmType to an LlvmType.9ghc-lib*Translate a Cmm Float Width to a LlvmType.9ghc-lib(Translate a Cmm Bit Width to a LlvmType.9ghc-lib#Llvm Function type for Cmm function9ghc-libLlvm Function signature9ghc-libAlignment to use for functions9ghc-lib Alignment to use for into tables9ghc-libSection to use for a function9ghc-libA Function's arguments9ghc-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.9ghc-libLlvm standard fun attributes9ghc-libConvert a list of types to a list of function parameters (each with no parameter attributes)9ghc-lib Pointer width9ghc-lib-The LLVM Version that is currently supported.9ghc-libGet target platform9ghc-libGet LLVM options9ghc-libGet initial Llvm environment.9ghc-lib"Lift a stream into the LlvmM monad9ghc-lib9Clear variables from the environment for a subcomputation9ghc-lib3Insert variables or functions into the environment.9ghc-lib3Insert variables or functions into the environment.9ghc-lib1Lookup variables or functions in the environment.9ghc-lib1Lookup variables or functions in the environment.9ghc-lib(Set a register as allocated on the stack9ghc-lib2Check whether a register is allocated on the stack9ghc-lib1Allocate a new global unnamed metadata identifier9ghc-lib/Get the LLVM version we are generating code for9ghc-libDumps the document if the corresponding flag has been set by the user9ghc-lib.Prints the given contents to the output handle9ghc-libMarks a variable as "used"9ghc-lib,Return all variables marked as "used" so far9ghc-lib%Sets metadata node for a given unique9ghc-lib#Gets metadata node for given unique9ghc-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.9ghc-libPretty print a b.9ghc-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.9ghc-libDerive the definition label. It has an identified structure type.9ghc-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!9ghc-lib=Here we take a global variable definition, rename it with a $def, suffix, and generate the appropriate alias.699999999999999999999999999999999999999999999999999999699999999999999999999999999999999999999999999999999999None 9ghc-libRun compiler of C-like languages and raw objects (such as gcc or clang).9ghc-lib8Run the linker with some arguments and return the output9ghc-libRun the LLVM Optimiser9ghc-libRun the LLVM Compiler9ghc-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)9ghc-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.::::::::::::::Nonez:ghc-libEnforce intra-block invariants.::None'(:ghc-libTop level code generation::::None,:ghc-lib"instance for sparc instruction set::NoneU::::None:ghc-lib Instruction instance for powerpc::None: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 >?!;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./;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;/;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;None#;ghc-lib Generate DWARF/debug information;; Safe-Inferred5#3 ;;;;;;;;;; ;;;;;;;;;;None ?%;ghc-libDoes not contain variable;ghc-libThe variable itself;ghc-lib$The variable itself, contravariantly;ghc-lib Function type;ghc-libTuple type. The [a]= is the result of folding over the arguments of the tuple.;ghc-lib2Type app, variable only in last argument. The two ,s are the function and argument parts of  fun_ty arg_ty, respectively.;ghc-lib.Type app, variable other than in last argument;ghc-lib Forall type;ghc-libVariable to look forghc-lib How to foldghc-libType to process;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;None ?&=;;;;;;;;;;;;;;NoneB$;ghc-libA list of wanted ; constraints (;) to simplify when inferring a derived instance's context. These are used in all deriving strategies, but in the particular case of DeriveAnyClass5, we need extra information. In particular, we need:;, the list of type variables bound by a class method's regular type signature, which should be rigid.;, the list of type variables bound by a class method's default type signature. These can be unified as necessary.;, the list of constraints from a class method's regular type signature, which can be used to help solve constraints in the ;. (Note that ; will likely contain type variables from the derived type class or data type, neither of which will appear in ; or ;.)?For all other deriving strategies, it is always the case that ;, ;, and ; are empty.&Here is an example to illustrate this: class Foo a where bar :: forall b. Ix b => a -> b -> String default bar :: forall y. (Show a, Ix y) => a -> y -> String bar x y = show x ++ show (range (y, y)) baz :: Eq a => a -> a -> Bool default baz :: Ord a => a -> a -> Bool baz x y = compare x y == EQ data Quux q = Quux deriving anyclass Foo Then it would generate two ;s, one for each method: [ ThetaOrigin { to_anyclass_skols = [b] , to_anyclass_metas = [y] , to_anyclass_givens = [Ix b] , to_wanted_origins = [ Show (Quux q), Ix y , (Quux q -> b -> String) ~ (Quux q -> y -> String) ] } , ThetaOrigin { to_anyclass_skols = [] , to_anyclass_metas = [] , to_anyclass_givens = [Eq (Quux q)] , to_wanted_origins = [ Ord (Quux q) , (Quux q -> Quux q -> Bool) ~ (Quux q -> Quux q -> Bool) ] } ] (Note that the type variable q is bound by the data type Quux", and thus it appears in neither ; nor ;.)See ?Note [Gathering and simplifying constraints for DeriveAnyClass] in 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 b9, 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 C).A standalone deriving declaration with an extra-constraints wildcard as the context (in which case  mb_wildcard is F 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 b and b! 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 b, b, 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-libF if user requests a particular deriving strategy. Otherwise, C.<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 C.<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 b if wc is C, and b if wc is b. Useful for error-reporting.<ghc-lib Convert a ; to its corresponding b.;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<;;;<<<<<<<<<;;;;;;;;;;;;;;;;;;;<<<<<;;;;;;;;<<<;;;;;;;;<<<<<<<<<<<NoneD&<<<<None Ec<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 &E 3<<<<<<<<<<<< <<<<<3<<<<<<<None ?F<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 ?L &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)!&&&3333344<<<<<<<<<<<<<<<<<<<<<<?Y<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.% <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<===%<<<< <<<<<<<<<<<<<<<<<<<<<<<<<<<<<===Nonec!=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.======================================================Nonee=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.====Nonef=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======None5hE=ghc-lib"The register allocator monad type.=ghc-lib'Get native code generator configuration=ghc-lib?v=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 >?x=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>?zq=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 #$'(2<>?=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?>ghc-libAn efficient serialiser of b.>ghc-libAn efficient deserialiser of b.>>>>NoneC>>None>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 #$81>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 #$>>>SNone #$7>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&Execute an action with the interpreter0Fails if no target code interpreter is available>ghc-lib#Retreive the targe code interpreter0Fails if no target code interpreter is available>ghc-libGrab a lock on the b 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 b& that will automatically release the b! when it is no longer referenced.?ghc-lib Convert a b 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 b 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 way>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>?????????????????>>>>>>>>>>>>>>>>?>??>>>>>>>????>>>>>????>??????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 ???????????????????????????????? ????????????????????????????????Nonek?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 truely 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]?ghc-libFind all the package framework paths in these and the preload packages?ghc-libFind all the package frameworks in these and the preload packages????????????None?ghc-libReturn the "link info" stringSee Note [LinkInfo section] &????????? ?????&????!None<"!&&&&&99999999999999999::::????????!None?ghc-libfilename of executableghc-libextra objects to embed, maybe??None  &g?ghc-lib$Top-level of the LLVM Code generator99?99?None?ghc-lib(Generate code to initialise cost centres?ghc-lib3additional files to be compiled with the C compiler??????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.????NoneR?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 5????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.@ghc-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.b, 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????????NoneF@@WNone#$5@ghc-libFinds external references. Remember to remove the names defined by this group of BCOs themselves$$@@@@@@@$$@VNone #$5&@@@@None >_@@@@@@@@@@@@@@@@fNone#$@ghc-libLoad the module containing the given Name and get its associated . Throws a  . if loading fails or the name cannot be found.@ghc-lib"Temporarily extend the loaded env.@ghc-lib$Display the persistent linker state.@ghc-lib,Initialise the dynamic linker. This entails*a) Calling the C initialisation procedure,6b) Loading any packages specified on the command line,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.@ghc-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.Aghc-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.Aghc-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.Aghc-libThe linkables to *keep*.(((((((((((@@@@@@@@@AAAA((((((((((@(@@AAA@@A@@@@NoneAghc-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.Aghc-lib=Force the interfaces for the given modules to be loaded. The F# parameter is used for debugging (-ddump-if-trace) only: it is shown as the reason why the module is being loaded.Aghc-libForce the interface for the module containing the name to be loaded. The F# parameter is used for debugging (-ddump-if-trace) only: it is shown as the reason why the module is being loaded.Aghc-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 moduleAghc-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 failedAghc-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 segfaultAghc-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 AAAAAAAAA AAAAAAAAANoneʎAghc-lib&ghc-lib(Releases the external interpreter state.&&&&&&&&&&&&&&AA&&&&&&&&&&&AA&&&None#$؍Aghc-libFailure modes for A.Aghc-libF returned C.Aghc-libC: The module was compiled. b: The module was :loaded.Aghc-libThe  was defined interactively.Aghc-libdefault ExecOptionsAghc-lib3Run a statement in the current interactive context.Aghc-libLike A, but takes a parsed statement as argument. Useful when doing preprocessing on the AST before execution, e.g. in GHCi (see GHCi.UI.runStmt).Aghc-libRun some declarations and return any user-visible names that were brought into scope.Aghc-libLike A, but takes parsed declarations as argument. Useful when doing preprocessing on the AST before execution, e.g. in GHCi (see GHCi.UI.runStmt).Aghc-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.)Aghc-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.Aghc-libReturns True if the specified module is interpreted, and hence has its full top-level scope available.Aghc-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)Aghc-lib=Returns all names in scope in the current interactive contextAghc-lib Returns all s in scope in the current interactive context, excluding any that are internally-generated.Aghc-lib:Parses a string as an identifier, and returns the list of s that the identifier can refer to in the current interactive context.Aghc-libReturns True! if passed string is a statement.Aghc-libReturns True, if passed string has an import declaration.Aghc-libReturns True+ if passed string is an import declaration.Aghc-libReturns True' if passed string is a declaration but  not a splice.Aghc-libGet the type of an expression Returns the type as described by >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>???????????????AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBBBB&>>>>>>>>>>>>>>>>>AA>>>>>>A>>>>>>>AAAAAAAAA>>>>AAAA?AAAAAAAAAAAAAAAAAAAABBAAABAA??????????????BBBNone %Bghc-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 pragmasBghc-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.Bghc-lib/Computes the next output filename after we run  next_phase. Like B, but it operates in the !9 monad (which specifies all of the ambient information.)Bghc-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.b: is this intended to be a b or b build output? Temporary files just go in a fresh temporary name.b3: 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?)Bghc-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.Bghc-libWhat phase to run after one of the backend code generators has runBghc-libinput filenameghc-lib8optional buffer to use instead of reading the input fileghc-libstarting phaseBghc-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 successfulBghc-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 successfulBghc-libRun this phaseghc-libname of the input fileghc-lib.for convenience, we pass the current dflags in&!BB!BB?BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB&BBBBBB!BB!BBBBBBBBBBBBBBBBBBBBBBBBBB?BNone #$% Bghc-lib>Describes which modules of the module graph need to be loaded.Bghc-lib&Load all targets and its dependencies.Bghc-lib0Load only the given module and its dependencies.Bghc-libLoad only the dependencies of the given module, but not the module itself.Bghc-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.Bghc-lib$Perform dependency analysis like in B. In case of errors, the errors and an empty module graph are returned.Bghc-lib!Perform dependency analysis like B 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 B this function will not update _ with the new module graph.Bghc-libTry to load the program. See B 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 A> after each compiling each module, whether successful or not.If errors are encountered during dependency analysis, the module B 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 A.Bghc-libGeneralized version of B which also supports a custom A (for reporting progress) and ! (generally produced by calling B.Bghc-lib Tests if an b9 is a boot file, primarily for constructing elements of b. We conflate signatures and modules because they are bound in the same namespace; only boot interfaces can be disambiguated with `import {- SOURCE -}`.Bghc-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 cyclicBghc-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.Bghc-libexcluded modulesghc-liballow duplicate rootsBghc-libexcluded modulesghc-liballow duplicate rootsBghc-libexcluded modulesghc-liballow duplicate rootsghc-libpossibly empty Bag of errors and a module graph.Bghc-libDrop hi-boot nodes? (see below)ghc-libRoot module name. If Nothing, use the full graph.,,33BBBBBBBBBBBBBBBBBBBBBBBBBBBB,,BB33BBBBNone %& module is loaded.Bghc-lib8Return the bindings for the current interactive session.Bghc-lib9Return the instances for the current interactive session.Bghc-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.Cghc-lib!Retrieve module safe haskell modeCghc-libLooks up a global name: that is, any top-level name in any visible module. Unlike C, lookupGlobalName does not use the interactive context, and therefore does not require a preceding A.Cghc-lib"get the GlobalRdrEnv for a sessionCghc-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.Cghc-libprint a 0, adding parentheses if the name is an operator.Cghc-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.Cghc-lib.Give even more information on the source than C This function allows reconstructing the source completely with C.Cghc-libGiven a source location and a StringBuffer corresponding to this location, return a rich token stream with the source associated to the tokens.Cghc-lib/Take a rich token stream such as produced from C and return source code almost identical to the original code (except for insignificant whitespace.)Cghc-libTakes a  and possibly a F, and consults the filesystem and package database to find the corresponding +, using the algorithm that is used for an import declaration.Cghc-libLike C, but differs slightly when the module refers to a source file, and the file has not been loaded via B. In this case, C/ will throw an error (module not loaded), but C 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.Cghc-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.Cghc-libReturn if a module is trusted and the pkgs it depends on to be trusted.Cghc-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.Cghc-lib.Get the monad GHCi lifts user statements into.Cghc-lib Returns the  for a . The 2 may refer to any entity known to GHC, including s defined using runStmt.Cghc-lib&A pure interface to the module parser.Cghc-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 id2Bghc-libSee argument to B.ghc-libThe action to perform.Bghc-libSee argument to B.ghc-libThe action to perform.Cghc-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.Cghc-lib6Haskell module source text (full Unicode is supported)ghc-lib the flagsghc-lib#the filename (for source locations) ,EJ III  bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbcccccccccccccccccccccccccccccccccccccccccccccccccccccccbbcccccccccccccccccccccccccccccccccccccccccccccccccbccbccccccccccccccccccccccdddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddbdddddddddddddddddddddddeeeeeeeeeeeebeeeeeeeeebeeeeeeeCeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeebeeeeeeeeeeeeeeeeeeeeeeebeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeffffffffffffbffffffffffffffffffffffffffffffffffffffffffffffffffbffffffbffffffbffffffffffbffffffffffffffffffffffffffffffffffffffffffffgggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggghhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhbhhhhhhhhhhhhhhhhiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiibiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii iiiiiiijMMMMjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm mmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmMMMMMMMMMMmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn nnnnnnnnnnnnnn nnnnnnnnnnnn  ((((nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnoooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo!,,-,,,,,,,----&&&&>>>>>>>>>>>>(((((((((((*,6<<<<>>>>>>>>>>>>>>>>>>>>>>>AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCBB B(AAAABBBA*(   BBABBBBBBC((((((((BBBBBBBBBBBB&&&AABBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB(((((!,,-,,,,,,,----,BBBBBBCCCCCCCCCCCCC  AA>>>>>>A>>>>>>>AAAAAAACCBBBCCCCAACAABBCA<<>>>&>>>>>>>>>>>>>>>CAAAACCBC>>>AA ,ECJ C  C  6AA    BBCCCCCBNone<Cghc-libThe :print & friends commandsCCCCCCNone<5CCNone  ><Cghc-lib'Entry point to compile a Backpack file.CC Safe-Inferred=Cghc-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.CCNone>2Cghc-libUsed by GHCi to add an SPT entry for a set of interactive bindings.CCNone #$028@Cghc-lib1The exception thrown by "fail" in the GHCiQ monadCghc-libThe implementation of the  message: create a new IORef QState, and return a RemoteRef to it.Cghc-libRuns the mod finalizers.5The references must be created on the caller process.Cghc-libThe implementation of the  messageCghc-libThe TH state, created by Cghc-libThe splice to runghc-libWhat kind of splice it isghc-libThe source locationghc-lib>>>>>>>>>>>>>>>>>>>>>??????????????????????????????????????????????????????????????????????????????????@@AAAAAABBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDEFFFFFFFFFFFFFGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGHHIIIJKKKLLLLLMMMMMMMMMNNNNNNNNNOOOOPQQTXYYYYYYYYYYYYYYYYYYYYYYYYZZ[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[ [[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[ [ [[[[[ ]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]^_____________`aaaaabbcccdddddddddddddddd\\\\\\\gggggghhhiiiiiiiiiiiiiiiiiiilllllllmmmmnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnoooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooppppppppppqqqqqqqrrrrrrrrrrrrrrsssttttttttttuuuuuuuuuuuuuvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvwwwwwwwwwwwwwwwwxyyyyyyyyyyyyyyyyyyyyyyyyzz{||||||||||||||||||||||}}~                                                                                                                                                   !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""###################################################################################################################################$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$"$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%j%j%j%j%j%j%j%j%j%j%j%j%j%j%j%j%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&''''''''' ' ' ' ' ' ' ' ' ' ' ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''#'''''''''''''''''''''''''''(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((())))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))************ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * + + +++++++++++++++++++++++++++++e+e+e+e+e+e+e+e+e+e+e+e+e+e+e+e+e+e++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,---------------------------------------------------------"-"-"-"""-"-"-"-"-"-"-"-"-"-"-"-"----------------------------------------------&----------................................................................... . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / ' ' ' ' / ( ( ( ( / / / / / ' ' ' + + . . ( / / * * * * * * * * * * * / / / / / / , / * / / . , / / / / / / / ( ( * / / / / / / / / * / / / / / / / / / / / / / / / / / / ////////////////////////000+)++++++''///#*0***00**/R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R0000000000000000000000000000000000000000011111111111111111111111111U1U1U1U1U1U1U1U1U1U1U1U1U1U1U1U1U1U1U1U111111111111111111111111111111111111111111111111111111111111111111111111111111111111122222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222223333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333344444444444444444444444444444444444444444444444444444444444444444444444444444 4444444444444444444444444444444444444444444444444444455555555555555555555555,55555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555566666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777778888888888888888888888888888888888888888888888888888888888888888888888888888888888#888888888888888888888888888888888888888888888888888999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999::9:9:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<7<<<<<<<<<<<<<<<<<<<<<<<<<<===========================<=================<=====================================================&============================'='='='='='='='='='>'>'>'>'>'>'>'>'>'>'>'>'''>'>'>'>'>'>'>'>'>'>'>'>'>'>'>S>S>S>S>S>S>S>S>S>S>S>S>S>S=S>S>S>S>S>S>S>S>S=S=S=S>S=S=S&S=S=S=S=S=S>S>S>S>S>S>S>S>S>S>S>S>S>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>!>!>!>!>>>>>>>>>>>>>>>>>>>>???????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????W?W?W?W?W?W@W@V@V@V@V@V@V@V@V@V@V@V@V@V@V@V@V@V@V@V@V@V@@@@@@@@@f@f@f@f@f@f@f@f@f@f@f@f@f@f@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@)@)@)@)@)@)@)@)@AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAA"A"A"A"A"#"A"A"A"A"A"A"A"A"A"A"A"A"A"A"A"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBB@BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB'AAA$BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBkBkBkBkBkBkBkBBBBBBBBBBBBBBBB*B*BBB_BBBBBBBBCCCC C CCCCCCCCCCC CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC$CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCD""DDDDDDDDDDDCDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDCDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDEEEEEEEEEEEEEEEEEEE EBCEEEEEE)EEE E E E EEE EEEEEEEEEE EBEEEEEEEEECEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEFFFFFFFFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFGGGGGGGGGGGGGGGGGGGGGGGGEGEGEGEGEGEGEGEGEGEGEGEGEGEGEGEGEGEGEGEGEGEGEGEGEGEGEGEGEGEGEGEGEGEGEGEGEGEGEGEGEGEGEGFGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH)HHHHHHHHHHHHHHHHHHHHHH7HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH H H H H H H H H H H I III I IIIIIIIIII IIIIIII I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I 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 JJJ JIJ JFJFJFJFJFJFJFJFJFJFJFJFJFJFJFJFJFJFJFJFJFJFJFJFJFJFJFJFJFJFJFJFJFJFJFJFJFJFJFJFJFJFJFJFJFJFJFKFKFKFKFKFKFKFKFKFKFKFKFKFKFKFKFKFKFKFKFKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLBLBLBLBLBLBLBLBLBLBLBLBLBLBL L L L LLLLL L L L L L L L L L LBLBLBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMB8BMBMB8BMBMBMBMB B B MMMMMMMMMMMMMMMMMMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMGMGGGMGMGMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFN N N N N N N N N N N N N N N N N N N N N N N N N N N N N N N N N N N N N N N N N N N N N N N N N NMNMNMNMNMNMNMNMNMNMNMNM MNMO OBOBOBOOOOOOOOOOOOOOOOOOOOOOOOOOOBOBOBOBOBOBO O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O OMOMOMOOOOOOOMOMOMOMOMOJOJOJOJOJOJOJOJOJOJOJOJOJOJOJOJOJOJOJOJOJOJOJOJPJPJPJPJPJPJPJPJPJPJPJPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQEQEQEQEQEQEQQQRRRRRRRRRRRRRRRRRRRRRRRRRRRRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBSBSBSBSBSBSBSBSBSBSBSBSBSBSBSBSBBSBSBSBBSBSBBBSBSBSBBSBSBSBSBSBSBSBSBSBSBSBSBSBSBSBSBSBSBSBSBSBSBSBSBSBSBSBSBSBSBSBSBSBSBSBSBSBSBSBSBSB OSOSOSOSOSOSOSOSOSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTQTQTQTQTMTMTMTMTMTMTMTMTMTMTMTMUMUMUMUMUMUMUMUMUMUMUMUMUMUMUMUMUMUMUMUMUMUMUMUMUMUMUMUMUMUMUMUMUMUMUMUMUMUMUMUIUGUGUU 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 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 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 V V V V V V V V V V V V V V V V V V V V V V V V VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X Y Y Y YVYVYVYVYVYVYVYVYVYVYVYVYVYVYVYVYVYVYVYVYVYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYSYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYSYSYSYSYSYSYSYSYSYSYSYSYSYSYSYSYSYSYSYSYSYSZSZSZSZSZSZSZSZSZSZSZSZSZSZSZZZZZYZYZYZYZSZSZSZFZFZFZFZFZFZFZFZFZFZFZFZFZFZFZFZFZFZFZFZFZFZFZFZFZFZFZFZFZFZFZFZFZFZFZ 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 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 [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[A[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[I[I[I[I[I[I[I[I[I[I[I[I[I[I[I[I[I[I[I[I[I[I[I[I[I[I\I\I\I\I\I\I\I\I\I\I\I\I\I\I\I\I\I\I\I\I\I\\\I\I\O\O\O\O\O\O\O\O\O\O\O\O\O\O\O\O\O\O\O\O\O\O\O\O\O\O\O\O\O\O\O\O\O\O\O\O\O\O\O\O\O\O\O\O\O\O\O\O\O\O\O\O\O\O\O\O\O\O\O\O\O\O\O\O\O\O\O\O\O\O\O\O\O\O\O\O\I\I\I\I\I\I\I\I\I\I\I\I\I\I\I\I\I\I\I\I\I\I\I\I\I\I\I]I]I]I]I]I]I]I]I]I]I]I]I]I]I]I]I]I]I]I]I]I]I]I]I]I]I]I]I]I]I]I]I]I]I]I]I]I]I]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]@]'](]]]]]]]]]]^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^M^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^_^_^_^_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_GGG_G_G_G_G_G_G_G_G_G_G_G_G_G_____________________________________________________________________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`Y`Y`Y`Y`Y`Y`Y`Y`Y`Y`Y`Y`Y`Y`Y`Y`Y`Y`_`_`_`_`_`_`_`_`_`_`_`_`_`_`_`_`_`_`_`_`_`_`_`_`_`_`_`_`_`_`_`_`_`_`_`_`_`_`_D+`+`+`+`++_`_`_`_`_`_`_`_`_`_`_`_`"`"`"`"`"`"`"`"`"`"aaaaaaaaaaa aaa aa HRaRa aBaaBaaBaaaa aa a aaBaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaBCaBaaaaaaaaaaaBaaa"a"a"aaaaaaaaaaaaaaaaaaaaaaaa a a a aBaBaBaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaBaBaBaBaBaBaBaBaBaBaaaaaaaaaaBaBaBbBbBbBbBbBbBbBbBbBbBbBbBbBb b b b b b b bbbbbbbbBbBbBbBbBbBbBbBbBbBbBbBbBbBbBbBbBbBbBbBbBbBbBbBbBbBbBbBbBbBbBbBbBbBbBbBbBbBbBbBbBbBbBbBbBbBbBbBb b b b b babababBbBbBbBbBbBbBbBbBbBbaaabaaabababab b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b bacacacacacacacacacacacacacacacacacacacacacacacacacacacacacacacacacacacacacacacacacacacacacacacacacBcBcBcBcBcBcBcBcBcBcBcBcBcBcBcBcBcBcBcBcBcBcBcBcBcBcBcBcBcBcBcBcBcBcBcacacacacacacacacacacacacacacacacacacacacacacacacacacacacacacacacacacacacacacacacacacacac c c c c d d dBBBdBdBdBdBdBdBdBdBdBdBdBdBdadadadacadadadadadadadadadadadadadadadadadadadadadadadadadadadadadada5adadad d d d d d d dacadadadad d d d d dadadadadacadaddddd d d d d d d d dadadadadadadadadadadadadadadadadadadadadadadadad d d dadadad d d d d ddddddddddddddddddddeaeaeaedededededededededededededeBeBeBeBeBeBeBeBeBeBeBeBeBe e e e eeeaaaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeeeeeeeeeeeeeeeeeeeeeacaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeBeBeBeBeBeBeBeBeBeBeBeBeBeBeBeBeBeBeBeBeBeBeBeaeaeaeaeaeaeaeaeaeaeaeaeaeBeBeBeBeBeBeaeaeafafafafafafafafafafafafafafafafafafafafafafafafafafafafafafafafafBfBfBfBfBfBfBfBfBfBfBfBfBfBfBfBfBfBfBfBfBfBfBfBfBfBfBfBfBfBfBfBfBfBfBfBfBfBfBfBfBfBfBfafafafafafafafafafafafafafafafafafafafafafafafafafafafafafafafafafafafafafafafafafafafafafafafafaafafafafafafafafafafagagagagagagagagagagagagagagagagagagagagagagagagagagagagagagagagagagagagagagagagagagagagagagagagagagagagagagagagagagagagagagagagagagagagagagagagagagagagagagagagagagagagagagagagagagaaaaaaagaggagagagagagagagagagagagacagagagagagagagagagagagagagagacagagagagagagagagagagagagagagagagahahahahahahahahahahaeahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahahBh hahahah h h hahh hahahahahahBhBhBhBhBhBhBhBhBhBhBhBhBhBhBhBhBhBhBhBhBhBhBhBhBhBhBhBhBhBhBhBhBhBhBhBhBhBhBhBhBhBhBhBhBhBhBhBhBhBhBhBhBhBhBaBhBhBhBhBhBhBhBhBhBiBbBiBbBiBiBiBiBiBiBiBiBiBiBiBiBiBiBiBiBiBiBiBiBiBiBiBiBiBiBiBiBiBiBiBiBiBiBiBiBiBiBiaiaiai iaiaiaiai i iiiai iaiaiaiaiaiaiaiaiaiaiaiaiaiaiaiaiaiaiaiaiaiaiaiaiaiaiaiaiaiaiaiaiaiaiaiaiaeaeaiaiaiaiaiaiaiaiaiaiaiaiaiaiaiaiaiaiaiaiaiaiaiaiaiaiaiaiaiaiaiii i i i i i i j jajadaj jjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjajajajajajajajajajajajajajajajajajaj jajajajajajajajajajajajajajajajajajajajajajajajajajajajajajajajajajajajajajajajajajajajajajajajajajajajajajajajajajajajajabajadajajajajajajajaeajajajajajajakakakakakakakakakakakakakakakakakakakakakakakakakakakakakakakakakakakakakadak 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 b k k k k kakakalabalalalalalalalalalalalalalalalalalalalalalalalalalalalalalalalalalalalalalalalalalaldldldldldldldldldldldldldldld dldldldldldldldldlalalalalalalalalalalalililililililililililililililalalalalalalalalalalalalllllllllllllllllllllllllllllmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm)ghc-lib-0.20201201-5HCrHInU8m3DyamVwWZQIKGHC.HsToCore.MonadGHC.Rename.Unbound GHC.PluginsGHCGHC.Driver.MakeGHC.Tc.Utils.EnvGHC.Rename.NamesGHC.StgToCmm.MonadGHC.Builtin.Names.THGHC.Builtin.RebindableNamesGHC.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.StgToCmm.ExtCodeGHC.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.CoreToByteCodeGHC.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.DmdAnalGHC.Core.Opt.CprAnal GHC.Core.TidyGHC.Core.RulesGHC.Unit.FinderGHC.Linker.LoaderGHC.Core.Opt.SpecConstrGHC.Core.Opt.SimplifyGHC.Core.TyCon.SetGHC.Stg.Lift.AnalysisLanguage.Haskell.TH.Quote GHC.CoreToStgGHC.Data.Bitmap GHC.Cmm.InfoGHC.CmmToAsm.PPC.Instr GHC.CmmToAsm.Reg.Linear.FreeRegsGHC.CmmToAsm.PPC.RegInfoGHC.CmmToAsm.PICGHC.CmmToAsm.PPC.CodeGenGHC.Cmm.ProcPointGHC.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.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.Driver.PipelineGHC.Iface.UpdateIdInfosGHC.IfaceToCoreGHC.Linker.UnitGHC.Platform.HostGHC.Rename.ExprGHC.Settings.UtilsGHC.Settings.IO GHC.Stg.CSEGHC.Stg.DepAnal GHC.Stg.FVs GHC.Stg.Lint GHC.Stg.Stats GHC.Stg.SubstGHC.Stg.Lift.MonadGHC.Stg.UnariseGHC.StgToCmm.CgUtilsGHC.StgToCmm.ArgRepGHC.StgToCmm.BindGHC.StgToCmm.TickyGHC.StgToCmm.ProfGHC.StgToCmm.HpcGHC.StgToCmm.EnvGHC.StgToCmm.Layout GHC.Stg.LiftGHC.Stg.PipelineGHC.ByteCode.InstrGHC.StgToCmm.HeapGHC.StgToCmm.ForeignGHC.StgToCmm.PrimGHC.StgToCmm.DataConGHC.StgToCmm.Expr GHC.StgToCmmGHC.Cmm.ParserGHC.Cmm.LayoutStackGHC.SysTools.ArGHC.SysTools.ProcessGHC.SysTools.InfoGHC.Tc.Gen.MatchGHC.Tc.Gen.Splice GHC.Tc.ModuleGHC.Tc.Types.EvTermGHC.Runtime.EvalGHC.Tc.Utils.Monad GHC.Iface.EnvGHC.Tc.TyCl.PatSynGHC.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.FlattenGHC.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.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.CmmToLlvm.DataGHC.CmmToLlvm.PprGHC.CmmToLlvm.CodeGenGHC.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.Cmm.Info.BuildGHC.Cmm.PipelineGHCi.BinaryArrayGHCi.InfoTable GHCi.ObjLinkGHCi.ResolvedBCOGHCi.CreateBCOGHC.Runtime.Heap.InspectGHC.Linker.MacOSGHC.Linker.ExtraObjGHC.Linker.Windows GHC.CmmToLlvmGHC.Driver.CodeOutputGHC.Linker.DynamicGHC.Linker.StaticGHC.HsToCore.Coverage GHC.HsToCoreGHC.Iface.Ext.AstGHC.ByteCode.InfoTableGHC.ByteCode.LinkerGHC.Runtime.LoaderGHC.Driver.MainGHC.Runtime.DebuggerGHC.Driver.MakeFileGHC.Driver.Backpack GHCi.SignalsGHCi.StaticPtrTableGHCi.THGHCi.RunLanguage.Haskell.TH.CodeDo Paths_ghc_lib GHC.LinkerGHC.Core.SubstSubstliftedIdsExpander newFamInstcheckConsistentFamInst GHC.Hs.Pat ConPatOutGHC.LlvmDynFlagsbackendGHC.Driver.Env SourceErrorbaseGHC.Base<*>pure*> Applicative Control.Monad mapAndUnzipMData.TraversablemapM Data.FoldablefoldlMfoldrM Data.Functor<$><*liftA20ghc-lib-parser-0.20201201-1H96yL9kQWzJRo49QCadHFGHC.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 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 strTyLitIdKey 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 SucceededreboundIfSymbolGHC.Builtin.TypesliftedTypeKindunrestrictedFunTyConGHC.Builtin.Types.PrimfunTyConGHC.Core.TyCo.FVscloseOverKindscloseOverKindsDSetcloseOverKindsList coVarsOfType coVarsOfTypesnoFreeVarsOfType scopedSort tyCoFVsBndr tyCoFVsOfTypetyCoFVsVarBndrtyCoFVsVarBndrstyCoVarsOfTypetyCoVarsOfTypeDSettyCoVarsOfTypeWellScopedtyCoVarsOfTypestyCoVarsOfTypesWellScopedGHC.Core.TyCo.RepfoldTyCoisInvisibleBinder isNamedBinderisVisibleBinder mkForAllTy mkForAllTysmkInvisForAllTys mkInvisFunTymkInvisFunTyManymkInvisFunTysManymkPiTymkPiTys mkTyConApp mkTyConTy mkTyVarTy mkTyVarTys mkVisFunTymkVisFunTyMany mkVisFunTysmkVisFunTysManytypeSizeGHC.Core.TyCo.SubstcloneTyVarBndrcloneTyVarBndrscomposeTCvSubstcomposeTCvSubstEnv emptyTCvSubstemptyTvSubstEnv extendCvSubstextendTCvInScopeextendTCvInScopeListextendTCvInScopeSetextendTCvSubstextendTCvSubstListextendTCvSubstWithCloneextendTvSubstAndInScopeextendTvSubstBinderAndInScopeextendTvSubstWithClone getTCvInScopegetTCvSubstRangeFVs getTvSubstEnvisEmptyTCvSubst lookupTyVarmkEmptyTCvSubst mkTCvSubst mkTvSubstPrsnotElemTCvSubst setTvSubstEnvsubstCoUncheckedsubstCoWithUnchecked substScaledTysubstScaledTyUncheckedsubstScaledTyssubstScaledTysUnchecked substThetasubstThetaUncheckedsubstTyAddInScopesubstTyUnchecked 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 isAtomicTy isCoVarType isCoercionTyisCoercionTy_maybeisDataFamilyAppType isFamFreeTy isForAllTy isForAllTy_co isForAllTy_tyisFunTy isKindLevPolyisLiftedRuntimeRepisLiftedTypeKindisLiftedType_maybe isLinearTypeisLitTyisManyDataConTyisMultiplicityTyisMultiplicityVar isNumLitTyisOneDataConTyisPiTyisPredTyisPrimitiveTypeisRuntimeRepKindedTyisRuntimeRepTyisRuntimeRepVar isStrLitTy isStrictTypeisTauTy isTyVarTy isTypeLevPolyisUnboxedSumTypeisUnboxedTupleTypeisUnliftedRuntimeRepisUnliftedTypeisUnliftedTypeKindisValidJoinPointTypekindRep kindRep_maybelinearmapTyComapTyCoXmightBeUnliftedType mkAnonBindermkAppTymkAppTysmkCastTy mkCoercionTymkFamilyTyConApp mkInfForAllTymkInfForAllTys mkNumLitTymkScaledmkSpecForAllTymkSpecForAllTys mkStrLitTymkTyCoInvForAllTymkTyCoInvForAllTysmkTyConBindersPreferAnonmkVisForAllTysnewTyConInstRhs nonDetCmpTc nonDetCmpTypenonDetCmpTypeXnonDetCmpTypesnonDetCmpTypesXoccCheckExpandpartitionInvisibleTypespartitionInvisibles piResultTy piResultTyspickyIsLiftedTypeKindpprUserTypeErrorTyrepGetTyVar_mayberepSplitAppTy_mayberepSplitAppTysrepSplitTyConApp_mayberesultIsLevPoly scaledSetseqTypeseqTypes splitAppTysplitAppTy_maybe splitAppTyssplitCastTy_maybesplitForAllCoVar_maybesplitForAllInvisTVBinderssplitForAllReqTVBinderssplitForAllTyCoVarsplitForAllTyCoVarBinderssplitForAllTyCoVar_maybesplitForAllTyCoVarssplitForAllTyVar_maybe splitFunTysplitFunTy_maybe splitFunTyssplitInvisPiTyssplitInvisPiTysNsplitListTyConApp_maybe splitPiTysplitPiTy_maybe splitPiTys splitTyConAppsplitTyConApp_maybesplitVisVarsOfTypesplitVisVarsOfTypesstripCoercionTytcIsConstraintKindtcIsLiftedTypeKindtcIsRuntimeTypeKindtcRepSplitAppTy_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.CoercionbadCoercionHolebadCoercionHoleCo buildCoercioncastCoercionKindcastCoercionKind1castCoercionKind2coToMCo coVarKindcoVarKindsTypesRole coVarName coVarRole coVarTypes coercionKindcoercionKindRole coercionKinds coercionLKind coercionRKind coercionRole coercionTypecomposeSteppers decomposeCodecomposeFunCodecomposePiCos downgradeRoleemptyLiftingContext eqCoercion eqCoercionXetaExpandCoAxBranchextendLiftingContextextendLiftingContextAndInScopegetCoVar_maybeinstNewTyCon_maybe isCoVar_maybe isGReflCoisGReflCo_maybe isGReflMCo isMappedByLCisReflCoisReflCoVar_maybeisReflCo_maybe isReflexiveCoisReflexiveCo_maybe lcInScopeSet lcSubstLeft lcSubstRight lcTCvSubst liftCoSubstliftCoSubstTyVarliftCoSubstVarBndrUsingliftCoSubstWithliftCoSubstWithExliftEnvSubstLeftliftEnvSubstRightltRole mapStepResultmkAppComkAppCos mkAxInstCo mkAxInstLHS mkAxInstRHS mkAxiomInstCo mkAxiomRuleComkCoCast mkCoVarCo mkCoVarCosmkCoercionTypemkCoherenceLeftComkCoherenceRightComkFamilyTyConAppCo mkForAllCo mkForAllCosmkFunCo mkGReflCo mkGReflLeftComkGReflRightComkHeteroCoercionTypemkHeteroPrimEqPredmkHeteroReprPrimEqPredmkHoleComkHomoForAllCosmkInstComkKindComkLRCo mkNomReflComkNthCo mkNthCoFunCo mkPhantomComkPiComkPiCos mkPrimEqPredmkPrimEqPredRolemkProofIrrelComkReflCo mkRepReflComkReprPrimEqPredmkSubComkSubstLiftingContextmkSymCo mkTransCo mkTransMCo mkTransMCoL mkTyConAppComkUnbranchedAxInstComkUnbranchedAxInstLHSmkUnbranchedAxInstRHSmkUnivComultToCo nthCoRolenthRole pprCoAxBranchpprCoAxBranchLHSpprCoAxBranchUser pprCoAxiompromoteCoercionseqCo setCoVarNamesetCoVarUniquesetNominalRole_maybesimplifyArgsWorkersplitAppCo_maybesplitForAllCo_co_maybesplitForAllCo_maybesplitForAllCo_ty_maybesplitFunCo_maybesplitTyConAppCo_maybesubstForAllCoBndrUsingLC substLeftCo substRightCo swapLiftCoEnvtidyCoAxBndrsForUsertopNormaliseNewType_maybetopNormaliseTypeXtyConRolesRepresentational tyConRolesXunwrapNewTypeStepperzapLiftingContext coVarsOfCo tyCoFVsOfCo tyCoFVsOfCos tyCoVarsOfCotyCoVarsOfCoDSet tyCoVarsOfCospprCo pprParendCo coHoleCoVar coercionSizesetCoHoleCoVaremptyCvSubstEnv getCvSubstEnv lookupCoVar substCoVarsubstCoVarBndr substCoVars substCoWithsubstCostidyCotidyCosisCoVarmkCoVar LiftCoEnvLiftingContextLCNormaliseStepResultNS_AbortNS_DoneNS_StepNormaliseStepperBlockSubstFlag NoBlockSubst YesBlockSubst ch_blocker ch_co_varch_ref CoercionP CoercionR MCoercionMCoMRefl MCoercionRUnivCoProvenance CvSubstEnvGHC.Types.Var.Env InScopeSetGHC.Tc.Types.Constraint tyCoVarsOfCt tyCoVarsOfCts tyCoVarsOfWCQCInstQCIqci_ev qci_pend_scqci_predqci_tvsId RealSrcSpansfInteractInert sfInteractTop sfMatchFam alphaTyVarsGHC.Types.Fixity LexicalFixity GHC.Hs.Type mkHsAppTy typeNatTyConstypeNatAddTyContypeNatSubTyContypeNatMulTyContypeNatDivTyContypeNatModTyContypeNatExpTyContypeNatLogTyContypeNatLeqTyContypeNatCmpTyContypeSymbolCmpTyContypeSymbolAppendTyContypeNatCoAxiomRulesclassATs 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 idCoreRules idCprInfo idDataCon idDemandInfo idFunRepArity idHasRulesidInlineActivationidInlinePragmaidIsFrom idJoinArityidLFInfo_maybeidMultidName idOccInfo idOneShotInfoidRuleMatchInfo idScaledTypeidSpecialisationidStateHackOneShotInfo idStrictnessidType 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 setIdCprInfosetIdDemandInfo setIdInfo setIdLFInfo setIdName setIdOccInfosetIdOneShotInfosetIdSpecialisationsetIdStrictness setIdTypesetIdUnfolding setIdUniquesetInlineActivationsetInlinePragmasetOneShotLambdastateHackOneShottransferPolyIdInfo typeOneShotupdOneShotInfozapFragileIdInfozapIdDemandInfo zapIdOccInfozapIdStrictnesszapIdTailCallInfozapIdUsageEnvInfozapIdUsageInfozapIdUsedOnceInfo 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.LabelFactBase RewriteFun TransferFunDataflowLatticefact_bot fact_join JoinedFactChanged NotChangedNewFactOldFactFact changedIf analyzeCmmBwd analyzeCmmFwd rewriteCmmBwdgetFact joinOutFacts joinFacts mkFactBasefoldNodesBwdOOfoldRewriteNodesBwdOOGHC.Cmm.BlockId newBlockIdpprExprpprLit$fOutputablePenvGlobalReg$fOutputableGlobalReg$fOutputableArea$fOutputableLocalReg$fOutputablePPlatformCmmLit$fOutputableCmmReg$fOutputablePPlatformCmmExprpprCmms pprCmmGroup pprStatic pprSection$fOutputableForeignHint!$fOutputablePPlatformCmmInfoTable$fOutputablePPlatformCmmStatic"$fOutputablePPlatformGenCmmStatics$fOutputablePPlatformGenCmmDecl CmmLocalLive liveLatticecmmLocalLivenesscmmGlobalLivenessgen_killGHC.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_DistrustAllPackagesOpt_DmdTxDictSelOpt_DoAnnotationLintingOpt_DoAsmLintingOpt_DoCmmLintingOpt_DoCoreLintingOpt_DoEtaReductionOpt_DoLambdaEtaExpansionOpt_DoLinearCoreLintingOpt_DoStgLintingOpt_DumpToFileOpt_EagerBlackHolingOpt_EmbedManifestOpt_EnableRewriteRulesOpt_EnableThSpliceWarningsOpt_ErrorSpansOpt_ExcessPrecisionOpt_ExitificationOpt_ExposeAllUnfoldingsOpt_ExposeInternalSymbolsOpt_ExternalDynamicRefsOpt_ExternalInterpreter Opt_FastLlvm Opt_FlatCache 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_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 depSuffixes dirsToCleandumpDir dumpFlags dumpPrefixdumpPrefixForce dump_actiondylibInstallName dynHiSuf_ dynLibLoader dynObjectSuf_dynOutputFile_ dynamicNowdynamicTooFailedenableTimeStatsextensionFlags extensionsfatalWarningFlags fileSettings filesToClean floatLamArgsflushErrflushOutframeworkPathsfrontendPluginOpts generalFlagsgeneratedDumps ghcHeapSizeghcLinkghcModeghcNameVersionghcVersionFile ghciHistSize ghciScriptshaddockOptionshcSufhiDirhiSuf_hieDirhieSuf historySize homeUnitId_homeUnitInstanceOf_homeUnitInstantiations_hookshpcDirignorePackageFlags importPaths includePathsincoherentOnLoc initialUnique inlineCheckinteractivePrintlanguageldInputsliberateCaseThreshold libraryPaths liftLamsKnownliftLamsNonRecArgsliftLamsRecArgs llvmConfig log_action mainFunIsmainModuleNameIs maxErrorsmaxInlineAllocSizemaxInlineMemcpyInsnsmaxInlineMemsetInsnsmaxPmCheckModelsmaxRefHoleFitsmaxRelevantBindsmaxSimplIterationsmaxUncoveredPatternsmaxValidHoleFits maxWorkerArgs newDerivOnLocnextTempSuffixnextWrapperNum objectDir objectSuf_optLevel outputFile_outputHioverlapInstLocpackageDBFlags packageEnv packageFlags parMakeCount pkgTrustOnLoc platformMiscpluginModNameOptspluginModNamespluginPackageFlagspprCols pprUserLengthprofAuto rawSettingsreductionDepthrefLevelHoleFits reverseErrorsrtccInfortldInfortsOptsrtsOptsEnabledrtsOptsSuggestions ruleCheck safeHaskell safeInfer safeInferred simplPhasessimplTickFactorsolverIterationsspecConstrCountspecConstrRecursivespecConstrThreshold splitInfo sseVersionstrictnessBeforestubDirtargetPlatform targetWays_thOnLoc toolSettings trace_action trustFlagstrustworthyOnLoc unfoldingOptsuniqueIncrement unitDatabases unitStateuseColor useUnicode verbosity warnSafeOnLocwarnUnsafeOnLoc warningFlagsGhcLink LinkBinary LinkDynLib LinkInMemory LinkStaticLibNoLinkGhcMode CompManagerMkDependOneShot getDynFlagsGHC.Utils.CliOptionOption FileOptionGHC.Types.SafeHaskellSafeHaskellModeGHC.Types.ErrorSeverity 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 replaceLabelsremoveUnreachableBlocksProcelimCommonBlocksRootedGraphEdgePathNodedompdomdomTreepdomTreeidomipdompddfsrpddfsfromAdj 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.ErrorprettyPrintGhcErrorsSevDumpSevErrorSevFatalSevInfoSevInteractive SevOutput SevWarning llvmFixupAsm 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 SimplCountHscEnvGHC.ByteCode.Types ModBreaksGHC.Core.InstEnvClsInstGHC.Types.CompleteMatch CompleteMatch GHCi.MessageEvalExprEvalAppEvalThis EvalResult EvalException EvalSuccess EvalStatus EvalStatus_ EvalBreak EvalCompleteMessage AbandonStmtAddLibrarySearchPath AddSptEntryBreakpointStatusCostCentreStackInfo CreateBCOsEnableBreakpointEvalIOEvalStmt EvalStringEvalStringToStringFindSystemLibraryFreeFFIFreeHValueRefsGetBreakpointVar GetClosure InitLinker LoadArchiveLoadDLLLoadObj LookupClosure LookupSymbol MallocData MallocStringsMkConInfoTable MkCostCentres NewBreakArrayPrepFFIRemoveLibrarySearchPath ResolveObjs ResumeSeq ResumeStmt RtsRevertCAFsRunModFinalizersRunTHSeqShutdownStartTH UnloadObj floatInwardsinstanceDFunId pprInstancepprInstanceHdrCompleteMatches BreakIndexmodBreaks_breakInfo modBreaks_ccsmodBreaks_declsmodBreaks_flagsmodBreaks_locsmodBreaks_vars UnlinkedBCOSizedSeq 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$fOutputableFloatBindsSimplMinitSmpl traceSmpl getSimplRules getFamEnvsgetOptCoercionOptsnewId newJoinId getSimplCounttick checkedTickfreeTick$fMonadIOSimplM$fHasDynFlagsSimplM$fMonadUniqueSimplM $fMonadSimplM$fApplicativeSimplM$fFunctorSimplM JoinFloats JoinFloat LetFloatsSimplSRDoneExDoneIdContEx SimplFloats sfLetFloats sfJoinFloats sfInScopeSimplEnvseMode seTvSubst seCvSubst seIdSubst seInScope emptyFloats pprSimplEnv mkSimplEnvgetMode seDynFlagsseUnfoldingOptssetModeupdMode 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 doStaticArgsDataConAppContextdcac_dcdcac_tys dcac_arg_tysdcac_co mkWwBodiesisWorkerSmallEnough mkWorkerArgsmkWWstr wantToUnboxdeepSplitProductType_maybe findTypeShape wwTopBinds DmdAnalOptsdmd_strict_dictsdmdAnalProgram$fOutputableAnalEnvcprAnalProgramtidyExpr tidyRules tidyUnfoldingmkRule roughTopNamespprRulesForUserextendRuleInfo addRuleInfoaddIdSpecialisations rulesOfBindsgetRules emptyRuleBase mkRuleBaseextendRuleBaseList unionRuleBase pprRuleBase lookupRule initRuleOptsruleCheckProgramGHC.Types.TargetTargetGHC.Unit.Module.Graph ModuleGraphGHC.Unit.Finder.Types FinderCacheGHC.Linker.TypesLoader specProgram$fOutputableSpecEnv$fOutputableDictBind$fOutputableSpecArg$fOutputableCallInfo$fOutputableCallInfoSet$fOutputableUsageDetailsspecConstrProgram$fOutputableValue$fOutputableHowBound$fOutputableCall$fOutputableArgOcc$fOutputableScUsage simplTopBinds simplExpr simplRulesTyConSetisEmptyTyConSet emptyTyConSet unitTyConSet mkTyConSetextendTyConSetListextendTyConSet unionTyConSetunionTyConSets minusTyConSet elemTyConSetdelFromTyConSetfilterTyConSetintersectTyConSetdisjointTyConSetdelListFromTyConSetintersectsTyConSet nameSetAny nameSetAllGHC.Stg.SyntaxLlStgAlt LlStgBinding LlStgExprLlStgRhsLanguage.Haskell.TH.Syntax dataToExpQ dataToPatQdataToQa coreToStg$fHasDynFlagsCtsM $fMonadCtsM$fApplicativeCtsM $fFunctorCtsM $fEqHowBound $fEqLetInfoBitmapmkBitmapintsToReverseBitmapmAX_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.LexerTokenGHC.Parser.Annotation AnnKeywordId ApiAnnKeyAnnotationCommentPDunPDliftP 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$fShowCmmTokengetAndRemoveAnnotationgetAndRemoveAnnotationComments getAnnotationgetAnnotationComments unicodeAnn AnnAnyclassAnnAsAnnAt AnnBackquoteAnnBangAnnByAnnCaseAnnClassAnnClose AnnCloseB AnnCloseBU AnnCloseC AnnCloseP 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 AnnOpenEQUAnnOpenPAnnOpenSAnnPackageName AnnPattern AnnPercent AnnPercentOneAnnProc AnnQualified AnnRarrow AnnRarrowU AnnRarrowtailAnnRarrowtailUAnnRecAnnRoleAnnSafeAnnSemi AnnSignatureAnnSimpleQuote AnnStaticAnnStock AnnThTyQuoteAnnThenAnnTildeAnnTypeAnnUnitAnnUsingAnnVal AnnValStrAnnVbarAnnViaAnnWhere AnnlarrowtailAnnlarrowtailU AnnrarrowtailAnnrarrowtailUAnnBlockCommentAnnDocCommentNamedAnnDocCommentNextAnnDocCommentPrev AnnDocOptions AnnDocSectionAnnLineCommentApiAnnsapiAnnComments apiAnnEofPos apiAnnItemsapiAnnRogueCommentsnodeId 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 varEnvDom unionUnVarSetunionUnVarSetsemptyUnVarGraphunionUnVarGraphunionUnVarGraphscompleteBipartiteGraph completeGraph neighbors hasLoopAt$fOutputableUnVarSet$fOutputableGen$fOutputableUnVarGraph $fEqUnVarSetcallArityAnalProgram 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 isUserSigmkDeclsGHCi.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 mergeSortAstssimpleNodeInfolocOnlymkScopemkLScope combineScopesmkSourcedNodeInfomakeNode makeTypeNode$fOutputableEvidenceInfo$fEqEvidenceInfo$fOrdEvidenceInfo$fFunctorEvidenceInfo DiffIdentDiffdiffFilediffAstsdiffAstnormalizeIdentsdiffListeqDiffvalidAstvalidateScopesfingerprintDynFlagsfingerprintOptFlagsfingerprintHpcFlagsGHC.Unit.Module.ModSummary ModSummaryGHC.Driver.Pipeline.Monad PhasePlus CompPipelineupdateModDetailsIdInfos tcIfaceDeclstcIfaceCompleteMatchestcIfaceAnnotationstcIfaceFamInst tcIfaceInst tcIfaceRules tcIfaceDeclgetUnitLinkOptscollectLinkOptscollectArchivescollectLibraryPathsgetLibsgetUnitLibraryPath packageHsLibshostPlatformArchhostPlatformOShostPlatformArchOSrnStmtsrnLExpr GHC.BaseDir expandTopDir RawSettings maybeReadmaybeReadFuzzygetTargetArchOS getRawSettinggetRawFilePathSettinggetRawBooleanSettingreadRawSetting SettingsErrorSettingsError_MissingDataSettingsError_BadData initSettingsstgCse$fTrieMapStgArgMap$fTrieMapConAppMap depSortStgPgmannTopBindingsFreeVarsannBindingFreeVarslintStgTopBindings $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 newUnique 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$fFunctorCmmParsecgBindcgLit mkSimpleLit addToMemLbl addToMemLblEaddToMem addToMemEmkTaggedObjectLoad tagToClosure emitRtsCallemitRtsCallWithResultemitRtsCallGencallerSaveVolatileRegscallerSaveGlobalRegcallerRestoreGlobalReg emitDataLitsemitRODataLits emitDataCon newStringCLitnewByteStringCLit assignTempnewTempnewUnboxedTupleRegsemitMultiAssign emitSwitchemitCmmLitSwitchwhenUpdRemSetEnabledemitUpdRemSetPushemitUpdRemSetPushThunkwithNewTickyCounterFunwithNewTickyCounterLNEwithNewTickyCounterThunkwithNewTickyCounterStdThunkwithNewTickyCounterContickyPushUpdateFrametickyUpdateFrameOmittedtickyEnterDynContickyEnterThunktickyUpdateBhCaf tickyEnterFun tickyEnterLNEtickyReturnOldContickyReturnNewContickyUnboxedTupleReturntickyDirectCall tickySlowCall tickyDynAlloctickyAllocHeaptickyAllocPrimtickyAllocThunk tickyAllocPAPtickyHeapChecktickyStackCheckccsTypeccType storeCurCCS mkCCostCentremkCCostCentreStackcostCentreFrom staticProfHdr dynProfHdrinitUpdFrameProfsaveCurrentCostCentrerestoreCurrentCostCentre profDynAlloc profAllocenterCostCentreThunkenterCostCentreFuninitCostCentres emitSetCCCldvRecordCreateldvEnterClosureldvEnter mkTickBoxinitHpc litIdInfo lneIdInfo rhsIdInfo mkRhsInit idInfoToAmodemaybeLetNoEscapeaddBindC addBindsC getCgIdInfo getArgAmodegetNonVoidArgAmodes bindToReg rebindToReg bindArgToRegbindArgsToRegsidToReg ClosureHeaderNoHeader StdHeader ThunkHeaderFieldOffOrPaddingFieldOffPadding emitReturnemitCalladjustHpBackwards directCallslowCallgetHpRelOffsetmkVirtHeapOffsetsWithPaddingmkVirtHeapOffsetsmkVirtConstrOffsetsmkVirtConstrSizes mkArgDescremitClosureProcAndInfoTableemitClosureAndInfoTable BinderInfo BindsClosure BoringBinderSkeleton ClosureSkRhsSkAltSkBothSkNilSkbinderInfoBndrtagSkeletonTopBind goodToLift closureGrowth$fOutputableSkeleton$fOutputableBndrBinderInfo$fOutputableBinderInfo stgLiftLamsstg2stg$fMonadUniqueStgM $fEqStgToDo $fFunctorStgM$fApplicativeStgM $fMonadStgM $fMonadIOStgMsizeSSssEltsBCInstrSTKCHECKPUSH_LPUSH_LLPUSH_LLLPUSH8PUSH16PUSH32PUSH8_WPUSH16_WPUSH32_WPUSH_G PUSH_PRIMOPPUSH_BCO PUSH_ALTSPUSH_ALTS_UNLIFTED PUSH_PAD8 PUSH_PAD16 PUSH_PAD32 PUSH_UBX8 PUSH_UBX16 PUSH_UBX32PUSH_UBX PUSH_APPLY_N PUSH_APPLY_V PUSH_APPLY_F PUSH_APPLY_D PUSH_APPLY_L PUSH_APPLY_P PUSH_APPLY_PPPUSH_APPLY_PPPPUSH_APPLY_PPPPPUSH_APPLY_PPPPPPUSH_APPLY_PPPPPPSLIDEALLOC_APALLOC_AP_NOUPD ALLOC_PAPMKAPMKPAPUNPACKPACKLABELTESTLT_ITESTEQ_ITESTLT_WTESTEQ_WTESTLT_FTESTEQ_FTESTLT_DTESTEQ_DTESTLT_PTESTEQ_PCASEFAILCCALLSWIZZLEENTERRETURN RETURN_UBXBRK_FUN LocalLabel getLocalLabelProtoBCO protoBCONameprotoBCOInstrsprotoBCOBitmapprotoBCOBitmapSize protoBCOArity protoBCOExpr protoBCOFFIs bciStackUse$fOutputableLocalLabel$fOutputableBCInstr$fOutputableProtoBCO$fEqLocalLabel$fOrdLocalLabelallocDynClosureallocDynClosureCmmallocHeapClosure emitSetDynHdrmkStaticClosureFieldsmkStaticClosureentryHeapCheckentryHeapCheck' altHeapCheckaltHeapCheckReturnsTonoEscapeHeapCheckheapStackCheckGen cgForeignCall emitCCall emitPrimCallemitForeignCallemitSaveThreadStatesaveThreadState emitSaveRegsemitRestoreRegsemitCloseNurseryemitLoadThreadStateloadThreadStateemitOpenNurserycgOpAppshouldInlinePrimOp cgTopRhsCon buildDynCon bindConArgscgExprcgTopRhsClosureemitBlackHoleCodepushUpdateFrameemitUpdateFramecodeGen parseCmmFilecmmLayoutStacksetInfoTableStackMap$fOutputableStackMap$fOutputableStackSlotArchive 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 tcInferRhoNCtcExprtcCheckMonoExprtcCheckMonoExprNC tcMonoExpr tcMonoExprNCtcCheckPolyExprtcCheckPolyExprNC tcMatchesFun tcGRHSsPatfinishTHrunRemoteModFinalizersrunQuasilookupThName_mayberunMetaDrunMetaTrunMetaPrunMetaEtcTopSpliceExpr runAnnotation runTopSplicetcTypedBrackettcUntypedBracket tcSpliceExpr FunDepEqnFDEqnfd_qtvsfd_eqsfd_pred1fd_pred2fd_locimproveFromAnother pprEquationimproveFromInstEnvcheckInstCoverage checkFunDeps$fOutputableFunDepEqnbadReexportedBootThingmissingBootThingcheckBootDeclMevDelayedError evCallStack tcInitTidyEnvGHC.Runtime.ContextInteractiveImportIIDeclIIModuleGHC.Runtime.Eval.TypesResumeinitTc initTcWithGblinitTcInteractive initTcRnIf discardResult getTopEnv updTopEnv getGblEnv updGblEnv setGblEnv getLclEnv updLclEnv setLclEnvgetEnvssetEnvsxoptMdoptMgoptMwoptMsetXOptM unsetXOptM unsetGOptM unsetWOptM whenDOptM whenGOptM whenWOptM whenXOptM unlessXOptM getGhcModewithDynamicNowwithoutDynamicNow getEpsVargetEps updateEps updateEps_getHpt getEpsAndHpt withException newArrowScopeescapeArrowScopenewUniqueSupplycloneLocalNamenewName newNameAt newSysName newSysLocalIdnewSysLocalIdsnewTcRef readTcRef writeTcRefupdTcReftraceTctraceRn traceOptTcRn dumpOptTcRndumpTcRngetPrintUnqualifiedprintForUserTcRntraceIf traceHiDiffs traceOptIf getIsGHCi getGHCiMonadgetInteractivePrintNametcIsHsBootOrSigtcIsHsigtcSelfBootInfogetGlobalRdrEnv getRdrEnvs getImports getFixityEnvextendFixityEnvgetRecFieldEnvgetDeclaredDefaultTysaddDependentFiles getSrcSpanMinGeneratedCode setSrcSpanaddLocMwrapLocM wrapLocFstM wrapLocSndM wrapLocM_ getErrsVar setErrsVaraddErrfailWithfailAtaddErrAtaddErrscheckErr addMessagesdiscardWarnings mkLongErrAt mkErrDocAt addLongErrAt reportErrors reportError reportWarning checkNoErrs whenNoErrsifErrsM failIfErrsM getErrCtxt setErrCtxt addErrCtxt addErrCtxtMaddLandmarkErrCtxtaddLandmarkErrCtxtM popErrCtxt getCtLocM setCtLocM askNoErrstryCaptureConstraintscaptureConstraintstcCollectingUsagetcScalingUsagetcEmitBindingUsageattemptMrecoverMmapAndRecoverM mapAndReportMfoldAndRecoverMtryTc discardErrstryTcDiscardingErrsaddErrTc addErrTcM failWithTc failWithTcMcheckTccheckTcMfailIfTc failIfTcM warnIfFlagwarnIfwarnTcwarnTcM addWarnTc addWarnTcMaddWarn addWarnAtadd_warn 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 getCCIndexTcMtargetAllowObjCodetargetContentstargetIdTargetId TargetFile TargetModuleGHC.Driver.PhasesPhaseemptyMGmapMGmgLookupModulemgModSummaries mkModuleGraphneedsTemplateHaskellOrQQGHC.Types.Name.CacheextendNameCachelookupOrigNameCache FindResultFound FoundMultiple NoPackageNotFoundfr_mods_hiddenfr_pathsfr_pkgfr_pkgs_hiddenfr_suggestions fr_unusablesInstalledFindResultInstalledFoundInstalledNoPackageInstalledNotFounduninitializedLoader loader_state LoaderState bcos_loaded closure_envitbl_env objs_loaded pkgs_loadedtemp_sosGHC.Driver.MonadGhc$fMonadUniqueIOEnvtcPatSynBuilderBind tcPatSynDecl tcAnnotationsannCtxt WhereLookingWL_Any WL_Global WL_LocalTop WL_LocalOnlymkUnboundNameRdrreportUnboundName unboundName unboundNameX notInScopeErrunknownNameSuggestions exactNameErrrnTopSpliceDecls rnSpliceDecl rnSplicePat rnSpliceTypeloadSysInterfaceNameCacheUpdaterNCUupdateNameCachenewGlobalBindernewInteractiveBinderallocateGlobalBinderifaceExportNamesmkNameCacheUpdaterupdNameCacheTc lookupOrig lookupOrigIOexternaliseName setNameModule tcIfaceLclIdextendIfaceIdEnv tcIfaceTyVarlookupIfaceTyVarlookupIfaceVarextendIfaceTyVarEnvextendIfaceEnvslookupIfaceTop newIfaceName newIfaceNames updNameCacheMethInfo TcMethInfo mkNewTyConRhs buildDataCon buildPatSyn buildClassnewImplicitBindernewTyConRepName BinDictionary bin_dict_next bin_dict_mapBinSymbolTablebin_symtab_nextbin_symtab_map TraceBinIFace QuietBinIFace CheckHiWay IgnoreHiWay readBinIface readBinIface_getWithUserData 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 newTyVarTyVarcloneTyVarTyVarnewPatSigTyVar newFskTyVar newFmvTyVarnewMetaDetailsnewTauTvDetailsAtLevelcloneMetaTyVar readMetaTyVarisFilledMetaTyVar_maybeisFilledMetaTyVarisUnfilledMetaTyVarwriteMetaTyVarwriteMetaTyVarRefnewMultiplicityVar newFlexiTyVarnewNamedFlexiTyVarnewFlexiTyVarTynewFlexiTyVarTysnewOpenTypeKindnewOpenFlexiTyVarTynewOpenFlexiTyVar newMetaTyVarsnewMetaTyVarsX newMetaTyVarXnewMetaTyVarTyVarX newWildCardXnewMetaTyVarTyAtLevelcandidateKindVarspartitionCandidatescandidateQTyVarsOfTypecandidateQTyVarsOfTypescandidateQTyVarsOfKindcandidateQTyVarsOfKinds delCandidatesquantifyTyVarsisQuantifiableTvzonkAndSkolemiseskolemiseQuantifiedTyVar defaultTyVarskolemiseUnboundMetaTyVar promoteTyVarpromoteTyVarSetzonkTcTypeAndFVzonkTyCoVarsAndFVzonkDTyCoVarSetAndFVzonkTyCoVarsAndFVList 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$fOutputableUniqSDFMflushFinderCachesfindImportedModulefindPluginModulefindExactModulefindExposedPackageModuleaddHomeModuleToFinder uncacheModulefindHomeModulemkHomeModLocationmkHomeModLocation2mkHiOnlyModLocation mkObjPathmkHiPath mkStubPathsfindObjectLinkableMaybefindObjectLinkablecannotFindModulecannotFindInterfaceGHC.Types.SourceErrorhandleSourceErrortcLookupImported_maybe importDeclcheckWiredInTyConifCheckWiredInThingneedWiredInHomeIfaceloadSrcInterfaceloadSrcInterface_maybeloadModuleInterfaceloadModuleInterfacesloadInterfaceForNameloadInterfaceForNameMaybeloadInterfaceForModuleloadWiredInHomeIfaceloadUserInterfaceloadPluginInterface loadInterfacemoduleFreeHolesPrecisefindAndReadIface writeIface readIfaceinitExternalPackageState ifaceStats showIfacepprModIfaceSimple pprModIface$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 DefaultFlexiSkolemiseFlexiRuntimeUnkFlexiZonkEnv hsLPatType hsPatType hsLitType shortCutLit hsOverLitName emptyZonkEnvmkEmptyZonkEnv initZonkEnv zonkTopBndrs zonkTyBndrs zonkTyBndrsXzonkTyVarBinderszonkTyVarBindersXzonkTyVarBinderX zonkTopExpr zonkTopLExpr zonkTopDecls zonkTcEvBinds zonkEvBinds zonkTyVarOcclookupTyVarOcczonkTcTypeToTypezonkTcTypesToTypeszonkTcTypeToTypeXzonkTcTypesToTypesX zonkCoToCozonkScaledTcTypesToTypesXzonkTcMethInfoToMethInfoX$fOutputableZonkEnvnewMethodFromName topSkolemisetopInstantiateinstantiateSigmainstTyVarsWithinstCallinstCallConstraints instDFunTypeinstStupidThetatcInstInvisibleTyBinderstcInstInvisibleTyBindersNtcInstInvisibleTyBinder tcInstTypetcInstTypeBndrstcSkolDFunTypetcSuperSkolTyVarstcInstSkolTyVarstcInstSkolTyVarsXtcInstSuperSkolTyVarsXtcInstSkolTyVarsAtfreshenTyVarBndrsfreshenCoVarBndrsXnewOverloadedLit mkOverLit tcSyntaxNamegetOverlapFlag tcGetInsts newClsInsttcExtendLocalInstEnvMetaTyVarUpdateResultMTVU_OKMTVU_BadMTVU_HoleBlocker MTVU_OccursmatchActualFunTySigmamatchActualFunTysRhomatchExpectedFunTysmatchExpectedListTymatchExpectedTyConAppmatchExpectedAppTy tcWrapResult tcWrapResultOtcWrapResultMono tcSubTypePat tcSubTypetcSubTypeSigmatcSkolemiseScoped tcSkolemise tcSkolemiseETcheckConstraintscheckTvConstraintsemitResidualTvConstraintbuildTvImplicationbuildImplicationForuTypeswapOverTyVarscanSolveByUnificationmatchExpectedFunKindoccCheckForErrorsmetaTyVarUpdateOK!$fOutputableMetaTyVarUpdateResult$fMonadMetaTyVarUpdateResult"$fApplicativeMetaTyVarUpdateResult$fFunctorMetaTyVarUpdateResultmkTypeableBindstyConIsTypeable$fFunctorKindRepM$fApplicativeKindRepM$fMonadKindRepM HsDocContext TypeSigCtxStandaloneKindSigCtxPatCtxSpecInstSigCtxDefaultDeclCtxForeignDeclCtx DerivDeclCtxRuleCtx TyDataCtxTySynCtx TyFamilyCtx FamPatCtx ConDeclCtx ClassDeclCtxExprWithTySigCtxTypBrCtx HsTypeCtxGHCiCtx SpliceTypeCtxClassInstanceCtx GenericCtxnewLocalBndrRnnewLocalBndrsRnbindLocalNamesbindLocalNamesFVextendTyVarEnvFVRncheckDupRdrNames checkDupNamescheckShadowedRdrNamescheckDupAndShadowedNamescheckInferredVarsnoNestedForallsContextsErraddNoNestedForallsContextsErraddFvRnmapFvRn mapMaybeFvRnwarnUnusedTopBindscheckUnusedRecordWildcardwarnUnusedLocalBindswarnUnusedMatcheswarnUnusedTypePatterns mkFieldEnvaddNameClashErrRnunknownSubordinateErr dupNamesErrbadQualBndrErr typeAppErr checkTupSize checkCTupSizewithHsDocContextinHsDocContextpprHsDocContext 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_impsthNameToGhcName$fMonadThingsCoreMsptCreateStaticBindssptModuleInitCodemkBootModDetailsTc tidyProgram $fMonadDFFV$fApplicativeDFFV $fFunctorDFFV corePrepPgm corePrepExprmkConvertNumLiteral$fOutputableFloatingBind$fOutputableOkToSpec$fOutputableFloatscheckFamInstConsistencytcInstNewTyCon_maybetcLookupDataFamInsttcLookupDataFamInst_maybetcTopNormaliseNewTypeTF_maybetcExtendLocalFamInstEnvreportInjectivityErrors reportConflictingInjectivityErrstcGetFamInstEnvsreportUnsolvedreportAllUnsolvedwarnAllUnsolvedwarnDefaultingsolverDepthErrorTcS$fMonoidReport$fSemigroupReport$fOutputableReport$fOutputableTypeErrorChoice$fOutputableHoleChoice$fOutputableReportErrCtxt MiniFixityEnvaddLocalFixitieslookupFixityRnlookupFixityRn_helplookupTyFixityRnlookupFieldFixityRn HsSigCtxt TopSigCtxt LocalBindCtxt ClsDeclCtxt HsBootCtxt RoleAnnotCtxtChildLookupResult NameNotFoundIncorrectParent FoundNameFoundFLnewTopSrcBinderlookupTopBndrRnlookupLocatedTopBndrRnlookupInstDeclBndrlookupFamInstNamelookupConstructorFieldslookupRecFieldOcclookupSubBndrOcc_helpercombineChildLookupResultlookupLocatedOccRnlookupLocalOccRn_maybelookupLocalOccThLvl_maybe lookupOccRnlookupLocalOccRnlookupTypeOccRnlookupOccRn_maybelookupOccRn_overloadedlookupGlobalOccRn_maybelookupGlobalOccRnlookupInfoOccRnlookupGlobalOccRn_overloadedlookupGreAvailRnaddUsedDataCons addUsedGRE addUsedGREslookupSigOccRnlookupSigCtxtOccRnlookupLocalTcNames dataTcOccslookupIfThenElselookupSyntaxNamelookupSyntaxExpr lookupSyntaxlookupSyntaxNameslookupQualifiedDoExprlookupQualifiedDolookupNameWithQualifierlookupQualifiedDoNamelookupReboundIf$fMonoidDisambigInfo$fSemigroupDisambigInfo$fOutputableDisambigInfo$fOutputableChildLookupResult$fOutputableHsSigCtxt 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_irreds inert_countInertSetIS inert_cans inert_fsksinert_flat_cacheinert_solved_dictsWorkListWLwl_eqs wl_funeqswl_rest wl_implicsappendWorkList workListSizeworkListWantedCountextendWorkListEqextendWorkListFunEqextendWorkListNonEqextendWorkListCtextendWorkListCtsisEmptyWorkList emptyWorkList getWorkListselectNextWorkItem emptyInert isImprovable foldTyEqs findTyEqslookupInertTyVaraddInertForAll addInertCankickOutAfterUnificationaddInertSafehaskinsertSafeOverlapFailureTcSgetSafeOverlapFailures addSolvedDictgetSolvedDictssetSolvedDicts updInertTcS getInertCans setInertCans updInertCans updInertDictsupdInertSafehaskupdInertFunEqsupdInertIrreds getInertEqsgetInertInsolsgetInertGivensgetPendingGivenScsgetUnsolvedInerts isInInertEqs getNoGivenEqsmatchableGivensmightMatchLaterprohibitedSuperClassSolveremoveInertCtslookupFlatCachelookupInertDictlookupSolvedDict foldIrreds emptyDictMapfindDictfindDictsByClassdelDictaddDictaddDictsByClass filterDicts foldDicts findFunEqfindFunEqsByTyCon insertFunEq wrapErrTcS wrapWarnTcSfailTcSwarnTcS addErrTcSpanicTcStraceTcSrunTcPluginTcSgetGlobalRdrEnvTcSbumpStepCountTcS csTraceTcS traceFireTcSrunTcSrunTcSDerivedsrunTcSEqualities runTcSInertsrunTcSWithEvBinds setEvBindsTcS nestImplicTcSnestTcSemitImplicationTcSemitTvImplicationTcS getTcSInerts setTcSInertspushLevelNoWorkListupdWorkListTcS emitWorkNCemitWorkgetTcEvBindsVar unifyTyVarreportUnificationsgetDefaultInfo getInstEnvsgetFamInstEnvscheckWellStagedDFunpprEqnewFlattenSkolemextendFlatCache unflattenFmvdemoteUnfilledFmvdischargeFunEq pprKicked newFlexiTcSTy instFlexi instFlexiXisFresh freshGoals getEvExpr setEvBind setWantedEqsetWantedEvTermsetEvBindIfWanted newGivenEvVarnewBoundEvVarIdnewGivenEvVarsemitNewWantedEq newWantedEqnewWantedEq_SInewWantedEvVarNCnewWantedEvVar newWanted_SI newWantedNCemitNewDerivedsemitNewDerivedEq newDerivedNCcheckReductionDepthmatchFam matchFamTcM$fOutputableWorkList$fOutputableInertCans$fOutputableInertSet$fHasDynFlagsTcS$fMonadThingsTcS$fHasModuleTcS$fMonadUniqueTcS$fMonadFailTcS $fMonadTcS$fApplicativeTcS $fFunctorTcS FlattenMode FM_FlattenAll FM_SubstOnlyflatten rewriteTyVar flattenKindflattenArgsNom flattenTypeunflattenWanteds$fOutputableFlattenMode$fApplicativeFlatM $fMonadFlatM$fFunctorFlatMStopOrContinue ContinueWith canonicalizesolveCallStackmakeSuperClasses continueWithstopWith unifyDerivedmaybeSym$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_env ds_unqualds_msgs ds_if_envds_complete_matchesds_cc_st$fContainsModuleDsGblEnvsolveSimpleGivenssolveSimpleWanteds$fOutputableInteractResult InferModeApplyMREagerDefaultingNoRestrictionscaptureTopConstraintssimplifyTopImplic simplifyToppushLevelAndSolveEqualitiespushLevelAndSolveEqualitiesXsolveEqualitiessimplifyAndEmitFlatConstraintsreportUnsolvedEqualitiessimplifyTopWantedssimplifyAmbiguityChecksimplifyInteractivesimplifyDefaulttcCheckSatisfiability tcNormalise simplifyInfergrowThetaTyVarssimplifyWantedsTcMsolveWantedsAndDrop 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 tcRnExportsexports_from_avail FreeKiTyVarsWarnUnusedForallsNoWarnUnusedForallsHsPatSigTypeScoping AlwaysBind NeverBind rnHsSigWcTypernHsPatSigType rnHsWcType rnHsSigTypernImplicitBndrs rnLHsType rnLHsTypesrnScaledLHsTypernHsType rnLHsKindrnHsKind rnLHsTypeArgs rnContextrnLTyVarbindSigTyVarsFV bindHsQTyVarsbindHsOuterTyVarBndrsbindHsForAllTelescopebindLHsTyVarBndrsbindLHsTyVarBndrnewTyVarNameRnrnConDeclFields mkOpAppRn mkNegAppRn mkOpFormRn mkConOpPatRncheckPrecMatchcheckSectionPrecextractHsTyArgRdrKiTyVarsextractHsTyRdrTyVarsextractHsTyRdrTyVarsKindVarsextractHsTysRdrTyVarsextractRdrKindSigVarsextractConDeclGADTDetailsTyVarsextractDataDefnKindVarsextractHsOuterTvBndrsnubL$fOutputableRnTyKiWhat$fOutputableRnTyKiEnv$fOutputableWarnUnusedForalls$fOutputableOpNameHsRecFieldContext HsRecFieldCon HsRecFieldPat HsRecFieldUpd NameMakerCpsRnliftCpstopRecNameMakerisTopRecNameMakerlocalRecNameMakerrnPatsrnPatapplyNameMaker rnBindPat rnPatAndThen rnHsRecFieldsrnHsRecUpdFieldsrnLit rnOverLit patSigErr $fMonadCpsRn$fApplicativeCpsRn$fFunctorCpsRn rnTopBindsLHSrnTopBindsBootrnLocalBindsAndThenrnLocalValBindsLHS rnValBindsRHSrnLocalValBindsRHSmakeMiniFixityEnv rnMethodBinds renameSigs rnMatchGrouprnGRHSsrnGRHSrnSrcFixityDecl rnSrcDecls addTcgDUs findSplice SpliceInfospliceDescription spliceSource spliceIsDeclspliceGenerated rnBracket rnSpliceExpr traceSplicecheckThLocalNamernExpr$fOutputableMonadNames$fOutputableStmtTreetypecheckIfacetypecheckIfacesForMergingtypecheckIfaceForInstantiate tcHiBootIface tcIfaceExprtcIfaceOneShot tcIfaceGlobalDataSort DataDeclSortDataInstanceSortDataFamilySort ContextKindTheKindAnyKindOpenKind SAKS_or_CUSKSAKSCUSKInitialKindStrategyInitialKindCheckInitialKindInfer funsSigCtxt addSigCtxt pprSigCtxt tcHsSigWcTypekcClassSigTypetcClassSigType tcHsSigTypetcStandaloneKindSig tcHsDerivtcDerivStrategytcHsClsInstType tcHsTypeApp tcFamTyPats tcHsOpenTypetcHsLiftedTypetcHsOpenTypeNCtcHsLiftedTypeNCtcCheckLHsTypetcInferLHsTypetcInferLHsTypeKindtcInferLHsTypeUnsaturatedtcMult tcHsMbContext 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 tcImpPrags 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' checkUnit tcRnCheckUnittcRnMergeSignaturesmergeSignaturestcRnInstantiateSignatureinstantiateSignaturepatSynBuilderOccHsSigFun tcClassSigs tcClassDecl2tcClassMinimalDefinstantiateMethod mkHsSigFunfindMethodBind badMethodErr instDeclCtxt1 instDeclCtxt2 instDeclCtxt3 tcATDefault RebuilderEValArgValArgQLva_exprva_funva_argsva_ty va_rebuild HsExprArgETypeArgEPragEParEWrapeva_loceva_arg eva_arg_ty eva_hs_tyeva_tyTcPassTcpRnTcpInstTcpTc eValArgExpr addArgWrap splitHsAppsrebuildPrefixApps isHsValArgcountLeadingValArgs isVisibleArgsetSrcSpanFromArgspprHsExprArgTctcInferAppHeadtcInferAppHead_maybeaddAmbiguousNameErr obviousSigtyConOf tyConOfET lookupParentsfieldNotInType notSelector tcCheckId tcInferIdnonBidirectionalErr addFunResCtxt addLExprCtxt addExprCtxt$fOutputableEValArg$fOutputableHsExprArg TcStmtCheckerTcCmdStmtCheckerTcExprStmtChecker TcMatchCtxtMCmc_whatmc_body tcMatchesCase tcMatchLambdatcGRHS tcDoStmtstcBodytcStmtstcStmtsAndThen tcGuardStmttcDoStmttcProc tcInferSigmatcApptcValArg 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 putSrcSpanDswarnDs 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 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 dsEvBinds 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 llvmPtrBitsparseLlvmVersionsupportedLlvmVersionllvmVersionSupportedllvmVersionStrllvmVersionList getLlvmOptsrunLlvm liftStream withClearVars varInsert funInsert varLookup funLookup markStackReg checkStackReggetMetaUniqueId getLlvmVer dumpIfSetLlvm renderLlvm markUsedVar getUsedVars setUniqMeta getUniqMetaghcInternalFunctionsstrCLabel_llvm getGlobalPtr llvmDefLabelgenerateExternDeclsaliasify$fMonadUniqueLlvmM$fHasDynFlagsLlvmM $fMonadLlvmM$fApplicativeLlvmM$fFunctorLlvmMrunUnlitrunCpprunPprunCc isContainedInaskLdrunAs runLlvmOpt runLlvmLlcrunClangfigureLlvmVersionrunLinkrunMergeObjects runLibtoolrunAraskOtoolrunInstallNameTool runRanlib runWindrestouchtraceToolCommand genLlvmDatagenData pprLlvmDatapprLlvmCmmDecl infoSection genLlvmProc$fMonoidLlvmAccum$fSemigroupLlvmAccum $fEqSignage $fShowSignagepprData 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 tcInstDecls1tcTyAndClassDecls 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$fFunctorCmmOptMSRTMap ModuleSRTInfo thisModule dedupSRTsflatSRTs moduleSRTMapCAFEnvCAFSet cafAnalDatacafAnalemptySRT srtMapNonCAFsdoSRTs$fOutputablePenvSomeLabel$fOutputablePenvModuleSRTInfo $fEqSomeLabel$fOrdSomeLabel $fEqSRTEntry $fOrdSRTEntry $fEqCAFLabel $fOrdCAFLabel$fOutputablePenvSRTEntry$fOutputablePenvCAFLabel cmmPipelineputArraygetArraymkConInfoTable $fShowArchShouldRetainCAFs 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 SingleStepRunAndLogStepsRunToCompletioniservCmd withInterp hscInterp withIServ withIServ_evalStmt abandonStmtevalIO evalStringevalStringToIOString mallocData mkCostCentres addSptEntrycostCentreStackInfo newBreakArrayenableBreakpointbreakpointStatusgetBreakpointVar getClosure seqHValuepurgeLookupSymbolCache iservCall readIServ writeIServ stopInterpmkFinalizedHValuefreeHValueRefswormhole wormholeRef mkEvalOptsfromEvalResult getModBreaksinterpreterProfiledinterpreterDynamicTermFoldfTermfPrim fSuspension fNewtypeWrapfRefWrapTermPrim Suspension NewtypeWrapRefWraptydcvalsubTermsvalRawctypebound_to wrapped_termtermTypeisFullyEvaluatedTermconstrClosToNamefoldTerm mapTermType termTyCoVarscPprTerm cPprTermBase cvObtainTermcvReconstructTypeimproveRTTIType$fOutputableTermrunInjectRPathsgetUnitFrameworkOptsgetFrameworkOptsgetUnitFrameworkPathgetUnitFrameworks loadFramework mkExtraObjmkExtraObjToLinkIntoBinarymkNoteObjsToLinkIntoBinary getLinkInfoplatformSupportsSavingLinkOptsghcLinkInfoSectionNameghcLinkInfoNoteName checkLinkInfohaveRtsOptsFlagslazyInitLlvmConfig initSysToolscopycopyWithHeadermaybeCreateManifest llvmCodeGen codeOutputoutputForeignStubsprofilingInitCode linkDynLib libmLinkOpts linkBinary linkBinary' linkStaticLib exeFileNameaddTicksToBinds hpcInitCode$fHasDynFlagsTM $fMonadTM$fApplicativeTM $fFunctorTM$fEqTickishType$fEqTickDensitydeSugar deSugarExpr mkHieFilemkHieFileWithSourcegetCompressedAsts enrichHie$fModifyStateVar$fModifyStateName$fHasLocHsDataDefn $fHasLocHsArg$fHasLocFamEqn $fHasLoc[]$fHasLocGenLocated$fHasLocPScoped$fHasRealDataConNameGhcPass$fHasRealDataConNameGhcPass0$fToHieIEContext$fToHieIEContext0$fToHieIEContext1$fToHieGenLocated$fToHieRScoped$fToHieGenLocated0$fToHieGenLocated1$fToHieAnnProvenance$fToHieGenLocated2$fToHieGenLocated3$fToHieGenLocated4$fToHieForeignExport$fToHieForeignImport$fToHieGenLocated5$fToHieGenLocated6$fToHieGenLocated7$fToHieGenLocated8$fToHiePatSynFieldContext$fToHieGenLocated9$fToHieGenLocated10$fToHieGenLocated11$fToHieGenLocated12$fToHieGenLocated13$fToHieGenLocated14$fToHieGenLocated15$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$fToHieGenLocated29$fToHieRScoped0$fToHieFamilyInfo$fToHieGenLocated30$fToHieGenLocated31$fToHieTyClGroup$fToHieHsConDeclGADTDetails$fToHieHsConDetails$fToHieRFContext$fToHieRFContext0$fToHieRFContext1$fToHieRFContext2$fToHieRContext$fToHieTScoped4$fToHieContext$fToHieGenLocated32$fToHieEvBindContext$fToHieContext0$fToHieContext1$fToHieIEContext2 $fToHieMaybe $fToHieBag $fToHie[]$fToHieGenLocated33$fToHieSigContext$fToHieGenLocated34$fToHieGenLocated35$fToHieRScoped1$fToHieRContext0$fToHieRScoped2$fToHieRScoped3$fToHieRScoped4$fToHieRScoped5$fToHieRScoped6$fToHieGenLocated36$fToHieGenLocated37$fToHieGenLocated38 $fToHieGRHSs$fToHiePScoped$fToHieHsStmtContext$fToHieHsMatchContext$fToHieGenLocated39$fToHieHsPatSynDir$fToHieGenLocated40$fToHieMatchGroup$fToHieBindContext$fHiePassTypechecked$fHiePassRenamed$fHasTypeGenLocated$fHasTypeGenLocated0$fHasTypeGenLocated1 $fDataPScopedmkITbls bcoFreeNames assembleBCOsassembleOneBCOiNTERP_STACK_CHECK_THRESH$fMonadAssembler$fApplicativeAssembler$fFunctorAssembler byteCodeGencoreExprToBCOs$fOutputableDiscr$fHasDynFlagsBcM $fMonadBcM$fApplicativeBcM $fFunctorBcM $fEqDiscr $fOrdDiscr $fEnumWordOff $fEqWordOff$fIntegralWordOff $fNumWordOff $fOrdWordOff $fRealWordOff $fEnumByteOff $fEqByteOff$fIntegralByteOff $fNumByteOff $fOrdByteOff $fRealByteOff ClosureEnvemptyClosureEnvextendClosureEnvlinkBCOlookupStaticPtrlookupIElinkFail nameToCLabelextendLoadedPkgsextendLoadedEnvdeleteFromLoadedEnvloadNamewithExtendedLoadedEnvshowLoaderStateinitLoaderStateloadCmdLineLibsloadExpr loadDecls loadModuleunload loadPackages$fOutputableLibrarySpecinitializePluginsloadFrontendPluginforceLoadModuleInterfacesforceLoadNameModuleInterfaceforceLoadTyCongetValueSafelygetHValueSafelylessUnsafeCoercelookupRdrNameInModuleForPluginsGHC.Unit.Module.Status HscStatusHscNotGeneratingCode 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()()defaultWarnErrLoggergetSessionDynFlagsprintExceptionGhcMonad getSession setSessionGhcT WarnErrLoggerGetDocsFailureNameHasNoModule NoDocsInIfaceInteractiveNamegetResumeContextgetHistoryModulegetHistorySpan execOptionsexecStmt execStmt'runDeclsrunDeclsWithLocationrunParsedDeclsparseImportDecl resumeExecbackforwardabandon abandonAll setContextavailsToGlobalRdrEnv getContextmoduleIsInterpretedgetInfogetNamesInScopegetRdrNamesInScope parseNameisStmt hasImportisImportisDeclgetDocsexprTypegetInstancesForTypeparseInstanceHead parseExpr compileExprcompileExprRemotecompileParsedExprRemotecompileParsedExprdynCompileExpr showModulemoduleIsBootOrNotObjectLinkableobtainTermFromValobtainTermFromIdreconstructType$fOutputableGetDocsFailure getPipeEnv getPipeState setDynFlagssetModLocationunPHscOut RealPhasePipeEnv output_spec src_basename src_filename src_suffix stop_phase PipeState foreign_oshsc_enviface maybe_loc preprocess compileOne compileOne'link linkingNeededoneShot compileFilephaseOutputFilenamegetOutputFilenamerunPhase getLocationdoCppwriteInterfaceOnlyModehscPostBackendPhase SummaryNode LoadHowMuchLoadAllTargetsLoadUpToLoadDependenciesOfdepanaldepanalEdepanalPartialloadload'hscSourceToIsBoottopSortModuleGraphmoduleGraphNodes downsweepsummariseModule noModErrorcyclicModuleErr 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_filespm_annotations coreModuleTypecheckedMod renamedSourcetypecheckedSource moduleInfo ParsedMod parsedSourcedefaultErrorHandlerdefaultCleanupHandlerrunGhcrunGhcTwithCleanupSession initGhcMonadsetSessionDynFlagssetProgramDynFlags setLogActiongetProgramDynFlagssetInteractiveDynFlagsgetInteractiveDynFlagsparseDynamicFlagsparseTargetFiles 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$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.EnumsuccdeepSplitCprType_maybeGHC.CoreCoreRuleGHC.Runtime.Heap.LayoutStgWord GHC.Hs.DeclsHsGroupghc-prim GHC.TypesTrue Data.DataDataRnEnv2emptyInScopeSettransformers-0.5.6.2Control.Monad.Trans.RWS.StrictRWSTGHC.Data.OrdListOrdListUniqSMStgTopStringLitlocalPrimRep CmmInfoTable GenStgExprinfinityHappyStkTcMDumpFlagPprUserPprDumpIfGTcRnIfGblEnvTcGblEnvControl.Monad.FixMonadFixmfixControl.Monad.IO.ClassMonadIOliftIO 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 writeMutVar IOEnvFailureemptyImportAvailsemptyRoleAnnotEnv getLclEnvLocgetLclEnvTcLevel getRoleAnnotsimpLevel lintGblEnvlookupRoleAnnot mkModDepsmkRoleAnnotEnv modDepsElts outerLevelplusImportAvails pprPECategorypprTcTyThingCategory pushErrCtxtpushErrCtxtSameOriginremoveBindingShadowing runTcPluginM setLclEnvLocsetLclEnvTcLeveltcVisibleOrphanMods topAnnStagetopSpliceStagetopStage ArrowCtxt NoArrowCtxt ClosedTypeIdenv_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 SpliceTypeTypedUntypedTcBinderTcTvBndrTcIdBndrTcIdBndr_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_maintcg_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 TyConRepNameIOUserDataGHC.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.TracetraceGHC.ExtssortWith 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.SetUniqSet availFromGRE bestImportdelLocalRdrEnvList demoteRdrNameelemLocalRdrEnvemptyGlobalRdrEnvemptyLocalRdrEnvextendGlobalRdrEnvextendLocalRdrEnvextendLocalRdrEnvListgetGRE_NameQualifier_maybes getRdrNameglobalRdrEnvEltsgreLabel greOccNamegreParent_maybegreQualModName greRdrNames greSrcSpan gresFromAvailgresToAvailInfo importSpecLocimportSpecModuleinLocalRdrEnvScopeisExact isExact_maybeisExplicitItem isLocalGREisOrig isOrig_maybeisOverloadedRecFldGREisQual isQual_maybe isRdrDataConisRdrTc isRdrTyVar isRecFldGRE isSrcRdrNameisUnquallocalGREsFromAvaillocalRdrEnvEltslookupGRE_FieldLabellookupGRE_NamelookupGRE_Name_OccNamelookupGRE_RdrNamelookupGlobalRdrEnvlookupLocalRdrEnvlookupLocalRdrOccmkGlobalRdrEnvmkOrigmkQual mkRdrQual mkRdrUnqualmkUnqual mkVarUnqual nameRdrNameopIsAtpickGREspickGREsModExpplusGlobalRdrEnvpprGlobalRdrEnvpprNameProvenancepromoteRdrName qualSpecOK rdrNameOcc rdrNameSpace shadowNamesstarInfo transformGREsunQualOK unQualSpecOK GlobalRdrEltGREgre_pargre_lclgre_namegre_imp GlobalRdrEnv ImpDeclSpecis_qualis_modis_asis_dloc ImpItemSpecImpAllImpSome is_explicitis_iloc ImportSpecImpSpecis_declis_item LocalRdrEnvParentParentIs FldParentNoParentpar_ispar_lblGHC.Types.Name.SetNameSetGHC.Types.FieldLabelFieldLabelString FieldLabelArityBoxityUnboxedBoxedappendFSbytesFSconcatFSconsFSfastStringToByteStringfastStringToShortByteStringfastZStringToByteStringfsLitgetFastStringTablegetFastStringZEncCounterhPutFShPutFZSheadFSisUnderscoreFSlengthFS lengthFZSlengthPSlexicalCompareFS mkFastString mkFastString#mkFastStringByteListmkFastStringByteStringmkFastStringBytesmkFastStringShortByteString mkPtrString mkPtrString#nilFSnullFSsLit 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 VanillaDMEPfromEPtoEPFunctionOrDataIsData 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 tyConResKind tyConBinders tyConUnique tyConName TyConBinderGHC.Types.Var.Set TyCoVarSet InvisTVBinder ReqTVBinderconstraintKind GHC.Core.FVs orphNamesOfCoorphNamesOfCoConorphNamesOfTypeorphNamesOfTypes isTauTyCon DTyCoVarSet DTyVarSetTyVarSetEvVar algTyConRhsexpandSynTyCon_maybefamTyConFlav_maybeisAbstractTyCon isAlgTyConisBoxedTupleTyConisBuiltInSynFamTyCon_maybe%isClosedSynFamilyTyConWithAxiom_maybeisDataFamilyTyConisDataProductTyCon_maybeisDataSumTyCon_maybe isDataTyConisEnumerationTyConisFamFreeTyConisFamInstTyConisGadtSyntaxTyConisGenInjAlgRhsisGenerativeTyConisImplicitTyConisInjectiveTyConisInvisibleTyConBinder isKindTyConisLiftedTypeKindTyConNameisNamedTyConBinder isNoParentisProductTyConisPromotedDataConisPromotedDataCon_maybeisPromotedTupleTyCon isTcLevPoly isTcTyCon isTupleTyCon isTyConAssocisTyConWithSrcDataConsisUnboxedSumTyConisUnboxedTupleTyConisUnliftedTyConisVanillaAlgTyConisVisibleTyConBinderlookupTyConFieldLabel mkAlgTyConmkAnonTyConBindermkAnonTyConBinders mkClassTyConmkDataTyConRhs mkFamilyTyCon mkFunTyCon mkKindTyConmkLiftedPrimTyConmkNamedTyConBindermkNamedTyConBindersmkPrelTyConRepName mkPrimTyConmkPromotedDataConmkRequiredTyConBinder mkSumTyConmkSynonymTyCon mkTcTyCon mkTupleTyCon mkTyConKind mkTyConTagMapmustBeSaturated newTyConConewTyConCo_maybenewTyConDataCon_maybenewTyConEtadAritynewTyConEtadRhs newTyConRhsnoTcTyConScopedTyVarspprPromotionQuoteprimElemRepSizeBprimRepCompatibleprimRepIsFloat primRepSizeBprimRepsCompatiblesetTcTyConKindtcFlavourIsOpentyConATstyConAssoc_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 LiftedRepRuntimeRepInfoNoRRIVecElem RuntimeRepVecCount TyConBndrVisAnonTCBNamedTCB TyConFlavourTypeSynonymFlavour TupleFlavour SumFlavourPromotedDataConFlavourOpenTypeFamilyFlavourNewtypeFlavourDataTypeFlavourDataFamilyFlavourClosedTypeFamilyFlavour ClassFlavourAbstractTypeFlavourBuiltInTypeFlavourTyConTyCoBinderVarBndrBndrGHC.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_RDRboxingDataCon_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_maybeisCTupleTyConName justDataConjustDataConNameliftedRepDataConliftedRepDataConTyliftedRepDataConTyCon liftedRepTyliftedTypeKindTyConliftedTypeKindTyConName listTyCon listTyConName listTyCon_RDRmakeRecoveryTyCon manyDataConmanyDataConName manyDataConTymanyDataConTyCon maybeTyConmaybeTyConNamemkBoxedTupleTymkListTymkPromotedListTymkSumTy 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 unitTyConKeyunliftedRepDataConTyunrestrictedFunTyConNamevec16DataConTy vec2DataConTyvec32DataConTy vec4DataConTyvec64DataConTy vec8DataConTy vecCountTyCon vecElemTyConvecRepDataConTyCon wiredInTyConsword16ElemRepDataConTyword16RepDataConTyword32ElemRepDataConTyword32RepDataConTyword64ElemRepDataConTyword64RepDataConTy word8DataConword8ElemRepDataConTyword8RepDataConTyword8Ty word8TyCon wordDataConwordRepDataConTywordTy wordTyCon wordTyConNameTickishProfNoteHpcTick SourceNote Breakpoint tickModuletickId sourceSpan breakpointId breakpointFVs profNoteScope profNoteCount sourceName profNoteCC SrcStrictnessSrcLazy NoSrcStrict SrcStrict LayoutInfo VirtualBracesExplicitBraces NoLayoutInfo HsImplBangHsUnpackHsLazyHsStrict HsSrcBangSrcUnpackedness SrcUnpack NoSrcUnpack SrcNoUnpackBindNonRecRec TaggedBndrTBRule BuiltinRuleru_rough ru_orphan ru_originru_localru_autoru_tryru_nargsru_rhsru_nameru_fnru_bndrsru_actru_argsLetLamCaseTickLitAppGHC.Types.Id.InfoIdInfolfInfo unfoldingInfostrictnessInforuleInfooccInfoinlinePragInfocprInfo 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 InlineRhsAltConLitAltDataAltDEFAULTCoreBindFieldLblflLabel flSelectorflIsOverloaded<&&><||>abstractDataTypeall2 applyWhenatLength capitalise changeLastcharToC chkAppend chunkListcmpList compareLengthcount countWhile debugIsOndoesDirNameExistdropListdropTaildropWhileEndLEeqListBy eqMaybeBy equalLength escapeSpaces exactLog2 filterByList filterByLists filterOutfirst3MfirstMfoldl2fst3fstOf3 fuzzyLookup fuzzyMatchgetCmdgetModificationUTCTime ghciSupported hashString isDarwinHostisEqualisIn isSingleton isSortedBy isWindowsHostisn'tInlast2 lastMaybeleLength lengthAtLeast lengthAtMost lengthExceedslengthIs lengthIsNotlengthLessThanliftFstliftSnd listLengthCmplooksLikeModuleNamelooksLikePackageNameltLengthmakeRelativeTo mapAndUnzip mapAndUnzip3mapFstmapLastMmapSnd mergeListsByminWithmodificationTimeIfExistsnTimesnotNullnubSortonlyordNub overrideWithpartitionByList partitionWithreadHexRational readRational removeSpacesreslashsecondMseqList singletonsnd3sndOf3snocViewspanEndsplit splitAtListsplitLongestPrefixstretchZipWith strictMaptakeListthdOf3thenCmpthird3toArgs toCmdArgstransitiveClosureuncurry3 unzipWith whenNonEmptywithAtomicRename zipAndUnzipzipEqualzipLazy zipWith3Equal zipWith3Lazy zipWith4EqualzipWithAndUnzip zipWithEqual zipWithLazy Direction BackwardsForwardsOverridingBoolNeverAlwaysAutoSuffix 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_tyconEqSpecArgCoreBndrCoreExprGHC.Types.Literal LitNumType LitNumWord8 LitNumWord64 LitNumWord32 LitNumWord16 LitNumWord LitNumNatural LitNumInteger LitNumInt8 LitNumInt64 LitNumInt32 LitNumInt LitNumInt16RuleOpts roPlatformroExcessRationalPrecisionroNumConstantFolding InScopeEnv 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 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 pprWithCommasprimCharSuffixprimDoubleSuffixprimFloatSuffixprimInt64Suffix primIntSuffixprimWord64SuffixprimWordSuffix 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 sdocColSchemesdocCanUseUnicodesdocSuppressVarKindssdocSuppressUnfoldingssdocSuppressTypeSignaturessdocSuppressTypeApplicationssdocSuppressTickssdocSuppressIdInfosdocSuppressCoercionssdocPrintCaseAsLetsdocPrintTypecheckerElaborationsdocPrintExplicitCoercionssdocSuppressUniquessdocUnitIdForUsersdocSuppressModulePrefixesGHC.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 mkNoCount mkNoScope mkOtherCon mkRuleEnv mkStringLitmkTyAppsmkTyArgmkTyBind mkVarAppsmkWord64LitWord64 mkWord8Lit mkWordLit mkWordLitWrap needSaturatedneverUnfoldGuidance noUnfolding notOrphan otherCons rhssOfAlts rhssOfBindruleActivation ruleArity ruleIdName ruleModuleruleName setRuleIdName stripNArgstickishCanSplittickishContains tickishCountstickishFloatable tickishIsCode tickishPlace tickishScopedtickishScopesLike unSaturatedOkunfoldingTemplate valArgCount valBndrCount varToCoreExprvarsToCoreExprsAltAnnAltAnnBind AnnNonRecAnnExprAnnExpr'AnnVarAnnTickAnnLit AnnCoercionAnnCastAnnAppCoreAltCoreArg CoreProgramIdUnfoldingFunInAltInArgInBindInBndr InCoercionInExprInKindInTypeIsOrphan NotOrphan MOutCoercionOutAltOutArgOutBindOutBndr OutCoercionOutExprOutKindOutTypeRuleBaseRuleEnvre_basere_visible_orphsRuleFun TaggedAlt TaggedArg TaggedBind TaggedExprTickishPlacement PlaceRuntimePlaceCostCentre PlaceNonLamTickishScoping SoftScopeCostCentreScopeLiteral LitRubbish LitNullAddrLitLabel LitString LitNumberLitFloatLitChar LitDoubleGHC.Unit.Module.Env ModuleSetinitUniqSupplyinitUsinitUs_listSplitUniqSupplymkSplitUniqSupplysplitUniqSupplytakeUniqFromSupplyuniqFromSupplyuniqsFromSupplyGHC.Driver.PprpprDebugAndThen pprSTracepprTrace pprTraceDebugpprTraceException pprTraceIt pprTraceMpprTraceWithFlags printForC printForUsershowPpr showPprUnsafeshowSDoc showSDocDebug showSDocDumpshowSDocForUser warnPprTrace 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 setCprInfo setDemandInfosetInlinePragInfo setLFInfosetLevityInfoWithTypesetNeverLevPoly setOccInfosetOneShotInfo setRuleInfosetRuleInfoHeadsetStrictnessInfosetUnfoldingInfo unknownArity vanillaIdInfozapCallArityInfo zapDemandInfozapFragileInfo zapLamInfozapTailCallInfo zapUnfoldingzapUsageEnvInfo zapUsageInfozapUsedOnceInfo ArityInfoInlinePragInfo LevityInfo TickBoxId TickBoxOpTickBoxDVarSet NonCaffySetoptimisationFlagsaddGlobalIncludeaddPluginModuleNameaddQuoteIncludeallNonDeprecatedFlags compilerInfodefaultDynFlagsdefaultFatalMessagerdefaultFlushErrdefaultFlushOutdefaultLogActiondefaultLogActionHPrintDocdefaultLogActionHPutStrDoc defaultWaysdoptdopt_set dopt_unsetdynFlagDependenciesdynamicOutputFiledynamicTooStateemptyFilesToCleanextraGccViaCFlagsfFlags fLangFlagsflagsAll flagsDynamicflagsForCompletion flagsPackageflattenIncludesgetOpts getVerbFlags ghcUsagePath ghciUsagePathglasgowExtsFlagsglobalPackageDatabasePathgopt_set gopt_unsethasNoDebugOutputhasNoOptCoercionhasNoStateHack hasPprDebughiSuf impliedGFlagsimpliedOffGFlags impliedXFlagsinitDefaultSDocContext initDynFlagsinitSDocContext isAvx2EnabledisAvx512cdEnabledisAvx512erEnabledisAvx512fEnabledisAvx512pfEnabled isAvxEnabled isBmi2Enabled isBmiEnabledisNoLink isOneShot isSse2EnabledisSse4_2Enabled isSseEnabledlang_setlanguageExtensions mainModIsmakeDynFlagsConsistentmkHomeUnitFromFlags 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 programNameprojectVersion putLogMsgsafeDirectImpsReqsafeHaskellModeEnabled safeHaskellOnsafeImplicitImpsReq safeImportsOn safeInferOnsafeLanguageOnsccProfilingEnabled setDynamicNowsetDynamicTooFailedsetFlagsFromEnvFilesetGeneralFlag' setTmpDir setUnitIdsetUnsafeGlobalDynFlagssettingssupportedLanguagesAndExtensions targetProfiletmpDirtopDirturnOffturnOnunSetGeneralFlag' unsafeFlagsunsafeFlagsForInfer updOptLevelversionedAppDirversionedFilePath wWarningFlags warningGroupswarningHierarchieswayswopt wopt_fatalwopt_setwopt_set_fatal wopt_unsetwopt_unset_fatal wordAlignmentxFlagsxoptxopt_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_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 Haskell2010 Haskell98 WarnReasonReasonNoReason ErrReason 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_WarnMissingImportListOpt_WarnMissingHomeModulesOpt_WarnMissingFields!Opt_WarnMissingExportedSignaturesOpt_WarnMissingExportList!Opt_WarnMissingDerivingStrategiesOpt_WarnMissedSpecsOpt_WarnMissedExtraSharedLibOpt_WarnInvalidHaddockOpt_WarnInlineRuleShadowingOpt_WarnInferredSafeImportsOpt_WarnIncompleteUniPatterns Opt_WarnIncompletePatternsRecUpdOpt_WarnIncompletePatternsOpt_WarnInaccessibleCodeOpt_WarnImplicitPreludeOpt_WarnImplicitKindVarsOpt_WarnIdentitiesOpt_WarnHiShadowsOpt_WarnEmptyEnumerationsOpt_WarnDuplicateExportsOpt_WarnDuplicateConstraintsOpt_WarnDodgyImportsOpt_WarnDodgyForeignImportsOpt_WarnDodgyExportsOpt_WarnDerivingTypeableOpt_WarnDerivingDefaultsOpt_WarnDeprecatedFlagsOpt_WarnDeferredTypeErrors#Opt_WarnDeferredOutOfScopeVariables Opt_WarnCompatUnqualifiedImportsOpt_WarnCPPUndefOpt_WarnAutoOrphansOpt_WarnAllMissedSpecs)Opt_WarnAlternativeLayoutRuleTransitional CompilerInfo UnknownCCGCCClang AppleClang AppleClang51ContainsDynFlagsextractDynFlags DynLibLoader DeployableSystemDependentDynamicTooStateDT_OK DT_FailedDT_DontDT_Dyn FatalMessager FilesToCleanftcCurrentModule ftcGhcSessionFlagSpec flagSpecNameflagSpecGhcModeflagSpecAction flagSpecFlagFlushErrFlushOut HasDynFlagsIgnorePackageFlag IgnorePackage IncludeSpecsincludePathsGlobalincludePathsQuote LinkerInfo UnknownLD SolarisLDLlvmLLDGnuLDGnuGoldAixLDDarwinLD LlvmConfig llvmPasses llvmTargets LlvmTarget lDataLayout lAttributeslCPU LogAction 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 sFileSettingssGhcNameVersionGHC.Unit.State UnitDatabaseunitDatabasePathunitDatabaseUnits UnitStatewireMap unwireMap unitInfoMaprequirementContext preloadUnitspreloadClosurepluginModuleNameProvidersMappackageNameMapmoduleNameProvidersMapallowVirtualUnits explicitUnits ModuleEnv advanceBufPos advancePsLoc advanceSrcLoc cmpBufSpancombineSrcSpans containsSpangeneratedSrcLocgeneratedSrcSpan getBufPos getBufSpaninteractiveSrcLocinteractiveSrcSpanisGeneratedSrcSpan isOneLineSpanisRealSubspanOfleftmostColumnliftL lookupSrcLoc lookupSrcSpanmapLocmkGeneralSrcLocmkGeneralSrcSpanmkPsSpan mkRealSrcLoc mkRealSrcSpan mkSrcSpanPspprUnhelpfulSpanReasonpprUserRealSpan psSpanEnd psSpanStartrealSrcLocSpanrealSrcSpanEndrealSrcSpanStart sortLocatedsortRealLocatedsrcSpanFileName_maybesrcSpanFirstCharacterunhelpfulSpanFSwiredInSrcSpanBufPosbufPosBufSpan 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_maybeContainsModule extractModule HasModule getModuleDModuleNameEnvInstalledModuleEnv ModuleNameEnvaddListToUniqSetaddOneToUniqSetdelListFromUniqSetdelListFromUniqSet_DirectlydelOneFromUniqSetdelOneFromUniqSet_DirectlydisjointUniqSetselemUniqSet_DirectlyelementOfUniqSet emptyUniqSet filterUniqSetfilterUniqSet_Directly getUniqSetintersectUniqSetsisEmptyUniqSet lookupUniqSetlookupUniqSet_Directly mapUniqSet minusUniqSet mkUniqSetnonDetEltsUniqSetnonDetKeysUniqSetnonDetStrictFoldUniqSetpartitionUniqSet pprUniqSetrestrictUniqSetToUFM sizeUniqSetunionManyUniqSets unionUniqSets uniqSetAll uniqSetAnyuniqSetMinusUDFMuniqSetMinusUFM unitUniqSetunsafeUFMToUniqSetIdEnvaddRnInScopeSet 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 DTyVarEnvDVarEnv TyCoVarEnvTyVarEnvGHC.Core.Utils addDefaultaltsAreExhaustiveapplyTypeToArgs bindNonRec cheapEqExpr cheapEqExpr'collectMakeStaticArgscombineIdenticalAlts coreAltType coreAltsTypedataConRepFSInstPatdataConRepInstPat 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 CheapAppFun bindFreeVarsbndrRuleAndUnfoldingVarsDSet dIdFreeVars exprFreeIdsexprFreeIdsDSetexprFreeIdsList exprFreeVarsexprFreeVarsDSetexprFreeVarsListexprSomeFreeVarsexprSomeFreeVarsListexpr_fvs exprsFreeIdsexprsFreeIdsDSetexprsFreeIdsList exprsFreeVarsexprsFreeVarsListexprsOrphNamesexprsSomeFreeVarsexprsSomeFreeVarsListfreeVars freeVarsBind freeVarsOf freeVarsOfAnnidFVs idFreeVars idRuleRhsVars idRuleVarsidUnfoldingVars mkRuleInfoorphNamesOfAxiomorphNamesOfFamInst ruleFreeVarsruleLhsFreeIdsruleLhsFreeIdsListruleRhsFreeIdsruleRhsFreeVars rulesFreeVarsrulesFreeVarsDSetstableUnfoldingVarsvarTypeTyCoFVsvarTypeTyCoVarsCoreAltWithFVsCoreBindWithFVsCoreExprWithFVsCoreExprWithFVs'FVAnn GHC.Utils.FVInterestingVarFunIdSetDIdSetabsentLiteralOf charToIntLitdoubleToFloatLitdoubleToIntLit extendIntLit extendWordLitfloatToDoubleLit floatToIntLit inCharRangeint16Litint32Litint8Lit intToCharLitintToDoubleLit intToFloatLit intToWordLit isZeroLit litFitsInChar litIsDupable litIsLifted litIsTriviallitNumCheckRangelitNumIsSignedlitValue literalType mapLitValue mkLitChar mkLitDouble mkLitFloatmkLitInt mkLitInt16mkLitInt16Wrap mkLitInt32mkLitInt32Wrap mkLitInt64mkLitInt64Wrap mkLitInt8 mkLitInt8WrapmkLitIntUnchecked mkLitIntWrap mkLitIntWrapC mkLitInteger mkLitNatural mkLitNumbermkLitNumberWrap mkLitString mkLitWord mkLitWord16mkLitWord16Wrap mkLitWord32mkLitWord32Wrap mkLitWord64mkLitWord64Wrap mkLitWord8mkLitWord8Wrap mkLitWordWrapmkLitWordWrapCnarrow16IntLitnarrow16WordLitnarrow32IntLitnarrow32WordLit narrow8IntLitnarrow8WordLitnarrowInt16LitnarrowInt32Lit narrowInt8LitnarrowWord16LitnarrowWord32LitnarrowWord8Lit nullAddrLit pprLiteral rubbishLit word16Lit word32Litword8Lit wordToIntLit 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 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 getUniqMaskgetVisibleOrphanModshasDetailedCountsliftIOWithCountpprPassDetailsputMsgputMsgSrunCoreMrunMayberunWhen simplCountNwarnMsgCoreMCorePluginPassCoreToDo CoreOccurAnalCoreLiberateCaseCoreDoWorkerWrapperCoreDoStaticArgsCoreDoSpecialisingCoreDoSpecConstrCoreDoSimplifyCoreDoRuleCheckCoreDoPrintCoreCoreDoPluginPass CoreDoPasses CoreDoNothingCoreDoFloatOutwardsCoreDoFloatInwards CoreDoExitify CoreDoDemand CoreDoCprCoreDoCallArityCoreDesugarOpt CoreDesugarCoreCSECoreAddCallerCcsCorePrepCoreTidyFloatOutSwitchesfloatToTopLevelOnlyfloatOutOverSatAppsfloatOutConstantsfloatOutLambdas SimplMode sm_uf_optssm_rules sm_pre_inlinesm_phasesm_names 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_annshsc_type_env_var hsc_targetshsc_static_plugins hsc_plugins hsc_mod_graph hsc_loader hsc_interp hsc_home_unithsc_NChsc_IChsc_HPThsc_FC hsc_dflagshsc_EPSCgGuts 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 hptInstanceshptRuleshptSomeThingsBelowUshscEPSlookupIfaceByModule lookupTypemkInteractiveHscEnvprepareAnnotationsrunHscrunInteractiveHscHscGHC.Driver.Plugins LoadedPluginlpModulelpPlugin StaticPluginspPluginhfIsLclpprHoleFitCand CandPlugin FitPluginHoleFit RawHoleFithfWraphfTypehfRefLvl hfMatcheshfIdhfCandhfDocHoleFitCandidate NameHFCand GreHFCandIdHFCand TypedHoleth_relevant_ctsth_hole th_implicsGHC.Types.MetaMetaHook GHC.Unit.Info mapUnitInfomkUnit mkUnitKeyInfo mkUnitPprInfo pprUnitInfounitPackageIdStringunitPackageNameStringcollectIncludeDirsemptyUnitStategetPreloadUnitsAnd getUnitDbRefsgetUnitExtraCcOptsgetUnitIncludePath improveUnit initUnitsinstModuleToModuleinstUnitToUnit listUnitInfolistVisibleModuleNameslookupModuleInAllUnitslookupModuleWithSuggestionslookupPackageName!lookupPluginModuleWithSuggestions lookupUnit lookupUnit' lookupUnitId lookupUnitId'pprFlag pprModuleMap pprReasonpprUnitIdForUserpprUnitInfoForUserpprUnitspprUnitsSimplepprWithUnitStatereadUnitDatabasereadUnitDatabasesrenameHoleModulerenameHoleModule'renameHoleUnitrenameHoleUnit'resolveUnitDatabasesearchPackageIdunsafeLookupUnitunsafeLookupUnitId unwireUnitGHC.Unit.DatabaseGenericUnitInfounitPackageVersionunitPackageName unitPackageIdunitLinkerOptionsunitLibraryDynDirsunitLibraryDirs unitLibraries unitIsTrustedunitIsIndefinite unitIsExposedunitInstantiationsunitInstanceOf unitIncludesunitIncludeDirsunitImportDirsunitIdunitHiddenModulesunitHaddockInterfacesunitHaddockHTMLsunitExtDepLibsSysunitExtDepLibsGhcunitExtDepFrameworksunitExtDepFrameworkDirsunitExposedModules unitDependsunitComponentName unitCcOptionsunitAbiDepends unitAbiHash GenUnitInfo PackageId PackageName unPackageNameUnitInfo UnitKeyInfo LookupResultLookupUnusableLookupNotFoundLookupMultiple LookupFound LookupHidden ModuleOrigin ModUnusable ModHidden ModOriginfromPackageFlag fromOrigUnitfromExposedReexportfromHiddenReexportModuleSuggestion SuggestHiddenSuggestVisible ShHoleSubst UnitInfoMapUnusableUnitReasonShadowedDependenciesIgnoredWithFlagIgnoredDependenciesBrokenDependenciesCyclicDependenciesdefaultFrontendPlugin defaultPlugin flagRecompile impurePluginkeepRenamedSource lpModuleName mapPluginspluginRecompile'plugins purePlugin withPlugins withPlugins_CommandLineOption CorePluginFrontendPluginfrontendFrontendPluginActionPlugintypeCheckResultActiontcPluginspliceRunActionrenamedResultActionpluginRecompileparsedResultActioninterfaceLoadAction holeFitPlugininstallCoreToDos driverPluginPluginRecompileNoForceRecompileForceRecompileMaybeRecompilePluginWithArgs paArgumentspaPluginmkSrcErrsrcErrorMessages throwErrors throwOneError metaRequestAW metaRequestD metaRequestE metaRequestP metaRequestT MetaRequestMetaTMetaPMetaEMetaAWMetaD MetaResult findTarget isBootSummarymsDynObjFilePath msHiFilePath msHsFilePath msObjFilePathms_home_allimpsms_impsms_installed_mod showModMsgGHC.Data.FiniteMap deleteList foldRightfoldRightWithKey insertListinsertListWithFixitylookupFixityRn' lookupReboundunflattenGivensandWhenContinueeqPmLit eqConLikepickQuantifiablePreds GHC.ClassesEqOrdEnumSeparateBagsDerivStuff AuxBindSpec rnImportDecl LHsQTyVarsmergeIfaceDecl HsTyVarBndrHsForAllTelescopeTcTyMode ViaStrategyGHC.Types.SourceFile HscSourcerequirementMerges GHC.Hs.ExprHsMatchContext addPhiCts leftToRight topToBottomHsExpr GHC.Hs.LitOverLitMatch MatchGroupPatGRHSsGRHSLHsExprrootNGHC.Cmm.CLabelCLabelStringCtOriginGHC.ReadReadGHC.ShowShowStandAloneDerivOriginDerivClauseOriginFalse DerivStrategy andThenCheck array-0.5.4.0Data.Array.BaseUArrayGHC.Runtime.Interpreter.TypesIServ ForeignRef RemoteRefHsAppMaybeGHC.Unit.Module.ModDetails ModDetailsPipelineOutput Temporary Persistent BuildModule GHC.Hs.BindsABExportABE XABExportabe_wrap abe_pragsabe_polyabe_extabe_monoGHC.Hs.ExtensionGhcTcGhcRnGhcPsAmbiguousFieldOccXAmbiguousFieldOcc Ambiguous UnambiguousAnnDecl HsAnnotationXAnnDeclApplicativeArgXApplicativeArgApplicativeArgManyApplicativeArgOnexarg_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_instsCmdTopTcCoPat 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 fdResultSigfdLNamefdInjectivityAnnfdInfofdExtfdFixity FamilyInfoOpenTypeFamilyClosedTypeFamily DataFamilyFamilyResultSigXFamilyResultSigTyVarSigNoSigKindSigFieldOcc XFieldOcc extFieldOccrdrNameFieldOcc FixitySig XFixitySig ForeignDecl XForeignDecl ForeignExport ForeignImport fd_sig_tyfd_namefd_i_extfd_fifd_e_extfd_feXGRHSXGRHSsgrhssLocalBindsgrhssExt grhssGRHSsHsArgHsValArgHsArgPar HsTypeArgHsTypeXHsType HsWildCardTyHsTyLit HsTupleTyHsSumTyHsStarTy HsSpliceTyHsRecTyHsQualTyHsParTyHsOpTy HsKindSig HsIParamTy HsForAllTyHsExplicitTupleTyHsExplicitListTyHsDocTyHsBangTyHsAppTy HsAppKindTyHsFunTyHsListTyHsTyVar hst_xqual hst_xforallhst_telehst_bodyhst_ctxtHsKindHsArrowHsUnrestrictedArrowHsExplicitMult 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_lhs HsBracketXBracketVarBrTypBrTExpBrPatBrExpBrDecBrGDecBrLHsCmdXCmdHsCmdParHsCmdLet HsCmdLamCaseHsCmdLamHsCmdIfHsCmdDo HsCmdCase HsCmdArrFormHsCmdApp HsCmdArrAppHsCmdTopXCmdTopHsConDeclGADTDetails PrefixConGADT RecConGADT HsDataDefn XHsDataDefn dd_kindSigdd_ext dd_derivsdd_ctxtdd_consdd_NDdd_cTypeHsDeclXHsDeclWarningDTyClDSpliceDRuleDKindSigDInstDForDDocDDerivDDefDAnnD RoleAnnotDValDSigDHsDerivingClauseXHsDerivingClausederiv_clause_tysderiv_clause_extderiv_clause_strategyXExprSectionRSectionL RecordUpd RecordConOpAppNegApp HsUnboundVarHsTickHsTcBracketOutHsStatic HsSpliceEHsRnBracketOutHsRecFldHsProcHsPragE HsOverLabel HsMultiIfHsLet HsLamCaseHsLamHsIfHsIPVarHsDo HsConLikeOutHsCase HsBinTick HsAppType ExprWithTySig ExplicitTuple ExplicitSumArithSeq HsOverLitHsLitHsParHsVar ExplicitList rupd_fldsrupd_ext rupd_expr rcon_flds rcon_con_namercon_extXHsForAllTelescope 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 HsRecFields rec_dotdotrec_fldsHsScaled HsSigTypeHsSig XHsSigTypesig_ext sig_bndrssig_bodyHsSpliceXSpliceHsUntypedSplice HsTypedSplice HsQuasiQuote HsSplicedHsSplicedThing HsSplicedTy HsSplicedExpr HsSplicedPat HsStmtContext TransStmtCtxtPatGuard ParStmtCtxt MonadCompMDoExpr GhciStmtCtxtDoExprListComp ArrowExprHsTupArgXTupArgMissingPresent XTyVarBndr KindedTyVar UserTyVar HsValBindsLRValBinds XValBindsLRHsWildCardBndrsHsWCXHsWildCardBndrs hswc_bodyhswc_ext GHC.Hs.ImpExpIEXIE IEThingWith IEThingAllIEModuleContentsIEGroup IEDocNamedIEDocIEVar IEThingAbsIPBindXIPBind ImportDecl XImportDeclideclSourceSrc ideclSource ideclSafeideclQualified ideclPkgQual ideclName ideclImplicit ideclHidingideclAsideclExtInjectivityAnnInstDecl 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 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_rets RecordConTc rcon_con_expr rcon_con_like 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 TyFamInstDecltfid_eqnWarnDeclWarning XWarnDecl WarnDeclsWarnings XWarnDecls wd_warningswd_extwd_src XBindStmtRn xbsrn_bindOp xbsrn_failOp XBindStmtTc xbstc_failOpxbstc_boundResultType xbstc_bindOpxbstc_boundResultMult XXExprGhcTc ExpansionExprWrapExprhsExprNeedsParens hsLMatchPatsisAtomicHsExprisComprehensionContextisEmptyMatchGroup isInfixMatchisMonadCompContextisMonadStmtContext isPatSynCtxt isQuietHsCmd isQuietHsExprisSingletonMatchGroupisTypedBracket isTypedSplicematchContextErrStringmatchGroupAritymatchSeparator mkExpandedmkRnSyntaxExpr mkSyntaxExprnoExpr noSyntaxExprparenthesizeHsExpr pp_dotdotpp_rhspprAStmtContextpprArg pprBindStmtpprBindspprBypprCmd pprCmdArgpprComppprDebugParendExprpprDopprExternalSrcLoc pprFunBindpprGRHSpprGRHSs pprHsBracketpprLCmdpprLExprpprMatchpprMatchContextpprMatchContextNounpprMatchInCtxt pprMatches pprParendExprpprParendLExpr pprPatBindpprPendingSplicepprQuals pprSplice pprSpliceDeclpprStmtpprStmtContext pprStmtInCtxt pprTransStmtpprTransformStmtppr_appsppr_cmd ppr_do_stmtsppr_exprppr_infix_exprppr_lcmd ppr_lexprppr_module_name_prefix ppr_quasi ppr_spliceppr_splice_declprependQualifiedqualifiedDoModuleName_maybestripParensHsExprstripParensLHsExpr thBrackets thTyBrackets tupArgPresentCmdLStmtCmdStmtCmdSyntaxTable DelayedSplice ExprLStmtExprStmt FailOperator GhciLStmtGhciStmt GuardLStmt GuardStmt HsArrAppTypeHsFirstOrderAppHsHigherOrderApp HsExpansion HsExpanded HsRecordBinds HsSplicedTHsWrapLGRHSLHsCmd LHsCmdTop LHsTupArgLMatchLStmtLStmtLR MatchGroupTc mg_arg_tys mg_res_ty PostTcExpr PostTcTableSpliceDecoration BareSplice DollarSpliceSplicePointNameStmt SyntaxExpr SyntaxExprGhcThModFinalizers TransForm GroupFormThenFormUntypedSpliceFlavourUntypedTypeSpliceUntypedPatSpliceUntypedDeclSpliceUntypedExpSplicePass TypecheckedParsedRenamedOutputableBndrIdGhcPassXXParStmtBlockXApplicativeArgOneLPatXApplicativeArgManyXXApplicativeArg NoExtFieldXApp XAppTypeEXApplicativeStmt XArithSeqXBinTick XBindStmt XBodyStmtXCGRHSXCGRHSsXCMatchXCaseXCmdApp XCmdArrApp XCmdArrFormXCmdCaseXCmdDoXCmdIf XCmdLamCaseXCmdLamXCmdLetXCmdParXCmdWrap XConLikeOutXDecBrGXDecBrLXDoXExpBr XExplicitList XExplicitSumXExplicitTupleXExprWithTySigXIPVarXIfXLamCaseXLam XLastStmtXLetXLetStmtXLitEXMGXMissingXMultiIfXNegAppXOpApp XOverLabel XOverLitEXParXParStmtXPatBrXPragEXPresentXProc XQuasiQuoteXRecFldXRecStmt XRecordCon XRecordUpd XRnBracketOutXSCC XSectionL XSectionRXSpliceEXSplicedXStaticXTExpBr XTcBracketOutXTick XTransStmtXTypBr XTypedSplice XUnboundVarXUntypedSpliceXVarBrXVarNoExtCon XXBracketXXCmdXXCmdTopXXExprXXGRHSXXGRHSsXXMatch XXMatchGroupXXPragEXXSpliceXXStmtLRXXTupArg LHsLocalBindsLHsDeclLHsTypeIdPXRecLIdPHsIPName LHsWcTypeNoGhcTcLHsRecUpdField LHsSigWcTypeLHsLocalBindsLRIsPassghcPassUnXRecunXRecannProvenanceName_maybe appendGroupscollectRuleBndrSigTyscountTyClDeclsderivStrategyName docDeclDoc emptyRdrGroup emptyRnGroupfamResultKindSignaturefamilyDeclLNamefamilyDeclNameflattenRuleDeclsfoldDerivStrategy getConNamesgetRecConArgs_maybehsConDeclTheta hsDeclHasCuskhsGroupInstDeclshsGroupTopLevelFixitySigsinstDeclDataFamInsts isClassDeclisClosedTypeFamilyInfo isDataDeclisDataFamilyDecl isFamilyDeclisOpenTypeFamilyInfo isSynDeclisTypeFamilyDeclmapDerivStrategynewOrDataToFlavourpartitionBindsAndSigspprDataFamInstFlavourpprFullRuleNamepprHsFamInstLHSpprTyClDeclFlavourpprTyFamInstDeclresultVariableNameroleAnnotDeclNamestandaloneKindSigNametcdName tyClDeclLNametyClDeclTyVarstyClGroupInstDeclstyClGroupKindSigstyClGroupRoleDeclstyClGroupTyClDeclstyFamInstDeclLNametyFamInstDeclName AnnProvenanceValueAnnProvenanceModuleAnnProvenanceTypeAnnProvenance CImportSpecCWrapper CFunction DataDeclRn tcdDataCusktcdFVsDocDeclDocGroupDocCommentPrevDocCommentNamedDocCommentNextCExportCImportHsConDeclH98Details HsDerivingHsRuleRnHsTyPatsLAnnDecl LClsInstDeclLConDeclLDataFamInstDecl LDefaultDeclLDerivClauseTys LDerivDeclLDerivStrategyLDocDecl LFamilyDeclLFamilyResultSig LForeignDeclLHsDerivingClause LHsFunDepLInjectivityAnn LInstDeclLRoleAnnotDecl LRuleBndr LRuleDecl LRuleDecls LSpliceDeclLStandaloneKindSig LTyClDeclLTyFamDefltDeclLTyFamInstDecl LTyFamInstEqn LWarnDecl LWarnDecls NewOrDataDataTypeNewTypeTyFamDefltDecl TyFamInstEqn XHsAnnotation XXAnnDecl XCClsInstDecl LHsSigTypeLHsBindsLSig XXClsInstDecl XConDeclGADTHsOuterSigTyVarBndrs LHsContext GHC.Hs.Doc LHsDocString XConDeclH98 LHsTyVarBndr XXConDeclXAnnD XCDefaultDecl XCDerivDeclXCFamEqn XCFamilyDecl XCHsDataDefnXCHsDerivingClause XCHsGroup XCKindSigXCRoleAnnotDecl XCRuleBndr XCRuleDecls XCTyClGroup XClassDecl XClsInstD XDataDecl XDataFamInstD XDctMulti XDctSingleXDefDXDerivDXDocDXFamDeclXForDXForeignExportXForeignImportXHsRuleXInstD XKindSigDXNoSig XRoleAnnotD XRuleBndrSigXRuleDXSigDXSpliceDXSynDeclXTyClD XTyFamInstD XTyVarSigXValD XViaStrategy XWarningDXWarning XWarnings XXDefaultDeclXXDerivClauseTys XXDerivDeclXXFamEqn XXFamilyDeclXXFamilyResultSig XXForeignDecl XXHsDataDefnXXHsDeclXXHsDerivingClause XXHsGroup XXInstDeclXXRoleAnnotDecl XXRuleBndr XXRuleDecl XXRuleDecls XXSpliceDeclXXStandaloneKindSig XXTyClDecl XXTyClGroup XXWarnDecl XXWarnDecls HsDocStringHsOuterFamEqnTyVarBndrsLHsKind LBangType LConDeclField HsConDetailsRecConInfixCon PrefixConHsBind LFixitySig LHsTypeArgcollectEvVarsPatcollectEvVarsPats hsConPatArgs hsRecFieldId hsRecFieldSel hsRecFieldshsRecFieldsArgshsRecUpdFieldIdhsRecUpdFieldOcchsRecUpdFieldRdr isBangedLPatisIrrefutableHsPat isSimplePatlooksLazyPatBind mkCharLitPatmkNilPatmkPrefixConPatparenthesizePatpatNeedsParens pprConArgs pprParendLPatConLikePHsConPatDetails HsRecField HsRecField'hsRecPun hsRecFieldArg hsRecFieldLbl HsRecUpdField LHsRecField LHsRecField'XAsPatXBangPatXConPatXLazyPatXListPatXLitPatXNPat XNPlusKPatXParPatXSigPat XSplicePatXSumPat XTuplePatXVarPatXViewPatXWildPatXXPat XCFieldOcc LFieldOcc emptyLHsBindsemptyLocalBindsemptyValBindsInemptyValBindsOuteqEmptyLocalBinds hasSpecPragshsSigDocisCompleteMatchSigisDefaultMethodisEmptyIPBindsPRisEmptyIPBindsTcisEmptyLHsBindsisEmptyValBinds isFixityLSig isInlineLSig isMinimalLSig isPragLSig isSCCFunSigisSpecInstLSig isSpecLSig isTypeLSig noSpecPragsplusHsValBinds pprDeclList pprLHsBindspprLHsBindsForUser pprMinimalSigpprSpecpprTcSpecPragspprTicks pprVarSig ppr_monobindppr_sig pragBracketspragSrcBrackets HsLocalBindsHsPatSynDetailsLHsBind LHsBindLR LHsBindsLRLIPBind LTcSpecPragRecordPatSynFieldrecordPatSynPatVarrecordPatSynSelectorId TcSpecPragSpecPrag TcSpecPragsIsDefaultMethod SpecPrags XXPatSynBindXABE XXABExport XAbsBindsXCIPBind XClassOpSigXCompleteMatchSigXEmptyLocalBindsXFixSigXFunBind XHsValBindsXIPBindsXIdSig XInlineSig XMinimalSigXPSBXPatBind XPatSynSig XSCCFunSig XSpecInstSigXSpecSigXTypeSig XValBindsXVarBind XXFixitySig XXHsBindsLR XXHsIPBindsXXHsLocalBindsLRXXIPBindXXSig XXValBindsLR convertLithsLitNeedsParenshsOverLitNeedsParensnegateOverLitVal overLitType pmPprHsLit pp_st_suffix OverLitTc ol_rebindableol_type OverLitVal HsIsString HsFractional HsIntegral XXOverLitXHsChar XHsCharPrim XHsDoublePrim XHsFloatPrim XHsInt64PrimXHsInt XHsIntPrim XHsIntegerXHsRat XHsString XHsStringPrim XHsWord64Prim XHsWordPrimXXLitambiguousFieldOcc arrowToHsType dropWildCards emptyLHsQTvsgetBangStrictness getBangTypegetLHsInstDeclClass_maybegetLHsInstDeclHeadhsAllLTyVarNameshsExplicitLTyVarNames hsIPNameFShsLTyVarLocNamehsLTyVarLocNames hsLTyVarName hsLTyVarNameshsLinearhsMulthsOuterExplicitBndrshsOuterTyVarNames hsPatSigType hsQTvExplicit hsScaledThing hsScopedTvs hsSigWcTypehsTvbAllKindedhsTyGetAppHead_maybe hsTyKindSighsTyVarBndrFlag hsTyVarNamehsTypeNeedsParenshsUnrestricted hsWcScopedTvs ignoreParensisHsKindedTyVarisUnrestrictedlhsTypeArgSrcSpanmapHsOuterImplicitmkAmbiguousFieldOccmkAnonWildCardTymkEmptyWildCardBndrs mkFieldOcc mkHsAppKindTy mkHsAppTysmkHsExplicitSigTypemkHsForAllInvisTelemkHsForAllVisTelemkHsImplicitSigTypemkHsOpTymkHsOuterExplicitmkHsOuterImplicitmkHsPatSigTypemkHsQTvsmkHsWildCardBndrs noLHsContextnumVisibleArgsparenthesizeHsContextparenthesizeHsTypepprAnonWildCardpprConDeclFields pprHsForAllpprHsOuterFamEqnTyVarBndrspprHsOuterSigTyVarBndrs pprHsType pprLHsContextrdrNameAmbiguousFieldOccselectorAmbiguousFieldOccsetHsTyVarBndrFlagsplitHsFunTypesplitLHsForAllTyInvissplitLHsForAllTyInvis_KPsplitLHsGadtTysplitLHsInstDeclTysplitLHsPatSynTysplitLHsQualTysplitLHsSigmaTyInvisunambiguousFieldOccBangType HsContextHsPSRn hsps_imp_tvs hsps_nwcs HsTupleSortHsBoxedOrConstraintTupleHsUnboxedTupleHsNumTyHsStrTy NewHsTypeX NHsCoreTyOutputableBndrFlag XUnambiguous XAmbiguousXXAmbiguousFieldOccXXConDeclField XAppKindTyXAppTyXBangTyXDocTyXExplicitListTyXExplicitTupleTy XForAllTyXFunTyXHsForAllInvis XHsForAllVisXHsOuterExplicitXHsOuterImplicitXHsPSXHsQTvsXHsSigXHsWC XIParamTyXKindSig XKindedTyVarXListTyXOpTyXParTyXQualTyXRecTy XSpliceTyXStarTyXSumTyXTupleTyXTyLitXTyVar XUserTyVar XWildCardTy XXFieldOccXXHsForAllTelescopeXXHsOuterTyVarBndrsXXHsPatSigType XXHsSigTypeXXHsWildCardBndrs XXLHsQTyVars XXTyVarBndrXXTypeieNameieNames ieWrappedNameimportDeclQualifiedStyleisImportDeclQualifiedlieWrappedName pprImpExpreplaceLWrappedNamereplaceWrappedNamesimpleImportDecl IEWildcard NoIEWildcard IEWrappedNameIEName IEPatternImportDeclQualifiedStyle QualifiedPre NotQualified QualifiedPostLIELIEWrappedName LImportDecl XCImportDeclXIEDoc XIEDocNamedXIEGroupXIEModuleContents XIEThingAbs XIEThingAll XIEThingWithXIEVarXXIE XXImportDecl appendDocs concatDocsemptyArgDocMapemptyDeclDocMaphsDocStringToByteStringisEmptyDocString mkHsDocStringmkHsDocStringUtf8ByteString ppr_mbDoc unpackHDS ArgDocMap DeclDocMapnoExtCon noExtFieldpprIfPspprIfRnpprIfTcIdGhcPMapXRecmapXRec NoGhcTcPassWrapXRecwrapXRecXCoPatchunkifycollectHsBindBinderscollectHsBindListBinderscollectHsBindsBinderscollectHsIdBinderscollectHsValBinderscollectLStmtBinderscollectLStmtsBinderscollectLocalBinderscollectMethodBinderscollectPatBinderscollectPatsBinderscollectStmtBinderscollectStmtsBinders emptyRecStmtemptyRecStmtIdemptyRecStmtNameemptyTransStmtgetPatSynBindshsDataFamInstBindershsForeignDeclsBindershsGroupBindershsLTyClDeclBindershsPatSynSelectorshsTyClForeignBindershsTypeToHsSigTypehsTypeToHsSigWcTypehsValBindsImplicitsisBangedHsBindisInfixFunBindisUnliftedHsBind lPatImplicitslStmtsImplicits missingTupArgmkBigLHsPatTup mkBigLHsTupmkBigLHsVarPatTupmkBigLHsVarTup mkBodyStmt mkChunkified mkClassOpSigs mkFunBindmkGroupByUsingStmtmkGroupUsingStmt mkHsAppType mkHsAppTypes mkHsAppWithmkHsApps mkHsAppsWith mkHsCmdIf mkHsCmdWrapmkHsCompmkHsDomkHsFractionalmkHsIf mkHsIntegral mkHsIsStringmkHsLammkHsLams mkHsOpAppmkHsParmkHsQuasiQuote mkHsSigEnv mkHsStringmkHsStringPrimLit mkHsVarBindmkHsWrap mkHsWrapCo mkHsWrapCoR mkHsWrapPat mkHsWrapPatCo mkLHsCmdWrapmkLHsParmkLHsTupleExpr mkLHsVarTuple mkLHsWrap mkLHsWrapCo mkLastStmtmkMatch 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_HsVarunguardedGRHSs unguardedRHS unitRecStmtTcGHC.HsHsModule hsmodName hsmodLayouthsmodHaddockModHeaderhsmodDeprecMessage hsmodDecls hsmodExports hsmodImportsHsParsedModule hpm_src_fileshpm_annotations hpm_module CollectPass collectXXPatCode