h$;j,      !"#$%&'()*+, - . / 0 12 3456789:;<=>?@ABCDEFGHIJKLMNOPQ R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                                                                                                                                                                                                                                                                           !""""#  $ %%         &    ''                                                                                                   % % ( ( )                                        * * * * * +                                                                                                                                                                                                                                                                                                                                                                                                                                                     ,                                                                    ''''-...//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////*****************00000000111111111111''''''''''''''''''''''''22223333333333444444444444555555555555555555555555555555555555555555555555555555555566666666677777777788888888999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999:;;;;;;;;;;;;;;<<<<<<<<===========================================>>>>?@@@@@AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBBCDDDDDDDDDDDDDDDDDDDDDDDDEEEEEEEEEEEEEEEEEEEEEEEEFFFFFFFFFFFFFGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGHHHHHHHHHHHHHHHHIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIJJJJJJJJJJJJJJJJJJJJJJJKKKKKKKKKKKKKKKLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLMMMMMMMMMMMMMMMMMMMMMMMMMNNNNNNOOOOOOOOOOPPPPPPPPPQQQQQQQQRRSSTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTUUUUUUUVVVVVVVVVVVVVVVVVVVVVVWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWXXYYYYYYZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ[[[[[[[[[\\\\\\\\\]]]]^^^^^^^^^^^^^^^^_`aabcdeeeeeeeeeeeeeeeeeeeeeeeeff                   ggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggghhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhiiijkkkkkkkkkkkkkkkkkkkllllllllllllllllllllllllllllllllllllllmnnnnooooooooooooooooooooooooooppppppppppppppppppppppppppppppppppp p p p p p p p p p p p p p p p p p p p p p p p p p p p p p p p p p p p p p p p p p p p p p p p p p p p p p p p p p p p p p p p p q q q q q q q q q q r r r r r r r s s s s s s s s s s t t t t t t t t t t t t t t t t 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!w!w!x!y!y!y!y!y!y!y!y!y!y!y!y!y!y!y!y!y!y!y!y!y!y!z!z!{!{!{!{!{!{!{!{!{!{!{!{!{!|!|!|!|!|!|!|!|!|!|!|!|!|!|!|!|!|!|!|!|!|!|!|!|!|!|!|!|!|!|!|!|!|!|!|!|!|!|!|!|!|!|!|!|!|!|!|!|!|!|!|!|!|!|!|!|!|!|!|!|!|!|!|!-!-!-!-!-!-!-!-!-!-!-!-!-!-!-!-!-!-!-!-!-"-"-"-"-"-"-"-"-"-"-"-"-"-"-"-"-"-"-"-"-"-"-"}"}"}"}"}"}"}"}"}"}"}"}"}"}"}"}"}"}"}"}"}"}"}"}"}"}"}"}"}"}"}"}"}"}"}"}"}"~"~"~""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""################################################################################################################################$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''(((((((((((((((((((((((((%(%(%(%(%(%(%(%(%(%(%(%(%(%(%(%(%(%(%(%(%(%(%(%(%(%(%(%(%(%(%(%(%(%(%(%(%(%(%(%(%(%(%(%(%(%(%(%(%(%(%(%(%(%(%(%(%(%(%(%(%(%(%(%(%(%(%((((((((((((((((((((((((((((((((((((())))))))))))))))))))))))))))))))))))))))))))))))))))))!)!)!)!)!)!)!)!)!)!)!)!)!)!)!)!)!)!)!)!)!)!)!)!)!)!)!)!)!)!)!)!)!)!)!))))))))))))))))))))))))))))))))))))))) ) * * * * * * * * * * * * * * * * * * * * * * * * ****************************************************************"*"*"*"*"*"*"*"*"*"*"*"*"*"*"*"*************************++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.+.+.+.+.+.+.+.+++++++++++++++++++++++++++++++++++++++,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,),),),),),),),),),),),),),),),),,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,--------------------------------------------------------------------------------------------------------------------------------..................................................(.(.(.(.(.(.(.(.(.(.(.(.(.(.(.(.(.(.(.(.(.(.(......#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.........,.,.,.,.,.,.,.,.,.,.,.,.,.,.,.,.,.,.,.,.,.,.,/,/,/,/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////000000000000000000000000000 0 0 0 0 0 0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001111111111111111111111111111111111111111111111111 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 111111111111111111111111111111111111111111111111122222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222&2&2&2&2&2&2&2&2&2&22233333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444445555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555566666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666+6+6+6+6+6+6+6+6+6+6+6+6+7+7+7777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777778888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888899999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<================================================================================================================================>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C D D D D D D D D D D D D D DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD D D D D D D D D D D E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E EEEEEEEEEEEEEEEEEEEEEEEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF/Noneu*None'  Noneǃghc-libThis list is used to ensure that when you say "Prelude.map" in your source code, or in an interface file, you get a Name with the correct known key (See Note [Known-key names] in GHC.Builtin.Names)ghc-libGiven a  lookup its associated ) if it corresponds to a known-key thing.ghc-libIs a  known-key?ghc-libGiven a  lookup any associated arbitrary SDoc's to be displayed by GHCi's ':info' command.  0None >1None<+ ghc-libTarget Profileghc-lib Optimize Cmm Control Flow or notghc-lib"Do Cmm Linting Optimization or notghc-libEliminate common blocks or notghc-lib&Perform sink after stack layout or notghc-lib5Generate stack unwinding instructions (for debugging)ghc-lib/Generate code to link against dynamic librariesghc-lib1Should the Cmm pass replace Stg switch statementsghc-lib#Should Cmm split proc points or notghc-lib retrieve the target Cmm platform  'None'(/5ghc-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.2None3None'(  4Noneϫghc-libReturn the UnitId of the home-unit. This is used to create labels.5None996None >7None '(>??8None '(?ghc-libThe dataflow latticeghc-lib'Calculated liveness info for a CmmGraphghc-libThe dataflow lattice9None '( ghc-libWe make a top-level decl for the string, and return a label pointing to itghc-libWe make a top-level decl for the embedded binary file, and return a label pointing to itghc-libBuild a data-segment data blockghc-libUseful for creating an index into an array, with a statically known offset. The type is the element type; used for making the multiplierghc-libUseful for creating an index into an array, with an unknown offset.ghc-lib*Load a naturally-aligned non-pointer word.ghc-lib$Load a naturally-aligned GC pointer.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 firstghc-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. -GBMghc-lib1Extract all tick annotations from the given block:None'(ghc-libTraverses the F, making sure that F# are suitable for code generation.;None'(>? <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 F (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-libAssumes natural alignmentghc-libA jump where the caller says what the live GlobalRegs are. Used for low-level hand-written Cmm.ghc-lib Construct a F7 node for the given register and unwinding expression.**>None?None'(@None '(5?!ANone'(>?qghc-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 F= 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.BNone'( CNone'(AD Safe-InferredtE(c) Matt Morrow 2009BSD3stableportableNone ?Fghc-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.F2F9 FNone  GNoneghc-lib#Native code generator configurationghc-libTarget platformghc-libContext for ASM code generationghc-lib1The name of the module we are currently compilingghc-libMandatory proc alignmentghc-lib/Generate code to link against dynamic librariesghc-lib Enable Position-Independent Codeghc-lib If inlining memcpy produces less than this threshold (in pseudo-instruction unit), do itghc-lib Ditto for memsetghc-libSplit sectionsghc-libPerform ASM linting passghc-libPerform CMM constant foldingghc-lib(x86) SSE instructionsghc-lib(x86) BMI instructionsghc-libCFG edge weightsghc-lib$Use CFG based block layout algorithmghc-lib+Layout based on last instruction per block.ghc-libEnable Dwarf generationghc-libEnable unwindingsghc-lib0Strip out block information from generated Dwarfghc-lib0Expose symbol table entries for internal symbolsghc-lib$Enable GHC-specific source note DIEsghc-lib%Enable static control-flow predictionghc-libEnable shortcutting (don't jump to blocks only containing a jump)ghc-libCompute block unwinding tablesghc-lib+Whether to enable the dead-code eliminationghc-libReturn Word sizeghc-lib=Size in bytes of the pre-allocated spill space on the C stackghc-libReturn Word size##HNoneghc-lib%Get the integer format of this width.ghc-lib#Get the float format of this width.ghc-lib-Check if a format represent an integer value.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.INoneghc-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.JNoneghc-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-lib instructionsghc-libthe reg to reload.ghc-libthe current stack deltaghc-libthe spill slot to useghc-lib instructionsghc-libsource registerghc-libdestination registerKNone+LNoneCghc-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.00MNone ghc-lib"A subcomponent of another registerghc-libA register of some classghc-libWorst case displacementa node N of classN has some number of neighbors, all of which are from classC.(worst neighbors classN classC) is the maximum number of potential colors for N that can be lost by coloring its neighbors.This should be hand coded/cached for each particular architecture, because the compute time is very long..ghc-libFor a node N of classN and neighbors of classesC (bound classN classesC) is the maximum number of potential colors for N that can be lost by coloring its neighbors.ghc-libThe total squeese on a particular node with a list of neighbors.A version of this should be constructed for each particular architecture, possibly including uses of bound, so that aliased registers don't get counted twice, as per the paper.ghc-libso we can put regs in UniqSetsNNone ghc-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 x86ONoneghc-libArmv6 | Armv7-A | Armv8-A AArch64 | | SIMD extension | NEON | NEON | |===========================================================================| | - Operates on 32-bit | - Separate reg. bank, | - Separate reg. bank, | | GP ARM registers | 32x64-bit NEON regs | 32x128-bit NEON regs | | - 8-bit16-bit integer | - 8163264-bit int | - 81632/64-bit int | | | - Single percision fp | - Single percision fp | | | | - Double precision fp | | | | - Single/Double fp are | | | | IEEE compliant | | - 2x16-bit/4x8-bit ops | - Up to 16x8-bit ops | - Up to 16x8-bit ops | | per instruction | per instruction | per instruction | '---------------------------------------------------------------------------'PNonebQNoneZghc-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 allocatedRNoneNone  SNoneghc-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).TNone$ghc-lib,SXTW Operand Operand | SXTX Operand Operandghc-lib;ADC Operand Operand Operang -- rd = rn + rm + C | ADCS ...ghc-libADDS Operand Operand Operand -- rd = rn + rm | ADR ... | ADRP ...ghc-libMADD ... | MNEG ...ghc-lib6NEGS ... | NGC ... | NGCS ... | SBC ... | SBCS ...ghc-libSMADDL ... | SMNEGL ... | SMSUBL ... | SMULH ... | SMULL ...ghc-libSUBS ...ghc-libUMADDL ... -- Xd = Xa + Wn  Wm | UMNEGL ... -- Xd = - Wn  Wm | UMSUBL ... -- Xd = Xa - Wn  Wm | UMULH ... -- Xd = (Xn  Xm)_127:64 | UMULL ... -- Xd = Wn  Wmghc-lib,MOVN Operand Operand | MOVZ Operand Operandghc-libTODO: verify this!ghc-libAll registers are 8 byte wide.ghc-libThe number of bytes that the stack pointer should be aligned to.ghc-lib reg move instruction or Nothing if it's not oneghc-lib'Make an unconditional jump instruction.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.RegUsage = RU [ readregs] [ writeregs]UNone'V 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.WNone,ghc-libregSqueeze_class reg Calculate the maximum number of register colors that could be denied to a node of this class due to having this reg as a neighbour.ghc-lib&The complete set of machine registers.ghc-libTake the class of a register.ghc-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 negativeXNone. YNone.8ZNone3 ghc-libThe format argument is the size of operand 1 (the number of bits we keep) We always zero *all* high bits, even though this isn't how the actual instruction works. The code generator also seems to rely on this behaviour and it's faster to execute on many cpus as well so for now I'm just documenting the fact.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-lib Make a reg-reg move instruction.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)[None4\None5]None '(55a^None7 ghc-libTarget platformghc-lib Context for LLVM code generationghc-lib+Fill undefined literals with garbage valuesghc-libSplit sectionsghc-lib(x86) BMI instructionsghc-libversion of Llvm we're usingghc-lib&True ==> warn unsupported Llvm versionghc-libtarget triple passed to LLVMghc-lib>mirror DynFlags LlvmConfig. see Note [LLVM configuration] in  GHC.SysTools. This can be strict since GHC.Driver.Config.CmmToLlvm.initLlvmCgConfig verifies the files are present._None84ghc-lib!Read in assembly file and process`None<8aaNone9:ghc-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.bNone9ghc-lib8Traverses the AST, simply to find all joinrecs and call exitify8 on them. The really interesting function is exitifyReccNone:dNone:IeNone:ufNone: None;vghc-libMake a join id with given type and arity but without call-by-value annotations.QRSTUUTQRSgNone< ghc-libA substitution result.hNone=ciNone>None?Sghc-libSpecialise calls to type-class overloaded functions occurring in a program.jNone?kNone@+ghc-lib,True if there is a non-empty intersection. s1  s2 doesn't compute s2 if s1 is emptylNone&VTghc-lib Returned by 9. See also Note [Detecting recursive data constructors].ghc-libThe algorithm detected a loopghc-libThe algorithm detected no loop, went out of fuel or hit an .hs-boot fileghc-libDescribes the outer shape of an argument to be unboxed or left as-is Depending on how s is instantiated (e.g., F or F).ghc-lib/We ran out of strictness info. Leave untouched.ghc-lib'The argument/field was absent. Drop it.ghc-libThe argument is used strictly or the returned product was constructed, so unbox it. The 4 carries the bits necessary for instantiation with F. The [s] carries the bits of information with which we can continue unboxing, e.g. s will be F or F.ghc-libThe argument can't be unboxed, but we want it to be passed evaluated to the worker.ghc-libThe information needed to build a pattern for a DataCon to be unboxed. The pattern can be generated from  and  via F. The coercion  is for newtype wrappers. If we get DataConPatContext dc tys co for some type ty and *dataConRepInstPat ... dc tys = (exs, flds), thendc exs flds :: T tys@ co :: T tys ~ tyghc-libGiven a function definition data T = MkT Int Bool Char f :: (a, b) -> Int -> T f = \x y -> E mkWwBodies _ f7 ['x::(a,b)','y::Int'] '(a,b)' ['1P(L,L)', '1P(L)'] '1' returnsThe wrapper body context for the call to the worker function, lacking only the   for the worker function: W[_] :: Id -> CoreExpr W[work_fn] = \x y -> -- args of the wrapper (cloned_arg_vars) case x of (a, b) -> -- unbox wrapper args (wrap_fn_str) case y of I# n -> -- case a b n of -- call to the worker fun (call_work) (# i, b, c #) -> MkT i b c -- rebox result (wrap_fn_cpr)The worker body context that wraps around its hole reboxing defns for x and y, as well as returning CPR transit variables of the unboxed MkT result in an unboxed tuple: w[_] :: CoreExpr -> CoreExpr w[fn_rhs] = \a b n -> -- args of the worker (work_lam_args) let { y = I# n; x = (a, b) } in -- reboxing wrapper args (work_fn_str) case x y of -- call to the original RHS (call_rhs) MkT i b c -> (# i, b, c #) -- return CPR transit vars (work_fn_cpr)NB: The wrap_rhs hole is to be filled with the original wrapper RHS x y -> E". This is so that we can also use w to transform stable unfoldings, the lambda args of which may be different than x and y.Id details for the worker function like demands on arguments and its join arity.All without looking at E (except for beta reduction, see Note [Join points and beta-redexes]), which allows us to apply the same split to function body and its unfolding(s) alike.ghc-lib'Whether the worker needs an additional `Void#` arg as per Note [Protecting the last value argument] or Note [Preserving float barriers].ghc-lib Inserts a `Void#` arg before the first value argument (but after leading type args).ghc-lib Unwraps the F decision encoded in the given F and returns a - as well the nested demands on fields of the   to unbox.ghc-libTries to find a suitable absent filler to bind the given absent identifier to. See Note [Absent fillers].If mkAbsentFiller _ id == Just e, then e, is an absent filler with the same type as id/. Otherwise, no suitable filler could be found.ghc-libExactly F3, but lacks the (ASSERT'ed) precondition that the   may not have existentials. The lack of cloning the existentials compared to dataConInstExAndArgVars makes this function "dubious"; only use it where type variables aren't substituted for!ghc-libisRecDataCon _ fuel dc, where tc = dataConTyCon dc returnsDefinitelyRecursive if the analysis found that tc" is reachable through one of dc's arg_tys.NonRecursiveOrUnsure if the analysis found that tc& is not reachable through one of dc$'s fields (so surely non-recursive).NonRecursiveOrUnsure when fuel /= Infinity and fuel expansions of nested data TyCons were not enough to prove non-recursivenss, nor arrive at an occurrence of tc thus proving recursiveness. (So not sure if non-recursive.)NonRecursiveOrUnsure when we hit an abstract TyCon (one without visible DataCons), such as those imported from .hs-boot files. Similarly for stuck type and data families.If fuel = Infinity and there are no boot files involved, then the result is never Nothing. and the analysis is a depth-first search. If fuel = F f, then the analysis behaves like a depth-limited DFS and returns Nothing! if the search was inconclusive.See Note [Detecting recursive data constructors] for which recursive DataCons we want to flag.ghc-libThe original functionghc-lib"Manifest args of original functionghc-libResult type of the original function, after being stripped of argsghc-libStrictness of original functionghc-libInfo about function resultghc-libConsider unliftingghc-libType of the argumentghc-libHow the arg was used##mNoneWNoneW0nNone[ ghc-lib&A bitmap represented by a sequence of F 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 duplicatesoNonea) 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-wordpNoneg 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 one          qNonei;  rNoneiy  sNone #'(i tNonep ghc-libGraph nodes. Represents a thing that can conflict with another thing. For the register allocater the nodes represent registers. ghc-lib"A unique identifier for this node. ghc-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.  uNoneq  vNone ghc-libLookup a node from the graph. ghc-lib>Get a node from the graph, throwing an error if it's not there ghc-lib-Add a node to the graph, linking up its edges ghc-lib/Delete a node and all its edges from the graph. ghc-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 graph ghc-libAdd some conflicts to the graph, creating nodes if required. All the nodes in the set are taken to conflict with each other. ghc-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 graph ghc-libFreeze a node This is for the iterative coalescer. By freezing a node we give up on ever coalescing it. Move all its coalesce edges into the frozen set - and update back edges from other nodes. ghc-libFreeze one node in the graph This if for the iterative coalescer. Look for a move related node of low degree and freeze it.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 criteria!ghc-libvalidate the internal structure of a graph all its edges should point to valid nodes If they don't then throw an error!ghc-libSlurp out a map of how many nodes had a certain number of conflict neighbours!ghc-libSet the color of a certain node ghc-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 coalesced ghc-libkey of the node to freezeghc-lib the graphghc-libgraph with that node frozen!ghc-lib(extra debugging info to display on errorghc-lib-whether this graph is supposed to be colored.ghc-libgraph to validateghc-libvalidated graph!ghc-lib9(conflict neighbours, num nodes with that many conflicts) !!!! !!!!wNone!ghc-lib9Pretty print a graph in a somewhat human readable format.!ghc-libPretty print a graph in graphviz .dot format. Conflicts get solid edges. Coalescences get dashed edges.!ghc-libWhat graphviz color to use for each node color It's usually safe to return X11 style colors here, ie "red", "green" etc or a hex triplet #aaff55 etc!!!!xNone!ghc-libTry to color a graph with this set of colors. Uses Chaitin's algorithm to color the graph. The graph is scanned for nodes which are deamed 'trivially colorable'. These nodes are pushed onto a stack and removed from the graph. Once this process is complete the graph can be colored by removing nodes from the stack (ie in reverse order) and assigning them colors different to their neighbors.!ghc-lib"whether to do iterative coalescingghc-lib6how many times we've tried to color this graph so far.ghc-lib>map of (node class -> set of colors available for this class).ghc-lib3fn to decide whether a node is trivially colorable.ghc-libfn to choose a node to potentially leave uncolored if nothing is trivially colorable.ghc-libthe graph to color.+ !!!!!!!!yNone!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!zNone!!!!{ Safe-Inferred !ghc-lib"The internal data structure for a !, which either records the representative element of an equivalence class, or a link to the !. that actually stores the representative type.!ghc-libA variable which can be unified; alternately, this can be thought of as an equivalence class with a distinguished representative.!ghc-libMutable write to a !!ghc-libRead the current value of !.!ghc-lib2Create a fresh equivalence class with one element.!ghc-lib)Flatten any chains of links, returning a !8 which points directly to the canonical representation.!ghc-lib6Return the canonical element of an equivalence class !.!ghc-libUnify two equivalence classes, so that they share a canonical element. Keeps the descriptor of point2.!ghc-lib5Test if two points are in the same equivalence class. !!!!!!!!!!!! !!!!!!!!!!!!|None /?!ghc-libInformation about edges!ghc-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 conditions]!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. Parameters are `f from to edgeInfo`!ghc-libSometimes we insert a block which should unconditionally be executed after a given block. This function updates the CFG for these cases. So we get A -> B => A -> A' -> B -> C => -> C!ghc-lib5Adds a new edge, overwrites existing edges if present!ghc-libAdds a edge with the given weight to the cfg If there already existed an edge it is overwritten. `addWeightEdge from to weight cfg`!ghc-lib4Destinations from bid ordered by weight (descending)!ghc-lib1Get successors of a given node with edge weights.!ghc-lib/Returns a unordered list of all edges with info!ghc-lib5Returns a unordered list of all edges without weights!ghc-lib4Get successors of a given node without edge weights.!ghc-libInsert a block in the control flow between two other blocks. We pass a list of tuples (A,B,C) where * A -> C: Old edge * A -> B -> C : New Arc, where B is the new block. It's possible that a block has two jumps to the same block in the assembly code. However we still only store a single edge for these cases. We assign the old edge info to the edge A -> B and assign B -> C the weight of an unconditional jump.!ghc-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 destination!ghc-libCareful! Since we assume there is at most one edge from A to B the Eq instance does not consider weight..!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!.!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!-None5>?!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.%!!!!!!!!!!!!!!!!!!!!!"""""""""""""""%!!!!!!!!!!!!!!!!!!!!!"""""""""""""""}None#$"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-lib1Find the register mapping for a specific BlockId."ghc-lib?Lookup which register a virtual register was first assigned to."ghc-libAn initial empty ""ghc-lib/Add new register mappings for a specific block."ghc-lib'Get the reg numbers stored in this Loc.""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""~None"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""""""None 5#"ghc-lib"The register allocator monad type."ghc-lib'Get native code generator configuration"ghc-lib 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.""""None'(D "ghc-libMap of ""ghc-lib1Records the expected cost to spill some register."ghc-libAn empty map of spill costs."ghc-libAdd two spill cost infos."ghc-libAdd two spill cost records."ghc-lib7Slurp out information used for determining spill costs.For each vreg, the number of times it was written to, read from, and the number of instructions it was live on entry to (lifetime)"ghc-lib&Choose a node to spill from this graph"ghc-lib+Extract a map of register lifetimes from a "."ghc-libShow a spill cost record, including the degree from the graph and final calculated spill cost. """"""""" """""""""None 5>?"ghc-lib9Holds interesting statistics from the register allocator."ghc-libInitial code, with liveness."ghc-libThe initial, uncolored graph."ghc-lib/Information to help choose which regs to spill."ghc-libTarget platform"ghc-lib(Code we tried to allocate registers for."ghc-libThe regs that were coalesced."ghc-libSpiller stats."ghc-lib#Code with spill instructions added."ghc-libCoalesced and colored graph."ghc-libCode with coalescings applied."ghc-lib"Code with vregs replaced by hregs."ghc-lib-Code with unneeded spill/reloads cleaned out."ghc-lib Final code."ghc-lib0Spill/reload/reg-reg moves present in this code."ghc-lib;Do all the different analysis on this list of RegAllocStats"ghc-libDump a table of how many spill loads / stores were inserted for each vreg."ghc-libDump a table of how long vregs tend to live for in the initial code."ghc-libDump a table of how many conflicts vregs tend to have in the initial code."ghc-libFor every vreg, dump how many conflicts it has, and its lifetime. Good for making a scatter plot."ghc-lib Count spillreloadreg-reg moves. Lets us see how well the register allocator has done."ghc-libglobal register conflict graph""""""""""""""""""""""""#""""""""""""""""""""""""#None >?#ghc-lib7The top level of the graph coloring register allocator.#ghc-lib#registers we can use for allocationghc-libset of available spill slots.ghc-libcurrent number of spill slotsghc-lib)code annotated with liveness information.ghc-lib CFG of basic blocks if availableghc-libcode with registers allocated, additional stacks required and stats for each stage of allocation##None5s#ghc-libTwo 32-bit regs used as a single virtual 64-bit register and the code to set them appropriately#ghc-lib8Two 32-bit regs used as a single virtual 64-bit register#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 weights#ghc-lib%Record that we added a block between from and old.#ghc-libPlace F after block' and change any edges block -> X to F -> X#ghc-lib Return a virtual 64-bit register#ghc-lib7Convert a 64-bit LocalReg into two virtual 32-bit regs.9Used to handle 64-bit "registers" on 32-bit architectures#ghc-lib'Get native code generator configuration#ghc-libLocal state of the desugarer, extended as we lexically descend$ghc-libTemplate Haskell bindings$ghc-lib%To put in pattern-matching error msgs$ghc-lib(See 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 turn$ghc-libGlobal read-only context and state of the desugarer. The statefulness is implemented through Fs.$ghc-lib2See Note [Generating fresh names for FFI wrappers]$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$None?|$ghc-lib Using Cabal?$$$$$$$$$$$$$$$$None 3567><3$ghc-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 file$ghc-libtype or data family$ghc-lib type synonym$ghc-libdata declaration$ghc-libconstructor declaration$ghc-libpattern synonym$ghc-libclass declaration$ghc-libinstance declaration$ghc-libTypes of imports and exports$ghc-libEq/Ord instances compare on the converted HieName, as non-exported names may have different uniques after a roundtrip$ghc-libbound by a pattern match$ghc-libbound by a type signature$ghc-libbound by a hswrapper$ghc-libbound by an implicit variable$ghc-lib%Bound by some instance of given class$ghc-libA direct let binding$ghc-lib0Different contexts under which identifiers exist$ghc-libregular variable$ghc-lib import/export$ghc-lib Value binding$ghc-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 Declaration$ghc-lib Type variable$ghc-lib Record field$ghc-lib/Constraint/Dictionary evidence variable binding$ghc-libUsage of evidence variable$ghc-lib,Information associated with every identifierWe need to include types with identifiers because sometimes multiple identifiers occur in the same span(Overloaded Record Fields and so on)$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 Annotations%ghc-lib'The Haskell types of this node, if any.%ghc-lib%All the identifiers and their details%ghc-libA node annotation%ghc-lib name of the AST node constructor%ghc-libname of the AST node Type%ghc-libSource of node info%ghc-libNodeInfos grouped by source%ghc-lib/Mapping from filepaths to the corresponding AST%ghc-libA list of type arguments along with their respective visibilities (ie. is this an argument that would return F for isVisibleArgFlag?).%ghc-lib(Roughly isomorphic to the original core Type.%ghc-libA flattened version of Type.9See Note [Efficient serialization of redundant type info]%ghc-libtype with constraint: t1 => t2 (see  IfaceDFunTy)%ghc-libGHC builds up a wealth of information about Haskell source as it compiles it. .hie files are a way of persisting some of this information to disk so that external tools that need to work with haskell source don't need to parse, typecheck, and rename all over again. These files contain:a simplified AST3nodes are annotated with source positions and types0identifiers are annotated with scope information+the raw bytes of the initial Haskell source#Besides saving compilation cycles, .hie; files also offer a more stable interface than the GHC API.%ghc-lib Initial Haskell source file path%ghc-libThe module this HIE file is for%ghc-libTypes referenced in the %.9See Note [Efficient serialization of redundant type info]%ghc-lib$Type-annotated abstract syntax trees%ghc-lib"The names that this module exports%ghc-lib'Raw bytes of the initial Haskell source%ghc-libCurrent version of .hie files$ghc-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 signature$ghc-lib,whether or not the binding is in an instanceghc-lib#scope over which the value is boundghc-libspan of entire binding$ghc-libscope in the pattern9 (the variable bound can be used further in the pattern)ghc-lib%rest of the scope outside the patternghc-libspan of entire binding$ghc-libtype of declarationghc-libspan of entire binding$ghc-lib!how did this bind come into beingghc-lib#scope over which the value is boundghc-libspan of the binding site$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%$%%%%%%$$$$$$$$$$$$$$$$$$$%$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$%%None  &5>H&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 F)ghc-lib)return an empty list if this is unhelpful&ghc-libhelps fill in % (with F)ghc-lib)return an empty list if this is unhelpful&ghc-libhelps fill in % (with F)ghc-lib)return an empty list if this is unhelpfulghc-libtype to associate with the node&ghc-libhelps fill in % (with F)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-libTarget platform&ghc-libGenerate CStub or not&ghc-libIds for `unpackCString[Utf8]#`&ghc-lib StaticPtrInfo datacon&ghc-lib StaticPtr datacon&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. &&&&&&&&& &&&&&&&&& Safe-InferredNone&ghc-libFind all the link options in these and the preload packages, returning (package hs lib options, extra library options, other flags)&&&&&&&&NoneD&ghc-libReturns True! if passed string is a statement.'ghc-libReturns True, if passed string has an import declaration.'ghc-libReturns True+ if passed string is an import declaration.'ghc-libReturns True' if passed string is a declaration but  not a splice.&'''&''' Safe-Inferred'''''' Safe-InferredS'ghc-lib%Read target Arch/OS from the settings'ghc-lib&Settings filepath (for error messages)ghc-libRaw settings file contents''''''''''''''''None'ghc-lib TopDir path''''''''None''None''NoneJ''''''''''None'ghc-lib4Initialize STG pretty-printing options from DynFlags''None'(-/>b'ghc-libSimple convert env to a env of the 'InferTaggedBinders pass with no other changes.FFFFFFFF''''''''''''''''''''''''''''''''''''''''None'ghc-libMaximum number of arguments after lambda lifting a recursive function.'ghc-libMaximum number of arguments after lambda lifting non-recursive function.'ghc-libLambda lift even when this turns a known call into an unknown call.''''''''''''None,''NoneW''Noner 'ghc-libA renaming substitution from  s to  s. Like F4, but not maintaining pairs of substitutions. Like , but with the domain being  s instead of entire CoreExpr.'ghc-lib  emptySubst = ' F'ghc-libConstructs a new '% assuming the variables in the given   are in scope.'ghc-libSubstitutes an  " for another one according to the '+ given in a way that avoids shadowing the  ', returning the result and an updated '1 that should be used by subsequent substitutions.'ghc-lib 4substBndrs = runState . traverse (state . substBndr)'ghc-libSubstitutes an occurrence of an identifier for its counterpart recorded in the '.'ghc-libSubstitutes an occurrence of an identifier for its counterpart recorded in the '. Does not generate a debug warning if the identifier to to substitute wasn't in scope.'ghc-libAdd the   to the in-scope set and remove any existing substitutions for it.'ghc-libAdd a substitution for an   to the ': you must ensure that the in-scope set is such that TyCoSubst Note [The substitution invariant] holds after extending the substitution like this. ''''''''''' '''''''''''None +'ghc-lib-The analysis monad consists of the following F components:': Reader-like context. Contains a substitution, info about how how lifted identifiers are to be expanded into applications and configuration options.F '.: Writer output for the resulting STG program.No pure state componentBut wrapping around F2 for generating fresh lifted binders. (The uniqAway approach could give the same name to two different lifted binders, so this is necessary.)'ghc-libWe need to detect when we are lifting something out of the RHS of a recursive binding (c.f. GHC.Stg.Lift.Monad#floats), in which case that binding needs to be added to the same top-level recursive group. This requires we detect a certain nesting structure, which is encoded by ' and '. Although ' will only ever care if the current binding to be lifted (through ') will occur inside such a binding group or not, e.g. doesn't care about the nesting level as long as its greater than 0.'ghc-lib)Environment threaded around in a scoped, Reader-like fashion.'ghc-lib Read-only.'ghc-lib(We need to track the renamings of local  s to their lifted  , because shadowing might make a closure's free variables unavailable at its call sites. Consider: * let f y = x + y in let x = 4 in f x  Here, f9 can't be lifted to top-level, because its free variable x# isn't available at its call site.'ghc-libLifted  s don't occur as free variables in any closure anymore, because they are bound at the top-level. Every occurrence must supply the formerly free variables of the lifted  , so they in turn become free variables of the call sites. This environment tracks this expansion from lifted  s to their free variables. s to  s. Invariant:  /s not present in this map won't be substituted.'ghc-lib uncurry ' . ' = id'ghc-libFlattens an expression in ['] into an STG program, see GHC.Stg.Lift.Monad#floats4. Important pre-conditions: The nesting of opening StartBindinGroups and closing EndBindinGroups is balanced. Also, it is crucial that every binding group has at least one recursive binding inside. Otherwise there's no point in announcing the binding group in the first place and an ASSERT will trigger.'ghc-libWrites a plain F to the output.'ghc-lib&Starts a recursive binding group. See GHC.Stg.Lift.Monad#floats and '.'ghc-lib$Ends a recursive binding group. See GHC.Stg.Lift.Monad#floats and '.'ghc-libLifts a binding to top-level. Depending on whether it's declared inside a recursive RHS (see GHC.Stg.Lift.Monad#floats and '), this might be added to an existing recursive top-level binding group.'ghc-libTakes a binder and a continuation which is called with the substituted binder. The continuation will be evaluated in a ' context in which that binder is deemed in scope. Think of it as a F computation: After the continuation finishes, the new binding won't be in scope anymore.'ghc-libSee '.'ghc-lib Similarly to ', this function takes a set of variables to abstract over, the binder to lift (and generate a fresh, substituted name for) and a continuation in which that fresh, lifted binder is in scope.It takes care of all the details involved with copying and adjusting the binder and fresh name generation.'ghc-libSee '.'ghc-libSubstitutes a binder  occurrence), which was brought in scope earlier by ' / '.'ghc-lib:Whether the given binding was decided to be lambda lifted.'ghc-libReturns an empty list for a binding that was not lifted and the list of all local variables the binding abstracts over (so, exactly the additional arguments at adjusted call sites) otherwise.'ghc-lib Creates an expander function for the current set of lifted binders. This expander function will replace any   by their corresponding   and, in addition, will expand any lifted binders by the former free variables it abstracts over.''''''''''''''''''''''''''''''''''''''''''''''''''''''''None /-'ghc-lib3Strip ticks of a given type from an STG expression.'ghc-libStrip ticks of a given type from an STG expression returning only the expression. '''''''''' ''''''''''None?-R''None 5?-'ghc-libmodule being compiledghc-libhave we run Unarise yet?ghc-libwho produced the STG?''None'(/>?.1''None'(-/>?.h((None2K(ghc-libDependency sort a STG program, and annotate it with free variables The returned bindings: * Are in dependency order * Each StgRhsClosure is correctly annotated (in its extension field) with the free variables needed in the closure * Each StgCase is correctly annotated (in its extension field) with the variables that must be saved across the case(ghc-lib!Dependency analysis on STG terms.Dependencies of a binding are just free variables in the binding. This includes imported ids and ids in the current module. For recursive groups we just return one set of free variables which is just the union of dependencies of all bindings in the group.Implementation: pass bound variables (NestedIds) to recursive calls, get free variables (TopFVs) back. We ignore imported TopFVs as they do not change the ordering but it improves performance (see nameIsExternalFrom call in vars_fvs).((((None /52((None'(4 (ghc-libWe map STG registers onto appropriate CmmExprs. Either they map to real machine registers or stored as offsets from BaseReg. Given a GlobalReg, get_GlobalReg_addr always produces the register table address for it.(ghc-libFixup global registers so that they assign to locations within the RegTable if they aren't pinned for the current target.((((((((((None6(ghc-lib: (ghc-libNo args, not a function(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 F 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 F.(ghc-lib'Get the info table label for a *thunk*. (((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((( ((((((((((((((((((((((((((((((((((((((((((((((((((((((((((None '(>=)ghc-libThe current tick scope. We will assign this to generated blocks.)ghc-libPlaces blocks generated by the given code into a fresh (sub-)scope. This will make sure that Cmm annotations in our scope will apply to the Cmm blocks generated therein - but not the other way around.)ghc-libGenerate code into a fresh tick (sub-)scope and gather generated code)ghc-libAssumes natural alignment. (((((((((((((((((((((((((((((((((((((((()))))))))))))))))))))))))))))))))))))))))))))))(()((())))))))))))()))))))))))))))))))))) (((((())))))))(((((((((((()(()))((((((((((((((!None5G)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 ))))))))))))))))))))))))))))))) )))))))))))))))))))))))))))))))NoneH)ghc-lib1Retrieve cg info for a name if it already exists.()))))))))))))))()))))))))))))))NoneIe)ghc-lib>Make a global definition for the string, and return its label))))))))NoneI)))))))))))))))))))))))))))))))) NoneL*ghc-libaddToMem rep ptr n adds n to the integer pointed-to by ptr.*ghc-libaddToMemE rep ptr n adds n to the integer pointed-to by ptr.*ghc-libEmit a data-segment data block*ghc-libEmit a read-only data block*ghc-libEmit code to add an entry to a now-overwritten pointer to the update remembered set.*ghc-libA bare bones InfoProvEnt for things which don't have a good source location*ghc-lib:Convert source information collected about identifiers in  to entries suitable for placing into the info table provenenance table.*ghc-lib&value of pointer which was overwritten*ghc-lib the thunk5(())************************5********(*******(****))*****NoneO*ghc-libPredicted a pointer would be tagged correctly (GHC will crash if not so no miss case)*ghc-lib2Pass a boolean expr indicating if tag was present.*ghc-libCalled when for `case v of ...` we can avoid entering v based on tag inference information.*ghc-libstaticghc-lib updateableghc-lib Free vars*ghc-lib updateableghc-libFree vars + function*ghc-lib!size of the full header, in bytesghc-libsize of the payload, in bytes ******************************** ********************************NoneR*ghc-libCheck all arguments marked as already tagged for a function are tagged by inserting runtime checks.*ghc-libCheck all required-tagged arguments of a constructor are tagged *at compile time*.*ghc-libCall barf if we failed to predict a tag correctly. This is immensly useful when debugging issues in tag inference as it will result in a program abort when we encounter an invalid call/heap object, rather than leaving it be and segfaulting arbitrary or producing invalid results. We check if either: * A tag is present * Or the object is a 25 (for which zero is the proper tag)****************NoneV/*ghc-libUsed to tell the various mkVirtHeapOffsets functions what kind of header the object has. This will be accounted for in the offsets of the fields returned.*ghc-lib$Return multiple values to the sequelIf the sequel is Return  return (x,y)If the sequel is AssignTo [p,q]  p=x; q=y;*ghc-libemitCall conv fun args# makes a call to the entry-code of fun$, using the call/return convention conv , passing args3, and returning the results to the current sequel.*ghc-lib1Just like mkVirtHeapOffsets, but for constructors*ghc-libJust like mkVirtConstrOffsets, but used when we don't have the actual arguments. Useful when e.g. generating info tables; we just need to know sizes of pointer and non-pointer fields."))))))))))))**********************"********************))))))))))))**"None /]*ghc-lib%The type used in binder positions in Fs.*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 F . 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. F; 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 ?av*ghc-libOptional Stg-to-Stg passes.*ghc-lib Common subexpression elimination*ghc-libLambda lifting closure variables, trading stack/register allocation for heap allocation*ghc-libMandatory unarise pass, desugaring unboxed tuple and sum binders*ghc-lib$Mandatory when compiling to bytecode*ghc-libUseful for building up  getStgToDo*ghc-lib$Spec of what stg-to-stg passes to do*ghc-lib9Should we lint the STG at various stages of the pipeline? ************* *************Noneb*ghc-lib4Initialize STG pretty-printing options from DynFlags**None?b+ghc-lib:A local block label (e.g. identifying a case alternative).*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++Nonec++.None #$5d+ghc-libFinds external references. Remember to remove the names defined by this group of BCOs themselves++++++++++None #$5?d++NoneeG+ghc-lib;Emit top-level tables for HPC and return code to initialise++++None  f9+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.++++++++++++++++++++++++++++++++++++++Nonek<,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)++++,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,++++,Nonel2,ghc-lib,Grab compiler info and cache it in DynFlags.,ghc-lib-Grab assembler info and cache it in DynFlags.,,,,,,,,,,,,)None5lq ,,,,,,,,,,,,,,,,,,,,,,,,,, ,,Nonel,,,,None #$>O(,ghc-lib*Setup the initial typechecking environment,ghc-libRun a F& action in the context of an existing GblEnv.,ghc-libDo it flag is true,ghc-libUpdate the external package state. Returns the second result of the modifier function.This is an atomic operation and forces evaluation of the modified EPS in order to avoid space leaks.-ghc-lib"Update the external package state.This is an atomic operation and forces evaluation of the modified EPS in order to avoid space leaks.-ghc-lib"A convenient wrapper for taking a MaybeErr SDoc a. and throwing an exception if it is an error.-ghc-libDump if the given F 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 F style. However, generally we want all other debugging output to use F style. We F 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-lib(Display a warning if a condition is met.-ghc-lib(Display a warning if a condition is met.-ghc-lib+Display a diagnostic if a condition is met.-ghc-lib,Display a diagnostic in the current context.-ghc-lib(Display a diagnostic in a given context.-ghc-libA variation of -$ that takes a function to produce a  TcRnDsMessage5 given some additional context about the diagnostic.-ghc-libDisplay a diagnostic for the current source location, taken from the F monad.-ghc-lib1Display a diagnostic for a given 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 F= (top-level interface monad) computation inside an existing F; (typecheck-renaming monad) computation by initializing an F based on F..ghc-lib.? can be used when there's no chance that the action will call typecheckIface% when inside a module loop and hence  tcIfaceGlobal..ghc-lib'This is used when we are doing to call typecheckModule on an ModIface, if it's part of a loop with some other modules then we need to use their IORef TypeEnv vars when typechecking but crucially not our own..ghc-lib.Initialize interface typechecking, but with a 0' 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 throws an error if the computation failsIt's used for lazily type-checking interface signatures, which is pretty benign.&See Note [Masking exceptions in forkM].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 0, 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.)0ghc-libRename just the exports of a ?. Useful when we're doing shaping prior to signature merging.00000000None00None\0ghc-libOptions for the demand analysis0ghc-libUse strict dictionaries0ghc-libUse strict dictionaries0ghc-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])000000000000None00None0000None?L0ghc-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.0ghc-libLocate a plugin module requested by the user, for a compiler plugin. This consults the same set of exposed packages as 0 , unless -hide-all-plugin-packages or -plugin-package are specified.0ghc-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").0ghc-libConstructs the filename of a .o file for a given source file. Does not! check whether the .o file exists0ghc-libConstructs the filename of a .hi file for a given source file. Does not" check whether the .hi file exists7000000000000000000070000000000000000000None &?.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.0ghc-libWrite interface file0ghc-lib readIface tries just the one file.Failed err  => file not found, or unreadable, or illegible Succeeded iface  = successfully found and parsed0ghc-lib'Read binary interface, and print it out0ghc-libShow a ModIface but don't display details; suitable for ModIfaces stored in the EPT.0ghc-libShow a ModIface+The UnitState is used to pretty-print units0ghc-lib/Reason for loading the iface (used for tracing)ghc-lib=The unique identifier of the on-disk module we're looking forghc-libThe *actual* module we're looking for. We use this to check the consistency of the requirements of the module we read out.ghc-lib Looking for .hi-boot or .hi file $$$$$$$$.0000000000000000000000000000000000.000000000000None >?X1ghc-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.1ghc-libGet a I that includes mappings for all vars free in the given type. Useful when tidying open types.1ghc-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.1ghc-lib mkWrapperName ref what nameBase8See Note [Generating fresh names for ccall wrapper] for ref 's purpose.+1:9876543 ,0000000000000000000000000000000000001111111111111111111111111111111111111111111111 :987654310000111110000000000000000000000000000011111111111111111111111111110,1001111+11111111 None ?o1ghc-libSee Note [The ZonkEnv] Confused by zonking? See Note [What is zonking?] in GHC.Tc.Utils.TcMType.%12111111111111111111111111111111%11112111111111111111111111111111None#?q1ghc-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 => 1 is supposed to instantiate just the outer type variable and constraint1ghc-libGiven ty::forall k1 k2. k, instantiate all the invisible forall-binders returning ty kk1  kk2 :: k[kk1k1, kk2k1]1ghc-libUsed only in *types*1ghc-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.1ghc-libGive fresh uniques to a bunch of TyVars, but they stay as TyVars, rather than becoming TcTyVars Used in &, and 11ghc-libGive fresh uniques to a bunch of CoVars Used in "GHC.Tc.Instance.Family.newFamInst"1ghc-libwhy do we need this?ghc-libname of the methodghc-lib)types with which to instantiate the class1ghc-lib%How to instantiate the type variablesghc-libType to instantiateghc-lib1Result (type vars, preds (incl equalities), rho)1ghc-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#//011111111111111111111111111111#1111111//11111111111111111011111None1ghc-lib1 looks for just one function arrow, returning an uninstantiated sigma-type.Invariant: the returned argument type has a fixed RuntimeRep as per Note [Fixed RuntimeRep] in GHC.Tc.Utils.Concrete. See Note [Return arguments with a fixed RuntimeRep].1ghc-libLike 1, but used when you have an "actual" type, for example in function application.INVARIANT: the returned arguemnt types all have a fixed RuntimeRep in the sense of Note [Fixed RuntimeRep] in GHC.Tc.Utils.Concrete. See Note [Return arguments with a fixed RuntimeRep].1ghc-libUse this function to split off arguments types when you have an "expected" type.*This function skolemises at each polytype.Invariant: this function only applies the provided function to a list of argument types which all have a fixed RuntimeRep in the sense of Note [Fixed RuntimeRep] in GHC.Tc.Utils.Concrete. See Note [Return arguments with a fixed RuntimeRep].1ghc-lib Variant of 1 that takes an ExpType2ghc-libChecks (TYVAR-TV), (COERCION-HOLE) and (CONCRETE) of Note [Unification preconditions]; returns True if these conditions are satisfied. But see the Note for other preconditions, too.2ghc-lib-Breaks apart a function kind into its pieces./ghc-lib'If present, the thing that has type ty11ghc-lib)See Note [Herald for matchExpectedFunTys]ghc-libThe thing with type TcSigmaTypeghc-libTotal number of value args in the call, and types of values args to which function has been applied already (reversed) Both are used only for error messages)ghc-libType to analyse: a TcRhoType1ghc-lib)See Note [Herald for matchExpectedFunTys]ghc-libthe thing with type TcSigmaType1ghc-libActualghc-libExpected1ghc-libThe wrapper has type: spec_ty ~> expected_ty See Note [Skolemisation] for the differences between tcSkolemiseScoped and tcSkolemise1ghc-libThe wrapper has type: spec_ty ~> expected_ty See Note [Skolemisation] for the differences between tcSkolemiseScoped and tcSkolemise2ghc-libtype, only for errorsghc-libn: number of desired arrowsghc-lib fun_ kindghc-lib-co :: fun_kind ~ (arg1 -> ... -> argn -> res)!/////1111111111111111111122222222!111111111/11211//12/22/1111211222None #$"2ghc-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.2ghc-libIs a particular   representable by Typeable.?. These exclude type families and polytypes.2222None2ghc-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 printer2ghc-libTerm reconstruction"Given a pointer to a heap object () and its type, build a 2 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 2s. 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 23 for an overview of how type reconstruction works.2ghc-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] = _2ghc-lib&How many times to recurse for subtermsghc-lib Force thunksghc-lib!Type of the object to reconstructghc-libObject to reconstruct2ghc-lib&How many times to recurse for subtermsghc-libType to refineghc-lib Refine the type using this value 22222222222222222222222222222222 22222222222222222222222222222222None ?52ghc-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].2ghc-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 2 on the type forall b. C (Either a b) to catch the nested forall' and create a suitable error message. 2 returns I 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.2ghc-libA common way to invoke 2.2ghc-libChecks to see if we need to warn for -Wunused-record-wildcards or -Wredundant-record-wildcards2ghc-libMake a map from selector names to field labels and parent tycon names, to be used when reporting unused record fields.2ghc-lib?Ensure that a boxed or unboxed tuple has arity no larger than I.2ghc-lib8Ensure that a constraint tuple has arity no larger than I.2ghc-libThe error msg if the signature is not allowed to contain manually written inferred variables.%2222222222222222222222222222222222222%2222222222222222222222222222222222222None2ghc-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.(IIFIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII'&#%$IIIIIIIIIIIIIIIIIIIIIQRIIISTIIIIIIIIIIJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJUJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJdJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL"! LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOOOOOOOOOOOOOOOOOOOOFOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSFSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT TTTTTTTTTTT T TTTTTTTTTTTTTTTT TTTUUUUUUUUUUUUUUUUUUU U UUUUUU UU UUUU UU UUUUUUUUUUUUUUUUUUUU UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUIUUUUUUUUUUUUUUUFUUUUUUUUUUUUUUVVVVVVVVVVVVVVVVVVVVVVVVVVVVV  VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV VV VVWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXF FIXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYY Y Y Y YY YY YYY YY YYYYYYYYY YYYYY YYY Y YYYYYYYY YYYYYYYYYY YY YY Y YYYYYYYYY YYYYYYYYYYIYYYYYYYYYYYYYYYZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ ZZZZZZZZZZZZZZZ ZZZZ ZZZZZZ ZZZZZZZZZZZZZZZZ ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[F[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[ [[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[\\\\\\\\\ \\\\\ \\\\\\\\\\\\\\\\\\F\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\ \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\]]]]]]] ]] ]] ]]]]] ] ]]]]I ]] ]] ]]]]]]F]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]] ]]]]]]^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^___________________________________________________________________________________________I_____________________________________````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaFaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbcccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc cccccccccccccccccccccccccccccccccccccIcccccccccccccccccccccccccccccccddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddIdddddddddddddFFdddddddddeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeIIIIIII2         2None%5$2ghc-libWhich unfoldings to expose2ghc-libtrim off the arity, one-shot-ness, strictness etc which were retained for the benefit of the code generator2ghc-libAre rules exposed or not?2ghc-lib?Options for generated static pointers, if enabled (/= Nothing).2ghc-libDon't expose unfoldings2ghc-libOnly expose required unfoldings2ghc-libExpose all unfoldings222222222222222222222222222222None$2222None% 2ghc-libCreate a function that converts Bignum literals into their final CoreExpr222222&None &'(+2ghc-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 TcCoercion2ghc-libLike 2, but returns the arguments back if there is no data family to unwrap. Returns a Representational coercion2ghc-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.2ghc-lib2 gets rid of top-level newtypes, potentially looking through newtype  instances.It is only used by the type inference engine (specifically, when solving representational equality), and hence it is careful to unwrap only if the relevant data constructor is in scope. That's why it gets a GlobalRdrEnv argument.It is careful not to unwrap data/newtype instances if it can't continue unwrapping. Such care is necessary for proper error messages.It does not look through type families. It does not normalise arguments to a tycon.If the result is Just ((gres, co), rep_ty), then co : ty ~R rep_ty gres are the GREs for the data constructors that had to be in scope2ghc-libReport a list of injectivity errors together with their source locations. Looks only at one equation; does not look for conflicts *among* equations.2ghc-libReport error message for a pair of equations violating an injectivity annotation. No error message if there are no branches.2ghc-lib(Type family for which we generate errorsghc-lib1Currently checked equation (represented by axiom)ghc-libInjectivity annotation 2222222222 2222222222None %1d2ghc-libReport unsolved goals as errors or warnings. We may also turn some into deferred run-time errors if `-fdefer-type-errors` is on.2ghc-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)2ghc-libReport all unsolved goals as warnings (but without deferring any errors to run-time). See Note [Safe Haskell Overlapping Instances Implementation] in  GHC.Tc.Solver3ghc-libIf the e is a type mismatch between an actual and an expected type, return the actual and expected types (in that order)./Prefer using this over manually inspecting the e datatype if you just want this information, as the datatype itself is subject to change across GHC versions.3ghc-libRetrieves all "expected"/"actual" messages from a e.&Prefer using this over inspecting the e datatype if you just need this information, as the datatype itself is subject to change across GHC versions.222333222333None33ghc-lib3 returns (True, fixity) if it finds a e 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).3ghc-libLook up the fixity of an occurrence of a record field selector. We use e 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).333333333333None%> 3ghc-libResult of looking up an occurrence that might be an ambiguous field.3ghc-libOccurrence picked out a single name, which may or may not belong to a field (or might be unbound, if an error has been reported already, per Note [ Unbound vs Ambiguous Names ]).3ghc-libOccurrence picked out two or more fields, and no non-fields. For now this is allowed by DuplicateRecordFields in certain circumstances, as the type-checker may be able to disambiguate later.3ghc-libLook up an occurrence of a field in record construction or pattern matching (but not update). When the -XDisambiguateRecordFields flag is on, take account of the data constructor name to disambiguate which field to use.See Note [DisambiguateRecordFields] and Note [NoFieldSelectors].3ghc-libLook up an occurrence of a field in a record update, returning the selector name..Unlike construction and pattern matching with -XDisambiguateRecordFields (see 3), there is no data constructor to help disambiguate, so this may be ambiguous if the field is in scope multiple times. However we ignore non-fields in scope with the same name if -XDisambiguateRecordFields: is on (see Note [DisambiguateRecordFields for updates]).!Here a field is in scope even if NoFieldSelectors was enabled at its definition site (see Note [NoFieldSelectors]).3ghc-lib,Used in export lists to lookup the children.3ghc-lib5Specialised version of msum for RnM ChildLookupResult3ghc-lib Look up a  % used as a variable in an expression.This may be a local variable, global variable, or one or more record selector functions. It will not return record fields created with the NoFieldSelectors) extension (see Note [NoFieldSelectors]).If the name is not in scope at the term level, but its promoted equivalent is in scope at the type level, the lookup will succeed (so that the type-checker can report a more informative error later). See Note [Promotion].3ghc-lib,Lookup a name in relation to the names in a 33ghc-lib,Lookup a name in relation to the names in a 33ghc-lib:description of thing we're looking up, like "type family"3ghc-lib:description of thing we're looking up, like "type family"3ghc-libThe standard nameghc-libPossibly a non-standard name Lookup a Name that may be subject to Rebindable Syntax (RS).8When RS is off, just return the supplied (standard) NameWhen RS is on, look up the OccName of the supplied Name; return what we find, or the supplied Name if there is nothing in scope3ghc-libThe standard nameghc-libPossibly a non-standard name<333333333333333333333333333333333333333333333333333333333333<333333333333333333333333333333333333333333333333333333333333NoneA3ghc-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.3ghc-libThe scoped6 tyvars of the instance Why scoped? See bind_me in 3ghc-libMaps class tyvars to their instance types See Note [Matching in the consistent-instantiation check]333333333333333333333333333333333333333333333333None&5<JX4ghc-lib"Remove inert constraints from the e?, for use when a typechecker plugin wishes to discard a given.4ghc-lib,Looks up a family application in the inerts.4ghc-libLook up a dictionary inert.4ghc-libLook up a solved inert.4ghc-libThis variant of 4 will immediatley fail upon encountering an insoluble ct. See Note [Speeding up valid hole-fits]. Its one usage site does not need the ev_binds, so we do not return them.4ghc-lib-This can deal only with equality constraints.4ghc-lib A variant of 4 that takes and returns an e for later resumption of the 3 session.4ghc-libEqualities only4ghc-lib+Good for both equalities and non-equalities4ghc-lib Make a new   of the given type, bound (in the monad's EvBinds) to the given term4ghc-lib-Emit a new Wanted equality into the work-list4ghc-libCreate a new Wanted constraint holding a coercion hole for an equality between the two types at the given  .4ghc-libSee Note [Pattern match warnings with insoluble Givens] above.5ghc-lib4Return True if the Wanteds are soluble, False if not5ghc-libNormalise a type as much as possible using the given constraints. See Note [tcNormalise]./55555555555555555555555555555555555555555555555/555None<Z5ghc-libDo validity checks on a type family equation, including consistency with any enclosing class instance head, termination, and lack of polytypes.5ghc-lib.Checks that an associated type family default:  Cls cls_ty_1 ... cls_ty_m (TC tc_arg_1 ... tc_arg_n) where ... 5 corresponds to cls_ty_1 ... cls_ty_m.5 corresponds to TC.5 corresponds to tc_arg_1 ... tc_arg_n.See &Note [DerivEnv and DerivSpecMechanism] in GHC.Tc.Deriv.Utils for a more in-depth explanation, including the relationship between 55 and 55.A 5? value can be seen as a more structured representation of the  denv_inst_tys in a DerivEnv , as the  denv_inst_tys is equal to dit_cls_tys ++ [  dit_tc dit_tc_args]?. Other parts of the instance declaration can be found in the DerivEnv. For example, the Cls* in the example above corresponds to the denv_cls field of DerivEnv./Similarly, the type variables that appear in a 5+ value are the same type variables as the denv_tvs in the parent DerivEnv. Accordingly, if we are inferring an instance context, the type variables will be  , skolems. Otherwise, they will be ordinary  s. See Note [Overlap and deriving] in GHC.Tc.Deriv.Infer.5ghc-lib,Other arguments to the class except the last5ghc-libType constructor for which the instance is requested (last arguments to the type class)5ghc-lib!Arguments to the type constructor5ghc-libThe representation tycon for 57 (for data family instances). Otherwise the same as 5.5ghc-libThe representation types for 57 (for data family instances). Otherwise the same as 5.5ghc-libThe cached results of instantiating each data constructor's field types using S data_con 5 . See 2Note [Instantiating field types in stock deriving].This field is only used for stock-derived instances and goes unused for newtype-derived instances. It is put here mainly for the sake of convenience.5ghc-libA declarative description of an auxiliary binding that should be generated. See Note [Auxiliary binders]8 for a more detailed description of how these are used.5ghc-lib$tag2con:: Given a tag, computes the corresponding data constructor5ghc-lib$maxtag: The maximum possible tag value among a data type's constructors5ghc-lib$t: The DataType representation for a Data instance5ghc-lib$c: The Constr representation for a Data instance5ghc-libTake a e of 5s and generate the code for auxiliary bindings based on the declarative descriptions in the supplied 5s. See Note [Auxiliary binders].5ghc-libProduces a function binding. When no equations are given, it generates a binding of the given arity and an empty case expression for the last argument that it passes to the given function to produce the right-hand side.5ghc-libProduces a function binding. When there are no equations, it generates a binding with the given arity that produces an error based on the name of the type of the last argument.5ghc-lib$getPossibleDataCons tycon tycon_args returns the constructors of tycon0 whose return types match when checked against  tycon_args.7See Note [Filter out impossible GADT data constructors]5ghc-lib;Look up a data constructor's instantiated field types in a 5. See 2Note [Instantiating field types in stock deriving].5ghc-lib5 tycon arg_tys' constructs a cache that maps each of tycon's data constructors to their field types, with are to be instantiated with arg_tys. See 2Note [Instantiating field types in stock deriving].5ghc-lib#Apply a substitution to all of the  s contained in a 5. See 2Note [Instantiating field types in stock deriving]' for why we need to substitute into a 5 in the first place.5ghc-lib Zonk the  s in a 5 value to  s. See Note [What is zonking?] in GHC.Tc.Utils.TcMType.This is only used in the final zonking step when inferring the context for a derived instance. See Note [Overlap and deriving] in GHC.Tc.Deriv.Infer.&55555555555555555555555555555555555555&55555555555555555555555555555555555555None ?p#6ghc-libDoes not contain variable6ghc-libThe variable itself6ghc-lib$The variable itself, contravariantly6ghc-lib Function type6ghc-libTuple type. The [a]= is the result of folding over the arguments of the tuple.6ghc-lib2Type app, variable only in last argument. The two  ,s are the function and argument parts of  fun_ty arg_ty, respectively.6ghc-lib.Type app, variable other than in last argument6ghc-lib Forall type6ghc-libVariable to look forghc-lib How to foldghc-libType to process55666666666666665566666666666666None ?p6666666666666666None 06ghc-lib A list of 6 constraints to simplify when inferring a derived instance's context. For the stock, newtype, and via- deriving strategies, these will consist of 6 s, and for DeriveAnyClass, these will consist of 60s. Here is an example to illustrate the latter: 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 6s, one for each method: [ SubTypePredSpec { stps_ty_actual = forall y. (Show (Quux q), Ix y) => Quux q -> y -> String , stps_ty_expected = forall b. (Ix b) => Quux q -> b -> String , stps_ty_origin = DerivClauseCtxt } , SubTypePredSpec { stps_ty_actual = Ord (Quux q) => Quux q -> Quux q -> Bool , stps_ty_expected = Eq (Quux q) => Quux q -> Quux q -> Bool , stps_ty_origin = DerivClauseCtxt } ] (Note that the type variable q is bound by the data type Quux , and thus appears free in the 6s and 6s.)See ?Note [Gathering and simplifying constraints for DeriveAnyClass] in GHC.Tc.Deriv.Infer! for an explanation of how these 6/s are used to compute implication constraints.6ghc-libA 6 specifies a constraint to emitted when inferring the instance context for a derived instance in .6ghc-lib An ordinary 6 that directly stores a  , which will be emitted as a wanted constraint in the constraint solving machinery. This is the simple case, as there are no skolems, metavariables, or given constraints involved.6ghc-lib A special 6 that is only used by DeriveAnyClass. This will check if stps_ty_actual0 is a subtype of (i.e., more polymorphic than) stps_ty_expected in the constraint solving machinery, emitting an implication constraint as a side effect. For more details on how this works, see ?Note [Gathering and simplifying constraints for DeriveAnyClass] in GHC.Tc.Deriv.Infer.6ghc-lib"The constraint to emit as a wanted6ghc-libThe origin of the constraint6ghc-lib(Whether the constraint is a type or kind6ghc-lib#The actual type. In the context of DeriveAnyClass-, this is the default method type signature.6ghc-lib%The expected type. In the context of DeriveAnyClass., this is the original method type signature.6ghc-libThe origin of the constraint6ghc-lib-Describes how to generate instance bindings (6)) and associated type family instances (6+) for a particular stock-derived instance.6ghc-libDescribes how to generate instance bindings for a stock-derived instance."This function takes two arguments: : the source location where the instance is being derived. This will eventually be instantiated with the 6 field of a 6.5: information about the argument types to which a class is applied in a derived instance. This will eventually be instantiated with the 6 field of a 6."This function returns four things: e e6: The derived instance's function bindings (e.g., !compare (T x) (T y) = compare x y)[e e]: A list of instance specific signatures/pragmas. Most likely INLINE pragmas for class methods.e 5: Auxiliary bindings needed to support the derived instance. As examples, derived e and e+ instances sometimes require top-level con2tag functions. See Note [Auxiliary binders] in GHC.Tc.Deriv.Generate.[]: A list of Names for which -Wunused-binds should be suppressed. This is used to suppress unused warnings for record selectors when deriving e, e, or Generic . See +Note [Deriving and unused record selectors].6ghc-libDescribes how to generate associated type family instances for a stock-derived instance. This function takes the same arguments as the 6 function but returns a list of s instead. Generating type family instances is done separately from 6 since the type family instances must be generated before the instance bindings can be typechecked. See Note [Staging of tcDeriving] in  GHC.Tc.Deriv.6ghc-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.6ghc-libWhether GHC is processing a deriving. clause or a standalone deriving declaration.6ghc-lib'InferContext mb_wildcard is either:A deriving clause (in which case  mb_wildcard is F).A standalone deriving declaration with an extra-constraints wildcard as the context (in which case  mb_wildcard is I loc, where loc$ is the location of the wildcard.GHC should infer the context.6ghc-lib6 theta. is a standalone deriving declaration, where theta& is the context supplied by the user.6ghc-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.6ghc-lib"Standard" classes6ghc-lib GeneralizedNewtypeDeriving6ghc-lib DeriveAnyClass6ghc-lib  DerivingVia6ghc-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].6ghc-libHow to generate the instance bindings and associated type family instances.6ghc-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].6ghc-libThe newtype rep type.6ghc-lib0All arguments to the class besides the last one.6ghc-libThe last argument to the class.6ghc-libThe via type6ghc-libContains all of the information known about a derived instance when determining what its EarlyDerivSpec should be. See &Note [DerivEnv and DerivSpecMechanism].6ghc-lib Is this an overlapping instance?6ghc-libUniversally quantified type variables in the instance. If the  denv_ctxt is 6, these will be   skolems. If the  denv_ctxt is 6, these will be ordinary   s. See Note [Overlap and deriving] in GHC.Tc.Deriv.Infer.&All type variables that appear in the 6, 6, 6, and 6 should come from 6.6ghc-lib-Class for which we need to derive an instance6ghc-libAll arguments to 6 in the derived instance.6ghc-lib6 theta for standalone deriving (where theta( is the context of the instance). 6 for deriving clauses, or for standalone deriving that uses a wildcard constraint. See %Note [Inferring the instance context].6ghc-libThe e used to skolemise the denv_tvs in the case where the 6 is 6.6ghc-libI if user requests a particular deriving strategy. Otherwise, F.6ghc-lib0To avoid having to manually plumb everything in 6" throughout various functions in  GHC.Tc.Deriv and GHC.Tc.Deriv.Infer , we use 6#, which is a simple reader around F.6ghc-lib4Is GHC processing a standalone deriving declaration?6ghc-libIs GHC processing a standalone deriving declaration with an extra-constraints wildcard as the context? (e.g., !deriving instance _ => Eq (Foo a))6ghc-libReturn ! if processing with a standalone deriving declaration or  if processing a deriving clause.6ghc-lib6 wc returns e if wc is F, and e if wc is e. Useful for error-reporting.6ghc-libSet the 6 in a 6.6ghc-lib Zonk the  s in a 6 to  s. See Note [What is zonking?] in GHC.Tc.Utils.TcMType.This is only used in the final zonking step when inferring the context for a derived instance. See Note [Overlap and deriving] in GHC.Tc.Deriv.Infer.6ghc-lib Convert a 6 to its corresponding e.6ghc-lib Zonk the  s in a 6 to  s. See Note [What is zonking?] in GHC.Tc.Utils.TcMType.This is only used in the final zonking step when inferring the context for a derived instance. See Note [Overlap and deriving] in GHC.Tc.Deriv.Infer.6ghc-libBuild a list of 6s, using the supplied I and \ values for each  .6ghc-lib"Capture wanted constraints from a 6.6ghc-lib9Used to inform error messages as to whether we are in a deriving clause or a standalone deriving declarationghc-lib0The specs from which constraints will be created66666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666None #$,ghc-libSort by size uses as a measure for relevance the sizes of the different types needed to instantiate the fit to the type of the hole. This is much quicker than sorting by subsumption, and gives reasonable results in most cases.,ghc-libtcFilterHoleFits filters the candidates by whether, given the implications and the relevant constraints, they can be made to match the type by running the type checker. Stops after finding limit matches.,ghc-libReports whether first type (ty_a) subsumes the second type (ty_b), discarding any errors. Subsumption here means that the ty_b can fit into the ty_a, i.e. `tcSubsumes a b == True` if b is a subtype of a.,ghc-libTakes a list of free variables and restores any Flexi type variables in free_vars after the action is run.,ghc-libA tcSubsumes which takes into account relevant constraints, to fix trac #14273. This makes sure that when checking whether a type fits the hole, the type has to be subsumed by type of the hole as well as fulfill all constraints on the type of the hole.6ghc-lib.Checks whether a MetaTyVar is flexible or not.,ghc-lib%How many we should output, if limitedghc-libThe hole to filter againstghc-libThe type to check for fits and a list of refinement variables (free type variables in the type) for emulating additional holes.ghc-lib$The candidates to check whether fit.ghc-libWe return whether or not we stopped due to hitting the limit and the fits we found.,ghc-libThe hole to check againstghc-libThe type of the hole to check against (possibly modified, e.g. refined with additional holes for refinement hole-fits.)ghc-libThe type to check whether fits.ghc-lib;Whether it was a match, and the wrapper from hole_ty to ty.,ghc-libThe tidy_env for zonkingghc-lib!Enclosing implications for givensghc-libThe unsolved simple constraints in the implication for the hole.#'&%$#"! ,666,,,,,,,,,,,,,66#,,,,6,,,,,,,6666,,,"! '&%$#None6666+None ?q6ghc-libProcess Import Decls. See e for a description of what the return types represent. Note: Do the non SOURCE ones first, so that we get a helpful warning for SOURCE ones that are unnecessary6ghc-libRename raw package imports6ghc-libRename raw package imports6ghc-libCalculate the H> induced by an import of a particular interface, but without H. 6666666666666776666 66766667666None77777777None  ?7ghc-libF 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!)7777None /? 7ghc-libShould GHC warn if a quantified type variable goes unused? Usually, the answer is "yes", but in the particular case of binding e$, we avoid emitting warnings. See 8Note [Suppress -Wunused-foralls when binding LHsQTyVars].7ghc-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 7#, 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 7 is used instead. See also ,Note [Pattern signature binders and scoping] in  GHC.Hs.Type.7ghc-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.7ghc-libCreate new renamed type variables corresponding to source-level ones. Duplicates are permitted, but will be removed. This is intended especially for the case of handling the implicitly bound free variables of a type signature.7ghc-libFilter out any type and kind variables that are already in scope in the the environment's LocalRdrEnv. Note that this includes named wildcards, which look like perfectly ordinary type variables at this point.7ghc-lib7 finds the type/kind variables of a HsType/HsKind. It's used when making the forall6s explicit. See Note [Kind and type-variable binders]7ghc-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].7ghc-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.7ghc-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].7ghc-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.7ghc-libI _ => an associated type decl4777777777777777777777777777777777777777777777777777747777777777777777777777777777777777777777777777777777None#&5?7777777777777777777777777777777777777777None -33333333777777777777777777777777777733333333None ?7ghc-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 already77777777None.ghc-lib/Rename a splice pattern. See Note [rnSplicePat]7ghc-libThe splice data to be logged7ghc-liboutputs splice information for 2 flags which have different output formats: `-ddump-splices` and `-dth-dec-file`....77777777777..7..7777777777None -?2'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.''''''''None?L7ghc-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 (e). 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.7ghc-libTypecheck a signature  under the assumption that we have instantiated it under some implementation (recorded in K?) and want to check if the implementation fills the signature.0This needs to operate slightly differently than 7 because (1) we have a 0, 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&&&&&&&00077777770007777&&&&&&&777None &/?7ghc-lib'A description of whether something is adata or newtype (7) data instance or newtype instance (7) data family (8)/At present, this data type is only consumed by 8.8ghc-lib1Describes the kind expected in a certain context.8ghc-liba specific kind8ghc-libany kind will do8ghc-libsomething of the form TYPE _8ghc-libTypecheck a deriving strategy. For most deriving strategies, this is a no-op, but for the via* strategy, this requires typechecking the via type.8ghc-lib%Type-check a visible type application8ghc-libSkolemise the es in an e with the supplied e.8ghc-libBring into scope the binders of a PolyTcTyCon Used 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.8ghc-libSpecialised version of e, but with empty WantedConstraints, so no filtering is needed i.e. kindGeneraliseAll = kindGeneralizeSome emptyWC8ghc-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.TyCl8ghc-lib2Checks that the result kind of a class is exactly  Constraint<, rejecting type synonyms and type families that reduce to  Constraint . See #16826.8ghc-libMake an appropriate message for an error in a function argument. Used for both expressions and types.8ghc-lib3Add a "In the data declaration for T" or some such.8ghc-libThe deriving strategyghc-libThe typechecked deriving strategy and the tyvars that it binds (if using e).8ghc-libof the thing being checkedghc-lib What sort of   is being checkedghc-libBinders in the headerghc-libThe result kindghc-libA suitably-kinded TcTyCon777888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888877788888888888None8ghc-libFind the location of the top-level context of a HsType. For example:  forall a b. (Eq a, Ord b) => blah ^^^^^^^^^^^^^  If there is none, return Nothing8ghc-lib0If there are no wildcards, return a LHsSigWcType+)*;>==<EDCBA@?FONMLKJIHG;*)8888888888888888888None ?S8ghc-lib A variant of tcPat that takes a custom origin8ghc-libatternsghc-libtypes of the patternsghc-libchecker for the body8ghc-lib(origin to use if the type needs inst'ing 88888888888 88888888888Noneԩ88None ?888888888888None 5F8ghc-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. 888888888 888888888None ޞ9ghc-lib For a module modname of type e, determine the list of extra "imports" of other requirements which should be considered part of the import of the requirement, because it transitively depends on those requirements by imports of modules from other packages. The situation is something like this:unit p where signature X signature Y import Xunit q where dependency p[X=,Y=] signature A signature BAlthough q's B does not directly import A, we still have to make sure we process A first, because the merging process will cause B to indirectly import A. This function finds the TRANSITIVE closure of all such imports we need to make.9ghc-libLike implicitRequirements', but returns either the module name, if it is a free hole, or the instantiated unit the imported module is from, so that that instantiated unit can be processed and via the batch mod graph (rather than a transitive closure done here) all the free holes are still reachable.9ghc-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.9ghc-libTop-level driver for signature instantiation (run when compiling an hsig file.)9ghc-libTop-level driver for signature merging (run after typechecking an hsig file).9ghc-libGiven a local ), merge all inherited requirements from L) into this signature, producing a final F? that matches the local signature and all required signatures.9ghc-libTop-level driver for signature instantiation (run when compiling an hsig file.)9ghc-libGiven G, instantiate a  from the indefinite library to use the actual implementations of the relevant entities, checking that the implementation matches the signature. 999999999 999999999None ?889889Noneߦ9ghc-libConstruct default instances for any associated types that aren't given a user definition Returns [] or singleton 999999999999 999999999999None#&'(/?9ghc-lib:Count visible and invisible value arguments in a list of 9 arguments.9ghc-libCounts the number of invisible term-level arguments applied by an e7. Precondition: this wrapper contains no abstractions.09999999999999999999999999999999999999999999999990999999999999999999999999999999999999999999999999None#$-?v9ghc-lib Case contextghc-libType of scrutineeghc-libThe case alternativesghc-lib!Type of the whole case expression,,9999999999999999,9,999999999999999None 99None'(/?999999None /?,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.,,,,,,,,,,,,99,,,,,,,,,,,,99None99None &9ghc-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.999999999999999999999999999999999999None 9ghc-lib%Stuff needed to process a datatype's  `deriving` clauses9ghc-libThe data tycon for normal datatypes, or the *representation* tycon for data families9ghc-lib4Variables that scope over the deriving clause. See !Note [Scoped tyvars in a TcTyCon] in GHC.Core.TyCon.9ghc-lib error context99999999999999None &(899:::::::::::::::::99:::8::::::::None ?u: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.9::9::None 5>?:ghc-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.:ghc-libWe represent the case where there is no hole without a function from S, like this, because sometimes we have nothing to put in the hole and so want to be sure there is in fact no hole.:ghc-libThe patterns for an equation NB: We have already applied decideBangHood3 to these patterns. See Note [decideBangHood] in GHC.HsToCore.Utils:ghc-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.:ghc-libWhat to do after match:ghc-libRun a $ action inside the F monad.:ghc-libRun a $ action inside the e monad.:ghc-libRun a $& action in the context of an existing K:ghc-lib0Get the current pattern match oracle state. See $.:ghc-libSet the pattern match oracle state within the scope of the given action. See $.:ghc-libEmit a diagnostic for the current source location. In case the diagnostic is a warning, the latter will be ignored and discarded if the relevant ] is not set in the DynFlags. See Note [Discarding Messages] in .:ghc-libIssue an error, but return the expression for (), so that we can continue reporting errors.:ghc-libThe COMPLETE pragmas that are in scope.:ghc-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.:ghc-libSee ..:ghc-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.:ghc-libheaderghc-libinformation to outputghc-lib expression  $$$$$,,,,--:::::::::::::::::::::::::::::::::::::::::::::::::$::::: ,,,, ::::::::::--::::::::$$$$::::::::::::::::::::::::::None":ghc-libGenerate a fresh   of a given type:ghc-lib=All warning flags that need to run the pattern match checker.:ghc-libCheck whether the redundancy checker should run (redundancy only):ghc-libCheck whether the exhaustiveness checker should run (exhaustiveness only):ghc-lib6Check whether unnecessary bangs should be warned about:ghc-libDenotes whether an exhaustiveness check is supported, and if so, via which ] it's controlled. Returns F if check is not supported.:ghc-libCheck whether any part of pattern match checking is enabled for this e (does not matter whether it is the redundancy check or the exhaustiveness check).:ghc-lib4Return True when any of the pattern match warnings (:) are enabled, in which case we need to run the pattern match checker. :::::::::: ::::::::::None& :ghc-lib)See Note [Case split inhabiting patterns]:ghc-libA high-level pattern-match constraint. Corresponds to  from Figure 3 of the LYG paper.:ghc-libA type constraint "T ~ U".:ghc-lib PhiCoreCt x e encodes "x ~ e", equating x with the S e.:ghc-libPhiConCt x K tvs dicts ys encodes K @tvs dicts ys <- x , matching x against the f application K @tvs dicts ys , binding tvs, dicts and possibly unlifted fields ys in the process. See Note [Strict fields and variables of unlifted type].:ghc-libPhiNotConCt x K! encodes "x D K", asserting that x can't be headed by K.:ghc-lib PhiBotCt x encodes "x ~ E", equating x to E. by K.:ghc-libPhiNotBotCt x y! encodes "x D E", asserting that x can't be E.:ghc-libAdd a bunch of : s to all the  s. Lifts f over many .:ghc-libaddPmCtsNablas for a single PmCt.:ghc-libTest if any of the s is inhabited. Currently this is pure, because we preserve the invariant that there are no uninhabited s. But that could change in the future, for example by implementing this function in terms of notNull  $ generateInhabitingPatterns 1 ds.:ghc-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.::::::::::::::::::::::::::::::None '(5>:ghc-lib*Coverage checking action. Can be composed f or f.::::::::::::::None ?;ghc-libUse -XStrict to add a ! or remove a ~ See Note [decideBangHood];ghc-lib Scrutineeghc-lib Type of expghc-lib,Alternatives (bndrs *include* tyvars, dicts);ghc-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 binds;ghc-libOriginal pattern5::::::::::::::::::::;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5::::::::::::::::;;;;;;;;;;:;;;;;;;;;;;;;;;;;;;:::;;;;None;;;;;;;;;;None ?;;None y;ghc-libPost-typechecker, the F field of an f8 contains (an expression for) the literal value itself.;ghc-libEmit warnings on overloaded integral literals which overflow the bounds implied by their type.;ghc-libEmit warnings on integral literals which overflow the bounds implied by their type.;ghc-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.;ghc-lib!Type of the whole case expressionghc-lib All PgLits ;;;;;;;;;;;; ;;;;;;;;;;;;Noneq;ghc-lib Guarded RHSsghc-lib Type of RHSghc-libRefined pattern match checking models, one for the pattern part and one for each GRHS.;;;;;;None #'(>;ghc-libDesugar the non-empty fes of a f.;;;;;;;;None '(2>;ghc-lib8Check a pattern binding (let, where) for exhaustiveness.;ghc-libExhaustive for guard matches, is used for guards in pattern bindings and in MultiIf expressions. Returns the  covered by the RHSs.;ghc-libCheck a list of syntactic f1es (part of case, functions, etc.), each with a f and one or more f:  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  for 1.) each pattern of a f and 2.) each of a fes f& 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].;ghc-libAdd in-scope type constraints if the coverage checker might run and then run the given action.;ghc-libAdd equalities for the S scrutinee to the local $ 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.;ghc-lib;, but desugars the F first.;ghc-lib#Match context, for warning messagesghc-libThe GRHSs to checkghc-libCovered ( for each RHS, for long distance info;ghc-lib$Match context, for warnings messagesghc-lib#Match variables, i.e. x and y aboveghc-libList of matchesghc-lib One covered / per Match and GRHS, for long distance info.:;;;;;;;;;:;;;None ?";ghc-libDesugar top level binds, strict binds are treated like normal binds since there is no good time to force before first usage.;ghc-libDesugar all other kind of bindings, Ids of strict binds are returned to later be forced in the binding group body, see Note [Desugar Strict binds] ;;;;;;;;;; ;;;;;;;;;;None/?;ghc-lib5This is Nothing only when we are dealing with a VarBr;;None;;;;None !&:ghc-lib matchSimply is a wrapper for : which deals with the situation where we want to match a single expression against a single pattern. It returns an expression.:ghc-lib&The scrutinee the match id is bound to:ghc-lib Scrutineeghc-lib Match kindghc-libPattern it should matchghc-libReturn this if it matchesghc-libReturn this if it doesn't:ghc-libFor shadowing warning messagesghc-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 :):ghc-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!::::;;:;::;:None;;;;None3;;None:ghc-libReplace the body of the function with this block to test the hsExprType function in GHC.Tc.Utils.Zonk: putSrcSpanDs loc $ do { core_expr <- dsExpr e ; massertPpr (exprType core_expr & hsExprType e) (ppr e  + dcolon  +6 ppr (hsExprType e) $$ ppr core_expr  + dcolon  +2 ppr (exprType core_expr)) ; return core_expr }::::;;:::;;:None 5;ghc-libThe .hs file has been touched, or the .o/.hi file does not exist;ghc-libThe .o/.hi files are up to date, but something else has changed to force recompilation; the String says what (one-line summary);ghc-lib0The item contained is validated to be up to date;ghc-libThe item is are absent altogether or out of date, for the reason given.;ghc-lib7everything is up to date, recompilation is not required;ghc-libNeed to compile the module<ghc-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 on the outside whether the interface file is up to date, providing evidence that is with a . In the case that it isn't, we may also return a found or provided . Why we don't always return the old one, if it exists, is unclear to me, except that I tried it and some tests failed (see #18205).<ghc-lib1Add fingerprints for top-level declarations to a .$See Note [Fingerprinting IfaceDecls];ghc-lib the reason we need to recompile.ghc-libThe old item, if it exists,;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;<<<,<;;;;<;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;<None<<<<None!<ghc-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.<ghc-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 ( ).<<<<<<<<<<<<None$<ghc-libPretty-prints a 8 (type/data family instance) with its defining location.<ghc-libPretty-prints a   with its defining location.<ghc-libPretty-prints the   header. For functions and data constructors the function is equivalent to < but for type constructors and classes it prints only the header part of the declaration.<ghc-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.<ghc-libLike <!, but adds the defining location.<ghc-libPretty-prints a  .<<<<<<<<<<<<None?) ,ghc-libCompares two things for equivalence between boot-file and normal code, reporting an error if they don't match up.<ghc-lib3How should we infer a type? See Note [TcRnExprMode]<ghc-lib-Instantiate inferred quantifiers only (:type)<ghc-libInstantiate all quantifiers, and do eager defaulting (:type +d)<ghc-lib1Top level entry point for typechecker and renamer<ghc-libCompares the two things for equivalence between boot-file and normal code. Returns Nothing on success or !Just "some helpful info for user"; failure. If the difference will be apparent to the user,  Just empty is perfectly suitable.<ghc-libThe returned [Id] is the list of new Ids bound by this statement. It can be used to extend the InteractiveContext via extendInteractiveContext.The returned TypecheckedHsExpr is of type IO [ () ], a list of the bound values, coerced to ().<ghc-lib:tcRnExpr just finds the type of an expression for :type<ghc-lib)ASSUMES that the module is either in the HomePackageTable or is a package module with an interface on disk. If neither of these is true, then the result will be an error indicating the interface could not be found.<ghc-lib8Find all the Names that this RdrName could mean, in GHCi<ghc-lib.Extract the renamed information from TcGblEnv.,ghc-libTrue  =& an hs-boot file (could also be a sig)#,,,9999999<<<<<<<<<<<<<<<<<<<<<<<<<#<<<<<<<<<<<<<<<<<<<<<<9999999<,,,<<f0None '(-/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.7See Note [Computing the type of every node in the tree]<<<<<<<<None-=ghc-lib"Main entry point to the desugarer.====None-=ghc-libGenerate a section type (e.g.  @progbits). See #13937.=ghc-libTarget platformghc-lib section typeghc-libpretty assembler fragment==None/=ghc-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 Nothing=ghc-libread a Note as a StringIf you try to read a note from a section which does not support the Note format, the parsing is likely to fail and Nothing will be returned=ghc-lib.Generate the GAS code to create a Note sectionHeader fields for notes are 32-bit long (see Note [ELF specification]).======None1 =ghc-lib#Get bytes of a Float representation=ghc-lib$Get bytes of a Double representation=ghc-libEmit a ".string" directive=ghc-libEmit a ".incbin" directive+A NULL byte is added after the binary data.============Nonem=ghc-libLlvm cast operations.=ghc-libInteger truncate=ghc-libInteger extend (zero fill)=ghc-libInteger extend (sign fill)=ghc-libFloat truncate=ghc-lib Float extend=ghc-libFloat to unsigned Integer=ghc-libFloat to signed Integer=ghc-libUnsigned Integer to Float=ghc-libSigned Int to Float=ghc-libPointer to Integer=ghc-libInteger to Pointer=ghc-lib6Cast between types where no bit manipulation is needed=ghc-libLlvm compare operations.=ghc-libEqual (Signed and Unsigned)=ghc-libNot equal (Signed and Unsigned)=ghc-libUnsigned greater than=ghc-libUnsigned greater than or equal=ghc-libUnsigned less than=ghc-libUnsigned less than or equal=ghc-libSigned greater than=ghc-libSigned greater than or equal=ghc-libSigned less than=ghc-libSigned less than or equal=ghc-lib Float equal=ghc-libFloat not equal=ghc-libFloat greater than=ghc-libFloat greater than or equal=ghc-libFloat less than=ghc-libFloat less than or equal=ghc-lib)Llvm binary operators machine operations.=ghc-lib1add two integer, floating point or vector values.=ghc-libsubtract two ...=ghc-lib multiply ..=ghc-lib$unsigned integer or vector division.=ghc-libsigned integer ..=ghc-lib*unsigned integer or vector remainder (mod)=ghc-lib signed ...=ghc-lib(add two floating point or vector values.=ghc-libsubtract two ...=ghc-lib multiply ...=ghc-lib divide ...=ghc-lib remainder ...=ghc-lib Left shift=ghc-lib3Logical shift right Shift right, filling with zero=ghc-libArithmetic shift right The most significant bits of the result will be equal to the sign bit of the left operand.=ghc-libAND bitwise logical operation.=ghc-libOR bitwise logical operation.=ghc-libXOR bitwise logical operation.=ghc-libLinkage type of a symbol.The description of the constructors is copied from the Llvm Assembly Language Reference Manual  -http://www.llvm.org/docs/LangRef.html#linkage5, because they correspond to the Llvm linkage types.=ghc-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.=ghc-lib Globals with linkonce linkage are merged with other globals of the same name when linkage occurs. This is typically used to implement inline functions, templates, or other code which must be generated in each translation unit that uses it. Unreferenced linkonce globals are allowed to be discarded.=ghc-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.=ghc-lib appending linkage may only be applied to global variables of pointer to array type. When two global variables with appending linkage are linked together, the two global arrays are appended together. This is the Llvm, typesafe, equivalent of having the system linker append together sections/ with identical names when .o files are linked.=ghc-libThe semantics of this linkage follow the ELF model: the symbol is weak until linked, if not linked, the symbol becomes null instead of being an undefined reference.=ghc-libThe symbol participates in linkage and can be used to resolve external symbol references.=ghc-lib Alias for =3 but with explicit textual form in LLVM assembly.=ghc-libSymbol is private to the module and should not appear in the symbol table=ghc-libFunctions can have a fixed amount of parameters, or a variable amount.=ghc-lib1Different calling conventions a function can use.=ghc-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).=ghc-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.=ghc-libThis calling convention attempts to make code in the caller as efficient as possible under the assumption that the call is not commonly executed. As such, these calls often preserve all registers so that the call does not break any live ranges in the caller side. This calling convention does not support varargs and requires the prototype of all callees to exactly match the prototype of the function definition.>ghc-libThe GHC-specific  registerised calling convention.>ghc-libAny calling convention may be specified by number, allowing target-specific calling conventions to be used. Target specific calling conventions start at 64.>ghc-lib X86 Specific > convention. LLVM includes a specific alias for it rather than just using CC_Ncc.>ghc-lib#Different types to call a function.>ghc-lib(Normal call, allocate a new stack frame.>ghc-lib7Tail call, perform the call in the current stack frame.>ghc-libLlvm Function Attributes.Function attributes are set to communicate additional information about a function. Function attributes are considered to be part of the function, not of the function type, so functions with different parameter attributes can have the same function type. Functions can have multiple attributes.Descriptions taken from )http://llvm.org/docs/LangRef.html#fnattrs>ghc-libThis attribute indicates that the inliner should attempt to inline this function into callers whenever possible, ignoring any active inlining size threshold for this caller.>ghc-libThis attribute indicates that the source code contained a hint that inlining this function is desirable (such as the "inline" keyword in C/C++). It is just a hint; it imposes no requirements on the inliner.>ghc-libThis attribute indicates that the inliner should never inline this function in any situation. This attribute may not be used together with the alwaysinline attribute.>ghc-libThis attribute suggests that optimization passes and code generator passes make choices that keep the code size of this function low, and otherwise do optimizations specifically to reduce code size.>ghc-libThis function attribute indicates that the function never returns normally. This produces undefined behavior at runtime if the function ever does dynamically return.>ghc-libThis function attribute indicates that the function never returns with an unwind or exceptional control flow. If the function does unwind, its runtime behavior is undefined.>ghc-libThis attribute indicates that the function computes its result (or decides to unwind an exception) based strictly on its arguments, without dereferencing any pointer arguments or otherwise accessing any mutable state (e.g. memory, control registers, etc) visible to caller functions. It does not write through any pointer arguments (including byval arguments) and never changes any state visible to callers. This means that it cannot unwind exceptions by calling the C++ exception throwing methods, but could use the unwind instruction.>ghc-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.>ghc-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.>ghc-libThis attribute indicates that the function should always emit a stack smashing protector. This overrides the ssp function attribute.If a function that has an sspreq attribute is inlined into a function that doesn't have an sspreq attribute or which has an ssp attribute, then the resulting function will have an sspreq attribute.>ghc-libThis attribute indicates that the code generator should not use a red zone, even if the target-specific ABI normally permits it.>ghc-lib>This attributes disables implicit floating point instructions.>ghc-libThis attribute disables prologue / epilogue emission for the function. This can have very system-specific consequences.>ghc-libLLVM Parameter Attributes.Parameter attributes are used to communicate additional information about the result or parameters of a function>ghc-libThis indicates to the code generator that the parameter or return value should be zero-extended to a 32-bit value by the caller (for a parameter) or the callee (for a return value).>ghc-libThis indicates to the code generator that the parameter or return value should be sign-extended to a 32-bit value by the caller (for a parameter) or the callee (for a return value).>ghc-libThis indicates that this parameter or return value should be treated in a special target-dependent fashion during while emitting code for a function call or return (usually, by putting it in a register as opposed to memory).>ghc-libThis indicates that the pointer parameter should really be passed by value to the function.>ghc-libThis indicates that the pointer parameter specifies the address of a structure that is the return value of the function in the source program.>ghc-libThis indicates that the pointer does not alias any global or any other parameter.>ghc-libThis indicates that the callee does not make any copies of the pointer that outlive the callee itself>ghc-libThis indicates that the pointer parameter can be excised using the trampoline intrinsics.>ghc-libAn LLVM Function>ghc-lib!Unique identifier of the function>ghc-libLinkageType of the function>ghc-lib&The calling convention of the function>ghc-libType of the returned value>ghc-lib'Indicates if this function uses varargs>ghc-libParameter types and attributes>ghc-lib(Function align value, must be power of 2>ghc-libLlvm Static Data.These represent the possible global level variables and constants.>ghc-libA comment in a static section>ghc-lib#A static variant of a literal value>ghc-libFor uninitialised data>ghc-libDefines a static >>ghc-libA static array>ghc-libA static structure type>ghc-libA static structure type>ghc-libA pointer to other data>ghc-libTruncate>ghc-libPointer to Pointer conversion>ghc-libPointer to Integer conversion>ghc-libConstant addition operation>ghc-libConstant subtraction operation>ghc-libLlvm Literal Data.(These can be used inline in expressions.>ghc-lib'Refers to an integer constant (i64 42).>ghc-libFloating point literal>ghc-lib.Literal NULL, only applicable to pointer types>ghc-libVector literal>ghc-lib>Undefined value, random bit pattern. Useful for optimisations.>ghc-libLLVM Variables>ghc-libVariables with a global scope.>ghc-lib,Variables local to a function or parameters.>ghc-libNamed local variables. Sometimes we need to be able to explicitly name variables (e.g for function arguments).>ghc-libA constant variable>ghc-libMutable global variable>ghc-libConstant global variable>ghc-libAlias of another variable>ghc-libAn LLVM section definition. If Nothing then let LLVM decide the section>ghc-lib Llvm Types>ghc-lib&An integer with a given width in bits.>ghc-lib32 bit floating point>ghc-lib64 bit floating point>ghc-lib 80 bit (x86 only) floating point>ghc-lib128 bit floating point>ghc-libA pointer to a >>ghc-lib An array of >>ghc-lib A vector of >>ghc-libA > can represent a label (address)>ghc-lib Void type>ghc-libPacked structure type>ghc-libUnpacked structure type>ghc-lib A type alias>ghc-lib LLVM Metadata>ghc-lib3Function type, used to create pointers to functions>ghc-lib A type alias>ghc-libA String in LLVM>ghc-lib4A global mutable variable. Maybe defined or external>ghc-libReturns the variable of the >>ghc-libReturn the value of the >>ghc-lib Return the > of the >>ghc-lib Return the > of a >>ghc-lib Return the > of the >>ghc-lib Return the = for a >>ghc-lib0Add a pointer indirection to the supplied type. > and > cannot be lifted.>ghc-libLift a variable to > type.>ghc-lib:Remove the pointer indirection of the supplied type. Only > constructors can be lowered.>ghc-libLower a variable of > type.>ghc-libTest if the given > is an integer>ghc-libTest if the given > is a floating point type>ghc-libTest if the given > is an > construct>ghc-libTest if the given > is an > construct>ghc-lib Test if a > is global.>ghc-libWidth in bits of an >, returns 0 if not applicable>ghc-lib"The target architectures word size>ghc-lib"The target architectures word size>ghc-libConvert a Haskell Double to an LLVM hex encoded floating point form. In Llvm float literals can be printed in a big-endian hexadecimal format, regardless of underlying architecture.See Note [LLVM Float Types].==============================================================>>>===>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>=>>>================================================================>>>>>>Noner?ghc-libMetadata declarations. Metadata can only be declared in global scope.?ghc-libNamed metadata. Only used for communicating module information to LLVM. ('!name = !{ [!] }' form).?ghc-libMetadata node declaration. ('!0 = metadata !{ }' form).?ghc-libAssociates some metadata with a specific label for attaching to an instruction.?ghc-libLLVM metadata expressions?ghc-lib)A reference to an un-named metadata node. ???????????? ????????????None;?ghc-libLlvm Expressions?ghc-libAllocate amount * sizeof(tp) bytes on the stack * tp: LlvmType to reserve room for * amount: The nr of tp's which must be allocated?ghc-libPerform the machine operator op on the operands left and right * op: operator * left: left operand * right: right operand?ghc-libPerform a compare operation on the operands left and right * op: operator * left: left operand * right: right operand?ghc-libExtract a scalar element from a vector * val: The vector * idx: The index of the scalar within the vector?ghc-libExtract a scalar element from a structure * val: The structure * idx: The index of the scalar within the structure Corresponds to "extractvalue" instruction.?ghc-libInsert a scalar element into a vector * val: The source vector * elt: The scalar to insert * index: The index at which to insert the scalar?ghc-libAllocate amount * sizeof(tp) bytes on the heap * tp: LlvmType to reserve room for * amount: The nr of tp's which must be allocated?ghc-libLoad the value at location ptr?ghc-lib(Atomic load of the value at location ptr?ghc-libNavigate in a structure, selecting elements * inbound: Is the pointer inbounds? (computed pointer doesn't overflow) * ptr: Location of the structure * indexes: A list of indexes to select the correct value.?ghc-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 to?ghc-libAtomic read-modify-write operation * op: Atomic operation * addr: Address to modify * operand: Operand to operation * ordering: Ordering requirement?ghc-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.?ghc-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.?ghc-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.?ghc-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.?ghc-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.?ghc-lib/A LLVM expression with metadata attached to it.?ghc-libLlvm Statements?ghc-libAssign an expression to a variable: * dest: Variable to assign to * source: Source expression?ghc-libMemory fence operation?ghc-lib!Always branch to the target label?ghc-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 false?ghc-libComment Plain comment.?ghc-libSet a label on this position. * name: Identifier of this label, unique for this module?ghc-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 in?ghc-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.?ghc-libReturn a result. * result: The variable or constant to return?ghc-libAn instruction for the optimizer that the code following is not reachable?ghc-libRaise an expression to a statement (if don't want result or want to use Llvm unnamed values.?ghc-libA nop LLVM statement. Useful as its often more efficient to use this then to wrap LLvmStatement in a Just or [].?ghc-lib.A LLVM statement with metadata attached to it.?ghc-lib'LLVM atomic operations. Please see the  atomicrmw instruction in the LLVM documentation for a complete description.?ghc-libLLVM ordering types for synchronization purposes. (Introduced in LLVM 3.0). Please see the LLVM documentation for a better description.?ghc-lib(Some partial order of operations exists.?ghc-lib?A single total order for operations at a single address exists.?ghc-lib"Acquire synchronization operation.?ghc-lib"Release synchronization operation.?ghc-lib,Acquire + Release synchronization operation.?ghc-lib&Full sequential Consistency operation.?ghc-libAn LLVM Function?ghc-lib(The signature of this declared function.?ghc-libThe functions arguments?ghc-libThe function attributes.?ghc-lib%The section to put the function into,?ghc-lib Prefix data?ghc-libThe body of the functions.?ghc-lib6An LLVM Module. This is a top level container in LLVM.?ghc-lib/Comments to include at the start of the module.?ghc-libLLVM Alias type definitions.?ghc-libLLVM meta data.?ghc-lib*Global variables to include in the module.?ghc-libLLVM Functions used in this module but defined in other modules.?ghc-lib&LLVM Functions defined in this module.?ghc-libA block of LLVM code.?ghc-libThe code label for this block?ghc-libA list of LlvmStatement's representing the code for this block. This list must end with a control flow statement.?ghc-lib Block labels????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????Nonet?ghc-libPrint out a whole LLVM module.?ghc-libPrint out a multi-line comment, can be inside a function or on its own?ghc-lib;Print out a comment, can be inside a function or on its own?ghc-lib7Print out a list of global mutable variable definitions?ghc-lib.Print out a global mutable variable definition?ghc-lib&Print out a list of LLVM type aliases.@ghc-libPrint out an LLVM type alias.@ghc-lib"Print out a list of LLVM metadata.@ghc-lib&Print out an LLVM metadata definition.@ghc-lib)Print out a list of function definitions.@ghc-lib Print out a function definition.@ghc-lib)Print out a list of function declaration.@ghc-libPrint out a function declaration. Declarations define the function type but don't define the actual body of the function.@ghc-lib)Return the variable name or value of the >* in Llvm IR textual representation (e.g. @x, %y or 42).@ghc-lib)Return the variable name or value of the >* in a plain textual representation (e.g. x, y or 42).@ghc-libPrint a literal value. No type.??????@@@@@@@@@@@@??????@@@@@@@@@@@@None=================================================================>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>?????????????????????????????????????????????????????????????????????????????????????????????@@@@@@@@@@@@????????????????>>>>>>>>>?>???????????????????????????????????????>>>>>>>>>>???????????????????====>>>>>>============>>>>>>>>>>>>>>=================================================>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>????????????>>>>>>>>>>>>>>@@@@@?????@@@@@?@@None @ghc-lib;Get the LlvmVar function variable storing the real register@ghc-lib;Get the LlvmVar function argument storing the real register@ghc-lib>A list of STG Registers that should always be considered alive@ghc-lib'STG Type Based Alias Analysis hierarchy@ghc-libId values The f node is the root (there can be more than one) of the TBAA hierarchy and as of LLVM 4.0 should *only* be referenced by other nodes. It should never occur in any LLVM instruction statement.@ghc-libId values The f node is the root (there can be more than one) of the TBAA hierarchy and as of LLVM 4.0 should *only* be referenced by other nodes. It should never occur in any LLVM instruction statement.@ghc-libId values The f node is the root (there can be more than one) of the TBAA hierarchy and as of LLVM 4.0 should *only* be referenced by other nodes. It should never occur in any LLVM instruction statement.@ghc-libId values The f node is the root (there can be more than one) of the TBAA hierarchy and as of LLVM 4.0 should *only* be referenced by other nodes. It should never occur in any LLVM instruction statement.@ghc-libId values The f node is the root (there can be more than one) of the TBAA hierarchy and as of LLVM 4.0 should *only* be referenced by other nodes. It should never occur in any LLVM instruction statement.@ghc-libThe TBAA metadata identifier@ghc-libGet the correct TBAA metadata information for this register type @@@@@@@@@@@ @@@@@@@@@@@None5k,@ghc-libThe Llvm monad. Wraps LlvmEnv state as well as the IO monad@ghc-libAn unresolved Label.Labels are unresolved when we haven't yet determined if they are defined in the module we are currently compiling, or an external one.@ghc-lib.Top level LLVM Data (globals and type aliases)@ghc-libUnresolved code. Of the form: (data label, data type, unresolved data)@ghc-lib#Global registers live on proc entry@ghc-lib)Translate a basic CmmType to an LlvmType.@ghc-lib*Translate a Cmm Float Width to a LlvmType.@ghc-lib(Translate a Cmm Bit Width to a LlvmType.@ghc-lib#Llvm Function type for Cmm function@ghc-libLlvm Function signature@ghc-libAlignment to use for functions@ghc-lib Alignment to use for into tables@ghc-libSection to use for a function@ghc-libA Function's arguments@ghc-lib=Return a list of "padding" registers for LLVM function calls.When we generate LLVM function signatures, we can't just make any register alive on function entry. Instead, we need to insert fake arguments of the same register class until we are sure that one of them is mapped to the register we want alive. E.g. to ensure that F5 is alive, we may need to insert fake arguments mapped to F1, F2, F3 and F4.Invariant: Cmm FPR regs with number "n" maps to real registers with number "n" If the calling convention uses registers in a different order or if the invariant doesn't hold, this code probably won't be correct.@ghc-libLlvm standard fun attributes@ghc-libConvert a list of types to a list of function parameters (each with no parameter attributes)@ghc-lib Pointer width@ghc-libThe (inclusive) lower bound on the LLVM Version that is currently supported.@ghc-libThe (not-inclusive) upper bound bound on the LLVM Version that is currently supported.@ghc-libGet target platform@ghc-libLifting of IO actions. Not exported, as we want to encapsulate IO.@ghc-libGet initial Llvm environment.@ghc-lib9Clear variables from the environment for a subcomputation@ghc-lib3Insert variables or functions into the environment.@ghc-lib3Insert variables or functions into the environment.@ghc-lib1Lookup variables or functions in the environment.@ghc-lib1Lookup variables or functions in the environment.@ghc-lib(Set a register as allocated on the stack@ghc-lib2Check whether a register is allocated on the stack@ghc-lib1Allocate a new global unnamed metadata identifier@ghc-lib/Get the LLVM version we are generating code for@ghc-libDumps the document if the corresponding flag has been set by the user@ghc-lib.Prints the given contents to the output handle@ghc-libMarks a variable as "used"@ghc-lib,Return all variables marked as "used" so far@ghc-lib%Sets metadata node for a given unique@ghc-lib#Gets metadata node for given unique@ghc-libHere we pre-initialise some functions that are used internally by GHC so as to make sure they have the most general type in the case that user code also uses these functions but with a different type than GHC internally. (Main offender is treating return type as void) instead of 'void *'). Fixes trac #5486.@ghc-libPretty print a f.@ghc-libCreate/get a pointer to a global value. Might return an alias if the value in question hasn't been defined yet. We especially make no guarantees on the type of the returned pointer.@ghc-libDerive the definition label. It has an identified structure type.@ghc-lib7Generate definitions for aliases forward-referenced by  getGlobalPtr.Must be called at a point where we are sure that no new global definitions will be generated anymore!@ghc-lib=Here we take a global variable definition, rename it with a $def, suffix, and generate the appropriate alias.6@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@6@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@None@ghc-libPrepend the working directory to the search path. Note [Filepaths and Multiple Home Units]@ghc-libRun compiler of C-like languages and raw objects (such as gcc or clang).@ghc-lib8Run the linker with some arguments and return the output@ghc-libRun the LLVM Optimiser@ghc-libRun the LLVM Compiler@ghc-libRun the clang compiler (used as an assembler for the LLVM backend on OS X as LLVM doesn't support the OS X system assembler)@ghc-lib
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 AAAAAAAAANoneAghc-lib>Initialize the Llvm code generator configuration from DynFlagsAANoneTAghc-lib4Pass a CmmStatic section to an equivalent Llvm code.Aghc-libHandle static dataAAAANonejAghc-libPretty print LLVM data codeAghc-libPretty print LLVM codeAghc-libThe section we are putting info tables and their entry code into, should be unique since we process the assembly pattern matching this.AAAAAANone '(Aghc-lib)Top-level of the LLVM proc Code generatorAANone  &=Aghc-lib$Top-level of the LLVM Code generator@A@ANonevAAAAAAAAAAAANone '(Aghc-libAs 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.Aghc-libThis works on the invariant that all jumps in the given blocks are required. Starting from there we try to make a few more jumps redundant by reordering them. We depend on the information in the CFG to do so so without a given CFG we do nothing.Aghc-libCFG if presentghc-libBlocks with info tablesghc-libList of basic blocksAAAAAAAAAANoneՉAghc-lib-Instruction instance for x86 instruction set.AAAANoneպAAAANoneAghc-lib Instruction instance for powerpcAANoneDAAAANone֢Aghc-lib Instruction instance for aarch64AANonewAghc-libLanguage ID used for Haskell.Bghc-lib.Mapping of registers to DWARF register numbersBghc-lib2Virtual register number to use for return address.AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBNone >?Bghc-libUnwind instructions for a block. Will become part of the containing FDE.Bghc-libthese unwind points must occur in the same order as they occur in the blockBghc-libUnwind instructions for an individual procedure. Corresponds to a "Frame Description Entry" (FDE) in DWARF.Bghc-lib%List of blocks. Order must match asm!Bghc-libInformation about unwind instructions for a procedure. This corresponds to a "Common Information Entry" (CIE) in DWARF.Bghc-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.Bghc-libIndividual dwarf records. Each one will be encoded as an entry in the  .debug_info section.Bghc-lib)label of DIE belonging to the parent tickBghc-libAbbreviation declaration. This explains the binary encoding we use for representing B1. Be aware that this must be updated along with B.Bghc-lib Generate assembly for DWARF dataBghc-lib4Print assembler directives corresponding to a DWARF .debug_aranges address table entry.Bghc-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.Bghc-lib)Align assembly at (machine) word boundaryBghc-lib1Assembly for a single byte of constant DWARF dataBghc-lib(Assembly for a two-byte constant integerBghc-lib*Assembly for 4 bytes of dynamic DWARF dataBghc-libAssembly for a DWARF word of dynamic data. This means 32 bit, as we are generating 32 bit DWARF.Bghc-libAssembly for a machine word of dynamic data. Depends on the architecture we are currently generating code for.Bghc-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.Bghc-libSame as  pprLEBWord, but for a signed numberBghc-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./BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB/BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBNoneBghc-lib Generate DWARF/debug informationBBNone'(5>?OBghc-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 statsBghc-libthe cmm to generate code forghc-lib!sequence number of this top thing################BBBB################NoneBghc-lib(Generate code to initialise cost centresBghc-libGenerate code to initialise info pointer origin See Note [Mapping Info Tables to Source Positions]Bghc-lib3additional files to be compiled with the C compiler ghc-lib DependenciesBBBBBBBBNoneBghc-lib.The profiling header words in a static closureBghc-lib+Profiling header words in a dynamic closureBghc-lib1Initialise the profiling field of an update frameBghc-libRecord the allocation of a closure. The CmmExpr is the cost centre stack to which to attribute the allocation.Bghc-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.Bghc-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.BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBNone?Bghc-lib!Low-level heap object allocation.Bghc-liblower-level version for GHC.Cmm.ParserBghc-librepresentation of the objectghc-lib info pointerghc-lib cost centreghc-libpayloadghc-lib!returns the address of the object(((*BBBBBBBBBBBB(((*BBBBBBBBBBBBNoneBBBBBBNone #$'(2<>?Bghc-libMaps labels from B 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.Bghc-libCurrent module being compiled. Required for calling labelDynamic.Bghc-libprevious SRTs we've emitted, so we can de-duplicate. Used to implement the [Common] optimisation.Bghc-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.Bghc-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 B-: a mapping from code block to sets of labelsBghc-libGiven B of a module, returns the set of non-CAFFY names in the module. Any Names not in the set are CAFFY.Bghc-libAttach SRTs to all info tables in the CmmDecls, and add SRT declarations to the ModuleSRTInfo.BBBBBBBBBBBBBBBBBBBBBBBBBBBBNoneCghc-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.Cghc-lib1Produce code to save the current thread state to  CurrentTSOCghc-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.Cghc-libRestore STG registers (see C)Cghc-libPush a subset of STG registers onto the stack, specified by the bitmapSometimes, a "live" subset of the STG registers needs to be saved on the stack, for example when storing an unboxed tuple to be used in the GHCi bytecode interpreter.The "live registers" bitmap corresponds to the list of registers given by , with the least significant bit indicating liveness of the first register in the list.Each register is saved to a stack slot of one or more machine words, even if the register size itself is smaller.The resulting Cmm code looks like this, with a line for each real or virtual register used for returning tuples:... if((mask & 2) != 0) { Sp_adj(-1); Sp(0) = R2; } if((mask & 1) != 0) { Sp_adj(-1); Sp(0) = R1; }See Note [GHCi tuple layout]Cghc-lib2Pop a subset of STG registers from the stack (see C)Cghc-lib3Produce code to load the current thread state from  CurrentTSO)CCCCCCCCCCCCCC)CCCCCCCCCCCCNoneFCCCCNone #$'(yCCCCNoneCghc-lib!Top level driver for C-- pipelineCCNone )CC)None6)CCCCC)CCCNone/tCCNone'(CCNone >CCf9 f9 None '(Cghc-lib ~,ghc-lib(Releases the external interpreter state.,,,,,,,,,,,,,,CC,,,,,,,,,,,CC,,, None #$Cghc-libFailure modes for C.Cghc-lib  returned F.Cghc-libF: The module was compiled. e: The module was :loaded.Cghc-libThe  was defined interactively.Cghc-libdefault ExecOptionsCghc-lib3Run a statement in the current interactive context.Cghc-libLike C, but takes a parsed statement as argument. Useful when doing preprocessing on the AST before execution, e.g. in GHCi (see GHCi.UI.runStmt).Cghc-libRun some declarations and return any user-visible names that were brought into scope.Cghc-libLike C, but takes parsed declarations as argument. Useful when doing preprocessing on the AST before execution, e.g. in GHCi (see GHCi.UI.runStmt).Cghc-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 imports9, and updates the icReaderEnv 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.)Cghc-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.Cghc-libReturns True if the specified module is interpreted, and hence has its full top-level scope available.Cghc-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)Cghc-lib=Returns all names in scope in the current interactive contextCghc-lib Returns all  s in scope in the current interactive context, excluding any that are internally-generated.Cghc-lib:Parses a string as an identifier, and returns the list of s that the identifier can refer to in the current interactive context.Cghc-libGet the type of an expression Returns the type as described by ?6 Dghc-lib>Describes which modules of the module graph need to be loaded.Dghc-lib&Load all targets and its dependencies.Dghc-lib0Load only the given module and its dependencies.Dghc-libLoad only the dependencies of the given module, but not the module itself.Dghc-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.Dghc-lib$Perform dependency analysis like in D. In case of errors, the errors and an empty module graph are returned.Dghc-lib!Perform dependency analysis like D 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 D this function will not update J with the new module graph.Dghc-lib5Collect the instantiations of dependencies to create f work graph nodes. These are used to represent the type checking that is done after all the free holes (sigs in current package) relevant to that instantiation are compiled. This is necessary to catch some instantiation errors.In the future, perhaps more of the work of instantiation could be moved here, instead of shoved in with the module compilation nodes. That could simplify backpack, and maybe hs-boot too.Dghc-libTry to load the program. See D 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 V> after each compiling each module, whether successful or not.If errors are encountered during dependency analysis, the module D 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 V.Dghc-libGeneralized version of D which also supports a custom C (for reporting progress) and ! (generally produced by calling D.Dghc-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 cyclicDghc-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.Dghc-libexcluded modulesghc-liballow duplicate rootsDghc-libexcluded modulesghc-liballow duplicate rootsDghc-libexcluded modulesghc-liballow duplicate rootsghc-libpossibly empty Bag of errors and a module graph.Dghc-libDrop hi-boot nodes? (see below)ghc-libRoot module name. If Nothing, use the full graph.Dghc-lib Old summariesDghc-libMap of old summaries099DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD0DDDDDDDDDDDDDDDDDDDDDD99DDDDDDDDDDD None %&\"9Dghc-lib?An error thrown if the GHC API is used in an incorrect fashion.Dghc-lib"Container for information about a .Dghc-lib.A CoreModule consists of just the fields of a K that are needed for the E interface.Dghc-lib Module nameDghc-lib2Type environment for types declared in this moduleDghc-lib DeclarationsDghc-libSafe Haskell modeEghc-libThe result of successful desugaring (i.e., translation to core). Also contains all the information of a typechecked module.Eghc-libThe result of successful typechecking. It also contains the parser result.Eghc-lib!The result of successful parsing.Eghc-libInstall some default exception handlers and run the inner computation. Unless you want to handle exceptions yourself, you should wrap this around the top level of your program. The default handlers output the error message(s) to stderr and exit cleanly.Eghc-libThis function is no longer necessary, cleanup is now done by runGhc/runGhcT.Eghc-libRun function for the a monad.0It initialises the GHC session and warnings via E. Each call to this function will create a new session which should not be shared among several threads."Any errors not handled inside the a) action are propagated as IO exceptions.Eghc-libRun function for b monad transformer.0It initialises the GHC session and warnings via E. Each call to this function will create a new session which should not be shared among several threads.Eghc-libInitialise a GHC session.If you implement a custom ` you must call this function in the monad run function. It will initialise the session variable and clear all warnings.The first argument should point to the directory where GHC's library files reside. More precisely, this should be the output of ghc --print-libdir of the version of GHC the module using this API is compiled with. For portability, you should use the  ghc-paths package, available at  ,http://hackage.haskell.org/package/ghc-paths.Eghc-libSets the program . Note: this invalidates the internal cached module graph, causing more work to be done the next time D is called.Returns a boolean indicating if preload units have changed and need to be reloaded.Eghc-libReturns the program .Eghc-libSet the  used to evaluate interactive expressions. Also initialise (load) plugins.9Note: this cannot be used for changes to packages. Use E, or E and then copy the  unitState into the interactive DynFlags.Eghc-libGet the * used to evaluate interactive expressions.Eghc-libParse command line arguments that look like files. First normalises its arguments and then splits them into source files and object files. A source file can be turned into a  via EEghc-libSets the targets for this session. Each target may be a module name or a filename. The targets correspond to the set of root modules for the program/library. Unloading the current program is achieved by setting the current set of targets to be empty, followed by D.Eghc-lib"Returns the current set of targetsEghc-libAdd another target.Eghc-libRemove a targetEghc-libAttempts to guess what Target a string refers to. This function implements the --make(/GHCi command-line syntax for filenames:if the string looks like a Haskell source filename, then interpret it as suchif adding a .hs or .lhs suffix yields the name of an existing file, then use that/otherwise interpret the string as a module nameEghc-libInform GHC that the working directory has changed. GHC will flush its cache of module locations, since it may no longer be valid.Note: Before changing the working directory make sure all threads running in the same session have stopped. If you change the working directory, you should also unload the current program (set targets to empty, followed by load).Eghc-lib Return the ! of a module with the given name.1The module must be part of the module graph (see J and 9). If this is not the case, this function will throw a D.This function ignores boot modules and requires that there is only one non-boot module with the given name.Eghc-libParse a module. Throws a J on parse error.Eghc-lib%Typecheck and rename a parsed module. Throws a J if either fails.Eghc-libDesugar a typechecked module.Eghc-libThis is the way to get access to the Core bindings corresponding to a module.  compileToCore parses, typechecks, and desugars the module, then returns the resulting Core module (consisting of the module name, type declarations, and function declarations) if successful.Eghc-libLike compileToCoreModule, but invokes the simplifier, so as to return simplified and tidied Core.Eghc-lib Get the module dependency graph.Eghc-libReturn True <==> module is loaded.Eghc-lib8Return the bindings for the current interactive session.Eghc-lib9Return the instances for the current interactive session.Eghc-lib#Request information about a loaded Eghc-lib2The list of top-level entities defined in a moduleEghc-libReturns the instances defined by the specified module. Warning: currently unimplemented for package modules.Eghc-lib!Retrieve module safe haskell modeEghc-libLooks up a global name: that is, any top-level name in any visible module. Unlike E, lookupGlobalName does not use the interactive context, and therefore does not require a preceding C.Eghc-lib"get the GlobalRdrEnv for a sessionEghc-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.Eghc-libprint a 0, adding parentheses if the name is an operator.Eghc-lib9Return module source as token stream, including comments.A  can be turned into a  using E2 if your session is fully initialised. Throws a  on parse error.Eghc-lib.Give even more information on the source than E This function allows reconstructing the source completely with E.Eghc-libGiven a source location and a StringBuffer corresponding to this location, return a rich token stream with the source associated to the tokens.Eghc-lib/Take a rich token stream such as produced from E and return source code almost identical to the original code (except for insignificant whitespace.)Eghc-libTakes a  and possibly a d, and consults the filesystem and package database to find the corresponding +, using the algorithm that is used for an import declaration.Eghc-libLike E, but differs slightly when the module refers to a source file, and the file has not been loaded via D. In this case, E/ will throw an error (module not loaded), but E 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.Eghc-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.Eghc-libReturn if a module is trusted and the pkgs it depends on to be trusted.Eghc-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.Eghc-lib.Get the monad GHCi lifts user statements into.Eghc-lib Returns the   for a . The 2 may refer to any entity known to GHC, including s defined using runStmt.Eghc-lib&A pure interface to the module parser.Eghc-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 id2Eghc-libSee argument to E.ghc-libThe action to perform.Eghc-libSee argument to E.ghc-libThe action to perform.Eghc-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.Eghc-lib6Haskell module source text (full Unicode is supported)ghc-lib the flagsghc-lib#the filename (for source locations)VWXYZ[\]`_^abcdgfemlkjihqopnxwvutsr~}|{zyffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffgggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggghhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiijjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjfjjjjjjjfjjjjjkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkekkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkklllllllllllllllllllllllFlllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmeemmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnennnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnennnnnnnnnnnnnnnnnnnnnnnnnnnnnnnooooooooooooooooooooooooooooooooooeooooooooeooooooooooooooooooooooooooooooooooooooeoooooooooooooooooooooooooooooooooooooooooooooooopppppppppppppppppppppppppppppfpppppppppppppppppppppppppppppppppppppppppfppppppppppppppppppppppppppppppppppppppppppppppppppppppppppqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqeqFqqqqqFqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqfqqqqqfqqqqqqFqqqrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttSSSSSSSSSSSSSS ttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttuuu uuuuuu uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu \\\   uuuuvvvvvvvvvvvvvvvvvvvvve&'''<<<<|8Eghc-lib'Entry point to compile a Backpack file.EENone 5|Eghc-lib)A state monad which is lazy in the state. EEEEEEEEEE EEEEEEEEEEENone#$>|EENone}+FFNone Fghc-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.Fghc-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.Fghc-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.Fghc-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.Fghc-libpurgeObj drops the symbols for the dynamic library from the symbol table. Unlike F, the library will not be dropped memory during a future major GC.FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF Safe-InferredXFghc-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.FFNoneFghc-libUsed by GHCi to add an SPT entry for a set of interactive bindings.FFNone #$0289Fghc-lib1The exception thrown by "fail" in the GHCiQ monadFghc-libThe implementation of the v message: create a new IORef QState, and return a RemoteRef to it.Fghc-libRuns the mod finalizers.5The references must be created on the caller process.Fghc-libThe implementation of the v messageFghc-libThe TH state, created by Fghc-libThe splice to runghc-libWhat kind of splice it isghc-libThe source locationghc-lib>>>?@@@@@AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBBCDDDDDDDDDDDDDDDDDDDDDDDDEEEEEEEEEEEEEEEEEEEEEEEEFFFFFFFFFFFFFGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGHHHHHHHHHHHHHHHHIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIJJJJJJJJJJJJJJJJJJJJJJJKKKKKKKKKKKKKKKLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLMMMMMMMMMMMMMMMMMMMMMMMMMNNNNNNOOOOOOOOOOPPPPPPPPPQQQQQQQQRRSSTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTUUUUUUUVVVVVVVVVVVVVVVVVVVVVVWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWXXYYYYYYZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ[[[[[[[[[\\\\\\\\\]]]]^^^^^^^^^^^^^^^^_`aabcdeeeeeeeeeeeeeeeeeeeeeeeeff                   ggggggggggggggggggggggggggggggggg ggggggggggggggggggg g g g g g g g g g g g g g g g g g g ggg g gg g g g h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h h i i i        j k k k k k k k k k k k k k k!k!k!k!k!k!l!l!l!l!l!l!l!l!l!l!l!l!l!l!l!l!l!l!l!l!l!l!l!l!l!l!l!l!l!l!l!l!l!l!l!l!l!l!m!!!!!!!!n!n!n!n!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!ppppppp!p!pp!p!p!p!p!p!p!p!pp!p!p!pp!p!pp!pp!p!p!p!p!p!p!p!p!p!p!p!p!ppp!p!pp!pp!p!p!ppp!p!p!p!p!p!p!p!p!ppp!p!p!p"p"p"p"p"p"pp"p"p"pp"p"p"ppppppppppppppppppp"q"q"q"q"q"qq"q"q"q"rrrrrrrs"s"s"s"s"s"s"s"s"s"ttt"t"t"t"t"t"t"ttt"t"t"t"t"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"w"w"x"y"y"y"y"y"y"y"y"y"y"y"y"y"y"y"y"y"y"y"y"y"y"z"z"{"{"{"{"{"{"{"{"{"{"{"{"{"|"|"|"|"|"|"|"|"|"|"|"|"|"|"|"|"|"|"|"|"|"|"|"|"|"|"|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#-#-#-#-#-#-#-#-#-#-#-#--#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#}#}#}#}#}#}#}#}#}#}#}#}#}#}#}#}#}#}#}#}#}#}#}#}#}#}#}#}#}#}#}#}#}#}#}#}#}#~#~#~###############$$$$$$$$$$$$$$$$$$$$$$$$$$$#$$$$$$$$$$$$$$$$$#$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$#$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%$%$%$%$%$%$%$%$%$%$%$%$%$%$%$%$%$%$%$%$%$%$%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((#(((((((((((((((((((((((((((((((((()))))))))))))))))))))))%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%))))))))))))))))))))))))))))))))))))))))))***********************************************!*!*!(!*!*!*!*!!!*!*!*!!*!*!*!*!*!*!*!*!*!*!*!*!*!*!*!*!*!*!*!*!*!************************************** * * * * * * * * * * * * * * * * * * * * * * * * + ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+++++++++++++++++++++++++++++++++++++++++++++++++,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,.,.,.,.,.,.,.,.,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,--------------------------------------)-)-)-)-)-)-)-)-)-)-)-)-)-)-)-)-----------------------------------------------------)----------------------................................................................................................................................////////////////////(/(/(/(/(/(/(/(/(/(/(/(/(/(/(/(/(/(/(/(/(/(/(//////#/#/#/#/#/#/#/#/#/#/#/#/#/#/#/#/#/#/#/#/////////,/,/,/,/,/,/,/,/,/,/,/,/,/,/,/,/,/,/,/,/,/,/,/,/,/,////////////////////////////////000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 0 0 0 0 0 0001111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111112222222222 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 22222222222222222222222222222222222222222222222222222222222222222222222222222222222222222233333333333333333333333333333333333333333333333333333333333333333333333 333&&3&3&3&3&3&3&3&3&333333333333333333333333333333333333333333333334444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444----4....44455555----1144.550000000000055525055425555555../555555/5555555555555555555555555 555555555551/111111-5-555)0500/5/055555555555555555555555555555555555555555555555555555555555555555666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666677777777+7+7+7+7+7+7+7+7+7+7+7+7+7+7+77777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777788888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888999999999999999999999999999999999999999999999999 999999999999999999999999999999999999999999999999999999999999999999999999999999999::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::2::::::::::::::::::::::::::::::::::::::::::::::::;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<================================================================================================================================>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>??????????????????????????????????????????????????????????????????????????????)???????????????????????????????????????????????????????@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@#@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA$AAAA$$$$$AAA$AA$AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC C C C C C C C C C C C C C C C C C C C C C * C C C C C C C C C C C C C C C C C C C C CCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDCDDDDDD>DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD D D D D D D D D D D D D D D D D D D D D D D D D D D D D D D D D D D D D D D E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E - C C C * E E E E E E E E E E EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE,EEEEEEEEEEEEEEEEEEEEEEEEEFFFFFFFFFFFFFFFFFFFFFFEFEFFFFFFFFFF FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF FFFFFFFFFFFFFFFFFFF@FFFFFFFFFFFFFFFFFFFFFFFFFFF((FFFFFFFFFFFFFFFFFFGGGGGGFGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGHGHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH*HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH HHHHHHHHHHHHIIIIIIII IIIIIIIFIIIIIIFIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIGIHIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII.-IICIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJKJKJKJKJKJKJKJKJKJKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKLKLKLKLKLKLKLKLKLKLKLKLKLKLKLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFOFOFOFOFOFOFOFOFOFOFOFOFOFOFOFOFOFOFOFOFOFOFOFOFOFOFOFOFOFOFOFOFOFOFCFOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ(QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQRQRQRQRQRQRQRQRQRQRQRQRQRQRQ?QJQ?QRQRQRQRQRQQQQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQRQQ Q Q QRQRQRQ QS 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 S S S S S S S S S S S S S S S S SFSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTSTST T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T 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 U U U U U U U U U U U U U UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVIVIVIVIVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVWVWVWVWVWVWVWVWVWVWVWVWVWVWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW!W!WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYY Y Y Y Y Y Y Y Y Y Y Y Y Y Y Z Z Z Z Z Z ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\>\\\\\\\\\\\\\\\\\\\ \ \ \ \ \ \ \ \ \ \ \ \ \ \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^_________________________________________________________________P_P_P_P_P_P_P_P_P_P_P_P_P_P_P_P_P_P_P_P_P_P_P_P_P_PPYP_P________________________________________````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````a`a`a`a`a`a`a`a`a`a`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbHbHbHbHbHbHbHbHbHbHbHbHbHbHbHcHcHcHcHcHcHcHcHcHcHcHcHcHcHcHcHcHcHcHcHcHcHcHHHcHcHcHcHcHcHcHcHcHccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdIdIdIdIdIdddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddIdIdIdIdIdIdIdIdIeIeIeIeIeIeIeIeIeIeIeIeIeIeIeIeIeIeeeeeeeeeeeeeFeeeFeeFeeeeeeeeeFeFe+eeeeeeeeeeFeeeeFeFeeeeeeeFeFeeeFeFeeeeeeeeFeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgggggggghghghghghghghghghghghghghghghghghghghghghghghghghghghghghghghhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiififfifififiFiFiFiFiFiFiFiFiFiFiFiFiFiFiFiFiFiFiFiFiFiFiFiFiFiFiFiFiFiFiFiFiFiFiFiFiFiFiFiFiFiFiFiFiFiFiFiFiFiFiFiFiFiFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFeFjFjFjFjFjFjFeFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjF;FjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFFFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFkFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFeFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFlFmFmFmFmFmFmFmFmFmFmFmFmFmFmFmFmFmFmFmFmFmFmFmFmFmFmFmFmFmFmFmFmFmFmFmFmFmFmFmFmemememememememememememememememememememememememememememememememememememememememememememememememememememememememememememememememememememememememememememememememememememememhmememememememememememememeneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneneoeoeoeoeoeoeoeoeoeoeoeoeoeoeoeoeoeoeoeoeoeoeoeoeoeoeoeoeoeoeoeoeoeoeoeoeoeoeoeoeoeoeoeoeoeoeoeoeoeoeoeoeoeoeoeoeoeoeoeoeoeoooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo%ooooooooooooooooooooooooooooooooooooooooooooooooooooooooooopopopopopopopopopopopopopopopopopopopopopopFpFpFpFpFpFpFpFeFFFpFpFpFpFpFpFpFpFpFpFpFpFpFpFpFpFpFpFpFpFpFpFpFpFpFpFpFpFpFpFpFpFpFpFpFpFpFpFpFpFpFpFpFpFpFiFoFoFpFpFpFpFpFpFpFpFpFpFpFpFpFpFpFpFpFpFpFpFpFpFeFpFpFpFpFppppppppppppppppppppppppppppppppppmpppppppppppppppmpppppppppppppppqpqpqpqpqpqpqpqpqpqpqpqpmpqplpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpkpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqpqprprprprprprprprprprprprprprprprprprprprprprprprprprprprpjprprprprprprprprprprprprprprprprprprprprprprprprprprprprprprpjprprprprprprprprprprprprprprprprprprpoprprprprprprprprprprprprprprprprprprprprprprprprprprprprprprprprprprprprprprprprprprprprprprprprprprprprpspspspspspspspspnpspspspspspspspspspspspspspspspspspspspspsps 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 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 s s s s s s s s t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t tttttttttttttttttttttttttttttttttttttttttttttttttttttttt)ghc-lib-0.20220401-9mkRL5hIWPMDixbbkqVIehGHC.HsToCore.MonadGHC.Core.Opt.SpecConstr GHC.SysToolsGHC.Driver.PipelineGHC.Tc.Errors.Hole GHC.Tc.PluginGHC.Tc.Gen.SigGHC.Tc.Utils.EnvGHC.Types.Name.ShapeGHC.Tc.Utils.ZonkGHC.Core.Opt.Simplify.MonadGHCGHC.Runtime.Eval GHC.PluginsGHC.HsToCore.Pmc.SolverGHC.Tc.Solver.MonadGHC.Tc.Utils.InstantiateGHC.Tc.ValidityGHC.Driver.MainGHC.Driver.MakeGHC.Builtin.UtilsLanguage.Haskell.TH.QuoteGHC.Core.Opt.SpecialiseGHC.Tc.Gen.ExprGHC.Tc.Utils.TcMTypeGHC.Linker.LoaderGHC.Unit.FinderGHC.Driver.Config.FinderGHC.StgToCmm.MonadGHC.CmmToAsm.TypesGHC.StgToByteCodeGHC.StgToCmm.UtilsGHC.StgToCmm.ExtCodeGHC.Stg.Lift.Analysis GHC.Iface.EnvGHC.HsToCore.TypesGHC.StgToCmm.ClosureGHC.Tc.Instance.FamilyGHC.Cmm.DataflowGHC.Rename.UnboundGHC.Tc.Instance.FunDepsGHC.Builtin.Types.LiteralsGHC.Rename.NamesGHC.Iface.BinaryGHC.CmmToAsm.Reg.LivenessGHC.ByteCode.AsmGHC.Builtin.Names.THGHC.ByteCode.LinkerGHC.Cmm.ConfigGHC.Cmm.InitFiniGHC.Cmm.LRegSetGHC.Cmm.Parser.Monad GHC.Cmm.LexerGHC.Cmm.Ppr.ExprGHC.Cmm.Ppr.DeclGHC.Cmm.Liveness GHC.Cmm.UtilsGHC.Cmm.Switch.Implement GHC.Cmm.PprGHC.Cmm.CallConv GHC.Cmm.Graph GHC.Cmm.Opt GHC.Cmm.Sink GHC.Cmm.LintGHC.Cmm.DebugBlockGHC.Cmm.ContFlowOptGHC.Cmm.CommonBlockElimGHC.CmmToAsm.AArch64.CondGHC.CmmToAsm.CFG.DominatorsGHC.CmmToAsm.CPrimGHC.CmmToAsm.ConfigGHC.CmmToAsm.FormatGHC.CmmToAsm.AArch64.RegsGHC.CmmToAsm.InstrGHC.CmmToAsm.PPC.CondGHC.CmmToAsm.PPC.RegsGHC.CmmToAsm.Reg.Graph.BaseGHC.CmmToAsm.Reg.Graph.X86GHC.CmmToAsm.Reg.Linear.AArch64GHC.CmmToAsm.Reg.Linear.PPC GHC.CmmToAsm.Reg.Linear.StackMapGHC.CmmToAsm.Reg.UtilsGHC.CmmToAsm.UtilsGHC.CmmToAsm.AArch64.InstrGHC.CmmToAsm.AArch64.RegInfoGHC.CmmToAsm.X86.CondGHC.CmmToAsm.X86.RegsGHC.CmmToAsm.X86.RegInfoGHC.CmmToAsm.Reg.TargetGHC.CmmToAsm.X86.InstrGHC.CmmToAsm.Reg.Linear.X86_64GHC.CmmToAsm.Reg.Linear.X86 GHC.CmmToCGHC.CmmToLlvm.ConfigGHC.CmmToLlvm.ManglerGHC.Core.LateCCGHC.Core.Opt.CSEGHC.Core.Opt.ExitifyGHC.Core.Opt.FloatInGHC.Core.Opt.LiberateCaseGHC.Core.Opt.SetLevelsGHC.Core.Opt.FloatOutGHC.Core.Opt.Simplify.EnvGHC.Core.Opt.Simplify.UtilsGHC.Core.Opt.SimplifyGHC.Core.Opt.StaticArgsGHC.Core.TyCon.SetGHC.Core.Opt.WorkWrap.UtilsGHC.Core.Opt.WorkWrapGHC.Data.Bitmap GHC.Cmm.InfoGHC.CmmToAsm.PPC.Instr GHC.CmmToAsm.Reg.Linear.FreeRegsGHC.CmmToAsm.PPC.RegInfoGHC.Cmm.ProcPointGHC.Data.Graph.Base$GHC.CmmToAsm.Reg.Graph.TrivColorableGHC.Data.Graph.OpsGHC.Data.Graph.PprGHC.Data.Graph.ColorGHC.Data.Graph.UnVarGHC.Core.Opt.CallArityGHC.Data.UnionFindGHC.CmmToAsm.CFGGHC.CmmToAsm.Reg.Linear.BaseGHC.CmmToAsm.Reg.Linear.StatsGHC.CmmToAsm.Reg.Linear.State%GHC.CmmToAsm.Reg.Linear.JoinToTargetsGHC.CmmToAsm.Reg.Linear!GHC.CmmToAsm.Reg.Graph.SpillCleanGHC.CmmToAsm.Reg.Graph.SpillGHC.CmmToAsm.Reg.Graph.Coalesce GHC.CmmToAsm.Reg.Graph.SpillCostGHC.CmmToAsm.Reg.Graph.StatsGHC.CmmToAsm.Reg.GraphGHC.CmmToAsm.MonadGHC.CmmToAsm.PICGHC.CmmToAsm.PPC.CodeGenGHC.CmmToAsm.AArch64.CodeGenGHC.CmmToAsm.BlockLayoutGHC.Driver.Config.CmmGHC.Driver.Config.CmmToAsmGHC.Driver.Config.HsToCoreGHC.Driver.Config.Stg.PprGHC.Driver.Config.StgToCmmGHC.Driver.Pipeline.LogQueueGHC.HandleEncoding GHC.Hs.StatsGHC.Hs.Syn.TypeGHC.HsToCore.CoverageGHC.HsToCore.DocsGHC.Iface.ErrorsGHC.Iface.Ext.TypesGHC.Iface.Ext.UtilsGHC.Iface.Ext.DebugGHC.Iface.Recomp.FlagsGHC.Iface.Tidy.StaticPtrTableGHC.IfaceToCoreGHC.Linker.UnitGHC.Parser.UtilsGHC.Platform.HostGHC.Rename.ExprGHC.Settings.UtilsGHC.Settings.IOGHC.Stg.BcPrep GHC.Stg.CSE GHC.Stg.DebugGHC.Driver.Config.Stg.DebugGHC.Stg.InferTags.TypesGHC.Stg.Lift.ConfigGHC.Driver.Config.Stg.Lift GHC.Stg.Stats GHC.Stg.SubstGHC.Stg.Lift.Monad GHC.Stg.UtilsGHC.Stg.Unarise GHC.Stg.LintGHC.Stg.InferTags.RewriteGHC.Stg.InferTags GHC.Stg.FVs GHC.CoreToStgGHC.StgToCmm.CgUtilsGHC.StgToCmm.SequelGHC.StgToCmm.ForeignGHC.StgToCmm.BindGHC.StgToCmm.EnvGHC.StgToCmm.LitGHC.StgToCmm.ArgRepGHC.StgToCmm.TickyGHC.StgToCmm.TagCheckGHC.StgToCmm.Layout GHC.Stg.LiftGHC.Stg.PipelineGHC.Driver.Config.Stg.PipelineGHC.ByteCode.InstrGHC.ByteCode.InfoTableGHC.StgToCmm.HpcGHC.SysTools.ArGHC.SysTools.ProcessGHC.SysTools.InfoGHC.Tc.Gen.MatchGHC.Tc.Gen.Splice GHC.Tc.ModuleGHC.Tc.Types.EvTermGHC.Tc.Utils.MonadGHC.Tc.Gen.AnnotationGHC.Rename.SpliceGHC.Iface.LoadGHC.Tc.TyCl.BuildGHC.Iface.Ext.BinaryGHC.Tc.Utils.UnifyGHC.Tc.Utils.Concrete GHC.ThToHsGHC.Iface.RenameGHC.Types.Unique.MemoFunGHC.Core.Opt.DmdAnalGHC.Core.Opt.CprAnalGHC.Core.Opt.PipelineGHC.Tc.Instance.TypeableGHC.Runtime.Heap.InspectGHC.Rename.UtilsGHC.Iface.TidyGHC.Driver.Config.TidyGHC.CoreToStg.Prep GHC.Tc.ErrorsGHC.Rename.FixityGHC.Rename.EnvGHC.Tc.Instance.ClassGHC.Tc.Solver.RewriteGHC.Tc.Solver.CanonicalGHC.Tc.Solver.Interact GHC.Tc.SolverGHC.Tc.Deriv.GenerateGHC.Tc.Deriv.FunctorGHC.Tc.Deriv.GenericsGHC.Tc.Deriv.UtilsGHC.Tc.Deriv.InferGHC.Rename.DocGHC.Tc.Gen.ExportGHC.Rename.HsTypeGHC.Rename.PatGHC.Rename.BindGHC.Rename.ModuleGHC.Tc.Gen.HsTypeGHC.Tc.TyCl.PatSynGHC.Tc.Gen.PatGHC.Tc.Gen.DefaultGHC.Tc.Gen.BindGHC.Tc.TyCl.UtilsGHC.Tc.Utils.BackpackGHC.Tc.TyCl.ClassGHC.Tc.Gen.HeadGHC.Tc.Gen.ArrowGHC.Tc.Gen.AppGHC.Tc.Gen.RuleGHC.Tc.Gen.Foreign GHC.Tc.DerivGHC.Tc.TyCl.Instance GHC.Tc.TyClGHC.HsToCore.Pmc.UtilsGHC.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.PprGHC.Iface.Ext.Ast GHC.HsToCore GHC.Utils.AsmGHC.SysTools.ElfGHC.CmmToAsm.PprGHC.Llvm.TypesGHC.Llvm.MetaDataGHC.Llvm.Syntax GHC.Llvm.PprGHC.CmmToLlvm.RegsGHC.CmmToLlvm.BaseGHC.SysTools.TasksGHC.Linker.MacOSGHC.Linker.ExtraObjGHC.Linker.WindowsGHC.Linker.DynamicGHC.Linker.StaticGHC.Runtime.LoaderGHC.Driver.Config.CmmToLlvmGHC.CmmToLlvm.DataGHC.CmmToLlvm.PprGHC.CmmToLlvm.CodeGen GHC.CmmToLlvmGHC.CmmToAsm.X86.PprGHC.CmmToAsm.X86.CodeGenGHC.CmmToAsm.X86GHC.CmmToAsm.PPC.PprGHC.CmmToAsm.PPCGHC.CmmToAsm.AArch64.PprGHC.CmmToAsm.AArch64GHC.CmmToAsm.Dwarf.ConstantsGHC.CmmToAsm.Dwarf.TypesGHC.CmmToAsm.Dwarf GHC.CmmToAsmGHC.Driver.CodeOutputGHC.StgToCmm.ProfGHC.StgToCmm.HeapGHC.StgToCmm.DataConGHC.Cmm.Info.BuildGHC.StgToCmm.PrimGHC.Cmm.LayoutStackGHC.Cmm.PipelineGHC.StgToCmm.Expr GHC.StgToCmmGHC.Driver.GenerateCgIPEStubGHC.Cmm.ParserGHC.Driver.Pipeline.ExecuteGHC.Runtime.DebuggerGHC.Driver.MakeFileGHC.Driver.BackpackGHC.Utils.Monad.State.LazyGHCi.CreateBCOGHCi.InfoTable GHCi.ObjLink GHCi.SignalsGHCi.StaticPtrTableGHCi.THGHCi.RunLanguage.Haskell.TH.CodeDo Paths_ghc_lib GHC.LinkerGHC.Core.SubstSubstGHC.STGDebugliftedIdsExpander newFamInstcheckConsistentFamInst simplifyInfer GHC.TypesErrorGHC.LlvmDynFlagsbackendGHC.Driver.Env SourceErrorbaseGHC.Base<*>pure*> ApplicativeGHC.ExtsForceSpecConstr NoSpecConstrSpecConstrAnnotation Control.Monad mapAndUnzipMData.TraversablemapM Data.FoldablefoldlMfoldrM Data.Functor<$><*liftA2directory-1.3.6.0System.DirectorycopyFile0ghc-lib-parser-0.20220401-3F1kDYVQ1aUCvl7HWBPMHdGHC.Driver.Pipeline.PhasesT_MergeForeign T_LlvmMangle T_LlvmLlc T_LlvmOptT_AsT_CcT_CmmT_CmmCpp T_HscBackend T_HscPostTcT_Hsc T_HscRecompT_HsPpT_Cpp T_FileArgsT_UnlitTPhaseGHC.Tc.Errors.Hole.FitTypes fitPlugin candPlugin HoleFitPlugin hfPluginStop hfPluginRun hfPluginInitHoleFitPluginR GHC.Tc.TypesunsafeTcPluginTcMhasCompleteSig isPartialSigthLevelns_map ns_exports ns_mod_name NameShapeTcIdTcIdSettct_infotct_id APromotionErrATcTyConATyVarATcIdAGlobal TcTyThingTcSigFun TcPatSynSigTcIdSig TcSigInfo psig_hs_ty psig_namesig_locsig_ctxtsig_bndr PartialSig CompleteSig TcIdSigInstpatsig_body_ty patsig_provpatsig_ex_bndrs patsig_reqpatsig_univ_bndrspatsig_implicit_bndrs patsig_nameTPSI TcPatSynInfo TcPluginMGHC.Core.Opt.Monad pprSimplCountplusSimplCountisZeroSimplCountzeroSimplCount SimplCountGHC.Driver.MonaddefaultWarnErrLoggerprintException putLogMsgMputMsgM popLogHookM pushLogHookM modifyLoggergetSessionDynFlags setSession getSessionGhcMonadGhcGhcT WarnErrLoggerGHC.Driver.Env.TypesHscEnvGHC.Runtime.ContextIIModuleIIDeclInteractiveImportGHC.Runtime.Eval.TypesexecWrapexecLineNumberexecSourceFileexecSingleStep ExecOptionsRunAndLogSteps SingleStepRunToCompletion breakInfo breakNamesexecAllocation execResult ExecBreak ExecComplete ExecResultresumeHistoryIx resumeHistory resumeCCS resumeDecl resumeSpanresumeBreakInfo resumeApStackresumeFinalIdsresumeBindings resumeContext resumeStmtResumehistoryEnclosingDeclshistoryBreakInfohistoryApStackHistoryGHC.Runtime.Interpreter getModBreaksGHC.Types.SourceErrorhandleSourceErrorGHC.Parser.LexerTokenGHC.Parser.Errors.Types PsWarningPsErrorGHC.Tc.Errors.Types showMatchesshowProvshowType showWrapVarsshowWrapHFDCHoleFitDispConfigGHC.HsToCore.Pmc.Solver.Types initNablasNablaMkNablasNablasGHC.Tc.Solver.Types insertFunEqGHC.Tc.Types.Constraint tyCoVarsOfWC tyCoVarsOfCts tyCoVarsOfCt qci_pend_scqci_predqci_tvsqci_evQCIQCInstGHC.Tc.Types.OriginTyFamResKindCtxt TySynKindCtxt DataKindCtxtTyVarBndrKindCtxtDerivClauseCtxt DataTyCtxt SigmaCtxt ClassSCCtxtGhciCtxt GenSigCtxt SpecInstCtxt InstDeclCtxtDefaultDeclCtxt ForSigCtxt RuleSigCtxt PatSigCtxt PatSynCtxt TySynCtxt ConArgCtxt TypeAppCtxtStandaloneKindSigCtxt KindSigCtxt ExprSigCtxt InfSigCtxt FunSigCtxt UserTypeCtxtGHC.Unit.Module.StatusHscRecompNeeded HscUpToDateHscRecompStatushscs_old_iface_hashhscs_partial_ifacehscs_mod_location hscs_guts HscRecomp HscUpdateHscBackendActionGHC.Unit.Module.ModIfaceModIface mi_src_hash mi_ext_fields mi_final_extsmi_docsmi_complete_matches mi_trust_pkgmi_trustmi_hpcmi_rules mi_fam_instsmi_insts mi_globalsmi_declsmi_annsmi_warns mi_fixities mi_used_th mi_exports mi_usagesmi_deps mi_hsc_src mi_sig_of mi_module ModIface_GHC.Unit.Module.Graph mkNodeKey mkModuleGraphemptyMGmgLookupModulemgModSummariesmapMG mnkUnitId mnkModuleNameModNodeKeyWithUid ModuleGraph SummaryNode ModNodeKeyGHC.Unit.Module.ModSummary ms_home_impsms_home_srcimps ms_mod_name ms_hspp_buf ms_hspp_opts ms_hspp_file ms_parsed_modms_ghc_prim_importms_textual_imps ms_srcimps ms_hie_date ms_iface_datems_dyn_obj_date ms_obj_date ms_hs_hash ms_location ms_hsc_srcms_mod ModSummaryGHC.HsHsParsedModuleGHC.Types.Id.Make ghcPrimIds wiredInIds GHC.Hs.Utils mkHsDictLet mkHsCaseAltmkHsApp GHC.Hs.Type mkHsAppTyLanguage.Haskell.TH.Syntax dataToPatQ dataToExpQdataToQaGHC.Core.Unfold.Make specUnfoldingGHC.Core.InstEnvpprInstanceHdr pprInstanceinstanceDFunIdClsInst TcIdSigInfoGHC.Tc.Utils.TcType synKnownTypemkCheckExpTypeTcType TcThetaType TcTauTypeTcKind TcTyVarSetInferCheckExpType ExpSigmaType ExpRhoTypeSynTypeSynFunSynListSynRhoSynAny SyntaxOpTypeTcLevelGHC.Linker.TypesuninitializedLoader loader_stateLoadertemp_sos pkgs_loaded objs_loaded bcos_loadeditbl_env closure_env LoaderStateGHC.Types.TargettargetContents targetUnitIdtargetAllowObjCodetargetIdTarget TargetFile TargetModuleTargetIdGHC.Unit.Finder.Types FinderCacheInstalledNotFoundInstalledNoPackageInstalledFoundInstalledFindResultfr_suggestions fr_unusablesfr_pkgs_hiddenfr_mods_hiddenfr_pkgfr_pathsNotFound FoundMultiple NoPackageFound FindResultfinder_stubDirfinder_dynObjectSuffinder_objectSuffinder_objectDirfinder_dynHiSuf finder_hiSuf finder_hiDir finder_hieSuf finder_hieDirfinder_reexportedModulesfinder_hiddenModulesfinder_thisPackageNamefinder_workingDirectoryfinder_enableSuggestions finder_waysfinder_bypassHiFileCheckfinder_lookupHomeInterfacesfinder_importPaths FinderOptsGHC.Driver.Sessiongopt cfgWeightsuniqueIncrement initialUnique maxErrors reverseErrorsmaxInlineMemsetInsnsmaxInlineMemcpyInsnsmaxInlineAllocSize rtasmInfortccInfortldInfoavx512pfavx512favx512eravx512cdavx2avx bmiVersion sseVersioninteractivePrintcallerCcFiltersprofAuto colScheme canUseColoruseColor useUnicodepprCols pprUserLength ghciScriptshaddockOptionsghcVersionFileflushOut ghciHistSize maxWorkerArgs unfoldingOptsextensionFlags extensionstrustworthyOnLocwarnUnsafeOnLoc warnSafeOnLoc pkgTrustOnLocincoherentOnLocoverlapInstLocderiveViaOnLoc newDerivOnLocthOnLoc safeInferred safeInfer safeHaskelllanguagefatalWarningFlags warningFlags generalFlags dumpFlags packageEnv trustFlagspluginPackageFlags packageFlagsignorePackageFlagspackageDBFlags depSuffixesdepExcludeModsdepIncludeCppDepsdepIncludePkgDeps depMakefilefrontendPluginOptspluginModNameOptspluginModNameshpcDirrtsOptsSuggestionsrtsOptsEnabledrtsOptscmdlineFrameworksframeworkPaths libraryPaths includePathsldInputsdumpPrefixForce dumpPrefix dynamicNow dynLibLoader dynOutputHioutputHidynOutputFile_ outputFile_ dynHiSuf_ dynObjectSuf_hieSufhiSuf_hcSuf objectSuf_dumpDirstubDirhieDirhiDirdylibInstallName objectDir splitInfo targetWays_reexportedModules hiddenModulesthisPackageNameworkingDirectoryhomeUnitInstantiations_homeUnitInstanceOf_ homeUnitId_solverIterationsreductionDepth mainFunIsmainModuleNameIs importPaths historySizecmmProcAlignment liftLamsKnownliftLamsNonRecArgsliftLamsRecArgs floatLamArgsliberateCaseThresholdbinBlobThresholdspecConstrRecursivespecConstrCountspecConstrThreshold dmdUnboxWidthsimplTickFactormaxPmCheckModelsmaxUncoveredPatternsrefLevelHoleFitsmaxRefHoleFitsmaxValidHoleFitsmaxRelevantBinds ghcHeapSizeenableTimeStats parMakeCountstrictnessBefore ruleCheckmaxSimplIterations simplPhases debugLevel verbosity llvmOptLevel llvmConfigtmpDir rawSettings platformMisc toolSettingstargetPlatform fileSettingsghcNameVersionghcLinkghcMode getDynFlagsMkDependOneShot CompManagerGhcMode LinkMergedObj LinkStaticLib LinkDynLib LinkInMemory LinkBinaryNoLinkGhcLinkGHC.Driver.Pipeline.MonadTPipelineClassuseMonadUse output_spec src_suffix src_basename src_filename stop_phasePipeEnvGHC.StgToCmm.ConfigstgToCmmAvx512f stgToCmmAvx2 stgToCmmAvxstgToCmmVecInstrsErrstgToCmmTickyAPstgToCmmAllowFabsInstrsstgToCmmAllowIntMul2Instr!stgToCmmAllowExtendedAddSubInstrsstgToCmmAllowQuotRem2stgToCmmAllowQuotRemInstrstgToCmmAllowBigArithstgToCmmDoTagCheckstgToCmmDoBoundsCheckstgToCmmExtDynRefs stgToCmmPIE stgToCmmPICstgToCmmOmitIfPragmasstgToCmmOmitYieldsstgToCmmInfoTableMapstgToCmmEagerBlackHolestgToCmmSCCProfilingstgToCmmFastPAPCallsstgToCmmOptHpcstgToCmmAlignCheckstgToCmmLoopificationstgToCmmTickyTagstgToCmmTickyDynThunkstgToCmmTickyLNEstgToCmmTickyAllocdstgToCmmDoTickystgToCmmMaxInlAllocSizestgToCmmBinBlobThreshstgToCmmDebugLevelstgToCmmContextstgToCmmTmpDirstgToCmmThisModulestgToCmmProfileStgToCmmConfigGHC.Utils.ErrorprettyPrintGhcErrorsGHC.Utils.Logger popLogHook pushLogHookLogger getLoggerGHC.Types.ErrorMessagesSevError SevWarning SevIgnoreSeverityGHC.CmmblockId RawCmmDecl RawCmmStatics BasicBlock GenBasicBlock ListGraph substTickish substDVarSetsubstRulesForImportedIds substRuleInfo substIdOccsubstUnfoldingsubstUnfoldingSC substIdInfo substIdTypesubstCo getTCvSubstsubstTycloneRecIdBndrs cloneBndr cloneBndrs cloneIdBndrs cloneIdBndr substRecBndrs substBndrs substBndr deShadowBinds substBind substBindSC substExpr substExprSC setInScopeextendInScopeIdsextendInScopeList extendInScope isInScope mkOpenSubstdelBndrsdelBndr lookupIdSubstextendSubstListextendSubstWithVar extendSubstextendTvSubstList extendTvSubstextendIdSubstList extendIdSubst zapSubstEnv substInScopemkSubst mkEmptySubst emptySubst isEmptySubst IdSubstEnvGHC.ByteCode.Types UnlinkedBCO BreakIndexmodBreaks_breakInfo modBreaks_ccsmodBreaks_declsmodBreaks_varsmodBreaks_locsmodBreaks_flags ModBreaksGHC.Platform.Regs callerSavesGHC.Cmm.BlockId newBlockIdGHC.Stg.Syntax LlStgBinding LlStgExprLlStgRhsLlStgAltGHC.Types.Name.CachelookupOrigNameCacheGHC.Types.TyThingACoAxiomATyConAConLikeAnId GHC.Types.IdisNeverRepPolyIdtransferPolyIdInfozapStableUnfoldingzapIdTailCallInfozapIdUsedOnceInfozapIdUsageEnvInfozapIdUsageInfozapIdDemandInfozapFragileIdInfo zapLamIdInfoupdOneShotInfosetIdOneShotInfoclearOneShotLambdasetOneShotLambdaisProbablyOneShotLambdaisStateHackType typeOneShotstateHackOneShot isOneShotBndridStateHackOneShotInfo idOneShotInfo isConLikeIdidRuleMatchInfosetInlineActivationidInlineActivationmodifyInlinePragmasetInlinePragmaidInlinePragma zapIdOccInfo setIdOccInfo idOccInfo setIdLFInfoidLFInfo_maybe setIdCafInfo idCafInfosetIdSpecialisation idHasRules idCoreRulesidSpecialisationsetCaseBndrEvaldidCbvMarkArityidCbvMarks_maybe setIdCbvMarks setIdTagSigsetIdDemandInfo idDemandInfosetIdUnfoldingrealIdUnfolding idUnfoldingidTagSig_maybe isStrictId zapIdDmdSig setIdCprSigidCprSig setIdDmdSigidDmdSig isDeadEndId idFunRepAritysetIdCallArity idCallArity setIdArityidArityasJoinId_maybe zapJoinIdasJoinId idJoinArity isDeadBinderidIsFrom isImplicitId hasNoBinding idDataConisJoinId_maybeisJoinIdisDataConId_maybeisDataConWrapId_maybeisDataConWrapIdisDataConWorkId_maybeisDataConWorkIdisFCallId_maybe isFCallIdisPrimOpId_maybeisDFunId isPrimOpIdisClassOpId_maybe isClassOpIdisNaughtyRecordSelectorisPatSynRecordSelectorisDataConRecordSelectorisRecordSelectorrecordSelectorTyCon_mayberecordSelectorTyConmkTemplateLocalsNummkTemplateLocalsmkScaledTemplateLocalmkTemplateLocal mkWorkerIdmkUserLocalOrCoVar mkUserLocalmkSysLocalOrCoVarM mkSysLocalMmkSysLocalOrCoVar mkSysLocalmkExportedVanillaIdmkExportedLocalIdmkLocalIdWithInfomkLocalIdOrCoVar mkLocalCoVar mkLocalIdmkVanillaGlobalWithInfomkVanillaGlobal mkGlobalIdmaybeModifyIdInfo modifyIdInfo setIdInfo localiseId setIdType setIdUnique setIdName scaleVarBy scaleIdBy idScaledTypeidMultidTypeidUniqueGHCi.RemoteTypesHValue ForeignHValueGHC.Types.CompleteMatchCompleteMatchesGHC.Core.ConLike conLikeResTyGHC.StgToCmm.TypesLambdaFormInfoStandardFormInfoGHC.Core.DataConisVanillaDataCondataConWrapperTypedataConSrcBangsdataConIsInfixisMarkedStrictNotMarkedStrict MarkedStrictStrictnessMarkGHC.Core.FamInstEnvFamInst FamInstEnvsGHC.Core.Coercion setCoHoleTypehasThisCoercionHoleTyhasCoercionHoleCohasCoercionHoleTy buildCoercionmkReprPrimEqPredmkHeteroReprPrimEqPredmkHeteroPrimEqPredmkPrimEqPredRole mkPrimEqPredmkHeteroCoercionType coercionRolecoercionKindRole coercionKinds lcInScopeSet lcTCvSubstliftEnvSubstRightliftEnvSubstLeft lcSubstRight lcSubstLeft swapLiftCoEnv substRightCo substLeftCo isMappedByLCliftCoSubstVarBndrUsingliftCoSubstTyVarsubstForAllCoBndrUsingLCzapLiftingContextextendLiftingContextAndInScopeextendLiftingContextmkSubstLiftingContextemptyLiftingContextliftCoSubstWithliftCoSubstWithEx eqCoercionX eqCoerciontopNormaliseTypeXunwrapNewTypeSteppercomposeSteppers mapStepResultinstNewTyCon_maybemkCoCast mkFunResComkPiComkPiCosmkFamilyTyConAppCocastCoercionKindcastCoercionKind1castCoercionKind2promoteCoercionltRolenthRoletyConRolesRepresentational tyConRolesXsetNominalRole_maybe downgradeRolemkCoherenceRightComkCoherenceLeftCo mkGReflLeftComkGReflRightCo nthCoRole mkNthCoFunComkHoleComkUnbranchedAxInstLHS mkAxInstLHSmkUnbranchedAxInstRHS mkAxInstRHSmkUnbranchedAxInstCo mkAxInstCo isCoVar_maybe mkCoVarCosmkHomoForAllCos mkForAllCosmkAppCos mkRepReflCoisReflexiveCo_maybeisReflCo_maybeisGReflCo_maybeisReflCoVar_maybe coVarKind coVarTypes coVarRType coVarLTypesplitForAllCo_co_maybesplitForAllCo_ty_maybesplitForAllCo_maybesplitFunCo_maybesplitAppCo_maybemultToCosplitTyConAppCo_maybegetCoVar_maybedecomposeFunCo decomposeCo isReflMComkCoherenceRightMComkGReflRightMComkGReflLeftMCo mkFunResMComkPiMCosmkHomoForAllMCo mkCastTyMComkSymMCo mkTransMCoR mkTransMCoL mkTransMCo isGReflMCocheckReflexiveMCocoToMCotidyCoAxBndrsForUser pprCoAxBranchpprCoAxBranchLHSpprCoAxBranchUser pprCoAxiometaExpandCoAxBranch setCoVarNamesetCoVarUnique coVarNameNormaliseStepperNS_StepNS_AbortNS_DoneNormaliseStepResultLC LiftCoEnvGHC.Core.TyCo.Ppr pprTypeApp pprForAllpprThetaArrowTy pprParendCo pprParendTypeGHC.Cmm.Dataflow.Graph entryLabelGHC.Cmm.Dataflow.LabelFactBase GHC.Core.Type isLinearTypeisOneDataConTyisManyDataConTy scaledSetmkScaledirrelevantMulttymultlinear unrestrictedtyConAppNeedsKindSigclassifiesTypeWithValues isConcreteisFixedRuntimeRepKindsplitVisVarsOfTypessplitVisVarsOfType tyConsOfTypeoccCheckExpandresultHasFixedRuntimeReptypeHasFixedRuntimeReptcReturnsConstraintKindtcIsRuntimeTypeKindtcIsBoxedTypeKindtcIsLiftedTypeKindtcIsConstraintKind tcTypeKindtypeKind nonDetCmpTcnonDetCmpTypesXnonDetCmpTypeXnonDetCmpTypes nonDetCmpType eqVarBndrseqTypeseqTypeXeqTypeseqTypesseqTypeisValidJoinPointTypeisPrimitiveType isStrictTypeisDataFamilyAppType isAlgTypeisUnboxedSumTypeisUnboxedTupleTypegetLevity_maybe getRuntimeRepgetRuntimeRep_maybedropRuntimeRepArgsisRuntimeRepKindedTy isBoxedTypemightBeUnliftedTypemightBeLiftedType isStateTypeisUnliftedTypetypeLevity_maybe buildSynTyCon isCoVarType isFamFreeTy coAxNthLHSmkFamilyTyConAppbinderRelevantType_maybe tyBinderTypetyCoBinderTypetyCoBinderVar_maybeisAnonTyCoBinder mkAnonBinder isAtomicTyisTauTy appTyArgFlags tyConArgFlagspartitionInvisiblesfilterOutInferredTypesfilterOutInvisibleTypessplitInvisPiTysNsplitInvisPiTysinvisibleTyBndrCountsplitForAllTyCoVarBindersgetRuntimeArgTys splitPiTys splitPiTysplitPiTy_maybesplitForAllCoVar_maybesplitForAllTyVar_maybesplitForAllTyCoVar_maybe dropForAllssplitForAllTyCoVarisFunTyisPiTy isForAllTy_co isForAllTy_ty isForAllTysplitForAllInvisTVBinderssplitForAllReqTVBinderssplitForAllTyCoVarsmkTyConBindersPreferAnonmkVisForAllTysmkSpecForAllTysmkSpecForAllTymkInfForAllTysmkTyCoInvForAllTys mkInfForAllTymkTyCoInvForAllTystripCoercionTyisCoercionTy_maybe mkCoercionTytyConBindersTyCoBinderssplitCastTy_maybenewTyConInstRhssplitListTyConApp_maybetcRepSplitTyConApp_mayberepSplitTyConApp_maybetcSplitTyConApp_maybe splitTyConApp tyConAppArgN tyConAppArgstyConAppArgs_maybe tyConAppTyContyConAppTyConPicky_maybe applyTysX piResultTysfunArgTy funResultTy splitFunTyssplitFunTy_maybe splitFunTypprUserTypeErrorTyuserTypeError_maybeisLitTy isCharLitTy mkCharLitTy isStrLitTy mkStrLitTy isNumLitTy mkNumLitTyrepSplitAppTys splitAppTys splitAppTytcRepSplitAppTy_mayberepSplitAppTy_maybesplitAppTy_maybemkAppTysrepGetTyVar_maybegetCastedTyVar_maybegetTyVar_maybe isTyVarTygetTyVarmapTyCoXmapTyCoisMultiplicityVar isLevityVarisRuntimeRepVarisUnliftedLevityisLiftedLevityisUnliftedRuntimeRepisLiftedRuntimeRepruntimeRepLevity_maybeisBoxedRuntimeRepisUnliftedTypeKindpickyIsLiftedTypeKindisBoxedTypeKind kindRep_maybekindRepexpandTypeSynonymsOneMany tcm_tycontcm_tycobindertcm_hole tcm_covar tcm_tyvar TyCoMapperGHC.Builtin.Types.PrimfunTyCon alphaTyVarsGHC.Core.TyCo.Subst substTyCoBndrcloneTyVarBndrscloneTyVarBndrsubstCoVarBndr substVarBndrs substVarBndrsubstTyVarBndrssubstTyVarBndr lookupCoVar substCoVars substCoVarsubstCossubstCoUnchecked lookupTyVar substTyVars substTyVarsubstThetaUnchecked substThetasubstScaledTysUncheckedsubstTysUncheckedsubstScaledTyssubstTyssubstScaledTyUnchecked substScaledTysubstTyUncheckedsubstTyAddInScope substTysWithsubstCoWithUnchecked substCoWithsubstTyWithUnchecked substTyWithzipCoEnvzipTyEnv mkTvSubstPrs zipTCvSubst zipTvSubst unionTCvSubstextendTCvSubstListextendTvSubstAndInScope extendCvSubstextendTvSubstWithCloneextendTvSubstBinderAndInScopeextendTCvSubstWithCloneextendTCvSubstextendTCvInScopeSetextendTCvInScopeListextendTCvInScope zapTCvSubst setTvSubstEnvnotElemTCvSubstgetTCvSubstRangeFVs getTCvInScope getCvSubstEnv getTvSubstEnv mkTCvSubstisEmptyTCvSubstmkEmptyTCvSubst emptyTCvSubstcomposeTCvSubstcomposeTCvSubstEnvemptyCvSubstEnvemptyTvSubstEnvTCvSubst TvSubstEnv CvSubstEnvGHC.Core.TyCo.TidytidyCostidyCo tidyTopType tidyOpenType tidyOpenTypestidyType tidyTypestidyTyCoVarOcctidyOpenTyCoVartidyOpenTyCoVarstidyFreeTyCoVarstidyTyCoVarBinderstidyTyCoVarBinder tidyVarBndr tidyVarBndrsGHC.Core.TyCo.FVstyCoVarsOfTypesWellScopedtyCoVarsOfTypeWellScoped scopedSortnoFreeVarsOfTypeanyFreeVarsOfCoanyFreeVarsOfTypesanyFreeVarsOfType tyCoFVsOfCos tyCoFVsOfCotyCoVarsOfCoDSettyCoFVsVarBndrtyCoFVsVarBndrs tyCoFVsBndr tyCoFVsOfTypetyCoVarsOfTypeDSetcloseOverKindsDSetcloseOverKindsListcloseOverKinds coVarsOfCo coVarsOfTypes coVarsOfType tyCoVarsOfCos tyCoVarsOfCotyCoVarsOfTypestyCoVarsOfTypeGHC.Core.TyCo.Rep coercionSizetypeSizenoViewfoldTyCosetCoHoleCoVar coHoleCoVarmkPiTysmkPiTymkInvisForAllTys mkForAllTysmkInvisFunTysManymkVisFunTysMany mkVisFunTysmkInvisFunTyManymkVisFunTyMany mkInvisFunTy mkVisFunTymkFunTy mkTyVarTys mkTyVarTy isNamedBinderisVisibleBinderisInvisibleBinder KindOrTypeKnotTied CoercionR CoercionPMCoMRefl MCoercionRch_ref ch_co_var CoercionHoletcf_tycobindertcf_hole tcf_covar tcf_tyvartcf_view TyCoFolderGHC.Core.TyContyConClass_maybe isClassTyConsynTyConRhs_maybesynTyConDefn_maybe tyConDataConsisOpenTypeFamilyTyConisTypeFamilyTyConisOpenFamilyTyCon isFamilyTyConisTypeSynonymTyCon isNewTyConisConstraintKindCon isPrimTyCon isGcPtrRep isVoidRep tyConTyVars tyConArity tyConKindGHC.Builtin.Names isUnboundName mkUnboundNameGHC.Core.Class pprFundeps classTvsFds classSCThetaclassATs classMethodsClassmkReflCo mkTyConAppComkAppCo mkForAllComkFunCo mkCoVarCo mkAxiomInstCo mkPhantomComkUnivComkSymCo mkTransComkNthComkLRComkInstCo mkGReflCo mkNomReflComkKindComkSubComkProofIrrelCo mkAxiomRuleCo isGReflCoisReflCo isReflexiveCodecomposePiCoscoVarKindsTypesRole coVarRolemkCoercionType liftCoSubstseqCo coercionKind coercionLKind coercionRKind coercionTypetopNormaliseNewType_maybeLiftingContextGHC.Core.Coercion.AxiomPhantomRepresentationalNominalRolesfInteractInert sfInteractTop sfMatchFamBuiltInSynFamilyGHC.Parser.AnnotationAnnRarrowtailU AnnRarrowtailAnnLarrowtailU AnnLarrowtailAnnrarrowtailU AnnrarrowtailAnnlarrowtailU AnnlarrowtailAnnWhereAnnViaAnnVbar AnnValStrAnnValAnnUsingAnnUnitAnnTypeAnnTilde AnnThTyQuoteAnnThenAnnStock AnnStatic AnnSignatureAnnSimpleQuoteAnnSemiAnnSafeAnnRoleAnnRec AnnRarrowU AnnRarrow AnnQualifiedAnnProc AnnPercentOne AnnPercent AnnPatternAnnPackageNameAnnDollarDollar AnnDollar AnnOpenPHAnnOpenSAnnOpenP AnnOpenEQU AnnOpenEQAnnOpenEAnnOpenC AnnOpenBUAnnOpenBAnnOpenAnnOfAnnName AnnNewtype AnnModuleAnnMinusAnnMdo AnnLollyUAnnLet AnnLarrowU AnnLarrowAnnLam AnnInstanceAnnInfixAnnIn AnnImportAnnIf AnnHiding AnnHeaderAnnGroupAnnFunId AnnForeign AnnForallU AnnForall AnnFamily AnnExportAnnEqualAnnElse AnnDotdotAnnDotAnnDo AnnDeriving AnnDefault AnnDcolonU AnnDcolonAnnData AnnDarrowU AnnDarrow AnnCommaTupleAnnCommaAnnColon AnnCloseS AnnClosePH AnnCloseP AnnCloseQU AnnCloseQ AnnCloseC AnnCloseBU AnnCloseBAnnCloseAnnClassAnnCaseAnnBy AnnBackquoteAnnBangAnnAtAnnAs AnnAnyclass AnnKeywordId ac_prior_tokac_tok EpaCommentGHC.Types.Name.ReadergresFromAvailsQualUnqualRdrNameGHC.Types.Var.Env InScopeSet GHC.Types.Var isExportedId isGlobalId isLocalIdisCoVarisIdisTyVar setIdMultupdateIdTypeAndMultMupdateIdTypeAndMultupdateIdTypeButNotMult globaliseIdmkCoVar idDetailsidInfo tyVarKindmkTyVarBindersmkTyCoVarBinders mkTyVarBindermkTyCoVarBinder binderType binderArgFlag binderVars binderVartyVarSpecToBinderssameVisisInvisibleArgFlagisVisibleArgFlagInferred SpecifiedCoVarJoinIdInVarInIdOutVarOutIdvarTypeRequired Invisible SpecifiedSpec InferredSpecInvisArgVisArg TyCoVarBinder TyVarBinderGHC.Types.Name pprPrefixName pprInfixNamegetOccFS getOccString getSrcSpan getSrcLocnameStableStringpprNameDefnLoc pprDefinedAtpprModulePrefixpprNameUnqualified pprTickyName pprFullName stableNameCmp localiseName setNameLoc mkFCallName mkSysTvNamemkSystemVarNamemkSystemNameAt mkSystemName mkWiredInNamemkExternalNamemkDerivedInternalNamemkClonedInternalNamemkInternalName isSystemName isVarName isValName isDataConName isTyConName isTyVarNamenameIsFromExternalPackagenameIsHomePackageImportnameIsHomePackagenameIsExternalOrFromnameIsLocalOrFromnameModule_maybe nameModule isDynLinkName isHoleNameisInternalNameisExternalNameisBuiltInSyntaxwiredInNameTyThing_maybe isWiredIn isWiredInName nameSrcSpan nameSrcLoc nameNameSpace UserSyntax BuiltInSyntaxGHC.Types.Name.Occurrence tidyOccNameavoidClashesOccEnvdelTidyOccEnvListinitTidyOccEnvemptyTidyOccEnv mkMethodOcc mkDFunOcc mkInstTyTcOcc mkLocalOccmkSuperDictSelOccmkSuperDictAuxOccmkDataConWorkerOccmkGen1RmkGenR mkTyConRepOcc mkDataCOcc mkDataTOcc mkMaxTagOcc mkTag2ConOcc mkCon2TagOcc mkEqPredCoOcc mkInstTyCoOcc mkNewTyCoOccmkClassDataConOcc mkRepEqOccmkForeignExportOcc mkSpecOccmkIPOcc mkDictOccmkClassOpAuxOccmkDefaultMethodOcc mkBuilderOcc mkMatcherOcc mkWorkerOccmkDataConWrapperOccisTypeableBindOccisDefaultMethodOccisDerivedOccNamestartsWithUnderscore parenSymOccisSymOcc isDataSymOcc isDataOccisValOccisTcOccisTvOccisVarOccsetOccNameSpace occSetToEnv filterOccSetintersectOccSet isEmptyOccSet elemOccSet minusOccSetunionManyOccSets unionOccSetsextendOccSetList extendOccSetmkOccSet unitOccSet emptyOccSet pprOccEnv minusOccEnv_C minusOccEnv alterOccEnv filterOccEnvdelListFromOccEnv delFromOccEnv mkOccEnv_C mapOccEnvextendOccEnv_AccextendOccEnv_C plusOccEnv_C plusOccEnvnonDetOccEnvElts foldOccEnv elemOccEnvmkOccEnv lookupOccEnvextendOccEnvList extendOccEnv unitOccEnv emptyOccEnvpromoteOccName demoteOccName mkClsOccFSmkClsOcc mkTcOccFSmkTcOcc mkTyVarOccFS mkTyVarOcc mkDataOccFS mkDataOccmkVarOcc mkOccNameFS mkOccName pprOccNamepprNameSpaceBriefpprNonVarNameSpace pprNameSpaceisValNameSpaceisVarNameSpace isTvNameSpaceisTcClsNameSpaceisDataConNameSpacetvName srcDataNamedataName tcClsNameclsNametcName NameSpace occNameFS occNameSpaceOccEnvOccSet TidyOccEnvGHC.Builtin.TypesunliftedTypeKindliftedTypeKindunrestrictedFunTyCon dataConTyCondataConFieldLabelsDataConGHC.Data.FastString.EnvmkFsEnv lookupFsEnv extendFsEnv emptyFsEnv FastStringEnvGHC.Driver.Backend NoBackend InterpreterViaCLLVMNCGBackendGHC.Driver.PhasesPhaseGHC.Types.Basicfailed succeededpickLRCRightCLeft LeftOrRightConTagZFailed Succeeded SuccessFlagpprCoisPredTy isCoercionTymkAppTymkCastTy mkTyConTy mkTyConApp piResultTycoreViewtcViewisRuntimeRepTy isLevityTyisMultiplicityTyisLiftedTypeKind mkTYPEappsplitTyConApp_maybetyConAppTyCon_maybe getLevitypartitionInvisibleTypes mkForAllTyTypeCoercionUnivCoProvenance TyCoBinder MCoercionScaledMultPredTypeKind ThetaType CoercionN MCoercionNTyThing isFunTyConTyConidNameArgFlag AnonArgFlagVar SpecificityTyVarIdTyCoVarTcTyVarGHC.Driver.FlagsOpt_G_NoOptCoercionOpt_G_NoStateHackOpt_PluginTrustworthyOpt_PackageTrustOpt_DistrustAllPackagesOpt_BuildDynamicTooOpt_KeepOFilesOpt_KeepHiFilesOpt_KeepLlvmFilesOpt_KeepRawTokenStreamOpt_KeepTmpFilesOpt_KeepSFilesOpt_KeepHcFilesOpt_KeepHiDiffsOpt_KeepHscppFilesOpt_ImplicitImportQualifiedOpt_AutoLinkPackagesOpt_SuppressCoreSizesOpt_SuppressTimestampsOpt_SuppressTicksOpt_SuppressStgExtsOpt_SuppressUniquesOpt_SuppressTypeSignaturesOpt_SuppressUnfoldingsOpt_SuppressIdInfoOpt_SuppressTypeApplicationsOpt_SuppressModulePrefixesOpt_SuppressVarKindsOpt_SuppressCoercionsOpt_HexWordLiteralsOpt_ShowLoadedModulesOpt_ShowMatchesOfHoleFitsOpt_ShowProvOfHoleFitsOpt_ShowTypeOfHoleFitsOpt_ShowDocsOfHoleFitsOpt_ShowTypeAppVarsOfHoleFitsOpt_ShowTypeAppOfHoleFitsOpt_UnclutterValidHoleFitsOpt_AbstractRefHoleFitsOpt_SortBySubsumHoleFitsOpt_SortBySizeHoleFitsOpt_SortValidHoleFitsOpt_ShowValidHoleFitsOpt_ShowHoleConstraintsOpt_PprShowTicksOpt_PprCaseAsLetOpt_DiagnosticsShowCaretOpt_DeferDiagnosticsOpt_ErrorSpans Opt_LinkRts Opt_ByteCode Opt_KeepGoing Opt_KeepCAFsOpt_ExposeInternalSymbolsOpt_SingleLibFolderOpt_WholeArchiveHsLibsOpt_VersionMacrosOpt_OptimalApplicativeDoOpt_ExternalInterpreterOpt_FamAppCacheOpt_HpcOpt_CompactUnwindOpt_RelativeDynlibPaths Opt_RPath Opt_Ticky_AP Opt_Ticky_TagOpt_Ticky_Dyn_Thunk Opt_Ticky_LNEOpt_Ticky_Allocd Opt_TickyOpt_ExternalDynamicRefsOpt_PICExecutableOpt_PIEOpt_PICOpt_DeferOutOfScopeVariablesOpt_DeferTypedHolesOpt_DeferTypeErrorsOpt_HelpfulErrorsOpt_NoItOpt_LocalGhciHistoryOpt_ValidateHieOpt_GhciLeakCheckOpt_GhciHistoryOpt_GhciSandboxOpt_IgnoreDotGhciOpt_BuildingCabalPackageOpt_SharedImplibOpt_EmbedManifestOpt_GenManifestOpt_PrintBindContentsOpt_PrintEvldWithShowOpt_BreakOnErrorOpt_BreakOnExceptionOpt_HaddockOptions Opt_HaddockOpt_PrintBindResultOpt_HideAllPluginPackagesOpt_HideAllPackages Opt_StgStatsOpt_SplitSections Opt_NoHsMainOpt_EagerBlackHolingOpt_ExcessPrecisionOpt_IgnoreHpcChangesOpt_IgnoreOptimChangesOpt_ForceRecompOpt_PpOpt_ProfLateCcsOpt_ProfCountEntriesOpt_AutoSccsOnIndividualCafs Opt_WriteHieOpt_WriteInterfaceOpt_ExposeAllUnfoldingsOpt_OmitInterfacePragmasOpt_IgnoreInterfacePragmasOpt_SimplPreInliningOpt_DoTagInferenceChecksOpt_FastPAPCallsOpt_CoreConstantFoldingOpt_NumConstantFoldingOpt_CatchNonexhaustiveCasesOpt_AlignmentSanitisationOpt_SolveConstantDictsOpt_WorkerWrapperUnliftOpt_WorkerWrapper Opt_CprAnalOpt_WeightlessBlocklayoutOpt_CfgBlocklayoutOpt_LoopificationOpt_DmdTxDictSelOpt_DictsStrictOpt_FunToThunkOpt_OmitYieldsOpt_AsmShortcuttingOpt_CmmControlFlowOpt_CmmElimCommonBlocksOpt_CmmStaticPred Opt_CmmSinkOpt_IrrefutableTuplesOpt_LlvmFillUndefWithGarbage Opt_LlvmTBAAOpt_PedanticBottomsOpt_RegsIterative Opt_RegsGraphOpt_EnableThSpliceWarningsOpt_EnableRewriteRulesOpt_DictsCheapOpt_UnboxSmallStrictFieldsOpt_UnboxStrictFieldsOpt_CaseFolding Opt_CaseMergeOpt_DoEtaReductionOpt_IgnoreAssertsOpt_DoLambdaEtaExpansionOpt_SpecConstrKeenOpt_SpecConstrOpt_LiberateCaseOpt_StgLiftLams Opt_StgCSEOpt_CSE Opt_StaticArgumentTransformationOpt_InlineGenericsAggressivelyOpt_InlineGenericsOpt_CrossModuleSpecialiseOpt_SpecialiseAggressivelyOpt_SpecialiseOpt_LateSpecialise Opt_FloatInOpt_FullLazinessOpt_KillOneShotOpt_KillAbsenceOpt_LateDmdAnalOpt_StrictnessOpt_Exitification Opt_CallArityOpt_PrintTypecheckerElaborationOpt_PrintPotentialInstancesOpt_PrintExpandedSynonymsOpt_PrintUnicodeSyntaxOpt_PrintAxiomIncompsOpt_PrintEqualityRelationsOpt_PrintExplicitRuntimeRepsOpt_PrintExplicitCoercionsOpt_PrintExplicitKindsOpt_PrintExplicitForallsOpt_HideSourcePathsOpt_ShowWarnGroupsOpt_WarnIsErrorOpt_InfoTableMapOpt_DistinctConstructorTablesOpt_NoTypeableBinds Opt_FastLlvmOpt_NoLlvmManglerOpt_DoBoundsCheckingOpt_DoAnnotationLintingOpt_DoAsmLintingOpt_DoCmmLintingOpt_DoStgLintingOpt_DoLinearCoreLintingOpt_DoCoreLintingOpt_D_dump_minimal_importsOpt_DumpToFile GeneralFlagGHC.Types.Fixity compareFixity negateFixity defaultFixity maxPrecedenceInfixNInfixRInfixLFixityDirectionInfixPrefix LexicalFixityGHC.Types.SafeHaskell Sf_IgnoreSf_SafeInferredSf_SafeSf_Trustworthy Sf_UnsafeSf_NoneSafeHaskellModeGHC.Types.SourceFilehscSourceToIsBootGHC.Types.PkgQualOtherPkgThisPkg NoPkgQualPkgQualGHC.Types.BreakInfobreakInfo_numberbreakInfo_module BreakInfoGHC.Unit.Module.Location ml_hie_fileml_dyn_obj_file ml_obj_fileml_dyn_hi_file ml_hi_file ml_hs_file ModLocationGHC.Unit.TypesmkModuleIsBootNotBootIsBootInterfaceGHC.Unit.Module.Name mkModuleNamemoduleNameStringGHC.Utils.Binary putDictionary nameUnique setNameUnique nameOccName tidyNameOccNamegetName getOccName NamedThingGHC.Tc.Types.RankMustBeMonoTypeMonoTypeConstraintMonoTypeSynArgMonoTypeTyConArgMonoTypeRankZero LimitedRank ArbitraryRankRankGHC.Types.SrcLoc unRealSrcSpangetRealSrcSpan isSubspanOfspansleftmost_largestleftmost_smallestrightmost_smallest cmpLocated eqLocatedaddCLoc combineLocsmkGeneralLocatednoLocgetLocunLoc srcSpanEnd srcSpanStart srcSpanEndColsrcSpanStartColsrcSpanEndLinesrcSpanStartLine isGoodSrcSpan mkSrcSpan srcLocSpan noSrcSpan srcLocCol srcLocLine srcLocFilenoSrcLocmkSrcLoc RealSrcLoc UnhelpfulLocSrcLoc srcSpanFile RealSrcSpan UnhelpfulSpanSrcSpanL GenLocatedLocated RealLocatedGHC.Types.Unique.Supply UniqSupply getUniquesM getUniqueMgetUniqueSupplyM MonadUniqueGHC.Types.UniqueUnique getUnique UniquableGHC.Utils.PanicwithSignalHandlersshowGhcExceptionPprProgramError ProgramErrorInstallationErrorPprSorrySorryPprPanicPanic CmdLineError UsageErrorSignal GhcExceptionGHC.Utils.Outputable alwaysQualifyPrintUnqualified occNameStringmkRecFldSelOcc mkVarOccFSOccNameoccName HasOccName moduleName moduleUnit pprModuleModuleUnitGHC.Utils.CliOptionOption FileOption ModuleNameGHC.Cmm.Dataflow.BlocklastNodeOCBlockGHC.Cmm.Dataflow.CollectionsmapEmptyGHC.Data.SizedSeqsizeSSssEltsSizedSeq GHC.BaseDir expandTopDirtemplateHaskellNamesthSynthLibqqLib 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 getFieldENameprojectionEName fieldExpName guardedBName normalBName normalGEName patGEName bindSNameletSName noBindSNameparSNamerecSNamefunDNamevalDName dataDName newtypeDName tySynDName classDNameinstanceWithOverlapDName standaloneDerivWithStrategyDNamesigDName kiSigDName defaultDNamedefaultSigDName forImpDName pragInlDName pragSpecDNamepragSpecInlDNamepragSpecInstDName pragRuleDNamepragCompleteDName pragAnnDName dataInstDNamenewtypeInstDNametySynInstDNameopenTypeFamilyDNameclosedTypeFamilyDNamedataFamilyDName infixLDName infixRDName infixNDNameroleAnnotDName patSynDNamepatSynSigDNameimplicitParamBindDNamecxtNamenoSourceUnpackednessNamesourceNoUnpackNamesourceUnpackNamenoSourceStrictnessNamesourceLazyNamesourceStrictName normalCNamerecCName infixCName forallCName gadtCName recGadtCNamebangName bangTypeNamevarBangTypeNameunidirPatSynNameimplBidirPatSynNameexplBidirPatSynNameprefixPatSynNameinfixPatSynNamerecordPatSynName forallTNameforallVisTNamevarTNameconTName tupleTNameunboxedTupleTNameunboxedSumTName arrowTName mulArrowTName listTNameappTName appKindTNamesigTName equalityTNamelitTName promotedTNamepromotedTupleTNamepromotedNilTNamepromotedConsTName wildCardTName infixTNameimplicitParamTName numTyLitName strTyLitName charTyLitName plainTVName kindedTVNameplainInvisTVNamekindedInvisTVNamespecifiedSpecNameinferredSpecName nominalRNamerepresentationalRName phantomRName inferRName starKNameconstraintKName noSigName kindSigName tyVarSigNameinjectivityAnnName cCallName stdCallName cApiCallName primCallNamejavaScriptCallName unsafeNamesafeNameinterruptibleName ruleVarNametypedRuleVarName funDepName tySynEqnNamevalueAnnotationNametypeAnnotationNamemoduleAnnotationNamederivClauseNamestockStrategyNameanyclassStrategyNamenewtypeStrategyNameviaStrategyName expQTyConNamedecsQTyConNametypeQTyConName patQTyConName stmtTyConName conTyConNamebangTypeTyConNamevarBangTypeTyConNameruleBndrTyConNametySynEqnTyConName roleTyConNamederivClauseTyConName kindTyConNametyVarBndrUnitTyConNametyVarBndrSpecTyConNamederivStrategyTyConName quoteExpName quotePatName quoteDecName quoteTypeNamenoInlineDataConNameinlineDataConNameinlinableDataConNameopaqueDataConNameconLikeDataConNamefunLikeDataConNameallPhasesDataConNamefromPhaseDataConNamebeforePhaseDataConNameoverlappableDataConNameoverlappingDataConNameoverlapsDataConNameincoherentDataConName liftClassKey quoteClassKey expTyConKey matchTyConKeyclauseTyConKey qTyConKey expQTyConKey patTyConKey stmtTyConKey conTyConKey typeQTyConKey typeTyConKey decTyConKeybangTypeTyConKeyvarBangTypeTyConKeyfieldExpTyConKeyfieldPatTyConKey nameTyConKey patQTyConKeyfunDepTyConKey predTyConKey predQTyConKeytyVarBndrUnitTyConKey decsQTyConKeyruleBndrTyConKeytySynEqnTyConKey roleTyConKeyinjAnnTyConKey kindTyConKeyoverlapTyConKeyderivClauseTyConKeyderivStrategyTyConKey decsTyConKeytyVarBndrSpecTyConKey codeTyConKeymodNameTyConKeynoInlineDataConKeyinlineDataConKeyinlinableDataConKeyopaqueDataConKeyconLikeDataConKeyfunLikeDataConKeyallPhasesDataConKeyfromPhaseDataConKeybeforePhaseDataConKeyoverlappableDataConKeyoverlappingDataConKeyoverlapsDataConKeyincoherentDataConKey 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 mdoEIdKeygetFieldEIdKeyprojectionEIdKey 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 kiSigDIdKey defaultDIdKeycxtIdKeynoSourceUnpackednessKeysourceNoUnpackKeysourceUnpackKeynoSourceStrictnessKey sourceLazyKeysourceStrictKey normalCIdKey recCIdKey infixCIdKey forallCIdKey gadtCIdKey recGadtCIdKey bangIdKeybangTKey varBangTKeyunidirPatSynIdKeyimplBidirPatSynIdKeyexplBidirPatSynIdKeyprefixPatSynIdKeyinfixPatSynIdKeyrecordPatSynIdKey forallTIdKeyforallVisTIdKey varTIdKey conTIdKey tupleTIdKeyunboxedTupleTIdKeyunboxedSumTIdKey arrowTIdKey listTIdKey appTIdKey appKindTIdKey sigTIdKeyequalityTIdKey litTIdKeypromotedTIdKeypromotedTupleTIdKeypromotedNilTIdKeypromotedConsTIdKeywildCardTIdKeyimplicitParamTIdKey infixTIdKey numTyLitIdKey strTyLitIdKeycharTyLitIdKey plainTVIdKey kindedTVIdKeyplainInvisTVIdKeykindedInvisTVIdKey nominalRIdKeyrepresentationalRIdKey phantomRIdKey inferRIdKey starKIdKeyconstraintKIdKey noSigIdKey kindSigIdKey tyVarSigIdKeyinjectivityAnnIdKey cCallIdKey stdCallIdKey cApiCallIdKey primCallIdKeyjavaScriptCallIdKey unsafeIdKey safeIdKeyinterruptibleIdKey funDepIdKeymulArrowTIdKey tySynEqnIdKey quoteExpKey quotePatKey quoteDecKey quoteTypeKey ruleVarIdKeytypedRuleVarIdKeyvalueAnnotationIdKeytypeAnnotationIdKeymoduleAnnotationIdKeyderivClauseIdKeystockStrategyIdKeyanyclassStrategyIdKeynewtypeStrategyIdKeyviaStrategyIdKeyspecifiedSpecKeyinferredSpecKeylift_RDR liftTyped_RDRunsafeCodeCoerce_RDR mkNameG_dRDR mkNameG_vRDRconE_RDRlitE_RDRappE_RDR infixApp_RDR stringL_RDR intPrimL_RDR wordPrimL_RDRfloatPrimL_RDRdoublePrimL_RDRstringPrimL_RDR charPrimL_RDR typeNatTyConstypeNatAddTyContypeNatSubTyContypeNatMulTyContypeNatDivTyContypeNatModTyContypeNatExpTyContypeNatLogTyContypeNatCmpTyContypeSymbolCmpTyContypeSymbolAppendTyContypeConsSymbolTyContypeUnconsSymbolTyContypeCharToNatTyContypeNatToCharTyContypeNatCoAxiomRulestypeCharCmpTyCon knownKeyNameslookupKnownKeyNameisKnownKeyNamelookupKnownNameInfoghcPrimExportsghcPrimDeclDocsmaybeCharLikeConmaybeIntLikeConisNumericClassisStandardClass ClosureEnvemptyClosureEnvextendClosureEnvlinkBCOlookupStaticPtrlookupIElinkFail nameToCLabel CmmConfig cmmProfilecmmOptControlFlow cmmDoLintingcmmOptElimCommonBlks cmmOptSinkcmmGenStackUnwindInstrcmmExternalDynamicRefscmmDoCmmSwitchPlanscmmSplitProcPoints cmmPlatform RewriteFun TransferFunDataflowLatticefact_bot fact_join JoinedFactChanged NotChangedNewFactOldFactFact changedIf analyzeCmmBwd analyzeCmmFwd rewriteCmmBwdgetFact joinOutFacts joinFacts mkFactBasefoldNodesBwdOOfoldRewriteNodesBwdOO InitOrFini IsInitArray IsFiniArrayisInitOrFiniArrayLRegKeyLRegSet emptyLRegSet nullLRegSet insertLRegSet elemLRegSetdeleteFromLRegSet sizeLRegSet plusLRegSet elemsLRegSetPDunPDliftP failMsgPD getProfile getPlatform 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$fShowCmmTokenpprExprpprLit$fOutputablePenvGlobalReg$fOutputableGlobalReg$fOutputableArea$fOutputableLocalReg$fOutputablePPlatformCmmLit$fOutputableCmmReg$fOutputablePPlatformCmmExprpprCmms pprCmmGroup pprStatic pprSection$fOutputableForeignHint!$fOutputablePPlatformCmmInfoTable$fOutputablePPlatformCmmStatic"$fOutputablePPlatformGenCmmStatics$fOutputablePPlatformGenCmmDecl CmmLocalLive liveLatticecmmLocalLivenesscmmGlobalLivenessgen_kill liveLatticeLcmmLocalLivenessL gen_killLprimRepCmmType slotCmmType typeCmmTypeprimRepForeignHinttypeForeignHint mkIntCLit mkIntExprzeroCLitzeroExpr mkWordCLitmkByteStringCLitmkFileEmbedLit mkDataLits mkRODataLits mkStgWordCLitpackHalfWordsCLit mkLblExpr cmmOffsetExpr cmmOffset cmmRegOff cmmOffsetLit cmmLabelOffcmmIndex cmmIndexExpr cmmLoadIndex cmmLoadBWord cmmLoadGCWord 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 cmmIsTaggedcmmIsNotTagged cmmConstrTag1 regsOverlap regUsedIn mkLiveness modifyGraph toBlockMap ofBlockMap toBlockListtoBlockListEntryFirst%toBlockListEntryFirstFalseFallthrough ofBlockListbodyToBlockList mapGraphNodesmapGraphNodes1foldlGraphBlocks revPostorder blockTicksbaseExprspExpr spLimExprhpExpr hpLimExprcurrentTSOExprcurrentNurseryExprcccsExprcmmImplementSwitchPlans $fOutputablePPlatformGenCmmGraph$fOutputablePPlatformGraph'$fOutputablePPlatformBlock$fOutputablePPlatformBlock0$fOutputablePPlatformBlock1$fOutputablePPlatformBlock2$fOutputableCmmReturnInfo"$fOutputablePPlatformForeignTarget$fOutputableForeignConvention$fOutputableConvention$fOutputablePPlatformCmmNode$fOutputablePPlatformCmmTopInfo$fOutputableCmmStackInfo $fOutputablePPlatformInfoProvEnt ParamLocation RegisterParam StackParamassignArgumentsPos assignStackrealArgRegsCovertupleRegsCover$fOutputableParamLocationTransferCallJumpRetJumpRetCgStmtCgLabelCgLastCgForkCmmAGraphScoped CmmAGraph catAGraphsmkLabelmkMiddlemkLast outOfLinelgraphOfAGraph labelAGraphmkNop mkCommentmkAssignmkStoremkJump mkRawJump mkJumpExtra mkCbranchmkSwitchmkReturnmkBranch mkFinalCallmkCallReturnsTomkJumpReturnsTo mkUnsafeCallmkUnwind stackStubExpr copyInOflow copyOutOflow mkCallEntry noExtraStacktoCall $fEqTransferconstantFoldNodeconstantFoldExpr cmmMachOpFoldcmmMachOpFoldMcmmSinkcmmLint cmmLintGraph$fMonadCmmLint$fApplicativeCmmLint$fFunctorCmmLint UnwindExprUwConstUwRegUwDerefUwLabelUwPlusUwMinusUwTimes UnwindTable UnwindPoint DebugBlock dblProceduredblLabel dblCLabel dblHasInfoTbl dblParentdblTicks dblSourceTick dblPosition dblUnwind dblBlocks cmmDebugGencmmDebugLabels cmmDebugLink debugToMap toUnwindExpr$fOutputablePenvUnwindExpr$fOutputablePenvUnwindPoint$fOutputablePenvDebugBlock$fEqUnwindExpr cmmCfgOptscmmCfgOptsProc replaceLabelsremoveUnreachableBlocksProcelimCommonBlocksCondALWAYSEQNESLTSLESGESGTULTULEUGEUGTOLTOLEOGEOGTUOLTUOLEUOGEUOGTNEVERVSVC$fEqCondRootedGraphEdgePathNodedompdomdomTreepdomTreeidomipdompddfsrpddfsfromAdj fromEdgestoAdjtoEdgesparents ancestorsasGraphasTree$fApplicativeS$fMonadS $fFunctorS popCntLabel pdepLabel pextLabel bSwapLabel bRevLabelclzLabelctzLabelword2FloatLabelatomicRMWLabel xchgLabel cmpxchgLabelatomicReadLabelatomicWriteLabel NCGConfig ncgPlatform ncgAsmContext ncgThisModulencgProcAlignmentncgExternalDynamicRefsncgPICncgInlineThresholdMemcpyncgInlineThresholdMemsetncgSplitSectionsncgRegsIterative ncgRegsGraph ncgAsmLintingncgDoConstantFolding ncgSseVersion ncgBmiVersionncgDumpRegAllocStagesncgDumpAsmStatsncgDumpAsmConflicts ncgCfgWeightsncgCfgBlockLayoutncgCfgWeightlessLayoutncgDwarfEnabledncgDwarfUnwindingsncgDwarfStripBlockInfoncgExposeInternalSymbolsncgDwarfSourceNotesncgCmmStaticPredncgEnableShortcuttingncgComputeUnwindingncgEnableDeadCodeElimination ncgWordWidthncgSpillPreallocSizeplatformWordWidthFormatII8II16II32II64FF32FF64 intFormat floatFormat isIntFormat isFloatFormat cmmTypeFormat formatToWidth formatInBytes $fShowFormat $fEqFormatImmImmInt ImmIntegerImmCLblImmLitImmIndexImmFloat ImmDoubleImmConstantSumImmConstantDiffAddrMode AddrRegReg AddrRegImmAddrReg allMachRegNosallocatableRegs allGpArgRegs allFpArgRegs strImmLitlitToImmvirtualRegSqueezerealRegSqueeze mkVirtualRegclassOfRealReg regDotColor$fEqSDoc $fShowSDoc $fEqAddrMode$fShowAddrMode$fEqImm $fShowImm InstructionregUsageOfInstrpatchRegsOfInstrisJumpishInstrjumpDestsOfInstrpatchJumpInstr mkSpillInstr mkLoadInstrtakeDeltaInstr isMetaInstrmkRegRegMoveInstrtakeRegRegMoveInstr mkJumpInstrmkStackAllocInstrmkStackDeallocInstrpprInstrRegUsageRUreadswritesnoUsage$fShowRegUsageEQQGEGEUGTTGULELEULTTLU condNegate condUnsignedLOHIHAHIGHERAHIGHESTA addrOffsetspRelargRegs allArgRegscallClobberedRegsshowRegtoRegNo allFPArgRegs fits16Bits makeImmediatefRegr0sptocr3r4r11r12r30f1tmpRegRegSubSubL16SubL8SubL8HRegRegClassClassG32ClassG16ClassG8ClassF64worstboundsqueese$fUniquableReg $fShowReg$fEqReg $fShowRegSub $fEnumRegSub $fOrdRegSub $fEqRegSub$fShowRegClass $fEqRegClass$fEnumRegClass classOfReg regsOfClassregNameregAliasFreeRegs noFreeRegsshowBits allocateReg getFreeRegs initFreeRegs releaseReg$fOutputableFreeRegs$fShowFreeRegsStackMapstackMapNextFreeSlotstackMapAssignment StackSlot emptyStackMapgetStackSlotFor getStackUsetoRegMap toVRegMap NatBasicBlock NatCmmDeclNatCmm topInfoTable entryBlocksOperandOpRegOpRegExt OpRegShiftOpImm OpImmShiftOpAddrRegShiftExtShift ShiftModeSLSLSLSRSASRSRORExtModeEUXTBEUXTHEUXTWEUXTXESXTBESXTHESXTWESXTXTBlockTLabelTRegInstrCOMMENTMULTILINE_COMMENTANNLOCATIONLDATANEWBLOCKDELTASXTBUXTBSXTHUXTHPUSH_STACK_FRAMEPOP_STACK_FRAMEADDCMNCMPMSUBMULNEGSDIVSUBUDIVSBFMUBFMSBFXUBFXANDANDSASRBICBICSEONEORLSLLSRMOVMOVKMVNORNORRRORTSTSTRLDRSTPLDPCSETCBZCBNZJBBLBCONDDMBSYFCVTSCVTFFCVTZSFABSstackFrameHeaderSize spillSlotSize stackAlign maxSpillSlotsspillSlotToOffsetcallerSavedRegistersallocMoreStackopRegxzrwzrip0_xx0x1x2x3x4x5x6x7x8x9x10x11x12x13x14x15x16x17x18x19x20x21x22x23x24x25x26x27x28x29x30x31_dd0d1d2d3d4d5d6d7d8d9d10d11d12d13d14d15d16d17d18d19d20d21d22d23d24d25d26d27d28d29d30d31 opRegUExt opRegSExt$fOutputableRegUsage $fShowInstr $fEqOperand $fShowOperand $fEqShiftMode$fShowShiftMode $fEqExtMode $fShowExtModeJumpDest DestBlockIdgetJumpDestBlockId canShortcutshortcutStatics shortcutJump$fOutputableJumpDestPOSCARRYOFLOPARITY NOTPARITYcondToUnsigned maybeFlipCondmaybeInvertCondEAIndex EAIndexNoneEABase EABaseNone EABaseReg EABaseRip AddrBaseIndexImmAddr addrModeRegsfirstxmmlastxmmlastinteaxebxecxedxesiediebpespraxrbxrcxrdxrsirdirbprspr8r9r10r13r14r15xmm0xmm1xmm2xmm3xmm4xmm5xmm6xmm7xmm8xmm9xmm10xmm11xmm12xmm13xmm14xmm15ripRelxmm allIntArgRegsinstrClobberedRegstargetVirtualRegSqueezetargetRealRegSqueezetargetClassOfRealRegtargetMkVirtualRegtargetRegDotColortargetClassOfRegDestImmPrefetchVariantNTALvl0Lvl1Lvl2UNWINDCMOVMOVZxLMOVSxLLEAADCSBBMUL2IMULIMUL2DIVIDIVADD_CCSUB_CCORXORNOTNEGIBSWAPSHLSARSHRBTNOPX87StoreCVTSS2SDCVTSD2SS CVTTSS2SIQ CVTTSD2SIQCVTSI2SSCVTSI2SDFDIVSQRTTESTSETCCPUSHPOPJMPJXXJXX_GBLJMP_TBLCALLCLTDFETCHGOTFETCHPCPOPCNTLZCNTTZCNTBSFBSRPDEPPEXTPREFETCHLOCKXADDCMPXCHGXCHGMFENCEarchWordFormatcmmToC $fMonadTE$fApplicativeTE $fFunctorTE LlvmCgConfigllvmCgPlatform llvmCgContextllvmCgFillUndefWithGarbagellvmCgSplitSectionllvmCgBmiVersionllvmCgLlvmVersion llvmCgDoWarnllvmCgLlvmTargetllvmCgLlvmConfig LlvmVersion llvmVersionNE$fEqLlvmVersion$fOrdLlvmVersion llvmFixupAsmaddLateCostCentres cseProgram cseOneExprexitifyProgram floatInwards 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$fHasLoggerSimplM$fHasDynFlagsSimplM$fMonadUniqueSimplM $fMonadSimplM$fApplicativeSimplM$fFunctorSimplM JoinFloats JoinFloat LetFloatsSimplSRDoneExDoneIdContEx SimplFloats sfLetFloats sfJoinFloats sfInScopeSimplEnvseMode seTvSubst seCvSubst seIdSubst seInScope seCaseDepth emptyFloats pprSimplEnv mkSimplEnvgetMode seDynFlagsseLoggerseUnfoldingOptssetModeupdMode bumpCaseDepth getInScope setInScopeSetsetInScopeFromEsetInScopeFromFaddNewInScopeIds modifyInScope setSubstEnvmkContExdoFloatFromRhsemptyLetFloatsemptyJoinFloats unitLetFloat unitJoinFloat mkFloatBind extendFloats addLetFloats addJoinFloats addFloats addLetFlts letFloatBinds addJoinFlts mkRecFloats wrapFloatswrapJoinFloatsXwrapJoinFloatsgetTopFloatBinds mapLetFloatssubstIdrefineFromInScope lookupRecBndr simplBinders simplBindersimplNonRecBndr simplRecBndrssimplNonRecJoinBndrsimplRecJoinBndrs$fOutputableSimplSR$fOutputableFloatFlag$fOutputableLetFloats$fOutputableSimplFloatsArgSpecValArgTyArgCastByas_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_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 simplTopBinds simplExpr simplRules specProgram$fOutputableSpecEnv$fOutputableDictBind$fOutputableSpecArg$fOutputableCallInfo$fOutputableCallInfoSet$fOutputableUsageDetails doStaticArgsTyConSetisEmptyTyConSet emptyTyConSet unitTyConSet mkTyConSetextendTyConSetListextendTyConSet unionTyConSetunionTyConSets minusTyConSet elemTyConSetdelFromTyConSetfilterTyConSetintersectTyConSetdisjointTyConSetdelListFromTyConSetintersectsTyConSet nameSetAny nameSetAllIsRecDataConResultDefinitelyRecursiveNonRecursiveOrUnsureUnboxingDecision StopUnboxing DropAbsentUnboxUnliftDataConPatContextdcpc_dc dcpc_tc_argsdcpc_coWwOptsMkWwOpts wo_fam_envswo_simple_opts wo_cpr_anal wo_modulewo_unlift_strict initWwOpts mkWwBodiesisWorkerSmallEnoughneedsVoidWorkerArgaddVoidWorkerArg badWorker goodWorker isGoodWorkerwantToUnboxArgmkWWstr mkWWstr_onemkAbsentFillerdubiousDataConInstArgTys findTypeShape isRecDataCon$fOutputableIsRecDataConResult$fEqIsRecDataConResult$fShowIsRecDataConResult wwTopBindsspecConstrProgram$fOutputableValue$fOutputableHowBound$fOutputableCall$fOutputableArgOcc$fOutputableScUsage$fOutputableCallPatBitmapmkBitmapintsToReverseBitmapmAX_SMALL_BITMAP_SIZEmkEmptyContInfoTable cmmToRawCmm srtEscapeclosureInfoPtr entryCode getConstrTagcmmGetClosureType infoTableinfoTableConstrTaginfoTableSrtBitmapinfoTableClosureType infoTablePtrsinfoTableNonPtrs funInfoTable funInfoAritystdInfoTableSizeWfixedInfoTableSizeWprofInfoTableSizeWmaxStdInfoTableSizeWmaxRetInfoTableSizeWstdInfoTableSizeBstdSrtBitmapOffsetstdClosureTypeOffset stdPtrsOffsetstdNonPtrsOffsetconInfoTableSizeBLDLDFARLASTSTFARSTUSTCLISLIMRCMPLBCCBCCFARMTCTRBCTRBCTRLADDOADDCADDEADDZEADDISSUBFSUBFOSUBFCSUBFEMULLMULLOMFOVMULHUANDCNANDORISXORISEXTSCNTLZSLSRSRARLWINMCLRLICLRRIFADDFSUBFMULFNEGFCMPFCTIWZFCTIDZFCFIDFRSPCRNORMFCRMFLRHWSYNCISYNCLWSYNCRIRIRegRIImmmakeFarBranchesFR frAllocateReg frGetFreeRegsfrInitFreeRegs frReleaseReg $fFRFreeRegs $fFRFreeRegs0 $fFRFreeRegs1 $fFRFreeRegs2Status ReachedBy ProcPoint ProcPointSetprocPointAnalysiscallProcPointsminimalProcPointSetsplitAtProcPointsattachContInfoTables$fOutputableStatusnodeId nodeClass nodeColor nodeConflictsnodeExclusionsnodePreference nodeCoalescegraphMapTriv initGraphgraphMapModifynewNode trivColorable lookupNodegetNodeaddNodedelNodemodNodesizeunion addConflict delConflict addConflicts addExclusion addExclusions addCoalesce delCoalesce addPreference coalesceGraph coalesceNodes freezeNodefreezeOneInGraphfreezeAllInGraph scanGraph validateGraphslurpNodeConflictCountsetColor dumpGraphdotGraph colorGraph UnVarGraphUnVarSet emptyUnVarSet elemUnVarSetisEmptyUnVarSet delUnVarSet mkUnVarSet varEnvDomextendUnVarSet unionUnVarSetunionUnVarSetsemptyUnVarGraphunionUnVarGraphunionUnVarGraphscompleteBipartiteGraph completeGraph neighbors hasLoopAt$fOutputableUnVarSet$fOutputableUnVarGraph $fEqUnVarSetcallArityAnalProgram callArityRHSLinkInfoPoint writePoint readPointfreshreprfind equivalent $fEqPointEdgeInfotransitionSource edgeWeightTransitionSource CmmSource AsmCodeGen trans_cmmNode trans_infoCfgEdgeedgeFromedgeToedgeInfoCFG EdgeWeightweightToDouble mkWeightInfoadjustEdgeWeight setEdgeWeight getCfgNodeshasNodesanityCheckCfg filterEdgesshortcutWeightMapaddImmediateSuccessoraddEdge addWeightEdgedelEdgegetSuccEdgesSortedgetSuccessorEdges getEdgeInfo reverseEdges infoEdgeListedgeList getSuccessorspprEdgeWeightsaddNodesBetween getCfgProcgetCfg optimizeCFG loopMembers loopLevelsloopInfomkGlobalWeights$fOutputableEdgeWeight$fOutputableBranchInfo$fOutputableEdgeInfo$fOutputableCfgEdge $fOrdCfgEdge $fEqCfgEdge$fOutputableLoopInfo$fNonLocalBlockNode $fEqEdgeInfo$fEqTransitionSource$fEqBranchInfo$fEqEdgeWeight$fOrdEdgeWeight$fEnumEdgeWeight$fNumEdgeWeight$fRealEdgeWeight$fFractionalEdgeWeightLiveBasicBlockLiveInfoLivenessliveBorn 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 SpillJoinRMLocInRegInMemInBothBlockAssignmentlookupBlockAssignmentlookupFirstUsedemptyBlockAssignmentupdateBlockAssignment regsOfLoc$fOutputableLoc$fEqLoc $fShowLoc$fOrdLoc$fEqReadingOrWriting$fOrdReadingOrWritingbinSpillReasonscountRegRegMovesNatpprStatsRegM getConfigrunRspillRloadR getFreeRegsR setFreeRegsR getAssigR setAssigRgetBlockAssigRsetBlockAssigR setDeltaR getDeltaR getUniqueR recordSpillrecordFixupBlock $fMonadRegM$fApplicativeRegM $fFunctorRegM joinToTargetsregAlloc cleanSpills$fOutputableStore$fUniquableStore SpillStatsspillStoreLoadregSpill accSpillSL$fOutputableSpillStats regCoalesce slurpJoinMovs SpillCostInfoSpillCostRecordzeroSpillCostInfoplusSpillCostInfoplusSpillCostRecordslurpSpillCostInfo chooseSpilllifeMapFromSpillCostInfopprSpillCostRecordRegAllocStatsStartRegAllocStatsSpillRegAllocStatsColored raLiveCmmraGraph raSpillCosts raPlatformraCode raCoalesced raSpillStats raSpilledraGraphColoredraCodeCoalesced raPatched raSpillCleanraFinalraSRMspprStatsSpillspprStatsLifetimespprStatsConflictpprStatsLifeConflict countSRMsaddSRM$fOutputableRegAllocStats$fFunctorRegAllocStats RegCode64Reg64NatM DwarfFiles NatM_Statenatm_us natm_delta natm_importsnatm_pic natm_config natm_modloc natm_fileidnatm_debug_mapnatm_cfgNcgImpl ncgConfig cmmTopCodeGengenerateJumpTableForInstr pprNatCmmDeclncgAllocMoreStackncgMakeFarBranchesextractUnwindPointsinvertCondBranches mkNatM_StateinitNat mapAccumLNat getUniqueNat getDeltaNat getCfgWeights setDeltaNatgetThisModuleNat addImportNat updateCfgNataddNodeBetweenNataddImmediateSuccessorNat getBlockIdNatgetNewLabelNat getNewRegNat getNewReg64 localReg64getPicBaseMaybeNat getPicBaseNat getModLoc getFileId getDebugBlock$fHasModuleNatM$fMonadUniqueNatM $fMonadNatM$fApplicativeNatM $fFunctorNatMCmmMakeDynamicReferenceM addImport ReferenceKind DataReference CallReference JumpReferencecmmMakeDynamicReferenceneedImportedSymbolspprGotDeclarationpprImportedSymbolinitializePicBase_ppcinitializePicBase_x86$fCmmMakeDynamicReferenceMNatM$fEqReferenceKind InstrBlock sequenceTopbackendMaintainsCfg$fOutputableBlockChain$fOrdBlockChain$fEqBlockChain initCmmConfig initNCGConfiginitFinderOpts initBangOptsinitStgPprOptsinitStgToCmmConfigcompileEmptyStubcompileForeign LogQueueQueueLogQueue logQueueIdlogQueueMessageslogQueueSemaphore newLogQueuefinishLogQueue writeLogQueue parLogActionnewLogQueueQueue initLogQueue allLogQueues logThreadconfigureHandleEncoding ppSourceStats hsLPatType hsPatType hsLitType lhsExprType hsExprType hsWrapperTypeCoverageConfigcoverageConfig_loggercoverageConfig_dynFlagscoverageConfig_mInterpaddTicksToBinds hpcInitCode $fMonadTM$fApplicativeTM $fFunctorTM$fEqTickishType$fEqTickDensity extractDocsmkDocStructuremkDocStructureFromExportListmkDocStructureFromDeclsgetNamedChunksmkMapsgetMainDeclBinder sigNameNoLoc getInstLoc subordinates conArgDocs h98ConArgDocsgadtConArgDocs con_arg_docsisValD classDecls declTypeDocs nubByNametypeDocs sigTypeDocstopDeclsungroup collectDocs filterDecls filterClasses isUserSigmkDecls extractTHDocs unionArgMapsDsM DsMetaValDsBoundDsSplice DsMetaEnvDsLclEnvdsl_metadsl_loc dsl_nablasDsGblEnvds_modds_fam_inst_envds_gbl_rdr_env ds_unqualds_msgs ds_if_envds_complete_matchesds_cc_stds_next_wrapper_num$fContainsModuleDsGblEnv badIfaceFilehiModuleNameMismatchWarn homeModErrorcannotFindInterfacecantFindInstalledErrmayShowLocationscannotFindModule cantFindErrHieName 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$fEqHieTypeFix$fFunctorHieType$fFoldableHieType$fTraversableHieType $fEqHieType$fFunctorHieArgs$fFoldableHieArgs$fTraversableHieArgs $fEqHieArgs HieTypeStateHTStyMaphtyTable freshIndex EvidenceInfo evidenceVar evidenceSpan evidenceTypeevidenceDetailsRefMapgenerateReferencesMap renderHieTyperesolveVisibilityfoldType selectPointfindEvidenceUsegetEvidenceTreesAtPointgetEvidenceTreehieTypeToIface initialHTSfreshTypeIndex compressTypesrecoverFullType getTypeIndexresolveTyVarScopesresolveTyVarScopeLocalgetNameBinding getNameScopegetNameBindingInClassgetNameScopeAndBindinggetScopeFromContextgetBindSiteFromContext flattenAstsmallestContainingSatisfyingselectLargestContainedByselectSmallestContaining definedInAstsgetEvidenceBindDepsisEvidenceBindisEvidenceContext isEvidenceUse isOccurrencescopeContainsSpan combineAst insertAstnodeInfo emptyNodeInfosourcedNodeIdentscombineSourcedNodeInfocombineNodeInfo mergeAstsrightOfleftOf startsRightOf mergeSortAstssimpleNodeInfolocOnlymkScopeAmkScopemkLScope mkLScopeA mkLScopeN combineScopesmkSourcedNodeInfo makeNodeAmakeNode makeTypeNodeA makeTypeNode$fOutputableEvidenceInfo$fEqEvidenceInfo$fOrdEvidenceInfo$fFunctorEvidenceInfo DiffIdentDiffdiffFilediffAstsdiffAstnormalizeIdentsdiffListeqDiffvalidAstvalidateScopesfingerprintDynFlagsfingerprintOptFlagsfingerprintHpcFlags StaticPtrOpts opt_platform opt_gen_cstub opt_mk_stringopt_static_ptr_info_dataconopt_static_ptr_dataconsptCreateStaticBindssptModuleInitCode tcIfaceDeclstcIfaceCompleteMatchestcIfaceAnnotationstcIfaceFamInst tcIfaceInst tcIfaceRules tcIfaceDeclgetUnitLinkOptscollectLinkOptscollectArchivesgetLibsisStmt hasImportisImportisDeclhostPlatformArchhostPlatformOShostPlatformArchOSAnnoBodyrnStmtsrnLExprrnExpr RawSettings maybeReadmaybeReadFuzzygetTargetArchOS getRawSettinggetRawFilePathSettinggetRawBooleanSettingreadRawSetting SettingsErrorSettingsError_MissingDataSettingsError_BadData initSettingsbcPrepstgCse$fTrieMapStgArgMap$fTrieMapConAppMap StgDebugOptsstgDebug_infoTableMap"stgDebug_distinctConstructorTablescollectDebugInformationinitStgDebugOptsTagEnvTEte_envte_get TagSigEnv InferStgAlt InferStgRhs InferStgExprInferStgBindingInferStgTopBindingcombineAltInfo getBinderIdinitEnv makeTaggednoSig lookupSig lookupInfo isDunnoSig isTaggedInfo extendSigEnv$fOutputableTagEnv StgLiftConfigc_targetProfilec_liftLamsRecArgsc_liftLamsNonRecArgsc_liftLamsKnown$fShowStgLiftConfig$fReadStgLiftConfig$fEqStgLiftConfig$fOrdStgLiftConfiginitStgLiftConfig showStgStats$fEqCounterType$fOrdCounterTypenoWarnLookupIdSubstLiftM FloatLangStartBindingGroupEndBindingGroupPlainTopBinding LiftedBindingEnve_confige_subst e_expansionsdecomposeStgBinding mkStgBinding collectFloatsrunLiftMaddTopStringLitstartBindingGroupendBindingGroupaddLiftedBinding withSubstBndrwithSubstBndrswithLiftedBndrwithLiftedBndrssubstOccisLiftedformerFreeVars$fOutputableFloatLang$fMonadUniqueLiftM$fFunctorLiftM$fApplicativeLiftM $fMonadLiftM mkUnarisedIds mkUnarisedIdmkStgAltTypeFromStgAlts bindersOf bindersOfX bindersOfTopbindersOfTopBindsidArgsstripStgTicksTopstripStgTicksTopEunarise$fOutputableUnariseVallintStgTopBindings $fMonadLintM$fApplicativeLintM$fFunctorLintMrewriteTopBinds$fMonadUniqueRM $fFunctorRM $fMonadRM$fApplicativeRM inferTagsdepSortWithAnnotStgPgmannBindingFreeVars coreToStg$fHasDynFlagsCtsM $fMonadCtsM$fApplicativeCtsM $fFunctorCtsM $fEqHowBound $fEqLetInfo baseRegOffsetget_GlobalReg_addrregTableOffsetget_Regtable_addr_from_offsetfixStgRegisters SelfLoopInfoSequelReturnAssignTo$fOutputableSequel ClosureInfo closureName closureLFInfoclosureInfoLabel CallMethodEnterItJumpToItReturnItInferedReturnItSlowCall DirectEntryDynTagNonVoidCgLocCmmLocLneLoc isKnownFun fromNonVoid nonVoidIdsassertNonVoidIdsnonVoidStgArgsassertNonVoidStgArgs idPrimRep addIdReps addArgReps argPrimRep mkLFArgumentmkLFLetNoEscape mkLFReEntrant mkLFThunk mkConLFInfomkSelectorLFInfo mkApLFInfo mkLFImported mkLFStringLit isSmallFamily tagForCon tagForAritylfDynTag isLFThunk isLFReEntrantnodeMustPointToIt getCallMethod mkCmmInfo mkClosureInfoblackHoleOnEntryisStaticClosureclosureUpdReqd lfUpdatableclosureReEntrantclosureFunInfofunTagisToplevClosurestaticClosureLabelclosureSlowEntryLabelclosureLocalEntryLabelmkClosureInfoTableLabelmkDataConInfoTablecafBlackHoleInfoTableindStaticInfoTablestaticClosureNeedsLink$fOutputablePPlatformCgLoc$fOutputableNonVoid$fOutputableCallMethod $fEqNonVoid $fShowNonVoidVirtualHpOffset HeapUsagevirtHprealHpCgState MkCgState cgs_stmtscgs_tops cgs_binds cgs_hp_usg cgs_uniqs ReturnKindAssignedDirectly ReturnedToCgIdInfocg_idcg_lfcg_locFCodeinitCrunCfixCheapHWM initHpUsagegetStatesetState getHpUsage setHpUsage setVirtHp getVirtHp setRealHpgetBindssetBinds newUniquenewTempinitFCodeState getSelfLoop withSelfLoop withSequel getSequelwithUpdFrameOffgetUpdFrameOffgetTickyCtrLabelsetTickyCtrLabel getTickScope tickScopegetStgToCmmConfig getContext getModuleNameforkClosureBody forkLneBodycodeOnlyforkAlts forkAltPairgetCodeRgetCode getCodeScoped getHeapUsage emitLabel emitCommentemitTick emitUnwind emitAssign emitStore emitStore'emitemitDecl emitOutOfLineemitProcWithStackFrameemitProcWithConventiongetCmmmkCmmIfThenElsemkCmmIfThenElse' mkCmmIfGoto mkCmmIfGoto' mkCmmIfThen mkCmmIfThen'mkCall mkCmmCall aGraphToGraph$fOutputablePPlatformCgIdInfo$fMonadUniqueFCode $fMonadFCode$fApplicativeFCode$fFunctorFCode emitPrimCallCmmParseunECNamedVarNFunNLabelN loopDeclsgetEnvwithNamenewLocalnewLabelnewFunctionName newImport lookupLabel lookupNamecode$fMonadUniqueCmmParse$fMonadCmmParse$fApplicativeCmmParse$fFunctorCmmParsecgBind litIdInfo lneIdInfo rhsIdInfo mkRhsInit idInfoToAmodemaybeLetNoEscapeaddBindC addBindsC getCgIdInfogetCgInfo_maybe bindToReg rebindToReg bindArgToRegbindArgsToRegsidToReg newStringCLitnewByteStringCLitcgLit mkSimpleLitArgRepPNVFDV16V32V64 argRepStringtoArgRepisNonV argRepSizeWidArgRepslowCallPattern$fOutputableArgRep $fEqArgRep addToMemLbl addToMemLblEaddToMem addToMemEmkTaggedObjectLoad tagToClosureemitBarf emitRtsCallemitRtsCallWithResultemitRtsCallGencallerSaveVolatileRegscallerSaveGlobalRegcallerRestoreGlobalReg emitDataLitsemitRODataLits emitDataCon assignTempnewUnboxedTupleRegsemitMultiAssign emitSwitchemitCmmLitSwitchwhenUpdRemSetEnabledemitUpdRemSetPushemitUpdRemSetPushThunkcmmInfoTableToInfoProvEntconvertInfoProvMapwithNewTickyCounterFunwithNewTickyCounterLNEwithNewTickyCounterThunkwithNewTickyCounterStdThunkwithNewTickyCounterConemitTickyCounterTagtickyPushUpdateFrametickyUpdateFrameOmittedtickyEnterDynContickyEnterThunktickyUpdateBhCaf tickyEnterFun tickyEnterLNEtickyReturnOldContickyReturnNewContickyUnboxedTupleReturntickyDirectCalltickyKnownCallTooFewArgstickyKnownCallExacttickyKnownCallExtraArgs tickySlowCalltickySlowCallPat tickyDynAlloctickyAllocHeaptickyAllocPrimtickyAllocThunk tickyAllocPAPtickyHeapChecktickyStackCheck tickyTagged tickyUntagged tickyTagSkip$fToJsonTickyClosureTypecheckFunctionArgTagscheckConArgsStaticcheckConArgsDyn whenCheckTagsemitTagAssertionemitArgTagCheckcheckArgcheckArgStatic ClosureHeaderNoHeader StdHeader ThunkHeaderFieldOffOrPaddingFieldOffPadding emitReturnemitCalladjustHpBackwards directCallslowCallgetHpRelOffsetmkVirtHeapOffsetsWithPaddingmkVirtHeapOffsetsmkVirtConstrOffsetsmkVirtConstrSizes mkArgDescr getArgAmodegetNonVoidArgAmodesemitClosureProcAndInfoTableemitClosureAndInfoTable BinderInfo BindsClosure BoringBinderSkeleton ClosureSkRhsSkAltSkBothSkNilSkbinderInfoBndrtagSkeletonTopBind goodToLift closureGrowth$fOutputableSkeleton$fOutputableBndrBinderInfo$fOutputableBinderInfo stgLiftLamsStgToDoStgCSE StgLiftLamsStgStats StgUnarise StgBcPrep StgDoNothingStgPipelineOptsstgPipeline_phasesstgPipeline_lintstgPipeline_pprOptsstg2stg$fMonadUniqueStgM $fShowStgToDo $fReadStgToDo $fEqStgToDo $fOrdStgToDo $fFunctorStgM$fApplicativeStgM $fMonadStgM $fMonadIOStgMinitStgPipelineOptsBCInstrSTKCHECKPUSH_LPUSH_LLPUSH_LLLPUSH8PUSH16PUSH32PUSH8_WPUSH16_WPUSH32_WPUSH_G PUSH_PRIMOPPUSH_BCO PUSH_ALTSPUSH_ALTS_UNLIFTEDPUSH_ALTS_TUPLE PUSH_PAD8 PUSH_PAD16 PUSH_PAD32 PUSH_UBX8 PUSH_UBX16 PUSH_UBX32PUSH_UBX PUSH_APPLY_N PUSH_APPLY_V PUSH_APPLY_F PUSH_APPLY_D PUSH_APPLY_L PUSH_APPLY_P PUSH_APPLY_PPPUSH_APPLY_PPPPUSH_APPLY_PPPPPUSH_APPLY_PPPPPPUSH_APPLY_PPPPPPSLIDEALLOC_APALLOC_AP_NOUPD ALLOC_PAPMKAPMKPAPUNPACKPACKLABELTESTLT_ITESTEQ_ITESTLT_WTESTEQ_WTESTLT_FTESTEQ_FTESTLT_DTESTEQ_DTESTLT_PTESTEQ_PCASEFAILCCALLSWIZZLEENTERRETURNRETURN_UNLIFTED RETURN_TUPLEBRK_FUN LocalLabel getLocalLabelProtoBCO protoBCONameprotoBCOInstrsprotoBCOBitmapprotoBCOBitmapSize protoBCOArity protoBCOExpr protoBCOFFIs bciStackUse$fOutputableLocalLabel$fOutputableBCInstr$fOutputableProtoBCO$fEqLocalLabel$fOrdLocalLabelmkITbls bcoFreeNames assembleBCOsassembleOneBCOmkTupleInfoLitiNTERP_STACK_CHECK_THRESH$fMonadAssembler$fApplicativeAssembler$fFunctorAssembler byteCodeGen$fOutputableDiscr$fHasDynFlagsBcM $fMonadBcM$fApplicativeBcM $fFunctorBcM $fEqDiscr $fOrdDiscr mkTickBoxinitHpcArchive ArchiveEntryfilenamefiletimefileownfilegrpfilemodefilesizefiledataafilter isBSDSymdef isGNUSymdefparseAr writeBSDAr writeGNUArloadArloadObj $fEqArchive $fShowArchive$fSemigroupArchive$fMonoidArchive$fEqArchiveEntry$fShowArchiveEntry BuildMessageBuildMsg BuildErrorEOFenableProcessJobs hGetContents'readCreateProcessWithExitCode' replaceVarreadProcessEnvWithExitCode c_locale_env getGccEnv runSomethingrunSomethingResponseFilerunSomethingFilteredrunSomethingWith handleProcbuilderMainLoop readerProc parseError breakColon breakIntColon linesPlatformneededLinkArgs getLinkerInfogetLinkerInfo'getCompilerInfogetAssemblerInfogetCompilerInfo'HoleFitSortingAlgsortHoleFitsByGraphsortHoleFitsBySizezonkSubsgetHoleFitDispConfiggetHoleFitSortingAlg pprHoleFitaddHoleFitDocsgetLocalBindingstcFilterHoleFits tcSubsumeswithoutUnificationtcCheckHoleFitfindValidHoleFits tcSyntaxOpGen tcSyntaxOp tcInferRho tcInferRhoNCtcExpr tcPolyExprtcCheckMonoExprtcCheckMonoExprNC tcMonoExpr tcMonoExprNCtcCheckPolyExprtcCheckPolyExprNC tcMatchesFun tcGRHSsPatfinishTHrunRemoteModFinalizersrunQuasilookupThName_mayberunMetaDrunMetaTrunMetaPrunMetaEtcTopSpliceExpr runAnnotation runTopSplicetcUntypedBrackettcTypedBracket tcSpliceExpr FunDepEqnFDEqnfd_qtvsfd_eqsfd_pred1fd_pred2fd_locinstFDimproveFromAnother pprEquationimproveFromInstEnvcheckInstCoveragecloseWrtFunDeps checkFunDeps$fOutputableFunDepEqn$fFunctorFunDepEqnbadReexportedBootThingmissingBootThingcheckBootDeclMevDelayedError evCallStack tcInitTidyEnvIsExtraConstraintYesExtraConstraintNoExtraConstraintinitTc initTcWithGblinitTcInteractive initTcRnIf discardResult getTopEnv updTopEnv getGblEnv updGblEnv setGblEnv getLclEnv updLclEnv setLclEnv restoreLclEnvgetEnvssetEnvsupdEnvs restoreEnvsxoptMdoptMgoptMwoptMsetXOptM unsetXOptM unsetGOptM unsetWOptM whenDOptM whenGOptM whenWOptM whenXOptM unlessXOptM getGhcModewithoutDynamicNow updTopFlags getEpsVargetEps updateEps updateEps_getHpt getEpsAndHug withException newArrowScopeescapeArrowScopenewUniqueSupplycloneLocalNamenewName newNameAt newSysName newSysLocalIdnewSysLocalIdsnewTcRef readTcRef writeTcRefupdTcReftraceTctraceRn traceOptTcRn dumpOptTcRndumpTcRngetPrintUnqualifiedprintForUserTcRntraceIf traceOptIf getIsGHCi getGHCiMonadgetInteractivePrintNametcIsHsBootOrSigtcIsHsigtcSelfBootInfogetGlobalRdrEnv getRdrEnvs getImports getFixityEnvextendFixityEnvgetRecFieldEnvgetDeclaredDefaultTysaddDependentFiles getSrcSpanMinGeneratedCode setSrcSpan setSrcSpanAaddLocMaddLocMAwrapLocM wrapLocAM wrapLocMA wrapLocFstM wrapLocFstMA wrapLocSndM wrapLocSndMA wrapLocM_ wrapLocMA_ getErrsVar setErrsVaraddErrfailWithfailAtaddErrAtaddErrscheckErr addMessagesdiscardWarnings mkTcRnMessagereportDiagnosticsreportDiagnostic checkNoErrs whenNoErrsifErrsM failIfErrsM getErrCtxt setErrCtxt addErrCtxt addErrCtxtMaddLandmarkErrCtxtaddLandmarkErrCtxtM popErrCtxt getCtLocM setCtLocM askNoErrstryCaptureConstraintscaptureConstraintstcCollectingUsagetcScalingUsagetcEmitBindingUsageattemptMrecoverMmapAndRecoverM mapAndReportMfoldAndRecoverMtryTc discardErrstryTcDiscardingErrsaddErrTc addErrTcM failWithTc failWithTcMcheckTccheckTcMfailIfTc failIfTcMwarnIf diagnosticTc diagnosticTcMaddDiagnosticTcaddDiagnosticTcMaddDetailedDiagnosticaddTcRnDiagnostic addDiagnosticaddDiagnosticAt mkErrInfodebugTc addTopEvBinds newTcEvBindsnewNoTcEvBindscloneEvBindsVargetTcEvTyCoVarsgetTcEvBindsMapsetTcEvBindsMap addTcEvBindchooseUniqueOccTcgetConstraintVarsetConstraintVaremitStaticConstraintsemitConstraints emitSimple emitSimplesemitImplicationemitImplications emitInsolubleemitHole emitHolesdiscardConstraintspushLevelAndCaptureConstraints pushTcLevelM_ pushTcLevelM getTcLevel setTcLevelisTouchableTcM getLclTypeEnv setLclTypeEnvtraceTcConstraintsemitAnonTypeHoleemitNamedTypeHole recordThUserecordThSpliceUserecordThNeededRuntimeDeps keepAlivegetStagegetStageAndBindLevelsetStageaddModFinalizersWithLclEnvrecordUnsafeInfer finalSafeModefixSafeInstancesgetLocalRdrEnvsetLocalRdrEnv mkIfLclEnv initIfaceTcRn initIfaceLoadinitIfaceLoadModuleinitIfaceCheck initIfaceLclinitIfaceLclWithSubst getIfModulefailIfMforkMsetImplicitEnvM getCCIndexM getCCIndexTcM$fMonadUniqueIOEnv$fOutputableIsExtraConstraint tcAnnotationsannCtxt LookingForLFlf_whichlf_where WhereLooking WL_Anywhere WL_Global WL_LocalTop WL_LocalOnly WhatLooking WL_AnythingWL_Constructor WL_RecFieldWL_NonemkUnboundNameRdrreportUnboundName'reportUnboundName unboundName unboundNameX notInScopeErrunknownNameSuggestionsnameSpacesRelated$fEqWhatLookingrnTopSpliceDecls rnSpliceDecl rnSplicePat rnSpliceTypeloadSysInterfacenewGlobalBindernewInteractiveBinderallocateGlobalBinderifaceExportNames lookupOrig lookupOrigIOexternaliseName setNameModule tcIfaceLclIdextendIfaceIdEnv tcIfaceTyVarlookupIfaceTyVarlookupIfaceVarextendIfaceTyVarEnvextendIfaceEnvslookupIfaceTop newIfaceName newIfaceNamestrace_iftrace_hi_diffsMethInfo TcMethInfo mkNewTyConRhs buildDataCon buildPatSyn buildClassnewImplicitBindernewTyConRepName BinDictionary bin_dict_next bin_dict_mapBinSymbolTablebin_symtab_nextbin_symtab_map TraceBinIFace QuietBinIFace CheckHiWay IgnoreHiWayreadBinIfaceHeader readBinIfacegetWithUserData writeBinIfaceputWithUserDataputSymbolTablegetSymbolTableputName getSymtabName putFastStringgetDictFastString$fEqCheckHiWay HieHeader HieFileResulthie_file_result_versionhie_file_result_ghc_versionhie_file_resulthieMagic writeHieFilereadHieFileWithVersion readHieFile tcSubMult unifyKind unifyTypeCandidatesQTvsDVdv_kvsdv_tvsdv_cvs ConcreteHolenewMetaKindVarnewMetaKindVars newEvVarsnewEvVarnewWantedWithLoc newWanted newWantedscloneWantedCtEv cloneWantedcloneWC emitWanted emitWantedEqs emitWantedEqemitWantedEvVaremitWantedEvVarsemitNewExprHolenewDictnewImplicationnewCoercionHolefillCoercionHoleisFilledCoercionHoleunpackCoercionHoleunpackCoercionHole_maybecheckCoercionHolenewConcreteHolenewInferExpTypereadExpType_maybereadScaledExpType readExpTypecheckingExpType_maybecheckingExpTypescaledExpTypeToType expTypeToTypeinferResultToTypetcInferfillInferResult promoteTcTypenewMetaTyVarNamenewAnonMetaTyVarnewSkolemTyVar newTyVarTyVarcloneTyVarTyVarnewPatSigTyVarnewCycleBreakerTyVarnewMetaDetailsnewTauTvDetailsAtLevelcloneMetaTyVar readMetaTyVarisFilledMetaTyVar_maybeisFilledMetaTyVarisUnfilledMetaTyVarwriteMetaTyVarwriteMetaTyVarRefnewMultiplicityVar newFlexiTyVarnewNamedFlexiTyVarnewFlexiTyVarTynewFlexiTyVarTysnewOpenTypeKindnewOpenFlexiTyVarTynewOpenFlexiTyVarnewOpenBoxedTypeKind newMetaTyVarsnewMetaTyVarsX newMetaTyVarXnewMetaTyVarTyVarX newWildCardXnewMetaTyVarTyAtLevelcandidateKindVars delCandidatespartitionCandidatescandidateQTyVarsWithBinderscandidateQTyVarsOfTypecandidateQTyVarsOfTypescandidateQTyVarsOfKindcandidateQTyVarsOfKindsquantifyTyVarsisQuantifiableTvzonkAndSkolemiseskolemiseQuantifiedTyVar defaultTyVardoNotQuantifyTyVarspromoteMetaTyVarTopromoteTyVarSetzonkTcTypeAndFVzonkTyCoVarsAndFVzonkDTyCoVarSetAndFVzonkTyCoVarsAndFVList zonkTcTyVarszonkTyCoVarKindzonkImplication zonkEvVarzonkWC zonkSimpleszonkCtzonkSkolemInfozonkSkolemInfoAnon zonkTcType zonkTcTypeszonkCo zonkTcTyVarzonkTcTyVarsToTcTyVarszonkTcTyVarToTcTyVarzonkInvisTVBinderzonkId zonkCoVarzonkTidyTcTypezonkTidyTcTypeszonkTidyOriginzonkTidyOriginstidyCttidyHole tidyEvVarcheckTypeHasFixedRuntimeRepanyUnfilledCoercionHoles$fOutputableCandidatesQTvs$fMonoidCandidatesQTvs$fSemigroupCandidatesQTvs"$fMonoidUnfilledCoercionHoleMonoid%$fSemigroupUnfilledCoercionHoleMonoidhasFixedRuntimeRep_MustBeReflhasFixedRuntimeRepconvertToHsDeclsconvertToHsExpr convertToPatconvertToHsTypethRdrNameGuesses $fMonadCvtM$fApplicativeCvtM$fCvtFlagSpecificitySpecificity $fCvtFlag()() $fFunctorCvtMemptyNameShape mkNameShapeextendNameShapenameShapeExportssubstNameShapemaybeSubstNameShape tcRnModIfacetcRnModExports rnModIface rnModExportsmemoiseUniqueFun DmdAnalOptsdmd_strict_dictsdmd_unbox_widthdmd_max_worker_argsdmdAnalProgram$fOutputableAnalEnvcprAnalProgram$fOutputableSigEnv core2core simplifyExprinitFinderCacheflushFinderCacheslookupFileCachefindImportedModulefindPluginModulefindExactModulefindExposedPackageModuleaddModuleToFinderaddHomeModuleToFinder uncacheModulefindHomeModulemkHomeModLocationmkHomeModLocation2mkHiOnlyModLocation mkObjPathmkHiPath mkStubPathsfindObjectLinkableMaybefindObjectLinkabletcLookupImported_maybe importDeclcheckWiredInTyConifCheckWiredInThingneedWiredInHomeIfaceloadSrcInterfaceloadSrcInterface_maybeloadModuleInterfaceloadModuleInterfacesloadInterfaceForNameloadInterfaceForModuleloadWiredInHomeIfaceloadUserInterfaceloadPluginInterface loadInterfacemoduleFreeHolesPrecisefindAndReadIface writeIface readIface ifaceStats showIfacepprModIfaceSimple pprModIface$fOutputableWarnings InstBindings ib_tyvarsib_binds ib_pragmas ib_extensions ib_derivedInstInfoiSpeciBinds lookupGloballookupGlobal_maybeioLookupDataConaddTypecheckedBindstcLookupLocatedGlobaltcLookupGlobaltcLookupGlobalOnlytcLookupDataContcLookupPatSyntcLookupConLike tcLookupClass tcLookupTyCon tcLookupAxiomtcLookupLocatedGlobalIdtcLookupLocatedClasstcLookupLocatedTyContcLookupInstance tcGetInstEnvssetGlobalTypeEnvtcExtendGlobalEnvImplicittcExtendGlobalEnvtcExtendTyConEnv tcTyThBinderstcExtendGlobalValEnvtcExtendRecEnvtcLookupLocatedtcLookupLcl_maybetcLookup tcLookupTyVar tcLookupIdtcLookupIdMaybetcLookupLocalIdstcLookupTcTyCongetInLocalScopetcExtendKindEnvListtcExtendKindEnvtcExtendTyVarEnvtcExtendNameTyVarEnvisTypeClosedLetBndrtcExtendRecIdstcExtendSigIdstcExtendLetEnv tcExtendIdEnvtcExtendIdEnv1tcExtendIdEnv2tcExtendLocalTypeEnv tcCheckUsagetcExtendBinderStacktcInitOpenTidyEnvtcAddDataFamConPlaceholderstcAddPatSynPlaceholdersgetTypeSigNames tcExtendRulescheckWellStagedtopIdLvltcMetaTy isBrackStagetcGetDefaultTysiDFunIdpprInstInfoDetailssimpleInstInfoClsTysimpleInstInfoTysimpleInstInfoTyCon newDFunNamenewFamInstTyConNamenewFamInstAxiomNamemkStableIdFromStringmkStableIdFromName mkWrapperName pprBinders wrongThingErr$fMonadThingsIOEnv$fOutputableInstInfo ZonkFlexi DefaultFlexiSkolemiseFlexiRuntimeUnkFlexiNoFlexiZonkEnv tcShortCutLit shortCutLit hsOverLitName emptyZonkEnvmkEmptyZonkEnv initZonkEnv zonkTopBndrs zonkTyBndrs zonkTyBndrsXzonkTyVarBindersXzonkTyVarBinderX zonkTopExpr zonkTopLExpr zonkTopDecls zonkTcEvBinds zonkEvBinds zonkTyVarOcc lookupTyVarXzonkTcTypeToTypezonkTcTypeToTypeXzonkTcTypesToTypesX zonkCoToCozonkScaledTcTypesToTypesXzonkTcMethInfoToMethInfoX$fOutputableZonkEnvnewMethodFromName topSkolemisetopInstantiateinstantiateSigmainstTyVarsWithinstCallinstCallConstraints instDFunTypeinstStupidThetatcInstInvisibleTyBinderstcInstInvisibleTyBindersNtcInstInvisibleTyBinder tcInstTypetcInstTypeBndrstcSkolDFunTypetcSuperSkolTyVarstcInstSkolTyVarstcInstSkolTyVarsXtcInstSuperSkolTyVarsXtcSkolemiseInvisibleBndrsfreshenTyVarBndrsfreshenCoVarBndrsXnewOverloadedLit mkOverLit tcSyntaxNamegetOverlapFlag tcGetInsts newClsInsttcExtendLocalInstEnvmatchActualFunTySigmamatchActualFunTysRhomatchExpectedFunTysmatchExpectedListTymatchExpectedTyConAppmatchExpectedAppTy tcWrapResult tcWrapResultOtcWrapResultMonounifyExpectedType tcSubTypePat tcSubTypetcSubTypeSigmatcSkolemiseScoped tcSkolemise tcSkolemiseETcheckConstraintscheckTvConstraintsemitResidualTvConstraintbuildTvImplicationbuildImplicationForuTypecanSolveByUnificationswapOverTyVarsmatchExpectedFunKind checkTyVarEq checkTyFamEq checkTypeEqmkTypeableBindstyConIsTypeable$fFunctorKindRepM$fApplicativeKindRepM$fMonadKindRepMTermFoldfTermfPrim fSuspension fNewtypeWrapfRefWrapTermPrim Suspension NewtypeWrapRefWraptydcvalsubTermsvalRawctypebound_to wrapped_termtermTypeisFullyEvaluatedTermconstrClosToNamefoldTerm mapTermType termTyCoVarscPprTerm cPprTermBase cvObtainTermcvReconstructTypeimproveRTTIType$fOutputableTermnewLocalBndrRnnewLocalBndrsRnbindLocalNamesbindLocalNamesFVcheckDupRdrNamescheckDupRdrNamesN checkDupNamescheckShadowedRdrNamescheckDupAndShadowedNamescheckInferredVarsnoNestedForallsContextsErraddNoNestedForallsContextsErraddFvRnmapFvRn mapMaybeFvRnwarnUnusedTopBindscheckUnusedRecordWildcardwarnUnusedLocalBindswarnUnusedMatcheswarnUnusedTypePatternswarnForallIdentifier mkFieldEnvaddNameClashErrRn dupNamesErrbadQualBndrErr typeAppErrbadFieldConErr checkTupSize checkCTupSize wrapGenSpan genHsAppsgenHsApp genLHsVargenHsVar genAppTypegenHsIntegralLit genHsTyLitthNameToGhcName$fMonadThingsCoreMTidyOptsopt_name_cacheopt_collect_ccsopt_unfolding_optsopt_expose_unfoldings opt_trim_idsopt_expose_rulesopt_static_ptr_optsUnfoldingExposure ExposeNone ExposeSome ExposeAllmkBootModDetailsTc tidyProgram $fMonadDFFV$fApplicativeDFFV $fFunctorDFFV$fShowUnfoldingExposure$fEqUnfoldingExposure$fOrdUnfoldingExposure initTidyOptsinitStaticPtrOpts corePrepPgm corePrepExprmkConvertNumLiteral$fOutputableFloatingBind$fOutputableOkToSpec$fOutputableFloatscheckFamInstConsistencytcInstNewTyCon_maybetcLookupDataFamInsttcLookupDataFamInst_maybetcTopNormaliseNewTypeTF_maybetcExtendLocalFamInstEnvreportInjectivityErrors reportConflictingInjectivityErrstcGetFamInstEnvsreportUnsolvedreportAllUnsolvedwarnAllUnsolvedwarnDefaultingsolverReportMsg_ExpectedActuals solverReportInfo_ExpectedActuals MiniFixityEnvaddLocalFixitieslookupFixityRnlookupFixityRn_helplookupTyFixityRnlookupFieldFixityRn HsSigCtxt TopSigCtxt LocalBindCtxt ClsDeclCtxt HsBootCtxt RoleAnnotCtxtAmbiguousResultUnambiguousGreAmbiguousFieldsChildLookupResult NameNotFoundIncorrectParent FoundChildnewTopSrcBinderlookupTopBndrRnlookupLocatedTopConstructorRnlookupLocatedTopConstructorRnNlookupLocatedTopBndrRnlookupLocatedTopBndrRnNlookupInstDeclBndrlookupFamInstNamelookupConstructorFieldslookupRecFieldOcclookupRecFieldOcc_updatelookupSubBndrOcc_helpercombineChildLookupResultlookupLocatedOccRnlookupLocatedOccRnConstrlookupLocatedOccRnRecFieldlookupLocatedOccRnNonelookupLocalOccRn_maybelookupLocalOccThLvl_maybe lookupOccRnlookupLocalOccRnlookupTypeOccRnlookupOccRn_maybelookupExprOccRnlookupGlobalOccRn_maybelookupGlobalOccRnlookupInfoOccRnlookupGreAvailRnaddUsedDataCons addUsedGRE addUsedGREslookupSigOccRnlookupSigOccRnNlookupSigCtxtOccRnNlookupSigCtxtOccRnlookupLocalTcNames dataTcOccslookupIfThenElselookupSyntaxNamelookupSyntaxExpr lookupSyntaxlookupSyntaxNameslookupQualifiedDoExprlookupQualifiedDolookupNameWithQualifierlookupQualifiedDoName$fMonoidDisambigInfo$fSemigroupDisambigInfo$fOutputableDisambigInfo$fOutputableChildLookupResult$fOutputableHsSigCtxt$fEqFieldsOrSelectors InstanceWhatBuiltinInstanceBuiltinEqInstance LocalInstanceTopLevInstance iw_dfun_id iw_safe_over ClsInstResult NoInstanceOneInstNotSure cir_new_theta cir_mk_evcir_what AssocInstInfo NotAssociated InClsInstai_class ai_tyvars ai_inst_envisNotAssociated safeOverlapinstanceReturnsDictConmatchGlobalInst$fOutputableInstanceWhat$fOutputableClsInstResultMaybeNewFreshCachedTouchabilityTestResultTouchableSameLevelTouchableOuterLevel UntouchableTcSaddInertForAll addInertCankickOutAfterUnificationaddInertSafehaskinsertSafeOverlapFailureTcSgetSafeOverlapFailures addSolvedDictgetSolvedDictssetSolvedDicts updInertTcS getInertCans setInertCans updInertCans updInertDictsupdInertSafehaskupdInertIrreds getInertEqsgetInnermostGivenEqLevelgetInertInsolsgetInertGivensgetPendingGivenScsgetUnsolvedInertsgetHasGivenEqsremoveInertCtslookupFamAppInertlookupInertDictlookupSolvedDictlookupFamAppCacheextendFamAppCache foldIrredswrapTcS wrapErrTcS wrapWarnTcSfailTcSwarnTcS addErrTcSpanicTcStraceTcSrunTcPluginTcSgetGlobalRdrEnvTcSbumpStepCountTcS csTraceTcS traceFireTcSrunTcSrunTcSEarlyAbortrunTcSEqualities runTcSInertsrunTcSWithEvBinds setEvBindsTcS nestImplicTcSnestTcSemitImplicationTcSemitTvImplicationTcS getTcSInerts setTcSInertspushLevelNoWorkListupdWorkListTcS emitWorkNCemitWorkgetTcEvBindsVar unifyTyVarreportUnificationstouchabilityTestgetDefaultInfo getWorkListselectNextWorkItem getInstEnvsgetFamInstEnvscheckWellStagedDFunpprEq pprKickedresetUnificationFlagsetUnificationFlag newFlexiTcSTy instFlexi instFlexiXisFresh freshGoals getEvExpr setEvBind setWantedEqsetWantedEvTermsetEvBindIfWanted newGivenEvVarnewBoundEvVarIdnewGivenEvVarsemitNewWantedEq newWantedEqnewWantedEvVarNC newWantedNCcheckReductionDepthmatchFam matchFamTcMbreakTyVarCycle_maybe rewriterView$fHasDynFlagsTcS$fMonadThingsTcS$fHasModuleTcS$fMonadUniqueTcS$fMonadFailTcS $fMonadIOTcS $fMonadTcS$fApplicativeTcS"$fOutputableTouchabilityTestResult $fFunctorTcSrewriterewriteArgsNom rewriteType$fHasDynFlagsRewriteM$fApplicativeRewriteM$fMonadRewriteM$fFunctorRewriteMStopOrContinue ContinueWith canonicalizesolveCallStackmakeSuperClasses continueWithstopWithandWhenContinue unifyWanted$fOutputableStopOrContinue$fFunctorStopOrContinue tcPluginIO tcPluginTracegetTargetPlatformisTouchableTcPluginMnewGivensolveSimpleGivenssolveSimpleWanteds$fOutputableInteractResult InferModeApplyMREagerDefaultingNoRestrictionscaptureTopConstraintssimplifyTopImplic simplifyToppushLevelAndSolveEqualitiespushLevelAndSolveEqualitiesXsolveEqualitiessimplifyAndEmitFlatConstraintsreportUnsolvedEqualitiessimplifyTopWantedssimplifyAmbiguityChecksimplifyInteractivesimplifyDefault tcCheckGivenstcCheckWanteds tcNormalisefindInferredDiffgrowThetaTyVarssimplifyWantedsTcM solveWanteds approximateWC$fOutputableInferModecheckValidTypecheckValidMonoType checkTySynRhscheckValidThetaarityErrcheckValidInstHeadvalidDerivPredcheckValidInstancecheckValidCoAxiomcheckValidCoAxBranchcheckValidTyFamEqncheckValidAssocTyFamDefltcheckTyConTelescopeallDistinctTyVars$fOutputableTypeOrKindCtxt$fOutputableExpandMode$fOutputableValidityEnv$fEqTypeOrKindCtxt DerivInstTys dit_cls_tysdit_tc dit_tc_args dit_rep_tcdit_rep_tc_argsdit_dc_inst_arg_env AuxBindSpec DerivTag2Con DerivMaxTagDerivDataDataTypeDerivDataConstr gen_Eq_binds gen_Ord_bindsgen_Enum_bindsgen_Bounded_binds gen_Ix_bindsgen_Read_bindsgen_Show_bindsgen_Data_bindsgen_Lift_bindsgen_Newtype_bindsgen_Newtype_fam_instsmkCoerceClassMethEqn genAuxBinds mkRdrFunBindmkRdrFunBindECmkRdrFunBindSEordOpTbl boxConTbl litConTbl error_ExprgetPossibleDataConsderivDataConInstArgTysbuildDataConInstArgEnvsubstDerivInstTyszonkDerivInstTys$fOutputableDerivInstTys 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 canDoGenericscanDoGenerics1gen_Generic_fam_inst ThetaSpecPredSpecSimplePredSpecSubTypePredSpecsps_pred sps_originsps_type_or_kindstps_ty_actualstps_ty_expected stps_origin StockGenFnsstock_gen_bindsstock_gen_fam_instsOriginativeDerivStatusCanDeriveStockStockClassErrorCanDeriveAnyClassNonDerivableClass DerivContext InferContext SupplyContextDerivSpecMechanismDerivSpecStockDerivSpecNewtypeDerivSpecAnyClass DerivSpecVia dsm_stock_ditdsm_stock_gen_fnsdsm_newtype_ditdsm_newtype_rep_tydsm_via_cls_tysdsm_via_inst_ty dsm_via_ty DerivSpecDSds_locds_nameds_tvsds_thetads_clsds_tys ds_skol_info ds_user_ctxt ds_overlapds_standalone_wildcard ds_mechanismDerivEnvdenv_overlap_modedenv_tvsdenv_cls denv_inst_tys denv_ctxtdenv_skol_info denv_stratDerivMisStandaloneDerivisStandaloneWildcardDerivaskDerivUserTypeCtxt mkDerivOrigin pprDerivSpecsetDerivSpecTheta zonkDerivSpecderivSpecMechanismToStrategyisDerivSpecStockisDerivSpecNewtypeisDerivSpecAnyClassisDerivSpecViazonkDerivSpecMechanismmkDirectThetaSpec substPredSpeccaptureThetaSpecConstraintshasStockDerivingcheckOriginativeSideConditionsstd_class_via_coerciblenon_coercible_classnewDerivClsInstextendLocalInstEnv$fOutputableDerivContext$fOutputableDerivEnv$fOutputableDerivSpecMechanism$fOutputableDerivSpec$fOutputablePredSpec HFSNoSorting HFSBySizeHFSBySubsumptionrelevantCtEvidence isFlexiTyVar$fEqHoleFitSortingAlg$fOrdHoleFitSortingAlginferConstraintssimplifyInstanceContextsImportDeclUsage rnImportsrenameRawPkgQual renamePkgQualcalculateAvailsextendGlobalRdrEnvRngetLocalNonValBindersnewRecordSelector mkChildEnv findChildrenreportUnusedNamesfindImportUsagegetMinimalImportsprintMinimalImports checkConNamernLHsDoc rnLDocDecl rnDocDeclrnHsDoc rnExportsexports_from_avail FreeKiTyVarsNegationHandlingReassociateNegationKeepNegationIntactWarnUnusedForallsNoWarnUnusedForallsHsPatSigTypeScoping AlwaysBind NeverBind rnHsSigWcTypernHsPatSigType rnHsWcTypernHsPatSigTypeBindingVars rnHsSigTypernImplicitTvOccs rnLHsType rnLHsTypesrnScaledLHsTypernHsType rnLHsKindrnHsKind rnLHsTypeArgs rnContextrnMaybeContextrnLTyVarbindSigTyVarsFV bindHsQTyVarsbindHsOuterTyVarBndrsbindHsForAllTelescopebindLHsTyVarBndrsbindLHsTyVarBndrnewTyVarNameRnrnConDeclFields lookupField mkOpAppRn mkNegAppRn mkOpFormRn mkConOpPatRncheckPrecMatchcheckSectionPrecfilterInScopeMextractHsTyArgRdrKiTyVarsextractHsTyRdrTyVarsextractHsTyRdrTyVarsKindVarsextractHsTysRdrTyVarsextractRdrKindSigVarsextractConDeclGADTDetailsTyVarsextractDataDefnKindVarsextractHsOuterTvBndrsnubLnubN$fOutputableRnTyKiWhat$fOutputableRnTyKiEnv$fOutputableWarnUnusedForalls$fOutputableOpNameHsRecFieldContext HsRecFieldCon HsRecFieldPat HsRecFieldUpd NameMakerCpsRnliftCpsliftCpsWithConttopRecNameMakerisTopRecNameMakerlocalRecNameMakerrnPatsrnPatapplyNameMaker rnBindPat rnPatAndThen rnHsRecFieldsrnHsRecUpdFieldsrnLit rnOverLit $fMonadCpsRn$fApplicativeCpsRn$fFunctorCpsRn rnTopBindsLHSrnTopBindsLHSBootrnTopBindsBootrnLocalBindsAndThenrnLocalValBindsLHS rnValBindsRHSrnLocalValBindsRHSmakeMiniFixityEnv rnMethodBinds renameSigs rnMatchGrouprnGRHSsrnGRHSrnSrcFixityDecl rnSrcDecls addTcgDUs rnWarningTxt findSplice SpliceInfospliceDescription spliceSource spliceIsDeclspliceGeneratedrnTypedBracketrnUntypedBracket rnSpliceExpr traceSplicecheckThLocalName$fOutputableMonadNames$fOutputableStmtTreetypecheckIfacetypecheckIfacesForMergingtypecheckIfaceForInstantiate tcHiBootIface tcIfaceExprtcIfaceOneShot tcIfaceGlobalDataSort DataDeclSortDataInstanceSortDataFamilySort ContextKindTheKindAnyKindOpenKind SAKS_or_CUSKSAKSCUSKInitialKindStrategyInitialKindCheckInitialKindInferHoleModeHM_Sig HM_FamPatHM_VTA HM_TyAppPat funsSigCtxt addSigCtxt pprSigCtxt tcHsSigWcTypekcClassSigTypetcClassSigType tcHsSigTypetcStandaloneKindSig tcHsDerivtcDerivStrategytcHsClsInstType tcHsTypeApp tcFamTyPats tcHsOpenTypetcHsLiftedTypetcHsOpenTypeNCtcHsLiftedTypeNCtcCheckLHsTypetcInferLHsTypetcInferLHsTypeKindtcInferLHsTypeUnsaturatedtcMult tcHsContext tcLHsPredTypebindNamedWildCardBinders kcDeclHeadercheckForDuplicateScopedTyVars outerTyVarsouterTyVarBndrsscopedSortOuterbindOuterSigTKBndrs_TvbindOuterFamEqnTKBndrs_Q_TvbindOuterFamEqnTKBndrstcOuterTKBndrstcExplicitTKBndrsbindExplicitTKBndrs_SkolbindExplicitTKBndrs_TvbindExplicitTKBndrs_Q_SkolbindExplicitTKBndrs_Q_TvbindImplicitTKBndrs_SkolbindImplicitTKBndrs_TvbindImplicitTKBndrs_Q_SkolbindImplicitTKBndrs_Q_TvbindTyClTyVarsbindTyClTyVarsAndZonkzonkAndScopedSortkindGeneralizeAlletaExpandAlgTyConcheckDataKindSigcheckClassKindSigtcbVisibilitiestcHsPartialSigTypetcHsPatSigType tcLHsKindSig funAppCtxtaddTyConFlavCtxt$fOutputableHoleMode$fOutputableTcTyMode$fOutputableSAKS_or_CUSK TcPragEnv tcIdSigName tcSigInfoNamecompleteSigPolyId_maybetcTySigs tcUserTypeSiglhsSigWcTypeContextSpanlhsSigTypeContextSpancompleteSigFromIdisCompleteHsSig tcInstSig emptyPragEnv lookupPragEnv extendPragEnv mkPragEnvaddInlinePrags tcSpecPrags tcSpecWrapper tcImpPragstcPatSynBuilderBind tcPatSynDecl LetBndrSpec LetLclBndr LetGblBndrtcLetPattcPats tcInferPat tcCheckPat tcCheckPat_O newLetBndraddDataConStupidTheta polyPatSig$fOutputableLetBndrSpec tcDefaults tcTopBinds tcHsBootSigs tcLocalBinds tcValBinds tcPolyCheckchooseInferredQuantifiers$fOutputableGeneralisationPlan RolesInfocheckSynCyclescheckClassCycles inferRolesaddTyConsToGblEnvmkDefaultMethodType tcRecSelBinds mkRecSelBindsmkOneRecordSelector$fMonadSynCycleM$fApplicativeSynCycleM $fMonadRoleM$fApplicativeRoleM$fFunctorRoleM$fFunctorSynCycleMfindExtraSigImportsimplicitRequirementsimplicitRequirementsShallow checkUnit tcRnCheckUnittcRnMergeSignaturesmergeSignaturestcRnInstantiateSignatureinstantiateSignaturepatSynBuilderOccHsSigFun tcClassSigs tcClassDecl2tcClassMinimalDefinstantiateMethod mkHsSigFunfindMethodBind badMethodErr instDeclCtxt1 instDeclCtxt2 instDeclCtxt3 tcATDefaultAppCtxt VAExpansionVACallEValArgValArgQLva_exprva_funva_argsva_ty HsExprArgETypeArgEPragEWrapeva_ctxteva_arg eva_arg_ty eva_hs_tyeva_tyTcPassTcpRnTcpInstTcpTc appCtxtLocinsideExpansion addArgWrap splitHsApps rebuildHsApps isHsValArgcountLeadingValArgs isVisibleArgcountVisAndInvisValArgscountHsWrapperInvisArgspprHsExprArgTctcInferAppHeadtcInferAppHead_maybe obviousSigtyConOf tyConOfET lookupParentsfieldNotInType notSelector tcCheckId tcInferIdnonBidirectionalErr addFunResCtxt addExprCtxt$fOutputableAppCtxt$fOutputableEWrap$fOutputableEValArg$fOutputableHsExprArg TcStmtCheckerTcCmdStmtCheckerTcExprStmtChecker TcMatchCtxtMCmc_whatmc_body tcMatchesCase tcMatchLambdatcGRHS tcDoStmtstcBodytcStmtstcStmtsAndThen tcGuardStmttcDoStmttcProc tcInferSigmatcApp tcExprPraggetFixedTyVarstcRulesisForeignImportisForeignExportnormaliseFfiTypetcForeignImportstcForeignImports' tcFImport tcCheckFIType checkCTargettcForeignExportstcForeignExports' tcFExport tcCheckFETypecheckForeignArgscheckForeignResnonIOokmustBeIO checkSafe noCheckSafe DerivInfo di_rep_tc di_scoped_tvs di_clausesdi_ctxt tcDeriving$fOutputableEarlyDerivSpec tcInstDecls1 DataDeclInfo DDataType DDataInstancetcTyAndClassDecls kcConDeclstcTyFamInstEqncheckFamTelescopeunravelFamInstPatsaddConsistencyConstraintsdataDeclChecks tcConDeclscheckValidTyContcAddTyFamInstCtxttcMkDataFamInstCtxttcAddDataFamInstCtxtwrongKindOfFamilytcInstDeclsDeriv tcInstDecls2 DsWarning MatchResult MR_Infallible MR_Fallible DsWrapper EquationInfoEqnInfoeqn_patseqn_origeqn_rhsDsMatchContext idDsWrapperrunMatchResultfixDsinitDsTcinitDsinitDsWithModGutsinitTcDsForSolver newUniqueIdduplicateLocalDs newPredVarDs newSysLocalDsnewFailLocalDsnewSysLocalsDs getGhcModeDs getPmNablas updPmNablas getSrcSpanDs putSrcSpanDs putSrcSpanDsA diagnosticDs errDsCoreExpr failWithDsfailDsmkPrintUnqualifiedDsdsLookupGlobaldsLookupGlobalId dsLookupTyCondsLookupDataCondsLookupConLikedsGetFamInstEnvs dsGetMetaEnvdsGetCompleteMatchesdsLookupMetaEnvdsExtendMetaEnvdiscardWarningsDspprRuntimeTrace getCCIndexDsM$fOutputableDsMatchContext$fApplicativeMatchResult$fOutputableEquationInfo$fFunctorMatchResulttracePmtraceWhenFailPmmkPmIdallPmCheckWarnings overlapping exhaustive redundantBangexhaustiveWarningFlagisMatchContextPmCheckedneedToRunPmCheckGenerateInhabitingPatternsModeCaseSplitTopLevel MinimalCoverPhiCtsPhiCtPhiTyCt PhiCoreCtPhiConCt PhiNotConCtPhiBotCt PhiNotBotCtaddPhiCtsNablasaddPhiCtNablas isInhabitedgenerateInhabitingPatterns"$fOutputableTopNormaliseTypeResult$fOutputablePhiCt*$fOutputableGenerateInhabitingPatternsMode"$fEqGenerateInhabitingPatternsMode$$fShowGenerateInhabitingPatternsMode CheckActionCAunCAcheckMatchGroup checkGRHSscheckEmptyCase checkPatBind$fFunctorCheckActionmatchSinglePatVar matchSimply matchWrappermatch dsLocalBinds dsSyntaxExprdsLExprdsExprCaseAlt MkCaseAltalt_pat alt_bndrs alt_wrapper alt_resultselectSimpleMatchVarLselectMatchVarsselectMatchVarfirstPat shiftEqns matchCanFailalwaysFailMatchResultcantFailMatchResultextractMatchResultcombineMatchResultsadjustMatchResultDs wrapBindswrapBindseqVarmkCoLetMatchResultmkViewMatchResultmkEvalMatchResultmkGuardedMatchResultmkCoPrimCaseMatchResultmkCoAlgCaseMatchResultmkCoSynCaseMatchResult mkErrorAppDs mkFailExpr mkCoreAppDs mkCoreAppsDsmkCastDsmkSelectorBinds mkLHsPatTupmkVanillaTuplePatmkBigLHsVarTupId mkBigLHsTupIdmkBigLHsVarPatTupIdmkBigLHsPatTupIdshareFailureHandlerdsHandleMonadicFailure mkOptTickBoxmkBinaryTickBoxdecideBangHood isTrueLHsExprdsCCallmkFCallunboxArg boxResult resultWrapper dsForeignsdsLit dsOverLitwarnAboutIdentitieswarnAboutOverflowedOverLitwarnAboutOverflowedLitwarnAboutEmptyEnumerations tidyLitPattidyNPat matchLiteralshsLitKey matchNPatsmatchNPlusKPats dsGuardeddsGRHSs dsHsWrapperdesugarPatBinddesugarEmptyCasedesugarMatches desugarGRHSs pmcPatBindpmcGRHSs pmcMatchesaddTyCsaddCoreScrutTmCsaddHsScrutTmCs $fMonoidCIRB$fSemigroupCIRB$fEqFormatReportWarningsMode dsTopLHsBinds dsLHsBindsdsSpec dsMkUserRuledecomposeRuleLhs dsTcEvBinds_s dsTcEvBinds dsEvBindsdsEvTerm dsBracket$fRepTVSpecificitySpecificity $fRepTV()()matchConFamily matchPatSynmatchEquationsmatchSinglePat dsListComp dsMonadComp dsProcExpr dsValBinds RecompReasonUnitDepRemovedModulePackageChangedSourceFileChangedThisUnitIdChanged ImpurePluginPluginsChangedPluginFingerprintChangedModuleInstChanged HieMissing HieOutdatedSigsMergeChanged ModuleChanged ModuleRemoved ModuleAddedModuleChangedRawModuleChangedIface FileChanged CustomReason FlagsChangedOptimFlagsChangedHpcFlagsChangedMissingBytecodeMissingObjectFileMissingDynObjectFileMissingDynHiFileMismatchedDynHiFileObjectsChangedLibraryChanged CompileReason MustCompile RecompBecauseMaybeValidated UpToDateItem OutOfDateItemRecompileRequiredUpToDateNeedsRecompileneedsRecompileBecauseoutOfDateItemBecauserecompileRequired recompThen checkOldIfaceaddFingerprints$fOutputableRecompReason$fOutputableCompileReason$fMonoidRecompileRequired$fSemigroupRecompileRequired$fOutputableRecompileRequired$fBinaryIfaceIdExtras$fBinaryIfaceDeclExtras$fOutputableIfaceDeclExtras$fEqRecompileRequired$fFunctorMaybeValidated$fEqCompileReason$fEqRecompReason mkUsedNames mkUsageInfomkPartialIface mkFullIface mkIfaceTcmkIfaceExportstyThingToIfaceDeclcoAxiomToIfaceDecl pprFamInst pprTyThingLoc pprTyThingHdrpprTyThingInContextpprTyThingInContextLoc pprTyThing RenamedStuff TcRnExprModeTM_Inst TM_Default tcRnModuletcRnModuleTcRnMcheckHiBootIface' checkBootDecl rnTopSrcDecls tcTopSrcDeclsrunTcInteractivetcRnStmt isGHCiMonadtcRnExprtcRnImportDeclstcRnType tcRnDeclsigetModuleInterfacetcRnLookupRdrNametcRnLookupName tcRnGetInfoloadUnqualIfaces withTcPluginswithHoleFitPluginsgetRenamedStuff mkHieFilemkHieFileWithSourcegetCompressedAsts enrichHie$fModifyStateVar$fModifyStateName$fHasLocHsDataDefn $fHasLocHsArg $fHasLoc[]$fHasLocGenLocated$fHasLocGenLocated0$fHasLocGenLocated1$fHasLocPScoped$fToHieGenLocated$fToHieGenLocated0$fToHieIEContext$fToHieIEContext0$fToHieIEContext1$fToHieGenLocated1$fToHieRScoped$fToHieGenLocated2$fToHieGenLocated3$fToHieAnnProvenance$fToHieGenLocated4$fToHieGenLocated5$fToHieGenLocated6$fToHieForeignExport$fToHieForeignImport$fToHieGenLocated7$fToHieGenLocated8$fToHieGenLocated9$fToHieGenLocated10$fToHieGenLocated11$fToHieGenLocated12$fToHieGenLocated13$fToHieGenLocated14$fToHieGenLocated15$fToHieGenLocated16$fToHieGenLocated17$fToHiePendingTcSplice$fToHiePendingRnSplice$fToHieHsQuote$fToHieGenLocated18$fToHieArithSeqInfo$fToHieGenLocated19$fToHieGenLocated20$fToHieTScoped$fToHieTVScoped $fToHieHsArg$fToHieGenLocated21$fToHieTVScoped0$fToHieTScoped0$fToHieStandaloneKindSig$fToHieGenLocated22$fToHieTScoped1$fToHieTScoped2$fToHieGenLocated23$fToHieGenLocated24$fToHieHsScaled$fToHieGenLocated25$fToHieGenLocated26$fToHieGenLocated27$fToHieGenLocated28$fToHieGenLocated29$fToHieHsDataDefn$fToHieGenLocated30 $fToHieFamEqn$fToHieTScoped3$fToHieTScoped4$fToHieGenLocated31$fToHieRScoped0$fToHieFamilyInfo$fToHieGenLocated32$fToHieGenLocated33$fToHieTyClGroup$fToHieHsConDeclGADTDetails$fToHieHsConDetails$fToHieRContext$fToHieTScoped5$fToHieContext$fToHieGenLocated34$fToHieEvBindContext$fToHieContext0$fToHieContext1$fToHieContext2$fToHieContext3$fToHieIEContext2 $fToHieMaybe $fToHieBag $fToHie[] $fToHieVoid$fToHiePatSynFieldContext$fToHieContext4$fToHieGenLocated35$fToHieSigContext$fToHieGenLocated36$fToHieGenLocated37$fToHieRScoped1$fToHieRFContext$fToHieRFContext0$fToHieRContext0$fToHieRScoped2$fToHieRScoped3$fToHieRScoped4$fToHieRScoped5$fToHieHsTupArg$fToHieGenLocated38$fToHiePScoped$fToHieHsStmtContext$fToHieHsMatchContext$fToHieHsPatSynDir$fToHieGenLocated39$fToHieBindContext$fHiePassTypechecked$fHiePassRenamed$fHasTypeGenLocated$fHasTypeGenLocated0$fHasTypeGenLocated1$fHasLocFamEqn$fToHieRScoped6$fToHieGenLocated40 $fToHieGRHSs$fToHieGenLocated41$fToHieMatchGroup $fDataPScopeddeSugar deSugarExpr sectionTypereadElfSectionByNamereadElfNoteAsString makeElfNote floatToBytes 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 LlvmParamAttrZeroExtSignExtByValSRetNoAlias NoCaptureNest LlvmParameterLlvmFunctionDeclsLlvmFunctionDecldecName funcLinkagefuncCc decReturnType decVarargs decParams funcAlign LlvmStatic LMComment LMStaticLit LMUninitType LMStaticStr LMStaticArray LMStaticStrucLMStaticStrucULMStaticPointerLMTruncLMBitcLMPtoILMAddLMSubLlvmLitLMIntLit LMFloatLit LMNullLit LMVectorLit LMUndefLitLlvmVar LMGlobalVar LMLocalVar LMNLocalVarLMLitVarLMConstGlobalConstantAliasLMAlign LMSectionLlvmTypeLMIntLMFloatLMDouble LMFloat80 LMFloat128 LMPointerLMArrayLMVectorLMLabelLMVoidLMStruct LMStructULMAlias LMMetadata LMFunction LlvmAliasLMStringLMGlobal getGlobalVargetGlobalValueppTypeppParams 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 UnresStatic UnresLabelLlvmData LlvmUnresDataLiveGlobalRegsLlvmBasicBlock LlvmCmmDecl cmmToLlvmTypewidthToLlvmFloatwidthToLlvmInt llvmFunTy llvmFunSig llvmFunAlign llvmInfAlignllvmFunSection llvmFunArgsisFPR padLiveArgsllvmStdFunAttrs tysToParams llvmPtrBitsparseLlvmVersionsupportedLlvmVersionLowerBoundsupportedLlvmVersionUpperBoundllvmVersionSupportedllvmVersionStrllvmVersionListliftIOrunLlvm withClearVars varInsert funInsert varLookup funLookup markStackReg checkStackReggetMetaUniqueId getLlvmVer dumpIfSetLlvm renderLlvm markUsedVar getUsedVars setUniqMeta getUniqMetaghcInternalFunctionsstrCLabel_llvm getGlobalPtr llvmDefLabelgenerateExternDeclsaliasify$fMonadUniqueLlvmM$fHasLoggerLlvmM $fMonadLlvmM$fApplicativeLlvmM$fFunctorLlvmMrunUnlitaugmentImportsrunCpprunPprunCc isContainedInaskLdrunAs runLlvmOpt runLlvmLlcrunClangfigureLlvmVersionrunLinkrunMergeObjects runLibtoolrunAraskOtoolrunInstallNameTool runRanlib runWindrestouchtraceToolCommandrunInjectRPathsgetUnitFrameworkOptsgetFrameworkOpts loadFramework mkExtraObjmkExtraObjToLinkIntoBinarymkNoteObjsToLinkIntoBinary getLinkInfoplatformSupportsSavingLinkOptsghcLinkInfoSectionNameghcLinkInfoNoteName checkLinkInfohaveRtsOptsFlagslazyInitLlvmConfig initSysTools copyHandlecopyWithHeadermaybeCreateManifest linkDynLib libmLinkOpts linkBinary linkBinary' linkStaticLibgetLoaderStateextendLoadedEnvdeleteFromLoadedEnvloadNamewithExtendedLoadedEnvshowLoaderStateinitLoaderStateloadCmdLineLibsloadExpr loadDecls loadModuleunload loadPackagesinitializePluginsloadFrontendPluginforceLoadModuleInterfacesforceLoadNameModuleInterfaceforceLoadTyCongetValueSafelygetHValueSafelylessUnsafeCoercelookupRdrNameInModuleForPluginsinitLlvmCgConfig genLlvmDatagenData pprLlvmDatapprLlvmCmmDecl infoSection genLlvmProc$fMonoidLlvmAccum$fSemigroupLlvmAccum $fEqSignage $fShowSignage llvmCodeGenpprData pprFormatpprImm pprDataItemncgX86 ncgX86_64$fInstructionInstrncgPPC$fOutputableInstr ncgAArch64dW_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$fEnumDwarfAbbrevdwarfGen nativeCodeGen cmmNativeGen!$fCmmMakeDynamicReferenceMCmmOptM$fMonadCmmOptM$fApplicativeCmmOptM$fFunctorCmmOptM codeOutputoutputForeignStubsprofilingInitCode ipInitCodeccsTypeccType storeCurCCS mkCCostCentremkCCostCentreStackcostCentreFrom staticProfHdr dynProfHdrinitUpdFrameProfsaveCurrentCostCentrerestoreCurrentCostCentre profDynAlloc profAllocenterCostCentreThunkenterCostCentreFuninitCostCentresinitInfoTableProvemitInfoTableProv emitSetCCCldvRecordCreateldvEnterClosureldvEnterallocDynClosureallocDynClosureCmmallocHeapClosure emitSetDynHdrmkStaticClosureFieldsmkStaticClosureentryHeapCheckentryHeapCheck' altHeapCheckaltHeapCheckReturnsTonoEscapeHeapCheckheapStackCheckGen cgTopRhsCon buildDynCon bindConArgsSRTMap ModuleSRTInfo thisModule dedupSRTsflatSRTs moduleSRTMapCAFEnvCAFSet cafAnalDatacafAnalemptySRT srtMapNonCAFsdoSRTs$fOutputablePenvSomeLabel$fOutputablePenvModuleSRTInfo $fEqSomeLabel$fOrdSomeLabel $fEqSRTEntry $fOrdSRTEntry $fEqCAFLabel $fOrdCAFLabel$fOutputablePenvSRTEntry$fOutputablePenvCAFLabel cgForeignCall emitCCallemitForeignCallemitSaveThreadStatesaveThreadState emitSaveRegsemitRestoreRegsemitPushTupleRegsemitPopTupleRegsemitCloseNurseryemitLoadThreadStateloadThreadStateemitOpenNurserycgOpAppshouldInlinePrimOpcmmLayoutStacksetInfoTableStackMap$fOutputableStackMap$fOutputableStackSlot cmmPipelinecgExprcgTopRhsClosureemitBlackHoleCodepushUpdateFrameemitUpdateFramecodeGengenerateCgIPEStub parseCmmFileMessager newHscEnvnewHscEnvWithHUG getHscEnv ioMsgMaybehscTcRnLookupRdrNamehscTcRcLookupNamehscTcRnGetInfohscIsGHCiMonadhscGetModuleInterfacehscRnImportDeclshscParse hscParse'hscTypecheckRenamehscTypecheckAndGetWarnings tcRnModule' hscDesugar hscDesugar'makeSimpleDetailshscRecompStatusinitModDetailshscDesugarAndSimplifyhscMaybeWriteIface oneShotMsgbatchMsg batchMultiMsg hscCheckSafe hscGetSafe hscSimplify hscSimplify'hscSimpleIface'hscGenHardCodehscInteractivehscCompileCmmFile doCodeGenhscStmthscStmtWithLocation hscParsedStmthscDeclshscParseModuleWithLocationhscParseDeclsWithLocationhscDeclsWithLocationhscParsedDeclshscAddSptEntries hscImport hscTcExpr hscKcType hscParseExprhscParseStmtWithLocation hscParseTypehscParseIdentifierhscTidyhscCompileCoreExprhscCompileCoreExpr'dumpIfaceStatsshowModuleIndexwriteInterfaceOnlyModedefaultRunMetarunMeta' $fQuasiIOEnv!$fReifyFlagSpecificitySpecificity$fReifyFlag()()GetDocsFailureNameHasNoModule NoDocsInIfaceInteractiveNamegetResumeContextgetHistoryModulegetHistorySpan execOptionsexecStmt execStmt'runDeclsrunDeclsWithLocationrunParsedDeclsparseImportDecl resumeExecsetupBreakpointbackforwardabandon abandonAll setContextmoduleIsInterpretedgetInfogetNamesInScopegetRdrNamesInScope parseNamegetDocsexprTypegetInstancesForTypeparseInstanceHead parseExpr compileExprcompileExprRemotecompileParsedExprRemotecompileParsedExprdynCompileExpr showModulemoduleIsBootOrNotObjectLinkableobtainTermFromValobtainTermFromIdreconstructType$fOutputableGetDocsFailure HookedUse runHookedUse runPipelinerunPhaserunLlvmManglePhaserunMergeForeignrunLlvmLlcPhaserunLlvmOptPhase runAsPhase runCcPhaserunHscBackendPhase runUnlitPhase getFileArgs runCppPhase runHscPhasemkOneShotModLocation runHscTcPhaserunHscPostTcPhase runHsPpPhasephaseOutputFilenameNewgetOutputFilename llvmOptionsoffsetIncludePathsdoCppgetBackendDefshscPostBackendPhase compileStubjoinObjectFilesgetHCFilePackageslinkDynLibCheckgeneratePackageVersionMacrosfixchargenerateMacrostouchObjectFilegetGhcVersionPathName$fMonadUseTPhaseHookedUse$fFunctorHookedUse$fApplicativeHookedUse$fMonadHookedUse$fMonadIOHookedUse$fMonadThrowHookedUse$fMonadCatchHookedUse preprocess compileOne compileOne'link linkingNeededoneShot compileFile mkPipeEnvpreprocessPipeline fullPipeline hscPipelinehscBackendPipelinehscGenBackendPipeline asPipeline viaCPipeline llvmPipelinellvmLlcPipelinellvmManglePipelinecmmCppPipelinehscPostBackendPipeline pipelineStartSummariseResultFoundInstantiationFoundHomeWithError FoundHomeNotThere ModNodeMap unModNodeMap LoadHowMuchLoadAllTargetsLoadUpToLoadDependenciesOfdepanaldepanalEdepanalPartialinstantiationNodesload loadWithCacheload'topSortModuleGraphemptyModNodeMapmodNodeMapInsertmodNodeMapElemsmodNodeMapLookupmodNodeMapSingletonmodNodeMapUnionWith downsweepcheckHomeUnitsClosed summariseFilesummariseModule noModErrorcyclicModuleErr'$fOutputableModuleGraphNodeWithBootFile$fOutputableBuildPlan$fFunctorResultVar$fFunctorModNodeMap$fTraversableModNodeMap$fFoldableModNodeMap GhcApiError ModuleInfo CoreModule cm_modulecm_typescm_bindscm_safeTypecheckedSource RenamedSource ParsedSourceDesugaredModuledm_typechecked_moduledm_core_moduleTypecheckedModuletm_parsed_moduletm_renamed_sourcetm_typechecked_sourcetm_checked_module_info tm_internals_ ParsedModulepm_mod_summarypm_parsed_sourcepm_extra_src_files coreModuleTypecheckedMod renamedSourcetypecheckedSource moduleInfo ParsedMod parsedSourcedefaultErrorHandlerdefaultCleanupHandlerrunGhcrunGhcTwithCleanupSession initGhcMonadsetSessionDynFlagssetUnitDynFlagssetTopSessionDynFlagssetProgramDynFlagsgetProgramDynFlagssetInteractiveDynFlagsgetInteractiveDynFlagsparseDynamicFlagsparseTargetFiles setTargets getTargets addTarget removeTarget guessTargetworkingDirectoryChanged getModSummary parseModuletypecheckModule desugarModulecompileToCoreModulecompileToCoreSimplifiedgetModuleGraphisLoaded getBindingsgetInstsgetPrintUnqual getModuleInfomodInfoTyThingsmodInfoTopLevelScopemodInfoExportsmodInfoExportsWithSelectorsmodInfoInstancesmodInfoIsExportedNamemkPrintUnqualifiedForModulemodInfoLookupName modInfoIface modInfoRdrEnv modInfoSafemodInfoModBreaks isDictonaryIdlookupGlobalNamefindGlobalAnnsgetGREgetNameToInstancesIndex dataConTypepprParenSymNamegetTokenStreamgetRichTokenStreamaddSourceToTokensshowRichTokenStream findModulefindQualifiedModulerenamePkgQualMrenameRawPkgQualM lookupModulelookupQualifiedModuleisModuleTrustedmoduleTrustReqs setGHCiMonadparserinterpretPackageEnv$fParsedModParsedModule$fOutputableCoreModule$fParsedModTypecheckedModule$fParsedModDesugaredModule$fTypecheckedModDesugaredModule!$fTypecheckedModTypecheckedModule$fDesugaredModDesugaredModule$fExceptionGhcApiError$fShowGhcApiErrorpprintClosureCommandshowTermpprTypeAndContents doMkDependHS doBackpack$fGhcMonadIOEnv$fHasLoggerIOEnv$fHasDynFlagsIOEnv$fEqSessionTypeStatestategetgetsputmodify evalState execStaterunState $fMonadState$fApplicativeState$fFunctorState createBCOsmkConInfoTableShouldRetainCAFs RetainCAFsDontRetainCAFs initObjLinker lookupSymbol lookupClosureloadDLL loadArchive unloadObjpurgeObjaddLibrarySearchPathremoveLibrarySearchPathfindSystemLibrary resolveObjsinstallSignalHandlers 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.Types.DemandDemand GHC.Types.CprCprGHC.Core.UtilsdataConRepInstPatBoxity SubDemanddataConInstArgTysghc-primIntGHC.Runtime.Heap.LayoutStgWordGHC.EnumsuccLanguage.Haskell.Syntax.ExprLHsExprGHC.Hs.ExtensionGhcTcHsExpr tcg_th_docsLanguage.Haskell.Syntax.DeclsHsGroup GHC.IORefIORefTrue Data.DataDataGHC.Stg.InferTags.TagSig isTaggedSigTagInfo TagTagged TagProperTagDunnoTagTupleTagSigRnEnv2emptyInScopeSettransformers-0.5.6.2Control.Monad.Trans.RWS.StrictRWSTGHC.Data.OrdListOrdListUniqSMStgTopStringLitlocalPrimRep CmmInfoTable GenStgExprinfinityTcMDumpFlagPprUserPprDumpTcRnIfGIfGblEnvTcGblEnvControl.Monad.FixMonadFixmfixControl.Monad.IO.ClassMonadIO lintGblEnv getRoleAnnotslookupRoleAnnotemptyRoleAnnotEnvmkRoleAnnotEnvplusImportAvailsemptyImportAvails mkModDeps peCategory pprPECategorytcTyThingCategorypprTcTyThingCategorytcTyThingTyCon_maybe outerLevelimpLeveltopSpliceStage topAnnStagetopStageremoveBindingShadowingpushErrCtxtSameOrigin pushErrCtxt bootExportstcVisibleOrphanModsTcRnIfIfMIfLRnMenv_lclenv_gblenv_topenv_um RewriteEnvRE re_rewriters re_eq_relre_loc re_flavourif_doc if_rec_typesIfLclEnv if_id_env if_tv_envif_implicits_env if_nsubstif_locif_modif_bootFrontendResultFrontendTypechecktcg_next_wrapper_num tcg_cc_sttcg_complete_matches tcg_static_wc tcg_top_loctcg_hf_pluginstcg_defaulting_pluginstcg_tc_plugin_rewriterstcg_tc_plugin_solverstcg_safe_infer_reasonstcg_safe_infertcg_main tcg_self_boottcg_hpc tcg_doc_hdr tcg_patsyns tcg_fords tcg_rules tcg_fam_insts tcg_insts tcg_ksigstcg_tcstcg_anns tcg_warns tcg_imp_specstcg_sigs tcg_binds tcg_tr_module tcg_ev_bindstcg_th_remote_state tcg_th_statetcg_th_corepluginstcg_th_modfinalizerstcg_th_topnamestcg_th_foreign_filestcg_th_topdeclstcg_dependent_files tcg_rn_declstcg_rn_importstcg_rn_exports tcg_merged tcg_dfun_ntcg_th_needed_depstcg_th_splice_used tcg_th_usedtcg_keep tcg_used_grestcg_dus tcg_imports tcg_exports tcg_ann_envtcg_fam_inst_env tcg_inst_env tcg_type_env tcg_field_env tcg_fix_env tcg_default tcg_rdr_envtcg_srctcg_semantic_modtcg_type_env_vartcg_mod RecFieldEnvErrCtxt TcTypeEnv ThBindEnvTcRef TcBinderStackTcBinderTcTvBndrTcIdBndrTcIdBndr_ExpType SpliceTypeTypedUntypedThStageBrackCompSplice RunSplice PendingStuff TcPendingRnPendingUntypedRnPendingTypedThLevel ArrowCtxt NoArrowCtxt PromotionErr NoDataKindsDC RecDataConPEPatSynPEConstrainedDataConPE FamDataConPETyConPEClassPE IdBindingInfo NonClosedLet NotLetBound ClosedLet IsGroupClosedRhsNames ClosedTypeId WhereFromImportByPlugin ImportByUserImportBySystemTISI sig_inst_wcx sig_inst_wcs sig_inst_tausig_inst_theta sig_inst_sigsig_inst_skolsTcPluginSolverTcPluginRewriter runTcPluginMTcPlugin tcPluginStoptcPluginRewrite tcPluginInit tcPluginSolveTcPluginSolveResultTcPluginContradiction TcPluginOktcPluginNewCtstcPluginInsolubleCtstcPluginSolvedCtsTcPluginRewriteResultTcPluginNoRewriteTcPluginRewriteTotcPluginReductiontcRewriterNewWantedsDefaultingProposal deProposalCtsdeProposalTyVardeProposalCandidatesDefaultingPluginResultFillDefaultingDefaultingPlugin dePluginStop dePluginInit dePluginRun RoleAnnotEnvDocLocInstDocArgDoc ModuleDocDeclDocTHDocs TcRnMessageGHC.Data.IOEnvupdEnvsetEnvatomicUpdMutVar'atomicUpdMutVar updMutVarM updMutVar readMutVar writeMutVar newMutVaruninterruptibleMaskM_unsafeInterleaveMtryMostMtryAllMtryMfixMrunIOEnv failWithMfailMIOEnv IOEnvFailuresetLclEnvTcLevelgetLclEnvTcLevel setLclEnvLoc getLclEnvLocTcLclEnvtcl_errstcl_lie tcl_bndrs tcl_usagetcl_envtcl_rdrtcl_arrow_ctxt tcl_th_bndrs tcl_th_ctxt tcl_tclvltcl_in_gen_codetcl_loctcl_ctxt SelfBootInfo NoSelfBootSelfBootsb_mdssb_tcsGHC.Unit.Module.Deps ImportAvails imp_finsts imp_orphs imp_sig_mods imp_boot_modsimp_trust_pkgsimp_trust_own_pkgimp_dep_direct_pkgsimp_modsimp_direct_dep_mods CompleteMatchGHC.Utils.Monad filterOutMunlessMwhenM maybeMapMfoldlM_orMallManyM fmapEitherM fmapMaybeM mapMaybeM concatMapMliftSndMliftFstMmapSndM mapAccumLM mapAndUnzip5M mapAndUnzip4M mapAndUnzip3MzipWithAndUnzipM zipWith4M zipWith3M_ zipWith3MGHC.ForeignSrcLang.TypeForeignSrcLang RawObjectLangAsm LangObjcxxLangObjcLangCLangCxx TyConRepNameUserDataGHC.IOFilePathGHC.Data.FastString FastString NameCache Data.EitherLeftCtLocCtOrigin Implicationic_tclvlic_bindsic_infoGHC.Utils.Panic.Plainpanicic_envFixedRuntimeRepProvenance runtimeRepTy RuntimeRepGHC.Types.Avail AvailInfoGHC.Data.MaybeMaybeErrmoduleFreeHolesTidyEnvJustGHC.Settings.ConstantsmAX_TUPLE_SIZEmAX_CTUPLE_SIZEsortWith mkNoRepType Data.VersionVersion versionBranch versionTagsControl.Exception.Basetry GHC.Conc.SyncthrowToGHC.Exception.Type ExceptiondisplayException toException fromExceptionGHC.Listfoldl1'GHC.Stack.Types HasCallStackGHC.Driver.PluginsdefaultFrontendPlugin withPlugins_ mapPlugins withPluginspluginsWithArgskeepRenamedSource defaultPlugin flagRecompile impurePlugin purePluginpluginRecompile' lpModuleNameCommandLineOptionPluginWithArgspaPlugin paArgumentsPluginRecompileMaybeRecompileForceRecompileNoForceRecompile CorePluginFrontendPluginActionFrontendPluginfrontendhfIsLclpprHoleFitCand TypedHoleth_holeth_relevant_cts th_implics CandPlugin FitPlugin debugTraceMsgdebugTraceMsgS fatalErrorMsgfatalErrorMsgSerrorMsg errorMsgSputMsgputMsgSmsggetFirstAnnotationsgetAnnotationsgetPackageFamInstEnv getUniqMask addSimplCountgetVisibleOrphanMods getRuleBaseliftIOWithCountrunCoreM doSimplTickdoFreeSimplTickhasDetailedCounts simplCountN bindsOnlyPassrunMayberunWhenpprPassDetailsCoreToDo CoreOccurAnalCoreAddLateCcsCoreAddCallerCcsCoreDesugarOpt CoreDesugar CoreDoPasses CoreDoNothingCoreDoRuleCheckCoreCSECoreDoSpecConstrCoreDoSpecialisingCoreDoWorkerWrapper CoreDoCpr CoreDoDemand CoreDoExitifyCoreDoCallArityCoreDoStaticArgsCoreDoPrintCoreCoreLiberateCaseCoreDoFloatOutwardsCoreDoFloatInwardsCoreDoPluginPassCoreDoSimplifyCorePrepCoreTidy SimplMode sm_dflags sm_logger sm_pre_inlinesm_cast_swizzle sm_eta_expand sm_case_case sm_inlinesm_rules sm_uf_optssm_namessm_phaseFloatOutSwitchesfloatToTopLevelOnlyfloatOutOverSatAppsfloatOutLambdasfloatOutConstantsCorePluginPassTickSimplifierDoneFillInCaseDefault CaseIdentityCaseElimAltMerge CaseMerge KnownBranch CaseOfCase BetaReduction EtaReduction EtaExpansionLetFloatFromLet RuleFired UnfoldingDonePreInlineUnconditionallyPostInlineUnconditionallyCoreM discardIChscActiveUnitIdhscSetActiveUnitIdhscSetActiveHomeUnit hscSetFlagshscUpdateFlagshscUpdateLoggerFlags hscInterp mainModIslookupIfaceByModule lookupTypeprepareAnnotationshptSomeThingsBelowUs hptAllThingshptAnnshptRuleshptInstancesBelowhptAllInstanceshptCompleteSigshscEPS hscUpdateHUG hscUpdateHPThsc_all_home_unit_idshsc_HUGhsc_HUEhsc_HPT hsc_unitshsc_home_unit_maybe hsc_home_unitrunInteractiveHscmkInteractiveHscEnvrunHsc'runHscHsc hsc_tmpfs hsc_hooks hsc_logger hsc_unit_env hsc_plugins hsc_interphsc_type_env_varshsc_FChsc_NChsc_IC hsc_mod_graph hsc_dflags hsc_targets throwOneError throwErrorssrcErrorMessagesmkSrcErrGHC.Types.Meta metaRequestAW metaRequestD metaRequestT metaRequestP metaRequestE MetaRequestMetaAWMetaDMetaTMetaEMetaP MetaResultMetaHookGHC.Unit.Module.ModGutsmg_mnwibModGutsmg_docs mg_trust_pkgmg_safe_haskellmg_boot_exportsmg_fam_inst_env mg_inst_env mg_modBreaks mg_hpc_infomg_complete_matchesmg_annsmg_warnsmg_foreign_files mg_foreignmg_bindsmg_rules mg_patsyns mg_fam_instsmg_instsmg_tcs mg_fix_env mg_rdr_env mg_used_th mg_usagesmg_deps mg_exportsmg_loc mg_module mg_hsc_srcCgGutscg_spt_entries cg_modBreaks cg_hpc_info cg_dep_pkgscg_foreign_files cg_foreigncg_ccscg_binds cg_module cg_tycons forceModIfaceemptyIfaceHashCachemkIfaceHashCacheemptyFullModIfaceemptyPartialModIfacerenameFreeHoles mi_free_holesmi_semantic_modulemi_fixmi_mnwibmi_bootPartialModIfaceModIfaceBackend mi_hash_fn mi_fix_fn mi_warn_fnmi_orphan_hash mi_exp_hash mi_finsts mi_orphanmi_plugin_hash mi_hpc_hash mi_opt_hash mi_flag_hash mi_iface_hash mi_mod_hash IfaceDeclExtsIfaceBackendExts IfaceExportWhetherHasOrphansWhetherHasFamInst findTargetmsDepsms_mnwib isBootSummarymsDynObjFilePath msObjFilePathmsDynHiFilePath msHiFilePath msHsFilePathms_plugin_impsms_impsms_installed_mod ms_unitidGHC.Core.RulesruleCheckProgram initRuleOpts lookupRule pprRuleBase extendRuleEnvextendRuleBaseList mkRuleBase emptyRuleBasegetRules rulesOfBindsaddIdSpecialisations addRuleInfoextendRuleInfopprRulesForUser roughTopNamesmkRule GHC.Core.MakemkAbsentErrorAppaBSENT_ERROR_IDaBSENT_SUM_FIELD_ERROR_ID tYPE_ERROR_IDnON_EXHAUSTIVE_GUARDS_ERROR_IDnO_METHOD_BINDING_ERROR_ID pAT_ERROR_IDrEC_CON_ERROR_IDrUNTIME_ERROR_IDrEC_SEL_ERROR_IDerrorIdsmkImpossibleExprmkRuntimeErrorApp mkJustExpr mkNothingExpr mkBuildExpr mkFoldrExprmkNonEmptyListExpr mkListExpr mkConsExpr mkNilExpr floatBindings wrapFloatmkSmallTupleCase mkTupleCasemkSmallTupleSelectormkTupleSelector1mkTupleSelectorunitExprmkBigCoreTupTy mkBigCoreTupmkBigCoreVarTupTymkBigCoreVarTup1mkBigCoreVarTup mkCoreUbxSummkCoreTupBoxity mkCoreUbxTup mkCoreTupmkCoreVarTupTymkStringExprFSWithgetMkStringIdsmkStringExprFS mkStringExpr mkCharExpr mkDoubleExpr mkFloatExpr mkNaturalExpr mkIntegerExpr mkWordExpr mkIntExprIntmkUncheckedIntExpr mkLitRubbishcastBottomExpr mkIfThenElse mkWildCasemkWildValBindermkWildEvBinder mkCoreApp mkCoreApps mkCoreConApps mkCoreLets mkCoreLams mkCoreLet sortQuantVars MkStringIdsunpackCStringIdunpackCStringUtf8Id FloatBindFloatLet FloatCaseHoleFitCandidate GreHFCandIdHFCand NameHFCandHoleFit RawHoleFithfDoc hfMatcheshfWraphfRefLvlhfTypehfIdhfCandGHC.Driver.Ppr printForUsershowSDocForUsershowPprshowSDocGHC.Unit.StateimplicitPackageDepspprWithUnitStateinstModuleToModulerenameHoleUnit'renameHoleModule'renameHoleUnitrenameHoleModuleinstUnitToUnit improveUnit pprModuleMappprUnitsSimplepprUnitspprUnitInfoForUserpprUnitIdForUserrequirementMergesmayThrowUnitErrcloseUnitDeps' closeUnitDepslistVisibleModuleNames!lookupPluginModuleWithSuggestionslookupModulePackagelookupModuleWithSuggestionslookupModuleInAllUnits unwireUnit pprReasonpprFlagreadUnitDatabaseresolveUnitDatabase getUnitDbRefsreadUnitDatabases initUnits listUnitInforesolvePackageImportsearchPackageIdlookupPackageNameunsafeLookupUnitIdunsafeLookupUnit lookupUnitId' lookupUnitId lookupUnit' lookupUnitemptyUnitState ModuleOrigin ModOrigin ModHidden ModUnusablefromPackageFlagfromHiddenReexport fromOrigUnitfromExposedReexportPreloadUnitClosure UnitStateallowVirtualUnitsrequirementContextpluginModuleNameProvidersMapmoduleNameProvidersMaphomeUnitDepends explicitUnits preloadUnits unwireMapwireMappackageNameMap unitInfoMappreloadClosure UnitDatabaseunitDatabasePathunitDatabaseUnits UnitInfoMapUnusableUnitReasonShadowedDependenciesIgnoredDependenciesCyclicDependenciesIgnoredWithFlagBrokenDependencies LookupResultLookupNotFoundLookupUnusable LookupHidden LookupFoundLookupMultipleModuleSuggestionSuggestVisible SuggestHiddenUnitErr TrustFlagErr CloseUnitErrPackageFlagErr ShHoleSubstupdatePlatformConstantspprDynFlagsDiffways objectSuf outputFileinitDefaultSDocContextinitSDocContextuseXLinkerRPathneedSourceNotessccProfilingEnabled isBmi2Enabled isBmiEnabledisAvx512pfEnabledisAvx512fEnabledisAvx512erEnabledisAvx512cdEnabled isAvx2Enabled isAvxEnabledisSse4_2EnabledsetUnsafeGlobalDynFlagsmakeDynFlagsConsistent targetProfile compilerInfopicPOpts pieCCLDOpts picCCOpts setTmpDirsetFlagsFromEnvFileaugmentByWorkingDirectory setUnitIdunSetGeneralFlag'setGeneralFlag'glasgowExtsFlags impliedXFlagsimpliedOffGFlags impliedGFlagsxFlagssupportedLanguagesAndExtensions fLangFlagsfFlags wWarningFlags flagSpecOfturnOffturnOnflagsForCompletion flagsPackage flagsDynamicflagsAllallNonDeprecatedFlagsparseDynamicFlagsFullparseDynamicFilePragmaparseDynamicFlagsCmdLine updOptLeveladdPluginModuleNamesetDynOutputHi setOutputHisetDynOutputFile setOutputFile getVerbFlagsgetOptsunsafeFlagsForInfer unsafeFlagssafeImplicitImpsReqsafeDirectImpsReq safeImportsOn safeInferOnsafeLanguageOnsafeHaskellModeEnabled safeHaskellOnpackageTrustOnlang_setxopt_FieldSelectorsxopt_DuplicateRecordFieldsxopt_set_unlessExplSpec xopt_unsetxopt_setxoptwopt_unset_fatalwopt_set_fatal wopt_fatal wopt_unsetwopt_setwopt gopt_unsetgopt_set dopt_unsetdopt_setdopthasNoOptCoercionhasNoStateHackhasNoDebugOutput hasPprDebuglanguageExtensionsdefaultFlushOutdefaultFatalMessagerdefaultDynFlags initDynFlags setDynamicNowdynamicTooStatepositionIndependentpackageFlagsChangedisNoLink isOneShotversionedFilePathversionedAppDiropt_iopt_lcopt_loopt_lcc opt_windresopt_lmopt_lopt_aopt_cxxopt_copt_Fopt_P_signatureopt_Popt_Lpgm_ipgm_lcpgm_lo pgm_ranlibpgm_install_name_tool pgm_otoolpgm_arpgm_lcc pgm_libtool pgm_windrespgm_Tpgm_dllpgm_lmpgm_lpgm_apgm_cpgm_Fpgm_Ppgm_LglobalPackageDatabasePathextraGccViaCFlagstopDir ghciUsagePath ghcUsagePathprojectVersion programNamesettingsflattenIncludesaddImplicitQuoteIncludeaddQuoteIncludeaddGlobalInclude IncludeSpecsincludePathsQuoteImplicitincludePathsQuoteincludePathsGlobal HasDynFlagsContainsDynFlagsextractDynFlagsProfAuto ProfAutoCallsProfAutoExports ProfAutoTop NoProfAuto ProfAutoAll LlvmTarget lAttributes lDataLayoutlCPU LlvmConfig llvmTargets llvmPasses PackageArg UnitIdArg ModRenamingmodRenamingWithImplicit modRenamingsIgnorePackageFlag IgnorePackage TrustFlag TrustPackageDistrustPackage PackageFlag ExposePackage HidePackage PackageDBFlagClearPackageDBsNoGlobalPackageDB PackageDBNoUserPackageDB DynLibLoader DeployableSystemDependentRtsOptsEnabled RtsOptsAllRtsOptsSafeOnlyRtsOptsIgnoreAll RtsOptsNone RtsOptsIgnoreDynamicTooStateDT_DynDT_DontDT_OK FatalMessagerFlushOut TurnOnFlagFlagSpecflagSpecGhcModeflagSpecAction flagSpecName flagSpecFlagPkgDbRef PkgDbPath GlobalPkgDb UserPkgDb LinkerInfo UnknownLDAixLD SolarisLDDarwinLDLlvmLLDGnuLDGnuGold CompilerInfo UnknownCC AppleClang51 AppleClangGCCClangDiagnosticReasonErrorWithoutFlagWarningWithoutFlagWarningWithFlagisUnsafeEqualityProofcomputeCbvInfodumpIdInfoOfProgram isJoinBindcollectMakeStaticArgsnormSplitTyConApp_maybe isEmptyTycanEtaReduceToArity tryEtaReduce diffBindseqExpr cheapEqExpr' cheapEqExprdataConRepFSInstPatexprIsTickedString_maybeexprIsTickedStringexprIsTopLevelBindable exprIsConLike exprIsHNFaltsAreExhaustiveexprOkForSideEffectsexprOkForSpeculationisExpandableApp isCheapAppexprIsExpandable exprIsCheapX exprIsCheapexprIsWorkFree exprIsDupable exprIsDeadEndgetIdFromTrivialExpr_maybegetIdFromTrivialExpr exprIsTrivial scaleAltsBycombineIdenticalAltsrefineDefaultAlt filterAlts trimConArgs mergeAltsfindAlt isDefaultAlt addDefault findDefaultmkSingleAltCase mkDefaultCase mkAltExprneedsCaseBinding bindNonRec stripTicksT stripTicksEstripTicksTopTstripTicksTopE stripTicksTop tickHNFArgs mkTickNoHNFisSaturatedConAppmkTicksmkTickmkCastmkPiMCo mkCastMCoapplyTypeToArgs mkLamTypes mkLamType coreAltsType coreAltType CheapAppFun GHC.Core.FVsfreeVars freeVarsBindstableUnfoldingVarsidUnfoldingVars idRuleVarsbndrRuleAndUnfoldingIdsbndrRuleAndUnfoldingVarsDSetidFVs dIdFreeVars idFreeVarsvarTypeTyCoFVsvarTypeTyCoVars freeVarsOfAnn freeVarsOf mkRuleInfo rulesFreeVarsrulesFreeVarsDSet ruleFreeVarsruleLhsFreeIdsListruleLhsFreeIdsrulesRhsFreeIdsruleRhsFreeVarsorphNamesOfFamInstorphNamesOfAxiomorphNamesOfCoCon orphNamesOfCoorphNamesOfTypesorphNamesOfTypeexprsOrphNamesexpr_fvsexprsSomeFreeVarsListexprsSomeFreeVarsexprSomeFreeVarsListexprSomeFreeVars bindFreeVarsexprsFreeVarsList exprsFreeVarsexprsFreeIdsListexprsFreeIdsDSetexprFreeIdsListexprFreeIdsDSet exprsFreeIds exprFreeIdsexprFreeVarsListexprFreeVarsDSet exprFreeVarsFVAnnCoreBindWithFVsCoreExprWithFVsCoreExprWithFVs'CoreAltWithFVs filterCTuplenaturalNBDataConnaturalNSDataCon naturalTyConnaturalNBDataConNamenaturalNSDataConNamenaturalTyConNameintegerINDataConintegerIPDataConintegerISDataCon integerTyConintegerINDataConNameintegerIPDataConNameintegerISDataConNameintegerTyConNamemkPromotedListTypromotedNilDataConpromotedConsDataConpromotedGTDataConpromotedEQDataConpromotedLTDataConpromotedJustDataConpromotedNothingDataConpromotedFalseDataConpromotedTrueDataConmkSumTy mkTupleTy1 mkTupleTyisPromotedMaybeTy mkMaybeTymkPromotedMaybeTy justDataConnothingDataCon maybeTyConnonEmptyDataCon nonEmptyTyCon consDataCon nilDataConmkListTyordGTDataConIdordEQDataConIdordLTDataConId ordGTDataCon ordEQDataCon ordLTDataCon orderingTyCon trueDataConIdfalseDataConId trueDataCon falseDataCon boolTyConboolTy doubleDataCon doubleTyCondoubleTy floatDataCon floatTyConfloatTy word8DataCon word8TyConword8Ty wordDataCon wordTyConwordTy intDataConintTyConintTystringTy charDataCon charTyConboxingDataCon_maybesumRepDataConTyConunliftedDataConTyConunrestrictedFunTyConName manyDataCon oneDataConcoercibleDataConcoercibleClass heqDataConheqClass eqDataConeqClasseqTyConunboxedSumKindunboxedUnitDataConunboxedUnitTyCon unboxedUnitTy pairTyCon soloTyCon unitDataConId unitDataCon unitTyConKey unitTyConisPromotedPairTypemkPromotedPairTytupleDataConName cTupleSelIdcTupleDataConNamescTupleTyConNameArity_maybeisCTupleTyConNamecTupleTyConNames cTupleTyCon mkTupleStrisBuiltInOcc_maybetypeToTypeKindconstraintKindTyContypeSymbolKindConconsDataCon_RDR listTyCon_RDRintDataCon_RDRstringTyCon_RDR charTyCon_RDR intTyCon_RDRtrue_RDR false_RDR boolTyCon_RDRmanyDataConNameoneDataConNamemultiplicityTyConNameunliftedRepTyConNameliftedRepTyConNameunliftedTypeKindTyConNameconstraintKindTyConNamemakeRecoveryTyConanyTyanyTyCondoubleTyConNamefloatTyConName wordTyConNamejustDataConNamenothingDataConNamemaybeTyConNamenonEmptyDataConNamenonEmptyTyConNameconsDataConNamenilDataConName listTyConName boolTyConName intTyConName charTyConNamecoercibleTyConName heqTyConName eqTyCon_RDR eqTyConNamemkWiredInIdNamemkWiredInTyConName wiredInTyConsGHC.Types.Id.InfoisNeverRepPolyIdInfosetLevityInfoWithTypesetNeverRepPolyzapCallArityInfozapTailCallInfo zapUnfoldingzapFragileInfozapUsedOnceInfozapUsageEnvInfo zapUsageInfo zapDemandInfo zapLamInfo ppCafInfomayHaveCafRefssetRuleInfoHead ruleInfoRulesruleInfoFreeVarsisEmptyRuleInfo emptyRuleInfo pprStrictness ppArityInfo unknownArity noCafIdInfo setCprSigInfo setDmdSigInfo setDemandInfosetOneShotInfo setTagSig setLFInfo setCafInfosetCallArityInfo setArityInfohasInlineUnfoldingsetUnfoldingInfo unfoldingInfo setOccInfosetInlinePragInfo setRuleInfo tagSigInfo callArityInfocafInfo arityInfo oneShotInfo levityInfoisJoinIdDetails_maybe RecSelParent RecSelData RecSelPatSyn ArityInfoInlinePragInfoRuleInfoCafInfoMayHaveCafRefs NoCafRefs TickBoxId TickBoxOpTickBox LevityInfoGHC.CorecollectNAnnBndrscollectAnnBndrs deAnnBinddeAnnAlt deAnnotate' deAnnotatecollectAnnArgsTickscollectAnnArgs valArgCount valBndrCount isTypeArgisCoArg isTyCoArgisValArg isRuntimeArg isRuntimeVarcollectArgsTicks stripNArgs wrapLamBody collectArgscollectNBinderscollectTyAndValBinderscollectTyBinderscollectBinders flattenBinds rhssOfAlts rhssOfBindbindersOfBindsexprToCoercion_maybe exprToTypeapplyTypeToArgvarsToCoreExprs varToCoreExprmkCoBindmkTyBindmkLetRec mkLetNonRecmkLetmkLetsmkLamsmkDoubleLitDouble mkDoubleLitmkFloatLitFloat mkFloatLit mkStringLit mkCharLitmkInt64LitInt64mkWord64LitWord64 mkWord8Lit mkWordLitWrap mkWordLit mkIntLitWrapmkIntLitmkTyArg mkConApp2mkTyAppsmkConApp mkVarAppsmkCoAppsmkApps deTagExpr cmpAltConltAltcmpAlt canUnfoldhasCoreUnfoldingneverUnfoldGuidanceisBootUnfoldinghasSomeUnfoldingisInlineUnfoldingisStableUnfoldingisCompulsoryUnfoldingexpandUnfolding_maybeisExpandableUnfoldingisCheapUnfoldingisConLikeUnfoldingisEvaldUnfoldingisValueUnfolding otherConsmaybeUnfoldingTemplateunfoldingTemplateisStableSource mkOtherCon bootUnfoldingevaldUnfolding noUnfoldingboringCxtNotOk boringCxtOk unSaturatedOk needSaturated setRuleIdName isLocalRule ruleIdNameruleActivation ruleModuleruleName ruleArity isAutoRule isBuiltinRule emptyRuleEnv mkRuleEnvchooseOrphanAnchor notOrphanisOrphanCaseLetLamLitAppArgAltAltConDEFAULTDataAltLitAltBindNonRecRecInBndrInTypeInKindInBindInExprInAltInArg InCoercionOutBndrOutTypeOutKind OutCoercionOutBindOutExprOutAltOutArg MOutCoercionIsOrphan NotOrphanRuleBaseRuleEnvre_basere_visible_orphsCoreRuleRule BuiltinRuleru_tryru_nargsru_local ru_orphan ru_originru_autoru_rhsru_argsru_bndrsru_roughru_fnru_nameru_actRuleOpts roBignumRulesroExcessRationalPrecision roPlatformroNumConstantFoldingRuleFun InScopeEnvIdUnfoldingFun Unfolding CoreUnfolding DFunUnfoldingOtherCon NoUnfolding BootUnfolding uf_guidance uf_expandableuf_is_work_free uf_is_conlike uf_is_value uf_is_topuf_srcuf_tmpldf_argsdf_bndrsdf_conUnfoldingSourceInlineCompulsory InlineRhs InlineStableUnfoldingGuidanceUnfNeverUnfWhen UnfIfGoodArgsug_resug_sizeug_args ug_boring_okug_arity ug_unsat_ok CoreProgramCoreBndrCoreExprCoreArgCoreBindCoreAlt TaggedBndrTB TaggedBind TaggedExpr TaggedArg TaggedAltAnnExprAnnExpr' AnnCoercionAnnTickAnnCastAnnAppAnnLitAnnVarAnnAltAnnBind AnnNonRecsplitDataProductType_maybedataConUserTyVarsArePermuteddataConCannotMatch classDataConspecialPromotedDc isNewDataConisUnboxedTupleDataConisBoxedTupleDataConisTupleDataCondataConIdentitydataConRepArgTysdataConOtherThetadataConOrigArgTysdataConInstUnivsdataConDisplayTypedataConNonlinearTypedataConOrigResTydataConInstSig dataConBoxerdataConImplBangsdataConRepStrictnessisNullaryRepDataConisNullarySrcDataCondataConRepAritydataConFieldType_maybedataConFieldTypedataConImplicitTyThingsdataConWrapId_maybe dataConTheta dataConEqSpecdataConUnivAndExTyCoVarsdataConUnivTyVarsdataConRepTypedataConOrigTyCon dataConTagZ dataConTag mkDataConcbvFromStrictMark isSrcUnpacked isSrcStrictisBangedeqHsBang filterEqSpec substEqSpec eqSpecPreds eqSpecPair eqSpecType eqSpecTyVarmkEqSpec DataConEnv HsSrcBang HsImplBangHsUnpackHsLazyHsStrict SrcStrictness NoSrcStrictSrcLazy SrcStrictSrcUnpackedness NoSrcUnpack SrcUnpack SrcNoUnpackmkFunctionTypeGHC.Types.Literal pprLiteral literalType litIsLifted litFitsInChar litIsDupable litIsTrivial nullAddrLitdoubleToFloatLitfloatToDoubleLitintToDoubleLitdoubleToIntLit intToFloatLit floatToIntLit intToCharLit charToIntLitconvertToIntLitconvertToWordLitnarrowWord64LitnarrowWord32LitnarrowWord16LitnarrowWord8LitnarrowInt64LitnarrowInt32LitnarrowInt16Lit narrowInt8Lit mapLitValueisLitValue_maybelitValueisOneLit isZeroLit inCharRange isMaxBound isMinBound isLitRubbish mkLitBigNat mkLitString mkLitChar mkLitDouble mkLitFloatmkLitWord64UncheckedmkLitWord64Wrap mkLitWord64mkLitInt64UncheckedmkLitInt64Wrap mkLitInt64mkLitWord32UncheckedmkLitWord32Wrap mkLitWord32mkLitInt32UncheckedmkLitInt32Wrap mkLitInt32mkLitWord16UncheckedmkLitWord16Wrap mkLitWord16mkLitInt16UncheckedmkLitInt16Wrap mkLitInt16mkLitWord8UncheckedmkLitWord8Wrap mkLitWord8mkLitInt8Unchecked mkLitInt8Wrap mkLitInt8mkLitWordWrapCmkLitWordUnchecked mkLitWordWrap mkLitWord mkLitIntWrapCmkLitIntUnchecked mkLitIntWrapmkLitInt mkLitNumber litNumRangelitNumCheckRange litNumNarrow litNumCoerce litNumWrapmkLitNumberWrap litNumBitSizelitNumIsSignedLiteralLitLabel LitDoubleLitFloat LitRubbish LitNullAddr LitStringLitChar LitNumber LitNumType LitNumWord64 LitNumWord32 LitNumWord16 LitNumWord8 LitNumWord LitNumInt64 LitNumInt32 LitNumInt16 LitNumInt8 LitNumBigNat LitNumInt tyConSkolempprPromotionQuotetcFlavourIsOpen tyConFlavour mkTyConTagMaptyConRuntimeRepInfotyConFamilyCoercion_maybetyConFamInst_maybetyConFamInstSig_maybeisFamInstTyContyConATsfamTyConFlav_maybetyConStupidThetanewTyConDataCon_maybe newTyConConewTyConCo_maybenewTyConEtadRhsnewTyConEtadArity newTyConRhs tyConRolestyConFamilyResVar_maybe algTyConRhstyConFamilySizetyConAlgDataCons_maybetyConSingleAlgDataCon_maybetyConSingleDataContyConSingleDataCon_maybetyConDataCons_maybeisTyConWithSrcDataConsexpandSynTyCon_maybeisConcreteTyContcHasFixedRuntimeRepsetTcTyConKind isTcTyContyConCType_maybeisImplicitTyConisLiftedTypeKindTyConName isKindTyConisPromotedDataCon_maybeisPromotedDataConisPromotedTupleTyConisUnboxedSumTyConisBoxedTupleTyContyConTuple_maybetyConFlavourAssoc_maybetyConAssoc_maybe isTyConAssocisBuiltInSynFamTyCon_maybetyConInjectivityInfo%isClosedSynFamilyTyConWithAxiom_maybeisDataFamilyTyConisEnumerationTyConisGadtSyntaxTyConmustBeSaturatedisForgetfulSynTyConisFamFreeTyCon isTauTyConunwrapNewTyConEtad_maybeunwrapNewTyCon_maybeisGenInjAlgRhsisGenerativeTyConisInjectiveTyCon isDataTyConisVanillaAlgTyCon isAlgTyConisAbstractTyConmkPromotedDataCon mkFamilyTyConmkSynonymTyCon mkPrimTyConnoTcTyConScopedTyVars mkTcTyCon mkSumTyCon mkTupleTyCon mkClassTyCon mkAlgTyCon mkFunTyConlookupTyConFieldLabeltyConFieldLabelsprimRepIsFloatprimElemRepToPrimRepprimElemRepSizeB primRepSizeBprimRepsCompatibleprimRepCompatibletyConRepModOcc isNoParentvisibleDataConsmkDataTyConRhsmkLevPolyDataTyConRhstyConVisibleTyVarstyConInvisTVBinders mkTyConKindisInvisibleTyConBinderisVisibleTcbVisisVisibleTyConBinderisNamedTyConBindertyConBndrVisArgFlagtyConBinderArgFlagmkRequiredTyConBindermkNamedTyConBindersmkNamedTyConBindermkAnonTyConBindersmkAnonTyConBinder TyConBinderTyConTyCoBinder TyConBndrVisNamedTCBAnonTCB AlgTyConRhsNewTyConSumTyCon TupleTyCon AbstractTyCon DataTyCon nt_fixed_repnt_co nt_etad_rhsnt_rhstup_sortdata_condata_fixed_levis_enum data_consdata_cons_sizeRuntimeRepInfo UnliftedInfo LiftedInfoNoRRIVecElemVecCount AlgTyConFlavDataFamInstTyCon ClassTyConVanillaAlgTyConUnboxedSumTyCon Injectivity NotInjective Injective FamTyConFlavBuiltInSynFamTyConAbstractClosedSynFamilyTyConClosedSynFamilyTyConDataFamilyTyConOpenSynFamilyTyConVoidRep DoubleRepFloatRepAddrRep Word64Rep Word32Rep Word16RepWord8RepWordRepInt64RepInt32RepInt16RepInt8RepIntRep UnliftedRepVecRep LiftedRep PrimElemRep DoubleElemRep FloatElemRep Word64ElemRep Word32ElemRep Word16ElemRep Word8ElemRep Int64ElemRep Int32ElemRep Int8ElemRep Int16ElemRep TyConFlavourPromotedDataConFlavourBuiltInTypeFlavourTypeSynonymFlavourClosedTypeFamilyFlavourOpenTypeFamilyFlavourDataFamilyFlavourAbstractTypeFlavourNewtypeFlavourDataTypeFlavour SumFlavour ClassFlavour TupleFlavour nilDataConKey listTyConKeyGHC.Types.AnnotationsdeserializeAnnsfindAnnsByTypeRepfindAnns plusAnnEnvextendAnnEnvListmkAnnEnv emptyAnnEnv Annotation ann_target ann_value AnnPayload AnnTarget NamedTarget ModuleTarget CoreAnnTargetAnnEnvopIsAtpprNameProvenanceisExplicitItemimportSpecModule importSpecLoc qualSpecOK unQualSpecOK bestImport shadowNamesextendGlobalRdrEnv transformGREsmkGlobalRdrEnvplusGlobalRdrEnvpickGREsModExppickGREsunQualOK greFieldLabelisFieldSelectorGREisNoFieldSelectorGREisDuplicateRecFldGRE isRecFldGRE isLocalGREgetGRE_NameQualifier_maybeslookupGRE_Name_OccNamelookupGRE_FieldLabellookupGRE_GreNamelookupGRE_NamelookupGRE_RdrName'lookupGRE_RdrNamelookupGlobalRdrEnvpprGlobalRdrEnvglobalRdrEnvEltsemptyGlobalRdrEnv availFromGREgresToAvailInfogreParent_maybe greSrcSpan greRdrNamesgreQualModNamegreDefinitionModulegreDefinitionSrcSpangrePrintableNamegreMangledName greOccName gresFromAvaillocalGREsFromAvailminusLocalRdrEnvinLocalRdrEnvScopelocalRdrEnvEltselemLocalRdrEnvlookupLocalRdrOcclookupLocalRdrEnvextendLocalRdrEnvListextendLocalRdrEnvemptyLocalRdrEnv isExact_maybeisExact isOrig_maybeisOrig isQual_maybeisQualisUnqual isSrcRdrNameisRdrTc isRdrTyVar isRdrDataCon nameRdrName getRdrNamemkQual mkVarUnqualmkUnqualmkOrig mkRdrQual mkRdrUnqualpromoteRdrName demoteRdrName rdrNameSpace rdrNameOccExactOrig LocalRdrEnv GlobalRdrEnv GlobalRdrEltGREgre_impgre_lclgre_namegre_parParentNoParentParentIspar_is ImportSpecImpSpecis_declis_item ImpDeclSpecis_dlocis_qualis_modis_as ImpItemSpecImpAllImpSome is_explicitis_ilocgreNameSrcSpanGreName NormalGreName FieldGreNameGHC.Types.Name.EnvnonDetStrictFoldDNameEnvplusDNameEnv_C foldDNameEnv eltsDNameEnvextendDNameEnv_CextendDNameEnv alterDNameEnvadjustDNameEnv mapDNameEnvfilterDNameEnvdelFromDNameEnvlookupDNameEnvisEmptyDNameEnv emptyDNameEnvlookupNameEnv_NFseqEltsNameEnvdisjointNameEnv anyNameEnv filterNameEnvdelListFromNameEnvdelFromNameEnvextendNameEnvList_CextendNameEnv_Acc mapNameEnvextendNameEnv_CplusNameEnv_CD2plusNameEnv_CD plusNameEnv_C plusNameEnv elemNameEnv mkNameEnvWith mkNameEnv alterNameEnv lookupNameEnvextendNameEnvList extendNameEnv unitNameEnvisEmptyNameEnv emptyNameEnvnonDetNameEnvEltsdepAnalNameEnvDNameEnvGHC.Types.Name.SetfindUsesduUsesallUsesduDefsplusDUmkDUsusesOnlyemptyDUs intersectFVsdelFVsdelFVunitFVaddOneFVmkFVsplusFVplusFVsemptyFVs isEmptyFVsnameSetElemsStableintersectsNameSetdelListFromNameSetdisjointNameSetintersectNameSet filterNameSetdelFromNameSet elemNameSet minusNameSet unionNameSets unionNameSet extendNameSetextendNameSetList mkNameSet unitNameSet emptyNameSetisEmptyNameSetNameSetFreeVarsDefsUsesDefUseDefUses NonCaffySet anyDVarEnvextendDVarEnvListpartitionDVarEnv modifyDVarEnvextendDVarEnv_C elemDVarEnvisEmptyDVarEnvdelDVarEnvList delDVarEnv unitDVarEnv plusDVarEnv_C plusDVarEnv alterDVarEnv filterDVarEnv mapDVarEnvnonDetStrictFoldDVarEnv foldDVarEnv lookupDVarEnv minusDVarEnv extendDVarEnv mkDVarEnv dVarEnvElts emptyDVarEnvmodifyVarEnv_Directly modifyVarEnvlookupVarEnv_NF zipVarEnvrestrictVarEnvpartitionVarEnv isEmptyVarEnv unitVarEnv emptyVarEnvmkVarEnv_DirectlymkVarEnv mapVarEnvlookupWithDefaultVarEnv filterVarEnvlookupVarEnv_Directly lookupVarEnvplusVarEnvList plusVarEnv minusVarEnv delVarEnv delVarEnvListplusMaybeVarEnv_C plusVarEnv_CD plusVarEnv_CextendVarEnvListextendVarEnv_AccextendVarEnv_C extendVarEnv alterVarEnvdisjointVarEnvelemVarEnvByKey elemVarEnvdelTidyEnvListmkEmptyTidyEnv emptyTidyEnvrnSwap nukeRnEnvR nukeRnEnvLlookupRnInScopeinRnEnvRinRnEnvL rnOccR_maybe rnOccL_maybernOccRrnOccL delBndrsR delBndrsLdelBndrRdelBndrLrnEtaRrnEtaLrnBndrRrnBndrL rnBndr2_varrnBndr2rnBndrs2rnEnvRrnEnvL rnInScopeSet rnInScopeextendRnInScopeSetListmkRnEnv2unsafeGetFreshLocalUniqueuniqAway varSetInScope unionInScopelookupInScope_Directly lookupInScopeelemInScopeSet delInScopeSetextendInScopeSetSetextendInScopeSetListextendInScopeSet mkInScopeSetgetInScopeVarsVarEnvIdEnvTyVarEnv TyCoVarEnvCoVarEnvDVarEnvDIdEnv DTyVarEnv GHC.Utils.FVInterestingVarFunGHC.Types.Var.SettransCloDVarSetdVarSetToVarSetextendDVarSetList seqDVarSetdelDVarSetListpartitionDVarSet sizeDVarSet filterDVarSet mapDVarSet allDVarSet anyDVarSetnonDetStrictFoldDVarSetdVarSetMinusVarSet minusDVarSet delDVarSetisEmptyDVarSetintersectsDVarSetdisjointDVarSetdVarSetIntersectVarSetintersectDVarSetmapUnionDVarSet unionDVarSets unionDVarSet subDVarSet dVarSetElems elemDVarSet extendDVarSet mkDVarSet unitDVarSet emptyDVarSet pprVarSet pluralVarSet seqVarSettransCloVarSet fixVarSetnonDetStrictFoldVarSet mapVarSet allVarSet anyVarSet subVarSetdisjointVarSetintersectsVarSetmapUnionVarSetpartitionVarSetelemVarSetByKeydelVarSetByKey filterVarSet sizeVarSetlookupVarSetByName lookupVarSetlookupVarSet_DirectlymkVarSet isEmptyVarSet delVarSetList delVarSet minusVarSet elemVarSet unionVarSets unionVarSetintersectVarSetextendVarSetList extendVarSet unitVarSet emptyVarSetVarSetIdSetTyVarSetCoVarSet TyCoVarSetDVarSetDIdSet DTyVarSet DTyCoVarSetmustHaveLocalBinding isLocalVar isNonCoVarId isTyCoVar isTcTyVarsetIdNotExported setIdExported setIdDetails lazySetIdInfomkExportedLocalVar mkLocalVar mkGlobalVarsetTcTyVarDetailstcTyVarDetails mkTcTyVarmkTyVarupdateTyVarKindMupdateTyVarKind setTyVarKind setTyVarNamesetTyVarUnique tyVarName lookupVarBndr mapVarBndrs mapVarBndr isTyVarBindertyVarReqToBindertyVarReqToBinderstyVarSpecToBinderisInferredArgFlagupdateVarTypeM updateVarType setVarType setVarName setVarUnique varMultMaybe varUnique nonDetCmpVarNcIdTKVarTypeVarKindVarEvIdEvVarDFunIdDictIdIpIdEqVarInTyVarInCoVarOutTyVarOutCoVar ReqTVBinder listTyContypeSymbolKindcharTymkBoxedTupleTyheqTyConcoercibleTyConunitTyliftedTypeKindTyConNamezeroBitTypeKindunliftedTypeKindTyConliftedTypeKindTyConunliftedRepTyConliftedRepTyConconstraintKind vecElemTyCon vecCountTyCon levityTyConruntimeRepTyConlevityTyliftedDataConTyConboxedRepDataConTyContupleRepDataConTyConvecRepDataConTyCon zeroBitRepTy unliftedRepTy liftedRepTyunliftedDataConTyliftedDataConTydoubleRepDataConTyfloatRepDataConTyaddrRepDataConTyword64RepDataConTyword32RepDataConTyword16RepDataConTyword8RepDataConTywordRepDataConTyint64RepDataConTyint32RepDataConTyint16RepDataConTyint8RepDataConTyintRepDataConTyvec64DataConTyvec32DataConTyvec16DataConTy vec8DataConTy vec4DataConTy vec2DataConTydoubleElemRepDataConTyfloatElemRepDataConTyword64ElemRepDataConTyword32ElemRepDataConTyword16ElemRepDataConTyword8ElemRepDataConTyint64ElemRepDataConTyint32ElemRepDataConTyint16ElemRepDataConTyint8ElemRepDataConTy anyTypeOfKindunboxedTupleKindmultiplicityTyConmultiplicityTy oneDataConTyoneDataConTyCon manyDataConTymanyDataConTyCon multMulTyContupleTyConName naturalTy integerTypromotedTupleDataCon tupleDataCon tupleTyCon cTupleDataConcTupleDataConNamecTupleTyConNamecTupleSelIdName sumDataConsumTyCon dataConName dataConWorkIddataConExTyCoVarsdataConUserTyVarsdataConUserTyVarBindersdataConSourceAritydataConInstOrigArgTysdataConStupidThetadataConFullSigisUnboxedSumDataCon dataConWrapIdpromoteDataCon DataConRep NoDataConRepDCR dcr_bangs dcr_stricts dcr_arg_tys dcr_wrap_id dcr_boxerEqSpecGHC.Types.FieldLabelFieldLabelString FieldLabel flSelectorflHasFieldSelectorflLabelflHasDuplicateRecordFields GHC.Unit.Info unitHsLibscollectFrameworksDirscollectFrameworkscollectLibraryDirscollectExtraCcOptscollectIncludeDirs mkUnitPprInfomkUnit pprUnitInfounitPackageNameStringunitPackageIdString mapUnitInfo mkUnitKeyInfo GenUnitInfo UnitKeyInfoUnitInfo PackageId PackageName unPackageName GHC.SettingssLibFFIsGhcWithInterpretersTargetPlatformStringsExtraGccViaCFlagssOpt_isOpt_lccsOpt_lcsOpt_lo sOpt_windressOpt_lmsOpt_lsOpt_asOpt_cxxsOpt_csOpt_FsOpt_P_fingerprintsOpt_PsOpt_LsPgm_isPgm_lccsPgm_lcsPgm_lo sPgm_ranlibsPgm_ar sPgm_libtool sPgm_windressPgm_TsPgm_dllsPgm_lmsPgm_lsPgm_asPgm_csPgm_FsPgm_PsPgm_LsGccSupportsNoPie sLdIsGnuLdsLdSupportsFilelistsLdSupportsBuildIdsLdSupportsCompactUnwindsGlobalPackageDatabasePathsTopDirsToolDirsGhciUsagePath sGhcUsagePathsProjectVersion sProgramNameSettings sRawSettings sPlatformMisc sToolSettingssTargetPlatformsGhcNameVersion sFileSettings FileSettings"fileSettings_globalPackageDatabasefileSettings_topDirfileSettings_toolDirfileSettings_ghcUsagePathfileSettings_ghciUsagePathGhcNameVersionghcNameVersion_programNameghcNameVersion_projectVersion GHC.Platform wordAlignment PlatformMiscplatformMisc_llvmTargetplatformMisc_libFFI!platformMisc_targetPlatformStringplatformMisc_ghcWithInterpreterdefaultNonStandardTyVarsmightBeUnlifted mightBeLifted isKindLevel isTypeLevel mkIntWithInftreatZeroAsInf subWithInf intGtLimitpprInlineDebug pprInlineinlinePragmaNamesetInlinePragmaRuleMatchInfosetInlinePragmaActivationinlinePragmaRuleMatchInfoinlinePragmaActivationinlinePragmaSatisOpaquePragmaisAnyInlinePragmaisNoInlinePragmaisInlinablePragmaisInlinePragmaisDefaultInlinePragmadfunInlinePragmainlineSpecSourceinlinePragmaSourceinlinePragmaSpecalwaysInlineConLikePragmaneverInlinePragmaalwaysInlinePragmadefaultInlinePragmanoUserInlineSpec isFunLike isConLike competesWithisAlwaysActive isNeverActiveactiveInFinalPhaseisActiveactivateDuringFinalactivateAfterInitial laterPhase nextPhase activeAfter beginPhase successIf zapFragileOccisOneOcc isDeadOccisStrongLoopBreakerisWeakLoopBreakerweakLoopBreakerstrongLoopBreakerisAlwaysTailCalledzapOccTailCallInfo tailCallInfo seqOccInfo isManyOccs isNoOccInfo noOccInfo oneBranchunboxedTupleOrSumExtensionpprAlternative sumParens tupleParensboxityTupleSorttupleSortBoxity maybeParenappPrecstarPrecopPrecfunPrecsigPrectopPrechasOverlappingFlaghasOverlappableFlaghasIncoherentFlagsetOverlapModeMaybe isGenerated boolToRecFlagisNonRecisRec isMarkedCbvisBoxed isTopLevel isNotTopLevel pprRuleName isPromotedunSwap isSwappedflipSwap bestOneShot worstOneShothasNoOneShotInfo isOneShotInfo noOneShotInfo alignmentOf mkAlignment fIRST_TAGArityRepArity JoinArity FullArgCountConTag AlignmentalignmentBytes OneShotInfo NoOneShotInfo OneShotLamSwapFlag NotSwapped IsSwapped PromotionFlag NotPromoted IsPromotedFunctionOrData IsFunctionIsDataRuleName TopLevelFlagTopLevel NotTopLevelBoxedUnboxedCbvMark MarkedCbv NotMarkedCbvRecFlag Recursive NonRecursiveOrigin FromSource Generated OverlapFlag overlapMode isSafeOverlap OverlapMode NoOverlap IncoherentOverlaps Overlappable OverlappingPprPrec TupleSortConstraintTuple BoxedTuple UnboxedTupleUnboxedTupleOrSumUnboxedTupleTypeUnboxedSumTypeEPfromEPtoEPOccInfoIAmALoopBreakerOneOccManyOccsIAmDeadocc_rules_only occ_int_cxtocc_n_brocc_tail occ_in_lam BranchCountInterestingCxt IsInterestingNotInteresting InsideLam IsInsideLam NotInsideLam TailCallInfoAlwaysTailCalledNoTailCallInfo DefMethSpec VanillaDM GenericDMPhaseNum CompilerPhase FinalPhase InitialPhase Activation NeverActive FinalActive ActiveAfter AlwaysActive ActiveBefore InlinePragmainl_ruleinl_actinl_satinl_src inl_inline RuleMatchInfoConLikeFunLike InlineSpecNoUserInlinePrag InlinableInlineOpaque IntWithInfSpliceExplicitFlagExplicitSpliceImplicitSplice TypeOrKind TypeLevel KindLevelLevityLiftedUnlifted ExprOrPat ExpressionPatternNonStandardDefaultingStrategyDefaultNonStandardTyVars TryNotToDefaultNonStandardTyVarsDefaultingStrategyDefaultKindVarsNonStandardDefaulting isTupleTyConisUnboxedTupleTyContyConRepName_maybemkPrelTyConRepName tcTyConIsPolytcTyConScopedTyVars famTcResVar algTcFields tyConCTypetyConNullaryTy tyConResKind tyConBinders tyConName tyConUniquevarMultvarNameVarBndrBndr InvisTVBinderoptimisationFlagsLanguageGHC2021 Haskell98 Haskell2010Opt_D_faststring_statsOpt_D_dump_faststringsOpt_D_no_debug_outputOpt_D_ppr_debugOpt_D_dump_jsonOpt_D_dump_debugOpt_D_verbose_core2core!Opt_D_dump_view_pattern_commoningOpt_D_dump_timingsOpt_D_dump_mod_mapOpt_D_dump_mod_cyclesOpt_D_dump_hi_diffs Opt_D_dump_hiOpt_D_verbose_stg2stgOpt_D_source_statsOpt_D_dump_rttiOpt_D_dump_tickedOpt_D_dump_BCOsOpt_D_th_dec_fileOpt_D_dump_splicesOpt_D_dump_if_traceOpt_D_dump_ec_traceOpt_D_dump_tc_traceOpt_D_dump_cs_traceOpt_D_dump_simpl_statsOpt_D_dump_opt_cmmOpt_D_dump_rn_statsOpt_D_dump_rn_traceOpt_D_dump_worker_wrapperOpt_D_dump_cseOpt_D_dump_rulesOpt_D_dump_typesOpt_D_dump_hieOpt_D_dump_tc_ast Opt_D_dump_tcOpt_D_dump_cpr_signaturesOpt_D_dump_cpranalOpt_D_dump_str_signaturesOpt_D_dump_stranalOpt_D_dump_exitifyOpt_D_dump_call_arityOpt_D_dump_stg_finalOpt_D_dump_stg_tagsOpt_D_dump_stg_cgOpt_D_dump_stg_unarisedOpt_D_dump_stg_from_coreOpt_D_dump_prepOpt_D_dump_specOpt_D_dump_simpl_iterationsOpt_D_dump_simplOpt_D_dump_rn_ast Opt_D_dump_rnOpt_D_dump_parsed_astOpt_D_dump_parsedOpt_D_dump_occur_analOpt_D_dump_simpl_traceOpt_D_dump_rule_rewritesOpt_D_dump_rule_firingsOpt_D_dump_verbose_inliningsOpt_D_dump_inliningsOpt_D_dump_foreignOpt_D_dump_ds_preopt Opt_D_dump_dsOpt_D_dump_derivOpt_D_dump_core_statsOpt_D_dump_llvmOpt_D_dump_c_backendOpt_D_dump_asm_statsOpt_D_dump_asm_conflictsOpt_D_dump_asm_regalloc_stagesOpt_D_dump_asm_regallocOpt_D_dump_asm_livenessOpt_D_dump_asm_nativeOpt_D_dump_asmOpt_D_dump_cfg_weightsOpt_D_dump_cmm_cpsOpt_D_dump_cmm_infoOpt_D_dump_cmm_splitOpt_D_dump_cmm_procmapOpt_D_dump_cmm_cafOpt_D_dump_cmm_sinkOpt_D_dump_cmm_spOpt_D_dump_cmm_procOpt_D_dump_cmm_switchOpt_D_dump_cmm_cbeOpt_D_dump_cmm_cfgOpt_D_dump_cmm_verboseOpt_D_dump_cmm_verbose_by_procOpt_D_dump_cmm_rawOpt_D_dump_cmmOpt_D_dump_cmm_from_stg WarningFlag%Opt_WarnTypeEqualityRequiresOperatorsOpt_WarnTypeEqualityOutOfScopeOpt_WarnGADTMonoLocalBinds,Opt_WarnUnicodeBidirectionalFormatCharactersOpt_WarnForallIdentifier Opt_WarnRedundantStrictnessFlags/Opt_WarnMissingExportedPatternSynonymSignaturesOpt_WarnMissingKindSignaturesOpt_WarnImplicitLiftOpt_WarnAmbiguousFieldsOpt_WarnOperatorWhitespace%Opt_WarnOperatorWhitespaceExtConflictOpt_WarnInvalidHaddockOpt_WarnDerivingDefaults Opt_WarnCompatUnqualifiedImportsOpt_WarnMissingSafeHaskellModeOpt_WarnInferredSafeImportsOpt_WarnUnusedPackages"Opt_WarnPrepositiveQualifiedModule!Opt_WarnMissingDerivingStrategiesOpt_WarnSpaceAfterBangOpt_WarnImplicitKindVarsOpt_WarnStarBinderOpt_WarnStarIsTypeOpt_WarnInaccessibleCodeOpt_WarnMissingExportListOpt_WarnPartialFieldsOpt_WarnMissingHomeModulesOpt_WarnUnbangedStrictPatternsOpt_WarnCPPUndef$Opt_WarnSimplifiableClassConstraints Opt_WarnUnrecognisedWarningFlags'Opt_WarnMissingPatternSynonymSignatures#Opt_WarnNonCanonicalMonoidInstances&Opt_WarnNonCanonicalMonadFailInstances"Opt_WarnNonCanonicalMonadInstances#Opt_WarnDeferredOutOfScopeVariablesOpt_WarnDeferredTypeErrorsOpt_WarnDerivingTypeable$Opt_WarnUntickedPromotedConstructors!Opt_WarnMissingExportedSignaturesOpt_WarnPartialTypeSignaturesOpt_WarnTypedHolesOpt_WarnInlineRuleShadowingOpt_WarnMissedExtraSharedLibOpt_WarnUnsupportedLlvmVersion%Opt_WarnUnsupportedCallingConventionsOpt_WarnAllMissedSpecsOpt_WarnMissedSpecsOpt_WarnTrustworthySafe Opt_WarnSafeOpt_WarnUnsafe)Opt_WarnAlternativeLayoutRuleTransitionalOpt_WarnWrongDoBindOpt_WarnUnusedDoBindOpt_WarnDodgyForeignImportsOpt_WarnUnrecognisedPragmas Opt_WarnTabsOpt_WarnIdentitiesOpt_WarnAutoOrphansOpt_WarnOrphansOpt_WarnDodgyImportsOpt_WarnDodgyExportsOpt_WarnSemigroup!Opt_WarnMissingMonadFailInstancesOpt_WarnDeprecatedFlagsOpt_WarnWarningsDeprecations Opt_WarnRedundantRecordWildcardsOpt_WarnRedundantBangPatternsOpt_WarnUnusedRecordWildcardsOpt_WarnUnusedForallsOpt_WarnUnusedTypePatternsOpt_WarnUnusedMatchesOpt_WarnUnusedImportsOpt_WarnUnusedPatternBindsOpt_WarnUnusedLocalBindsOpt_WarnUnusedTopBindsOpt_WarnMonomorphismOpt_WarnTypeDefaultsOpt_WarnOverlappingPatternsOpt_WarnNameShadowingOpt_WarnMissingLocalSignaturesOpt_WarnMissingSignaturesOpt_WarnMissingMethodsOpt_WarnMissingImportListOpt_WarnMissingFieldsOpt_WarnEmptyEnumerationsOpt_WarnOverflowedLiterals Opt_WarnIncompletePatternsRecUpdOpt_WarnIncompleteUniPatternsOpt_WarnIncompletePatternsOpt_WarnImplicitPreludeOpt_WarnHiShadowsOpt_WarnRedundantConstraintsOpt_WarnDuplicateExportsOpt_WarnDuplicateConstraints RawPkgQual NoRawPkgQual GHC.Unit.HomehomeModuleInstantiationhomeModuleNameInstantiationmkHomeInstalledModule mkHomeModulenotHomeModuleMaybe notHomeModulenotHomeInstalledModuleMaybenotHomeInstalledModuleisHomeInstalledModule isHomeModuleisHomeUnitInstanceOf notHomeUnitId isHomeUnitId isHomeUnitisHomeUnitInstantiatingisHomeUnitDefiniteisHomeUnitIndefinite homeUnitMaphomeUnitAsUnithomeUnitInstanceOfMaybehomeUnitInstanceOfhomeUnitInstantiations homeUnitId GenHomeUnitDefiniteHomeUnitIndefiniteHomeUnitHomeUnitGHC.Unit.Module mkHoleModule isHoleModuleuninstantiateInstantiatedModuleuninstantiateInstantiatedUnitgetUnitInstantiationsgetModuleInstantiationinstalledModuleEqstableModuleCmpmoduleStableStringmoduleIsDefiniteContainsModule extractModule HasModule getModuleGHC.Unit.Module.EnvplusInstalledModuleEnvmergeInstalledModuleEnvinstalledModuleEnvEltsdelInstalledModuleEnvfilterInstalledModuleEnvextendInstalledModuleEnvlookupInstalledModuleEnvemptyInstalledModuleEnv unitModuleSetunionManyModuleSetsunionModuleSet delModuleSetminusModuleSetintersectModuleSet elemModuleSet moduleSetEltsisEmptyModuleSetemptyModuleSetextendModuleSetListextendModuleSet mkModuleSetisEmptyModuleEnv unitModuleEnvmoduleEnvToList moduleEnvElts moduleEnvKeysemptyModuleEnv mkModuleEnvpartitionModuleEnv mapModuleEnvlookupWithDefaultModuleEnvlookupModuleEnv plusModuleEnv delModuleEnvdelModuleEnvListplusModuleEnv_CextendModuleEnvList_CextendModuleEnvListextendModuleEnvWithextendModuleEnv elemModuleEnvfilterModuleEnv ModuleEnv ModuleSet ModuleNameEnvDModuleNameEnvInstalledModuleEnvaddBootSuffixLocnOutaddBootSuffixLocnaddBootSuffixLocn_maybeaddBootSuffix_mayberemoveBootSuffix addBootSuffixwiredInUnitIdsisInteractiveModulemainUnit mainUnitIdinteractiveUnit thisGhcUnitrtsUnitbaseUnit bignumUnitprimUnitthUnitthUnitIdinteractiveUnitId thisGhcUnitId rtsUnitId baseUnitId bignumUnitId primUnitIdstringToUnitId unitIdStringunitIsDefinite virtualUnitIdtoUnitIdmapInstantiations mapGenUnit stringToUnit unitStringfsToUnitmkInstantiatedUnitHash mkVirtUnitmkInstantiatedUnitunitFreeModuleHoles stableUnitCmp isHoleUnitpprInstantiatedModule moduleUnitIdInstalledModuleHomeUnitModuleInstantiatedModuleIsUnitIdunitFSUnitKeyGenInstantiatedUnitInstantiatedUnit instUnitHoles instUnitInstsinstUnitInstanceOf instUnitFS instUnitKeyGenInstantiationsInstantiations DefUnitIdDefinite unDefinite GenWithIsBootGWIBgwib_mod gwib_isBootModuleNameWithIsBootModuleWithIsBootparseModuleNamemoduleNameColonsmoduleNameSlashesmkModuleNameFS moduleNameFS pprModuleNamestableModuleNameCmp vanillaIdInfo coVarDetailsisCoVarDetails pprIdDetailsIdInfotagSiglfInfo demandInfo cprSigInfo dmdSigInfooccInfoinlinePragInforuleInforealUnfoldingInfo IdDetailsStrictWorkerIdCoVarId TickBoxOpIdFCallIdPrimOpId ClassOpId DataConWrapId DataConWorkIdRecSelId VanillaId sel_tycon sel_naughtyleftmostColumn mkSrcSpanPs psSpanEnd psSpanStartmkPsSpan advancePsLocpsLocatedToLocatedliftLisRealSubspanOfpprLocatedAlways pprLocated cmpBufSpanmapLocpprUserRealSpan pprUserSpanpprUnhelpfulSpanReasonunhelpfulSpanFSsrcSpanToRealSrcSpansrcSpanFileName_mayberealSrcSpanEndrealSrcSpanStart containsSpanisZeroWidthSpan isOneLineSpansrcSpanFirstCharactercombineRealSrcSpanscombineSrcSpans mkRealSrcSpanrealSrcLocSpanmkGeneralSrcSpanisGeneratedSrcSpangeneratedSrcSpaninteractiveSrcSpanwiredInSrcSpan getBufSpan lookupSrcSpan lookupSrcLocsortRealLocated sortLocated advanceBufPos advanceSrcLocmkGeneralSrcLocinteractiveSrcLocgeneratedSrcLoc getBufPos mkRealSrcLocBufPosbufPosBufSpan bufSpanStart bufSpanEndUnhelpfulSpanReasonUnhelpfulOtherUnhelpfulGeneratedUnhelpfulInteractiveUnhelpfulNoLocationInfoUnhelpfulWiredInPsLoc psRealLocpsBufPosPsSpan psRealSpan psBufSpan PsLocated LayoutInfo NoLayoutInfoExplicitBraces VirtualBracesGHC.Types.Unique.Set pprUniqSetunsafeUFMToUniqSet getUniqSet mapUniqSetnonDetStrictFoldUniqSetnonDetKeysUniqSetnonDetEltsUniqSetlookupUniqSet_Directly lookupUniqSetisEmptyUniqSet sizeUniqSet uniqSetAll uniqSetAnypartitionUniqSetfilterUniqSet_Directly filterUniqSetelemUniqSet_DirectlyelementOfUniqSetuniqSetMinusUDFMuniqSetMinusUFMrestrictUniqSetToUFMdisjointUniqSetsintersectUniqSets minusUniqSetunionManyUniqSets unionUniqSetsdelListFromUniqSet_DirectlydelListFromUniqSetdelOneFromUniqSet_DirectlydelOneFromUniqSetaddListToUniqSetaddOneToUniqSet mkUniqSet unitUniqSet emptyUniqSetUniqSetGHC.Types.Unique.FM pluralUFMpprUFMWithKeyspprUFM pprUniqFM equalKeysUFMunsafeCastUFMKeyunsafeIntMapToUFM ufmToIntMapnonDetUFMToListnonDetStrictFoldUFM_DirectlynonDetStrictFoldUFM_DirectlyMnonDetStrictFoldUFM nonDetKeysUFM nonDetEltsUFM seqEltsUFMallUFManyUFMufmToSet_DirectlylookupWithDefaultUFM_DirectlylookupWithDefaultUFMlookupUFM_Directly lookupUFMelemUFM_DirectlyelemUFMsizeUFM partitionUFMfilterUFM_Directly filterUFMmapUFM_Directly mapMaybeUFMmapUFMfoldUFM disjointUFMintersectUFM_C intersectUFM minusUFM_CminusUFMsequenceUFMList plusUFMListplusMaybeUFM_CmergeUFM plusUFM_CD2 plusUFM_CD plusUFM_CplusUFMdelFromUFM_DirectlydelListFromUFM_DirectlydelListFromUFM delFromUFMadjustUFM_Directly adjustUFMaddListToUFM_CalterUFM addToUFM_Acc addToUFM_CaddToUFM_DirectlyaddListToUFM_Directly addListToUFMaddToUFM listToUFM_ClistToIdentityUFMlistToUFM_Directly listToUFMzipToUFMunitDirectlyUFMunitUFM isNullUFMemptyUFMUniqFM NonDetUniqFM getNonDetinitUs_initUstakeUniqFromSupplyuniqsFromSupplyuniqFromSupplylistSplitUniqSupplysplitUniqSupply uniqFromMaskinitUniqSupplymkSplitUniqSupply assertPprM massertPpr assertPprassertPprPanicprettyCallStackDoc callStackDoctryMost pgmErrorDocsorryDocpanicDocpprPanichandleGhcExceptionthrowGhcExceptionIOthrowGhcExceptionshowGhcExceptionUnsafesafeShowException showException hasOrHave thisOrThese itsOrTheirdoOrDoesisOrAresingularpluralspeakNOfspeakNspeakNth intWithCommasquotedListWithNorquotedListWithOr pprQuotedList interpp'SP' interpp'SP interppSP pprWithBars pprWithCommaspprFilePathStringpprFastFilePath pprInfixVar pprPrefixVar pprPrimWord64 pprPrimWord32 pprPrimWord16 pprPrimWord8 pprPrimInt64 pprPrimInt32 pprPrimInt16 pprPrimInt8 pprPrimWord pprPrimInt pprPrimCharprimWord64SuffixprimInt64SuffixprimWord32SuffixprimInt32SuffixprimWord16SuffixprimInt16SuffixprimWord8SuffixprimInt8SuffixprimWordSuffixprimDoubleSuffix primIntSuffixprimFloatSuffixprimCharSuffix pprHsBytes pprHsString pprHsCharkeywordcolouredppUnlessOption ppWhenOptionppUnlessppWhen punctuate hangNotEmptyhangfcatfsepcatsepvcathsephcat$+$$$<+><>nest unicodeSyntaxbullet forAllLitmulArrowrbracelbracerbracklbrackrparenlparenvbardot underscorespaceequalscoloncommasemilambdalarrowttarrowttlarrowtarrowtdarrowlarrowlollipoparrowdcolon blankLinequotescparen angleBrackets doubleQuotesquotebracketsbracesparens doublePrecwordrationaldoublefloatintegerintztextptextftextcharempty docToSDocisEmptypprDebugAndThen showPprUnsafeshowSDocUnsafeshowSDocOneLinerenderWithContextpprCodebufLeftRenderSDoc printSDocLn printSDoc whenPprDebug ifPprDebug getPprDebug userStyle dumpStyleasmStyle codeStyle queryQual qualPackage qualModulequalNameupdSDocContext sdocOptionsdocWithContext getPprStyle pprSetDepth pprDeeperList pprDeeper withPprStyledefaultSDocContextrunSDocsetStyleColoured withErrStyle withUserStyle mkUserStylecmdlineParserStyle mkErrStyledefaultErrStyle mkDumpStyledefaultDumpStyledefaultUserStyle neverQualifyreallyAlwaysQualifyneverQualifyPackagesalwaysQualifyPackagesneverQualifyModulesalwaysQualifyModulesneverQualifyNamesalwaysQualifyNamesreallyAlwaysQualifyNames LabelStyleCStyleAsmStyleDepth DefaultDepth AllTheWayPartWay QueryQualifyqueryQualifyPackagequeryQualifyNamequeryQualifyModuleQueryQualifyNameQueryQualifyModuleQueryQualifyPackage QualifyNameNameNotInScope2NameNotInScope1 NameUnqualNameQual Outputableppr OutputablePpdocPDoc BindingSiteLetBind CasePatBind LambdaBindCaseBindOutputableBndrbndrIsJoin_maybe pprInfixOccpprBndr pprPrefixOccfsLitlengthPSunpackPtrString mkPtrString mkPtrString#hPutFSgetFastStringZEncCountergetFastStringTableisUnderscoreFSnilFS uniqueOfFSunconsFSconsFSheadFSconcatFSappendFS zEncodeFSunpackFSnullFSlengthFSmkFastStringByteList mkFastStringmkFastStringShortByteStringmkFastStringByteStringmkFastStringBytes mkFastString# uniqCompareFSlexicalCompareFS lengthFZSzStringhPutFZSunsafeMkByteStringfastZStringToByteStringfastStringToShortByteStringfastStringToByteStringbytesFS FastZStringfs_zencfs_sbsuniqn_charsNonDetFastStringLexicalFastString PtrStringGHC.Utils.Misc mapMaybe' hashStringcharToCabstractDataTypeabstractConstrmakeRelativeToreslash escapeSpacessplitLongestPrefixwithAtomicRenamefileHashIfExistsmodificationTimeIfExistsgetModificationUTCTimedoesDirNameExistreadHexSignificandExponentPairreadHexRationalreadSignificandExponentPair readRational exactLog2looksLikePackageNamelooksLikeModuleNamestrictZipWith3 strictZipWith strictMapseqList unzipWith fuzzyLookup fuzzyMatch<||><&&> removeSpacescmpList eqMaybeByeqListBythenCmpisEqual capitalisesplitsnocViewonJust lastMaybelast2spanEnddropWhileEndLEdropTail splitAtListdropListtakeList countWhilecountall2foldl2transitiveClosureordNubOnordNubnubSortminWith isSortedBy mergeListsBy whenNonEmpty mapAccumMmapLastM changeLast chunkList expectOnlyonlynotNull isSingleton singletonltLengthleLength compareLength equalLength listLengthCmplengthLessThan lengthAtMost lengthIsNotlengthIs lengthAtLeast lengthExceedsatLength zipAndUnzipzipWithAndUnzip mapAndUnzip3 mapAndUnzipmapSndmapFststretchZipWithpartitionByList filterByLists filterByList zipWith3Lazy zipWithLazyzipLazy zipWith4Equal zipWith3Equal zipWithEqualzipEqual chkAppend partitionWith filterOutsecondMfirst3MfirstMliftSndliftFstuncurry3third3snd3fst3thdOf3sndOf3fstOf3const2nTimes applyWhenSuffix DirectionForwards BackwardsHasDebugCallStack assertPaniccmdLineErrorIO cmdLineErrorpgmErrorsorryUnitIdunitIdFS GenModuleGenUnitHoleUnitRealUnitVirtUnittextSDocPprStylePprCode SDocContextSDCsdocUnitIdForUsersdocPrintTypeAbbreviationssdocImpredicativeTypessdocLinearTypessdocStarIsTypesdocErrorSpanssdocSuppressStgExtssdocSuppressModulePrefixessdocSuppressUniquessdocSuppressVarKindssdocSuppressUnfoldingssdocSuppressCoercionssdocSuppressIdInfosdocSuppressTypeApplicationssdocSuppressTypeSignaturessdocSuppressTickssdocPrintEqualityRelationssdocPrintPotentialInstancessdocPrintExplicitForallssdocPrintExplicitRuntimeRepssdocPrintExplicitCoercionssdocPrintExplicitKindssdocPrintAxiomIncompssdocPrintTypecheckerElaborationsdocPrintCaseAsLetsdocPrintUnicodeSyntax sdocPprDebugsdocHexWordLiteralssdocCanUseUnicodesdocLineLengthsdocDefaultDepthsdocShouldUseColorsdocLastColour sdocStyle sdocColSchemeGHC.Unit.DatabaseGenericUnitInfo unitIsTrusted unitIsExposedunitIsIndefiniteunitHiddenModulesunitExposedModulesunitHaddockHTMLsunitHaddockInterfacesunitIncludeDirs unitIncludes unitCcOptionsunitLinkerOptionsunitExtDepFrameworkDirsunitExtDepFrameworksunitLibraryDynDirsunitLibraryDirsunitExtDepLibsGhcunitExtDepLibsSys unitLibrariesunitImportDirsunitAbiDepends unitDepends unitAbiHashunitComponentNameunitPackageVersionunitPackageName unitPackageIdunitInstantiationsunitIdunitInstanceOfshowOptGHC.SerializeddeserializeWithDataserializeWithDatafromSerialized toSerialized SerializedGHC.Data.FiniteMapfoldRightWithKey foldRight deleteListinsertListWith insertList emptyPluginsPlugininterfaceLoadActionspliceRunActiontypeCheckResultActionrenamedResultActionparsedResultActionpluginRecompile driverPlugin holeFitPlugindefaultingPlugininstallCoreToDostcPluginPluginsloadedPluginDeps staticPlugins loadedPlugins LoadedPluginlpPluginlpModule StaticPluginspPluginTcSolverReportMsgTcSolverReportInfoFixitylookupFixityRn'GHC.Tc.Solver.InertSet InertCansInertSet GHC.Data.BagBagLanguage.Haskell.Syntax.BindsLHsBindsGhcPsLSig GHC.ClassesEqOrdGHC.ReadReadGHC.ShowShow SkolemInfoStandAloneDerivOriginDerivClauseOriginFalse DerivStrategy rnImportDeclLanguage.Haskell.Syntax.Type LHsQTyVarsmergeIfaceDecl HsTyVarBndrHsForAllTelescopeTcTyModekindGeneralizeSome ViaStrategy HscSourceGHC.Tc.Types.Evidence HsWrapperIOHsMatchContextPmAltCon addPhiCts leftToRight topToBottomLanguage.Haskell.Syntax.LitOverLitMatch MatchGroupLanguage.Haskell.Syntax.PatPatGRHSsGRHS andThenCheckrootNGHC.Cmm.CLabelCLabelStringHappyStkMaybeGHC.Unit.Module.ModDetails ModDetailsPipelineOutput Temporary PersistentInstantiationNodeHsModulehsmodHaddockModHeaderhsmodDeprecMessage hsmodDecls hsmodImports hsmodExports hsmodNamehsmodAnn hsmodLayout AnnsModuleam_mainam_decls hpm_module hpm_src_files lPatImplicitshsValBindsImplicitslStmtsImplicitshsDataFamInstBindersgetPatSynBindshsPatSynSelectorshsForeignDeclsBindershsLTyClDeclBindershsTyClForeignBindershsGroupBinderscollectPatsBinderscollectPatBinderscollectStmtBinderscollectLStmtBinderscollectStmtsBinderscollectLStmtsBinderscollectMethodBinderscollectHsBindListBinderscollectHsBindsBinderscollectHsBindBinderscollectHsValBinderscollectHsIdBinderscollectLocalBindersisBangedHsBindisUnliftedHsBindmkMatchmkPrefixFunRhsmkSimpleGeneratedFunBindspanHsLocaLBindsisInfixFunBind mkPatSynBind mkVarBind mkHsVarBind mkTopFunBind mkFunBind mkHsWrapPatCo mkHsWrapPat mkLHsCmdWrap mkHsCmdWrap mkLHsWrapCo mkHsWrapCoR mkHsWrapComkHsWrap mkLHsWrap mkClassOpSigs mkHsSigEnvhsTypeToHsSigWcTypehsTypeToHsSigTypechunkify mkChunkifiedmkBigLHsPatTupmkBigLHsVarPatTup mkBigLHsTupmkBigLHsVarTup missingTupArg nlTuplePat mkLHsVarTuplemkLHsTupleExpr nlHsAppKindTy nlHsTyConApp nlHsParTy nlHsFunTy nlHsTyVar nlHsAppTynlListnlHsCasenlHsIfnlHsParnlHsLam nlHsOpAppnlHsDo nlWildPatName nlWildPat nlWildConPatnlNullaryConPat nlConPatNamenlConPat nlInfixConPatnlConVarPatName nlConVarPat nlHsVarAppsnlHsAppsnlHsSyntaxAppsnlHsAppnlLitPatnlVarPat nlHsIntLitnlHsLit nlHsDataConnl_HsVarnlHsVar mkConLikeTcmkHsCharPrimLitmkHsStringPrimLit mkHsStringmkHsQuasiQuote mkTypedSplicemkUntypedSplice mkHsOpApp mkLetStmt mkRecStmtemptyRecStmtIdemptyRecStmtName emptyRecStmt unitRecStmtTc mkTcBindStmt mkRnBindStmt mkPsBindStmt mkBodyStmt mkLastStmtmkGroupByUsingStmtmkGroupUsingStmtmkTransformByStmtmkTransformStmtemptyTransStmt mkNPlusKPatmkNPat mkHsCmdIfmkHsIf mkHsCompAnnsmkHsComp mkHsDoAnnsmkHsDo mkHsIsStringmkHsFractional mkHsIntegralnlParPatmkParPatmkLHsPar nlHsTyApps nlHsTyAppmkHsLamsmkHsLam mkHsAppTypes mkHsAppType mkHsAppsWithmkHsApps mkHsAppWith mkLocatedList mkMatchGroup unguardedRHSunguardedGRHSs mkSimpleMatchmkHsPar CollectFlagCollNoDictBindersCollWithDictBinders CollectPass collectXXPatcollectXXHsBindsLR GHC.Hs.Expr pprStmtInCtxtpprMatchInCtxtmatchDoContextErrStringmatchArrowContextErrStringmatchContextErrString pp_dotdotppr_with_pending_tc_splices thTyBrackets thBrackets ppr_splice ppr_quasippr_splice_declpprPendingSplicepprQualspprComp ppr_do_stmtsppr_module_name_prefix pprArrowExprpprDopprBy pprTransStmtpprTransformStmtpprArg pprBindStmtpprStmtpp_rhspprGRHSpprGRHSspprMatch pprMatches hsLMatchPatsmatchGroupArityisSingletonMatchGroupisEmptyMatchGroup pprCmdArgppr_cmdppr_lcmd isQuietHsCmdpprCmdpprLCmdisAtomicHsExprstripParensHsExprstripParensLHsExprparenthesizeHsExprgHsParhsExprNeedsParens pprParendExprpprParendLExprpprDebugParendExprppr_appsppr_infix_expr_tcppr_infix_expr_rnppr_infix_exprppr_expr ppr_lexprpprBinds isQuietHsExpr tupArgPresentmkRnSyntaxExpr mkSyntaxExpr noSyntaxExprnoExpr PostTcExpr PostTcTable SyntaxExprGhc SyntaxExprRnNoSyntaxExprRn SyntaxExprTcNoSyntaxExprTc syn_res_wrapsyn_expr syn_arg_wraps RecordUpdTc rupd_wrap rupd_out_tys rupd_cons rupd_in_tysHsWrap HsBracketTcbrack_pending_splicesbrack_quote_wrapperbrack_renamed_quotebrack_ty EpAnnHsCasehsCaseAnnsRest hsCaseAnnCase hsCaseAnnOfEpAnnUnboundVarhsUnboundBackquotes hsUnboundHoleAnnExplicitSumaesClose aesBarsAfteraesOpen aesBarsBefore AnnFieldLabelafDot AnnProjectionapOpenapCloseAnnsIf aiElseSemi aiThenSemiaiElseaiIfaiThen XXExprGhcTc HsBinTickHsTick ConLikeTcWrapExpr ExpansionExpr HsExpansion HsExpandedCmdTopTcGrhsAnnga_vbarga_sep RecStmtTc recS_ret_ty recS_rec_rets recS_bind_tyrecS_later_rets XBindStmtRn xbsrn_bindOp xbsrn_failOp XBindStmtTc xbstc_failOpxbstc_boundResultMult xbstc_bindOpxbstc_boundResultType HsSplicedT DelayedSpliceSplicePointNamePendingRnSplicePendingTcSplice GHC.Hs.DeclsroleAnnotDeclNameflattenRuleDeclsmapDerivStrategyfoldDerivStrategyinstDeclDataFamInstspprHsFamInstLHSpprDataFamInstFlavourpprTyFamInstDeclhsConDeclThetagetRecConArgs_maybe getConNamesstandaloneKindSigNameresultVariableNamefamResultKindSignaturefamilyDeclNamefamilyDeclLNamepprTyClDeclFlavour hsDeclHasCusktcdName tyClDeclLNametyFamInstDeclLNametyFamInstDeclName appendGroupshsGroupTopLevelFixitySigs emptyRnGroup emptyRdrGrouppartitionBindsAndSigsXViaStrategyPs HsRuleAnnra_rest ra_tyanns ra_tmanns GHC.Hs.PatcollectEvVarsPatcollectEvVarsPatsparenthesizePatgParPatpatNeedsParens isSimplePatisIrrefutableHsPatlooksLazyPatBind isBangedLPat mkCharLitPatmkNilPatmkPrefixConPat pprConArgs pprParendLPathsRecUpdFieldOcchsRecUpdFieldIdhsRecUpdFieldRdr hsRecFieldId EpAnnSumPatsumPatVbarsAfter sumPatParenssumPatVbarsBefore XXPatGhcTcCoPat ExpansionPat co_pat_ty co_cpt_wrap co_pat_innerHsPatExpansion HsPatExpandedConPatTccpt_wrap cpt_binds cpt_dicts cpt_arg_tyscpt_tvs GHC.Hs.Binds pprMinimalSigpprTcSpecPragspprSpec pprVarSigpragSrcBrackets pragBracketsppr_sigisDefaultMethod hasSpecPrags noSpecPragsisEmptyIPBindsTcisEmptyIPBindsPRpprTicks ppr_monobindplusHsValBindsisEmptyLHsBinds emptyLHsBindsemptyValBindsOutemptyValBindsInisEmptyValBindseqEmptyLocalBindsemptyLocalBinds pprDeclListpprLHsBindsForUser pprLHsBinds NHsValBindsLR NValBindsAbsBindsabs_sig abs_binds abs_ev_binds abs_exportsabs_tvs abs_ev_varsABExportABE abe_pragsabe_wrapabe_polyabe_monoAnnSigasDcolonasRest TcSpecPragsIsDefaultMethod SpecPrags LTcSpecPrag TcSpecPragSpecPrag GHC.Hs.Lit pmPprHsLit pp_st_suffix convertLit overLitType pprXOverLit OverLitRn$sel:ol_from_fun:OverLitRn$sel:ol_rebindable:OverLitRn OverLitTc$sel:ol_witness:OverLitTc$sel:ol_rebindable:OverLitTc$sel:ol_type:OverLitTcparenthesizeHsContextparenthesizeHsTypehsTypeNeedsParens pprHsTypepprConDeclFields pprLHsContext pprHsForAllpprHsOuterSigTyVarBndrspprHsOuterFamEqnTyVarBndrspprAnonWildCardambiguousFieldOccunambiguousFieldOccselectorAmbiguousFieldOccrdrNameAmbiguousFieldOccmkAmbiguousFieldOcc mkFieldOccgetLHsInstDeclClass_maybegetLHsInstDeclHeadsplitLHsInstDeclTysplitLHsQualTysplitLHsForAllTyInvis_KPsplitLHsForAllTyInvissplitLHsGadtTysplitLHsSigmaTyInvissplitLHsPatSynTylhsTypeArgSrcSpanhsTyGetAppHead_maybesplitHsFunType mkHsAppKindTy mkHsAppTysmkHsOpTymkAnonWildCardTy ignoreParens hsTyKindSighsLTyVarLocNameshsLTyVarLocNamehsAllLTyVarNameshsExplicitLTyVarNames hsLTyVarNames hsLTyVarName hsTyVarName hsScopedTvs hsWcScopedTvs pprHsArrow arrowToHsTypeisUnrestrictedhsUnrestrictedhsLinearhsTvbAllKindedsetHsTyVarBndrFlaghsTyVarBndrFlagmkEmptyWildCardBndrsmkHsPatSigTypemkHsWildCardBndrsmkHsExplicitSigTypemkHsImplicitSigTypemkHsOuterExplicitmkHsOuterImplicithsOuterExplicitBndrshsOuterTyVarNames dropWildCards hsSigWcType emptyLHsQTvsmkHsQTvsmkHsForAllInvisTelemkHsForAllVisTelefromMaybeContextgetBangStrictness getBangType EpAnnForallTyOutputableBndrFlagpprLExpr pprSplice pprSpliceDecl pprPatBind pprFunBindprependQualifiedpprHsDoFlavourpprAHsDoFlavourpprStmtContextpprAStmtContextpprArrowMatchContextNounpprMatchContextNounpprMatchContextmatchSeparatorisMonadDoCompContextisMonadCompContextisMonadDoStmtContextisMonadStmtContextisDoComprehensionContextisComprehensionContextqualifiedDoModuleName_maybe isPatSynCtxt isTypedSplice isInfixMatch pprHsArrTypepprExternalSrcLocpprFieldLabelStringsLFieldLabelStringsFieldLabelStringsRecProj LHsRecProj RecUpdProj LHsRecUpdProjCmdSyntaxTable DotFieldOcc XDotFieldOccdfoExtdfoLabelHsPragE HsPragSCCXHsPragE LHsTupArgHsTupArgXTupArgPresentMissingLHsCmdHsCmdXCmdHsCmdDoHsCmdLetHsCmdIf HsCmdLamCase HsCmdCaseHsCmdParHsCmdLamHsCmdApp HsCmdArrApp HsCmdArrForm HsArrAppTypeHsHigherOrderAppHsFirstOrderApp LHsCmdTopHsCmdTopXCmdTop HsRecordBinds MatchGroupTc mg_arg_tys mg_res_tyLMatchXMatchm_grhssm_patsm_extm_ctxtLGRHSXGRHSLStmtLStmtLRStmtCmdLStmtCmdStmt ExprLStmtExprStmt GuardLStmt GuardStmt GhciLStmtGhciStmtStmtLRXStmtLRRecStmt TransStmtParStmtLetStmtBodyStmtApplicativeStmtLastStmtBindStmt recS_mfix_fn recS_ret_fn recS_bind_fn recS_rec_idsrecS_later_ids recS_stmtsrecS_exttrS_fmaptrS_bindtrS_rettrS_by trS_using trS_bndrs trS_stmtstrS_exttrS_form TransFormThenForm GroupForm ParStmtBlock XParStmtBlock FailOperatorApplicativeArgXApplicativeArgApplicativeArgOneApplicativeArgMany stmt_context bv_pattern final_expr app_stmtsxarg_app_arg_many is_body_stmtarg_exprxarg_app_arg_oneapp_arg_patternSpliceDecoration DollarSplice BareSpliceThModFinalizersHsSplicedThing HsSplicedPat HsSplicedExpr HsSplicedTyUntypedSpliceFlavourUntypedDeclSpliceUntypedTypeSpliceUntypedExpSpliceUntypedPatSpliceHsQuoteXQuoteVarBrTypBrDecBrGDecBrLExpBrPatBr ArithSeqInfo FromThenToFromToFromFromThen ThPatQuote ThPatSpliceStmtCtxtRecUpd PatBindGuards PatBindRhsArrowMatchCtxtIfAlt LambdaExprPatSynFunRhs mc_strictnessmc_fun mc_fixity HsStmtContext ArrowExpr TransStmtCtxt ParStmtCtxtHsDoStmtPatGuardHsArrowMatchContext KappaExprProcExpr ArrowCaseAlt HsDoFlavour MonadCompListComp GhciStmtCtxtDoExprMDoExprannProvenanceName_maybe docDeclDocpprFullRuleNamecollectRuleBndrSigTysderivStrategyNamenewOrDataToFlavour pprFlavourtyClGroupKindSigstyClGroupRoleDeclstyClGroupInstDeclstyClGroupTyClDeclscountTyClDeclstyClDeclTyVarsisDataFamilyDeclisClosedTypeFamilyInfoisOpenTypeFamilyInfoisTypeFamilyDecl isFamilyDecl isClassDecl isSynDecl isDataDeclhsGroupInstDeclsLHsDeclHsDeclXHsDecl RoleAnnotDDocDSpliceDRuleDAnnDWarningDForDDefDKindSigDSigDValDDerivDTyClDInstDXHsGrouphs_docs hs_ruledshs_annds hs_warndshs_fordshs_defdshs_fixds hs_derivds hs_tyclds hs_splcdshs_exths_valds LSpliceDecl SpliceDecl XSpliceDecl LTyClDeclTyClDecl XTyClDecl ClassDeclDataDeclFamDeclSynDecltcdDocs tcdATDefstcdATstcdMethstcdSigstcdFDstcdCtxttcdCExt tcdDataDefntcdDExttcdRhs tcdFixity tcdTyVarstcdLNametcdSExttcdFExttcdFamFunDepXFunDep LHsFunDep DataDeclRn tcdDataCusktcdFVs TyClGroup XTyClGroup group_instds group_kisigs group_roles group_ext group_tycldsLFamilyResultSigFamilyResultSigXFamilyResultSigTyVarSigNoSigKindSig LFamilyDecl FamilyDecl XFamilyDeclfdInjectivityAnn fdResultSigfdFixityfdTyVarsfdLName fdTopLevelfdExtfdInfoLInjectivityAnnInjectivityAnnXInjectivityAnn FamilyInfoClosedTypeFamily DataFamilyOpenTypeFamily HsDataDefn XHsDataDefn dd_derivsdd_cons dd_kindSigdd_cTypedd_ctxtdd_extdd_ND HsDerivingLHsDerivingClauseHsDerivingClauseXHsDerivingClausederiv_clause_tysderiv_clause_extderiv_clause_strategyLDerivClauseTysDerivClauseTysXDerivClauseTys DctSingleDctMultiLStandaloneKindSigStandaloneKindSigXStandaloneKindSig NewOrDataDataTypeNewTypeLConDeclConDeclXConDecl ConDeclGADT ConDeclH98con_args con_ex_tvs con_forallcon_namecon_extcon_doc con_res_ty con_g_args con_mb_cxt con_bndrs con_g_ext con_namesHsConDeclH98DetailsHsConDeclGADTDetails PrefixConGADT RecConGADT LTyFamInstEqnHsTyPats TyFamInstEqnTyFamDefltDeclLTyFamDefltDeclLTyFamInstDecl TyFamInstDeclXTyFamInstDecltfid_xtntfid_eqnLDataFamInstDeclDataFamInstDecldfid_eqnFamEqnXFamEqnfeqn_rhs feqn_fixity feqn_pats feqn_bndrsfeqn_ext feqn_tycon LClsInstDecl ClsInstDecl XClsInstDeclcid_overlap_modecid_datafam_instscid_tyfam_instscid_sigs cid_bindscid_ext cid_poly_ty LInstDeclInstDecl XInstDecl TyFamInstDClsInstD DataFamInstD tfid_insttfid_ext dfid_instdfid_ext cid_d_extcid_inst LDerivDecl DerivDecl XDerivDeclderiv_overlap_modederiv_strategy deriv_ext deriv_typeLDerivStrategyNewtypeStrategy StockStrategyAnyclassStrategy LDefaultDecl DefaultDecl XDefaultDecl LForeignDecl ForeignDecl XForeignDecl ForeignExport ForeignImportfd_fefd_e_extfd_fi fd_sig_tyfd_i_extfd_nameCImport CImportSpecCWrapper CFunctionCExport LRuleDecls RuleDeclsHsRules XRuleDecls rds_rulesrds_extrds_src LRuleDeclRuleDeclHsRule XRuleDeclrd_rhsrd_lhsrd_tmvsrd_tyvsrd_actrd_extrd_nameHsRuleRn LRuleBndrRuleBndr XRuleBndr RuleBndrSigLDocDeclDocDeclDocGroupDocCommentNamedDocCommentNextDocCommentPrev LWarnDecls WarnDeclsWarnings XWarnDecls wd_warningswd_extwd_src LWarnDeclWarnDeclWarning XWarnDeclLAnnDeclAnnDecl HsAnnotationXAnnDecl AnnProvenanceModuleAnnProvenanceValueAnnProvenanceTypeAnnProvenanceLRoleAnnotDecl RoleAnnotDeclXRoleAnnotDeclextractSpecPragNamehsSigDocisCompleteMatchSig isSCCFunSig isMinimalLSig isInlineLSig isPragLSigisSpecInstLSig isSpecLSig isTypeLSig isFixityLSig HsLocalBinds LHsLocalBindsHsLocalBindsLRXHsLocalBindsLREmptyLocalBinds HsIPBinds HsValBindsLHsLocalBindsLR HsValBindsLRValBinds XValBindsLRLHsBindHsBind LHsBindsLR LHsBindLRHsBindLR XHsBindsLRVarBindPatBind PatSynBindFunBindvar_rhsvar_idvar_ext pat_tickspat_rhspat_lhspat_extfun_tick fun_matchesfun_extfun_id XPatSynBindPSBpsb_dirpsb_defpsb_argspsb_extpsb_id XHsIPBindsIPBindsLIPBindIPBindXIPBindSigXSigCompleteMatchSig SCCFunSig MinimalSig SpecInstSigSpecSig InlineSigFixSigIdSig ClassOpSigTypeSig PatSynSig LFixitySig FixitySig XFixitySigHsPatSynDetailsRecordPatSynFieldrecordPatSynFieldrecordPatSynPatVar HsPatSynDirExplicitBidirectionalUnidirectionalImplicitBidirectionalpprLPat hsRecFieldSelhsRecFieldsArgs hsRecFields hsConPatArgsConLikePHsConPatDetails HsRecFieldsrec_flds rec_dotdot LHsFieldBind LHsRecFieldLHsRecUpdField HsRecField HsRecUpdField HsFieldBindhfbPunhfbRHShfbAnnhfbLHS pprHsArgsAppnumVisibleArgs noTypeArgs hsScaledThinghsMultisHsKindedTyVar hsIPNameFSmapHsOuterImplicit hsPatSigType hsQTvExplicit LBangTypeBangType LHsContext HsContextLHsTypeHsKindLHsKindXHsForAllTelescope HsForAllVis HsForAllInvishsf_invis_bndrs hsf_xinvishsf_xvis hsf_vis_bndrs LHsTyVarBndrHsQTvs XLHsQTyVarshsq_ext hsq_explicitHsOuterTyVarBndrsXHsOuterTyVarBndrsHsOuterImplicitHsOuterExplicit hso_bndrs hso_ximplicit hso_xexplicitHsOuterSigTyVarBndrsHsOuterFamEqnTyVarBndrsHsWildCardBndrsHsWCXHsWildCardBndrshswc_ext hswc_body HsPatSigTypeHsPS XHsPatSigTypehsps_ext hsps_bodyHsPSRn hsps_nwcs hsps_imp_tvs LHsSigType LHsWcType LHsSigWcType HsSigTypeHsSig XHsSigTypesig_bodysig_ext sig_bndrsHsIPName XTyVarBndr UserTyVar KindedTyVarHsTypeXHsType HsWildCardTyHsExplicitTupleTyHsExplicitListTyHsRecTyHsBangTyHsDocTy HsSpliceTy HsKindSigHsStarTy HsIParamTyHsParTyHsOpTyHsSumTy HsTupleTyHsListTyHsFunTy HsAppKindTyHsAppTyHsTyVarHsQualTyHsTyLit HsForAllTyhst_ctxt hst_xqualhst_body hst_xforallhst_teleHsCoreTyHsCharTyHsNumTyHsStrTyHsArrowHsExplicitMultHsUnrestrictedArrow HsLinearArrowHsLinearArrowTokensHsPct1HsLollyHsScaled HsTupleSortHsUnboxedTupleHsBoxedOrConstraintTuple LConDeclField ConDeclField XConDeclField cd_fld_doc cd_fld_type cd_fld_ext cd_fld_names HsConDetailsInfixCon PrefixConRecConHsArgHsArgParHsValArg HsTypeArg LHsTypeArg LFieldOccFieldOcc XFieldOccfoExtfoLabelLAmbiguousFieldOccAmbiguousFieldOccXAmbiguousFieldOcc Unambiguous AmbiguousXPatSigPat NPlusKPatNPatLitPat SplicePatViewPatConPatSumPatTuplePatListPatBangPatParPatAsPatLazyPatWildPatVarPatpat_args pat_con_extpat_conLPathsOverLitNeedsParenshsLitNeedsParensnegateOverLitValHsLitXLit HsDoublePrim HsFloatPrimHsRat HsInteger HsWord64Prim HsInt64Prim HsWordPrim HsIntPrimHsInt HsStringPrimHsStringHsChar HsCharPrim HsOverLitXOverLitol_extol_val OverLitVal HsIsString HsIntegral HsFractional GHC.Hs.ImpExp pprImpExpreplaceLWrappedNamereplaceWrappedNameieLWrappedNamelieWrappedName ieWrappedNameieWrappedLNameieNamesieNamesimpleImportDeclisImportDeclQualifiedimportDeclQualifiedStyle LImportDeclImportDeclQualifiedStyle NotQualified QualifiedPre QualifiedPost ImportDecl XImportDecl ideclHidingideclAs ideclImplicitideclQualified ideclSafe ideclSource ideclPkgQual ideclNameideclExtideclSourceSrcImportDeclPkgQualEpAnnImportDeclimportDeclAnnAsimportDeclAnnPackageimportDeclAnnQualifiedimportDeclAnnSafeimportDeclAnnImportimportDeclAnnPragma IEWrappedNameIEName IEPatternLIEWrappedNameLIEIEXIE IEDocNamedIEDocIEGroupIEModuleContents IEThingWith IEThingAllIEVar IEThingAbs IEWildcard NoIEWildcard GHC.Hs.Doc emptyDocs pprHsDocDebugpprMaybeWithDoc pprWithDochsDocIdsHsDocWithHsDocIdentifiers hsDocStringhsDocIdentifiersLHsDocDocStructureItem DsiModExport DsiExportsDsiNamedChunkRefDsiSectionHeading DsiDocChunk DocStructureDocsdocs_extensions docs_languagedocs_haddock_optsdocs_named_chunksdocs_structure docs_args docs_mod_hdr docs_declsExtractedTHDocsethd_inst_docs ethd_arg_docsethd_mod_headerethd_decl_docs noHsUniToknoHsTokpprIfTcpprIfRnpprIfPs IsSrcSpanAnnGhcPassGhcRnPass TypecheckedParsedRenamedIsPassghcPassIdGhcP NoGhcTcPassOutputableBndrIdXExprHsStaticHsProc HsSpliceEHsUntypedBracketHsTypedBracketArithSeq ExprWithTySig HsProjection HsGetField RecordUpd RecordCon ExplicitListHsDoHsLet HsMultiIfHsIfHsCase ExplicitSum ExplicitTupleSectionRSectionLHsParNegAppOpApp HsAppTypeHsApp HsLamCaseHsLamHsIPVar HsOverLabelHsRecSel HsUnboundVarHsVar proj_fldsproj_extgf_fieldgf_exprgf_ext rupd_flds rupd_exprrupd_ext rcon_fldsrcon_extrcon_conHsSpliceXSplice HsSpliced HsQuasiQuote HsTypedSpliceHsUntypedSpliceMG XMatchGroup mg_originmg_extmg_altsXGRHSsgrhssLocalBindsgrhssExt grhssGRHSs SyntaxExpr!Language.Haskell.Syntax.ExtensiondataConCantHappen noExtField NoExtFieldDataConCantHappenXRecAnnoUnXRecunXRecMapXRecmapXRecWrapXRecwrapXRecIdPLIdP XHsValBindsXEmptyLocalBindsXXHsLocalBindsLR XValBinds XXValBindsLRXFunBindXPatBindXVarBind XXHsBindsLRXPSB XXPatSynBindXIPBinds XXHsIPBindsXCIPBindXXIPBindXTypeSig XPatSynSig XClassOpSigXIdSigXFixSig XInlineSigXSpecSig XSpecInstSig XMinimalSig XSCCFunSigXCompleteMatchSigXXSig XXFixitySigXXStandaloneKindSigXTyClDXInstDXDerivDXValDXSigD XKindSigDXDefDXForD XWarningDXAnnDXRuleDXSpliceDXDocD XRoleAnnotDXXHsDecl XCHsGroup XXHsGroup XXSpliceDeclXFamDeclXSynDecl XDataDecl XClassDecl XXTyClDeclXCFunDepXXFunDep XCTyClGroup XXTyClGroupXNoSig XCKindSig XTyVarSigXXFamilyResultSig XCFamilyDecl XXFamilyDecl XCHsDataDefn XXHsDataDefnXCHsDerivingClauseXXHsDerivingClause XDctSingle XDctMultiXXDerivClauseTys XConDeclGADT XConDeclH98 XXConDeclXCFamEqnXXFamEqnXCTyFamInstDeclXXTyFamInstDecl XCClsInstDecl XXClsInstDecl XClsInstD XDataFamInstD XTyFamInstD XXInstDecl XCDerivDecl XXDerivDeclXStockStrategyXAnyClassStrategyXNewtypeStrategy XViaStrategy XCDefaultDecl XXDefaultDeclXForeignImportXForeignExport XXForeignDecl XCRuleDecls XXRuleDeclsXHsRule XXRuleDecl XCRuleBndr XRuleBndrSig XXRuleBndr XWarnings XXWarnDeclsXWarning XXWarnDecl XHsAnnotation XXAnnDeclXCRoleAnnotDeclXXRoleAnnotDeclXCInjectivityAnnXXInjectivityAnnXVar XUnboundVarXRecSel XOverLabelXIPVar XOverLitEXLitEXLamXLamCaseXApp XAppTypeEXOpAppXNegAppXPar XSectionL XSectionRXExplicitTuple XExplicitSumXCaseXIfXMultiIfXLetXDo XExplicitList XRecordCon XRecordUpd XGetField XProjectionXExprWithTySig XArithSeq XTypedBracketXUntypedBracketXSpliceEXProcXStaticXTickXBinTickXPragEXXExpr XCDotFieldOcc XXDotFieldOccXSCCXXPragE XUnambiguous XAmbiguousXXAmbiguousFieldOccXPresentXMissingXXTupArg XTypedSpliceXUntypedSplice XQuasiQuoteXSplicedXXSpliceXExpBrXPatBrXDecBrLXDecBrGXTypBrXVarBrXXQuoteXXCmdTopXMG XXMatchGroupXCMatchXXMatchXCGRHSsXXGRHSsXCGRHSXXGRHS XLastStmt XBindStmtXApplicativeStmt XBodyStmtXLetStmtXParStmt XTransStmtXRecStmtXXStmtLR XCmdArrApp XCmdArrFormXCmdAppXCmdLamXCmdParXCmdCase XCmdLamCaseXCmdIfXCmdLetXCmdDoXCmdWrapXXCmdXXParStmtBlockXApplicativeArgOneXApplicativeArgManyXXApplicativeArgXHsChar XHsCharPrim XHsString XHsStringPrimXHsInt XHsIntPrim XHsWordPrim XHsInt64Prim XHsWord64Prim XHsIntegerXHsRat XHsFloatPrim XHsDoublePrimXXLit XXOverLitXWildPatXVarPatXLazyPatXAsPatXParPatXBangPatXListPat XTuplePatXSumPatXConPatXViewPat XSplicePatXLitPatXNPat XNPlusKPatXSigPatXCoPatXXPat XHsFieldBindXHsQTvs XXLHsQTyVarsXHsOuterImplicitXHsOuterExplicitXXHsOuterTyVarBndrsXHsSig XXHsSigTypeXHsWCXXHsWildCardBndrsXHsPSXXHsPatSigType XForAllTyXQualTyXTyVarXAppTy XAppKindTyXFunTyXListTyXTupleTyXSumTyXOpTyXParTy XIParamTyXStarTyXKindSig XSpliceTyXDocTyXBangTyXRecTyXExplicitListTyXExplicitTupleTyXTyLit XWildCardTyXXType XHsForAllVisXHsForAllInvisXXHsForAllTelescope XUserTyVar XKindedTyVar XXTyVarBndrXXConDeclField XCFieldOcc XXFieldOcc XCImportDecl XXImportDeclXIEVar XIEThingAbs XIEThingAll XIEThingWithXIEModuleContentsXIEGroupXIEDoc XIEDocNamedXXIENoGhcTcLHsTokenHsTokenHsTok LHsUniToken HsUniToken HsNormalTok HsUnicodeTokremoveCommentsA commentsOnlyA transferAnnsAsetCommentsEpAnnaddCommentsToEpAnnsetCommentsSrcAnnaddCommentsToSrcAnncommentplaceholderRealSpan noCommentssetPriorCommentssetFollowingCommentsgetFollowingComments addCLocAAaddCLocAcombineSrcSpansA combineLocsAmapLocA sortLocatedA epAnnCommentsannParen2AddEpAnn epAnnAnns epAnnAnnsLwidenLocatedAn widenAnchorR widenAnchor widenSpanaddAnnsAaddAnnsnoAnn noSrcSpanA noAnnSrcSpannoLocAgetLocA getLocAnnreAnnLreAnnCreAnnextraToAnnListla2r realSrcSpanreLocNreLocCreLocLreLocAreLocna2lal2lla2lala2nan2ll2naddTrailingCommaToNaddTrailingAnnToAaddTrailingAnnToLtrailingAnnToAddEpAnn parenTypeKws emptyCommentsrealSpanAsAnchor spanAsAnchorepaLocationFromSrcAnnepaLocationRealSrcSpan getDeltaLinedeltaPos unicodeAnnIsUnicodeSyntax UnicodeSyntax NormalSyntaxHasENoE EpaCommentTok EpaEofCommentEpaBlockCommentEpaLineComment EpaDocComment EpaDocOptionsAddEpAnn EpaLocationEpaSpanEpaDelta TokenLocation NoTokenLocTokenLocDeltaPosSameLine DifferentLine deltaColumn deltaLineEpAnn EpAnnNotUsedcommentsentryannsAnchoranchor anchor_opAnchorOperationUnchangedAnchor MovedAnchor EpAnnComments EpaCommentsEpaCommentsBalanced priorCommentsfollowingComments LEpaComment SrcSpanAnn' SrcSpanAnnannlocASrcAnnLocatedALocatedNLocatedLLocatedPLocatedC SrcSpanAnnA SrcSpanAnnN SrcSpanAnnL SrcSpanAnnP SrcSpanAnnC LocatedAn TrailingAnn AddVbarAnn AddSemiAnn AddCommaAnn AnnListItem lann_trailingAnnList al_trailingal_restal_close al_anchoral_openAnnParenap_close ap_adornmentap_open ParenTypeAnnParensSquare AnnParens AnnParensHash AnnContextac_close ac_darrowac_openNameAnnNameAnnTrailing NameAnnQuote NameAnnRArrow NameAnnOnly NameAnnBars NameAnnCommas nann_quoted nann_quote nann_bars nann_commas nann_trailing nann_close nann_namenann_adornment nann_open NameAdornment NameSquareNameBackquotes NameParensNameParensHash AnnPragmaapr_restapr_open apr_close AnnSortKey NoAnnSortKeyEpAnnCONoEpAnnsGHC.Hs.DocStringrenderHsDocStringsrenderHsDocStringexactPrintHsDocStringpprHsDocStringspprHsDocStringdocStringChunksisEmptyDocStringmkGeneratedHsDocString unpackHDSC mkHsDocStringChunkUtf8ByteStringmkHsDocStringChunkpprWithDocString LHsDocString HsDocStringGeneratedDocStringMultiLineDocStringNestedDocStringHsDocStringDecoratorHsDocStringGroupHsDocStringNamedHsDocStringNextHsDocStringPreviousLHsDocStringChunkHsDocStringChunk GHCi.MessageStartTHRunTHCode