h&вj      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[ \ ] ^_ ` a bcdefghijklmnopqrstuvwx yz{|}~                                                                                                                    !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!""""""""""""""""""""""""""""""""""""""""""#$$$$$%%%%%%%%%%&&&&&&&&&&&&&&&&&&&&&&&&&'()))))))))*+++++,,,,-----------./////////////00001111111111222222333333333333333333                                        4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 5 5 5 5 5 6 6 6 6 6 6 6 6 6 6 6 6 6 6 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 9 9 9 9 9 9 9 9 9 9 : : : : : : ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < = = = = = = = = = = = = = = = = = = = = = = = = = = = 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000>>>>??????????????@@@@@@@AAAAAAAAAAAAAAABBBBBBBBBBBBCCCCCCCCCCCDEEEEEEEFFFFFFFFFFFFFFFFFFFFFFFFFFGGGGGGGGGGGGGGGGGGGGGGHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKLLLLLLLLLLLLLLLLMMMMMMMMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOO::OOOOOO:OOO:OOOO:PPPPPPPPQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQRRRRRRRRSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSTTTTTTTTTT*****************11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111UUUUUUUUUUUUUVVVVWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWXXXXXXXXXXXXXXYYYYYYYYYYYYYYYYYYYYYYYYYYZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ[[[[[[[[[[[[[[[\\\\\\\\\\\\\\\\\]]]]]]]]]^^^^^^^^^^^^__________`aaaaaabbbbbbbbbbbbbbccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccddddddddddddddddddddddddddeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeaaaaaaaaaaaaaaaaaaaaaaaaaaaaffffffgggggggggggggggghhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiijjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjj                           kkkkkkkkkkkkkkllllllllmmmmmmmmmmmmmmmmnnnnnnnnnnnnnnnnnnnnnnnnnnnnnoooooooooooooppqqqqqqqqqqqqqqqqqqqqqqqq                       r 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 u u u u u u u u!v!v!v!w!x!x!y!y!w!y!y!z!w!w!w!w!x!w!y!w!w!w!w!w!w!w!w!w!w!w!w!w!w!w!w!{!f!{!{!f!|!|!|!|!|!|!|!|!|!|!|!|!|!|!|!|!|!}!}!}!}!}!}!}!}!}!f!}!}!}!}!}!}!}!}!}!}!}!}!}!}!}!}!}!}!}!}!w!}!}!}!}!}!}!}!}!}!}!}!}!}!}!}!}!}!}!}!}!}!}!}!}!}!}!}!w!}!w!}!}!}!}!}!}!}!}!}!}"}"}"}"}"}"}"}"}"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_#_#_#_#_#_#_#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~############################################$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%&&&&&&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:&:':':':':':':':''''''''''''''''''R'R'R'R'R'R'R'R'R'R'R'R'R'R'R'R'R'R'R'R'R'R'R'R'R'R'R'R'R'R'R'R'R'R'R'R'R'R'R'R'R'R'R'R'R'R'R'R'R'R'R'R'R'R'R'R'R'R'R'R'R'R'R'''''''''''''''''''''''''''''''''''''''''(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((())))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))********************************************************************************************************************************++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,--------------------------------------------------------------------------------------------------------------------------------................................................................................................................................////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////0000000000000000000000000000u0u0u0u00000000000000000000y0y0y0y0y0y0y0y0y0y0y0y0y0y0y0y0y0y0y0y0y0y0y0y0y0y0y0y0y0y0y0y0y0y00000000000000000000000000000000000000000000111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111112222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222233333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444445555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555}5555555555555555555555555666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666667777777777777777777}77777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777778888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888899999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::u:u:u:u:u:u:u:u:u:w: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;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<u<u<u<u<u<u<u<u<u<u<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<================================================================================================================================>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>x>y>y>x>w>w>w>x>w>>w>w>w>w>w>w>w>w>x>f>f>w>w>w>w>w>w>x>x>>>y>w>x>x>x>x>x>x>x>x>x>x>x>x>x>x>x>x>x>x>y>y>y>y>y>y>x>w>w>y>y>y>>x>x>x>w>w>w>w>w>w>w>x>x>x>x>x>x>x>x>x>x>x>x>x>x>x>x>x>x>x>x>x?x?x?x?x?x?x?x?x?x?x?x?x?x?x?x?x? ? ?w?w?w?w?w? ? ?w?w? ? ? ? ? ? ?w? ? ?w? ? ? ? ? ? ?w? ? ?w?f?w?w? ? ? ? ? ?w?w?f?w?w?f?f?w??y?y?w?w?w?w?w?w?w?w?w?w?w?w?w?w?w??w?w?w?w???w?w?w??w?w?w?w?w?w?w?w?w?w?w??w?w?w?w?w???w??w?w?f?w?w??w??w?????w?@@@w@w@w@w@w@w@w@w@w@@w@w@w@w@w@w@f@@w@w@w@w@@w@@w@w@w@w@@w@w@w@@w@w@w@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDwDDDDDDDDEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEFFFFFFFFFFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwFwGwGwGwGwGwGwGwGwGwGwGwGwGwGwGwGwGwGwGwGwGwGwGwGwGwGwGwGwGwGwGwGwGwGwGwGwGwGwGwGwGwGwGwGwGwGwGwGwGwGwGwGwGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHIIIIIIIIII{IfI{I{I{IfIfIfI{I{IfI{IfIfIfIfI{I{IfI{I{I{IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIyIyIyIyIyIyIyIyIyIyIyIyIyIyIyIyIyIyIyIyIyIyIyIyIyIyIyIyIyIyIyIyIyIyIyIyIyIyJyJyJyJyJyJyJyJyJyJyJyJyJyJyJyJyJyJyJyJyJyJyJyJyJyJyJyJyJyJyJyJyJyJyJyJyJyJyJyJyJyJyJyJyJyJyJyJyJyJyJyJyJyJyJyJyJyJyJyJyJyJyJyJyJyJyJyJyJyJyJyJyJyJyJyJyJyJyJyJyJyJyJyJyJyJyJyJyJyJJJJJJJJJJJJfJJJfJfJfJJJJfJJfJJJJJJJJJJJJJJJJKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKLLLLLLLLLLLLLLLLLLLLLLLLLL|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|L|L|L|L|L|L|L|L|L|L|L|L|L|L|L|L|L|L|L|L|L|LzLzLzLzLzLzLzLzLzLzLzLzLzLzL|L|L|L|L|L|L|L|L|L|L|L|L|L|L|L|L|L|L|L|L|L|L|LLLLLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNaNaNaNaNaNaNaNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO5O5O5O5O5O5O5O5O5O5O5O5O5O5O5O5O5O5O5O5O5O5O5O5O5O5O5O5O5O5O5O5O5O5O5O5O5O5O5O5O5O5O5O5O5O5O5O5O5O5O5O5O5O5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5P5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5Q5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5R5RRSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS2S2S2S2S2S2S2S2S2S2S2S2S2S2S2S2S2S2S2S2S2S2S2S2S2S2S2S2S2S2S2S2S2S2S2S2S2S2S2S2S2S2S2S2S2S2S2S2S2S2S2S2S2S2S2T2T2T2T2T2T2T2T2T2T2T2T2T2T2T2T2T2T2T2T2T2T2T2T2T2T2T2T2T2T2T2T2T2T2TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTUUUUUUUUUUUUUUUUUUUUU 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 UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZaZaZaZaZaZaZaZaZaZaZaZaZaZaZaZaZaZaZaZaZaZaZaZaZaZaZaZaZaZaZa[a[a[a[a[a[a[a[a[a[a[a[a[a[a[a[a[a[a[a[a[a[a[a[a[a[a[a[a[a[a[a[a[a[a[a[a[a[a[a[a[a[a[a[a[a[a[a[a[a[a[a[a[a[a[`[`[`[`[`[`[`[`[`[`[`[`[`[`[`[`[`[`[`[`[`[`[`[`[`[`[`[`[`[`[`[`[`[`[`[`[`[`[`[`[`[`[`[`[`[`[`[`[`[`[`[`[`[`[`[`[`[`[`[`[`[`[`[`[`[`[`[`[`[`[`[`[`[`\`\`\`\`\`\`\`\`\`\`\`\`\`\`\`\`\`\`\`\`\`\`\`\`\`\`\`\`\`\`\`\`\`\`\`\`\`\`\`\`\`\`\`\`\`\`\`\`\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\v\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}^}^}^}^}^}^}^}^}^}^}^}^}^}^}^}^}^}^}^}^}^}^}^}^}^}^}^}^}^}^}^}^}^}^}^}^}^}^}^}^}^}^}^}^}^}^}^}^}^}^}^}^}^}^}^}^}^}^}^^^^^^^^^^^^^^#^#^#^#^#^#^#^#^#^#^#^#^#^#^#^#^#^#^#^#^#^#^#^#^#^#^#^#^#^#^#^#^#^#^#^#^#^#^#^#^#^#^#^#^#^#^#^#^#^#^#^#^#^#^#^#^#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#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#cddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffgggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggghhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiijjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkfkfkkfkfkkkkkkkkkkkkkkllflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflflfmfmfmfmfmfmfmfmfmfmfmfmfmfmfmfmfmfmfmfmfmfmfmfmfmfmfmfmfmfmfmfmfmfmfmfmfmfmfmfmfmfmfmfmfmfmfmfmfmfmfmfmfmfmfmfmfmfmfmfmfmfmfmfmfmfmfmfmfmfmfmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~€ÀĀŀƀǀȀɀʀˀ̀̀΀πЀрҀӀԀՀր׀؀ـڀۀ܀݀ހ߀ÁāŁƁǁȁɁʁˁ́́΁ρЁсҁӁԁՁցׁ؁فځہ܁݁ށ߁‚ÂĂłƂǂȂɂʂ˂̂͂΂ςЂт҂ӂԂՂւׂ؂قڂۂ܂݂ނ߂ƒÃăŃƃǃȃɃʃ˃̃̓΃σЃу҃ӃԃՃփ׃؃كڃۃ܃݃ރ߃„ÄĄńƄDŽȄɄʄ˄̄̈́΄τЄф҄ӄԄՄքׄ؄لڄۄ܄݄ބ߄…ÅąŅƅDžȅɅʅ˅̅ͅ΅υЅх҅ӅԅՅօׅ؅مڅۅ܅݅ޅ߅†ÆĆņƆdžȆɆʆˆ̆͆ΆφІц҆ӆԆՆֆz׆z؆zنzچzۆz܆z݆zކz߆zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz‡zÇzćzŇzƇzLJzȇzɇzʇzˇżz͇z·zχzЇzчz҇zӇzԇzՇzևzׇz؇zهzڇzۇz܇z݇zއz߇zzzzzzzzzzzzzzzzzzzˆÈĈňƈLjȈɈʈˈ͈̈ΈψЈш҈ӈԈՈֈ׈؈وڈۈ܈݈ވ߈‰ÉĉʼnƉljȉɉʉˉ͉̉ΉωЉщ҉ӉԉՉ։׉؉ىډۉ܉݉މ߉ŠÊĊŊƊNJȊɊʊˊ̊͊ΊϊЊъҊӊԊՊ֊׊؊يڊۊ܊݊ފߊ‹ËċŋƋNjȋɋʋˋ̋͋΋ϋЋыҋӋԋՋ֋׋؋ًڋۋ܋݋ދߋŒÌČŌƌnjȌɌʌˌ̌͌ΌόЌьҌӌԌՌ֌׌،ٌڌی܌݌ތߌÍčōƍǍȍɍʍˍ͍̍΍ύЍэҍӍԍՍ֍׍؍ٍڍۍ܍ݍލߍŽÎĎŎƎǎȎɎʎˎ͎̎ΎώЎюҎӎԎՎ֎׎؎َڎێ܎ݎގߎÏďŏƏǏȏɏʏˏ̏͏ΏϏЏяҏӏԏՏ֏׏؏ُڏۏ܏ݏޏߏÐĐŐƐǐȐɐʐː̐͐ΐϐАѐҐӐԐՐ֐אِؐڐېܐݐސߐ‘ÑđőƑǑȑɑʑˑ̑͑ΑϑБёґӑԑՑ֑בّؑڑۑܑݑޑߑ’ÒĒŒƒǒȒɒʒ˒̒͒ΒϒВђҒӒԒՒ֒גْؒڒےܒݒޒߒ“ÓēœƓǓȓɓʓ˓͓̓ΓϓГѓғӓԓՓ֓דؓٓړۓܓݓޓߓ”ÔĔŔƔǔȔɔʔ˔͔̔ΔϔДєҔӔԔՔ֔הؔٔڔ۔ܔݔޔߔ•ÕĕŕƕǕȕɕʕ˕͕̕ΕϕЕѕҕӕԕՕ֕וٕؕڕەܕݕޕߕ–ÖĖŖƖǖȖɖʖ˖̖͖ΖϖЖіҖӖԖՖ֖זٖؖږۖܖݖޖߖ—×ėŗƗǗȗɗʗ˗̗͗ΗϗЗїҗӗԗ՗֗חؗٗڗۗܗݗޗߗ˜ØĘŘƘǘȘɘʘ˘̘͘ΘϘИјҘӘԘ՘֘טؘ٘ژۘܘݘޘߘ™ÙęřƙǙșəʙ˙̙͙ΙϙЙљҙәԙՙ֙יؙٙڙۙܙݙޙߙšÚĚŚƚǚȚɚʚ˚͚̚ΚϚКњҚӚԚ՚֚ךؚٚښۚܚݚޚߚ›ÛěśƛǛțɛʛ˛̛͛ΛϛЛћқӛԛ՛֛כ؛ٛڛۛܛݛޛߛœÜĜŜƜǜȜɜʜ˜̜͜ΜϜМќҜӜԜ՜֜ל؜ٜڜۜܜݜޜߜÝĝŝƝǝȝɝʝ˝̝͝ΝϝНѝҝӝԝ՝֝ם؝ٝڝ۝ܝݝޝߝžÞĞŞƞǞȞɞʞ˞̞͞ΞϞОўҞӞԞ՞֞מ؞ٞڞ۞ܞݞޞߞŸßğşƟǟȟɟʟ˟̟͟ΟϟПџҟӟԟ՟֟ן؟ٟڟ۟ܟݟޟߟ àĠŠƠǠȠɠʠˠ̠͠ΠϠРѠҠӠԠՠ֠נؠ٠ڠ۠ܠݠޠߠ¡áġšơǡȡɡʡˡ̡͡ΡϡСѡҡӡԡա֡סء١ڡۡܡݡޡߡ¢âĢŢƢǢȢɢʢˢ̢͢΢ϢТѢҢӢԢբ֢עآ٢ڢۢܢݢޢߢ£ãģţƣǣȣɣʣˣ̣ͣΣϣУѣңӣԣգ֣ףأ٣ڣۣܣݣޣߣ¤äĤŤƤǤȤɤʤˤ̤ͤΤϤФѤҤӤԤդ֤פؤ٤ڤۤܤݤޤߤ¥åĥťƥǥȥɥʥ˥̥ͥΥϥХѥҥӥԥե֥ץإ٥ڥۥܥݥޥߥ¦æĦŦƦǦȦɦʦ˦̦ͦΦϦЦѦҦӦԦզ֦צئ٦ڦۦܦݦަߦ§çħŧƧǧȧɧʧ˧̧ͧΧϧЧѧҧӧԧէ֧קا٧ڧۧܧݧާߧ¨èĨŨƨǨȨɨʨ˨̨ͨΨϨШѨҨӨԨը֨רب٨ڨۨܨݨިߨ©éĩũƩǩȩɩʩ˩̩ͩΩϩЩѩҩөԩթ֩שة٩ک۩ܩݩީߩªêĪŪƪǪȪɪʪ˪̪ͪΪϪЪѪҪӪԪժ֪תت٪ڪ۪ܪݪުߪ«ëīūƫǫȫɫʫ˫̫ͫΫϫЫѫҫӫԫի֫׫ث٫ګ۫ܫݫޫ߫¬ìĬŬƬǬȬɬʬˬ̬ͬάϬЬѬҬӬԬլ֬׬ج٬ڬ۬ܬݬެ߬((((((((((((((((((((((((((((((((((((((((­íĭŭƭǭȭɭʭ˭̭ͭέϭЭѭҭӭԭխ֭׭ح٭ڭۭܭݭޭ߭®îĮŮƮǮȮɮʮˮ̮ͮήϮЮѮҮӮԮծ֮׮خٮڮۮܮݮޮ߮¯ïįůƯǯȯɯʯ˯̯ͯίϯЯѯүӯԯկ֯ׯدٯگۯܯݯޯ߯°ðİŰưǰȰɰʰ˰̰ͰΰϰаѰҰӰ԰հְװذٰڰ۰ܰݰް߰±ñıűƱDZȱɱʱ˱̱ͱαϱбѱұӱԱձֱױرٱڱ۱ܱݱޱ߱²òIJŲƲDzȲɲʲ˲̲ͲβϲвѲҲӲԲղֲײزٲڲ۲ܲݲ޲߲³óijųƳdzȳɳʳ˳̳ͳγϳгѳҳӳԳճֳ׳سٳڳ۳ܳݳ޳߳´ôĴŴƴǴȴɴʴ˴̴ʹδϴдѴҴӴԴմִ״شٴڴ۴ܴݴ޴ߴµõĵŵƵǵȵɵʵ˵̵͵εϵеѵҵӵԵյֵ׵صٵڵ۵ܵݵ޵ߵ¶öĶŶƶǶȶɶʶ˶̶Ͷζ϶жѶҶӶԶնֶ׶ضٶڶ۶ܶݶ޶߶·÷ķŷƷǷȷɷʷ˷̷ͷηϷзѷҷӷԷշַ׷طٷڷ۷ܷݷ޷߷¸øĸŸƸǸȸɸʸ˸̸͸θϸиѸҸӸԸոָ׸ظٸڸ۸ܸݸ޸߸¹ùĹŹƹǹȹɹʹ˹̹͹ιϹйѹҹӹԹչֹ׹عٹڹ۹ܹݹ޹߹ºúĺźƺǺȺɺʺ˺̺ͺκϺкѺҺӺԺպֺ׺غٺںۺܺݺ޺ߺ»ûĻŻƻǻȻɻʻ˻̻ͻλϻлѻһӻԻջֻ׻ػٻڻۻܻݻ޻߻¼üļżƼǼȼɼʼ˼̼ͼμϼмѼҼӼԼռּ׼ؼټڼۼܼݼ޼߼½ýĽŽƽǽȽɽʽ˽̽ͽνϽнѽҽӽԽսֽ׽ؽٽڽ۽ܽݽ޽߽¾þľžƾǾȾɾʾ˾̾;ξϾоѾҾӾԾվ־׾ؾپھ۾ܾݾ޾߾¿ÿĿſƿǿȿɿʿ˿̿ͿοϿпѿҿӿԿտֿ׿ؿٿڿۿܿݿ޿߿ Safe-InferredDe Safe-InferredF %&'() *+,- ./012356$"#78bdec9:! ;JM<=>?@ABKLCRPQDEFGONijklmnopqrstwyz{ %&'() *+,- ./012356$"#78bdec9:! ;JM<=>?@ABKLCRPQDEFGONijklmnopqrstwyz{ Safe-InferredJ Safe-InferredN ghc5Test if two points are in the same equivalence class.ghc6Return the canonical element of an equivalence class .ghc2Create a fresh equivalence class with one element.ghcRead the current value of .ghc)Flatten any chains of links, returning a 8 which points directly to the canonical representation.ghcUnify two equivalence classes, so that they share a canonical element. Keeps the descriptor of point2.ghcMutable write to a ghc"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.ghcA variable which can be unified; alternately, this can be thought of as an equivalence class with a distinguished representative.   Safe-InferredW5ghcTurn a Stream into an ordinary list, by demanding all the elements.ghcTurn a list into a #, by yielding each element in turn.ghc&Apply a function to each element of a , lazilyghcNote this is not very efficient because it traverses the whole stream before rebuilding it, avoid using it if you can. mapAccumL used to implemented but it wasn't used anywhere in the compiler and has similar effiency problems.ghc/Apply a monadic operation to each element of a , lazilyghc Stream m a b is a computation in some Monad m/ that delivers a sequence of elements of type a followed by a result of type b.!More concretely, a value of type  Stream m a b can be run using runStreamInternal in the Monad m, and it delivers eitherthe final result: Done b, or Yield a str where a( is the next element in the stream, and str is the rest of the stream Effect mstr where mstr is some action running in m* which generates the rest of the stream.4Stream is itself a Monad, and provides an operation  that produces a new element of the stream. This makes it convenient to turn existing monadic computations into streams.The idea is that Stream is useful for making a monadic computation that produces values from time to time. This can be used for knitting together two complex monadic operations, so that the producer does not have to produce all its values before the consumer starts consuming them. We make the producer into a Stream, and the consumer pulls on the stream each time it wants a new value. is implemented in the "yoneda" style for efficiency. By representing a stream in this manner  and  operations are accumulated in the function parameters before being applied once when the stream is destroyed. In the old implementation each usage of  and  would traverse the entire stream in order to apply the substitution at the leaves.The >>= operation for . was a hot-spot in the ticky profile for the ManyConstructors test which called the cg function many times in  StgToCmm.hsYY Safe-InferredW Safe-InferredW Safe-InferredX Safe-InferredZghcmaybeFlipCond c returns Just c'= if it is possible to flip the arguments to the conditional c", and the new condition should be c'.ghc 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. Safe-Inferred[3ghcBranch condition codes.(c) Matt Morrow 2009BSD3stableportable Safe-Inferred_ ghc Dominators. Complexity as for idomghcDominator tree. Complexity as for idom.ghcImmediate 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.ghcImmediate post-dominators. Complexity as for idom.ghc!Post-dominated depth-first search.ghcPost-dominators. Complexity as for idom.ghcPost-dominator tree. Complexity as for idom.ghc)Reverse post-dominated depth-first search.ghc arr .= x idx => write x to indexghcrenum n g: Rename all nodesGives nodes sequential names starting at n. Returns the new graph and a mapping. (renamed, old -> new)29  Safe-Inferred`"! Safe-Inferred 789`::" Safe-Inferred()/047f ghcSplit a closed block into its entry node, open middle block, and exit node.ghc#map a function over the nodes of a ghc A strict ghcmap over a block, with different functions to apply to first nodes, middle nodes and last nodes respectively. The map is strict.ghc2A sequence of nodes. May be any of four shapes (OO, OC, CO, CC). Open at the entry means single entry, mutatis mutandis for exit. A closedclosed block is a basic/ block and can't be extended further. Clients should avoid manipulating blocks and should stick to either nodes or graphs.ghcUsed at the type level to indicate "open" vs "closed" structure.ghcA "closed" structure which supports control transfer only through the use of named labels---no "fallthrough" is permitted. The number of control-flow edges is unconstrained.ghcAn "open" structure with a unique, unnamed control-flow edge flowing in or out. "Fallthrough" and concatenation are permitted at an open point.ghc6Either type indexed by closed/open using type familiesghc!Maybe type indexed by open/closedghcFold a function over every node in a block, forward or backward. The fold function must be polymorphic in the shape of the nodes.))$ Safe-Inferredg % Safe-InferredhghcDefault maximum depth for both class instance search and type family reduction. See also #5395.ghcDefault maximum constraint-solver iterations Typically there should be very few  & Safe-Inferred!l| ghc File bytes.ghc File group.ghc File mode.ghc File name.ghc File owner.ghc File size.ghcFile modification time.ghc Int testp k = (n - ) . length . group . sort . map hs . take n $ ls where ls = [] : [c : l | l <- ls, c <- ['\0'..'\xff']] hs = foldl' f golden f m c = fromIntegral (ord c) * k + hashInt32 m n = 100000!We discover that testp magic = 0.ghc-Get the last two elements in a list. Partial!ghcTrue if length xs <= length ysghc '(lengthAtLeast xs n) = (length xs >= n)ghc &(lengthAtMost xs n) = (length xs <= n)ghc &(lengthExceeds xs n) = (length xs > n)ghc "(lengthIs xs n) = (length xs == n)ghc %(lengthIsNot xs n) = (length xs /= n)ghc ((lengthLessThan xs n) == (length xs < n)ghcTrue if length xs < length ysghcApply an effectful function to the last list element. Assumes a non-empty list (panics otherwise).ghc4Merge an unsorted list of sorted lists, for example: mergeListsBy compare [ [2,5,15], [1,10,100] ] = [1,2,5,10,15,100] O(n \log{} k) ghcApply a function n times to a given value.ghc=Remove duplicates but keep elements in order. O(n * log n)ghc takes a list of Bools and a list of some elements and partitions the list according to the list of Bools. Elements corresponding to M+ go to the left; elements corresponding to J go to the right. For example, ;partitionByList [True, False, True] [1,2,3] == ([1,3], [2]) This function does not check whether the lists have equal length; when one list runs out, the function stops.ghcUses a function to determine which of two output lists an input element should joinghcParse a string into a significand and exponent according to the "Hexadecimal Floats in Haskell" proposal. A trivial example might be: ghci> readHexSignificandExponentPair "0x1p+1" (1,1) Behaves similar to readSignificandExponentPair but the base is 16 and numbers are given in hexadecimal: ghci> readHexSignificandExponentPair "0xAp-4" (10,-4) ghci> readHexSignificandExponentPair "0x1.2p3" (18,-1)ghcParse a string into a significand and exponent. A trivial example might be: ghci> readSignificandExponentPair "1E2" (1,2) In a more complex case we might return a exponent different than that which the user wrote. This is needed in order to use a Integer significand. ghci> readSignificandExponentPair "-1.11E5" (-111,3)ghcSplit a list into its last element and the initial part of the list. %snocView xs = Just (init xs, last xs) for non-empty lists. snocView xs = Nothing otherwise. Unless both parts of the result are guaranteed to be used prefer separate calls to last + init. If you are guaranteed to use both, this will be more efficient.ghc+spanEnd p l == reverse (span p (reverse l)). The first list returns actually comes after the second list (when you look at the input list).ghc;Given two lists xs and ys, return `splitAt (length xs) ys`.ghcstretchZipWith p z f xs ys stretches ys by inserting z in the places where p returns True ghcThis has the effect of making the two lists have equal length by dropping the tail of the longer one. ghc  is a kind of 0 that is lazy in the second list (observe the ~) ghc  is like  but is lazy in the second and third lists. The length of the output is always the same as the length of the first list. ghc  is like  but is lazy in the second list. The length of the output is always the same as the length of the first list. ghc'A call stack constraint, but only when  isDebugOn.ghcFind the "restricted" Damerau-Levenshtein edit distance between two strings. See:  9http://en.wikipedia.org/wiki/Damerau-Levenshtein_distance. Based on the algorithm presented in "A Bit-Vector Algorithm for Computing Levenshtein and Damerau Edit Distances" in PSC'02 (Heikki Hyyro). See  *http://www.cs.uta.fi/~helmu/pubs/psc02.pdf and  ,http://www.cs.uta.fi/~helmu/pubs/PSCerr.html for an explanationghcA sample (and useful) hash function for Int32, implemented by extracting the uppermost 32 bits of the 64-bit result of multiplying by a 33-bit constant. The constant is from Knuth, derived from the golden ratio: $golden = round ((sqrt 5 - 1) * 2^32)We get good key uniqueness on small inputs (a problem with previous versions): (length $ group $ sort $ map hashInt32 [-32767..65536]) == 65536 + 32768WX     W  X 329  Safe-Inferred .7) ghcTakes a list of Maybes and returns the first Just if there is one, or Nothing otherwise. ghcTakes computations returnings Maybes6; tries each one in order. The first one to return a Just wins. Returns Nothing if all computations return Nothing. ghcFlipped version of  fromMaybe, useful for chaining. ghcTry performing an E action, failing on error.BKL    4  Safe-Inferred ghcTry to locate "DerivedConstants.h" file in the given dirs and to parse the PlatformConstants from it.See Note [Platform constants] ghcThis predicate tells us whether the OS supports ELF-like shared libraries. ghcThis predicate tells us whether the OS support Mach-O shared libraries. ghcPlatform architecture ghcFor some architectures the C calling convention is that any integer shorter than 64 bits is replaced by its 64 bits representation using sign or zero extension. ghc>Test if the given Integer is representable with a platform Int ghc?Test if the given Integer is representable with a platform Word ghc6Maximum representable Int value for the given platform ghc7Maximum representable Word value for the given platform ghc6Minimum representable Int value for the given platform ghc Platform OS ghc7This predicate tells us whether the platform is 32-bit. ghc'x86 BMI (bit manipulation) instructions ghcPlatform descriptionThis is used to describe platforms so that we can generate code for them. ghcArchitecture and OS ghcByte order (endianness) ghcSymbols need underscore prefix ghcDetermines whether we will be compiling info tables that reside just before the entry code, or with an indirection to the entry code. See TABLES_NEXT_TO_CODE in includesrtsstorage/InfoTables.h. ghc Word size ghc5Constants such as structure offsets, type sizes, etc. ghcstableportable Safe-Inferredh+ ghcAbove, except that if the last line of the first argument stops at least one position before the first line of the second begins, these two lines are overlapped. For example: % text "hi" $$ nest 5 (text "there") lays out as  hi there rather than  hi there  is associative, with identity  , and also satisfies(x   y)   z = x   (y   z), if y non-empty. ghcAbove, with no overlapping.   is associative, with identity  . ghc;Beside, separated by space, unless one of the arguments is  .   is associative, with identity  . ghc Beside.   is associative, with identity  . ghcEither   or  . ghcA document of height and width 1, containing a literal character. ghc2The empty document, with no height and no width.   is the identity for  ,  ,   and  ), and anywhere in the argument list for  ,  ,  ,  ,   etc. ghc"Paragraph fill" version of  . ghc"Paragraph fill" version of  . ghc The general rendering interface. ghc "hang d1 n d2 = sep [d1, nest n d2] ghcApply   to the arguments if the first   is not empty. ghcList version of  . ghcList version of  . ghcReturns M if the document is empty ghcApply   to   if boolean is true. ghcNest (or indent) a document by a given number of positions (which may also be negative).   satisfies the laws:   0 x = x   k (  k' x) =   (k+k') x   k (x   y) =   k z     k y   k (x   y) =   k x     k y   k   =  x     k y = x   y, if x non-empty6The side condition on the last law is needed because   is a left identity for  . ghc punctuate p [d1, ... dn] = [d1 <> p, d2 <> p, ... dn-1 <> p, dn] ghc Render the Doc to a String using the given Style. ghcEither   or  . ghcSome text with any width. (text s = sizedText (length s) s) ghcThe default style (7mode=PageMode False, lineLength=100, ribbonsPerLine=1.5). ghc5A document of height 1 containing a literal string.   satisfies the following laws:   s     t =   (st)  ""   x = x, if x non-empty8The side condition on the last law is necessary because   "" has height 1, while   has no height. ghcDefault TextDetails printer ghcList version of  . ghcSome text, but without any width. Use for non-printing text such as a HTML or Latex tags ghcThe abstract type of documents. A Doc represents a *set* of layouts. A Doc with no occurrences of Union or NoDoc represents just one layout. ghcRendering mode. ghc%No indentation, infinitely long lines ghcAll on one line ghcNormal ghcWith zig-zag cuts ghcA rendering style. ghcLength of line, in chars ghcThe rendering mode ghc%Ratio of line length to ribbon length ghcThe TextDetails data typeA TextDetails represents a fragment of text that will be output at some point. ghcA single Char fragment ghcA whole String fragmentghcRDoc is a "reduced GDoc", guaranteed not to have a top-level Above or Beside.ghc*Perform some simplification of a built up GDoc.ghcfirst returns its first argument if it is non-empty, otherwise its second.ghcCan we output an ascii space character for spaces? Mostly true, but not for e.g. UTF16 See Note [putSpaces optimizations] for why we bother to track this. ghcWrap document in {...} ghcWrap document in [...] ghcA : character ghcA ',' character ghc double n = text (show n) ghcWrap document in "..." ghcA '=' character ghc float n = text (show n) ghcRendering modeghc Line lengthghcRibbons per lineghcWhat to do with textghcWhat to do at the endghc The documentghcResult ghc%See Note [Print Hexadecimal Literals] ghc int n = text (show n) ghc integer n = text (show n) ghcA '{' character ghcA '[' character ghcA '(' character ghcWrap document in (...) ghcWrap document in '...' ghc rational n = text (show n) ghcA '}' character ghcA ']' character ghcA ')' character ghcA ';' character ghcA space character  5 5 6 6= Safe-Inferred ghc;Parse the colour scheme from a string (presumably from the  GHC_COLORS environment variable). ghcA colour/style for use with coloured. ghcAllow colours to be combined (e.g. bold + red); In case of conflict, right side takes precedence.  z Safe-Inferred.45 F׆ghcWhen creating syntax we use the shorthands. It's better for printing, also, the shorthands work trivially at each pass.܆ghcWhen creating syntax we use the shorthands. It's better for printing, also, the shorthands work trivially at each pass.݆ghc Does this ' come with an explicit kind annotation?߆ghcAn empty list that can be used to indicate that there are no type arguments allowed in cases where HsConDetails is applied to Void.ghcAmbiguous Field OccurrenceRepresents an *occurrence* of a field that is potentially ambiguous after the renamer, with the ambiguity resolved by the typechecker. We always store the + that the user originally wrote, and store the selector function after the renamer (for unambiguous occurrences) or the typechecker (for ambiguous occurrences).+See Note [HsRecField and HsRecUpdField] in  GHC.Hs.Pat- and Note [Disambiguating record fields] in GHC.Tc.Gen.Head". See Note [Located RdrNames] in  GHC.Hs.Exprghc Bang TypeIn the parser, strictness and packedness annotations bind more tightly than docstrings. This means that when consuming a  (and looking for 8) we must be ready to peer behind a potential layer of  . See #15206 for motivation and  getBangType for an example.ghcConstructor Declaration Fieldghc, : ,ghcSee Note [ConDeclField passs]ghcField OccurrenceRepresents an *occurrence* of an unambiguous field. This may or may not be a binding occurrence (e.g. this type is used in  and RecordPatSynField& which bind their fields, but also in  HsRecField6 for record construction and patterns, which do not).We store both the + the user originally wrote, and after the renamer, the selector function.ghcSee Note [Located RdrNames] in  GHC.Hs.Exprghc2Denotes the type of arrows in the surface languageghca %m -> b or a %m C b (very much including `a %Many -> b`! This is how the programmer wrote it). It is stored as an 9 so as to preserve the syntax as written in the program.ghca %1 -> b or a %1 C b, or a E bghca -> b or a C bghcDescribes the arguments to a data constructor. This is a common representation for several constructor-related concepts, including:The arguments in a Haskell98-style constructor declaration (see HsConDeclH98Details in  GHC.Hs.Decls).)The arguments in constructor patterns in case/function definitions (see HsConPatDetails in  GHC.Hs.Pat).The left-hand side arguments in a pattern synonym binding (see HsPatSynDetails in  GHC.Hs.Binds).One notable exception is the arguments in a GADT constructor, which uses a separate data type entirely (see HsConDeclGADTDetails in  GHC.Hs.Decls). This is because GADT constructors cannot be declared with infix syntax, unlike the concepts above (#18844).ghcHaskell Contextghc The type variable binders in an  . See also 1Note [Variable Specificity and Forall Visibility] in GHC.Tc.Gen.HsType.ghc An invisible forall (e.g., forall a {b} c. {...}), where each binder has a .ghc A visible forall (e.g., forall a -> {...}). These do not have any notion of specificity, so we use () as a placeholder value.ghcThese names are used early on to store the names of implicit parameters. They completely disappear after type-checking.ghc Haskell Kindghc.Used for type-family instance equations, e.g., 'type instance forall a. F [a] = Tree a The notion of specificity is irrelevant in type family equations, so we use () for the  flag.ghcUsed for signatures, e.g., f :: forall a {b}. blah We use  for the  flag to allow distinguishing between specified and inferred type variables.ghc6The outermost type variables in a type that obeys the forall-or-nothing rule. See Note [forall-or-nothing rule].ghcExplicit forall, e.g., f :: forall a b. a -> b -> bghcImplicit forall, e.g., f :: a -> b -> bghcThe extension field for 2, which is only used in the renamer onwards. See ,Note [Pattern signature binders and scoping].ghcImplicitly bound variable namesghcWildcard namesghcTypes that can appear in pattern signatures, as well as the signatures for term-level binders in RULES. See ,Note [Pattern signature binders and scoping].This is very similar to  HsSigWcType., but with slightly different semantics: see Note [HsType binders] . See also #Note [The wildcard story for types].ghcMain payload (the type itself)ghcAfter renamer: ghcThis is used in the syntax. In constructor declaration. It must keep the arrow representation.ghc A type signature that obeys the forall&-or-nothing rule. In other words, an ߇ that uses an  to represent its outermost type variable quantification. See #Note [Representing type signatures].ghcHaskell Tuple SortghcHaskell Type LiteralghcHaskell Type Variable Binder The flag annotates the binder. It is  in places where explicit specificity is allowed (e.g. x :: forall {a} b. ...) or () in other places.ghc, : - , ,, ,ghc Haskell Typeghc, : Noneghc, : - '{-# UNPACK' or '{-# NOUNPACK' , , '#-}' , '!'ghc, : Noneghc, : - "'[" , , ']'ghc, : - "'(" , , ')'ghc, : - , ,,,= For details on above see note [exact print annotations] in GHC.Parser.Annotationghc, : -,ghc  (?x :: ty), : ,ghc  (ty :: kind), : - '(' , ,,, ')'ghc, : - '[' , , ']'ghc, : Noneghc, : - '(' , , ')'ghc, : - '{' , , '}'ghc, : - '$(' , , ')'ghc, : None‡ghc, : - '(#' , , '#)'@Çghc, : -  '(' or '(#' , ,  ')' or '#)'ćghc, : NoneŇghc, : NoneƇghc, : None͇ghcHaskell Wildcard Binders҇ghcLocated Bang TypeӇghc%Located Constructor Declaration FieldԇghcLocated Field OccurrenceՇghcLocated Haskell ContextևghcLocated Haskell Kindׇghc)Located Haskell Quantified Type Variables܇ghcLocated Haskell Signature Type݇ghc'Located Haskell Signature Wildcard Typeއghc$Located Haskell Type Variable Binder߇ghcLocated Haskell TypeghcLocated Haskell Wildcard TypeӇghc May have , : , when in a listՇghc, : - For details on above see note [exact print annotations] in GHC.Parser.Annotationևghc, : ,߇ghc May have , : , when in a list!LLLLLLLLLLLLLLֆ׆؆نچۆ܆݆ކ߆ćŇLJƇLJȇɇʇˇ͇̇·χЇч҇ӇԇՇևׇ؇هڇۇ܇݇އ߇!؆ۆ׆܆ćŇLJƇLJȇɇʇˇ̇߇ևއׇ؇هڇۇ͇·χЇч܇݇Շֆ҇LLLLLLLLLLLLLLӇ߆ԇކچ݆ن Safe-Inferred().05 Ughc Eliminate a U . Much like .Ughc=Used when constructing a term with an unused extension point.Ughc*Maps the "normal" id type for a given passUghc4We can map over the underlying type contained in an XRec( while preserving the annotation as is.UghcUsed in TTG extension constructors that have yet to be extended with anything. If an extension constructor has U as its field, it is not intended to ever be constructed anywhere, and any function that consumes the extension constructor can eliminate it by way of U.!This should not be confused with U', which are found in unused extension points (not  constructors!) and therefore can be inhabited.UghcA placeholder type for TTG extension points that are not currently unused to represent any particular value.!This should not be confused with U', which are found in unused extension  constructors8 and therefore should never be inhabited. In contrast, U is used in extension points (e.g., as the field of some constructor), so it must have an inhabitant to construct AST passes that manipulate fields with that extension point as their type.UghcSee Note [NoGhcTc] in GHC.Hs.Extension. It has to be in this module because it is used like an extension point (in the data definitions of types that should be parameter-agnostic.UghcWe can strip off the XRec to access the underlying data. See Note [XRec and SrcSpans in the AST]UghcThe trivial wrapper that carries no additional information See Note [XRec and SrcSpans in the AST]WghcGHC's L prefixed variants wrap their vanilla variant in this type family, to add SrcLoc info via Located. Other passes than GhcPass= not interested in location information can define this as "type instance XRec NoLocated a = a*. See Note [XRec and SrcSpans in the AST]UUUUUUUUUUUUUUUUUUUUVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXUUUUUWUUUUUUUUUVVVXWXVWWUWXUWWXVXVXWWVVVWWWWWVXVWWXWWVWWWVVWUWWVWXVXWXVWVVXVXVXWVWWVWVXVXVVWVVWVWVXVWVVWXVWWUWWVWVVWVXVXVWXWXWXVWVXVXWWVWWVWWWWVVWWWWWVVVWWWVVWWVWVVVWWWWWWVWWVXWXWUWWWXWWWWXVWVVWWWWVWWXVXVXVXWVVVWWWWXVVVVVVVVVVVWWXVVWVVVVVVVVVVVVVXWXWWWVWVWWWVWWWWWWVXVVXVVXVXVXVXVWWVVVWWWWWVWWWVVWVVWWXVVXWWXVWVWVXVVVVVVVVXU0 Safe-Inferred 4>7ghc'Represents a pretty-printable document.To display an , use  ,  ,  , or  . Avoid calling  . directly as it breaks the abstraction layer. ghc Join two  together vertically; if there is no vertical overlap it "dovetails" the two onto one line ghc Join two  together vertically ghc Join two . together horizontally with a gap between them ghc Join two $ together horizontally without a gap ghc$NB: This won't ever show package IDs ghcAn efficient variant of   specialized for   that outputs to a  . ghcCatenate: is either like   or like  , depending on what fits ghc.Apply the given colour/style for the argument.)Only takes effect if colours are enabled. ghcDefault style for error messages, when we don't know PrintUnqualified It's a bit of a hack because it doesn't take into account what's in scope Only used for desugarer warnings, and typechecker errors in interface sigs ghcDefault pretty-printing options ghcDetermines the form of to do appropriate for the length of a list: doOrDoes [] = text "do" doOrDoes ["Hello"] = text "does" doOrDoes ["Hello", "World"] = text "do" ghcdoublePrec p n shows a floating point number n with p. digits of precision after the decimal point. ghcThis behaves like  , but it uses  ( for horizontal conposition rather than  ghcA paragraph-fill combinator. It's much like sep, only it keeps fitting things on one line until it can't fit any more. ghc'Indicate if -dppr-debug mode is enabled ghcThis behaves like  , but does not indent the second document when the header is empty. ghc Concatenate  horizontally ghc Concatenate + horizontally with a space between each one ghc,Says what to do with and without -dppr-debug ghcReturns the comma-separated concatenation of the pretty printed things. ghcReturns the separated concatenation of the pretty printed things. ghcDetermines the form of to be appropriate for the length of a list: isOrAre [] = text "are" isOrAre ["Hello"] = text "is" isOrAre ["Hello", "World"] = text "are" ghcDetermines the form of possessive appropriate for the length of a list: itsOrTheir [x] = text "its" itsOrTheir [x,y] = text "their" itsOrTheir [] = text "their" -- probably avoid this ghc!Style for printing error messages ghcIndent  some specified amount ghcDetermines the pluralisation suffix appropriate for the length of a list: plural [] = char 's' plural ["Hello"] = empty plural ["Hello", "World"] = char 's' ghc6Truncate a list that is longer than the current depth. ghc9Normalise, escape and render a string representing a pathe.g. "c:\whatever" ghc3Special combinator for showing bytestring literals. ghc2Special combinator for showing character literals. ghc/Special combinator for showing string literals. ghc0Special combinator for showing unboxed literals. ghcReturns the comma-separated concatenation of the quoted pretty printed things. ,y,z] ==> `x', `y', `z' ghcThe analog of   for , which tries to make sure the terminal doesn't get screwed up by the ANSI color codes if an exception is thrown during pretty-printing. ghcLike   but appends an extra newline. ghcSeparate: is either like   or like  , depending on what fits ghc-Converts an integer to a verbal multiplicity: speakN 0 = text "none" speakN 5 = text "five" speakN 10 = text "10" ghcConverts an integer and object description to a statement about the multiplicity of those objects: speakNOf 0 (text "melon") = text "no melons" speakNOf 1 (text "melon") = text "one melon" speakNOf 3 (text "melon") = text "three melons" ghc&Converts an integer to a verbal index: speakNth 1 = text "first" speakNth 5 = text "fifth" speakNth 21 = text "21st" ghc Concatenate  vertically with dovetailing ghc7Says what to do with -dppr-debug; without, return empty ghc  is used to tell the thing that prints binder what language construct is binding the identifier. This can be used to decide how much info to print. Also see Note [Binding-site specific printing] in  GHC.Core.Ppr ghc+The x in case scrut of x { (y,z) -> ... } ghc+The y,z in case scrut of x { (y,z) -> ... } ghcThe x in (x. e)ghcThe x in (let x = rhs in e)ghcUse  field as depthghc 0 => stopghcStyle of label pretty-printing.When we produce C sources or headers, we have to take into account that C compilers transform C labels when they convert them into symbols. For example, they can add prefixes (e.g., "_" on Darwin) or suffixes (size for stdcalls on Windows). So we provide two ways to pretty-print CLabels: C style or Asm style.ghc%Asm label style (used by NCG backend)ghc+C label style (used by C and LLVM backends)ghc(Class designating that some type has an  representationghcWhen we print a binder, we often want to print its type too. The OutputableBndr class encapsulates this idea.ghc5Outputable class with an additional environment value See Note [The OutputableP class]ghcWrapper for types having a Outputable instance when an OutputableP instance is required.ghc!Print code; either C or assemblerghcWhen printing code that contains original names, we need to map the original names back to something the user understands. This is the purpose of the triple of functions that gets passed around when rendering .ghcFor a given module, we need to know whether to print it with a package name to disambiguate it.ghcGiven a Name's  and  (, decide whether and how to qualify it.ghcFor a given package, we need to know whether to print it with the component id to disambiguate it.ghcTrue if Unicode encoding is supported and not disable by GHC_NO_UNICODE environment variableghcS'ghcModule name (e.g. A.B.C)ghcUnit the module belongs toghc6A generic module is a pair of a unit identifier and a .ghcA unit identifier identifies a (possibly partially) instantiated library. It is primarily used as part of , which in turn is used in Name=, which is used to give names to entities when typechecking.#There are two possible forms for a :1) It can be a , in which case we just have a  that uniquely identifies some fully compiled, installed library we have on disk.2) It can be an . When we are typechecking a library with missing holes, we may need to instantiate a library on the fly (in which case we don't have any on-disk representation.) In that case, you have an , which explicitly records the instantiation, so that we can substitute over it.ghcAn  is an  with the invariant that it only refers to an indefinite library; i.e., one that can be instantiated.ghcA Module is a pair of a  and a .ghcA UnitId identifies a built library in a database and is used to generate unique symbols, etc. It's usually of the form:pkgname-1.2:libname+hash(These UnitId are provided to us via the  -this-unit-id flag.The library in question may be definite or indefinite; if it is indefinite, none of the holes have been filled (we never install partially instantiated libraries as we can cheaply instantiate them on-the-fly, cf VirtUnit). Put another way, an installed unit id is either fully instantiated, or not instantiated at all.ghc+Create a new simple unit identifier from a  . Internally, this is primarily used to specify wired-in unit identifiers.ghcThis is the package Id for the current program. It is the default package Id if you don't specify a package name. We don't add this prefix to symbol names, since there can be only one main package per program.ghcMap over the unit type of a ghc4Map over the unit identifier of unit instantiations.ghc Create a new ' given an explicit module substitution.ghcGenerate a uniquely identifying hash (internal unit-id) for an instantiated unit.This is a one-way function. If the indefinite unit has not been instantiated at all, we return its unit-id.This hash is completely internal to GHC and is not used for symbol names or file paths. It is different from the hash Cabal would produce for the same instantiated unit.ghc*Smart constructor for instantiated GenUnitghcCalculate the free holes of a . If this set is non-empty, this module was defined in an indefinite library that had required signatures.If a module has free holes, that means that substitutions can operate on it; if it has no free holes, substituting over a module has no effect.ghc2Compares unit ids lexically, rather than by their sghcReturn the UnitId of the Unit. For on-the-fly instantiated units, return the UnitId of the indefinite unit this unit is an instance of.ghc+Retrieve the set of free module holes of a .ghcA % is definite if it has no free holes.ghc=Return the virtual UnitId of an on-the-fly instantiated unit.ghcA  is an  with the invariant that it only refers to a definite library; i.e., one we have generated code for.ghc3A definite unit (i.e. without any free module hole)ghcAn instantiated unit.It identifies an indefinite library (with holes) that has been instantiated.This unit may be indefinite or not (i.e. with remaining holes or not). If it is definite, we don't know if it has already been compiled and installed in a database. Nevertheless, we have a mechanism called "improvement" to try to match a fully instantiated unit with existing compiled and installed units: see Note [VirtUnit to RealUnit improvement].?An indefinite unit identifier pretty-prints to something like p[H= H ,A=aimpl:A>] (p is the 5, and the brackets enclose the module substitution).ghcA private, uniquely identifying representation of an InstantiatedUnit. This string is completely private to GHC and is just used to get a unique.ghc$A cache of the free module holes of &. This lets us efficiently tell if a  has been fully instantiated (empty set of free module holes) and whether or not a substitution can have any effect.ghc'The indefinite unit being instantiated.ghcThe sorted (by ) instantiations of this unit.ghcCached unique of .ghcFake hole unitghcInstalled definite unit (either a fully instantiated unit or a closed unit)ghcVirtual unit instantiated on-the-fly. It may be definite if all the holes are instantiated but we don't have code objects for it.ghc"This data type just pairs a value - with an IsBootInterface flag. In practice,  is usually a Module or  ModuleName'.ghcA  is a # whose unit is identified with an .ghcAn  is a " whose unit is identified with an .ghcIndicates whether a module name is referring to a boot interface (hs-boot file) or regular module (hs file). We need to treat boot modules specially when building compilation graphs, since they break cycles. Regular source files and signature files are treated equivalently.ghcClass for types that are used as unit identifiers (UnitKey, UnitId, Unit)We need this class because we create new unit ids for virtual units (see VirtUnit) and they have to to be made from units with different kinds of identifiers.ghcThe full hashed unit identifier, including the component id and the hash.ghcA unit key in the databaseghc2Generate a hash for a sorted module instantiation.S Safe-Inferred()/4[ghc$Get access to the underlying buffer.0It is quite important that no references to the ; leak out of the continuation lest terrible things happen.ghcDo not rely on instance sizes for general types, we use variable length encoding for many of them.ghcEncode the argument in it's full length. This is different from many default binary instances which make no guarantee about the actual encoding and might do things use variable length encoding.ghcInformation we keep around during interface file serialization/deserialization. Namely we keep the functions for serializing and deserializing s and  s. We do this because we actually use serialization in two distinct settings,+When serializing interface files themselvesWhen computing the fingerprint of an IfaceDecl (which we computing by hashing its Binary serialization)These two settings have different needs while serializing Names:Names in interface files are serialized via a symbol table (see Note [Symbol table representation of names] in GHC.Iface.Binary).During fingerprinting a binding Name is serialized as the OccName and a non-binding Name is serialized as the fingerprint of the thing they represent. See Note [Fingerprinting IfaceDecls] for further discussion.ghcserialize a binding  (e.g. the name of an IfaceDecl)ghcserialize a non-binding ( (e.g. a reference to another binding).ghc&Takes a size and action writing up to size bytes. After the action has run advance the index to the buffer by size bytes.ghchow to deserialize sghchow to serialize non-binding sghchow to serialize binding s..H Safe-Inferred5i" ghcAdd elements to the map, combining existing values with inserted ones using the given function.ghcDetermines the pluralisation suffix appropriate for the length of a set in the same way that plural from Outputable does for lists.ghc1`plusUFM_CD f m1 d1 m2 d2` merges the maps using f! as the combinding function and d1 resp. d2/ as the default value if there is no entry in m1 reps. m2-. The domain is the union of the domains of m1 and m2.IMPORTANT NOTE: This function strictly applies the modification function and forces the result unlike most the other functions in this module.Representative example: plusUFM_CD f {A: 1, B: 2} 23 {B: 3, C: 4} 42 == {A: f 1 42, B: f 2 3, C: f 23 4 } ghc,`plusUFM_CD2 f m1 m2` merges the maps using f$ as the combining function. Unlike =, a missing value is not defaulted: it is instead passed as K to f. f' can never have both its arguments be K.IMPORTANT NOTE: This function strictly applies the modification function and forces the result.`plusUFM_CD2 f m1 m2` is the same as `plusUFM_CD f (mapUFM Just m1) Nothing (mapUFM Just m2) Nothing`.ghcPretty-print a non-deterministic set. The order of variables is non-deterministic and for pretty-printing that shouldn't be a problem. Having this function helps contain the non-determinism created with nonDetEltsUFM.ghcPretty-print a non-deterministic set. The order of variables is non-deterministic and for pretty-printing that shouldn't be a problem. Having this function helps contain the non-determinism created with nonDetUFMToList.ghc Cast the key domain of a UniqFM.As long as the domains don't overlap in their uniques this is safe.ghcA wrapper around  with the sole purpose of informing call sites that the provided 7 and 8 instances are nondeterministic. If you use this please provide a justification why it doesn't introduce nondeterminism. See Note [Deterministic UniqFM] in GHC.Types.Unique.DFM to learn about determinism.ghcA finite map from uniques* of one type to elements in another type.The key is just here to keep us honest. It's always safe to use a single type as key. If two types don't overlap in their uniques it's also safe to index the same map at multiple key types. But this is very much discouraged.ghcInherently nondeterministic. If you use this please provide a justification why it doesn't introduce nondeterminism. See Note [Deterministic UniqFM] in GHC.Types.Unique.DFM to learn about determinism.ghcInherently nondeterministic. If you use this please provide a justification why it doesn't introduce nondeterminism. See Note [Deterministic UniqFM] in GHC.Types.Unique.DFM to learn about determinism.ghcThe things to be pretty printedghc3The pretty printing function to use on the elementsghc+ where the things have been pretty printedghcThe things to be pretty printedghc3The pretty printing function to use on the elementsghc+ where the things have been pretty printed Safe-InferredrUghcPanic with an assertion failure, recording the given file and line number. Should typically be accessed with the ASSERT family of macrosghc&Throw an exception saying "bug in GHC"ghcThrow an exception saying "bug in pgm being compiled" (used for unusual program errors)ghc7Throw an exception saying "bug in GHC" with a callstackghcShow an exception which can possibly throw other exceptions. Used when displaying exception thrown within TH code.ghcShow an exception as a string.ghc;Append a description of the given exception to this string.ghc;Append a description of the given exception to this string.Note that this uses  >, which doesn't use the options set by the user via DynFlags.ghc3Throw an exception saying "this isn't finished yet"ghcLike try, but pass through UserInterrupt and Panic exceptions. Used when we want soft failures when reading interface files, for example. TODO: I'm not entirely sure if this is catching what we really want to catchghcTemporarily install standard signal handlers for catching ^C, which just throw an exception in the current thread.ghc=GHC's own exception type error messages all take the form:  : If the location is on the command line, or in GHC itself, then ="ghc". All of the error types below correspond to a of "ghc", except for ProgramError (where the string is assumed to contain a location already, so we don't print one).ghcA problem with the command line arguments, but don't print usage.ghcAn installation problem.ghcThe  impossible happened.ghc&An error in the user's code, probably.ghc(Some other fatal signal (SIGHUP,SIGTERM)ghcThe user tickled something that's known not to work yet, but we're not counting it as a bug.ghc*Prints the short usage msg after the errorghc-We use reference counting for signal handlers(uv~}|(~}|uvF Safe-InferredughcThe interface file symbol-table encoding assumes that known-key uniques fit in 30-bits; verify this.3See Note [Symbol table representation of names] in GHC.Iface.Binary for details.ghc%Class of things that we can obtain a  fromghcUnique identifier.The type of unique identifiers that are used in many places in GHC for fast ordering and equality tests. You should generate these with the functions from the  UniqSupply moduleThese are sometimes also referred to as "keys" in comments in GHC.ghcHow many bits are devoted to the unique index (as opposed to the class character).Q Safe-Inferred$%5789B3ghcCombine locations from two % things and add them to a third thingghc Move the  down by one line if the character is a newline, to the next 8-char tabstop if it is a tab, and across by one character in any other caseghc Compare the  of two located things./Precondition: both operands have an associated .ghc,Tests the ordering of the two located thingsghc Combines two  into one that spans at least all the characters within both spans. Assumes the "file" part is the same in both inputsghc Combines two  into one that spans at least all the characters within both spans. Returns UnhelpfulSpan if the files differ.ghcTests whether the first span "contains" the other span, meaning that it covers at least as much source code. True where spans are equal.ghc.Tests whether the two located things are equalghcBuilt-in "bad"  values for particular locationsghcBuilt-in "bad" ,s for common sources of location uncertaintyghcBuilt-in "bad"  values for particular locationsghcBuilt-in "bad" ,s for common sources of location uncertaintyghc Test if a 1 is "good", i.e. has precise location informationghcTrue if the span is known to straddle only one line. For "bad" , it returns Falseghc4Determines whether a span is enclosed by another oneghc4Determines whether a span is enclosed by another oneghcTrue if the span has a width of zero, as returned for "virtual" semicolons in the lexer. For "bad" , it returns FalseghcCreate a name which is actually defined by the compiler itself'ghcReturns True if the Name comes from some other package: neither this package nor the interactive package.'ghcReturns True if the name is (a) Internal (b) External but from the specified module (c) External but from the  interactive packageThe key idea is that False means: the entity is defined in some other module you can find the details (type, fixity, instances) in some interface file those details will be stored in the EPT or HPTTrue means: the entity is defined in this module or earlier in the GHCi session you can find details (type, fixity, instances) in the TcGblEnv or TcLclEnvThe isInteractiveModule part is because successive interactions of a GHCi session each give rise to a fresh module (Ghci1, Ghci2, etc), but they all come from the magic  interactive package; and all the details are kept in the TcLclEnv, TcGblEnv, NOT in the HPT or EPT. See Note [The interactive package] in GHC.Runtime.Context'ghc!Get a string representation of a  that's unique and stable across recompilations. Used for deterministic generation of binds for derived instances. eg. "$aeson_70dylHtv1FFGeai1IoxcQr$Data.Aeson.Types.Internal$String"'ghc0Print the string of Name unqualifiedly directly.'ghcCompare Names lexicographically This only works for Names that originate in the source code or have been tidied.'ghc!BuiltInSyntax is for things like (:), [] and tuples, which have special syntactic forms. They aren't in scope as such.'ghcAssumes that the  is a non-binding one. See  and  for serializing binding s. See ) for the rationale for this distinction.'ghcThe same comments as for 's . instance apply.ghcIts occurrence name.NOTE: kept lazy to allow known names to be known constructor applications and to inline better. See Note [Fast comparison for built-in Names]'ghcCaution#: This instance is implemented via , which means that the ordering is not stable across deserialization or rebuilds.See  for further information, and trac #15240 for a bug caused by improper use of this instance.ghc Its unique.ghcWhat sort of name it isghcDefinition siteNOTE: we make the n_loc field strict to eliminate some potential (and real!) space leaks, due to the fact that we don't look at the SrcLoc in a Name all that often. &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&'''''''''''''''''''''''''''''''''''''''''''''''''':''''''''''''''''''''''''''''''''''''''''''''''''''X Safe-Inferred $%Z ghcGiven a possibly on-the-fly instantiated module, split it into a  that we definitely can find on-disk, as well as an instantiation if we need to instantiate it on the fly. If the instantiation is Nothing" no on-the-fly renaming is needed.ghcReturn the unit-id this unit is an instance of and the module instantiations (if any).ghc Test if a  corresponds to a given , modulo instantiation.ghc$Test if a Module is not instantiatedghcCreate a hole ModuleghcA % is definite if it has no free holes.ghc!Get a string representation of a  that's unique and stable across recompilations. eg. "$aeson_70dylHtv1FFGeai1IoxcQr$Data.Aeson.Types.Internal"ghcThis gives a stable ordering, as opposed to the Ord instance which gives an ordering based on the Uniques of the components, which may not be stable from run to run of the compiler.ghc;Remove instantiations of the given module instantiated unitghc4Remove instantiations of the given instantiated unit* Safe-Inferred+ghc2A ModuleName is essentially a simple string, e.g.  Data.List.ghcReturns the string version of the module name, with dots replaced by colons.ghcReturns the string version of the module name, with dots replaced by slashes.ghc6Compares module names lexically, rather than by their s  U Safe-Inferred ghcAdd the -boot suffix to .hs, .hi and .o filesghcAdd the -boot4 suffix to all file paths associated with the moduleghcAdd the -boot suffix to all output file paths associated with the module, not including the input file itselfghcAdd the -boot suffix if the Bool argument is Trueghc Remove the -boot suffix to .hs, .hi and .o filesghcModule LocationWhere a module lives on the file system: the actual locations of the .hs, .hi and .o files, if we have them.For a module in another unit, the ml_hs_file and ml_obj_file components of ModLocation are undefined.The locations specified by a ModLocation may or may not correspond to actual files yet: for example, even if the object file doesn't exist, the ModLocation still contains the path to where the object file will reside if/when it is created.ghcWhere the .hi file is, whether or not it exists yet. Always of form foo.hi, even if there is an hi-boot file (we add the -boot suffix later)ghc6Where the .hie file is, whether or not it exists yet.ghcThe source file, if we have one. Package modules probably don't have source files.ghcWhere the .o file is, whether or not it exists yet. (might not exist either because the module hasn't been compiled yet, or because it is part of a unit with a .a file)  W Safe-InferredghcA map keyed off of s (actually, their s) Has deterministic folds and can be deterministically converted to a listghcA map keyed off of ghcA map keyed off of sghcA map keyed off of s (actually, their s)ghc A set of s))J Safe-Inferred 5789>}ghc(Apply a function to a particular elementghc(Apply a function to a particular elementghcThe expression (alterUDFM f k map) alters value x at k, or absence thereof. alterUDFM can be used to insert, delete, or update a value in UniqDFM. Use addToUDFM, delFromUDFM or adjustUDFM when possible, they are more efficient.ghc(Delete a list of elements from a UniqDFMghcPerforms a deterministic fold over the UniqDFM. It's O(n log n) while the corresponding function on  is O(n).ghc,Map a function over every value in a UniqDFMghcPerforms a nondeterministic strict fold over the UniqDFM. It's O(n), same as the corresponding function on . If you use this please provide a justification why it doesn't introduce nondeterminism.ghc>Partition UniqDFM into two UniqDFMs according to the predicateghc Converts  to a list, with elements in deterministic order. It's O(n log n) while the corresponding function on  is O(n).ghc7This allows for lossy conversion from UniqDFM to UniqFMghc Cast the key domain of a UniqFM.As long as the domains don't overlap in their uniques this is safe.ghc(Type of unique deterministic finite mapsThe key is just here to keep us honest. It's always safe to use a single type as key. If two types don't overlap in their uniques it's also safe to index the same map at multiple key types. But this is very much discouraged.ghc+A type of values tagged with insertion timeghcinsertion timeghcDeterministic, in O(n log n).ghcDeterministic, in O(n log n).ghcThe things to be pretty printedghc3The pretty printing function to use on the elementsghc+ where the things have been pretty printed..N Safe-Inferred5cK Safe-Inferred5=ghcWhat's the point you might ask? We might have changed an object without it's key changing. In which case this lookup makes sense.ghc converts a  a into a  a0 assuming, without checking, that it maps each  to a value that has that . See Note [UniqSet invariant].$$Y Safe-Inferred'ghcReturn the module that is used to instantiate the given home module.If the given module isn't a module hole, return the actual home module."E.g., the instantiating module of p:A in  p[A=q[]:B] is q[]:B%. the instantiating module of r:A in  p[A=q[]:B] is r:A%. the instantiating module of p:A in p is p:A%. the instantiating module of r:A in p is r:A.ghcReturn the module that is used to instantiate the given home module name. If the ModuleName doesn't refer to a signature, return the actual home module."E.g., the instantiating module of A in  p[A=q[]:B] is q[]:B%. the instantiating module of A in p is p:A.ghc&Return the home unit as a normal unit.We infer from the home unit itself the kind of unit we create: 1. If the home unit is definite, we must be compiling so we return a real unit. The definite home unit may be the result of a unit instantiation, say `p = q[A=r:X]`. In this case we could have returned a virtual unit `q[A=r:X]` but it's not what the clients of this function expect, especially because p is lost when we do this. The unit id of a virtual unit is made up internally so `unitId(q[A=r:X])` is not equal to p. If the home unit is indefinite we can only create a virtual unit from it. It's ok because we must be only typechecking the home unit so we won't produce any code object that rely on the unit id of this virtual unit.ghcReturn home unit idghcReturn the unit id of the unit that is instantiated by the home unit.-E.g. if home unit = q[A=p:B,...] we return q.If the home unit is not an instance of another unit, we return its own unit id (it is an instance of itself if you will).ghcReturn the unit id of the unit that is instantiated by the home unit.4E.g. if home unit = q[A=p:B,...] we return (Just q).If the home unit is not an instance of another unit, we return Nothing.ghcReturn home unit instantiationsghc4Map over the unit identifier for instantiating unitsghc+Test if the module comes from the home unitghc+Test if the module comes from the home unitghc!Test if the unit is the home unitghc(Test if we are compiling a definite unit3(if it is, we should never use on-the-fly renaming)ghc'Test if the unit-id is the home unit-idghc/Test if we are type-checking an indefinite unit7(if it is not, we should never use on-the-fly renaming)ghc9Test if the home unit is an instance of the given unit-idghc9Test if we are compiling by instantiating a definite unitghcMake a module in home unitghcMake a module in home unitghc6Test if a module doesn't come from the given home unitghc6Test if a module doesn't come from the given home unitghc6Test if a module doesn't come from the given home unitghc6Test if a module doesn't come from the given home unitghcInformation about the home unit (i.e., the until that will contain the modules we are compiling)The unit identifier of the instantiating units is left open to allow switching from UnitKey (what is provided by the user) to UnitId (internal unit identifier) with .TODO: this isn't implemented yet. UnitKeys are still converted too early into UnitIds in GHC.Unit.State.readUnitDataBaseghc.Definite home unit (i.e. that we can compile).Nothing: not an instantiated unit Just (i,insts): made definite by instantiating "i" with "insts"ghc6Indefinite home unit (i.e. that we can only typecheck)All the holes are instantiated with fake modules from the Hole unit. See Note [Representation of module/name variables] in GHC.Unitv Safe-Inferredq !ghcA global typecheckable-thing, essentially anything that has a name. Not to be confused with a  TcTyThing, which is also a typecheckable thing but in the *local* context. See GHC.Tc.Utils.Env for how to retrieve a ! given a .\ghcDetermine the ! s brought into scope by another ! other than itself. For example, Id's don't have any implicit TyThings as they just bring themselves into scope, but classes bring their dictionary datatype, type constructor and some selector functions into scope, just for a start!\ghcReturns True if there should be no interface-file declaration for this thing on its own: either it is built-in, or it is part of some other declaration, or it is generated implicitly by some other declaration.\ghcThe Names that a TyThing should bring into scope. Used to build the GlobalRdrEnv for the InteractiveContext.\ghcGet the 0 from a !2 if it is a coercion axiom thing. Panics otherwise\ghcGet the N from a !5 if it is a data constructor thing. Panics otherwise\ghcGet the ! from a !4 if it is a data constructor thing. Panics otherwise\ghcGet the  from a !< if it is a id *or* data constructor thing. Panics otherwise\ghctyThingParent_maybe x returns (Just p) when pprTyThingInContext should print a declaration for p (albeit with some "..." in it) when asked to show x It returns the *immediate* parent. So a datacon returns its tycon but the tycon could be the associated type of a class, so it in turn might have a parent.\ghcGet the   from a !4 if it is a type constructor thing. Panics otherwise\ghcClass that abstracts out the common ability of the monads in GHC to lookup a ! in the monadic environment by . Provides a number of related convenience functions for accessing particular kinds of !!!!\\\\\\\\\\\\\\\\\\\\\\\\\\!\\\\\\\\\!!\\\\\\\\\\\\\\\\\ Safe-Inferred'ghcConvert a DVarSet to a VarSet by forgetting the order of insertion'ghc'Delete a list of variables from DVarSet'ghcTrue if empty intersection(ghc"Add a list of variables to DVarSet(ghcTrue if non-empty intersection(ghc5Map the function over the list, and union the results(ghc5map the function over the list, and union the results(ghc2Partition DVarSet according to the predicate given(ghcDetermines the pluralisation suffix appropriate for the length of a set in the same way that plural from Outputable does for lists.(ghcPretty-print a non-deterministic set. The order of variables is non-deterministic and for pretty-printing that shouldn't be a problem. Having this function helps contain the non-determinism created with nonDetEltsUFM. Passing a list to the pretty-printing function allows the caller to decide on the order of Vars (eg. toposort them) without them having to use nonDetEltsUFM at the call site. This prevents from let-binding non-deterministically ordered lists and reusing them where determinism matters.(ghctransCloVarSet for DVarSet(ghcCoercion Variable Set(ghcDeterministic Identifier Set(ghc+Deterministic Type or Coercion Variable Set(ghcDeterministic Type Variable Set(ghcDeterministic Variable Set(ghcIdentifier Set(ghcType or Coercion Variable Set(ghcType Variable Set(ghc A non-deterministic Variable SetA non-deterministic set of variables. See Note [Deterministic UniqFM] in GHC.Types.Unique.DFM for explanation why it's not deterministic and why it matters. Use DVarSet if the set eventually gets converted into a list or folded over in a way where the order changes the generated code, for example when abstracting variables.(ghcThe things to be pretty printedghc4The pretty printing function to use on the elementsghc+ where the things have been pretty printed''''''''''''''''(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((('('''(((''(((((((((((((((((((((''((((('('(''(((('''(((('_ Safe-Inferred 5b2ghcThe non-dependent version of . See Note [AnonArgFlag] Appears here partly so that it's together with its friends ArgFlag and ForallVisFlag, but also because it is used in IfaceType, rather early in the compilation chainghc Argument Flag3Is something required to appear in source Haskell ("), permitted by request (") (visible type application), or prohibited entirely from appearing in source Haskell (")? See Note [VarBndrs, TyCoVarBinders, TyConBinders, and visibility] in GHC.Core.TyCo.Repghc Identifierghc Whether an "' argument may appear in source Haskell.ghc*Type variable that might be a metavariableghcType or Coercion VariableghcType or kind VariableghcVariableEssentially a typed ?, that may also contain some additional information about the  and its use sites."ghcIf it's a local, make it global"ghc(Is this a coercion variable? Satisfies " v ==> " v == not (" v)."ghcisExportedIdVar means "don't throw this away""ghc7Is this a value-level (i.e., computationally relevant) entifier? Satisfies isId = not . isTyVar."ghc Does this 5 classify an argument that is not written in Haskell?"ghc" returns True% for type variables as well as local s These are the variables that we need to pay attention to when finding free variables, or doing dependency analysis."ghcIs this a term variable ( ) that is not! a coercion variable? Satisfies " v ==> " v == not (" v)."ghcIs this a type-level (i.e., computationally irrelevant, thus erasable) variable? Satisfies isTyVar = not . isId."ghc Does this 1 classify an argument that is written in Haskell?"ghc Exported "s will not be removed as dead code"ghcMake a named binder"ghcMake many named binders"ghcMake a named binder var should be a type variable"ghc): a non-dependent predicate arrow. The argument is invisible in source code."ghc Used for (->): an ordinary non-dependent arrow. The argument is visible in source code."ghcCoercion Variable"ghcDictionary Function Identifier"ghcDictionary Identifier"ghcEquality Variable"ghcEvidence Identifier"ghcEvidence Variable"ghcImplicit parameter Identifier"ghc Kind Variable"ghc"ghcthe argument may not appear in source Haskell, it is only inferred."ghc?the argument may appear in source Haskell, but isn't required."ghcType or Kind Variable"ghcVariable BinderA " is the binder of a ForAllTy It's convenient to define this synonym here rather its natural home in GHC.Core.TyCo.Rep/, because it's used in GHC.Core.DataCon.hs-bootA " is a binder with only TyVar"ghc Type Variable"ghcThe type or kind of the  in questionghcKey for fast comparison Identical to the Unique in the name, cached here for speedghc,Not exported: may be discarded as dead code.ghcExported: kept aliveghcIdentifier Scope""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""a Safe-Inferred1ghcJust a synonym for [. Written separately so it can be exported in the hs-boot file.ghc Check if an  says [.ghcBasic . that carries no useful information whatsoeverghcIdentifier DetailsThe  of an Id7 give stable, and necessary, information about the Id.ghcIdentifier InformationAn  gives optional information about an Id. If present it never lies, but it may not be present, in which case there is always a conservative assumption which can be made.Two Id:s may have different info even though they have the same Unique (and are hence the same Id); for example, one might lack the properties attached to the other. Most of the ; gives information about the value, or definition, of the Id4, independent of its usage. Exceptions to this are [, [, Z and Z.!Performance note: when we update , we have to reallocate this entire record, so it is a good idea not to let this data structure get too big.ZghcId arity, as computed by GHC.Core.Opt.Arity%. Specifies how many arguments this Id: has to be applied to before it doesn any meaningful work.ZghcId CAF infoZghcHow this is called. This is the number of arguments to which a binding can be eta-expanded without losing any sharing. n  =% all calls have at least n argumentsZghc1Assume that no specializations exist: always safeZghc?When applied, will this Id ever have a levity-polymorphic type?ZghcMore informative  we can use when we know the Id has no CAF referencesZghc+Info about a lambda-bound variable, if the Id is oneZghcRetrieve the locally-defined free variables of both the left and right hand sides of the specialization rulesZghcMarks an IdInfo describing an Id that is never levity polymorphic (even when applied). The Type is only there for checking that it's really never levity polymorphicZghcChange the name of the function the rule is keyed on all of the Ys[ghc$It is always safe to assume that an Id has an arity of 0[ghcRemove all demand info on the [ghc'Zap info that depends on free variables[ghcThis is used to remove information on lambda binders that we have setup as part of a lambda group, assuming they will be applied all at once, but turn out to be part of an unsaturated lambda as in e.g: (\x1. \x2. e) arg1[ghcRemove usage environment info from the strictness signature on the [ghc.Remove usage (but not strictness) info on the [ghcArity InformationAn [ of n, tells us that partial application of this Id to up to n-1* value arguments does essentially no work.7That is not necessarily the same as saying that it has n6 leading lambdas, because coerces may get in the way.The arity might increase later in the compilation process, if an extra lambda floats up to the binding site.[ghc%Constant applicative form InformationRecords whether an Id+ makes Constant Applicative Form references[ghcIndicates that the Id is for either: A function or static constructor that refers to one or more CAFs, orA real live CAF[ghc9A function or static constructor that refers to no CAFs.[ghcThe Id9 is a superclass selector, or class operation of a class[ghc&A coercion variable This only covers  un-lifted coercions, of type (t1 ~# t2) or (t1 ~R# t2), not their lifted variants[ghc$A dictionary function. Bool = True  = the class has only one method, so may be implemented with a newtype, so it might be bad to be strict on this dictionary[ghcThe Id is for a data constructor worker[ghcThe Id is for a data constructor wrapper[ghcThe Id is for a foreign call. Type will be simple: no type families, newtypes, etc[ghcAn Id< for a join point taking n arguments Note [Join points] in GHC.Core[ghcThe Id is for a primitive operator[ghcThe Id for a record selector[ghcThe Id4 is for a HPC tick box (both traditional and binary)[ghcInformation on whether the function will ultimately return a freshly allocated constructor.[ghcID demand information[ghc"Any inline pragma attached to the Id[ghcHow the Id occurs in the program[ghcSpecialisations of the Ids function which exist. See Note [Specialisations and RULES in IdInfo][ghcA strictness signature. Digests how a function uses its arguments if applied to at least Z arguments.[ghcThe Id s unfolding[ghcInline Pragma InformationTells when the inlining is active. When it is active the thing may be inlined, depending on how big it is.If there was an INLINE pragma, then as a separate matter, the RHS will have been made to look small with a Core inline Note The default [ is , so the info serves entirely as a way to inhibit inlining until we want it[ghcRecursive Selector Parent[ghcRule Information$Records the specializations of this Id, that we know about in the form of rewrite Ys that target them[ghcTick box for Hpc-style coverageghcEncodes arities, OneShotInfo, CafInfo and LevityInfo. From least-significant to most-significant bits:Bit 0 (1): OneShotInfoBit 1 (1): CafInfoBit 2 (1): LevityInfoBits 3-32(30): Call Arity infoBits 33-62(30): Arity infoghcBitfield packs CafInfo, OneShotInfo, arity info, LevityInfo, and call arity info in one 64-bit word. Packing these fields reduces size of  from 12 words to 7 words and reduces residency by almost 4% in some programs. See #17497 and associated MR.See documentation of the getters for what these packed fields mean.ghcAssumes that the Id$ has CAF references: definitely safe[[[[[[[[[[[[[[[[[[[[[NNNNNNNZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[Z[[[ZZZ[[[[[[[[[[[ZZZZZ[Z[Z[ZZ[Z[[Z[Z[[ZZZZZ[Z[[[ZZZZNNNNNNN[Z[[[[ZZZZ Z1Z1Z1Z1Z1Z1Z1Z1Z1Z1Z1Z1c Safe-Inferred5fghc,How to call a particular function in C-land.ghc A C type, used in CAPI FFI calls :   '{-# CTYPE' , , ,  '#-}',ghcLike PlaySafe, but additionally the worker thread running this foreign call may be unceremoniously killed, so it must be scheduled on an unbound thread.ghcNone of the above can happen; the call will return without interacting with the runtime system at all. Specifically:No GC No call backs No blockingNo precise exceptionsghcMight invoke Haskell GC, or do a call back, or switch threads, etc. So make sure things are tidy before the call. Additionally, in the threaded RTS we arrange for the external call to be executed by a separate OS thread, i.e., _concurrently_ to the execution of other Haskell threads.!!Z Safe-Inferred5 ghc7The integer should already be negated if it's negative.ghc=The arguments should already be negated if they are negative.ghc/Special combinator for showing string literals.ghcFractional LiteralUsed (instead of Rational) to represent exactly the floating point literal that we encountered in the user's source program. This allows us to pretty-print exactly what the user wrote, which is important e.g. for floating point numbers that can't represented as Doubles (we used to via Double for pretty-printing). See also #2245. Note [FractionalLit representation] in GHC.HsToCore.Match.Literal The actual value then is: sign * fl_signi * (fl_exp_base^fl_exp) where sign = if fl_neg then (-1) else 1For example FL { fl_neg = True, fl_signi = 5.3, fl_exp = 4, fl_exp_base = Base10 } denotes -5300ghc'How the value was written in the sourceghcIntegral LiteralUsed (instead of Integer) to represent negative zegative zero which is required for NegativeLiterals extension to correctly parse `-0::Double` as negative zero. See also #13211.ghcFor when code is generated, e.g. TH, deriving. The pretty printer will then make its own representation of the item.ghcA String Literal in the source, including its original raw format for use by source to source manipulation tools.ghcBe wary of using this instance to compare for equal *values* when exponents are large. The same value expressed in different syntactic form won't compare as equal when any of the exponents is >= 100.ghcBe wary of using this instance to compare for equal *values* when exponents are large. The same value expressed in different syntactic form won't compare as equal when any of the exponents is >= 100.ghcCompare fractional lits with small exponents for value equality but large values for syntactic equality.!! Safe-Inferred'SMghcReturns true if an application to n args would diverge or throw an exception.If a function having M is applied to a less number of arguments than its syntactic arity, we cannot say for sure that it is going to diverge. Hence this function conservatively returns False in that case. See Note [Dead ends].Mghc"See Note [Computing one-shot info]Mghc"See Note [Computing one-shot info]MghcWhen e is evaluated after executing an IO action that may throw a precise exception, we act as if there is an additional control flow path that is taken if e throws a precise exception. The demand type of this control flow path * is lazy and absent (M/) in all free variables and arguments * has M N, result So we can simply take a variant of M,  . Why not M? Because then the result of e can never be M! That means failure to drop dead-ends, see #18086. See Note [Precise exceptions and strictness analysis]Mghc A special N for data constructors that feeds product demands into the constructor arguments.Mghc A special N for dictionary selectors that feeds the demand on the result into the indicated dictionary component (if saturated).Mghc Extrapolate a demand signature (N ) into a N.Given a function's N and a N for the evaluation context, return how the function evaluates its free variables and arguments.MghcWe are expanding (x y. e) to (x y z. e z) or reducing from the latter to the former (when the Simplifier identifies a new join points, for example). In contrast to M, this appends extra arg demands if necessary. This works by looking at the N (which was produced under a call demand for the old arity) and trying to transfer as many facts as we can to the call demand of new arity. An arity increase (resulting in a stronger incoming demand) can retain much of the info, while an arity decrease (a weakening of the incoming demand) must fall back to a conservative default.MghcTrue  = upper bound is 0.Mghc True if the N indicates that evaluation will not return. See Note [Dead ends].MghcTrue if the signature diverges or throws an exception in a saturated call. See Note [Dead ends].Mghc7Not absent and used strictly. See Note [Strict demands]MghcTrue  = lower bound is 1.Mghc8Contrast with isStrictUsedDmd. See Note [Strict demands]Mghc;Used to suppress pretty-printing of an uninformative demandMghcTrue  = upper bound is 1.MghcIs the value used at most once?MghcWe try to avoid tracking weak free variable demands in strictness signatures for analysis performance reasons. See Note [Lazy and unleashable free variables] in GHC.Core.Opt.DmdAnal.MghckeepAliveDmdType dt vs makes sure that the Ids in vs have some usage in the returned demand types -- they are not Absent. See Note [Absence analysis for stable unfoldings and RULES] in GHC.Core.Opt.DmdAnal.MghcSee M.MghcFirst argument of catch#: MCM(L). Evaluates its arg lazily, but then applies it exactly once to one argument.MghcSecond argument of catch#:  MCM(C1(L)). Calls its arg lazily, but then applies it exactly once to an additional argument.MghcDenotes D on M.MghcDenotes D on M.Mghc%Compute the least upper bound of two N*s elicited /by the same incoming demand/!MghcDenotes D on N.Mghc Wraps the N with a one-shot call demand: d -> C1(d).MghcmkCalledOnceDmds n d returns C1(C1...(C1 d)) where there are n C1's.MghcA smart constructor for N6, applying rewrite rules along the semantic equality #Prod [polyDmd n, ...] === polyDmd n, simplifying to  Ns when possible. Note that this degrades boxity information! E.g. a polymorphic demand will never unbox.MghcTurns a N computed for the particular  into a N unleashable at that arity. See Note [Understanding DmdType and StrictSig]MghcDenotes  on M.MghcThe demand type of doing nothing (lazy, absent, no Divergence information). Note that it is 'not' the top of the lattice (which would be "may use everything"), so it is (no longer) called topDmdType.MghcIntersect with [0,1].MghcMake a M evaluated at-most-once.MghcPeels one call level from the sub-demand, and also returns how many times we entered the lambda body.MghcDenotes  on M.MghcDenotes  on M.MghcDenotes  on N.Mghc Add extra (M7) arguments to a strictness signature. In contrast to M, this prepends8 additional argument demands. This is used by FloatOut.Mghc(saturatedByOneShots n CM(CM(...)) = True  = There are at least n nested CM(..) calls. See Note [Demand on the worker] in GHC.Core.Opt.WorkWrapMghcFirst argument of 'GHC.Exts.atomically#': SCS(L)-. Called at least once, possibly many times.MghcFirst argument of 'GHC.Exts.maskAsyncExceptions#': 1C1(L). Called exactly once.MghcIf the argument is a used non-newtype dictionary, give it strict demand. Also split the product type & demand and recur in order to similarly strictify the argument's contained used non-newtype superclass dictionaries. We use the demand as our recursive measure to guarantee termination.MghcMake a M' evaluated at-least-once (e.g. strict).Mghc viewProd n sd interprets sd as a N of arity n , expanding  demands as necessary.Mghc1Remove the demand environment from the signature.Mghc#Remove all `C_01 :*` info (but not CM sub-demands) from the demandMghc#Remove all `C_01 :*` info (but not CM. sub-demands) from the strictness signatureMghcDescribes an interval of evaluation cardinalities&. See Note [Evaluation cardinalities]Mghc{0} Absent.Mghc{0,1} Used at most once.Mghc4{0,1,n} Every possible cardinality; the top element.Mghc>{} The empty interval; the bottom element of the lattice.Mghc{1} Strict and used once.Mghc.{1,n} Strict and used (possibly) many times.MghcA demand describes a scaled evaluation context, e.g. how many times and how deep the denoted thing is evaluated.-The "how many" component is represented by a M7inality. The "how deep" component is represented by a N+. Examples (using Note [Demand notation]): puts demand 1A on its first argument: It evaluates the argument strictly (1), but not any deeper (A). puts demand 1P(1L,A) on its argument: It evaluates the argument pair strictly and the first component strictly, but no nested info beyond that (L*). Its second argument is not used at all.  puts demand 1C1(L)" on its first argument: It calls (C>) the argument function with one argument, exactly once (1=). No info on how the result of that call is evaluated (L). puts demand MCM(L) on its second argument: It evaluates the argument function at most once ((M)aybe) and calls it once when it is evaluated. fst p + fst p puts demand SP(SL,A) on p: It's 1P(1L,A)# multiplied by two, so we get S4 (used at least once, possibly multiple times).#This data type is quite similar to Scaled N, but it's scaled by M, which is an interval on  Multiplicity, the upper bound of which could be used to infer uniqueness types.NghcN characterises whether something surely diverges. Models a subset lattice of the following exhaustive set of divergence results: nnontermination (e.g. loops)ithrows imprecise exceptionpthrows precise exceTtioncconverges (reduces to WHNF).The different lattice elements correspond to different subsets, indicated by juxtaposition of indicators (e.g. nc definitely doesn't throw an exception, and may or may not reduce to WHNF).  Dunno (nipc) | ExnOrDiv (nip) | Diverges (ni) %As you can see, we don't distinguish n and i. See Note [Precise exceptions and strictness analysis] for why p is so special compared to i.Nghc5Definitely throws an imprecise exception or diverges.Nghc7Might diverge, throw any kind of exception or converge.NghcDefinitely throws a *precise* exception, an imprecise exception or diverges. Never converges, hence M! See scenario 1 in Note [Precise exceptions and strictness analysis].NghcA demand transformer> is a monotone function from an incoming evaluation context (N) to a N, describing how the denoted thing (i.e. expression, function) uses its arguments and free variables, and whether it diverges.See Note [Understanding DmdType and StrictSig] and Note [What are demand signatures?].NghcCharacterises how an expression * Evaluates its free variables (N!) * Evaluates its arguments (N,) * Diverges on every code path or not (N)NghcDemand on argumentsNghc?Whether evaluation diverges. See Note [Demand type Divergence]Nghc-Demand on explicitly-mentioned free variablesNghcThe depth of the wrapped N encodes the arity at which it is safe to unleash. Better construct this through M1. See Note [Understanding DmdType and StrictSig]NghcA sub-demand describes an evaluation context5, e.g. how deep the denoted thing is evaluated. See M for examples. The nested N d of a  Cn(d) is relative- to a single such call. E.g. The expression  f 1 2 + f 3 4 puts call demand  SCS(C1(L)) on f: f is called exactly twice (S), each time exactly once (1) with an additional argument. The nested Ms dn of a N  P(d1,d2,...) apply  absolutely: If dn is a used once demand (cf. M), then that means that the denoted sub-expression is used once in the entire evaluation context described by the surrounding M. E.g., LP(ML) means that the field of the denoted expression is used at most once, although the entire expression might be used many times.See Note [Call demands are relative] and Note [Demand notation].NghcProd ds describes the evaluation context of a case scrutinisation on an expression of product type, where the product components are evaluated according to ds.NghcSee Note [Demand notation] Current syntax was discussed in #19016.NghcSee Note [Demand notation]ghcPolymorphic demand, the denoted thing is evaluated arbitrarily deep, with the specified cardinality at every level. Expands to  via  and to N via M.Poly n is semantically equivalent to Prod [n :* Poly n, ...] or Call n (Poly n).  and M do these rewrites.In Note [Demand notation]: L === P(L,L,...) and  L === CL(L), 1 === P(1,1,...) and  1 === C1(1) , and so on.We only really use  with M (B), M (A), M (L) and sometimes M (S), but it's simpler to treat it uniformly than to have a special constructor for each of the three cases.NghcSee Note [Demand notation]ghc Call n sd% describes the evaluation context of n function applications, where every individual result is evaluated according to sd. sd is relative to a single call, cf. Note [Call demands are relative]. Used only for values of function type. Use the smart constructor  whenever possible!ghcThis makes sure we can use the demand type with n arguments after eta expansion, where n must not be lower than the demand types depth. It appends the argument list with the correct .ghcA smart constructor for 6, applying rewrite rules along the semantic equality Call n (Poly n) === Poly n, simplifying to  Ns when possible.ghc viewCall sd interprets sd as a  , expanding  demands as necessary.ghcThe trivial cases of the mult* functions. If multTrivial n abs a = ma/, we have the following outcomes depending on n:M => multiply by one,  ma = Just aM, M (e.g. M n$) => return the absent thing,  ma = Just abs Otherwise (M#, 'C_*N') it's not a trivial case,  ma = Nothing.ghc6See Note [Asymmetry of 'plus*'], which concludes that < needs to be symmetric. Strictly speaking, we should have (plusDivergence Dunno Diverges = ExnOrDiv. But that regresses in too many places (every infinite loop, basically) to be worth it and is only relevant in higher-order scenarios (e.g. Divergence of f (throwIO blah)). So  currently is  glbDivergence , really.ghcIn a non-strict scenario, we might not force the Divergence, in which case we might converge, hence Dunno.ghcThe demand type of an unspecified expression that is guaranteed to throw a (precise or imprecise) exception or diverge.ghc)A conservative approximation for a given N in case of an arity decrease. Currently, it's just nopDmdType.Mghcdepending on saturationMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNNNNNNNNNNNNNNNNNNNNNMMMMMMMMNNNMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNMMMNNNNMMMMMNNNNNMMMMMMNMMMMMMMMNNMMMMMMMMMMMMNMMMNNNNMMMMMMMMM Safe-InferreddY (ghc)Tells whether a variable is locally bound(ghc)Tells whether a variable is locally bound(ghcLook up a variable the ). This lets you map from the variable's identity (unique) to its full value.)ghc$Wipe the left or right side renaming)ghc$Wipe the left or right side renaming)ghcrnBndr2 env bL bR goes under a binder bL5 in the Left term, and binder bR, in the Right term. It finds a new binder, new_b&, and returns an environment mapping  bL -> new_b and  bR -> new_b)ghc Similar to )= but returns the new variable as well as the new environment)ghc Similar to )7 but used when there's a binder on the left side only.)ghc Similar to )8 but used when there's a binder on the right side only.)ghcApplies ) to several variables: the two variable lists must be of equal length)ghcRetrieve the left mapping)ghcRetrieve the right mapping)ghc Similar to )5 but used for eta expansion See Note [Eta expansion])ghc Similar to )5 but used for eta expansion See Note [Eta expansion])ghc?Look up the renaming of an occurrence in the left or right term)ghc?Look up the renaming of an occurrence in the left or right term)ghc?Look up the renaming of an occurrence in the left or right term)ghc?Look up the renaming of an occurrence in the left or right term)ghc"swap the meaning of left and right)ghcuniqAway in_scope v finds a unique that is not used in the in-scope set, and gives that to v. See Note [Local uniques].)ghcunsafeGetFreshUnique in_scope3 finds a unique that is not in-scope in the given ). This must be used very carefully since one can very easily introduce non-unique %s this way. See Note [Local uniques].)ghcCoercion Variable Environment)ghcDeterministic Identifier Environment Sadly not always indexed by Id, but it is in the common case.)ghc'Deterministic Type Variable Environment)ghc"Deterministic Variable Environment)ghcIdentifier Environment)ghcA set of variables that are in scope at some point "Secrets of the Glasgow Haskell Compiler inliner" Section 3.2 provides the motivation for this abstraction.)ghcRename Environment 2When we are comparing (or matching) types or terms, we are faced with "going under" corresponding binders. E.g. when comparing: \x. e1 ~ \y. e2Basically we want to rename [x -> y] or [y -> x], but there are lots of things we must be careful of. In particular, x might be free in e2 , or y in e1. So the idea is that we come up with a fresh binder that is free in neither, and rename x and y, respectively. That means we must maintain: 'A renaming for the left-hand expression)A renaming for the right-hand expressionsAn in-scope setFurthermore, when matching, we want to be able to have an 'occurs check', to prevent: \x. f ~ \y. ymatching with [f -> y]. So for each expression we want to know that set of locally-bound variables. That is precisely the domain of the mappings 1. and 2., but we must ensure that we always extend the mappings as we go in.-All of this information is bundled up in the ))ghcTidy EnvironmentWhen tidying up print names, we keep a mapping of in-scope occ-names (the &+) and a Var-to-Var of the current renamings)ghc%Type or Coercion Variable Environment)ghcType Variable Environment)ghcVariable Environment((((((((((((((((((((((((((((((((((((((((((((((((((((((((()))))))))))))))))))))))))))))))))))))))))))))))))))))))))()))(((((()))))(((((((()))((()))))(((((((((()(()()))((()()((((((((()())))()))))(()))))))((((())))()))(((: Safe-Inferred!5o ghcOther names in the compiler add additional information to an OccName. This class provides a consistent way to access the underlying OccName. ghcOccurrence NameIn this context that means: "classified (i.e. as a type name, value name, etc) but not qualified and not yet resolved"&ghc Test if the  8 is a data constructor that starts with a symbol (e.g. :, or [])&ghcTest for definitions internally generated by GHC. This predicate is used to suppress printing of internal definitions in some debug prints&ghc Test if the   is that for any operator (whether it is a data constructor or variable or whatever)&ghcIs an   one of a Typeable TyCon or Module binding? This is needed as these bindings are renamed differently. See Note [Grand plan for Typeable] in GHC.Tc.Instance.Typeable.&ghcValue OccNamess are those that are either in the variable or data constructor namespaces&ghc fib x has arity 1 See also Note [Definition of arity] in GHC.Core.Opt.ArityghcA *one-index* constructor tagType of the tags associated with each constructor possibility or superclass selectorghc A *zero-indexed* constructor tagghcDefault Method SpecificationghcEmbedding Projection pairghcFullArgCount is the number of type or value arguments in an application, or the number of type or value binders in a lambda. Note: it includes both type and value arguments!ghcInline Specificationghc Inside LambdaghcOccurs inside a non-linear lambda Substituting a redex for this occurrence is dangerous because it might duplicate work.ghcAn integer or infinityghcInteresting ContextghcFunction: is applied Data value: scrutinised by a case with at least one non-DEFAULT branchghcThe number of arguments that a join point takes. Unlike the arity of a function, this is a purely syntactic property and is fixed when the join point is created (or converted from a value). Both type and value arguments are counted.ghc!identifier Occurrence InformationghcThis identifier breaks a loop of mutually recursive functions. The field marks whether it is only a loop breaker due to a reference in a ruleghcMarks unused variables. Sometimes useful for lambda and case-bound variables.ghc2There are many occurrences, or unknown occurrencesghc3Occurs exactly once (per branch), not inside a ruleghcIf the Id is a lambda-bound variable then it may have lambda-bound variable info. Sometimes we know whether the lambda binding this variable is a "one-shot" lambda; that is, whether it is applied at most once.This information may be useful in optimisation, as computations may safely be floated inside such a lambda without risk of duplicating work.+See also Note [OneShotInfo overview] above.ghcNo informationghc#The lambda is applied at most once.ghcThe semantics allowed for overlapping instances for a particular instance. See Note [Safe Haskell isSafeOverlap] (in GHC.Core.InstEnv) for a explanation of the  field. :  '{-# OVERLAPPABLE'" or '{-# OVERLAPPING'" or '{-# OVERLAPS'" or '{-# INCOHERENT',  `#-}`,ghcBehave like Overlappable and Overlapping, and in addition pick an arbitrary one if there are multiple matching candidates, and don't worry about later instantiationExample: constraint (Foo [b]) instance {-# INCOHERENT -} Foo [Int] instance Foo [a] Without the Incoherent flag, we'd complain that instantiating b would change which instance was chosen. See also note [Incoherent instances] in GHC.Core.InstEnvghc'This instance must not overlap another - instance. However, it may be overlapped by  instances, and it may overlap  instances.ghcSilently ignore this instance if you find a more specific one that matches the constraint you are trying to resolveExample: constraint (Foo [Int]) instance Foo [Int] instance {-# OVERLAPPABLE #-} Foo [a]Since the second instance has the Overlappable flag, the first instance will be chosen (otherwise its ambiguous which to choose)ghcSilently ignore any more general instances that may be used to solve the constraint.Example: constraint (Foo [Int]) instance {-# OVERLAPPING #-} Foo [Int] instance Foo [a]Since the first instance has the Overlapping flag, the second---more general---instance will be ignored (otherwise it is ambiguous which to choose)ghcEquivalent to having both  and  flags.ghc Phase Numberghc2A general-purpose pretty-printing precedence type.ghcIs a TyCon a promoted data constructor or just a normal type constructor?ghcRecursivity FlagghcRepresentation ArityThe number of represented arguments that can be applied to a value before it does "real work". So: fib 100 has representation arity 0 x -> fib x has representation arity 1 (# x, y #) -> fib (x + y) has representation arity 2ghcRule Match Informationghc = $(f x y)ghc =* f x y, i.e. a naked top level expressionghcFlag to see whether we're type-checking terms or kind-checking typesghcIf any occurrence of an identifier is inside a lambda, then the occurrence info of that identifier marks it as occurring inside a lambdaghcIf there is any  interesting identifier occurrence, then the aggregated occurrence info of that identifier is considered interesting.ghcAdd two sghc Multiply two sghc#The pretty printing function to useghcThe things to be pretty printedghcAlternative (one-based)ghcArityghc where the alternative havs been pretty printed and finally packed into a paragraph.w Safe-Inferred 'f!ghcThis function strips off the top layer only of a type synonym application (if any) its underlying representation type. Returns K? if there is nothing to look through. This function considers  Constraint to be a synonym of Type.By being non-recursive and inlined, this case analysis gets efficiently joined onto the case analysis that the caller is already doing!ghcThis version considers Constraint to be the same as *. Returns True if the argument is equivalent to Type/Constraint and False otherwise. See Note [Kind Constraint and kind Type]!ghcIs this the type  Multiplicity?!ghcIs this the type ;?!ghc&Applies a type to another, as in e.g. k a!ghcMake a >. The Coercion must be nominal. Checks the Coercion for reflexivity, dropping it if it's reflexive. See Note [Respecting definitional equality] in GHC.Core.TyCo.Rep!ghcA key function: builds a > or > as appropriate to its arguments. Applies its arguments to the constructor from left to right.!ghcCreate the plain type constructor type which has been applied to no type arguments at all.!ghcGiven a  = and a list of argument types, partition the arguments into: " or " (i.e., invisible) arguments and" (i.e., visible) arguments!ghcAttempts to tease a type apart into a type constructor and the application of a number of arguments to that constructor!ghcGiven a  RuntimeRep , applies TYPE to it. See Note [TYPE and RuntimeRep] in GHC.Builtin.Types.Prim.!ghcGives the typechecker view of a type. This unwraps synonyms but leaves  Constraint alone. c.f. !, which turns  Constraint into ! . Returns K> if no unwrapping happens. See also Note [coreView vs tcView]!ghc The same as fst . splitTyConAppFghcGiven a !+ and a list of argument types to which the !5 is applied, determine each argument's visibility (", ", or ").(Most of the time, the arguments will be ", but not always. Consider f :: forall a. a -> Type. In  f Type Bool, the first argument (Type) is " and the second argument (Bool) is "?. It is precisely this sort of higher-rank situation in which F comes in handy, since  f Type Bool$ would be represented in Core using >s. (See also #15792).Fghc)Extract a relevant type, if there is one.FghcDoes this classify a type allowed to have values? Responds True to things like *, #, TYPE Lifted, TYPE v, Constraint.$True of any sub-kind of OpenTypeKindFghcGet the type on the LHS of a coercion induced by a type/data family instance.FghcDrops all ForAllTysFghc+Drops prefix of RuntimeRep constructors in >s. Useful for e.g. dropping 'LiftedRep arguments of unboxed tuple TyCon applications:dropRuntimeRepArgs [ 'LiftedRep, 'IntRep , String, Int# ] == [String, Int#]Fghc5Type equality on source types. Does not look through newtypes or !s, but it does look through type synonyms. This first checks that the kinds of the types are equal and then checks whether the types are equal, ignoring casts and coercions. (The kind check is a recursive call, but since all kinds have type Type, there is no need to check the types of kinds.) See also Note [Non-trivial definitional equality] in GHC.Core.TyCo.Rep.Fghc7Compare types with respect to a (presumably) non-empty ).FghcType equality on lists of types, looking through type synonyms but not newtypes.FghcExpand out all type synonyms. Actually, it'd suffice to expand out just the ones that discard type variables (e.g. type Funny a = Int) But we don't know which those are currently, so we just expand all.F only expands out type synonyms mentioned in the type, not in the kinds of any TyCon or TyVar mentioned in the type.Keep this synchronized with synonymTyConsOfTypeFghcGiven a  . and a list of argument types, filter out any " arguments.FghcGiven a   and a list of argument types, filter out any invisible (i.e., " or " ) arguments.Fghc Just like F/ but for a single argument Try not to iterate !, because it's inefficient to substitute one variable at a time; instead use 'piResultTys"Extract the function argument type and panic if that is not possibleFghcExtract the function result type and panic if that is not possibleFghcIf the type is a tyvar, possibly under a cast, returns it, along with the coercion. Thus, the co is :: kind tv ~N kind tyFghcIs this a numeric literal. We also look through type synonyms.FghcIs this a function or forall?Fghc1Returns true of types that are opaque to Haskell.Fghc3Is this a type of kind RuntimeRep? (e.g. LiftedRep)FghcIs a tyvar of type ;?Fghc=Is this a symbol literal. We also look through type synonyms.FghcComputes whether an argument (or let right hand side) should be computed strictly or lazily, based only on its type. Currently, it's just F%. Panics on levity-polymorphic types.FghcReturns True if a type is levity polymorphic. Should be the same as (isKindLevPoly . typeKind) but much faster. Precondition: The type has kind (TYPE blah)FghcSee Type#type_classification for what an unlifted type is. Panics on levity polymorphic types; See F for a more approximate predicate that behaves better in the presence of levity polymorphism.Fghc9Returns True if the kind classifies unlifted types (like 'Int#') and False otherwise. Note that this returns False for levity-polymorphic kinds, which may be specialized to a kind that classifies unlifted types.FghcDetermine whether a type could be the type of a join point of given total arity, according to the polymorphism rule. A join point cannot be polymorphic in its return type, since given join j a b x y z = e1 in e2, the types of e1 and e2 must be the same, and a and b are not in scope for e2. (See Note [The polymorphism rule of join points] in GHC.Core.) Returns False also if the type simply doesn't have enough arguments.Note that we need to know how many arguments (type *and* value) the putative join point takes; for instance, if j :: forall a. a -> Int then j could be a binary join point returning an Int, but it could *not* be a unary join point returning a -> Int.4TODO: See Note [Excess polymorphism and join points]FghcExtract the RuntimeRep classifier of a type from its kind. For example, kindRep * = LiftedRep; Panics if this is not possible. Treats * and Constraint as the sameFghcGiven a kind (TYPE rr), extract its RuntimeRep classifier rr. For example,  kindRep_maybe * = Just LiftedRep Returns K if the kind is not of form (TYPE rr) Treats * and Constraint as the sameFghcScale a payload by OneFghcReturns:J if the type is  guaranteed lifted orM if it is unlifted, OR we aren't sure (e.g. in a levity-polymorphic case)FghcMake an anonymous binderFghcGiven a family instance TyCon and its arg types, return the corresponding family type. E.g: 1data family T a data instance T (Maybe b) = MkT b%Where the instance tycon is :RTL, so: +mkFamilyTyConApp :RTL Int = T (Maybe Int)FghcLike F, but tv should be a tyvarFghcLike F#, but tvs should be a list of tyvarFghcLike !,, but assumes the variable is dependent and ", a common caseFghcLike >/, but assumes all variables are dependent and ", a common caseFghc Make a dependent forall over an " variableFghcLike >/, but assumes all variables are dependent and ", a common caseFghcGiven a list of type-level vars and the free vars of a result kind, makes TyCoBinders, preferring anonymous binders if the variable is, in fact, not dependent. e.g. mkTyConBindersPreferAnon  k->k(k:*),(b:k),(c:k)- We want (k:*) Named, (b:k) Anon, (c:k) AnonAll non-coercion binders are visible.FghcLike mkForAllTys, but assumes all variables are dependent and visibleFghc Unwrap one layer of newtype on a type constructor and its arguments, using an eta-reduced version of the newtype2 if possible. This requires tys to have at least newTyConInstArity tycon elements.Fghc Compare two  s. NB: This should never see  Constraint (as recognized by Kind.isConstraintKindCon) which is considered a synonym for !7 in Core. See Note [Kind Constraint and kind Type] in  GHC.Core.Type*. See Note [nonDetCmpType nondeterminism]FghcGiven a list of things paired with their visibilities, partition the things into (invisible things, visible things).Fghc(piResultTys f_ty [ty1, .., tyn]) gives the type of (f ty1 .. tyn) where f :: f_ty F" is interesting because: 1. f_ty may have more for-alls than there are args 2. Less obviously, it may have fewer for-alls For case 2. think of: piResultTys (forall a.a) [forall b.b, Int] This really can happen, but only (I think) in situations involving undefined. For example: undefined :: forall a. a Term: undefined (forall b. b->b) Int This term should have type (Int -> Int), but notice that there are more type args than foralls in s type.Fghc=Render a type corresponding to a user type error into a SDoc.Fghc2Attempts to obtain the type variable underlying a !, without any expansionFghcDoes the AppTy split as in F7, but assumes that any Core view stuff is already doneFghcLike F(, but doesn't look through type synonymsFghcLike !, but doesn't look through synonyms. This assumes the synonyms have already been dealt with.FghcLooking past all pi-types, is the end result potentially levity polymorphic? Example: True for (forall r (a :: TYPE r). String -> a) Example: False for (forall r1 r2 (a :: TYPE r1) (b :: TYPE r2). a -> b -> Type)Fghc1Attempts to take a type application apart, as in F%, and panics if this is not possibleFghcAttempt to take a type application apart, whether it is a function, type constructor, or plain type application. Note that type family applications are NEVER unsaturated by this!FghcRecursively splits a type as far as is possible, leaving a residual type being applied to and the type arguments applied to it. Never fails, even if that means returning an empty list of type applications.FghcLike G0, but only returns Just if it is a covar binder.FghcLike G, but only splits >s with " type variable binders. Furthermore, each returned tyvar is annotated with its .FghcLike G, but only splits >s with " type variable binders. Furthermore, each returned tyvar is annotated with ().Fghc t)GghcLike G, but doesn't look through synonyms. This assumes the synonyms have already been dealt with.Moreover, for a FunTy, it only succeeds if the argument types have enough info to extract the runtime-rep arguments that the funTyCon requires. This will usually be true; but may be temporarily false during canonicalization: see Note [Decomposing FunTy] in GHC.Tc.Solver.Canonical and Note [The Purely Kinded Type Invariant (PKTI)] in GHC.Tc.Gen.HsType, Wrinkle around FunTyGghcSplit a type constructor application into its type constructor and applied types. Note that this may fail in the case of a ># with an argument of unknown kind > (e.g. FunTy (a :: k) Int. since the kind of a isn't of the form TYPE rep). Consequently, you may need to zonk your type before using this function.This does *not* split types headed with (=>), as that's not a TyCon in the type-checker.If you only need the  , consider using tcTyConAppTyCon_maybe.Gghc The same as snd . splitTyConAppGghcDoes a   (that is applied to some number of arguments) need to be ascribed with an explicit kind signature to resolve ambiguity if rendered as a source-syntax type? (See Note [When does a tycon application need an explicit kind signature?]; for a full explanation of what this function checks for.)Gghc k tyConArgFlags T [forall m. m -> m -> m, S, R, Q]After substituting, we get T (forall m. m -> m -> m) :: (forall m. m -> m -> m) -> forall n. n -> n -> n'Thus, the first argument is invisible, S is visible, R is invisible again, and Q is visible.GghcAll type constructors occurring in the type; looking through type synonyms, but not newtypes. When it finds a Class, it returns the class TyCon.Gghc8Scale a payload by Many; used for type arguments in coreGghcScale a payload by ManyGghcIs this type a custom user error? If so, give us the kind and the error message.GghcThis describes how a "map" operation over a type/coercion should behaveGghc>What to do with coercion holes. See Note [Coercion holes] in GHC.Core.TyCo.Rep.Gghc.The returned env is used in the extended scopeGghcThis is used only for TcTyCons a) To zonk TcTyCons b) To turn TcTyCons into TyCons. See Note [Type checking recursive type and class declarations] in  GHC.Tc.TyClghc!An ordering relation between two !s (known below as t1 :: k1 and t2 :: k2)ghc t1 < t2ghc t1 > t2ghct1 ~ t2> and there are no casts in either, therefore we can conclude k1 ~ k2ghct1 ~ t2 yet one of the types contains a cast so they may differ in kind.ghcexpandSynTyConApp_maybe tc tys! expands the RHS of type synonym tc instantiated at arguments tys , or returns K if tc is not a synonym.ghc'Splits the longest initial sequence of >s that satisfy  argf_pred', returning the binders transformed by  argf_predghc A helper for 3 to avoid inlining this cold path into call-sites.ghc Iterates ! until there is no more to synonym to expand. See Note [Inlining coreView].ghc&An INLINE helper for function such as F below.isTyConKeyApp_maybe key ty returns Just tys iff the type  ty = T tys, where T's unique = keyghc`isBoxedRuntimeRep_maybe (rep :: RuntimeRep)` returns `Just lev` if rep% expands to `Boxed lev` and returns K otherwise.Types with this runtime rep are represented by pointers on the GC'd heap.ghc&An INLINE helper for function such as F below.ghcLike G, but split only for tyvars. This always succeeds, even if it returns only an empty list. Note that the result type returned may have free variables that were bound by a forall.ghcGiven a function kind and a list of argument types (where each argument's kind aligns with the corresponding position in the argument kind), determine each argument's visibility (", ", or ").ghcLike F, but considers  Constraint to be distinct from !8. For a version that treats them as the same type, see F.Fghcresult kindFghcbindersghcfree variables of resultGghcShould specified binders count towards injective positions in the kind of the TyCon? (If you're using visible kind applications, then you want True here.ghcThe number of args the   is applied to.ghcDoes  T t_1 ... t_n need a kind signature? (Where n is the number of arguments)ghcthe arity of the synonymghc"the variables bound by the synonymghcthe RHS of the synonymghc2the type arguments the synonym is instantiated at."""""""""!!!!!!!!!!!!!!!!!!!!!!!!!!!"""""""""""""""":>>>>>>>>>>>>>>>>>>>>>>>>>>>>????????????????????????????????????????????????????????????????@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@DFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG!"""""""""">!!"!""!!>>>FFFF""!FFFFFFG>>>>>>>>GGGFF!!!!GGGG!GGGGFG!>>FFFFFFFGFFFGFGFGGGF>>!FFFFFFFFFFFF!FFF!FFGFFGGGFFF!FGFGGGGGGGFF>>>>>>>>F""""""FF""""GGGF"">>>GD!FF!FFFFFFFFFFGF!FFFFFFFFFFFFFFFFFFF!FFFF!FGFGFFFFFFFF!GGFFGGGGG!!????????????GGF>F??????FFFFFFFFFFF!!G@@@????@?@???@?????????????????@@?@@@@@@@@@@@@@@@??@@@@@@@??????????????????:FF Safe-Inferred(ghc5Mark the variable as not free by putting it in scope.(ghc%Mark many free variables as not free.(ghcReturn no free variables.(ghc#Filter a free variable computation.(ghcRun a free variable computation, returning a deterministic set of free variables. Note that this is just a wrapper around the version that returns a deterministic list. If you need a list you should use (.(ghcRun a free variable computation, returning a list of distinct free variables in deterministic order.(ghcRun a free variable computation, returning a non-deterministic set of free variables. Don't use if the set will be later converted to a list and the order of that list will impact the generated code.(ghcMap a free variable computation over a list and union the results.(ghcAdd multiple variables - when free, to the returned free variables. Ignores duplicates and respects the filtering function.(ghc%Union two free variable computations.(ghc&Union many free variable computations.(ghcAdd a variable - when free, to the returned free variables. Ignores duplicates and respects the filtering function.(ghc.Predicate on possible free variables: returns True! iff the variable is interestingghcRun a free variable computation, returning a list of distinct free variables in deterministic order and a non-deterministic set containing those variables.((((((((((((((((((((((((((((m Safe-Inferred7"  o Safe-Inferredyghc7Lookup key, fail gracefully using Nothing if not found.ghc4Calculate the set difference of two lists. This is O((m + n) log n), where we subtract a list of n elements from a list of m elements.3Extremely short cases are handled specially: When m or n is 0, this takes O(1) time. When m is 1, it takes O(n) time.ghc0Assumes that the arguments contain no duplicatesghc9A finite mapping based on equality and association lists.  g Safe-Inferred ghc!If debug output is on, show some 7 on the screen along with a call stack when available.ghc!If debug output is on, show some  on the screenghcpprTraceException desc x action< runs action, printing a message if it throws an exception.ghcpprTraceIt desc x is equivalent to pprTrace desc (ppr x) xghc!If debug output is on, show some  on the screenghcLike   but specialized with   and  -. This is typically used to output C-- code.ghc3Show a SDoc as a String with the default user styleghc4Allows caller to specify the PrintUnqualified to useghcJust warn about an assertion failure, recording the given file and line number. Should typically be accessed with the WARN macrosghcpprTraceWith desc f x is equivalent to pprTrace desc (f x) x. This allows you to print details from the returned value as well as from ambient variables.2 Safe-Inferred&Sghc#Pretty-print a UnitId for the user.Cabal packages may contain several components (programs, libraries, etc.). As far as GHC is concerned, installed package components ("units") are identified by an opaque IndefUnitId string provided by Cabal. As the string contains a hash, we don't want to display it to users so GHC queries the database to retrieve some infos about the original source package (name, version, component name).?Instead we want to display: packagename-version[:componentname]Component name is only displayed if it isn't the default library,To do this we need to query a unit database.ghc9Print unit-ids with UnitInfo found in the given UnitStateghcGiven a wired-in , "unwire" it into the 2 that it was recorded as in the package database.ghc Unit databaseSghcTakes a list of UnitIds (and their "parent" dependency, used for error messages), and returns the list with dependencies included, in reverse dependency order (a units appears before those it depends on).SghcSimilar to closeUnitDeps but takes a list of already loaded units as an additional argument.SghcGiven a fully instantiated , improve it into a + if we can find it in the package database.SghcRead the unit database files, and sets up various internal tables of unit information, according to the unit-related flags on the command-line (-package,  -hide-package etc.)S6 can be called again subsequently after updating the Q field of the  , and it will update the  unitState in  .Sghc Injects an  to  (see also S.SghcCheck the database to see if we already have an installed unit that corresponds to the given . Return a  which either wraps the 4 unchanged or references a matching installed unit.+See Note [VirtUnit to RealUnit improvement]SghcGet a list of entries from the unit database. NB: be careful with this function, although all units in this map are "visible", this does not imply that the exposed-modules of the unit are available (they may have been thinned or renamed).SghcTakes a , and if the module is in any package returns list of modules which take that name.SghcThe package which the module **appears** to come from, this could be the one which reexports the module from it's original package. This function is currently only used for -Wunused-packagesSghc>Find the unit we know about with the given package name (e.g. foo), if any (NB: there might be a locally defined unit name which overrides this)Sghc7Find the unit we know about with the given unit, if anySghc6A more specialized interface, which doesn't require a . (so it can be used while we're initializing  )Parameters: * a boolean specifying whether or not to look for on-the-fly renamed interfaces * a T * a SSghc:Find the unit we know about with the given unit id, if anySghc:Find the unit we know about with the given unit id, if anySghc4Show the mapping of modules to where they come from.Sghc Show (very verbose) package infoSghcShow simplified unit info.The idea is to only print package id, and any information that might be different from the package databases (exposure, trust)SghcSubstitutes holes in a 0. NOT suitable for being called directly on a  nameModule6, see Note [Representation of module/name variable].  p[A=]:B maps to  p[A=q():A]:B with A=q():A; similarly,  maps to q():A.SghcLike S, but requires only ClosureUnitInfoMap so it can be used by GHC.Unit.State.SghcSubstitutes holes in a , suitable for renaming when an include occurs; see Note [Representation of module/name variable].p[A=] maps to p[A=] with A=.Sghc(Like 'renameHoleUnit, but requires only ClosureUnitInfoMap so it can be used by GHC.Unit.State.SghcReturn this list of requirement interfaces that need to be merged to form mod_name, or [] if this is not a requirement.Sghc-Return the path of a package database from a R . Return K when the user database filepath is expected but the latter doesn't exist.NB: This logic is reimplemented in Cabal, so if you change it, make sure you update Cabal. (Or, better yet, dump it in the compiler info so Cabal can use the info.)Sghc9Search for units with a given package ID (e.g. "foo-0.1")SghcLooks up the given unit in the unit state, panicing if it is not foundSghcLooks up the given unit id in the unit state, panicing if it is not foundSghc!The result of performing a lookupSghc-Found the module uniquely, nothing else to doSghcNo modules found, but there were some hidden ones with an exact name match. First is due to package hidden, second is due to module being hiddenSghc,Multiple modules with the same name in scopeSghc6Nothing found, here are some suggested different namesSghcNo modules found, but there were some unusable ones with an exact name matchSghcGiven a module name, there may be multiple ways it came into scope, possibly simultaneously. This data type tracks all the possible ways it could have come into scope. Warning: don't use the record functions, they're partial!SghcModule is hidden, and thus never will be available for import. (But maybe the user didn't realize), so we'll still keep track of these modules.)Sghc7Module is public, and could have come from some places.Sghc6Module is unavailable because the package is unusable.SghcIs the module available from a reexport of an exposed package? There could be multiple.Sghc,B=r[C=]:B]*, then the interfaces to merge for A are  p[A=]:A, q[A=,B=r[C=]:B]:A and  r[C=]:C.?There's an entry in this map for each hole in our home library.Tghc A mapping of  to >. This list is adjusted so that only valid units are here. 5 reflects what was stored *on disk*, except for the trusted flag, which is adjusted at runtime. (In particular, some units in this map may have the exposed flag be J.)TghcA mapping from wired in unit ids to unit keys from the database.Tghc7A mapping from database unit keys to wired in unit ids.Tghc"The reason why a unit is unusable.TghcThis unit transitively depends on a unit that was never present in any of the provided databases.TghcThis unit transitively depends on a unit involved in a cycle. Note that the list of  reports the direct dependencies of this unit that (transitively) depended on the cycle, and not the actual cycle itself (which we report separately at high verbosity.)Tghc;This unit transitively depends on a unit which was ignored.TghcWe ignored it explicitly using -ignore-package.TghcThis unit transitively depends on a unit which was shadowed by an ABI-incompatible unit.ghc< records the various aspects of visibility of a particular .ghc Map from & to a set of module providers (i.e. a  and its S).NB: the set is in fact a 'Map Module ModuleOrigin', probably to keep only one origin for a given ghc Rename a ( according to some module instantiation.ghc'A reverse dependency index, mapping an  to the  s which have a dependency on it.ghcUnit configurationghcPlatform arch and OSghc Ways to useghcAllow virtual units ^ Do we allow the use of virtual units instantiated on-the-fly (see Note [About units] in GHC.Unit). This should only be true when we are type-checking an indefinite unit (not producing any code).ghcName of the compiler (e.g. GHC, GHCJS). Used to fetch environment variables such as "GHC[JS]_PACKAGE_PATH".ghcPath to global DBghc%Main GHC dir: contains settings, etc.ghc$User DB name (e.g. "package.conf.d")ghc,Units to link automatically (e.g. base, rts)ghcDistrust all units by defaultghcHide all units by defaultghc!Hide all plugins units by defaultghcCache of databases to use, in the order they were specified on the command line (later databases shadow earlier ones). If Nothing, databases will be found using .ghcUnit databases flagsghc Exposed unitsghc Ignored unitsghc Trusted unitsghcPlugins exposed unitsghcFor each unit, a mapping from uid -> i indicates that this unit was brought into GHC by the ith  -package-db flag on the command line. We use this mapping to make sure we prefer units that were defined later on the command line, if there is an ambiguity.ghc-Any custom renamings that should bring extra s into scope.ghc%The package name associated with the 4. This is used to implement legacy behavior where -package foo-0.1& implicitly hides any packages named fooghcThe signatures which are contributed to the requirements context from this unit ID.ghcWhether or not this unit was explicitly brought into scope, as opposed to implicitly via the exposed' fields in the package database (when -hide-all-packages is not passed.)ghc map from  to a .ghcAdd a UnitId and those it depends on (recursively) to the given list of UnitIds if they are not already in it. Return a list in reverse dependency order (a unit appears before those it depends on).The UnitId is looked up in the given UnitInfoMap (to find its dependencies). It it's not found, the optional parent unit is used to return a more precise error message ("dependency of  PARENT").ghcGiven a fully instantiated , improve it into a + if we can find it in the package database.ghc+Smart constructor for a module which is in exposed-modules. Takes as an argument whether or not the defining package is exposed.ghc+Smart constructor for a module which is in reexported-modules. Takes as an argument whether or not the reexporting package is exposed, and also its .ghcSmart constructor for a module which was bound by a package flag.ghcIs the name from the import actually visible? (i.e. does it cause ambiguity, or is it only relevant when we're making suggestions?)ghcAre there actually no providers for this module? This will never occur except when we're filtering based on package imports.ghcCreate a Map UnitId UnitInfoFor each instantiated unit, we add two map keys: * the real unit id * the virtual unit id made from its instantiationWe do the same thing for fully indefinite units (which are "instantiated" with module holes).ghcLike , but doesn't return a list of unmatched packages. Furthermore, any packages it returns are *renamed* if the UnitArg# has a renaming associated with it.ghcThis sorts a list of packages, putting "preferred" packages first. See # for the semantics of "preference".ghcReturns R if pkg should be preferred over pkg' when picking which should be "active". Here is the order of preference:  First, prefer the latest versionIf the versions are the same, prefer the package that came in the latest package database.Pursuant to #12518, we could change this policy to, for example, remove the version preference, meaning that we would always prefer the units in later unit database.ghc8Compute the reverse dependency index of a unit database.ghcGiven a list of s to remove, a database, and a reverse dependency index (as computed by ), remove those units, plus any units which depend on them. Returns the pruned database, as well as a list of s that was removed.ghcGiven a  from some T, return all entries in depends; which correspond to units that do not exist in the index.ghcGiven a  from some T return all entries in  which correspond to units that do not exist, OR have mismatching ABIs.ghcGiven a list of databases, merge them together, where units with the same unit id in later databases override earlier ones. This does NOT check if the resulting database makes sense (that's done by ).ghcValidates a database, removing unusable units from it (this includes removing units that the user has explicitly ignored.) Our general strategy: /Remove all broken units (dangling dependencies) Remove all units that are cyclicApply ignore flags6Remove all units which have deps with mismatching ABIsghc1Makes the mapping from ModuleName to package infoghcMake a % covering a set of unusable packages.ghc.Add a list of key/value pairs to a nested map. The outer map is processed with  to prevent memory leaks when reloading modules in GHCi (see #4029). This ensures that each value is forced before installing into the map.ghc!Create a singleton module mappingghc Home unit idghcHome unit instance ofghcHome unit instantiationsghc-SDocContext used to render exception messagesghc Trace printerghc-SDocContext used to render exception messages_a`TTTTTTTTTTTTTTTSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSTTTTTTTTTTTTTTTTTTTTTTTSTTTTTTTSSSSSSTSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSTTTTTTSSSSSSSSSSSSSSSS Safe-Inferred]#RghcDefault action for  dumpAction hookSghcLike S but appends an extra newline.SghcThe boolean arguments let's the pretty printer know if it can optimize indent by writing ascii ' ' characters without going through decoding.SghcDefault action for  traceAction hookSghcA wrapper around  dumpAction. First check whether the dump flag is set Do nothing if it is unsetSghcA wrapper around S. First check whether the dump flag is set Do nothing if it is unsetUnlike S, has a printer argumentSghcMake the logger thread-safeSghcPop a dump hookSghcPop a log hookSghcPop a trace hookSghcPush a dump hookSghcPush a log hookSghcPush a trace hookSghcDump somethingSghc Log somethingSghcTrace somethingSghc9Ensure that a dump file is created even if it stays emptySghc#Run an action with the handle of a , if we are outputting to a file, otherwise K.SghcFormat of a dumpDump formats are loosely defined: dumps may contain various additional headers and annotations and they may be partial. S2 is mainly a hint (e.g. for syntax highlighters).Sghc Assembly codeSghcByteCodeSghc C code/headerSghcCmmSghcCoreSghcHaskellSghc LLVM bytecodeSghcSTGSghcUnstructured dumpghcLog hooks stackghcDump hooks stackghcTrace hooks stackghcChoose where to put a dump file based on DynFlags and DumpFlagghcThis is a helper for S; to ensure that it's not duplicated despite the fact that S has an INLINE.(RRSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS(SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSRSSRSSSSSS Safe-Inferred7gOghcCreates a new O out of a list of .Oghc5Make an unannotated error message with location info.Oghc;Make a possibly annotated error message with location info.Oghc!A long (multi-line) error messageOghc!A long (multi-line) error messageOghc A short (one-line) error messageOghc;Variant that doesn't care about qualified/unqualified namesOghc;Variant that doesn't care about qualified/unqualified namesOghc A short (one-line) error messageOghcPartitions the O and returns a tuple which first element are the warnings, and the second the errors.Oghc+Joins two collections of messages together.OghcA O is isomorphic to a '[SDoc]' but it carries the invariant that the input '[SDoc]' needs to be rendered  decorated into its final form, where the typical case would be adding bullets between each elements of the list. The type of decoration depends on the formatting function used, but in practice GHC uses the formatBulleted.OghcA collection of messages emitted by GHC during error reporting. A diagnostic message is typically a warning or an error. See Note [Messages].OghcAn envelope for GHC's facts about a running program, parameterised over the domain-specific5 (i.e. parsing, typecheck-renaming, etc) diagnostics.%To say things differently, GHC emits  diagnostics= about the running program, each of which is wrapped into a O that carries specific information like where the error happened, its severity, etc. Finally, multiple Os are aggregated into O that are returned to the user.Oghc=The SrcSpan is used for sorting errors into line-number orderOghcA class for types (typically errors and warnings) which can be "rendered" into an opaque O7. For more information, see Note [Rendering Messages].OghcLog message intended for compiler developers No file/line/column stuffOghcSevWarning and SevError are used for warnings and errors o The message has a file/line/column heading, plus "warning:" or "error:", added by mkLocMessags o Output is intended for end usersOghcLog messages intended for end users. No file/line/column stuff.ghc Shows an O.Oghcoptional annotationghcseverityghclocationghcmessage1OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO1OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOi Safe-InferredlghcDebugging flagsghc#Dump the cfg used for block layout.ghcFinal STG (after stg2stg)ghcInitial STG (CoreToStg output)ghcSTG after unariseghc-Enumerates the simple on-or-off dynamic flagsghc)Use the cfg based block layout algorithm.ghc -fcompact-unwindghcdeprecated, no effect and behaviour is now default. Allowed switching of a special demand transformer for dictionary selectorsghc.Append dump output to files instead of stdout.ghc -fPICghc -pieghc -fPIEghcSuppress timestamps in dumpsghc+Layout based on last instruction per block.ghcUsed when outputting warnings: if a reason is given, it is displayed. If a warning isn't controlled by a flag, this is made explicit at the point of use.ghcWarning was made an error because of -Werror or -Werror=WarningFlagghc!Warning was enabled with the flags Safe-Inferred 7s ghccombining functionghc initial stateghcinputsghcfinal state, outputs ghccombining functionghc initial stateghcinputsghcfinal state, outputs# #  3 35 Safe-Inferred  ghc&Initialize the pretty-printing options ghc"Contains not only a collection of s but also a plethora of information relating to the compilation of a single file or GHC sessionOghcAppend to the list of includes a path that shall be included using `-I` when the C compiler is called. These paths override system search paths.OghcThese includes are not considered while fingerprinting the flags for iface | See note [Implicit include paths]OghcAppend to the list of includes a path that shall be included using `-iquote` when the C compiler is called. These paths only apply when quoted includes are used. e.g. #include "foo.h"OghcAll dynamic flags option strings without the deprecated ones. These are the user facing strings for enabling and disabling options.Oghc The normal  . Note that they are not suitable for use in this form and must be fully initialized by  first.OghcTest whether a  is setOghcSet a OghcUnset a OghcSome modules have dependencies on others through the DynFlags rather than textual importsOghcCompute the path of the dynamic object corresponding to an object file.OghcThese -f flags can all be reversed with  -fno-OghcThese -f flags can all be reversed with  -fno-OghcMake a list of flags for shell completion. Filter all available flags into two groups, for interactive GHC vs all other.OghcConcatenate and flatten the list of global and quoted includes returning just a flat list of paths.Oghc3Retrieve the options corresponding to a particular opt_* field in the correct orderOghcGets the verbosity flag for the current verbosity level. This is fed to other tools, so GHC-specific verbosity flags like  -ddump-most are not includedOghcTest whether a  is set Note that Q (i.e., dynamic objects built with `-dynamic-too`) always implicitly enables Opt_PIC, Opt_ExternalDynamicRefs, and disables Opt_SplitSections.OghcSet a OghcUnset a OghcInitialize the pretty-printing options using the default user styleOghcUsed by  to partially initialize a new   valuePghcThe language extensions implied by the various language variants. When updating this be sure to update the flag documentation in docs users_guideexts.Pghc1Resolve any internal inconsistencies in a set of  . Returns the consistent  6 as well as a list of warnings to report to the user.Pghc1Indicate whether we need to generate source notesPghcIs the -fpackage-trust mode onPghcLike P but does not allow the package flags (-package, -hide-package, -ignore-package, -hide-all-packages, -package-db). Used to parse flags set in a modules pragma.PghcParse dynamic flags from a list of command line arguments. Returns the parsed  =, the left-over arguments, and a list of warnings. Throws a  if errors occurred during parsing (such as unknown flags or missing arguments).PghcParses the dynamically set flags for GHC. This is the most general form of the dynamic flag parser that the other methods simply wrap. It allows saying which flags are valid flags and indicating if we are parsing arguments from the command line or from a file pragma.PghcAre we building with -fPIE or -fPIC enabled?Pghc/Pretty-print the difference between 2 DynFlags.For now only their general flags but it could be extended. Useful mostly for debugging.PghcAre all direct imports required to be safe for this Safe Haskell mode? Direct imports are when the code explicitly imports a modulePghc9Is Safe Haskell on in some way (including inference mode)PghcAre all implicit imports required to be safe for this Safe Haskell mode? Implicit imports are things in the prelude. e.g System.IO when print is used.Pghc(Test if Safe Imports are on in some formPghc.Is the Safe Haskell safe inference mode activePghc(Is the Safe Haskell safe language in usePghc,Indicate if cost-centre profiling is enabledPghc "unbuild" a   from a  . This shouldn't be needed in the vast majority of code. But GHCi questionably uses this to produce a default  1 from which to compute a flags diff for printing.PghcFind the smallest group in every hierarchy which a warning belongs to, excluding Weverything.PghcGet target profilePghcA list of unsafe flags under Safe Haskell. Tuple elements are: * name of the flag * function to get srcspan that enabled the flag * function to test if the flag is on * function to turn the flag offPghcA list of unsafe flags under Safe Haskell. Tuple elements are: * name of the flag * function to get srcspan that enabled the flag * function to test if the flag is on * function to turn the flag offPghc Sets the  , to be appropriate to the optimisation levelPghcShould we use `-XLinker -rpath` when linking or not? See Note [-fno-use-rpaths]PghcThe directory for this version of ghc in the user's app directory The appdir used to be in ~/.ghc but to respect the XDG specification we want to move it under $XDG_DATA_HOME/ However, old tooling (like cabal) might still write package environments to the old directory, so we prefer that if a subdirectory of ~/.ghc with the correct target and GHC version suffix exists. i.e. if ~.ghc$UNIQUE_SUBDIR exists we use that otherwise we use $XDG_DATA_HOME/$UNIQUE_SUBDIRUNIQUE_SUBDIR is typically a combination of the target platform and GHC versionPghc Find the R for a .PghcThese -W flags can all be reversed with  -Wno-PghcWarning groups.As all warnings are in the Weverything set, it is ignored when displaying to the user which group a warning is in.PghcWarning group hierarchies, where there is an explicit inclusion relation.Each inner list is a hierarchy of warning groups, ordered from smallest to largest, where each group is a superset of the one before it.Separating this from P allows for multiple hierarchies with no inherent relation to be defined.3The special-case Weverything group is not included.PghcTest whether a  is setPghcTest whether a  is set as fatalPghcSet a PghcMark a  as fatal (do not set the flag)PghcUnset a PghcMark a  as not fatalPghcThese -X blah$ flags can all be reversed with -XNo blahPghcTest whether a  is setPghcSet a PghcSet or unset a 7, unless it has been explicitly set or unset before.PghcUnset a PghcThe backend to use (if any).7Whenever you change the backend, also make sure to set Q to something sensible.  can be used to avoid generating any output, however, note that:If a program uses Template Haskell the typechecker may need to run code from an imported module. To facilitate this, code generation is enabled for modules imported by modules that use template haskell, using the default backend for the platform. See Note [-fno-code mode].PghcBinary literals (e.g. strings) whose size is above this threshold will be dumped in a binary file by the assembler code generator (0 to disable)Pghc/Temporary: CFG Edge weights for fast iterationsPghc4Align Cmm functions at this boundary or use default.Pghc%How much debug information to produceQghcThis is set by  or 'ghc.GHCi.UI.runStmt'$ based on where its output is going.Qghc Override the Q set by  or 'ghc.GHCi.UI.runStmt' . Set by -ddump-file-prefixQghcIndicate if we are now generating dynamic output because of -dynamic-too. This predicate is used to query the appropriate fields (outputFile/dynOutputFile, ways, etc.)QghcEnable RTS timing statistics?Qghc%Arg count for lambda floating See Qghcthe -ffrontend-opt flags given on the command line, in *reverse* order that they're specified on the command line.QghcThe heap size to set.Qghc8GHCi scripts specified by -ghci-script, in reverse orderQghcSimplification history sizeQghcTarget home unit-idQghcId of the unit to instantiateQghcModule instantiationsQghcPath to store the .mix filesQghcThe -ignore-package flags from the command line. In *reverse* order that they're specified on the command line.Qghc9Unique supply configuration for testing build determinismQghc+A prefix to report inlining decisions aboutQghcThreshold for LiberateCaseQghcLambda lift even when this turns a known call into an unknown call.QghcMaximum number of arguments after lambda lifting a non-recursive function.QghcMaximum number of arguments after lambda lifting a recursive function.QghcN.B. It's important that this field is lazy since we load the LLVM configuration lazily. See Note [LLVM Configuration] in  GHC.SysTools.Qghc*Limit the maximum number of errors to showQghc0Max size, in bytes, of inline array allocations.QghcOnly inline memcpy if it generates no more than this many pseudo (roughly: Cmm) instructions.QghcOnly inline memset if it generates no more than this many pseudo (roughly: Cmm) instructions.QghcSoft limit on the number of models the pattern match checker checks a pattern against. A safe guard against exponential blow-up.QghcMaximum number of refinement hole fits to show in typed hole error messagesQghcMaximum number of bindings from the type envt to show in type error messagesQghcMax simplifier iterationsQghcMaximum number of unmatched patterns to show in non-exhaustiveness warningsQghcMaximum number of hole fits to show in typed hole error messagesQghcOptimisation levelQghcThe  -package-db flags given on the command line, In *reverse* order that they're specified on the command line. This is intended to be applied with the list of "initial" package databases derived from GHC_PACKAGE_PATH; see  getUnitDbRefs.QghcFilepath to the package environment file (if overriding default)QghcThe -package and  -hide-package flags from the command-line. In *reverse* order that they're specified on the command line.QghcThe number of modules to compile in parallel in --make mode, where Nothing ==> compile as many in parallel as there are CPUs.QghcThe -plugin-package-id flags from command line. In *reverse* order that they're specified on the command line.Qghc-what kind of {-# SCC #-} to add automaticallyQghcTypechecker maximum stack depthQghcMaximum level of refinement for refinement hole fits in typed hole error messagesQghc/Reverse the order of error messages in GHC/GHCiQghcRun-time compiler informationQghc8Run-time linker information (what options we need, etc.)QghcSafe Haskell modeQghcNumber of simplifier phasesQghcMultiplier for simplifier ticksQghcNumber of iterations in the constraints solver Typically only 1 is neededQghc2Max number of specialisations for any one functionQghcMax number of specialisations for recursive types Not optional; otherwise ForceSpecConstr can diverge.QghcThreshold for SpecConstrQghc(Machine dependent flags (-m stuff)QghcAdditional demand analysisQghc&Target way flags from the command lineQghcThe -trust and  -distrust flags. In *reverse* order that they're specified on the command line.QghcUnfolding control See Note [Discounts and thresholds] in GHC.Core.UnfoldQghc,Verbosity level: see Note [Verbosity levels]Rghc&Don't try to build dynamic objects tooRghc5Currently generating dynamic objects (in the backend)Rghc5Won't try to generate dynamic objects for some reasonRghc*Will still try to generate dynamic objectsRghcExtra action to run when the flag is found Typically, emit a warning or errorRghcFlag in internal formRghc%In which ghc mode the flag has effectRghcFlag in string formRghc-What to do in the link step, if there is one.RghcLink object code into a binaryRghcLink objects into a dynamic lib (DLL on Windows, DSO on ELF platforms)RghcUse the in-memory dynamic linker (works for both bytecode and object code).RghcLink objects into a static libRghcDon't link at allRghcThe R tells us whether we're doing multi-module compilation (controlled via the GHC API) or one-shot (single-module) compilation. This makes a difference primarily to the GHC.Unit.Finder: in one-shot mode we look for interface files for imported modules, but in multi-module mode we look for source files in order to check whether they need to be recompiled.Rghc--make , GHCi, etc.Rghcghc -M, see GHC.Unit.Finder for why we need thisRghc  ghc -c Foo.hsRghc6Flags for manipulating the set of non-broken packages.Rghc -ignore-packageRghcUsed to differentiate the scope an include needs to apply to. We have to split the include paths to avoid accidentally forcing recursive includes since -I overrides the system search paths. See #14312.Rghc!See note [Implicit include paths]Rghc!See Note [LLVM Configuration] in  GHC.SysTools.RghcRepresents the renaming that may be associated with an exposed package, e.g. the rns part of -package "foo (rns)".Here are some example parsings of the package flags (where a string literal is punned to be a : -package foo is ModRenaming True []-package foo () is ModRenaming False []-package foo (A) is ModRenaming False [(A, A)]-package foo (A as B) is ModRenaming False [(A, B)]-package foo with (A as B) is ModRenaming True [(A, B)]Rghc%Bring all exposed modules into scope?Rghc Bring module m into scope under name n.RghcWe accept flags which make packages visible, but how they select the package varies; this data type reflects what selection criterion is used.Rghc-package, by  PackageNameRghc -package-id, by Rghc+Flags for manipulating packages visibility.Rghc-package,  -package-idRghc  -hide-packageRghcno SCC annotations addedRghc,top-level and nested functions are annotatedRghcannotate call-sitesRghc!exported functions annotated onlyRghc"top-level functions annotated onlyRghc%Flags for manipulating package trust.Rghc  -distrustRghc -trustghcThings you get with -WghcThings you get with -WallghcThings you get with -Weverything, i.e. *all* known warnings flagsghcThings you get with -Wcompat.This is intended to group together warnings that will be enabled by default at some point in the future, so that library authors eager to make their code future compatible to fix issues before they even generate warnings.ghc+Warnings enabled unless specified otherwiseghc(Set the Haskell language standard to useghcSet a 'Safe Haskell' flagghcCombine two Safe Haskell modes correctly. Used for dealing with multiple flags. This makes Safe Haskell very much a monoid but for now I prefer this as I don't want to export this functionality from the module but do want to export the type constructors.ghcCheck (and potentially disable) any extensions that aren't allowed in safe mode.The bool is to indicate if we are parsing command line flags (false means file pragma). This allows us to generate better warnings.ghc4All flags with possibility to filter deprecated onesghcThis is where we handle unrecognised warning flags. We only issue a warning if -Wunrecognised-warning-flags is set. See #11429 for context.ghcDefine a new flag.ghc!Define a new flag with an effect.ghc,Define a new deprecated flag with an effect.ghcDefine a new deprecated flag.ghcDefine a new deprecated flag with an effect where the deprecation message depends on the flag valueghcDefine a new deprecated flag where the deprecation message depends on the flag valueghcDefine a new deprecated flag where the deprecation message is shown depending on the flag valueghcDefine a new flag for GHCi.ghc*Define a new flag for GHCi with an effect.ghc.Define a new flag invisible to CLI completion.ghc=Define a new flag invisible to CLI completion with an effect.ghcHide a R from being displayed in --show-options.This is for example useful for flags that are obsolete, but should not (yet) be deprecated for compatibility reasons.ghcThese - flags can all be reversed with  -no-ghcThese -d flags can all be reversed with  -dno-ghcThese -f flags have to do with the typed-hole error message or the valid hole fits in that message. See Note [Valid hole fits include ...] in the GHC.Tc.Errors.Hole/ module. These flags can all be reversed with  -fno-ghcThese -X blah# flags cannot be reversed with -XNo blahghcThese -X blah# flags cannot be reversed with -XNo blah They are used to place hard requirements on what GHC Haskell language features can be used.ghcThese are the default settings for the display and sorting of valid hole fits in typed-hole error messages. See Note [Valid hole fits include ...] in the GHC.Tc.Errors.Hole module.Oghc  to retrieve the options fromghc%Relevant record accessor: one of the opt_* accessorsghc#Correctly ordered extracted optionsPghcUpdated  -, left-over arguments, and list of warnings.PghcUpdated  -, left-over arguments, and list of warnings.Pghcvalid flags to match againstghc(are the arguments from the command line?ghccurrent dynamic flagsghcarguments to parseghcTrue  = it should be turned onghcThe flag prefixghc!What to do when the flag is foundghc&Specification of this particular flag PP QQPPPPPPPPPPPPPPPPQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQRROOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRROPP OOOOOOOOPPPPPPPPPPPPPPPRRRRROPPOOPP PP QQPPPPPPPPPPPPPPPPQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQRRPOPPRRRRRRRRPPRRRRRRRRRRORRRRRRORRRRRRRRRRPRRRRRRRRRRRRRRRRROOPPPOPPPPOPPPPPPPPPPPPRRRRRRRRR PPPOOPPPPOOPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPOOOOOOOOPPPRPPOOOPPPOOOOOPPPPOPPPOPOOOOOOOORRRRRRRRPPPPPPPRRRRROOOO OV Safe-Inferredd\ Safe-Inferred$ ghcSafe Haskell information for ModIface Simply a wrapper around SafeHaskellMode to sepperate iface and flagsghcIs an import a safe import?ghcThe various Safe Haskell modesghc-fno-safe-haskell stateghcinferred unsafeghcdeclared and checkedghcinferred as safeghcdeclared and checkedghcdeclared and checked  e Safe-Inferred5^ghcUndo the name mangling described in Note [FieldLabel] to produce a Name that has the user-visible OccName (but the selector's unique). This should be used only when generating output, when we want to show the label, but may need to qualify it with a module prefix.ghcRecord selector OccNames are built from the underlying field name and the name of the first data constructor of the type, to support duplicate record field names. See Note [Why selector names include data constructors].ghcFlag to indicate whether the DuplicateRecordFields extension is enabled.ghc+Fields may be duplicated in a single moduleghc3Fields must be unique within a module (the default)ghc:Fields in an algebraic record type; see Note [FieldLabel].ghcWas DuplicateRecordFields- on in the defining module for this datatype?ghcWas FieldSelectors enabled in the defining module for this datatype? See Note [NoFieldSelectors] in GHC.Rename.EnvghcUser-visible label of the fieldghcRecord selector functionghc2A map from labels to all the auxiliary informationghcField labels are just represented as strings; they are not necessarily unique (even within a module)ghcFlag to indicate whether the FieldSelectors extension is enabled.ghc.Selector functions are available (the default)ghc$Selector functions are not availableghc We need the  Binary Name> constraint here even though there is an instance defined in GHC.Types.Name, because the we have a SOURCE import, so the instance is not in scope. And the instance cannot be added to Name.hs-boot because GHC.Utils.Binary itself depends on GHC.Types.Name.ghcSelector name mangling should be used if either DuplicateRecordFields or NoFieldSelectors is enabled, so that the OccName of the field can be used for something else. See Note [FieldLabel], and Note [NoFieldSelectors] in GHC.Rename.Env. Safe-Inferred ghcExpand occurrences of the $tooldir interpolation in a string on Windows, leave the string untouched otherwise.ghc.Returns a Unix-format path pointing to TopDir.ghctopdirghc,Maybe TopDir path (without the '-B' prefix).ghcTopDir (in Unix format  separated)jNone8ghc Add a wayghc)Check if a combination of ways is allowedghc.Filter ways that have an impact on compilationghcTest if a ways is enabledghcHost "full" ways (i.e. ways that have an impact on the compilation, not RTS only ways).These ways must be used when compiling codes targeting the internal interpreter.ghc/Consult the RTS to find whether it is debugged.ghcConsult the RTS to find whether GHC itself has been built with dynamic linking. This can't be statically known at compile-time, because we build both the static and dynamic versions together with -dynamic-too.ghcConsult the RTS to find whether it has been built with profiling enabled.ghc/Consult the RTS to find whether it is threaded.ghc.Consult the RTS to find whether it is tracing.ghc Host ways.ghcFilter RTS-only ways (ways that don't have an impact on compilation)ghc*Turn these flags on when enabling this wayghc=Pass these options to the preprocessor when enabling this wayghc;Pass these options to the C compiler when enabling this wayghc3Pass these options to linker when enabling this wayghcReturn true for ways that only impact the RTS, not the generated codeghc$Unique build-tag associated to a wayghc+Turn these flags off when enabling this wayghc-Unique build-tag associated to a list of waysRTS only ways are filtered out because they have no impact on the build.ghc'Unique tag associated to a list of waysghcA way4Don't change the constructor order as it us used by  to create a unique tag (e.g. thr_debug_p) which is expected by other tools (e.g. Cabal).ghc,for GHC API clients building custom variantsghc1Debugging, enable trace messages and extra checksghcDynamic linkingghc:Profiling, enable cost-centre stacks and profiling reportsghc'(RTS only) Multithreaded runtime systemghc)(RTS only) enable event logging (tracing)l Safe-Inferredbghc Unique build tag for the profileghcGet platform constantsghcIs profiling enabledghcWord size in bytesghcA platform profile fully describes the kind of objects that are generated for a platform.  doesn't fully describe the ABI of an object. Compiler ways (profiling, debug, dynamic) also modify the ABI.ghcPlatformghcWaysh Safe-InferredghcWhen we are given files (modified by -x arguments) we need to determine if they are Haskellish or not to figure out how we should try to compile it. The rules are: If no -x flag was specified, we check to see if the file looks like a module name, has no extension, or has a Haskell source extension.If an -x flag was specified, we just make sure the specified suffix is a Haskell one.ghcForeign language of the phase if the phase deals with a foreign code++[ Safe-InferredAghc .hs-boot fileghc.hs fileghc .hsig fileghcIndicates whether a given module's source has been modified since it was last compiled.ghcthe source has been modifiedghcthe source has not been modified. Compilation may or may not be necessary, depending on whether any dependencies have changed since we last compiled.ghcthe source has not been modified, and furthermore all of its (transitive) dependencies are up to date; it definitely does not need to be recompiled. This is important for two reasons: (a) we can omit the version check in checkOldIface, and (b) if the module used TH splices we don't need to force recompilation.  t Safe-Inferred7. ghcA command-line error message ghc4GHC flag modes describing when a flag has an effect. ghc#The flag affects multiple ghc modes ghc.This flag should not be seen in cli completion ghc-The flag only affects the non-interactive GHC ghc)The flag only affects the interactive GHC ghc6A command-line warning message and the reason it arose ghcUsed when filtering warnings: if a reason is given it can be filtered out when displaying.ghc Parse an IntLooks for "433" or "=342", with no trailing gubbins * n or =n => Just n * gibberish => NothingghcDiscards a leading equals sign5 5  Safe-Inferred!ghcUnfolding optionspghcSees if the unfolding is pretty certain to inline. If so, return a *stable* unfolding for it, that will always inline.pghc2Threshold above which unfoldings are not *created*pghcDiscount for dictionariespghc,Discount for lambdas that are used (applied)pghc2Threshold above which unfoldings are not *inlined*pghc!Force inlining in many more casesghc0The size of a candidate expression for unfoldingghc Size foundghc2Arguments cased herein, and discount for each suchghc?Size to subtract if result is scrutinised by a case expressionghc)Finds a nominal size of a string literal.ghcThe size of a function callghc"The size of a jump to a join pointghcReport the inlining of an identifier's RHS to the user, if requested.ghcnumber of value argsghc"number of value args that are voidghcnumber of value argsghc"number of value args that are void$ppppppppZZppppppppppppppppp$ZZppppppppppppppppppppppppp Safe-Inferred 045XghcReturns True" for a tick that is both counting and> scoping and can be split into its (tick, scope) parts using X and mkNoTick respectively.XghcReturns whether one tick "contains" the other one, therefore making the second tick redundant.XghcA "counting tick" (where tickishCounts is True) is one that counts evaluations in some way. We cannot discard a counting tick, and the compiler should preserve the number of counting ticks as far as possible.However, we still allow the simplifier to increase or decrease sharing, so in practice the actual number of ticks may vary, except that we never change the value from zero to non-zero or vice versa.XghcReturns True for ticks that can be floated upwards easily even where it might change execution counts, such as: Just (tick ... foo) ==> tick ... (Just foo)This is a combination of tickishSoftScope and  tickishCounts. Note that in principle splittable ticks can become floatable using mkNoTick -- even though there's currently no tickish for which that is the case.XghcReturn True if this source annotation compiles to some backend code. Without this flag, the tickish is seen as a simple annotation that does not have any associated evaluation code.What this means that we are allowed to disregard the tick if doing so means that we can skip generating any code in the first place. A typical example is top-level bindings: foo = tick ...% y -> ... ==> foo = y -> tick ... ...Here there is just no operational difference between the first and the second version. Therefore code generation should simply translate the code as if it found the latter.Xghc)Placement behaviour we want for the ticksXghc/Returns the intended scoping rule for a TickishXghcReturns whether the tick scoping rule is at least as permissive as the given scoping rule.Xghc)Tickish in Cmm context (annotations only)XghcA breakpoint for the GHCi debugger. This behaves like an HPC tick, but has a list of free variables which will be available for inspection in GHCi when the program stops at the breakpoint.NB. we must take account of these Ids when (a) counting free variables, and (b) substituting (don't substitute for them)XghcA "tick" used by HPC to track the execution of each subexpression in the original source code.XghcAn  {-# SCC #-} profiling annotation, either automatically added by the desugarer as a result of -auto-all, or added by the user.XghcA source note.Source notes are pure annotations: Their presence should neither influence compilation nor execution. The semantics are given by causality: The presence of a source note means that a local change in the referenced source code span will possibly provoke the generated code to change. On the flip-side, the functionality of annotated code *must* be invariant against changes to all source code *except* the spans referenced in the source notes (see "Causality of optimized Haskell" paper for details).Therefore extending the scope of any given source note is always valid. Note that it is still undesirable though, as this reduces their usefulness for debugging and profiling. Therefore we will generally try only to make use of this property where it is necessary to enable optimizations.Xghcthe order of this list is important: it matches the order of the lists in the appropriate entry in .9Careful about substitution! See Note [substTickish] in GHC.Core.Subst.Xghcthe cost centreXghcbump the entry count?Xghc;scopes over the enclosed expression (i.e. not just a tick)Xghc4Name for source location (uses same names as CCs)XghcSource coveredXghcGoverns the kind of expression that the tick gets placed on when annotating for example using mkTick. If we find that we want to put a tickish on an expression ruled out here, we try to float it inwards until we find a suitable expression.XghcIn addition to floating through lambdas, cost-centre style tickishs can also be moved from constructors, non-function variables and literals. For example: let x = scc ... C (scc ... y) (scc ... 3) in ...Neither the constructor application, the variable or the literal are likely to have any cost worth mentioning. And even if y names a thunk, the call would not care about the evaluation context. Therefore removing all annotations in the above example is safe.XghcAs  PlaceRuntime, but we float the tick through all lambdas. This makes sense where there is little difference between annotating the lambda and annotating the lambda's code.XghcPlace ticks exactly on run-time expressions. We can still move the tick through pure compile-time constructs such as other ticks, casts or type lambdas. This is the most restrictive placement rule for ticks, as all tickishs have in common that they want to track runtime processes. The only legal placement rule for counting ticks.XghcSpecifies the scoping behaviour of ticks. This governs the behaviour of ticks that care about the covered code and the cost associated with it. Important for ticks relating to profiling.XghcCost centre scoping: We don't want any costs to move to other cost-centre stacks. This means we not only want no code or cost to get moved out of their cost centres, but we also object to code getting associated with new cost-centre ticks - or changing the order in which they get applied.A rule of thumb is that we don't want any code to gain new annotations. However, there are notable exceptions, for example:let f = y -> foo in tick ... ... (f x) ... ==> tick ... ... foo[x/y] ...In-lining lambdas like this is always legal, because inlining a function does not change the cost-centre stack when the function is called.XghcNo scoping: The tick does not care about what code it covers. Transformations can freely move code inside as well as outside without any additional annotation obligationsXghcSoft scoping: We want all code that is covered to stay covered. Note that this scope type does not forbid transformations from happening, as long as all results of the transformations are still covered by this tick or a copy of it. For example let x = tick ...6 (let y = foo in bar) in baz ===> let x = tick ... bar; y = tick ... foo in bazIs a valid transformation as far as "bar" and "foo" is concerned, because both still are scoped over by the tick.Note though that one might object to the "let" not being covered by the tick any more. However, we are generally lax with this - constant costs don't matter too much, and given that the "let" was effectively merged we can view it as having lost its identity anyway.Also note that this scoping behaviour allows floating a tick "upwards" in pretty much any situation. For example:case foo of x -> tick ... bar ==> tick ... case foo of x -> barWhile this is always legal, we want to make a best effort to only make us of this where it exposes transformation opportunities.ghc6Keep track of the type of breakpoints in STG, for GHCighc;Allows attaching extra information to points in expressionsUsed as a data type index for the GenTickish annotations. See Note [Tickish passes]%XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX%XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX Safe-Inferred5*ghc.Is this a cost-centre which records scc counts*ghcPrint a flavour in Core*ghc)Is this a cost-centre which can be sccd ?*ghcThe flavour of a cost centre.Index fields represent 0-based indices giving source-code ordering of centres with the same module, name, and flavour.*ghcAuto-generated top-level thunk*ghc Explicitly annotated declaration*ghcExplicitly annotated expression*ghcGenerated by HPC for coverage*ghcA Cost Centre is a single  {-# SCC #-} annotation.*ghcTwo cost centres may have the same name and module but different SrcSpans, so we need a way to distinguish them easily and give them different object-code labels. So every CostCentre has an associated flavour that indicates how it was generated, and flavours that allow multiple instances of the same name and module have a deterministic 0-based index.*ghc Name of module defining this CC.*ghcName of the cost centre itself*ghcA Cost Centre Stack is something that can be attached to a closure. This is either:$the current cost centre stack (CCCS)a pre-defined cost centre stack (there are several pre-defined CCSs, see below).ghc Extract the index from a flavourghcPrint a flavour's index in Coreghc(Print the flavour component of a C labelghc.Print the flavour index component of a C label#***********************************#***********************************] Safe-Inferred5ghc-Get a new index for a given cost centre name.ghcInitialize cost centre state.ghc9An index into a given cost centre module,name,flavour setghc2Per-module state for tracking cost centre indices.See documentation of  for more details. Safe-Inferred 5=|Gghc-Extend or narrow a fixed-width literal (e.g. #) to a target word-sized literal ( or ). Narrowing can only happen on 32-bit architectures when we convert a 64-bit literal into a 32-bit one.Gghc-Extend or narrow a fixed-width literal (e.g. #) to a target word-sized literal ( or ). Narrowing can only happen on 32-bit architectures when we convert a 64-bit literal into a 32-bit one.Gghc Returns the A contained in the H', for when that makes sense, i.e. for = and numbers.GghcTests whether the literal represents a one of whatever type it isGghcTests whether the literal represents a zero of whatever type it isGghc?True if code space does not go bad if we duplicate this literalGghcTrue if there is absolutely no penalty to duplicating the literal. False principally of strings."Why?", you say? I'm glad you asked. Well, for one duplicating strings would blow up code sizes. Not only this, it's also unsafe.Consider a program that wants to traverse a string. One way it might do this is to first compute the Addr# pointing to the end of the string, and then, starting from the beginning, bump a pointer using eqAddr# to determine the end. For instance, -- Given pointers to the start and end of a string, count how many zeros -- the string contains. countZeros :: Addr# -> Addr# -> -> Int countZeros start end = go start 0 where go off n | off addrEq#- end = n | otherwise = go (off  1) n' where n' | isTrue# (indexInt8OffAddr# off 0# ==# 0#) = n + 1 | otherwise = n Consider what happens if we considered strings to be trivial (and therefore duplicable) and emitted a call like countZeros "hello"# ("hello"# plusAddr# 5). The beginning and end pointers do not belong to the same string, meaning that an iteration like the above would blow up terribly. This is what happened in #12757.Ultimately the solution here is to make primitive strings a bit more structured, ensuring that the compiler can't inline in ways that will break user code. One approach to this is described in #8472.GghcNumber of bitsGghc>Check that a given number is in the range of a numeric literalGghc>Coerce a literal number into another using wrapping semantics.Gghc ? will be appended to label name when emitting assembly.3) Flag indicating whether the symbol references a function or a dataHghcThe NULL pointer, the only pointer value that can be represented as a Literal. Create with GHghcAny numeric literal that can be internally represented with an Integer.Hghc/A nonsense value; always boxed, but True  = lifted, False  = unlifted Used when a binding is absent. See Note [Rubbish literals]HghcA string-literal: stored and emitted UTF-8 encoded, we'll arrange to decode it at runtime. Also emitted with a '\0' terminator. Create with GHghcNeeded for the Ord instance of AltCon, which in turn is needed in .ghc Creates a H of type Word# without checking its range.ghc Creates a H of type Int8# without checking its range.ghc Creates a H of type Word8# without checking its range.ghc Creates a H of type Int16# without checking its range.ghc Creates a H of type Word16# without checking its range.ghc Creates a H of type Int32# without checking its range.ghc Creates a H of type Word32# without checking its range.ghc Creates a H of type Int64# without checking its range.ghc Creates a H of type Word64# without checking its range.ghc0Narrow a literal number (unchecked result range)GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGHHHHHHHHHHHHHHHHHHHHHHHHHHHHGGGHHHHHHHHHHGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGu Safe-InferredN ghc Does this   represent a tuple?NB: when compiling  Data.Tuple, the tycons won't reply True to  , because they are built as  AlgTyCons. However they get spat into the interface file as tuple tycons, so I don't think it matters. ghc Is this the   for an unboxed tuple? ghcMake a  for the Typeable* representation of the given wired-in type ghcName of the constructor ghcTyCons represent type constructors. Type constructors are introduced by things such as:1) Data declarations: data Foo = ... creates the Foo type constructor of kind *2) Type synonyms: type Foo = ... creates the Foo type constructor 3) Newtypes: newtype Foo a = MkFoo ... creates the Foo type constructor of kind * -> *4) Class declarations: class Foo where creates the Foo type constructor of kind *This data type also encodes a number of primitive, built in type constructors such as those for function and tuple types.:ghc Extract an ; with information about data constructors from an algebraic or tuple  . Panics for any other sort of  :ghcExtract the flavour of a type family (with all the extra information that it carries):ghc Test if the  8 is algebraic but abstract (invisible data constructors):ghcReturns True if the supplied   resulted from either a data or newtype declaration:ghc Is this the   for a boxed tuple?:ghcIs this   that for a class instance?:ghc0Is this a non-empty closed type family? Returns K( for abstract or empty closed families.:ghcReturns True for the   of the  Constraint kind.:ghcIs this a synonym  1 that can have may have further instances appear?:ghcReturns True for data types that are  definitely represented by heap-allocated constructors. These are scrutinised by Core-level case: expressions, and they get info tables allocated for them.-Generally, the function will be true for all data types and false for newtype1s, unboxed tuples, unboxed sums and type family  &s. But it is not guaranteed to return True in all cases that it could.%NB: for a data type family, only the instance  2s get an info table. The family declaration   does not:ghcIs this an algebraic  ( which is just an enumeration of values?:ghcIs this tycon neither a type family nor a synonym that expands to a type family?:ghcIs this  ! that for a data family instance?:ghc Is this a  ., synonym or otherwise, that defines a family?:ghcIs this a forgetful type synonym? If this is a type synonym whose RHS does not mention one (or more) of its bound variables, returns True. Thus, False means that all bound variables appear on the RHS; True may not mean anything, as the test to set this flag is conservative.:ghcIs this an algebraic   declared with the GADT syntax?:ghc Is this an ; of a   that is generative and injective with respect to representational equality?:ghc: is true of  s for which this property holds (where X is the role passed in): If (T tys ~X t), then (t's head ~X T). See also Note [Decomposing equality] in GHC.Tc.Solver.Canonical:ghcIdentifies implicit tycons that, in particular, do not go into interface files (because they are implicitly reconstructed when the interface is read). Note that:Associated families are implicit, as they are re-constructed from the class declaration in which they reside, andFamily instances are not? implicit as they represent the instance body (similar to a dfun! does that for a class instance).Tuples are implicit iff they have a wired-in name (namely: boxed and unboxed tuples are wired-in and implicit, but constraint tuples are not):ghc: is true of  s for which this property holds (where X is the role passed in): If (T a1 b1 c1) ~X (T a2 b2 c2), then (a1 ~X1 a2), (b1 ~X2 b2), and (c1 ~X3 c2) (where X1, X2, and X3, are the roles given by tyConRolesX tc X) See also Note [Decomposing equality] in GHC.Tc.Solver.Canonical:ghcIs this tycon really meant for use at the kind level? That is, should it be permitted without -XDataKinds?:ghcIs this   that for a newtype:ghc Is this a  >, synonym or otherwise, that defines a family with instances?:ghc"Is this an open type family TyCon?:ghc Does this  7 represent something that cannot be defined in Haskell?:ghcIs this a PromotedDataCon?:ghc T a ...;ghcTake a   apart into the s it scopes over, the ! it expands into, and (possibly) a coercion from the representation type to the newtype . Returns Nothing if this is not possible.;ghcBoth type classes as well as family instances imply implicit type constructors. These implicit type constructors refer to their parent structure (ie, the class or family from which they derive) using a type of the following form.Extract those !s that we are able to learn about. Note that visibility in this sense does not correspond to visibility in the context of any particular user program!;ghcType constructors representing a class dictionary. See Note [ATyCon for classes] in GHC.Core.TyCo.Rep;ghcType constructors representing an *instance* of a *data* family. Parameters:1) The type family in question*2) Instance types; free variables are the < of the current   (not the family one). INVARIANT: the number of types matches the arity of the family  3) A CoTyCon identifying the representation type with the type instance family;ghcAn unboxed type constructor. The TyConRepName is a Maybe since we currently don't allow unboxed sums to be Typeable since there are too many of them. See #13276.;ghc+An ordinary type constructor has no parent.;ghcRepresents right-hand-sides of  s for algebraic types;ghcSays that we know nothing about this data type, except that it's represented by a pointer. Used when we export a data type abstractly into an .hi file.;ghcInformation about those  s derived from a data declaration. This includes data types with no constructors at all.;ghcInformation about those  s derived from a newtype declaration;ghcAn unboxed sum type.;ghcThe unique constructor for the newtype. It has no existentials;ghcThe data type constructors; can be empty if the user declares the type to have no constructors'INVARIANT: Kept in order of increasing !/ tag (see the tag assignment in mkTyConTagMap);ghcCached value: length data_cons;ghcCached value: is this an enumeration type? See Note [Enumeration types];ghc Same as the ;0, but this time eta-reduced. Hence the list of ?s in this field may be shorter than the declared arity of the  .;ghcCached value: the argument type of the constructor, which is just the representation type of the   (remember that newtypes do not exist at runtime so need a different representation type). The free s of this type are the < from the corresponding  ;ghc.Is this a boxed, unboxed or constraint tuple?;ghc;Information pertaining to the expansion of a type synonym (type);ghcA closed type synonym family declared in an hs-boot file with type family F a where ..;ghc0Built-in type family used by the TypeNats solver;ghc$A closed type synonym family e.g. &type family F x where { F Int = Bool };ghcRepresents an open type family without a fixed right hand side. Additional instances can appear at any time.7These are introduced by either a top level declaration: data family T a :: *Or an associated data type declaration, within a class declaration: !class C a b where data T b :: *;ghc"An open type synonym family e.g. type family F x y :: * -> *;ghcA ; is an abstraction of a type. It contains information that the code generator needs in order to pass arguments, return results, and store values of this type. See also Note [RuntimeRep and PrimRep] in GHC.Types.RepType and Note [VoidRep] in GHC.Types.RepType.;ghcA pointer, but not) to a Haskell value (use '(Un)liftedRep');ghcSigned, 16-bit value;ghcSigned, 32-bit value;ghcSigned, 64 bit value;ghcSigned, 8-bit value;ghcSigned, word-sized value;ghcUnlifted pointer;ghcA vector;ghcUnsigned, 16 bit value;ghcUnsigned, 32 bit value;ghcUnsigned, 64 bit value;ghcUnsigned, 8 bit value;ghcUnsigned, word-sized value;ghcSome promoted datacons signify extra info relevant to GHC. For example, the IntRep constructor of  RuntimeRep corresponds to the ; constructor of ;. This data structure allows us to store this information right in the  6. The other approach would be to look up things like  RuntimeRep's PrimRep by known-key every time. See also Note [Getting from RuntimeRep to PrimRep] in GHC.Types.RepType;ghcA constructor of Levity;ghcan ordinary promoted data con;ghcA constructor of  RuntimeRep. The argument to the function should be the list of arguments to the promoted datacon.<ghcA constructor of Levity<ghcA constructor of VecCount<ghcA constructor of VecElem<ghc,Maps a label to information about the field<ghcName of result type variable, used for pretty-printing with --show-iface and for reifying TyCon in Template Haskell<ghc$Is this TcTyCon already generalized?<ghcScoped tyvars over the tycon's body See Note [Scoped tyvars in a TcTyCon]<ghcArity<ghc Full binders<ghcThe C type that should be used for this type when using the FFI and CAPI<ghcKind of this TyCon<ghcA pre-allocated TyConApp tycon []<ghc Result kind<ghc TyVar binders<ghcA Unique of this TyCon. Invariant: identical to Unique of Name stored in tyConName field.<ghcPaints a picture of what a   represents, in broad strokes. This is used towards more informative error messages.<ghc e.g., the (->)  .ghcThe function type constructor, (->)ghc"Algebraic data types, from - data declarations - newtype declarations - data instance declarations - type instance declarations - the TyCon generated by a class declaration - boxed tuples - unboxed tuples - constraint tuples All these constructors are lifted and boxed except unboxed tuples which should have an ; parent. Datanewtypetype families are handled by . See ; for more information.ghcRepresents type synonymsghcRepresents families (both type and data) Argument roles are all NominalghcPrimitive types; cannot be defined in Haskell. This includes the usual suspects (such as Int#0) as well as foreign-imported types and kinds (*, #, and ?)ghc%Represents promoted data constructor.ghcThese exist only during type-checking. See Note [How TcTyCons work] in  GHC.Tc.TyClghcThe role for each type variable This list has length = tyConArity See also Note [TyCon Role signatures]ghcWas the data type declared with GADT syntax? If so, that doesn't mean it's a true GADT; only that the "where" form was used. This field is used only to guide pretty-printingghcThe "stupid theta" for the data type (always empty for GADTs). A "stupid theta" is the context to the left of an algebraic type declaration, e.g. Eq a in the declaration data Eq a => T a ....ghcContains information about the data constructors of the algebraic typeghc'Gives the class or family declaration   for derived  8s representing class or family instances, respectively.ghc8Contains information about the expansion of the synonymghcType family flavour: open, closed, abstract, built-in. See comments for FamTyConFlavghcFor *associated* type/data families The class tycon in which the family is declared See Note [Associated families and their parent class]ghcis this a type family injective in its type variables? Nothing if no injectivity annotation was givenghcMost primitive tycons are unlifted (may not contain bottom) but other are lifted, e.g.  RealWorld Only relevant if tyConKind = *ghcCorresponding data constructorghcSee comments with ;ghc What sort of   this represents.ghcChecks the invariants of a ;/ given the appropriate type class name, if anyghc-The labels for the fields of this particular  ghcMake a map from strings to FieldLabels from all the data constructors of this algebraic tyconghcThese TyCons should be allowed at the kind level, even without -XDataKinds.ghcCan this flavour of   appear unsaturated? :ghc Arguments to  ghc Returns a  substitution, the body type of the synonym (not yet substituted) and any arguments remaining from the application ^ Expand a type synonym application Return Nothing if the TyCon is not a synonym, or if not enough arguments are supplied:ghcBinders of the  ghc Result kindghcThe roles for each TyVarghc>The C type this type corresponds to when using the CAPI FFIghcStupid theta: see ghc#Information about data constructorsghc0What flavour is it? (e.g. vanilla, type family)ghcWas the   declared with GADT syntax?;ghcresult kind;ghcresult kind;ghcresult kind;ghcresult kind, never levity-polymorphic;ghcKind of the resulting  ghcArity of the sumghcs scoped over: see <;ghcresult kind;ghcresult kind onlyghcScoped type variables; see Note [How TcTyCons work] in GHC.Tc.TyClghc$Is this TcTyCon generalised already?ghc What sort of   this represents;ghcResult kind of the  ghcArity of the tuple  ghc%Whether the tuple is boxed or unboxedghcresult kind, never levity-polymorphic (If you need a levity-polymorphic PrimTyCon, change isTcLevPoly.) <<<<<<<<<<< < 0000:::::::::::::::::::::::::::::::::::::::::::::::::::::;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;<<;;<<<<<<<<<<<<<<<<<<< ;;;;;;;;;;;;;;;;;;;;;:;;;;;;0000;;;;;<<;;<<<<<<<<<<<<<<<<<<<;;;::;;:::;:::;;;;;;;;;;;;::::: : :::::;:::::::::::::::::;:::::::;;:::;: ;<<<;<;;;;;;;;;<<;;;;;;;;;;;:<:;;;;;;<;<<;<<;:;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::;;;;; Safe-Inferred*ghcDeterministic Name Environment#See Note [Deterministic UniqFM] in GHC.Types.Unique.DFM' for explanation why we need DNameEnv.*ghcName Environment$))))))))))))))))))))))))))))********$*))))**)))))))****))))))))*)))))))))  Safe-Inferred') ghcGiven a start vertex, a way to get successors from a node and a list of (directed) edges classify the types of edges.ghcFind a reasonably short cycle a->b->c->a, in a strongly connected component. The input nodes are presumed to be a SCC, so you can start anywhere.ghc1Given a list of roots return all reachable nodes.ghc*Edge direction based on DFS Classificationghc7Loop back towards the root node. Eg backjumps in loopsghcv -> v ghc&Representation for nodes of the Graph.The payload1 is user data, just carried around in this moduleThe key is the node identifier. Key has an Ord instance for performance reasons.The [key] are the dependencies of the node; it's ok to have extra keys in the dependencies that are not the key of any Node in the graph ghc#Dependencies/successors of the node ghcUser defined node id ghc User data! ! x Safe-Inferred5v&!ghcLike mkTyCoForAllTy, but does not check the occurrence of the binder See Note [Unused coercion variable in ForAllTy]!ghcCreate a nullary >$. In general you should rather use w8. This merely exists to break the import cycle between  and this module.!ghcA ! is concrete evidence of the equality/convertibility of two types.!ghc0The key type representing kinds in the compiler.!ghcA semantically more meaningful type to represent what may or may not be a useful !.!ghcMult is a type alias for Type.Mult must contain Type because multiplicity variables are mere type variables (of kind Multiplicity) in Haskell. So the simplest implementation is to make Mult be Type.Multiplicities can be formed with: - One: GHC.Types.One (= oneDataCon) - Many: GHC.Types.Many (= manyDataCon) - Multiplication: GHC.Types.MultMul (= multMulTyCon)So that Mult feels a bit more structured, we provide pattern synonyms and smart constructors for these.!ghcA type of the form p of constraint kind represents a value whose type is the Haskell predicate p/, where a predicate is what occurs before the => in a Haskell type.We use ! as documentation to mark those types that we guarantee to have this kind.0It can be expanded into its representation, but:(The type checker must treat it as opaque1The rest of the compiler treats it as transparentConsider these examples: f :: (Eq a) => a -> Int g :: (?x :: Int -> Int) => a -> Int h :: (r\l) => {r} => {l::Int | r} Here the Eq a and ?x :: Int -> Int and rl are all called "predicates"!ghc&A shorthand for data with an attached ! element (the multiplicity).!ghcA collection of !s!ghcA ! represents an argument to a function. TyCoBinders can be dependent (>) or nondependent (>;). They may also be visible or not. See Note [TyCoBinders]!ghcFor simplicity, we have just one UnivCo that represents a coercion from some type to some other type, with (in general) no restrictions on the type. The UnivCoProvenance specifies more exactly what the coercion really is and why a program should (or shouldn't!) trust the coercion. It is reasonable to consider each constructor of ! as a totally independent coercion form; their only commonality is that they don't tell you what types they coercion between. (That info is in the > constructor of !.>ghcRemove the binder's variable from the set, if the binder has a variable.>ghc,Does this binder bind an invisible argument?>ghcIf its a named binder, is the binder a tyvar? Returns True for nondependent binder. This check that we're really returning a *Ty*Binder (as opposed to a coercion binder). That way, if/when we allow coercion quantification in more places, we'll know we missed updating some function.>ghc)Does this binder bind a visible argument?>ghcApply a function to both the Mult and the Type in a 'Scaled Type'>ghc/Wraps foralls over the type using the provided s from left to right>ghc/Wraps foralls over the type using the provided s from left to right>ghc0Special, common, case: Arrow type with mult Many>ghcMake nested arrow types>ghc;See Note [Coercion holes] Only present during typechecking>ghcA coercion to be filled in by the type-checker. See Note [Coercion holes]>ghc3The key representation of types within the compiler>ghcA type labeled > might have knot-tied tycons in it. See Note [Type checking recursive type and class declarations] in  GHC.Tc.TyCl>ghc> is like !, but there can only be " in the > field.>ghc>What to do with coercion holes. See Note [Coercion holes] in GHC.Core.TyCo.Rep.>ghc.The returned env is used in the extended scope>ghc+Type application to something other than a   . Parameters:1) Function: must not be a > or >, must be another >, or > See Note [Respecting definitional equality] (EQ1) about the no > requirement2) Argument type>ghcA kind cast. The coercion is always nominal. INVARIANT: The cast is never reflexive (EQ2) INVARIANT: The Type is not a CastTy (use TransCo instead) (EQ3) INVARIANT: The Type is not a ForAllTy over a tyvar (EQ4) See Note [Respecting definitional equality]>ghcInjection of a Coercion into a type This should only ever be used in the RHS of an AppTy, in the list of a TyConApp, when applying a promoted GADT data constructor>ghcA  type. INVARIANT: If the binder is a coercion variable, it must be mentioned in the Type. See Note [Unused coercion variable in ForAllTy]>ghcFUN m t1 t2 Very common, so an important special case See Note [Function types]>ghc/Type literals are similar to type constructors.>ghcApplication of a  , including newtypes and1 synonyms. Invariant: saturated applications of FunTyCon must use > and saturated synonyms must use their own constructors. However,  unsaturated FunTyCons do appear as >s. Parameters:%1) Type constructor being applied to.2) Type arguments. Might not have enough type arguments here to saturate the constructor. Even type synonyms are not necessarily saturated; for example unsaturated type synonyms can appear as the right hand side of a type synonym.>ghc;Vanilla type or kind variable (*never* a coercion variable)>ghc>See Note [Phantom coercions]. Only in Phantom roled coercions>ghcFrom a plugin, which asserts that this coercion is sound. The string is for the use of the plugin.>ghcFrom the fact that any two coercions are considered equivalent. See Note [ProofIrrelProv]. Can be used in Nominal or Representational coercions""""""!!!!>>>>>>>>>>>>>>>>>>!!!>>!!!!>!!>>!>>>!>>>>>>>>>>>>!>>>>""""""">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>!>>>>>>>>>>>>!>>>>!>!!""""""""!>>>>>>>>>>>>>>>>>>!>>>>>>>>>>!>>>!>>>!!>>>>>>>>!>>>>!>>>>>>>!>>">"""">"">>>>>>>>>>>>>>>!>>>>!>3>3>3>3>3 Safe-Inferred ɿghc;Stores the arguments in a type application as a list. See &Note [Suppressing invisible arguments].ghc3A kind of universal type, used for types and kinds. Any time a Type0 is pretty-printed, it is first converted to an  before being printed. See Note [Pretty printing via Iface syntax] in GHC.Types.TyThing.Ppr<ghc"Extract the variable name from an <.<ghc Extract an  from an <.<ghc"Extract the variable name from an =.<ghc Extract an  from an =.<ghc?Given a kind K, is K of the form (TYPE ('BoxedRep 'LiftedRep))?<ghcMake an < from an =.<ghc Build the <: from the binders and the result kind. Keep in sync with ; in GHC.Core.TyCon.<ghcPrints a context or ()- if empty You give it the context precedence<ghcPrints "(C a, D b) =>", including the arrow. Used when we want to print a context in a type, so we use  to decide whether to parenthesise a singleton predicate; e.g. Num a => a -> a<ghc;Render the "forall ... ." or "forall ... ->" bit of a type.<ghcLike <, but always uses an explicit forall.<ghc!See Note [Holes in IfaceCoercion]=ghcThe various types of TyCons which have special, built-in syntax.=ghcA heterogeneous equality TyCon (i.e. eqPrimTyCon, eqReprPrimTyCon, heqTyCon) that is actually being applied to two types of the same kind. This affects pretty-printing only: see Note [Equality predicates in IfaceType]=ghca regular tycon=ghce.g.  (a | b | c)=ghce.g.  (a, b, c) or  (#a, b, c#). The arity is the tuple width, not the tycon arity (which is twice the width in the case of unboxed tuples).=ghcShow forall flag1Unconditionally show the forall quantifier with (= ) or when (=) the names used are free in the binder or when compiling with -fprint-explicit-foralls.=ghcDo we want to suppress kind annotations on binders? See Note [Suppressing binder signatures]ghcGiven a kind constructor K and arguments A, returns true if both of the following statements are true: K is TYPE=A is a singleton IfaceAppArgs of the form ('BoxedRep 'Lifted)For the second condition, we must also check for the type synonym LiftedRep.ghcDefault ; variables to ;, and  Multiplicity variables to Many. For example: ($) :: forall (r :: GHC.Types.RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b Just :: forall (k :: Multiplicity) a. a # k -> Maybe a  turns in to,. ($) :: forall a (b :: *). (a -> b) -> a -> b  ! Just :: forall a . a -> Maybe a We do this to prevent RuntimeRep and Multiplicity variables from incurring a significant syntactic overhead in otherwise simple type signatures (e.g. ($)). See Note [Defaulting RuntimeRep variables] and #11549 for further discussion.ghc6The type ('BoxedRep 'Lifted), also known as LiftedRep.ghcRender the ... in (forall ... .) or (forall ... ->). Returns both the list of not-yet-rendered binders and the doc. No anonymous binders here!ghcPrefix a space if the given  is a promoted  1. See Note [Printing promoted type constructors]ghcPretty-print a type-level equality. Returns (Just doc) if the argument is a  saturated application of eqTyCon (~) eqPrimTyCon (~#) eqReprPrimTyCon (~R#) heqTyCon (~~)See Note [Equality predicates in IfaceType] and Note [The equality types story] in GHC.Builtin.Types.PrimghcPretty-prints an application of a type constructor to some arguments (whose visibilities are known). This is polymorphic (over a) since we use this function to pretty-print two different things:  Types (from <`)Coercions (from <)ghcif printing coercionsghc otherwiseghc*visibility of the first binder in the list<<<<<<<<<<<<<<<<<<<<<<<================""""""<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<=====================================<<============<<<<<<<<<<<<<<<<<<<================<========<<<<<========<""""""""===<<<<<<<<<<<<======<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<f Safe-Inferred1lghcIs a ! a  CallStack implicit parameter?(If so, return the name of the parameter.lghc Is a type a  CallStack?lghc.Does a type represent a floating-point number?lghc2Should this type be applied to a visible argument?lghcIf the tycon is applied to the types, is the next argument visible?lghcLike l, but also says M for m typeslghc Is a type <?lghcCheck that a type does not contain any type family applications.lghcMake an m suitable for checking.lghc-Make a sigma ty where all type variables are ">. That is, they cannot be used with visible type application.lghcMake a sigma ty where all type variables are "specified". That is, they can be used with visible type applicationlghcLike mkFunTys but for mlghcWhen inferring types, should we quantify over a given predicate? Generally true of classes; generally false of equality constraints. Equality constraints that mention quantified type variables and implicit variables complicate the story. See Notes [Inheriting implicit parameters] and [Quantifying over equality constraints]lghcLike pickyEqTypeVis$, but returns a Bool for conveniencelghc8Change the TcLevel in a skolem, extending a substitutionlghcLike m but accepts a regular TcTypelghcCheck whether two TyConApps are the same; if the number of arguments are different, just checks the common prefix of arguments.lghc;tcEqType implements typechecker equality, as described in 4Note [Typechecker equality vs definitional equality].lghc Just like l, but will return True for types of different kinds as long as their non-coercion structure is identical.lghcLike l, but returns True if the visible part of the types are equal, even if they are really unequal (in the invisible bits)lghc?Strips off n *visible* arguments and returns the resulting typelghcIf the type is a tyvar, possibly under a cast, returns it, along with the coercion. Thus, the co is :: kind tv ~N kind typelghc'Is this a ForAllTy with a named binder?lghcReturns the number of arguments in the given type, without looking through synonyms. This is used only for error reporting. We don't look through synonyms because of #11313.lghcLike l, but only splits >s with " type variable binders. All split tyvars are annotated with their .lghcLike l, but only splits >s with " type variable binders.lghcLike l, but only splits >s with "= type variable binders. All split tyvars are annotated with ().lghcLike l$, but splits off only named binders.lghcLike l, but splits off only named binders, returning just the tyvars.lghcSplit off exactly the specified number argument types Returns (Left m) if there are m missing arrows in the type (Right (tys,res)) if the type looks like t1 -> ... -> tn -> reslghc (a -> f b) -> s -> f t if you called tcSplitSigmaTy on this type: 2forall s t a b. Each s t a b => Traversal s t a b then it would return .([s,t,a,b], [Each s t a b], Traversal s t a b). But if you instead called tcSplitNestedSigmaTys on the type, it would return ([s,t,a,b,f], [Each s t a b, Applicative f], (a -> f b) -> s -> f t).lghcSplits a type into a TyBinder and a body, if possible. Panics otherwiselghc$Splits a forall type into a list of >s and the inner type. Always succeeds, even if it returns an empty list.lghc4Split a sigma type into its parts. This only splits  invisible type variable binders, as these are the only forms of binder that the typechecker will implicitly instantiate.mghcLike l, but only splits a > if argf_pred argf is M, where argf is the visibility of the ForAllTy's binder and  argf_pred is a predicate over visibilities provided as an argument to this function.mghcLike G, but only returns the  .mghcIn an application of a   to some arguments, find the outermost occurrences of type family applications within the arguments. This function will not consider the  4 itself when checking for type family applications.See m for more details on how this works (as this function is called inside of m).mghcFor every arg a tycon can take, the returned list says True if the argument is taken visibly, and False otherwise. Ends with an infinite tail of Trues to allow for oversaturation.mghcFinds outermost type-family applications occurring in a type, after expanding synonyms. In the list (F, tys) that is returned we guarantee that tys matches F's arity. For example, given type family F a :: * -> * (arity 1) calling tcTyFamInsts on (Maybe (F Int Bool) will return (F, [Int]), not (F, [Int,Bool])This is important for its use in deciding termination of type instances (see #11581). E.g. type instance G [Int] = ...(F Int )... we don't need to take into account when asking if the calls on the RHS are smaller than the LHSmghcLike m, except that the output records whether the type family and its arguments occur as an  invisible argument in some type application. This information is useful because it helps GHC know when to turn on -fprint-explicit-kinds during error reporting so that users can actually see the type family being mentioned.As an example, consider: class C a data T (a :: k) type family F a :: k instance C (T @(F Int) (F Bool)) -There are two occurrences of the type family F in that C instance, so m (C (T @(F Int) (F Bool))) will return: [ (M, F, [Int]) , (J, F, [Bool]) ] F Int is paired with M since it appears as an  invisible argument to C , whereas F Bool is paired with J since it appears an a visible argument to C. See also 'Note [Kind arguments in error messages] in  GHC.Tc.Errors.mghcAn expected type to check against during type-checking. See Note [ExpType] in GHC.Tc.Utils.TcMType&, where you'll also find manipulators.mghcWhat to expect for an argument to a rebindable-syntax operator. Quite like !, but allows for holes to be filled in by tcSyntaxOp. The callback called from tcSyntaxOp gets a list of types; the meaning of these types is determined by a left-to-right depth-first traversal of the m tree. So if you pass in >SynAny `SynFun` (SynList `SynFun` SynType Int) `SynFun` SynAny/you'll get three types back: one for the first m, the element) type of the list, and one for the last m". You don't get anything for the m, because you've said positively that it should be an Int, and so it shall be.You'll also get three multiplicities back: one for each function arrow. See also Note [Linear types] in Multiplicity.-This is defined here to avoid defining it in GHC.Tc.Gen.Expr boot file.mghcAny typemghc A function.mghc6A list type. You get back the element type of the listmghc5A rho type, skolemised or instantiated as appropriatemghc A known type.ghcType equality comparing both visible and invisible arguments and expanding type synonyms.ghcReal worker for l. No kind check!ghc7Is this an invisible argument to some type application?ghc7Is this an invisible argument to some type application?ghcTrue  = do not expand type synonymsghcTrue  = compare visible args only""""""mmmmmmmm!!!!!!!!!!!!!!!!!:>>>>>>>>>>>>>>>>???????????????????????????????@@@@@@@@@@@@@@@@@@@@FFFFFFFFFFFFFFFFFFFFFGGGIIIIIIIIIIJJJJJJkkkklllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm>mmmmmmmmmmlmmmmmmllmmmlllllmmllllmmmmmmlmmmmmmmlllFllllllllllllllllllllllllFlllmlllllllllllllmGmmmlllGllllllFFFFFlllllllllllllllllllllllF:ll!lllllkkkklllmlllllmmmlllllllllllllllll!G!!!FF!!!!""""""""!>>FFFFF>>>>>>>!!F!>>>>JJJJJJlllFF>>@@@??@??@?????????@????@@@@@@@@@@@@@??@FFF!!???????????!II!IIIIIIIImll?mllm0 Safe-Inferred'Sghc*If they aren't all valid, return the firstSghcFormats the input list of structured document, where each element of the list gets a bullet.SghcLike S but with O rather then OSghcTime a compilation phase.(When timings are enabled (e.g. with the -v2 flag), the allocations and CPU time used by the phase will be reported to stderr. Consider a typical usage: withTiming getDynFlags (text "simplify") force PrintTimings pass. When timings are enabled the following costs are included in the produced accounting,The cost of executing pass to a result r in WHNFThe cost of evaluating force r to WHNF (e.g. ())The choice of the force function depends upon the amount of forcing desired; the goal here is to ensure that the cost of evaluating the result is, to the greatest extent possible, included in the accounting provided by S. Often the pass already sufficiently forces its result during construction; in this case const () is a reasonable choice. In other cases, it is necessary to evaluate the result to normal form, in which case something like Control.DeepSeq.rnf is appropriate.To avoid adversely affecting compiler performance when timings are not requested, the result is only forced when timings are enabled.See Note [withTiming] for more.SghcSame as S:, but doesn't print timings in the console (when given -vN, N >= 2 or -ddump-timings).See Note [withTiming] for more.SghcEverything is fineSghc%A problem, and some indication of whyghc Worker for S and S.SghcDynFlagsghcThe name of the phaseghc.A function to force the result (often either const () or rnf)ghc!The body of the phase to be timedSghcDynFlagsghcThe name of the phaseghc.A function to force the result (often either const () or rnf)ghc!The body of the phase to be timedghc ghcThe name of the phaseghc.A function to force the result (often either const () or rnf)ghcWhether to print the timingsghc!The body of the phase to be timedOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSOOOOOOOOOOOOOOOOOOOOOOOOOSSSOOOOOOOOOOOOSSOSSSSSSSSSSSSSSSSSS Safe-Inferred^ )ghc Just like ), but ) are not eliminated from the ) returned)ghc,True if there is a non-empty intersection. s1 ) s2 doesn't compute s2 if s1 is empty)ghc Collect all )>, regardless of whether the group is itself used, but remove ) on the way)ghc Given some ) and some ), find all the uses, transitively. The result is a superset of the input ),; and includes things defined in the input ) (but only if they are used))ghcGet the elements of a NameSet with some stable ordering. This only works for Names that originate in the source code or have been tidied. See Note [Deterministic UniqFM] to learn about nondeterminism)ghc(Just ds, us) => The use of any member of the ds, implies that all the us+ are used too. Also, us may mention ds. Nothing => Nothing is defined in this group, but nevertheless all the uses are essential. Used for instance declarations, for example)ghc A number of )s in dependency order: earlier ) scope over later ) In a single (def, use) pair, the defs also scope over the uses)ghc)A set of names that are defined somewhere)ghcIds which have no CAF references. This is a result of analysis of C--. It is always safe to use an empty ). TODO Refer to Note.)ghc&A set of names that are used somewhere-)))))))))))))))))))))))))))))))))))))))))))))-)))))))))))))))))))))))))))))))))))))))))))))n Safe-Inferred '7ghcStrict left fold.ghc?Compare not only the values but also the structure of two listsghc?Compare not only the values but also the structure of two listsghc An unboxed B% type with two unboxed fields in the L case. Useful for defining  and  without overhead.555 Safe-Inferred#?ghcThis checks if the substitution satisfies the invariant from Note [The substitution invariant].?ghcComposes two substitutions, applying the second one provided first, like in function composition.?ghc(compose env1 env2)(x) is  env1(env2(x)) ; i.e. apply env2 then env14. It assumes that both are idempotent. Typically, env1* is the refinement to a base substitution env2?ghcReturns the free variables of the types in the range of a substitution as a non-deterministic set.?ghc When calling @ it should be the case that the in-scope set in the substitution is a superset of the free vars of the range of the substitution. See also Note [The substitution invariant].?ghcMake a TCvSubst with specified covar subst and empty tyvar subst?ghcMake a TCvSubst with specified tyvar subst and empty covar subst?ghc#Generates the in-scope set for the @ from the types in the incoming environment. No CoVars, please!?ghcSubstitute within a ! The substitution has to satisfy the invariants described in Note [The substitution invariant].?ghcSubstitute within a ! disabling sanity checks. The problems that the sanity checks in substCo catch are described in Note [The substitution invariant]. The goal of #11371 is to migrate all the calls of substCoUnchecked to substCo and remove this function. Please don't use in new code.?ghcCoercion substitution, see @?ghcCoercion substitution, see @. Disables sanity checks. The problems that the sanity checks in substCo catch are described in Note [The substitution invariant]. The goal of #11371 is to migrate all the calls of substCoUnchecked to substCo and remove this function. Please don't use in new code.?ghcSubstitute within several !s The substitution has to satisfy the invariants described in Note [The substitution invariant].@ghcSubstitute within a ! The substitution has to satisfy the invariants described in Note [The substitution invariant].@ghcSubstitute within a ! disabling the sanity checks. The problems that the sanity checks in substTys catch are described in Note [The substitution invariant]. The goal of #11371 is to migrate all the calls of substThetaUnchecked to substTheta and remove this function. Please don't use in new code.@ghcSubstitute within a ! The substitution has to satisfy the invariants described in Note [The substitution invariant].@ghcSubstitute within a ! after adding the free variables of the type to the in-scope set. This is useful for the case when the free variables aren't already in the in-scope set or easily available. See also Note [The substitution invariant].@ghcSubstitute within a ! disabling the sanity checks. The problems that the sanity checks in substTy catch are described in Note [The substitution invariant]. The goal of #11371 is to migrate all the calls of substTyUnchecked to substTy and remove this function. Please don't use in new code.@ghcType substitution, see @@ghcSubstitute covars within a type@ghc.Substitute tyvars within a type using a known ). Pre-condition: the in_scope set should satisfy Note [The substitution invariant]; specifically it should include the free vars of tys , and of ty minus the domain of the subst.@ghcType substitution, see @. Disables sanity checks. The problems that the sanity checks in substTy catch are described in Note [The substitution invariant]. The goal of #11371 is to migrate all the calls of substTyUnchecked to substTy and remove this function. Please don't use in new code.@ghcSubstitute within several !s The substitution has to satisfy the invariants described in Note [The substitution invariant].@ghcSubstitute within several !s disabling the sanity checks. The problems that the sanity checks in substTys catch are described in Note [The substitution invariant]. The goal of #11371 is to migrate all the calls of substTysUnchecked to substTys and remove this function. Please don't use in new code.@ghcType substitution, see @@ghcType substitution, see @@ghc#Generates the in-scope set for the @ from the types in the incoming environment. No TyVars, please!@ghc#Generates the in-scope set for the @ from the types in the incoming environment. No CoVars, please!@ghcA substitution of !s for "s@ghcType & coercion substitutiontcvsubst_invariant* The following invariants must hold of a @: The in-scope set is needed only* to guide the generation of fresh uniquesIn particular, the kind; of the type variables in the in-scope set is not relevantThe substitution is only applied ONCE! This is because in general such application will not reach a fixed point.@ghcA substitution of !s for s and !s for "sghcSubstitute a covar in a binding position, returning an extended subst and a new covar. Use the supplied function to substitute in the kindghcSubstitute a tyvar in a binding position, returning an extended subst and a new tyvar. Use the supplied function to substitute in the kindghcLike @, but disables sanity checks. The problems that the sanity checks in substCo catch are described in Note [The substitution invariant]. The goal of #11371 is to migrate all the calls of substCoUnchecked to substCo and remove this function. Please don't use in new code.ghcLike @, but disables sanity checks. The problems that the sanity checks in substTy catch are described in Note [The substitution invariant]. The goal of #11371 is to migrate all the calls of substTyUnchecked to substTy and remove this function. Please don't use in new code.ghc"Use this to substitute in the kind???????????????????????????????????????????????@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@???????????????????@?????????????@@@@@@?@@@@?@@@@@@@@@??@@@@????????@@@@?@@@@@@@??{ Safe-Inferred!OIghcdebugPprType is a simple pretty printer that prints a type without going through IfaceType. It does not format as prettily as the normal route, but it's much more direct, and that can be useful for debugging. E.g. with -dppr-debug it prints the kind on type-variable  occurrences1 which the normal route fundamentally cannot do.IghcPretty prints a  , using the family instance in case of a representation tycon. For example: data T [a] = ...In that case we want to print T [a], where T is the family  IghcPrint a user-level forall; see Note [When to print foralls] in GHC.Iface.Type.Ighc#Display all kind information (with -fprint-explicit-kinds) when the provided ; argument is M. See 'Note [Kind arguments in error messages] in  GHC.Tc.Errors.IghcThis variant preserves any use of TYPE in a type, effectively locally setting -fprint-explicit-runtime-reps.#!!!!!IIIIIIIIIIIIIIIIIIIIII#!IIIIIIIIIIII!III!I!IIII!II Safe-Inferred" "======="======= Safe-Inferred$X1ghcData Constructor Boxerghc/Unpack/Strictness decisions from source module.This function should only ever be invoked for data constructor fields, and never on the field of a newtype constructor. See Note [HsImplBangs for newtypes].ghcWrappers+Workers and representation following UnpackStrictness decisions"0000015—×ė˗̗͗ΗϗЗїҗӗԗ՗֗חؗٗڗۗܗݗޗߗҗӗ0ԗ0՗ݗ1ޗї0Ηڗ0ߗؗܗϗ5͗0˗ٗ֗ח̗Зۗ Safe-Inferred'+ NghcTurns a N computed for the particular  into a N unleashable at that arity. See Note [Understanding DmdType and StrictSig] in GHC.Types.DemandNghc Unpacks a N-shaped N and returns the field Ns wrapped in a N. Otherwise, it returns N with the appropriate N to assume for each field. The use of N( allows O(1) space for the common, non-N case.NghcThe arity of the wrapped N is the arity at which it is safe to unleash. See Note [Understanding DmdType and StrictSig] in GHC.Types.DemandNghcThe abstract domain A_t+ from the original 'CPR for Haskell' paper.NghcNumber of value arguments the denoted expression eats before returning the NNghcN) eventually unleashed when applied to N argumentsNghcThe result of N.NghcBNF: ``` cpr ::= '' -- TopCpr | n -- FlatConCpr n | n '(' cpr1 ',' cpr2 ',' ... ')' -- ConCpr n [cpr1,cpr2,...] | b -- BotCpr ``` Examples: * `f x = f x` has denotation b" * `1(1,)` is a valid (nested) N! denotation for `(I# 42#, f 42)`.NghcOnly print the CPR resultghc The number of field Cprs equals L&. If all of them are top, better use %, as ensured by the pattern synonym N.NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN| Safe-Inferred5Pu!ghcThe existentially-quantified type/coercion variables of the constructor including dependent (kind-) GADT equalities!ghc-The labels for the fields of this particular !!ghcThe "full signature" of the ! returns, in order:1) The result of L2) The result of !3) The non-dependent GADT equalities. Dependent GADT equalities are implied by coercion variables in return value (2).4) The other constraints of the data constructor type, excluding GADT equalities&5) The original argument types to the ! (i.e. before any change of the representation of the type) with linearity annotations#6) The original result type of the !!ghcReturns just the instantiated value argument types of a !, (excluding dictionary args)!ghcThe  of the !+, giving it a unique, rooted identification!ghc*Source-level arity of the data constructor!ghcThe "stupid theta" of the ! , such as  data Eq a in: data Eq a => T a = ...!ghcThe type constructor that we are building via this data constructor!ghcs for the type variables of the constructor, in the order the user wrote them!ghcThe type variables of the constructor, in the order the user wrote them!ghcGet the Id of the ! worker: a function that is the "actual" constructor and has no top level binding in the program. The type may be different from the obvious one written in the source program. Panics if there is no such  for this !!ghcReturns an Id which looks like the Haskell-source constructor by using the wrapper if it exists (see L') and failing over to the worker (see !)!ghcA data constructor : , ,!ghcData Constructor Representation See Note [Data constructor workers and wrappers]!ghcAn ! is a tyvar/type pair representing an equality made in rejigging a GADT constructorLghcEqualities derived from the result type of the data constructor, as written by the programmer in any GADT declaration. This includes *all* GADT-like equalities, including those written in by hand by the programmer.Lghc5Extract the type for any given labelled field of the !LghcExtract the label and type for any given labelled field of the ! , or return K# if the field does not belong to itLghc The string package:module.name identifying a constructor, which is attached to its info table and used by the GHCi debugger and the heap profilerLghc Find all the s implicitly brought into scope by the data constructor. Currently, the union of the ! and the !LghcFinds the instantiated types of the arguments required to construct a ! representation NB: these INCLUDE any dictionary args but EXCLUDE the data-declaration context, which is discarded It's all post-flattening etc; this is a representation typeLghcInstantiate the universal tyvars of a data con, returning ( instantiated existentials , instantiated constraints including dependent GADT equalities which are *also* listed in the instantiated existentials , instantiated args)Lghc Should the ! be presented infix?LghcReturns the argument types of the wrapper, excluding all dictionary arguments and without substituting for any type variablesLghcThe original type constructor used in the definition of this data constructor. In case of a data family instance, that will be the family type constructor.LghcReturns constraints in the wrapper type, other than those in the dataConEqSpecLghcReturns the arg types of the worker, including *all* non-dependent evidence, after any flattening has been done and without substituting for any type variablesLghc)Gives the number of actual fields in the representation of the data constructor. This may be more than appear in the source code; the extra ones are the existentially quantified dictionariesLghcGive the demands on the arguments of a Core constructor application (Con dc args)LghcThe representation type of the data constructor, i.e. the sort type that will represent values of this type at runtimeLghcStrictness/unpack annotations, from user; or, for imported DataCons, from the interface file The list is in one-to-one correspondence with the arity of the !LghcThe tag used for ordering !sLghcThe *full* constraints on the constructor type, including dependent GADT equalities.LghcBoth the universal and existential type/coercion variables of the constructorLghc b -> T [a] rather than: 3T :: forall a c. forall b. (c~[a]) => a -> b -> T cThe type variables are quantified in the order that the user wrote them. See )Note [DataCon user type variable binders].NB: If the constructor is part of a data instance, the result type mentions the family tycon, not the internal one.LghcCompare strictness annotationsLghcFilter out any s mentioned in an !.Lghc Is this the ! of a newtype?Lghc5Return whether there are any argument types for this !9s runtime representation type See Note [DataCon arities]Lghc5Return whether there are any argument types for this !2s original source type See Note [DataCon arities]LghcVanilla !8s are those that are nice boring Haskell 98 constructorsLghcBuild a new data constructorLghcMake a non-dependent !LghcShould this DataCon be allowed in a type even without -XDataKinds? Currently, only Lifted & UnliftedLghcExtract the type constructor, type argument, data constructor and it's representation4 argument types from a type if it is a product type.Precisely, we return Just" for any data type that is all of:$Concrete (i.e. constructors visible)Single-constructor... which has no existentialsWhether the type is a data type or a newtype.LghcSubstitute in an !. Precondition: if the LHS of the EqSpec is mapped in the substitution, it is mapped to a type variable, not a full type.LghcHaskell Implementation BangBangs of data constructor arguments as generated by the compiler after consulting HsSrcBang, flags, etc.Lghc(Lazy field, or one with an unlifted typeLghcStrict but not unpacked fieldLghc;Strict and unpacked field co :: arg-ty ~ product-ty HsBangLghcHaskell Source BangBangs on data constructor arguments as the user wrote them in the source code.(HsSrcBang _ SrcUnpack SrcLazy) and #(HsSrcBang _ SrcUnpack NoSrcStrict) (without StrictData) makes no sense, we emit a warning (in checkValidDataCon) and treat it like !(HsSrcBang _ NoSrcUnpack SrcLazy)LghcSource Strictness)What strictness annotation the user wroteLghcno strictness annotationLghc Lazy, ie ~Lghc Strict, ie !LghcSource Unpackedness$What unpackedness the user requestedLghcno unpack pragmaLghc{-# NOUNPACK #-} specifiedLghc{-# UNPACK #-} specifiedghcTag, used for ordering !sghcDependent (kind-level) equalities in a constructor. There are extracted from the existential variables. See Note [Existential coercion variables]LghcA datacon with no existentials or equality constraints However, it can have a dcTheta (notably it can be a class dictionary, with superclasses)ghcInstantiated at these typesLghc"Is the constructor declared infix?ghc#TyConRepName for the promoted TyConghc(Strictness/unpack annotations, from userghcField labels for the constructor, if it is a record, otherwise emptyghc Universals.ghc Existentials.ghc User-written "/s. These must be Inferred/Specified. See Note [TyVarBinders in DataCons]ghcGADT equalities ghc0Theta-type occurring before the arguments proper ghcOriginal argument types ghcOriginal result type ghcSee comments on ; ghcRepresentation type constructorghcConstructor tagghc:The "stupid theta", context of the data declaration e.g. data Eq a => T a ...ghc Worker IdghcRepresentationLghcA product type, perhaps!!!!!!!!!!!!!!!!LLLLLLL!LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL!!LLLLLLLLLLLLLLLLLLLLLLLL!LLLLLLLLLL!!LLL!LLLLL!L!!LL!LLLL!L!LLL!LL!!LLLLLLLLLLL!LLLLLLLLLLL! Safe-Inferred57k!Kghc-Allow the binding of any variable to any typeKghcK is sort of inverse to 0. In particular, if  liftCoMatch vars ty co == Just s, then liftCoSubst s ty == co , where == there means that the result of 0 has the same type as the original co; but may be different under the hood. That is, it matches a type against a coercion of the same "shape", and returns a lifting substitution which could have been used to produce the given coercion from the given type. Note that this function is incomplete -- it might return Nothing when there does indeed exist a possible lifting context.This function is incomplete in that it doesn't respect the equality in F. That is, it's possible that this will succeed for t1 and fail for t2, even when t1 F t2. That's because it depends on there being a very similar structure between the type and the coercion. This incompleteness shouldn't be all that surprising, especially because it depends on the structure of the coercion, which is a silly thing to do.The lifting context produced doesn't have to be exacting in the roles of the mappings. This is because any use of the lifting context will also require a desired role. Thus, this algorithm prefers mapping to nominal coercions where it can do so.KghcAllow binding only for any variable in the set. Variables may be bound to any type. Used when doing simple matching; e.g. can we find a substitution S = [a :-> t1, b :-> t2] such that S( Maybe (a, b->Int ) = Maybe (Bool, Char -> Int) KghcThis one is called from the expression matcher, which already has a MatchEnv in handKghctcMatchTy t1 t2) produces a substitution (over fvs(t1)) s such that s(t1) equals t2. The returned substitution might bind coercion variables, if the variable is an argument to a GADT constructor.Precondition: typeKind ty1 F typeKind ty2We don't pass in a set of "template variables" to be bound by the match, because tcMatchTy (and similar functions) are always used on top-level types, so we can bind any of the free variables of the LHS. See also Note [tcMatchTy vs tcMatchTyKi]KghcLike K, but allows the kinds of the types to differ, and thus matches them as well. See also Note [tcMatchTy vs tcMatchTyKi]KghcLike K but over a list of types. See also Note [tcMatchTy vs tcMatchTyKi]KghcLike K, but extending a substitution See also Note [tcMatchTy vs tcMatchTyKi]KghcThis is similar to K, but extends a substitution See also Note [tcMatchTy vs tcMatchTyKi]KghcLike K but over a list of types. See also Note [tcMatchTy vs tcMatchTyKi]KghcLike K, but extending a substitution See also Note [tcMatchTy vs tcMatchTyKi]KghcSimple unification of two types; all type variables are bindable Precondition: the kinds are already equalKghcLike K, but also unifies the kindsKghcLike K but also unifies the kindsKghcUnify two types, treating type family applications as possibly unifying with anything and looking through injective type family applications. Precondition: kinds are the sameKghctcUnifyTysFG bind_tv tys1 tys2! attempts to find a substitution s% (whose domain elements all respond K to bind_tv ) such that s(tys1) and that of s(tys2) are equal, as witnessed by the returned Coercions. This version requires that the kinds of the types are the same, if you unify left-to-right.KghcGiven a list of pairs of types, are any two members of a pair surely apart, even after arbitrary type function evaluation and substitution?Kghc#Declare that this type variable is apart from the type provided. That is, the type variable will never be instantiated to that type. See also Note [Binding when looking up instances] in GHC.Core.InstEnv.KghcA regular type variableKghc2Some unification functions are parameterised by a K, which says whether or not to allow a certain unification to take place. A K takes the  involved along with the !" it will potentially be bound to.It is possible for the variable to actually be a coercion variable (Note [Matching coercion variables]), but only when one-way matching. In this case, the ! will be a >.KghcWhy are two types K? K takes precedence: This is used (only) in Note [Infinitary substitution in lookup] in GHC.Core.InstEnvKghcmatching e.g. a ~? Maybe aKghcmatching e.g. F Int ~? BoolKghcSee Note [Unificiation result]ghcThis function is actually the one to call the unifier -- a little too general for outside clients, though.ghc does all the actual work for K.ghc=Same as tc_match_tys_x, but starts with an empty substitutionghc Worker for K and Kghc(Converts any SurelyApart to a MaybeApart Kghctemplate variablesghctype substitution to extendghcTemplateghcTargetKghcTemplateghcTargetghcOne-shot substitutionKghcSubstitution to extendghcTemplateghcTargetghcOne-shot substitutionKghcSubstitution to extendghcTemplateghcTargetKghcTemplateghcTargetghcOne-shot; in principle the template variables could be free in the targetKghcSubstitution to extendghcTemplateghcTargetghcOne-shot substitutionKghcTrue  =" do two-way unification; False  =: do one-way matching. See end of sec 5.2 from the paperKghcA regular one-shot (idempotent) substitution that unifies the erased types. See comments for KghcTrue  = unify; False  = matchghcTrue  = doing an injectivity checkghcTrue  = treat the kinds as wellghcsubstitution to extendghcambient helpful infoghcincoming substghcty, type to matchghcco, coercion to match againstghc/:: kind of L type of substed ty ~N L kind of coghc/:: kind of R type of substed ty ~N R kind of coghc match kinds?ghc match kinds?'KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK'KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK  Safe-Inferred}@?ghcGiven a covar and a coercion, returns True if covar is almost devoid in the coercion. That is, covar can only appear in Refl and GRefl. See last wrinkle in Note [Unused coercion variable in ForAllCo] in GHC.Core.Coercion?ghcAdd the kind variables free in the kinds of the tyvars in the given set. Returns a deterministic set.?ghcAdd the kind variables free in the kinds of the tyvars in the given set. Returns a deterministically ordered list.?ghc Returns the free variables of a ! that are in injective positions. Specifically, it finds the free variables while:Expanding type synonymsIgnoring the coercion in  (ty |> co)'Ignoring the non-injective fields of a >For example, if F& is a non-injective type family, then: 9injectiveTyVarsOf( Either c (Maybe (a, F b c)) ) = {a,c} If ? ty = itvs, then knowing ty fixes itvs. More formally, if a is in ? ty and S1(ty) ~ S2(ty), then S1(a) ~ S2(a) , where S1 and S2 are arbitrary substitutions.See Note [When does a tycon application need an explicit kind signature?].?ghc Returns the free variables of a ! that are in injective positions. Specifically, it finds the free variables while:Expanding type synonymsIgnoring the coercion in  (ty |> co)'Ignoring the non-injective fields of a >See Note [When does a tycon application need an explicit kind signature?].?ghcReturns the set of variables that are used invisibly anywhere within the given type. A variable will be included even if it is used both visibly and invisibly. An invisible use site includes: * In the kind of a variable * In the kind of a bound variable in a forall * In a coercion * In a Specified or Inferred argument to a function See Note [VarBndrs, TyCoVarBinders, TyConBinders, and visibility] in GHC.Core.TyCo.Rep?ghcLike ?, but for many types.?ghcDo a topological sort on a list of tyvars, so that binders occur before occurrences E.g. given [ a::k, k::*, b::k ] it'll return a well-scoped list [ k::*, a::k, b::k ]This is a deterministic sorting operation (that is, doesn't depend on Uniques).It is also meant to be stable: that is, variables should not be reordered unnecessarily. This is specified in Note [ScopedSort] See also Note [Ordering of implicit variables] in GHC.Rename.HsType?ghcReturns free variables of types, including kind variables as a non-deterministic set. For type synonyms it does not expand the synonym.?ghcThe worker for ? and tyCoFVsOfTypeList$. The previous implementation used ( which is O(n+m) and can make the function quadratic. It's exported, so that it can be composed with other functions that compute free variables. See Note [FV naming conventions] in  GHC.Utils.FV.Eta-expanded because that makes it run faster (apparently) See Note [FV eta expansion] in  GHC.Utils.FV for explanation.?ghc6Get a deterministic set of the vars free in a coercion?ghc? that returns free variables of a type in a deterministic set. For explanation of why using (6 is not deterministic see Note [Deterministic FV] in  GHC.Utils.FV.?ghc? that returns free variables of a type in deterministic order. For explanation of why using (6 is not deterministic see Note [Deterministic FV] in  GHC.Utils.FV.?ghc+Get the free vars of a type in scoped order?ghcReturns free variables of types, including kind variables as a deterministic set. For type synonyms it does not expand the synonym.?ghcReturns free variables of types, including kind variables as a deterministically ordered list. For type synonyms it does not expand the synonym.?ghc*Get the free vars of types in scoped orderghcGiven a list of tyvars returns a deterministic FV computation that returns the given tyvars with the kind variables free in the kinds of the given tyvars.?ghcShould we look under injective type families? See Note [Coverage condition for injective type families] in GHC.Tc.Instance.Family.?ghclook under injective type families? See Note [Coverage condition for injective type families] in GHC.Tc.Instance.Family.2???????????????????????????????????????????????2??????????????????????????????????????????????? Safe-Inferred  JghcSynthesizes a  DeBruijn a from an a9, by assuming that there are no bound binders (an empty K<). This is usually what you want if there isn't already a K in scope.Kghc Extend a K$ with a type in the given context. 8extendTypeMapWithScope m (mkDeBruijnContext [a,b,c]) t v is equivalent to #extendTypeMap m (forall a b c. t) v<, but allows reuse of the context over multiple insertions.KghcConstruct a deBruijn environment with the given variables in scope. e.g. mkDeBruijnEnv [a,b,c] constructs a context  forall a b c.KghcA K is a K which allows us to distinguish between binding forms whose binders have different types. For example, if we are doing a H lookup on (x :: Int) -> ()), we should not pick up an entry in the H for (x :: Bool) -> (): we can disambiguate this by matching on the type (or kind, if this a binder in a type) of the binder.We also need to do the same for multiplicity! Which, since multiplicities are encoded simply as a !, amounts to have a Trie for a pair of types. Tries of pairs are composition.Kghc DeBruijn a represents a modulo alpha-renaming. This is achieved by equipping the value with a K, which tracks an on-the-fly deBruijn numbering. This allows us to define an ' instance for  DeBruijn a., even if this was not (easily) possible for a. Note: we purposely don't export the constructor. Make a helper function if you find yourself needing it.KghcA K doesn't do a kind-check. Thus, when lookup up (t |> g), you'll find entries inserted under (t), even if (g) is non-reflexive.Kghc TypeMap a is a map from ! to a. If you are a client, this is the type you want. The keys in this map may have different kinds.Kghc TypeMapG a is a map from  DeBruijn Type to a. The extended key makes it suitable for recursive traversal, since it can track binders, but it is strictly internal to this module. If you are including a K inside another H, this is the type you want. Note that this lookup does not do a kind-check. Thus, all keys in this map must have the same kind. Also note that this map respects the distinction between Type and  Constraint, despite the fact that they are equivalent type synonyms in Core.ghc TypeMapX a is the base map from  DeBruijn Type to a, but without the H optimization. See Note [Computing equality on types] in GHC.Core.Type.ghcSqueeze out any synonyms, and change TyConApps to nested AppTys. Why the last one? See Note [Equality on AppTys] in GHC.Core.TypeNote, however, that we keep Constraint and Type apart here, despite the fact that they are both synonyms of TYPE 'LiftedRep (see #11715).We also keep (Eq a => a) as a FunTy, distinct from ((->) (Eq a) a).&HHHHHHHHHJJJJKKKKKKKKKKKKKKKKKKKKKKKKK&HHHHHHHHHKJKKKKKKKKKJKJKKKKJKKKKKKKKKK Safe-Inferred HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH1H1H1y Safe-Inferred}0ghcIf it is the case that c :: (t1 ~ t2)i.e. the kind of c relates t1 and t2, then coercionKind c = Pair t1 t2.0ghcTests if this coercion is obviously a generalized reflexive coercion. Guaranteed to work very quickly.0ghcTests if this coercion is obviously reflexive. Guaranteed to work very quickly. Sometimes a coercion can be reflexive, but not obviously so. c.f. 00ghcSlowly checks if the coercion is reflexive. Don't call this in a loop, as it walks over the entire coercion.0ghcliftCoSubst role lc ty produces a coercion (at role role) that coerces between  lc_left(ty) and  lc_right(ty) , where lc_left is a substitution mapping type variables to the left-hand types of the mapped coercions in lc, and similar for lc_right.0ghcApply a ! to another !. The second coercion must be Nominal, unless the first is Phantom. If the first is Phantom, then the second can be either Phantom or Nominal.0ghcMakes a coercion type from two types: the types whose equality is proven by the relevant !0ghcMake a Coercion from a tycovar, a kind coercion, and a body coercion. The kind of the tycovar should be the left-hand kind of the kind coercion. See Note [Unused coercion variable in ForAllCo]0ghcBuild a function ! from two other !s. That is, given  co1 :: a ~ b and  co2 :: x ~ y produce co :: (a -> x) ~ (b -> y).0ghc%Make a generalized reflexive coercion0ghcInstantiates a !.0ghcGiven co :: (a :: k) ~ (b :: k') produce  co' :: k ~ k'.0ghc!Make a nominal reflexive coercion0ghcMake a phantom coercion between two types. The coercion passed in must be a nominal coercion between the kinds of the types.0ghc$Make a "coercion between coercions".0ghcMake a reflexive coercion0ghc(Create a symmetric version of the given ! that asserts equality between the same types but in the other "direction", so a kind of t1 ~ t2 becomes the kind t2 ~ t1.0ghc Create a new ! by composing the two given !s transitively. (co1 ; co2)0ghcApply a type constructor to a list of coercions. It is the caller's responsibility to get the roles correct on argument coercions.0ghc6Make a universal coercion between two arbitrary types.IghcAssuming that two types are the same, ignoring coercions, find a nominal coercion between the types. This is useful when optimizing transitivity over coercion applications, where splitting two AppCos might yield different kinds. See Note [EtaAppCo] in GHC.Core.Coercion.Opt.IghcCreates a new coercion with both of its types casted by different casts castCoercionKind g h1 h2, where  g :: t1 ~r t2 , has type (t1 |> h1) ~r (t2 |> h2). h1 and h2 must be nominal. It calls coercionKindRole#, so it's quite inefficient (which I stands for) Use castCoercionKind2 instead if t1, t2, and r are known beforehand.IghccastCoercionKind1 g r t1 t2 h = coercionKind g r t1 t2 h h That is, it's a specialised form of castCoercionKind, where the two kind coercions are identical castCoercionKind1 g r t1 t2 h, where  g :: t1 ~r t2 , has type (t1 |> h) ~r (t2 |> h). h/ must be nominal. See Note [castCoercionKind1]IghcCreates a new coercion with both of its types casted by different casts !castCoercionKind2 g r t1 t2 h1 h2, where  g :: t1 ~r t2 , has type (t1 |> h1) ~r (t2 |> h2). h1 and h2 must be nominal.Ighc4Extract out all the coercion holes from a given typeIghcGet a coercion's kind and role.IghcApply 0 to multiple !sIghc"Retrieve the role from a coercion.IghcTry one stepper and then try the next, if the first doesn't make progress. So if it returns NS_Done, it means that both steppers are satisfiedIghcThis breaks a ! with type T A B C ~ T D E F into a list of ! s of kinds A ~ D, B ~ E and E ~ F. Hence: decomposeCo 3 c [r1, r2, r3] = [nth r1 0 c, nth r2 1 c, nth r3 2 c]IghcLike , but panics if the change isn't a downgrade. See Note [Role twiddling functions]IghcSyntactic equality of coercionsIghc Compare two !s, with respect to an RnEnv2Ighc,Extend a lifting context with a new mapping.IghcExtend a lifting context with a new mapping, and extend the in-scope setIghc2Attempts to obtain the type variable underlying a !Ighc*Is there a coercion hole in this coercion?Ighc&Is there a coercion hole in this type?IghcIf co :: T ts ~ rep_ty then: +instNewTyCon_maybe T ts = Just (rep_ty, co)-Checks for a newtype, and for being saturatedIghcExtract a covar, if possible. This check is dirty. Be ashamed of yourself. (It's dirty because it cares about the structure of a coercion, which is morally reprehensible.)IghcReturns the type coerced if this coercion is a generalized reflexive coercion. Guaranteed to work very quickly.IghcTests if this MCoercion is obviously generalized reflexive Guaranteed to work very quickly.Ighc,Is a var in the domain of a lifting context?IghcReturns the type coerced if this coercion is reflexive. Guaranteed to work very quickly. Sometimes a coercion can be reflexive, but not obviously so. c.f. IIghcExtracts the coerced type from a reflexive coercion. This potentially walks over the entire coercion, so avoid doing this in a loop.IghcGet the ) from a 0Jghc;Extract the underlying substitution from the LiftingContextJghcApplies multiple ! s to another ! , from left to right. See also 0.JghcReturn the left-hand type of the axiom, when the axiom is instantiated at the types given.JghcCast a type by an !JghcGiven ty :: k1,  co :: k1 ~ k2, co2:: ty ~r ty', produces @co' :: (ty |> co) ~r ty' It is not only a utility function, but it saves allocation when co is a GRefl coercion.JghcGiven ty :: k1,  co :: k1 ~ k2, co2:: ty' ~r ty, produces @co' :: ty' ~r (ty |> co) It is not only a utility function, but it saves allocation when co is a GRefl coercion.JghcLike J, but with an !JghcGiven a family instance   and its arg !$s, return the corresponding family !. E.g: 1data family T a data instance T (Maybe b) = MkT bWhere the instance   is :RTL, so: mkFamilyTyConAppCo :RTL (co :: a ~# Int) = T (Maybe a) ~# T (Maybe Int)cf. FJghcMake nested ForAllCosJghcGiven ty :: k1,  co :: k1 ~ k2 , produces co' :: (ty |> co) ~r tyJghcGiven ty :: k1,  co :: k1 ~ k2 , produces co' :: ty ~r (ty |> co)Jghc?Creates a primitive type equality predicate with explicit kindsJghcCreates a primitive representational type equality predicate with explicit kindsJghc$Make a coercion from a coercion holeJghcMake a Coercion quantified over a type/coercion variable; the variable has the same type in both sides of the coercionJghc Extract the nth field of a FunCoJghcMake a forall !, where both types related by the coercion are quantified over the same variable.JghcCreates a primitive type equality predicate. Invariant: the types are not CoercionsJghc3Makes a lifted equality predicate at the given roleJghc*Make a representational reflexive coercionJghcGet the reverse of an !Jghc'Compose two MCoercions via transitivityJghc5Instantiate the left-hand side of an unbranched axiomJghcIf you're about to call mkNthCo r n co, then r should be whatever nthCoRole n co returns.Jghclike mkKindCo, but aggressively & recursively optimizes to avoid using a KindCo constructor. The output role is nominal.JghcConverts a coercion to be nominal, if possible. See Note [Role twiddling functions]Jghc-Attempt to take a coercion application apart.JghcLike J(, but only returns Just for covar binderJghcLike J(, but only returns Just for tyvar binderJghcAttempts to tease a coercion apart into a type constructor and the application of a number of coercion arguments to that constructorJghcLike @ , but works on a lifting contextJghc"Apply "sym" to all coercions in a JJghc$Sometimes we want to look through a newtype< and get its associated coercion. This function strips off newtype1 layers enough to reveal something that isn't a newtype&. Specifically, here's the invariant: 5topNormaliseNewType_maybe rec_nts ty = Just (co, ty') then (a)  co : ty ~ ty'". (b) ty' is not a newtype.The function returns Nothing for non-newtypes, or unsaturated applicationsThis function does *not* look through type families, because it has no access to the type family environment. If you do have that at hand, consider to use topNormaliseType_maybe, which should be a drop-in replacement for topNormaliseNewType_maybe If topNormliseNewType_maybe ty = Just (co, ty'), then co : ty ~R ty'JghcA general function for normalising the top-level of a type. It continues to use the provided J until that function fails, and then this function returns. The roles of the coercions produced by the J must all be the same, which is the role returned from the call to J.Typically ev is Coercion.If topNormaliseTypeX step plus ty = Just (ev, ty') then ty ~ev1~ t1 ~ev2~ t2 ... ~evn~ ty' and ev = ev1 plus ev2 plus ... plus evn If it returns Nothing then no newtype unwrapping could happenJghcA J that unwraps newtypes, careful not to fall into a loop. If it would fall into a loop, it produces J.Jghc+Erase the environments in a lifting contextJghc A set of >sJghc9The result of stepping in a normalisation function. See J.Jghc2Utter failure. The outer function should fail too.JghcNothing more to doJghcWe stepped, yielding new bits; ^ ev is evidence; Usually a co :: old type ~ new typeJghcA function to check if we can reduce a type by one step. Used with J.ghcThe "lifting" operation which substitutes coercions for type variables in a type to produce a coercion.For the inverse operation, see  liftCoMatchghcLike 0, but the inner coercion shouldn't be an obvious reflexive coercion. For example, it is guaranteed in J. The kind of the tycovar should be the left-hand kind of the kind coercion.ghcGiven a coercion &co1 :: (a :: TYPE r1) ~ (b :: TYPE r2), produce a coercion rep_co :: r1 ~ r2.ghcLike J, but the inner coercion shouldn't be an obvious reflexive coercion. For example, it is guaranteed in J.ghcChanges a role, but only a downgrade. See Note [Role twiddling functions]ghcsay g = promoteCoercion h. Then, instCoercion g w yields Just g' , where g' = promoteCoercion (h w)%. fails if this is not possible, if g coerces between a forall and an -> or if second parameter has a representational role and can't be used with an InstCo.ghcRepeated use of ghcExtend a lifting context with existential-variable bindings. See Note [extendLiftingContextEx] 0ghc :: t1 ~r t2ghc%:: s1 ~N s2, where s1 :: k1, s2 :: k2ghc:: t1 s1 ~r t2 s20ghc!role of the created coercion, "r"ghc:: phi1 ~N phi2ghc g1 :: phi1ghc g2 :: phi2ghc :: g1 ~r g20ghcrole of the built coercion, "r"ghct1 :: k1ghct2 :: k2ghc :: t1 ~r t2Ighc original LCghcnew variable to map...ghc...to this lifted versionIghc Original LCghcnew variable to map...ghcto this coercionJghc"n"ghcmultiplicity coercionghcargument coercionghcresult coercionghcnth coercion from a FunCo See Note [Function coercions] If FunCo _ mult arg_co res_co :: (s1:TYPE sk1 :mult-> s2:TYPE sk2) ~ (t1:TYPE tk1 :mult-> t2:TYPE tk2) Then we want to behave as if co was TyConAppCo mult argk_co resk_co arg_co res_co where argk_co :: sk1 ~ tk1 = mkNthCo 0 (mkKindCo arg_co) resk_co :: sk2 ~ tk2 = mkNthCo 0 (mkKindCo res_co) i.e. mkRuntimeRepCoghc desired roleghc current roleghcmust be nominalghcoriginal lifting contextghcex. var / value pairs!!!>>!!!"""00000000000000000000000000000000000000J>>>>>>>>>>???????????????????@IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJ!!>>!>>!>!>>>>>>"0000JII0000000III00J00JJJJJJJJJJ000JJ000J00J0JJ0J0000I0JJJJ0IIIJJJJJJJIJJJJJIJJJJII0IJJJJJJJJJJ00II0IIIJJJIJJJJJJJJII""IJJI??????>?@??????????0JJJIIIJIJJJJIJ0JJJJJJIJII0!IJJJJJI??JIJJIIJII Safe-Inferred'oghcA more efficient version of X when we have several arguments. The first argument is just for debugging, and gives some contextoghcbindNonRec x r b produces either: let x = r in bor: case r of x { _DEFAULT_ -> b }&depending on whether we have to use a case or let" binding for the expression (see o). It's used by the desugarer to avoid building bindings that give Core Lint a heart attack, although actually the simplifier deals with them perfectly well. See also oghcA cheap equality test which bales out fast! If it returns True the arguments are definitely equal, otherwise, they may or may not be equal.oghc9Cheap expression equality test, can ignore ticks by type.oghc-collectMakeStaticArgs (makeStatic t srcLoc e) yields Just (makeStatic, t, srcLoc, e).Returns Nothing for every other expression.oghc4Returns the type of the alternatives right hand sideoghcReturns the type of the first alternative, which should be the same as for all alternativesoghc-Finds differences between core bindings, see diffExpr.The main problem here is that while we expect the binds to have the same order in both lists, this is not guaranteed. To do this properly we'd either have to do some sort of unification or check all possible mappings, which would be seriously expensive. So instead we simply match single bindings as far as we can. This leaves us just with mutually recursive and/or mismatching bindings, which we then speculatively match by ordering them. It's by no means perfect, but gets the job done well enough.oghcFinds differences between core expressions, modulo alpha and renaming. Setting top means that the IdInfo6 of bindings will be checked for differences as well.oghc Similar to o but includes CONLIKE functions as well as data constructors. Conlike arguments are considered interesting by the inliner.oghc:exprIsHNF returns true for expressions that are certainly already evaluated to head normal form. This is used to decide whether it's ok to change: case x of _ -> einto: e-and to decide whether it's safe to discard a . So, it does not treat variables as evaluated, unless they say they are. However, it does treat partial applications and constructor applications as values, even if their arguments are non-trivial, provided the argument type is lifted. For example, both of these are values: &(:) (f x) (map f xs) map (...redex...)because & on such things completes immediately.3For unlifted argument types, we have to be careful: C (f x :: Int#)Suppose f x diverges; then C (f x)1 is not a value. However this can't happen: see GHC.Core#let_app_invariant. This invariant states that arguments of unboxed type must be ok-for-speculation (or trivial).oghcCheck if the expression is zero or more Ticks wrapped around a literal string.oghcExtract a literal string from an expression that is zero or more Ticks wrapped around a literal string. Returns Nothing if the expression has a different shape. Used to "look through" Ticks in places that need to handle literal strings.oghcCan we bind this Y at the top level?oghco' returns True of an expression that is:Safe to evaluate even if normal order eval might not evaluate the expression at all, orSafe not- to evaluate even if normal order would do soIt is usually called on arguments of unlifted type, but not always In particular, Simplify.rebuildCase calls it on lifted types when a 'case' is a plain . See the example in Note [exprOkForSpeculation: case expressions] belowPrecisely, it returns True iff: a) The expression guarantees to terminate, b) soon, c) without causing a write side effect (e.g. writing a mutable variable) d) without throwing a Haskell exception e) without risking an unchecked runtime exception (array out of bounds, divide by zero)For exprOkForSideEffects( the list is the same, but omitting (e).Note that exprIsHNF implies exprOkForSpeculation exprOkForSpeculation implies exprOkForSideEffects3See Note [PrimOp can_fail and has_side_effects] in GHC.Builtin.PrimOps and Note [Transformations affected by can_fail and has_side_effects];As an example of the considerations in this test, consider: -let x = case y# +# 1# of { r# -> I# r# } in Ebeing translated to: 3case y# +# 1# of { r# -> let x = I# r# in E }We can only do this if the y + 1 is ok for speculation: it has no side effects, and can't diverge or raise an exception.oghco' returns True of an expression that is:Safe to evaluate even if normal order eval might not evaluate the expression at all, orSafe not- to evaluate even if normal order would do soIt is usually called on arguments of unlifted type, but not always In particular, Simplify.rebuildCase calls it on lifted types when a 'case' is a plain . See the example in Note [exprOkForSpeculation: case expressions] belowPrecisely, it returns True iff: a) The expression guarantees to terminate, b) soon, c) without causing a write side effect (e.g. writing a mutable variable) d) without throwing a Haskell exception e) without risking an unchecked runtime exception (array out of bounds, divide by zero)For exprOkForSideEffects( the list is the same, but omitting (e).Note that exprIsHNF implies exprOkForSpeculation exprOkForSpeculation implies exprOkForSideEffects3See Note [PrimOp can_fail and has_side_effects] in GHC.Builtin.PrimOps and Note [Transformations affected by can_fail and has_side_effects];As an example of the considerations in this test, consider: -let x = case y# +# 1# of { r# -> I# r# } in Ebeing translated to: 3case y# +# 1# of { r# -> let x = I# r# in E }We can only do this if the y + 1 is ok for speculation: it has no side effects, and can't diverge or raise an exception.oghcRecover the type of a well-typed Core expression. Fails when applied to the actual Z7 expression as it cannot really be said to have a typeoghcFind the case alternative corresponding to a particular constructor: panics if no such constructor existsoghc$Extract the default case alternativeoghcTrue if the type has no non-bottom elements, e.g. when it is an empty datatype, or a GADT with non-satisfiable type parameters, e.g. Int :~: Bool. See Note [Bottoming expressions]See Note [No alternatives lint check] for another use of this function.oghcIs this expression levity polymorphic? This should be the same as saying (isKindLevPoly . typeKind . exprType) but much faster.oghcDoes this binding bind a join point (or a recursive group of join points)?oghcMerge alternatives preserving order; alternatives in the first argument shadow ones in the secondoghcThis guy constructs the value that the scrutinee must have given that you are in one particular branch of a caseoghcWrap the given expression in the coercion safely, dropping identity coercions and coalescing nested coercionsoghcMakes a (->) type or an implicit forall type, depending on whether it is given a type variable or a term variable. This is used, for example, when producing the type of a lambda. Always uses Inferred binders.oghco% for multiple type or value argumentsoghcWraps the given expression in the source annotation, dropping the annotation if possible.oghcTests whether we have to use a case rather than let7 binding for this expression as per the invariants of Y: see GHC.Core#let_app_invariantoghc$Refine the default alternative to a Y, if there is a unique way to do so. See Note [Refine DEFAULT case alternatives]oghcCompletely strip ticks satisfying a predicate from an expression. Note this is O(n) in the size of the expression!oghc ...We want to drop the leading type argument of the scrutinee leaving the arguments to match against the patternghcReturns true for values or value-like expressions. These are lambdas, constructors / CONLIKE functions (as determined by the function argument) or PAPs.ghcFind differences in IdInfo. We will especially check whether the unfoldings match, if present (see  diffUnfold).ghcFind differences in unfoldings. Note that we will not check for differences of IdInfo in unfoldings, as this is generally redundant, and can lead to an exponential blow-up in complexity.ghc)Add location information to diff messagesoghcType constructor of scrutinee's type (used to prune possibilities)ghcAnd its type argumentsghc imposs_cons: constructors known to be impossible due to the form of the scrutineeghc AlternativesoghcCase alternative constructorghc!Things bound by the pattern matchghc*The type arguments to the case alternativeoghc$Uniques for constructing new bindersghc.Multiplicity annotation of the case expressionghc$Type constructor of scrutinee's typeghc"Type arguments of scrutinee's typeghc3Constructors that cannot match the DEFAULT (if any)ghcM', if a default alt was replaced with a YIXYYoooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooIooooooooooooooooooooooooooooYYoXoooooooooooo Safe-InferredJghc3Get the equality relation relevant for a pred type.Jghc>A choice of equality relation. This is separate from the type 0 because 03 does not define a (non-trivial) equality relation.JghcA predicate in the solver. The solver tries to prove Wanted predicates from Given ones.'!"JJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJ'JJJJJJ!JJJJJJJJJJJJJJJJJJJJJJJJJJJJJ"JJ Safe-InferredZ>ghc8The default upper bound (100) for the number of times a > is allowed to encounter each  .>ghc Initialise a > with >.>ghc1Change the upper bound for the number of times a > is allowed to encounter each  .>>>>>>>>>> Safe-InferredK>ghcDeterministic TyCon Environment#See Note [Deterministic UniqFM] in GHC.Types.Unique.DFM( for explanation why we need DTyConEnv.>ghcTyCon Environment&===========>>>>>>>>>>>>>>>>>>>>>>>>>>>&>>>=>>>>>>>>>=>>>>=>>===>=>=>>=>>>==>> Safe-InferredcIghcmkMultSup w1 w2" returns a multiplicity such that mkMultSup w1 w2 >= w1 and mkMultSup w1 w2 >= w2.. See Note [Overapproximating multiplicities].Ighc submult w1 w2' check whether a value of multiplicity w1+ is allowed where a value of multiplicity w2& is expected. This is a partial order.!!>>>>FFFFFFGGIIIIIIIII!FFIIII!>>>GFGFFFIIIII>} Safe-Inferred!!ghc "type LiftedRep = 'BoxedRep 'Lifted!ghcBuild the type of a small tuple that holds the specified type of thing Flattens 1-tuples. See Note [One-tuples].!ghcMake a *promoted* list.!ghc=Data constructor for i-th alternative of a n-ary unboxed sum.!ghc'Type constructor for n-ary unboxed sum.!ghcSpecialization of  for tuples!ghc &type UnliftedRep = 'BoxedRep 'Unlifted!ghc .type UnliftedType = TYPE ('BoxedRep 'Unlifted)]ghcIf the given name is that of a constraint tuple, return its arity.]ghc>Replaces constraint tuple names with corresponding boxed ones.]ghcBuilt-in syntax isn't "in scope" so these OccNames map to wired-in Names with BuiltInSyntax. However, this should only be necessary while resolving names produced by Template Haskell splices since we take care to encode built-in syntax names specially in interface files. See Note [Symbol table representation of names].Moreover, there is no need to include names of things that the user can't write (e.g. type representation bindings like $tc(,,,)).]ghcMake a fake, recovery   from an existing one. Used when recovering from errors in type declarations]ghc,Make a tuple type. The list of types should not include any RuntimeRep specifications. Boxed 1-tuples are flattened. See Note [One-tuples]]ghc,Make a tuple type. The list of types should not include any RuntimeRep specifications. Boxed 1-tuples are *not* flattened. See Note [One-tuples] and Note [Don't flatten tuples from HsSyn] in  GHC.Core.Make^ghcSpecialization of  for sumsghcCached type constructors, data constructors, and superclass selectors for constraint tuples. The outer array is indexed by the arity of the constraint tuple and the inner array is indexed by the superclass position.ghcCached type and data constructors for sums. The outer array is indexed by the arity of the sum and the inner array is indexed by the alternative.ghcGiven the TupleRep/SumRep tycon and list of RuntimeReps of the unboxed tuple;sum arguments, produces the return kind of an unboxed tuplesum type constructor. unboxedTupleSumKind [IntRep, LiftedRep] --> TYPE (TupleRep/SumRep [IntRep, LiftedRep])ghc/OccName for n-ary unboxed sum type constructor.ghcOccName for i-th alternative of n-ary unboxed sum data constructor.ghcCreate type constructor and data constructors for n-ary unboxed sum.ghcExtract the elements of a promoted list. Panics if the type is not a promoted list!ghcof the elements of the listghcelementsghcdeclared infix?ghc datacon nameghc univ tyvarsghc ex tycovarsghcuser-written tycovarsghcargsghcThe promoted list!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!""""""""57:]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^]]^]]]]]^^^]]]^^^^^^^^^^^^]]]]!^]^]]]]]]]]]]]]]]^^^^^^^!]]5^^7]]]^^]!^^^^]]^^^]]^]]]]]!]!!!^!^^^!^^^]]^^^!^]]!]]]!!]]!]]!]]!!^!:^!!!!!]!!]]^]^!]]]]]]]]!]]]!!!!!!!!!!^!^!!!!!!!"""""!!!!!!!!!!!!!"!""!!]^]!!^]!!!!!!^!]]]]]]]]!]^]]]] Safe-Inferred5&62*ghc>The module in which the name pointed to by the GRE is defined.*ghc.The SrcSpan of the name pointed to by the GRE.*ghc2Returns the field label of this GRE, if it has one*ghcA - for the GRE for internal use. Careful: the   of this $ is not necessarily the same as the * (see Note [GreNames]).*ghcSee Note [GreNames]*ghcA 3 for the GRE suitable for output to the user. Its   will be the * (see Note [GreNames]).+ghcmake a + where all the elements point to the same Provenance (useful for "hiding" imports, or imports with no details).+ghcTakes a list of distinct GREs and folds them into AvailInfos. This is more efficient than mapping each individual GRE to an AvailInfo and the folding using *& but needs the uniqueness assumption.+ghcIs this a record field defined with DuplicateRecordFields? (See Note [GreNames])+ghcIs this a record field defined with FieldSelectors? (See Note [NoFieldSelectors] in GHC.Rename.Env)+ghcIs this a record field defined with NoFieldSelectors? (See Note [NoFieldSelectors] in GHC.Rename.Env)+ghcLook for a particular record field selector in the environment, where the selector name and field label may be different: the GlobalRdrEnv is keyed on the label. See Note [GreNames] for why this happens.+ghcLook for precisely this * in the environment. This tests whether it is in scope, ignoring anything else that might be in scope with the same  .+ghcLook for precisely this  in the environment. This tests whether it is in scope, ignoring anything else that might be in scope with the same  .+ghcLook for precisely this ! in the environment, but with an  % that might differ from that of the . See + and Note [GreNames].+ghcLook for this + in the global environment. Omits record fields without selector functions (see Note [NoFieldSelectors] in GHC.Rename.Env).+ghcLook for this + in the global environment. Includes record fields without selector functions (see Note [NoFieldSelectors] in GHC.Rename.Env).+ghcMake a qualified +& in the given namespace and where the  and the   are taken from the first and second elements of the tuple respectively+ghc.Indicate if the given name is the "@" operator+ghc2Takes a list of GREs which have the right OccName x: Pick those GREs that are in scope * Qualified, as 4 if want_qual is Qual M _ * Unqualified, as x if want_unqual is Unqual _Return each such GRE, with its ImportSpecs filtered, to reflect how it is in scope qualified or unqualified respectively. See Note [GRE filtering]+ghcPick GREs that are in scope *both* qualified *and* unqualified Return each GRE that is, as a pair (qual_gre, unqual_gre) These two GREs are the original GRE with imports filtered to express how it is in scope qualified an unqualified respectively9Used only for the 'module M' item in export list; see +ghcPrint out one place where the name was define/imported (With -dppr-debug, print them all)+ghc,Is in scope qualified with the given module?+ghc$Display info about the treatment of  under NoStarIsType.%With StarIsType, three properties of  hold:(a) it is not an infix operator (b) it is always in scope (c) it is a synonym for Data.Kind.TypeHowever, the user might not know that they are working on a module with NoStarIsType and write code that still assumes (a), (b), and (c), which actually do not hold in that module.Violation of (a) shows up in the parser. For instance, in the following examples, we have ! not applied to enough arguments:data A :: * data F :: * -> *Violation of (b) or (c) show up in the renamer and the typechecker respectively. For instance:type K = Either * BoolThis will parse differently depending on whether StarIsType is enabled, but it will parse nonetheless. With NoStarIsType it is parsed as a type operator, thus we have ((*) Either Bool). Now there are two cases to consider: There is no definition of (*) in scope. In this case the renamer will fail to look it up. This is a violation of assumption (b).There is a definition of the (*) type operator in scope (for example coming from GHC.TypeNats). In this case the user will get a kind mismatch error. This is a violation of assumption (c).The user might unknowingly be working on a module with NoStarIsType or use  as  out of habit. So it is important to give a hint whenever an assumption about  is violated. Unfortunately, it is somewhat difficult to deal with (c), so we limit ourselves to (a) and (b).+ generates an appropriate hint to the user depending on the extensions enabled in the module and the name that triggered the error. That is, if we have NoStarIsType and the error is related to  or its Unicode variant, the resulting SDoc will contain a helpful suggestion. Otherwise it is empty.+ghc>Apply a transformation function to the GREs for these OccNames+ghc>Test if an unqualified version of this thing would be in scope+ghcIs in scope unqualified?+ghcGlobal Reader ElementAn element of the ++ghcIn scope through these imports+ghcTrue  = the thing was defined locally+ghcSee Note [GreNames]+ghcSee Note [Parents]+ghcGlobal Reader Environment Keyed by  3; when looking up a qualified name we look up the   part, and then check the  Provenance to see if the appropriate qualification is valid. This saves routinely doubling the size of the env by adding both qualified and unqualified names to the domain.The list in the codomain is required because there may be name clashes These only get reported on lookup, not on constructionINVARIANT 1: All the members of the list have distinct +$ fields; that is, no duplicate NamesINVARIANT 2: Imported provenance => Name is an ExternalName However LocalDefs can have an InternalName. This happens only when type-checking a [d| ... |] Template Haskell quotation; see this note in GHC.Rename.Names Note [Top-level Names in Template Haskell decl quotes]INVARIANT 3: If the GlobalRdrEnv maps [occ -> gre], then greOccName gre = occNB: greOccName gre is usually the same as nameOccName (greMangledName gre), but not always in the case of record selectors; see Note [GreNames]+ghc Import Declaration SpecificationDescribes a particular import declaration and is shared among all the  Provenances for that decl+ghcImport alias, e.g. from as M (or Muggle if there is no as clause)+ghc-The location of the entire import declaration+ghcModule imported, e.g.  import Muggle Note the Muggle5 may well not be the defining module for this thing!+ghcWas this import qualified?+ghcImport Item Specification'Describes import info a particular Name+ghc4The import had no import list, or had a hiding list+ghc$The import had an import list. The + field is True iff the thing was named  explicitly in the import specs rather than being imported as part of a "..." group. Consider: import C( T(..) )Here the constructors of T! are not named explicitly; only T is named explicitly.+ghcImport SpecificationThe + of something says how it came to be imported It's quite elaborate so that we can give accurate unused-name warnings.+ghc0Local Reader Environment See Note [LocalRdrEnv]+ghcSee Note [Parents]+ghc Reader NameDo not use the data constructors of RdrName directly: prefer the family of functions that creates them, such as +Note: A Located RdrName will only have API Annotations if it is a compound one, e.g.  `bar` ( ~ ) :  ,  '(' or '[' or '[:' ,  ')' or ']' or ':]',,  '`' ,  ,+ghc Exact nameWe know exactly the . This is used: ,When the parser parses built-in syntax like [] and (,), but wants a + from it8By Template Haskell, when TH has generated a unique nameSuch a + can be created by using * on a +ghc Original name$An original name; the module is the defining module. This is used when GHC generates code that will be fed into the renamer (e.g. from deriving clauses), but where we want to say "Use Prelude.map dammit". One of these can be created with ++ghcQualified name)A qualified name written by the user in source code. The module isn't necessarily the module where the thing is defined; just the one from which it is imported. Examples are Bar.x, Bar.y or Bar.Foo. Create such a + with ++ghcUnqualified name1Used for ordinary, unqualified occurrences, e.g. x, y or Foo. Create such a + with +ghcisBuiltInSyntax filter out names for built-in syntax They just clutter up the environment (esp tuples), and the parser will generate Exact RdrNames for them, so the cluttered envt is no use. Really, it's only useful for GHC.Base and GHC.Tuple.**************************++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*++*+++++++++++++***++*++*+*+++**++*++++++*++++++**+*+*****+++++++++++++++****++++*++++++++++++++++++*++ Safe-Inferred51^*ghc Does this * export the parent decl? This depends on the invariant that the parent is first if it appears at all.*ghc5Fields made available by the availability information*ghcNames and fields made available by the availability information.*ghcJust the main name made available, i.e. not the available pieces of type or class brought into scope by the **ghcAll names made available by the availability information (excluding overloaded selectors)*ghcAll names made available by the availability information (including overloaded selectors)*ghcNames for non-fields made available by the availability information*ghcNames and fields made available by the availability information, other than the main decl itself.*ghc filters an * by the given predicate*ghcfilters *s by the given predicate*ghcA  for internal use, but not for output to the user. For fields, the   will be the selector. See Note [GreNames] in GHC.Types.Name.Reader.*ghcA 3 suitable for output to the user. For fields, the   will be the field label. See Note [GreNames] in GHC.Types.Name.Reader.*ghc Combines *s from the same family avails may have several items with the same availName E.g import Ix( Ix(..), index ) will give Ix(Ix,index,range) and Ix(index) We want to combine these; addAvail does that*ghcCompare lexicographically*ghc trims an * to keep only a single name*ghc2Records what things are "available", i.e. in scope*ghcAn ordinary identifier in scope, or a field label without a parent type (see Note [Representing pattern synonym fields in AvailInfo]).*ghcA type or class in scopeThe AvailTC Invariant=: If the type or class is itself to be in scope, it must be first in this list. Thus, typically: AvailTC Eq [Eq, ==, \/=]*ghcA collection of *& - several things that are "available"*ghcUsed where we may have an ordinary name or a record field label. See Note [GreNames] in GHC.Types.Name.Reader.*ghc/Used when deciding if the interface has changed*ghcThe name of the type or classghcThe available pieces of type or class (see Note [Representing fields in AvailInfo])."**********************************"********************************** Safe-Inferred57892//////////////////////////////////////// Safe-Inferred 57gf,ghcCombine locations from two % things and add them to a third thing,ghcAdd additional comments, used for manipulating the AST prior to exact printing the changed one.,ghcAdd additional comments to a ., used for manipulating the AST prior to exact printing the changed one.,ghc,Helper function used in the parser to add a ." items to an existing annotation.,ghc,Helper function used in the parser to add a ." items to an existing annotation.,ghcHelper function used in the parser to add a comma location to an existing annotation.,ghcRemove the exact print annotations payload, leaving only the anchor and comments.,ghcSmart constructor for a -+. It preserves the invariant that for the - constructor - is always > 0.,ghc%Used in the parser only, extract the  from an -!. The parser will never insert a -#, so the partial function is safe.,ghcHelper function (temporary) during transition of names Discards any annotations,ghcHelper function (temporary) during transition of names Discards any annotations,ghcHelper function (temporary) during transition of names Discards any annotations,ghcHelper function (temporary) during transition of names Discards any annotations,ghcShort form for -,ghc Maps the . to the related opening and closing AnnKeywordId. Used when actually printing the item.,ghcRemove the comments, leaving the exact print annotations payload,ghcReplace any existing comments, used for manipulating the AST prior to exact printing the changed one.,ghc#Replace any existing comments on a ., used for manipulating the AST prior to exact printing the changed one.,ghcTransfer comments and trailing items from the annotations in the first .! argument to those in the second.,ghc;Convert a normal annotation into its unicode equivalent one,ghcThe annotations need to all come after the anchor. Make sure this is the case.,ghc$Captures an annotation, storing the ,2 and its location. The parser only ever inserts - fields with a RealSrcSpan being the original location of the annotation in the source file. The - can also store a delta position if the AST has been modified and needs to be pretty printed again. The usual way an , is created is using the mj ("make jump") function, and then it can be inserted into the appropriate annotation.,ghcAn , records the base location for the start of the syntactic element holding the annotations, and is used as the point of reference for calculating delta positions for contained annotations. It is also normally used as the reference point for the spacing of the element relative to its container. If it is moved, that relationship is tracked in the , instead.,ghcBase location for the start of the syntactic element holding the annotations.,ghc'If tools modify the parsed source, the , variant can directly provide the spacing for this item relative to the previous one when printing. This allows AST fragments with a particular anchor to be freely moved, without worrying about recalculating the appropriate anchor span.,ghcExact print annotation for the Context data type.,ghc!zero or more closing parentheses.,ghclocation and encoding of the '=>' , if present.,ghc!zero or more opening parentheses.,ghcExact print annotations exist so that tools can perform source to source conversions of Haskell code. They are used to keep track of the various syntactic keywords that are not otherwise captured in the AST.*The wiki page describing this feature is  8https://gitlab.haskell.org/ghc/ghc/wikis/api-annotations https://gitlab.haskell.org/ghc/ghc/-/wikis/implementing-trees-that-grow/in-tree-api-annotationsNote: in general the names of these are taken from the corresponding token, unless otherwise noted See note [exact print annotations] above for details of the usage,ghc'`',ghc!,ghccase or lambda case,ghc'#)' or '#-}' etc,ghc'|)',ghc'|)', unicode variant,ghc'}',ghc')',ghc'#)',ghc'|]',ghc'|]', unicode variant,ghc']',ghcas a list separator,ghcin a RdrName for a tuple,ghc'=>',ghc'=>', unicode variant,ghc'::',ghc'::', unicode variant,ghcprefix   -- TemplateHaskell,ghcprefix   -- TemplateHaskell,ghc,ghc'..'-ghcUnicode variant-ghcfor function name in matches where there are multiple equations for the function.-ghc for CType-ghc'infix' or 'infixl' or 'infixr'-ghc'<-'-ghc'<-', unicode variant-ghc-<<-ghc-<<, unicode variant-ghcThe E unicode arrow-ghc -ghc;where a name loses its location in the AST, this carries it-ghc'{-# DEPRECATED' etc. Opening of pragmas where the capitalisation of the string can be changed by the user. The actual text used is stored in a  SourceText on the relevant pragma item.-ghc'(|'-ghc'(|', unicode variant-ghc'{'-ghc'[e|' or '[e||'-ghc'[|'-ghc'[|', unicode variant-ghc'('-ghc'(#'-ghc'['-ghc% -- for HsExplicitMult-ghc'%1' -- for HsLinearArrow-ghc->-ghc->, unicode variant-ghc>>--ghc>>-, unicode variant-ghc';'-ghc'''-ghcstatic-ghc double '''-ghc~-ghc() for types-ghc e.g. INTEGER-ghc*String value, will need quotes when output-ghc'|'-ghcvia-ghc-<-ghc-<, unicode variant-ghc->-ghc->, unicode variant-ghcAnnotation for the "container" of a list. This captures surrounding items such as braces if present, and introductory keywords such as 'where'.-ghc#start point of a list having layout-ghccontext, such as 'where' keyword-ghc)items appearing after the list, such as '=>' for a context-ghcAnnotation for items appearing in a list. They can have one or more trailing punctuations items, such as commas or semicolons.-ghcexact print annotation for an item having surrounding "brackets", such as tuples or lists-ghcexact print annotation used for capturing the locations of annotations in pragmas.-ghcCaptures the sort order of sub elements. This is needed when the sub-elements have been split (as in a HsLocalBind which holds separate binds and sigs) or for infix patterns where the order has been re-arranged. It is captured explicitly so that after the Delta phase a SrcSpan is used purely as an index into the annotations, allowing transformations of the AST including the introduction of new Located items or re-arranging existing ones.-ghcSpacing between output items when exact printing. It captures the spacing from the current print position on the page to the position required for the thing about to be printed. This is either on the same line in which case is is simply the number of spaces to emit, or it is some number of lines down, with a given column offset. The exact printing algorithm keeps track of the column offset pertaining to the current anchor position, so the -5 is the additional spaces to add in this case. See  8https://gitlab.haskell.org/ghc/ghc/wikis/api-annotations for details.-ghcdeltaLine should always be > 0-ghcThe exact print annotations (EPAs) are kept in the HsSyn AST for the GhcPs phase. We do not always have EPAs though, only for code that has been parsed as they do not exist for generated code. This type captures that they may be missing.A goal of the annotations is that an AST can be edited, including moving subtrees from one place to another, duplicating them, and so on. This means that each fragment must be self-contained. To this end, each annotated fragment keeps track of the anchor position it was originally captured at, being simply the start span of the topmost element of the ast fragment. This gives us a way to later re-calculate all Located items in this layer of the AST, as well as any annotations captured. The comments associated with the AST fragment are also captured here.The . type parameter allows this general structure to be specialised to the specific set of locations of original exact print annotation elements. So for HsLet we havetype instance XLet GhcPs = EpAnn AnnsLet data AnnsLet = AnnsLet { alLet :: EpaLocation, alIn :: EpaLocation } deriving DataThe spacing between the items under the scope of a given EpAnn is normally derived from the original ,. But if a sub-element is not in its original position, the required spacing can be directly captured in the , field of the - Anchor. This allows us to freely move elements around, and stitch together new AST fragments out of old ones, and have them still printed out in a precise way.-ghc?No Annotation for generated code, e.g. from TH, deriving, etc.-ghcAnnotations added by the Parser-ghc6Comments enclosed in the SrcSpan of the element this - is attached to-ghcBase location for the start of the syntactic element holding the annotations.-ghcWhen we are parsing we add comments that belong a particular AST element, and print them together with the element, interleaving them into the output stream. But when editing the AST to move fragments around it is useful to be able to first separate the comments into those occuring before the AST element and those following it. The - constructor is used to do this. The GHC parser will only insert the - form.-ghc?The location of the prior token, used in exact printing. The - appears as an . containing its location. The difference between the end of the prior token and the start of this location is used for the spacing when exact printing the comment.-ghccomment in {- -}-ghcsomething beginning '-- $'-ghcsomething beginning '-- |'-ghcsomething beginning '-- ^'-ghc(doc options (prune, ignore-exports, etc)-ghca section heading-ghc)empty comment, capturing location of EOF-ghccomment starting by "--"-ghcThe anchor for an ,. The Parser inserts the - variant, giving the exact location of the original item in the parsed source. This can be replaced by the - version, to provide a position for the item relative to the end of the previous item in the source. This is useful when editing an AST prior to exact printing the changed one. The list of comments in the - variant captures any comments between the prior output and the thing being marked here, since we cannot otherwise sort the relative order..ghc, as an identifier.ghcUsed when adding a . to an existing .' which has no Api Annotation (via the - constructor..ghc$Detail of the "brackets" used in an - exact print annotation..ghc'(', ')'.ghc '(#', '#)'.ghc'[', ']'.ghc,We mostly use 'SrcSpanAnn'' with an 'EpAnn''.ghc&The 'SrcSpanAnn'' type wraps a normal , together with an extra annotation type. This is mapped to a specific  usage in the AST through the XRec and Anno type families..ghcCaptures the location of punctuation occuring between items, normally in a list. It is captured as a trailing annotation..ghc Trailing ','.ghc Trailing E.ghc Trailing ->.ghc Trailing ->, unicode variant.ghc Trailing ';'.ghc Trailing '|'ghcThe annotations need to all come after the anchor. Make sure this is the case.-ghc!Api Annotations for comments only,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,---,-,-,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,---------------------------------------------------------------------------------------------------------------------------........................................................,---,-,-,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,--------------------------------------------------------------------------------...,...,,---,,-----,,------,,,,,,,,,,-----.,,,,-................---------------....,-----,,,,,......................---.......,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,, Safe-InferredrNghcNumber of argumentsNghc0Existentially quantified type/coercion variablesNghc"Names of fields used for selectorsNghc5Extract the type for any given labelled field of the NNghcThe "full signature" of the N returns, in order:,1) The universally quantified type variables72) The existentially quantified type/coercion variables3) The equality specification;4) The provided theta (the constraints provided by a match)<5) The required theta (the constraints required for a match)6) The original argument types (i.e. before any change of the representation of the type)7) The original result typeNghcN returns True except for uni-directional pattern synonyms, which have no builderNghc7Returns the strictness information for each constructorNghcReturns just the instantiated value argument types of a N, (excluding dictionary args)Nghc%Returns the type of the whole patternNghcThe "stupid theta" of the N , such as  data Eq a in: data Eq a => T a = ...It is empty for N$ as they do not allow such contexts.Nghc" s for the type variables of the N. For pattern synonyms, this will always consist of the universally quantified variables followed by the existentially quantified type variables. For data constructors, the situation is slightly more complicated@see )Note [DataCon user type variable binders] in GHC.Core.DataCon.Nghc-The ConLikes that have *all* the given fieldsNghcIs this a 'vanilla' constructor-like thing (no existentials, no provided constraints)?NghcA constructor-like thingNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN Safe-InferredvIghcIs this a 'vanilla' pattern synonym (no existentials, no provided constraints)?IghcBuild a new pattern synonymIghcArity of the pattern synonymIghc5Extract the type for any given labelled field of the DataConIghc Should the I be presented infix?IghcThe  of the I+, giving it a unique, rooted identificationIghcPrint the type of a pattern synonym. The foralls are printed explicitlyIghcPattern SynonymSee Note [Pattern synonym representation] See Note [Pattern synonym signature contexts]Ighc&Is the pattern synonym declared infix?ghc:Universially-quantified type variables and required dictsghc;Existentially-quantified type variables and provided dictsghcOriginal argumentsghcOriginal result typeghcMatcherghcBuilderghc/Names of fields for a record pattern synonymIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII Safe-Inferred ()05ya/ghcThe  [CoAxBranch] passed into the mapping function is a list of all previous branches, reversed0ghcA 0: is a "coercion constructor", i.e. a named equality axiom.0ghc,For now, we work only with nominal equality.0ghccoaxrProves returns Nothing when it doesn't like the supplied arguments. When this happens in a coercion that means that the coercion is ill-formed, and Core Lint checks for that.0ghc-A more explicit representation for `t1 ~ t2`.///////////////////////////////////000000000000000000000000000000000//0/////////000000000000000000////////////////////0000/0000000//000/ Safe-Inferred{g0ghcInformation about an associated type family default implementation. This is used solely for validity checking. See (Note [Type-checking default assoc decls] in  GHC.Tc.TyCl."0000000000000000000000000000000000"0000000000000000000000000000000000 Safe-InferredaDghcGiven a Role, what TyCon is the type of equality predicates at that role?Dghc Primitive  3s that are defined in, and exported from, GHC.Prim.DghcThe FUN type constructor. FUN :: forall (m :: Multiplicity) -> forall {rep1 :: RuntimeRep} {rep2 :: RuntimeRep}. TYPE rep1 -> TYPE rep2 -> * The runtime representations quantification is left inferred. This means they cannot be specified with -XTypeApplications.This is a deliberate choice to allow future extensions to the function arrow. To allow visible application a type synonym can be defined: type Arr :: forall (rep1 :: RuntimeRep) (rep2 :: RuntimeRep). TYPE rep1 -> TYPE rep2 -> Type type Arr = FUN 'Many Eghc Convert a ; to a !> of kind RuntimeRep Defined here to avoid (more) module loopsEghc Primitive  s that are defined in GHC.Prim but not exposed. It's important to keep these separate as we don't want users to be able to write them (see #15209) or see them in GHCi's :browse output (see #12023).!DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEFFFFFFFFFEEEEEEEEEDDDDDDDDDDDDDDEEEEEEEEEEEEEEEE!EDDDEDEDDDEEEFFFDDDDDDDDDEEEEEEEDEDDDEEEEEEEEEEEEEEEEEEEEEEEDDDDEEEEEEEEEEDDDEEEEEEEEEEEEEEEDDDDEEEEEEEEEEDEEEEEEEEEEEEEFFEEEEEEFFEEEEEEFFEEEEEEDDDDDDDDDDDD Safe-Inferred1111111111111111111111111111111111111111111112222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222233333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444445555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555566666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777778888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888899999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::1111111111111111111111111111111111111111111112222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222233333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444445555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555566666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777778888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888899999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: Safe-Inferredghc?A function to produce an annotation for a given right-hand-sideghc-Annotate with the size of the right-hand-sideghc No annotationghc4Pretty print the argument in a function application.ghc3generate an annotation to place before the bindingghcbindings to showghcthe pretty result fffffffffff fffffffffff Safe-InferredfghcA measure of the size of the expressions, strictly greater than 0 Counts *leaves*, not internal nodes. Types and coercions are not counted. fffffffffff fffffffffff Safe-Inferred&5ծXghcDetermines the type resulting from applying an expression with given type to a given argument expressionXghc$Extract every variable by this groupXghcX$ applied to a list of binding groupsXghcThere is no known Z*, because this came from an hi-boot file.Xghc Compares Ys within a single list of alternatives DEFAULT comes out smallest, so that sorting by AltCon puts alternatives in the order required: see Note [Case expression invariants]XghcTakes a nested application expression and returns the function being applied and the arguments to which it is appliedXghcAs X but for Y rather than ZXghcTakes a nested application expression and returns the function being applied and the arguments to which it is appliedXghcLike  collectArgs, but also collects looks through floatable ticks if it means that we can find more arguments.XghcWe often want to strip off leading lambdas before getting down to business. Variants are X, , and XXghcAs X but for Y rather than ZXghcStrip off exactly N leading lambdas (type or value). Good for use with join points.Yghc ... }Yghc A literal: case e of { 1 -> ... } Invariant: always an *unlifted* literal See Note [Literal alternatives]YghcA clone of the Y0 type but allowing annotation at every tree nodeYghcA clone of the Y0 type but allowing annotation at every tree nodeYghc;Annotated core: allows annotation at every node in the treeYghcA clone of the Z0 type but allowing annotation at every tree nodeYghcType synonym for expressions that occur in function argument positions. Only Y should contain a Z at top level, general Z should notYghcBinding, used for top level bindings in a module and local bindings in a let.Yghc$Case alternatives where binders are YsYghc'Argument expressions where binders are YsYghc!Binding groups where binders are YsYghcThe common case for the type of binders and variables when we are manipulating the Core language within GHCYghcExpressions where binders are YsYghcA Y is:"Local" if the function it is a rule for is defined in the same module as the rule itself."Orphan" if nothing on the LHS is defined in the same module as the rule itselfYghcBuilt-in rules are used for constant folding and suchlike. They have no free variables. A built-in rule is always visible (there is no such thing as an orphan built-in rule.)YghcWhen the rule is activeYghcLeft hand side argumentsYghcTrue  = this rule is auto-generated (notably by Specialise or SpecConstr) False  = generated at the user's behest See Note [Trimming auto-rules] in GHC.Iface.Tidy% for the sole purpose of this field.YghcVariables quantified overYghc Name of the ` at the head of this ruleYghcTrue iff the fn at the head of the rule is defined in the same module as the rule and is not an implicit  (like a record selector, class operation, or data constructor). This is different from Z, where a rule can avoid being an orphan if *any* Name in LHS of the rule was defined in the same module as the rule.Yghc1Name of the rule, for communication with the userYghcNumber of arguments that Z1 consumes, if it fires, including type argumentsYghc the rule was defined in, used to test if we should see an orphan rule.Zghc%Whether or not the rule is an orphan.ZghcRight hand side of the rule Occurrence info is guaranteed correct See Note [OccInfo in unfoldings and rules]Zghc7Name at the head of each argument to the left hand sideZghcThis function does the rewrite. It given too many arguments, it simply discards them; the returned Y is just the rewrite of Y applied to the first Y argsZghcThis is the data type that represents GHCs core intermediate language. Currently GHC uses System FC  https://www.microsoft.com/en-us/research/publication/system-f-with-type-equality-coercions/ for this purpose, which is closely related to the simpler and better known System F  %http://en.wikipedia.org/wiki/System_F.We get from Haskell source to this Core language in a number of stages: The source code is parsed into an abstract syntax tree, which is represented by the data type  with the names being This syntax tree is renamed, which attaches a F to every  (yielding a ) to disambiguate identifiers which are lexically identical. For example, this program: 3 f x = let f x = x + 1 in f (x - 2) Would be renamed by having Unique,s attached so it looked something like this:  f_1 x_2 = let f_3 x_4 = x_4 + 1 in f_3 (x_2 - 2) But see Note [Shadowing] below. The resulting syntax tree undergoes type checking (which also deals with instantiating type class arguments) to yield a  type that has ` as it's names.Finally the syntax tree is  desugared from the expressive  type into this Z type, which has far fewer constructors and hence is easier to perform optimization, analysis and code generation on.The type parameter b3 is for the type of binders in the expression tree.0The language consists of the following elements:5Variables See Note [Variable occurrences in Core]Primitive literals.Applications: note that the argument may be a Z. See Note [Core let/app invariant] See Note [Levity polymorphism invariants]Lambda abstraction See Note [Levity polymorphism invariants]Recursive and non recursive lets. Operationally this corresponds to allocating a thunk for the things bound and then executing the sub-expression.See Note [Core letrec invariant] See Note [Core let/app invariant] See Note [Levity polymorphism invariants] See Note [Core type and coercion invariant]Case expression. Operationally this corresponds to evaluating the scrutinee (expression examined) to weak head normal form and then examining at most one level of resulting constructor (i.e. you cannot do nested pattern matching directly with this).The binder gets bound to the value of the scrutinee, and the Z* must be that of all the case alternatives0IMPORTANT: see Note [Case expression invariants]Cast an expression to a particular type. This is used to implement newtypes (a newtype. constructor or destructor just becomes a Z in Core) and GADTs.Ticks. These are used to represent all the source annotation we support: profiling SCCs, HPC ticks, and GHCi breakpoints.;A type: this should only show up at the top level of an Arg A coercionZghcIs this instance an orphan? If it is not an orphan, contains an  ? witnessing the instance's non-orphanhood. See Note [Orphans]ZghcGathers a collection of Ys. Maps (the name of) an  to its rulesZghc?A full rule environment which we can apply rules from. Like a Z, but it also includes the set of visible orphans we use to filter out orphan rules which are not visible (even though we can see them...)Zghc Rule optionsZghcEnable rules for bignumsZghcCut down precision of Rational values to that of Float/Double if disabledZghc-Enable more advanced numeric constant foldingZghcTarget platformZghc Binders are tagged with a tZghc Records the  unfolding of an identifier, which is approximately the form the identifier would have if we substituted its definition in for the identifier. This type should be treated as abstract everywhere except in GHC.Core.UnfoldZghc:We have no information about the unfolding, because this  came from an hi-boot1 file. See Note [Inlining and hs-boot files] in GHC.CoreToIface for what this is used for.Zghc;An unfolding with redundant cached information. Parameters:uf_tmpl: Template used to perform unfolding; NB: Occurrence info is guaranteed correct: see Note [OccInfo in unfoldings and rules]'uf_is_top: Is this a top level binding? uf_is_value:  exprIsHNF* template (cached); it is ok to discard a  on this variableuf_is_work_free: Does this waste only a little work if we expand it inside an inlining? Basically this is a cached version of exprIsWorkFree!uf_guidance: Tells us about the size of the unfolding templateZghc+We have no information about the unfolding.Zghc%It ain't one of these constructors.  OtherCon xs also indicates that something has been evaluated and hence there's no point in re-evaluating it.  OtherCon [] is used even for non-data-type values to indicated evaluated-ness. Notably: 1data C = C !(Int -> Int) case x of { C f -> ... }Here, f gets an  OtherCon [] unfolding.ZghcZ& says when unfolding should take place"""""""""XXXXXXXXXXXXXXXXXXXXYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZYYYYYYYYYYYYYYYYZZZZZZY"ZZZZZZZ"Z"""ZZZZZZZ"Z""ZYYYYYYYYYYYYYYYYYYYYYYYYYYYYY"XXYXXYYXXXXXYXYYYXYYYYYYYYZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZYXYYYYXXYYYYYYYYYYYYYYXYYYYYYYYYYYYYYYYYYYXXYYYYXXZZZYYXYYYYYYYYYYYYZZZZZZZZZZZZZZZZZZYYYYYYYYYYYY4Y4Y4Y4Z4 Safe-Inferred|&kghc4Find all locally defined free Ids in a binding groupkghc2Find all locally-defined free Ids in an expressionkghcFind all locally-defined free Ids in an expression returning a deterministic set.kghcFind all locally-defined free Ids in an expression returning a deterministically ordered list.kghcFind all locally-defined free Ids or type variables in an expression returning a non-deterministic set.kghcFind all locally-defined free Ids or type variables in an expression returning a deterministic set.kghcFind all locally-defined free Ids or type variables in an expression returning a deterministically ordered list.kghc=Finds free variables in an expression selected by a predicatekghcFinds free variables in an expression selected by a predicate returning a deterministically ordered list.kghcFind all locally-defined free Ids in several expressions returning a deterministic set.kghcFind all locally-defined free Ids in several expressions returning a deterministically ordered list.kghcFind all locally-defined free Ids or type variables in several expressions returning a non-deterministic set.kghcFind all locally-defined free Ids or type variables in several expressions returning a deterministically ordered list.kghcFinds the free external# names of several expressions: see  for detailskghcFinds free variables in several expressions selected by a predicatekghcFinds free variables in several expressions selected by a predicate returning a deterministically ordered list.kghc Annotate a Y with its (non-global) free type and value variables at every tree node.kghcInverse function to kkghc$Extract the vars reported in a FVAnnkghcMake a [ containing a number of Y!s, suitable for putting into an kghcorphNamesOfAxiom collects the names of the concrete types and type constructors that make up the LHS of a type family instance, including the family name itself.For instance, given `type family Foo a b`: `type instance Foo (F (G (H a))) b = ...` would yield [Foo,F,G,H].Used in the implementation of ":info" in GHCi.kghcThose variables free in the both the left right hand sides of a rule returned as a non-deterministic setkghcThis finds all locally-defined free Ids on the left hand side of a rule and returns them as a non-deterministic setkghcThis finds all locally-defined free Ids on the left hand side of a rule and returns them as a deterministically ordered listkghcThose variables free in the right hand side of a rule returned as a non-deterministic setkghcThose variables free in both the left right hand sides of several ruleskghcThose variables free in the both the left right hand sides of rules returned as a deterministic setkghcThose locally-defined free s in the right hand side of several rules returned as a non-deterministic setkghcEvery node in an expression annotated with its (non-global) free variables, both Ids and TyVars, and type.kghcEvery node in a binding group annotated with its (non-global) free variables, both Ids and TyVars, and type.kghcEvery node in an expression annotated with its (non-global) free variables, both Ids and TyVars, and type. NB: see Note [The FVAnn invariant]ghcFind all locally-defined free Ids or type variables in an expression returning a composable FV computation. See Note [FV naming conventions] in  GHC.Utils.FV for why export it.ghcThose locally-defined variables free in the left and/or right hand sides of the rule, depending on the first argument. Returns an ( computation.ghcFind all locally-defined free Ids or type variables in several expressions returning a composable FV computation. See Note [FV naming conventions] in  GHC.Utils.FV for why export it.ghcFinds free variables in an expression selected by a predicate returning a deterministic set.ghcFinds free variables in several expressions selected by a predicate returning a deterministic set.ghcFinds the free external names of an expression, notably including the names of type constructors (which of course do not show up in k).ghcThose locally-defined variables free in the left and/or right hand sides from several rules, depending on the first argument. Returns an ( computation.kghc Says which Zs are interestingkghc Says which Zs are interestingghc Says which Zs are interestingghc Says which Zs are interesting4(kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkl4kkkkkkkkkkkk(kkkkkkkkkkkkkkkkkkkkkkkkkkkkkklkkkkkkkk Safe-Inferred ()7 KghcDo an apartness check, as described in the "Closed Type Families" paper (POPL '14). This should be used when determining if an equation (0) of a closed type family can be used to reduce a certain target type family application.KghcCheck whether two type family axioms don't violate injectivity annotation.KghcCheck whether an open type family equation can be added to already existing instance environment without causing conflicts with supplied injectivity annotations. Returns list of conflicting axioms (type instance declarations).KghcCreate a coercion constructor (axiom) suitable for the given newtype  . The % should be that of a new coercion 0, the  s the arguments expected by the newtype8 and the type the appropriate right hand side of the newtype/, with the free variables a subset of those s.KghcGet rid of *outermost* (or toplevel) * type function redex * data family redex * newtypes returning an appropriate Representational coercion. Specifically, if topNormaliseType_maybe env ty = Just (co, ty') then (a) co :: ty ~R ty' (b) ty' is not a newtype, and is not a type-family or data-family redexHowever, ty' can be something like (Maybe (F ty)), where (F ty) is a redex.Always operates homogeneously: the returned type has the same kind as the original type, and the returned coercion is always homogeneous.KghcTry to simplify a type-family application, by *one* step If topReduceTyFamApp_maybe env r F tys = Just (co, rhs, res_co) then co :: F tys ~R# rhs res_co :: typeKind(F tys) ~ typeKind(rhs) Type families and data families; always Representational roleLghc;Result of testing two type family equations for injectiviy.LghcEither RHSs are distinct or unification of RHSs leads to unification of LHSsLghcRHSs unify but LHSs don't unify under that substitution. Relevant for closed type families where equation after unification might be overlpapped (in which case it is OK if they don't unify). Constructor stores axioms after unification.ghc1a monad for the normalisation functions, reading L, a 0, and a 0.ghc&Index a FamInstEnv by the tyCons name.ghc&Create a FamInstEnv from Name indices.Kghc flattened target arguments. Make sure they're flattened! See Note [Flattening type-family applications when matching instances] in GHC.Core.Unify.ghcthe candidate equation we wish to use Precondition: this matches the targetghcTrue  = equation can fire9KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKLLLLLLLLLLLLLLLLLL9KKLLLLLLLLKKKKKKKKKKKKLLKKKKKKKKKKKKLLLLLKKKKKLLLKKKKKKKK# Safe-InferredF^ghcTrue of dyadic operators that can fail only if the second arg is zero!This function probably belongs in an automagically generated file.. but it's such a special case I thought I'd leave it here for now.^ghc Returns the * of the wrapper associated with the given . See Note [Primop wrappers].b^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^________________________________________________________________________________________________________________________________````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbcccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc^^^^^^^^^^^^^^^^^^^^^cccccccb^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^________________________________________________________________________________________________________________________________````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbcccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc^^^^^^^^^^^^^^^^^^^ccc^^d Safe-Inferred5  ghcCaptures the fixity of declarations as they are parsed. This is not necessarily the same as the fixity declaration, as the normal fixity may be overridden using parens or backticks.~ Safe-Inferred #ghc7A bit-mask for the lower half-word of current platform.#ghc3The width of the current platform's half-word size.#ghcNarrow a signed value to the given width. The result will reside in [-2^(width-1), +2^(width-1)). narrowS W8 256 == 0narrowS W8 255 == -1narrowS W8 128 == -128narrowS W8 127 == 127narrowS W8 0 == 0narrowS W8 (-127) == -127narrowS W8 (-128) == -128narrowS W8 (-129) == 127narrowS W8 (-255) == 1narrowS W8 (-256) == 0#ghcNarrow a signed or unsigned value to the given width. The result will reside in  [0, +2^width). narrowU W8 256 == 256narrowU W8 255 == 255narrowU W8 128 == 128narrowU W8 127 == 127narrowU W8 0 == 0narrowU W8 (-127) == 129narrowU W8 (-128) == 128narrowU W8 (-129) == 127narrowU W8 (-255) == 1narrowU W8 (-256) == 0#ghc*Partial* A width from the number of bytes.#ghcA width in bits.#ghcA width in bytes. %widthFromBytes (widthInBytes w) === w#ghc:log_2 of the width in bytes, useful for generating shifts.#ghc.The width of the current platform's word size.######################################################################################################################################## Safe-Inferred o?ghcTidy a Coercion-See Note [Strictness in tidyType and friends]?ghc Add the free s to the env in tidy form, so that we can tidy the type they are free in?ghc Treat a new  as a binder, and give it a fresh tidy name using the environment if one has not already been allocated. See also ??ghc:Grabs the free type variables, tidies them and then uses ? to work over the type itself?ghcCalls ?= on a top-level type (i.e. with an empty tidying environment)?ghc Tidy a Type-See Note [Strictness in tidyType and friends]?ghcTidy a list of Types-See Note [Strictness in tidyType and friends]?ghcThis tidies up a type for printing in an error message, or in an interface file.;It doesn't change the uniques at all, just the print names.???????????????????????????????????? Safe-Inferred qghc0Used for things that absolutely must be unfoldedqghcSame as q= but no simple optimiser pass is performed on the unfolding.qghcMake an unfolding that may be used unsaturated (ug_unsat_ok = unSaturatedOk) and that is reported as having its manifest arity (the number of outer lambdas applications will resolve before doing any work).qghcMake an unfolding that will be used once the RHS has been saturated to the given arity.YqqqqqqqqqqqqqYqqqqqqqqqqqqq Safe-Inferred  fghcUnfolding optionsfghcSimple optimiser optionsghc)Default options for the Simple optimiser.ghcReturns 'Just ([b1..bp], dc, [t1..tk], [x1..xn]) if the argument expression is a *saturated* constructor application of the form *let b1 in .. let bp in dc t1..tk x1 .. xn>, where t1..tk are the *universally-quantified* type args of dc. Floats can also be (and most likely are) single-alternative case expressions. Why does  return floats? We may have to look through lets and cases to detect that we are in the presence of a data constructor wrapper. In this case, we need to return the lets and cases that we traversed. See Note [exprIsConApp_maybe on data constructors with wrappers]. Data constructor wrappers are unfolded late, but we really want to trigger case-of-known-constructor as early as possible. See also Note [Activation for data constructor wrappers] in GHC.Types.Id.Make.We also return the incoming InScopeSet, augmented with the binders from any [FloatBind] that we returnghcReturns Just (bndr,rhs) if the binding is a join point: If it's a JoinId, just return it If it's not yet a JoinId but is always tail-called, make it into a JoinId and return it. In the latter case, eta-expand the RHS if necessary, to make the lambdas explicit, as is required for join pointsPrecondition: the InBndr has been occurrence-analysed, so its OccInfo is validghcCoercion optimiser optionsghc"Options for the coercion optimiserghcUnfolding optionsghcDeals with preInlineUnconditionally; things that occur exactly once and are inlined without having first been simplifiedghc+Deals with cloning; includes the InScopeSet fff fff Safe-Inferred -/!pghcVery similar to p , but it always allocates a new  for each variable in its output. It substitutes the IdInfo though.pghcApplies p to a number of 8s, accumulating a final substitution from left to rightpghc$Clone a mutually recursive group of spghcDe-shadowing the program is sometimes a useful pre-pass. It can be done simply by running over the bindings with an empty substitution, because substitution returns a result that has no-shadowing guaranteed.(Actually, within a single type* there might still be shadowing, because p is a no-op for the empty substitution, but that's probably OK.) Aug 09This function is not used in GHC at the moment, but seems so short and simple that I'm going to leave it herepghcAdd a substitution from a " to a Z to the p4: you must ensure that the in-scope set satisfies GHC.Core.TyCo.Subst Note [The substitution invariant] after extending the substitution like thispghcAdd a substitution for an  to the p: you must ensure that the in-scope set is such that TyCoSubst Note [The substitution invariant] holds after extending the substitution like thispghcAdds multiple  substitutions to the p : see also ppghcAdd the Z to the in-scope set: as a side effect, and remove any existing substitutions for itpghcOptimized version of p that can be used if you are certain all the things being added are s and hence none are s or "spghcAdd the Z s to the in-scope set: see also ppghcAdd a substitution appropriate to the thing being substituted (whether an expression, type, or coercion). See also p, p, ppghcAdd a substitution as appropriate to each of the terms being substituted (whether expressions, types, or coercions). See also p.pghcAdd a substitution for a  to the p The  *must* be a real TyVar, and not a CoVar You must ensure that the in-scope set is such that GHC.Core.TyCo.Subst Note [The substitution invariant] holds after extending the substitution like this.pghcAdds multiple  substitutions to the p : see also ppghcFind the substitution for an  in the ppghcFind the substitution for a  in the ppghcSimultaneously substitute for a bunch of variables No left-right shadowing ie the substitution for (x y. e) a1 a2 so neither x nor y scope over a1 a2pghc"Apply a substitution to an entire Y$, additionally returning an updated p2 that should be used by subsequent substitutions.pghc"Apply a substitution to an entire Y$, additionally returning an updated p2 that should be used by subsequent substitutions.pghcSubstitutes a Z" for another one according to the p- given, returning the result and an updated p3 that should be used by subsequent substitutions.  is preserved by this process, although it is substituted into appropriately.pghcApplies p to a number of Zs, accumulating a new p left-to-rightpghcSee ?pghc.substExpr applies a substitution to an entire Y1. Remember, you may only apply the substitution once/: See Note [Substitutions apply only once] in GHC.Core.TyCo.SubstDo *not* attempt to short-cut in the case of an empty substitution! See Note [Extending the Subst]pghcSubstitute into some ! with regard to the supplied new .pghcFind the in-scope set: see GHC.Core.TyCo.Subst" Note [The substitution invariant]pghc,Substitute in a mutually recursive group of spghcSubstitutes for the  s within the [ given the new function pghcSee w.pghcSubstitutes for the *s within an unfolding NB: substUnfolding discards any unfolding without without a Stable source. This is usually what we want, but it may be a bit unexpectedpghcSubstitutes for the *s within an unfolding NB: substUnfolding discards any unfolding without without a Stable source. This is usually what we want, but it may be a bit unexpectedpghcRemove all substitutions for s and Zs that might have been built up while preserving the in-scope setpghc$An environment for substituting for spghc'A substitution environment, containing , , and " substitutions.6Some invariants apply to how you use the substitution: %Note [The substitution invariant] in GHC.Core.TyCo.Subst(Note [Substitutions apply only once] in GHC.Core.TyCo.Substghc"Substitution to use for the IdInfoghc Substitution and Id to transformghc-Transformed pair NB: unfolding may be zapped9)?@pppppppppppppppppppppppppppppppppppppppppppppppppppppp9pp@p)pppppppppppppppppppppppppp?ppppppppppppppppppppppppp Safe-Inferred .fghcEvaluate all the fields of the - that are generally demanded by the compilerffffffffffffff Safe-Inferred' 1%ghcDecide whether some bindings should be made into join points or not. Returns J if they can't be join points. Note that it's an all-or-nothing decision, as if multiple binders are given, they're assumed to be mutually recursive.1It must, however, be a final decision. If we say True for f , and then subsequently decide not make f= into a join point, then the decision about another binding g might be invalidated if (say) f tail-calls g.(See Note [Invariants on join points] in GHC.Core.qqqq Safe-Inferred Epghc+The number of value args for the arity typepghc etaExpand n e1 returns an expression with the same meaning as e, but with arity n.Given: e' = etaExpand n eWe should have that: ty = exprType e = exprType e'pghcSplit an expression into the given number of binders and a body, eta-expanding if necessary. Counts value *and* type binders.pghcTrue  =+ eta-expansion will add at least one lambdapghc!An approximate, fast, version of ppghcThe Arity returned is the number of value args the expression can be applied to without doing much workqghcmanifestArity sees how many leading value lambdas there are, after looking through castsqghcExpand a non-bottoming arity type so that it has at least the given arity.qghc;The analysis lattice of arity analysis. It is isomorphic to  data ArityType' = AEnd Divergence | ALam OneShotInfo ArityType' 1Which is easier to display the Hasse diagram for:  ALam OneShotLam at | AEnd topDiv | ALam NoOneShotInfo at | AEnd exnDiv | AEnd botDiv  where the at fields of ALam6 are inductively subject to the same order. That is, ALam os at1 < ALam os at2 iff  at1 < at2.Why the strange Top element? See Note [Combining case branches].We rely on this lattice structure for fixed-point iteration in p. For the semantics of q, see Note [ArityType].qghc AT oss div- means this value can safely be eta-expanded  length oss( times, provided use sites respect the s in oss. A  annotation can come from two sources: * The user annotated a lambda as one-shot with  * It's from a lambda binder of a type affected by `-fstate-hack`. See [. In both cases,  should win over &, see Note [Combining case branches].If div is dead-ending (M), then application to  length os? arguments will surely diverge, similar to the situation with N.qghc(This is the BNF of the generated output:  @ We format AT [o1,..,on] topDiv as o1..on.T and AT [o1,..,on] botDiv as o1..on.E", respectively. More concretely, AT [NOI,OS,OS] topDiv is formatted as ?11.T6. If the one-shot info is empty, we omit the leading .@.ghc*Each of the entry-points of the analyser (3) has different requirements. The entry-points are pppFor each of the entry-points, there is a separate mode that governs How pedantic we are wrt. E, in .Whether we store arity signatures for non-recursive let-bindings, accessed in /7. See Note [Arity analysis] why that's important.Which expressions we consider cheap to float inside a lambda, in .ghc.Used for regular, fixed-point arity analysis (p). See Note [Arity analysis] for details about fixed-point iteration. INVARIANT: Disjoint with .ghc Used during p.ghcUsed for finding an expression's eta-expanding arity quickly, without fixed-point iteration (p).ghcThe analysis mode. See .ghcIn-scope join points. See Note [Eta-expansion and join points] INVARIANT: Disjoint with the domain of  (if present).ghcThe ArityEnv used by p. Pedantic about bottoms and no application is ever considered cheap.ghcSee Note [Dead ends] in GHC.Types.Demand. Bottom implies a dead end.ghcTrim an arity type so that it has at most the given arity. Any excess s are truncated to M, even if they end in ABot.ghcLeast upper bound in the q lattice. See the haddocks on q for the lattice.Used for branches of a case.ghcThe ArityEnv used by p.ghcThe ArityEnv used by p.ghc8Whether the analysis should be pedantic about bottoms. p always is.ghc A version of o that considers results from arity analysis and optionally the expression's type. Under p, no expressions are cheap.ghc A version of o that considers results from arity analysis. See Note [Arity analysis] for what's in the signature environment and why it's important.ghcmkEtaWW n _ fvs ty will compute the , necessary for eta-expanding an expression e :: ty to take n value arguments, where fvs are the free variables of e.Note that this function is entirely unconcerned about cost centres and other semantically-irrelevant source annotations, so call sites must take care to preserve that info. See Note [Eta expansion and SCCs].ghc&How many value arguments to eta-expandghc5The pretty-printed original expression, for warnings.ghc=A super-set of the free vars of the expression to eta-expand.ghcThe variables in  are fresh wrt. to the incoming ). The outgoing ) extends the incoming ) with the fresh variables in .pppppppppppqqqqqqqqqqqqqqqqqpqpppppqqqqppqqppqqqqqqp Safe-Inferred f-ghcBuild a big tuple holding the specified expressions One-tuples are flattened; see Note [Flattening one-tuples]ghcBuild the type of a big tuple that holds the specified type of thing One-tuples are flattened; see Note [Flattening one-tuples]ghcBuild a big tuple holding the specified variables One-tuples are flattened; see Note [Flattening one-tuples]ghcBuild the type of a big tuple that holds the specified variables One-tuples are flattened; see Note [Flattening one-tuples]ghcMake a build6 expression applied to a locally-bound worker functionghc Create a Y" which will evaluate to the given Charghc Makes a list (:) for lists of the specified typeghcConstruct an expression which represents the application of one expression to the other Respects the let/app invariant by building a case expression where necessary See Note [Core let/app invariant] in GHC.CoreghcConstruct an expression which represents the application of a number of expressions to another. The leftmost expression in the list is applied first Respects the let/app invariant by building a case expression where necessary See Note [Core let/app invariant] in GHC.CoreghcConstruct an expression which represents the application of a number of expressions to that of a data constructor expression. The leftmost expression in the list is applied firstghcCreate a lambda where the given expression has a number of variables bound over it. The leftmost binder is that bound by the outermost lambda in the resultghc1Bind a binding group over an expression, using a let or case as appropriate (see GHC.Core#let_app_invariant)ghcBind a list of binding groups over an expression. The leftmost binding group becomes the outermost group in the resulting expressionghcBuild a small tuple holding the specified expressions One-tuples are flattened; see Note [Flattening one-tuples]ghc=Make a core tuple of the given boxity; don't flatten 1-tuplesghcBuild an unboxed sum.)Alternative number ("alt") starts from 1.ghcBuild a small unboxed tuple holding the specified expressions, with the given types. The types must be the types of the expressions. Do not include the RuntimeRep specifiers; this function calculates them for you. Does not5 flatten one-tuples; see Note [Flattening one-tuples]ghcBuild the type of a small tuple that holds the specified variables One-tuples are flattened; see Note [Flattening one-tuples]ghc Create a Y" which will evaluate to the given Doubleghc Create a Y" which will evaluate to the given FloatghcMake a fully applied  expressionghc Create a Y" which will evaluate to the given Intghc Create a Y" which will evaluate to the given Intghc Create a Y" which will evaluate to the given Integerghc/Makes a Just from a value of the specified typeghcMake a list containing the given expressions, where the list has the given typeghc Create a Y" which will evaluate to the given Naturalghc Makes a list [] for lists of the specified typeghc&Makes a Nothing for the specified typeghcAs , but for a tuple that is small enough to be guaranteed not to need nesting.ghc is like  but one-tuples are NOT flattened (see Note [Flattening one-tuples])Like 7 but for tuples that are guaranteed never to be "big". mkSmallTupleSelector [x] x v e = [| e |] mkSmallTupleSelector [x,y,z] x v e = [| case e of v { (x,y,z) -> x } |]ghc Create a Y" which will evaluate to the given Stringghc Create a Y which will evaluate to a string morally equivalent to the given  FastStringghcA generalization of ?, allowing the body of the case to be an arbitrary expression.;To avoid shadowing, we use uniques to invent new variables./If necessary we pattern match on a "big" tuple.ghc is like  but one-tuples are NOT flattened (see Note [Flattening one-tuples])Builds a selector which scrutises the given expression and extracts the one name from the list given. If you want the no-shadowing rule to apply, the caller is responsible for making sure that none of these names are in scope.If there is just one 7 in the tuple, then the selector is just the identity.0If necessary, we pattern match on a "big" tuple.A tuple selector is not linear in its argument. Consequently, the case expression built by  must consume its scrutinee F? times. And all the argument variables must have multiplicity F.ghcBuilds a selector which scrutises the given expression and extracts the one name from the list given. If you want the no-shadowing rule to apply, the caller is responsible for making sure that none of these names are in scope.If there is just one 7 in the tuple, then the selector is just the identity.0If necessary, we pattern match on a "big" tuple.A tuple selector is not linear in its argument. Consequently, the case expression built by  must consume its scrutinee F? times. And all the argument variables must have multiplicity F.ghc Create a Y" which will evaluate to the given Int. Don't check that the number is in the range of the target platform IntghcMake a wildcard binder. This is typically used when you need a binder that you expect to use only at a *binding* site. Do not use it at occurrence sites because it has a single, fixed unique, and it's very easy to get into difficulties with shadowing. That's why it is used so little. See Note [WildCard binders] in GHC.Core.Opt.Simplify.Envghc Create a Y which will evaluate to the a Word with the given valueghcThe unit expressionghc/Applies the floats from right to left. That is wrapFloats [b1, b2, @, bn] u = let b1 in let b2 in @ in let bn in ughcConstruct an expression which represents the application of one expression paired with its type to an argument. The result is paired with its type. This function is not exported and used in the definition of  and . Respects the let/app invariant by building a case expression where necessary See Note [Core let/app invariant] in GHC.CoreghcBuild a small tuple holding the specified expressions One-tuples are *not* flattened; see Note [Flattening one-tuples] See also Note [Don't flatten tuples from HsSyn]ghcLike 7 but for tuples that are guaranteed never to be "big". mkSmallTupleSelector [x] x v e = [| e |] mkSmallTupleSelector [x,y,z] x v e = [| case e of v { (x,y,z) -> x } |]ghc!Exception with type "forall a. a"Any exceptions added via this function needs to be added to the RTS's initBuiltinGcRoots() function.ghc!Type of list elements to be builtghc+Function that, given information about the s of the binders for the build worker function, returns the body of that workerghcElement type of the listghcFold result typeghcCons! function expression for the foldghcNil expression for the foldghc#List expression being folded acressghcThe tuple argsghcBody of the caseghc,A variable of the same type as the scrutineeghc Scrutineeghc-For inventing names of intermediate variablesghc)The tuple identifiers to pattern match onghcBody of the caseghc,A variable of the same type as the scrutineeghc ScrutineeghcThe $s to pattern match the tuple againstghcThe  to selectghc,A variable of the same type as the scrutineeghc ScrutineeghcSelector expressionghcThe $s to pattern match the tuple againstghcThe  to selectghc,A variable of the same type as the scrutineeghc ScrutineeghcSelector expressionoޖߖoޖߖ44#Generic helpers for the HsSyn type.((c) The University of Glasgow, 1992-2006 Safe-Inferred'().0 z%ƕghcSplit a list into lists that are small enough to have a corresponding tuple arity. The sub-lists of the result all have length <=  But there may be more than  sub-listsǕghc Collect both s and pattern-synonym bindersȕghcSame as ɕ#, but works over a list of bindingsʕghcCollect  binders only, or "s + pattern synonyms, respectivelyϕghcUsed exclusively for the bindings of an instance decl which are all FunBindsٕghcthe < returned are for the whole declarations, not just the namesڕghcSee Note [SrcSpan for binders]ܕghcReturns all the binding names of the decl. The first one is guaranteed to be the name of the decl. The first component represents all binding names except record fields; the second represents field occurrences. For record fields mentioned in multiple constructors, the SrcLoc will be from the first occurrence.3Each returned (Located name) has a SrcSpan for the whole- declaration. See Note [SrcSpan for binders]ݕghcCollects record pattern-synonym selectors only; the pattern synonym names are collected by ˕.ߕghc Convert an ߇ to an ܇.ghc Convert an ߇ to an ݇.ghc5Is a binding a strict variable or pattern bind (e.g. !x = ...)?ghcIf any of the matches in the  are infix, the  is considered infix.ghcShould we treat this as an unlifted bind? This will be true for any bind that binds an unlifted variable, but we must be careful around AbsBinds. See Note [Unlifted id check in isUnliftedHsBind]. For usage information, see Note [Strict binds checks] is GHC.HsToCore.Binds.ghc1The Big equivalents for the source tuple patternsghc4The Big equivalents for the source tuple expressionsghcLifts a "small" constructor into a "big" constructor by recursive decompositionghcConvert  to . The former is what is parsed, but the latter is what we need in class/instance declarationsghc8Not infix, with place holders for coercion and free varsghcA simple case alternative with a single pattern, no binds, no guards; pre-typecheckingghcA useful function for building OpApps. The operator is always a variable, and we don't know the fixity yet.ghc e => (e)ghcAvoid Ԑ co1 (Ԑ co2 _) and Ԑ co1 (Ȍ _ _)/ See Note [Detecting forced eta expansion] in GHC.HsToCore.ExprghcWrap in parens if  appPrec says it needs them So f x becomes (f x), but 3 stays as 3.ghc#Make a prefix, non-strict function ghcConvenience function using . This is for generated bindings only, do not use for user-written code.ghc!In Name-land, with empty bind_fvsghc NB: Only for X .іghc Wildcard pattern - after parsingҖghc!Wildcard pattern - after renamingԖghc Return the 0 encompassing the contents of any enclosed bindsؖghc2Indicate if evidence binders have to be collected.This type is used as a boolean (should we collect evidence binders or not?) but also to pass an evidence that the AST has been typechecked when we do want to collect evidence binders, otherwise these binders are not available.*See Note [Dictionary binders in ConPatOut]ٖghcDon't collect evidence bindersږghcCollect evidence bindersۖghcThis class specifies how to collect variable identifiers from extension patterns in the given pass. Consumers of the GHC API that define their own passes should feel free to implement instances in order to make use of functions which depend on it.In particular, Haddock already makes use of this, with an instance for its DocNameI pass so that it can reuse the code in GHC for collecting binders.ghcCollect s, or /s + pattern synonyms, depending on boolean flagghcthe < returned are for the whole declarations, not just the namesghc5"Small" constructor function, of maximum input arity ghc/Possible "big" list of things to construct fromghc:Constructed thing made possible by recursive decompositionƕǕȕɕʕ˕͕̕ΕϕЕѕҕӕԕՕ֕וٕؕڕەܕݕޕߕ–ÖĖŖƖǖȖɖʖ˖̖͖ΖϖЖіҖӖԖՖ֖זٖؖږۖܖՖ֖ÖĖǖӖ–ȖʖƕԖϖ˖ɖ̖ЖіҖΖ͖ߕƖŖוԕ֕ՕזΕ˕ȕʕɕǕϕЕѕ͕ӕ̕ҕۖܖٖؖږܕޕݕؕڕەٕ Safe-Inferred5 nghcConvert the QuoteWrapper into a normal HsWrapper which can be used to apply its contents.nghcd |> conghc,Any sort of evidence Id, including coercionsnghcIdentifies the  lambda-bound dictionaries of an o. This is used (only) to allow the pattern-match overlap checker to know what Given dictionaries are in scope.7We specifically do not collect dictionaries bound in a o. These are either superclasses of lambda-bound ones, or (extremely numerous) results of binding Wanted dictionaries. We definitely don't want all those cluttering up the Given dictionaries for pattern-match overlap checking!nghcThis version does a slow check, calculating the related types and seeing if they are equal.nghcIf the EqRel is ReprEq, makes a SubCo; otherwise, does nothing. Note that the input coercion should always be nominal.nghcIf a  is $, flip the orientation of a coercionnghc Create a Z that unwraps an implicit-parameter or overloaded-label dictionary to expose the underlying value. We expect the Z to have the form `IP sym ty` or `IsLabel sym ty`, and return a Z `co :: IP sym ty ~ ty` or `co :: IsLabel sym ty ~ ty`. See also Note [Type-checking overloaded labels] in GHC.Tc.Gen.Expr.nghc Create a Z> that wraps a value in an implicit-parameter dictionary. See n.nghc Evidence for  CallStack implicit parameters.nghcEvCsPushCall name loc stk represents a call to name, occurring at loc, in a calling context stk.oghcInstructions on how to make a Typeable0 dictionary. See Note [Typeable evidence terms]oghcDictionary for Typeable (s # w -> t), given a dictionaries for w, s, and t.oghcDictionary for Typeable (s t), given a dictionaries for s and t.oghcDictionary for  Typeable T where T is a type constructor with all of its kind variables saturated. The [EvTerm] is Typeable" evidence for the applied kinds..oghc%Dictionary for a type literal, e.g. Typeable "foo" or  Typeable 3 The o is evidence of, e.g.,  KnownNat 3 (see #10348)oghcWhere to store evidence for expression holes See Note [Holes] in GHC.Tc.Types.Constraintoghc&where to write the erroring expressionghc expected type of that expressionghcfor debug output only0000>nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnoooooooooooooooooooooooooooooooooooooooooooooooooonnnnnnnnnnnnnnnooonnnnnnnnnnnnnnnnnnnnnnnnnnnnnnooooooooonnnnnnnnnnnnnnnnooooooooooo>ooo0000nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnoonn Safe-Inferred'. UghcConvert an arrow into its corresponding multiplicity. In essence this erases the information of whether the programmer wrote an explicit multiplicity or a shorthand.ghc3Decompose a type class instance type (of the form forall  tvs. context => instance_head ) into the  instance_head and retrieve the underlying class type constructor (if it exists).ghc3Decompose a type class instance type (of the form forall  tvs. context => instance_head ) into the  instance_head.ghcDo all type variables in this ׇ come with kind annotations?ghcRetrieve the name of the "head" of a nested type application. This is somewhat like GHC.Tc.Gen.HsType.splitHsAppTys, but a little more thorough. The purpose of this function is to examine instance heads, so it doesn't handle *all* cases (like lists, tuples, (~), etc.).ghc7Get the kind signature of a type, ignoring parentheses:hsTyKindSig `Maybe ` = Nothing hsTyKindSig `Maybe :: Type -> Type ` = Just `Type -> Type` hsTyKindSig `Maybe :: ((Type -> Type))` = Just `Type -> Type`This is used to extract the result kind of type synonyms with a CUSK:2type S = (F :: res_kind) ^^^^^^^^ghcReturn the attached flagghc p t returns M if the type t% needs parentheses under precedence p.ghc Compute the  associated with an .ghc p ctxt checks if ctxt is a single constraint c such that  p c is true, and if so, surrounds c with an  to form a parenthesized ctxt . Otherwise, it simply returns ctxt unchanged.ghc p ty checks if  p ty is true, and if so, surrounds ty with an  . Otherwise, it simply returns ty.ghc3Prints a forall; When passed an empty list, prints forall ./ forall -> only when  -dppr-debug is enabled.ghcPrints the explicit forall in a type family equation if one is written. If there is no explicit forall, nothing is printed.ghcPrints the outermost forall in a type signature if one is written. If there is no outermost forall, nothing is printed.ghcSet the attached flagghcDecompose a type of the form forall  tvs. body into its constituent parts. Only splits type variable binders that were quantified invisibly (e.g.,  forall a., with a dot).This function is used to split apart certain types, such as instance declaration types, which disallow visible forall)s. For instance, if GHC split apart the forall in "instance forall a -> Show (Blah a)6, then that declaration would mistakenly be accepted!Note that this function looks through parentheses, so it will work on types such as  (forall a.  ...). The downside to this is that it is not generally possible to take the returned types and reconstruct the original type (parentheses and all) from them. Unlike , this function does not look through parentheses, hence the suffix _KP (short for "Keep Parentheses").ghcDecompose a type of the form forall  tvs. body into its constituent parts. Only splits type variable binders that were quantified invisibly (e.g.,  forall a., with a dot).This function is used to split apart certain types, such as instance declaration types, which disallow visible forall)s. For instance, if GHC split apart the forall in "instance forall a -> Show (Blah a)6, then that declaration would mistakenly be accepted!Unlike , this function does not look through parentheses, hence the suffix _KP (short for "Keep Parentheses").ghc;Decompose a GADT type into its constituent parts. Returns (outer_bndrs, mb_ctxt, body), where: outer_bndrs are  if the type has explicit, outermost type variable binders. Otherwise, they are .mb_ctxt is Just5 the context, if it is provided. Otherwise, it is Nothing.body, is the body of the type after the optional foralls and context.?This function is careful not to look through parentheses. See Note [GADT abstract syntax] (Wrinkle: No nested foralls or contexts)  GHC.Hs.Decls for why this is important.ghc3Decompose a type class instance type (of the form forall  tvs. context => instance_head-) into its constituent parts. Note that the [Name] s returned correspond to either:The implicitly bound type variables (if the type lacks an outermost forall), orThe explicitly bound type variables (if the type has an outermost forall).?This function is careful not to look through parentheses. See 6Note [No nested foralls or contexts in instance types] for why this is important.ghcDecompose a pattern synonym type signature into its constituent parts.Note that this function looks through parentheses, so it will work on types such as  (forall a.  ...). The downside to this is that it is not generally possible to take the returned types and reconstruct the original type (parentheses and all) from them.ghcDecompose a type of the form context => body into its constituent parts.Note that this function looks through parentheses, so it will work on types such as  (context =>  ...). The downside to this is that it is not generally possible to take the returned types and reconstruct the original type (parentheses and all) from them.ghc$Decompose a sigma type (of the form forall  tvs. context => body) into its constituent parts. Only splits type variable binders that were quantified invisibly (e.g.,  forall a., with a dot).This function is used to split apart certain types, such as instance declaration types, which disallow visible forall)s. For instance, if GHC split apart the forall in "instance forall a -> Show (Blah a)6, then that declaration would mistakenly be accepted!Note that this function looks through parentheses, so it will work on types such as  (forall a.  ...). The downside to this is that it is not generally possible to take the returned types and reconstruct the original type (parentheses and all) from them.ghcDecompose a type of the form context => body into its constituent parts.Unlike , this function does not look through parentheses, hence the suffix _KP (short for "Keep Parentheses").ghc Location of forall and -> for HsForAllVis Location of forall and  for HsForAllInvis!LLLLLLLLLLLLLLֆ׆؆نچۆ܆݆ކ߆ćŇLJƇLJȇɇʇˇ͇̇·χЇч҇ӇԇՇևׇ؇هڇۇ܇݇އ߇!؆ۆ׆܆ćŇLJƇLJȇɇʇˇ̇߇ևއׇ؇هڇۇ͇·χЇч܇݇Շֆ҇LLLLLLLLLLLLLLӇ߆ԇކچ݆ن Safe-Inferred().05 ԅghcUsed as a data type index for the hsSyn AST; also serves as a singleton type for Passۅghc.Maps the "normal" id type for a given GHC pass܅ghcAllows us to check what phase we're in at GHC's runtime. For example, this class allows us to write > f :: forall p. IsPass p => HsExpr (GhcPass p) -> blah > f e = case ghcPass @p of > GhcPs -> ... in this RHS we have HsExpr GhcPs... > GhcRn -> ... in this RHS we have HsExpr GhcRn... > GhcTc -> ... in this RHS we have HsExpr GhcTc... which is very useful, for example, when pretty-printing. See Note [IsPass].ghc1Constraint type to bundle up the requirement for  on both the id and the U of it. See Note [NoGhcTc].ghcMarks that a field uses the GhcRn variant even when the pass parameter is GhcTc. Useful for storing HsTypes in GHC.Hs.Exprs, say, because HsType GhcTc should never occur. See Note [NoGhcTc]х҅ӅԅՅօׅ؅مڅۅ܅݅ޅ߅ޅԅՅօׅ؅مڅ܅݅ۅ߅х҅Ӆ Safe-Inferred.045 ghc p e returns M if the expression e% needs parentheses under precedence p.ghc.Is there only one RHS in this list of matches?ghcMake a X from a 4 (the "rn" is because this is used in the renamer).ghcMake a 'SyntaxExpr GhcRn' from an expression Used only in getMonadFailOp. See Note [Monad fail : Rebindable syntax, overloaded strings] in GHC.Rename.ExprghcThis is used for rebindable-syntax pieces that are too polymorphic for tcSyntaxOp (trS_fmap and the mzip in ParStmt)ghc p e checks if  p e is true, and if so, surrounds e with an Ȍ. Otherwise, it simply returns e.ghc')'ghc'('ΐghcMatch separator locationԐghcHsWrap appears only in typechecker output Invariant: The contained Expr is *NOT* itself an HsWrap. See Note [Detecting forced eta expansion] in GHC.HsToCore.Expr#. This invariant is maintained by +. hs_syn is something like HsExpr or HsCmd֐ghcPending Renamer SpliceؐghcPending Type-checker SpliceڐghcPost-Type checking ExpressionPostTcExpr is an evidence expression attached to the syntax tree by the type checker (c.f. postTcType).ېghcPost-Type checking TableWe use a PostTcTable where there are a bunch of pieces of evidence, more than is convenient to keep individually.ghcExtra data fields for a ׌, added by the type checkerghcThe function to use in rebindable syntax. See Note [NoSyntaxExpr].ghc7An expression with wrappers, used for rebindable syntaxThis should desugar to syn_res_wrap $ syn_expr (syn_arg_wraps[0] arg0) (syn_arg_wraps[1] arg1) ...:where the actual arguments come from elsewhere in the AST.ghc(Just print the original expression (the a).XXߌތ݌܌یٌ،ҌьЌόΌ͌ˌʌƌɌŌԌŒ׌Ì̌֌njȌՌČڌӌXXXXًڋۋ܋݋ދߋԍӍҍэЍύ΍͍̍ˍʍɍȍǍƍōč͍Ս֍׍؍ٍڍލݍۍ܍ÐǐƐĐŐȐːɐʐ̐ϐ͐ΐАѐҐӐԐՐ֐אِؐڐېܐߐݐސÐǐƐĐŐȐːɐʐ̐ϐ͐ΐАѐҐӐԐՐ֐אِؐڐېܐߐݐސ Safe-Inferred.05 XghcGuarded Right-Hand Sides8GRHSs are used both for pattern bindings and for Matches :  , , , , ,XghcA Haskell expression.XghcHaskell SpliceXghcLocated Haskell ExpressionXghcSyntax ExpressionSyntaxExpr is represents the function used in interpreting rebindable syntax. In the parser, we have no information to supply; in the renamer, we have the name of the function (but see Note [Monad fail : Rebindable syntax, overloaded strings] for a wrinkle) and in the type-checker we have a more elaborate structure  SyntaxExprTc.In some contexts, rebindable syntax is not implemented, and so we have constructors to represent that possibility in both the renamer and typechecker instantiations.E.g. (>>=)4 is filled in before the renamer by the appropriate  for (>>=), and then instantiated by the type checker with its type args etc܋ghcIs this a monadic context?ghcApplicative ArgumentghcTrue  = was a BodyStmt, False  =1 was a BindStmt. See Note [Applicative BodyStmt]ghc,context of the do expression, used in pprArgghc!The fail operator, after renamingThe fail operator is needed if this is a BindStmt where the pattern can fail. E.g.: (Just a) <- stmt The fail operator will be invoked if the pattern match fails. It is also used for guards in MonadComprehensions. The fail operator is Nothing if the pattern match can't failghcArithmetic Sequence InformationghcCommand Located StatementghcCommand Statementghc'Command Syntax Table (for Arrow syntax)ghcExpression Located StatementghcExpression StatementghcThe fail operatorThis is used for `.. <-` "bind statements" in do notation, including non-monadic "binds" in applicative.The fail operator is 'Just expr' if it potentially fail monadically. if the pattern match cannot fail, or shouldn't fail monadically (regular incomplete pattern exception), it is K.See Note [Monad fail : Rebindable syntax, overloaded strings] for the type of expression in the L case, and why it is so.See Note [Failing pattern matches in Stmts] for which contexts for 'BindStmt3's should use the monadic fail and which shouldn't.ghcRecordDotSyntax field updatesghcGuarded Right Hand Side.ghc Guarded RHSsghcThe where clauseghcGhci Located StatementghcGhci StatementghcGuard Located StatementghcGuard StatementghcHaskell Array Application TypeghcHaskell arrow match context.ghc(A case alternative inside arrow notationghcAn arrow kappa abstractionghcA proc expressionghcHaskell Bracketghc;Haskell Command (e.g. a "statement" in an Arrow proc block)ghc :  , , , ghc :  '(|' ,  '|)'ghc :  , , '{' ,  '}'ghc : , , , , ghc :  ,  , , , ,ghc :  , ,ghc :  , , '{' ,  '}'ghc :  ,  '{' ,  '}',ghc :  '(',  ')'ghcHaskell Top-level CommandghcThe AST used to hard-refer to GhcPass, which was a layer violation. For now, we paper it over with this new extension point.ghcArithmetic sequence :  '[', ,,  ']'ghcSyntactic list: [a,b,c,...] :  '[',  ']'ghcUsed for unboxed sum types :  '(#' , ,  '#)',There will be multiple , (1 - alternative) before the expression, (arity - alternative) after itghc-Used for explicit tuples and sections thereof :  , ghc,Expression with an explicit type signature.  e :: type : ghc ApplicationghcVisible type applicationExplicit type argument; e.g f @Int x y NB: Has wildcards, but no implicit quantification : ,ghc :  , , , ,ghc :  , , '{' ,  '}'ghcAfter typechecker only; must be different HsVar for pretty printingghc : , , , , ghcRecord field selection e.g z.x. : This case only arises when the OverloadedRecordDot langauge extension is enabled.ghc2Implicit parameter (not in use after typechecking)ghc :  ,  , , , ,ghc3Lambda abstraction. Currently always a single match :  , ,Œghc Lambda-case :  , , , Ìghclet(rec) :  ,  '{' ,  '}',Čghc Simple (non-overloaded) literalsŌghc Multi-way if :  ,,ƌghcOverloaded label (Note [Overloaded labels] in GHC.OverloadedLabels)njghcOverloaded literalsȌghc :  '(',  ')'ʌghcproc notation for Arrows :  , ˌghcRecord field selector. e.g. (.x) or (.x.y) :  , This case only arises when the OverloadedRecordDot langauge extensions is enabled.̌ghcVariable pointing to record selector The parser produces HsVars The renamer renames record-field selectors to HsRecFld The typechecker preserves HsRecFldΌghc :  , όghc : ,ҌghcUnbound variable; also used for "holes" (_ or _x). Turned from HsVar to HsUnboundVar by the renamer, when it finds an out-of-scope variable or hole. The (XUnboundVar p) field becomes an HoleExprRef after typechecking; this is where the erroring expression will be written after solving. See Note [Holes] in GHC.Tc.Types.Constraint.ӌghc%Variable See Note [Located RdrNames]ԌghcNegation operator. Contains the negated expression and the name of  : ՌghcOperator applications: NB Bracketed ops such as (+) come out as Vars.֌ghcRecord construction :  '{' , , '}'׌ghc Record update :  '{' , , '}'+ 'GHC.Parser.Annotation.AnnComma,  ,  '}'ghcHaskell Match ContextContext of a pattern match. This is more subtle than it would seem. See Note [Varieties of pattern matches].ghc%A pattern match inside arrow notationghc)Patterns and guards on a case alternativeghc$Guards of a multi-way if alternativeghcPatterns of a lambdaghcGuards of pattern bindings, e.g., (Just b) | Just _ <- x = e | otherwise = e'ghc"A pattern binding eg [y] <- e = eghcA pattern synonym declarationghcRecord update [used only in GHC.HsToCore.Expr to tell matchWrapper what sort of runtime error message to generate]ghc=Pattern of a do-stmt, list comprehension, pattern guard, etcghc1A Template Haskell pattern quotation [p| (a,b) |]ghc!A Template Haskell pattern spliceghc fixing of fghcfunction binder of fghcwas f' banged? See Note [FunBind vs PatBind]ghcA pragma, written as {-# ... #-}, that may appear within an expression.ghc :  ,  '{-# GENERATED' , , , , ,  , , ,  ,  '#-}'ghcHaskell Record BindingsghcHaskell Spliced Thing-Values that can result from running a splice.ghcHaskell Spliced ExpressionghcHaskell Spliced PatternghcHaskell Spliced TypeghcHaskell Statement Context.ghc'do-notation in an arrow-command contextghc  ModuleName. do { ... }ghc&A command-line Stmt in GHCi pat <- rhsghc  ModuleName.'mdo { ... } ie recursive do-expressionghcA branch of a parallel stmtghc!Pattern guard for specified thingghcA branch of a transform stmtghc : Haskell Tuple Argumentghc-The argument is missing, but this is its typeghc The argumentghc&Note [Trees that Grow] extension pointghcLocated Guarded Right-Hand Sideghc*Located Haskell Command (for arrow syntax)ghcTop-level command, introducing a new arrow. This may occur inside a proc (where the stack is empty) or as an argument of a command-forming operator.!Located Haskell Top-level CommandghcLocated Haskell Tuple Argument is used for tuple sections (,a,) is represented by 3ExplicitTuple [Missing ty1, Present a, Missing ty3] Which in turn stands for (x:ty1 y:ty2. (x,a,y))ghc Located Match May have  :  when in a listghcLocated do block Statementghc3Located Statement with separate Left and Right id'sghcParenthesised Statement BlockghcA splice can appear with various decorations wrapped around it. This data type captures explicitly how it was originally written, for use in the pretty printer.ghc bare spliceghc$splice or $$spliceghcdo block Statementghc>Exact print annotations when in qualifier lists or guards -  :  , , , , , ,ghc2 represents an applicative expression built with  and ". It is generated by the renamer, and is desugared into the appropriate applicative expression by the desugarer, but it is intended to be invisible in error messages..For full details, see Note [ApplicativeDo] in GHC.Rename.Exprghc :   '{', '}',ghc : Սghc&Finalizers produced by a splice with See Note [Delaying modFinalizers in untyped splices] in GHC.Rename.Splice. For how this is used.Xghc May have  :  when in a listȌghc.Parenthesised expr; see Note [Parens in HsSyn]ghcPost renaming has optional fail and bind / (>>=) operator. Post typechecking, also has multiplicity of the argument and the result type of the function passed to bind; that is, (P, S) in (>>=) :: Q -> (R # P -> S) -> T See Note [The type of bind in Stmts]XXߌތ݌܌یٌ،ҌьЌόΌ͌ˌʌƌɌŌԌŒ׌Ì̌֌njȌՌČڌӌXXXXًڋۋ܋݋ދߋԍӍҍэЍύ΍͍̍ˍʍɍȍǍƍōč͍Ս֍׍ٍ؍ڍލݍ܍ۍXXXߌތ݌܌یٌ،ҌьЌόΌ͌ˌʌƌɌŌԌŒ׌Ì̌֌njȌՌČڌӌXڋXԍӍҍэЍύ΍͍̍ˍʍɍȍǍƍōč͍׍ٍ؍XߋՍ֍ڍލݍ܍ۍދ݋ً܋ۋ Safe-Inferred'.789 IՆghcPattern : ghc#Haskell Constructor Pattern DetailsghcHaskell Record FieldghcHaskell Record Field : ,For details on above see note [exact print annotations] in GHC.Parser.Annotationghc!Filled in by renamer when punningghcNote [Punning]ghcHaskell Record FieldsHsRecFields is used only for patterns and expressions (not data type declarations)ghcHaskell Record Update FieldghcLocated Haskell Record FieldghcLocated Haskell Record Fieldghc#Located Haskell Record Update FieldghcAs pattern ^ -  : ghcBang pattern ^ -  : ghcConstructor PatternghcLazy Pattern ^ -  : ghcSyntactic List :  '['&,  ']'ghcLiteral Pattern Used for *non-overloaded* literal patterns: Int#, Char#, Int, Char, String, etc.ghcNatural Pattern :  ghc n+k patternghcParenthesised pattern See Note [Parens in HsSyn] in GHC.Hs.Expr ^ -  :  '('&,  ')'ghc : ghc :  '$('  ')'ghcAnonymous sum pattern :  '(#',  '#)'ghcTuple sub-patterns :  '(' or '(#',  ')' or '#)'ghcVariable Patternghc : ghcWildcard Pattern The sole reason for a type on a WildPat is to support hsPatType :: Pat Id -> Typeghc4Trees that Grow extension point for new constructorsghcPattern with a type signatureghc&Splice Pattern (Includes quasi-quotes)ghc View Pattern+ԆՆ+ՆԆ Safe-Inferred.5 ghc p l returns M if a literal l- needs to be parenthesized under precedence p.ghc p ol returns M if an overloaded literal ol, needs to be parenthesized under precedence p.ghcHaskell Literalghc CharacterghcUnboxed characterghcUnboxed Doubleghc Unboxed FloatghcGenuinely an Int; arises from GHC.Tc.Deriv.Generate, and from TRANSLATIONghcliteral Int64#ghcliteral Int#ghcGenuinely an integer; arises only from TRANSLATION (overloaded literals are done with HsOverLit)ghcGenuinely a rational; arises only from TRANSLATION (overloaded literals are done with HsOverLit)ghcStringghc Packed bytesghcliteral Word64#ghcliteral Word#ÆghcHaskell Overloaded LiteralɆghcOverloaded Literal ValueʆghcFrac-looking literalsˆghcInteger-looking literals;̆ghcString-looking literals†ÆȆdžƆĆņɆ̆ˆʆ†ÆȆdžƆĆņɆ̆ˆʆ Safe-Inferred'.5 .ghcA short description of a DerivStrategy'.ghc type classghcclosed type family infoghcTrue  = argument is a data/newtype declaration.ghcdata family declarationghctype/data family declarationghcopen type family infoghc!type or type instance declarationghctype family declarationghc Convert a  to a <ghcAnnotation Declarationghc :  ,   ghcAnnotation ProvenanceghcClass Instance Declarationghc : &, ,ghc data T b = forall a. Eq a => MkT a b MkT :: forall b a. Eq a => MkT a b data T b where MkT1 :: Int -> T Int data T = Int MkT, Int | MkT2 data T a where Int MkT Int :: T Int s : , ,, ,, ,, ,data Constructor Declaration‰ghcArguments; can be infixÉghcThe outermost type variable binders, be they explicit or implicit. The W is used to anchor exact print annotations, AnnForall and AnnDot.ĉghcA possible Haddock comment.ʼnghcExistentials onlyljghcTrue  = explicit user-written forall e.g. data T a = forall b. MkT b (b->a) con_ex_tvs = {b} False => con_ex_tvs is emptyȉghcArguments; never infixʉghcUser-written context (if any)͉ghc Result typeЉghcdoes this have a CUSK? See Note [CUSKs: complete user-supplied kind signatures]҉ghc Data Family Instance DeclarationӉghc :  , , ,  , , ՉghcDefault Declaration։ghcs :  , ,؉ghc The types mentioned in a single deriving& clause. This can come in two forms, ډ or ى, depending on whether the types are surrounded by enclosing parentheses or not. These parentheses are semantically different than . For example,  deriving () means "derive zero classes" rather than "derive an instance of the 0-tuple".؉ use ܇ because deriving clauses can mention type variables that aren't bound by the datatype, e.g. data T b = ... deriving (C [a])&should produce a derived instance for  C [a] (T b).ىghcA deriving clause with a comma-separated list of types, surrounded by enclosing parentheses. Example: deriving (Eq, C a)ډghcA deriving clause with a single type. Moreover, that type can only be a type constructor without any arguments. Example:  deriving Eq܉ghc+Stand-alone 'deriving instance' declarationghc :  , ,  , ,  , ,ghcThe instance type to derive. It uses an ݇9 because the context is allowed to be a single wildcard: !deriving instance _ => Eq (Foo a)4Which signifies that the context should be inferred.ghcWhich technique the user explicitly requested when deriving an instance.ghc -XDeriveAnyClassghc -XGeneralizedNewtypeDerivingghcGHC's "standard" strategy, which is to implement a custom instance for the data type. This only works for certain types that GHC knows about (e.g., ', 3, , when -XDeriveFunctor is enabled, etc.)ghc  -XDerivingViaghc!Documentation comment DeclarationghcFamily EquationOne equation in a type family instance declaration, data family instance declaration, or type family default. See Note [Type family instance declarations in HsSyn] See Note [Family instance declaration binders]ghcOptional quantified type varsghcFixity used in the declarationghc : ghctype Family Declarationghc : , , , , , , , , , ghcK if we're in an hs-boot file and the user said "type family Foo x where .."ghctype Family Result Signatureghc : ,, ghc :ghc : ,, , ghcForeign Declarationghc :  , , , ghcThe arguments in a GADT constructor. Unlike Haskell98-style constructors, GADT constructors cannot be declared with infix syntax. As a result, we do not use  here, as  would be an unrepresentable state. (There is a notion of infix GADT constructors for the purposes of derived Show instances@see Note [Infix GADT constructors] in GHC.Tc.TyCl@but that is an orthogonal concern.)ghc4The arguments in a Haskell98-style data constructor.ghcHaskell Data type Definitionghc:Declares a data type or newtype, giving its constructors  data/newtype T a =  constrs! data/newtype instance T [a] =  constrs ghcData constructorsFor data T a = T1 | T2 a the  s all have . For data T a where { T1 :: T a } the  LConDecls all have .ghcContextghc Optional  'deriving' clauseghcOptional kind signature.(Just k) for a GADT-style data, or  data instance decl, with explicit kind sigAlways Nothing for H98-syntax declsghcA Haskell DeclarationghcAnnotation declarationghc 'default' declarationghcDeriving declarationghc!Documentation comment declarationghcForeign declarationghcInstance declarationghcStandalone kind signatureghcRole annotation declarationghcRule declarationghcSignature declarationghc+Splice declaration (Includes quasi-quotes)ghcType or Class DeclarationghcValue declarationghcWarning declarationghcHaskell Deriving clauseghc A single deriving clause of a data declaration. : ,  , ,  , ,ghc;The user-specified strategy (if any) to use when deriving .ghcThe types to derive.ghc Haskell GroupA  is categorised into a " before being fed to the renamer.ъghcHaskell Type PatternsҊghcIf the user supplied an injectivity annotation it is represented using InjectivityAnn. At the moment this is a single injectivity condition - see Note [Injectivity annotation]. `Located name` stores the LHS of injectivity condition. `[Located name]` stores the RHS of injectivity condition. Example:.type family Foo a b c = r | r -> a c where ...,This will be represented as "InjectivityAnn r [a, c]"ӊghc : , ՊghcInstance DeclarationghcLocated Annotation Declarationghc"Located Class Instance Declarationghc$Located data Constructor Declarationghc(Located Data Family Instance DeclarationghcLocated Default Declarationghc3Located stand-alone 'deriving instance' declarationghcA  .ghc)Located Documentation comment DeclarationghcLocated type Family Declarationghc$Located type Family Result SignatureghcLocated Foreign DeclarationghcLocated Injectivity AnnotationghcLocated Instance Declarationghc#Located Role Annotation DeclarationghcLocated Rule BinderghcLocated Rule DeclarationghcLocated Rule DeclarationsghcLocated Splice Declarationghc!Located Standalone Kind Signatureghc&Located Declaration of a Type or Classghc)Located type family default declarations.ghc(Located Type Family Instance Declarationghc%Located Type Family Instance Equationghc"Located Warning pragma DeclarationghcLocated Warning Declarationsghc  data Blah ...ghc newtype Blah ...ghcRole Annotation Declarationghc :  , ghc Rule Binderghc : , ,ghcRule Declarationghc-After renamer, free-vars from the LHS and RHSghcNote [Pragma source text] in GHC.Types.Basicghc : , ,  ,  , , , ,ghcForall'd term vars, before typechecking; after typechecking this includes all forall'd varsghcForall'd type varsghcRule DeclarationsghcSplice DeclarationghcA type or class declaration.ghcdata declaration : , , , , ,ghc type/data family T :: *->* : , , ,, ,, ,, ,, ghctype declaration : , ,ghcAssociated type defaultsghcAssociated types;ghcPost renamer, FVsghc Context...ghcPost renamer, CUSK flag, FVsghc Haddock docsghcFunctional depsghcFixity used in the declarationghcType constructorghcDefault methodsghcRHS of type declarationghcPost renameer, FVsghcMethods' signaturesghcType variables; for an associated type these include outer bindersghcType or Class Groupghc abe_mono) ~ abe_polyghcFixity SignatureghcHaskell Bindingghc1Haskell Binding with separate Left and Right id'sghcAbstraction BindingsghcFunction-like Binding'FunBind is used for both functions f x = e) and variables  f = x -> e) and strict variables  !x = x + 1/Reason 1: Special case for type inference: see .Reason 2: Instance decls can only have FunBinds, which is convenient. If you change this, you'll need to change e.g. rnMethodBinds'But note that the form f :: a->a = ... parses as a pattern binding, just like (f :: a -> a) = ... 6Strict bindings have their strictness recorded in the L of their  MatchContext. See Note [FunBind vs PatBind] for details about the relationship between FunBind and PatBind.s), attached to each element of fun_matches,, ,,ghcPattern BindingThe pattern is never a simple variable; That case is done by FunBind. See Note [FunBind vs PatBind] for details about the relationship between FunBind and PatBind.ghcPatterns Synonym BindingghcVariable BindingDictionary binding and suchlike. All VarBinds are introduced by the type checkerghcTypechecked user bindingsˆghc#Evidence bindings Why a list? See GHC.Tc.TyCl.Instance4 Note [Typechecking plan for instance declarations]ÈghcIncludes equality constraintsĈghcAbsBinds only gets used when idL = idR after renaming, but these need to be idL's for the collect... code in HsUtil to have the right typeȈghcAfter the renamer (but before the type-checker), this contains the locally-bound free variables of this defn. See Note [Bind free vars]After the type-checker, this contains a coercion from the type of the MatchGroup to the type of the Id. Example: 1 f :: Int -> forall a. a -> a f x y = y Then the MatchGroup will have type (Int -> a' -> a') (with a free type variable a'). The coercion will take a CoreExpr of this type and convert it to a CoreExpr of type Int -> forall a'. a' -> a' Notice that the coercion captures the free a'.ʈghc The payloadˈghcTicks to put on the rhs, if anÿghcSee Note [Bind free vars]ψghcTicks to put on the rhs, if any, and ticks to put on the bound variables.҈ghcLocated only for consistencyӈghc#Haskell Implicit Parameter BindingsֈghcHaskell Local Bindings׈ghcHaskell Local Bindings with separate Left and Right identifier typesBindings in a 'let' expression or a 'where' clause؈ghcEmpty Local Bindingsوghc#Haskell Implicit Parameter BindingsڈghcHaskell Value Bindings܈ghcHaskell Pattern Synonym Details݈ghc!Haskell Pattern Synonym DirectionghcHaskell Value BindingsghcHaskell Value bindings with separate Left and Right identifier types (not implicit parameters) Used for both top level and nested bindings May contain pattern synonym bindingsghcValue Bindings InBefore renaming RHS; idR is always RdrName Not dependency analysed Recursive by defaultghcValue Bindings OutAfter renaming RHS; idR can be Name or Id Dependency analysed, later bindings in the list may depend on earlier ones.ghcImplicit parameter bindings.These bindings start off as (Left "x") in the parser and stay that way until after type-checking when they are replaced with (Right d), where "d" is the name of the dictionary holding the evidence for the implicit parameter. : ghcLocated Fixity SignatureghcLocated Haskell BindingghcLocated Haskell Binding with separate Left and Right identifier typesghcLocated Haskell BindingsghcLocated Haskell Bindings with separate Left and Right identifier typesghcLocated Haskell local bindingsghc"Located Implicit Parameter Binding May have  :  when in a listghcLocated Signatureghc*Located Type checker Specification Pragmasghc : , ,, , '{',  '}',Pattern Synonym bindingghcFormal parameter namesghcRight-hand sideghcDirectionalityghc.Post renaming, FVs. See Note [Bind free vars]ghcName of the pattern synonymghcRecord Pattern Synonym Fieldghc'Field label visible in rest of the fileghc=Filled in by renamer, the name used internally by the patternghcSignatures and pragmasghcA signature for a class method False: ordinary class-method signature True: generic-default class method signature e.g. class C a where op :: a -> a -- Ordinary default op :: Eq a => a -> a -- Generic default No wildcards allowed here :  , ghcA complete match pragma {-# COMPLETE C, D [:: T] #-}Used to inform the pattern match checker about additional complete matchings which, for example, arise from pattern synonym definitions.ghcAn ordinary fixity declaration  infixl 8 *** :  , ghcA type signature in generated code, notably the code generated for record selectors. We simply record the desired Id itself, replete with its name, type and IdDetails. Otherwise it's just like a type signature: there should be an accompanying bindingghcAn inline pragma {#- INLINE f #-} :   '{-# INLINE' and '[' , , , , , ghc$A minimal complete definition pragma ${-# MINIMAL a | (b, c | (d | e)) #-} : , ,, ghc A pattern synonym type signature ,pattern Single :: () => (Show a) => a -> [a] :  , , ,ghc+A "set cost centre" pragma for declarations {-# SCC funName #-}or &{-# SCC funName "cost_centre_name" #-}ghc6A specialisation pragma for instance declarations only ${-# SPECIALISE instance Eq [Int] #-}(Class tys); should be a specialisation of the current instance declaration : , ,ghcA specialisation pragma "{-# SPECIALISE f :: Int -> Int #-} : ,  '{-# SPECIALISE' and '[', , ,  ']' and '#-}', ghcAn ordinary type signature f :: Num a => a -> aAfter renaming, this list of Names contains the named wildcards brought into scope by this signature. For a signature _ -> _a -> Bool., the renamer will leave the unnamed wildcard _$ untouched, and the named wildcard _a is then replaced with fresh meta vars in the type. Their names are stored in the type signature that brought them into scope, in this third field to be more specific. :  , ghc!Type checker Specification PragmaghcThe Id to be specialised, a wrapper that specialises the polymorphic function, and inlining spec for the specialised functionghc#Type checker Specialisation Pragmas conveys  SPECIALISE/ pragmas from the type checker to the desugarerghcSuper-specialised: a default method should be macro-expanded at every call siteghc :  , , ,   '{', '}'҈шЈψΈ͈̈ˈʈȈLjƈňĈȈɈӈԈՈֈ׈ۈ؈وڈ܈݈߈ވֈ׈ۈ؈وڈ҈шЈψΈ͈̈ˈʈȈLjƈňĈȈɈӈԈՈ܈݈߈ވ Safe-Inferred5 Z'ghcConstructs the cache for the  mi_warn_fn field of a ModIface'ghc Warning Text6reason/explanation from a WARNING or DEPRECATED pragma'ghc Warning information for a module'ghcNothing deprecated'ghcWhole module deprecated'ghcSome specific things deprecated ''''''''''' ''''''''''' Safe-Inferred5 ^] /ghcJoin two docstrings.Non-empty docstrings are joined with two newlines in between, resulting in separate paragraphs./ghc/Concat docstrings with two newlines in between.Empty docstrings are skipped.If all inputs are empty, K is returned./ghcReturn the contents of a / as a UTF8-encoded ./ghc Create a / from a UTF8-encoded ./ghc>Docs for arguments. E.g. function arguments, method arguments./ghcDocs for declarations: functions, data types, instances, methods etc./ghc4Maps of docs that were added via Template Haskell's putDoc./ghc.The documentation added to function arguments./ghc(The documentation added to declarations./ghc6The documentation added to class and family instances./ghc4The added module header documentation, if it exists./ghcHaskell Documentation String"Internally this is a UTF8-Encoded ./ghc$Located Haskell Documentation String//////////////////////////////////////////// Safe-Inferred7 <ghc Access the n carried by the & during constraint solving. Returns K if invoked during  or .ghcGet target platformghc#No signature or a partial signatureghc Check the  for consistency. Currently, only checks axioms, but should check other aspects, too.ghcUnion two ImportAvailsThis function is a key part of Import handling, basically for each import we create a separate ImportAvails structure and then union them all together with this function.ghc;This function provides an escape for direct access to the : monad. It should not be used lightly, and the provided  API should be favoured instead.ghcThis is a mirror of Template Haskell's DocLoc, but the TH names are resolved to GHC names.ʧghcʧ describes the result of running the frontend of a Haskell module. Currently one always gets a ˧, since running the frontend involves typechecking a program. hs-sig merges are not handled here.This data type really should be in GHC.Driver.Env, but it needs to have a TcGblEnv which is only defined here.̧ghc+IdBindingInfo describes how an Id is bound.?It is used for the following purposes: a) for static forms in  and b) to figure out when a nested binding can be generalised, in .ghc summarises what was imported from where, irrespective of whether the imported things are actually used or not. It is used: when processing the export list,4when constructing usage info for the interface file,to identify the list of directly imported modules for initialisation purposes and for optimised overlap checking of family instances,/when figuring out what things are really unusedghc8Home-package modules needed by the module being compiledIt doesn't matter whether any of these dependencies are actually used when compiling the module; they are listed if they are below it at all. For example, suppose M imports A which imports X. Then compiling M might not need to consult X.hi, but X is still listed in M's dependencies.ghcPackages needed by the module being compiled, whether directly, or via other modules in this package, or via modules imported from other packages.ghcFamily instance modules below us in the import tree (and maybe including us for imported modules)ghc'Domain is all directly-imported modules-See the documentation on ImportedModsVal in GHC.Unit.Module.Imported for the meaning of the fields.We need a full ModuleEnv rather than a ModuleNameEnv here, because we might be importing modules of the same name from different packages. (currently not the case, but might be in the future).ghcOrphan modules below us in the import tree (and maybe including us for imported modules)ghcDo we require that our own package is trusted? This is to handle efficiently the case where a Safe module imports a Trustworthy module that resides in the same package as it. See Note [Trust Own Package] in GHC.Rename.NamesghcThis is strictly a subset of imp_dep_pkgs and records the packages the current module needs to trust for Safe Haskell compilation to succeed. A package is required to be trusted if we are dependent on a trustworthy module in that package. While perhaps making imp_dep_pkgs a tuple of (UnitId, Bool) where True for the bool indicates the package is required to be trusted is the more logical design, doing so complicates a lot of code not concerned with Safe Haskell. See Note [Tracking Trust Transitively] in GHC.Rename.Namesghc>IsGroupClosed describes a group of mutually-recursive bindingsghcA  is a substitution on s that can be used to refine the identities of a hole while we are renaming interfaces (see GHC.Iface.Rename). Specifically, a  for ns_module_name A, defines a mapping from {A.T} (for some   T) to some arbitrary other ."The most intruiging thing about a (, however, is how it's constructed. A  is *implied* by the exported *s of the implementor of an interface: if an implementor of signature  exports M.T-, you implicitly define a substitution from {H.T} to M.T. So a  is computed from the list of *s that are exported by the implementation of a module, or successively merged together by the export lists of signatures which are joining together.It's not the most obvious way to go about doing this, but it does seem to work!NB: Can't boot this and put it in NameShape because then we start pulling in too many DynFlags things.ghc+Historical "renaming monad" (now it's just ).ghcThe current collection of docs that Template Haskell has built up via putDoc.ghc describes the top-level of the module at the point at which the typechecker is finished work. It is this structure that is handed on to the desugarer For state that needs to be updated during the typechecking phase and returned at end, use a  (= x).ghcAnd for annotationsghc,Tracking indices for cost centre annotationsghcTypes used for defaulting. Nothing => no default declghc"dependencies from addDependentFileghc&Allows us to choose unique DFun names.ghcMaybe Haddock header docsghcWhat is exportedghcDitto for family instances NB. BangPattern is to fix a leak, see #15111ghcJust for things in this module See Note [The interactive package] in GHC.Runtime.ContextghcJust for things in this moduleghc8A list of user-defined plugins for hole fit suggestions.ghcTrue if any part of the prog uses hpc instrumentation. NB. BangPattern is to fix a leak, see #15111ghcInformation about what was imported from where, including things bound in this module. Also store Safe Haskell info here about transitive trusted package requirements.There are not many uses of this field, so you can grep for all them.The ImportAvails records information about the following things: 6All of the modules you directly imported (tcRnImports)The orphans (only!) of all imported modules in a GHCi session (runTcInteractive)(The module that instantiated a signature%Each of the signatures that merged inIt is used in the following ways: - imp_orphs is used to determine what orphan modules should be visible in the context (tcVisibleOrphanMods) - imp_finsts is used to determine what family instances should be visible (tcExtendLocalFamInstEnv) - To resolve the meaning of the export list of a module (tcRnExports) - imp_mods is used to compute usage info (mkIfaceTc, deSugar) - imp_trust_own_pkg is used for Safe Haskell in interfaces (mkIfaceTc, as well as in GHC.Driver.Main) - To create the Dependencies field in interface (mkDependencies)ghcInstance envt for all  home-package modules; Includes the dfuns in tcg_insts NB. BangPattern is to fix a leak, see #15111ghcThe Name of the main function, if this module is the main module.ghcThe requirements we merged with; we always have to recompile if any of these changed.ghcModule being compiledghc$Top level envt; used during renamingghcRenamed decls, maybe. Nothing! <=> Don't retain renamed decls.ghcHas the typechecker inferred this module as -XSafe (Safe Haskell) See Note [Safe Haskell Overlapping Instances Implementation], although this is used for more than just that failure case.ghc5Whether this module has a corresponding hi-boot fileghcIf a signature, the backing module See also Note [Identity versus semantic module]ghc4What kind of module (regular Haskell, hs-boot, hsig)ghcWanted constraints of static forms. See Note [Constraints in static forms].ghc9A list of user-defined plugins for the constraint solver.ghc,Core plugins added by Template Haskell code.ghc#Docs added in Template Haskell via putDoc.ghcForeign files emitted from TH.ghc#Template Haskell module finalizers.+They can use particular local environments.ghcTemplate Haskell stateghcTrue( <=> A Template Haskell splice was used.2Splices disable recompilation avoidance (see #481)¨ghc'Top-level declarations from addTopDeclsèghc>Exact names bound in top-level declarations in tcg_th_topdeclsĨghcTrue" <=> Template Haskell syntax used.We need this so that we can generate a dependency on the Template Haskell package, because the desugarer is going to emit loads of references to TH symbols. The reference is implicit rather than explicit, so we have to zap a mutable variable.Ũghc%The RealSrcSpan this module came fromǨghcGlobal type env for the module we are compiling now. All TyCons and Classes (for this module) end up in here right away, along with their derived constructors, selectors.(Ids defined in this module start in the local envt, though they move to the global envt during zonking)NB: for what "things in this module" means, see Note [The interactive package] in GHC.Runtime.Contextghc0Historical "type-checking monad" (now it's just ).ghc.Initialize plugin, when entering type-checker.ghcSolve some constraints. TODO: WRITE MORE DETAILS ON HOW THIS WORKS.ghc9Clean up after the plugin, when exiting the type-checker.ghcThe plugin found a contradiction. The returned constraints are removed from the inert set, and recorded as insoluble.ghcThe first field is for constraints that were solved. These are removed from the inert set, and the evidence for them is recorded. The second field contains new work, that should be processed by the constraint solver.ghcType alias for x; the convention is we'll use this for mutable bits of data in  which are updated during typechecking and returned at the end.ghc?A typecheckable thing available in a local context. Could be  !1, but also lexically scoped variables, etc. See GHC.Tc.Utils.Env for how to retrieve a ! given a .OOmmmmmݨިߨ§çħŧƧǧȧɧʧ˧̧ͧΧϧЧѧҧӧԧէ֧קا٧ڧۧܧݧާߧȨ¨èĨŨƨǨɨʨ˨̨ͨΨϨШѨҨӨԨը֨רب٨ڨۨܨߧէЧçħŧƧǧȧȨ¨èĨŨƨǨɨʨmݨިߨmmmmѧҧӧԧ֧קا٧ڧۧܧݧާʧ˧ɧ̧ͧΧϧOO§ͨΨϨШѨҨӨԨը֨רب٨ڨۨܨ˨̨ Safe-Inferred nghcConstructs an empty ModDetailsnghcThe n/ is essentially a cache for information in the ModIface for home modules only. Information relating to packages will be loaded into global environments in ExternalPackageState.nghcAnnotations present in this module: currently they only annotate things also declared in this modulenghc&Complete match pragmas for this modulenghcDFunId"s for the instances in this modulenghcDomain may include Ids from other modulesnghcLocal type environment for this particular module Includes Ids, TyCons, PatSyns nnnnnnnnnn nnnnnnnnnn Safe-Inferred \ghc A map from s to !s, constructed by typechecking local declarations or interface files\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\ Safe-Inferred EOghcA list of conlikes which represents a complete pattern match. These arise from COMPLETE signatures. See also Note [Implementation of COMPLETE pragmas].Oghc The set of N valuesOghc6The optional, concrete result TyCon the set applies toOOOOOOOOOOOOOO Safe-Inferred7 >+ghcDeserialize all annotations of a given type. This happens lazily, that is no deserialization will take place until the [a] is actually demanded and the [a] can also be empty (the UniqFM is not filtered).+ghc An empty annotation environment.+ghc,Add the given annotation to the environment.+ghc5Find the annotations attached to the given target as  values of your choice. If no deserializer is specified, only transient annotations will be returned.,ghc5Find the annotations attached to the given target as  values of your choice. If no deserializer is specified, only transient annotations will be returned.,ghcConstruct a new annotation environment that contains the list of annotations provided.,ghc"Union two annotation environments.,ghcA collection of annotations,ghcAn annotation target,ghc%We are annotating a particular module,ghcWe are annotating something with a name: a type or identifier,ghcRepresents an annotation after it has been sufficiently desugared from it's initial form of ,ghcThe target of the annotation,ghcThe kind of annotation target found in the middle end of the compilerghcFind payloads for the given , in an ,.,ghcThe "payload" of an annotation allows recovery of its value at a given type, and can be persisted to an interface file++++,,,,,,,,,,,,,,,,,,,,,,,,+,++,+ Safe-Inferred5 4mghcA fuzzy comparison function for class instances, intended for sorting instances before displaying them to the user.mghcTrue when when the instance heads are the same e.g. both are Eq [(a,b)] Used for overriding in GHCi Obviously should be insensitive to alpha-renamingmghcTest if an instance is visible, by checking that its origin module is in m2. See Note [Instance lookup and orphan instances]mghcSee Note [Rules for instance lookup] ^ See Note [Safe Haskell Overlapping Instances] in  GHC.Tc.Solver ^ See Note [Safe Haskell Overlapping Instances Implementation] in  GHC.Tc.SolvermghcLook up an instance in the given instance environment. The given class application must match exactly one instance and the match may not contain any flexi type variables. If the lookup is unsuccessful, yield 'Left errorMessage'.mghcChecks for an exact match of ClsInst in the instance environment. We use this when we do signature checking in  GHC.Tc.ModulemghcCollects the names of concrete types and type constructors that make up the head of a class instance. For instance, given `class Foo a b`:`instance Foo (Either (Maybe Int) a) Bool` would yield [Either, Maybe, Int, Bool].Used in the implementation of ":info" in GHCi.The l is because of instance Foo a => Baz T where ... The decl is an orphan if Baz and T are both not locally defined, even if Foo *is* locally definedmghcA type-class instance. Note that there is some tricky laziness at work here. See Note [ClsInst laziness and the rough-match fields] for more details.mghc Class namemghcis_dfun_name = idName . is_dfun.We use m for the visibility check, m, which needs to know the  which the dictionary is defined in. However, we cannot use the  attached to m since doing so would mean we would potentially pull in an entire interface file unnecessarily. This was the cause of #12367.mghcTop of type argsmghcm represents the combination of the global type class instance environment, the local type class instance environment, and the set of transitively reachable orphan modules (according to what modules have been directly imported) used to test orphan instance visibility.mghcSet of visible orphan modules, according to what modules have been directly imported. This is based off of the dep_orphs field, which records transitively reachable orphan modules (modules that define orphan instances).ghcAdd a new solution, knocking out strictly less specific ones See Note [Rules for instance lookup]mghcthe name of the classghc(the types which the class was applied toghcthe  of the dictionary bindingghcthe  of the dictionary.ghcmay this instance overlap?ghcis this instance an orphan?"KKmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm"mmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmKKmmm Safe-Inferred +ghcIf a module was "imported" by the user, we associate it with more detailed usage information +; a module imported by the system only gets used for usage information.+ghcRecords the modules directly imported by a module for extracting e.g. usage information, and also to give better error message+ghc(all the things the module could provide.4NB. BangPattern here: otherwise this leaks. (#15111)+ghc"whether this is an "hiding" import+ghcwhether this is a safe import+ghc$The name the module is imported with+ghc"whether this is a qualified import+ghc#the source span of the whole import +++++++++++++ +++++++++++++ Safe-Inferred V_a`  Safe-Inferred $% = ghc2Find all the C-compiler options in the given unitsghc*Find all the frameworks in the given unitsghcFind all the package framework paths in these and the preload packagesghc3Find all the include directories in the given unitsghcFind all the library directories in the given units for the given waysghcMap over the unit parameterghcMake a  from a  If the unit is definite, make a  from  field."If the unit is indefinite, make a  from  and 8 fields. Note that in this case we don't keep track of . It can be retrieved later with "improvement", i.e. matching on `unitInstanceOf/unitInstantiations` fields (see Note [About units] in GHC.Unit).ghc9Convert a DbUnitInfo (read from a package database) into ghc$Create a UnitPprInfo from a UnitInfoghc#Information about an installed unitWe parameterize on the unit identifier: * UnitKey: identifier used in the database (cf 5) * UnitId: identifier used to generate code (cf )These two identifiers are different for wired-in packages. See Note [About Units] in GHC.UnitghcInformation about an installed unit (units are identified by their internal UnitId)ghcInformation about an installed unit (units are identified by their database UnitKey)ghc Either the  or  as appropriate for the way.:a`_:a`_E Safe-Inferred eghc9Subset of UnitInfo: just enough to pretty-print a unit-idInstead of printing the unit-id which may contain a hash, we print: package-version:componentnameghcComponent nameghc IdentifierghcSource package nameghcSource package version Safe-Inferred *ghcCreates cached lookup for the  mi_fix_fn field of ModIface*ghcFixity information for an . We keep the OccName in the range so that we can generate an interface from it*ghc2Fixity environment mapping names to their fixities************** Safe-Inferred c œghc-Extract a suitable CtOrigin from guarded RHSsƜghc)Extract a suitable CtOrigin from a HsExprǜghc-Extract a suitable CtOrigin from a MatchGroupޜghc C [a] where ... When typechecking the instance decl itself, including producing evidence for the superclasses of C, the superclasses of (Foo a) and (Bar a) will have  origin.ghc is used for a Given constraint obtained by superclass selection from a constraint  other than the context of an instance declaration. (For the latter we use .) E.g. f :: Foo a => blah f = e When typechecking body of f3, the superclasses of the Given (Foo a) will have . Needed for Note [Replacement vs keeping] and Note [Use only the best local instance], both in GHC.Tc.Solver.Interact.ghc is used only for the Wanted constraints for the superclasses of an instance declaration. If the instance head is  C ty1 .. tyn then #TypeSize = sizeTypes [ty1, .., tyn] See Note [Solving superclass constraints] in GHC.Tc.TyCl.Instanceghc The thing that has type "actual"ghcIs at least one of the three elements above visible? (Errors from the polymorphic subsumption check are considered visible.) Only used for prioritizing error messages.ghcUserTypeCtxt describes the origin of the polymorphic type in the places where we need an expression to have that typeghcThe number of superclass selections needed to get this Given. If  d :: C ty has  ScDepth=2, then the evidence d will look like sc_sel (sc_sel dg), where dg is a Given.ghc7Extract a suitable CtOrigin from a list of guarded RHSsghcShort one-linersghcThe number of superclass selections necessary to get this constraint; see Note [Replacement vs keeping] and Note [Use only the best local instance], both in GHC.Tc.Solver.InteractghcIf (C ty1 .. tyn) is the largest class from which we made a superclass selection in the chain, then #TypeSize = sizeTypes [ty1, .., tyn] See Note [Solving superclass constraints] in GHC.Tc.TyCl.InstanceghcThe number of superclass selections necessary to get this constraintghcWhere the sub-class constraint arose from (used only for printing)œÜĜŜƜǜȜɜʜ˜̜͜ΜϜМќҜӜԜ՜֜ל؜ٜڜۜܜݜޜߜ˜Ĝɜʜ͜ΜϜМќҜӜԜ՜֜ל؜ٜڜۜܜݜޜߜƜǜœŜ̜ȜÜ Safe-Inferred.45 e ɚghcHaskell ModuleAll we actually declare here is the top-level structure for a module.̚ghc1Type, class, value, and interface signature decls͚ghc9reason/explanation for warning/deprecation of this module,s : -% ,,Κghc Export listNothing+: export list omitted, so export everythingJust [] : export nothing Just [...]: as you would expect...,s : -% ,,Ϛghc-Haddock module info and description, unparsed,s : -% ,,КghcWe snaffle interesting stuff out of the imported interfaces early on, adding that info to TyDecls/etc; so this list is often empty, downstream.њghcLayout info for the module. For incomplete modules (e.g. the output of parseHeader), it is NoLayoutInfo.ҚghcNothing: "module X where" is omitted (in which case the next field is Nothing too)֚ghcextra source files (e.g. from #includes). The lexer collects these from '#  file  line' pragmas, which the C preprocessor leaves behind. These files and their timestamps are stored in the .hi file, so that we can force recompilation if any of them change (#3589)!,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,-------------------------------------------------------------------,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,-,-,-----------------------------------------------------------........................................................//////////////////////LLLLLLLLLLLLLLUUUUUUUUUUUUUUUUUUUUVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXߌތ݌܌یٌ،ҌьЌόΌ͌ˌʌƌɌŌԌŒ׌Ì̌֌njȌՌČڌӌXXXXх҅ӅԅՅׅօ؅مڅۅ܅݅ޅ߅†ÆȆdžƆņĆɆ̆ʆˆԆՆֆ׆؆نچۆ܆݆ކ߆̇ˇʇɇȇLJƇ‡ÇŇć͇чЇ·χ҇ӇԇՇևׇۇڇ؇ه܇݇އ߇҈шЈψΈ͈̈ˈʈȈLjƈňĈȈɈӈՈԈֈ׈ۈ؈ڈو܈݈ވ߈͉̉ʉɉȉljƉʼnĉɉˉΉщωЉ҉ӉԉՉ։׉؉ۉىډ܉߉݉މΊ͊̊ˊʊɊȊNJƊŊĊÊŠϊЊъҊӊԊՊߊފ݊܊ۊڊي׊֊؊‹ËċŋƋˋʋɋNjȋًڋۋ܋݋ދߋԍӍҍэЍύ΍͍̍ˍʍɍȍǍƍōč͍Ս֍׍؍ٍڍލݍۍ܍ЎюҎӎԎՎ֎׎؎َڎێ܎ݎގߎÏďŏƏǏȏɏ͏̏ʏˏΏϏÐǐƐĐŐȐːɐʐ̐ϐ͐ΐАѐҐӐԐՐ֐אِؐڐېܐߐݐސƕǕȕɕʕ˕͕̕ΕϕЕѕҕӕԕՕ֕וٕؕڕەܕݕޕߕ–ÖĖŖƖǖȖɖʖ˖̖͖ΖϖЖіҖӖԖՖ֖זٖؖږۖܖŚƚǚȚɚʚ˚͚̚ΚϚКњҚӚԚ՚֚ɚʚ˚͚̚ΚϚКњҚŚƚǚȚӚԚ՚֚ Safe-Inferred . E !LLLLLLLLLLLLLLUUUUUUUUUUUUUUUUUUUUVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXߌތ݌܌یٌ،ҌьЌόΌ͌ˌʌƌɌŌԌŒ׌Ì̌֌njȌՌČڌӌXXXX†ÆȆdžƆņĆɆ̆ʆˆԆՆֆ׆؆نچۆ܆݆ކ߆̇ˇʇɇȇLJƇ‡ÇŇć͇чЇ·χ҇ӇԇՇևׇۇڇ؇ه܇݇އ߇҈шЈψΈ͈̈ˈʈȈLjƈňĈȈɈӈՈԈֈ׈ۈ؈ڈو܈݈ވ߈͉̉ʉɉȉljƉʼnĉɉˉΉщωЉ҉ӉԉՉ։׉؉ۉىډ܉߉݉މΊ͊̊ˊʊɊȊNJƊŊĊÊŠϊЊъҊӊԊՊߊފ݊܊ۊڊي׊֊؊‹ËċŋƋˋʋɋNjȋًڋۋ܋݋ދߋԍӍҍэЍύ΍͍̍ˍʍɍȍǍƍōč͍Ս֍׍؍ٍڍލݍۍ܍ Safe-Inferred.5 ghc%Is the pattern any of combination of:(pat) pat :: Type~pat!pat x (variable)ghc p pat checks if  p pat is true, and if so, surrounds pat with a . Otherwise, it simply returns pat.ghc p pat returns M if the pattern pat% needs parentheses under precedence p.ghc#Coercion Pattern (translation only):During desugaring a (CoPat co pat) turns into a cast with co+ on the scrutinee, followed by a match on pat.ghcCoercion Pattern If co :: t1 ~ t2, p :: t2, then (CoPat co p) :: t1ghc)Why not LPat? Ans: existing locn will doghcType of whole pattern, t1ghcThis is the extension field for ConPat, added after typechecking It adds quite a few extra fields, to support elaboration of pattern matching.ghcThe universal arg types 1-1 with the universal tyvars of the constructor/pattern synonym Use (conLikeResTy pat_con cpt_arg_tys) to get the type of the patternghc%Bindings involving those dictionariesghcDitto *coercion variables* and *dictionaries* One reason for putting coercion variable here I think is to ensure their kinds are zonkedghcExistentially bound type variables in correctly-scoped order e.g. [k:* x:k]ghc)Print with type info if -dppr-debug is onghc p cp returns M if the constructor patterns cp% needs parentheses under precedence p.ghc Are we in a -XStrict1 context? See Note [-XStrict and irrefutability]ԆՆՆԆ Safe-Inferred.5 ghc0Convert a literal from one index type to anotherghcpmPprHsLit pretty prints literals and is used when pretty printing pattern match warnings. All are printed the same (i.e., without hashes if they are primitive and not wrapped in constructors if they are boxed). This happens mainly for too reasons: * We do not want to expose their internal representation * The warnings become too messy$†ÆȆdžƆņĆɆ̆ʆˆ Safe-Inferred.5 ghcUsing SourceText in case the pragma was spelled differently or used mixed case҈шЈψΈ͈̈ˈʈȈLjƈňĈȈɈӈՈԈֈ׈ۈ؈ڈو܈݈ވ߈ЎюҎӎԎՎ֎׎؎َڎێ܎ݎގߎЎюҎӎԎՎ֎׎؎َڎێ܎ݎގߎ Safe-Inferred 45  Safe-Inferred05 !ghcGiven two possible located  qualified tokens, compute a style (in a conforming Haskell program only one of the two can be not K). This is called from  GHC.Parser.ghcConvenience function to answer the question if an import decl. is qualified.ghcImported or exported entity.ghcSome documentationghcReference to named docghcDoc section headingghc$Imported or exported module contents (Export Only),s : -ghc+Imported or exported Thing with Absent list+The thing is a Class/Type (can't tell) - ,s : -, -,-ghc8Imported or exported Thing with All imported or exportedThe thing is a Class"Type and the All refers to methods constructors,s : - , ,,,#, -ghc:Imported or exported Thing With given imported or exportedThe thing is a Class/Type and the imported or exported things are methods/constructors and record fields; see Note [IEThingWith] - ,s : -%, ,%, ,%, -ghcImported or Exported VariableghcImported or Exported WildcardghcA name in an import or export specification which may have adornments. Used primarily for accurate pretty printing of ParsedSource, and API Annotation placement. The : is the location of the adornment in the original source.ghcno extraghc pattern Xghc type (:+:)ghcImport DeclarationA single Haskell import declaration.ghc,s--, , for ideclSource-,-, -,,, --,-, ,) attached to location in ideclHidingghc as Moduleghc(True => hiding, names)ghc$True => implicit import (of Prelude)ghc Module name.ghcPackage qualifier.ghcIf/how the import is qualified.ghcTrue => safe importghcIsBoot  = {-# SOURCE #-} importghcIf/how an import is  qualified.ghcNot qualified.ghc qualified" appears in postpositive position.ghc qualified! appears in prepositive position.ghcLocated Import or Exportghc(Located name with possible adornment - ,s : - , -ghcLocated Import DeclarationghcWhen in a list this may have, : ,ghcWhen in a list this may have, : -99 Safe-Inferred.5 = ghc Eliminate a .ghcReturn L fields> if a data constructor declaration uses record syntax (i.e.,  ), where fields- are the field selectors. Otherwise, return K.ghcDoes this declaration have a complete, user-supplied kind signature? See Note [CUSKs: complete user-supplied kind signatures]ghcThe fixity signatures for each top-level declaration and class method in an 7. See Note [Top-level fixity signatures in an HsGroup]ghc Map over the via type if dealing with . Otherwise, return the  unchanged.ghcPartition a list of HsDecls into function/pattern bindings, signatures, type family declarations, type family instances, and documentation comments.Panics when given a declaration that cannot be put into any of the output groups.2The primary use of this function is to implement .ghc-Maybe return name of the result type variablȅghcThe locations of forall and  for forall'd term vars Using AddEpAnn to capture possible unicode variants͏ghcThe locations of forall and  for forall'd type vars Using AddEpAnn to capture possible unicode variantsˉ‰ÉĉʼnƉljȉɉʉ͉̉ΉωЉщ҉ӉԉՉ։׉؉ىډۉ܉݉މ߉ŠÊĊŊƊNJȊɊʊˊ̊͊ΊϊЊъҊӊԊՊ֊؊׊يڊۊ܊݊ފߊ‹ËċŋƋNjȋɋʋˋÏďŏƏǏȏɏʏˏ̏͏ΏϏ؉ىډۉďΉωЉщŏȏǏƏՊ֊؊׊يڊۊ܊݊ފߊ҉Ӊԉ‹ъ܉݉މ߉ΏϏϊЊɏʏˏ̏͏Չ։׉ˉ‰ÉĉʼnƉljȉɉʉ͉̉ËċŋƋNjȋɋʋˋÏҊӊԊŠÊĊŊƊNJȊɊʊˊ̊͊Ί Safe-Inferred -;ghcRetrieve the kind of a ghc Convert a  back into a ZghcIs a type a canonical LHS? That is, is it a tyvar or an exactly-saturated type family application? Does not look through type synonyms.Ýghc(Get the equality relation for the given ŝghc)Get the equality relation relevant for a Ǟɝghc-Extract the flavour, role, and boxity from a ǞΝghcGet the role relevant for a ǞѝghcGet the flavour of the given ҝghc Does this О subsumed ў ? True of [WD] and [D].ӝghc$Extract the flavour and role from a ghc8No problems in checking the validity of a type equality.ghcRetain only information about occurs-check failures, because only that matters after recurring into a kind.ghcCheck whether a  is marked successful.ghcCheck whether a  has one  and no otherghcCheck whether a  has a ghcMark a  as not having an insoluble occurs-check: any occurs check under a type family or in a representation equality is soluble.ghcAre two s equal?ghcA constraint is considered to be a custom type error, if it contains custom type errors anywhere in it. See Note [Custom type errors in constraints]ghc?Are we sure that more solving will never solve this constraint?ghcDoes this hole represent an "out of scope" error? See Note [Insoluble holes]ghcChecks whether a the given wanted constraints are solved, i.e. that there are no simple constraints left and all the implications are solved.ghcMakes a new equality predicate with the same role as the given evidence.ghcTrue if taking superclasses of givens, or of wanteds (to perhaps expose more equalities or functional dependencies) might help to solve this constraint. See Note [When superclasses help]ghc+Take a CtLoc and moves it to the kind levelghcReturns free variables of constraints as a non-deterministic setghcReturns free variables of constraints as a deterministically ordered. list. See Note [Deterministic FV] in  GHC.Utils.FV.ghcReturns free variables of a bag of constraints as a non-deterministic set. See Note [Deterministic FV] in  GHC.Utils.FV.ghcReturns free variables of a bag of constraints as a deterministically ordered list. See Note [Deterministic FV] in  GHC.Utils.FV.ghcReturns free variables of WantedConstraints as a non-deterministic set. See Note [Deterministic FV] in  GHC.Utils.FV.ghcReturns free variables of WantedConstraints as a deterministically ordered list. See Note [Deterministic FV] in  GHC.Utils.FV.ghcA  is a type that can appear on the left of a canonical equality: a type variable or exactly-saturated type family application.ghc0An individual problem that might be logged in a ghcA set of problems in checking the validity of a type equality. See  checkTypeEq.ԞghcWhether or not one  can rewrite another is determined by its flavour and its equality relation. See also Note [Flavours with roles] in GHC.Tc.Solver.Monad՞ghcUsed to indicate extra information about why a CIrredCan is irreducible֞ghcan equality like T a b c ~ Q d e where either T or Q is an abstract type constructor. See Note [Skolem abstract data] in GHC.Core.TyCon. INVARIANT: The constraint is an equality constraint between two TyConAppsמghcthis constraint is blocked on the coercion hole(s) listed See Note [Equalities with incompatible kinds] in GHC.Tc.Solver.Canonical Wrinkle (4a). Why store the HoleSet? See Wrinkle (2) of that same Note. INVARIANT: A HoleBlockerReason constraint is a homogeneous equality whose left hand side can fit in a CanEqLHS.؞ghc0this constraint has a non-canonical shape (e.g. c Int, for a variable c)ٞghc8an equality where some invariant other than (TyEq:H) of  is not satisfied; the $ states exactly why INVARIANT: the + has some bit set other than cteHoleBlockerڞghcan equality that cannot be decomposed because it is representational. Example:  a b ~R# Int. These might still be solved later. INVARIANT: The constraint is a representational equality constraint۞ghca nominal equality that relates two wholly different types, like  Int ~# Bool or a b ~# 3=. INVARIANT: The constraint is a nominal equality constraintghcA hole stores the information needed to report diagnostics about holes in terms (unbound identifiers or underscores) or in types (also called wildcards, as used in partial type signatures). See Note [Holes].ghcWhere hole was writtenghcThe name of this holeghcWhat flavour of hole is this?ghcType to be printed to the user For expression holes: type of expr For type holes: the missing typeghc,Used to indicate which sort of hole we have.ghcA hole in a constraint, like @f :: (_, Eq a) => ... Differentiated from TypeHole because a ConstraintHole is simplified differently. See Note [Do not simplify ConstraintHoles] in GHC.Tc.Solver.ghcEither an out-of-scope variable or a "true" hole in an expression (TypedHoles). The HoleExprRef says where to write the the erroring expression for -fdefer-type-errors.ghc(A hole in a type (PartialTypeSignatures)ghcSee Note [SubGoalDepth]ghcA place for type-checking evidence to go after it is generated. Wanted equalities are always HoleDest; other wanteds are always EvVarDest.ghcbind this var to the evidence EvVarDest is always used for non-type-equalities e.g. class constraintsghcfill in this hole with the evidence HoleDest is always used for type-equalities See Note [Coercion holes] in GHC.Core.TyCo.RepghcA -type is one that has been fully rewritten with respect to the inert set; that is, it has been rewritten by the algorithm in GHC.Tc.Solver.Rewrite. (Historical note: , for years and years, meant that a type was type-family-free. It does *not* mean this any more.)ghcReturns free variables of WantedConstraints as a composable FV computation. See Note [Deterministic FV] in  GHC.Utils.FV.ghcReturns free variables of constraints as a composable FV computation. See Note [Deterministic FV] in  GHC.Utils.FV.ghcReturns free variables of a bag of constraints as a composable FV computation. See Note [Deterministic FV] in  GHC.Utils.FV.ghcReturns free variables of Implication as a composable FV computation. See Note [Deterministic FV] in  GHC.Utils.FV.ghc of the familyghcexactly saturating the familyJÝĝŝƝǝȝɝʝ˝̝͝ΝϝНѝҝӝԝ՝֝ם؝ٝڝ۝ܝݝޝߝžÞĞŞƞǞȞɞʞ˞̞͞ΞϞОўҞӞԞ՞֞מ؞ٞڞ۞ܞݞޞߞžÞĞŞƞНԝܝѝÝ۝ʝ͝˝̝ŝǝϝĝƝ՞֞מ؞ٞڞ۞Jޝݝߝܞݞޞߞٝ֝ם؝ڝ՝ǞȞɞʞ˞̞͞ΞϞΝОўҞӞҝȝԞɝӝ( Safe-Inferred 9ghc7A HoleFitPlugin is a pair of candidate and fit plugins.ghcA plugin for modifying the candidate hole fits *before* they're checked.ghc=A plugin for modifying hole fits *after* they've been found.ghcHoleFit is the type we use for valid hole fits. It contains the element that was checked, the Id of that element as found by tcLookup, and the refinement level of the fit, which is the number of extra argument holes that this fit uses (e.g. if hfRefLvl is 2, the fit is for `Id _ _`).ghcA fit that is just displayed as is. Here so thatHoleFitPlugins can inject any fit they want.ghcThe candidate that was checked.ghc,Documentation of this HoleFit, if available.ghcThe elements id in the TcMghc;What the refinement variables got matched with, if anythingghc The number of holes in this fit.ghc$The type of the id, possibly zonked.ghcThe wrapper for the match.ghcHoleFitCandidates are passed to hole fit plugins and then checked whether they fit a given typed-hole.ghcHoleFitPluginR adds a TcRef to hole fit plugins so that plugins can track internal state. Note the existential quantification, ensuring that the state cannot be modified from outside the plugin.ghc0Initializes the TcRef to be passed to the pluginghc'The function defining the plugin itselfghc7Cleanup of state, guaranteed to be called even on errorghc2The hole itself, if available. Only for debugging.ghcThe nested implications of the hole with the innermost implication first.ghcAny relevant Cts to the hole   Safe-Inferred  ;ghcHooks can be used by GHC API clients to replace parts of the compiler pipeline. If a hook is not installed, GHC uses the default built-in behaviourghcActual type: Maybe ([LForeignDecl GhcTc] -> DsM (ForeignStubs, OrdList (Id, CoreExpr))) Safe-Inferred C4ݚghc Did this  originate from a hs-boot file?ghc2All of the (possibly) home module imports from a ; that is to say, each of these module names could be a home import if an appropriately named file existed. (This is in contrast to package qualified imports, which are guaranteed not to be home imports.)ghcLike , but for SOURCE imports.ghcEnrichment of  with backpack dependenciesghcExtra backpack deps NB: This is sometimes left empty in situations where the instantiated units would not be used. See call sites of ۚ.ghcData for a module node in a  ModuleGraph/. Module nodes of the module graph are one of:A regular Haskell source moduleA hi-boot source moduleghc%Timestamp of hie file, if we have oneghcTimestamp of source fileghc8The module source either plain Haskell, hs-boot, or hsigghc-The actual preprocessed source, if we have itghc$Filename of preprocessed source fileghcCached flags from OPTIONS, INCLUDE and LANGUAGE$ pragmas in the modules source codeghc summarises everything we know about a compiled module. The  is the stuff *before* linking, and can be written out to an interface file. The 'ModDetails is after linking and can be completely recovered from just the .4When we read an interface file, we also construct a . from it, except that we explicitly make the  and a few other fields empty; as when reading we consolidate the declarations etc. into a number of indexed maps and environments in the ExternalPackageState.ghcAnnotations NOT STRICT! we read this field lazily from the interface fileghcDocs on arguments.ghcDocs on declarations.ghcType, class and variable declarations The hash of an Id changes if its fixity or deprecations change (as well as its type of course) Ditto data constructors, class operations, except that the hash of the parent class/tycon changesghcThe dependencies of the module. This is consulted for directly-imported modules, but not for anything else (hence lazy)ghcModule header.ghcExports Kept sorted by (mod,occ), to make version comparisons easier Records the modules that are the declaration points for things exported by this module, and the  s of those thingsghcAdditional optional fields, where the Map key represents the field name, resulting in a (size, serialized data) pair. Because the data is intended to be serialized through the internal 3 class (increasing compatibility with types using  and  FastString,, such as HIE), this format is chosen over  ByteStrings.ghcSorted family instancesghcEither () or % for a fully instantiated interface.ghcFixities NOT STRICT! we read this field lazily from the interface fileghc6Binds all the things defined at the top level in the original source code for this module. which is NOT the same as mi_exports, nor mi_decls (which may contains declarations for things not actually defined by the user). Used for GHCi and for inspecting the contents of modules via the GHC API only.(We need the source file to figure out the top-level environment, if we didn't compile this module from source then this field contains Nothing).1Strictly speaking this field should live in the  HomeModInfo", but that leads to more plumbing.ghc:True if this program uses Hpc at any point in the program.ghcBoot? Signature?ghcSorted class instanceghcName of the module we are for›ghc Sorted rulesÛghcAre we a sig of another mod?ěghc/Safe Haskell Trust information for this module.śghcDo we require the package this module resides in be trusted to trust this module? This is used for the situation where a module is Safe (so doesn't require the package be trusted itself) but imports some trustworthy modules from its own package (which does require its own package be trusted). See Note [Trust Own Package] in GHC.Rename.NamesƛghcUsages; kept sorted so that it's easy to decide whether to write a new iface file (changing usages doesn't affect the hash of this module) NOT STRICT! we read this field lazily from the interface file It is *only* consulted by the recompilation checkerǛghcModule required TH splices when it was compiled. This disables recompilation avoidance (see #481).țghcWarnings NOT STRICT! we read this field lazily from the interface fileʛghc)Does this module define family instances?˛ghc? ghcForeign export stubsghc!There are some stubs. Parameters:?1) Header file prototypes for "foreign exported" functions2) C stubs to use when calling "foreign exported" functionsghcWe don't have any stubs   Safe-Inferred р Nghc8An ArgDescr describes the argument pattern of a functionNghcCodegen-generated Id infos, to be passed to downstream via interfaces.This stuff is for optimization purposes only, they're not compulsory.When CafInfo of an imported Id is not known it's safe to treat it as CAFFY.When LambdaFormInfo of an imported Id is not known it's safe to treat it as `LFUnknown True` (which just says "it could be anything" and we do slow entry).See also Note [Conveying CAF-info and LFInfo between modules] above.Nghc,The C stub which is used for IPE informationNghc;LambdaFormInfos of exported closures in the current module.NghcExported Non-CAFFY closures in the current module. Everything else is either not exported of CAFFY.NghcInformation about an identifier, from the code generator's point of view. Every identifier is bound to a LambdaFormInfo in the environment, which gives the code generator enough info to be able to tail call or return that identifier.NghcWe represent liveness bitmaps as a Bitmap (whose internal representation really is a bitmap). These are pinned onto case return vectors to indicate the state of the stack for the garbage collector.In the compiled program, liveness bitmaps that fit inside a single word (StgWord) are stored as a single word, while larger bitmaps are stored as a pointer to an array of words.Nghc9Maps names in the current module to their LambdaFormInfosNghcStandardFormInfo tells whether this thunk has one of a small number of standard formsNghcWord offset, or word countNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN Safe-Inferred.05 fghc4Initialize STG pretty-printing options from DynFlagsfghcDoes this constructor application refer to anything in a different *Windows* DLL? If so, we can't allocate it staticallyfghcUsed when constructing a term with an unused extension point that should not appear in pretty-printed output at all.fghc3STG pretty-printing options used for panic messagesfghc3STG pretty-printing options used for short messagesfghc Type of an StgArg8Very half baked because we have lost the type arguments.fghcGiven an alt type and whether the program is unarised, return whether the case binder is in scope.Case binders of unboxed tuple or unboxed sum type always dead after the unariser has run. See Note [Post-unarisation invariants].fghc3Strip ticks of a given type from an STG expression.fghcStrip ticks of a given type from an STG expression returning only the expression.fghcWhen `-fdistinct-constructor-tables` is turned on then each usage of a constructor is given an unique number and an info table is generated for each different constructor.fghcA top-level binding.gghcLike , but with an  instance that returns  .gghc,Used as a data type index for the stgSyn ASTgghcSTG pretty-printing optionsgghcEnable cost-centresghc,Code gen needs to track non-global free varsfghc unarised? fghc do ...The tmpDir: will be a new subdirectory of the given directory, e.g.  src/sdist.342.UghcDependent packages, used to generate #includes for C code genghcForeign export stubsghc%Program coverage tick box informationghcModule breakpointsghcModule being compiledghcStatic pointer table entries for static forms defined in the module. See Note [Grand plan for static forms] in GHC.Iface.Tidy.StaticPtrTableghcAlgebraic data types (including ones that started life as classes); generate constructors and info tables. Includes newtypes, just for the benefit of External CoreghcA ModGuts is carried through the compiler, accumulating stuff as it goes There is only one ModGuts at any time, the one for the module being compiled right now. Once it is compiled, a ModIface and  ModDetails, are extracted and the ModGuts is discarded.ghc#Annotations declared in this moduleghcDocs on arguments.ghcBindings for this moduleghcComplete MatchesghcDocs on declarations.ghc*What it depends on, directly or otherwiseghcModule header.ghcWhat it exportsghc&Type-family instance environment for  home-package% modules (including this one); c.f. tcg_fam_inst_envghc(Family instances declared in this moduleghcFixities declared in this module. Used for creating interface files.ghc'Foreign exports declared in this moduleghc(Files to be compiled with the C compilerghc!Coverage tick boxes in the moduleghcWhether it's an hs-boot moduleghc Class instance environment for  home-package% modules (including this one); c.f.  tcg_inst_envghc'Class instances declared in this moduleghc$For error messages from inner passesghcBreakpoints for the moduleghcModule being compiledghc(Pattern synonyms declared in this moduleghcTop-level lexical environmentghcBefore the core pipeline starts, contains See Note [Overall plumbing for rules] in GHC.Core.RulesghcSafe Haskell modeghc=TyCons declared in this module (includes TyCons for classes)ghcDo we need to trust our own package for Safe Haskell? See Note [Trust Own Package] in GHC.Rename.Namesghc$What was used? Used for interfaces.ghcDid we run a TH splice?ghcWarnings declared in the module** Safe-Inferred HghcH is the compiler plugin data type. Try to avoid constructing one of these directly, and just modify some fields of  instead: this is to try and preserve source-code compatibility when we add fields to this.Nonetheless, this API is preliminary and highly likely to change in the future.ghc>A plugin with its arguments. The result of loading the plugin.ghcA static plugin with its arguments. For registering compiled-in plugins through the GHC API.ghcDefault plugin: does nothing at all, except for marking that safe inference has failed unless -fplugin-trustworthy is passed. For compatibility reason you should base all your plugin definitions on this default value.ghcA renamer plugin which mades the renamed source available in a typechecker plugin.įghc9Perform an operation by using all of the plugins in turn.ůghcPerform a constant operation by using all of the plugins in turn.ƯghcCommand line options gathered from the -PModule.Name:stuff syntax are given to you as this type̯ghc the module containing the pluginͯghc9the actual plugin together with its commandline argumentsϯ ghcAn optional plugin to update , right after plugin loading. This can be used to register hooks or tweak any field of DynFlags' before doing actual work on a module.ЯghcAn optional plugin to handle hole fits, which may re-order or change the list of valid hole fits and refinement hole fits.ѯghcModify the Core pipeline that will be used for compilation. This is called as the Core pipeline is built for every module being compiled, and plugins get the opportunity to modify the pipeline in a nondeterministic order.үghc>Modify an interface that have been loaded. This is called by GHC.Iface.Load when an interface is successfully loaded. Not applied to the loading of the plugin interface. Tools that rely on information from modules other than the currently compiled one should implement this function.ӯghc8Modify the module when it is parsed. This is called by GHC.Driver.Main when the parsing is successful.ԯghc3Specify how the plugin should affect recompilation.կghcModify each group after it is renamed. This is called after each  has been renamed.֯ghc4Modify the TH splice or quasiqoute before it is run.ׯghcAn optional typechecker plugin, which may modify the behaviour of the constraint solver.دghcModify the module when it is type checked. This is called at the very end of typechecking.߯ghc%command line arguments for the pluginghcthe actual callable pluginghc9the actual plugin together with its commandline arguments/HίѯϯЯүӯԯկ֯ׯدIȯɯ˯̯ͯ¯ïįůƯǯʯٯگۯܯݯޯ߯/HίѯϯЯүӯԯկ֯ׯدƯïٯگۯܯIȯɯʯǯݯޯ߯¯˯̯ͯįů Safe-Inferred 7>? ghc#Grabs the DynFlags from the Sessionghc(A monad that allows logging of warnings.ghcModify the loggerghcSet the current session to the result of applying the current session to the argument.ghcSet the current session to the result of applying the current session to the argument.ghcPop a log hook from the stackghcPrint the error message and all warnings. Useful inside exception handlers. Clears warnings after printing.ghcPush a log hook on the stackghcPut a log messageghcPut a log messageghcReflect a computation in the  monad into the E monad.>You can use this to call functions returning an action in the  monad inside an E action. This is needed for some (too restrictive) callback arguments of some library functions: libFunc :: String -> (Int -> IO a) -> IO a ghcFunc :: Int -> Ghc a ghcFuncUsingLibFunc :: String -> Ghc a -> Ghc a ghcFuncUsingLibFunc str = reifyGhc $ \s -> libFunc $ \i -> do reflectGhc (ghcFunc i) sghc+Call the argument with the current session.ghc3Call an action with a temporarily modified Session.ghcTime an actionghcA minimal implementation of a . If you need a custom monad, e.g., to maintain additional state consider wrapping this monad or using .ghc:A monad that has all the features needed by GHC API calls.In short, a GHC monadallows embedding of IO actions,can log warnings,/allows handling of (extensible) exceptions, andmaintains a current session.If you do not use  or , make sure to call 5 before any call to the GHC API functions can occur.ghcA monad transformer to add GHC specific features to another monad.Note that the wrapped monad must support IO and handling of exceptions.ghcThe Session is a handle to the complete state of a compilation session. A compilation session consists of a set of modules constituting the current program or library, the context for interactive evaluation, and various caches.ghc-A function called to log warnings and errors.YY Safe-Inferred OghcPerform the given action and call the exception handler if the action throws a O. See O for more information.OghcA source error is an error that is caused by one or more errors in the source code. A O is thrown by many functions in the compilation pipeline. Inside GHC these errors are merely printed via  log_action, but API clients may treat them differently, for example, insert them into a list box. If you want the default behaviour, use the idiom: handleSourceError printExceptionAndWarnings $ do ... api calls that may fail ...The O%s error messages can be accessed via O8. This list may be empty if the compiler failed due to -Werror (Opt_WarnIsError).See printExceptionAndWarnings for more information on what to take care of when writing a custom error handler.Oghcexception handlerghcaction to performOOOOOOOOOOOOOO Safe-Inferred -UghcChecks if given O is a fatal warning.UghcGiven a bag of warnings, turn them into an exception if -Werror is enabled, or print them out otherwise.UghcConverts a list of O into a tuple where the second element contains only error, i.e. warnings that are considered fatal by GHC based on the input  .UUUUUUUUUU Safe-Inferred  ghcGet annotations from modules "below" this one (in the dependency sense)ghcFind all the instance declarations (of classes and families) from the Home Package Table filtered by the provided predicate function. Used in  tcRnImports, to select the instances that are in the transitive closure of imports from the currently compiled module.ghcGet rules from modules "below" this one (in the dependency sense)ghcGet things from modules "below" this one (in the dependency sense) C.f Inst.hptInstancesghc(Retrieve the ExternalPackageState cache.ghc Find the  for a , searching in both the loaded home and external package module informationghc Find the ! for the given  by using all the resources at our disposal: the compiled modules in the : and the compiled modules in other packages that live in '. Note that this does NOT look up the ! in the module being compiled: you have to do that yourself, if desiredghcSwitches in the DynFlags and Plugins from the InteractiveContextghcDeal with gathering annotations in from all possible places and combining them into a single ,ghcA variant of runHsc that switches in the DynFlags and Plugins from the InteractiveContext before running the Hsc computation.%% Safe-Inferred %ghc&Add stats for one newly-read interfaceghc%Constructs an empty PackageIfaceTableghc:Accumulated statistics about what we are putting into the !. "In" means stuff that is just read from interface files, "Out" means actually sucked in and type-checkedghcInformation about other packages that we have slurped in by reading their interface filesghcThe s for modules in external packages whose interfaces we have opened. The declarations in these interface files are held in the  eps_decls, ,  and  eps_rules$ fields of this record, not in the , fields of the interface we have sucked in.What is in the PIT is: The ModuleFingerprint info Its exportsFixitiesDeprecations and warningsghcResult of typechecking all the external package interface files we have sucked in. The domain of the mapping is external-package modulesghc The total ,3 accumulated from all the external-package modulesghc The total O3 accumulated from all the external-package modulesghc The total L3 accumulated from all the external-package modulesghc Cache for #. Ordinarily, we can rely on the  for this information, EXCEPT that when we do dependency analysis, we need to look at the  Dependencies of our imports to determine what their precise free holes are (moduleFreeHolesPrecise). We don't want to repeatedly reread in the interface for every import, so cache it here. When the PIT gets filled in we can drop these entries.ghc The total m3 accumulated from all the external-package modulesghcIn OneShot mode (only), home-package modules accumulate in the external package state, and are sucked in lazily. For these home-pkg modules (only) we need to record which are boot modules. We set this field after loading all the explicitly-imported interfaces, but before doing anything elseThe  part is not necessary, but it's useful for debug prints, and it's convenient because this field comes direct from ghcThe family instances accumulated from external packages, keyed off the module that declared themghc The total RuleEnv3 accumulated from all the external-package modulesghc5Stastics about what was loaded from external packagesghcHelps us find information about modules in the imported packages Safe-Inferred (<TghcLookup  for every preload unit from the UnitState and for every unit used to instantiate the home unit.TghcLookup  for every preload unit from the UnitState, for every unit used to instantiate the home unit, and for every unit explicitly passed in the given list of UnitId.Tghc Home unitTghc2GHC name/version (used for dynamic library suffix)TghcPlatformTghcUnitsTTTTTTTTTTTTTTTT Safe-Inferred 4ghc'Constructs an empty InteractiveContext.ghcextendInteractiveContext is called with new TyThings recently defined to update the InteractiveContext to include them. Ids are easily removed when shadowed, but Classes and TyCons are not. Some work could be done to determine whether they are entirely shadowed, but as you could still have references to them (e.g. instances for classes or values of the type for TyCons), it's not clear whether removing them is even the appropriate behavior.ghcAdd TyThings to the GlobalRdrEnv, earlier ones in the list shadowing later ones, and shadowing existing entries in the GlobalRdrEnv.ghcThis function returns the list of visible TyThings (useful for e.g. showBindings)ghcGet the PrintUnqualified function based on the flags and this InteractiveContextghcInteractive context, recording information about the state of the context in which statements are executed in a GHCi session.ghcvirtual CWD of the programghc$The current default types, set by a  'default' declarationghcThe  : used to evaluate interactive expressions and statements.ghc#Fixities declared in let statementsghcThe GHCi top-level scope (ic_rn_gbl_env) is extended with these importsThis field is only stored here so that the client can retrieve it with GHC.getContext. GHC itself doesn't use it, but does reset it to empty sometimes (such as before a GHC.load). The context is set with GHC.setContext.ghcAll instances and family instances created during this session. These are grabbed en masse after each update to be sure that proper overlapping is retained. That is, rather than re-check the overlapping each time we update the context, we just take the results from the instance code that already does that.ghcThe function that is used for printing results of expressions in ghci and -e mode.ghcEach GHCi stmt or declaration brings some new things into scope. We give them names like interactive:Ghci9.T, where the ic_index is the '9'. The ic_mod_index is incremented whenever we add something to ic_tythings See Note [The interactive package]ghc#The monad that GHCi is executing inghcCache of loaded plugins. We store them here to avoid having to load them everytime we switch to the interctive context.ghc The stack of breakpoint contextsghc The cached + , built by  and updated regularly It contains everything in scope at the command line, including everything in ic_tythingsghcTyThings defined by the user, in reverse order of definition (ie most recent at the front) See Note [ic_tythings]ghcBring the exports of a particular module (filtered by an import decl) into scopeghcBring into scope the entire top-level envt of of this module, including the things imported into it. Safe-Inferred 7^ghcCreates some functions that work out the best ways to format names for the user according to a set of heuristics.^ghcCreates a function for formatting modules based on two heuristics: (1) if the module is the current module, don't qualify, and (2) if there is only one exposed package which exports this module, don't qualify.^ghcCreates a function for formatting packages based on two heuristics: (1) don't qualify if the package in question is "main", and (2) only qualify with a unit id if the package ID would be ambiguous.^ghcA function which only qualifies package names if necessary; but qualifies all other identifiers.^^^^^^^^ Safe-Inferred 8\ghcline number (for errors)\ghc stepping mode\ghcfilename (for errors)(\\\\\\\\\\\\\\\\\\\\\\\]]]]]]]]]]]]]]]]](]]]]]]]]]]]]]\\\\\\\\\\\\]]]]\\\\\\\\\\\ Safe-Inferred7 FDghc7The Hsc monad: Passing an environment and warning stateghcHscEnv is like , except that some of the fields are immutable. An HscEnv is used to compile a single module from plain Haskell source code (after preprocessing) to either C, assembly or C--. It's also used to store the dynamic linker state to allow for multiple linkers in the same address space. Things like the module graph don't change during a single compilation.Historical note: "hsc" used to be the name of the compiler binary, when there was a separate driver and compiler. To compile a single module, the driver would invoke hsc on the source code... so nowadays we think of hsc as the layer of the compiler that deals with compiling a single module.ghcInformation about the currently loaded external packages. This is mutable because packages will be demand-loaded during a compilation run as required.ghc:The cached result of performing finding in the file systemghcThe home package table describes already-compiled home-package modules,  excluding the module we are compiling right now. (In one-shot mode the current module is the only home-package module, so hsc_HPT is empty. All other modules count as "external-package" modules. However, even in GHCi mode, hi-boot interfaces are demand-loaded into the external-package table.) is not mutable because we only demand-load external packages; the home package is eagerly loaded, module by module, by the compilation manager.0The HPT may contain modules compiled earlier by --make but not actually below the current module in the dependency graph.4(This changes a previous invariant: changed Jan 05.)ghc1The context for evaluating interactive statementsghcAs with , this is side-effected by compiling to reflect sucking in interface files. They cache the state of external interface files, in effect.ghcThe dynamic flag settingsghcHooksghctarget code interpreter (if any) to use for TH and GHCi. See Note [Target code interpreter]ghcLoggerghc'The module graph of the current sessionghcplugins dynamically loaded after processing arguments. What will be loaded here is directed by DynFlags.pluginModNames. Arguments are loaded from DynFlags.pluginModNameOpts.The purpose of this field is to cache the plugins so they don't have to be loaded each time they are needed. See .ghcstatic plugins which do not need dynamic loading. These plugins are intended to be added by GHC API users directly to this list.;To add dynamically loaded plugins through the GHC API see addPluginModuleName instead.ghc-The targets (or roots) of the current sessionghcTemporary filesghc7Used for one-shot compilation only, to initialise the IfGblEnv. See  for (. See also Note [hsc_type_env_var hack]ghc0Stack of unit databases for the target platform.+This field is populated with the result of S.K4 means the databases have never been read from disk.Usually we don't reload the databases from disk if they are cached, even if the database flags changed!ghc/Unit environment (unit state, home unit, etc.).)Initialized from the databases cached in  and from the DynFlags. Safe-Inferred$% N ghcAdd an ExtendedModSummary to ModuleGraph. Assumes that the new ModSummary is not an element of the ModuleGraph.ghcThis function filters out all the instantiation nodes from each SCC of a topological sort. Use this with care, as the resulting "strongly connected components" may not really be strongly connected in a direct way, as instantiations have been removed. It would probably be best to eliminate uses of this function where possible.ghcMap a function f over all the  ModSummaries. To preserve invariants f can't change the isBoot status.ghc'Look up a ModSummary in the ModuleGraphghcDetermines whether a set of modules requires Template Haskell or Quasi QuotesNote that if the session's   enabled Template Haskell when depanal was called, then each module in the returned module graph will have Template Haskell enabled whether it is actually needed or not.ghcA ' ModuleGraph=' contains all the nodes from the home package (only). See 'ModuleGraphNode"' for information about the nodes.Modules need to be compiled. hs-boots need to be typechecked before the associated "real" module so modules with {-# SOURCE #-} imports can be built. Instantiations also need to be typechecked to ensure that the module fits the signature. Substantiation typechecking is roughly comparable to the check that the module and its hs-boot agree.The graph is not necessarily stored in topologically-sorted order. Use  and   to achieve this.ghcA 'ModuleGraphNode' is a node in the ' ModuleGraph'. Edges between nodes mark dependencies arising from module imports and dependencies arising from backpack instantiations.ghcInstantiation nodes track the instantiation of other units (backpack dependencies) with the holes (signatures) of the current package.ghcThere is a module summary node for each module, signature, and boot module being built. Safe-Inferred S- Tghc/The result of searching for an imported module.NB: FindResult manages both user source-import lookups (which can result in ) as well as direct imports for interfaces (which always result in ).TghcThe module was foundTghc"_Error_: both in multiple packagesTghc The requested unit was not foundTghc Not foundTghc7Module is in these units, but the *module* is hiddenTghcPlaces where I lookedTghcJust p => module is in this unit's manifest, but couldn't find the .hi fileTghc5Module is in these units, but the *unit* is hiddenTghcPossible mis-spelled modulesTghc,Module is in these units, but it is unusableTghcThe T maps modules to the result of searching for that module. It records the results of searching for modules along the search path. On :load., we flush the entire contents of this cache.TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT Safe-Inferred U8^ghc6Return a function to atomically update the name cache.^ghcThe NameCache makes sure that there is just one Unique assigned for each original name; i.e. (module-name, occ-name) pair and provides something of a lookup mechanism for those names.^ghc.Ensures that one original name gets one unique^ghcSupply of uniques^ghcPer-module cache of original  s given s ^^^^^^^^^ ^^^^^^^^^ Safe-Inferred Y+kghcExternal interpreterThe external interpreter is spawned lazily (on first use) to avoid slowing down sessions that don't require it. The contents of the MVar reflects the state of the interpreter (running or not).kghc5Configuration needed to spawn an external interpreterkghcUse Dynamic waykghcHookkghcCommand-line optionskghcUse Profiling waykghcExternal program to runkghc!Trace action executed after spawnkghcExternal interpreter instancekghcValues that need to be freed before the next command is sent. Threads can append values to this list asynchronously (by modifying the IServ state MVar).kghc State of an external interpreterkghcNot spawned yetkghcRunningkghc Interpreterkghc)Interpreter instance (internal, external)kghcInterpreter loaderkghcExternal interpreterkghcInternal interpreterkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk Safe-Inferred7 c7ghc2Outputs a debugging message at verbosity level of -v or higherghc8Output a string debugging message at verbosity level of -v or higherghcShow some labelled 8 if a particular flag is set or at a verbosity level of -v -ddump-most or higherghcOutput an error to the screen. Does not cause the compiler to die.ghcOutput an error to the screen. Does not cause the compiler to die.ghcOutput a fatal error to the screen. Does not cause the compiler to die.ghcOutput a fatal error to the screen. Does not cause the compiler to die.ghcGet all annotations of a given type. This happens lazily, that is no deserialization will take place until the [a] is actually demanded and the [a] can also be empty (the UniqFM is not filtered).This should be done once at the start of a Core-to-Core pass that uses annotations.See Note [Annotations]ghcGet at most one annotation of a given type per annotatable item.ghcLift an E operation into ʤ while consuming its ¤ghcOutput a message to the screenäghc%Output a String message to the screenʤghcThe monad used by Core-to-Core passes to register simplification statistics. Also used to have common state (in the form of UniqueSupply) for generating Uniques.ˤghc'A description of the plugin pass itselfghcTrue  = float constants to top level, even if they do not escape a lambdaghcJust n  = float lambdas to top level, if doing so will abstract over n or fewer value variables Nothing  = float all lambdas to top level, regardless of how many free variables Just 0 is the vanilla case: float a lambda iff it has no free varsghcTrue  = float out over-saturated applications based on arity information. See Note [Floating over-saturated applications] in GHC.Core.Opt.SetLevelsghc%Allow floating to the top level only.ghcWhether case-of-case is enabledghc!Do we swizzle casts past lambdas?ghc Whether eta-expansion is enabledghcWhether inlining is enabledghcName(s) of the phaseghcWhether pre-inlining is enabledghcWhether RULES are enabledghcUnfolding optionsghcLift an U operation into ʤĤghcMaskYR¤äĤŤƤǤȤɤʤˤ̤ͤΤϤФѤҤӤԤդ֤פؤ٤ڤۤܤݤޤߤ̤ͤΤϤФѤҤӤԤդ֤פؤ٤ڤۤܤݤޤߤƤŤˤǤɤʤĤRY¤äȤ  Safe-Inferred>? g-UghcAtomically update the reference. Does not force the evaluation of the new variable contents. For strict update, use U.UghcStrict variant of U.Ughc2Perform a computation with a different environmentUghc1Perform a computation with an altered environmentghcLike u+, but doesn't catch asynchronous exceptions<46$"#ZY^xUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUxUUUUUUU Safe-Inferred()07 k qghcThe branch block id is that of the first block in the branch, which is that branch's entry pointqghc?Should a data in this section be considered constant at runtimeqghcCmm group before SRT generationqghcCmm group with SRTsqghc!Info table as a haskell data typerghcan embedded binary filerghc8a literal value, size given by cmmLitRep of the literal.rghc1string of 8-bit values only, not zero terminated.rghc uninitialised data, N bytes longrghcCmmTopInfo is attached to each CmmDecl (see defn of CmmGroup), and contains the extra info (beyond the executable code) that belongs to that CmmDecl.rghcA top-level chunk, abstracted over the type of the contents of the basic blocks (Cmm or instructions are the likely instantiations).rghc%Static data, after SRTs are generatedrghcRaw1 cmm group (TODO (osa): not sure what that means)##################################################################################$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$%%%%%%%%%%%%%%%%%$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%TTTTTTTTXhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrqqrrqqrrrqrrrrqrrrrrrrrrrrrrrrrrrrrrrrrrrqrrqrrqrrrrrrrrqqrrrrrqTTTTTTTrrrT Safe-Inferred vTghcFirst round the given byte count up to a multiple of the machine's word size and then convert the result to words.TghcThe byte offset into the card table of the card for a given elementTghc>Convert a number of elements to a number of cards, rounding upTghc"The size of a card table, in bytesTghc"The size of a card table, in wordsTghcSize of a closure header (StgHeader in includes/rts/storage/Closures.h)TghcHalf word size in bytesTghc(The total size of the closure, in words.TghcSize of the profiling part of a closure header (StgProfHeader in includes/rts/storage/Closures.h)Tghc Round up base to a multiple of size.TghcRound up the given byte count to the next byte count that's a multiple of the machine's word size.Tghc%Derives the RTS closure type from an TTghc7Convert the given number of words to a number of bytes.This function morally has type WordOff -> ByteOff , but uses Num a to allow for overloading.TghcByte offset, or byte countTghcTrue <=> This is a static closure. Affects how we garbage-collect it. Static closure have an extra static link field at the end. Constructors do not have a static variant; see Note [static constructors]TghcA description of the layout of a closure. Corresponds directly to the closure types in includes/rts/storage/ClosureTypes.h.ghcThe garbage collector requires that every closure is at least as big as this.NNNNNNTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTNTTTTTTTTTTTTTTTTTTTTTTTTTTTTNNNNNTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT Safe-Inferred()4 qghcCombine two tick scopes. The new scope should be sub-scope of both parameters. We simplify automatically if one tick scope is a sub-scope of the other already.qghcChecks whether two tick scopes are sub-scopes of each other. True if the two scopes are equal.qghcTick scope identifier, allowing us to reason about what annotations in a Cmm block should scope over. We especially take care to allow optimisations to reorganise blocks without losing tick association in the process.qghcA combined scope scopes over everything that the two given scopes cover. It is therefore a sub-scope of either scope. This is required for optimisations. Consider common block elimination: A -> tick 2, case ... of C -> [common] B -> tick 3 case ... of D -> [common]We will generate code for the C and D alternatives, and figure out afterwards that it's actually common code. Scoping rules dictate that the resulting common block needs to be covered by both tick 2 and tick 3, therefore we need to construct a scope that is a child to *both* scope. Now we can do that - if we assign the scopes ac and bd to the common-ed up blocks, the new block could have a combined tick scope ac+bd, which both tick 2 and tick 3 apply to.qghcThe global scope is the "root" of the scope graph. Every scope is a sub-scope of the global scope. It doesn't make sense to add ticks to this scope. On the other hand, this means that setting this scope on a block means no ticks apply to it.qghcConstructs a new sub-scope to an existing scope. This allows us to translate Core-style scoping rules (see  tickishScoped2) into the Cmm world. Suppose the following code:tick 1# case ... of A -> tick 2 ... B -> tick 3 ...We want the top-level tick annotation to apply to blocks generated for the A and B alternatives. We can achieve that by generating tick 1 into a block with scope a, while the code for alternatives A and B gets generated into sub-scopes a/b and a/c respectively.qghcA convention maps a list of values (function arguments or return values) to registers or stack locations.qghcEntry to the garbage collector: uses the node reg! (TODO: I don't think we need this --SDM)qghc top-level Haskell functions use NativeDirectCall, which maps arguments to registers starting with R2, according to how many registers are available on the platform. This convention ignores R1, because for a top-level function call the function closure is implicit, and doesn't need to be passed.qghcnon-top-level Haskell functions, which pass the address of the function closure in R1 (regardless of whether R1 is a real register or not), and the rest of the arguments in registers or on the stack.qghca native return. The convention for returns depends on how many values are returned: for just one value returned, the appropriate register is used (R1, F1, etc.). regardless of whether it is a real register or not. For multiple values returned, they are mapped to registers or the stack.qghc/Slow entry points: all args pushed on the stackghcReturns the head uniques of the scopes. This is based on the assumption that the Unique of SubScope identifies the underlying super-scope. Used for efficient equality and comparison, see below.ghcOutput all scope paths.XqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqXqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq Safe-Inferred jghcHere is where the STG register map is defined for each target arch. The order matters (for the llvm backend anyway)! We must make sure to maintain the order here with the order used in the LLVM calling conventions. Note that also, this isn't all registers, just the ones that are currently possibly mapped to real registers.jghcReturns M if this global register is stored in a caller-saves machine register.jjjjjjjjjj Safe-Inferred iiiiiiiiiiii Safe-Inferred 1ghcThe patch function supplied by the allocator maps VirtualReg to RealReg regs, but sometimes we want to apply it to plain old Reg.1ghcRealRegs are machine regs which are available for allocation, in the usual way. We know what class they are, because that's part of the processor's architecture.RealRegPairs are pairs of real registers that are allocated together to hold a larger value, such as with Double regs on SPARC.1ghc"A register, either virtual or real1ghc4An identifier for a primitive real machine register.1ghcPrint a reg in a generic manner If you want the architecture specific names, then use the pprReg function from the appropriate Ppr module.1111111111111111111111111111111111111111111111111111 Safe-Inferred 1ghcThe class of a register. Used in the register allocator. We treat all registers in a class as being interchangeable.11111111 Safe-Inferred \iiiiiiiiiiii Safe-Inferred iiiiiiiiii Safe-Inferred iiiiiiiiii Safe-Inferred #iiiiiiiiii Safe-Inferred diiiiiiiiii Safe-Inferred iiijjiijji Safe-Inferred jjjjjjjjjj Safe-Inferred 'jjjjjjjjjj Safe-Inferred() THghcDoes the backend support switch out of the box? Then leave this to the backend!HghcThis function creates a SwitchPlan from a SwitchTargets value, breaking it down into smaller pieces suitable for code generation.Hghc#Custom equality helper, needed for GHC.Cmm.CommonBlockElimHghc7Changes all labels mentioned in the SwitchTargets valueHghcThe smart constructor mkSwitchTargets normalises the map a bit: * No entries outside the range * No entries equal to the default * No default if all elements have explicit valuesHghcReturns the list of non-default branches of the SwitchTargets valueHghc3Return the default label of the SwitchTargets valueHghcGroups cases with equal targets, suitable for pretty-printing to a c-like switch statement with fall-through semantics.Hghc+Return the range of the SwitchTargets valueHghc.Return whether this is used for a signed valueHghcA value of type SwitchTargets contains the alternatives for a  CmmSwitch value, and knows whether the value is signed, the possible range, an optional default value and a map from values to jump labels.ghcMinimum non-zero offset for a jump table. See Note [Jump Table Offset].ghcA FlatSwitchPlan is a list of SwitchPlans, with an integer inbetween every two entries, dividing the range. So if we have (abusing list syntax) [plan1,n,plan2], then we use plan1 if the expression is < n, and plan2 otherwise.ghcNumber of consecutive default values allowed in a jump table. If there are more of them, the jump tables are split.Currently 7, as it costs 7 words of additional code when a jump table is split (at least on x64, determined experimentally).ghcMinimum size of a jump table. If the number is smaller, the switch is implemented using conditionals. Currently 5, because an if-then-else tree of 4 values is nice and compact.HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH Safe-Inferred ()0 HghcMaps over all nodes in a graph.Hghc Function H enables a change of representation of blocks, nodes, or both. It lifts a polymorphic block transform into a polymorphic graph transform. When the block representation stabilizes, a similar function should be provided for blocks.HghcReturns a list of blocks reachable from the provided Labels in the reverse postorder.This is the most important traversal over this data structure. It drops unreachable code and puts blocks in an order that is good for solving forward dataflow problems quickly. The reverse order is good for solving backward dataflow problems quickly. The forward order is also reasonably good for emitting instructions, except that it will not usually exploit Forrest Baskett's trick of eliminating the unconditional branch from a loop. For that you would need a more serious analysis, probably based on dominators, to identify loop headers.For forward analyses we want reverse postorder visitation, consider: - A -> [B,C] B -> D C -> D  Postorder: [D, C, B, A] (or [D, B, C, A]) Reverse postorder: [A, B, C, D] (or [A, C, B, D]) This matters for, e.g., forward analysis, because we want to analyze *both* B and C before we analyze D.Hghc5A (possibly empty) collection of closed/closed blocksHghcA control-flow graph, which may take any of four shapes (O/O, OC, CO, C/C). A graph open at the entry has a single, distinguished, anonymous entry point; if a graph is closed at the entry, its entry point(s) are supplied by a context.HghcGraph' is abstracted over the block type, so that we can build graphs of annotated blocks for example (Compiler.Hoopl.Dataflow needs this).IghcGives access to the anchor points for nonlocal edges as well as the edges themselvesghcBody abstracted over blockIghc"The label of a first node or blockIghcGives control-flow successorsHHHHHHHHHHIIIIIIHHHIIIIIIHHHHHHH Safe-Inferred Ighc|lookupUE x env| returns the multiplicity assigned to |x| in |env|, if |x| is not bound in |env|, then returns |Zero| or |Bottom|.IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII Safe-Inferred7 &ghcThis checks whether a pass correctly looks through debug annotations ( SourceNote). This works a bit different from other consistency checks: We check this by running the given task twice, noting all differences between the results.ghc Type-check a Y!. See Note [Core Lint guarantee].ghcSee Note [Checking StaticPtrs]ghc,See Note [Linting type synonym applications]ghcSee Note [Linting linearity]ghcAllow  makeStatic to occur anywhere.ghcAllow  makeStatic calls at the top-level only.ghc Reject any  makeStatic occurrence.ghc1Checks the RHS of bindings. It only differs from 8 in that it doesn't reject occurrences of the function  makeStatic( when they appear at the top level and 'lf_check_static_ptrs == AllowAtTopLevel, and for join points, it skips the outer lambdas that take arguments to the join point.See Note [Checking StaticPtrs].ghc9Lint the RHS of a join point with expected join arity of n (see Note [Join points] in GHC.Core).ghcLint an expression cast through the given coercion, returning the type resulting from the cast.ghc'Implements the case rules for linearityghclintValApp arg fun_ty arg_ty lints an application of fun arg where  fun :: fun_ty and  arg :: arg_ty), returning the type of the application.ghcRun the given pass without annotations. This means that we both set the debugLevel setting to 0 in the environment as well as all annotations from incoming modules.ghcIf M!, display linter warnings. If J, ignore linter warnings.ghc The source of the linted programghc"The linted program, pretty-printedghcThe source of the linted axiomsghc#The source of the linted expressionghc>What sort of casted thing this is ("expression" or "type").ghc:What sort of coercion is being used ("type" or "kind").ghcThe thing being casted.   Safe-Inferred nghcCheck to make sure that an AxInstCo is internally consistent. Returns the conflicting branch, if it exists See Note [Conflict checking with AxiomInstCo]nghcoptCoercion applies a substitution to a coercion, *and* optimises it to reduce its sizenghcCoercion optimisation optionsnghc.Enable coercion optimisation (reduce its size)ghc.Do we force the result to be representational?ghcDo we apply a sym to the result?ghcOptimize a coercion, making no assumptions. All coercions in the lifting context are already optimized (and sym'd if nec'y)ghc=Optimize a coercion, knowing the coercion's non-Phantom role.ghcOptimize a phantom coercion. The input coercion may not necessarily be a phantom, but the output sure will be.ghc Optimize a non-phantom coercion.ghcOptimize a coercion, knowing the coercion's role. No other assumptions.ghc Optimize a non-phantom coercion.ghc/Conditionally set a role to be representationalghcIf we require a representational role, return that. Otherwise, return the "default" role provided.ghcThe role of the input coercionghc current roleghc"default" rolennnnnnnnnn Safe-Inferred '7 ×ghcMatch the scrutinee of a case and potentially return a new scrutinee and a function to apply to each literal alternative.ghc(Match the application of a binary primopghcMatch a literalghc9Explicit "type-class"-like dictionary for numeric primopsghcAdd two numbersghcSub two numbersghcMultiply two numbersghc Literal typeghcMatch a primopghc?Shift right, putting zeros in rather than sign-propagating as  would do. Do this by converting to the appropriate Word and back. Obviously this won't work for too-big values, but its ok as we use it here.ghcCheck if there is comparison with minBound or maxBound, that is always true or false. For instance, an Int cannot be smaller than its minBound, so we can replace such comparison with False.ghcCreate an Int literal expression while ensuring the given Integer is in the target Int rangeghcCreate an Int literal expression while ensuring the given Integer is in the target Int rangeghcCreate an Int literal expression while ensuring the given Integer is in the target Int rangeghcCreate an unboxed pair of an Int literal expression, ensuring the given Integer is in the target Int range and the corresponding overflow flag (0#/1#) if it wasn't.ghcCreate a Word literal expression while ensuring the given Integer is in the target Word rangeghcCreate a Word literal expression while ensuring the given Integer is in the target Word rangeghcCreate a Word literal expression while ensuring the given Integer is in the target Word rangeghcCreate a Word literal expression while ensuring the given Integer is in the target Word rangeghcCreate an unboxed pair of a Word literal expression, ensuring the given Integer is in the target Word range and the corresponding carry flag (0#/1#) if it wasn't.ghc'ambiant (primop x) = x', but not nececesarily 'primop (ambient x) = x'.ghc=Transform `extendWordN (narrowWordN x)` into `x .&. 0xFF..FF`ghcnarrow subsumes bitwise  with full mask (cf #16402):narrowN (x .&. m) m .&. (2^N-1) = 2^N-1 ==> narrowN x3e.g. narrow16 (x .&. 0xFFFF) ==> narrow16 xghcMatch (op (op v e) e) or (op e (op v e)) or (op (op e v) e) or (op e (op e v)) and return the innermost (op v e) or (op e v).ghcLooks into the expression or its unfolding to find "App (Var f) x"ghc$Left identity rule for PrimOps like IntAddC and WordAddC, where, in addition to the result, we have to indicate that no carry/overflow occurred.ghc%Right identity rule for PrimOps like IntSubC and WordSubC, where, in addition to the result, we have to indicate that no carry/overflow occurred.ghcIdentity rule for PrimOps like IntAddC and WordAddC, where, in addition to the result, we have to indicate that no carry/overflow occurred.ghcCreate a numeric literal—×ėė—× Safe-Inferred &5:<> M  > Safe-Inferred #ghc TopDir pathghc&Settings filepath (for error messages)ghcRaw settings file contents? Safe-Inferred ghcThe predicates below look costly, but aren't, GHC+GCC do a great job at the big case below.@ Safe-Inferred UghcWe (allegedly) put the first six C-call arguments in registers; where do we start putting the rest of them?ghc6Check whether an offset is representable with 13 bits.ghcCheck whether an integer will fit in 32 bits. A CmmInt is intended to be truncated to the appropriate number of bits, so here we truncate it to Int64. This is important because e.g. -1 as a CmmInt might be either -1 or 18446744073709551615.ghcSadness.ghc9We need 8 bytes because our largest registers are 64 bit.A Safe-Inferred D Safe-Inferred ›ghcGenerate a section type (e.g.  @progbits). See #13937.ghcTarget platformghc section typeghcpretty assembler fragmentL Safe-Inferred >ghc5Modify the finite map holding the nodes in the graph.ghcAn empty graph.ghcAn empty node.ghcThe Interference graph. There used to be more fields, but they were turfed out in a previous revision. maybe we'll want more later..ghcAll active nodes in the graph.ghcGraph nodes. Represents a thing that can conflict with another thing. For the register allocater the nodes represent registers.ghcThe class of this node, determines the set of colors that can be used.ghc>Neighbors that this node would like to be colored the same as.ghcThe color of this node, if any.ghc9Neighbors which must be colored differently to this node.ghc(Colors that cannot be used by this node.ghc"A unique identifier for this node.ghc>Colors that this node would prefer to be, in descending order.ghcA 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.M Safe-Inferred2 ghcaddToUSDFM env x a sets the entry x is associated with to a1, thereby modifying its whole equivalence class.$Examples in terms of the model (see ): >>> addToUSDFM [] u1 ele1 == [({u1}, Just ele1)] >>> addToUSDFM [({u1,u3}, Just ele1)] u3 ele2 == [({u1,u3}, Just ele2)]ghcequateUSDFM env x y makes x and y+ point to the same entry, thereby merging x's class with y 's. If both x and y$ are in the domain of the map, then y.'s entry will be chosen as the new entry and x's old entry will be returned.$Examples in terms of the model (see ): >>> equateUSDFM [] u1 u2 == (Nothing, [({u1,u2}, Nothing)]) >>> equateUSDFM [({u1,u3}, Just ele1)] u3 u4 == (Nothing, [({u1,u3,u4}, Just ele1)]) >>> equateUSDFM [({u1,u3}, Just ele1)] u4 u3 == (Nothing, [({u1,u3,u4}, Just ele1)]) >>> equateUSDFM [({u1,u3}, Just ele1), ({u2}, Just ele2)] u3 u2 == (Just ele1, [({u2,u1,u3}, Just ele2)])ghclookupSUDFM env x looks up an entry for x, looking through all s until it finds a shared .$Examples in terms of the model (see ): >>> lookupUSDFM [({u1,u3}, Just ele1), ({u2}, Just ele2)] u3 == Just ele1 >>> lookupUSDFM [({u1,u3}, Just ele1), ({u2}, Just ele2)] u4 == Nothing >>> lookupUSDFM [({u1,u3}, Just ele1), ({u2}, Nothing)] u2 == NothingghcA  whose domain is sets of /s, each of which share a common value of type ele. Every such set ("equivalence class") has a distinct representative . Supports merging the entries of multiple such sets in a union-find like fashion.An accurate model is that of [(Set key, Maybe ele)]!: A finite mapping from sets of keys to possibly absent entries ele+, where the sets don't overlap. Example:  m = [({u1,u3}, Just ele1), ({u2}, Just ele2), ({u4,u7}, Nothing)] 9 On this model we support the following main operations: m u3 == Just ele1,  m u4 == Nothing,  m u5 == Nothing. m u1 u3 is a no-op, but  m u1 u2 merges {u1,u3} and {u2} to point to  Just ele2 and returns the old entry of {u1,u3},  Just ele1. m u3 ele4 sets the entry of {u1,u3} to  Just ele4.8As well as a few means for traversal/conversion to list.ghcEither  Indirect x., meaning the value is represented by that of x , or an Entry6 containing containing the actual value it represents.P Safe-Inferred յghc-An empty stack map, with all slots available.ghcIf this vreg unique already has a stack assignment then return the slot number, otherwise allocate a new slot, and update the map.ghc4Return the number of stack slots that were allocatedghc#Assignment of vregs to stack slots.ghc3The slots that are still available to be allocated.ghcIdentifier for a stack slot. Safe-Inferred 1ghcFor 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.1ghcThe 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.1ghcWorst 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..1ghcA register of some class1ghc"A subcomponent of another register1ghcso we can put regs in UniqSetsghcpowerset (for lists)ghcpowersetLS (list of sets)111111111111111111111111111111 Safe-Inferred ۲1ghc!Determine the class of a register1ghc!Which regs alias what other regs.1ghcDetermine the common name of a reg returns Nothing if this reg is not part of the machine.1ghc4Determine all the regs that make up a certain class.1ghcOptimised versions of RegColorBase.{worst, squeese} specific to x86111111111111 Safe-Inferred 1111 Safe-Inferred +11p Safe-Inferred ޗghcPretty print a graph in graphviz .dot format. Conflicts get solid edges. Coalescences get dashed edges.ghc9Pretty print a graph in a somewhat human readable format.ghcNodes in the graph are doubly linked, but we only want one edge for each conflict if the graphviz graph. Traverse over the graph, but make sure to only print the edges for each node once.ghcWhat 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 etcq Safe-Inferred 6ghcAdd a coalescence edge to the graph, creating nodes if required. It is considered adventageous to assign the same color to nodes in a coalesence.ghcAdd a conflict between nodes to the graph, creating the nodes required. Conflicts are virtual regs which need to be colored differently.ghcAdd some conflicts to the graph, creating nodes if required. All the nodes in the set are taken to conflict with each other.ghcAdd an exclusion to the graph, creating nodes if required. These are extra colors that the node cannot use.ghc-Add a node to the graph, linking up its edgesghcAdd 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.ghcDo 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.ghcCoalesce 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 graphghc4Delete a coalescence edge (k1 -> k2) from the graph.ghcDelete a conflict edge. k1 -> k2 returns Nothing if the node isn't in the graphghc/Delete a node and all its edges from the graph.ghcFreeze all the nodes in the graph for debugging the iterative allocator.ghcFreeze 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.ghcFreeze 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>Get a node from the graph, throwing an error if it's not thereghcLookup a node from the graph.ghcModify a node in the graph. returns Nothing if the node isn't present.ghc7Find all the nodes in the graph that meet some criteriaghcSet the color of a certain nodeghcGet the size of the graph, O(n)ghcSlurp out a map of how many nodes had a certain number of conflict neighboursghcUnion two graphs together.ghcvalidate the internal structure of a graph all its edges should point to valid nodes If they don't then throw an errorghcIf this node is colored, check that all the nodes which conflict with it have different colors.ghcIf True, coalesce nodes even if this might make the graph less colorable (aggressive coalescing)ghcIf True, coalesce nodes even if this might make the graph less colorable (aggressive coalescing)ghc!keys of the nodes to be coalescedghckey of the node to freezeghc the graphghcgraph with that node frozenghc9(conflict neighbours, num nodes with that many conflicts)ghc(extra debugging info to display on errorghc-whether this graph is supposed to be colored.ghcgraph to validateghcvalidated graphghcTrue if this node is okr Safe-Inferred  ghcTry 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.ghcScan through the conflict graph separating out trivially colorable and potentially uncolorable (problem) nodes.Checking whether a node is trivially colorable or not is a reasonably expensive operation, so after a triv node is found and removed from the graph it's no good to return to the start of the graph and recheck a bunch of nodes that will probably still be non-trivially colorable.To ward against this, during each pass through the graph we collect up a list of triv nodes that were found, and only remove them once we've finished the pass. The more nodes we can delete at once the more likely it is that nodes we've already checked will become trivially colorable for the next pass.TODO: add work lists to finding triv nodes is easier. If we've just scanned the graph, and removed triv nodes, then the only nodes that we need to rescan are the ones we've removed edges from.ghc)Try to assign a color to all these nodes.ghcSelect a color for a certain node taking into account preferences, neighbors and exclusions. returns Nothing if no color can be assigned to this node. ghc"whether to do iterative coalescingghc6how many times we've tried to color this graph so far.ghc>map of (node class -> set of colors available for this class).ghc3fn to decide whether a node is trivially colorable.ghcfn to choose a node to potentially leave uncolored if nothing is trivially colorable.ghcthe graph to color.ghc"whether to do iterative coalescingghc2fn to decide whether a node is trivially colorableghcfn to choose a node to potentially leave uncolored if nothing is trivially colorable.ghcthe graph to scanghc>map of (node class -> set of colors available for this class).ghc the graphghcnodes to assign a color to.ghc>map of (node class -> set of colors available for this class).ghc the graphghc&key of the node to select a color for.+   Safe-Inferred UghcFind all the link options in these and the preload packages, returning (package hs lib options, extra library options, other flags)ghc Either the  or  as appropriate for the way.UUUUUUUU Safe-Inferred UghcBreak 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")UghcEnable process jobs support on Windows if it can be expected to work (e.g. process >= 1.6.9.0).Ughc Version of &System.Process.readProcessWithExitCode> that takes a key-value tuple to insert into the environment.UghcRun 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/10777UghcstdoutUghc program pathghc program argsghcaddition to the environmentghc(exit_code, stdout, stderr)UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUU Safe-Inferred UUUUUUUUUU Safe-Inferred Tghc.Generate the GAS code to create a Note sectionHeader fields for notes are 32-bit long (see Note [ELF specification]).Tghcread 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 returnedTghc8Given a section name, read its contents as a ByteString.If the section isn't found or if there is any parsing error, we return Nothingghc ELF headerThe ELF header indicates the native word size (32-bit or 64-bit) and the endianness of the target machine. We directly store getters for words of different sizes as it is more convenient to use. We also store the word size as it is useful to skip some uninteresting fields.Other information such as the target machine and OS are left out as we don't use them yet. We could add them in the future if we ever need them.ghc(Get a Word16 with the correct endiannessghc(Get a Word32 with the correct endiannessghc7Get a Word with the correct word size and endiannessghcWord size in bytesghc A sectionghcName of the sectionghcContent of the sectionghc Description of the section tableghc'offset of the table describing sectionsghc%size of an entry in the section tableghcnumber of sectionsghc 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.UghcMagic 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.Ughc%Make a bitmap from a sequence of bitsUghc&A bitmap represented by a sequence of T 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.Ughc size in bitsghc*sorted indices of zeros free of duplicatesUUUUUUUU Safe-Inferred$% ghcProduce 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  . Safe-Inferred ,ghcShow a GHC syntax tree. This parameterised because it is also used for comparing ASTs in ppr roundtripping tests, where the SrcSpan's are blanked out, to avoid comparing locations, only structureghc The type constructor for queriesghc.Extend a generic query by a type-specific caseghc/Type extension of queries for type constructorsghc/Type extension of queries for type constructorsghcFlexible type extensionghcFlexible type extension Safe-Inferred =ghc,True if there is a non-empty intersection. s1 = s2 doesn't compute s2 if s1 is empty====================================== Safe-Inferred J \ghc  emptySubst = \ (\ghcAdd the  to the in-scope set and remove any existing substitutions for it.\ghcAdd 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.\ghcSubstitutes an occurrence of an identifier for its counterpart recorded in the \.\ghcConstructs a new \% assuming the variables in the given ) are in scope.\ghcSubstitutes 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.\ghcSubstitutes 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 4substBndrs = runState . traverse (state . substBndr)\ghcA renaming substitution from s to s. Like )4, but not maintaining pairs of substitutions. Like , but with the domain being s instead of entire CoreExpr. \\\\\\\\\\\ \\\\\\\\\\\ Safe-Inferred Vghccomplete bipartite graphghccomplete graphghc Resolves all 0, by pushing them in, and simplifies `D D @ = @`ghcShallow empty check.]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]] Safe-Inferred pp Safe-Inferred ffffff Safe-Inferred 9gg Safe-Inferred Ngghc1Annotates an STG binding with its free variables.gghcAnnotates a top-level STG binding group with its free variables.ghcThis makes sure that only local, non-global free vars make it into the set.gggg Safe-Inferred cgghcDependency sort a STG program so that dependencies come before uses.ghcSet of bound variablesghcSet of free variablesghc!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 (BVs) to recursive calls, get free variables (FVs) back. We ignore imported FVs as they do not change the ordering but it improves performance.ghcSort free-variable-annotated STG bindings so that dependencies come before uses.gg Safe-Inferred ghc3Try to find the best source position surrounding a g. The heuristic strips ticks from the current expression until it finds one which is from the module currently being compiled. This is the same method that the DWARF information uses to give locations to info tables.2It is usually a better alternative than using the - which is carefully propagated downwards by . It's "quick" because it works only using immediate context rather than looking at the parent context like gg Safe-Inferred 7 Pghc(Precondition: argument expression is an Z, and there is a Z at the head of the Z chain. Safe-Inferred  /oghcLifts a binding to top-level. Depending on whether it's declared inside a recursive RHS (see GHC.Stg.Lift.Monad#floats and o), this might be added to an existing recursive top-level binding group.oghcWrites a plain f to the output.oghcFlattens an expression in [p] 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.oghc uncurry p . o = idpghc$Ends a recursive binding group. See GHC.Stg.Lift.Monad#floats and o.pghcReturns 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.pghc:Whether the given binding was decided to be lambda lifted.pghc 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.pghc&Starts a recursive binding group. See GHC.Stg.Lift.Monad#floats and o.pghcSubstitutes a binder  occurrence), which was brought in scope earlier by p / p.pghc Similarly to p, 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.pghcSee p.pghcTakes a binder and a continuation which is called with the substituted binder. The continuation will be evaluated in a p context in which that binder is deemed in scope. Think of it as a  computation: After the continuation finishes, the new binding won't be in scope anymore.pghcSee p.pghc)Environment threaded around in a scoped, Reader-like fashion.pghc Read-only.pghcLifted 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.pghc(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.pghcWe 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 p and p. Although o will only ever care if the current binding to be lifted (through p) 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.pghc-The analysis monad consists of the following  components:p: Reader-like context. Contains a substitution, info about how how lifted identifiers are to be expanded into applications and details such as  . p.: Writer output for the resulting STG program.No pure state componentBut wrapping around 2 for generating fresh lifted binders. (The uniqAway approach could give the same name to two different lifted binders, so this is necessary.)ghcOmitting this makes for strange closure allocation schemes that crash the GC.oooopppppppppppppppppppppppopppppppppppoppppoopppppppp Safe-Inferred  2Tkghc CoreMap a is a map from Y to a3. If you are a client, this is the type you want.ghc CoreMapX a is the base map from DeBruijn CoreExpr to a, but without the H optimization.ghc CoreMapG a is a map from DeBruijn CoreExpr to a. The extended key makes it suitable for recursive traversal, since it can track binders, but it is strictly internal to this module. If you are including a k inside another H, this is the type you want.HHHHHHHHHHHHHKKKKkkkkkkkkkkHHHHHHHHHHKKKKHHH Safe-Inferred ;ghc.The CSE environment. See note [CseEnv Example]ghcThe main component of the environment is the trie that maps data constructor applications (with their " arguments) to an in-scope name that can be used instead. This name is always either a let-bound variable or a case binder.ghcThis substitution is applied to the code as we traverse it. Entries have one of two reasons:The input might have shadowing (see Note [Shadowing]), so we have to rename some binders as we traverse the tree.If we remove `let x = Con z` because `let y = Con z` is in scope, we note this here as x C y.ghcIf we come across a case expression case x as b of @ with a trivial binder, we add b C x to this. This map is *only* used when looking something up in the ce_conAppMap. See Note [Trivial case scrutinee]ghcThe third component is an in-scope set, to rename away any shadowing bindersghcNote [CseEnv Example] ~~~~~~~~~~~~~~~~~~~~~ The following tables shows how the CseEnvironment changes as code is traversed, as well as the changes to that code.InExpr OutExpr conAppMap subst in_scope JJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJ -- empty {} {} case @ as a of {Con x y -> case @ as a of {Con x y -> -- Con x y C a {} {a,x,y} let b = Con x y (removed) -- Con x y C a bCa {a,x,y,b} let c = Bar a let c = Bar a -- Con x y C a, Bar a C c bCa {a,x,y,b,c} let c = some expression let c' = some expression -- Con x y C a, Bar a C c bCa, cCc', {a,x,y,b,c,c'} let d = Bar b (removed) -- Con x y C a, Bar a C c bCa, cCc', dCc {a,x,y,b,c,c',d} (a, b, c d) (a, a, c' c)ghc;This function short-cuts let-bindings that are now obsoletekk Safe-Inferred ;B@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDCCCCBBBCCCCCBCCBABAA@DB@AC@AB@BC@CBBBBBBBBBDDDBB@CAADAACC@BDCDD@AC@@DCBCDAB@D@B@@AACCBACDD@BB@AB@CDAAACAAAABCCCAABBB@BBBCAD@BC@ACAABCCCBBC@@BD@B@AAACBBBA@BCCBCCBCAAAC@@DDAACACAAD@ACDD@BB@@CABCCCCDABC@BABACABCBAC@BADA@C@CADCACDADDDBAC@BDBAC@@DD@CDCAADDACCCCBAA@A@A@BBBABCAB@CABC@DDDD@@DAABBACC@CDC@AABAA@BBAA@A@A@BBBAC@CBBBBBBBBDDDBB@CAADAACC@BBDCDD@AC@@DCBCDAB@D@B@@AACCBACDD@BB@A@AAAABCCCCDAABACAABBB@BBBCAD@BC@AACABCCCBB@@B@@BDCAAACBBBAA@BCCBCCBCAAAC@@DDAACACAAD@CDD@B@@CABCCCCDAABC@BABABCBAC@BADA@C@CADCAABDCCCCCDDDB@C@BDCABBBBD@B@ACADAAC@ Safe-Inferred C 0nnnnnnnnnnnn nnnnnnnnnnnn0 Safe-Inferred  GghcAn accumulator to build a prefix data constructor, e.g. when parsing  MkT A B C), the accumulator will evolve as follows:  1. PrefixDataConBuilder [] MkT 2. PrefixDataConBuilder [A] MkT 3. PrefixDataConBuilder [A, B] MkT 4. PrefixDataConBuilder [A, B, C] MkT There are two reasons we have a separate builder type instead of using HsConDeclDetails GhcPs directly: It's faster, because  gives us constant-time snoc.Having a separate type helps ensure that we don't forget to finalize a RecTy into a  (we do that in dataConBuilderDetails).See Note [PatBuilder] for another builder type used in the parser. Here the technique is similar, but the motivation is different.ghc?See Note [Ambiguous syntactic categories] and Note [PatBuilder]ghc"Last two are the locations of the '|' before and after the payload Safe-Inferred d;ghcErrors from the Cmm parserghcUnknown calling conventionghc Unknown macroghcUnknown Cmm primitiveghcUnrecognised hintghcUnrecognised safetyghcType applications in patterns are only allowed on data constructorsghc Lexical errorghcLexical error in pragmaghc$Numeric escape sequence out of rangeghc*Llexical error in string/character literalghc2Unexpected end-of-file in string/character literalghcUnknown pragmaghcUnterminated `{-'ghcUnterminated OPTIONS pragmaghcUnterminated quasiquotationghcError at given characterghc End of inputghcUTF-8 decoding errorghc$The operator occurrence type in the WarnOperatorWhitespace warning.őghcThe operator symbol in the !WarnOperatorWhitespaceExtConflict warning.ˑghcError description̑ghcHints͑ghcError positionϑghc"Arrow command-syntax in expressionБghcArrow command-syntax in patternёghc"Arrow expression-syntax in patternґghc @-operator in a pattern positionӑghcBang-pattern (!) without space after itԑghc/Unexpected case command in function applicationՑghc2Unexpected case expression in function application֑ghccase..of in patternבghcCmm lexer errorؑghcCmm parser errorّghc"Declaration splice not a top-levelڑghc-Unexpected do command in function applicationۑghc+Unexpected do block in function applicationܑghcDo-notation in patternݑghcDots used in record updateޑghcFound two single quotesߑghcEmpty 'where'& clause in pattern-synonym declarationghcExpected a hyphenghc=Explicit forall found but no extension allowing it is enabledghc-Unexpected if command in function applicationghc0Unexpected if expression in function applicationghcIf-then-else syntax in patternghc*Bang-pattern without BangPattterns enabledghcIllegal datatyp contextghc#Explicit namespace keyword without ExplicitNamespacesghcIllegal import bundle formghc.Illegal export form allowed by PatternSynonymsghc.Found qualified-do without QualifiedDo enabledghcIllegal role nameghc!Illegal traditional record syntax+TODO: distinguish errors without using SDocghc)Illegal unboxed string literal in patternghcIllegal 'where' keyword in data declarationghcPost qualified import without ImportQualifiedPostghc Import: multiple occurrences of  qualifiedghc(Inferred type variables not allowed hereghc;Cannot parse data constructor in a data/newtype declarationghc;Cannot parse data constructor in a data/newtype declarationghc.Invalid infix hole, expected an infix operatorghcInvalid package nameghcNot a record constructorghcInvalid rule activation markerghcInvalid type signatureghcInvalid binding name in 'where'& clause of pattern-synonym declarationghc4LambdaCase syntax used without the extension enabledghc9Unexpected lambda-case expression in function applicationghcLambda-case in patternghc1Unexpected lambda command in function applicationghc4Unexpected lambda expression in function applicationghcLambda-syntax in patternghcLazy-pattern (~) without space after itghc.Unexpected let command in function applicationghc1Unexpected let expression in function applicationghclet-syntax in patternghc Lexer errorghc1Linear function found but LinearTypes not enabledghc,Unexpected mdo block in function applicationghc!Malformed ... declaration for ...ghcMalformed entity stringghc+Malformed head of type or class declarationghc Missing blockghc8Multi-way if-expression found but MultiWayIf not enabledghc,Multiple names in standalone kind signaturesghcMultiple bindings in 'where'& clause of pattern-synonym declarationghcNot a data constructorghc5Underscores in literals without the extension enabledghc%Operator applied to too few argumentsghc!Invalid use of record dot syntax ghcCan't use qualified fields when OverloadedRecordUpdate is enabled.ghcOverloadedRecordUpdate is not enabled.ghc Parse errorsghcParse error in command+TODO: distinguish errors without using SDocghcParse error in pattern+TODO: distinguish errors without using SDocghcParse error on inputghcPrecedence out of rangeghc%Invalid character in primitive stringghc2Unexpected proc expression in function applicationghcQualified do block in commandghc1Record syntax used in pattern synonym declarationghc-Unexpected semi-colons in conditional commandghc0Unexpected semi-colons in conditional expressionghcFound a space in a SCCghcSuffix occurrence of @ghc Tuple section in pattern contextghc&Type-application without space before @ghc#Pragma not allowed in this positionghc7Unexpected kind application in data/newtype declarationghc Unexpected qualified constructorghc,Unexpected type application in a declarationghcUnexpected type in declarationghc$UNPACK applied to a data constructorghc#Unsupported boxed sum in expressionghc Unsupported boxed sum in patternghc1Expecting a type constructor but found a variableghcView-pattern in expressionghc*A warning that might arise during parsing.ghcPsWarnBidirectionalFormatChars is a warning (controlled by the -Wwarn-bidirectional-format-characters flag) that occurs when unicode bi-directional format characters are found within in a fileThe  contains the exact position in the buffer the character occured, and the string contains a description of the character.ghc,Multiple Haddock comment for the same entityghc Invalid Haddock comment positionghcPre qualified import with WarnPrepositiveQualifiedModule enabledghc;Found binding occurrence of "*" while StarIsType is enabledghcUsing "*" for Type without StarIsType enabledghcWarn when tabulations are foundghcTransitional layout warningsghcUnrecognised pragmaghcNumber of other occurrencesghcFirst occurrence of a tabghc"`|'- at the same depth as implicit layout block")ghc"`where'3 clause at the same depth as implicit layout block"ghcconditional exprghc"then" semi-colon?ghc "then" exprghc"else" semi-colon?ghc "else" exprghcconditional exprghc"then" semi-colon?ghc "then" exprghc"else" semi-colon?ghc "else" expr‘ÑđőƑǑȑɑʑˑ̑͑ΑϑБёґӑԑՑ֑בّؑڑۑܑݑޑߑőƑǑȑ‘Ñđɑʑˑ̑͑ΑϑБёґӑԑՑ֑בّؑڑۑܑݑޑߑ Safe-Inferred 5 {_*ϒghcGet a bag of the errors that have been accumulated so far. Does not take -Werror into account.ҒghcGet the warnings and errors accumulated so far. Does not take -Werror into account.֒ghcCreates a parse state from a ʓ valueגghc.Set parser options for parsing OPTIONS pragmasےghcGiven a  that surrounds a HsPar or HsParTy , generate , values for the opening and closing bordering on the start and end of the spanܒghc1Given exactly the information needed, set up the ʓghcTest whether a  is setghcVarious boolean flags, mostly language extensions, that impact lexing and parsing. Note that a handful of these can change during lexing/parsing.ghcIf this is enabled, '{-# LINE ... -#}' and '{-# COLUMN ... #-}' update the internal position. Otherwise, those pragmas are lexed as tokens of their own.ghcHaddock comment as produced by the lexer. These are accumulated in  and then processed in GHC.Parser.PostProcess.Haddock.ghcAn mtl-style class for monads that support parsing-related operations. For example, sometimes we make a second pass over the parsing results to validate, disambiguate, or rearrange them, and we do so in the PV monad which cannot consume input but can report parsing errors, check for extension bits, and accumulate parsing annotations. Both P and PV are instances of MonadP.MonadP grants us convenient overloading. The other option is to have separate operations for each monad: addErrorP vs addErrorPV, getBitP vs getBitPV, and so on.ghcAdd a non-fatal error. Use this when the parser can produce a result despite the error.#For example, when GHC encounters a forall in a type, but -XExplicitForAll$ is disabled, the parser constructs ForAllTy as if -XExplicitForAll= was enabled, adding a non-fatal error to the accumulator.Control flow wise, non-fatal errors act like warnings: they are added to the accumulator and parsing continues. This allows GHC to report more than one parse error per file.ghcAdd a fatal error. This will be the last error reported by the parser, and the parser will not produce any result, ending in a ȓ state.ghc)Add a warning to the accumulator. Use Ғ! to get the accumulated warnings.ghcGo through the  comment_q in PState; and remove all comments that belong within the given spanghcGo through the  comment_q in PState8 and remove all comments that come after the given spanghcGo through the  comment_q in PState and remove all comments that come before or within the given spanghc5Check if a given flag is currently set in the bitmap.ghc!The parsing monad, isomorphic to StateT PState Maybe.ǓghcThe result of running a parser.ȓghcThe parser has consumed a (possibly empty) prefix of the input and failed.ɓghcThe parser has consumed a (possibly empty) prefix of the input and produced a result. Use Ғ; to check for accumulated warnings and non-fatal errors.ʓghcParser options.See ܒ to construct this.̓ghcbitmap of permitted extensions͓ghcenabled warning flagsϓghc -<<Гghc >>-ؓghccomment in {- -}ghc |)ghcsomething beginning -- $ghcsomething beginning -- |ghcsomething beginning -- ^ghc(doc options (prune, ignore-exports, etc)ghca section headingghcend of file tokenghc -<ghccomment starting by "--"ghc (|Δghc >-ghc*Used when the lexer can't make sense of itghcFor reasons of efficiency, boolean parsing flags (eg, language extensions or whether we are currently in a RULE2 pragma) are represented by a bitmap stored in a Word64.ghcDo we want to generate ';' layout tokens? In some cases we just want to generate '}', e.g. in MultiWayIf we don't need ';'s because '|'# separates alternatives (unlike a `case` expression where we need ';' to as a separator between alternatives).ܒghcwarnings flags enabledghc%permitted language extensions enabledghcare safe imports on?ghckeeping Haddock comment tokensghckeep regular comment tokensghcIf this is enabled, '{-# LINE ... -#}' and '{-# COLUMN ... #-}' update the internal position kept by the parser. Otherwise, those pragmas are lexed as  and  tokens.ȓghcThe parsing state right before failure, including the fatal parse error. Ғ and ϒ* must return a non-empty bag of errors.ɓghc;The resulting parsing state. Can be used to resume parsing.ghcThe resulting value.ƒǒȒɒʒ˒̒͒ΒϒВђҒӒԒՒ֒גْؒڒےܒݒޒߒƓ“ÓēœǓȓɓʓ˓͓̓ΓϓГѓғӓԓՓ֓דؓٓړۓܓݓޓߓ”ÔĔŔƔǔȔɔʔ˔͔̔ΔϔДєҔӔԔՔ֔הؔٔڔ۔ܔݔޔߔΓϓГѓғӓԓՓ֓דؓٓړۓܓݓޓߓ”ÔĔŔƔǔȔɔʔ˔͔̔ΔϔДєҔӔԔՔ֔הؔٔڔ۔ܔݔޔߔْڒʓ˓͓̓ܒƓ“Óēœ֒גǓȓɓǒɒȒՒӒ̒˒ϒҒޒƒݒђߒؒے͒ԒВΒʒ Safe-Inferred&27>? ghcAdd Haddock documentation accumulated in the parser state to a parsed HsModule.Reports badly positioned comments when -Winvalid-haddock is enabled.ghcThe state of HdkM.ghc,Represents a predicate on the column number.ColumnBound | Int -> Bool --------------+----------------- ColumnFrom n | (>=n)+The semigroup instance corresponds to (&&).ghcWarnings accumulated in HdkM.ghcThe inverse of  that merges partitioned items back into a flat list. Elements are put back into the order in which they appeared in the original program before partitioning, using BufPos to order them.=Precondition (unchecked): the input lists are already sorted. Safe-Inferred'(). :ghcAnnotate a type with either an {-# UNPACK #-} or a {-# NOUNPACK #-} pragma.ghcAdd the annotation for a 'where' keyword to existing  HsLocalBindsghcValidate the context constraints and break up a context into a list of predicates.  (Eq a, Ord b) --> [Eq a, Ord b] Eq a --> [Eq a] (Eq a) --> [Eq a] (((Eq a))) --> [Eq a] ghcCheck if the gadt_constrlist is empty. Only raise parse error for `data T where` to avoid affecting existing error message, see #8258.ghcYield a parse error if we have a function applied directly to a do block etc. and BlockArguments is not enabled.ghcCheck for monad comprehensions1If the flag MonadComprehensions is set, return a # context, otherwise use the usual  contextghcCheck if a fixity is valid. We support bypassing the usual bound checks for some special operators.ghcFunction definitions are restructured here. Each is assumed to be recursive initially, and non recursive definitions are discovered by the dependency analyser.ghc Converts އ annotated with its  to one without annotations. Only accepts specified variables, and errors if the provided binder has an " annotation.ghcConverts a list of އs annotated with their  to binders without annotations. Only accepts specified variables, and errors if any of the provided binders has an " annotation.ghc#Hint about bang patterns, assuming  BangPatterns is off.ghcConstruct a GADT-style data constructor from the constructor names and their type. Some interesting aspects of this function:This splits up the constructor type into its quantified type variables (if provided), context (if provided), argument types, and result type, and records whether this is a prefix or record GADT constructor. See Note [GADT abstract syntax] in  GHC.Hs.Decls for more details.îghcmkClassDecl builds a RdrClassDecl, filling in the names for tycon and datacon by deriving them from the name of the class. We fill in the names for the tycon and datacon corresponding to the class, by deriving them from the name of the class itself. This saves recording the names in the interface file (which would be equally good).̮ghcThis rather gruesome function is used mainly by the parser. When parsing: data T a = T | T1 Int"we parse the data constructors as types? because of parser ambiguities, so then we need to change the  type constr to a  data constrThe exact-name case can occur when parsing: data [] a = [] | a : [a]3For the exact-name case we return an original name.ЮghcDisambiguate constructs that may appear when we do not know ahead of time whether we are parsing an expression, a command, or a pattern. See Note [Ambiguous syntactic categories]ѮghcSee Note [Body in DisambECP]Үghc Function argument representationӮghcInfix operator representationԮghcReturn a command without ambiguity, or fail in a non-command context.ծghcReturn an expression without ambiguity, or fail in a non-expression context.֮ghc)Disambiguate "f x" (function application)׮ghc.Disambiguate "f @t" (visible type application)خghcDisambiguate "a@b" (as-pattern)ٮghc Disambiguate "!a" (bang pattern)ڮghcDisambiguate "case ... of ..."ۮghc'Disambiguate "do { ... }" (do notation)ܮghc$Disambiguate "[a,b,c]" (list syntax)ݮghc'Disambiguate "if ... then ... else ..."߮ghc"Disambiguate "... -> ..." (lambda)ghc Disambiguate "~a" (lazy pattern)ghcDisambiguate "let ... in ..."ghc"Disambiguate a monomorphic literalghcDisambiguate "-a" (negation)ghc%Disambiguate "f # x" (infix operator)ghc"Disambiguate an overloaded literalghc$Disambiguate "( ... )" (parentheses)ghcDisambiguate "f { a = b, ... }" syntax (record construction and record updates)ghc-Disambiguate "(# a)" (right operator section)ghc5Disambiguate "$(...)" and "[quasi|...|]" (TH splices)ghc'Disambiguate "a :: t" (type annotation)ghc2Disambiguate a variable "f" or a data constructor MkF.ghc&Disambiguate "(a -> b)" (view pattern)ghcDisambiguate a wildcardghc,Disambiguate tuple sections and unboxed sumsghcValidate infixexp LHS to reject unwanted {-# SCC ... #-} pragmasghcBring superclass constraints on FunArg into scope. See Note [UndecidableSuperClasses for associated types]ghcBring superclass constraints on InfixOp into scope. See Note [UndecidableSuperClasses for associated types]ghcDisambiguate infix operators. See Note [Ambiguous syntactic categories]ghcDisambiguate constructs that may appear when we do not know ahead of time whether we are parsing a type or a newtype/data constructor.?See Note [Ambiguous syntactic categories] for the general idea.See Note [Parsing data constructors is hard] for the specific issue this particular class is solving.ghc Disambiguate f @t (visible kind application)ghcProcess the head of a type-level function/constructor application, i.e. the H in H a b c.ghc Disambiguate f x3 (function application or prefix data constructor).ghc Disambiguate f # x (infix operator)ghc Disambiguate {-# UNPACK #-} t (unpack/nounpack pragma)ghcEssentially a wrapper for a RuleBndr GhcPsghcResult of parsing {-# UNPACK #-} or {-# NOUNPACK #-}.ghcReinterpret a type constructor, including type operators, as a data constructor. See Note [Parsing data constructors is hard]ghcCheck whether the given list of type parameters are all type variables (possibly with a kind signature).ghc precedenceghc operators®îĮŮƮǮȮɮʮˮ̮ͮήϮЮѮҮӮԮծ߮ڮޮ֮׮ݮۮܮخٮĮǮƮ®Ůî̮ʮɮȮͮϮήˮЮѮҮӮԮծ߮ڮޮ֮׮ݮۮܮخٮ Safe-Inferred'7 + ghc#16895 Ensure an infix expression's operator is a variable/constructor. Consider this example: $(uInfixE [|1|] [|id id|] [|2|])This infix expression is obviously ill-formed so we use this helper function to reject such programs outright.The constructors  permits should be in sync with  pprInfixExp> in Language.Haskell.TH.Ppr from the template-haskell library.ghccvtOpApp x op y converts op and y' and produces the operator application x op y. The produced tree of infix expressions will be left-biased, provided x is.We can see that cvtOpApp9 is correct as follows. The inductive hypothesis is that cvtOpApp x op y is left-biased, provided x7 is. It is clear that this holds for both branches (of cvtOpApp:), provided we assume it holds for the recursive calls to cvtOpApp. When we call cvtOpApp from cvtl, the first argument will always be left-biased since we have already run cvtl on it.ghccvtOpAppP x op y converts op and y' and produces the operator application x op y. The produced tree of infix patterns will be left-biased, provided x is.See the cvtOpApp+ documentation for how this function works.ghcConvert a Template Haskell ! to an ܇%. To avoid duplicating the logic in  here, we simply reuse  and perform surgery on the ߇ it returns to turn it into an ܇.ghcConstructs an application of a type to arguments passed in a list.ghccvtOpAppT x op y converts op and y' and produces the operator application x op y. The produced tree of infix types will be right-biased, provided y is.See the cvtOpApp+ documentation for how this function works.ghcConvert Maybe Kind to a type family result signature. Used with data families where naming of the result is not possible (thus only kind or no signature is possible).ghcConvert type family result signature. Used with both open and closed type families.ghc0Convert injectivity annotation of a type family.ghcIf passed an empty list of އ/s, this simply returns the third argument (an ߇). Otherwise, return an  using the provided ׇ and ߇.ghcIf passed an empty ., this simply returns the third argument (an ߇). Otherwise, return an  using the provided Շ and ߇.ghcThe location of the returned ߇" if it needs an explicit forallghc#The converted type variable bindersghcThe converted rho typeghc8The complete type, quantified with a forall if necessaryghc%The original Template Haskell contextghcThe location of the returned ߇# if it needs an explicit contextghcThe converted contextghcThe converted tau typeghc8The complete type, qualified with a context if necessary Safe-Inferred 9ghc9Initialise coercion optimiser configuration from DynFlagsghc0Extracts the flag information needed for parsingghc7Initialise Simple optimiser configuration from DynFlags Safe-Inferred ghc!Max #ticks in this simplifier runghcCoercion optimiser optionsɤɤ Safe-Inferred() t Safe-Inferred ' ­ghcAll the sub declarations of a class (that we handle), ordered by source location, with documentation attached if it exists.íghc7Collect docs and attach them to the right declarations.;A declaration may have multiple doc strings attached to it.This is an example.ĭghcExtract constructor argument docs from inside constructor decls.ƭghc;Extract function argument docs from inside top-level decls.ǭghcExtract docs from renamer output. This is monadic since we need to be able to read documentation added from Template Haskell's putDoc, which is stored in .ȭghcExtracts out individual maps of documentation added via Template Haskell's putDoc.ɭghcGo through all class declarations and filter their sub-declarationsʭghc7Filter out declarations that we don't handle in Haddockϭghc%Was this signature given by the user?ѭghcTake a field of declarations from a data structure and create HsDecls using the given constructorҭghcCreate decl and arg doc-maps by looping through the declarations. For each declaration, find its names, its subordinates, and its doc strings.խghc1Extract function argument docs from inside types.֭ghcGet all subordinate declarations inside a declaration, and their docs. A subordinate declaration is something like the associate type or data family of a type class.׭ghcThe top-level declarations of a module that we care about, ordered by source location, with documentation attached if it exists.حghc1Extract function argument docs from inside types.٭ghcTake all declarations except pragmas, infix decls, rules from an .ڭghcUnions together two  ArgDocMaps (or ArgMaps in haddock-api), such that two maps with values for the same key merge the inner map as well. Left biased so unionArgMaps a b prefers a over b.ǭghc  Module headerDocs on top level declarationsDocs on arguments­íĭŭƭǭȭɭʭ˭̭ͭέϭЭѭҭӭԭխ֭׭ح٭ڭǭҭͭԭ̭֭ĭέ˭ŭЭ­ƭӭحխ׭٭íʭɭϭѭȭڭ Safe-Inferred m Safe-Inferred @ghcA mapping from binders to the Ids they were expanded/renamed to.x :-> MultiVal [a,b,c] in rhoiff x's typePrimRep is not a singleton, or equivalently x's type is an unboxed tuple, sum or void.x :-> UnaryVal x'iff x's RepType is UnaryRep or equivalently x's type is not unboxed tuple, sum or void.So x :-> MultiVal [a] in rho means x is represented by singleton tuple.*x :-> MultiVal [] in rho means x is void.INVARIANT: OutStgArgs in the range only have NvUnaryTypes (i.e. no unboxed tuples, sums or voids)ghcExtend the environment, checking the UnariseEnv invariant. The id is mapped to one or more things. See Note [UnariseEnv]ghcMake alternatives that match on the tag of a sum (i.e. generate LitAlts for the tag)ghc:Build a unboxed sum term from arguments of an alternative.3Example, for (# x | #) :: (# (# #) | Int #) we call0mkUbxSum (# _ | #) [ (# #), Int ] [ voidPrimId ] which returns  1#, rubbish ghc/Return a rubbish value for the given slot type.We use the following rubbish values: * Literals: 0 or 0.0 * Pointers: `ghc-prim:GHC.Prim.Panic.absentSumFieldError`(See Note [aBSENT_SUM_FIELD_ERROR_ID] in  GHC.Core.Makeghc:MultiVal a function argument. Never returns an empty list.ghcMultiVal a DataCon argument. Returns an empty list when argument is void. Safe-Inferred ƣghcIf *splitArgType_maybe ty = Just (dc, tys, co) then ,dc @tys @_ex_tys (_args::_arg_tys) :: tc tys and co :: ty ~ tc tys< where underscore prefixes are holes, e.g. yet unspecified.$See Note [Which types are unboxed?].ghcThe information needed to build a pattern for a DataCon to be unboxed. The pattern can be generated from  and  via . The coercion  is for newtype wrappers. If we get DataConPatContext dc tys co for some type ty and *dataConRepInstPat ... dc tys = (exs, flds), thendc exs flds :: T tys@ co :: T tys ~ tyghcDescribes the outer shape of an argument to be unboxed or left as-is Depending on how s is instantiated (e.g., M).ghc/We ran out of strictness info. Leave untouched.ghcThe argument is used strictly or the returned product was constructed, so unbox it. The 4 carries the bits necessary for instantiation with dataConRepInstPat. The [s] carries the bits of information with which we can continue unboxing, e.g. s will be M.ghcIf /splitResultType_maybe n ty = Just (dc, tys, co) then ,dc @tys @_ex_tys (_args::_arg_tys) :: tc tys and co :: ty ~ tc tys> where underscore prefixes are holes, e.g. yet unspecified. dc is the nth data constructor of tc.$See Note [Which types are unboxed?].ghcExactly L3, 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!ghcTries to find a suitable dummy RHS to bind the given absent identifier to.If mk_absent_let _ id == Just wrap, then wrap e will wrap a let binding for id with that RHS around e. Otherwise, there could no suitable RHS be found (currently only happens for bindings of ; representation). Safe-Inferred ghcAn environment storing N$s for local Ids. Puts binders with N in a space-saving IntSet+. See Note [Efficient Top sigs in SigEnv].ghc1Current approximation of signatures for local idsghcTrue only on every first iteration in a fixed-point iteration. See Note [Initialising strictness] in GHC.Core.Opt.DmdAnalghcNeeded when expanding type families and synonyms of product types.ghcAll these Ids have N . Like a VarSet, but more efficient.ghc#Ids that have something other than N.ghcThe abstract semantic function O_O : Expr -> Env -> A from "Constructed Product Result Analysis for Haskell"ghcThe abstract semantic function O_O : Expr -> Env -> A from "Constructed Product Result Analysis for Haskell"ghc CPR transformers for special IdsghcProcess the RHS of the binding for a sensible arity, add the CPR signature to the Id, and augment the environment with the signature as well.ghcReturns an expandable unfolding (See Note [exprIsExpandable] in GHC.Core.Utils8) that has So effectively is a constructor application.ghc2Extend an environment with the (Id, CPR sig) pairsghc;Extend an environment with the CPR sigs attached to the idsghc7Extend an environment with the same CPR sig for all idsghc A version of  for a binder of which we don't see the RHS needed to compute a N (e.g. lambdas and DataAlt field binders). In this case, we can still look at their demand to attach CPR signatures anticipating the unboxing done by worker/wrapper. See Note [CPR for binders that will be unboxed].ghc Produces a N? according to how a strict argument will be unboxed. Examples:A head-strict demand 1L on Int would translate to 1A product demand 1P(1L,L) on  (Int, Bool) would translate to 1(1,)A product demand 1P(1L,L) on  (a , Bool) would translate to 1(,)9, because the unboxing strategy would not unbox the a.ghcexpression to be denoted by a Nghcthe updated expression and its Nghcexpression to be denoted by a Nghcthe updated expression and its NghcCPR type of the scrutineeghccurrent alternativeghcThe analysis environmentghc The functionghcinfo about incoming value argumentsghc"The demand type of the application Safe-Inferred ghc!Initialize RuleOpts from DynFlagsghcThe main rule matching function. Attempts to apply all (active) supplied rules to this instance of an application in a given context, returning the rule applied and the resulting expression if successful.ghc Used to make Y for an 1 defined in the module being compiled. See also YghcFind the "top" free names of several expressions. Such names are either: The function finally being applied to in an application chain (if that name is a GlobalId: see GHC.Types.Var#globalvslocal), orThe TyCon if the expression is a ZThis is used for the fast-match-check for rules; if the top names don't match, the rest can'tghcReport partial matches for rules beginning with the specified string for the purposes of error reportingghcGather all the rules for locally bound identifiers from the supplied bindingsghcruleCantMatch tpl actual returns True only if actual definitely can't match tpl by instantiating tpl. It's only a one-way match; unlike instance matching we don't consider unification.Notice that [_$_] )ruleCantMatch [Nothing] [Just n2] = False Reason: a template variable can be instantiated by a constant Also: )ruleCantMatch [Just n1] [Nothing] = False Reason: a local variable v in the actuals might [_$_]ghc Rule optionsghcRule activation testghc Rule patternghcRules for an IdghcBindings to check inghcResulting check messageghc0Target; can have more elements than the template Safe-Inferred ؤghc5Clone the binders bound by a single-alternative case.ߦߦ Safe-Inferred ڂpghc8Traverses the AST, simply to find all joinrecs and call exitify8 on them. The really interesting function is exitifyRecghcState Monad used inside exitifyghcGiven a recursive group of a joinrec, identifies @exit paths@ and binds them as join-points outside the joinrec.pp Safe-Inferred pghc 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.ghcGiven a binding of in_id to in_rhs , and a fresh name to refer to in_id (out_id>, created from addBinder or addRecBinders), first try to CSE in_rhs>, and then add the resulting (possibly CSE'd) binding to the , so that we attempt to CSE any expressions which are equal to out_rhs.ghcGiven a binder `let x = e`, this function determines whether we should add `e -> x` to the cs_mapghcAdd clones to the substitution to deal with shadowing. See Note [Shadowing] for more details. You should call this whenever you go under a binder.pppp Safe-Inferred EghcCompute the logarithm of a number in the given base, rounded down to the closest integer. The boolean indicates if we the result is exact (i.e., True means no rounding happened, False means we rounded down). The logarithm base is the second argument. ghcSubtract two natural numbers.ghcCompute the exact logarithm of a natural number. The logarithm base is the second argument.ghcDivide two natural numbers.ghcCompute the exact root of a natural number. The second argument specifies which root we are computing.ghcCompute the n-th root of a natural number, rounded down to the closest natural number. The boolean indicates if the result is exact (i.e., True means no rounding was done, False means rounded down). The second argument specifies which root we are computing. //000//000 Safe-Inferred ghcSee Note [Thunk splitting].splitThunk converts the *non-recursive* binding x = e into x = let x' = e in case x' of I# y -> let x' = I# y in x' See comments above. Is it not beautifully short? Moreover, it works just as well when there are several binders, and if the binders are lifted E.g. x = e --> x = let x' = e in case x' of (a,b) -> let x' = (a,b) in x' Here, x' is a localised version of x, in case x is a top-level Id with an External Name, because Lint rejects local binders with External Names; see Note [About the NameSorts] in GHC.Types.Name.How can we do thunk-splitting on a top-level binder? See Note [Thunk splitting for top-level binders]. Safe-Inferred ghcA substitution result.¥åĥťƥǥȥɥʥ˥̥ͥΥϥХѥҥӥԥե֥ץإ٥ڥۥܥݥޥߥݥʥץ٥إեӥǥȥťޥɥڥۥܥԥХΥ֥ߥ˥¥ҥѥƥ̥ͥĥϥå Safe-Inferred hghcBomb-out size for deciding if potential liberatees are too big.ghcUnfolding optionsghcCurrent level The level is incremented when (and only when) going inside the RHS of a (sufficiently small) recursive function.ghcBinds all non-top-level in-scope Ids (top-level and imported things have a level of zero)ghcBinds *only* recursively defined ids, to their own binding group, and *only* in their own RHSsghcEach of these Ids was scrutinised by an enclosing case expression, at a level deeper than its binding level.The first LibCaseLevel is the *binding level* of the scrutinised Id, The second is the level *at which it was scrutinised*. (see Note [Avoiding fruitless liberate-case]) The former is a bit redundant, since you could always look it up in lc_lvl_env, but it's just cached here-The order is insignificant; it's a bag reallyThere's one element per scrutinisation; in principle the same Id may appear multiple times, although that'd be unusual: case x of { (a,b) -> ....(case x of ...) .. }pp Safe-Inferred ¦ƦǦæĦŦȦɦʦ˦̦ͦΦϦЦѦҦӦԦզ֦צ¦ƦǦæĦŦȦɦʦ˦̦ͦΦϦЦѦҦӦԦզ֦צ Safe-Inferred ßghcIs a  known-key?ƟghcThis 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)ǟghcGiven a  lookup its associated ) if it corresponds to a known-key thing.ȟghcGiven a  lookup any associated arbitrary SDoc's to be displayed by GHCi's ':info' command.ghcMaps s to known-key names. The type is UniqFM Name Name to denote that the s used in the domain are s associated with *s (as opposed to some other namespace of s).ghc.Check the known-key names list of consistency.—ėΗŸßğşƟǟȟɟʟ˟ßǟȟƟΗė—Ÿ˟ɟʟğş Safe-Inferred !57893ΟghcCurrent version of .hie files֟ghc0Different contexts under which identifiers exist؟ghc Declarationٟghc/Constraint/Dictionary evidence variable bindingڟghcUsage of evidence variable۟ghc import/exportݟghcPattern 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 Record fieldghc Type variableghcregular variableghc Value bindingghcclass declarationghcconstructor declarationghcdata declarationghctype or data familyghcinstance declarationghcpattern synonymghc type synonymghcEq/Ord instances compare on the converted HieName, as non-exported names may have different uniques after a roundtripghcbound by an implicit variableghc%Bound by some instance of given classghcA direct let bindingghcbound by a pattern matchghcbound by a type signatureghcbound by a hswrapperghc/Mapping from filepaths to the corresponding ASTghcA list of type arguments along with their respective visibilities (ie. is this an argument that would return M for isVisibleArgFlag?).ghcGHC 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$Type-annotated abstract syntax treesghc"The names that this module exportsghc Initial Haskell source file pathghc'Raw bytes of the initial Haskell sourceghcThe module this HIE file is forghcTypes referenced in the .9See Note [Efficient serialization of redundant type info]ghc's get converted into 's before being written into .hie files. See ҟ and  fromHieName6 for logic on how to convert between these two types.ghcA flattened version of Type.9See Note [Efficient serialization of redundant type info]ghctype with constraint: t1 => t2 (see  IfaceDFunTy)ghc(Roughly isomorphic to the original core Type.ghcTypes of imports and exportsghc,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)ghcA node annotationghc name of the AST node constructorghcname of the AST node Typeghc'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 Annotationsghc%All the identifiers and their detailsghc'The Haskell types of this node, if any.ghcSource of node infoghcNodeInfos grouped by sourceghcScope 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 .ghc4Unresolved scopes should never show up in the final .hie file؟ghctype of declarationghcspan of entire bindingٟghc!how did this bind come into beingghc#scope over which the value is boundghcspan of the binding siteݟghcscope in the pattern9 (the variable bound can be used further in the pattern)ghc%rest of the scope outside the patternghcspan of entire bindingghc,whether or not the binding is in an instanceghc#scope over which the value is boundghcspan of entire bindingghc3names of the definitions over which the scope spansghcthe location of the instance/class declaration for the case where the type variable is declared in a method type signature̟͟ΟϟПџҟӟ՟ԟ֟ߟޟݟܟ۟ڟٟן؟ Ο ̟џП֟ߟޟݟܟ۟ڟٟן؟ϟӟ՟ԟ͟ҟ Safe-Inferred !'7ghc>One must contain the other. Leaf nodes cannot contain anythingghcMerge two nodes together.,Precondition and postcondition: elements in  are ordered.ghc/Insert an AST in a sorted list of disjoint Asts¡ghcMerge 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*combines and sorts ASTs using a merge sortghchelps fill in  (with )ghc)return an empty list if this is unhelpfulghchelps fill in  (with )ghc)return an empty list if this is unhelpfulghchelps fill in  (with )ghc)return an empty list if this is unhelpfulghctype to associate with the nodeghchelps fill in  (with )ghc)return an empty list if this is unhelpfulghctype to associate with the node¡áġšơǡȡɡʡˡ̡͡ΡϡСѡҡӡԡա֡סء١ޡݡܡۡڡߡ̡ϡӡ١ޡݡܡۡڡߡˡΡ֡͡ҡԡѡʡס¡Сءáաȡǡġšơɡ Safe-Inferred!ghcLook for any identifiers which occur outside of their supposed scopes. Returns a list of error messages.   Safe-InferredghcPush a TickIt context outwards past applications and cases, as long as this is a non-scoping tick, to let case and application optimisations apply.ghc.A "friendly name" to build the new binder fromghc/This expression satisfies the let/app invariantghc.a "friendly name" to build the new binder fromghc/This expression satisfies the let/app invariantܦݦަަܦݦ Safe-Inferred) Safe-Inferred+ghcOutputs 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])ghcOptions for the demand analysisghcUse strict dictionariesghcEnable strict dictghcTrue on first iteration only See Note [Initialising strictness]ghcWe attach useful (e.g. not M) [3 to top-level bindings that satisfy this function.Basically, we want to know how top-level *functions* are *used* (e.g. called). The information will always be lazy. Any other top-level bindings are boring.;See also Note [Why care for top-level demand annotations?].ghcAnalyse a binding group and its "body", e.g. where it is in scope.It calls a function that knows how to analyse this "body" given an  with updated demand signatures for the binding group (reflecting their idStrictnessInfo) and expects to receive a N in return, which it uses to annotate the binding group with their [.ghc-Annotates uninteresting top level functions () with M!, the rest with the given demand.ghcLet bindings can be processed in two ways: Down (RHS before body) or Up (body before RHS). This function handles the up variant.It is very simple. For let x = rhs in body * Demand-analyse body2 in the current environment * Find the demand, rhs_dmd placed on x by body * Demand-analyse rhs in rhs_dmdThis is used for a non-recursive local let without manifest lambdas (see ).This is the LetUp rule in the paper @Higher-Order Cardinality Analysis@.ghcLet bindings can be processed in two ways: Down (RHS before body) or Up (body before RHS). This function handles the down variant.,It computes a demand signature (by means of +) and uses that at call sites in the body.It is used for toplevel definitions, recursive definitions and local non-recursive definitions that have manifest lambdas (cf. ). Local non-recursive definitions without a lambda are handled with LetUp.This is the LetDown rule in the paper @Higher-Order Cardinality Analysis@.ghcA simple, syntactic analysis of whether an expression MAY throw a precise exception when evaluated. It's always sound to return M<. See Note [Which scrutinees may throw precise exceptions].ghc Recognises types that are * State# RealWorld * Unboxed tuples with a State# RealWorld+ field modulo coercions. This will detect E actions (even post Nested CPR! See T13380e) and user-written variants thereof by their type.ghc dmdAnalRhsSig analyses the given RHS to compute a demand signature for the LetDown rule. It works as follows:0assuming the weakest possible body sub-demand, Llooking at the definition"determining a strictness signatureSince it assumed a body sub-demand of L, the resulting signature is applicable at any call site.ghc.If given the (local, non-recursive) let-bound ,  determines whether we should process the binding up (body before rhs) or down (rhs before body).We use LetDown if there is a chance to get a useful strictness signature to unleash at call sites. LetDown is generally more precise than LetUp if we can correctly guess how it will be used in the body, that is, for which incoming demand the strictness signature should be computed, which allows us to unleash higher-order demands on arguments at call sites. This is mostly the case whenThe binding takes any arguments before performing meaningful work (cf. [;), in which case we are interested to see how it uses them.The binding is a join point, hence acting like a function, not a value. As a big plus, we know *precisely* how it will be used in the body; since it's always tail-called, we can directly unleash the incoming demand of the let binding on its RHS when computing a strictness signature. See [Demand analysis for join points].Thus, if the binding is not a join point and its arity is 0, we have a thunk and use LetUp, implying that we have no usable demand signature available when we analyse the let body.;Since thunk evaluation is memoised, we want to unleash its N of free vars at most once, regardless of how many times it was forced in the body. This makes a real difference wrt. usage demands. The other reason is being able to unleash a more precise product demand on its RHS once we know how the thunk was used in the let body.=Characteristic examples, always assuming a single evaluation:let x = 2*y in x + x => LetUp. Compared to LetDown, we find out that the expression uses y at most once.let x = (a,b) in fst x6 => LetUp. Compared to LetDown, we find out that b is absent.let f x = x*2 in f y => LetDown. Compared to LetUp, we find out that the expression uses y strictly, because we have f4's demand signature available at the call site.>join exit = 2*y in if a then exit else if b then exit else 3*y => LetDown. Compared to LetUp, we find out that the expression uses y' strictly, because we can unleash exit's signature at each call site.For a more convincing example with join points, see Note [Demand analysis for join points].ghcExtend an environment with the strictness IDs attached to the idghc7Demand put on the "body" (important for join points)ghcHow to analyse the "body", e.g. where the binding is in scopeghcThe strictness environmentghc The functionghcThe demand on the functionghcThe demand type of the function in this context Returned DmdEnv includes the demand on this function plus demand on its free variables Safe-Inferred+Iqqqq Safe-Inferred0Ughc!Read in assembly file and processghc4These are the rewrites that the mangler will performghcRewrite a line of assembly source with the given rewrites, taking the first rewrite that applies.ghcThis rewrites .type$ annotations of function symbols to %object+. This is done as the linker can relocate  %functions through the Procedure Linking Table (PLT). This is bad since we expect that the info table will appear directly before the symbol's location. In the case that the PLT is used, this will be not an info table but instead some random PLT garbage.ghcThis rewrites aligned AVX instructions to their unaligned counterparts on x86-64. This is necessary because the stack is not adequately aligned for aligned AVX spills, so LLVM would emit code that adjusts the stack pointer and disable tail call optimization. Both would be catastrophic here so GHC tells LLVM that the stack is 32-byte aligned (even though it isn't) and then rewrites the instructions in the mangler.ghcreplaceOnce match replace bs1 replaces the first occurrence of the substring match in bs with replace.ghcThis function splits a line of assembly code into the label and the rest of the code.UU Safe-Inferred;hghcNo regs read or written to.hghcCommon 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.hghcChecks 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.hghcCheck 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.hghcGive the possible destinations of this jump instruction. Must be defined for all jumpish instructions.hghcMake 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.hghc6An instruction to reload a register from a spill slot.hghcCopy the value in a register to another one. Must work for all register classes.hghc5An instruction to spill a register into a spill slot.hghcChange the destination of this jump instruction. Used in the linear allocator when adding fixup blocks for join points.hghcApply a given mapping to all the register references in this instruction.hghcPretty-print an instructionhghcGet 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.hghc?See if this instruction is telling us the current C stack deltahghcTake the source and destination from this reg -> reg move instruction or Nothing if it's not onehghcHolds 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).hghcthe reg to reload.ghcthe current stack deltaghcthe spill slot to useghc instructionshghcsource registerghcdestination registerhghcthe reg to spillghcthe current stack deltaghcspill slot to useghc instructionshhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh Safe-Inferred <8jjjj Safe-Inferred() Eq a => Show b => c -> Blah f a b @c i dEqA dShowA x = blah c -> Blah $sf = SUBST[a :-> T1, b :-> T2, dEqA :-> dEqT1, dShowA :-> dShow1] (@c i x -> blah)?where dShow1 is a floated binding created by bindAuxiliaryDict.The cases for  below are presented in the same order as this running example. The result of  for this example is as follows:( -- Returned arguments env + [a :-> T1, b :-> T2, dEqA :-> dEqT1, dShowA :-> dShow1] , [x]- RULE helpers , [c, i, d1, d2] , [T1, T2, c, i, d1, d2]- Specialised function helpers , [c, i, x] , [dShow1 = $dfShow dShowT2] , [T1, T2, c, i, dEqT1, dShow1] )ghcBinds a dictionary argument to a fresh name, to preserve sharingghc Construct a  from a Yghc!Identify the free variables of a YghcFlatten a set of "dumped" s, and some other binding pairs, into a single recursive binding.qq Safe-InferredH)ghcUnfolding optionsVUTVUT Safe-InferredHghc7True if it's a bad idea to float bindings into this RHS Safe-InferredU ghcLocate 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").ghcLocate 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.ghcLocate a plugin module requested by the user, for a compiler plugin. This consults the same set of exposed packages as  , unless -hide-all-plugin-packages or -plugin-package are specified.ĢghcConstructs the filename of a .hi file for a given source file. Does not" check whether the .hi file existsǢghcConstructs the filename of a .o file for a given source file. Does not! check whether the .o file existsghcConstructs the filename of a .hie file for a given source file. Does not# check whether the .hie file existsghcGiven a monadic actions this and or_this, first execute this. If the returned T/ is successful, return it; otherwise, execute or_this. If both failed, this function also combines their failure messages in a reasonable way.ghcHelper function for 8: this function wraps an IO action which would look up mod_name in the file system (the home package), and first consults the  cache to see if the lookup has already been done. Otherwise, do the lookup (with the IO action) and save the result in the finder cache and the module location cache (if it was successful.)ghcImplements the search for a module name in the home package only. Calling this function directly is usually *not* what you want; currently, it's used as a building block for the following operations: When you do a normal package lookup, we first check if the module is available in the home module, before looking it up in the package database.When you have a package qualified import with package name "this", we shortcut to the home module.When we look up an exact , if the unit id associated with the module is the current home module do a look up in the home module.Some special-case code in GHCi (ToDo: Figure out why that needs to call this.)ghc.Search for a module in external packages only.ghc2Look up the interface file associated with module mod. This function requires a few invariants to be upheld: (1) the  in question must be the module identifier of the *original* implementation of a module, not a reexport (this invariant is upheld by GHC.Unit.State) and (2) the , must be consistent with the unit id in the . The redundancy is to avoid an extra lookup in the package state for the appropriate config. TTTTTTTTTTTTTTTT¢âĢŢƢǢȢɢ TTTTTTTTTTTTTTTT¢ŢƢâĢǢɢȢ Safe-InferredVghcExtract information from the rename and typecheck phases to produce a dependencies information for the module being compiled.;The second argument is additional dependencies from plugins Safe-Inferred$%`"ghc4Create a set of BCOs that may be mutually recursive.ghcExecute an action of type IO ()ghcExecute an action of type IO [a] , returning s for each of the results.ghcExecute an action of type  IO StringghcExecute an action of type String -> IO Stringghc$Retrieve the target code interpreter0Fails if no target code interpreter is availableghc3Run a command in the interpreter's context. With -fexternal-interpreter, the command is serialized and sent to an external iserv process, and the response is deserialized (hence the Binary constraint). With -fno-external-interpreter' we execute the command directly here.ghcInterpreter uses Dynamic wayghcInterpreter uses Profiling wayghcSend a 0 and receive the response from the iserv processghcloadDLL loads a dynamic library using the OS's native linker (i.e. dlopen() on Unix, LoadLibrary() on Windows). It takes either an absolute pathname to the file, or a relative filename (e.g. "libfoo.so" or "foo.dll"). In the latter case, loadDLL searches the standard locations for the appropriate library.Returns:0Nothing => success Just err_msg => failureghcAllocate and store the given bytes in memory, returning a pointer to the memory in the remote process.ãghc Creates a & that will automatically release the ! when it is no longer referenced.ƣghc#Read a value from the iserv processʣghcSend a Seq message to the iserv process to force a value #2950ˣghcStop the interpreterΣghcGrab a lock on the k and do something with it. Overloaded because this is used from TcM as well as IO.Уghc Convert a  to the value it references directly. This only works when the interpreter is running in the same process as the compiler, so it fails when -fexternal-interpreter is on.ѣghc Convert an  to the value it references directly. This only works when the interpreter is running in the same process as the compiler, so it fails when -fexternal-interpreter is on.ңghc!Send a value to the iserv processghcProcess the result of a Seq or ResumeSeq message. #2950ghcSpawn an external interpreterkkkkkkkkkkkkkkkkkkkkkkkkkk£ãģţƣǣȣɣʣˣ̣ͣΣϣУѣңɣģ̣ʣͣǣȣΣϣˣƣңţãУѣ£ Safe-Inferred 7eghc1Decide whether to add a tick to a binding or not.ghcA let body is treated differently from addTickLHsExprEvalInner above with TickForBreakPoints, because for breakpoints we always want to tick the body, even if it is not a redex. See test break012. This gives the user the opportunity to inspect the values of the let-bound variables.ghcShould we produce X ticks?ghcTickishs that only make sense when their source code location refers to the current file. This might not always be true due to LINE pragmas in the code - which would confuse at least HPC.ghc:Get the next HPC cost centre index for a given centre name Safe-Inferred eRݣޣߣݣޣߣ Safe-Inferredh*rghcon 64bit platforms we pass the first 8 float/double arguments in the xmm registers.rghc&The complete set of machine registers.rghcthese are the regs which we cannot assume stay alive over a C call.rghcTake the class of a register.rghcGet the name of the register with this number. NOTE: fixme, we dont track which "way" the XMM registers are usedrghcregSqueeze_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.rghc3desired stack offset in bytes, positive or negativerrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrssssssssssssssssssssrrssssssssssrrsssrrrrrrrrrrsssssssrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr Safe-Inferredissssssssssssss Safe-Inferredissssssssssssss Safe-InferredksghcReturn 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).sghcReturns the info table associated with the CmmDecl's entry point, if any.ssss Safe-InferredkL qrrrrrrsss sssrrqrrrr Safe-InferredmOsghcConvert a CmmLit to an Imm. Narrow to the width: a CmmInt might be out of range, but we assume that ImmInteger only contains in-range values. A signed value should be fine here.sghc'Create a ImmLit containing this string.sghcAn immediate value. Not all of these are directly representable by the machine. Things like ImmLit are slurped out and put in a data segment instead.ssssssssssssssssssssssssssss Safe-Inferrednusghc4Add an integer offset to the address in an AddrMode.sghcRepresents a memory address in an instruction. Being a RISC machine, the SPARC addressing modes are very regular.ssssssss Safe-Inferredo-sghcEmit a ".incbin" directive+A NULL byte is added after the binary data.sghcEmit a ".string" directivessssssssss Safe-Inferredsghc Return the t for a usghc Return the t of a tsghc Return the t of the tsghc Return the t of the usghcGet LlvmOptions from DynFlagssghcTest if the given t is a floating point typesghc Test if a u is global.sghcTest if the given t is an integersghcTest if the given t is an t constructsghcTest if the given t is an t constructsghcWidth in bits of an t, returns 0 if not applicablesghc"The target architectures word sizesghc"The target architectures word sizesghc0Add a pointer indirection to the supplied type. t and t cannot be lifted.sghc:Remove the pointer indirection of the supplied type. Only t constructors can be lowered.sghcLift a variable to t type.sghcLower a variable of t type.sghcConvert 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].sghcAlias of another variablesghcConstant global variablesghcMutable global variablesghc4A global mutable variable. Maybe defined or externalsghcReturn the value of the ssghcReturns the variable of the ssghcAn LLVM section definition. If Nothing then let LLVM decide the sectionsghcA String in LLVMsghc A type aliassghc1Different calling conventions a function can use.sghcThe 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).sghcThis 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.sghcThis 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.sghcThe GHC-specific  registerised calling convention.sghcAny calling convention may be specified by number, allowing target-specific calling conventions to be used. Target specific calling conventions start at 64.sghc X86 Specific s convention. LLVM includes a specific alias for it rather than just using CC_Ncc.sghc#Different types to call a function.sghc(Normal call, allocate a new stack frame.sghc7Tail call, perform the call in the current stack frame.sghcLlvm cast operations.sghc6Cast between types where no bit manipulation is neededsghc Float extendsghcFloat to signed IntegersghcFloat to unsigned IntegersghcFloat truncatesghcInteger to PointertghcPointer to IntegertghcInteger extend (sign fill)tghcSigned Int to FloattghcInteger truncatetghcUnsigned Integer to FloattghcInteger extend (zero fill)tghcLlvm compare operations.tghcEqual (Signed and Unsigned)tghc Float equaltghcFloat greater than or equaltghcFloat greater thantghcFloat less than or equaltghcFloat less thantghcFloat not equaltghcNot equal (Signed and Unsigned)tghcSigned greater than or equaltghcSigned greater thantghcSigned less than or equaltghcSigned less thantghcUnsigned greater than or equaltghcUnsigned greater thantghcUnsigned less than or equaltghcUnsigned less thantghcLlvm 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#fnattrstghcThis attribute indicates that the inliner should attempt to inline this function into callers whenever possible, ignoring any active inlining size threshold for this caller.tghcThis 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.tghcThis attribute disables prologue / epilogue emission for the function. This can have very system-specific consequences.tghc>This attributes disables implicit floating point instructions.tghcThis attribute indicates that the inliner should never inline this function in any situation. This attribute may not be used together with the alwaysinline attribute.tghcThis attribute indicates that the code generator should not use a red zone, even if the target-specific ABI normally permits it.tghcThis function attribute indicates that the function never returns normally. This produces undefined behavior at runtime if the function ever does dynamically return.tghcThis 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.tghcThis 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.tghcThis 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.tghcThis 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.tghcThis 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.tghcThis 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.tghcAn LLVM Functiontghc!Unique identifier of the functiontghcParameter types and attributestghcType of the returned valuetghc'Indicates if this function uses varargstghc(Function align value, must be power of 2tghc&The calling convention of the functiontghcLinkageType of the functiontghcLinkage 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.tghc 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.tghcThe 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.tghc Alias for t3 but with explicit textual form in LLVM assembly.tghcThe symbol participates in linkage and can be used to resolve external symbol references.tghcGlobal 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.tghc 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.tghcSymbol is private to the module and should not appear in the symbol tabletghcweak 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.tghcLlvm Literal Data.(These can be used inline in expressions.tghcFloating point literaltghc'Refers to an integer constant (i64 42).tghc.Literal NULL, only applicable to pointer typestghc>Undefined value, random bit pattern. Useful for optimisations.tghcVector literaltghc)Llvm binary operators machine operations.tghcArithmetic shift right The most significant bits of the result will be equal to the sign bit of the left operand.tghc1add two integer, floating point or vector values.tghcAND bitwise logical operation.tghc(add two floating point or vector values.tghc divide ...tghc multiply ...tghc remainder ...tghcsubtract two ...tghc3Logical shift right Shift right, filling with zerotghc multiply ..tghcOR bitwise logical operation.tghcsigned integer ..tghc signed ...tghc Left shifttghcsubtract two ...tghc$unsigned integer or vector division.tghc*unsigned integer or vector remainder (mod)tghcXOR bitwise logical operation.tghcLLVM code generator optionstghc+Fill undefined literals with garbage valuestghcTarget platformtghcSplit sectionstghcLLVM Parameter Attributes.Parameter attributes are used to communicate additional information about the result or parameters of a functiontghcThis indicates that the pointer parameter should really be passed by value to the function.tghcThis 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).tghcThis indicates that the pointer parameter can be excised using the trampoline intrinsics.tghcThis indicates that the pointer does not alias any global or any other parameter.tghcThis indicates that the callee does not make any copies of the pointer that outlive the callee itselftghcThis indicates that the pointer parameter specifies the address of a structure that is the return value of the function in the source program.tghcThis 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).tghcThis 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).tghcFunctions can have a fixed amount of parameters, or a variable amount.tghcLlvm Static Data.These represent the possible global level variables and constants.tghcConstant addition operationtghcPointer to Pointer conversiontghcA comment in a static sectiontghcPointer to Integer conversiontghcA static arraytghc#A static variant of a literal valuetghcA pointer to other datatghcDefines a static stghcA static structure typetghcConstant subtraction operationtghcTruncatetghcFor uninitialised datatghc Llvm Typestghc A type aliastghc An array of ttghc64 bit floating pointtghc32 bit floating pointtghc128 bit floating pointtghc 80 bit (x86 only) floating pointtghc3Function type, used to create pointers to functionstghc&An integer with a given width in bits.tghcA u can represent a label (address)tghc LLVM MetadatatghcA pointer to a ttghcPacked structure typetghcUnpacked structure typetghc A vector of ttghc Void typeughcLLVM VariablesughcVariables with a global scope.ughcA constant variableughc,Variables local to a function or parameters.ughcNamed local variables. Sometimes we need to be able to explicitly name variables (e.g for function arguments).ssssssssssssssssssssssssssssssssssssssssssssssssssssssssttttttssssssttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttuuuuussssssttttttttttttttttssssssssuuuuuttttttttttttttttttttttttsssssssssssssssssssssssssttttttttttttttttttttttttttttttttttssssssssssttttttttttttttttttttttttttttttttttttttttttttttttsttttttssssssssssss Safe-InferredughcAssociates some metadata with a specific label for attaching to an instruction.ughcMetadata declarations. Metadata can only be declared in global scope.ughcNamed metadata. Only used for communicating module information to LLVM. ('!name = !{ [!] }' form).ughcMetadata node declaration. ('!0 = metadata !{ }' form).ughcLLVM metadata expressionsughc)A reference to an un-named metadata node. uuuuuuuuuuuu uuuuuuuuuuuu Safe-Inferred;ughc'LLVM atomic operations. Please see the  atomicrmw instruction in the LLVM documentation for a complete description.ughcA block of LLVM code.ughcThe code label for this blockughcA list of LlvmStatement's representing the code for this block. This list must end with a control flow statement.ughc Block labelsughcLlvm Expressionsughc(Atomic load of the value at location ptrughcAllocate amount * sizeof(tp) bytes on the stack * tp: LlvmType to reserve room for * amount: The nr of tp's which must be allocatedughcInline 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.ughcAtomic read-modify-write operation * op: Atomic operation * addr: Address to modify * operand: Operand to operation * ordering: Ordering requirementughcCall 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.ughcCall 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.ughcCast 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 toughcCompare-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.ughcPerform a compare operation on the operands left and right * op: operator * left: left operand * right: right operandughcExtract a scalar element from a vector * val: The vector * idx: The index of the scalar within the vectorughcExtract a scalar element from a structure * val: The structure * idx: The index of the scalar within the structure Corresponds to "extractvalue" instruction.ughcNavigate 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.ughcInsert a scalar element into a vector * val: The source vector * elt: The scalar to insert * index: The index at which to insert the scalarughcPerform the machine operator op on the operands left and right * op: operator * left: left operand * right: right operandughcLoad the value at location ptrughc/A LLVM expression with metadata attached to it.ughcAllocate amount * sizeof(tp) bytes on the heap * tp: LlvmType to reserve room for * amount: The nr of tp's which must be allocatedughcMerge 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.ughcAn LLVM FunctionughcThe functions argumentsughcThe function attributes.ughcThe body of the functions.ughc(The signature of this declared function.ughc Prefix dataughc%The section to put the function into,ughc6An LLVM Module. This is a top level container in LLVM.ughcLLVM Alias type definitions.ughc/Comments to include at the start of the module.ughc&LLVM Functions defined in this module.ughcLLVM Functions used in this module but defined in other modules.ughc*Global variables to include in the module.ughcLLVM meta data.ughcLlvm StatementsughcAssign an expression to a variable: * dest: Variable to assign to * source: Source expressionughc!Always branch to the target labelughcBranch 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 falseughcComment Plain comment.ughcRaise an expression to a statement (if don't want result or want to use Llvm unnamed values.ughcMemory fence operationughc.A LLVM statement with metadata attached to it.ughcSet a label on this position. * name: Identifier of this label, unique for this moduleughcA nop LLVM statement. Useful as its often more efficient to use this then to wrap LLvmStatement in a Just or [].ughcReturn a result. * result: The variable or constant to returnughcStore 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 inughcMultiway 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.ughcAn instruction for the optimizer that the code following is not reachableughcLLVM ordering types for synchronization purposes. (Introduced in LLVM 3.0). Please see the LLVM documentation for a better description.ughc,Acquire + Release synchronization operation.ughc"Acquire synchronization operation.ughc?A single total order for operations at a single address exists.ughc"Release synchronization operation.ughc&Full sequential Consistency operation.ughc(Some partial order of operations exists.uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu Safe-InferrednvghcPrint a literal value. No type.vghcPrint out an LLVM type alias.vghc&Print out a list of LLVM type aliases.vghc;Print out a comment, can be inside a function or on its ownvghcPrint out a multi-line comment, can be inside a function or on its ownvghc Print out a function definition.vghcPrint out a function declaration. Declarations define the function type but don't define the actual body of the function.vghc)Print out a list of function declaration.vghc)Print out a list of function definitions.vghc.Print out a global mutable variable definitionvghc7Print out a list of global mutable variable definitionsvghc&Print out an LLVM metadata definition.vghc"Print out a list of LLVM metadata.vghcPrint out a whole LLVM module.vghc)Return the variable name or value of the u* in Llvm IR textual representation (e.g. @x, %y or 42).vghc)Return the variable name or value of the u* in a plain textual representation (e.g. x, y or 42).ghc'Print out a function definition header.ghc Print out a list of LLVM blocks.ghcPrint out an LLVM block. It must be part of a function definition.ghcPrint out an LLVM block label.ghcPrint out an LLVM statement.ghcPrint out an LLVM expression.ghcShould always be a function pointer. So a global var of function type (since globals are always pointers) or a local var of pointer function type.ghc Blank line.ghcExclamation point.vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv Safe-Inferredssssssssssssssssssssssssssssssssssssssssssssssssssssttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuvvvvvvvvvvvvvvvvvvtttttsuuuuuuuuuuuuuuuutttttttttutuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuttttttttttuuuuuuuuuuuuuuuuuuussssssssssttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttsssssssttttttuuuuutttttttttttttttttttttttttttttttttttssssssssssssssssssssuuuuuuuuuuuussssssssssssssvvvvvvvvvvvvvvvvvv Safe-Inferred` vghc>A list of STG Registers that should always be considered alivevghcId values The  node is the root (there can be more than one) of the TBAA hierarchy and as of LLVM 4.0 should *only* be referenced by other nodes. It should never occur in any LLVM instruction statement.vghcGet the correct TBAA metadata information for this register typevghcId values The  node is the root (there can be more than one) of the TBAA hierarchy and as of LLVM 4.0 should *only* be referenced by other nodes. It should never occur in any LLVM instruction statement.vghc;Get the LlvmVar function argument storing the real registervghc;Get the LlvmVar function variable storing the real registervghcId values The  node is the root (there can be more than one) of the TBAA hierarchy and as of LLVM 4.0 should *only* be referenced by other nodes. It should never occur in any LLVM instruction statement.vghcId values The  node is the root (there can be more than one) of the TBAA hierarchy and as of LLVM 4.0 should *only* be referenced by other nodes. It should never occur in any LLVM instruction statement.vghc'STG Type Based Alias Analysis hierarchyvghcThe TBAA metadata identifiervghcId values The  node is the root (there can be more than one) of the TBAA hierarchy and as of LLVM 4.0 should *only* be referenced by other nodes. It should never occur in any LLVM instruction statement.ghcId values The  node is the root (there can be more than one) of the TBAA hierarchy and as of LLVM 4.0 should *only* be referenced by other nodes. It should never occur in any LLVM instruction statement. vvvvvvvvvvv vvvvvvvvvvv Safe-InferredvghcConvert a Cmm type to a Format.vghc#Get the float format of this width.vghcGet the Width of a Format.vghc%Get the integer format of this width.vghc4Check if a format represents a floating point value.vghc-Check if a format represent an integer value.vvvvvvvvvvvvvvvvvvvvvvvvvvvv Safe-InferredAvvvv Safe-InferredNvghc7All the regs that could possibly be returned by argRegsvghcAll the allocatable registers in the machine, including register pairs.vghcProduce the second-half-of-a-double register given the first half.All the regs that the register allocator can allocate to, with the fixed use regs removed.vghcThe registers to place arguments for function calls, for some number of arguments.vghc.Some specific regs used by the code generator.vghc.Some specific regs used by the code generator.vghc.Some specific regs used by the code generator.vghc.Some specific regs used by the code generator.vghc.Some specific regs used by the code generator.vghc.Some specific regs used by the code generator.vghc.Some specific regs used by the code generator.vghc"Get the regno for this sort of regvghc.Some specific regs used by the code generator.vghc.Some specific regs used by the code generator.vghc.Some specific regs used by the code generator.vghc.Some specific regs used by the code generator.vghc"Get the regno for this sort of regvghc"Get the regno for this sort of regvghc"Get the regno for this sort of regvghc$Make a virtual reg with this format.vghc.Some specific regs used by the code generator.vghc.Some specific regs used by the code generator.vghc"Get the regno for this sort of regvghc8Get the standard name for the register with this number.vghc.Some specific regs used by the code generator.vghcregSqueeze_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.vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv Safe-InferredvghcGet an address relative to the frame pointer. This doesn't work work for offsets greater than 13 bits; we just hope for the bestvghcThe maximum number of spill slots available on the C stack. If we use up all of the slots, then we're screwed.Why do we reserve 64 bytes, instead of using the whole thing?? -- BL 20090215vghcGet an AddrMode relative to the address in sp. This gives us a stack relative addressing mode for volatile temporaries and for excess call arguments.vghc=Convert a spill slot number to a *byte* offset, with no sign.vghc+stack offset in words, positive or negativevvvvvvvv Safe-InferredBvghcGrab a register.vghc)Get all the free registers of this class.vghcThe initial set of free regs.vghc1A reg map where no regs are free to be allocated.vghcRelease a register from allocation. The register liveness information says that most regs die after a C call, but we still don't want to allocate to some of them. vvvvvvvvv vvvvvvvvv Safe-InferredIvghcregSqueeze_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.0vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvwwwwwwwwwwwwww0vvvvvwwwwwwwwwwwwwwvvvvvvvvvvvvvvvvvvvvvvvvvvvvv Safe-Inferred5wwwwwwwwwwwwww Safe-InferredwghcLanguage ID used for Haskell.wghc.Mapping of registers to DWARF register numberswghc2Virtual register number to use for return address.wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww Safe-InferredWwghcregSqueeze_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.wwwwwwwwwwwwwwwwxxxxxxwwwwwwwwwwwwxxxxxxwwwwwwwwww Safe-Inferredxxxxxxxxxxxx Safe-InferredxghcCalculate the effective address which would be used by the corresponding fpRel sequence.xghcAn instruction that will cause the one after it never to be exectutedxghc)Make an unconditional branch instruction.xghc Make a spill reload instruction.xghcMake a reg-reg move instruction. On SPARC v8 there are no instructions to move directly between floating point and integer regs. If we need to do that then we have to go via memory.xghcMake a spill instruction. On SPARC we spill below frame pointer leaving 2 words/spillxghc+Code to shift the stack pointer by n words.xghcApply a given mapping to tall the register references in this instruction.xghcregUsage returns the sets of src and destination registers used by a particular instruction. Machine registers that are pre-allocated to stgRegs are filtered out, because they are uninteresting from a register allocation standpoint. (We wouldn't want them to end up on the free list!) As far as we are concerned, the fixed registers simply don't exist (for allocation purposes, anyway).xghcCheck if a RI represents a zero value. - a literal zero - register %g0, which is always zero.xghc?See if this instruction is telling us the current C stack deltaxghcCheck 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.xghcSPARC instruction set. Not complete. This is only the ones we need.xghcRegister or immediateghcInteresting regs are virtuals, or ones that are allocatable by the register allocator.xghcregister to load intoghccurrent stack deltaghcspill slot to usexghcregister to spillghccurrent stack deltaghcspill slot to use=vxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxvxxxxxxxxxxxx Safe-Inferredxxxxxxxxxxxxxxxx Safe-Inferredfxghc9Expand out synthetic instructions in this top level thingghc/Expand out synthetic instructions in this blockghcExpand out some instructionsghcIn the SPARC instruction set the FP register pairs that are used to hold 64 bit floats are referred to by just the first reg of the pair. Remap our internal reg pairs to the appropriate reg.-For example: ldd [%l1], (%f0 | %f1)'gets mapped to ldd [$l1], %f0ghc$The high partner for this float reg.xx Safe-InferredxghcGrab the Reg for a CmmRegxghc&Change the format field in a Register.xghc,Holds code that references a memory address.xghca.k.a "Register64" Reg is the lower 32-bit temporary which contains the result. Use getHiVRegFromLo to find the other VRegUnique.Rules of this simplified insn selection game are therefore that the returned Reg may be modifiedxghc#Condition codes passed up the tree.xghcxs 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.xghcCode to produce a result into a register. If the result must go in a specific register, it comes out as Fixed. Otherwise, the parent can decide which register to put it in. xxxxxxxxxxxxx xxxxxxxxxxxxx Safe-InferredqxghcArmv6 | 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 | '---------------------------------------------------------------------------'xxxxxxxxxxxxxxxx Safe-Inferred=xghc0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 42 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | |== General Purpose registers ==================================================================================================================================| |  ----argument passing ------------- | IR |  -------tmp registers -------- | IP0| IP1| PL |  -------------------callee saved ------------ | FP | LR | SP | |  ------free registers -------------------------------------------------------------------- | BR | Sp | Hp | R1 | R2 | R3 | R4 | R5 | R6 | SL | -- | -- | -- | |== SIMD/FP Registers ==========================================================================================================================================| |  ----argument passing ------------- |  -- callee saved (lower 64 bits) --- |  '---------------------------------------#caller saved ---------------------- | |  ------free registers -------------+ | F1 | F2 | F3 | F4 | D1 | D2 | D3 | D4 |  ------free registers ----------------------------------------------------- | '---------------------------------------------------------------------------------------------------------------------------------------------------------------' IR: Indirect result location register, IP: Intra-procedure register, PL: Platform register, FP: Frame pointer, LR: Link register, SP: Stack pointer BR: Base, SL: SpLimyghcChecks 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.yghcChecks 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.yghc reg move instruction or Nothing if it's not oneyghc;ADC Operand Operand Operang -- rd = rn + rm + C | ADCS ...yghcADDS Operand Operand Operand -- rd = rn + rm | ADR ... | ADRP ...yghcMADD ... | MNEG ...yghc,MOVN Operand Operand | MOVZ Operand Operandzghc,SXTW Operand Operand | SXTX Operand OperandzghcUMADDL ... -- Xd = Xa + Wn  Wm | UMNEGL ... -- Xd = - Wn  Wm | UMSUBL ... -- Xd = Xa - Wn  Wm | UMULH ... -- Xd = (Xn  Xm)_127:64 | UMULL ... -- Xd = Wn  Wmzghc6NEGS ... | NGC ... | NGCS ... | SBC ... | SBCS ...zghcSMADDL ... | SMNEGL ... | SMSUBL ... | SMULH ... | SMULL ...zghcSUBS ...zghcGet 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]xxxxxxxxxxxxxxxxxyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyzzzzzzzzzzzzzzzyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyzzzyyyyyyyyyyzzzzzzzzzzzzzzzzzyyyyyyxyyyyyyyyyyyyyxyzzzzzzzzzzzzzzzyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyzzzyyyyyyyyyyzzzzyyyyyyyyyzzzzzyzzzzzzzzyyyyyxyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyxxxxyyyyyyyxxxxxxxxxxyyyyyyyyyyyyyy Safe-Inferred;zzzzzzzzzzzz Safe-Inferred~ghc7Print appropriate alignment for the given section type.ghcPrint section header and appropriate alignment for that section.This one will emit the header:.section .text .balign 8ghcOutput the ELF .size directive.zzzz Safe-Inferred()"$ zghc1Extract all tick annotations from the given blockzghcUseful for creating an index into an array, with a statically known offset. The type is the element type; used for making the multiplierzghcUseful for creating an index into an array, with an unknown offset.zghc*Load a naturally-aligned non-pointer word.zghc$Load a naturally-aligned GC pointer.zghcWe make a top-level decl for the string, and return a label pointing to itzghcBuild a data-segment data blockzghcWe make a top-level decl for the embedded binary file, and return a label pointing to itzghcReturns 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].{ghcReturns 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.{ghclike {(, but the entry block always comes first{ghcLike {, 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. -GBMzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz{{{{{{{{{{{{{{z{{{z{zzzzzzzzz{zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz{z{zzzzzzzzzz{{zzzz{z{z{{zz{zz Safe-Inferred $%( {ghcAssumes that arguments have one PrimRep, which holds after unarisation. See Note [Post-unarisation invariants]{ghcAssumes that Ids have one PrimRep, which holds after unarisation. See Note [Post-unarisation invariants]{ghcAssumes that the argument has one PrimRep, which holds after unarisation. See Note [Post-unarisation invariants]{ghcUsed 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.{ghcUsed 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$Assumes that there is precisely one ; of the type. This assumption holds after unarise. See Note [Post-unarisation invariants]{ghcReturn the tag in the low order bits of a variable bound to this LambdaForm{ghc Convert from { to q.{ghcLoopification enabled (cf -floopification){ghcPlatform profile{ghcTicky profiling enabled (cf -ticky)ghcthunkEntryLabel is a local help function, not exported. It's used from getCallMethod.::NN{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{::{{{{{{{{{{NN{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{ Safe-Inferred*{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{ Safe-Inferred()+{ghcFixup global registers so that they assign to locations within the RegTable if they aren't pinned for the current target.{ghcWe 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.{{{{{{{{{{ Safe-Inferred7>8>{ghc=Here we take a global variable definition, rename it with a $def, suffix, and generate the appropriate alias.{ghc2Check whether a register is allocated on the stack{ghc)Translate a basic CmmType to an LlvmType.{ghcDumps the document if the corresponding flag has been set by the user{ghc3Insert variables or functions into the environment.{ghc1Lookup variables or functions in the environment.{ghc7Generate 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!{ghcCreate/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.{ghcGet LLVM options{ghc/Get the LLVM version we are generating code for{ghc1Allocate a new global unnamed metadata identifier{ghcGet target platform{ghc#Gets metadata node for given unique{ghc,Return all variables marked as "used" so far{ghcHere 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.{ghcLifting of IO actions. Not exported, as we want to encapsulate IO.{ghcDerive the definition label. It has an identified structure type.{ghcAlignment to use for functions{ghcA Function's arguments{ghcSection to use for a function{ghcLlvm Function signature|ghc#Llvm Function type for Cmm function|ghc Alignment to use for into tables|ghc Pointer width|ghcLlvm standard fun attributes|ghc(Set a register as allocated on the stack|ghcMarks a variable as "used"|ghc=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.Prints the given contents to the output handle|ghcGet initial Llvm environment.|ghc%Sets metadata node for a given unique|ghcPretty print a h.|ghcThe (inclusive) lower bound on the LLVM Version that is currently supported.|ghcThe (not-inclusive) upper bound bound on the LLVM Version that is currently supported.|ghcConvert a list of types to a list of function parameters (each with no parameter attributes)|ghc3Insert variables or functions into the environment.|ghc1Lookup variables or functions in the environment.|ghc*Translate a Cmm Float Width to a LlvmType.|ghc(Translate a Cmm Bit Width to a LlvmType.|ghc9Clear variables from the environment for a subcomputation|ghc#Global registers live on proc entry|ghc.Top level LLVM Data (globals and type aliases)|ghcThe Llvm monad. Wraps LlvmEnv state as well as the IO monad|ghcUnresolved code. Of the form: (data label, data type, unresolved data)|ghcAn 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 LLVM versionghcLLVM backend optionsghc Dynamic flagsghcLoggerghc Output bufferghcMask for creating unique valuesghcSupply of fresh metadata IDsghcGlobal metadata nodesghc"Global functions so far, with typeghc;Globals that we had to alias, see [Llvm Forward References]ghc'Pointers to be added to llvm.used (see cmmUsedLlvmGens)ghc!Local variables so far, with typeghc9Non-constant registers (alloca'd in the function prelude)ghcGHC Call Convention for LLVMghcGet environment (internal)ghcModify environment (internal)ghcSaves that at some point we didn't know the type of the label and generated a reference to a type variable instead7R{{{{{{{{{{{{{{{{{{{{{{||||||||||||||||||||||||||||||||7||||||||||||||||||||{{{{R{||{{{{{|{{{|||{{|{|||{|{|{{{{ Safe-InferredB(|ghc8Run the linker with some arguments and return the output|ghc
|||||||| Safe-Inferred()Ojj|||| Safe-Inferred()e-:|ghc)Top-level of the LLVM proc Code generatorghcA more convenient way of accumulating LLVM statements and declarations.ghcValues which can be passed to 6 to configure its behaviour in certain circumstances.Currently just used for determining if a comparison should return a boolean (i1) or a word. See Note [Literals and branch conditions].ghcAn expression conversion return data: * LlvmVar: The var holding the result of the expression * LlvmStatements: Any statements needed to evaluate the expression * LlvmCmmDecl: Any global data needed for this expressionghcGenerate code for a list of blocks that make up a complete procedure. The first block in the list is expected to be the entry point.ghcGenerate code for one blockghc.Convert a list of CmmNode's to LlvmStatement'sghc.Convert a CmmStmt to a list of LlvmStatement'sghcWrapper function to declare an instrinct function by function typeghc= 3.0ghc Insert a , unless the target platform is in the provided list of exceptions (where no code will be emitted instead).ghc Foreign CallsghcGenerate a call to an LLVM intrinsic that performs arithmetic operation with overflow bit (i.e., returns a struct containing the actual result of the operation and an overflow bit). This function will also extract the overflow bit and zero-extend it (all the corresponding Cmm PrimOps represent the overflow "bit" as a usual Int# or Word#).ghcA helper function for genCallWithOverflow that handles generating the call to the LLVM intrinsic and extracting the result from the struct to LlvmVars.ghc(Create a function pointer from a target.ghc(Create a function pointer from a target.ghcConversion of call arguments.ghcConversion of call arguments.ghc6Cast a collection of LLVM variables to specific types.ghc6Cast a collection of LLVM variables to specific types.ghcCast an LLVM variable to a specific type, panicing if it can't be done.ghc:Decide what C function to use to implement a CallishMachOpghcTail function callsghcCmmAssign operationWe use stack allocated variables for CmmReg. The optimiser will replace these with registers when possible.ghcCmmStore operationghcCmmStore operation This is a special case for storing to a global register pointer offset such as I32[Sp+8].ghcCmmStore operation Generic case. Uses casts and pointer arithmetic if needed.ghcUnconditional branchghcConditional branchghcGenerate call to llvm.expect.x intrinsic. Assigning result to a new var.ghc Switch branchghc'i1 type expected (condition scrutinee).ghcWord type expected (usual).ghcConvert a CmmExpr to a list of LlvmStatements with the result of the expression being stored in the returned LlvmVar.ghcHandle CmmMachOp expressionsghcHandle CmmMachOp expressions This is a specialised method that handles Global register manipulations like 'Sp - 16', using the getelementptr instruction.ghcHandle CmmMachOp expressions This handles all the cases not handle by the specialised genMachOp_fast.ghcHandle CmmLoad expression.ghcHandle CmmLoad expression. This is a special case for loading from a global register pointer offset such as I32[Sp+8].ghcHandle Cmm load expression. Generic case. Uses casts and pointer arithmetic if needed.ghcHandle CmmReg expression. This will return a pointer to the stack location of the register. Throws an error if it isn't allocated on the stack.ghcReturn the value of a given register, as well as its type. Might need to be load from stack.ghc$Allocate a local CmmReg on the stackghcGenerate code for a literalghc=Find CmmRegs that get assigned and allocate them on the stackAny register that gets written needs to be allocated on the stack. This avoids having to map a CmmReg to an equivalent SSA form and avoids having to deal with Phi node insertion. This is also the approach recommended by LLVM developers.On the other hand, this is unnecessarily verbose if the register in question is never written. Therefore we skip it where we can to save a few lines in the output and hopefully speed compilation up a bit.ghcFunction epilogue. Load STG variables to use as argument for call. STG Liveness optimisation done here.ghc/Get a function pointer to the CLabel specified.This is for Haskell functions, function type is assumed, so doesn't work with foreign functions.ghcCreate a new local varghc0Execute an expression, assigning result to a varghcExpand CmmRegOffghc0Convert a block id into a appropriate Llvm labelghcCreate Llvm int Literalghc1Convert int type to a LLvmVar of word or i32 sizeghcError functionsghc Returns TBAA meta data by uniqueghc)Returns TBAA meta data for given registerghc'Return element of single-element list; % if list is not a single-element listghcPrimOpghcWidth of the operands.ghcActual arguments.ghc"LLVM types of the returned struct.|| Safe-Inferred !'f|ghc$Top-level of the LLVM Code generatorghc8Do LLVM code generation on all these Cmms data sections.ghcComplete LLVM code generation phase for a single top-level chunk of Cmm.ghcGenerate meta data nodesghc'Marks variables as used where necessaryU||||||U Safe-Inferred ()7ighcThe result type of most operations is determined by the operands. However, there are a few exceptions: particularly operations which might get promoted to a signed result. For these we explicitly cast the result.ghcProduce a list of word sized literals encoding the given list of is.ghcPrint in C hex format Examples:5114 :: W32 ===> ((StgWord32)0x13faU) (-5114) :: W32 ===> ((StgWord32)(-0x13faU))We use casts to support types smaller than `unsigned int`; C literal suffixes support longer but not shorter types.|| Safe-Inferred mW|ghcPretty print a data item.|ghc0Pretty print a format for an instruction suffix.|ghc Pretty print an immediate value.|ghcPretty print an instruction.ghcPretty print a register.ghcPretty print a register name, based on this register number. The definition has been unfolded so we get a jump-table in the object code. This function is called quite a lot when emitting the asm file..ghcPretty print a format for an instruction suffix. eg LD is 32bit on sparc, but LDD is 64 bit.ghcPretty print a condition code.ghcPretty print an address mode.ghcPretty print a section / segment header. On SPARC all the data sections must be at least 8 byte aligned incase we store doubles in them.ghc7Print appropriate alignment for the given section type.ghcPretty print a RIghc#Pretty print a two reg instruction.ghc%Pretty print a three reg instruction.ghc1Pretty print an instruction of two regs and a ri.|||||||||||||| Safe-Inferredm|ghcEnforce intra-block invariants.|| Safe-Inferred 0+"|ghc5Adds a new edge, overwrites existing edges if present|ghcSometimes 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|ghcInsert 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.|ghcAdds a edge with the given weight to the cfg If there already existed an edge it is overwritten. `addWeightEdge from to weight cfg`|ghcAdjust the weight between the blocks using the given function. If there is no such edge returns the original map.}ghc5Returns a unordered list of all edges without weights}ghcFilter the CFG with a custom function f. Paramaeters are `f from to edgeInfo`}ghcGenerate weights for a Cmm proc based on some simple heuristics.}ghc4Destinations from bid ordered by weight (descending)}ghc1Get successors of a given node with edge weights.}ghc4Get successors of a given node without edge weights.}ghc!Is this block part of this graph?}ghc/Returns a unordered list of all edges with info}ghcDetermine 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.}ghcDetermine loop membership of blocks based on SCC analysis This is faster but only gives yes/no answers.}ghcWe 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.}ghcConvenience function, generate edge info based on weight not originating from cmm.}ghcCheck 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.}ghcSet the weight between the blocks to the given weight. If there is no such edge returns the original map.}ghcA 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.}ghcInformation about edges}ghcCan we trace back a edge to a specific Cmm Node or has it been introduced during assembly codegen. We use this to maintain some information which would otherwise be lost during the Cmm <-> asm transition. See also Note [Inverting Conditional Branches]}ghcCareful! Since we assume there is at most one edge from A to B the Eq instance does not consider weight.}ghcEdges are sorted ascending pointwise by weight, source and destinationghc%Unknown, but not heap or stack check.ghcHeap or stack checkghcList of back edgesghcBlockId -> LoopLevel mappingghc*(backEdge, loopBody), body includes headerghcCombination of target node id and information about the branch we are looking at.ghc8Invariant: The edge **must** exist already in the graph.ghcModify branch weights based on educated guess on patterns GHC tends to produce and how they affect performance.6Most importantly we penalize jumps across info tables.ghc5Convert block-local branch weights to global weights.ghcUpdate branch weights based on certain heuristics. See Note [Static Branch Prediction] TODO: This should be combined with optimizeCFG.||||||}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}.}}}}}}}}}}}}}}}}}}||||}}}|}|}}}}}}}}}}}}}}}}}} Safe-Inferred 7 }ghcConvert a NatCmmDecl to a LiveCmmDecl, with liveness information}ghcErase Delta instructions.}ghc7map a function across all the basic blocks in this code}ghcmap a function across all the basic blocks in this code (monadic version)}ghcmap a function across all the basic blocks in this code (monadic version)}ghcMap over instruction type in }}ghcPatch 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.}ghcPatch registers in this LiveInstr, including the liveness information.}ghcPretty-print a }}ghcIf 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.}ghcSlurp 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.}ghcFor 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.}ghc4Strip away liveness information, yielding NatCmmDecl}ghcStrip away liveness information from a basic block, and make real spill instructions out of SPILL, RELOAD pseudos along the way.}ghcThe register allocator also wants to use SPILL/RELOAD meta instructions, so we'll keep those here.}ghcA real machine instruction}ghc!reload this reg from a stack slot}ghcspill this reg to a stack slot}ghc(A basic block with liveness information.}ghc5A top level thing which carries liveness information.}ghcStash regs live on entry to each basic block in the info part of the cmm code.}ghc)An instruction with liveness information.}ghcLiveness 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?registers born in this instruction (written to for first time).}ghc=registers that died because they were read for the last time.}ghc=registers that died because they were clobbered by something.}ghc$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]ghcCheck ordering of Blocks The computeLiveness function requires SCCs to be in reverse dependent order. If they're not the liveness information will be wrong, and we'll get a bad allocation. Better to check for this precondition explicitly or some other poor sucker will waste a day staring at bad assembly code..ghcComputing livenessOn entry, the SCCs must be in "reverse" order: later blocks may transfer control to earlier ones only, else .The SCCs returned are in the *opposite* order, which is exactly what we want for the next pass.ghc:Annotate a basic block with register liveness information.ghcCalculate liveness going forwards, filling in when regs are bornghcCalculate liveness going backwards, filling in when regs die, and what regs are live across each instructionghcSCCs of blocks that we're about to run the liveness determinator on.ghc$BlockIds that fail the test (if any)%}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}%}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}} Safe-Inferred$%}ghcAn initial empty }}ghc1Find the register mapping for a specific BlockId.}ghc?Lookup which register a virtual register was first assigned to.}ghc'Get the reg numbers stored in this Loc.}ghc/Add new register mappings for a specific block.}ghcUsed 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.}ghcWhere 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.}ghc0vreg is held in both a register and a stack slot}ghcvreg is held in a stack slot}ghcvreg is in a register}ghcThe register allocator state}ghc assignment of temps to locations}ghcthe current mapping from basic blocks to the register assignments at the beginning of that block.}ghc#Native code generator configuration}ghccurrent stack delta}ghc<(from,fixup,to) : We inserted fixup code between from and to}ghcfree machine registers}ghcRecord 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.}ghcfree stack slots for spilling}ghc?unique supply for generating names for join point fixup blocks.}ghc>Used to carry interesting stats out of the register allocator.}ghc<(from,fixup,to) : We inserted fixup code between from and to}ghcReasons why instructions might be inserted by the spiller. Used when generating stats for -ddrop-asm-stats.}ghcvreg was spilled to a slot so we could use its current hreg for another vreg}ghc-vreg was moved because its hreg was clobbered~ghc,reg-mem move inserted during join to targets~ghc,reg-reg move inserted during join to targets~ghc!vreg was loaded from a spill slot}}}}}}}}}}}}}}}}}}}}}}}}}}}}~~~}}}}}}}}}}}}}~~~}}}}}}}}}}}}}}} Safe-Inferred@~ghcBuild a map of how many times each reg was alloced, clobbered, loaded etc.~ghc+Count reg-reg moves remaining in this code.~ghcPretty print some RegAllocStats~~~~~~ Safe-Inferred7~ghc'Get native code generator configuration~ghc blocks which reload from this slot) used to decide if whether slot spilled to will ever be reloaded from on this path.ghc6Spills and reloads cleaned each pass (latest at front)ghc>Spills and reloads that have been cleaned in this pass so far.ghcThe identification number of a spill slot. A value is stored in a spill slot when we don't have a free register to hold it.ghc$Construct the initial cleaner state.ghcDo one pass of cleaning.ghcClean out unneeded reload instructions, while walking forward over the code.ghc'Clean out unneeded reload instructions.Walking forwards across the code On a reload, if we know a reg already has the same value as a slot then we don't need to do the reload.ghc?Try and rewrite a reload instruction to something more pleasingghcClean out unneeded spill instructions, while walking backwards over the code.If there were no reloads from a slot between a spill and the last one then the slot was never read and we don't need the spill.SPILL r0 -> s1 RELOAD s1 -> r2 SPILL r3 -> s1 <--- don't need this spill SPILL r4 -> s1 RELOAD s1 -> r5Maintain a set of "slots which were spilled to but not reloaded from yet"Walking backwards across the code: a) On a reload from a slot, remove it from the set.a) On a spill from a slot If the slot is in set then we can erase the spill, because it won't be reloaded from until after the next spill.otherwise keep the spill and add the slot to the setTODO: This is mostly inter-block we should really be updating the noReloads set as we cross jumps also..TODO: generate noReloads from liveSlotsOnEntryghcCombine the associations from all the inward control flow edges.ghcSee if we have a reg with the same value as this slot in the association table.ghc(Remember the associations before a jump.ghcCheck if this is a reg store.ghcAn empty associationghcAdd an association between these two things. addAssoc :: Uniquable a => a -> a -> Assoc a -> Assoc aghc"Delete all associations to a node.ghc*Delete a single association edge (a -> b).ghc)Check if these two things are associated.ghcFind the refl. trans. closure of the association from this point.ghcIntersect two associations.ghc!Iteration number for the cleaner.ghc!Liveness annotated code to clean.ghc!the block that we're currently inghctwo store locations are associated if they have the same valueghcaccghc$instrs to clean (in backwards order)ghc$cleaned instrs (in forward order)ghc!Slots live on entry to each blockghc3Slots that have been spilled, but not reloaded fromghcaccghc#Instrs to clean (in forwards order)ghc$Cleaned instrs (in backwards order)~~ Safe-Inferred~ghc:Add a spill/reload count to a stats record for a register.~ghc,Spill all these virtual regs to stack slots.5Bumps the number of required stack slots if required.TODO: See if we can split some of the live ranges instead of just globally spilling the virtual reg. This might make the spill cleaner's job easier.TODO: On CISCy x86 and x86_64 we don't necessarily have to add a mov instruction when making spills. If an instr is using a spilled virtual we may be able to address the spill slot directly.~ghc 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?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.ghcDetermine the canonical name for a register by following v1 = v2 renamings in this map.ghcAdd a v1 = v2 register renaming to the map. The register with the lowest lexical name is set as the canonical version.~~~~ Safe-Inferred() ~ghc&Choose a node to spill from this graph~ghc+Extract a map of register lifetimes from a ~.~ghcAdd two spill cost infos.~ghcAdd two spill cost records.~ghcShow a spill cost record, including the degree from the graph and final calculated spill cost.~ghc7Slurp 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)~ghcAn empty map of spill costs.~ghcMap of ~~ghc1Records the expected cost to spill some register.ghc-Take all the virtual registers from this set.ghc Chaitins spill cost function is:cost = sum loadCost * freq (u) + sum storeCost * freq (d) u <- uses (v) d <- defs (v)There are no loops in our code at the moment, so we can set the freq's to 1.If we don't have live range splitting then Chaitins function performs badly if we have lots of nested live ranges and very few registers.v1 v2 v3 def v1 . use v1 . def v2 . . def v3 . . . use v1 . . . use v3 . . . use v2 . . use v1 .defs uses degree cost v1: 1 3 3 1.5 v2: 1 2 3 1.0 v3: 1 1 3 0.666v3 has the lowest cost, but if we only have 2 hardregs and we insert spill code for v3 then this isn't going to improve the colorability of the graph.When compiling SHA1, which as very long basic blocks and some vregs with very long live ranges the allocator seems to try and spill from the inside out and eventually run out of stack slots.Without live range splitting, its's better to spill from the outside in so set the cost of very long live ranges to zeroghcDetermine the degree (number of neighbors) of this node which have the same class. ~~~~~~~~~ ~~~~~~~~~ Safe-Inferred 7~ghc Count spillreloadreg-reg moves. Lets us see how well the register allocator has done.~ghc;Do all the different analysis on this list of RegAllocStats~ghcDump a table of how many conflicts vregs tend to have in the initial code.~ghcFor every vreg, dump how many conflicts it has, and its lifetime. Good for making a scatter plot.~ghcDump a table of how long vregs tend to live for in the initial code.~ghcDump a table of how many spill loads / stores were inserted for each vreg.~ghc9Holds interesting statistics from the register allocator.~ghcThe regs that were coalesced.~ghc(Code we tried to allocate registers for.~ghcCode with coalescings applied.~ghc Final code.~ghcThe initial, uncolored graph.~ghcCoalesced and colored graph.~ghcInitial code, with liveness.~ghc"Code with vregs replaced by hregs.~ghcTarget platform~ghc0Spill/reload/reg-reg moves present in this code.~ghc-Code with unneeded spill/reloads cleaned out.~ghc/Information to help choose which regs to spill.~ghcSpiller stats.~ghc#Code with spill instructions added.~ghcglobal register conflict graph~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Safe-Inferred ̣~ghc7The top level of the graph coloring register allocator.ghc5The maximum number of build/spill cycles we'll allow.It should only take 3 or 4 cycles for the allocator to converge. If it takes any longer than this it's probably in an infinite loop, so it's better just to bail out and report a bug.ghc;Perform solver iterations for the graph coloring allocator.We extract a register conflict graph from the provided cmm code, and try to colour it. If that works then we use the solution rewrite the code with real hregs. If coloring doesn't work we add spill code and try to colour it again. After  iterations we give up.ghcBuild a graph from the liveness and coalesce information in this code.ghcAdd some conflict edges to the graph. Conflicts between virtual and real regs are recorded as exclusions.ghcAdd some coalesence edges to the graph Coalesences between virtual and real regs are recorded as preferences.ghcPatch registers in code using the reg -> reg mapping in this graph.~ghc#registers we can use for allocationghcset of available spill slots.ghccurrent number of spill slotsghc)code annotated with liveness information.ghc CFG of basic blocks if availableghccode with registers allocated, additional stacks required and stats for each stage of allocationghc4Number of solver iterations we've already performed.ghcFunction for calculating whether a register is trivially colourable.ghc$Free registers that we can allocate.ghc!Free stack slots that we can use.ghcNumber of spill slots in useghc!Current regalloc stats to add to.ghc$Liveness annotated code to allocate.~~ Safe-Inferred~~~~~~~~ Safe-InferredԐ~ghc:Takes a closure pointer and returns the info table pointer~ghcTakes a closure pointer, and return the closure type obtained from the info table~ghcTakes an info pointer (the first word of a closure) and returns its entry code~ghcTakes the info pointer of a function, returns the function's arity~ghcTakes the info pointer of a function, and returns a pointer to the first word of the StgFunInfoExtra struct in the info table.~ghcTakes 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).~ghcTakes 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)~ghcTakes an info table pointer (from infoTable) and returns the closure type field of the info table.~ghcTakes an info table pointer (from infoTable) and returns the constr tag field of the info table (same as the srt_bitmap field)~ghcTakes an info table pointer (from infoTable) and returns the srt_bitmap field of the info table~ghcValue of the srt field of an info table when using an StgLargeSRT~ghc)Byte offset of the closure type half-word~ghcByte offset of the SRT bitmap half-word which is in the *higher-addressed* part of the type_lit~ghcInsert alignment check (cf -falignment-sanitisation)~ghcPlatform profileghcIs the SRT offset field inline in the info table on this platform?See the section "Referring to an SRT from the info table" in Note [SRTs] in GHC.Cmm.Info.BuildghcWrap a i in an alignment check when -falignment-sanitisation is enabled.ghcReturns: 1. The bitmap (literal value or label) 2. Large bitmap CmmData if needed~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Safe-Inferred~ghcChecks 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.~ghcChecks 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 reg move instruction or Nothing if it's not oneghcThe maximum number of bytes required to spill a register. PPC32 has 32-bit GPRs and 64-bit FPRs, while PPC64 has 64-bit GPRs and 64-bit FPRs. So the maximum is 8 regardless of platforms unlike x86. Note that AltiVec's vector registers are 128-bit wide so we must not use this to spill them.ghcThe number of bytes that the stack pointer should be aligned to. This is 16 both on PPC32 and PPC64 ELF (see ELF processor specific supplements).ghc=Convert a spill slot number to a *byte* offset, with no sign.~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Safe-Inferredެ Safe-Inferred|ghcOutput the ELF .size directive.ghc7Print appropriate alignment for the given section type.ghcProcedure name Safe-InferredghcReturn the UnitId of the home-unit. This is used to create labels.   Safe-Inferredd9•Õĕ9•Õĕ Safe-Inferred()ghcExtract 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).ghcSets position and unwind table fields in the debug block tree according to native generated code.ghc9Converts debug blocks into a label map for easier lookupsghcConversion of Cmm expressions to unwind expressions. We check for unsupported operator usages and simplify the expression as far as possible.ghcDebug information about a block of code. Ticks scope over nested blocks.ghc Nested blocksghc Output labelghcHas an info table?ghc Hoopl labelghc9The parent of this proc. See Note [Splitting DebugBlocks]ghc+Output position relative to other blocks. Nothing# means the block was optimized outghcEntry label of containing procghcBest source tick covering blockghcTicks defined in this blockghc(Expressions, used for unwind informationghc literal valueghcpointer dereferencingghcregister plus offsetghcA label associated with an ghcMaps 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 K= when the register's previous value cannot be reconstructed.ghcIntermediate data structure holding debug-relevant context information about a block.ghc1Build a map of blocks sorted by their tick scopesThis involves a pre-order traversal, as we want blocks in rough control flow order (so ticks have a chance to be sorted in the right order). Safe-Inferred ghc)Make an unconditional branch instruction.ghc Make a spill reload instruction.ghcMake a reg-reg move instruction. On SPARC v8 there are no instructions to move directly between floating point and integer regs. If we need to do that then we have to go via memory.ghcMake a spill instruction.ghcApplies the supplied function to all registers in instructions. Typically used to change virtual registers to real registers.ghcReturns which registers are read and written as a (read, written) pair.ăghc?See if this instruction is telling us the current C stack deltaŃghcCheck 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.σghcX86 call instructionghc8Is this register interesting for the register allocator?ghcOn most OSes the kernel will place a guard page after the current stack page. If you allocate larger than a page worth you may jump over this guard page. Not only is this a security issue, but on certain OSes such as Windows a new page won't be allocated if you don't hit the guard. This will cause a segfault or access fault.This function defines if the current allocation amount requires a probe. On Windows (for now) we emit a call to _chkstk for this. For other OSes this is not yet implemented. See  https://docs.microsoft.com/en-us/windows/desktop/DevNotes/-win32-chkstk& The Windows stack looks like this:SP GUARD PAGE  UNMAPPED In essence each allocation larger than a page size needs to be chunked and a probe emitted after each page allocation. You have to hit the guard page so the kernel can map in the next page, otherwise you'll segfault. See Note [Windows stack allocations].σghc Jump targetghc,Arguments (required for register allocation)ƒÃăŃƃȃʃσԃۃ݃҃܃߃ǃɃ˃̃̓΃ЃуӃՃփ׃؃كڃރƃȃʃσԃۃ݃҃܃߃ǃɃ˃̃̓΃ЃуӃՃփ׃؃كڃރÃŃă Safe-InferredghcOutput an internal proc label. See Note [Internal proc labels] in CLabel.ghcOutput the ELF .size directive.ghcPrint section header and appropriate alignment for that section.ghc7Print appropriate alignment for the given section type.ghcProcedure nameghc Block name Safe-Inferred Safe-InferredJghcFor a jump instruction at the end of a block, generate fixup code so its vregs are in the correct regs for its destination.ghc.Construct a graph of register/spill movements.1Cyclic components seem to occur only very rarely.We cut some corners by not handling memory-to-memory moves. This shouldn't happen because every temporary gets its own stack slot.ghcExpand out the destination, so InBoth destinations turn into a combination of InReg and InMem.ghcGenerate fixup code for a particular component in the move graph This component tells us what values need to be moved to what destinations. We have eliminated any possibility of single-node cycles in expandNode above.ghc(Move a vreg between these two locations.ghcmaps the unique of the blockid to the set of vregs that are known to be live on the entry to each block.ghcid of the current blockghc,branch instr on the end of the source block.ghcmaps the unique of the blockid to the set of vregs that are known to be live on the entry to each block.ghcacc blocks of fixup code.ghcid of the current blockghc,branch instr on the end of the source block.ghc&branch destinations still to consider.ghcsource of moveghcdestination of moveghccurrent C stack delta.ghc%unique of the vreg that we're moving.ghcsource location.ghcdestination location.ghcmove instruction. Safe-Inferred./ ghcConstraints on the instruction instances used by the linear allocator.ghcDo register allocation on some basic blocks. But be careful to allocate a block in an SCC only if it has an entry in the block map or it is the first block.ghc*Do register allocation on this basic blockghcLoad the freeregs and current reg assignment into the RegM state for the basic block with this BlockId.ghc-Do allocation for a sequence of instructions.ghc'Do allocation for a single instruction.ghcMark all these real regs as allocated, and kick out their vreg assignments.ghcGiven a virtual reg find a preferred real register. The preferred register is simply the first one the variable was assigned to (if any). This way when we allocate for a loop variables are likely to end up in the same registers at the end and start of the loop, avoiding redundant reg-reg moves. Note: I tried returning a list of past assignments, but that turned out to barely matter.ghc:Calculate a new location after a register has been loaded.ghc=Load up a spilled temporary if we need to (read from memory).ghc entry pointsghc&live regs on entry to each basic blockghc$instructions annotated with "deaths"ghc entry pointsghc&live regs on entry to each basic blockghc$instructions annotated with "deaths"ghc&live regs on entry to each basic blockghc"block to do register allocation onghcblock with registers allocatedghc2map of what vregs are live on entry to each block.ghc'id of the current block, for debugging.ghc.liveness annotated instructions in this block.ghc2map of what vregs are love on entry to each block.ghc/accumulator for instructions already processed.ghc*the id of the current block, for debuggingghc9the instr to have its regs allocated, with liveness info.#}}}}}}}}}}}}}}}}}}}}}}}}}}~~~}}~~~ Safe-Inferred7 ghcPlace  after block' and change any edges block -> X to  -> Xghc%Record that we added a block between from and old.ghcGet CFG edge weightsghc'Get native code generator configurationghc when possible.ڄghcThe list of block ids records the redirected jumps to allow us to update the CFG.ބghc is only for printing internal labels. See Note [Internal proc labels] in CLabel.5„ÄĄńƄDŽȄɄʄ˄̄̈́΄τЄфԄքބلׄӄ߄҄Մ؄ڄۄ܄݄5ЄфԄքބلׄӄ߄҄Մ؄ڄۄ܄݄ńƄDŽȄɄʄ˄̄̈́΄τĄ„Ä Safe-Inferred ghc,Generate code to reference a memory address.ghcexpr producing an address Safe-Inferredm ghc*Make code to evaluate a 32 bit expression.ghcThe dual to getAnyReg: compute an expression into a register, but we don't mind which one it is.ghcsign extend and widenghcFor nop word format conversions we set the resulting value to have the required size, but don't need to generate any actual code.ghc)Generate an integer division instruction.ghcDo an integer remainder.NOTE: The SPARC v8 architecture manual says that integer division instructions _may_ generate a remainder, depending on the implementation. If so it is _recommended_ that the remainder is placed in the Y register.The UltraSparc 2007 manual says Y is _undefined_ after division.The SPARC T2 doesn't store the remainder, not sure about the others. It's probably best not to worry about it, and just generate our own remainders.ghc(Coerce a integer value to floating pointghc(Coerce a floating point value to integerNOTE: On sparc v9 there are no instructions to move a value from an FP register directly to an int register, so we have to use a load/store.ghcCoerce a double precision floating point value to single precision.ghcCoerce a single precision floating point value to double precisionghcwidth of source expressionghcwidth of resultghcsource expression Safe-Inferredghc(Code to assign a 64 bit value to memory.ghc,Code to assign a 64 bit value to a register.ghc6Get the value of an expression into a 64 bit register.ghc&expr producing the destination addressghc expr producing the source value.ghcthe destination registerghcexpr producing the source value Safe-Inferred> Safe-InferredghcSays what we have to add to our 'PIC base register' in order to get the address of a label.   Safe-Inferred ()ghcThis 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.ghcs are the insn sequences generated by the insn selectors. They are really trees of insns to facilitate fast appending, where a left-to-right traversal yields the insns in the correct order.ghc+Memory addressing modes passed up the tree.ghca.k.a  Register64 Reg is the lower 32-bit temporary which contains the result. Use getHiVRegFromLo to find the other VRegUnique.Rules of this simplified insn selection game are therefore that the returned Reg may be modifiedghc#Condition codes passed up the tree.ghcRegister's passed up the tree. If the stix code forces the register to live in a pre-decided machine register, it comes out as Fixed#; otherwise, it comes out as Any>, and the parent can decide which register to put it in.ghcConvert ۃ instructions into ) instructions to capture changes in the sp: register. See Note [What is this unwinding business?] in GHC.Cmm.DebugBlock for details.ghcbid refers to the current block and is used to update the CFG if new blocks are inserted in the control flow. See Note [Keeping track of the current block] for more details.ghcGrab the Reg for a CmmRegghcCheck whether an integer will fit in 32 bits. A CmmInt is intended to be truncated to the appropriate number of bits, so here we truncate it to Int64. This is important because e.g. -1 as a CmmInt might be either -1 or 18446744073709551615.ghc(Convert a BlockId to some CmmStatic dataghcThe dual to getAnyReg: compute an expression into a register, but we don't mind which one it is.ghc Convert a i' representing a memory address into an .An  is a datatype representing a valid address form for the target (e.g. "Base + Index + disp" or immediate) and the code to compute it.ghcLike , but on 32-bit use simple register addressing (i.e. no index register). This stops us from running out of registers on x86 when using instructions such as cmpxchg, which can use up to three virtual registers and one fixed register.ghcGiven a , produce a new  with an instruction block which will check the value for alignment. Used for -falignment-sanitisation.ghc%We return the instructions generated.ghcSee Note [Evaluate C-call arguments before placing in destination registers]ghcCFG if presentghcBlocks with info tablesghcList of basic blocksghc7Basic block these statement will start to be placed in.ghc Cmm StatementghcResulting instructionghc6Basic block this statement will start to be placed in.ghcInstructions, and bid of new block if successive statements are placed in a different basic block. Safe-Inferred `ghc-Instruction instance for x86 instruction set. Safe-Inferred()$0 ghcTop level code generationghcDo code generation on a single block of CMM code. code generation may introduce new basic block boundaries, which are indicated by the NEWBLOCK instruction. We must split up the instruction stream into basic blocks again. Also, we extract LDATAs here too.ghc2Convert some Cmm statements to SPARC instructions.ghc(Convert a BlockId to some CmmStatic dataghcGenerate code to calculate an argument, and move it into one or two integer vregs.ghcMove args from the integer vregs into which they have been marshalled, into %o0 .. %o5, and the rest onto the stack.ghcAssign results returned from the call into their destination regs.ghcGenerate a call to implement an out-of-line floating point operationghc:Decide what C function to use to implement a CallishMachOpxx Safe-Inferred$ghc"instance for sparc instruction set Safe-Inferred()(Jghcs are the insn sequences generated by the insn selectors. They are really trees of insns to facilitate fast appending, where a left-to-right traversal (pre-order?) yields the insns in the correct order.ghcs 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.ghcRegister's passed up the tree. If the stix code forces the register to live in a pre-decided machine register, it comes out as Fixed#; otherwise, it comes out as Any>, and the parent can decide which register to put it in.ghcGrab the Reg for a CmmRegghc(Convert a BlockId to some CmmStatic dataghcCompute an expression into a register, but we don't mind which one it is. Safe-Inferred(ghc Instruction instance for powerpc Safe-Inferred 0.ghcA non empty ordered sequence of basic blocks. It is suitable for serialization in this order.We use OrdList instead of [] to allow fast append on both sides when combining chains.ghcMaps blocks near the end of a chain to it's chain AND the other blocks near the end. [A,B,C,D,E] Gives entries like (B -> ([A,B], [A,B,C,D,E])) where [A,B] are blocks in the end region of a chain. This is cheaper then recomputing the ends multiple times.ghcLook at X number of blocks in two chains to determine if they are "neighbours".ghcGiven the Chain A -> B -> C -> D and we break at C we get the two Chains (A -> B, C -> D) as result.ghcFor a given list of chains and edges try to combine chains with strong edges between them.ghcPlace basic blocks based on the given CFG. See Note [Chain based CFG serialization]ghcRemove redundant jumps between blocks when we can rely on fall through.ghcCFG if we have one.ghcFunction to serializeghcEdges to considerghcCurrent chains of blocksghcResulting list of block chains, and a set of edges which were used to fuse chains and as such no longer need to be considered.ghc)Keys indicate an info table on the block.ghc&Control flow graph and some meta data.ghc"List of basic blocks to be placed.ghcBlocks placed in sequence. Safe-Inferred @R'ghcAbbreviation declaration. This explains the binary encoding we use for representing 1. Be aware that this must be updated along with .ghc1Assembly for a single byte of constant DWARF dataghc*Assembly for 4 bytes of dynamic DWARF dataghcAssembly for a DWARF word of dynamic data. This means 32 bit, as we are generating 32 bit DWARF.ghc4Print assembler directives corresponding to a DWARF .debug_aranges address table entry.ghcHeader for the  .debug_frame section. Here we emit the "Common Information Entry" record that establishes general call frame parameters and the default stack layout.ghc Generate assembly for DWARF dataghc(Assembly for a two-byte constant integerghcSame as  pprLEBWord, but for a signed numberghcPrints 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.ghcAssembly for a machine word of dynamic data. Depends on the architecture we are currently generating code for.ghcGenerate 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.ghc)Align assembly at (machine) word boundaryghcA 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.ghcInformation about unwind instructions for a procedure. This corresponds to a "Common Information Entry" (CIE) in DWARF.ghcUnwind instructions for a block. Will become part of the containing FDE.ghcthese unwind points must occur in the same order as they occur in the blockghcUnwind instructions for an individual procedure. Corresponds to a "Frame Description Entry" (FDE) in DWARF.ghc%List of blocks. Order must match asm!ghcIndividual dwarf records. Each one will be encoded as an entry in the  .debug_info section.ghc)label of DIE belonging to the parent tickghc;Abbreviation codes used for encoding above records in the  .debug_info section.ghc)Pseudo, used for marking the end of listsghc1Generate assembly for the given abbreviation codeghc+Print a CLabel name in a ".stringz "LABEL""ghcPrints assembler data corresponding to DWARF info records. Note that the binary format of this is parameterized in  abbrevDecls and has to be kept in synch.ghc'Close a DWARF info record with childrenghcWrites a "Frame Description Entry" for a procedure. This consists mainly of referencing the CIE and writing state machine instructions to describe how the frame base (CFA) changes.ghcGenerates unwind information for a block. We only generate instructions where unwind information actually changes. This small optimisations saves a lot of space, as subsequent blocks often have the same unwind information.ghc+Get DWARF register ID for a given GlobalRegghcGenerate code for setting the unwind information for a register, optimized using its known old value in the table. Note that Sp/ is special: We see it as synonym for the CFA.ghc'Print the register number of the given i' as an unsigned LEB128 encoded number.ghcGenerates a DWARF expression for the given unwind expression. If spIsCFA is true, we see Sp0 as the frame base CFA where it gets mentioned.ghcGenerate code for re-setting the unwind information for a register to  undefinedghc"Assembly for a constant DWARF flagghc+Assembly for 4 bytes of constant DWARF dataghcGenerates a dynamic null-terminated string. If required the caller needs to make sure that the string is escaped properly.ghc>Generate a string constant. We take care to escape the string.ghc%Escape a single non-unicode characterghc4the register to produce an unwinding table entry forghc&the old and new values of the register// Safe-InferredE: Ņghc Generate DWARF/debug informationghcBuild an address range entry for one proc. With split sections, each proc needs its own entry, since they may get scattered in the final binary. Without split sections, we could make a single arange based on the first/last proc.ghcHeader for a compilation unit, establishing global format parametersghcCompilation unit footer, mainly establishing size of debug sectionsghcSplits the blocks by procedures. In the result all nested blocks will come from the same procedure as the top-level block. See Note [Splitting DebugBlocks] for details.ghc/Generate DWARF info for a procedure debug blockghcGenerate DWARF info for a blockghcGenerates the data for the debug frame section, which encodes the desired stack unwind behaviour for the debuggerghc8Generates unwind information for a procedure debug blockŅŅ Safe-Inferred !()M ghcs 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.ghcRegister's passed up the tree. If the stix code forces the register to live in a pre-decided machine register, it comes out as Fixed#; otherwise, it comes out as Any>, and the parent can decide which register to put it in.ghc Utilitiesghcbid refers to the current block and is used to update the CFG if new blocks are inserted in the control flow. See Note [Keeping track of the current block] for more details.ghcSometimes we need to change the Format of a register. Primarily during conversion.ghcGrab the Reg for a CmmRegghcConvert a BlockId to some CmmStatic data TODO: Add JumpTable Logic, see Ticket 19912 jumpTableEntry :: NCGConfig -> Maybe BlockId -> CmmStatic jumpTableEntry config Nothing = CmmStaticLit (CmmInt 0 (ncgWordWidth config)) jumpTableEntry _ (Just blockid) = CmmStaticLit (CmmLabel blockLabel) where blockLabel = blockLbl blockidThe dual to getAnyReg: compute an expression into a register, but we don't mind which one it is.ghcThe register width to be used for an operation on the given width operand.ghcInstructions to sign-extend the value in the given register from width w up to width w'.ghcInstructions to truncate the value in the given register from width w down to width w'.ghc7Basic block these statement will start to be placed in.ghc Cmm StatementghcResulting instructionghc6Basic block this statement will start to be placed in.ghcInstructions, and bid of new block if successive statements are placed in a different basic block.ghcwidth of loaded valueƅDžƅDž Safe-InferredMsɅghc Instruction instance for aarch64ȅȅ Safe-Inferred()7RI ʅghcComplete native code generation phase for a single top-level chunk of Cmm. Dumping the output of each stage along the way. Global conflict graph and NGC stats˅ghcInitialize the native code generator configuration from the DynFlagsghcData accumulated during code generation. Mostly about statistics, but also collects debug data for DWARF generation.ghcNative code generated, for statistics. This might hold a lot of data, so it is important to clear this field as early as possible if it isn't actually required.ghcsee Note [Unwinding information in the NCG] and Note [What is this unwinding business?] in GHC.Cmm.DebugBlock.ghc,Do native code generation on all these cmms.ghcMake sure all blocks we want the layout algorithm to place have been placed.ghc6Compute unwinding tables for the blocks of a procedureghc Build a doc for all the imports.ʅghcthe cmm to generate code forghc!sequence number of this top thingghc+the native code generated for the procedureghc?unwinding tables for all points of all blocks of the procedureЄфԄքބلׄӄ߄҄Մ؄ڄۄ܄݄ʅ˅̅̅ʅЄфԄքބلׄӄ߄҄Մ؄ڄۄ܄݄˅ Safe-Inferred ()0Y ghcFolds backward over all nodes of an open-open block. Strict in the accumulator.ghcFolds 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.ghcReturns the result of joining the facts from all the successors of the provided node or block.ghc(Returns the joined facts for each label.ghc*The result of joining OldFact and NewFact.ghc!Result is different than OldFact.ghcResult is the same as OldFact.ghcFunction 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).ghcSort the blocks into the right order for analysis. This means reverse postorder for a forward analysis. For the backward one, we simply reverse that (see Note [Backward vs forward analysis]).ghcConstruct a mapping from a Label to the block indexes that should be re-analyzed if the facts at that Label change.Note that we're considering here the entry point of the block, so if the facts change at the entry: * for a backward analysis we need to re-analyze all the predecessors, but * for a forward analysis, we only need to re-analyze the current block (and that will in turn propagate facts into its successors).ghcAfter some new facts have been generated by analysing a block, we fold this function over them to generate (a) a list of block indices to (re-)analyse, and (b) the new FactBase.HIIH Safe-Inferred()]dghc'Calculated liveness info for a CmmGraphghcThe dataflow latticeghcThe dataflow latticeghc&The variables live on entry to a blockghc:A mapping from block labels to the variables live on entryghc>Specialization that only retains the keys for local variables.Local variablas are mostly glorified Ints, and some parts of the compiler really don't care about anything but the Int part. So we can avoid some overhead by computing a IntSet instead of a Set LocalReg which (unsurprisingly) is quite a bit faster.ghcOn entry to the procedure, there had better not be any LocalReg's live-in.ghcOn entry to the procedure, there had better not be any LocalReg's live-in. Safe-Inferred()^Eghcconflicts (r,e) node is False if and only if the assignment r = e' can be safely commuted past statement node. Safe-Inferred$()^x   Safe-Inferred()7_ghc2Check for obviously out-of-bounds shift operationsghcAs noted in Note [Register parameter passing], the arguments and q; of a foreign call mustn't mention caller-saved registers. Safe-Inferred`ˢghcGenerate code to initialise info pointer origin See note [Mapping Info Tables to Source Positions]͢ghc(Generate code to initialise cost centresʢghc3additional files to be compiled with the C compilerʢˢ̢͢ʢ̢͢ˢ Safe-Inferred()a Safe-Inferred()b]ghc$Ignore these node types for equalityghcGiven a block map, ensure that all "target" blocks are covered by the same ticks as the respective "source" blocks. This not only means copying ticks, but also adjusting tick scopes where necessary. Safe-InferredcghcGiven a list of arguments, and a function that tells their types, return a list showing where each argument is passed Safe-Inferred()h3 ghc5use the given BlockId as the label of the entry pointghc*allocate a fresh label for the entry pointghc.creates a sequence "goto id; id:" as an AGraphghc)creates a closed AGraph from a given nodeghc(creates an open AGraph from a given nodeghcA jump where the caller says what the live GlobalRegs are. Used for low-level hand-written Cmm.ghcAssumes natural alignmentghc Construct a q7 node for the given register and unwinding expression.ghc0A labelled code block; should end in a last nodeghc+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 r (closed at both ends) by providing a label for the entry point and a tick scope; see .ghcUnlabeled graph with tick scope*€ÀĀ*€ÀĀ Safe-Inferred ()kЀghcAssumes natural alignment.ހghcGenerate code into a fresh tick (sub-)scope and gather generated codeghcThe current tick scope. We will assign this to generated blocks.ghcPlaces 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.RƀǀȀɀʀˀ̀̀΀πЀрҀӀԀՀր׀؀ـڀۀ܀݀ހ߀Ԁ̀Ȁˀ΀π̀ɀЀрʀҀӀۀƀ݀܀ހ߀ڀ׀؀րՀǀRـ Safe-InferredpghcaddToMem rep ptr n adds n to the integer pointed-to by ptr.ghcaddToMemE rep ptr n adds n to the integer pointed-to by ptr.ghcA bare bones InfoProvEnt for things which don't have a good source locationghc:Convert source information collected about identifiers in  to entries suitable for placing into the info table provenenance table.ghcEmit a data-segment data blockghcEmit a read-only data blockghcEmit code to add an entry to a now-overwritten pointer to the update remembered set.ghc0lower bound (inclusive), upper bound (exclusive)ghc&value of pointer which was overwrittenghc the thunkghcUse signed comparisons8jzzzzzzzzzzzzzzzzzzzzzzzz{ÁāŁƁǁȁɁʁ8ÁǁȁɁāj{zzzzzzzzzzzzzzzzzzzzzzzzƁŁʁ Safe-InferredtѢghc+Profiling header words in a dynamic closureآghc1Initialise the profiling field of an update frameڢghcCalled 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.ޢghcRecord 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.ߢghcRecord the allocation of a closure. The CmmExpr is the cost centre stack to which to attribute the allocation.ghc.The profiling header words in a static closureghcTakes the address of a closure, and returns the address of the LDV word in the closure΢ϢТѢҢӢԢբ֢עآ٢ڢۢܢݢޢߢ֢΢ϢܢݢעҢѢߢޢآբԢТӢ٢ڢۢ Safe-Inferredughc;Emit top-level tables for HPC and return code to initialise Safe-Inferred7~ghc1Lift an FCode computation into the CmmParse monadghc+Get the current environment from the monad.ghc+Get the current context name from the monadghcLookup 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.ghcLookup 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.ghcTakes 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(Add a local function to the environment.ghcAdd 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.ghcAllocate a fresh label.ghc.Create a fresh local variable of a given type.ghc Set context name for a sub-parseghcDoes a computation in the FCode monad, with a current environment and a list of local declarations. Returns the resulting list of declarations.ghcAn environment of named things.ghc:The environment contains variable definitions or blockids.ghcA function name from this unitghcA blockid of some code or data.ghcHolds CmmLit(CmmLabel ..) which gives the label type, eg, RtsLabel, ForeignLabel, CmmLabel etc.ghcalloc_limit -= Hp + WDS(1) - cn->start; // Set cn->free to the next unoccupied word in the block cn->free = Hp + WDS(1); ghcopenNursery profile tso produces code to open the nursery. A local register holding the value of  CurrentTSO is expected for efficiency.6Opening the nursery corresponds to the following code:  tso = CurrentTSO; cn = CurrentNursery; bdfree = CurrentNursery->free; bdstart = CurrentNursery->start; // We *add* the currently occupied portion of the nursery block to // the allocation limit, because we will subtract it again in // closeNursery. tso->alloc_limit += bdfree - bdstart; // Set Hp to the last occupied word of the heap block. Why not the // next unoccupied word? Doing it this way means that we get to use // an offset of zero more often, which might lead to slightly smaller // code on some architectures. Hp = bdfree - WDS(1); // Set HpLim to the end of the current nursery block (note that this block // might be a block group, consisting of several adjacent blocks. HpLim = bdstart + CurrentNursery->blocks*BLOCK_SIZE_W - 1; ˁˁ Safe-InferredghcemitCall 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$Return multiple values to the sequelIf the sequel is Return  return (x,y)If the sequel is AssignTo [p,q]  p=x; q=y;ghc1Just like mkVirtHeapOffsets, but for constructorsghcJust 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.ghcUsed 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*emitCallWithExtraStack conv fun args stack$ makes a call to the entry-code of fun#, using the call/return convention conv , passing args0, pushing some extra stack frames described by stack2, and returning the results to the current sequel.ghc takes a list of function arguments and prepares them for pushing on the stack for "extra" arguments to a function which requires fewer arguments than we currently have. {{{{{{{{{{{{ {{{{{{{{{{{{ Safe-InferredghcRegister a ticky counter.It's important that this does not race with other entries of the same closure, lest the ticky_entry_ctrs list may become cyclic. However, we also need to make sure that this is reasonably efficient. Consequently, we first perform a normal load of the counter's "registered" flag to check whether registration is necessary. If so, then we do a compare-and-swap to lock the counter for registration and use an atomic-exchange to add the counter to the list. if ( f_ct.registeredp == 0 ) { if (cas(f_ct.registeredp, 0, 1) == 0) { old_head = xchg(ticky_entry_ctrs, f_ct); f_ct.link = old_head; } } ΁ghc!size of the full header, in bytesghcsize of the payload, in bytesghc updateableghcstaticghc updateablé́΁ρЁсҁӁԁՁցׁ؁فځہ܁݁ށ߁߁с́΁ρ́ցہЁׁށҁӁՁԁ݁܁ف؁ځ Safe-Inferred0 ghcGets the bound  out a .ghc"closureGrowth expander sizer f fvs> computes the closure growth in words as a result of lifting f to top-level. If there was any growing closure under a multi-shot lambda, the result will be  . Also see GHC.Stg.Lift.Analysis#clogro.ghcCombines several heuristics to decide whether to lambda-lift a given let-binding to top-level. See GHC.Stg.Lift.Analysis#when for details.ghcTags every binder with its  and let bindings with their s.ghc%The type used in binder positions in fs.ghcLet(-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).ghcEvery other kind of binderghcCaptures details of the syntax tree relevant to the cost model, such as closures, multi-shot lambdas and case expressions.ghcReturns K for s and L the flag indicating occurrences as argument or in a nullary applications otherwise.ghcTags binders of an g with its  and let bindings with their s. Additionally, returns its  and the set of binder occurrences in argument and nullary application position (cf. GHC.Stg.Lift.Analysis#arg_occs).ghcHow many times will the lambda body of the RHS bound to the given identifier be evaluated, relative to its defining context? This function computes the answer in form of a M.ghc?The size in words of a function closure closing over the given s, including the header.ghcThe number of words a single  adds to a closure's size. Note that this can't handle unboxed tuples (which may still be present in let-no-escapes, even after Unarise), in which case  will crash.ghc:Expands outer free ids that were lifted to their free varsghc/Computes the closure footprint of an identifierghc0Binding group for which lifting is to be decidedghcFree 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(Abstraction of the scope of the functionghcClosure growth. ; indicates there was growth under a (multi-shot) lambda.ghcAn expander function, turning "s into "s. See .ghc Just abs_ids  =) This binding is beneficial to lift and abs_ids* are the variables it would abstract overghc free vars ghchow often the RHS was entered ghcIs the binding a let-no-escape?ghcLet body skeletonghc Argument occurrences in the bodyghc Binding groupghcLet skeleton, argument occurrences, scope skeleton of binding and the annotated bindingghcIs the binding a let-no-escape?ghcLet bodyghc Binding groupghc9RHS skeletons, argument occurrences and annotated bindinggggggggg Safe-Inferredghc=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 .ghcJust former_fvs  =( this RHS was lifted and we have to add  former_fvs. as lambda binders, discarding all free vars. Safe-Inferred5ghc:A local block label (e.g. identifying a case alternative).ɂ‚ÂĂłƂǂȂʂ˂̂͂΂ςЂт҂ӂԂՂւׂ؂قڂۂ܂݂ނ߂ɂ‚ÂĂłƂǂȂʂ˂̂͂΂ςЂт҂ӂԂՂւׂ؂قڂۂ܂݂ނ߂ Safe-Inferredghc!Low-level heap object allocation.ghclower-level version for GHC.Cmm.Parserghc/The generic GC procedure; no params, no resultsghc;Create a CLabel for calling a garbage collector entry pointghcrepresentation of the objectghc info pointerghc cost centreghcpayloadghc!returns the address of the object Safe-Inferred!$%()4>_ghcFor each code block: - collect the references reachable from this code block to FUN, THUNK or RET labels for which hasCAF == TrueThis gives us a -: a mapping from code block to sets of labelsghcAttach SRTs to all info tables in the CmmDecls, and add SRT declarations to the ModuleSRTInfo.ghcGiven  of a module, returns the set of non-CAFFY names in the module. Any Names not in the set are CAFFY.ghcprevious SRTs we've emitted, so we can de-duplicate. Used to implement the [Common] optimisation.ghcThe 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.ghcCurrent module being compiled. Required for calling labelDynamic.ghcMaps labels from  to the final CLabel that will appear in the SRT. - closures with singleton SRTs resolve to their single entry - closures with larger SRTs map to the label for that SRT - CAFs must not map to anything! - if a labels maps to Nothing, we found that this label's SRT is empty, so we don't need to refer to it from other SRTs.ghc;Records the CAFfy references of a set of static data decls.ghcReturn a (Label,CLabel) pair for each labelled block of a CmmDecl, where the label is - the info label for a continuation or dynamic closure - the closure label for a top-level function (not a CAF)ghcPut the labelled blocks that we will be annotating with SRTs into dependency order. This is so that we can process them one at a time, resolving references to earlier blocks to point to their SRTs. CAFs themselves are not included here; see getCAFs below.ghcGet (Label, CAFLabel, Set CAFLabel) for each block that represents a CAF. These are treated differently from other labelled blocks: - we never shortcut a reference to a CAF to the contents of its SRT, since the point of SRTs is to keep CAFs alive. - CAFs therefore don't take part in the dependency analysis in depAnalSRTs. instead we generate their SRTs after everything else.ghcGet the list of blocks that correspond to the entry points for FUN_STATIC closures. These are the blocks for which if we have an SRT we can merge it with the static closure. [FUN]ghc3resolve a CAFLabel to its SRTEntry using the SRTMapghc:Build the SRT for a strongly-connected component of blocksghc Build an SRT for a set of blocksghcBuild a static SRT object (or a chain of objects) from a list of SRTEntries.ghcUpdate info tables with references to their SRTs. Also generate static closures, splicing in SRT fields as necessary.ghc static data Safe-Inferredә!ghcOut of line fake primop that's actually just a foreign call to other (presumably) C--.ghc#Real primop turned into inline C--.ghc*The big function handling all the primops.In the simple case, there is just one implementation, and we emit that.In more complex cases, there is a foreign call (out of line) fallback. This might happen e.g. if there's enough static information, such as statically know arguments.ghcInterpret the argument as an unsigned value, assuming the value is given in two-complement form in the given width. Example: asUnsigned W64 (-1) is 18446744073709551615.This function is used to work around the fact that many array primops take Int# arguments, but we interpret them as unsigned quantities in the code gen. This means that we have to be careful every time we work on e.g. a CmmInt literal that corresponds to the array size, as it might contain a negative Integer value if the user passed a value larger than 2^(wORD_SIZE_IN_BITS-1) as the Int# literal.ghc1Implements branchless recovery of the carry flag c/ by checking the leftmost bits of both inputs a and b and result  r = a + b:  c = a&b | (a|b)&~r  https://brodowsky.it-sky.net/2015/04/02/how-to-recover-the-carry-bit/ghc1Implements branchless recovery of the carry flag c/ by checking the leftmost bits of both inputs a and b and result  r = a - b:  c = ~a&b | (~a|b)&r  https://brodowsky.it-sky.net/2015/04/02/how-to-recover-the-carry-bit/ghc?Translate byte array prefetch operations into proper primcalls.ghcTranslate mutable byte array prefetch operations into proper primcalls.ghcthe offset of Sp relative to the base on entry to this block.ghcthe number of bytes of arguments in the area for this block Defn: the offset of young(L) relative to the base is given by (sm_sp - sm_args) of the StackMap for block L.ghcNumber of words of stack that we do not describe with an info table, because it contains an update frame.ghcregs on the stackghccreate a sequence of assignments to establish the new StackMap, given the old StackMap.ghcGiven a set of live registers and a StackMap, save all the registers on the stack and return the new StackMap and the assignments to do the saving.ghcManifest Sp: turn all the CmmStackSlots into CmmLoads from Sp. The block looks like this:middle_pre -- the middle nodes Sp = Sp + sp_off -- Sp adjustment goes here last -- the last nodeAnd we have some extra blocks too (that don't contain Sp adjustments)The adjustment for middle_pre will be different from that for middle_post, because the Sp adjustment intervenes.ghc,Determine whether a stack check cannot fail.ghcEliminate stores of the formSp[area+n] = rwhen we know that r is already in the same slot as Sp[area+n]. We could do this in a later optimisation pass, but that would involve a separate analysis and we already have the information to hand here. It helps clean up some extra stack stores in common cases.Note that we may have to modify the StackMap as we walk through the code using procMiddle, since an assignment to a variable in the StackMap will invalidate its mapping there. Safe-Inferred2 Safe-Inferred$%7ghcFinds external references. Remember to remove the names defined by this group of BCOs themselves Safe-Inferred $%7ghcMaps Ids to their stack depth. This allows us to avoid having to mess with it after each push/pop.ghcPush an atom for constructor (i.e., PACK instruction) onto the stack. This is slightly different to pushAtom due to the fact that we allow packing constructor fields. See also  mkConAppCode and  pushPadding.ghc/Indicate if the calling convention is supportedghcLet szsw be the sizes in bytes of some items pushed onto the stack, which has initial depth original_depth. Return the values which the stack environment should map these items to.ghc'original expression; for debugging onlyjj Safe-Inferred 7ghchave we run the unariser yet?ghcTop-level bindings can't inherit the cost centre stack from their (static) allocation site.ۭghcmodule being compiledghchave we run Unarise yet?ghcwho produced the STG?ۭۭ Safe-Inferred ghcOptional Stg-to-Stg passes.ghc Common subexpression eliminationghcLambda lifting closure variables, trading stack/register allocation for heap allocationghcMandatory unarise pass, desugaring unboxed tuple and sum bindersghcUseful for building up ghc;Which Stg-to-Stg passes to run. Depends on flags, ways etc.߭߭ Safe-Inferredghc!Top level driver for C-- pipeline Safe-InferredGʾ˾ʾ˾ Safe-InferredԾghc Top level unit declaration in a Backpack file.ؾghcA declaration in a package, e.g. a module or signature definition, or an include.ݾghcAn include of another unitghc Is this a dependency signature include? If so, we don't compile this include when we instantiate this unit (as there should not be any modules brought into scope.)ghcRename a module from one name to another. The identity renaming means that the module should be brought into scope. ̾;ξϾоѾҾӾԾվ־׾ؾپھ۾ܾݾ޾߾ ۾ܾӾоѾҾ̾;ξϾԾվ־׾ؾپھݾ޾߾ Safe-Inferred'()ghcParse a Haskell module with Haddock comments. This is done in two steps: to build the AST# to insert Haddock comments into itThis is the only parser entry point that deals with Haddock comments. The other entry points (, (, etc) do not insert them into the AST.ghcConstruct an AddEpAnn from the annotation keyword and the location of the keyword itselfghcConstruct an AddEpAnn from the annotation keyword and the location of the keyword itself, provided the span is not zero widthghcConstruct an AddEpAnn from the annotation keyword and the Located Token. If the token has a unicode equivalent and this has been used, provide the unicode variant of the annotation.ghcIf the Γ is using its unicode variant return the unicode variant of the annotationghc6Synonyms for AddEpAnn versions of AnnOpen and AnnCloseghc6Synonyms for AddEpAnn versions of AnnOpen and AnnCloseghcInstead of getting the *enclosed* comments, this includes the *preceding* ones. It is used at the top level to get comments between top level declarations.9 9  Safe-InferredghcReturns True, if passed string has an import declaration.ghcReturns True' if passed string is a declaration but  not a splice.ghcReturns True+ if passed string is an import declaration.ghcReturns True! if passed string is a statement. Safe-Inferred<ghc4Complain about non-dynamic flags in OPTIONS pragmas. Throws a O if the input list is non-empty claiming that the input flags are unknown.ghc#Parse the imports of a source file. Throws a O if parsing fails.ghc6Parse OPTIONS and LANGUAGE pragmas of the source file. Throws a O5 if flag parsing fails (including unsupported flags.)ghc6Parse OPTIONS and LANGUAGE pragmas of the source file. Throws a O5 if flag parsing fails (including unsupported flags.)ghcParser optionsghcImplicit Prelude?ghc Parse this.ghcFilename the buffer came from. Used for reporting parse error locations.ghcThe original source filename (used for locations in the function result)ghcThe source imports and normal imports (with optional package names from -XPackageImports), and the module name.ghc Input Bufferghc)Source filename. Used for location info.ghcParsed options.ghc Input fileghcParsed options, if any. Safe-Inferred "ghcLoad the given static-pointer table entries into the interpreter. See Note [Grand plan for static forms] in GHC.Iface.Tidy.StaticPtrTable.ghc&Check that a module is safe to import.We return True to indicate the import is safe and False otherwise although in the False case an exception may be thrown first.ghcCompile a declsghcCompile a declsghc$Convert a typechecked module to CoreghcCompile to hard-code.ghcReturn if a module is trusted and the pkgs it depends on to be trusted.ghcUsed by both OneShot and batch mode. Runs the pipeline HsSyn and Core parts of the pipeline. We return a interface if we already had an old one around and recompilation was not needed. Otherwise it will be created during later passes when we run the compilation pipeline.ghc-Find the kind of a type, after generalisationghcWrite interface filesghc+parse a file, returning the abstract syntaxghcRename some import declarationsghcRun Core2Core simplifier. The list of String is a list of (Core) plugin module names added via TH (cf  addCorePlugin).ghcRun Core2Core simplifier. The list of String is a list of (Core) plugin module names added via TH (cf  addCorePlugin).ghc9Compile a stmt all the way to an HValue, but don't run itWe return Nothing to indicate an empty statement (or comment only), not a parse error.¿ghc9Compile a stmt all the way to an HValue, but don't run itWe return Nothing to indicate an empty statement (or comment only), not a parse error.ÿghc*Typecheck an expression (but don't run it)ƿghc+Lookup things in the compiler's environmentǿghcRename and typecheck a module, additionally returning the renamed syntaxɿghcSet module to unsafe and (potentially) wipe trust information.Make sure to call this method to set a module to inferred unsafe, it should be a central and single failure method. We only wipe the trust information when we aren't in a specific Safe Haskell mode.While we only use this for recording that a module was inferred unsafe, we may call it on modules using Trustworthy or Unsafe flags so as to allow warning flags for safety to function correctly. See Note [Safe Haskell Inference].ghc.Figure out the final correct safe haskell modeghcGenerate a striped down interface file, e.g. for boot files or when ghci generates interface files. See Note [simpleTidyPgm - mkBootModDetailsTc]ghc The statementghc The statementghc The sourceghc Starting lineghcJust f  = _stub.c is fghcNormalise the typeghcThe type as a stringghc-Resulting type (possibly normalised) and kindghcThe parsed statement¿ghc The statementghc The sourceghc Starting lineÿghcThe expressionghcKeep renamed source??¿ÿĿſƿǿȿɿʿ˿̿ͿοϿ?˿ϿȿǿʿĿſƿ¿ÿο̿ɿͿ Safe-Inferred  ?ghcSee Note [The ZonkEnv] Confused by zonking? See Note [What is zonking?] in GHC.Tc.Utils.TcMType.ghc!Extend the knot-tied environment.(N˨̨(N˨̨ Safe-Inferred#ghcLike , but consider every free variable to be dependent. This is appropriate when generalizing a *kind*, instead of a type. (That way, -XNoPolyKinds will default the variables to Type.)ghcGathers free variables to use as quantification candidates (in ҫ). This might output the same var in both sets, if it's used in both a type and a kind. The variables to quantify must have a TcLevel strictly greater than the ambient level. (See Wrinkle in Note [Naughty quantification candidates]) See Note [CandidatesQTvs determinism and order] See Note [Dependent type variables]ghcLike , but over a list of types The variables to quantify must have a TcLevel strictly greater than the ambient level. (See Wrinkle in Note [Naughty quantification candidates])ghcCheck that a coercion is appropriate for filling a hole. (The hole itself is needed only for printing.) Always returns the checked coercion, but this return value is necessary so that the input coercion is forced only when the output is forced.ghcReturns the expected type when in checking mode. Panics if in inference mode.ghc0Returns the expected type when in checking mode.ghc!Emit a new wanted expression holeghcEmits a new Wanted. Deals with both equalities and non-equalities.ghcEmits a new equality constraintghcCreates a new EvVar and immediately emits it as a Wanted. No equality predicates here.ghcAccording to the rules around representation polymorphism (see  6https://gitlab.haskell.org/ghc/ghc/wikis/no-sub-kinds), no binder can have a representation-polymorphic type. This check ensures that we respect this rule. It is a bit regrettable that this error occurs in zonking, after which we should have reported all errors. But it's hard to see where else to do it, because this can be discovered only after all solving is done. And, perhaps most importantly, this isn't really a compositional property of a type system, so it's not a terrible surprise that the check has to go in an awkward spot.ghcExtracts the expected type if there is one, or generates a new TauTv if there isn't.ghcPut a value in a coercion holeghcIs a coercion hole filled in?ghc Create a new  with as many sensible defaults for its fields as possible. Note that the , , and  fields do not have sensible defaults, so they are initialized with lazy thunks that will  if forced, so one should take care to initialize these fields after creation.This is monadic to look up the m, which is used to initialize , and to set the -Winaccessible-code flag. See Note [Avoid -Winaccessible-code when deriving] in GHC.Tc.TyCl.Instance.«ghc.Create a new flexi ty var with a specific nameūghcCreate a tyvar that can be a lifted or unlifted type. Returns alpha :: TYPE kappa, where both alpha and kappa are freshӫghc4Extract a type out of an ExpType. Otherwise, panics.ԫghcExtract a type out of an ExpType, if one exists. But one should always exist. Unless you're quite sure you know what you're doing.֫ghc,Same as readExpType, but for Scaled ExpTypesګghc?Infer a type using a fresh ExpType See also Note [ExpType] in GHC.Tc.Utils.TcMType߫ghcRetrieve the contents of a coercion hole. Panics if the hole is unfilledghc9Retrieve the contents of a coercion hole, if it is filledghcExtract out the kind vars (in order) and type vars (in order) from a . The lists are guaranteed to be distinct. Keeping the lists separate is important only in the -XNoPolyKinds case.ghcDefault some unconstrained type variables: RuntimeRep tyvars default to LiftedRep Multiplicity tyvars default to Many Type tyvars from dv_kvs default to Type, when -XNoPolyKinds (under -XNoPolyKinds, non-defaulting vars in dv_kvs is an error)ghcA suitable TyCoMapper for zonking a type during type-checking, before all metavars are filled in.ghc*like "the class context (D a b, E foogle)"ghc!all candidates for quantificationghcthose variables not defaultedlmmmmmmmmmm©«ëīūƫǫȫɫʫ˫̫ͫΫϫЫѫҫӫԫի֫׫ث٫ګ۫ܫݫޫ߫mmmmm«īūƫëիɫ˫̫©߫ʫǫȫͫmmmmmlګӫԫ֫׫Ыܫ۫ݫޫϫѫҫ٫ثΫ Safe-Inferred,%,ձghcmatchActualFunTySigma does looks for just one function arrow returning an uninstantiated sigma-typeرghc-Breaks apart a function kind into its pieces.ޱghc Variant of ݱ that takes an ExpTypeghc'If present, the thing that has type ty1رghctype, only for errorsghcn: number of desired arrowsghc fun_ kindghc-co :: fun_kind ~ (arg1 -> ... -> argn -> res)ݱghcThe wrapper has type: spec_ty ~> expected_ty See Note [Skolemisation] for the differences between tcSkolemiseScoped and tcSkolemise߱ghcThe wrapper has type: spec_ty ~> expected_ty See Note [Skolemisation] for the differences between tcSkolemiseScoped and tcSkolemise!Ыګ̱ͱαϱбѱұӱԱձֱױرٱڱ۱ܱݱޱ߱!ݱ߱ޱϱб̱ͱԱЫܱαګڱ۱ױٱرձֱұѱӱ Safe-Inferred $%9!*ghcAdd a fixed message to the error context. This message should not do any tidying.ghcAdd a message to the error context. This message may do tidying.ghcAdd 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 Variant of 1 that allows for monadic operations and tidying.ghcAdds the given modFinalizers to the global environment and set them to use the current local environment.ĩghc2Display a warning for the current source location.ũghc.Display a warning for a given source location.Ʃghc)Display a warning in the current context.ǩghc%Display a warning in a given context.ȩghcDisplay a warning, with an optional flag, for the current source location.ԩghc5Throw out any constraints emitted by the thing_inside٩ghcDump if the given  is set.کghc&Unconditionally dump some trace outputCertain tests (T3017, Roles3, T12763 etc.) expect part of the output generated by `-ddump-types` to be in  style. However, generally we want all other debugging output to use  style. We  style if  useUserStyle is True.ghc.Figure out the final correct safe haskell modeghc9Switch instances to safe instances if we're in Safe mode.ghc2The accumulator is not updated if the action failsghcRun thing_inside in an interleaved thread. It shares everything with the parent thread, so this is DANGEROUS.+It returns Nothing if the computation failsIt's used for lazily type-checking interface signatures, which is pretty benign.,See Note [Masking exceptions in forkM_maybe]ghc,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.ghcShow a ModIface+The UnitState is used to pretty-print unitsghcShow a ModIface but don't display details; suitable for ModIfaces stored in the EPT.ghc'Read binary interface, and print it outghcWrite interface fileghcA wrapper for % that throws an exception if it failsghcReturns True if a  comes from an external package. In this case, we should NOT load it into the EPS; the entities should instead come from the local merged signature interface.ghcThis is an improved version of 6 which can also handle the case when a user requests p[A= B]:M$ but we only have an interface for p[A= A]:M (the indefinite interface. If we are not trying to build code, we load the interface we have, *instantiating it* according to how the holes are specified. (Of course, if we're actually building code, this is a hard error.)In the presence of holes,  has an important invariant: to load module M, its set of transitively reachable requirements must have an up-to-date local hi file for that requirement. Note that if we are loading the interface of a requirement, this does not apply to the requirement itself; e.g., p[A= A]:A does not require A.hi to be up-to-date (and indeed, we MUST NOT attempt to read A.hi, unless we are actually typechecking p.)ghcPretty-print unit dependenciesghc Using Cabal? Safe-InferredbbghcTypecheck a signature  under the assumption that we have instantiated it under some implementation (recorded in ?) and want to check if the implementation fills the signature.0This needs to operate slightly differently than  because (1) we have a , from the exports of the implementing module, which we will use to give our top-level declarations the correct s even when the implementor provided them with a reexport, and (2) we have to deal with DFun silliness (see Note [rnIfaceNeverExported])ghcThis is a very interesting function. Like typecheckIface, we want to type check an interface file into a ModDetails. However, the use-case for these ModDetails is different: we want to compare all of the ModDetails to ensure they define compatible declarations, and then merge them together. So in particular, we have to take a different strategy for knot-tying: we first speculatively merge the declarations to get the "base" truth for what we believe the types will be (this is "type computation.") Then we read everything in relative to this truth and check for compatibility.During the merge process, we may need to nondeterministically pick a particular declaration to use, if multiple signatures define the declaration (). If, for all choices, there are no type synonym cycles in the resulting merged graph, then we can show that our choice cannot matter. Consider the set of entities which the declarations depend on: by assumption of acyclicity, we can assume that these have already been shown to be equal to each other (otherwise merging will fail). Then it must be the case that all candidate declarations here are type-equal (the choice doesn't matter) or there is an inequality (in which case merging will fail.)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.ghcReturns true if an d is for data T (an abstract data type)ghc Merge two ds together, preferring a non-abstract one. If both are non-abstract we pick one arbitrarily (and check for consistency later.)ghc Merge two &s of ds by  .ghcTrue  =# discard IdInfo on IfaceId bindingsghc,For associated type/data family declarationsghcTrue  =# discard IdInfo on IfaceId bindings Safe-InferreddghcMonadic because it makes a Name for the coercion TyCon We pass the Name of the parent TyCon, as well as the TyCon itself, because the latter is part of a knot, whereas the former is not.ghc Make the   for this  ghc Univ and reqghc Ex and provghcArgument typesghc Result typeghc,Field labels for a record pattern synonym Safe-Inferredfghc6Look up a top-level name from the current Iface moduleghc Look up the  for a given  and   . Consider alternatively using  if you're in the է monad and  is simply that of the  you are typechecking.ghcSet the  of a .ghcA function that atomically updates the name cache given a modifier function. The second result of the modifier function will be the result of the IO action.^^^^ Safe-InferredqghcRename just the exports of a ?. Useful when we're doing shaping prior to signature merging.ghcWhat we have is a generalized ModIface, which corresponds to a module that looks like p[A=]:B. We need a *specific* ModIface, e.g. p[A=q():A]:B (or maybe even p[A=]:B) which we load up (either to merge it, or to just use during typechecking).Suppose we have:p[A=]:M ==> p[A=q():A]:MSubstitute all occurrences of with q():A (renameHoleModule). Then, for any Name of form {A.T}, replace the Name with the Name according to the exports of the implementing module. This works even for p[A=]:M, since we just read in the exports of B.hi, which is assumed to be ready now. This function takes an optional , which can be used to further refine the identities in this interface: suppose we read a declaration for {H.T} but we actually know that this should be Foo.T; then we'll also rename this (this is used when loading an interface to merge it into a requirement.)ghcEnvironment for  monads.ghcRun a computation in the  monad.ghcThe key function. This gets called on every Name embedded inside a ModIface. Our job is to take a Name from some generalized unit ID p[A=, B=], and change it to the correct name for a (partially) instantiated unit ID, e.g. p[A=q[]:A, B=].%There are two important things to do:If a hole is substituted with a real module implementation, we need to look at that actual implementation to determine what the true identity of this name should be. We'll do this by loading that module's interface and looking at the mi_exports.However, there is one special exception: when we are loading the interface of a requirement. In this case, we may not have the "implementing" interface, because we are reading this interface precisely to "merge it in".External case: p[A=]:A (and thisUnitId is something else) We are loading this in order to determine B.hi! So don't load B.hi to find the exports.Local case: p[A=]:A (and thisUnitId is p[A=]) This should not happen, because the rename is not necessary in this case, but if it does we shouldn't load A.hi!Compare me with  tcIfaceGlobal!ghcRename an implicit name, e.g., a DFun or coercion axiom. Here is where we ensure that DFuns have the correct module as described in Note [rnIfaceNeverExported].ghc Rename an d?, with special handling for an associated dictionary function. Safe-Inferred~ ghcCreate an empty  (i.e., the renaming that would occur with an implementing module with no exports) for a specific hole mod_name.ghcGiven an existing , merge it with a list of *s with Backpack style mix-in linking. This is used solely when merging signatures together: we successively merge the exports of each signature until we have the final, full exports of the merged signature.What makes this operation nontrivial is what we are supposed to do when we want to merge in an export for M.T when we already have an existing export {H.T}. What should happen in this case is that {H.T} should be unified with M.T: we've determined a more *precise* identity for the export at   T.Note that we don't do unrestricted unification: only name holes from ns_mod_name ns are flexible. This is because we have a much more restricted notion of shaping than in Backpack'14: we do shaping *as* we do type-checking. Thus, once we shape a signature, its exports are *final* and we're not allowed to refine them further,ghcLike , but returns Nothing if no substitution works.ghc Create a 7 corresponding to an implementing module for the hole mod_name that exports a list of *s.ghc%The export list associated with this  (i.e., what the exports of an implementing module which induces this  would be.)ghcGiven a !, substitute it according to the ! implied substitution, i.e. map {A.T} to M.T&, if the implementing module exports M.T.ghcSubstitution on {A.T}&. We enforce the invariant that the ' of keys of this map have  hole (meaning that if we have a hole substitution, the keys of the map are never affected.) Alternatively, this is isomorphic to Map (,  ) .ghcThe  of any s a  has action over.ghcSubstitute names in a .ghcSubstitute names in an *. This has special behavior for type constructors, where it is sufficient to substitute the * to induce a substitution on *.ghcSet the  of a  FieldSelectorghc Merges to * lists together, assuming the *s have already been unified ().ghcUnify two lists of *"s, given an existing substitution subst, with only name holes from flexi( unifiable (all other name holes rigid.)ghc Unify two *"s, given an existing substitution subst, with only name holes from flexi( unifiable (all other name holes rigid.)ghc Unify two "s, given an existing substitution subst, with only name holes from flexi( unifiable (all other name holes rigid.)ghc Unify a name h which '4 with another name, given an existing substitution subst, with only name holes from flexi) unifiable (all other name holes rigid.)   Safe-InferredghcThis performs a get action after reading the dictionary and symbol table. It is necessary to run this before trying to deserialise any Names or FastStrings.¬ghc(Put a piece of data with an initialised  field. This is necessary if you want to serialise Names or FastStrings. It also writes a symbol table and the dictionary. This segment should be read using .ìghcRead an interface fileĬghcRead an interface file in E.ŬghcWrite an interface fileghc:Initial ram buffer to allocate for writing interface files¬ìĬŬƬǬȬɬʬˬ̬ͬάϬЬѬӬҬŬìĬάϬЬѬӬҬ¬ʬˬ̬ͬƬǬȬɬ Safe-Inferred'ghcGive fresh uniques to a bunch of CoVars Used in "GHC.Tc.Instance.Family.newFamInst"ghcGive fresh uniques to a bunch of TyVars, but they stay as TyVars, rather than becoming TcTyVars Used in , and ghc Used when  is the wired-in name for a wired-in class method, so the caller knows its type for sure, which should be of form forall a. C a =>  is supposed to instantiate just the outer type variable and constraintghcUsed only in *types*ghcGiven ty::forall k1 k2. k, instantiate all the invisible forall-binders returning ty kk1  kk2 :: k[kk1k1, kk2k1]ghcGiven a list of [], skolemize the type variables, returning a substitution mapping the original tyvars to the skolems, and the list of newly bound skolems.ghc This takes a ~# b and returns a ~~ b.ghc This takes a ~# b and returns a ~ b.ghcwhy do we need this?ghcname of the methodghc)types with which to instantiate the classűghc%How to instantiate the type variablesghcType to instantiateghc1Result (type vars, preds (incl equalities), rho)ɱghcType to instantiate it atghc(Standard name, user name)ghc(Standard name, suitable expression) USED ONLY FOR CmdTop (sigh) *** See Note [CmdSyntaxTable] in  GHC.Hs.Expr#˫̫±ñıűƱDZȱɱʱ˱#˱ʱ˫̫űƱñ±DZȱıɱ Safe-Inferred 0ghcTypecheck a syntax operator The operator is a variable or a lambda at this stage (i.e. renamer output)tghc!Slightly more general version of  that allows the caller to specify the shape of the result of the syntax operatorghc5A data type to describe why a variable is not closed.ghc=Checks if the given name is closed and emits an error if not.%See Note [Not-closed error messages].ghc"shape of syntax operator argumentsghcoverall result typeghcType check any arguments, takes a type per hole and a multiplicity per arrow in the shape.ghcshape it is expected to haveghccheck the argumentsghcreturns a wrapper :: (type of right shape) "->" (type passed in)ghcargument shapesghc result shapeghccheck the argumentsghcreturns a wrapper to be applied to the original function, wrappers to be applied to arguments and a wrapper to be applied to the overall expressionlmmmmmm޺mmmmmml޺ Safe-Inferred'()ֲghcReport error message for a pair of equations violating an injectivity annotation. No error message if there are no branches.ײghcReport a list of injectivity errors together with their source locations. Looks only at one equation; does not look for conflicts *among* equations.ڲghcIf co :: T ts ~ rep_ty then: +instNewTyCon_maybe T ts = Just (rep_ty, co)Checks for a newtype, and for being saturated Just like Coercion.instNewTyCon_maybe, but returns a TcCoercion۲ghcLike ܲ, but returns the arguments back if there is no data family to unwrap. Returns a Representational coercionܲghcConverts a data family type (eg F [a]) to its representation type (eg FList a) and returns a coercion between the two: co :: F [a] ~R FList a.ݲghcݲ gets rid of top-level newtypes, potentially looking through newtype  instances.It is only used by the type inference engine (specifically, when solving representational equality), and hence it is careful to unwrap only if the relevant data constructor is in scope. That's why it gets a GlobalRdrEnv argument.It is careful not to unwrap data/newtype instances if it can't continue unwrapping. Such care is necessary for proper error messages.It does not look through type families. It does not normalise arguments to a tycon.If the result is Just (rep_ty, (co, gres), rep_ty), then co : ty ~R rep_ty gres are the GREs for the data constructors that had to be in scopeghc4Checks to make sure no two family instances overlap.ghcCheck whether a new open type family equation can be added without violating injectivity annotation supplied by the user. Returns True when this is possible and False if adding this equation would violate injectivity annotation. This looks only at the one equation; it does not look for interaction between equations. Use checkForInjectivityConflicts for that. Does checks (2)-(4) of Note [Verifying injectivity annotation] in GHC.Core.FamInstEnv.ghc,Is type headed by a type family application?ghcIf a RHS is a bare type variable return a set of LHS patterns that are not bare type variables.ghcReturn the set of type variables that a type family equation is expected to be injective in but is not. Suppose we have type family F a b = r | r -> a. Then any variables that appear free in the first argument to F in an equation must be fixed by that equation's RHS. This function returns all such variables that are not indeed fixed. It also returns whether any of these variables appear invisibly and whether -XUndecidableInstances would help. See Note [Coverage condition for injective type families].ghc:Injectivity error herald common to all injectivity errors.ghcReport error message for equation with injective type variables unused in the RHS. Note [Coverage condition for injective type families], step 6ghcReport error message for equation that has a type family call at the top level of RHSghcReport error message for equation that has a bare type variable in the RHS but LHS pattern is not a bare type variable.ײghc(Type family for which we generate errorsghc1Currently checked equation (represented by axiom)ghcInjectivity annotation LԲղֲײزٲڲ۲ܲݲ LٲԲز۲ܲڲݲղײֲ Safe-Inferred()1ghc(Releases the external interpreter state.ghcFor every argument type that a type constructor accepts, report whether or not the argument is poly-kinded. This is used to eventually feed into . See 5Note [Reified instances and explicit kind signatures].ghc*A type variable with kind * -> * named "m"ghc For a type m , emit the constraint 'Quote m'.ghcCompute the expected type of a quotation, and also the QuoteWrapper in the case where it is an overloaded quotation. All quotation forms are overloaded aprt from Variable quotations ('foo)ghc4Typechecking a pending splice from a untyped bracketghcWe only want to produce warnings for TH-splices if the user requests so. See Note [Warnings for TH splices].ghcForce the contents of the Serialized value so weknow it doesn't contain any bottomsghcLooks up documentation for a declaration in first the current module, otherwise tries to find it in another module via .ghcLike , looks up documentation for a function argument. If it can't find any documentation for a function in this module, it tries to find it in another module.ghc;Returns the module a Name belongs to, if it is isn't local.ghcFind the GHC name of the first instance that matches the TH typeghc8Adds a mod finalizer reference to the local environment.ghccommunicate with a remotely-running TH computation until it finishes. See Note [Remote Template Haskell] in librariesghci GHCi/TH.hs.ghc+Read a value of type QResult from the iservghcRetrieve (or create, if it hasn't been created already), the remote TH state. The TH state is a remote reference to an IORef QState living on the server, and we have to pass this to each RunTH call we make.>The TH state is stored in tcg_th_remote_state in the TcGblEnv.ghcAnnotate (with TH.SigT) a type if the first parameter is True and if the type contains a free variable. This is used to annotate type patterns for poly-kinded tyvars in reifying class and type instances. See 5Note [Reified instances and explicit kind signatures].ghcReturns N in the case that the instances were found to be class instances, or O if they are family instances.пѿпѿ Safe-Inferred> ghcSimplify top-level constraints, but without reporting any unsolved constraints nor unsafe overlapping.ghcType-check a thing that emits only equality constraints, solving any constraints we can and re-emitting constraints that we can't. Use this variant only when we'll get another crack at it later See Note [Failure in local type signatures]Panics if we solve any non-equality constraints. (In runTCSEqualities we use an error thunk for the evidence bindings.)ghcReturn (Just new_inerts) if the Givens are satisfiable, Nothing if definitely contradictoryghc4Return True if the Wanteds are soluble, False if notghcNormalise a type as much as possible using the given constraints. See Note [tcNormalise].ghc8How should we choose which constraints to quantify over?ghcApply the monomorphism restriction, never quantifying over any constraintsghcSee Note [TcRnExprMode] in  GHC.Tc.Module, the :type +d case; this mode refuses to quantify over any defaultable constraintghc-Quantify over any constraint that satisfies lghcDefault any remaining  CallStack constraints to empty  CallStacks.ghcLike , but in the TcS monad.ѫѫ Safe-Inferred7ghcSee Note [Rewriting]. If (xi, co) <- rewrite mode ev ty, then co :: xi ~r ty where r is the role in ev.ghcRewrite a type w.r.t. nominal equality. This is useful to rewrite a type w.r.t. any givens. It does not do type-family reduction. This will never emit new constraints. Call this when the inert set contains only givens.ghcThe  monad is a wrapper around  with a ghc+The result of rewriting a tyvar "one step".ghc;The inert set doesn't make the tyvar equal to anything elseghcThe tyvar rewrites to a not-necessarily rewritten other type. co :: new type ~r old type, where the role is determined by the RewriteEnvWith Quick Look, the returned TcType can be a polytype; that is, in the constraint solver, a unification variable can contain a polytype. See GHC.Tc.Gen.App Note [Instantiation variables are short lived]ghcSmart constructor for ;, as describe in Note [The one-shot state monad trick] in GHC.Utils.Monad.ghc Change the J in a .ghcMake sure that rewriting actually produces a coercion (in other words, make sure our flavour is not Derived) Note [No derived kind equalities]ghcfast path rewrite_args, in which none of the binders are named and therefore we can avoid tracking a lifting context. There are many bang patterns in here. It's been observed that they greatly improve performance of an optimized build. The T9872 test cases are good witnesses of this fact.ghcSlow path, compared to rewrite_args_fast, because this one must track a lifting context.ghcRewrite a coercion. Really, just zonk it so we can uphold (F1) of Note [Rewriting]ghcLike  splitPiTys' but comes with a ; which is M) iff there is at least one named binder.ghcLike G but you also get a ;7 which is true iff there is at least one named binder. Safe-Inferred'7>:гghcConditionally replace all type family applications in the RHS with fresh variables, emitting givens that relate the type family application to the variable. See Note [Type equality cycles] in GHC.Tc.Solver.Canonical. This only works under conditions as described in the Note; otherwise, returns Nothing.ҳghcChecks if the depth of the given location is too much. Fails if it's too big, with an appropriate error message.ڳghc-Emit a new Wanted equality into the work-listghcLooks up a family application in the inerts; returned coercion is oriented input ~ outputghcLook up a dictionary inert.ghcLook up a solved inert.ghcReturns Given constraints that might, potentially, match the given pred. This is used when checking to see if a Given might overlap with an instance. See Note [Instance and Given overlap] in GHC.Tc.Solver.Interactghc Make a new  of the given type, bound (in the monad's EvBinds) to the given termghcMake a new equality CtEvidenceghc"Remove inert constraints from the ?, for use when a typechecker plugin wishes to discard a given.ghcThis variant of  will keep solving, even when only Deriveds are left around. It also doesn't return any evidence, as callers won't need it.ghc-This can deal only with equality constraints.ghc A variant of  that takes and returns an  for later resumption of the  session.ʴghcEqualities only˴ghc+Good for both equalities and non-equalitiesghcSee Note [Safe Haskell Overlapping Instances Implementation] in  GHC.Tc.Solverghc ret.ghc name not in scope (no error reported)Just (UnambiguousGre x) -> name uniquely refers to x, or there is a name clash (reported)Just AmbiguousFields -> name refers to two or more record fields (no error reported)(See Note [ Unbound vs Ambiguous Names ].ghcLike  but returning at most one name, reporting an ambiguity error if there are more than one.ghc%Look up *all* the names to which the + may refer in GHCi (using -fimplicit-import-qualified). This will normally be zero or one, but may be more in the presence of DuplicateRecordFields.ghc:description of thing we're looking up, like "type family"ghc:description of thing we're looking up, like "type family"ghcThe standard nameghcPossibly a non-standard nameghcThe standard nameghcPossibly 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 scope77 Safe-Inferred~ ghcA common way to invoke .ghc8Ensure that a constraint tuple has arity no larger than .ghcThrow an error message if a user attempts to quantify an inferred type variable in a place where specificity cannot be observed. For example, forall {a}. [a] -> [a]2 would be rejected to the inferred type variable {a}, but forall a. [a] -> [a] would be accepted. See +Note [Unobservably inferred type variables].ghc?Ensure that a boxed or unboxed tuple has arity no larger than .ghcChecks to see if we need to warn for -Wunused-record-wildcards or -Wredundant-record-wildcardsghcMake a map from selector names to field labels and parent tycon names, to be used when reporting unused record fields.ghc"Examines a non-outermost type for foralls or contexts, which are assumed to be nested. For example, in the following declaration: ,instance forall a. forall b. C (Either a b) The outermost forall a is fine, but the nested forall b is not. We invoke  on the type forall b. C (Either a b) to catch the nested forall' and create a suitable error message.  returns L 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.ghcProduce a warning when the `..`! pattern binds no new variables. 0 data P = P { x :: Int } foo (P{x, ..}) = x The `..`$ here doesn't bind any variables as x is already bound.ghc/Produce a warning when no variables bound by a `..` pattern are used. . data P = P { x :: Int } foo (P{..}) = () The `..` pattern binds x6 but it is not used in the RHS so we issue a warning.ghc$Should we report the fact that this  is unused? The   may differ from  due to DuplicateRecordFields.ghcThe error msg if the signature is not allowed to contain manually written inferred variables.6²ò6²ò Safe-Inferred6ghcCalled from the typechecker ( GHC.Tc.Errors") when we find an unbound variableghcWhen the name is in scope as field whose selector has been suppressed by NoFieldSelectors, display a helpful message explaining this.ghcGenerate helpful suggestions if a qualified name Mod.foo is not in scope.5665 Safe-Inferred1 ޲ghcReport *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)߲ghcReport unsolved goals as errors or warnings. We may also turn some into deferred run-time errors if `-fdefer-type-errors` is on.ghcReport all unsolved goals as warnings (but without deferring any errors to run-time). See Note [Safe Haskell Overlapping Instances Implementation] in  GHC.Tc.SolverghcAn error Report collects messages categorised by their importance. See Note [Error report] for details.ghc,Report unsolved goals as errors or warnings.ghc(Put a doc into the important msgs block.ghc+Put a doc into the relevant bindings block.ghc)Put a doc into the valid hole fits block.ghc Returns True  =7 the ReportErrCtxt indicates that something is deferredghcThis function tries to reconstruct why a "Coercible ty1 ty2" constraint is left over.ghcPrints explicit kinds (with -fprint-explicit-kinds) in an > when a type mismatch occurs to due invisible kind arguments.)This function first checks to see if the ͜ argument is a , and if so, uses the expected/actual types from that to check for a kind mismatch (as these types typically have more surrounding types and are likelier to be able to glean information about whether a mismatch occurred in an invisible argument position or not). If the ͜ is not a 7, fall back on the actual mismatched types themselves.ghcExpand type synonyms in given types only enough to make them as similar as possible. Returned types are the same in terms of used type synonyms.To expand all synonyms, see .See ExpandSynsFail tests in tests testsuiteteststypecheck/should_fail for some examples of how this should work.޲߲߲޲ Safe-Inferred$%ghcSort 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.ghcA 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.ghctcFilterHoleFits 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.ghcReports 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.ghcTakes a list of free variables and restores any Flexi type variables in free_vars after the action is run.ghc.Checks whether a MetaTyVar is flexible or not.ghcThe tidy_env for zonkingghc!Enclosing implications for givensghcThe unsolved simple constraints in the implication for the hole.ghcThe hole to check againstghc;The type to check against (possibly modified, e.g. refined)ghcThe type to check whether fits.ghc;Whether it was a match, and the wrapper from hole_ty to ty.ghc%How many we should output, if limitedghcThe hole to filter againstghcThe type to check for fits and a list of refinement variables (free type variables in the type) for emulating additional holes.ghc$The candidates to check whether fit.ghcWe return whether or not we stopped due to hitting the limit and the fits we found.## Safe-Inferred ghc9A solved triple of constraints, with evidence for wantedsghcA triple of (given, derived, wanted) constraints to pass to pluginsghcRepresents collections of constraints generated by typechecker pluginsghcOriginal inputs to the plugins with solved/bad constraints removed, but otherwise unmodifiedghcConstraints solved by pluginsghc,Constraints reported as insoluble by pluginsghc"New constraints emitted by pluginsghcExtract the (inert) givens and invoke the plugins on them. Remove solved givens from the inert set and emit insolubles, but return new work produced so that ( can feed it back into the main solver.ghcGiven a bag of (rewritten, zonked) wanteds, invoke the plugins on them and produce an updated bag of wanteds (possibly with some new work) and a bag of insolubles. The boolean indicates whether < should feed the updated wanteds back into the main solver.ghcStarting from a triple of (given, derived, wanted) constraints, invoke each of the typechecker plugins in turn and return%the remaining unmodified constraints,"constraints that have been solved,#constraints that are insoluble, and new work.Note that new work generated by one plugin will not be seen by other plugins on this pass (but the main constraint solver will be re-invoked and they will see it later). There is no check that new work differs from the original constraints supplied to the plugin: the plugin itself should perform this check if necessary.ghcIf a class is "naturally coherent", then we needn't worry at all, in any way, about overlapping/incoherent instances. Just solve the thing! See Note [Naturally coherent classes] See also Note [The equality class story] in GHC.Builtin.Types.Prim. Safe-Inferred7ghcCompare types for equality, while zonking as necessary. Gives up as soon as it finds that two types are not equal. This is quite handy when some unification has made two types in an inert Wanted to be equal. We can discover the equality without rewriting, which is sometimes very expensive (in the case of type functions). In particular, this function makes a ~20% improvement in test case perfcompilerT5030.Returns either the (partially zonked) types in the case of inequality, or the one type in the case of equality. canEqReflexive is a good next step in the O case. Returning N is always safe.NB: This does *not* look through type synonyms. In fact, it treats type synonyms as rigid constructors. In the future, it might be convenient to look at only those arguments of type synonyms that actually appear in the synonym RHS. But we're not there yet.ghcDecompose a type application. All input types must be rewritten. See Note [Canonicalising type applications] Nominal equality only! co1) ~ ty2 (modulo a swap-flag)ghcCall when canonicalizing an equality fails, but if the equality is representational, there is some hope for the future. Examples in Note [Use canEqFailure in canDecomposableTyConApp]ghcCall when canonicalizing an equality fails with utterly no hope.ghc%Solve a reflexive equality constraintghc :: ty1 ~ ty2ghcty1ghc :: ty1 ~ ty1'ghcty2ghcty2, with type synonyms  0 Safe-Inferred '087¹ghc3Add a "In the data declaration for T" or some such.ŹghcSkolemise the s in an  with the supplied .ƹghcSkolemise the s in an  with the supplied .ϹghcUsed 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.йghc2Checks that the result kind of a class is exactly  Constraint<, rejecting type synonyms and type families that reduce to  Constraint . See #16826.ѹghcChecks 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.TyClӹghcMake an appropriate message for an error in a function argument. Used for both expressions and types.׹ghcSpecialised version of ٹ, but with empty WantedConstraints, so no filtering is needed i.e. kindGeneraliseAll = kindGeneralizeSome emptyWCعghcSpecialized version of ٹ, but where no variables can be generalized, but perhaps some may need to be promoted. Use this variant when it is unknowable whether metavariables might later be constrained.To see why this promotion is needed, see Note [Recipe for checking a signature], and especially Note [Promotion in signatures].ٹghcGeneralize some of the free variables in the given type. All such variables should be *kind* variables; any type variables should be explicitly quantified (with a forall ) before now.The WantedConstraints are un-solved kind constraints. Generally they'll be reported as errors later, but meanwhile we refrain from quantifying over any variable free in these unsolved constraints. See Note [Failure in local type signatures].But in all cases, generalize only those variables whose TcLevel is strictly greater than the ambient level. This "strictly greater than" means that you likely need to push the level before creating whatever type gets passed here.Any variable whose level is greater than the ambient level but is not selected to be generalized will be promoted. (See [Promoting unification variables] in  GHC.Tc.Solver. and Note [Recipe for checking a signature].)The resulting KindVar are the variables to quantify over, in the correct, well-scoped order. They should generally be Inferred, not Specified, but that's really up to the caller of this function.޹ghcTypecheck a deriving strategy. For most deriving strategies, this is a no-op, but for the via* strategy, this requires typechecking the via type.ghc%Type-check a visible type applicationghc1Describes the kind expected in a certain context.ghcany kind will doghcsomething of the form TYPE _ghca specific kindghc'A description of whether something is adata or newtype () data instance or newtype instance () data family ()/At present, this data type is only consumed by ѹ.ghcInfo about the context in which we're checking a type. Currently, differentiates only between types and kinds, but this will likely grow, at least to include the distinction between patterns and not-patterns./To find out where the mode is used, search for =This data type is purely local, not exported from this moduleghcLocal helper type used in ѹ.Superficially similar to , but it lacks  and , and instead of  liftedTypeKind provides 3, which is much simpler to match on and handle in .ghc) describes how to typecheck an explicit () or implicit () binder in a type. It is just a record of flags that describe what sort of  to create.ghcCheck and desugar a type, returning the core type and its possibly-polymorphic kind. Much like  tcInferRho at the expression level.ghcCall / and check its result against an expected kind.ghcInfer the kind of a type and desugar. This is the "up" type-checker, as described in Note [Bidirectional type checking]ghcApply a type of a given kind to a list of arguments. This instantiates invisible parameters as necessary. Always consumes all the arguments, using matchExpectedFunKind as necessary. This takes an optional  VarEnv Kind which maps kind variables to kinds.- These kinds should be used to instantiate invisible kind variables; they come from an enclosing class for an associated type/data family.tcInferTyApps also arranges to saturate any trailing invisible arguments of a type-family application, which is usually the right thing to do tcInferTyApps_nosat does not do this saturation; it is used only by ":kind" in GHCighcApply a type of a given kind to a list of arguments. This instantiates invisible parameters as necessary. Always consumes all the arguments, using matchExpectedFunKind as necessary. This takes an optional  VarEnv Kind which maps kind variables to kinds.- These kinds should be used to instantiate invisible kind variables; they come from an enclosing class for an associated type/data family.tcInferTyApps also arranges to saturate any trailing invisible arguments of a type-family application, which is usually the right thing to do tcInferTyApps_nosat does not do this saturation; it is used only by ":kind" in GHCighcThis instantiates invisible arguments for the type being checked if it must be saturated and is not yet saturated. It then calls and uses the result from checkExpectedKindX to build the final typeghcNew unification variable '_' for a wildcardghc Kind-check a ׇ . Used in inferInitialKind$ (for tycon kinds and other kinds).-This function does not do telescope checking.ghcKind-check a declaration header against a standalone kind signature. See Note [Arity inference in kcCheckDeclHeader_sig] ֹghcof the thing being checkedghc What sort of   is being checkedghcBinders in the headerghcThe result kindghcA suitably-kinded TcTyConٹghcneedn't be zonked޹ghcThe deriving strategyghcThe typechecked deriving strategy and the tyvars that it binds (if using ).ghcargument typesghcof these kindsghc expected kind of the whole tupleghcFunction (for printing only)ghcFunctionghcArgsghc(f args, args, result kind)ghcFunction (for printing only)ghcFunctionghcArgsghc(f args, args, result kind)ghc"type we're checking (for printing)ghctype we're checkingghcthe known kind of that typeghcthe expected kindghcof the thing being checkedghc What sort of   is being checkedghcBinders in the headerghc/The result kind. AnyKind == no result signatureghc%A suitably-kinded generalized TcTyConghcof the thing being checkedghc What sort of   is being checkedghcBinders in the headerghcThe result kindghc%A suitably-kinded generalized TcTyConghcof the thing being checkedghc What sort of   is being checkedghcThe result kindghc)A suitably-kinded non-generalized TcTyConghc;Standalone kind signature, fully zonked! (zonkTcTypeToType)ghcof the thing being checkedghc What sort of   is being checkedghcBinders in the headerghc/The result kind. AnyKind == no result signatureghcA suitably-kinded TcTyCon¹ùĹŹƹǹȹɹʹ˹̹͹ιϹйѹҹӹԹչֹ׹عٹڹ۹ܹݹ޹߹չݹԹڹ޹ʹɹȹǹƹŹĹù̹͹۹ι߹˹Ϲҹֹܹ׹ٹعѹйӹ¹ Safe-InferredK7ghc.Checks that an associated type family default:  a -> a in type Foo :: Show a => a -> a'. On the other hand, the same type in foo :: Show a => a -> a is unambiguously the type of a term, not the kind of a type, so it is permitted.ghcReturns M if the supplied  is unambiguously not the context for a kind of a type, where the arbitrary use of constraints is currently disallowed. (See Note [Constraints in kinds] in GHC.Core.TyCo.Rep.)ghcReturns M if the supplied  is unambiguously not the context for a kind of a type, where all function arrows currently must be unrestricted.ghcReturns M if the supplied  is unambiguously not the context for the type of a term, where visible, dependent quantification is currently disallowed. If the  can refer to both types and kinds, this function conservatively returns M.An example of something that is unambiguously the type of a term is the forall a -> a -> a in foo :: forall a -> a -> a'. On the other hand, the same type in %type family Foo :: forall a -> a -> a is unambiguously the kind of a type, not the type of a term, so it is permitted.For more examples, see  testsuitetests dependentshould_compileT16326_Compile*.hs+ (for places where VDQ is permitted) and  testsuitetests dependent should_failT16326_Fail*.hs' (for places where VDQ is disallowed).ghcIf LiberalTypeSynonyms is enabled, we start in $ mode for the reasons explained in Note [Liberal type synonyms]. Otherwise, we start in  mode.ghcReject type variables that would escape their escape through a kind. See ,Note [Type variables escaping through kinds].ghcReject a use of visible, dependent quantification in the type of a term.ghc/Reject uses of linear function arrows in kinds.ghc2See Note [Validity checking of HasField instances]ghcChecks that a list of type patterns is valid in a matching (LHS) position of a class instances or type/data family instance.Specifically: * All monotypes * No type-family applicationsghcWhen this says True:, ignore this class constraint during a termination checkghcTidy before printing a typeghc Family tyconghcof the type familyghc Type patternsghcof the type familyghcBound variables in the equationghc Type patternsghcRhsghc'Is this the argument to a type synonym?++ Safe-InferredMghc/Rename a splice pattern. See Note [rnSplicePat]ghcoutputs splice information for 2 flags which have different output formats: `-ddump-splices` and `-dth-dec-file`ghcThe splice data to be loggedghcReturns the result of running a splice and the modFinalizers collected during the execution.5See Note [Delaying modFinalizers in untyped splices]. Safe-Inferred '7OghcTurn a Fractional-looking literal which happens to be an integer into an Integer-looking literal. We only convert numbers where the exponent is between 0 and 100 to avoid converting huge numbers and incurring long compilation times. See #15646. Safe-Inferred 0eighcExtracts 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].¸ghcGet 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] b) -> eHere we do bring b into scope.RULES can also use #, 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  is used instead. See also ,Note [Pattern signature binders and scoping] in  GHC.Hs.Type.ghcNever 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.ghcShould GHC warn if a quantified type variable goes unused? Usually, the answer is "yes", but in the particular case of binding ׇ$, we avoid emitting warnings. See 8Note [Suppress -Wunused-foralls when binding LHsQTyVars].ghc9Name of an operator in an operator application or sectionghcA normal identifierghcPrefix negationghcAn unbound indentifierghc.A (possibly ambiguous) record field occurrenceghcWhen the NamedWildCards extension is enabled, partition_nwcs removes type variables that start with an underscore from the FreeKiTyVars in the argument and returns them in a separate list. When the extension is disabled, the function returns the argument and empty list. See Note [Renaming named wild cards]ghcCreate fresh type variables for binders, disallowing multiple occurrences of the same variable. Similar to ڸ except that duplicate occurrences will result in an error, and the source locations of the variables are not adjusted, as these variable occurrences are themselves the binding sites for the type variables, rather than the variables being implicitly bound by a signature.ghc(In what contexts are wildcards permittedghc>Ensures either that we're in a type or that -XPolyKinds is setghc=Look up the fixity for an operator name. Be careful to use 6 for (possibly ambiguous) record fields (see #13132).ghcFilter out any type and kind variables that are already in scope in the the supplied LocalRdrEnv. Note that this includes named wildcards, which look like perfectly ordinary type variables at this point.ghcFilter 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.ghcFilter out any potential implicit binders that are either already in scope, or are explicitly bound in the binder.ghcL _ => an associated type declڸghcL _ => an associated type declghcSurface-syntax free vars that we will implicitly bind. May have duplicates, which are removed here.ghcL _ => an associated type declghcSurface-syntax free vars that we will implicitly bind. Duplicate variables will cause a compile-time error regarding repeated bindings.ghctypeghcExplicitly bound hereghcPotential implicit bindersghcFinal implicit binders2¸øĸŸƸǸȸɸʸ˸̸͸θϸиѸҸӸԸոָ׸ظٸڸ۸ܸݸ޸߸2ظܸ޸ҸӸ۸ݸָٸո׸ԸθѸɸ߸̸˸͸ʸڸŸƸǸȸ¸øĸϸи Safe-Inferredi:ghcLook up the fixity of a (possibly ambiguous) occurrence of a record field selector. We use  so that we can specify the  6 as the field label, which might be different to the   of the selector  if DuplicateRecordFields is in use (#1173). If there are multiple possible selectors with different fixities, generate an error.ghc returns (True, fixity) if it finds a  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). Safe-Inferred .vXghcRename some StmtsghcThe s of return and pure. These may not be  returnName and pureName due to  QualifiedDo or RebindableSyntax.ghcA tree of statements using a mixture of applicative and bind constructs.ghclike 8 but applies a post-processing step to the renamed Stmtsghcmaybe rearrange statements according to the ApplicativeDo transformationghc.strip the FreeVars annotations from statementsghcIs this a context where we respect RebindableSyntax? but ListComp are never rebindable Neither is ArrowExpr, which has its own desugarer in GHC.HsToCore.Arrowsghcrearrange a list of statements using ApplicativeDoStmt. See Note [ApplicativeDo].ghcTurn a sequence of statements into an ExprStmtTree using a heuristic algorithm. O(n^2)ghcTurn a sequence of statements into an ExprStmtTree optimally, using dynamic programming. O(n^3)ghcTurn the ExprStmtTree back into a sequence of statements, using ApplicativeStmt where necessary.ghcDivide a sequence of statements into segments, where no segment depends on any variables defined by a statement in another segment.ghcFind a "good" place to insert a bind in an indivisible segment. This is the only place where we use heuristics. The current heuristic is to peel off the first group of independent statements and put the bind after those.ghcBuild an ApplicativeStmt, and strip the "return" from the tail if necessary.For example, if we start with do x <- E1; y <- E2; return (f x y) then we get do (E1[x] | E2[y]); f x ythe LastStmt in this case has the return removed, but we set the flag on the LastStmt to indicate this, so that we can print out the original statement correctly in error messages. It is easier to do it this way rather than try to ignore the return later in both the typechecker and the desugarer (I tried it that way first!).ghcGiven the statements following an ApplicativeStmt, determine whether we need a join or not, and remove the return if necessary.ghc(Just e, False), if the expression is return e (Just e, True) if the expression is  return $ e, otherwise Nothing.ghcBuild a А out of an extension constructor, and the two components of the expansion: original and desugared expressions.ghc7How to rename the body of each statement (e.g. rnLExpr)ghc Statementsghcif these statements scope over something, this renames it and returns the result.ghc7How to rename the body of each statement (e.g. rnLExpr)ghcpostprocess the statementsghc Statementsghcif these statements scope over something, this renames it and returns the result.ghc'How to rename the body of the statementghc The statementghc0Rename the stuff that this statement scopes overghc the "tail"ghcfree variables of the tailghcThe argsghcTrue  = need a joinghcThe body statementsghcsource expressionghcexpanded expressionghcsuitably wrapped А Safe-Inferred.v Safe-Inferred } ghcCalculate the > induced by an import of a particular interface, but without .ghcProcess Import Decls. See  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 unnecessaryghc#Given a located import declaration decl from this_mod1, calculate the following pieces of information:  An updated , where all unresolved +2 in the entity lists have been resolved into s,A + representing the new identifiers that were brought into scope (taking into account module qualification and hiding), summarizing the identifiers that were imported by this declaration, and A boolean 4 which is true if the imported module used HPC.ghcIssue a warning if the user imports Data.List without either an import list or  qualified.. This is part of the migration plan for the  proposal. See #17244.ghc7Given an import/export spec, construct the appropriate +s.ghcWarn the user about top level binders that lack type signatures. Called after type inference, so that we can report the inferred type of the functionghc>Warn the user about tycons that lack kind signatures. Called after type (and kind) inference, so that we can report the inferred kinds.++ Safe-Inferred  ghc 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 alreadyghcTracks whether we are renaming: A type family equation that is not associated with a parent type class ( ). Examples:  type family F a type instance F Int = Bool -- NonAssocTyFamEqn NotClosed type family G a where G Int = Bool -- NonAssocTyFamEqn Closed  /An associated type family default declaration (). Example:  class C a where type A a type instance A a = a -> a -- AssocTyFamDeflt C  0An associated type family instance declaration (). Example:  instance C a => C [a] where type A [a] = Bool -- AssocTyFamInst C [a] ghcTracks whether we are renaming an equation in a closed type family equation ( ) or not ().ghc0'InstDeclFreeVarsMap is an association of an InstDecl with FreeVars. The FreeVars are the tycon names that are both a) free in the instance declaration b) bound by this group of typeclassinstance declsghcStandalone kind signatures.ghc-Free variables of standalone kind signatures.ghcFor Windows DLLs we need to know what packages imported symbols are from to generate correct calls. Imported symbols are tagged with the current package, so if they get inlined across a package boundary we'll still know where they're from.ghc8Warn about non-canonical typeclass instance declarationsA "non-canonical" instance definition can occur for instances of a class which redundantly defines an operation its superclass provides as well (c.f. /#). In such cases, a canonical instance is one where the subclass inherits its method implementation from its superclass instance (usually the subclass has a default method implementation to that effect). Consequently, a non-canonical instance occurs when this is not the case.See also descriptions of checkCanonicalMonadInstances and checkCanonicalMonoidInstancesghcRenames role annotations, returning them as the values in a NameEnv and checks for duplicate role annotations. It is quite convenient to do both of these in the same place. See also Note [Role annotations in the renamer]ghc Construct an InstDeclFreeVarsMap by eliminating any Names from the FreeVars" which are *not* the binders of a TyClDecl.ghcGet the  LInstDecls which have empty FreeVars sets, and the InstDeclFreeVarsMap with these entries removed. We call (getInsts tcs instd_map) when we've completed the declarations for tcs. The call returns (inst_decls, instd_map'), where inst_decls are the instance declarations all of whose free vars are now defined instd_map' is the inst-decl map with tcs- removed from the free-var setghcRename injectivity annotation. Note that injectivity annotation is just the part after the "|". Everything that appears before it is renamed in rnFamDecl.ghcBrings pattern synonym names and also pattern synonym selectors from record pattern synonyms into scope.ghcAdditional kind variables to implicitly bind if there is no explicit forall. (See the comments on  all_imp_vars+ below for a more detailed explanation.)ghc.Type variables declared in type family headghcResult signatureghcInjectivity annotation Safe-Inferred& Safe-Inferred 7ghcThe COMPLETE pragmas that are in scope.ghc=Fail with an error message if the type is levity polymorphic.ghcCheck an expression for levity polymorphism, failing if it is levity polymorphic.ghcRuns the thing_inside. If there are no errors, then returns the expr given. Otherwise, returns unitExpr. This is useful for doing a bunch of levity polymorphism checks and then avoiding making a core App. (If we make a core App on a levity polymorphic argument, detecting how to handle the let/app invariant might call isUnliftedType, which panics on a levity polymorphic type.) See #12709 for an example of why this machinery is necessary.ghcIssue an error, but return the expression for (), so that we can continue reporting errors.ghcSee .ghc0Get the current pattern match oracle state. See .ghcRun a  action inside the E monad.ghcRun a  action inside the  monad.ghcRun a & action in the context of an existing ghcInject 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.ghcSet the pattern match oracle state within the scope of the given action. See .ghcEmit a warning for the current source location NB: Warns whether or not -Wxyz is setghcEmit a warning only if the correct WarnReason is set in the DynFlagsghc-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.ghcThe patterns for an equation NB: We have already applied decideBangHood3 to these patterns. See Note [decideBangHood] in GHC.HsToCore.UtilsghcWhat to do after matchghcThis 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.ghcWe represent the case where there is no hole without a function from Y, like this, because sometimes we have nothing to put in the hole and so want to be sure there is in fact no hole.ghcProduct 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.ghc5Build a set of desugarer environments derived from a .ghcheaderghcinformation to outputghc expression6"#$e^e^6"#$ Safe-InferredghcGlobal read-only context and state of the desugarer. The statefulness is implemented through xs.ghc>Local state of the desugarer, extended as we lexically descendghc%To put in pattern-matching error msgsghcTemplate Haskell bindingsghc.See Note [Note [Long-distance information] in GHC.HsToCore.Pmc. The set of reaching values Nablas is augmented as we walk inwards, refined through each pattern match in turnghcDesugaring monad. See also TcM.OO Safe-Inferred'7ghc#Pattern-match coverage check resultghc&A flag saying whether we ran into the maxPmCheckModels limit for the purpose of suggesting to crank it up in the warning message. Writer state.ghc,A hole for redundancy info and covered sets.ghcThe set of uncovered values falling out at the bottom. (for -Wincomplete-patterns, but also important state for the algorithm)ghcA sequence of s.ghc%A guard tree denoting an -XEmptyCase.ghcA guard tree denoting GRHS&: A payload describing the grds and a Ѷ/ useful for printing out in warnings messages.ghcA guard tree denoting GRHSs : A bunch of % guards for local bindings from the GRHSss where clauses and the actual list of GRHS=. See Note [Long-distance information for HsLocalBinds] in GHC.HsToCore.Pmc.Desugar.ghcA very simple language for pattern guards. Let bindings, bang patterns, and matching variables against flat constructor patterns. The LYG guard language.ghcPmBang x corresponds to a  seq x True guard. If the extra Ѷ is present, the bang guard came from a source bang pattern, in which case we might want to report it as redundant. See Note [Dead bang patterns] in GHC.HsToCore.Pmc.Check.ghcPmCon x K dicts args corresponds to a K dicts args <- x guard. The args" are bound in this construct, the x0 is just a use. For the arguments' meaning see .ghc PmLet x expr corresponds to a  let x = expr guard. This actually binds x.ghcA guard tree denoting Match5: A payload describing the pats and a bunch of GRHS.öghcA guard tree denoting  MatchGroup.Ŷghc(A guard tree denoting a pattern binding.ǶghcUsed as tree payload post-checking. The redundancy info we elaborated.ȶghc;Used as tree payload pre-checking. The LYG guards to check.̶ghcRedundancy sets, used to determine redundancy of RHSs and bang patterns (later digested into a CIRB).ζghcIf any of the ߵ is empty, the corresponding Ѷ pin-points a bang pattern in source that is redundant. See Note [Dead bang patterns].϶ghcThe Covered= set; the set of values reaching a particular program point.жghcThe  Diverging set; empty if no match can lead to divergence. If it wasn't empty, we have to turn redundancy warnings into inaccessibility warnings for any subclauses.ѶghcMeans by which we identify a source construct for later pretty-printing in a warning message.  for the equation to show,  for the location.ضghcFormat LYG guards as | True <- x, let x = 42, !zܶghcShould not be user-facing.ghcFormat a LYG sequence (e.g. Matches of a  MatchGroup or GRHSs) as {  firstalt; ...;  lastalt }OŵƵǵȵɵʵ˵̵͵εϵеѵҵӵԵյֵ׵ڵصٵ۵޵ܵݵߵ¶öĶŶƶǶȶɶʶ˶̶Ͷζ϶жѶҶ1ѶҶöĶ¶Ŷƶ̶Ͷζ϶жɶʶ˶ȶǶ Safe-Inferred2ɡ%ƵghcWhether there is a  in the  that compares  to the given  according to ȵ.ȵghc'We can't in general decide whether two ?s match the same set of values. In addition to the reasons in  and , a 2 might or might not represent the same value as a 1. See Note [Undecidable Equality for PmAltCons]. Just True ==> Surely equal Just False. ==> Surely different (non-overlapping, even!)Nothing" ==> Equality relation undecidable.Examples (omitting some constructor wrapping):/eqPmAltCon (LitInt 42) (LitInt 1) == Just False: Lit equality is decidable0eqPmAltCon (DataCon A) (DataCon B) == Just False": DataCon equality is decidable4eqPmAltCon (LitOverInt 42) (LitOverInt 1) == Nothing$: OverLit equality is undecidable-eqPmAltCon (PatSyn PA) (PatSyn PB) == Nothing#: PatSyn equality is undecidable-eqPmAltCon (DataCon I#) (LitInt 1) == Nothing: DataCon to Lit comparisons are undecidable without reasoning about the wrapped Int#5eqPmAltCon (LitOverInt 1) (LitOverInt 1) == Just True2: We assume reflexivity for overloaded literals/eqPmAltCon (PatSyn PA) (PatSyn PA) == Just True/: We assume reflexivity for Pattern Synonyms͵ghcIs a match on this constructor forcing the match variable? True of data constructors, literals and pattern synonyms (#17357), but not of newtypes. See Note [Coverage checking Newtype matches] in GHC.HsToCore.Pmc.Solver.Եghc Type of a ֵghc Type of a ׵ghcSee .۵ghcA normalised refinement type D ("nabla"), comprised of an inert set of canonical (i.e. mutually compatible) term and type constraints that form the refinement type's predicate.ݵghc"Term oracle; things like x~Nothing޵ghcType oracle; things like a~IntߵghcA disjunctive bag of ۵"s, representing a refinement type.ghc)Represents the head of a match against a N or literal. Really similar to Y.ghcUndecidable semantic equality result. See Note [Undecidable Equality for PmAltCons]ghcLiterals (simple and overloaded ones) for pattern match checking.-See Note [Undecidable Equality for PmAltCons]ghc A data type that caches for the  of x the results of querying dsGetCompleteMatches* and then striking out all occurrences of K for which we already know x D K from these sets.For motivation, see Section 5.3 in Lower Your Guards. See also Note [Implementation of COMPLETE pragmas]ghcThe residual sets for all COMPLETE sets from pragmas that are visible when compiling this module. Querying that set with dsGetCompleteMatches requires DsM, so we initialise it with K until first needed in a DsM context.ghcThe residual set for the vanilla COMPLETE set from the data defn. Tracked separately from , because it might only be known much later (when we have enough type information to see the  ? of the match), or not at all even. Until that happens, it is K.ghcThe term oracle state. Stores  for encountered s. These entries are possibly shared when we figure out that two variables must be equal, thus represent the same set of values.!See Note [TmState invariants] in GHC.HsToCore.Pmc.Solver.ghcWhich  needs to be checked for inhabitants because of new negative constraints (e.g. x D E or x D K).ghcFacts about term variables. Deterministic env, so that we generate deterministic error messages.ghcAn environment for looking up whether we already encountered semantically equivalent expressions that we want to represent by the same  representative.ghcThe type oracle state. An  that we incrementally add local type constraints to, together with a sequence number that counts the number of times we extended it with new facts.ghcInformation about an . Stores positive () facts, like  x ~ Just 42, and negative (5) facts, like "x is not (:)". Also caches the type (vi_ty), the  of a COMPLETE set ().+Subject to Note [The Pos/Neg invariant] in GHC.HsToCore.Pmc.Solver.ghc8Can this variable be E? Models (mutually contradicting) x ~ E and x D E constraints. E.g. * ڵ: Don't know; Neither x ~ E nor x D E. * ص: x ~ E * ٵ: x D EghcThe  in question. Important for adding new constraints relative to this  when we don't easily have the  available.ghcNegative info: A list of *s that it cannot match. Example, assuming 0 data T = Leaf Int | Branch T T | Node Int T then x D [Leaf, Node] means that x cannot match a Leaf or Node, and hence can only match Branch!. Is orthogonal to anything from , in the sense that ȵ returns PossiblyOverlap for any pairing between  and .ghcPositive info:  apps it is (i.e. x ~ [Just y, PatSyn z]), all at the same time (i.e. conjunctive). We need a list because of nested pattern matches involving pattern synonym case x of { Just y -> case x of PatSyn z -> ... } However, no more than one RealDataCon in the list, otherwise contradiction because of generativity.ghcA cache of the associated COMPLETE sets. At any time a superset of possible constructors of each COMPLETE set. So, if it's not in here, we can't possibly match on it. Complementary to . We still need it to recognise completion of a COMPLETE set efficiently for large enums.ghcSyntactic equality.ghcSyntactic equality.ghc/Undecidable equality for values represented by 1s. See Note [Undecidable Equality for PmAltCons] Just True ==> Surely equal Just False. ==> Surely different (non-overlapping, even!)Nothing" ==> Equality relation undecidableghcNot user-facing.ghcNot user-facing.ghcNot user-facing.ghc+An initial nabla that is always satisfiableghc!Initial state of the term oracle.ghcWhen  can be decided. True  = Equal, False  = Disjoint.ghc/Undecidable equality for values represented by N4s. See Note [Undecidable Equality for PmAltCons]. Ns aren't enforced to be generative, so two syntactically different Ns might match the exact same values. Without looking into and reasoning about the pattern synonym's definition, we can't decide if their sets of matched values is different. Just True ==> Surely equal Just False. ==> Surely different (non-overlapping, even!)Nothing" ==> Equality relation undecidableOŵƵǵȵɵʵ˵̵͵εϵеѵҵӵԵյֵ׵صٵڵ۵ܵݵ޵ߵ׵صٵڵ۵ܵݵ޵ߵ˵OʵεֵԵ͵ҵǵ̵Ƶɵӵȵϵеѵյŵ Safe-InferredghcReplace the body of the function with this block to test the hsExprType function in GHC.Tc.Utils.Zonk: putSrcSpanDs loc $ do { core_expr <- dsExpr e ; if debugIsOn && not ( exprType core_expr F= hsExprType e -- ) then (assertPprPanic "compiler.GHCHsToCoreExpr.hs" 249 ( ppr e  + dcolon  +8 ppr (hsExprType e) $$ -- ppr core_expr  + dcolon  ++ ppr (exprType core_expr) )) else return ()ghc Variant of  that ensures that the result is not levity polymorphic. This should be used when the resulting expression will be an argument to some other function. See Note [Levity polymorphism checking] in GHC.HsToCore.Monad/ See Note [Levity polymorphism invariants] in GHC.Coreghc4The longest list length which we will desugar using build.This is essentially a magic number and its setting is unfortunate rather arbitrary. The idea here, as mentioned in Note [Desugaring explicit lists], is to avoid deforesting large static data into large(r) code. Ideally we'd want a smaller threshold with larger consumers and vice-versa, but we have no way of knowing what will be consuming our list in the desugaring impossible to set generally correctly.0The effect of reducing this number will be that build fusion is applied less often. From a runtime performance perspective, applying build more liberally on "moderately" sized lists should rarely hurt and will often it can only expose further optimization opportunities; if no fusion is possible it will eventually get rule-rewritten back to a list). We do, however, pay in compile time.ghcTakes a (pretty-printed) expression, a function, and its instantiated type. If the function is a hasNoBinding op, and the type has levity-polymorphic arguments, issue an error. Note [Checking for levity-polymorphic functions]ghcIs this a hasNoBinding Id with a levity-polymorphic type? Returns the arguments that are levity polymorphic if they are bad; or an empty list otherwise Note [Checking for levity-polymorphic functions]˽˽ Safe-Inferred  ghcUse -XStrict to add a ! or remove a ~ See Note [decideBangHood]ghcOriginal patternghc Scrutineeghc Type of expghc,Alternatives (bndrs *include* tyvars, dicts)ghcticks to add, possiblyghc The patternghc(Expression to which the pattern is boundghcId the rhs is bound to, for desugaring strict binds (see Note [Desugar Strict binds] in GHC.HsToCore.Binds) and all the desugared binds55 Safe-Inferred "ghc 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.ghcVariables 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.ghcType of the case expressionghc.Info about patterns, etc. (type synonym below)ghcDesugared result!ghc Scrutineeghc Match kindghcPattern it should matchghcReturn this if it matchesghcReturn this if it doesn'tghc&The scrutinee the match id is bound toghcFor shadowing warning messagesghcScrutinee. (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 caseghcMatches being desugaredghcResults (usually passed to )ƽǽƽǽ Safe-Inferred ();ghcAdd equalities for the Y 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, but desugars the X first.ghcAdd in-scope type constraints if the coverage checker might run and then run the given action.ghcExhaustive for guard matches, is used for guards in pattern bindings and in MultiIf expressions. Returns the ߵ covered by the RHSs.ghcCheck a list of syntactic 1es (part of case, functions, etc.), each with a Ն and one or more X:  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  and 2.) each of a es & 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].ghc8Check a pattern binding (let, where) for exhaustiveness.ghc Just (Maybe, {L,K})ghcInitialise from 1 (containing all COMPLETE pragmas) if the given  were empty.ghcAdds the declared O from COMPLETE pragmas, as well as the vanilla data defn if it is a !.ghcAdds * the O% from COMPLETE pragmas * and the vanilla O from the data   to the , if not already present.ghcReturn the fields of 3. Returns appropriate defaults in the other cases.ghcGet rid of *outermost* (or toplevel) * type function redex * data family redex * newtypes Behaves like K, but instead of returning a coercion, it returns useful information for issuing pattern matching warnings. See Note [Type normalisation] for details. It also initially -s the type with the bag of local constraints.See % for the meaning of the return value.NB: Normalisation can potentially change kinds, if the head of the type is a type family with a variable result kind. I (Richard E) can't think of a way to cause trouble here, though.ghcReturns M if the argument Z is a fully saturated application of a closed type constructor.Closed type constructors are those with a fixed right hand side, as opposed to e.g. associated types. These are of particular interest for pattern-match coverage checking, because GHC can exhaustively consider all possible forms that values of a closed type can take on.Note that this function is intended to be used to check types of value-level patterns, so as a consequence, the Z= supplied as an argument to this function should be of kind Type.ghcNormalise the given source type to WHNF. If it isn't already in WHNF () , it will normalise the type and then try to step through type family applications, but not data family applications or newtypes.(This is a pretty common case of calling  and it should be efficient.ghc Is the source type in WHNF wrt. ?Returns False if the given type is not a TyCon application, or if the TyCon app head is a type family TyCon. (But not for data family TyCons!)ghcLike lookupVarInfo ts x, but lookupVarInfo ts x = (y, vi)3 also looks through newtype constructors. We have x ~ N1 (... (Nk y)) such that the returned y doesn't have a positive newtype constructor constraint associated with it (yet). The  returned is that of y's representative.Careful, this means that idType x might be different to idType y", even modulo type normalisation!2See also Note [Coverage checking Newtype matches].ghcThe fuel for the inhabitation test. See Note [Fuel for the inhabitation test].ghcAdds new constraints to ۵ and returns K# if that leads to a contradiction.0In terms of the paper, this function models the E_3 function in Figure 7 on batches of  constraints.ghcAdds new type-level constraints by calling out to the type-checker via .ghc'Add some extra type constraints to the  ; return K# if we find a contradiction (e.g.  Int ~ Bool).ghcAllocates a fresh " name for PredTys.ghcAdds a single higher-level  constraint by dispatching to the various oracle functions.In terms of the paper, this function amounts to the constructor constraint case of E_ in Figure 7, which "desugars" higher-level  constraints into lower-level  constraints. We don't have a data type for  constraints and call the corresponding oracle function directly instead.Precondition: The  is not0 a type constraint! These should be handled by  before, through .ghcAdds the constraint x ~ E', e.g. that evaluation of a particular  x$ surely diverges. Quite similar to #, only that it only cares about E.ghcAdds the constraint x ~/ E to ۵. Quite similar to *, but only cares for the E "constructor".ghc Record a x ~/ K$ constraint, e.g. that a particular  x can't take the shape of a  K in the ۵ and return Nothing if that leads to a contradiction. See Note [TmState invariants].ghcAdd a x ~ K tvs args ts constraint. addConCt x K tvs args ts+ extends the substitution with a solution x :-> (K, tvs, args)? if compatible with the negative and positive info we have on x , reject (Nothing ) otherwise.See Note [TmState invariants].ghcAdds a x ~ y constraint by merging the two &s and record the gained knowledge in ۵.Returns Nothing5 when there's a contradiction while merging. Returns  Just nabla when the constraint was compatible with prior facts, in which case nabla; has integrated the knowledge from the equality constraint.See Note [TmState invariants].ghc Inspects a PmCoreCt  let x = e by recording constraints for x based on the shape of the Y e . Examples:For let x = Just (42, z)( we want to record the constraints $x ~ Just a, a ~ (b, c), b ~ 42, c ~ z . See  data_con_app.For let x = unpackCString# "tmp"/ we want to record the literal constraint  x ~ "tmp".For  let x = I# 42 we want the literal constraint x ~ 42'. Similar for other literals. See ŵ.Finally, if we have  let x = e and we already have seen  let y = e, we want to record x ~ y.ghcFinds a representant of the semantic equality class of the given e. Which is the x of a  let x = e' constraint (with e semantically equivalent to e') we encountered earlier, or a fresh identifier if there weren't any such constraints.ghcLike ', but with an effectful modifier actionghcMakes sure the given ۵ is still inhabited, by trying to instantiate all dirty variables (or all variables when the 1 changed) to concrete inhabitants. It returns a ۵ with the *same* inhabitants, but with some amount of work cached (like failed instantiation attempts) from the test.The  D E x inh, judgment form in Figure 8 of the LYG paper.ghcChecks whether the given . needs to be tested for inhabitants. Returns J when we can skip the inhabitation test, presuming it would say "yes" anyway. See Note [Shortcutting the inhabitation test].ghcReturns (Just vi) if at least one member of each ConLike in the COMPLETE set satisfies the oracle9Internally uses and updates the CompleteMatchs in vi_rcm. NB: Does not filter each CompleteMatch with the oracle; members may remain that do not statisfy it. This lazy approach just avoids doing unnecessary work.ghcThe E_{Bot} rule from the paperghcDoes a ! and then tries to look through a data family application to find the representation TyCon, to which the data constructors are attached. Returns the representation TyCon, the TyCon application args and a representational coercion that will be Refl for non-data family apps.ghcThis is the |-Inst rule from the paper (section 4.5). Tries to find an inhabitant in every complete set by instantiating with one their constructors. If there is any complete set where we can't find an inhabitant, the whole thing is uninhabited. It returns the updated  where all the attempted ConLike instantiations have been purged from the , which functions as a cache.ghc instCompleteSet fuel nabla x cls iterates over cls5 until it finds the first inhabited ConLike (as per ). Any failed instantiation attempts of a ConLike are recorded as negative information in the returned ۵, so that later calls to this function can skip repeatedly fruitless instantiation of that same constructor.Note that the returned Nabla is just a different representation of the original Nabla, not a proper refinement! No positive information will be added, only negative information from failed instantiation attempts, entirely as an optimisation.ghcIs this ! trivially inhabited, that is, without needing to perform any inhabitation testing because of strict/unlifted fields or type equalities? See Note [DataCons that are definitely inhabitable]ghc'All these types are trivially inhabitedghc"instCon fuel nabla (x::match_ty) K tries to instantiate x to K. by adding the proper constructor constraint.#See Note [Instantiating a ConLike].ghcmatchConLikeResTy _ _ ty K tries to match ty against the result type of K, res_ty. It returns a substitution s for K's universal tyvars such that  s(res_ty) equals ty if successful.Make sure that ty is normalised before.2See Note [Matching against a ConLike result type].˵۵ߵɼʼ˼̼ͼμϼмѼҼӼԼռּ۵ߵ˵ͼμϼмѼҼӼԼռּɼʼ̼˼ Safe-Inferred#ټghcPretty-print the guts of an uncovered value vector abstraction, i.e., its components and refutable shapes associated to any mentioned variables. Example for )([Just p, q], [p :-> [3,4], q :-> [0,5]]): (Just p) q where p is not one of {3, 4} q is not one of {0, 5} When the set of refutable shapes contains more than 3 elements, the additional elements are indicated by "...".ghcThe result of .ghc5Output refutable shapes of a variable in the form of "var is not one of {2, Nothing, 3}. Will never print more than 3 refutable shapes, the tail is indicated by an ellipsis.ghcExtract and assigns pretty names to constraint variables with refutable shapes.ghc*Allocates a new, clean name for the given ! if it doesn't already have one.ghcPretty print a variable, but remember to prettify the names of the variables that refer to neg-literals. The ones that cannot be shown are printed as underscores.ghcExtract a list of s out of a sequence of cons cells, optionally terminated by a wildcard variable instead of []. Some examples:pmExprAsList (1:2:[]) == Just ( [1,2]), a regular, [].-terminated list. Should be pretty-printed as [1,2].pmExprAsList (1:2:x) == Just ( [1,2] x), a list prefix ending in a wildcard variable x (of list type). Should be pretty-printed as (1:2:_). pmExprAsList [] == Just ( [])ټټ Safe-Inferred ())ghcDesugar the non-empty es of a X.ghc.Smart constructor that eliminates trivial letsghcADT constructor pattern => no existentials, no local constraintsghcCreates a '[PmGrd]' refining a match var of list type to a list, where list fields are matched against the incoming tagged '[PmGrd]'s. For example: )mkListGrds "a" "[(x, True <- x),(y, !y)]" to 2"[(x:b) <- a, True <- x, (y:c) <- b, !y, [] <- c]" where b and c are freshly allocated in  mkListGrds and a is the match variable.ghc2Create a '[PmGrd]' refining a match variable to a .ghcdesugarPat _ x pat transforms pat into a '[PmGrd]', where the variable representing the match is x.ghc-, but also select and return a new match var.ghc-, but also select and return a new match var.ghc desugarListPat _ x [p1, ..., pn] is basically 6desugarConPatOut _ x $(mkListConPatOuts [p1, ..., pn]> without ever constructing the  ConPatOuts.ghcDesugar a constructor patternghc.Desugar a guarded right-hand side to a single GrdTreeghc(Desugar a guard statement to a '[PmGrd]'ghc%Desugar local bindings to a bunch of ! guards. Deals only with simple let or where bindings without any polymorphism, recursion, pattern bindings etc. See Note [Long-distance information for HsLocalBinds].ghcDesugar a pattern guard pat  -e == let x = e; guards for pat <- xghcDesugar a boolean guard e ==> let x = e; True <- x Safe-Inferred/3 ghcPost-typechecker, the X field of an Ć8 contains (an expression for) the literal value itself.ghc Warns about  [2,3 .. 1] or [b .. a] which return the empty list. For numeric literals, only works for integral types, not floating point.ghcEmit warnings on integral literals which overflow the bounds implied by their type.ghcEmit warnings on overloaded integral literals which overflow the bounds implied by their type.ghc'See Note [FractionalLit representation]ghcEmit warnings on integral literals which overflow the bounds implied by their type.ghcSee if the expression is an * literal.ghcIf *, extract the value and type of the overloaded literal. See Note [Literals and the OverloadedLists extension]ghcIf *;, extract the value and type of the non-overloaded literal.ghc5Extract the Char if the expression is a Char literal.ghcConvert a pair (Integer, Type) to (Integer, Name) after eventually normalising the typeghcConvert a pair (Integer, Type) to (Integer, Name) without normalising the typeghc!Type of the whole case expressionghc All PgLitsghc'the literal value and name of its tycon   Safe-Inferred 4/ghcDesugar 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]ghcDesugar top level binds, strict binds are treated like normal binds since there is no good time to force before first usage.ghc7Desugar a single binding (or group of recursive binds).ghcThis is where we apply INLINE and INLINABLE pragmas. All we need to do is to attach the unfolding information to the Id.5Other decisions about whether to inline are made in calcUnfoldingGuidance but the decision about whether to then expose the unfolding in the interface file is made in  using this information.ghc Returns a CoreExpr :: TypeRep tyghcThe Ids of strict binds, to be forced in the body of the binding group see Note [Desugar Strict binds] and all bindings and their desugared right hand sides.ghc EvTerm for  Typeable tyghc The type tyghcReturn CoreExpr :: TypeRep ty namely  typeRep# dict Remember that typeRep# :: forall k (a::k). Typeable k a -> TypeRep a   Safe-Inferred5.ghc Guarded RHSsghc Type of RHSghcRefined pattern match checking models, one for the pattern part and one for each GRHS. Safe-Inferred ()79H޼ghc*Coverage checking action. Can be composed  or .ghc Composes ޼s top-to-bottom: If a value falls through the resulting action, then it must fall through the first action and then through the second action. If a value matches the resulting action, then it either matches the first action or matches the second action. Basically the semantics of the LYG branching construct.ghc Composes ޼s left-to-right: If a value falls through the resulting action, then it either falls through the first action or through the second action. If a value matches the resulting action, then it must match the first action and then match the second action. Basically the semantics of the LYG guard construct.ghcthrottle limit old new returns old if the number of ۵s in new is exceeding the given limit and the old number of ۵-s. See Note [Countering exponential blowup].ڼۼܼݼ޼߼޼߼ܼۼݼڼ Safe-Inferred9ĽŽĽŽ Safe-Inferred0@ ghcConstruct the functions which will apply the relevant part of the QuoteWrapper to identifiers during desugaring.ghc+Represent result signature of a type familyghcRepresent result signature using a Maybe Kind. Used with data families, where the result signature can be either missing or a kind but never a named result variable.ghc1Represent injectivity annotation of a type familyghcIf a type implicitly quantifies its outermost type variables, return M if the list of implicitly bound type variables is empty. If a type explicitly quantifies its outermost type variables, always return M.This is used in various places to determine if a Template Haskell Z should be headed by a ForallT or not.ghcIf a type explicitly quantifies its outermost type variables, return M if the list of explicitly bound type variables is empty. If a type implicitly quantifies its outermost type variables, always return M.This is used in various places to determine if a Template Haskell Z should be headed by a ForallT or not.ghc Represent a type variable binderghc#Represent a type wrapped in a Maybeghc:Construct Core expression for Nothing of a given type nameghc5Construct Core expression for Nothing of a given typeghc:Store given Core expression in a Just of a given type nameghc5Store given Core expression in a Just of a given typeghc5This is Nothing only when we are dealing with a VarBrghc%Name of the TyCon of the element typeghcThe element typeghc%Name of the TyCon of the element typeghcThe element type Safe-InferredALghc'the desugared rhs of the bind statementghc S in (>>=) :: Q -> (R -> S) -> TȽɽȽɽ Safe-InferredAʽʽ Safe-Inferred Cghc A variant of tcPat that takes a custom originghc:Convenient wrapper for calling a matchExpectedXXX functionghcCheck that a pattern isn't a GADT, or doesn't have existential variables, in a situation in which that is not permitted (inside a lazy pattern, or in arrow notation).ghc(origin to use if the type needs inst'ingghcFully refined result typeghcTranslated patternghc existentialsghcargument types   Safe-InferredDfghc0If there are no wildcards, return a LHsSigWcType*ͨΨϨШѨҨӨԨը*ͨΨϨШѨҨӨԨը Safe-Inferred$%.EghcType-check a MatchGroup. Safe-Inferred()0F޺ghcThis name really is ambiguous, so add a suitable "ambiguous occurrence" error, then continue/޺ߺ/ߺ޺ Safe-Inferred IEghc PatSyn NameghcPatSyn type (UniBidirExplicitBidir)ghc Whether infixghcPattern of the PatSynghcPattern arguments and typesghc Pattern type ghc*->*ghc;Typechecking for case command alternatives. Used for both  and .ghc2Type-checked Arrow class methods (arr, (>>>), ...)ghctype of the scrutineeghccase alternatives Safe-Inferred ()0Nx Safe-Inferred \ghcCompares two things for equivalence between boot-file and normal code, reporting an error if they don't match up.ghcCompares 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)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.Extract the renamed information from TcGblEnv.ghc:tcRnExpr just finds the type of an expression for :typeghc8Find all the Names that this RdrName could mean, in GHCighc1Top level entry point for typechecker and renamerghcThe 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 ().ghc3How should we infer a type? See Note [TcRnExprMode]ghcInstantiate all quantifiers, and do eager defaulting (:type +d)ghc-Instantiate inferred quantifiers only (:type)ghc9A plan is an attempt to lift some code into the IO monad.ghcRuns TH finalizers and renames and typechecks the top-level declarations that they could introduce.ghc%Combines two potential error messagesghc9If the test in the first parameter is True, succeed with Nothing'; otherwise, return the provided checkghcRun the check provided for every pair of elements in the lists. The provided SDoc should name the element type, in the plural.ghc9If the test in the first parameter is True, succeed with Nothing'; otherwise, fail with the given SDoc.ghcA more perspicuous name for Nothing, for  checkBootDecl and friends.ghcWarn on local definitions of names that would clash with future Prelude elements.A name clashes if the following criteria are met: 1. It would is imported (unqualified) from Prelude 2. It is locally defined in the current module 3. It has the same literal name as the reference function 4. It is not identical to the reference functionghcGet the unqualified name of the function to use as the "main" for the main module. Either returns the default name or the one configured on the command line with -main-isghcTry the plans in order. If one fails (by raising an exn), try the next. If one succeeds, take it.ghcTypecheck (and lift4) a stmt entered by the user in GHCi into the GHCi  environment.By lift and 'environment we mean that the code is changed to execute properly in an IO monad. See Note [Interactively-bound Ids in GHCi] in GHC.Driver.Env for more details. We do this lifting by trying different ways (plans) of lifting the code into the IO monad and type checking each plan until one succeeds.ghcTypecheck the statements given and then return the results of the statement in the form 'IO [()]'.ghcGenerate a typed ghciStepIO expression (ghciStep :: Ty a -> IO a)ghc!Dump, with a banner, if -ddump-rnghcTrue  =& an hs-boot file (could also be a sig)ghcInstances of this ...ghc should also be instances of this!߬ƺǺɺ̺ͺϺк!Ǻɺƺͺк̺Ϻ߬0 Safe-Inferred`JghcPretty-prints a K8 (type/data family instance) with its defining location.ghcPretty-prints a !.ghcPretty-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.ghcPretty-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.ghcLike !, but adds the defining location.ghcPretty-prints a ! with its defining location. Safe-InferredbghcFully 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.ghcMake an interface from the results of typechecking only. Useful for non-optimising compilation, or where we aren't generating any object code at all ( ). Safe-Inferredoӻghc1Add fingerprints for top-level declarations to a .$See Note [Fingerprinting IfaceDecls]ԻghcTop level function to check if the version of an old interface file is equivalent to the current source file the user asked us to compile. If the same, we can avoid recompilation. We return a tuple where the first element is a bool saying if we should recompile the object file and the second is maybe the interface file, where Nothing means to rebuild the interface file and not use the existing one.׻ghcThe .hs file has been touched, or the .o/.hi file does not existػghcThe .o/.hi files are up to date, but something else has changed to force recompilation; the String says what (one-line summary)ٻghc7everything is up to date, recompilation is not requiredghc$Check if a module is still the same version.This function is called in the recompilation checker after we have determined that the module M being checked hasn't had any changes to its source file since we last compiled M. So at this point in general two things may have changed that mean we should recompile M: * The interface export by a dependency of M has changed. * The compiler flags specified this time for M have changed in a manner that is significant for recompilation. We return not just if we should recompile the object file but also if we should rebuild the interface file.ghc1Check if any plugins are requesting recompilationghcCheck if an hsig file needs recompilation because its implementing module has changed.ghc Check if .hie file is out of date or missing.ghcCheck the flags haven't changedghc,Check the optimisation flags haven't changedghc#Check the HPC flags haven't changedghcGiven the usage information extracted from the old M.hi file for the module being compiled, figure out whether M needs to be recompiled.ghcRetrieve the orphan hashes  for a list of modules (in particular, the orphan modules which are transitively imported by the current module).Q: Why do we need the hash at all, doesn't the list of transitively imported orphan modules suffice?A: If one of our transitive imports adds a new orphan instance, our export hash must change so that modules which import us rebuild. If we just hashed the [Module], the hash would not change even when a new instance was added to a module that already had an orphan instance.Q: Why don't we just hash the orphan hashes of our direct dependencies? Why the full transitive closure?!A: Suppose we have these modules:module A where instance Show (a -> b) where module B where import A -- ** module C where import A import BWhether or not we add or remove the import to A in B affects the orphan hash of B. But it shouldn't really affect the orphan hash of C. If we hashed only direct dependencies, there would be no way to tell that the net effect was a wash, and we'd be forced to recompile C and everything else.ghcCreates cached lookup for the  field of ModIface Hackily, we use "module" as the OccName for any module-level annotationsӻԻջֻ׻ػٻԻֻ׻ػٻջӻ Safe-Inferred ~ ƺghcGiven 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.ǺghcǺ, but in a convenient form for GHC.Driver.Make and  GHC.Tc.Module.Ⱥghc For a module modname of type , 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.˺ghcLike 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.̺ghcGiven , instantiate a  from the indefinite library to use the actual implementations of the relevant entities, checking that the implementation matches the signature.ͺghcGiven a local ), merge all inherited requirements from S) into this signature, producing a final ? that matches the local signature and all required signatures.κghcTop-level driver for signature instantiation (run when compiling an hsig file.)ϺghcTop-level driver for signature instantiation (run when compiling an hsig file.)кghcTop-level driver for signature merging (run after typechecking an hsig file).ghcGiven a n. of an instantiated signature (note that the n must be knot-tied consistently with the actual implementation) and a + constructed from the implementor of this interface, verify that the actual implementation actually matches the original interface.Note that it is already assumed that the implementation *exports* a sufficient set of entities, since otherwise the renaming and then typechecking of the signature  would have failed.ghc Checks if a m is "defined". In general, for hsig files we can't assume that the implementing file actually implemented the instances (they may be reexported from elsewhere). Where should we look for the instances? We do the same as we would otherwise: consult the EPS. This isn't perfect (we might conclude the module exports an instance when it doesn't, see #9422), but we will never refuse to compile something.ghc The list of s of *non-exported* ds which this d may refer to. A non-exported d1 should be kept after thinning if an *exported* d (or , perhaps) refers to it; we can't decide to keep it by looking at the exports of a module after thinning. Keep this synchronized with  rnIfaceDecl.ghcCheck if module implements a signature. (The signature is always un-hashed, which is why its components are specified explicitly.) ƺǺȺɺʺ˺̺ͺκϺк ȺǺʺɺ˺ƺκкͺϺ̺ Safe-Inferred !ghcGiven a resolved name in the children export list and a parent. Decide whether we are allowed to export the child with the parent. Invariant: gre_par == NoParent See note [Typing Pattern Synonym Exports]ghcK means no explicit export listghc-Imported modules; this is used to test if a  module Foo6 export is valid (it's not valid if we didn't import Foo!)ghc5Alleged parent type constructor User wrote T( P, Q )ghcEither a a) Pattern Synonym Constructor b) A pattern synonym selector Safe-Inferred һghcUse DerivInfo for data family instances (produced by tcInstDecls1), datatype declarations (TyClDecl), and standalone deriving declarations (DerivDecl) to check and process all derived class instances.ѻһһѻ Safe-InferredٺghcConstruct default instances for any associated types that aren't given a user definition Returns [] or singleton ҺӺԺպֺ׺غٺںۺܺݺ ܺںӺ׺ۺݺغҺԺպֺٺ Safe-Inferred 'yghcGet the initial kind of a TyClDecl, either generalized or non-generalized, depending on the .ghcMaybe return a list of Bools that say whether a type family was declared injective in the corresponding type arguments. Length of the list is equal to the number of arguments (including implicit kind/coercion arguments). True on position N means that a function is injective in its Nth argument. False means it is not.ghcProduce an "expected kind" for the arguments of a data/newtype. If the declaration is indeed for a newtype, then this expected kind will be the kind provided. Otherwise, it is OpenKind for datatypes and liftedTypeKind. Why do we not check for -XUnliftedNewtypes? See point  ErrorMessages. in Note [Implementation of UnliftedNewtypes]ghcFrom information about a source datacon definition, extract out what the universal variables and the GADT equalities should be. See Note [mkGADTVars].ghcProduce an error for oversaturated type family equations with too many required arguments. See Note [Oversaturated type family equations] in GHC.Tc.Validity.ghc Just cls  =* this is an associated family of class clsghc Just cls  =* this is an associated family of class clsghcFamily TyCon (not knot-tied)ghcDefaultsghcType checked RHSghcThe tycon varsghcThe datacon varsghcThe matching between the template result type and the actual result typeghcThe univ. variables, the GADT equalities, and a subst to apply to the GADT equalities and existentials.»ûĻŻƻǻȻɻʻ˻̻ͻλϻлʻŻȻλϻлĻû˻ǻɻƻ̻»ͻ Safe-Inferred ghc%Stuff needed to process a datatype's  `deriving` clausesghc error contextghcThe data tycon for normal datatypes, or the *representation* tycon for data familiesghc.Variables that scope over the deriving clause.ghc(Process the derived classes in a single deriving clause.ghc Process a single predicate in a deriving clause.This returns a B& because the user might try to derive Typeable, which is a no-op nowadays. Safe-Inferred<&ʷghc Convert a  to its corresponding .ѷghc4Is GHC processing a standalone deriving declaration?ҷghcIs GHC processing a standalone deriving declaration with an extra-constraints wildcard as the context? (e.g., !deriving instance _ => Eq (Foo a))ӷghcӷ wc returns  if wc is M, and ՜ if wc is J. Useful for error-reporting.ܷghcWhether GHC is processing a deriving. clause or a standalone deriving declaration.ݷghc'InferContext mb_wildcard is either:A deriving clause (in which case  mb_wildcard is K).A standalone deriving declaration with an extra-constraints wildcard as the context (in which case  mb_wildcard is L loc, where loc$ is the location of the wildcard.GHC should infer the context.޷ghc޷ theta. is a standalone deriving declaration, where theta& is the context supplied by the user.߷ghcContains all of the information known about a derived instance when determining what its EarlyDerivSpec should be. See &Note [DerivEnv and DerivSpecMechanism].ghc-Class for which we need to derive an instanceghc޷ theta for standalone deriving (where theta( is the context of the instance). ݷ for deriving clauses, or for standalone deriving that uses a wildcard constraint. See %Note [Inferring the instance context].ghcAll arguments to  in the derived instance.ghc Is this an overlapping instance?ghcL if user requests a particular deriving strategy. Otherwise, K.ghc5Universally quantified type variables in the instanceghcInformation about the arguments to the class in a stock- or newtype-derived instance. See &Note [DerivEnv and DerivSpecMechanism].ghc,Other arguments to the class except the lastghcThe representation tycon for 7 (for data family instances). Otherwise the same as .ghcThe representation types for 7 (for data family instances). Otherwise the same as .ghcType constructor for which the instance is requested (last arguments to the type class)ghc!Arguments to the type constructorghc0To avoid having to manually plumb everything in ߷" throughout various functions in  GHC.Tc.Deriv and GHC.Tc.Deriv.Infer , we use #, which is a simple reader around .ghc>What action to take in order to derive a class instance. See &Note [DerivEnv and DerivSpecMechanism], as well as Note [Deriving strategies] in  GHC.Tc.Deriv.ghc DeriveAnyClassghc GeneralizedNewtypeDerivingghc"Standard" classesghc  DerivingViaghcInformation 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].ghcThe newtype rep type.ghcInformation about the arguments to the class in the derived instance, including what type constructor the last argument is headed by. See &Note [DerivEnv and DerivSpecMechanism].ghc"This function returns four things: LHsBinds GhcPs6: The derived instance's function bindings (e.g., !compare (T x) (T y) = compare x y) [LSig GhcPs]: A list of instance specific signatures/pragmas. Most likely INLINE pragmas for class methods. BagDerivStuff: Auxiliary bindings needed to support the derived instance. As examples, derived Generic instances require associated type family instances, and derived ' and .! instances require top-level con2tag functions. See Note [Auxiliary binders] in GHC.Tc.Deriv.Generate.[Name]: A list of Names for which -Wunused-binds should be suppressed. This is used to suppress unused warnings for record selectors when deriving /, 3, or Generic . See +Note [Deriving and unused record selectors].ghc0All arguments to the class besides the last one.ghcThe last argument to the class.ghcThe via typeghcRecords 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.ghcA !- annotated with the origin of the constraint ͜9, and whether or the constraint deals in types or kinds.ghcA list of wanted  constraints () to simplify when inferring a derived instance's context. These are used in all deriving strategies, but in the particular case of DeriveAnyClass5, we need extra information. In particular, we need:, the list of type variables bound by a class method's regular type signature, which should be rigid., the list of type variables bound by a class method's default type signature. These can be unified as necessary., the list of constraints from a class method's regular type signature, which can be used to help solve constraints in the . (Note that  will likely contain type variables from the derived type class or data type, neither of which will appear in  or .)?For all other deriving strategies, it is always the case that , , and  are empty.&Here is an example to illustrate this: class Foo a where bar :: forall b. Ix b => a -> b -> String default bar :: forall y. (Show a, Ix y) => a -> y -> String bar x y = show x ++ show (range (y, y)) baz :: Eq a => a -> a -> Bool default baz :: Ord a => a -> a -> Bool baz x y = compare x y == EQ data Quux q = Quux deriving anyclass Foo Then it would generate two s, one for each method: [ ThetaOrigin { to_anyclass_skols = [b] , to_anyclass_metas = [y] , to_anyclass_givens = [Ix b] , to_wanted_origins = [ Show (Quux q), Ix y , (Quux q -> b -> String) ~ (Quux q -> y -> String) ] } , ThetaOrigin { to_anyclass_skols = [] , to_anyclass_metas = [] , to_anyclass_givens = [Eq (Quux q)] , to_wanted_origins = [ Ord (Quux q) , (Quux q -> Quux q -> Bool) ~ (Quux q -> Quux q -> Bool) ] } ] (Note that the type variable q is bound by the data type Quux", and thus it appears in neither  nor .)See ?Note [Gathering and simplifying constraints for DeriveAnyClass] in GHC.Tc.Deriv.Infer for an explanation of how  are determined in DeriveAnyClass, as well as how , , and  are used.ghcSome common validity checks shared among stock derivable classes. One check that absolutely must hold is that if an instance C (T a) is being derived, then T must be a tycon for a data type or a newtype. The remaining checks are only performed if using a deriving) clause (i.e., they're ignored if using StandaloneDeriving): The data type must have at least one constructor (this check is ignored if using EmptyDataDeriving).0The data type cannot have any GADT constructors.The data type cannot have any constructors with existentially quantified type variables.+The data type cannot have a context (e.g., data Foo a = Eq a => MkFoo).8The data type cannot have fields with higher-rank types.ghcFor some classes (eg ', .) we allow unlifted arg types by generating specialised code. For others (eg Data!) we don't. For even others (eg Lift7), unlifted types aren't even a special consideration!ghcThe data type's  ). For data families, this is the family  .ghc.For data families, this is the representation  ,. Otherwise, this is the same as the other   argument.ghcS" if deriving an instance for this   is possible. Otherwise, it's S err, where err explains what went wrong.ghc޷? if this is standalone deriving with a user-supplied context, ݷ if not. If it is the former, we relax some of the validity checks we would otherwise perform (i.e., "just go for it").ghcM  = allow higher rank arguments and empty data types (with no data constructors) even in the absence of the -XEmptyDataDeriving extension.ȷɷʷ˷̷ͷηϷзѷҷӷԷշַ׷طٷڷ۷ܷݷ޷߷߷ٷʷϷηͷзܷݷ޷ѷҷӷԷշַ۷ɷ̷ȷڷط׷˷ Safe-Inferred zghcSee documentation of ; that function uses the fields of this type to interpret the structure of a type when that type is considered as an argument to a constructor that is being represented with Rep1.ghc argTyFold3 implements a generalised and safer variant of the arg function from Figure 3 in  (http://dreixel.net/research/pdf/gdmh.pdf. arg is conceptually equivalent to: arg t = case t of _ | isTyVar t -> if (t == argVar) then Par1 else Par0 t App f [t'] | representable1 f && t' == argVar -> Rec1 f App f [t'] | representable1 f && t' has tyvars -> f :.: (arg t') _ -> Rec0 twhere argVar is the last type variable in the data type declaration we are finding the representation for. argTyFold is more general than arg because it uses . to abstract out the concrete invocations of Par0, Rec0, Par1, Rec1, and :.:. argTyFold is safer than arg because arg would lead to a GHC panic for some data types. The problematic case is when t0 is an application of a non-representable type f to argVar: App f [argVar] is caught by the _% pattern, and ends up represented as Rec0 t. This type occurs free in the RHS of the eventual Rep1 instance, which is therefore ill-formed. Some representable1 checks have been relaxed, and others were moved to canDoGenerics1.ghc-Variant of foldr for producing balanced lists·÷ķŷƷǷ·ŷƷǷ÷ķ Safe-Inferred 0NghcTake a  and partition it into . Also generate the code for auxiliary bindings based on the declarative descriptions in the supplied s. See Note [Auxiliary binders].ghc$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]ghcProduces 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.ghcProduces 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.ghcGiven a type constructor tycon of arity n and a list of argument types  tycon_args of length m, !tyConInstArgTys tycon tycon_args returns [tycon_arg_{1}, tycon_arg_{2}, ..., tycon_arg_{m}, extra_arg_{m+1}, ..., extra_arg_{n}] where  extra_args are distinct type variables. Examples:Given tycon: Foo a b and tycon_args: [Int, Bool] , return  [Int, Bool].Given tycon: Foo a b and tycon_args: [Int] , return [Int, b].ghc6A new, top-level auxiliary binding. Used for deriving ', ., &, Ix, and Data. See Note [Auxiliary binders].ghc%A new type family instance. Used for: DeriveGeneric, which generates instances of Rep(1)DeriveAnyClass3, which can fill in associated type family defaultsGeneralizedNewtypeDeriving, which generates instances of associated type families for newtypesghcA 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.ghc$tag2con:: Given a tag, computes the corresponding data constructorghc$maxtag: The maximum possible tag value among a data type's constructorsghc$t: The DataType representation for a Data instanceghc$c: The Constr representation for a Data instanceghc Retrieve the +" of the binding that the supplied  describes.ghcshowString :: String -> ShowSghc(showsPrec :: Show a => Int -> a -> ShowSghcshows :: Show a => a -> ShowSghc6Generate the full code for an auxiliary binding. See =Note [Auxiliary binders] (Wrinkle: Reducing code duplication).ghcGenerate the code for an auxiliary binding that is a duplicate of another auxiliary binding. See =Note [Auxiliary binders] (Wrinkle: Reducing code duplication).ghc:Generate the type signature of an auxiliary binding. See Note [Auxiliary binders].ghcMake a function binding. If no equations are given, produce a function with the given arity that produces a stock error.ghcMake a function binding. If no equations are given, produce a function with the given arity that uses an empty case expression for the last argument that is passes to the given function to produce the right-hand side.ghc0A table of postfix modifiers for unboxed values.ghcLookup ! in an association list.ghcLookup ! in an association list.ghc>Generate the name for an auxiliary binding, giving it a fresh . Returns an + + with an underlying System . See Note [Auxiliary binders]. Safe-Inferred Cghc.Type app, variable other than in last argumentghc$The variable itself, contravariantlyghc Forall typeghc Function typeghcDoes not contain variableghcTuple type. The [a]= is the result of folding over the arguments of the tuple.ghc2Type app, variable only in last argument. The two !,s are the function and argument parts of  fun_ty arg_ty, respectively.ghcThe variable itselfghcVariable to look forghc How to foldghcType to process Safe-InferredghcLike #, but used only in the case of the stock deriving strategy. The constraints are inferred by inspecting the fields of each data constructor. In this example: 'data Foo = MkFoo Int Char deriving Show*We would infer the following constraints (s): (Show Int, Show Char)9Note that this function also returns the type variables (s) and class arguments (m>s) for the resulting instance. This is because when deriving ,-like classes, we must sometimes perform kind substitutions to ensure the resulting instance is well kinded, which may affect the type variables and class arguments. In this example: newtype Compose (f :: k -> Type) (g :: Type -> k) (a :: Type) = Compose (f (g a)) deriving stock FunctorWe must unify k with Type in order for the resulting ,+ instance to be well kinded, so we return []/ [Type, f, g] for the sms, not [k] [k, f, g]-. See Note [Inferring the instance context].ghcLike , but used only in the case of DeriveAnyClass, which gathers its constraints based on the type signatures of the class's methods instead of the types of the data constructor's field.See Note [Gathering and simplifying constraints for DeriveAnyClass] for an explanation of how these constraints are used to determine the derived instance context.ghcGiven instance (wanted) => C inst_ty , simplify wanted, as much as possible. Fail if not possible.ghc C inst_ty, head of the instance we are deriving. Only used for SkolemInfo.ghcThe tyvars bound by inst_ty.ghcGiven and wanted constraintsghc1Needed constraints (after simplification), i.e. [!]. Safe-Inferred" Safe-Inferred 'ghcCheck 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.ghc&Checking a supported backend is in useghc&Checking a supported backend is in use Safe-Inferredӡ Safe-Inferredghc=Force the interfaces for the given modules to be loaded. The # parameter is used for debugging (-ddump-if-trace) only: it is shown as the reason why the module is being loaded.ghcForce the interface for the module containing the name to be loaded. The # parameter is used for debugging (-ddump-if-trace) only: it is shown as the reason why the module is being loaded.ghc Load the   associated with the given name, come hell or high water. Fails if:!The interface could not be loadedThe name is not that of a  +The name did not exist in the loaded moduleghc#Loads the value corresponding to a  if that value has the given !. This only provides limited safety in that it is up to the user to ensure that that type corresponds to the type you try to use the return value at!8If the value found was not of the correct type, returns Nothing.. Any other condition results in an exception:%If we could not load the names module(If the thing being loaded is not a value(If the Name does not exist in the moduleIf the link failedghcLoads the plugins specified in the pluginModNames field of the dynamic flags. Should be called after command line arguments are parsed, but before actual compilation starts. Idempotent operation. Should be re-called if pluginModNames or pluginModNameOpts changes.ghcCoerce a value as usual, but:1) Evaluate it immediately to get a segfault early if the coercion was wrong2) Wrap it in some debug messages at verbosity 3 or higher so we can see what happened if it does segfaultghc Finds the  corresponding to the given + in the context of the  . Returns Nothing if no such > could be found. Any other condition results in an exception: If the module could not be found3If we could not determine the imports of the moduleCan only be used for looking up names while loading plugins (and is *not* suitable for use within plugins). The interface file is loaded very partially: just enough that it can be used, without its rules and instances affecting (and being linked from!) the module being compiled. This was introduced by 57d6798.Need the module as well to record information in the interface file   Safe-Inferred$%ghc,Initialise the dynamic linker. This entails*a) Calling the C initialisation procedure,6b) Loading any packages specified on the command line,c) Loading any packages specified on the command line, now held in the -l options in v_Opt_l,d) Loading any .o/.dll7 files specified on the command line, now held in ldInputs, e) Loading any MacOS frameworks.NOTE: This function is idempotent; if called more than once, it does nothing. This is useful in Template Haskell, where we call it before trying to link.ghcLoad a single expression,  including first loading packages and modules that this expression depends on.Raises an IO exception () if it can't find a compiled version of the dependents to load.ghcLoad the module containing the given Name and get its associated . Throws a . if loading fails or the name cannot be found.ghcLoad exactly the specified packages, and their dependents (unless of course they are already loaded). The dependents are loaded automatically, and it doesn't matter what order you specify the input packages.ghcDisplay the loader state.ghc8Unloading old objects ready for a new compilation sweep.The compilation manager provides us with a list of linkables that it considers "stable", i.e. won't be recompiled this time around. For each of the modules current linked in memory,if the linkable is stable (and it's the same one -- the user may have recompiled the module on the side), we keep it,otherwise, we unload it.?we also implicitly unload all temporary bindings at this point.ghc"Temporarily extend the loaded env.ghcMerge runs of consecutive of . This allows for resolution of cyclic symbol references when dynamically linking. Specifically, we link together all of the static objects into a single shared object, avoiding the issue we saw in #13786.ghc#Load the object files and link themIf the interpreter uses dynamic-linking, build a shared library and load it. Otherwise, use the RTS linker.ghcCreate a shared library containing the given object files and load it.ghc!Useful to apply to the result of ghcRetrieve the list of search directory GCC and the System use to find libraries and components. See Note [Fork/Exec Windows].ghcCache for the GCC search directories as this can't easily change during an invocation of GHC. (Maybe with some env. variable but we'll) deal with that highly unlikely scenario then.ghcGet a list of system search directories, this to alleviate pressure on the findSysDll function.ghcMerge the given list of paths with those in the environment variable given. If the variable does not exist then just return the identity.ghcThe linkables to *keep*.kkkkkkkkkkkkkkkkkkkkkkkk Safe-Inferred7ȲɲȲɲ Safe-Inferred'Ʋghc!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.DzghcsptModuleInitCode 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.ƲDzƲDz Safe-Inferredլghc7The header for HIE files - Capital ASCII letters "HIE".֬ghcRead a  from a y. Can use an existing ^.׬ghcRead a  from a y. Can use an existing ^. Allows you to specify which versions of hieFile to attempt to read. N* case returns the failing header versions.جghcWrite a  to the given y., with a proper header and symbol tables for s and  s͟ҟլ֬׬ج٬ڬ۬ܬݬެ֬׬ެجҟ٬ڬ۬ܬݬլ͟ Safe-Inferred!().05νghc Construct an % from the outputs of the typechecker.Ͻghc Construct an  from the outputs of the typechecker but don't read the source file again from disk.ghc Pattern scopeٽghc!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., for example, doesn't have any type information available directly on the node. Our next recourse would be to desugar it into a CoreExpr then query the type of that. Yet both the desugaring call and the type query both involve recursive calls to the function and argument! This is particularly problematic when you realize that the HIE traversal will eventually visit those nodes too and ask for their types again.Since the above is quite costly, we just skip cases where computing the expression's type is going to be expensive. See #16233ghcUsed to collect type infoghccontext for record fieldsghcScope spans over everything to the right of a, (mostly) not including a itself (Includes a in a few special cases like recursive do bindings) or let/where bindingsghcFirst scope remains constant Second scope is used to build up the scope of a tyvar over things to its right, ala RScopedghcThe main worker class See Note [Updating HieAst for changes in the GHC AST] for more information on how to add/modify instances for this.ghccontext for imports/exportsghccontext for type signaturesghccontext for imports/exportsghc#context for pattern synonym fields.ghc2Each element scopes over the elements to the rightghcconveniently calculate locations for things without locations attachedghc specialised to  thingsghc specialised to ghc specialised to  thingsghcuse site of the patternghc*pattern to the right of a, not including a̽ͽνϽνϽͽ̽ Safe-Inferredaghc"Main entry point to the desugarer. Safe-Inferred ɾɾ Safe-Inferred Safe-Inferred, ϲghcCreate a function that converts Bignum literals into their final CoreExprghc.This environment is used for three operations: To support cloning of local Ids so that they are all unique (see item (6) of CorePrep overview).To support beta-reduction of runRW, see Note [runRW magic] and Note [runRW arg].To let us inline trivial RHSs of non top-level let-bindings, see Note [lazyId magic], Note [Inlining in CorePrep] and Note #12076(CorePrep inlines trivial CoreExpr not IdghcConvert some numeric literals (Integer, Natural) into their final Core formghc%See Note [Floating Ticks in CorePrep]ghc Convert a Y so it satisfies , without producing any floats (any generated floats are immediately let-bound using ). Generally you want this, esp. when you've reached a binding form (e.g., a lambda) and floating any further would be incorrect.ghc Convert a Y so it satisfies ; also produce a list of  which are being propagated upwards. In fact, this function is used in only two cases: to implement  (which is what you usually want), and in the case when a let-binding is in a case scrutinee--here, we can always float out:case (let x = y in z) of ... ==> let x = y in case z of ...ghcIs an argument okay to CPE?ghc+Like wrapFloats, but only wraps tick floatsghcCollect cost centres defined in the current module, including those in unfoldings.ͲβϲβͲϲ Safe-InferredIJghcAttempt 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.(Hدׯ֯կԯӯүЯϯίѯIȯɯWXYuv|~}_a`ͯ˯̯TTTTTTTTTTTTTTT RRQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQPPPPPPPPPPPPPPPPQQ PP &&  """"""""""""[[[[[[[[[[[[[[[[[[[[[ <<<<<<<<<<< < !!!!!>>!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!LLLLLLL!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((()))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))**********************************++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++,,,,,,,,,,,,,00000000000000000000000000000000000000J57:::::::::::::::::::::::::::::::::::::::::::::::::::::;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;<;;<;<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>??????????????????????????????????????????????????????????????????????????????@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@DFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGHHHHHHHHHHGGHHHHHHHHHIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLNNNNNNNOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSTTTTTTTTTTTXXXXXXXXXXXXXXXXXXXXYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYZZZZYYYYYYYYYYYZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkloooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooopppppppppppppppppppppppppppppppppppppppppppppppppppޖߖۚܚݚޚߚțǛƛśěÛ›ɛʛ˛¤äĤŤƤǤȤɤʤˤ̤ߤޤݤܤۤڤ٤ؤפ֤դԤӤҤѤФϤΤͤ¯ïįůƯǯʯٯܯگۯݯޯ߯IJ &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&''''''''''''''''''''''''''''''''''''''''''''''''''""""""""""""""""[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\)?@ppppppppppppppppppppppppppppppppppppppppppppppppppp"""""""""""!!!!!!!!!!!!!!!!!!!!!!!!!!!"""""""""""""""":>>>>>>>>>>>>>>>>>>>>>>>>>>>>?????????????????????????????????????????????????????????????@@@@@@@@@@@@@@@@@@@@@@@@@@@@@DFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG!!!>>!!!"""00000000000000000000000000000000000000J>>>>>>>>>>??????????????????@IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJIJ Safe-Inferred9ghcTakes 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 printerghcTerm reconstruction"Given a pointer to a heap object () and its type, build a  representation of the object. Subterms (objects in the payload) are also built up to the given  max_depth. After  max_depth any subterms will appear as s. Any thunks found while traversing the object will be forced based on force parameter.Types of terms will be refined based on constructors we find during term reconstruction. See 3 for an overview of how type reconstruction works.ghc'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] = _ghcTerm Reconstruction traceghcReturns the instantiated type scheme ty', and the mapping from new (instantiated) -to- old (skolem) type variablesghc&How many times to recurse for subtermsghc Force thunksghc!Type of the object to reconstructghcObject to reconstructghc&How many times to recurse for subtermsghcType to refineghc Refine the type using this value   Safe-Inferred<ghcCreate a fresh coercion hole.ghc Create a new derived constraint.ghc!Create a fresh evidence variable.ghcCreate a new given constraint, with the supplied evidence. This must not be invoked from  tcPluginInit or  tcPluginStop, or it will panic.ghcCreate a new wanted constraint.ghc;Bind an evidence variable. This must not be invoked from  tcPluginInit or  tcPluginStop, or it will panic.ghc=Perform some IO, typically to interact with an external tool.µghc)Output useful for debugging the compiler.(TTTTTTTTTTTµõĵ(µTTTTTTTTTTTĵõ Safe-Inferred$%IؿghcCompile an expression, run it, and deliver the resulting HValue.ٿghcCompile an expression, run it, and deliver the resulting HValue.ۿghcCompile a parsed expression (before renaming), run it, and deliver the resulting HValue.ܿghcCompile an expression, run it and return the result as a Dynamic.ݿghcdefault ExecOptions޿ghc3Run a statement in the current interactive context.߿ghcLike ޿, but takes a parsed statement as argument. Useful when doing preprocessing on the AST before execution, e.g. in GHCi (see GHCi.UI.runStmt).ghcGet the type of an expression Returns the type as described by ghcGet 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.ghcLooks up an identifier in the current interactive context (for :info) Filter the instances by the ones whose tycons (or clases resp) are in scope (qualified or otherwise). Otherwise we list a whole lot too many! The exact choice of which ones to show, and which to hide, is a judgement call. (see #1581)ghc=Returns all names in scope in the current interactive contextghc Returns all +s in scope in the current interactive context, excluding any that are internally-generated.ghcReturns True if the specified module is interpreted, and hence has its full top-level scope available.ghcParse an expression, the parsed expression can be further processed and passed to compileParsedExpr.ghc:Parses a string as an identifier, and returns the list of s that the identifier can refer to in the current interactive context.ghcRun some declarations and return any user-visible names that were brought into scope.ghcLike , but takes parsed declarations as argument. Useful when doing preprocessing on the AST before execution, e.g. in GHCi (see GHCi.UI.runStmt).ghc'Set the interactive evaluation context.(setContext imports) sets the ic_imports field (which in turn determines what is in scope at the prompt) to imports>, and constructs the ic_rn_glb_env environment to reflect it.We retain in scope all the things defined at the prompt, and kept in ic_tythings. (Indeed, they shadow stuff from ic_imports.)ghcGet the kind of a typeghcFailure modes for .ghcThe  was defined interactively.ghc' returned K.ghc7This is probably because the module was loaded without -haddock, but it's also possible that the entire module contains no documentation.ghc,Finds the enclosing top level function name ghc=Update fixity environment in the current interactive context.޿ghc a statement (bind or expression)ghcM: The module was compiled. J: The module was :loaded.\\\\\\\\\\\\\\\\\\]]]]]]]]]]]]]]]]]տֿ׿ؿٿڿۿܿݿ޿߿]]]]]]]]]]]]]\\\\\޿߿\\\\\\ݿ\\\\\\\]]]]տֿ׿ڿؿܿٿۿ Safe-Inferred &^A ghcCompileCompile a single module, under the control of the compilation manager.This is the interface between the compilation manager and the compiler proper (hsc), where we deal with tedious details like reading the OPTIONS pragma from the source file, converting the C or assembly that GHC produces into an object file, and compiling FFI stub files.NB. No old interface can also mean that the source has changed.ghcRun CPP1UnitState is needed to compute MIN_VERSION macrosghcComputes the next output filename for something in the compilation pipeline. This is controlled by several variables: !: the last phase to be run (e.g.  stopPhase). This is used to tell if we're in the last phase or not, because in that case flags like -o may be important.: is this intended to be a  or  build output? Temporary files just go in a fresh temporary name.<3: what was the basename of the original input file? : the obvious thing8: the phase we want to determine the output filename of.Maybe ModLocation: the  of the module we're compiling; this can be used to override the default output of an object file. (TODO: do we actually need this?)ghcWhat phase to run after one of the backend code generators has runghc/Computes the next output filename after we run  next_phase. Like , but it operates in the 9 monad (which specifies all of the ambient information.)ghcJust preprocess a file, put the result in a temp. file (used by the compilation manager during the summary phase).We return the augmented DynFlags, because they contain the result of slurping in the OPTIONS pragmasghcEach phase in the pipeline returns the next phase to execute, and the name of the file in which the output was placed.We must do things dynamically this way, because we often don't know what the rest of the phases will be until part-way through the compilation: for example, an {-# OPTIONS -fasm #-} at the beginning of a source file can change the latter stages of the pipeline from taking the LLVM route to using the native code generator.ghc:Run a compilation pipeline, consisting of multiple phases.This is the interface to the compilation pipeline, which runs a series of compilation steps on a single source file, specifying at which stage to stop.The DynFlags can be modified by phases in the pipeline (eg. by OPTIONS_GHC pragmas), and the changes affect later phases in the pipeline.ghc2pipeLoop runs phases until we reach the stop phaseghcLLVM Options. These are flags to be passed to opt and llc, to ensure consistency we list them in pairs, so that they form groups.ghcFigure out if a source file was modified after an output file (or if we anyways need to consider the source file modified since the output is gone).ghcFind out path to  ghcversion.h file ghc!summary for module being compiledghc module N ...ghc... of Mghcold interface, if we have oneghcold linkable, if we have oneghc'the complete HomeModInfo, if successfulghc!summary for module being compiledghc module N ...ghc... of Mghcold interface, if we have oneghcold linkable, if we have one ghc'the complete HomeModInfo, if successfulghcinteractive or batchghcLoggerghc dynamic flagsghcunit environmentghcattempt linking in batch mode?ghc what to linkghcinput filenameghc8optional buffer to use instead of reading the input fileghcstarting phaseghcRun this phaseghcname of the input fileghc dynamic flagsghcunit environmentghcattempt linking in batch mode?ghc what to linkghc When to stopghcCompilation environmentghc>Pipeline input file name, optional buffer and maybe -x suffixghc)original basename (if different from ^^^)ghcOutput filenameghc*A ModLocation, if this is a Haskell moduleghcforeign objectsghc)(final flags, output filename, interface)ghc When to startghcCompilation environmentghcInput filenameghc*A ModLocation, if this is a Haskell moduleghcforeign objects, if we have oneghc)(final flags, output filename, interface)ghcpairs of (opt, llc) argumentsghc#destination file we are looking forghc(last time of modification of source fileghc$do we need to regenerate the output?&|&| Safe-Inferred $%&789"ghcPerform 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.ghc$Perform dependency analysis like in . In case of errors, the errors and an empty module graph are returned.ghc!Perform dependency analysis like  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  this function will not update  with the new module graph.ghcDownsweep (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.ghc Tests if an 9 is a boot file, primarily for constructing elements of . We conflate signatures and modules because they are bound in the same namespace; only boot interfaces can be disambiguated with `import {-# SOURCE #-}`.ghc5Collect the instantiations of dependencies to create  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.ghcTry to load the program. See  for the different modes.+This function implements the core of GHC's --make mode. It preprocesses, compiles and loads the specified modules, avoiding re-compilation wherever possible. Depending on the backend (see  field) compiling and loading may result in files being created on disk. Calls the > after each compiling each module, whether successful or not.If errors are encountered during dependency analysis, the module  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 .ghcGeneralized version of  which also supports a custom Ͽ (for reporting progress) and ! (generally produced by calling .ghc$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 cyclicghc>Describes which modules of the module graph need to be loaded.ghc&Load all targets and its dependencies.ghcLoad only the dependencies of the given module, but not the module itself.ghc0Load only the given module and its dependencies.ghc)A Module and whether it is a boot module.We need to treat boot modules specially when building compilation graphs, since they break cycles. Regular source files and signature files are treated equivalently.ghc?The graph of modules to compile and their corresponding result  and .ghcEach module is given a unique ) to redirect compilation messages to. A K value contains the result of compilation, and denotes the end of the message queue.ghc Convenience named arguments for 5 only used to make code more readable, not exported.ghcStability tells us which modules definitely do not need to be recompiled. There are two main reasons for having stability:avoid doing a complete upsweep of the module graph in GHCi when modules near the bottom of the tree have not changed.to tell GHCi when it can load object code: we can only load object code for a module when we also load object code fo all of the imports of the module. So we need to know that we will definitely not be recompiling any of these modules, and we can use the object code.The stability check is as follows. Both stableObject and stableBCO are used during the upsweep phase later.  stable m = stableObject m || stableBCO m stableObject m = all stableObject (imports m) && old linkable does not exist, or is == on-disk .o && date(on-disk .o) > date(.hs) stableBCO m = all stable (imports m) && date(BCO) > date(.hs) ,These properties embody the following ideas:if a module is stable, then:if it has been compiled in a previous pass (present in HPT) then it does not need to be compiled or re-linked.if it has not been compiled in a previous pass, then we only need to read its .hi file from disk and link it to produce a  ModDetails.if a modules is not stable, we will definitely be at least re-linking, and possibly re-compiling it during the . All non-stable modules can (and should) therefore be unlinked before the .Note that objects are only considered stable if they only depend on other objects. We can't link object code against byte code.Note that even if an object is stable, we may end up recompiling if the interface is out of date because an *external* interface has changed. The current code in GHC.Driver.Make handles this case fairly poorly, so be careful.ghcFinish up after a load.ghcForget the current program, but retain the persistent info in HscEnvghcDiscard the contents of the InteractiveContext, but keep the DynFlags and the loaded plugins. It will also keep ic_int_print and ic_monad if their names are from external packages.ghcIf there is no -o option, guess the name of target executable by using top-level source file name as a base.ghcReturn (names of) all those in modsDone who are part of a cycle as defined by theGraph.ghc UnloadingghcBuild a  out of a list of strongly-connected modules, also returning the first, if any, encountered module cycle.ghc(The entry point to the parallel upsweep.!See also the simpler, sequential .ghc The upsweepThis is where we compile each module in the module graph, in a pass from the bottom to the top of the graph.There better had not be any cyclic groups here -- we check for them.ghcCompile a single module. Always produce a Linkable for it if successful. If no compilation happened, return the old Linkable.ghcGiven a non-boot ModSummary ms of a module, for which there exists a corresponding boot file in graph, return the set of modules which transitively depend on this boot file. This function is slightly misnamed, but its name "getModLoop" alludes to the fact that, when getModLoop is called with a graph that does not contain ms (non-parallel case) or is an SCC with hs-boot nodes dropped (parallel-case), the modules which depend on the hs-boot file are typically (but not always) the modules participating in the recursive module loop. The returned list includes the hs-boot file.Example: let g represent the module graph: C.hs A.hs-boot imports C.hs B.hs imports A.hs-boot A.hs imports B.hs genModLoop A.hs g == Just [A.hs-boot, B.hs, A.hs]It would also be permissible to omit A.hs from the graph, in which case the result is [A.hs-boot, B.hs]Example: A counter-example to the claim that modules returned by this function participate in the loop occurs here:let g represent the module graph: C.hs A.hs-boot imports C.hs B.hs imports A.hs-boot A.hs imports B.hs D.hs imports A.hs-boot genModLoop A.hs g == Just [A.hs-boot, B.hs, A.hs, D.hs]Arguably, D.hs should import A.hs, not A.hs-boot, but a dependency on the boot file is not illegal.ghcCollect the immediate dependencies of a ModuleGraphNode, optionally avoiding hs-boot dependencies. If the drop_hs_boot_nodes flag is False, and if this is a .hs and there is an equivalent .hs-boot, add a link from the former to the latter. This has the effect of detecting bogus cases where the .hs-boot depends on the .hs, by introducing a cycle. Additionally, it ensures that we will always process the .hs-boot before the .hs, and so the HomePackageTable will always have the most up to date information.ghcIf there are {-# SOURCE #-} imports between strongly connected components in the topological sort, then those imports can definitely be replaced by ordinary non-SOURCE imports: if SOURCE were necessary, then the edge would be part of a cycle.ghcUpdate the every ModSummary that is depended on by a module that needs template haskell. We enable codegen to the specified target, disable optimization and change the .hi and .o file locations to be temporary files. See Note [-fno-code mode]ghcHelper used to implement . In particular, this enables unoptimized code generation for all modules that meet some condition (first parameter), or are dependencies of those modules. The second parameter is a condition to check before marking modules for code generation.ghcReturns the dependencies of the ModSummary s. A wrinkle is that for a {-# SOURCE #-} import we return *both* the hs-boot file *and* the source file as "dependencies". That ensures that the list of all relevant modules always contains B.hs if it contains B.hs-boot. Remember, this pass isn't doing the topological sort. It's just gathering the list of all relevant ModSummaries ghcexcluded modulesghcallow duplicate rootsghcexcluded modulesghcallow duplicate rootsghcexcluded modulesghcallow duplicate rootsghcpossibly empty Bag of errors and a module graph.ghc Old summariesghcMap of old summariesghcDrop hi-boot nodes? (see below)ghcRoot module name. If Nothing, use the full graph.ghc0The number of workers we wish to run in parallelghcThe module we wish to compileghc-The map of home modules and their result MVarghc:The list of all module loops within the compilation graph.ghcThe thread-local LoggerghcThe thread-local TmpFsghcThe thread-local DynFlagsghc The home-unitghc The messagerghc>The semaphore for limiting the number of simultaneous compiles ghc7The MVar that synchronizes updates to the global HscEnv ghc The old HPT ghcSets of stable objects and BCOs ghcThe index of this module ghcThe total number of modulesghcThe result of this compileghc!HPT from last time round (pruned)ghc#stable modules (see checkStability)ghcMods to do (the worklist)ghcReturns: 3A flag whether the complete upsweep was successful.The  in the monad has an updated HPT*A list of modules which succeeded loading.ghc1optional source code buffer and modification time Ǻ˺ Ǻ˺ Safe-Inferred &'?ghcGiven a source location and a StringBuffer corresponding to this location, return a rich token stream with the source associated to the tokens.ghcAdd another target.ghcThis 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.ghcLike compileToCoreModule, but invokes the simplifier, so as to return simplified and tidied Core.ghcThis function is no longer necessary, cleanup is now done by runGhc/runGhcT.ghcInstall 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.ghcDesugar a typechecked module.ghcTakes a  and possibly a , and consults the filesystem and package database to find the corresponding +, using the algorithm that is used for an import declaration.ghc8Return the bindings for the current interactive session.ghc.Get the monad GHCi lifts user statements into.ghc"get the GlobalRdrEnv for a sessionghc9Return the instances for the current interactive session.ghcGet the  * used to evaluate interactive expressions.ghc Return the ! of a module with the given name.1The module must be part of the module graph (see  and 9). If this is not the case, this function will throw a .This function ignores boot modules and requires that there is only one non-boot module with the given name.ghc Get the module dependency graph.ghc#Request information about a loaded ghcRetrieve 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.ghcReturns the program  .ghc.Give even more information on the source than  This function allows reconstructing the source completely with .ghc"Returns the current set of targetsghc9Return module source as token stream, including comments.The module must be in the module graph and its source must be available. Throws a  on parse error.ghcAttempts 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 nameghcInitialise 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.ghc,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 id2ghcReturn True <==> module is loaded.ghcCheck 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.ghc3Load a module. Input doesn't need to be desugared.A module must be loaded before dependent modules can be typechecked. This always includes generating a  and, depending on the DynFlags's P#, may also include code generation.This function will always cause recompilation and will always overwrite previous compilation results (potentially files on disk).ghcLooks up a global name: that is, any top-level name in any visible module. Unlike , lookupGlobalName does not use the interactive context, and therefore does not require a preceding .ghcLike , but differs slightly when the module refers to a source file, and the file has not been loaded via . In this case, / will throw an error (module not loaded), but  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.ghc Returns the ! for a . The 2 may refer to any entity known to GHC, including s defined using runStmt.ghcReturns the instances defined by the specified module. Warning: currently unimplemented for package modules.ghc!Retrieve module safe haskell modeghc2The list of top-level entities defined in a moduleghcReturn if a module is trusted and the pkgs it depends on to be trusted.ghcParse a module. Throws a O on parse error.ghcParse 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 ghc&A pure interface to the module parser.ghcprint a 0, adding parentheses if the name is an operator.ghcRemove a targetghcRun function for the  monad.0It initialises the GHC session and warnings via . Each call to this function will create a new session which should not be shared among several threads."Any errors not handled inside the ) action are propagated as IO exceptions.ghcRun function for  monad transformer.0It initialises the GHC session and warnings via . Each call to this function will create a new session which should not be shared among several threads.ghc.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.ghcSet the   used to evaluate interactive expressions. Also initialise (load) plugins.9Note: this cannot be used for changes to packages. Use , or  and then copy the  unitState into the interactive DynFlags.ghcSets the program  . Note: this invalidates the internal cached module graph, causing more work to be done the next time  is called.Returns a boolean indicating if preload units have changed and need to be reloaded.ghcUpdates both the interactive and program DynFlags in a Session. This also reads the package database (unless it has already been read), and prepares the compilers knowledge about packages. It can be called again to load new packages: just add new package flags to (packageFlags dflags).ghcSets the targets for this session. Each target may be a module name or a filename. The targets correspond to the set of root modules for the program/library. Unloading the current program is achieved by setting the current set of targets to be empty, followed by .ghc/Take a rich token stream such as produced from  and return source code almost identical to the original code (except for insignificant whitespace.)ghc%Typecheck and rename a parsed module. Throws a O if either fails.ghcInform GHC that the working directory has changed. GHC will flush its cache of module locations, since it may no longer be valid.Note: Before changing the working directory make sure all threads running in the same session have stopped. If you change the working directory, you should also unload the current program (set targets to empty, followed by load).ghc.A CoreModule consists of just the fields of a  that are needed for the  interface.ghc Declarationsghc Module nameghcSafe Haskell modeghc2Type environment for types declared in this moduleghcThe result of successful desugaring (i.e., translation to core). Also contains all the information of a typechecked module.ghc?An error thrown if the GHC API is used in an incorrect fashion.ghc"Container for information about a .ghc!The result of successful parsing.ghcThe result of successful typechecking. It also contains the parser result.ghcTo simplify the handling of filepaths, we normalise all filepaths right away. Note the asymmetry of FilePath.normalise: Linux: p/q -> p/q; p\q -> p\q Windows: p/q -> p\q; p\q -> p\q #12674: Filenames starting with a hyphen get normalised from ./-foo.hs to -foo.hs. We have to re-prepend the current directory.ghcThe binutils linker on ARM emits unnecessary R_ARM_COPY relocations which breaks tables-next-to-code in dynamically linked modules. This check should be more selective but there is currently no released version where this bug is fixed. See  5https://sourceware.org/bugzilla/show_bug.cgi?id=16177 and 9https://gitlab.haskell.org/ghc/ghc/issues/4210#note_78333ghcSplitting arguments into source files and object files. This is where we interpret the -x  suffix option, and attach a (Maybe Phase) to each source file indicating the phase specified by the -x option in force, if any.ghcChecks the set of new DynFlags for possibly erroneous option combinations when invoking  and friends, and if found, returns a fixed copy (if possible).ghcvisible modules. An orphan instance will be returned if it is visible from at least one module in the list.ghcmodules to load. If this is not specified, we load modules for everything that is in scope unqualified.ghc6Haskell module source text (full Unicode is supported)ghc the flagsghc#the filename (for source locations)ghcSee argument to .ghcThe action to perform.ghcSee argument to .ghcThe action to perform. PP QQPPPPPPPPPPPPPPPPQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQRR  <<Create a new, externally provided hashed unit id from a hash.                                                                                                                                                                                                                                                                                                                                                                                                                        ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " # $ $ $ $ $ % % % % % % % % % % & & & & & & & & & & & & & & & & & & & & & & & & & ' ( ) ) ) ) ) ) ) ) ) * + + + + + , , , ,   - - - - - - - - - - - .                        / / / / / / / / / / / / / 0 0 00 1 1 1 1 1 1 1 1 1 1 2 2 22 2 2 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3                                                                    444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444455555666666666666667777777777777777777777777777777777777777777777777777777777777777778888888888888889999999999::::::;;;;;;;;;;;;;;;;;;;;;;;;;<<<<<<<<<<<<<< <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< <<<<<<<<<<<<<<<<<<<<<<<<===========================0000000000000000000000000000000000000000 00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000>>>>??????????????@@@@@@@AAA A A A A A A A A A A A A BBBBBBBBBBBBCCCCCCCCCCCDEEEEEEEFFFFFFFFFFFFFFFFFFFFFFFFFFGGGGGGGGGGGGGGGGGGGGGGHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKLLLL L LL L LLLLLLLLMMMMMMMMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOOOOOOOOOOOOOOOOOOOOPPPPPPPPQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQRRRRRRRRSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS S SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSTTTTTTTTTT*****************11111111111111111111111111111111111111111111111111 11111111 1111111111111 111111111111111111111111111111111111111111111111111111111111UUUUUUUUUUUUUVVVVWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWXXXXXXXXXXXXXXYYYYYYYYYYYYYYYYYYYYYYYYYYZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ[[[[[[[[[[[[[[[\\\\\\\\\\\\\\\\\]]]]]]]]]^^^^^^^^^^^^__________`aaaaaabbbbbbbbbbbbbbccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccddddddddddddddddddddddddddeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeffffffgggggggggggggggghhhhhhhhhhhhhhhhhhh h h h h h h hh h h h h h h h h h h h h h h h h h h h i i i i i i i i i i i i i i i i i i i i i i i i i i i i i i i i i i i i i i i i i i i i i i i i i i i i i i i i i i i i i i i i i i i i i i i i i i i i i i i i i i i i i i i i i i i i i i i i i i i i i i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i!i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i"i#i#i#i#i#i#i#i#i#i#i#i#i#i#i#i#i#i#i#i#i#i#i#i#i#i#i#i#i#i#i#i#i#i#i#i#i#i#i#i#i#i#i#i#i#i#j#j#j#j#j#j#j#j#j#j#j#j#j#j#j#j#j#j#j#j#j#j#j#j#j#j#j#j#j#j#j#j#j# # # # # # # # # # # # # # # # # # # # # # # # # # # #k#k#k#k#k#k#k#k#k#k#k#k#k#k#l#l#l#l#l#l#l#l#m#m#m#m#m$m$m$m$m$m$m$m$m$m$m$m$n$n$n$n$n$n$n$n$n$n$n$n$n$n$n$n$n$n$n$n$n$n$n$n$n$n$n$n$n$o$o$o$o$o$o$o$o$o$o$o$o$o$p$p$q$q$q$q$q$q$q$q$q$q$q$q$q$q$q$q$q$q$q$q$q$q$q q$ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $   $ $ $ $ $ $ $ $ $ $ $ $ $ $r$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%tt%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%uu%v%v%v%x%x%x%x%x%x%x%x%x%x%x%x%x%x%xx%w%w%w%w%w%w%w%w%w%ww%w%w%w%w%w%{%{%{%{%{%|%|%|&|&|&|&|&|&|&|&|&|&|&|&|&|&|&}&}&}&}&}&}&}&}&}&}&}&}&}&}&}&}&}&}&}&}&}&}&}&}&}&}&}&}&}&}&}&}&}&}&}&}&}&}&}&}&}&}&}&}&}&}&}&}&}&}&}&}&}&}&}&}&}&}&}&}&}&}&}&}&}&}&}&}&}&}&}&}&}&}&}&}&}&}&}&_&_&_&_&_&_&_&_&_&_&_&_&_&_&_&_&_&_&_&_&_&_&_&_&_&_&_&_&_&_&_&_&_&_&_'_'_'_'_'_'_'_'_'_'_'_'_'_'_'_'_'_'_'_'_'_'_'_'_'_'_'_'_'_'_'_'_'_'_'_'_'_'_'_'_'_'_'_'_'_'_'_'_'_'_'_'_'_'_'_'_'_'_'_'_'_'_'_'_'_'_'_'_'_'_'_'_'_'_'_'_'_'_'_'_'_'_'_'_'_'_'_'_'_'_'_'~'~'~'~'~'~'~'~'~'~'~'~'~'~'~'~'~'~'~'~'~'~'~'~'~'~'~'~'~'~'~'~'~'~'~'~'~(~(~(~(~(~(~(~(~(~(~(~(~(~(~(~(~(~(~(~(~(~(~(~(~(~(~(~(~(~(~(~(~(~(~(~(~(~(~(~(~(~(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((())))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))******************************************************************************************:*:*:*:*:*:*:*:*:*:*:*:*:*:*:*:*:*:*:*:*:*:*:*:*:*:*:*:*:*:*:*:*:*:*:*:*:*:*:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:':+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:++++++++++++++++++R+R+R+R+R+R+R+R+R+R+R+R+R+R+R+R+R+R+R+R+R+R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,--------------------------------------------------------------------------------------------------------------------------------.........--....................-.........-............................................................................................////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111122222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222,22222222222222222222222333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333334444444444444444444444444444444y4y4y4y4y4y4y4y4y4y4y4y4y4y4y4y4y4y4y4y4y4y4y4y4y4y4y4y4y4y4y4y4y4y4444444444444444444444444444444444444444444444444444444444444444455555555555555555555555555555555555555455555555555455555555555555555555555555555555555555555555555555555555555555555555555555555555555555566666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777778888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888899999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<================================================================================================================================>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>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?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?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@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ @@@@@@@@@@@@@@@@@@@@@@AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA..AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA.AAAAAAAAAAAAAxAxAxAxAxAxAxAxAxAxBxBxBxBxBxBxBxBxBxBxBxBxBxBxBxBxBxBxBxBxBxBxBxBxBxBxBxBxBxBxBxBxBxBxBxBxBxBxBxBxBxBxBxBxBxBxBxBxBxBxBxBxBxBx%xBxBxBxBxBxBxBxBxBxBxBxBxBxBxBxBxBxBxBxBxBxBxBxBxBxBxBxBxBxBxBxBxBxBxBxBxBxBxBxBxBxBxBxBxBxBxB B B B B B B B B B B B B B B B B B B B B B B B B B B B B B C C C C C C C C C C C C C C C C C CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIwIwIwIwIwIwIwIwIwIwIwIwIwIwIwwIwIwIwIwIwIwIwIwIwIwIwIwIwIwIwIwIwIwIwIwIwIwIwIwIwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwJwKwKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL LLLLLLLLLL{L{L{L{L{L{L{L{L{L{L{L{L{L{L{L{L{L{L{L{L{L{LLLLLLLLLLLLLLLLLLLLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM,MMMMMMyMyMyMyMyMyMyMyMyMyMyMyMyMyMyMyMyMyMyMyMyMyMyMyMyMyMyMyMyMyMyMyMyMyMyMyMyMyMyMyMyMyMyMyMyMyMyMyMyMyMyMyMyMyMyMyMyMyMyMyMyMyMyMyMyMyMyMyMyMyMyMyMyMyMyMyMyMyMyMyMyMyMyMyMyMyMyMyMyMyMyNyNyNyNyNyNyNyNyNyNyNyNyNyNyNyNyNyNyNyNyNyNyNyNyNyNyNyNyNyNyNyNyNyNyNyNyNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNLNNNNNNNNNNNNNNNNNNNNNNNOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO|O|O|O|O|O|O|O|O|O|O|O|O|O|O|O|O|O|O|O|O|O|O|O|O|O|O|O|O|O|O|P|P|P|P|P|P|P|P|P|P|P|P|P|P|P|P|P|P|P|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|PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRSSSSSSS5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5S5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T55T5T5T5T5T5T55T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5T5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5U5V5V5V5V5V5V5V5V5V5V5V5V5V5V5V5V5V5V5V5V5V5V5V5V5V5V5V5V5V5V5V5V5V5V5V5V5V5V5V5V5V5V5V5V5V5V5V5V5VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV2V2V2V2V2W2W2W2W2W2W2W2W2W2W2W2W2W2W2W2W2W2W2W2W2W2W2W2W2W2W2W2W2W2W2W2W2W2W2W2W2W2W2W2W2W2W2W2W2W2W2W2W2W2W2W2 2W2W2W2W2W2W2W2 2W2W2W2W2W2W2W2W2W2W2W2W2W2W2W2W2W2W2W2W2W2W2W2W2WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X XXXXXXXXXXXXXXXXXXXXXXXXXYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]%]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]a]a]a^a^a^a^a^a^a^a^a^a^a^a^a^a^a^a^a^a^a^a^a^a^a^a^a^a^a^a^a^a^a^a^a^a^a^a^a^a^a^a^a^a^a^a^a^a'a^a^a^a'a^a^a^a^a^a^a^a^a^a^a^a^a^a^a^a^a^a^a^a^a^a^a^a^a^a^a^a^a^a^a^a^a^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`_`_`_`_`_`_`_`_`&`_`_`_`_`_`_`_`_`_`_`_`_`_`_`_`_`_`_`_`_`_`_`_`_`_`_`_`_`_`_`_`_`_`_`_`'`_`_`_`'`_`_`_`_`_`_`_`_`_`_`_`_`_`_`_`_`_`_`_`_`_`_`_`_`_v_v_v_v_v_v_v_v_v_v_v_v_v_v_v_v_v_v_v_v_v_v_v_v_v_v_v_v_v______________________________```````````````````````````````````````$```````````````````}`}`}`}`}`}`}`}`}`}`}`}`}`}`}`}`}`}`}`}`}`}`}`}`}`}`}`}`}`}`}`}`}`}`}`}`}`}`}`}`}`}`}`}`}`}`}`}`}`}`}`}`}`}`}`}`}`}`}`}`}`}`}`}`}`}`}`}`}`}`}`}`}`}`}a}a}a}a}a}a}a}a}a}a}a}a}a}a}a}a}a}a}a}a}a}a}a}a}a}a}a}a}a}a}a}a}a}a}a}a}a}a}a}a}a}a}a}a}a}a}a}a}a}a}a}a}a}a}a}a}a}a}a}a}a}a}a}a}a}a}a}a}a}a}a}a}aaaaaaaaaaaaaa#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#a#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#b#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#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#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#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#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#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#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#f#g#g#g#g#g#g#g#g#g#g#g#ggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggghhhhhhh hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii\iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiijjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjZjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkklllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllXXlllllllllmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmRRmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmNNmmmmmmmmmnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofofooooooooooooppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr rrrrrrrrrrrrrrrrrrrr_Crr_rr_rrCCrrC_r_rrrrr__CCrrrrrrrrrrrCrrr_rsssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssstttltttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuutuuuttuuuuuuuuuuuutuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww]wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww]wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwxxxxxxxxxxxxxxxxtxttttxxxxxxxxxxxxxxxxxxxtxtxtxxtxuxuuuuxuuuuttttttttxxxtxxxttxxxtxtxttxxxtuuuuxuxxuuuuuuuuuuuuuuuuuuuxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxyyyyyyyyyyyyyttttxtxttuyuuuuuuuuuuuuyyyyyyyyyyyyykkykkkkkykkkykkyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyuuuuuyuuuuyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyzzzzkkkxkkkkkkzzzkkkxxzzkkzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzyyyzzzzzzzzzzzzyzyzzzyzzzyzzzzzzzzzzz yyzzzzzzzyzzyzzzzzyzzzzzzzzzzzzzzz#zzzzzzzzzzzyyyyyyykzzzzz{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{|||||||||||||||||||||||||||||||||N|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}kz}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}~~~~~~~~~y~~~~~~~~RR~~~~l~~~~~~~~~~~~~~~~v~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~|~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ykkkxkkkkkkkkkzkkyyyzzyyyyyyyyyyyyzz yyyyyyyyyyyyyyyykzkw€ÀĀŀƀǀȀɀʀˀ̀̀΀πЀрҀ|ӀԀՀր׀؀ـڀۀ܀݀ހ߀wÁāŁƁǁȁɁʁˁ́́΁ρЁсҁӁ̀̀΀X|ӀԀڀԁՁցׁ؁فځہ܁݁rBށ߁y‚ÂĂłƂǂȂɂʂ˂̂͂΂ςЂт҂ӂԂՂւׂ؂قڂڂۂ܂܂݂ނ߂yyykkkxkkkkkkkkkyykkyyyyzyyyyyyzzzyyyyyyyyzzzzy}}}}kzxƒÃăŃƃ~ǃȃɃʃ˃~̃̓΃σЃу҃Ӄԃ|Ճփ׃؃كڃۃ܃݃ރރ߃tyyxzyyyy„ÄĄńƄDŽȄɄʄ˄̄̈́΄τЄф҄ӄԄ҄ӄԄՄքׄ؄لڄۄ܄݄ބ߄Z…ÅąŅƅDžȅɅʅ˅z̅zͅz΅zυzЅzхz҅zӅzԅzՅzօzׅz؅zمzڅzۅz܅z܅zYz݅zޅz߅zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz†zÆzĆzņzƆzdžzȆzɆzʆzˆz̆z͆zΆzφzІzцz҆zӆzԆzՆzֆz׆z؆zنzچzۆz܆z݆zކz߆zYZ‡ÇćŇƇLJȇɇÇʇˇ͇͇̇·χЇч҇ӇԇՇևׇ؇هZڇۇ܇݇އ߇߇kˆÈĈňƈLjȈɈʈʈˈ͈̈ΈψЈш҈҈ӈԈՈֈ׈؈وڈۈ܈݈ވ߈44‰ÉĉʼnƉljȉɉʉˉ͉̉ΉωЉщ҉҉ӉԉԉՉ։׉؉ىډۉ܉݉މ߉ZZ+ŠÊĊŊƊNJȊɊʊˊ̊̊͊͊Ί[ϊЊъҊӊԊՊ֊׊؊يڊۊ܊݊ފߊYYފL‹ËċŋƋNjȋɋʋˋ̋͋΋ϋЋыҋӋԋՋ֋׋؋ًڋۋ܋܋݋ދߋZlŒÌČŌƌnjȌɌʌˌ̌͌ΌόЌьҌӌԌՌ֌׌،ٌڌی܌݌ތߌÍčōƍǍǍȍɍʍˍˍ͍̍΍ύЍэҍӍԍՍ֍׍؍ٍڍۍ܍ݍލߍiŽÎĎŎƎǎȎɎʎˎ͎̎ΎώЎюҎӎԎՎՎ֎׎؎َڎڎێ܎܎ݎގߎߎÏďŏƏǏȏɏʏˏ̏͏ΏϏЏяҏӏԏՏ֏׏؏ُڏۏ܏ݏޏߏÐĐŐƐǐȐɐʐː̐͐ΐϐАѐҐӐԐԐՐ֐אِؐڐېܐݐސߐR||‘ÑđőƑǑȑɑʑˑ̑͑ΑϑБёґӑԑՑ֑בّؑڑۑܑݑޑޑߑ’ÒĒŒƒǒȒɒʒ˒̒͒ΒϒВђҒӒԒՒ֒גْؒڒےܒݒޒߒ|ӀԀ“ÓēœƓǓȓɓʓ˓͓̓ΓϓГѓғӓԓՓ֓דؓٓړۓܓݓޓߓ”ÔĔŔƔǔȔɔʔ˔͔̔ΔϔДєҔӔԔՔ֔הؔٔڔ۔ܔݔޔߔi•ÕĕŕƕǕȕɕʕ˕͕̕ΕϕЕѕҕӕԕՕ֕וٕؕڕەܕݕޕߕ–ÖĖŖƖǖȖɖʖ˖̖͖ΖϖЖіҖӖԖՖ֖זٖؖږۖܖݖޖߖ—×ėŗƗǗȗɗʗ˗̗͗ΗϗЗїҗӗԗ՗֗חؗٗڗۗܗݗޗߗ˜ØĘĘŘƘǘǘȘɘʘ˘̘͘ΘϘИИјҘӘԘ՘֘טؘ٘ژۘܘݘޘߘ™ÙęřƙǙșəʙ˙̙͙ΙϙЙљҙәԙԙՙ֙יؙٙڙۙۙܙݙޙߙšÚĚŚƚǚȚɚʚ˚͚̚ΚϚКњҚӚԚ՚֚ךؚٚښۚܚݚޚߚ›ÛěśƛǛțɛʛ˛̛͛ΛϛЛћқӛԛ՛֛כ؛ٛڛۛܛݛޛߛœÜĜŜƜǜȜɜʜ˜̜͜ΜϜММќҜӜԜ՜֜ל؜ٜڜڜۜܜݜޜߜÝĝŝƝǝȝɝʝ˝̝͝ΝϝНѝҝӝԝ՝֝ם؝ٝڝ۝ܝݝݝޝߝ \žÞĞŞƞǞȞɞʞ˞̞͞ΞϞОўҞӞԞ՞֞מ؞ٞڞ۞ܞݞޞߞŸßğşƟǟȟɟʟ˟̟͟ΟϟПџҟӟԟ՟֟ן؟ٟڟ۟ܟݟޟߟ   àĠŠƠǠȠɠʠˠ̠͠ΠϠРѠҠӠԠՠ֠נؠ٠ڠ۠۠ܠݠޠߠ `¡áġšơǡȡɡʡˡ̡͡ΡϡСѡҡӡԡա֡סء١ڡۡܡݡޡߡVVVVV%¢âĢŢƢǢȢɢ]ʢˢ̢͢΢ϢТѢҢӢԢբ֢עآ٢ڢۢܢݢޢߢsCrCrCCCr£ãģţƣǣȣɣʣˣ̣ͣΣϣУѣңӣԣգ֣ףأ٣ڣۣܣݣޣߣR ¤äĤŤƤǤȤɤVʤˤ̤ͤΤϤФѤҤӤԤդ֤פؤ٤ڤۤܤݤ|ޤߤrr¥åĥťƥǥȥɥʥ˥̥ͥΥϥХѥҥӥԥե֥ץإ٥ڥۥܥݥޥߥo¦æĦŦƦǦȦɦʦ˦̦ͦΦϦЦѦҦӦԦզ֦צئ٦ڦۦܦݦަߦ%%§çħŧƧǧȧɧʧ˧̧ͧΧϧЧѧҧӧԧէ֧קا٧ڧۧܧݧާߧ¨èĨŨƨǨȨɨʨ˨̨ͨΨϨШѨҨӨԨը֨רب٨ڨۨܨݨިߨ©éĩũƩǩȩɩʩ˩̩ͩΩϩЩѩҩөԩթ֩שة٩ک۩ܩݩީߩ((((((((((((((((((( (((((((((((((((ª(ê(Ī(Ū(ƪ(Ǫ(Ȫɪʪ˪̪ͪΪϪЪѪҪӪԪժ֪תت٪ڪ۪ܪݪުߪդ֤ڤ«ëīūƫǫȫɫʫ˫̫ͫΫϫЫѫҫӫԫի֫׫ث٫ګ۫ܫݫޫ߫L¬ìĬŬƬǬȬȬɬʬʬˬ̬ͬάϬЬѬҬӬԬլ֬׬ج٬ڬ۬ܬݬެ߬  |­íĭŭƭǭȭɭʭ˭̭ͭέϭЭѭҭӭԭխ֭׭ح٭ڭۭܭݭޭ߭®îĮŮƮǮȮɮʮˮ̮ͮήϮЮѮҮӮԮծ֮׮خٮڮۮܮݮޮ߮¯ïįůƯǯȯɯʯ˯̯ͯίϯЯѯүӯԯկ֯ׯدٯگۯܯݯޯ߯°ðİŰưǰȰɰʰ˰̰ͰΰϰаѰҰӰ԰հְװذٰڰ۰ܰݰް߰ӨԨϧۨ٧ݧާή±ñıűƱDZȱɱʱ˱̱ͱͱαϱбѱұӱԱձֱױرٱڱ۱ܱݱޱ߱ĩبۨݨ²òIJŲƲDzȲɲʲ˲̲ͲβϲвѲҲӲԲղֲײزٲڲ۲ܲݲ޲߲³óijųƳdzȳɳʳ˳̳ͳγϳгѳҳӳԳճֳ׳سٳڳ۳ܳݳ޳߳´ôĴŴƴǴȴɴɴʴʴ˴̴ʹδϴдѴҴӴԴմִ״شٴڴ۴ܴݴ޴ߴµõĵŵƵǵȵɵʵ˵̵͵εϵеѵҵӵԵյյֵ׵صٵڵ۵ܵݵ޵ߵ¶öĶŶƶǶȶɶʶ˶̶Ͷζ϶жѶҶӶԶնֶ׶ضٶڶ۶ܶݶ޶߶·÷ķŷƷǷȷɷʷ˷̷ͷηϷзѷҷӷԷշַ׷طٷڷ۷ܷݷ޷߷O¸øĸŸƸǸȸɸʸ˸̸͸θϸиѸҸӸԸոָ׸ظٸڸ۸ܸݸ޸߸¹ùĹŹƹǹȹɹʹ˹̹͹ιϹйѹҹӹԹչֹ׹عٹڹ۹ܹݹ޹߹ºúĺźƺǺȺɺʺ˺̺ͺκϺкѺҺӺԺպֺ׺غٺںۺܺݺ޺ߺ»ûĻŻƻǻȻɻʻ˻̻ͻλϻлѻһӻԻջֻ׻ػٻڻۻܻݻ޻߻qJ¼üļżżƼǼȼɼʼ˼̼ͼμϼмѼҼӼԼռּ׼ؼټڼۼܼݼ޼߼ՁXX"½ýĽ&Ž&ƽ&ǽ&Ƚ'ɽʽ˽̽˽̽˽ͽ˽νϽϽннѽѽҽҽӽӽԽԽսսֽֽ׽ؽٽڽ۽ܽݽ޽߽3788888;<<<<1SFQQRRRRJJ____aaaZw¾þľžƾǾ:ȾGɾGʾ˾̾;ξwϾwоwѾwҾwӾwԾwվw־w׾wؾwپwھw۾wܾwݾ޾g߾2222222222222222222222222222222222222222222222222222555555555555555555555555555555ett¿ÿĿſƿǿȿɿʿ˿̿ͿοϿпѿҿӿԿտֿ׿ؿٿڿۿuܿuݿu޿u߿uuuouuuuuuuuuuuuuuuuuuuffffnnn|| yyyyyyyy}}}}}}}}0 slst >?MoMMpqrrrtt  X&\ zxyyyyyyyWuyy2y޼ ӑghc GHC.PreludeGHC.Utils.PanicGHC.Utils.MonadGHC.Driver.PluginsGHC.Utils.FingerprintGHC.Core.Opt.SpecConstrGHC.Utils.MiscGHC.Data.Stream GHC.Platform GHC.Unit.InfoGHC.Data.IOEnvGHC.Core.TyCo.FVsGHC.Data.Graph.DirectedGHC.Data.MaybeGHC.Types.BasicGHC.ByteCode.AsmGHC.SysTools.BaseDirGHC.Runtime.InterpreterGHCGHC.Iface.TypeGHC.Platform.ConstantsGHC.Driver.HooksGHC.Data.UnionFindGHC.Data.FiniteMapGHC.Data.FastMutIntGHC.Data.EnumSetGHC.Core.UnfoldGHC.Core.Opt.CallerCCGHC.CmmToAsm.X86.CondGHC.CmmToAsm.SPARC.CondGHC.CmmToAsm.CFG.DominatorsGHC.CmmToAsm.AArch64.CondGHC.Cmm.Dataflow.CollectionsGHC.Cmm.Dataflow.BlockGHC.Builtin.PrimOpsGHC.Settings.ConfigGHC.Settings.ConstantsGHC.SysTools.ArGHC.SysTools.TerminalGHC.Tc.Errors.Hole.FitTypesGHC.Types.HpcInfoGHC.Unit.Module.NameGHC.Utils.CliOptionGHC.Utils.ExceptionGHC.Utils.GlobalVarsGHC.Utils.IO.UnsafeGHC.Utils.Monad.StateGHC.Utils.OutputableGHC.Unit.TypesGHC.Unit.StateGHC.Utils.Panic.Plain GHC.SettingsGHC.Driver.SessionGHC.Driver.BackendGHC.Data.FastStringGHC.Utils.LexemeGHC.Utils.BufHandleGHC.Types.Name.OccurrenceGHC.Data.StringBuffer GHC.Utils.PprGHC.Utils.Ppr.ColourGHC.Settings.IOGHC.Parser.CharClassGHC.CmmToAsm.SPARC.BaseGHC.CmmToAsm.PPC.CondGHC.CmmToAsm.CFG.WeightGHC.Utils.Json GHC.Utils.Asm GHC.Unit.PprGHC.Types.UniqueGHC.Types.Unique.SupplyGHC.Types.Unique.FMGHC.Types.Unique.MapGHC.Types.Unique.DFMGHC.Types.Unique.SetGHC.Data.Graph.BaseGHC.Types.Unique.SDFMGHC.Types.Unique.DSetGHC.Data.FastString.Env GHC.CmmToAsm.Reg.Linear.StackMapGHC.Types.SrcLocGHC.Types.NameGHC.Utils.BinaryGHC.Utils.Binary.TypeableGHC.Unit.Module.LocationGHC.Unit.ParserGHC.Unit.Module.EnvGHC.Unit.Module GHC.Unit.HomeGHC.Types.SourceTextGHC.Types.SourceFileGHC.Types.SafeHaskellGHC.Types.CostCentre.StateGHC.Iface.Ext.Fields GHC.Types.Var GHC.Types.IdGHC.Types.Id.InfoGHC.Types.ForeignStubsGHC.Types.ForeignCallGHC.Types.FixityGHC.Types.FieldLabelGHC.Tc.Utils.TcTypeGHC.Driver.PprGHC.Driver.PhasesGHC.Driver.FlagsGHC.Platform.WaysGHC.Types.TargetGHC.Platform.Profile GHC.Data.PairGHC.Data.OrdListGHC.Data.List.SetOpsGHC.Data.Graph.PprGHC.Data.Graph.OpsGHC.Data.Graph.Color GHC.Data.BagGHC.Driver.CmdLineGHC.Core.TyConGHC.Types.TyThing GHC.Core.TypeGHC.Core.TyCo.RepGHC.Core.CoercionLanguage.Haskell.Syntax.TypeGHC.Core.TyCo.PprGHC.Core.DataConGHC.Builtin.Types GHC.Cmm.TypeGHC.CmmToAsm.ConfigGHC.Cmm.MachOpGHC.CmmToAsm.CPrimGHC.Builtin.UniquesGHC.Unit.Module.WarningsGHC.Unit.Module.DepsGHC.Types.Var.Set GHC.Utils.FVGHC.Types.Var.EnvGHC.Types.Name.SetGHC.Types.Name.EnvGHC.Types.Fixity.EnvGHC.Types.CostCentreGHC.Types.AvailGHC.Types.Name.ReaderGHC.Unit.Module.ImportedGHC.Types.AnnotationsGHC.Parser.AnnotationGHC.Data.BooleanFormulaGHC.Iface.Recomp.Binary GHC.Hs.DocGHC.Core.Coercion.AxiomGHC.Core.ClassGHC.Types.Id.MakeGHC.Platform.Reg.ClassGHC.Platform.RegGHC.CmmToAsm.Reg.Utils$GHC.CmmToAsm.Reg.Graph.TrivColorableGHC.CmmToAsm.Reg.Graph.BaseGHC.CmmToAsm.Reg.Graph.X86GHC.Builtin.NamesGHC.Types.RepTypeGHC.CoreToIfaceGHC.Core.TyCon.SetGHC.Core.TyCon.EnvGHC.Core.TyCon.RecWalkGHC.Core.MultiplicityGHC.Core.TyCo.TidyGHC.Core.TyCo.SubstGHC.Builtin.Names.THGHC.Builtin.Types.PrimGHC.Types.LiteralGHC.Data.TrieMapGHC.Core.Map.TypeGHC.Cmm.Dataflow.LabelGHC.Cmm.SwitchGHC.Cmm.Dataflow.GraphGHC.Cmm.BlockIdGHC.Core.PatSynGHC.Core.UtilsGHC.Core.UsageEnvGHC.Core.PredicateGHC.Core.UnifyGHC.Core.FamInstEnv GHC.Types.IPEGHC.Types.Demand GHC.Types.CprGHC.StgToCmm.TypesGHC.Core.ConLikeGHC.Types.CompleteMatch GHC.Tc.TypesGHC.Types.ErrorGHC.Types.SourceErrorGHC.Utils.LoggerGHC.Utils.ErrorGHC.Unit.Finder.Types GHC.Unit.EnvGHC.SysTools.ElfGHC.Runtime.Heap.LayoutGHC.CmmGHC.Data.BitmapGHC.Linker.UnitGHC.Driver.ErrorsGHC.CmmToLlvm.ManglerGHC.Utils.TmpFsGHC.SysTools.ProcessGHC.SysTools.Info!Language.Haskell.Syntax.ExtensionLanguage.Haskell.Syntax.ExprGHC.Types.TickishGHC.CoreGHC.Types.TypeEnv GHC.Stg.SubstGHC.Runtime.Eval.TypesGHC.Data.Graph.UnVarGHC.Types.Name.PprGHC.Types.Name.CacheGHC.Iface.SyntaxGHC.Core.StatsGHC.Core.SimpleOpt GHC.Core.Seq GHC.Core.Tidy GHC.Core.PprGHC.Stg.Syntax GHC.Stg.Stats GHC.Stg.FVsGHC.Stg.DepAnal GHC.Stg.DebugGHC.Cmm.CLabelGHC.CmmToAsm.Instr GHC.Cmm.ExprGHC.Platform.X86_64GHC.Platform.X86GHC.Platform.SPARCGHC.Platform.S390XGHC.Platform.RISCV64GHC.Platform.PPCGHC.Platform.NoRegsGHC.Platform.ARMGHC.Platform.AArch64GHC.Platform.RegsGHC.Cmm.Ppr.ExprGHC.Cmm.LRegSetGHC.ByteCode.TypesGHC.Linker.TypesGHC.Runtime.Interpreter.TypesGHC.Core.Map.Expr GHC.Stg.CSE GHC.Core.FVsGHC.Core.InstEnvGHC.Unit.Module.ModDetailsGHC.Tc.Instance.FunDepsGHC.Core.Coercion.OptGHC.Tc.Types.EvidenceGHC.Stg.Lift.MonadGHC.Core.Opt.LiberateCaseGHC.Core.Opt.StaticArgsGHC.Core.SubstGHC.Core.Opt.ExitifyGHC.Core.Opt.CSEGHC.Core.Opt.ArityGHC.Core.Opt.OccurAnalGHC.Core.Unfold.MakeGHC.Core.Opt.CallArity GHC.Cmm.NodeGHC.CmmToAsm.X86.RegsGHC.CmmToAsm.Reg.Linear.X86_64GHC.CmmToAsm.Reg.Linear.X86GHC.CmmToAsm.UtilsGHC.CmmToAsm.TypesGHC.CmmToAsm.SPARC.ImmGHC.CmmToAsm.SPARC.AddrModeGHC.CmmToAsm.PprGHC.Llvm.TypesGHC.Llvm.MetaDataGHC.Llvm.Syntax GHC.Llvm.PprGHC.CmmToLlvm.RegsGHC.CmmToAsm.FormatGHC.CmmToAsm.X86.RegInfoGHC.CmmToAsm.SPARC.RegsGHC.CmmToAsm.SPARC.StackGHC.CmmToAsm.Reg.Linear.SPARCGHC.CmmToAsm.PPC.RegsGHC.CmmToAsm.Reg.Linear.PPCGHC.CmmToAsm.Dwarf.ConstantsGHC.CmmToAsm.AArch64.RegsGHC.CmmToAsm.Reg.TargetGHC.CmmToAsm.SPARC.InstrGHC.CmmToAsm.SPARC.ShortcutJump!GHC.CmmToAsm.SPARC.CodeGen.ExpandGHC.CmmToAsm.SPARC.CodeGen.BaseGHC.CmmToAsm.Reg.Linear.AArch64GHC.CmmToAsm.AArch64.InstrGHC.CmmToAsm.AArch64.RegInfoGHC.CmmToAsm.AArch64.Ppr GHC.Cmm.UtilsGHC.StgToCmm.ClosureGHC.StgToCmm.ArgRepGHC.StgToCmm.CgUtilsGHC.CmmToLlvm.BaseGHC.SysTools.TasksGHC.Linker.ExtraObj GHC.SysToolsGHC.Linker.WindowsGHC.CmmToLlvm.DataGHC.CmmToLlvm.PprGHC.Cmm.Switch.ImplementGHC.Cmm.Ppr.Decl GHC.Cmm.PprGHC.CmmToLlvm.CodeGen GHC.CmmToLlvm GHC.CmmToCGHC.CmmToAsm.SPARC.Ppr!GHC.CmmToAsm.SPARC.CodeGen.SanityGHC.CmmToAsm.CFGGHC.CmmToAsm.Reg.LivenessGHC.CmmToAsm.Reg.Linear.BaseGHC.CmmToAsm.Reg.Linear.StatsGHC.CmmToAsm.Reg.Linear.State!GHC.CmmToAsm.Reg.Graph.SpillCleanGHC.CmmToAsm.Reg.Graph.SpillGHC.CmmToAsm.Reg.Graph.Coalesce GHC.CmmToAsm.Reg.Graph.SpillCostGHC.CmmToAsm.Reg.Graph.StatsGHC.CmmToAsm.Reg.Graph GHC.Cmm.Opt GHC.Cmm.InfoGHC.CmmToAsm.PPC.InstrGHC.CmmToAsm.PPC.RegInfoGHC.CmmToAsm.PPC.PprGHC.Cmm.DataflowGHC.Cmm.Liveness GHC.Cmm.SinkGHC.Cmm.ProcPoint GHC.Cmm.LintGHC.Cmm.ContFlowOptGHC.Cmm.CommonBlockElimGHC.Cmm.CallConv GHC.Cmm.GraphGHC.StgToCmm.MonadGHC.StgToCmm.UtilsGHC.StgToCmm.ForeignGHC.StgToCmm.TickyGHC.StgToCmm.BindGHC.StgToCmm.HpcGHC.StgToCmm.ExtCodeGHC.StgToCmm.EnvGHC.StgToCmm.LayoutGHC.Stg.Lift.Analysis GHC.Stg.LiftGHC.ByteCode.InstrGHC.Cmm.DebugBlockGHC.CmmToAsm.X86.InstrGHC.CmmToAsm.X86.Ppr GHC.CmmToAsm.Reg.Linear.FreeRegs%GHC.CmmToAsm.Reg.Linear.JoinToTargetsGHC.CmmToAsm.Reg.LinearGHC.CmmToAsm.Monad GHC.CmmToAsm.SPARC.CodeGen.Gen32#GHC.CmmToAsm.SPARC.CodeGen.CondCode GHC.CmmToAsm.SPARC.CodeGen.Amode GHC.CmmToAsm.SPARC.CodeGen.Gen64GHC.CmmToAsm.PICGHC.CmmToAsm.X86.CodeGenGHC.CmmToAsm.X86GHC.CmmToAsm.SPARC.CodeGenGHC.CmmToAsm.SPARCGHC.CmmToAsm.PPC.CodeGenGHC.CmmToAsm.PPCGHC.CmmToAsm.BlockLayoutGHC.CmmToAsm.Dwarf.TypesGHC.CmmToAsm.DwarfGHC.CmmToAsm.AArch64.CodeGenGHC.CmmToAsm.AArch64 GHC.CmmToAsmGHC.Hs.Extension GHC.Hs.ImpExpLanguage.Haskell.Syntax.LitLanguage.Haskell.Syntax.Pat GHC.Hs.PatLanguage.Haskell.Syntax.BindsLanguage.Haskell.Syntax.Decls GHC.Hs.Expr GHC.Hs.Lit GHC.Hs.Type GHC.Hs.Utils GHC.Hs.BindsGHC.Parser.Types GHC.Hs.DeclsGHC.Parser.ErrorsGHC.Parser.LexerGHC.Parser.Errors.PprGHC.Cmm.Parser.Monad GHC.Cmm.Lexer GHC.Core.MakeGHC.Tc.Types.EvTermGHC.Driver.ConfigGHC.Core.RulesGHC.Core.Opt.ConstantFoldGHC.Stg.Unarise GHC.CoreToStgGHC.Core.Opt.WorkWrap.UtilsGHC.Core.Opt.WorkWrapGHC.Core.Opt.DmdAnalGHC.Core.Opt.CprAnalGHC.Hs.InstancesGHC.HsGHC.Unit.Module.ModSummaryGHC.Unit.Module.GraphGHC.Unit.Module.ModIfaceGHC.Unit.Home.ModInfoGHC.Unit.ExternalGHC.Unit.Module.ModGutsGHC.Unit.Module.StatusGHC.Types.MetaGHC.Tc.Types.OriginGHC.Tc.Types.ConstraintGHC.Builtin.Types.LiteralsGHC.Builtin.UtilsGHC.Iface.Ext.TypesGHC.Iface.Ext.UtilsGHC.Iface.Ext.DebugGHC.Runtime.ContextGHC.Driver.EnvGHC.Driver.Env.TypesGHC.Unit.FinderGHC.Driver.CodeOutputGHC.StgToCmm.ProfGHC.StgToCmm.HeapGHC.StgToCmm.DataConGHC.Cmm.Info.BuildGHC.StgToCmm.PrimGHC.Cmm.LayoutStackGHC.StgToCmm.Expr GHC.StgToCmmGHC.Cmm.ParserGHC.Linker.MacOSGHC.Linker.DynamicGHC.Linker.StaticGHC.ByteCode.LinkerGHC.ByteCode.InfoTableGHC.StgToByteCodeGHC.Driver.MonadGHC.Core.Opt.MonadGHC.Core.Opt.SpecialiseGHC.Core.Opt.Simplify.MonadGHC.Core.Opt.Simplify.EnvGHC.Core.Opt.Simplify.UtilsGHC.Core.Opt.SimplifyGHC.Core.Opt.SetLevelsGHC.Core.Opt.FloatOutGHC.Core.Opt.FloatInGHC.Iface.Recomp.FlagsGHC.Cmm.Pipeline GHC.Core.LintGHC.Tc.Utils.UnifyGHC.Tc.Utils.EnvGHC.Tc.Utils.MonadGHC.Tc.Utils.TcMTypeGHC.Rename.UnboundGHC.Iface.Load GHC.Iface.EnvGHC.Types.Name.ShapeGHC.Tc.TyCl.BuildGHC.Iface.RenameGHC.Iface.BinaryGHC.Iface.Ext.Binary GHC.Tc.ModuleGHC.Tc.Gen.SpliceGHC.Tc.Gen.AnnotationGHC.Tc.Gen.MatchGHC.Tc.Gen.ExprGHC.Tc.Errors.HoleGHC.IfaceToCoreGHC.HsToCore.UsageGHC.HsToCore.Docs GHC.Stg.LintGHC.Stg.PipelineGHC.Rename.SpliceGHC.Rename.ExprGHC.Parser.PostProcess.HaddockGHC.Parser.PostProcess GHC.ThToHsGHC.HsToCore.Coverage GHC.Hs.Stats GHC.Hs.DumpGHC.Driver.Pipeline.MonadGHC.Tc.Utils.ZonkGHC.Tc.Utils.InstantiateGHC.Tc.Instance.TypeableGHC.Runtime.Heap.InspectGHC.Rename.Utils GHC.PluginsGHC.Iface.Tidy.StaticPtrTableGHC.Iface.TidyGHC.CoreToStg.PrepGHC.Tc.Instance.Family GHC.Tc.ErrorsGHC.Rename.FixityGHC.Rename.EnvGHC.Tc.Instance.ClassGHC.Tc.Solver.Monad GHC.Tc.SolverGHC.Tc.Solver.RewriteGHC.Tc.Solver.Canonical GHC.Tc.PluginGHC.HsToCore.Pmc.Solver.TypesGHC.HsToCore.Pmc.TypesGHC.Tc.Solver.InteractGHC.Tc.ValidityGHC.Tc.Deriv.GenerateGHC.Tc.Deriv.FunctorGHC.Tc.Deriv.GenericsGHC.Tc.Deriv.UtilsGHC.Tc.Deriv.InferGHC.Rename.NamesGHC.Tc.Gen.ExportGHC.Rename.HsTypeGHC.Rename.PatGHC.Rename.BindGHC.Rename.ModuleGHC.Linker.LoaderGHC.Runtime.LoaderGHC.Tc.Gen.HsTypeGHC.Tc.Gen.SigGHC.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.Iface.RecompGHC.Iface.MakeGHC.Types.TyThing.PprGHC.HsToCore.TypesGHC.HsToCore.MonadGHC.HsToCore.Pmc.UtilsGHC.HsToCore.PmcGHC.HsToCore.Pmc.SolverGHC.HsToCore.Pmc.PprGHC.HsToCore.Pmc.CheckGHC.HsToCore.MatchGHC.HsToCore.ExprGHC.HsToCore.UtilsGHC.HsToCore.Foreign.CallGHC.HsToCore.Match.LiteralGHC.HsToCore.GuardedRHSsGHC.HsToCore.BindsGHC.HsToCore.Pmc.DesugarGHC.HsToCore.QuoteGHC.HsToCore.Match.ConstructorGHC.HsToCore.ListCompGHC.HsToCore.ArrowsGHC.Iface.Ext.AstGHC.HsToCore.Foreign.DeclGHC.Core.Opt.PipelineGHC.Driver.Backpack.Syntax GHC.ParserGHC.Parser.UtilsGHC.Parser.HeaderGHC.Driver.Main GHC.HsToCoreGHC.Runtime.EvalGHC.Driver.PipelineGHC.Driver.MakeGHC.Runtime.DebuggerGHC.Driver.MakeFileGHC.Driver.Backpack GHC.Linker GhcExceptionSDoc Data.Listnullheadunconstail Data.VoidabsurdpprWithUnitStateputIfaceTopBndrgetIfaceTopBndr AnnKeywordIdAnnOpen AnnHeaderAnnValAnnCloseData.MapStrictrunGhc runPipelineFloatOutSwitches ModBreaks cc_flavourCoreMapfunTyCon mkTyConTyTyConAnnComma mkCoreLetMxexports_from_avail Data.KindTypeAnnType AnnBackquoteAnnTilde mkCoreApps mkCharExpr mkCoreConApps mkDoubleExpr mkFloatExpr mkIntExpr mkCoreLams mkCoreLets mkStringExpr mkWordExprIdHsExprRdrNamesUniqueRdrNamesubstTyGHC.ExtsoneShotmkHsWrapAnnVbarAnnEqualAnnWhere AnnRarrowAnnSemi Annlarrowtail Annrarrowtail AnnLarrowtail AnnRarrowtailAnnOpenB AnnCloseBAnnCaseAnnOfAnnDoAnnIfAnnThenAnnElseAnnLamAnnLetAnnIn AnnDotdot AnnDcolonAnnAtAnnOpenE AnnOpenEQ AnnCloseQAnnDotAnnProcAnnOpenP AnnCloseP AnnStaticAnnMinusAnnColonAnnByAnnGroupAnnUsingAnnRecLanguage.Haskell.TH.SyntaxaddModFinalizerAnnBang AnnModuleAnnCLose AnnDarrow AnnForallAnnData AnnNewType AnnInstance AnnDefault AnnDerivingAnnStock AnnAnyClass AnnNewtype AnnFamily AnnForeign AnnImport AnnExportAnnRole tcMonoBindsAnnFunId AnnPattern AnnLarrowAnnInfixcheckClosedInStaticFormdecideGeneralisationPlanAnnDeclGHC.UnitLanguage.Haskell.Syntax AnnotationcvBindsAndSigsload HscNoRecomp SourceNote NoExtField initGhcMonad GHC.Tc.Utils imp_dep_mods setContextSessioninitializePluginstcg_type_env_varTcGblEnvtopSortModuleGraph flattenSCCBitsshiftRSubstdataConRepInstPatGHC.LlvmGHC.STGDebug idPrimRepliftedIdsExpander rnImportDecl newFamInstcheckConsistentFamInstexpandTypeSynonyms singleton ConPatOut addExternalDynFlagsbackend SourceErrorbaseGHC.Base++ghc-primGHC.PrimseqGHC.Listfilterzip System.IOprint Data.Tuplefstsnd otherwise Debug.Tracetracemap$GHC.Num fromInteger-GHC.Real fromRationalGHC.EnumenumFrom enumFromThen enumFromToenumFromThenTo GHC.Classes==>=negate>>=>>fmapreturnControl.Monad.FixmfixControl.Monad.Failfail fromIntegral realToFrac toInteger toRationalmemptymappendmconcat<*>pure*>BoundedEnumEq GHC.FloatFloating FractionalIntegralMonadFunctorNumOrdGHC.ReadReadReal RealFloatRealFracGHC.ShowShowMonadFix MonadFail Applicative Data.FoldableFoldableData.Traversable Traversable SemigroupMonoid GHC.TypesBoolStringCharDoubleFloatInt ghc-bignumGHC.Num.IntegerInteger GHC.MaybeMaybeOrderingRationalIOWord Data.EitherEitherPluginFrontendPluginFalseNothingJustTrueLeftRightLTEQGTGHC.Fingerprint.Type Fingerprint NoSpecConstrForceSpecConstrSpecConstrAnnotationsortWith Data.Data mkNoRepTypeControl.Monad.IO.ClassliftIOMonadIO GHC.ByteOrder LittleEndian BigEndian ByteOrder Control.Monad mapAndUnzipM Data.Version versionTags versionBranchVersiontraverse sequenceAsequencemapMGHC.Fingerprint getFileHashfingerprintData fingerprint0 writeFilereadLnreadIOreadFileputStrLnputStrputCharinteractgetLine getContentsgetChar appendFileControl.Exception.Basetry GHC.Conc.SyncthrowToGHC.IO.ExceptionioError GHC.IORefIORefGHC.IOFilePathIOError userErrorGHC.Exception.Type toException fromExceptiondisplayException Exceptionsumproductminimummaximumlengthfoldr1foldrfoldl1foldl'foldlfoldMapelem sequence_ornotElemmapM_foldrMfoldlM concatMapconcatanyandall Data.OldListwordsunwordsunlineslinesData.Semigroup.InternalappEndoEndo Text.ReadreadsreadeitherfingerprintStringfingerprintFingerprints readsPrecreadList readParenlexText.ParserCombinators.ReadPReadS significand scaleFloatisNegativeZeroisNaN isInfiniteisIEEEisDenormalized floatRange floatRadix floatDigitsexponent encodeFloat decodeFloatatan2tanhtansqrtsinhsinpilogBaselogexpcoshcosatanhatanasinhasinacoshacos**GHC.Bits finiteBitSizecountTrailingZeroscountLeadingZeros FiniteBitszeroBitsxor unsafeShiftR unsafeShiftLtestBitshiftsetBitrotateRrotateLrotatepopCountisSigned complementBit complementclearBit bitSizeMaybebitSizebit.|..&.toIntegralSizedtestBitDefaultpopCountDefault bitDefaulttruncateroundproperFractionfloorceilingremquotRemquotmoddivModdivrecip/oddlcmgcdeven^^^toEnumsuccpredfromEnumminBoundmaxBoundShowS showsPrecshowListshowshows showString showParenshowCharzipWith3zipWithzip3unzip3unzip takeWhiletakesplitAtspanscanr1scanrscanl1scanlreverse replicaterepeatlookuplastiterateinitfoldl1' dropWhiledropcyclebreak!! Data.Maybemaybe Data.Functor<$>uncurrycurrysignumabs+*subtract<$liftA2<*untilidflipconstasTypeOf=<<.$!GHC.Err undefinederrorWithoutStackTraceerrorGHC.Stack.Types HasCallStack&&not||/=<<=>comparemaxmincontainers-0.6.5.1 Data.Graph CyclicSCC AcyclicSCCSCC flattenSCCstransformers-0.5.6.2Control.Monad.Trans.MaybeMaybeTghc-boot-th-9.2.3GHC.ForeignSrcLang.TypeLangCLangAsmLangCxxLangObjc LangObjcxx RawObjectForeignSrcLangghc-boot-9.2.3GHC.Unit.DatabaseunitPackageVersionunitPackageName unitPackageIdunitLinkerOptionsunitLibraryDynDirsunitLibraryDirs unitLibraries unitIsTrustedunitIsIndefinite unitIsExposedunitInstantiationsunitInstanceOf unitIncludesunitIncludeDirsunitImportDirsunitIdunitHiddenModulesunitHaddockInterfacesunitHaddockHTMLsunitExtDepLibsSysunitExtDepLibsGhcunitExtDepFrameworksunitExtDepFrameworkDirsunitExposedModules unitDependsunitComponentName unitCcOptions unitAbiHashunitAbiDependsGenericUnitInfoGHC.Platform.ArchOSELF_V2ELF_V1 PPC_64ABI OSUnknown OSSolaris2OSQNXNTO OSOpenBSDOSNetBSD OSMinGW32OSLinux OSKFreeBSDOSHurdOSHaiku OSFreeBSD OSDragonFlyOSDarwinOSAIXOSVFPv3D16VFPv3VFPv2NEONIWMMX2 ArmISAExtARMv7ARMv6ARMv5ArmISASOFTFPSOFTHARDArmABI archOS_arch archOS_OSArchOS ArchX86_64ArchX86 ArchUnknown ArchSPARC64 ArchSPARC ArchS390X ArchRISCV64 ArchPPC_64ArchPPC ArchMipsel ArchMipsebArchJavaScript ArchAlphaArchARM ArchAArch64ArchGHC.Data.SizedSeqSizedSeqssEltssizeSS GHC.BaseDir expandTopDir ghci-9.2.3 GHCi.Message UnloadObjStartTHShutdownSetupBreakpointSeqRunTHRunModFinalizers RtsRevertCAFs ResumeStmt ResumeSeq ResolveObjsRemoveLibrarySearchPathPrepFFI NewBreakArray MkCostCentresMkConInfoTable MallocStrings MallocData LookupSymbol LookupClosureLoadObjLoadDLL LoadArchive InitLinker GetClosureGetBreakpointVarFreeHValueRefsFreeFFIFindSystemLibraryEvalStringToString EvalStringEvalStmtEvalIO CreateBCOsCostCentreStackInfoBreakpointStatus AddSptEntryAddLibrarySearchPath AbandonStmtMessage EvalComplete EvalBreak EvalStatus_ EvalStatus EvalSuccess EvalException EvalResultEvalThisEvalAppEvalExprGHCi.RemoteTypesHValue ForeignHValue runMaybeT IfaceAppArgs IfaceBndr IfaceCoercion IfaceTyCon IfaceTyLit IfaceTypeparseConstantsHeaderPlatformConstantspc_AP_STACK_SPLIMpc_BITMAP_BITS_SHIFTpc_BLOCKS_PER_MBLOCK pc_BLOCK_SIZE pc_CINT_SIZEpc_CLONG_LONG_SIZE pc_CLONG_SIZEpc_CONTROL_GROUP_CONST_291pc_ILDV_CREATE_MASKpc_ILDV_STATE_CREATEpc_ILDV_STATE_USE pc_LDV_SHIFTpc_MAX_CHARLIKEpc_MAX_Double_REGpc_MAX_Float_REGpc_MAX_INTLIKEpc_MAX_Long_REGpc_MAX_Real_Double_REGpc_MAX_Real_Float_REGpc_MAX_Real_Long_REGpc_MAX_Real_Vanilla_REGpc_MAX_Real_XMM_REGpc_MAX_SPEC_AP_SIZEpc_MAX_SPEC_SELECTEE_SIZEpc_MAX_Vanilla_REGpc_MAX_XMM_REGpc_MIN_CHARLIKEpc_MIN_INTLIKEpc_MIN_PAYLOAD_SIZEpc_MUT_ARR_PTRS_CARD_BITSpc_OFFSET_Capability_r#pc_OFFSET_CostCentreStack_mem_alloc#pc_OFFSET_CostCentreStack_scc_countpc_OFFSET_StgArrBytes_bytespc_OFFSET_StgEntCounter_allocdpc_OFFSET_StgEntCounter_allocs#pc_OFFSET_StgEntCounter_entry_countpc_OFFSET_StgEntCounter_link#pc_OFFSET_StgEntCounter_registeredp"pc_OFFSET_StgFunInfoExtraFwd_arity"pc_OFFSET_StgFunInfoExtraRev_aritypc_OFFSET_StgHeader_ccspc_OFFSET_StgHeader_ldvwpc_OFFSET_StgMutArrPtrs_ptrspc_OFFSET_StgMutArrPtrs_sizepc_OFFSET_StgRegTable_rCCCS%pc_OFFSET_StgRegTable_rCurrentNursery!pc_OFFSET_StgRegTable_rCurrentTSOpc_OFFSET_StgRegTable_rD1pc_OFFSET_StgRegTable_rD2pc_OFFSET_StgRegTable_rD3pc_OFFSET_StgRegTable_rD4pc_OFFSET_StgRegTable_rD5pc_OFFSET_StgRegTable_rD6pc_OFFSET_StgRegTable_rF1pc_OFFSET_StgRegTable_rF2pc_OFFSET_StgRegTable_rF3pc_OFFSET_StgRegTable_rF4pc_OFFSET_StgRegTable_rF5pc_OFFSET_StgRegTable_rF6pc_OFFSET_StgRegTable_rHppc_OFFSET_StgRegTable_rHpAllocpc_OFFSET_StgRegTable_rHpLimpc_OFFSET_StgRegTable_rL1pc_OFFSET_StgRegTable_rR1pc_OFFSET_StgRegTable_rR10pc_OFFSET_StgRegTable_rR2pc_OFFSET_StgRegTable_rR3pc_OFFSET_StgRegTable_rR4pc_OFFSET_StgRegTable_rR5pc_OFFSET_StgRegTable_rR6pc_OFFSET_StgRegTable_rR7pc_OFFSET_StgRegTable_rR8pc_OFFSET_StgRegTable_rR9pc_OFFSET_StgRegTable_rSppc_OFFSET_StgRegTable_rSpLimpc_OFFSET_StgRegTable_rXMM1pc_OFFSET_StgRegTable_rXMM2pc_OFFSET_StgRegTable_rXMM3pc_OFFSET_StgRegTable_rXMM4pc_OFFSET_StgRegTable_rXMM5pc_OFFSET_StgRegTable_rXMM6pc_OFFSET_StgRegTable_rYMM1pc_OFFSET_StgRegTable_rYMM2pc_OFFSET_StgRegTable_rYMM3pc_OFFSET_StgRegTable_rYMM4pc_OFFSET_StgRegTable_rYMM5pc_OFFSET_StgRegTable_rYMM6pc_OFFSET_StgRegTable_rZMM1pc_OFFSET_StgRegTable_rZMM2pc_OFFSET_StgRegTable_rZMM3pc_OFFSET_StgRegTable_rZMM4pc_OFFSET_StgRegTable_rZMM5pc_OFFSET_StgRegTable_rZMM6!pc_OFFSET_StgSmallMutArrPtrs_ptrspc_OFFSET_StgStack_sppc_OFFSET_StgStack_stackpc_OFFSET_StgTSO_alloc_limitpc_OFFSET_StgTSO_cccspc_OFFSET_StgTSO_stackobj pc_OFFSET_StgUpdateFrame_updateepc_OFFSET_bdescr_blockspc_OFFSET_bdescr_flagspc_OFFSET_bdescr_freepc_OFFSET_bdescr_startpc_OFFSET_stgEagerBlackholeInfopc_OFFSET_stgGCEnter1pc_OFFSET_stgGCFunpc_PROF_HDR_SIZE pc_REP_CostCentreStack_mem_alloc pc_REP_CostCentreStack_scc_countpc_REP_StgEntCounter_allocdpc_REP_StgEntCounter_allocspc_REP_StgFunInfoExtraFwd_aritypc_REP_StgFunInfoExtraRev_aritypc_RESERVED_C_STACK_BYTESpc_RESERVED_STACK_WORDSpc_SIZEOF_CostCentreStackpc_SIZEOF_StgArrBytes_NoHdrpc_SIZEOF_StgFunInfoExtraRevpc_SIZEOF_StgMutArrPtrs_NoHdrpc_SIZEOF_StgSMPThunkHeader"pc_SIZEOF_StgSmallMutArrPtrs_NoHdrpc_SIZEOF_StgUpdateFrame_NoHdrpc_STD_HDR_SIZE pc_TAG_BITSpc_TICKY_BIN_COUNT pc_WORD_SIZE$fEqPlatformConstants$fReadPlatformConstants$fShowPlatformConstantsshiftL LoadedPlugin StaticPlugin emptyHooks ContainsHooks extractHooksHasHooksgetHooksHooks equivalentfindfresh readPointreprunion writePointLinkInfoPoint $fEqPointcollectconsumefromList mapAccumL_ runStreamyieldStreamrunStreamInternalStreamSDoneEffectYield$fApplicativeStream$fFunctorStream$fApplicativeStreamS$fFunctorStreamS$fMonadIOStream $fMonadStream$fMonadStreamS deleteList foldRightfoldRightWithKey insertListinsertListWithatomicFetchAddFastMut newFastMutIntreadFastMutIntwriteFastMutInt FastMutIntdelete differenceemptyinsertmembertoListEnumSetdefaultUnfoldingOptsupdateCaseScalingupdateCaseThresholdupdateCreationThresholdupdateDictDiscountupdateFunAppDiscountupdateUseThresholdupdateVeryAggressive UnfoldingOptsparseCallerCcFilterCallerCcFiltercondToUnsigned maybeFlipCondmaybeInvertCondCondALWAYSCARRYEQQGEGEUGTTGULELEULTTLUNENEG NOTPARITYOFLOPARITYPOS$fEqCondNEVERVCVS ancestorsasGraphasTreedomdomTreefromAdj fromEdgesidomipdomparentspddfspdompdomTreerpddfstoAdjtoEdgesEdgeGraphNodePathRooted$fApplicativeS $fFunctorS$fMonadSOGEOGTOLEOLTSGESGTSLESLTUGEUGTULEULTUOGEUOGTUOLEUOLT mapDeleteList mapInsertList mapUnions setDeleteList setInsertList setUnionsIsMapKeyOf mapAdjustmapAlter mapDelete mapDifferencemapElemsmapEmpty mapFiltermapFilterWithKeymapFindWithDefaultmapFoldMapWithKeymapFoldlmapFoldlWithKeymapFoldr mapFromListmapFromListWith mapInsert mapInsertWithmapIntersection mapIsSubmapOfmapKeys mapLookupmapMap mapMapWithKey mapMembermapNull mapSingletonmapSize mapToListmapUnionmapUnionWithKeyIsSetElemOf setDelete setDifferencesetElemssetEmpty setFiltersetFoldlsetFoldr setFromList setInsertsetIntersection setIsSubsetOf setMembersetNull setSingletonsetSizesetUnion UniqueMap UniqueSet $fEqUniqueMap $fEqUniqueSet$fFoldableUniqueMap$fFunctorUniqueMap$fIsMapUniqueMap$fIsSetUniqueSet$fMonoidUniqueSet$fSemigroupUniqueSet$fOrdUniqueMap$fOrdUniqueSet$fShowUniqueMap$fShowUniqueSet$fTraversableUniqueMap blockAppend blockCons blockFromList blockJoin blockJoinHead blockJoinTail blockSnoc blockSplitblockSplitHeadblockSplitTail blockToList emptyBlock firstNodefoldBlockNodesBfoldBlockNodesB3foldBlockNodesF isEmptyBlocklastNodemapBlock mapBlock' mapBlock3'replaceFirstNodereplaceLastNodeBlockBCatBConsBMiddleBNilBSnocBlockCCBlockCOBlockOCC ExtensibilityClosedOpen IndexedCOMaybeOJustONothingOO$fFunctorMaybeOPrimOpcBooterVersioncBuildPlatformStringcHostPlatformString cProjectNamecStage dOUBLE_SIZE fLOAT_SIZE hiVersionmAX_CTUPLE_SIZEmAX_REDUCTION_DEPTHmAX_SOLVER_ITERATIONS mAX_SUM_SIZEmAX_TUPLE_SIZEtARGET_MAX_CHAR wORD64_SIZEafilter isBSDSymdef isGNUSymdefloadArloadObjparseAr writeBSDAr writeGNUArArchive ArchiveEntryfiledatafilegrpfilemodefilenamefileownfilesizefiletime $fEqArchive$fEqArchiveEntry$fMonoidArchive$fSemigroupArchive $fShowArchive$fShowArchiveEntrystderrSupportsAnsiColors HoleFitPlugin emptyHpcInfo isHpcUsed AnyHpcUsageHpcInfo NoHpcInfo hpcInfoHashhpcInfoTickCounthpcUsed ModuleNameshowOptOption FileOption $fEqOptioncatchIOhandleIOtryIOExceptionMonadfingerprintByteStringreadHexFingerprint consIORefglobalglobalM sharedGlobal sharedGlobalMunsafeHasNoDebugOutputunsafeHasNoStateHackunsafeHasPprDebugv_unsafeHasNoDebugOutputv_unsafeHasNoStateHackv_unsafeHasPprDebuginlinePerformIOallManyM concatMapM filterOutM fmapEitherM fmapMaybeMfoldlM_liftFstMliftSndM mapAccumLM mapAndUnzip3M mapAndUnzip4M mapAndUnzip5M mapMaybeMmapSndM maybeMapMorMunlessMwhenM zipWith3M zipWith3M_ zipWith4MzipWithAndUnzipM evalState execStategetgetsmodifyputrunStateState runState'$fApplicativeState$fFunctorState $fMonadStatetextPprStyle SDocContext moduleName moduleUnit pprModule GenModuleGenUnit IndefUnitId IndefiniteModuleUnitUnitIdemptyUnitStatepprUnitIdForUser unwireUnit UnitDatabase UnitState assertPanic cmdLineErrorcmdLineErrorIOpanicpgmErrorprogNameshowPlainGhcExceptionsorryPlainGhcExceptionPlainCmdLineErrorPlainInstallationError PlainPanicPlainProgramError PlainSignal PlainSorryPlainUsageError$fExceptionPlainGhcException$fShowPlainGhcException<&&><||>abstractConstrabstractDataTypeall2 applyWhenatLength capitalise changeLastcharToC chkAppend chunkListcmpList compareLengthcount countWhile debugIsOndoesDirNameExistdropListdropTaildropWhileEndLEeqListBy eqMaybeBy equalLength escapeSpaces exactLog2 filterByList filterByLists filterOutfirst3MfirstMfoldl2fst3fstOf3 fuzzyLookup fuzzyMatchgetCmdgetModificationUTCTime ghciSupported hashString isDarwinHostisEqualisIn isSingleton isSortedBy isWindowsHostisn'tInlast2 lastMaybeleLength lengthAtLeast lengthAtMost lengthExceedslengthIs lengthIsNotlengthLessThanliftFstliftSnd listLengthCmplooksLikeModuleNamelooksLikePackageNameltLengthmakeRelativeTo mapAndUnzip mapAndUnzip3mapFstmapLastMmapSnd mergeListsByminWithmodificationTimeIfExistsnTimesnotNullnubSortonlyordNub overrideWithpartitionByList partitionWithreadHexRationalreadHexSignificandExponentPair readRationalreadSignificandExponentPair removeSpacesreslashsecondMseqListsnd3sndOf3snocViewspanEndsplit splitAtListsplitLongestPrefixstretchZipWith strictMap strictZipWithtakeListthdOf3thenCmpthird3toArgs toCmdArgstransitiveClosureuncurry3 unzipWith whenNonEmptywithAtomicRename zipAndUnzipzipEqualzipLazy zipWith3Equal zipWith3Lazy zipWith4EqualzipWithAndUnzip zipWithEqual zipWithLazy Direction BackwardsForwardsHasDebugCallStackOverridingBoolAlwaysAutoNeverSuffix$fShowOverridingBool expectJustfailME firstJust firstJusts firstJustsM isSuccess liftMaybeTorElse rightToMaybe tryMaybeT whenIsJustMaybeErrFailed Succeeded$fApplicativeMaybeErr$fFunctorMaybeErr$fMonadMaybeErrgenericPlatformisARMlookupPlatformConstants osElfTarget osMachOTargetosSubsectionsViaSymbols platformArchplatformCConvNeedsExtensionplatformConstantsplatformHsSONameplatformInIntRangeplatformInWordRangeplatformMaxIntplatformMaxWordplatformMinInt platformOS platformSOExtplatformSONameplatformUsesFrameworksplatformWordSizeInBitsplatformWordSizeInBytes target32Bit BmiVersionBMI1BMI2PlatformplatformArchOSplatformByteOrderplatformHasGnuNonexecStackplatformHasIdentDirective platformHasSubsectionsViaSymbolsplatformIsCrossCompilingplatformLeadingUnderscoreplatformTablesNextToCodeplatformUnregisterisedplatformWordSizeplatform_constants PlatformMiscplatformMisc_ghcRTSWaysplatformMisc_ghcRtsWithLibdwplatformMisc_ghcWithInterpreterplatformMisc_ghcWithSMPplatformMisc_libFFIplatformMisc_llvmTarget!platformMisc_targetPlatformStringPlatformWordSizePW4PW8 SseVersionSSE1SSE2SSE3SSE4SSE42$fEqBmiVersion $fEqPlatform$fEqPlatformWordSize$fEqSseVersion$fOrdBmiVersion$fOrdPlatformWordSize$fOrdSseVersion$fReadPlatform$fReadPlatformWordSize$fShowPlatform$fShowPlatformWordSize dynLibSuffixsExtraGccViaCFlagssGccSupportsNoPie sGhcRTSWayssGhcRtsWithLibdw sGhcUsagePathsGhcWithInterpreter sGhcWithSMPsGhciUsagePathsGlobalPackageDatabasePath sLdIsGnuLdsLdSupportsBuildIdsLdSupportsCompactUnwindsLdSupportsFilelistsLibFFIsOpt_FsOpt_LsOpt_PsOpt_P_fingerprintsOpt_asOpt_csOpt_cxxsOpt_isOpt_lsOpt_lcsOpt_lccsOpt_lmsOpt_lo sOpt_windressPgm_FsPgm_LsPgm_PsPgm_TsPgm_asPgm_arsPgm_csPgm_dllsPgm_isPgm_install_name_toolsPgm_lsPgm_lcsPgm_lcc sPgm_libtoolsPgm_lmsPgm_lo sPgm_otool sPgm_ranlib sPgm_windres sProgramNamesProjectVersionsTargetPlatformStringsTmpDirsToolDirsTopDir FileSettingsfileSettings_ghcUsagePathfileSettings_ghciUsagePath"fileSettings_globalPackageDatabasefileSettings_tmpDirfileSettings_toolDirfileSettings_topDirGhcNameVersionghcNameVersion_programNameghcNameVersion_projectVersionSettings sFileSettingssGhcNameVersion sPlatformMisc sRawSettingssTargetPlatform sToolSettings ToolSettingstoolSettings_ccSupportsNoPietoolSettings_extraGccViaCFlagstoolSettings_ldIsGnuLdtoolSettings_ldSupportsBuildId$toolSettings_ldSupportsCompactUnwindtoolSettings_ldSupportsFilelisttoolSettings_opt_FtoolSettings_opt_LtoolSettings_opt_PtoolSettings_opt_P_fingerprinttoolSettings_opt_atoolSettings_opt_ctoolSettings_opt_cxxtoolSettings_opt_itoolSettings_opt_ltoolSettings_opt_lctoolSettings_opt_lcctoolSettings_opt_lmtoolSettings_opt_lotoolSettings_opt_windrestoolSettings_pgm_FtoolSettings_pgm_LtoolSettings_pgm_PtoolSettings_pgm_TtoolSettings_pgm_atoolSettings_pgm_artoolSettings_pgm_ctoolSettings_pgm_dlltoolSettings_pgm_i"toolSettings_pgm_install_name_tooltoolSettings_pgm_ltoolSettings_pgm_lctoolSettings_pgm_lcctoolSettings_pgm_libtooltoolSettings_pgm_lmtoolSettings_pgm_lotoolSettings_pgm_otooltoolSettings_pgm_ranlibtoolSettings_pgm_windreshasNoDebugOutput hasPprDebuginitSDocContexttargetPlatformbackendProducesObjectbackendRetainsAllBindingsplatformDefaultBackendplatformNcgSupportedBackend InterpreterLLVMNCG NoBackendViaC $fEqBackend $fOrdBackend $fReadBackend $fShowBackendappendFSbytesFSconcatFSconsFSfastStringToByteStringfastStringToShortByteStringfastZStringToByteStringfsLitgetFastStringTablegetFastStringZEncCounterhPutFShPutFZSheadFSisUnderscoreFSlengthFS lengthFZSlengthPSlexicalCompareFS mkFastString mkFastString#mkFastStringByteListmkFastStringByteStringmkFastStringBytesmkFastStringShortByteString mkPtrString mkPtrString#nilFSnullFSsLitunconsFS uniqCompareFS uniqueOfFSunpackFSunpackPtrStringunsafeMkByteString zEncodeFSzString FastStringfs_sbsfs_zencn_charsuniq FastZStringLexicalFastStringNonDetFastString PtrString$fDataFastString$fDataLexicalFastString$fDataNonDetFastString$fEqFastString$fEqLexicalFastString$fEqNonDetFastString$fIsStringFastString$fMonoidFastString$fSemigroupFastString$fNFDataFastString$fNFDataFastZString$fOrdLexicalFastString$fOrdNonDetFastString$fShowFastString$fShowLexicalFastString$fShowNonDetFastStringisLexCon isLexConId isLexConSymisLexIdisLexSymisLexVar isLexVarId isLexVarSym okConIdOccokConOcc okConSymOccokTcOcc okVarIdOccokVarOcc okVarSymOcc GHC.Lexeme startsConId startsConSym startsVarId startsVarSymbFlushbPutCharbPutFSbPutFZS bPutPtrString bPutReplicatebPutStr newBufHandle BufHandlemkRecFldSelOcc mkVarOccFS occNameString HasOccNameoccNameOccNameappendStringBuffersatEndatLinebidirectionalFormatCharsbyteDiffcontainsBidirectionalFormatChar currentChardecodePrevNCharshGetStringBufferhGetStringBufferBlockhPutStringBufferlexemeToFastStringlexemeToStringnextChar offsetBytesparseUnsignedIntegerprevCharstepOnstringToStringBuffer StringBufferbufcurlen$fShowStringBuffer$$$+$<+><>bracesbrackets bufLeftRendercatcharcoloncommadouble doubleQuotesequalsfcatfloatfsepftext fullRenderhang hangNotEmptyhcathexhsepintintegerisEmptylbracelbracklparen maybeParensnestparensprintDoc printDoc_ptext punctuatequotequotesrationalrbracerbrack renderStylerparensemisep sizedTextspacestyle txtPrintervcat zeroWidthTextztextDocModeLeftMode OneLineModePageMode ZigZagMode asciiSpaceStyle lineLengthmoderibbonsPerLine TextDetailsChrLStrPStrRStrStrZStr $fShowDoc colBlackFg colBlueFgcolBold colCustom colCyanFg colGreenFg colMagentaFgcolRedFgcolReset colWhiteFg colYellowFg defaultScheme parseSchemerenderColourAfresh PprColour renderColourSchemesErrorsFatalsHeadersMarginsMessagesWarning$fMonoidPprColour$fSemigroupPprColour alwaysQualifyalwaysQualifyModulesalwaysQualifyNamesalwaysQualifyPackages angleBracketsarrowarrowtarrowttasmStyle blankLinebufLeftRenderSDocbulletcmdlineParserStyle codeStylecolouredcparendarrowdcolondefaultDumpStyledefaultErrStyledefaultSDocContextdefaultUserStyledoOrDoes docToSDocdot doublePrec dumpStyle forAllLit getPprDebug getPprStyle ifPprDebug intWithCommas interpp'SP interpp'SP' interppSPisOrAre itsOrTheirkeywordlambdalarrowlarrowtlarrowttlollipop mkDumpStyle mkErrStyle mkUserStylemulArrow neverQualifyneverQualifyModulesneverQualifyNamesneverQualifyPackagespluralppUnlessppUnlessOptionppWhen ppWhenOptionpprCode pprDeeper pprDeeperListpprFastFilePathpprFilePathString pprHsBytes pprHsChar pprHsString pprInfixVar pprPrefixVar pprPrimChar pprPrimInt pprPrimInt16 pprPrimInt32 pprPrimInt64 pprPrimInt8 pprPrimWord pprPrimWord16 pprPrimWord32 pprPrimWord64 pprPrimWord8 pprQuotedList pprSetDepth pprWithBars pprWithCommasprimCharSuffixprimDoubleSuffixprimFloatSuffixprimInt16SuffixprimInt32SuffixprimInt64SuffixprimInt8Suffix primIntSuffixprimWord16SuffixprimWord32SuffixprimWord64SuffixprimWord8SuffixprimWordSuffix printSDoc printSDocLn qualModulequalName qualPackage queryQualquotedListWithNorquotedListWithOrreallyAlwaysQualifyreallyAlwaysQualifyNamesrenderWithContextrunSDoc sdocOptionsdocWithContextsetStyleColoured showPprUnsafeshowSDocOneLineshowSDocUnsafespeakNspeakNOfspeakNth underscore unicodeSyntaxupdSDocContext userStylevbar whenPprDebug withErrStyle withPprStyle withUserStyleword BindingSiteCaseBind CasePatBind LambdaBindLetBindDepth AllTheWay DefaultDepthPartWay LabelStyleAsmStyleCStyle OutputablepprOutputableBndrbndrIsJoin_maybepprBndr pprInfixOcc pprPrefixOcc OutputablePpdocPDocPprCodePprDumpPprUserPrintUnqualified QueryQualifyqueryQualifyModulequeryQualifyNamequeryQualifyPackage QualifyNameNameNotInScope1NameNotInScope2NameQual NameUnqualQueryQualifyModuleQueryQualifyNameQueryQualifyPackageSDCsdocCanUseUnicode sdocColSchemesdocDefaultDepthsdocErrorSpanssdocHexWordLiteralssdocImpredicativeTypessdocLastColoursdocLineLengthsdocLinearTypes sdocPprDebugsdocPrintAxiomIncompssdocPrintCaseAsLetsdocPrintEqualityRelationssdocPrintExplicitCoercionssdocPrintExplicitForallssdocPrintExplicitKindssdocPrintExplicitRuntimeRepssdocPrintPotentialInstancessdocPrintTypeAbbreviationssdocPrintTypecheckerElaborationsdocPrintUnicodeSyntaxsdocShouldUseColorsdocStarIsType sdocStylesdocSuppressCoercionssdocSuppressIdInfosdocSuppressModulePrefixessdocSuppressStgExtssdocSuppressTickssdocSuppressTypeApplicationssdocSuppressTypeSignaturessdocSuppressUnfoldingssdocSuppressUniquessdocSuppressVarKindssdocUnitIdForUser$fEqLabelStyle$fIsStringSDoc$fOrdLabelStyle$fOutputable()$fOutputable(,)$fOutputable(,,)$fOutputable(,,,)$fOutputable(,,,,)$fOutputable(,,,,,)$fOutputable(,,,,,,)$fOutputableBool$fOutputableChar$fOutputableDouble$fOutputableEither$fOutputableExtension$fOutputableFastString$fOutputableFingerprint$fOutputableFloat$fOutputableInt$fOutputableInt32$fOutputableInt64$fOutputableIntMap$fOutputableIntSet$fOutputableInteger$fOutputableLexicalFastString$fOutputableMap$fOutputableMaybe$fOutputableNonDetFastString$fOutputableNonEmpty$fOutputableOrdering$fOutputablePenv(,)$fOutputablePenv(,,)$fOutputablePenvMap$fOutputablePenvMaybe$fOutputablePenvPDoc$fOutputablePenvSCC$fOutputablePenvSDoc$fOutputablePenvSet$fOutputablePenv[]$fOutputablePprStyle$fOutputableQualifyName$fOutputableSCC$fOutputableSDoc$fOutputableSerialized$fOutputableSet$fOutputableWord$fOutputableWord16$fOutputableWord32$fOutputableWord64$fOutputable[]$fShowLabelStyleassertPprPanic callStackDochandleGhcExceptionpanicDoc pgmErrorDocpprPanicsafeShowException showExceptionshowGhcExceptionshowGhcExceptionUnsafesorryDocthrowGhcExceptionthrowGhcExceptionIOtryMostwithSignalHandlers CmdLineErrorInstallationErrorPanicPprPanicPprProgramErrorPprSorry ProgramErrorSignalSorry UsageError$fExceptionGhcException$fShowGhcException expandToolDir findToolDir findTopDir tryFindTopDir initSettings SettingsErrorSettingsError_BadDataSettingsError_MissingDatahexDigit is_alphanumis_any is_bindigit is_decdigitis_digit is_hexdigitis_identis_lower is_octdigitis_space is_symbolis_upper octDecDigitextraStackArgsHere fits13Bitsis32BitIntegerlargeOffsetError spillSlotSize wordLengthwordLengthInBits condNegate condUnsigneddefaultWeights parseWeightsWeights backEdgeBonus callWeightcondBranchWeightinfoTablePenaltylikelyCondWeight switchWeight uncondWeightunlikelyCondWeightescapeJsonString renderJSONJsonDocJSArrayJSBoolJSIntJSNullJSObjectJSStringToJsonjson sectionType UnitPprInfounitPprComponentName unitPprIdunitPprPackageNameunitPprPackageVersion$fOutputableUnitPprInfoeqUniquegetKeyhasKey incrUniqueisValidKnownKeyUniqueltUniquemaxLocalUniqueminLocalUnique mkLocalUniquemkUniquemkUniqueGrimily newTagUniquenonDetCmpUniquepprUniqueAlways stepUnique uNIQUE_BITS unpkUnique Uniquable getUnique $fEqUnique$fOutputableUnique $fShowUnique$fUniquableFastString$fUniquableInt$fUniquableUniqueinitUniqSupplyinitUsinitUs_listSplitUniqSupplymkSplitUniqSupplysplitUniqSupplytakeUniqFromSupply uniqFromMaskuniqFromSupplyuniqsFromSupply MonadUnique getUniqueMgetUniqueSupplyM getUniquesMUniqSM UniqSupply$fApplicativeUniqSM$fFunctorUniqSM$fMonadFailUniqSM $fMonadUniqSM$fMonadFixUniqSM$fMonadUniqueUniqSM addListToUFMaddListToUFM_CaddListToUFM_DirectlyaddToUFM addToUFM_Acc addToUFM_CaddToUFM_Directly adjustUFMadjustUFM_DirectlyallUFMalterUFManyUFM delFromUFMdelFromUFM_DirectlydelListFromUFMdelListFromUFM_Directly disjointUFMelemUFMelemUFM_DirectlyeltsUFMemptyUFM equalKeysUFM filterUFMfilterUFM_DirectlyfoldUFM intersectUFMintersectUFM_C isNullUFMlistToIdentityUFM listToUFM listToUFM_ClistToUFM_Directly lookupUFMlookupUFM_DirectlylookupWithDefaultUFMlookupWithDefaultUFM_Directly mapMaybeUFMmapUFMmapUFM_DirectlymergeUFMminusUFM nonDetEltsUFM nonDetKeysUFMnonDetStrictFoldUFMnonDetStrictFoldUFM_DirectlynonDetUFMToList partitionUFM pluralUFMplusMaybeUFM_CplusUFM plusUFMList plusUFM_C plusUFM_CD plusUFM_CD2pprUFMpprUFMWithKeys pprUniqFM seqEltsUFMsizeUFM ufmToIntMapufmToSet_DirectlyunitDirectlyUFMunitUFMunsafeCastUFMKeyunsafeIntMapToUFMzipToUFM NonDetUniqFM getNonDetUniqFM $fDataUniqFM $fEqUniqFM$fFoldableNonDetUniqFM$fFunctorNonDetUniqFM$fFunctorUniqFM$fMonoidUniqFM$fSemigroupUniqFM$fOutputableUniqFM$fTraversableNonDetUniqFMaddListToUniqMapaddListToUniqMap_C addToUniqMapaddToUniqMap_AccaddToUniqMap_C adjustUniqMap allUniqMap alterUniqMap anyUniqMapdelFromUniqMapdelListFromUniqMapdisjointUniqMap elemUniqMap emptyUniqMap filterUniqMapintersectUniqMap isNullUniqMap listToUniqMaplistToUniqMap_C lookupUniqMaplookupWithDefaultUniqMap mapUniqMap minusUniqMappartitionUniqMapplusMaybeUniqMap_C plusUniqMapplusUniqMapList plusUniqMap_C sizeUniqMap unitUniqMapUniqMap $fDataUniqMap $fEqUniqMap$fFunctorUniqMap$fMonoidUniqMap$fSemigroupUniqMap$fOutputableUniqMap addListToUDFM addToUDFM addToUDFM_CaddToUDFM_C_DirectlyaddToUDFM_Directly adjustUDFMadjustUDFM_DirectlyallUDFM alterUDFMalwaysUnsafeUfmToUdfmanyUDFM delFromUDFMdelListFromUDFM disjointUDFMdisjointUdfmUfmelemUDFMeltsUDFM emptyUDFM equalKeysUDFM filterUDFMfilterUDFM_DirectlyfoldUDFM intersectUDFM isNullUDFM listToUDFMlistToUDFM_Directly lookupUDFMlookupUDFM_Directly mapMaybeUDFMmapUDFM minusUDFMnonDetStrictFoldUDFM partitionUDFMplusUDFM plusUDFM_CpprUDFM pprUniqDFMsizeUDFMudfmIntersectUFM udfmMinusUFM udfmToList udfmToUfm ufmMinusUDFMunitUDFMunsafeCastUDFMKeyUniqDFM$fDataTaggedVal $fDataUniqDFM $fEqTaggedVal$fFoldableTaggedVal$fFoldableUniqDFM$fFunctorTaggedVal$fFunctorUniqDFM$fMonoidUniqDFM$fSemigroupUniqDFM$fOutputableUniqDFM$fTraversableTaggedVal$fTraversableUniqDFMaddListToUniqSetaddOneToUniqSetdelListFromUniqSetdelListFromUniqSet_DirectlydelOneFromUniqSetdelOneFromUniqSet_DirectlydisjointUniqSetselemUniqSet_DirectlyelementOfUniqSet emptyUniqSet filterUniqSetfilterUniqSet_Directly getUniqSetintersectUniqSetsisEmptyUniqSet lookupUniqSetlookupUniqSet_Directly mapUniqSet minusUniqSet mkUniqSetnonDetEltsUniqSetnonDetKeysUniqSetnonDetStrictFoldUniqSetpartitionUniqSet pprUniqSetrestrictUniqSetToUFM sizeUniqSetunionManyUniqSets unionUniqSets uniqSetAll uniqSetAnyuniqSetMinusUDFMuniqSetMinusUFM unitUniqSetunsafeUFMToUniqSetUniqSet $fDataUniqSet $fEqUniqSet$fMonoidUniqSet$fSemigroupUniqSet$fOutputableUniqSetgraphMapModify initGraphnewNodegraphMap nodeClass nodeCoalesce nodeColor nodeConflictsnodeExclusionsnodeIdnodePreferenceTriv addToUSDFM emptyUSDFM equateUSDFM lookupUSDFM traverseUSDFMUniqSDFM$fOutputableShared$fOutputableUniqSDFMaddListToUniqDSetaddOneToUniqDSetdelListFromUniqDSetdelOneFromUniqDSetelementOfUniqDSet emptyUniqDSetfilterUniqDSet getUniqDSetintersectUniqDSetsisEmptyUniqDSetlookupUniqDSet mapUniqDSet minusUniqDSet mkUniqDSetnonDetStrictFoldUniqDSetpartitionUniqDSet pprUniqDSet sizeUniqDSetunionManyUniqDSetsunionUniqDSetsuniqDSetIntersectUniqSetuniqDSetMinusUniqSetuniqDSetToList unitUniqDSetUniqDSet$fDataUniqDSet $fEqUniqDSet$fMonoidUniqDSet$fSemigroupUniqDSet$fOutputableUniqDSet alterFsEnv dFsEnvElts delFromFsEnvdelListFromFsEnv elemFsEnv emptyDFsEnv emptyFsEnv extendFsEnvextendFsEnvListextendFsEnvList_CextendFsEnv_Acc extendFsEnv_C filterFsEnv lookupDFsEnv lookupFsEnvlookupFsEnv_NFmapFsEnvmkDFsEnvmkFsEnv plusFsEnv plusFsEnv_C unitFsEnvDFastStringEnv FastStringEnv emptyStackMapgetStackSlotFor getStackUseStackMapstackMapAssignmentstackMapNextFreeSlot StackSlotaddCLoc advanceBufPos advancePsLoc advanceSrcLoc cmpBufSpan cmpLocated combineLocscombineRealSrcSpanscombineSrcSpans containsSpan eqLocatedgeneratedSrcLocgeneratedSrcSpan getBufPos getBufSpangetLocgetRealSrcSpaninteractiveSrcLocinteractiveSrcSpanisGeneratedSrcSpan isGoodSrcSpan isOneLineSpanisRealSubspanOf isSubspanOfisZeroWidthSpanleftmostColumnleftmost_largestleftmost_smallestliftL lookupSrcLoc lookupSrcSpanmapLocmkGeneralLocatedmkGeneralSrcLocmkGeneralSrcSpanmkPsSpan mkRealSrcLoc mkRealSrcSpanmkSrcLoc mkSrcSpan mkSrcSpanPsnoLocnoSrcLoc noSrcSpan pprLocatedpprUnhelpfulSpanReasonpprUserRealSpan pprUserSpan psSpanEnd psSpanStartrealSrcLocSpanrealSrcSpanEndrealSrcSpanStartrightmost_smallest sortLocatedsortRealLocatedspans srcLocCol srcLocFile srcLocLine srcLocSpan srcSpanEnd srcSpanEndColsrcSpanEndLinesrcSpanFileName_maybesrcSpanFirstCharacter srcSpanStartsrcSpanStartColsrcSpanStartLinesrcSpanToRealSrcSpanunLoc unRealSrcSpanunhelpfulSpanFSwiredInSrcSpanBufPosbufPosBufSpan bufSpanEnd bufSpanStart GenLocatedL LayoutInfoExplicitBraces NoLayoutInfo VirtualBracesLocatedPsLocpsBufPos psRealLoc PsLocatedPsSpan psBufSpan psRealSpan RealLocated RealSrcLoc RealSrcSpan srcSpanFileSrcLoc UnhelpfulLocSrcSpan UnhelpfulSpanUnhelpfulSpanReasonUnhelpfulGeneratedUnhelpfulInteractiveUnhelpfulNoLocationInfoUnhelpfulOtherUnhelpfulWiredIn$fDataGenLocated$fDataLayoutInfo$fDataRealSrcSpan $fDataSrcSpan $fEqBufPos $fEqBufSpan$fEqGenLocated$fEqLayoutInfo $fEqPsLoc $fEqPsSpan$fEqRealSrcLoc$fEqRealSrcSpan $fEqSrcLoc $fEqSrcSpan$fEqUnhelpfulSpanReason$fFoldableGenLocated$fFunctorGenLocated$fNFDataSrcSpan $fOrdBufPos $fOrdBufSpan$fOrdGenLocated$fOrdLayoutInfo $fOrdPsLoc $fOrdPsSpan$fOrdRealSrcLoc$fOrdRealSrcSpan$fOutputableGenLocated$fOutputableGenLocated0$fOutputableRealSrcLoc$fOutputableRealSrcSpan$fOutputableSrcLoc$fOutputableSrcSpan$fOutputableUnhelpfulSpanReason$fSemigroupBufSpan $fShowBufPos $fShowBufSpan$fShowLayoutInfo $fShowPsLoc $fShowPsSpan$fShowRealSrcLoc$fShowRealSrcSpan $fShowSrcLoc $fShowSrcSpan$fShowUnhelpfulSpanReason$fToJsonRealSrcSpan$fToJsonSrcSpan$fTraversableGenLocated nameOccName nameUnique setNameUnique tidyNameOccName NamedThinggetName getOccNamecastBin dataHandlegetAtgetByte getDictionary getSLEB128 getULEB128 getUserData handleDatalazyGetlazyPut newReadState newWriteState openBinMemputAtputByte putDictionaryputFS putSLEB128 putULEB128 readBinMemseekBin setUserDatatellBin withBinBuffer writeBinMemBinBinData BinHandleBinaryput_ DictionaryFixedLengthEncoding unFixedLength SymbolTableUserData ud_get_fs ud_get_nameud_put_binding_name ud_put_fsud_put_nonbinding_name $fBinary() $fBinary(,) $fBinary(,,) $fBinary(,,,)$fBinary(,,,,)$fBinary(,,,,,)$fBinary(,,,,,,) $fBinaryArray $fBinaryBin$fBinaryBinData $fBinaryBool$fBinaryBufPos$fBinaryBufSpan$fBinaryByteString $fBinaryChar $fBinaryDay$fBinaryDiffTime$fBinaryEither$fBinaryFastString$fBinaryFingerprint$fBinaryFixedLengthEncoding$fBinaryFixedLengthEncoding0$fBinaryFixedLengthEncoding1$fBinaryFixedLengthEncoding2$fBinaryGenLocated $fBinaryInt $fBinaryInt16 $fBinaryInt32 $fBinaryInt64 $fBinaryInt8$fBinaryInteger$fBinaryLexicalFastString $fBinaryMaybe$fBinaryNonDetFastString $fBinaryRatio$fBinaryRealSrcSpan$fBinarySrcSpan$fBinaryUTCTime$fBinaryUnhelpfulSpanReason$fBinaryWord16$fBinaryWord32$fBinaryWord64 $fBinaryWord8 $fBinary[] $fBoundedBin$fEqBin$fNFDataBinData$fOrdBin $fShowBingetSomeTypeRep$fBinaryKindRep$fBinaryRuntimeRep$fBinarySerialized$fBinarySomeTypeRep $fBinaryTyCon$fBinaryTypeLitSort$fBinaryTypeRep$fBinaryVecCount$fBinaryVecElem mkModuleNamemkModuleNameFSmoduleNameColons moduleNameFSmoduleNameSlashesmoduleNameStringparseModuleName pprModuleNamestableModuleNameCmp$fBinaryModuleName$fDataModuleName$fEqModuleName$fNFDataModuleName$fOrdModuleName$fOutputableModuleName$fShowModuleName$fUniquableModuleNamebaseUnit baseUnitId bignumUnit bignumUnitIdfsToUnitinteractiveUnitinteractiveUnitId isHoleUnitisInteractiveModulemainUnit mainUnitId mapGenUnitmapInstantiationsmkInstantiatedUnitmkInstantiatedUnitHashmkModule mkVirtUnitmoduleFreeHolespprInstantiatedModuleprimUnit primUnitIdrtsUnit rtsUnitId stableUnitCmp stringToUnitstringToUnitIdthUnitthUnitId thisGhcUnit thisGhcUnitIdtoUnitIdunitFreeModuleHoles unitIdStringunitIsDefinite unitString virtualUnitIdwiredInUnitIds DefUnitIdDefinite unDefiniteGenInstantiatedUnitInstantiatedUnit instUnitFS instUnitHolesinstUnitInstanceOf instUnitInsts instUnitKeyGenInstantiationsHoleUnitRealUnitVirtUnit GenWithIsBootGWIB gwib_isBootgwib_mod indefUnitInstalledModuleInstantiatedModuleInstantiationsIsBootInterfaceIsBootNotBootIsUnitIdunitFSModuleNameWithIsBootModuleWithIsBootunitIdFSUnitKey$fBinaryDefinite$fBinaryGenInstantiatedUnit$fBinaryGenModule$fBinaryGenUnit$fBinaryGenWithIsBoot$fBinaryIndefinite$fBinaryIsBootInterface$fBinaryUnitId$fDataGenModule $fDataGenUnit$fDataIsBootInterface $fEqDefinite$fEqGenInstantiatedUnit $fEqGenModule $fEqGenUnit$fEqGenWithIsBoot$fEqIndefinite$fEqIsBootInterface $fEqUnitId$fFoldableGenWithIsBoot$fFunctorDefinite$fFunctorGenModule$fFunctorGenWithIsBoot$fFunctorIndefinite$fIsUnitIdDefinite$fIsUnitIdGenUnit$fIsUnitIdIndefinite$fIsUnitIdUnitId$fIsUnitIdUnitKey$fNFDataGenModule$fNFDataGenUnit $fOrdDefinite$fOrdGenInstantiatedUnit$fOrdGenModule $fOrdGenUnit$fOrdGenWithIsBoot$fOrdIndefinite$fOrdIsBootInterface $fOrdUnitId$fOutputableDefinite$fOutputableGenInstantiatedUnit$fOutputableGenModule$fOutputableGenModule0$fOutputableGenModule1$fOutputableGenUnit$fOutputableGenWithIsBoot$fOutputableIndefinite$fOutputableUnitId $fShowGenUnit$fShowGenWithIsBoot$fShowIsBootInterface$fTraversableGenWithIsBoot$fUniquableDefinite$fUniquableGenModule$fUniquableGenUnit$fUniquableIndefinite$fUniquableUnitId addBootSuffixaddBootSuffixLocnaddBootSuffixLocnOutaddBootSuffix_mayberemoveBootSuffix ModLocation ml_hi_file ml_hie_file ml_hs_file ml_obj_file$fOutputableModLocation$fShowModLocationparseHoleyModuleparseIndefUnitId parseModSubst parseUnitdelInstalledModuleEnv delModuleEnvdelModuleEnvList delModuleSet elemModuleEnv elemModuleSetemptyInstalledModuleEnvemptyModuleEnvemptyModuleSetextendInstalledModuleEnvextendModuleEnvextendModuleEnvListextendModuleEnvList_CextendModuleEnvWithextendModuleSetextendModuleSetListfilterInstalledModuleEnvfilterModuleEnvintersectModuleSetisEmptyModuleEnvlookupInstalledModuleEnvlookupModuleEnvlookupWithDefaultModuleEnv mapModuleEnvminusModuleSet mkModuleEnv mkModuleSet moduleEnvElts moduleEnvKeysmoduleEnvToList moduleSetElts plusModuleEnvplusModuleEnv_CunionModuleSet unitModuleEnv unitModuleSetDModuleNameEnvInstalledModuleEnv ModuleEnv ModuleNameEnv ModuleSet $fEqNDModule $fOrdNDModulegetModuleInstantiationgetUnitInstantiationsinstalledModuleEq isHoleModule mkHoleModulemoduleIsDefinitemoduleStableStringstableModuleCmpuninstantiateInstantiatedModuleuninstantiateInstantiatedUnitContainsModule extractModule HasModule getModulehomeModuleInstantiationhomeModuleNameInstantiationhomeUnitAsUnit homeUnitIdhomeUnitInstanceOfhomeUnitInstanceOfMaybehomeUnitInstantiations homeUnitMapisHomeInstalledModule isHomeModule isHomeUnitisHomeUnitDefinite isHomeUnitIdisHomeUnitIndefiniteisHomeUnitInstanceOfisHomeUnitInstantiatingmkHomeInstalledModule mkHomeModulenotHomeInstalledModulenotHomeInstalledModuleMaybe notHomeModulenotHomeModuleMaybe GenHomeUnitDefiniteHomeUnitIndefiniteHomeUnitHomeUnitfractionalLitFromRationalintegralFractionalLitmkFractionalLit mkIntegralLitmkSourceFractionalLitmkTHFractionalLitnegateFractionalLitnegateIntegralLitpprWithSourceTextrationalFromFractionalLitFractionalExponentBaseBase10Base2 FractionalLitFLfl_exp fl_exp_basefl_negfl_signifl_text IntegralLitILil_negil_textil_value SourceText NoSourceText StringLiteralsl_fssl_stsl_tc$fBinarySourceText$fBinaryStringLiteral$fDataFractionalExponentBase$fDataFractionalLit$fDataSourceText$fDataIntegralLit$fDataStringLiteral$fEqFractionalExponentBase$fEqFractionalLit$fEqIntegralLit$fEqSourceText$fEqStringLiteral$fOrdFractionalExponentBase$fOrdFractionalLit$fOrdIntegralLit$fOutputableFractionalLit$fOutputableIntegralLit$fOutputableSourceText$fOutputableStringLiteral$fShowFractionalExponentBase$fShowFractionalLit$fShowIntegralLit$fShowSourceTexthscSourceString isHsBootOrSig isHsigFile HscSource HsBootFile HsSrcFileHsigFileSourceModifiedSourceUnmodifiedSourceUnmodifiedAndStable$fBinaryHscSource $fEqHscSource$fOrdHscSource$fShowHscSource getSafeModenoIfaceTrustInfo setSafeModeIfaceTrustInfo IsSafeImportSafeHaskellMode Sf_IgnoreSf_NoneSf_SafeSf_SafeInferredSf_Trustworthy Sf_Unsafe$fBinaryIfaceTrustInfo$fEqSafeHaskellMode$fOutputableIfaceTrustInfo$fOutputableSafeHaskellMode$fShowSafeHaskellMode getCCIndexnewCostCentreStateCostCentreIndexunCostCentreIndexCostCentreState$fBinaryCostCentreIndex$fDataCostCentreIndex$fEqCostCentreIndex$fOrdCostCentreIndex deleteFieldemptyExtensibleFields readField readFieldWith writeFieldwriteFieldWithExtensibleFieldsgetExtensibleFields FieldName$fBinaryExtensibleFields$fNFDataExtensibleFields AnonArgFlagArgFlag InvisTVBinder SpecificityTcTyVarTyCoVarTyVarVarVarBndridName coVarDetailsisCoVarDetails pprIdDetails vanillaIdInfo IdDetailsIdInfo appendStubCCHeader getCHeaderCStubgetCStub ForeignStubsNoStubs$fMonoidCHeader$fSemigroupCHeader $fMonoidCStub$fSemigroupCStubccallConvAttributeccallConvToIntdefaultCCallConvisCLabelStringisDynamicTargetisSafeForeignCallplayInterruptibleplaySafepprCLabelString CCallConvCApiConvJavaScriptCallConv PrimCallConv StdCallConv CCallSpec CCallTarget DynamicTarget StaticTarget CExportSpec CExportStatic CLabelStringCType ForeignCallCCallHeaderSafetyPlayInterruptible PlayRiskyPlaySafe$fBinaryCCallConv$fBinaryCCallSpec$fBinaryCCallTarget$fBinaryCExportSpec $fBinaryCType$fBinaryForeignCall$fBinaryHeader$fBinarySafety$fDataCCallConv$fDataCCallTarget$fDataCExportSpec $fDataCType $fDataHeader $fDataSafety $fEqCCallConv $fEqCCallSpec$fEqCCallTarget $fEqCType$fEqForeignCall $fEqHeader $fEqSafety$fOutputableCCallConv$fOutputableCCallSpec$fOutputableCExportSpec$fOutputableCType$fOutputableForeignCall$fOutputableHeader$fOutputableSafety $fShowSafety compareFixity defaultFixity funTyFixity maxPrecedence minPrecedence negateFixityFixityFixityDirectionInfixLInfixNInfixR LexicalFixityInfixPrefix$fBinaryFixity$fBinaryFixityDirection $fDataFixity$fDataFixityDirection$fDataLexicalFixity $fEqFixity$fEqFixityDirection$fEqLexicalFixity$fOutputableFixity$fOutputableFixityDirection$fOutputableLexicalFixityfieldLabelPrintableNamefieldSelectorOccNameflIsOverloadedDuplicateRecordFieldsNoDuplicateRecordFields FieldLabelflHasDuplicateRecordFieldsflHasFieldSelectorflLabel flSelector FieldLabelEnvFieldLabelStringFieldSelectorsNoFieldSelectors$fBinaryDuplicateRecordFields$fBinaryFieldLabel$fBinaryFieldSelectors$fDataDuplicateRecordFields$fDataFieldLabel$fDataFieldSelectors$fEqDuplicateRecordFields$fEqFieldLabel$fEqFieldSelectors$fHasOccNameFieldLabel!$fOutputableDuplicateRecordFields$fOutputableFieldLabel$fOutputableFieldSelectors$fShowDuplicateRecordFields$fShowFieldSelectorsactivateAfterInitialactivateDuringFinalactiveInFinalPhase alignmentOfalwaysInlinePragmaappPrec bestOneShot boolToRecFlagboxityTupleSort competesWithdefaultInlinePragmadfunInlinePragma fIRST_TAGfailedflipSwapfunPrechasIncoherentFlaghasNoOneShotInfohasOverlappableFlaghasOverlappingFlaginfinityinlinePragmaActivationinlinePragmaRuleMatchInfoinlinePragmaSatinlinePragmaSpec intGtLimitisActiveisAlwaysActiveisAlwaysTailCalledisAnyInlinePragmaisBoxed isConLike isDeadOccisDefaultInlinePragma isFunLike isGeneratedisInlinablePragmaisInlinePragma isKindLevel isManyOccs isNeverActive isNoOccInfoisNonRec isNotTopLevelisOneOcc isOneShotInfo isPromotedisRecisStrongLoopBreaker isSwapped isTopLevel isTypeLevelisWeakLoopBreaker maybeParen mkAlignment mkIntWithInfneverInlinePragma noOccInfo noOneShotInfonoUserInlineSpec oneBranchopPrecpickLRpprAlternative pprInlinepprInlineDebug pprRuleName seqOccInfosetInlinePragmaActivationsetInlinePragmaRuleMatchInfosetOverlapModeMaybesigPrecstarPrecstrongLoopBreaker succeeded successIf sumParens tailCallInfotopPrectreatZeroAsInf tupleParenstupleSortBoxityunSwapweakLoopBreaker worstOneShot zapFragileOcczapOccTailCallInfo Activation ActiveAfter ActiveBefore AlwaysActive FinalActive NeverActive AlignmentalignmentBytesArityBoxityBoxedUnboxed BranchCount CompilerPhase FinalPhase InitialPhasePhaseConTagConTagZ DefMethSpec GenericDM VanillaDMEPfromEPtoEP FullArgCountFunctionOrDataIsData IsFunction InlinePragmainl_act inl_inlineinl_ruleinl_satinl_src InlineSpec InlinableInlineNoInlineNoUserInlinePrag InsideLam IsInsideLam NotInsideLam IntWithInfInterestingCxt IsInterestingNotInteresting JoinArity LeftOrRightCLeftCRightOccInfoIAmALoopBreakerIAmDeadManyOccsOneOcc occ_in_lam occ_int_cxtocc_n_brocc_rules_onlyocc_tail OneShotInfo NoOneShotInfo OneShotLamOrigin FromSource Generated OverlapFlag isSafeOverlap overlapMode OverlapMode Incoherent NoOverlap Overlappable OverlappingOverlapsPhaseNumPprPrec PromotionFlag IsPromoted NotPromotedRecFlag NonRecursive RecursiveRepArity RuleMatchInfoConLikeFunLikeRuleNameSpliceExplicitFlagExplicitSpliceImplicitSplice SuccessFlagSwapFlag IsSwapped NotSwapped TailCallInfoAlwaysTailCalledNoTailCallInfo TopLevelFlag NotTopLevelTopLevel TupleSort BoxedTupleConstraintTuple UnboxedTuple TypeOrKind KindLevel TypeLevel$fBinaryActivation$fBinaryFunctionOrData$fBinaryInlinePragma$fBinaryInlineSpec$fBinaryLeftOrRight$fBinaryOverlapFlag$fBinaryOverlapMode$fBinaryPromotionFlag$fBinaryRecFlag$fBinaryRuleMatchInfo$fBinaryTupleSort$fDataActivation $fDataBoxity$fDataFunctionOrData$fDataInlinePragma$fDataInlineSpec$fDataRuleMatchInfo$fDataLeftOrRight $fDataOrigin$fDataOverlapFlag$fDataOverlapMode$fDataPromotionFlag $fDataRecFlag$fDataSpliceExplicitFlag$fDataTopLevelFlag$fDataTupleSort$fEqActivation $fEqAlignment $fEqBoxity$fEqCompilerPhase$fEqFunctionOrData$fEqInlinePragma$fEqInlineSpec $fEqInsideLam$fEqIntWithInf$fEqInterestingCxt$fEqLeftOrRight $fEqOccInfo$fEqOneShotInfo $fEqOrigin$fEqOverlapFlag$fEqOverlapMode $fEqPprPrec$fEqPromotionFlag $fEqRecFlag$fEqRuleMatchInfo$fEqTailCallInfo $fEqTupleSort$fEqTypeOrKind$fMonoidInsideLam$fSemigroupInsideLam$fMonoidInterestingCxt$fSemigroupInterestingCxt$fNumIntWithInf$fOrdAlignment$fOrdFunctionOrData$fOrdIntWithInf $fOrdPprPrec$fOutputableActivation$fOutputableAlignment$fOutputableBoxity$fOutputableCompilerPhase$fOutputableDefMethSpec$fOutputableFunctionOrData$fOutputableInlinePragma$fOutputableInlineSpec$fOutputableIntWithInf$fOutputableLeftOrRight$fOutputableOccInfo$fOutputableOneShotInfo$fOutputableOrigin$fOutputableOverlapFlag$fOutputableOverlapMode$fOutputablePenvAlignment$fOutputablePromotionFlag$fOutputableRecFlag$fOutputableRuleMatchInfo$fOutputableSuccessFlag$fOutputableSwapFlag$fOutputableTailCallInfo$fOutputableTopLevelFlag$fOutputableTupleSort$fOutputableTypeOrKind$fShowInlineSpec $fShowPprPrec$fShowRuleMatchInfo isMetaTyVarisTyConableTyVarpprTcTyVarDetailsvanillaSkolemTv MetaDetailsTcTyVarDetailspprDebugAndThen pprSTracepprTrace pprTraceDebugpprTraceException pprTraceIt pprTraceMpprTraceWithFlags printForC printForUsershowPprshowSDoc showSDocDebug showSDocDumpshowSDocForUser warnPprTraceanyHsceqPhase happensBeforeisBackpackishSuffixisCishFilename isCishSuffixisDynLibFilenameisDynLibSuffixisHaskellSigFilenameisHaskellSigSuffixisHaskellSrcFilenameisHaskellSrcSuffixisHaskellUserSrcFilenameisHaskellUserSrcSuffixisHaskellishFilenameisHaskellishSuffixisHaskellishTargetisObjectFilenameisObjectSuffixisSourceFilenameisSourceSuffixisStopLnphaseForeignLanguage phaseInputExt startPhaseAsCcCcxxCmmCmmCppCobjcCobjcxxCppHCcHsPpHscLlvmLlc LlvmMangleLlvmOpt MergeForeignStopLnUnlit $fEqPhase$fOutputablePhase $fShowPhaseoptimisationFlagsDumpFlagOpt_D_dump_BCOsOpt_D_dump_asmOpt_D_dump_asm_conflictsOpt_D_dump_asm_expandedOpt_D_dump_asm_livenessOpt_D_dump_asm_nativeOpt_D_dump_asm_regallocOpt_D_dump_asm_regalloc_stagesOpt_D_dump_asm_statsOpt_D_dump_c_backendOpt_D_dump_call_arityOpt_D_dump_cfg_weightsOpt_D_dump_cmmOpt_D_dump_cmm_cafOpt_D_dump_cmm_cbeOpt_D_dump_cmm_cfgOpt_D_dump_cmm_cpsOpt_D_dump_cmm_from_stgOpt_D_dump_cmm_infoOpt_D_dump_cmm_procOpt_D_dump_cmm_procmapOpt_D_dump_cmm_rawOpt_D_dump_cmm_sinkOpt_D_dump_cmm_spOpt_D_dump_cmm_splitOpt_D_dump_cmm_switchOpt_D_dump_cmm_verboseOpt_D_dump_cmm_verbose_by_procOpt_D_dump_core_statsOpt_D_dump_cpr_signaturesOpt_D_dump_cpranalOpt_D_dump_cs_traceOpt_D_dump_cseOpt_D_dump_debugOpt_D_dump_deriv Opt_D_dump_dsOpt_D_dump_ds_preoptOpt_D_dump_ec_traceOpt_D_dump_exitifyOpt_D_dump_faststringsOpt_D_dump_foreign Opt_D_dump_hiOpt_D_dump_hi_diffsOpt_D_dump_hieOpt_D_dump_if_traceOpt_D_dump_inliningsOpt_D_dump_jsonOpt_D_dump_llvmOpt_D_dump_mod_cyclesOpt_D_dump_mod_mapOpt_D_dump_occur_analOpt_D_dump_opt_cmmOpt_D_dump_parsedOpt_D_dump_parsed_astOpt_D_dump_prep Opt_D_dump_rnOpt_D_dump_rn_astOpt_D_dump_rn_statsOpt_D_dump_rn_traceOpt_D_dump_rttiOpt_D_dump_rule_firingsOpt_D_dump_rule_rewritesOpt_D_dump_rulesOpt_D_dump_simplOpt_D_dump_simpl_iterationsOpt_D_dump_simpl_statsOpt_D_dump_simpl_traceOpt_D_dump_specOpt_D_dump_splicesOpt_D_dump_stg_finalOpt_D_dump_stg_from_coreOpt_D_dump_stg_unarisedOpt_D_dump_str_signaturesOpt_D_dump_stranal Opt_D_dump_tcOpt_D_dump_tc_astOpt_D_dump_tc_traceOpt_D_dump_tickedOpt_D_dump_timingsOpt_D_dump_types!Opt_D_dump_view_pattern_commoningOpt_D_dump_vt_traceOpt_D_dump_worker_wrapperOpt_D_no_debug_outputOpt_D_ppr_debugOpt_D_source_statsOpt_D_th_dec_fileOpt_D_verbose_core2coreOpt_D_verbose_stg2stg GeneralFlagOpt_AbstractRefHoleFitsOpt_AlignmentSanitisationOpt_AsmShortcuttingOpt_AutoLinkPackagesOpt_AutoSccsOnIndividualCafsOpt_BreakOnErrorOpt_BreakOnExceptionOpt_BuildDynamicTooOpt_BuildingCabalPackage Opt_ByteCodeOpt_CSE Opt_CallArityOpt_CaseFolding Opt_CaseMergeOpt_CatchBottomsOpt_CfgBlocklayoutOpt_CmmElimCommonBlocks Opt_CmmSinkOpt_CmmStaticPredOpt_CompactUnwind Opt_CprAnalOpt_CrossModuleSpecialiseOpt_D_dump_minimal_importsOpt_D_faststring_statsOpt_DeferDiagnosticsOpt_DeferOutOfScopeVariablesOpt_DeferTypeErrorsOpt_DeferTypedHolesOpt_DiagnosticsShowCaretOpt_DictsCheapOpt_DictsStrictOpt_DistinctConstructorTablesOpt_DistrustAllPackagesOpt_DmdTxDictSelOpt_DoAnnotationLintingOpt_DoAsmLintingOpt_DoBoundsCheckingOpt_DoCmmLintingOpt_DoCoreLintingOpt_DoEtaReductionOpt_DoLambdaEtaExpansionOpt_DoLinearCoreLintingOpt_DoStgLintingOpt_DumpToFileOpt_EagerBlackHolingOpt_EmbedManifestOpt_EnableRewriteRulesOpt_EnableThSpliceWarningsOpt_ErrorSpansOpt_ExcessPrecisionOpt_ExitificationOpt_ExposeAllUnfoldingsOpt_ExposeInternalSymbolsOpt_ExternalDynamicRefsOpt_ExternalInterpreterOpt_FamAppCache Opt_FastLlvm Opt_FloatInOpt_ForceRecompOpt_FullLazinessOpt_FunToThunkOpt_G_NoOptCoercionOpt_G_NoStateHackOpt_GenManifestOpt_GhciHistoryOpt_GhciLeakCheckOpt_GhciSandbox Opt_HaddockOpt_HaddockOptionsOpt_HelpfulErrorsOpt_HexWordLiteralsOpt_HideAllPackagesOpt_HideAllPluginPackagesOpt_HideSourcePathsOpt_HpcOpt_IgnoreAssertsOpt_IgnoreDotGhciOpt_IgnoreHpcChangesOpt_IgnoreInterfacePragmasOpt_IgnoreOptimChangesOpt_ImplicitImportQualifiedOpt_InfoTableMapOpt_InlineGenericsOpt_InlineGenericsAggressivelyOpt_IrrefutableTuples Opt_KeepCAFs Opt_KeepGoingOpt_KeepHcFilesOpt_KeepHiDiffsOpt_KeepHiFilesOpt_KeepHscppFilesOpt_KeepLlvmFilesOpt_KeepOFilesOpt_KeepRawTokenStreamOpt_KeepSFilesOpt_KeepTmpFilesOpt_KillAbsenceOpt_KillOneShotOpt_LateDmdAnalOpt_LateSpecialiseOpt_LiberateCase Opt_LinkRtsOpt_LlvmFillUndefWithGarbage Opt_LlvmTBAAOpt_LocalGhciHistoryOpt_Loopification Opt_NoHsMainOpt_NoItOpt_NoLlvmManglerOpt_NoTypeableBindsOpt_NumConstantFoldingOpt_OmitInterfacePragmasOpt_OmitYieldsOpt_OptimalApplicativeDoOpt_PICOpt_PICExecutableOpt_PIEOpt_PackageTrustOpt_PedanticBottomsOpt_PluginTrustworthyOpt_PpOpt_PprCaseAsLetOpt_PprShowTicksOpt_PrintAxiomIncompsOpt_PrintBindContentsOpt_PrintBindResultOpt_PrintEqualityRelationsOpt_PrintEvldWithShowOpt_PrintExpandedSynonymsOpt_PrintExplicitCoercionsOpt_PrintExplicitForallsOpt_PrintExplicitKindsOpt_PrintExplicitRuntimeRepsOpt_PrintPotentialInstancesOpt_PrintTypecheckerElaborationOpt_PrintUnicodeSyntaxOpt_ProfCountEntries Opt_RPath Opt_RegsGraphOpt_RegsIterativeOpt_RelativeDynlibPathsOpt_SharedImplibOpt_ShowDocsOfHoleFitsOpt_ShowHoleConstraintsOpt_ShowLoadedModulesOpt_ShowMatchesOfHoleFitsOpt_ShowProvOfHoleFitsOpt_ShowTypeAppOfHoleFitsOpt_ShowTypeAppVarsOfHoleFitsOpt_ShowTypeOfHoleFitsOpt_ShowValidHoleFitsOpt_ShowWarnGroupsOpt_SimplPreInliningOpt_SingleLibFolderOpt_SolveConstantDictsOpt_SortBySizeHoleFitsOpt_SortBySubsumHoleFitsOpt_SortValidHoleFitsOpt_SpecConstrOpt_SpecConstrKeenOpt_SpecialiseOpt_SpecialiseAggressivelyOpt_SplitSections Opt_StaticArgumentTransformation Opt_StgCSEOpt_StgLiftLams Opt_StgStatsOpt_StrictnessOpt_SuppressCoercionsOpt_SuppressIdInfoOpt_SuppressModulePrefixesOpt_SuppressStgExtsOpt_SuppressTicksOpt_SuppressTimestampsOpt_SuppressTypeApplicationsOpt_SuppressTypeSignaturesOpt_SuppressUnfoldingsOpt_SuppressUniquesOpt_SuppressVarKinds Opt_TickyOpt_Ticky_AllocdOpt_Ticky_Dyn_Thunk Opt_Ticky_LNEOpt_UnboxSmallStrictFieldsOpt_UnboxStrictFieldsOpt_UnclutterValidHoleFitsOpt_ValidateHieOpt_VersionMacrosOpt_WarnIsErrorOpt_WeightlessBlocklayoutOpt_WholeArchiveHsLibsOpt_WorkerWrapper Opt_WriteHieOpt_WriteInterfaceLanguageGHC2021 Haskell2010 Haskell98 WarnReason ErrReasonNoReasonReason WarningFlagOpt_WarnAllMissedSpecs)Opt_WarnAlternativeLayoutRuleTransitionalOpt_WarnAmbiguousFieldsOpt_WarnAutoOrphansOpt_WarnCPPUndef Opt_WarnCompatUnqualifiedImports#Opt_WarnDeferredOutOfScopeVariablesOpt_WarnDeferredTypeErrorsOpt_WarnDeprecatedFlagsOpt_WarnDerivingDefaultsOpt_WarnDerivingTypeableOpt_WarnDodgyExportsOpt_WarnDodgyForeignImportsOpt_WarnDodgyImportsOpt_WarnDuplicateConstraintsOpt_WarnDuplicateExportsOpt_WarnEmptyEnumerationsOpt_WarnHiShadowsOpt_WarnIdentitiesOpt_WarnImplicitKindVarsOpt_WarnImplicitLiftOpt_WarnImplicitPreludeOpt_WarnInaccessibleCodeOpt_WarnIncompletePatterns Opt_WarnIncompletePatternsRecUpdOpt_WarnIncompleteUniPatternsOpt_WarnInferredSafeImportsOpt_WarnInlineRuleShadowingOpt_WarnInvalidHaddockOpt_WarnMissedExtraSharedLibOpt_WarnMissedSpecs!Opt_WarnMissingDerivingStrategiesOpt_WarnMissingExportList!Opt_WarnMissingExportedSignaturesOpt_WarnMissingFieldsOpt_WarnMissingHomeModulesOpt_WarnMissingImportListOpt_WarnMissingKindSignaturesOpt_WarnMissingLocalSignaturesOpt_WarnMissingMethods!Opt_WarnMissingMonadFailInstances'Opt_WarnMissingPatternSynonymSignaturesOpt_WarnMissingSafeHaskellModeOpt_WarnMissingSignaturesOpt_WarnMonomorphismOpt_WarnNameShadowing&Opt_WarnNonCanonicalMonadFailInstances"Opt_WarnNonCanonicalMonadInstances#Opt_WarnNonCanonicalMonoidInstancesOpt_WarnOperatorWhitespace%Opt_WarnOperatorWhitespaceExtConflictOpt_WarnOrphansOpt_WarnOverflowedLiteralsOpt_WarnOverlappingPatternsOpt_WarnPartialFieldsOpt_WarnPartialTypeSignatures"Opt_WarnPrepositiveQualifiedModuleOpt_WarnRedundantBangPatternsOpt_WarnRedundantConstraints Opt_WarnRedundantRecordWildcards Opt_WarnSafeOpt_WarnSemigroup$Opt_WarnSimplifiableClassConstraintsOpt_WarnSpaceAfterBangOpt_WarnStarBinderOpt_WarnStarIsType Opt_WarnTabsOpt_WarnTrustworthySafeOpt_WarnTypeDefaultsOpt_WarnTypedHolesOpt_WarnUnbangedStrictPatterns,Opt_WarnUnicodeBidirectionalFormatCharactersOpt_WarnUnrecognisedPragmas Opt_WarnUnrecognisedWarningFlagsOpt_WarnUnsafe%Opt_WarnUnsupportedCallingConventionsOpt_WarnUnsupportedLlvmVersion$Opt_WarnUntickedPromotedConstructorsOpt_WarnUnusedDoBindOpt_WarnUnusedForallsOpt_WarnUnusedImportsOpt_WarnUnusedLocalBindsOpt_WarnUnusedMatchesOpt_WarnUnusedPackagesOpt_WarnUnusedPatternBindsOpt_WarnUnusedRecordWildcardsOpt_WarnUnusedTopBindsOpt_WarnUnusedTypePatternsOpt_WarnWarningsDeprecationsOpt_WarnWrongDoBind$fBoundedLanguage$fEnumDumpFlag$fEnumGeneralFlag$fEnumLanguage$fEnumWarningFlag $fEqDumpFlag$fEqGeneralFlag $fEqLanguage$fEqWarningFlag$fOrdWarningFlag$fOutputableLanguage$fOutputableWarnReason$fShowDumpFlag$fShowGeneralFlag$fShowLanguage$fShowWarnReason$fShowWarningFlag$fToJsonWarnReasonaddWayallowed_combinationfullWayshasWay hostFullWayshostIsDebugged hostIsDynamichostIsProfiledhostIsThreaded hostIsTracinghostWaysrtsWayswayDescwayGeneralFlagswayOptPwayOptcwayOptl wayRTSOnlywayTagwayUnsetGeneralFlags waysBuildTagwaysTagWay WayCustomWayDebugWayDynWayProf WayThreaded WayTracingWays$fEqWay$fOrdWay $fShowWaycollectExtraCcOptscollectFrameworkscollectFrameworksDirscollectIncludeDirscollectLibraryDirs mapUnitInfomkUnit mkUnitKeyInfo mkUnitPprInfo pprUnitInfo unitHsLibsunitPackageIdStringunitPackageNameString GenUnitInfo PackageId PackageName unPackageNameUnitInfo UnitKeyInfo $fEqPackageId$fEqPackageName$fOutputablePackageId$fOutputablePackageName$fUniquablePackageId$fUniquablePackageName pprTarget pprTargetIdInputFileBufferTargettargetAllowObjCodetargetContentstargetIdTargetId TargetFile TargetModule $fEqTargetId$fOutputableTarget$fOutputableTargetIdprofileBuildTagprofileConstantsprofileIsProfilingprofileWordSizeInBytesProfileprofilePlatform profileWayspLiftFstpLiftSndswaptoPairunPairPairpFstpSnd$fApplicativePair $fFunctorPair$fFoldablePair $fMonoidPair$fSemigroupPair$fOutputablePair$fTraversablePairConsOLNilOLSnocOLappOLconcatOLconsOLfoldlOLfoldrOLfromOL fromOLReverseheadOLisNilOLlastOLmapOLmapOL'nilOL reverseOLsnocOL strictlyEqOL strictlyOrdOLtoOLunitOLOrdList$fFoldableOrdList$fFunctorOrdList$fMonoidOrdList$fSemigroupOrdList$fOutputableOrdList$fTraversableOrdListassoc assocDefaultassocDefaultUsing assocMaybe assocUsing equivClasses findDupsEqgetNth hasNoDups minusList removeDups unionListsAssocdotGraph dumpGraph addCoalesce addConflict addConflicts addExclusion addExclusionsaddNode addPreference coalesceGraph coalesceNodes delCoalesce delConflictdelNodefreezeAllInGraph freezeNodefreezeOneInGraphgetNode lookupNodemodNode scanGraphsetColorsizeslurpNodeConflictCount validateGraph classifyEdgesedgesGemptyG findCyclegraphFromEdgedVerticesOrdgraphFromEdgedVerticesUniq hasVertexG reachableG reachablesG$stronglyConnCompFromEdgedVerticesOrd%stronglyConnCompFromEdgedVerticesOrdR%stronglyConnCompFromEdgedVerticesUniq&stronglyConnCompFromEdgedVerticesUniqRstronglyConnCompGtopologicalSortG transposeG verticesGEdgeTypeBackwardCrossForwardSelfLoop DigraphNodenode_dependenciesnode_key node_payload $fEqEdgeType$fEqTime $fNumTime $fOrdEdgeType $fOrdTime$fOutputableEdge$fOutputableEdgeType$fOutputableGraph$fOutputableNode$fOutputableTime colorGraphallBaganyBaganyBagM bagToList catBagMaybes concatBag concatMapBagconcatMapBagPairconsBagelemBagemptyBag filterBag filterBagM flatMapBagMflatMapBagPairMfoldBag isEmptyBagisSingletonBag lengthBag listToBag mapAccumBagL mapAccumBagLMmapAndUnzipBagMmapBagmapBagMmapBagM_ mapMaybeBag nonEmptyToBag partitionBagpartitionBagWithsnocBag unionBags unionManyBagsunitBagBag $fDataBag $fFoldableBag $fFunctorBag $fIsListBag$fOutputableBag$fTraversableBagaddErr addFlagWarnaddWarndefFlag defGhcFlag defGhciFlag defHiddenFlag deprecateerrorsToGhcExceptiongetArggetCmdLineState getCurLocliftEwM processArgsputCmdLineStaterunEwMCmdLineP runCmdLineErrerrMsgEwMFlag flagGhcModeflagName flagOptKind GhcFlagModeAllModes HiddenFlagOnlyGhcOnlyGhciOptKind AnySuffix FloatSuffixHasArg IntSuffixNoArg OptIntSuffix OptPrefixPassFlagSepArg WordSuffixWarnwarnMsg warnReasonReasonDeprecatedFlagReasonUnrecognisedFlag$fApplicativeCmdLineP$fFunctorCmdLineP$fApplicativeEwM $fFunctorEwM$fEqWarnReason$fMonadCmdLineP $fMonadEwM isFunTyCon isTupleTyConisUnboxedTupleTyConmkPrelTyConRepName tyConNametyConRepName_maybe TyConRepNamemkATyConmkAnIdTyThing mkForAllTy mkFunTyMany mkTyConTy_Coercion CoercionNKind MCoercion MCoercionNMultPredTypeScaled ThetaType TyCoBinderTyLitUnivCoProvenancecoreView isCoercionTyisLiftedTypeKindisMultiplicityTyisPredTyisRuntimeRepTymkAppTymkCastTy mkTyConApppartitionInvisibleTypes piResultTysplitTyConApp_maybetYPEtcViewtyConAppTyCon_maybepprCopprKindpprTyLitpprTyVarpprTypedataConExTyCoVarsdataConFieldLabelsdataConFullSigdataConInstOrigArgTys dataConNamedataConSourceAritydataConStupidTheta dataConTyCondataConUserTyVarBindersdataConUserTyVars dataConWorkId dataConWrapIdisUnboxedSumDataConpromoteDataConDataCon DataConRepEqSpecaddrRepDataConTy anyTypeOfKindboxedRepDataConTyCon cTupleDataConcTupleDataConNamecTupleSelIdNamecTupleTyConNamecharTycoercibleTyConconstraintKinddoubleElemRepDataConTydoubleRepDataConTyfloatElemRepDataConTyfloatRepDataConTyheqTyConint16ElemRepDataConTyint16RepDataConTyint32ElemRepDataConTyint32RepDataConTyint64ElemRepDataConTyint64RepDataConTyint8ElemRepDataConTyint8RepDataConTyintRepDataConTy integerTy levityTyConliftedDataConTyliftedDataConTyCon liftedRepTyliftedRepTyConliftedTypeKindliftedTypeKindTyCon listTyCon manyDataConTymanyDataConTyConmkBoxedTupleTymkPromotedListTy multMulTyConmultiplicityTymultiplicityTyCon naturalTy oneDataConTyoneDataConTyConpromotedTupleDataCon runtimeRepTyruntimeRepTyCon sumDataConsumTyCon tupleDataContupleRepDataConTyCon tupleTyContupleTyConNametypeSymbolKindunboxedTupleKindunitTyunliftedDataConTy unliftedRepTyunliftedRepTyConunliftedTypeKindunliftedTypeKindTyConunrestrictedFunTyConvec16DataConTy vec2DataConTyvec32DataConTy vec4DataConTyvec64DataConTy vec8DataConTy vecCountTyCon vecElemTyConvecRepDataConTyConword16ElemRepDataConTyword16RepDataConTyword32ElemRepDataConTyword32RepDataConTyword64ElemRepDataConTyword64RepDataConTyword8ElemRepDataConTyword8RepDataConTywordRepDataConTy binderArgFlag binderType binderVar binderVars globaliseId idDetailsidInfoisCoVar isExportedId isGlobalIdisIdisInferredArgFlagisInvisibleArgFlag isLocalId isLocalVar isNonCoVarId isTcTyVar isTyCoVarisTyVar isTyVarBinderisVisibleArgFlag lazySetIdInfo lookupVarBndr mapVarBndr mapVarBndrsmkCoVarmkExportedLocalVar mkGlobalVar mkLocalVar mkTcTyVarmkTyCoVarBindermkTyCoVarBindersmkTyVar mkTyVarBindermkTyVarBindersmustHaveLocalBinding nonDetCmpVarsameVis setIdDetails setIdExported setIdMultsetIdNotExportedsetTcTyVarDetails setTyVarKind setTyVarNamesetTyVarUnique setVarName setVarType setVarUniquetcTyVarDetails tyVarKind tyVarNametyVarReqToBindertyVarReqToBinderstyVarSpecToBindertyVarSpecToBindersupdateIdTypeAndMultupdateIdTypeAndMultMupdateIdTypeButNotMultupdateTyVarKindupdateTyVarKindM updateVarTypeupdateVarTypeM varMultMaybe varUniqueInvisArgVisArgInferred InvisibleRequired SpecifiedCoVarDFunIdDictIdEqVarEvIdEvVarInCoVarInIdInTyVarInVarIpIdJoinIdKindVarNcIdOutCoVarOutIdOutTyVarOutVar ReqTVBinder InferredSpec SpecifiedSpecTKVar TyCoVarBinder TyVarBinderTypeVarvarMultvarNamevarTypeBndr$fBinaryAnonArgFlag$fBinaryArgFlag$fBinarySpecificity$fBinaryVarBndr$fDataAnonArgFlag $fDataArgFlag$fDataSpecificity $fDataVar $fDataVarBndr$fEqAnonArgFlag $fEqArgFlag$fEqSpecificity$fEqVar$fHasOccNameVar$fNamedThingVar$fNamedThingVarBndr$fOrdAnonArgFlag $fOrdArgFlag$fOrdSpecificity$fOrdVar$fOutputableAnonArgFlag$fOutputableArgFlag$fOutputableVar$fOutputableVarBndr$fOutputableVarBndr0$fUniquableVarb128b16b256b32b512b64b8 bHalfWordbWordcInt cIntWidthcmmBits cmmEqTypecmmEqType_ignoring_ptrhoodcmmFloatcmmVecf32f64gcWord halfWordMask halfWordWidth isBitsType isFloat32 isFloat64 isFloatType isGcPtrType isVecTypeisWord32isWord64narrowSnarrowUrEP_CostCentreStack_mem_allocrEP_CostCentreStack_scc_countrEP_StgEntCounter_allocdrEP_StgEntCounter_allocs typeWidthvecvec16vec16b8vec2vec2b64vec2f64vec4vec4b32vec4f32vec8vec8b16 vecElemType vecLengthwidthFromBytes widthInBits widthInBytes widthInLog wordWidthCmmType ForeignHintAddrHintNoHint SignedHintLengthWidthW128W16W256W32W512W64W8 $fEqCmmCat$fEqForeignHint $fEqWidth $fOrdWidth$fOutputableCmmCat$fOutputableCmmType$fOutputableWidth $fShowCmmCat $fShowCmmType $fShowWidthncgSpillPreallocSize ncgWordWidthplatformWordWidth NCGConfig ncgAsmContext ncgAsmLinting ncgBmiVersionncgCfgBlockLayoutncgCfgWeightlessLayout ncgCfgWeightsncgDoConstantFoldingncgDumpAsmConflictsncgDumpAsmStatsncgDumpRegAllocStagesncgDwarfEnabledncgDwarfSourceNotesncgDwarfStripBlockInfoncgDwarfUnwindingsncgExposeInternalSymbolsncgExternalDynamicRefsncgInlineThresholdMemcpyncgInlineThresholdMemsetncgPIC ncgPlatformncgProcAlignmentncgRegsIterativencgSplitSections ncgSseVersion ncgThisModulecallishMachOpHintsisAssociativeMachOpisCommutableMachOpisComparisonMachOpisFloatComparison machOpArgRepsmachOpMemcpyishAlignmachOpResultTypemaybeIntComparisonmaybeInvertComparison mo_32To16mo_32To8 mo_WordTo16 mo_WordTo32 mo_WordTo64 mo_WordTo8 mo_s_16To32 mo_s_16ToWord mo_s_32ToWord mo_s_8To32 mo_s_8ToWord mo_u_16To32 mo_u_16ToWord mo_u_32ToWord mo_u_8To32 mo_u_8ToWord mo_wordAdd mo_wordAnd mo_wordEq mo_wordMul mo_wordNe mo_wordNot mo_wordOr mo_wordSGe mo_wordSGt mo_wordSLe mo_wordSLt mo_wordSNeg mo_wordSQuot mo_wordSRem mo_wordSShr mo_wordShl mo_wordSub mo_wordUGe mo_wordUGt mo_wordULe mo_wordULt mo_wordUQuot mo_wordURem mo_wordUShr mo_wordXorpprCallishMachOp pprMachOp AtomicMachOpAMO_AddAMO_AndAMO_NandAMO_OrAMO_SubAMO_Xor CallishMachOpMO_Add2 MO_AddIntC MO_AddWordC MO_AtomicRMW MO_AtomicReadMO_AtomicWriteMO_BRevMO_BSwapMO_Clz MO_CmpxchgMO_Ctz MO_F32_Acos MO_F32_Acosh MO_F32_Asin MO_F32_Asinh MO_F32_Atan MO_F32_Atanh MO_F32_Cos MO_F32_Cosh MO_F32_Exp MO_F32_ExpM1 MO_F32_Fabs MO_F32_Log MO_F32_Log1P MO_F32_Pwr MO_F32_Sin MO_F32_Sinh MO_F32_Sqrt MO_F32_Tan MO_F32_Tanh MO_F64_Acos MO_F64_Acosh MO_F64_Asin MO_F64_Asinh MO_F64_Atan MO_F64_Atanh MO_F64_Cos MO_F64_Cosh MO_F64_Exp MO_F64_ExpM1 MO_F64_Fabs MO_F64_Log MO_F64_Log1P MO_F64_Pwr MO_F64_Sin MO_F64_Sinh MO_F64_Sqrt MO_F64_Tan MO_F64_Tanh MO_I64_FromI MO_I64_Ge MO_I64_Gt MO_I64_Le MO_I64_Lt MO_I64_Quot MO_I64_Rem MO_I64_Shr MO_I64_ToI MO_Memcmp MO_Memcpy MO_Memmove MO_MemsetMO_PdepMO_Pext MO_PopCntMO_Prefetch_DataMO_ReadBarrier MO_S_Mul2 MO_S_QuotRem MO_SubIntC MO_SubWordCMO_Touch MO_UF_Conv MO_U_Mul2 MO_U_QuotRem MO_U_QuotRem2 MO_W64_FromW MO_W64_Ge MO_W64_Gt MO_W64_Le MO_W64_Lt MO_W64_Quot MO_W64_Rem MO_W64_Shr MO_W64_ToWMO_WriteBarrierMO_Xchg MO_x64_Add MO_x64_And MO_x64_Eq MO_x64_Mul MO_x64_Ne MO_x64_Neg MO_x64_Not MO_x64_Or MO_x64_Shl MO_x64_Sub MO_x64_XorMachOpMO_AddMO_AlignmentCheckMO_AndMO_Eq MO_FF_Conv MO_FS_ConvMO_F_AddMO_F_EqMO_F_GeMO_F_GtMO_F_LeMO_F_LtMO_F_MulMO_F_NeMO_F_Neg MO_F_QuotMO_F_SubMO_MulMO_NeMO_NotMO_Or MO_SF_Conv MO_SS_ConvMO_S_GeMO_S_GtMO_S_LeMO_S_LtMO_S_MulMayOfloMO_S_Neg MO_S_QuotMO_S_RemMO_S_ShrMO_ShlMO_Sub MO_UU_ConvMO_U_GeMO_U_GtMO_U_LeMO_U_LtMO_U_MulMayOflo MO_U_QuotMO_U_RemMO_U_Shr MO_VF_Add MO_VF_Extract MO_VF_Insert MO_VF_Mul MO_VF_Neg MO_VF_Quot MO_VF_Sub MO_VS_Neg MO_VS_Quot MO_VS_Rem MO_VU_Quot MO_VU_RemMO_V_Add MO_V_Extract MO_V_InsertMO_V_MulMO_V_Sub MO_XX_ConvMO_Xor$fEqAtomicMachOp$fEqCallishMachOp $fEqMachOp$fShowAtomicMachOp$fShowCallishMachOp $fShowMachOpatomicRMWLabelatomicReadLabelatomicWriteLabel bRevLabel bSwapLabelclzLabel cmpxchgLabelctzLabel pdepLabel pextLabel popCntLabelword2FloatLabel xchgLabeldataConTyRepNameUniquedataConWorkerUniqueinitExitJoinUniqueinitTyVarUniqueknownUniqueNamemkAlphaTyVarUniquemkBuiltinUniquemkCTupleDataConUniquemkCTupleSelIdUniquemkCTupleTyConUnique mkCoVarUniquemkCostCentreUniquemkDataOccUniquemkPreludeClassUniquemkPreludeDataConUniquemkPreludeMiscIdUniquemkPreludeTyConUniquemkPrimOpIdUniquemkPrimOpWrapperUniquemkPseudoUniqueDmkPseudoUniqueEmkPseudoUniqueHmkRegClassUniquemkRegPairUniquemkRegSingleUniquemkRegSubUniquemkSumDataConUniquemkSumTyConUnique mkTcOccUniquemkTupleDataConUniquemkTupleTyConUnique mkTvOccUniquemkVarOccUniquetyConRepNameUnique alterOccEnvavoidClashesOccEnvclsNamedataName delFromOccEnvdelListFromOccEnvdelTidyOccEnvList demoteOccName elemOccEnv elemOccSet emptyOccEnv emptyOccSetemptyTidyOccEnv extendOccEnvextendOccEnvListextendOccEnv_AccextendOccEnv_C extendOccSetextendOccSetList filterOccEnv filterOccSet foldOccEnvinitTidyOccEnvintersectOccSetisDataConNameSpace isDataOcc isDataSymOccisDefaultMethodOccisDerivedOccName isEmptyOccSetisSymOccisTcClsNameSpaceisTcOcc isTvNameSpaceisTvOccisTypeableBindOccisValNameSpaceisValOccisVarNameSpaceisVarOcc lookupOccEnv mapOccEnv minusOccSet mkBuilderOccmkClassDataConOccmkClassOpAuxOccmkClsOcc mkClsOccFS mkCon2TagOcc mkDFunOcc mkDataCOccmkDataConWorkerOccmkDataConWrapperOcc mkDataOcc mkDataOccFS mkDataTOccmkDefaultMethodOcc mkDictOcc mkEqPredCoOccmkForeignExportOccmkGen1RmkGenRmkIPOcc mkInstTyCoOcc mkInstTyTcOcc mkLocalOcc mkMatcherOcc mkMaxTagOcc mkMethodOcc mkNewTyCoOccmkOccEnv mkOccEnv_C mkOccName mkOccNameFSmkOccSet mkRepEqOcc mkSpecOccmkSuperDictAuxOccmkSuperDictSelOcc mkTag2ConOccmkTcOcc mkTcOccFS mkTyConRepOcc mkTyVarOcc mkTyVarOccFSmkVarOcc mkWorkerOccnameSpacesRelated occEnvElts parenSymOcc plusOccEnv plusOccEnv_C pprNameSpacepprNameSpaceBriefpprNonVarNameSpace pprOccEnv pprOccNamepromoteOccNamesetOccNameSpace srcDataNamestartsWithUnderscore tcClsNametcName tidyOccNametvNameunionManyOccSets unionOccSets unitOccEnv unitOccSet NameSpaceOccEnv occNameFS occNameSpaceOccSet TidyOccEnv$fBinaryNameSpace$fBinaryOccName $fDataOccEnv $fDataOccName $fEqNameSpace $fEqOccName$fHasOccNameOccName$fNFDataOccName$fOrdNameSpace $fOrdOccName$fOutputableBndrOccName$fOutputableOccEnv$fOutputableOccName$fUniquableOccNameemptyIfaceWarnCachemkIfaceWarnCache plusWarnspprWarningTxtForMsg WarningTxt DeprecatedTxtWarnings NoWarningsWarnAllWarnSome$fBinaryWarningTxt$fBinaryWarnings$fDataWarningTxt$fEqWarningTxt $fEqWarnings$fOutputableWarningTxtgetOccFS getOccString getSrcLoc getSrcSpanisBuiltInSyntax isDataConName isDynLinkNameisExternalName isHoleNameisInternalName isSystemName isTyConName isTyVarName isValName isVarName isWiredIn isWiredInName localiseNamemkClonedInternalNamemkDerivedInternalNamemkExternalName mkFCallNamemkInternalName mkSysTvName mkSystemNamemkSystemNameAtmkSystemVarName mkWiredInNamenameIsFromExternalPackagenameIsHomePackagenameIsHomePackageImportnameIsLocalOrFrom nameModulenameModule_maybe nameNameSpace nameSrcLoc nameSrcSpannameStableString pprDefinedAt pprInfixNamepprModulePrefixpprNameDefnLocpprNameUnqualified pprPrefixName setNameLoc stableNameCmpwiredInNameTyThing_maybe BuiltInSyntax UserSyntax $fBinaryName $fDataName$fEqName$fHasOccNameName $fNFDataName$fNFDataNameSort$fNamedThingGenLocated$fNamedThingName $fOrdName$fOutputableBndrName$fOutputableName$fOutputableNameSort$fUniquableNamenoDependencies DependenciesDeps dep_finstsdep_mods dep_orphsdep_pkgs dep_plginsUsage UsageFileUsageHomeModuleUsageMergedRequirementUsagePackageModule usg_entities usg_exports usg_file_hash usg_file_pathusg_mod usg_mod_hash usg_mod_nameusg_safe$fBinaryDependencies $fBinaryUsage$fEqDependencies $fEqUsage allDVarSet allVarSet anyDVarSet anyVarSet dVarSetElemsdVarSetIntersectVarSetdVarSetMinusVarSetdVarSetToVarSet delDVarSetdelDVarSetList delVarSetdelVarSetByKey delVarSetListdisjointDVarSetdisjointVarSet elemDVarSet elemVarSetelemVarSetByKey emptyDVarSet emptyVarSet extendDVarSetextendDVarSetList extendVarSetextendVarSetList filterDVarSet filterVarSet fixVarSetintersectDVarSetintersectVarSetintersectsDVarSetintersectsVarSetisEmptyDVarSet isEmptyVarSet lookupVarSetlookupVarSetByNamelookupVarSet_Directly mapDVarSetmapUnionDVarSetmapUnionVarSet mapVarSet minusDVarSet minusVarSet mkDVarSetmkVarSetnonDetStrictFoldDVarSetnonDetStrictFoldVarSetpartitionDVarSetpartitionVarSet pluralVarSet pprVarSet seqDVarSet seqVarSet sizeDVarSet sizeVarSet subDVarSet subVarSettransCloDVarSettransCloVarSet unionDVarSet unionDVarSets unionVarSet unionVarSets unitDVarSet unitVarSetCoVarSetDIdSet DTyCoVarSet DTyVarSetDVarSetIdSet TyCoVarSetTyVarSetVarSetdelFVdelFVsemptyFVfilterFV fvDVarSet fvVarListfvVarSet mapUnionFVmkFVsunionFVunionsFVunitFVFVInterestingVarFun alterDVarEnv alterVarEnv anyDVarEnv dVarEnvEltsdelBndrLdelBndrR delBndrsL delBndrsR delDVarEnvdelDVarEnvList delInScopeSetdelTidyEnvList delVarEnv delVarEnvListdisjointVarEnv elemDVarEnvelemInScopeSet elemVarEnvelemVarEnvByKey emptyDVarEnvemptyInScopeSet emptyTidyEnv emptyVarEnv extendDVarEnvextendDVarEnvListextendDVarEnv_CextendInScopeSetextendInScopeSetListextendInScopeSetSetextendRnInScopeSetList extendVarEnvextendVarEnvListextendVarEnv_AccextendVarEnv_C filterDVarEnv filterVarEnv foldDVarEnvgetInScopeVarsinRnEnvLinRnEnvRisEmptyDVarEnv isEmptyVarEnv lookupDVarEnv lookupInScopelookupInScope_DirectlylookupRnInScope lookupVarEnvlookupVarEnv_NFlookupWithDefaultVarEnv mapDVarEnv mapVarEnv minusDVarEnv minusVarEnv mkDVarEnvmkEmptyTidyEnv mkInScopeSetmkRnEnv2mkVarEnvmkVarEnv_Directly modifyDVarEnv modifyVarEnvmodifyVarEnv_DirectlynonDetStrictFoldDVarEnv nukeRnEnvL nukeRnEnvRpartitionDVarEnvpartitionVarEnv plusDVarEnv plusDVarEnv_CplusMaybeVarEnv_C plusVarEnvplusVarEnvList plusVarEnv_C plusVarEnv_CDrestrictVarEnvrnBndr2 rnBndr2_varrnBndrLrnBndrRrnBndrs2rnEnvLrnEnvRrnEtaLrnEtaR rnInScope rnInScopeSetrnOccL rnOccL_maybernOccR rnOccR_maybernSwap unionInScopeuniqAway unitDVarEnv unitVarEnvunsafeGetFreshLocalUnique varSetInScope zipVarEnvCoVarEnvDIdEnv DTyVarEnvDVarEnvIdEnv InScopeSetRnEnv2TidyEnv TyCoVarEnvTyVarEnvVarEnv$fOutputableInScopeSetaddOneFVallUsesdelFromNameSetdelListFromNameSetdisjointNameSetduDefsduUses elemNameSetemptyDUsemptyFVs emptyNameSet extendNameSetextendNameSetList filterNameSetfindUses intersectFVsintersectNameSetintersectsNameSet isEmptyFVsisEmptyNameSet minusNameSetmkDUs mkNameSet nameSetAll nameSetAnynameSetElemsStableplusDUplusFVplusFVs unionNameSet unionNameSets unitNameSetusesOnlyDefUseDefUsesDefsFreeVarsNameSet NonCaffySetUses$fMonoidNonCaffySet$fSemigroupNonCaffySetadjustDNameEnv alterDNameEnv alterNameEnv anyNameEnvdelFromDNameEnvdelFromNameEnvdelListFromNameEnvdepAnaldisjointNameEnv elemNameEnv emptyDNameEnv emptyNameEnvextendDNameEnv extendNameEnvextendNameEnvListextendNameEnvList_CextendNameEnv_AccextendNameEnv_CfilterDNameEnv filterNameEnvisEmptyNameEnvlookupDNameEnv lookupNameEnvlookupNameEnv_NF mapDNameEnv mapNameEnv mkNameEnv mkNameEnvWith nameEnvElts plusNameEnv plusNameEnv_CplusNameEnv_CDplusNameEnv_CD2 unitNameEnvDNameEnvNameEnvemptyFixityEnvemptyIfaceFixCache lookupFixitymkIfaceFixCacheFixItem FixityEnv$fOutputableFixItemccFromThisModule cmpCostCentre collectCCcostCentreSrcSpancostCentreUserNamecostCentreUserNameFS currentCCS dontCareCCSemptyCollectedCCsisCafCCisCafCCS isCurrentCCS isSccCountCCmaybeSingletonCCS mkAllCafsCCmkAutoCCmkSingletonCCSmkUserCCpprCostCentreCore sccAbleCC CCFlavourCafCCDeclCCExprCCHpcCCCcName CollectedCCs CostCentre AllCafsCCNormalCCcc_loccc_modcc_nameCostCentreStack$fBinaryCCFlavour$fBinaryCostCentre$fDataCCFlavour$fDataCostCentre $fEqCCFlavour$fEqCostCentre$fEqCostCentreStack$fOrdCCFlavour$fOrdCostCentre$fOrdCostCentreStack$fOutputableCostCentre$fOutputableCostCentreStackavailavailExportsDecl availField availFlds availGreName availGreNames availName availNamesavailNamesWithSelectorsavailNonFldNamesavailSubordinateGreNamesavailTCavailsToNameEnvavailsToNameSetavailsToNameSetWithSelectors filterAvail filterAvailsgreNameFieldLabelgreNameMangledNamegreNamePrintableNamegreNameSrcSpan nubAvailspartitionGreNames plusAvailstableAvailCmpstableGreNameCmp trimAvail AvailInfoAvailAvailTCAvailsGreName FieldGreName NormalGreName$fBinaryAvailInfo$fBinaryGreName$fDataAvailInfo $fDataGreName $fEqAvailInfo $fEqGreName$fHasOccNameGreName$fOutputableAvailInfo$fOutputableGreName availFromGRE bestImportdelLocalRdrEnvList demoteRdrNameelemLocalRdrEnvemptyGlobalRdrEnvemptyLocalRdrEnvextendGlobalRdrEnvextendLocalRdrEnvextendLocalRdrEnvListgetGRE_NameQualifier_maybes getRdrNameglobalRdrEnvEltsgreDefinitionModulegreDefinitionSrcSpan greFieldLabelgreMangledName greOccNamegreParent_maybegrePrintableNamegreQualModName greRdrNames greSrcSpan gresFromAvailgresFromAvailsgresToAvailInfo importSpecLocimportSpecModuleinLocalRdrEnvScopeisDuplicateRecFldGREisExact isExact_maybeisExplicitItemisFieldSelectorGRE isLocalGREisNoFieldSelectorGREisOrig isOrig_maybeisQual isQual_maybe isRdrDataConisRdrTc isRdrTyVar isRecFldGRE isSrcRdrNameisUnquallocalGREsFromAvaillocalRdrEnvEltslookupGRE_FieldLabellookupGRE_GreNamelookupGRE_NamelookupGRE_Name_OccNamelookupGRE_RdrNamelookupGRE_RdrName'lookupGlobalRdrEnvlookupLocalRdrEnvlookupLocalRdrOccmkGlobalRdrEnvmkOrigmkQual mkRdrQual mkRdrUnqualmkUnqual mkVarUnqual nameRdrNameopIsAtpickGREspickGREsModExpplusGlobalRdrEnvpprGlobalRdrEnvpprNameProvenancepromoteRdrName qualSpecOK rdrNameOcc rdrNameSpace shadowNamesstarInfo transformGREsunQualOK unQualSpecOK GlobalRdrEltGREgre_impgre_lclgre_namegre_par GlobalRdrEnv ImpDeclSpecis_asis_dlocis_modis_qual ImpItemSpecImpAllImpSome is_explicitis_iloc ImportSpecImpSpecis_declis_item LocalRdrEnvParentNoParentParentIspar_isExactOrigQualUnqual$fDataGlobalRdrElt$fDataImportSpec $fDataParent$fDataImpDeclSpec$fDataImpItemSpec $fDataRdrName$fEqGlobalRdrElt$fEqImportSpec$fEqImpDeclSpec$fEqImpItemSpec $fEqParent $fEqRdrName$fHasOccNameGlobalRdrElt$fHasOccNameRdrName $fOrdRdrName$fOutputableBndrRdrName$fOutputableGlobalRdrElt$fOutputableImportSpec$fOutputableLocalRdrEnv$fOutputableParent$fOutputableRdrNameimportedByUser ImportedByImportedBySystemImportedByUser ImportedModsImportedModsValimv_all_exports imv_is_hiding imv_is_safeimv_name imv_qualifiedimv_spandeserializeAnns emptyAnnEnvextendAnnEnvListfindAnnsfindAnnsByTypeRepmkAnnEnv plusAnnEnvAnnEnv AnnPayload AnnTarget ModuleTarget NamedTarget ann_target ann_value CoreAnnTarget$fBinaryAnnTarget$fFunctorAnnTarget$fOutputableAnnTarget$fOutputableAnnotationaddAnnsaddAnnsAaddCLocA addCLocAAaddCommentsToEpAnnaddCommentsToSrcAnnaddTrailingAnnToAaddTrailingAnnToLaddTrailingCommaToNannParen2AddEpAnn combineLocsAcombineSrcSpansAcomment commentsOnlyAdeltaPos emptyComments epAnnAnns epAnnAnnsL epAnnCommentsepaLocationFromSrcAnnepaLocationRealSrcSpanextraToAnnList getDeltaLinegetFollowingCommentsgetLocA getLocAnnl2ll2nla2lala2nala2rmapLocAn2lna2lanoAnn noAnnSrcSpan noCommentsnoLocA noSrcSpanA parenTypeKwsplaceholderRealSpanreAnnreAnnCreAnnLreLocreLocAreLocCreLocLreLocNrealSpanAsAnchor realSrcSpanremoveCommentsAsetCommentsEpAnnsetCommentsSrcAnnsetFollowingCommentssetPriorComments sortLocatedA spanAsAnchor transferAnnsA unicodeAnn widenAnchor widenAnchorRwidenLocatedAn widenSpanAddEpAnnAnchoranchor anchor_opAnchorOperation MovedAnchorUnchangedAnchor AnnContextac_close ac_darrowac_open AnnAnyclassAnnAsAnnClass AnnCloseBU AnnCloseC AnnClosePH AnnCloseQU AnnCloseS AnnCommaTuple AnnDarrowU AnnDcolonU AnnDollarAnnDollarDollar AnnForallU AnnHiding AnnLarrowUAnnLarrowtailU AnnLollyUAnnMdoAnnName AnnOpenBUAnnOpenC AnnOpenEQU AnnOpenPHAnnOpenSAnnPackageName AnnPercent AnnPercentOne AnnQualified AnnRarrowUAnnRarrowtailUAnnSafe AnnSignatureAnnSimpleQuote AnnThTyQuoteAnnUnit AnnValStrAnnViaAnnlarrowtailUAnnrarrowtailUAnnList al_anchoral_closeal_openal_rest al_trailing AnnListItem lann_trailingAnnParen ap_adornmentap_closeap_open AnnPragma apr_closeapr_openapr_rest AnnSortKey NoAnnSortKeyDeltaPos DifferentLineSameLine deltaColumn deltaLineEpAnn EpAnnNotUsedannscommentsentryEpAnnCO EpAnnComments EpaCommentsEpaCommentsBalancedfollowingComments priorComments EpaComment ac_prior_tokac_tok EpaCommentTokEpaBlockCommentEpaDocCommentNamedEpaDocCommentNextEpaDocCommentPrev EpaDocOptions EpaDocSection EpaEofCommentEpaLineComment EpaLocationEpaDeltaEpaSpanHasENoEIsUnicodeSyntax NormalSyntax UnicodeSyntax LEpaCommentLocatedA LocatedAnLocatedCLocatedLLocatedNLocatedP NameAdornmentNameBackquotes NameParensNameParensHash NameSquareNameAnn NameAnnCommas NameAnnOnly NameAnnQuote NameAnnRArrowNameAnnTrailingnann_adornment nann_close nann_commas nann_name nann_open nann_quote nann_quoted nann_trailingNoEpAnns ParenType AnnParens AnnParensHashAnnParensSquareSrcAnn SrcSpanAnn' SrcSpanAnnannlocA SrcSpanAnnA SrcSpanAnnC SrcSpanAnnL SrcSpanAnnN SrcSpanAnnP TrailingAnn AddCommaAnn AddLollyAnnU AddRarrowAnn AddRarrowAnnU AddSemiAnn AddVbarAnn$fDataAddEpAnn$fDataAnnKeywordId$fDataEpaLocation $fDataAnchor$fDataAnchorOperation$fDataDeltaPos$fDataAnnContext$fDataIsUnicodeSyntax $fDataAnnList$fDataTrailingAnn$fDataAnnListItem$fDataAnnParen$fDataParenType$fDataAnnPragma$fDataAnnSortKey $fDataEpAnn$fDataEpAnnComments$fDataEpaComment$fDataEpaCommentTok $fDataHasE$fDataNameAdornment $fDataNameAnn$fDataNoEpAnns$fDataSrcSpanAnn' $fEqAddEpAnn $fEqAnchor$fEqEpaComment$fEqAnchorOperation$fEqAnnKeywordId $fEqAnnList$fEqAnnListItem$fEqTrailingAnn $fEqAnnPragma$fEqAnnSortKey $fEqDeltaPos $fEqEpAnn$fEqEpAnnComments$fEqEpaCommentTok$fEqEpaLocation$fEqHasE$fEqIsUnicodeSyntax$fEqNameAdornment $fEqNameAnn $fEqNoEpAnns $fEqParenType$fEqSrcSpanAnn'$fFunctorEpAnn$fMonoidAnnList$fSemigroupAnnList$fMonoidAnnListItem$fSemigroupAnnListItem$fMonoidAnnSortKey$fSemigroupAnnSortKey $fMonoidEpAnn$fSemigroupEpAnn$fMonoidNameAnn$fSemigroupNameAnn $fOrdAddEpAnn $fOrdAnchor$fOrdEpaComment$fOrdAnnKeywordId $fOrdDeltaPos$fOrdEpaCommentTok$fOrdEpaLocation $fOrdHasE$fOrdIsUnicodeSyntax$fOrdNameAdornment $fOrdNoEpAnns$fOrdParenType$fOrdTrailingAnn$fOutputableAddEpAnn$fOutputableAnchor$fOutputableAnchorOperation$fOutputableAnnContext$fOutputableAnnKeywordId$fOutputableAnnList$fOutputableAnnListItem$fOutputableAnnPragma$fOutputableAnnSortKey$fOutputableDeltaPos$fOutputableEpAnn$fOutputableEpAnnComments$fOutputableEpaComment$fOutputableEpaLocation$fOutputableIsUnicodeSyntax$fOutputableNameAdornment$fOutputableNameAnn$fOutputableSrcSpanAnn'$fOutputableTrailingAnn$fSemigroupAnchor$fSemigroupEpAnnComments$fSemigroupSrcSpanAnn' $fShowAnchor$fShowAnchorOperation$fShowAnnKeywordId$fShowDeltaPos$fShowEpaComment$fShowEpaCommentTok $fShowHasE$fShowIsUnicodeSyntaxevalimplies impliesAtomisFalseisTrue isUnsatisfiedmkAndmkFalsemkOrmkTruemkVarpprBooleanFormulapprBooleanFormulaNicesimplifyBooleanFormulaAndOrParensLBooleanFormula$fBinaryBooleanFormula$fDataBooleanFormula$fEqBooleanFormula$fFoldableBooleanFormula$fFunctorBooleanFormula$fOutputableBooleanFormula$fTraversableBooleanFormulacomputeFingerprintfingerprintBinMemputNameLiterally appendDocs concatDocsemptyArgDocMapemptyDeclDocMaphsDocStringToByteStringisEmptyDocString mkHsDocStringmkHsDocStringUtf8ByteString ppr_mbDoc unpackHDS ArgDocMap DeclDocMapExtractedTHDocs ethd_arg_docsethd_decl_docsethd_inst_docsethd_mod_header HsDocString LHsDocString$fBinaryArgDocMap$fBinaryHsDocString$fBinaryDeclDocMap$fDataHsDocString$fEqHsDocString$fOutputableArgDocMap$fOutputableDeclDocMap$fOutputableHsDocString$fShowHsDocStringcoAxBranchCoVarscoAxBranchIncomps coAxBranchLHS coAxBranchRHScoAxBranchRolescoAxBranchSpancoAxBranchTyVars coAxiomAritycoAxiomBranches coAxiomNamecoAxiomNthBranchcoAxiomNumPats coAxiomRolecoAxiomSingleBranchcoAxiomSingleBranch_maybe coAxiomTyCon fromBranches fsFromRoleisImplicitCoAxiom manyBranchesmapAccumBranches numBranchesplaceHolderIncompstoBranchedAxiomtoUnbranchedAxiomtrivialBuiltInFamily unbranched BranchFlag BranchIndexBranchedBranches MkBranches unMkBranchesBuiltInSynFamilysfInteractInert sfInteractTop sfMatchFam CoAxBranchcab_cvs cab_eta_tvs cab_incompscab_lhscab_loccab_rhs cab_rolescab_tvsCoAxiomco_ax_branchesco_ax_implicit co_ax_name co_ax_roleco_ax_tc co_ax_unique CoAxiomRulecoaxrAsmpRoles coaxrName coaxrProves coaxrRoleRoleNominalPhantomRepresentationalTypeEqn Unbranched $fBinaryRole$fDataCoAxBranch $fDataCoAxiom$fDataCoAxiomRule $fDataRole $fEqCoAxiom$fEqCoAxiomRule$fEqRole$fNamedThingCoAxiom$fOrdCoAxiomRule $fOrdRole$fOutputableCoAxBranch$fOutputableCoAxiom$fOutputableCoAxiomRule$fOutputableRole$fUniquableCoAxiom$fUniquableCoAxiomRulecoVarKindsTypesRole coVarRole coercionKind coercionLKind coercionRKind coercionTypedecomposePiCos isGReflCoisReflCo isReflexiveCo liftCoSubstmkAppCo mkAxiomInstCo mkAxiomRuleCo mkCoVarComkCoercionType mkForAllComkFunCo mkGReflComkInstComkKindComkLRCo mkNomReflComkNthCo mkPhantomComkProofIrrelComkReflComkSubComkSymCo mkTransCo mkTyConAppComkUnivCoseqCoLiftingContext classATItemsclassATsclassAllSelIds classArity classBigSigclassExtraBigSig classHasFds classMethodsclassMinimalDef classOpItems classSCSelId classSCSelIds classSCTheta classTvsFdsisAbstractClassmkAbstractClassmkClasspprDefMethInfo pprFunDep pprFundepsATValidityInfoATVINoATVIClassclassKey className classTyCon classTyVars ClassATItemATIClassMinimalDef ClassOpItem DefMethInfoFunDep $fDataClass $fEqClass$fNamedThingClass$fOutputableClass$fUniquableClass magicDictIdmkDataConWorkId mkDictSelId mkPrimOpId voidPrimId DataConBoxerRegClassRcDoubleRcFloat RcInteger $fEqRegClass$fOutputableRegClass$fUniquableRegClassclassOfVirtualReggetHiVRegFromLogetHiVirtualRegFromLo isRealReg isVirtualRegliftPatchFnToRegReg realRegSingle realRegsAliasregNosOfRealRegregPair regSinglerenameVirtualReg takeRealRegtakeVirtualRegRealReg RealRegPair RealRegSingleRegRegReal RegVirtualRegNo VirtualReg VirtualRegD VirtualRegF VirtualRegHi VirtualRegI $fEqRealReg$fEqReg$fEqVirtualReg $fOrdRealReg$fOrdReg$fOrdVirtualReg$fOutputableRealReg$fOutputableReg$fOutputableVirtualReg $fShowRealReg $fShowReg$fShowVirtualReg$fUniquableRealReg$fUniquableReg$fUniquableVirtualRegtoRegMap toVRegMap trivColorableboundsqueeseworstRegSubClassF64ClassG16ClassG32ClassG8SubL16SubL8SubL8H$fEnumRegClass $fEnumRegSub $fEqRegSub $fOrdRegSub$fShowRegClass $fShowRegSub classOfRegregAliasregName regsOfClassaRROWabsentErrorIdKeyabsentSumFieldErrorIdKeyaddrPrimTyConKeyallNameStringsall_RDRalt_RDRalternativeClassKeyalternativeClassNameand_RDR anyBoxConKey anyTyConKey apAClassOpKeyapANameap_RDR appAIdKeyappAName appendIdKey appendName append_RDRapplicativeClassKeyapplicativeClassName arrAIdKeyarrANamearrayArrayPrimTyConKeyarrayPrimTyConKeyassertErrorIdKeyassertErrorName assertIdKey assertName augmentIdKey augmentNamebasicKnownKeyNamesbcoPrimTyConKeybignatFromWordListIdKeybignatFromWordListName bindIOIdKey bindIOName bindIO_RDRbindMClassOpKey bindMName bindM_RDRbitIntegerIdKey bnbVarQual bniVarQual bnnVarQual boolTyConKeyboundedClassKeyboundedClassNameboxedRepDataConKey boxityConKeybreakpointCondIdKeybreakpointCondNamebreakpointIdKeybreakpointName buildIdKey buildName build_RDRbyteArrayPrimTyConKey c1TyConKey c1TyConNamecONTROL_APPLICATIVEcONTROL_EXCEPTION_BASE cTyConKey cTyConNamecallStackTyConKeycallStackTyConNamecharDataConKeycharPrimTyConKey charTyConKey choiceAIdKey choiceAName choose_RDRclsQual clsQual_RDR coerceKeycoercibleDataConKeycoercibleSCSelIdKeycoercibleTyConKeycoercionTokenIdKeycomp1DataCon_RDR compTyConKey compTyConNamecompactPrimTyConKey compare_RDR composeAIdKey composeAName compose_RDR conFixity_RDRconIsRecord_RDR conName_RDR concatIdKey concatNameconsDataConKeyconsiderAccessibleIdKeyconsiderAccessibleNameconstraintKindTyConKeyconstructorClassKeyconstructorClassNamecrossDataConKeycstringLengthIdKeycstringLengthName d1TyConKey d1TyConNamedATA_ARRAY_PARALLEL_NAMEdATA_ARRAY_PARALLEL_PRIM_NAME dATA_COERCE dATA_EITHER dATA_FOLDABLE dATA_LIST dATA_STRINGdATA_TRAVERSABLE dATA_TUPLEdATA_TYPE_EQUALITY dEBUG_TRACE dTyConKey dTyConNamedYNAMIC dataClassKey dataClassName dataQual_RDR dataToTag_RDRdatatypeClassKeydatatypeClassNamedatatypeName_RDRdcQualdecidedLazyDataConKeydecidedLazyDataConNamedecidedStrictDataConKeydecidedStrictDataConNamedecidedUnpackDataConKeydecidedUnpackDataConNamederivableClassKeys divIntIdKey divIntName dollarIdKey dollarNamedoubleDataConKeydoublePrimTyConKeydoubleTyConKeydoubleX2PrimTyConKeydoubleX4PrimTyConKeydoubleX8PrimTyConKeyeitherTyConKeyeitherTyConNameemptyCallStackKeyemptyCallStackName enumClassKey enumClassName enumClass_RDRenumFromClassOpKey enumFromNameenumFromThenClassOpKeyenumFromThenNameenumFromThenToClassOpKeyenumFromThenToNameenumFromThenTo_RDRenumFromThen_RDRenumFromToClassOpKeyenumFromToNameenumFromTo_RDR enumFrom_RDR eqClassKey eqClassName eqClassOpKey eqClass_RDR eqDataConKeyeqNameeqPhantPrimTyConKeyeqPrimTyConKeyeqReprPrimTyConKey eqSCSelIdKey eqStringIdKey eqStringName eqString_RDR eqTag_RDR eqTyConKeyeq_RDR errorIdKeyerrorMessageTypeErrorFamKeyerrorMessageTypeErrorFamName error_RDR expectP_RDR failIOIdKey failIONamefailMClassOpKey failMName failM_RDRfalseDataConKey filterIdKey filterNamefingerprintDataConKeyfingerprintDataConName firstAIdKey firstANamefloatDataConKeyfloatPrimTyConKey floatTyConKeyfloatX16PrimTyConKeyfloatX4PrimTyConKeyfloatX8PrimTyConKeyfloatingClassKeyfloatingClassNamefmapClassOpKeyfmapNamefmap_RDR foldMap_RDRfoldableClassKeyfoldableClassNamefoldable_foldr_RDR foldrIdKey foldrName foldr_RDRforeignObjPrimTyConKeyfractionalClassKeyfractionalClassKeysfractionalClassName from1_RDR fromEnum_RDRfromIntegerClassOpKeyfromIntegerNamefromInteger_RDRfromIntegralIdKeyfromIntegralNamefromIntegral_RDRfromLabelClassOpKeyfromLabelClassOpNamefromListClassOpKeyfromListNClassOpKey fromListNName fromListN_RDR fromListName fromList_RDRfromRationalClassOpKeyfromRationalNamefromRational_RDRfromStaticPtrClassOpKeyfromStaticPtrNamefromStringClassOpKeyfromStringNamefromString_RDRfrom_RDRfrontendPluginTyConKeyfrontendPluginTyConNamefstIdKeyfstNamefunPtrTyConKeyfunPtrTyConName funTyConKeyfunctorClassKeyfunctorClassNamegENERICSgHC_BASE gHC_CLASSESgHC_CONC gHC_CSTRING gHC_DESUGARgHC_ENUMgHC_ERRgHC_EXTSgHC_FINGERPRINT_TYPE gHC_FLOAT gHC_GENERICSgHC_GHCIgHC_GHCI_HELPERSgHC_INTgHC_IOgHC_IO_ExceptiongHC_IXgHC_LIST gHC_MAGIC gHC_MAYBEgHC_NUMgHC_NUM_BIGNATgHC_NUM_INTEGERgHC_NUM_NATURALgHC_OVER_LABELSgHC_PRIMgHC_PRIMOPWRAPPERSgHC_PRIM_EXCEPTIONgHC_PRIM_PANICgHC_PTRgHC_READgHC_REAL gHC_RECORDSgHC_SHOW gHC_SRCLOCgHC_ST gHC_STABLE gHC_STACKgHC_STACK_TYPES gHC_STATICPTRgHC_STATICPTR_INTERNALgHC_TOP_HANDLER gHC_TUPLE gHC_TYPELITSgHC_TYPELITS_INTERNAL gHC_TYPENATSgHC_TYPENATS_INTERNAL gHC_TYPESgHC_WORD geClassOpKeygeNamege_RDR gen1ClassKey gen1ClassName genClassKey genClassNamegenUnitDataConKeygenericClassNamesgenericTyConNamesgetFieldClassOpKey getFieldName getTag_RDRghciIoClassKeyghciIoClassNameghciStepIoMClassOpKeyghciStepIoMNamegroupWithIdKey groupWithName gtTag_RDRgt_RDR guardMIdKey guardMNamehasFieldClassNamehasFieldClassNameKey heqDataConKey heqSCSelIdKey heqTyConKey ident_RDR inRange_RDR index_RDRinfixDataCon_RDRinfixIDataConKeyinfixIDataConName inlDataConKey inlineIdKey inlineIdName inrDataConKeyint16PrimTyConKey int16TyConKeyint16TyConNameint16X16PrimTyConKeyint16X32PrimTyConKeyint16X8PrimTyConKeyint32PrimTyConKey int32TyConKeyint32TyConNameint32X16PrimTyConKeyint32X4PrimTyConKeyint32X8PrimTyConKeyint64PrimTyConKey int64TyConKeyint64TyConNameint64X2PrimTyConKeyint64X4PrimTyConKeyint64X8PrimTyConKeyint8PrimTyConKey int8TyConKey int8TyConNameint8X16PrimTyConKeyint8X32PrimTyConKeyint8X64PrimTyConKey intDataConKeyintPrimTyConKey intTyConKeyintegerAbsIdKeyintegerAbsNameintegerAddIdKeyintegerAddNameintegerAdd_RDRintegerAndIdKeyintegerAndNameintegerBitIdKeyintegerBitNameintegerCompareIdKeyintegerCompareNameintegerComplementIdKeyintegerComplementNameintegerDivIdKeyintegerDivModIdKeyintegerDivModNameintegerDivNameintegerEncodeDoubleIdKeyintegerEncodeDoubleNameintegerEncodeFloatIdKeyintegerEncodeFloatNameintegerEqIdKey integerEqNameintegerFromInt64IdKeyintegerFromInt64NameintegerFromNaturalIdKeyintegerFromNaturalNameintegerFromWord64IdKeyintegerFromWord64NameintegerFromWordIdKeyintegerFromWordNameintegerGcdIdKeyintegerGcdNameintegerGeIdKey integerGeNameintegerGtIdKey integerGtNameintegerINDataConKeyintegerIPDataConKeyintegerISDataConKeyintegerLcmIdKeyintegerLcmNameintegerLeIdKey integerLeNameintegerLtIdKey integerLtNameintegerModIdKeyintegerModNameintegerMulIdKeyintegerMulNameintegerMul_RDRintegerNeIdKey integerNeNameintegerNegateIdKeyintegerNegateNameintegerOrIdKey integerOrNameintegerPopCountIdKeyintegerPopCountNameintegerQuotIdKeyintegerQuotNameintegerQuotRemIdKeyintegerQuotRemNameintegerRemIdKeyintegerRemNameintegerShiftLIdKeyintegerShiftLNameintegerShiftRIdKeyintegerShiftRNameintegerSignumIdKeyintegerSignumNameintegerSubIdKeyintegerSubNameintegerTestBitIdKeyintegerTestBitNameintegerToDoubleIdKeyintegerToDoubleNameintegerToFloatIdKeyintegerToFloatNameintegerToInt64IdKeyintegerToInt64NameintegerToIntIdKeyintegerToIntNameintegerToNaturalClampIdKeyintegerToNaturalClampNameintegerToNaturalIdKeyintegerToNaturalNameintegerToNaturalThrowIdKeyintegerToNaturalThrowNameintegerToWord64IdKeyintegerToWord64NameintegerToWordIdKeyintegerToWordNameintegerTyConKeyintegerXorIdKeyintegerXorNameintegralClassKeyintegralClassNameinteractiveClassKeysinteractiveClassNames ioDataConKey ioDataConName ioDataCon_RDRioPortPrimTyConKey ioTyConKey ioTyConName ipClassKey ipClassNameisListClassKeyisListClassNameisNewtypeName_RDRisStringClassKeyisStringClassName isUnboundNameitName ixClassKey ixClassName joinMIdKey joinMNamejustDataConKey k1DataCon_RDR k1TyConKey k1TyConName kindConKeykindRepAppDataConKeykindRepAppDataConNamekindRepFunDataConKeykindRepFunDataConNamekindRepTYPEDataConKeykindRepTYPEDataConNamekindRepTyConAppDataConKeykindRepTyConAppDataConNamekindRepTyConKeykindRepTyConNamekindRepTypeLitDDataConKeykindRepTypeLitDDataConNamekindRepTypeLitSDataConKeykindRepTypeLitSDataConNamekindRepVarDataConKeykindRepVarDataConNameknownCharClassNameknownCharClassNameKeyknownNatClassNameknownNatClassNameKeyknownSymbolClassNameknownSymbolClassNameKey l1DataCon_RDRlEX lazyIdKeyle_RDRleftAssocDataCon_RDRleftAssociativeDataConKeyleftAssociativeDataConNameleftDataConKeyleftDataConNameleftSectionKeyleft_RDRlevityTyConKeylexP_RDR liftA2_RDR liftMIdKey liftMNameliftedDataConKeyliftedRepTyConKeyliftedTypeKindTyConKey listTyConKey loopAIdKey loopAName ltTag_RDRlt_RDR m1DataCon_RDR m1TyConKey m1TyConName mAIN_NAMEmONAD mONAD_FAIL mONAD_FIX mONAD_ZIPmVarPrimTyConKey magicDictKeymain_RDR_Unqual makeStaticKeymakeStaticNamemanyDataConKeymapIdKeymapNamemap_RDRmappendClassOpKey mappendName mappend_RDR maxBound_RDR maybeTyConKeymconcatClassOpKey mconcatNamememptyClassOpKey memptyName mempty_RDRmetaConsDataConKeymetaConsDataConNamemetaDataDataConKeymetaDataDataConNamemetaSelDataConKeymetaSelDataConName mfixIdKeymfixName minBound_RDRminusClassOpKey minusName minus_RDR mkBaseModule mkBaseModule_mkBignumModulemkInteractiveModule mkMainModule mkMainModule_ mkPrimModulemkRationalBase10IdKeymkRationalBase10NamemkRationalBase2IdKeymkRationalBase2NamemkThisGhcModulemkThisGhcModule_ mkTrAppKey mkTrAppName mkTrConKey mkTrConName mkTrFunKey mkTrFunName mkTrTypeKey mkTrTypeName mkTyConKey mkUnboundNamemk_known_key_name modIntIdKey modIntNamemoduleName_RDR monadClassKeymonadClassNamemonadClass_RDRmonadFailClassKeymonadFailClassNamemonadFixClassKeymonadFixClassNamemonadPlusClassKeymonadPlusClassNamemonoidClassKeymonoidClassNamemultMulTyConKeymultiplicityTyConKeymutVarPrimTyConKeymutableArrayArrayPrimTyConKeymutableArrayPrimTyConKeymutableByteArrayPrimTyConKey mzipIdKeymzipNamenaturalAddIdKeynaturalAddNamenaturalAndIdKeynaturalAndNamenaturalAndNotIdKeynaturalAndNotNamenaturalBitIdKeynaturalBitNamenaturalCompareIdKeynaturalCompareNamenaturalEqIdKey naturalEqNamenaturalGcdIdKeynaturalGcdNamenaturalGeIdKey naturalGeNamenaturalGtIdKey naturalGtNamenaturalLcmIdKeynaturalLcmNamenaturalLeIdKey naturalLeNamenaturalLog2IdKeynaturalLog2NamenaturalLogBaseIdKeynaturalLogBaseNamenaturalLogBaseWordIdKeynaturalLogBaseWordNamenaturalLtIdKey naturalLtNamenaturalMulIdKeynaturalMulNamenaturalNBDataConKeynaturalNSDataConKeynaturalNeIdKey naturalNeNamenaturalNegateIdKeynaturalNegateNamenaturalOrIdKey naturalOrNamenaturalPopCountIdKeynaturalPopCountNamenaturalPowModIdKeynaturalPowModNamenaturalQuotIdKeynaturalQuotNamenaturalQuotRemIdKeynaturalQuotRemNamenaturalRemIdKeynaturalRemNamenaturalShiftLIdKeynaturalShiftLNamenaturalShiftRIdKeynaturalShiftRNamenaturalSignumIdKeynaturalSignumNamenaturalSizeInBaseIdKeynaturalSizeInBaseNamenaturalSubIdKeynaturalSubNamenaturalSubThrowIdKeynaturalSubThrowNamenaturalSubUnsafeIdKeynaturalSubUnsafeNamenaturalTestBitIdKeynaturalTestBitNamenaturalToDoubleIdKeynaturalToDoubleNamenaturalToFloatIdKeynaturalToFloatNamenaturalToWordClampIdKeynaturalToWordClampNamenaturalToWordIdKeynaturalToWordNamenaturalTyConKeynaturalXorIdKeynaturalXorNamenegateClassOpKey negateNamenewStablePtrIdKeynewStablePtrNamenewStablePtr_RDR nilDataConKeynoMethodBindingErrorIdKey noSelTyConKeynoSelTyConNamenoSourceStrictnessDataConKeynoSourceStrictnessDataConNamenoSourceUnpackednessDataConKeynoSourceUnpackednessDataConName noinlineIdKeynonEmptyDataConKeynonEmptyTyConKeynonExhaustiveGuardsErrorIdKeynotAssocDataCon_RDRnotAssociativeDataConKeynotAssociativeDataConNamenot_RDRnothingDataConKey nullAddrIdKeynull_RDR numClassKey numClassName numClass_RDRnumericClassKeys oneDataConKey oneShotKeyopaqueTyConKeyopaqueTyConName ordClassKey ordClassName ordClass_RDRordEQDataConKeyordEQDataConNameordGTDataConKeyordGTDataConNameordLTDataConKeyordLTDataConNameorderingTyConKeyorderingTyConNameotherwiseIdKeyotherwiseIdNamepLUGINSpRELUDE pRELUDE_NAMEpackageName_RDRpar1DataCon_RDR par1TyConKey par1TyConName parens_RDR patErrorIdKey pfail_RDRpluginTyConKeypluginTyConNameplus_RDRprec_RDRpred_RDRprefixDataCon_RDRprefixIDataConKeyprefixIDataConNamepretendNameIsInScope printIdKey printNameprodDataCon_RDR prodTyConKey prodTyConName proxyHashKeyproxyPrimTyConKey ptrTyConKey ptrTyConNamepunc_RDRpureAClassOpKey pureANamepure_RDRpushCallStackKeypushCallStackName r1DataCon_RDRrANDOM rEAD_PREC rOOT_MAIN rTyConKey rTyConNameraiseDivZeroIdKeyraiseOverflowIdKeyraiseUnderflowIdKeyrandomClassKeyrandomClassNamerandomGenClassKeyrandomGenClassName range_RDRratioDataConKeyratioDataConNameratioDataCon_RDR ratioTyConKeyratioTyConNamerationalToDoubleIdKeyrationalToDoubleNamerationalToFloatIdKeyrationalToFloatNamerationalTyConKeyrationalTyConName readClassKey readClassNamereadFieldHash_RDR readField_RDRreadListDefault_RDRreadListPrecDefault_RDRreadListPrec_RDR readList_RDR readPrec_RDRreadSymField_RDR realClassKey realClassNamerealFloatClassKeyrealFloatClassNamerealFracClassKeyrealFracClassNamerealToFracIdKeyrealToFracNamerealWorldPrimIdKeyrealWorldTyConKey rec0TyConKey rec0TyConNamerec1DataCon_RDR rec1TyConKey rec1TyConNamerecConErrorIdKeyrecSelErrorIdKey rep1TyConKey rep1TyConName repTyConKey repTyConName replace_RDR reset_RDR returnIOIdKey returnIOName returnIO_RDRreturnMClassOpKey returnMName returnM_RDRrightAssocDataCon_RDRrightAssociativeDataConKeyrightAssociativeDataConNamerightDataConKeyrightDataConNamerightSectionKey right_RDR rootMainKey runMainIOName runMainKeyrunRWKey runRWNameruntimeErrorIdKeyruntimeRepSimpleDataConKeysruntimeRepTyConKey s1TyConKey s1TyConName sTyConKey sTyConName sYSTEM_IOsappendClassOpKey sappendName selName_RDRselectorClassKeyselectorClassNamesemigroupClassKeysemigroupClassNameseqIdKeysetFieldClassOpKey setFieldName showClassKey showClassNameshowCommaSpace_RDR showParen_RDR showSpace_RDRshowString_RDR showsPrec_RDR shows_RDRsmallArrayPrimTyConKeysmallMutableArrayPrimTyConKeysndIdKeysndNamesomeTypeRepDataConKeysomeTypeRepDataConNamesomeTypeRepTyConKeysomeTypeRepTyConNamesourceLazyDataConKeysourceLazyDataConNamesourceNoUnpackDataConKeysourceNoUnpackDataConNamesourceStrictDataConKeysourceStrictDataConNamesourceUnpackDataConKeysourceUnpackDataConName specTyConKey specTyConNamesrcLocDataConKeysrcLocDataConNamestableNameDataConKeystableNamePrimTyConKeystableNameTyConKeystablePtrPrimTyConKeystablePtrTyConKeystablePtrTyConNamestandardClassKeysstarArrStarArrStarKindRepKeystarArrStarArrStarKindRepNamestarArrStarKindRepKeystarArrStarKindRepNamestarKindRepKeystarKindRepNamestatePrimTyConKeystaticPtrDataConKeystaticPtrDataConNamestaticPtrInfoDataConKeystaticPtrInfoDataConNamestaticPtrInfoTyConKeystaticPtrInfoTyConNamestaticPtrTyConKeystaticPtrTyConNamestep_RDRstringTyConKeysucc_RDRsumRepDataConKey sumTyConKey sumTyConName symbol_RDRtVarPrimTyConKeytYPEABLEtYPEABLE_INTERNAL tYPETyConKeytcQual tcQual_RDRthenAClassOpKey thenAName thenIOIdKey thenIONamethenMClassOpKey thenMNamethreadIdPrimTyConKey times_RDRto1_RDRtoAnnotationWrapperIdKeytoAnnotationWrapperName toDynIdKey toDynName toEnum_RDRtoIntegerClassOpKey toIntegerName toInteger_RDRtoListClassOpKey toListName toList_RDRtoRationalClassOpKeytoRationalNametoRational_RDRto_RDRtr'PtrRepLiftedKeytrGhcPrimModuleKeytrGhcPrimModuleNametrLiftedRepKeytrModuleDataConKeytrModuleDataConNametrModuleTyConKeytrModuleTyConNametrNameDDataConKeytrNameDDataConNametrNameSDataConKeytrNameSDataConNametrNameTyConKeytrNameTyConNametrRuntimeRepKeytrTYPE'PtrRepLiftedKey trTYPEKeytrTyConDataConKeytrTyConDataConNametrTyConTyConKeytrTyConTyConNametraceKey traceNametraversableClassKeytraversableClassName traverse_RDRtrueDataConKeytupleRepDataConKeytypeCharCmpTyFamNameKeytypeCharKindConNameKeytypeCharToNatTyFamNameKeytypeCharTypeRepKeytypeCharTypeRepName typeConKeytypeConsSymbolTyFamNameKeytypeErrorAppendDataConKeytypeErrorAppendDataConNametypeErrorIdKeytypeErrorShowTypeDataConKeytypeErrorShowTypeDataConNametypeErrorTextDataConKeytypeErrorTextDataConNametypeErrorVAppendDataConKeytypeErrorVAppendDataConNametypeLeqCharTyFamNameKeytypeLitCharDataConKeytypeLitCharDataConNametypeLitNatDataConKeytypeLitNatDataConNametypeLitSortTyConKeytypeLitSortTyConNametypeLitSymbolDataConKeytypeLitSymbolDataConNametypeNatAddTyFamNameKeytypeNatCmpTyFamNameKeytypeNatDivTyFamNameKeytypeNatExpTyFamNameKeytypeNatLogTyFamNameKeytypeNatModTyFamNameKeytypeNatMulTyFamNameKeytypeNatSubTyFamNameKeytypeNatToCharTyFamNameKeytypeNatTypeRepKeytypeNatTypeRepName typeRepIdKey typeRepIdNametypeRepTyConKeytypeRepTyConNametypeSymbolAppendFamNameKeytypeSymbolCmpTyFamNameKeytypeSymbolKindConNameKeytypeSymbolTypeRepKeytypeSymbolTypeRepNametypeUnconsSymbolTyFamNameKeytypeableClassKeytypeableClassName u1DataCon_RDR u1TyConKey u1TyConNameuAddrDataCon_RDR uAddrHash_RDR uAddrTyConKeyuAddrTyConNameuCharDataCon_RDR uCharHash_RDR uCharTyConKeyuCharTyConNameuDoubleDataCon_RDRuDoubleHash_RDRuDoubleTyConKeyuDoubleTyConNameuFloatDataCon_RDRuFloatHash_RDRuFloatTyConKeyuFloatTyConNameuIntDataCon_RDR uIntHash_RDR uIntTyConKey uIntTyConName uNSAFE_COERCE uRecTyConKey uRecTyConNameuWordDataCon_RDR uWordHash_RDR uWordTyConKeyuWordTyConName unComp1_RDRunK1_RDR unPar1_RDR unRec1_RDR unboundKeyunknown1TyConKeyunknown2TyConKeyunknown3TyConKeyunknownTyConKeyunliftedDataConKeyunliftedRepTyConKeyunliftedTypeKindTyConKeyunpackCStringAppendIdKeyunpackCStringFoldrIdKeyunpackCStringFoldrNameunpackCStringFoldrUtf8IdKeyunpackCStringFoldrUtf8NameunpackCStringFoldrUtf8_RDRunpackCStringFoldr_RDRunpackCStringIdKeyunpackCStringNameunpackCStringUtf8IdKeyunpackCStringUtf8NameunpackCStringUtf8_RDRunpackCString_RDRunrestrictedFunTyConKeyunsafeCoercePrimIdKeyunsafeCoercePrimNameunsafeEqualityProofIdKeyunsafeEqualityProofNameunsafeEqualityTyConKeyunsafeEqualityTyConNameunsafeIndex_RDRunsafeRangeSize_RDRunsafeReflDataConKeyunsafeReflDataConName v1TyConKey v1TyConNamevarQual varQual_RDRvecCountDataConKeysvecCountTyConKeyvecElemDataConKeysvecElemTyConKeyvecRepDataConKey voidArgIdKey voidPrimIdKeyweakPrimTyConKey wildCardKey wildCardNameword16PrimTyConKeyword16TyConKeyword16TyConNameword16X16PrimTyConKeyword16X32PrimTyConKeyword16X8PrimTyConKeyword32PrimTyConKeyword32TyConKeyword32TyConNameword32X16PrimTyConKeyword32X4PrimTyConKeyword32X8PrimTyConKeyword64PrimTyConKeyword64TyConKeyword64TyConNameword64X2PrimTyConKeyword64X4PrimTyConKeyword64X8PrimTyConKeyword8DataConKeyword8PrimTyConKey word8TyConKeyword8TyConNameword8X16PrimTyConKeyword8X32PrimTyConKeyword8X64PrimTyConKeywordDataConKeywordPrimTyConKey wordTyConKeyzipIdKeyzipName algTyConRhsexpandSynTyCon_maybefamTyConFlav_maybeisAbstractTyCon isAlgTyConisBoxedTupleTyConisBuiltInSynFamTyCon_maybe isClassTyCon%isClosedSynFamilyTyConWithAxiom_maybeisConstraintKindConisDataFamilyTyCon isDataTyConisEnumerationTyConisFamFreeTyConisFamInstTyCon isFamilyTyConisForgetfulSynTyConisGadtSyntaxTyCon isGcPtrRepisGenInjAlgRhsisGenerativeTyConisImplicitTyConisInjectiveTyConisInvisibleTyConBinder isKindTyConisLiftedAlgTyConisLiftedTypeKindTyConNameisNamedTyConBinder isNewTyCon isNoParentisOpenFamilyTyConisOpenTypeFamilyTyCon isPrimTyConisPromotedDataConisPromotedDataCon_maybeisPromotedTupleTyCon isTauTyCon isTcLevPoly isTcTyCon isTyConAssocisTyConWithSrcDataConsisTypeFamilyTyConisTypeSynonymTyConisUnboxedSumTyConisUnliftedTyConisVanillaAlgTyConisVisibleTyConBinder isVoidReplookupTyConFieldLabel mkAlgTyConmkAnonTyConBindermkAnonTyConBinders mkClassTyConmkDataTyConRhs mkFamilyTyCon mkFunTyCon mkKindTyConmkLiftedPrimTyConmkNamedTyConBindermkNamedTyConBinders mkPrimTyConmkPromotedDataConmkRequiredTyConBinder mkSumTyConmkSynonymTyCon mkTcTyCon mkTupleTyCon mkTyConKind mkTyConTagMapmustBeSaturated newTyConConewTyConCo_maybenewTyConDataCon_maybenewTyConEtadAritynewTyConEtadRhs newTyConRhsnoTcTyConScopedTyVarspprPromotionQuoteprimElemRepSizeBprimRepCompatibleprimRepIsFloat primRepSizeBprimRepsCompatiblesetTcTyConKindsynTyConDefn_maybesynTyConRhs_maybetcFlavourIsOpentyConATstyConAlgDataCons_maybetyConAssoc_maybetyConBinderArgFlagtyConBndrVisArgFlagtyConCType_maybetyConClass_maybe tyConDataConstyConDataCons_maybetyConFamInstSig_maybetyConFamInst_maybetyConFamilyCoercion_maybetyConFamilyResVar_maybetyConFamilySizetyConFieldLabels tyConFlavourtyConFlavourAssoc_maybetyConInjectivityInfotyConInvisTVBinderstyConRepModOcc tyConRolestyConRuntimeRepInfotyConSingleAlgDataCon_maybetyConSingleDataContyConSingleDataCon_maybe tyConSkolemtyConStupidThetatyConTuple_maybetyConVisibleTyVarsunwrapNewTyConEtad_maybeunwrapNewTyCon_maybevisibleDataCons AlgTyConFlav ClassTyConDataFamInstTyConUnboxedAlgTyConVanillaAlgTyCon AlgTyConRhs AbstractTyCon DataTyConNewTyConSumTyCon TupleTyCondata_con data_consdata_cons_sizeis_enumnt_co nt_etad_rhs nt_lev_polynt_rhstup_sort FamTyConFlavAbstractClosedSynFamilyTyConBuiltInSynFamTyConClosedSynFamilyTyConDataFamilyTyConOpenSynFamilyTyCon Injectivity Injective NotInjective PrimElemRep DoubleElemRep FloatElemRep Int16ElemRep Int32ElemRep Int64ElemRep Int8ElemRep Word16ElemRep Word32ElemRep Word64ElemRep Word8ElemRepPrimRepAddrRep DoubleRepFloatRepInt16RepInt32RepInt64RepInt8RepIntRep LiftedRep UnliftedRepVecRepVoidRep Word16Rep Word32Rep Word64RepWord8RepWordRepRuntimeRepInfo LiftedInfoNoRRI RuntimeRep UnliftedInfoVecCountVecElem algTcFields famTcResVar tcTyConIsPolytcTyConScopedTyVars tyConArity tyConBinders tyConCType tyConKindtyConNullaryTy tyConResKind tyConTyVars tyConUnique TyConBinder TyConBndrVisAnonTCBNamedTCB TyConFlavourAbstractTypeFlavourBuiltInTypeFlavour ClassFlavourClosedTypeFamilyFlavourDataFamilyFlavourDataTypeFlavourNewtypeFlavourOpenTypeFamilyFlavourPromotedDataConFlavour SumFlavour TupleFlavourTypeSynonymFlavourTyConTyCoBinder$fBinaryInjectivity$fBinaryTyConBndrVis $fDataTyCon$fEqInjectivity$fEqPrimElemRep $fEqPrimRep $fEqTyCon$fEqTyConFlavour$fNamedThingTyCon$fOutputableAlgTyConFlav$fOutputableFamTyConFlav$fOutputablePrimElemRep$fOutputablePrimRep$fOutputableTyCon$fOutputableTyConBndrVis$fOutputableTyConFlavour$fShowPrimElemRep $fShowPrimRep$fUniquableTyConappArgsIfaceTypesappArgsIfaceTypesArgFlagsifForAllBndrNameifForAllBndrVarifTyConBinderNameifTyConBinderVar ifaceBndrNameifaceForAllSpecToBndrifaceForAllSpecToBndrsinDomIfaceTySubstisIfaceLiftedTypeKindisIfaceTauTypemany_tymkIfaceForAllTvBndrmkIfaceTyConInfomkIfaceTyConKindmkIfaceTySubstpprIfaceAppArgs pprIfaceBndrspprIfaceCoTcApppprIfaceCoercionpprIfaceContextpprIfaceContextArrpprIfaceForAllpprIfaceForAllPartpprIfaceForAllPartMustpprIfaceIdBndrpprIfaceLamBndrpprIfacePrefixApppprIfaceSigmaTypepprIfaceTvBndrpprIfaceTyConBinders pprIfaceTyLit pprIfaceTypepprIfaceTypeApppprParendIfaceAppArgspprParendIfaceCoercionpprParendIfaceTypepprPrecIfaceType pprTyTcApppprUserIfaceForAll ppr_fun_arrowsplitIfaceSigmaTystripIfaceInvisVarsstripInvisArgssubstIfaceAppArgssubstIfaceTyVarsuppressIfaceInvisibles IfExtName IfLclNameIA_ArgIA_Nil IfaceIdBndr IfaceTvBndr IfaceAppCoIfaceAxiomInstCoIfaceAxiomRuleCo IfaceCoVarCo IfaceForAllCoIfaceFreeCoVar IfaceFunCo IfaceGReflCo IfaceHoleCo IfaceInstCo IfaceKindCo IfaceLRCo IfaceNthCo IfaceReflCo IfaceSubCo IfaceSymCo IfaceTransCoIfaceTyConAppCo IfaceUnivCo IfaceContextIfaceForAllBndrIfaceForAllSpecBndr IfaceKind IfaceLamBndrIfaceMCoercionIfaceMCo IfaceMRefl IfaceMult IfaceOneShotIfaceNoOneShot IfacePredTypeifaceTyConInfoifaceTyConNameIfaceTyConBinderIfaceTyConInfoifaceTyConIsPromotedifaceTyConSortIfaceTyConSortIfaceEqualityTyConIfaceNormalTyCon IfaceSumTyConIfaceTupleTyConIfaceCharTyLit IfaceNumTyLit IfaceStrTyLit IfaceAppTy IfaceCastTyIfaceCoercionTy IfaceForAllTyIfaceFreeTyVar IfaceFunTy IfaceLitTy IfaceTupleTy IfaceTyConApp IfaceTyVarIfaceUnivCoProvIfaceCorePrepProvIfacePhantomProvIfacePluginProvIfaceProofIrrelProvPrintExplicitKindsShowForAllFlagShowForAllMustShowForAllWhenSuppressBndrSig UseBndrParens$fBinaryDefMethSpec$fBinaryIfaceAppArgs$fBinaryIfaceBndr$fBinaryIfaceCoercion$fBinaryIfaceMCoercion$fBinaryIfaceOneShot$fBinaryIfaceTyCon$fBinaryIfaceTyConInfo$fBinaryIfaceTyConSort$fBinaryIfaceTyLit$fBinaryIfaceType$fBinaryIfaceUnivCoProv$fEqIfaceTyCon$fEqIfaceTyConInfo$fEqIfaceTyConSort$fEqIfaceTyLit$fMonoidIfaceAppArgs$fSemigroupIfaceAppArgs$fNFDataIfaceAppArgs$fNFDataIfaceBndr$fNFDataIfaceCoercion$fNFDataIfaceMCoercion$fNFDataIfaceOneShot$fNFDataIfaceTyCon$fNFDataIfaceTyConInfo$fNFDataIfaceTyConSort$fNFDataIfaceTyLit$fNFDataIfaceType$fNFDataIfaceUnivCoProv$fOutputableIfaceAppArgs$fOutputableIfaceBndr$fOutputableIfaceCoercion$fOutputableIfaceOneShot$fOutputableIfaceTyCon$fOutputableIfaceTyConInfo$fOutputableIfaceTyConSort$fOutputableIfaceTyLit$fOutputableIfaceTypetidyToIfaceTcArgstoIfaceCoercionXtoIfaceForAllBndr toIfaceTcArgs toIfaceTyCon toIfaceTyLit toIfaceTypeXdelFromTyConSetdelListFromTyConSetdisjointTyConSet elemTyConSet emptyTyConSetextendTyConSetextendTyConSetListfilterTyConSetintersectTyConSetintersectsTyConSetisEmptyTyConSet minusTyConSet mkTyConSet unionTyConSetunionTyConSets unitTyConSetTyConSetadjustDTyConEnvalterDTyConEnv alterTyConEnv anyTyConEnvdelFromDTyConEnvdelFromTyConEnvdelListFromTyConEnvdisjointTyConEnv elemTyConEnvemptyDTyConEnv emptyTyConEnvextendDTyConEnvextendTyConEnvextendTyConEnvListextendTyConEnvList_CextendTyConEnv_AccextendTyConEnv_CfilterDTyConEnvfilterTyConEnv foldDTyConEnvisEmptyDTyConEnvisEmptyTyConEnvlookupDTyConEnvlookupTyConEnvlookupTyConEnv_NF mapDTyConEnvmapMaybeDTyConEnv mapTyConEnv mkTyConEnvmkTyConEnvWith plusTyConEnvplusTyConEnv_CplusTyConEnv_CDplusTyConEnv_CD2 unitTyConEnv DTyConEnvTyConEnv checkRecTcdefaultRecTcMaxBound initRecTcsetRecTcMaxBound RecTcChecker$fOutputableRecTcCheckercmpTyLit coHoleCoVar coercionSize delBinderVarfoldTyCoisInvisibleBinder isNamedBinder isTyBinderisVisibleBinder mapScaledType mkForAllTysmkFunTymkInvisForAllTys mkInvisFunTymkInvisFunTyManymkInvisFunTysManymkPiTymkPiTys mkScaledFunTy mkTyCoVarTy mkTyCoVarTys mkTyVarTy mkTyVarTys mkVisFunTymkVisFunTyMany mkVisFunTysmkVisFunTysManynonDetCmpTyLitprovSize scaledMult scaledThingsetCoHoleCoVartypeSizeAppCo AxiomInstCo AxiomRuleCoCoVarCoForAllCoFunCoGReflHoleCoInstCoKindCoLRCoNthCoReflSubCoSymCoTransCo TyConAppCoUnivCo CoercionHole ch_co_varch_ref CoercionP CoercionR KindCoercion KindOrTypeKnotTiedMCoMRefl MCoercionRTyBinderAnonNamed TyCoFolder tcf_covartcf_holetcf_tycobinder tcf_tyvartcf_view CharTyLitNumTyLitStrTyLitAppTyCastTy CoercionTyForAllTyFunTyLitTyTyConAppTyVarTyft_afft_argft_multft_res CorePrepProv PhantomProv PluginProvProofIrrelProv$fDataCoercion$fDataCoercionHole$fDataMCoercion $fDataScaled $fDataType$fDataTyCoBinder $fDataTyLit$fDataUnivCoProvenance $fEqTyLit$fOutputableCoercion$fOutputableCoercionHole$fOutputableMCoercion$fOutputableScaled$fOutputableTyCoBinder$fOutputableTyLit$fOutputableType$fOutputableUnivCoProvenance$fUniquableCoercionHolealmostDevoidCoVarOfCoanyFreeVarsOfCoanyFreeVarsOfTypeanyFreeVarsOfTypescloseOverKindscloseOverKindsDSetcloseOverKindsList coVarsOfCo coVarsOfCos coVarsOfType coVarsOfTypes deepTcvFolderinjectiveVarsOfTypeinjectiveVarsOfTypesinvisibleVarsOfTypeinvisibleVarsOfTypesnoFreeVarsOfConoFreeVarsOfTypenoFreeVarsOfTypes runTyCoVars scopedSortshallowTyCoVarsOfCoshallowTyCoVarsOfCoVarEnvshallowTyCoVarsOfCosshallowTyCoVarsOfTyVarEnvshallowTyCoVarsOfTypeshallowTyCoVarsOfTypes tyCoFVsBndr tyCoFVsOfCo tyCoFVsOfCos tyCoFVsOfTypetyCoFVsOfTypestyCoFVsVarBndrtyCoFVsVarBndrs tyCoVarsOfCotyCoVarsOfCoDSettyCoVarsOfCoList tyCoVarsOfCos tyCoVarsOfMCotyCoVarsOfTypetyCoVarsOfTypeDSettyCoVarsOfTypeListtyCoVarsOfTypeWellScopedtyCoVarsOfTypestyCoVarsOfTypesDSettyCoVarsOfTypesListtyCoVarsOfTypesWellScopedavoidNameClashestidyCotidyCostidyFreeTyCoVarstidyKind tidyOpenKindtidyOpenTyCoVartidyOpenTyCoVars tidyOpenType tidyOpenTypes tidyTopTypetidyTyCoVarBindertidyTyCoVarBinderstidyTyCoVarOcctidyType tidyTypes tidyVarBndr tidyVarBndrscheckValidSubstcloneTyVarBndrcloneTyVarBndrscomposeTCvSubstcomposeTCvSubstEnv elemTCvSubstemptyCvSubstEnv emptyTCvSubstemptyTvSubstEnv extendCvSubstextendCvSubstWithCloneextendTCvInScopeextendTCvInScopeListextendTCvInScopeSetextendTCvSubstextendTCvSubstListextendTCvSubstWithClone extendTvSubstextendTvSubstAndInScopeextendTvSubstBinderAndInScopeextendTvSubstListextendTvSubstWithClone getCvSubstEnv getTCvInScopegetTCvSubstRangeFVs getTvSubstEnvisEmptyTCvSubst isInScopeisValidTCvSubst lookupCoVar lookupTyVar mkCvSubstmkEmptyTCvSubst mkTCvSubst mkTvSubst mkTvSubstPrsnotElemTCvSubst setCvSubstEnv setTvSubstEnvsubstCosubstCoUnchecked substCoVarsubstCoVarBndr substCoVars substCoWithsubstCoWithUncheckedsubstCossubstForAllCoBndrsubstForAllCoBndrUsing substScaledTysubstScaledTyUncheckedsubstScaledTyssubstScaledTysUnchecked substThetasubstThetaUncheckedsubstTyAddInScope substTyCoBndr substTyCoVarssubstTyUnchecked substTyVarsubstTyVarBndrsubstTyVarBndrs substTyVars substTyWithsubstTyWithCoVarssubstTyWithInScopesubstTyWithUncheckedsubstTyssubstTysUnchecked substTysWithsubstTysWithCoVars substVarBndrsubstVarBndrUsing substVarBndrs unionTCvSubst zapTCvSubstzipCoEnv zipCvSubst zipTCvSubst zipTvSubstzipTyEnv CvSubstEnvTCvSubst TvSubstEnv$fOutputableTCvSubstallPhasesDataConKeyallPhasesDataConNameanyclassStrategyIdKeyanyclassStrategyName appEIdKeyappENameappE_RDR appKindTIdKey appKindTName appTIdKeyappTName appTypeEIdKey appTypeEName arrowTIdKey arrowTNameasPIdKeyasPName bangIdKeybangName bangPIdKey bangPNamebangTKey bangTypeNamebangTypeTyConKeybangTypeTyConNamebeforePhaseDataConKeybeforePhaseDataConName bindQIdKey bindQName bindSIdKey bindSName cApiCallIdKey cApiCallName cCallIdKey cCallName caseEIdKey caseEName charLIdKey charLNamecharPrimLIdKey charPrimLName charPrimL_RDRcharTyLitIdKey charTyLitName classDIdKey classDName clauseIdKey clauseNameclauseTyConKeyclauseTyConNameclosedTypeFamilyDIdKeyclosedTypeFamilyDName codeTyConKey codeTyConName compEIdKey compEName conEIdKeyconENameconE_RDRconLikeDataConKeyconLikeDataConName conPIdKeyconPName conTIdKeyconTName conTyConKey conTyConName condEIdKey condENameconstraintKIdKeyconstraintKNamecxtIdKeycxtName dataDIdKey dataDNamedataFamilyDIdKeydataFamilyDNamedataInstDIdKey dataInstDName decTyConKey decTyConName decsQTyConKeydecsQTyConName decsTyConKey decsTyConNamedefaultSigDIdKeydefaultSigDNamederivClauseIdKeyderivClauseNamederivClauseTyConKeyderivClauseTyConNamederivStrategyTyConKeyderivStrategyTyConNamedoEIdKeydoENamedoublePrimLIdKeydoublePrimLNamedoublePrimL_RDRequalityTIdKey equalityTName expQTyConKey expQTyConName expTyConKey expTyConNameexplBidirPatSynIdKeyexplBidirPatSynName fieldExpIdKey fieldExpNamefieldExpTyConKeyfieldExpTyConName fieldPatIdKey fieldPatNamefieldPatTyConKeyfieldPatTyConNamefloatPrimLIdKeyfloatPrimLNamefloatPrimL_RDR forImpDIdKey forImpDName forallCIdKey forallCName forallTIdKey forallTNameforallVisTIdKeyforallVisTName fromEIdKey fromENamefromPhaseDataConKeyfromPhaseDataConNamefromThenEIdKey fromThenENamefromThenToEIdKeyfromThenToEName fromToEIdKey fromToEName funDIdKeyfunDName funDepIdKey funDepNamefunDepTyConKeyfunDepTyConNamefunLikeDataConKeyfunLikeDataConName gadtCIdKey gadtCNamegetFieldEIdKey getFieldEName guardedBIdKey guardedBNameimplBidirPatSynIdKeyimplBidirPatSynNameimplicitParamBindDIdKeyimplicitParamBindDNameimplicitParamTIdKeyimplicitParamTNameimplicitParamVarEIdKeyimplicitParamVarENameincoherentDataConKeyincoherentDataConName inferRIdKey inferRNameinferredSpecKeyinferredSpecName infixAppIdKey infixAppName infixApp_RDR infixCIdKey infixCName infixEIdKey infixEName infixLDIdKey infixLDName infixNDIdKey infixNDName infixPIdKey infixPNameinfixPatSynIdKeyinfixPatSynName infixRDIdKey infixRDName infixTIdKey infixTNameinjAnnTyConKeyinjAnnTyConNameinjectivityAnnIdKeyinjectivityAnnNameinlinableDataConKeyinlinableDataConNameinlineDataConKeyinlineDataConNameinstanceDIdKeyinstanceWithOverlapDIdKeyinstanceWithOverlapDName intPrimLIdKey intPrimLName intPrimL_RDR integerLIdKey integerLNameinterruptibleIdKeyinterruptibleNamejavaScriptCallIdKeyjavaScriptCallName kiSigDIdKey kiSigDName kindSigIdKey kindSigName kindTyConKey kindTyConNamekindedInvisTVIdKeykindedInvisTVName kindedTVIdKey kindedTVName labelEIdKey labelEName lamCaseEIdKey lamCaseEName lamEIdKeylamEName letEIdKeyletEName letSIdKeyletSNamelibFunlibTc liftClassKey liftClassName liftIdKeyliftNameliftStringIdKeyliftStringNameliftTypedIdKey liftTypedName liftTyped_RDRlift_RDR listEIdKey listEName listPIdKey listPName listTIdKey listTName litEIdKeylitENamelitE_RDR litPIdKeylitPName litTIdKeylitTName matchIdKey matchName matchTyConKeymatchTyConName mdoEIdKeymdoENamemkModNameIdKey mkModNameNamemkNameG_dIdKey mkNameG_dName mkNameG_dRDRmkNameG_tcIdKeymkNameG_tcNamemkNameG_vIdKey mkNameG_vName mkNameG_vRDR mkNameIdKey mkNameLIdKey mkNameLName mkNameName mkNameSIdKey mkNameSName mkTHModulemodNameTyConKeymodNameTyConNamemoduleAnnotationIdKeymoduleAnnotationNamemulArrowTIdKey mulArrowTName multiIfEIdKey multiIfEName nameTyConKey nameTyConName newNameIdKey newNameName newtypeDIdKey newtypeDNamenewtypeInstDIdKeynewtypeInstDNamenewtypeStrategyIdKeynewtypeStrategyName noBindSIdKey noBindSNamenoInlineDataConKeynoInlineDataConName noSigIdKey noSigNamenoSourceStrictnessKeynoSourceStrictnessNamenoSourceUnpackednessKeynoSourceUnpackednessName nominalRIdKey nominalRName normalBIdKey normalBName normalCIdKey normalCName normalGEIdKey normalGEName numTyLitIdKey numTyLitNameopenTypeFamilyDIdKeyopenTypeFamilyDNameoverlapTyConKeyoverlapTyConNameoverlappableDataConKeyoverlappableDataConNameoverlappingDataConKeyoverlappingDataConNameoverlapsDataConKeyoverlapsDataConName parSIdKeyparSName patGEIdKey patGEName patQTyConKey patQTyConName patSynDIdKey patSynDNamepatSynSigDIdKeypatSynSigDName patTyConKey patTyConName phantomRIdKey phantomRNameplainInvisTVIdKeyplainInvisTVName plainTVIdKey plainTVName pragAnnDIdKey pragAnnDNamepragCompleteDIdKeypragCompleteDName pragInlDIdKey pragInlDNamepragRuleDIdKey pragRuleDNamepragSpecDIdKey pragSpecDNamepragSpecInlDIdKeypragSpecInlDNamepragSpecInstDIdKeypragSpecInstDName predQTyConKey predTyConKey predTyConNameprefixPatSynIdKeyprefixPatSynName primCallIdKey primCallNameprojectionEIdKeyprojectionENamepromotedConsTIdKeypromotedConsTNamepromotedNilTIdKeypromotedNilTNamepromotedTIdKey promotedTNamepromotedTupleTIdKeypromotedTupleTName qTyConKey qTyConNameqqFunqqLib quoteClassKeyquoteClassName quoteDecKey quoteDecName quoteExpKey quoteExpName quotePatKey quotePatName quoteTypeKey quoteTypeNamerationalLIdKey rationalLName recCIdKeyrecCName recConEIdKey recConEName recGadtCIdKey recGadtCName recPIdKeyrecPName recSIdKeyrecSName recUpdEIdKey recUpdENamerecordPatSynIdKeyrecordPatSynNamerepresentationalRIdKeyrepresentationalRName returnQIdKey returnQNameroleAnnotDIdKeyroleAnnotDName roleTyConKey roleTyConNameruleBndrTyConKeyruleBndrTyConName ruleVarIdKey ruleVarName safeIdKeysafeName sectionLIdKey sectionLName sectionRIdKey sectionRNamesequenceQIdKey sequenceQName sigDIdKeysigDName sigEIdKeysigEName sigPIdKeysigPName sigTIdKeysigTName sourceLazyKeysourceLazyNamesourceNoUnpackKeysourceNoUnpackNamesourceStrictKeysourceStrictNamesourceUnpackKeysourceUnpackNamespecifiedSpecKeyspecifiedSpecName!standaloneDerivWithStrategyDIdKey standaloneDerivWithStrategyDName starKIdKey starKName staticEIdKey staticEName stdCallIdKey stdCallName stmtTyConKey stmtTyConNamestockStrategyIdKeystockStrategyName strTyLitIdKey strTyLitName stringLIdKey stringLName stringL_RDRstringPrimLIdKeystringPrimLNamestringPrimL_RDRtemplateHaskellNamesthClsthConthFunthLibthSynthTc tildePIdKey tildePName tupEIdKeytupEName tupPIdKeytupPName tupleTIdKey tupleTName tySynDIdKey tySynDName tySynEqnIdKey tySynEqnNametySynEqnTyConKeytySynEqnTyConNametySynInstDIdKeytySynInstDNametyVarBndrSpecTyConKeytyVarBndrSpecTyConNametyVarBndrUnitTyConKeytyVarBndrUnitTyConName tyVarSigIdKey tyVarSigNametypeAnnotationIdKeytypeAnnotationName typeQTyConKeytypeQTyConName typeTyConKey typeTyConNametypedRuleVarIdKeytypedRuleVarNameunTypeCodeIdKeyunTypeCodeName unTypeIdKey unTypeNameunboundVarEIdKeyunboundVarENameunboxedSumEIdKeyunboxedSumENameunboxedSumPIdKeyunboxedSumPNameunboxedSumTIdKeyunboxedSumTNameunboxedTupEIdKeyunboxedTupENameunboxedTupPIdKeyunboxedTupPNameunboxedTupleTIdKeyunboxedTupleTNameunidirPatSynIdKeyunidirPatSynNameunsafeCodeCoerceIdKeyunsafeCodeCoerceNameunsafeCodeCoerce_RDR unsafeIdKey unsafeName valDIdKeyvalDNamevalueAnnotationIdKeyvalueAnnotationName varBangTKeyvarBangTypeNamevarBangTypeTyConKeyvarBangTypeTyConName varEIdKeyvarEName varPIdKeyvarPName varTIdKeyvarTNameviaStrategyIdKeyviaStrategyName viewPIdKey viewPNamewildCardTIdKey wildCardTName wildPIdKey wildPNamewordPrimLIdKey wordPrimLName wordPrimL_RDR addrPrimTy addrPrimTyConaddrPrimTyConNamealphaTyalphaTyUnliftedRep alphaTyVaralphaTyVarUnliftedRep alphaTyVarsalphaTyVarsUnliftedRepalphaTysalphaTysUnliftedReparrayArrayPrimTyConarrayPrimTyCon bcoPrimTy bcoPrimTyConbetaTy betaTyVarbyteArrayPrimTybyteArrayPrimTyCon charPrimTy charPrimTyConcharPrimTyConName compactPrimTycompactPrimTyCondeltaTy deltaTyVar doublePrimTydoublePrimTyCondoublePrimTyConNamedoubleX2PrimTydoubleX2PrimTyCondoubleX4PrimTydoubleX4PrimTyCondoubleX8PrimTydoubleX8PrimTyConeqPhantPrimTyCon eqPrimTyConeqReprPrimTyCon equalityTyConexposedPrimTyCons floatPrimTyfloatPrimTyConfloatPrimTyConNamefloatX16PrimTyfloatX16PrimTyCon floatX4PrimTyfloatX4PrimTyCon floatX8PrimTyfloatX8PrimTyCon funTyConNamefunctionWithMultiplicitygammaTy gammaTyVar int16PrimTyint16PrimTyConint16PrimTyConNameint16X16PrimTyint16X16PrimTyConint16X32PrimTyint16X32PrimTyCon int16X8PrimTyint16X8PrimTyCon int32PrimTyint32PrimTyConint32PrimTyConNameint32X16PrimTyint32X16PrimTyCon int32X4PrimTyint32X4PrimTyCon int32X8PrimTyint32X8PrimTyCon int64PrimTyint64PrimTyConint64PrimTyConName int64X2PrimTyint64X2PrimTyCon int64X4PrimTyint64X4PrimTyCon int64X8PrimTyint64X8PrimTyCon int8PrimTy int8PrimTyConint8PrimTyConName int8X16PrimTyint8X16PrimTyCon int8X32PrimTyint8X32PrimTyCon int8X64PrimTyint8X64PrimTyCon intPrimTy intPrimTyConintPrimTyConNameioPortPrimTyCon mVarPrimTyConmkArrayArrayPrimTy mkArrayPrimTymkIOPortPrimTy mkMVarPrimTymkMutVarPrimTymkMutableArrayArrayPrimTymkMutableArrayPrimTymkMutableByteArrayPrimTymkPrimTyConName mkProxyPrimTymkSmallArrayPrimTymkSmallMutableArrayPrimTymkStableNamePrimTymkStablePtrPrimTy mkStatePrimTy mkTVarPrimTymkTemplateAnonTyConBindersmkTemplateKiTyVarmkTemplateKiTyVarsmkTemplateKindTyConBindersmkTemplateKindVarsmkTemplateTyConBindersmkTemplateTyVarsmkTemplateTyVarsFrom mkWeakPrimTymultiplicityTyVar1multiplicityTyVar2mutVarPrimTyConmutableArrayArrayPrimTyConmutableArrayPrimTyConmutableByteArrayPrimTyCon openAlphaTyopenAlphaTyVar openBetaTy openBetaTyVar openGammaTyopenGammaTyVarprimRepToRuntimeRep primTyConsproxyPrimTyConrealWorldStatePrimTy realWorldTyrealWorldTyCon runtimeRep1TyruntimeRep1TyVar runtimeRep2TyruntimeRep2TyVar runtimeRep3TyruntimeRep3TyVarsmallArrayPrimTyConsmallMutableArrayPrimTyConstableNamePrimTyConstablePtrPrimTyConstatePrimTyCon tVarPrimTyCon tYPETyCon tYPETyConNamethreadIdPrimTythreadIdPrimTyConunexposedPrimTyCons weakPrimTyCon word16PrimTyword16PrimTyConword16PrimTyConNameword16X16PrimTyword16X16PrimTyConword16X32PrimTyword16X32PrimTyConword16X8PrimTyword16X8PrimTyCon word32PrimTyword32PrimTyConword32PrimTyConNameword32X16PrimTyword32X16PrimTyConword32X4PrimTyword32X4PrimTyConword32X8PrimTyword32X8PrimTyCon word64PrimTyword64PrimTyConword64PrimTyConNameword64X2PrimTyword64X2PrimTyConword64X4PrimTyword64X4PrimTyConword64X8PrimTyword64X8PrimTyCon word8PrimTyword8PrimTyConword8PrimTyConNameword8X16PrimTyword8X16PrimTyConword8X32PrimTyword8X32PrimTyConword8X64PrimTyword8X64PrimTyCon wordPrimTy wordPrimTyConwordPrimTyConNameManyOne appTyArgFlags applyTysXbinderRelevantType_maybe buildSynTyConclassifiesTypeWithValues coAxNthLHS dropForAllsdropRuntimeRepArgseqTypeeqTypeXeqTypes eqVarBndrsfilterOutInferredTypesfilterOutInvisibleTypesfunArgTy funResultTygetCastedTyVar_maybe getRuntimeRepgetRuntimeRep_maybegetTyVargetTyVar_maybeinvisibleTyBndrCountirrelevantMult isAlgTypeisAnonTyCoBinder isAtomicTyisBoxedRuntimeRep isBoxedTypeisBoxedTypeKind isCharLitTy isCoVarTypeisCoercionTy_maybeisDataFamilyAppType isFamFreeTy isForAllTy isForAllTy_co isForAllTy_tyisFunTy isKindLevPoly isLevityTy isLevityVarisLiftedLevityisLiftedRuntimeRepisLiftedType_maybe isLinearTypeisLitTyisManyDataConTyisMultiplicityVar isNumLitTyisOneDataConTyisPiTyisPrimitiveTypeisRuntimeRepKindedTyisRuntimeRepVar isStrLitTy isStrictTypeisTauTy isTyVarTy isTypeLevPolyisUnboxedSumTypeisUnboxedTupleTypeisUnliftedLevityisUnliftedRuntimeRepisUnliftedTypeisUnliftedTypeKindisValidJoinPointTypekindRep kindRep_maybelinearmapTyComapTyCoXmightBeUnliftedType mkAnonBindermkAppTys mkCharLitTy mkCoercionTymkFamilyTyConApp mkInfForAllTymkInfForAllTys mkNumLitTymkScaledmkSpecForAllTymkSpecForAllTys mkStrLitTymkTyCoInvForAllTymkTyCoInvForAllTysmkTyConBindersPreferAnonmkVisForAllTysnewTyConInstRhs nonDetCmpTc nonDetCmpTypenonDetCmpTypeXnonDetCmpTypesnonDetCmpTypesXoccCheckExpandpartitionInvisibles piResultTyspickyIsLiftedTypeKindpprUserTypeErrorTyrepGetTyVar_mayberepSplitAppTy_mayberepSplitAppTysrepSplitTyConApp_mayberesultIsLevPoly scaledSetseqTypeseqTypes splitAppTysplitAppTy_maybe splitAppTyssplitCastTy_maybesplitForAllCoVar_maybesplitForAllInvisTVBinderssplitForAllReqTVBinderssplitForAllTyCoVarsplitForAllTyCoVarBinderssplitForAllTyCoVar_maybesplitForAllTyCoVarssplitForAllTyVar_maybe splitFunTysplitFunTy_maybe splitFunTyssplitInvisPiTyssplitInvisPiTysNsplitListTyConApp_maybe splitPiTysplitPiTy_maybe splitPiTys splitTyConAppsplitVisVarsOfTypesplitVisVarsOfTypesstripCoercionTytcIsBoxedTypeKindtcIsConstraintKindtcIsLiftedTypeKindtcIsRuntimeTypeKindtcRepSplitAppTy_maybetcRepSplitTyConApp_maybetcReturnsConstraintKindtcSplitTyConApp_maybe tcTypeKind tyBinderTypetyCoBinderTypetyCoBinderVar_maybe tyConAppArgN tyConAppArgstyConAppArgs_maybetyConAppNeedsKindSig tyConAppTyContyConAppTyConPicky_maybe tyConArgFlagstyConBindersTyCoBinders tyConsOfTypetymulttypeKind unrestricteduserTypeError_maybe TyCoMapper tcm_covartcm_holetcm_tycobinder tcm_tycon tcm_tyvar$fBoundedTypeOrdering$fEnumTypeOrdering$fEqTypeOrdering$fOrdTypeOrderingabsentLiteralOf charToIntLitconvertToIntLitconvertToWordLitdoubleToFloatLitdoubleToIntLitfloatToDoubleLit floatToIntLit inCharRange intToCharLitintToDoubleLit intToFloatLitisLitValue_maybe isMaxBound isMinBoundisOneLit isRubbishLit isZeroLit litFitsInChar litIsDupable litIsLifted litIsTrivial litNumBitSizelitNumCheckRange litNumCoercelitNumIsSigned litNumNarrow litNumWraplitValue literalType mapLitValue mkLitChar mkLitDouble mkLitFloatmkLitInt mkLitInt16mkLitInt16Wrap mkLitInt32mkLitInt32Wrap mkLitInt64mkLitInt64Wrap mkLitInt8 mkLitInt8WrapmkLitIntUnchecked mkLitIntWrap mkLitIntWrapC mkLitInteger mkLitNatural mkLitNumbermkLitNumberWrap mkLitString mkLitWord mkLitWord16mkLitWord16Wrap mkLitWord32mkLitWord32Wrap mkLitWord64mkLitWord64Wrap mkLitWord8mkLitWord8Wrap mkLitWordWrapmkLitWordWrapCnarrowInt16LitnarrowInt32LitnarrowInt64Lit narrowInt8LitnarrowWord16LitnarrowWord32LitnarrowWord64LitnarrowWord8Lit nullAddrLit pprLiteral rubbishLit LitNumType LitNumInt LitNumInt16 LitNumInt32 LitNumInt64 LitNumInt8 LitNumInteger LitNumNatural LitNumWord LitNumWord16 LitNumWord32 LitNumWord64 LitNumWord8LiteralLitChar LitDoubleLitFloatLitLabel LitNullAddr LitNumber LitRubbish LitString$fBinaryLitNumType$fBinaryLiteral$fDataLitNumType $fDataLiteral$fEnumLitNumType$fEqLitNumType $fEqLiteral$fOrdLitNumType $fOrdLiteral$fOutputableLiteral>.>deleteTMfdG filterMaybe foldMapTM foldMaybeinsertTM isEmptyTMlkGlkListmapGxtGxtList|>|>>GenMapListMap LiteralMapMaybeMapTrieMapKeyalterTMemptyTMfilterTMfoldTMlookupTMmapTMXT$fFoldableGenMap$fTrieMapGenMap$fFoldableListMap$fTrieMapListMap$fFoldableMaybeMap$fTrieMapMaybeMap$fOutputableGenMap$fOutputableListMap$fTrieMapIntMap $fTrieMapMap$fTrieMapUniqDFM lookupFact mkHooplLabelFactBaseLabelLabelMapLabelSet $fEqLabel $fEqLabelMap $fEqLabelSet$fFoldableLabelMap$fFunctorLabelMap$fIsMapLabelMap$fIsSetLabelSet$fMonoidLabelSet$fSemigroupLabelSet $fOrdLabel $fOrdLabelMap $fOrdLabelSet$fOutputableLabel$fOutputableLabelMap$fOutputableLabelSet$fOutputablePenvLabel$fOutputablePenvLabelMap $fShowLabel$fShowLabelMap$fShowLabelSet$fTraversableLabelMap$fTrieMapLabelMap$fUniquableLabelbackendSupportsSwitchcreateSwitchPlaneqSwitchTargetWithmapSwitchTargetsmkSwitchTargetsswitchTargetsCasesswitchTargetsDefaultswitchTargetsFallThroughswitchTargetsRangeswitchTargetsSignedswitchTargetsToListswitchTargetsToTable SwitchPlanIfEqualIfLT JumpTableUnconditionally SwitchTargets$fEqSwitchTargets$fShowSwitchPlan$fShowSwitchTargetsaddBlockbodyList emptyBody labelsDefinedmapGraphmapGraphBlocksrevPostorderFromBodyGraph'GManyGNilGUnitNonLocal entryLabel successors$fNonLocalBlock mkBlockIdBlockId debugPprType pprClassPred pprDataCons pprForAll pprParendCo pprParendKindpprParendTheta pprParendType pprPrecType pprPrecTypeX pprSigmaTypepprSourceTyCon pprTCvBndr pprTCvBndrspprThetapprThetaArrowTy pprTidiedType pprTyVars pprTypeApp pprUserForAllpprWithExplicitKindsWhen pprWithTYPEisVanillaPatSynmkPatSyn patSynArgs patSynArity patSynBuilderpatSynExTyVarBinderspatSynExTyVarspatSynFieldLabelspatSynFieldTypepatSynInstArgTyspatSynInstResTy patSynIsInfix patSynMatcher patSynNamepatSynResultType patSynSig patSynSigBndrpatSynUnivTyVarBinders pprPatSynTypePatSyn PatSynBuilder PatSynMatcher $fDataPatSyn $fEqPatSyn$fNamedThingPatSyn$fOutputableBndrPatSyn$fOutputablePatSyn$fUniquablePatSyn isMultMul mkMultAdd mkMultMul mkMultSup scaleScaledsubmult IsSubmultSubmultUnknown $fEqIsSubmult$fOutputableIsSubmult$fShowIsSubmultmkFunctionTypeaddUEaddUsagebottomUEdeleteUElookupUEscaleUE scaleUsagesupUEsupUEsunitUEzeroUEBottomMUsageZeroUsageEnv$fOutputableUsage$fOutputableUsageEnv buildCoercioncastCoercionKindcastCoercionKind1castCoercionKind2checkReflexiveMCocoToMCo coVarKind coVarName coVarTypescoercionHolesOfCocoercionHolesOfTypecoercionKindRole coercionKinds coercionRolecomposeSteppers decomposeCodecomposeFunCo downgradeRoleemptyLiftingContext eqCoercion eqCoercionXetaExpandCoAxBranchextendLiftingContextextendLiftingContextAndInScopegetCoVar_maybehasCoercionHoleCohasCoercionHoleTyinstNewTyCon_maybe isCoVar_maybeisGReflCo_maybe isGReflMCo isMappedByLCisReflCoVar_maybeisReflCo_maybe isReflMCoisReflexiveCo_maybe lcInScopeSet lcSubstLeft lcSubstRight lcTCvSubstliftCoSubstTyVarliftCoSubstVarBndrUsingliftCoSubstWithliftCoSubstWithExliftEnvSubstLeftliftEnvSubstRightltRole mapStepResultmkAppCos mkAxInstCo mkAxInstLHS mkAxInstRHS mkCastTyMComkCoCast mkCoVarCosmkCoherenceLeftComkCoherenceRightComkCoherenceRightMComkFamilyTyConAppCo mkForAllCos mkFunResCo mkFunResMCo mkGReflLeftComkGReflLeftMComkGReflRightComkGReflRightMComkHeteroCoercionTypemkHeteroPrimEqPredmkHeteroReprPrimEqPredmkHoleComkHomoForAllCosmkHomoForAllMCo mkNthCoFunComkPiComkPiCosmkPiMCos mkPrimEqPredmkPrimEqPredRole mkRepReflComkReprPrimEqPredmkSubstLiftingContextmkSymMCo mkTransMCo mkTransMCoL mkTransMCoRmkUnbranchedAxInstComkUnbranchedAxInstLHSmkUnbranchedAxInstRHSmultToCo nthCoRolenthRole pprCoAxBranchpprCoAxBranchLHSpprCoAxBranchUser pprCoAxiompromoteCoercion setCoVarNamesetCoVarUniquesetNominalRole_maybesimplifyArgsWorkersplitAppCo_maybesplitForAllCo_co_maybesplitForAllCo_maybesplitForAllCo_ty_maybesplitFunCo_maybesplitTyConAppCo_maybesubstForAllCoBndrUsingLC substLeftCo substRightCo swapLiftCoEnvtidyCoAxBndrsForUsertopNormaliseNewType_maybetopNormaliseTypeXtyConRolesRepresentational tyConRolesXunwrapNewTypeStepperzapLiftingContextHoleSet LiftCoEnvLCNormaliseStepResultNS_AbortNS_DoneNS_StepNormaliseStepper$fOutputableLiftingContext$fOutputableNormaliseStepResultclassMethodInstTy classMethodTyclassifyPredType eqRelRolegetClassPredTysgetClassPredTys_maybe getEqPredRole getEqPredTysgetEqPredTys_maybehasIPSuperClasses isCTupleClass isClassPredisDictIdisDictTyisEqPred isEqPredClass isEqPrimPredisEvVar isEvVarType isIPClass isIPLikePred isIPTyCon mkClassPred predTypeEqRelEqRelNomEqReprEqPred ClassPredEqPred ForAllPred IrredPred $fEqEqRel $fOrdEqRel$fOutputableEqRel deBruijnizeemptyCME emptyTypeMap extendCME extendCMEs extendTypeMapextendTypeMapWithScope foldTypeMaplkBndr lkDFreeVarlkDNamedlkVar lookupCME lookupTypeMaplookupTypeMapWithScopemkDeBruijnContextxtBndr xtDFreeVarxtDNamedxtVarBndrMapCmEnv CoercionMapGDeBruijnD LooseTypeMapTypeMapTypeMapGVarMap $fEqDeBruijn $fEqDeBruijn0 $fEqDeBruijn1 $fEqDeBruijn2$fTrieMapBndrMap$fTrieMapCoercionMap$fTrieMapCoercionMapX$fTrieMapLooseTypeMap$fTrieMapTyLitMap$fTrieMapTypeMap$fTrieMapTypeMapX$fTrieMapVarMap alwaysBindFun flattenTys flattenTysXinstanceCantMatchisRoughOtherTc liftCoMatch matchBindFun roughMatchTcsruleMatchTyKiX tcMatchTy tcMatchTyKi tcMatchTyKis tcMatchTyKisX tcMatchTyX tcMatchTyX_BM tcMatchTys tcMatchTysX tcUnifyTy tcUnifyTyKi tcUnifyTyKistcUnifyTyWithTFs tcUnifyTys tcUnifyTysFGtypesCantMatchBindFlagApartBindMeBindFunMaybeApartReason MARInfinite MARTypeFamily RoughMatchTcKnownTcOtherTc UnifyResult UnifyResultM MaybeApart SurelyApart Unifiable$fApplicativeUM $fFunctorUM$fApplicativeUnifyResultM$fFunctorUnifyResultM$fDataRoughMatchTc $fEqBindFlag $fMonadFailUM $fMonadUM$fMonadUnifyResultM$fOutputableMaybeApartReason$fOutputableUnifyResultM$fSemigroupMaybeApartReasonapartnessCheckdataFamInstRepTyConemptyFamInstEnvemptyFamInstEnvsextendFamInstEnvextendFamInstEnvList famInstAxiomfamInstEnvEltsfamInstEnvSize famInstRHSfamInstRepTyCon_maybe famInstTyConfamInstsRepTyConsfamilyInstancesinjectiveBranches isDominatedBylookupFamInstEnvlookupFamInstEnvByTyConlookupFamInstEnvConflicts$lookupFamInstEnvInjectivityConflictsmkBranchedCoAxiom mkCoAxBranchmkImportedFamInstmkNewTypeCoAxiommkSingleCoAxiommkUnbranchedCoAxiomnormaliseTcApp normaliseType pprFamInst pprFamInstsreduceTyFamApp_maybetopNormaliseTypetopNormaliseType_maybetopReduceTyFamApp_maybe FamFlavorDataFamilyInst SynFamilyInstFamInstfi_axiomfi_cvsfi_fam fi_flavorfi_rhsfi_tcsfi_tvsfi_tys FamInstEnv FamInstEnvs FamInstMatchfim_cos fim_instancefim_tysInjectivityCheckResultInjectivityAcceptedInjectivityUnified$fApplicativeNormM$fFunctorNormM $fMonadNormM$fNamedThingFamInst$fOutputableFamInst$fOutputableFamInstMatch$fOutputableFamilyInstEnv classDataCon dataConBoxerdataConCannotMatchdataConDisplayType dataConEqSpecdataConFieldTypedataConFieldType_maybedataConIdentitydataConImplBangsdataConImplicitTyThingsdataConInstArgTysdataConInstSigdataConIsInfixdataConNonlinearTypedataConOrigArgTysdataConOrigResTydataConOrigTyCondataConOtherThetadataConRepArgTysdataConRepAritydataConRepStrictnessdataConRepTypedataConSrcBangs dataConTag dataConTagZ dataConThetadataConUnivAndExTyCoVarsdataConUnivTyVarsdataConUserTyVarsArePermuteddataConWrapId_maybedataConWrapperTypeeqHsBang eqSpecPair eqSpecPreds eqSpecTyVar eqSpecType filterEqSpecisBangedisBoxedTupleDataConisMarkedStrict isNewDataConisNullaryRepDataConisNullarySrcDataCon isSrcStrict isSrcUnpackedisTupleDataConisUnboxedTupleDataConisVanillaDataCon mkDataConmkEqSpecspecialPromotedDcsplitDataProductType_maybe substEqSpecDCR NoDataConRep dcr_arg_tys dcr_bangs dcr_boxer dcr_stricts dcr_wrap_id HsImplBangHsLazyHsStrictHsUnpack HsSrcBang SrcStrictness NoSrcStrictSrcLazy SrcStrictSrcUnpackedness NoSrcUnpack SrcNoUnpack SrcUnpackStrictnessMark MarkedStrictNotMarkedStrict$fBinarySrcStrictness$fBinarySrcUnpackedness $fDataDataCon$fDataHsImplBang$fDataHsSrcBang$fDataSrcUnpackedness$fDataSrcStrictness $fEqDataCon$fEqSrcStrictness$fEqSrcUnpackedness$fNamedThingDataCon$fOutputableBndrDataCon$fOutputableDataCon$fOutputableEqSpec$fOutputableHsImplBang$fOutputableHsSrcBang$fOutputableSrcStrictness$fOutputableSrcUnpackedness$fOutputableStrictnessMark$fUniquableDataConcountConRepArgscountFunRepArgs isNvUnaryTypeisVoidTy layoutUbxSum primRepSlot primRepToTyperuntimeRepPrimRep slotPrimRep tyConPrimRep tyConPrimRep1 typePrimRep typePrimRep1typePrimRepArgs typeSlotTy ubxSumRepType unwrapType NvUnaryTypeSlotTy DoubleSlot FloatSlot PtrLiftedSlotPtrUnliftedSlot Word64SlotWordSlot UnaryType $fEqSlotTy $fOrdSlotTy$fOutputableSlotTyemptyInfoTableProvMap ClosureMapDCMapInfoTableProvMap provClosureprovDCabsDmdaddCaseBndrDmd addDemand appIsDeadEnd argOneShots argsOneShotsbotDivbotDmd botDmdTypebotSigdeferAfterPreciseExceptiondmdTransformDataConSigdmdTransformDictSelSigdmdTransformSig dmdTypeDepth emptyDmdEnvetaConvertStrictSigevalDmdexnDiv findIdDemandhasDemandEnvSigisAbsisAbsDmd isDeadEndDiv isDeadEndSigisSeqDmd isStrUsedDmdisStrict isStrictDmdisTopDmdisTopSig isUsedOnce isUsedOnceDmd isWeakDmdkeepAliveDmdEnvkeepAliveDmdType lazyApply1Dmd lazyApply2DmdlubCard lubDivergencelubDmd lubDmdType lubSubDmdmkCalledOnceDmdmkCalledOnceDmdsmkClosedStrictSig mkPlusDmdArgmkProdmkStrictSigForAritymkWorkerDemandmultCardmultDmd multDmdType multSubDmd nopDmdTypenopSig oneifyCard oneifyDmd peelCallDmdpeelFV peelManyCallsplusCardplusDmd plusDmdType plusSubDmdprependArgsStrictSigreuseEnvsaturatedByOneShots seqDemand seqDemandListseqDmd seqDmdType seqStrictSig splitDmdTysplitStrictSigstrictManyApply1DmdstrictOnceApply1DmdstrictSigDmdEnvstrictifyDictDmd strictifyDmd toPlusDmdArgtopDivtopDmd topSubDmd trimToTypeviewProd zapDmdEnvSigzapUsageDemandzapUsedOnceDemandzapUsedOnceSigCardC_00C_01C_0NC_10C_11C_1NDemand:* DivergenceDivergesDunnoExnOrDivDmdEnvDmdTransformerDmdTypedt_argsdt_divdt_env PlusDmdArg StrictSig SubDemandProd TypeShapeTsFunTsProdTsUnk $fBinaryCard$fBinaryDemand$fBinaryDivergence$fBinaryDmdType$fBinaryStrictSig$fBinarySubDemand$fEqCard $fEqDemand$fEqDivergence $fEqDmdType $fEqStrictSig $fEqSubDemand$fOutputableCard$fOutputableDemand$fOutputableDivergence$fOutputableDmdType$fOutputableStrictSig$fOutputableSubDemand$fOutputableTypeShape abstractCprTy applyCprTyasConCprbotCpr botCprType flatConCprflatConCprType isTopCprSig lubCprTypemkCprSigmkCprSigForArity seqCprSigtopCpr topCprSig topCprType trimCprTyunpackConFieldsCprCprConCprCprSig getCprSigCprTypect_artyct_cprUnpackConFieldsResult AllFieldsSame ForeachField $fBinaryCpr$fBinaryCprSig$fBinaryCprType$fEqCpr $fEqCprSig $fEqCprType$fOutputableCpr$fOutputableCprSig$fOutputableCprTypeArgDescrArgGenArgSpec ArgUnknownCgInfos cgIPEStub cgLFInfos cgNonCafsLambdaFormInfoLFCon LFLetNoEscape LFReEntrantLFThunk LFUnknown LFUnliftedLiveness ModuleLFInfosStandardFormInfoApThunkNonStandardThunk SelectorThunkWordOff $fEqArgDescr$fEqStandardFormInfo$fOutputableArgDescr$fOutputableLambdaFormInfo$fOutputableStandardFormInfo conLikeArityconLikeExTyCoVarsconLikeFieldLabelsconLikeFieldTypeconLikeFullSigconLikeHasBuilderconLikeImplBangsconLikeInstOrigArgTysconLikeIsInfix conLikeName conLikeResTyconLikeStupidThetaconLikeUserTyVarBindersconLikesWithFieldsisVanillaConLike PatSynCon RealDataCon $fDataConLike $fEqConLike$fNamedThingConLike$fOutputableBndrConLike$fOutputableConLike$fUniquableConLikecompleteMatchAppliesAtTypevanillaCompleteMatch CompleteMatch cmConLikes cmResultTyConCompleteMatches$fOutputableCompleteMatch addMessage emptyMessages errorsFoundgetCaretDiagnosticgetErrorMessagesgetSeverityColourgetWarningMessagesisEmptyMessagesisErrorMessageisWarningMessagemakeIntoWarning mkDecoratedmkErr mkLocMessagemkLocMessageAnnmkLongMsgEnvelope mkLongWarnMsg mkMessages mkMsgEnvelopemkPlainMsgEnvelopemkPlainWarnMsg mkWarnMsgpartitionMessages pprMessageBag unionMessages DecoratedSDoc unDecorated ErrorMessagesMessages MsgEnvelope errMsgContexterrMsgDiagnostic errMsgReasonerrMsgSeverity errMsgSpanRenderableDiagnosticrenderDiagnosticSeveritySevDumpSevErrorSevFatalSevInfoSevInteractive SevOutput SevWarningWarnMsgWarningMessages $fEqSeverity$fFunctorMessages$fFunctorMsgEnvelope#$fRenderableDiagnosticDecoratedSDoc$fShowMsgEnvelope$fShowSeverity$fToJsonSeverityhandleSourceErrormkSrcErrsrcErrorMessages throwErrors throwOneError$fExceptionSourceError$fShowSourceErroraddGlobalIncludeaddImplicitQuoteIncludeaddPluginModuleNameaddQuoteIncludeallNonDeprecatedFlags compilerInfodefaultDynFlagsdefaultFatalMessagerdefaultFlushErrdefaultFlushOutdoptdopt_set dopt_unsetdynFlagDependenciesdynamicOutputFiledynamicOutputHidynamicTooStateextraGccViaCFlagsfFlags fLangFlags flagSpecOfflagsAll flagsDynamicflagsForCompletion flagsPackageflattenIncludesgetOpts getVerbFlags ghcUsagePath ghciUsagePathglasgowExtsFlagsglobalPackageDatabasePathgoptgopt_set gopt_unsethasNoOptCoercionhasNoStateHackhiSuf impliedGFlagsimpliedOffGFlags impliedXFlagsinitDefaultSDocContext initDynFlags isAvx2EnabledisAvx512cdEnabledisAvx512erEnabledisAvx512fEnabledisAvx512pfEnabled isAvxEnabled isBmi2Enabled isBmiEnabledisNoLink isOneShot isSse2EnabledisSse4_2Enabled isSseEnabledlang_setlanguageExtensionsmakeDynFlagsConsistentneedSourceNotes objectSufopt_Fopt_Lopt_Popt_P_signatureopt_aopt_copt_cxxopt_iopt_lopt_lcopt_lccopt_lmopt_lo opt_windres outputFilepackageFlagsChangedpackageTrustOnparseDynamicFilePragmaparseDynamicFlagsCmdLineparseDynamicFlagsFullpgm_Fpgm_Lpgm_Ppgm_Tpgm_apgm_arpgm_cpgm_dllpgm_ipgm_install_name_toolpgm_lpgm_lcpgm_lcc pgm_libtoolpgm_lmpgm_lo pgm_otool pgm_ranlib pgm_windres picCCOptspicPOptspositionIndependentpprDynFlagsDiff programNameprojectVersionsafeDirectImpsReqsafeHaskellModeEnabled safeHaskellOnsafeImplicitImpsReq safeImportsOn safeInferOnsafeLanguageOnsccProfilingEnabled setDynamicNowsetDynamicTooFailedsetFlagsFromEnvFilesetGeneralFlag' setTmpDir setUnitIdsetUnsafeGlobalDynFlagssettingssmallestGroupssupportedLanguagesAndExtensions targetProfiletmpDirtopDirturnOffturnOnunSetGeneralFlag' unsafeFlagsunsafeFlagsForInfer updOptLevelupdatePlatformConstantsuseXLinkerRPathversionedAppDirversionedFilePathwWarningFlagMap wWarningFlags warningGroupswarningHierarchieswayswopt wopt_fatalwopt_setwopt_set_fatal wopt_unsetwopt_unset_fatal wordAlignmentxFlagsxoptxopt_DuplicateRecordFieldsxopt_FieldSelectorsxopt_setxopt_set_unlessExplSpec xopt_unset CompilerInfo AppleClang AppleClang51ClangGCC UnknownCCContainsDynFlagsextractDynFlagsavxavx2avx512cdavx512eravx512favx512pfbinBlobThreshold bmiVersioncallerCcFilters canUseColor cfgWeightscmdlineFrameworkscmmProcAlignment colScheme debugLeveldepExcludeModsdepIncludeCppDepsdepIncludePkgDeps depMakefile depSuffixesderiveViaOnLocdumpDir dumpFlags dumpPrefixdumpPrefixForcedylibInstallName dynHiSuf_ dynLibLoader dynObjectSuf_dynOutputFile_ dynOutputHi dynamicNowdynamicTooFailedenableTimeStatsextensionFlags extensionsfatalWarningFlags fileSettings floatLamArgsflushErrflushOutframeworkPathsfrontendPluginOpts generalFlags ghcHeapSizeghcLinkghcModeghcNameVersionghcVersionFile ghciHistSize ghciScriptshaddockOptionshcSufhiDirhiSuf_hieDirhieSuf historySize homeUnitId_homeUnitInstanceOf_homeUnitInstantiations_hpcDirignorePackageFlags importPaths includePathsincoherentOnLoc initialUnique inlineCheckinteractivePrintlanguageldInputsliberateCaseThreshold libraryPaths liftLamsKnownliftLamsNonRecArgsliftLamsRecArgs llvmConfig mainFunIsmainModuleNameIs maxErrorsmaxInlineAllocSizemaxInlineMemcpyInsnsmaxInlineMemsetInsnsmaxPmCheckModelsmaxRefHoleFitsmaxRelevantBindsmaxSimplIterationsmaxUncoveredPatternsmaxValidHoleFits maxWorkerArgs newDerivOnLocnextWrapperNum objectDir objectSuf_optLevel outputFile_outputHioverlapInstLocpackageDBFlags packageEnv packageFlags parMakeCount pkgTrustOnLoc platformMiscpluginModNameOptspluginModNamespluginPackageFlagspprCols pprUserLengthprofAuto rawSettingsreductionDepthrefLevelHoleFits reverseErrorsrtccInfortldInfortsOptsrtsOptsEnabledrtsOptsSuggestions ruleCheck safeHaskell safeInfer safeInferred simplPhasessimplTickFactorsolverIterationsspecConstrCountspecConstrRecursivespecConstrThreshold splitInfo sseVersionstrictnessBeforestubDir targetWays_thOnLoc toolSettings trustFlagstrustworthyOnLoc unfoldingOptsuniqueIncrementuseColor useUnicode verbosity warnSafeOnLocwarnUnsafeOnLoc warningFlags DynLibLoader DeployableSystemDependentDynamicTooStateDT_DontDT_Dyn DT_FailedDT_OK FatalMessagerFlagSpecflagSpecAction flagSpecFlagflagSpecGhcMode flagSpecNameFlushErrFlushOutGhcLink LinkBinary LinkDynLib LinkInMemory LinkStaticLibNoLinkGhcMode CompManagerMkDependOneShot HasDynFlags getDynFlagsIgnorePackageFlag IgnorePackage IncludeSpecsincludePathsGlobalincludePathsQuoteincludePathsQuoteImplicit LinkerInfoAixLDDarwinLDGnuGoldGnuLDLlvmLLD SolarisLD UnknownLD LlvmConfig llvmPasses llvmTargets LlvmTarget lAttributeslCPU lDataLayout ModRenamingmodRenamingWithImplicit modRenamings PackageArg UnitIdArg PackageDBFlagClearPackageDBsNoGlobalPackageDBNoUserPackageDB PackageDB PackageFlag ExposePackage HidePackagePkgDbRef GlobalPkgDb PkgDbPath UserPkgDbProfAuto NoProfAuto ProfAutoAll ProfAutoCallsProfAutoExports ProfAutoTopRtsOptsEnabled RtsOptsAll RtsOptsIgnoreRtsOptsIgnoreAll RtsOptsNoneRtsOptsSafeOnly TrustFlagDistrustPackage TrustPackage TurnOnFlag$fEnumProfAuto$fEqCompilerInfo$fEqDeprecation$fEqDynLibLoader$fEqDynamicTooState $fEqGhcLink $fEqGhcMode$fEqIgnorePackageFlag$fEqLinkerInfo$fEqModRenaming $fEqOnOff$fEqPackageArg$fEqPackageDBFlag$fEqPackageFlag $fEqPkgDbRef $fEqProfAuto $fEqTrustFlag$fHasDynFlagsExceptT$fHasDynFlagsMaybeT$fHasDynFlagsReaderT$fHasDynFlagsWriterT$fOrdDeprecation$fOrdDynamicTooState$fOutputableGhcMode$fOutputableModRenaming$fOutputableOnOff$fOutputablePackageArg$fOutputablePackageFlag$fShowDynamicTooState $fShowGhcLink$fShowIncludeSpecs $fShowOnOff$fShowPackageArg$fShowRtsOptsEnableddefaultDumpActiondefaultLogActiondefaultLogActionHPrintDocdefaultLogActionHPutStrDocdefaultTraceAction dumpIfSet dumpIfSet_dyndumpIfSet_dyn_printer initLogger jsonLogActionmakeThreadSafe popDumpHook popLogHook popTraceHook pushDumpHook pushLogHook pushTraceHook putDumpMsg putLogMsg putTraceMsg touchDumpFilewithDumpFileHandleContainsLogger extractLogger DumpAction DumpFormat FormatASMFormatByteCodeFormatC FormatCMM FormatCore FormatHaskell FormatLLVM FormatSTG FormatText HasLogger getLogger LogActionLogger TraceAction$fEqDumpFormat$fShowDumpFormatallValidandValidcompilationProgressMsg debugTraceMsgdoIfSet doIfSet_dynerrorMsg fatalErrorMsgfatalErrorMsg''formatBulleted getInvalidsghcExitisValidlogInfo logOutputorValidpprLocMsgEnvelopepprMsgEnvelopeBagWithLocprettyPrintGhcErrorsprintInfoForUserprintOutputForUserputMsgshowPass sortMsgBagtraceCmd warningMsg withTimingwithTimingSilentValidityIsValidNotValid$fEqPrintTimings$fShowPrintTimings closeUnitDepscloseUnitDeps' getUnitDbRefs improveUnit initUnitsinstModuleToModuleinstUnitToUnit listUnitInfolistVisibleModuleNameslookupModuleInAllUnitslookupModulePackagelookupModuleWithSuggestionslookupPackageName!lookupPluginModuleWithSuggestions lookupUnit lookupUnit' lookupUnitId lookupUnitId'mayThrowUnitErrpprFlag pprModuleMap pprReasonpprUnitInfoForUserpprUnitspprUnitsSimplereadUnitDatabasereadUnitDatabasesrenameHoleModulerenameHoleModule'renameHoleUnitrenameHoleUnit'requirementMergesresolveUnitDatabasesearchPackageIdunsafeLookupUnitunsafeLookupUnitId LookupResult LookupFound LookupHiddenLookupMultipleLookupNotFoundLookupUnusable ModuleOrigin ModHidden ModOrigin ModUnusablefromExposedReexportfromHiddenReexport fromOrigUnitfromPackageFlagModuleSuggestion SuggestHiddenSuggestVisiblePreloadUnitClosure ShHoleSubstunitDatabasePathunitDatabaseUnitsUnitErr CloseUnitErrPackageFlagErr TrustFlagErr UnitInfoMapallowVirtualUnits explicitUnitsmoduleNameProvidersMappackageNameMappluginModuleNameProvidersMappreloadClosure preloadUnitsrequirementContext unitInfoMap unwireMapwireMapUnusableUnitReasonBrokenDependenciesCyclicDependenciesIgnoredDependenciesIgnoredWithFlagShadowedDependencies$fMonoidModuleOrigin$fSemigroupModuleOrigin$fMonoidUnitVisibility$fSemigroupUnitVisibility$fOutputableModuleOrigin$fOutputableUnitErr$fOutputableUnitVisibility$fOutputableUnusableUnitReason FindResultFound FoundMultiple NoPackageNotFoundfr_mods_hiddenfr_pathsfr_pkgfr_pkgs_hiddenfr_suggestions fr_unusables FinderCacheInstalledFindResultInstalledFoundInstalledNoPackageInstalledNotFoundpreloadUnitsInfopreloadUnitsInfo'UnitEnv ue_home_unit ue_namever ue_platformue_units makeElfNotereadElfNoteAsStringreadElfSectionByNameaRG_GEN aRG_GEN_BIGarrPtrsHdrSizearrPtrsHdrSizeW arrPtrsReparrWordsHdrSizearrWordsHdrSizeW arrWordsRep blackHoleRepbytesToWordsRoundUpcard cardRoundUpcardTableSizeBcardTableSizeW fixedHdrSize fixedHdrSizeWfromStgHalfWord fromStgWord halfWordSizehalfWordSizeInBitshdrSizehdrSizeWheapClosureSizeW indStaticRepisConRepisFunRep isStackRepisStaticNoCafCon isStaticRep isThunkRep mkHeapRepmkRTSRep mkStackRep nonHdrSize nonHdrSizeW profHdrSizerET_BIG rET_SMALL roundUpToroundUpToWordsrtsClosureTypesmallArrPtrsHdrSizesmallArrPtrsHdrSizeWsmallArrPtrsRep thunkHdrSize toStgHalfWord toStgWord wordsToBytesByteOffClosureTypeInfo BlackHoleConstrFun IndStaticThunk ThunkSelectorConstrDescriptionIsStaticSMRep ArrayPtrsRep ArrayWordsRepHeapRepRTSRepSmallArrayPtrsRepStackRep StgHalfWordStgWord $fBitsStgWord $fEqStgWord$fEqStgHalfWord$fOutputableClosureTypeInfo$fOutputableSMRep$fOutputableStgHalfWord$fOutputableStgWordintsToReverseBitmapmAX_SMALL_BITMAP_SIZEmkBitmapBitmapcollectArchivescollectLinkOptsgetLibsgetUnitLinkOptshandleFlagWarningsisWarnMsgFatalprintBagOfErrorsprintOrThrowWarningswarningsToMessagesatomicUpdMutVaratomicUpdMutVar'failM failWithMfixMgetEnv newMutVar readMutVarrunIOEnvsetEnvtryAllMtryMtryMostMuninterruptibleMaskM_unsafeInterleaveMupdEnv updMutVar updMutVarM writeMutVarIOEnv IOEnvFailure$fAlternativeIOEnv$fApplicativeIOEnv$fFunctorIOEnv$fExceptionIOEnvFailure$fShowIOEnvFailure$fHasDynFlagsIOEnv$fHasHooksIOEnv$fHasLoggerIOEnv$fHasModuleIOEnv$fMonadCatchIOEnv$fMonadThrowIOEnv$fMonadFailIOEnv $fMonadIOEnv$fMonadIOIOEnv$fMonadMaskIOEnv$fMonadPlusIOEnv llvmFixupAsmaddFilesToCleanchangeTempFilesLifetimecleanCurrentModuleTempFiles cleanTempDirscleanTempFilesemptyFilesToClean forkTmpFsFrom initTmpFsmergeTmpFsInto newTempDirnewTempLibName newTempNamewithSystemTempDirectorywithTempDirectory FilesToCleanftcCurrentModule ftcGhcSessionTempFileLifetimeTFL_CurrentModuleTFL_GhcSessionTmpFs$fShowTempFileLifetime breakColon breakIntColonbuilderMainLoop c_locale_envenableProcessJobs getGccEnv handleProc linesPlatform parseErrorreadCreateProcessWithExitCode'readProcessEnvWithExitCode readerProc replaceVar runSomethingrunSomethingFilteredrunSomethingResponseFilerunSomethingWith BuildMessage BuildErrorBuildMsgEOFgetCompilerInfogetCompilerInfo' getLinkerInfogetLinkerInfo'neededLinkArgsnoExtCon noExtFieldAnnoIdPLIdPMapXRecmapXRecNoExtConNoGhcTcUnXRecunXRecWrapXRecwrapXRecXABE XAbsBinds XAmbiguousXAnnDXAnyClassStrategyXApp XAppKindTyXAppTy XAppTypeEXApplicativeArgManyXApplicativeArgOneXApplicativeStmt XArithSeqXAsPatXBangPatXBangTyXBinTick XBindStmt XBodyStmtXBracket XCClsInstDecl XCDefaultDecl XCDerivDeclXCFamEqn XCFamilyDecl XCFieldOccXCFunDepXCGRHSXCGRHSs XCHsDataDefnXCHsDerivingClauseXCHsFieldLabel XCHsGroupXCIPBind XCImportDeclXCInjectivityAnn XCKindSigXCMatchXCRoleAnnotDecl XCRuleBndr XCRuleDecls XCTyClGroupXCTyFamInstDeclXCase XClassDecl XClassOpSig XClsInstDXCmdApp XCmdArrApp XCmdArrFormXCmdCaseXCmdDoXCmdIfXCmdLam XCmdLamCaseXCmdLetXCmdParXCmdTopXCmdWrapXCoPatXCompleteMatchSig XConDeclField XConDeclGADT XConDeclH98 XConLikeOutXConPat XDataDecl XDataFamInstD XDctMulti XDctSingleXDecBrGXDecBrLXDefDXDerivDXDoXDocDXDocTyXEmptyLocalBindsXExpBr XExplicitListXExplicitListTy XExplicitSumXExplicitTupleXExplicitTupleTyXExprWithTySigXFamDeclXFixSig XFixitySig XForAllTyXForDXForeignExportXForeignImportXFunBindXFunTy XGetField XHsAnnotationXHsChar XHsCharPrim XHsDoublePrim XHsFloatPrimXHsForAllInvis XHsForAllVis XHsIPBindsXHsInt XHsInt64Prim XHsIntPrim XHsIntegerXHsOuterExplicitXHsOuterImplicitXHsPSXHsQTvsXHsRat XHsRecFieldXHsRuleXHsSig XHsString XHsStringPrim XHsValBindsXHsWC XHsWord64Prim XHsWordPrimXIEDoc XIEDocNamedXIEGroupXIEModuleContents XIEThingAbs XIEThingAll XIEThingWithXIEVarXIPBindsXIPVar XIParamTyXIdSigXIf XInlineSigXInstDXKindSig XKindSigD XKindedTyVarXLamXLamCase XLastStmtXLazyPatXLetXLetStmtXListPatXListTyXLitEXLitPatXMG XMinimalSigXMissingXMultiIfXNPat XNPlusKPatXNegAppXNewtypeStrategyXNoSigXOpAppXOpTy XOverLabelXOverLit XOverLitEXPSBXParXParPatXParStmt XParStmtBlockXParTyXPatBindXPatBr XPatSynBind XPatSynSigXPragEXPresentXProc XProjectionXQualTy XQuasiQuoteXRecXRecFldXRecStmtXRecTy XRecordCon XRecordUpd XRnBracketOut XRoleAnnotD XRuleBndrSigXRuleDXSCC XSCCFunSig XSectionL XSectionRXSigDXSigPat XSpecInstSigXSpecSigXSpliceD XSpliceDeclXSpliceE XSplicePat XSpliceTyXSplicedXStandaloneKindSigXStarTyXStaticXStockStrategyXSumPatXSumTyXSynDeclXTExpBr XTcBracketOutXTick XTransStmt XTuplePatXTupleTyXTyClD XTyFamInstDXTyLitXTyVar XTyVarSigXTypBrXTypeSig XTypedSplice XUnambiguous XUnboundVarXUntypedSplice XUserTyVar XValBindsXValDXVarXVarBindXVarBrXVarPat XViaStrategyXViewPatXWarning XWarningD XWarnings XWildCardTyXWildPat XXABExportXXAmbiguousFieldOcc XXAnnDeclXXApplicativeArg XXBracket XXClsInstDeclXXCmdXXCmdTop XXConDeclXXConDeclField XXDefaultDeclXXDerivClauseTys XXDerivDeclXXExprXXFamEqn XXFamilyDeclXXFamilyResultSig XXFieldOcc XXFixitySig XXForeignDeclXXFunDepXXGRHSXXGRHSs XXHsBindsLR XXHsDataDefnXXHsDeclXXHsDerivingClauseXXHsFieldLabelXXHsForAllTelescope XXHsGroup XXHsIPBindsXXHsLocalBindsLRXXHsOuterTyVarBndrsXXHsPatSigType XXHsSigTypeXXHsWildCardBndrsXXIEXXIPBind XXImportDeclXXInjectivityAnn XXInstDecl XXLHsQTyVarsXXLitXXMatch XXMatchGroup XXOverLitXXParStmtBlockXXPat XXPatSynBindXXPragEXXRoleAnnotDecl XXRuleBndr XXRuleDecl XXRuleDeclsXXSigXXSplice XXSpliceDeclXXStandaloneKindSigXXStmtLRXXTupArg XXTyClDecl XXTyClGroupXXTyFamInstDecl XXTyVarBndrXXType XXValBindsLR XXWarnDecl XXWarnDecls$fDataNoExtCon$fDataNoExtField $fEqNoExtCon$fEqNoExtField $fOrdNoExtCon$fOrdNoExtField$fOutputableNoExtCon$fOutputableNoExtFieldGRHSsHsSpliceLHsExpr MatchGroup SyntaxExpr mkNoCount mkNoScopetickishCanSplittickishContains tickishCountstickishFloatable tickishIsCode tickishPlace tickishScopedtickishScopesLike CmmTickish CoreTickish GenTickish BreakpointHpcTickProfNote breakpointExt breakpointFVs breakpointId profNoteCC profNoteCount profNoteScope sourceName sourceSpantickId tickModule StgTickishTickishPlacementPlaceCostCentre PlaceNonLam PlaceRuntimeTickishScopingCostCentreScopeNoScope SoftScope XTickishId$fDataGenTickish$fDataGenTickish0$fDataGenTickish1$fEqGenTickish$fEqGenTickish0$fEqTickishPlacement$fEqTickishScoping$fOrdGenTickish$fOrdGenTickish0applyTypeToArg bindersOfbindersOfBinds bootUnfoldingboringCxtNotOk boringCxtOk canUnfoldchooseOrphanAnchorcmpAlt cmpAltConcollectAnnArgscollectAnnArgsTickscollectAnnBndrs collectArgscollectArgsTickscollectBinderscollectNAnnBndrscollectNBinderscollectTyAndValBinderscollectTyBindersdeAnnAlt deAnnBind deAnnotate deAnnotate' deTagExpr emptyRuleEnvevaldUnfoldingexpandUnfolding_maybeexprToCoercion_maybe exprToType flattenBindshasCoreUnfoldinghasSomeUnfolding isAutoRuleisBootUnfolding isBuiltinRuleisCheapUnfoldingisCoArgisCompulsoryUnfoldingisConLikeUnfoldingisEvaldUnfoldingisExpandableUnfolding isLocalRuleisOrphan isRuntimeArg isRuntimeVarisStableSourceisStableUnfolding isTyCoArg isTypeArgisValArgisValueUnfoldingltAltmaybeUnfoldingTemplatemkApps mkCharLitmkCoAppsmkCoBindmkConApp mkConApp2 mkDoubleLitmkDoubleLitDouble mkFloatLitmkFloatLitFloatmkInt64LitInt64mkIntLit mkIntLitWrapmkLamsmkLet mkLetNonRecmkLetRecmkLets mkOtherCon mkRuleEnv mkStringLitmkTyAppsmkTyArgmkTyBind mkVarAppsmkWord64LitWord64 mkWord8Lit mkWordLit mkWordLitWrap needSaturatedneverUnfoldGuidance noUnfolding notOrphan otherCons rhssOfAlts rhssOfBindruleActivation ruleArity ruleIdName ruleModuleruleName setRuleIdName stripNArgs unSaturatedOkunfoldingTemplate valArgCount valBndrCount varToCoreExprvarsToCoreExprsAltAltConDEFAULTDataAltLitAltAnnAltAnnBind AnnNonRecAnnExprAnnExpr'AnnAppAnnCast AnnCoercionAnnLitAnnTickAnnVarArgBindNonRecRecCoreAltCoreArgCoreBindCoreBndrCoreExpr CoreProgramCoreRule BuiltinRuleRuleru_actru_argsru_autoru_bndrsru_fnru_localru_nameru_nargs ru_origin ru_orphanru_rhsru_roughru_tryExprAppCaseCastLamLetLitTickIdUnfoldingFunInAltInArgInBindInBndr InCoercionInExprInKind InScopeEnvInTypeIsOrphan NotOrphan MOutCoercionOutAltOutArgOutBindOutBndr OutCoercionOutExprOutKindOutTypeRuleBaseRuleEnvre_basere_visible_orphsRuleFunRuleOpts roBignumRulesroExcessRationalPrecisionroNumConstantFolding roPlatform TaggedAlt TaggedArg TaggedBind TaggedBndrTB TaggedExpr Unfolding BootUnfolding CoreUnfolding DFunUnfolding NoUnfoldingOtherCondf_argsdf_bndrsdf_con uf_expandable uf_guidance uf_is_conlike uf_is_top uf_is_valueuf_is_work_freeuf_srcuf_tmplUnfoldingGuidance UnfIfGoodArgsUnfNeverUnfWhenug_argsug_arity ug_boring_okug_resug_size ug_unsat_okUnfoldingSourceInlineCompulsory InlineRhs InlineStable$fBinaryIsOrphan $fDataAlt $fDataAltCon $fDataExpr $fDataBind$fDataIsOrphan $fEqAltCon$fEqUnfoldingGuidance $fOrdAltCon$fOutputableAltCon$fOutputableTaggedBndr arityInfocafInfo callArityInfo emptyRuleInfoisEmptyRuleInfoisJoinIdDetails_maybeisNeverLevPolyIdInfo levityInfomayHaveCafRefs noCafIdInfo oneShotInfo ppArityInfo ppCafInfo pprStrictnessruleInfoFreeVars ruleInfoRules setArityInfo setCafInfosetCallArityInfo setCprInfo setDemandInfosetInlinePragInfo setLFInfosetLevityInfoWithTypesetNeverLevPoly setOccInfosetOneShotInfo setRuleInfosetRuleInfoHeadsetStrictnessInfosetUnfoldingInfo unknownArityzapCallArityInfo zapDemandInfozapFragileInfo zapLamInfozapTailCallInfo zapUnfoldingzapUsageEnvInfo zapUsageInfozapUsedOnceInfo ArityInfoCafInfoMayHaveCafRefs NoCafRefs ClassOpIdCoVarId DataConWorkId DataConWrapIdFCallIdPrimOpIdRecSelId TickBoxOpId VanillaId sel_naughty sel_tyconcprInfo demandInfoinlinePragInfolfInfooccInforuleInfostrictnessInfo unfoldingInfoInlinePragInfo LevityInfo RecSelParent RecSelData RecSelPatSynRuleInfo TickBoxId TickBoxOpTickBox $fEqCafInfo$fEqLevityInfo$fEqRecSelParent $fOrdCafInfo$fOutputableCafInfo$fOutputableIdDetails$fOutputableLevityInfo$fOutputableRecSelParent$fOutputableTickBoxOpasJoinIdasJoinId_maybeclearOneShotLambda hasNoBindingidArity idCafInfo idCallArity idCoreRules idCprInfo idDataCon idDemandInfo idFunRepArity idHasRulesidInlineActivationidInlinePragmaidIsFrom idJoinArityidLFInfo_maybeidMult idOccInfo idOneShotInfoidRuleMatchInfo idScaledTypeidSpecialisationidStateHackOneShotInfo idStrictnessidType idUnfoldingidUnique isClassOpIdisClassOpId_maybe isConLikeIdisDFunIdisDataConId_maybeisDataConRecordSelectorisDataConWorkIdisDataConWorkId_maybeisDataConWrapIdisDataConWrapId_maybe isDeadBinder isDeadEndId isFCallIdisFCallId_maybe isImplicitIdisJoinIdisJoinId_maybeisNaughtyRecordSelectorisNeverLevPolyId isOneShotBndrisPatSynRecordSelector isPrimOpIdisPrimOpId_maybeisProbablyOneShotLambdaisRecordSelectorisStateHackType isStrictId localiseIdmaybeModifyIdInfomkExportedLocalIdmkExportedVanillaId mkGlobalId mkLocalCoVar mkLocalIdmkLocalIdOrCoVarmkLocalIdWithInfomkScaledTemplateLocal mkSysLocal mkSysLocalMmkSysLocalOrCoVarmkSysLocalOrCoVarMmkTemplateLocalmkTemplateLocalsmkTemplateLocalsNum mkUserLocalmkUserLocalOrCoVarmkVanillaGlobalmkVanillaGlobalWithInfo mkWorkerId modifyIdInfomodifyInlinePragmarealIdUnfoldingrecordSelectorTyConrecordSelectorTyCon_maybe scaleIdBy scaleVarBysetCaseBndrEvald setIdArity setIdCafInfosetIdCallArity setIdCprInfosetIdDemandInfo setIdInfo setIdLFInfo setIdName setIdOccInfosetIdOneShotInfosetIdSpecialisationsetIdStrictness setIdTypesetIdUnfolding setIdUniquesetInlineActivationsetInlinePragmasetOneShotLambdastateHackOneShottransferPolyIdInfo typeOneShotupdOneShotInfozapFragileIdInfozapIdDemandInfo zapIdOccInfozapIdStrictnesszapIdTailCallInfozapIdUsageEnvInfozapIdUsageInfozapIdUsedOnceInfo zapJoinId zapLamIdInfozapStableUnfoldingimplicitClassThingsimplicitCoTyConimplicitConLikeThingsimplicitTyConThingsimplicitTyThingsisImplicitTyThingpprShortTyThingpprTyThingCategorytyThingAvailInfotyThingCategorytyThingCoAxiomtyThingConLiketyThingDataCon tyThingIdtyThingParent_maybe tyThingTyContyThingsTyCoVars MonadThings lookupDataConlookupId lookupThing lookupTyConACoAxiomAConLikeATyConAnId$fMonadThingsReaderT$fNamedThingTyThing$fOutputableTyThing emptyTypeEnv extendTypeEnvextendTypeEnvListextendTypeEnvWithIds lookupTypeEnv mkTypeEnvmkTypeEnvWithImplicits plusTypeEnvtypeEnvClassestypeEnvCoAxiomstypeEnvDataCons typeEnvEltstypeEnvFromEntities typeEnvIdstypeEnvPatSyns typeEnvTyConsTypeEnv emptySubst extendInScope extendSubst lookupIdSubst mkEmptySubstnoWarnLookupIdSubst substBndr substBndrs IdSubstEnvisStep BreakInfobreakInfo_modulebreakInfo_number ExecOptionsexecLineNumberexecSingleStepexecSourceFileexecWrap ExecResult ExecBreak ExecComplete breakInfo breakNamesexecAllocation execResultHistoryhistoryApStackhistoryBreakInfohistoryEnclosingDeclsResume resumeApStackresumeBindingsresumeBreakInfo resumeCCS resumeContext resumeDeclresumeFinalIds resumeHistoryresumeHistoryIx resumeSpan resumeStmt SingleStepRunAndLogStepsRunToCompletioncompleteBipartiteGraph completeGraph delUnVarSet elemUnVarSetemptyUnVarGraph emptyUnVarSetextendUnVarSet hasLoopAtisEmptyUnVarSet mkUnVarSet neighborsunionUnVarGraphunionUnVarGraphs unionUnVarSetunionUnVarSets varEnvDom UnVarGraphUnVarSet $fEqUnVarSet$fOutputableUnVarGraph$fOutputableUnVarSetanyTyanyTyConboolTy boolTyCon boolTyConName boolTyCon_RDRboxingDataCon_maybecTupleDataConNames cTupleSelId cTupleTyConcTupleTyConNameArity_maybecTupleTyConNames charDataCon charTyCon charTyConName charTyCon_RDRcoercibleClasscoercibleDataConcoercibleTyConName consDataConconsDataConNameconsDataCon_RDRconstraintKindTyConconstraintKindTyConName doubleDataCondoubleTy doubleTyCondoubleTyConNameeqClass eqDataConeqTyCon eqTyConName eqTyCon_RDR falseDataConfalseDataConId false_RDR filterCTuple floatDataConfloatTy floatTyConfloatTyConNameheqClass heqDataCon heqTyConName intDataConintDataCon_RDRintTyintTyCon intTyConName intTyCon_RDRintegerINDataConintegerINDataConNameintegerIPDataConintegerIPDataConNameintegerISDataConintegerISDataConName integerTyConintegerTyConNameisBuiltInOcc_maybeisCTupleTyConNameisPromotedMaybeTyisPromotedPairType justDataConjustDataConNameliftedRepTyConNameliftedTypeKindTyConName listTyConName listTyCon_RDRmakeRecoveryTyCon manyDataConmanyDataConName maybeTyConmaybeTyConNamemkListTy mkMaybeTymkPromotedMaybeTymkPromotedPairTymkSumTy mkTupleStr mkTupleTy mkTupleTy1mkWiredInIdNamemkWiredInTyConNamemultiplicityTyConNamenaturalNBDataConnaturalNBDataConNamenaturalNSDataConnaturalNSDataConName naturalTyConnaturalTyConName nilDataConnilDataConNamenonEmptyDataConnonEmptyDataConName nonEmptyTyConnonEmptyTyConNamenothingDataConnothingDataConName oneDataCononeDataConName ordEQDataConordEQDataConId ordGTDataConordGTDataConId ordLTDataConordLTDataConId orderingTyCon pairTyConpromotedConsDataConpromotedEQDataConpromotedFalseDataConpromotedGTDataConpromotedJustDataConpromotedLTDataConpromotedNilDataConpromotedNothingDataConpromotedTrueDataCon soloTyConstringTystringTyCon_RDRsumRepDataConTyCon trueDataCon trueDataConIdtrue_RDRtupleDataConNametypeSymbolKindContypeToTypeKindunboxedSumKindunboxedUnitDataCon unboxedUnitTyunboxedUnitTyCon unitDataCon unitDataConId unitTyCon unitTyConKeyunliftedDataConTyConunliftedRepTyConNameunliftedTypeKindTyConNameunrestrictedFunTyConName wiredInTyCons word8DataConword8Ty word8TyCon wordDataConwordTy wordTyCon wordTyConNamemkPrintUnqualified mkQualModule mkQualPackagepkgQualextendNameCacheextendOrigNameCache initNameCachelookupOrigNameCache NameCachensNamesnsUniqs OrigNameCache allThePrimOpsgetPrimOpResultInfoisComparisonPrimOp maxPrimOpTagprimOpCodeSize primOpDocs primOpFixity primOpIsCheap primOpIsDiv primOpOccprimOpOkForSideEffectsprimOpOkForSpeculationprimOpOutOfLineprimOpResultType primOpSig primOpTag primOpTypeprimOpWrapperId tagToEnumKeyPrimCallAddCFinalizerToWeakOp AddrAddOpAddrEqOpAddrGeOpAddrGtOpAddrLeOpAddrLtOpAddrNeOp AddrRemOp AddrSubOp AddrToAnyOp AddrToIntOp AnyToAddrOpAtomicModifyMutVar2OpAtomicModifyMutVar_OpAtomicReadAddrOp_WordAtomicReadByteArrayOp_IntAtomicWriteAddrOp_WordAtomicWriteByteArrayOp_Int AtomicallyOpBRev16OpBRev32OpBRev64OpBRev8OpBRevOp BSwap16Op BSwap32Op BSwap64OpBSwapOpByteArrayContents_CharByteArrayIsPinnedOpCasAddrOp_AddrCasAddrOp_Word CasArrayOpCasByteArrayOp_Int CasMutVarOpCasSmallArrayOpCatchOp CatchRetryOp CatchSTMOpCharEqOpCharGeOpCharGtOpCharLeOpCharLtOpCharNeOpChrOp ClearCCSOp CloneArrayOpCloneMutableArrayOpCloneSmallArrayOpCloneSmallMutableArrayOp ClosureSizeOpClz16OpClz32OpClz64OpClz8OpClzOp CompactAddCompactAddWithSharingCompactAllocateBlockOpCompactContainsAnyOpCompactContainsOpCompactFixupPointersOpCompactGetFirstBlockOpCompactGetNextBlockOp CompactNewOpCompactResizeOp CompactSizeCompareByteArraysOpCopyAddrToByteArrayOpCopyArrayArrayOp CopyArrayOpCopyByteArrayOpCopyByteArrayToAddrOpCopyMutableArrayArrayOpCopyMutableArrayOpCopyMutableByteArrayOpCopyMutableByteArrayToAddrOpCopySmallArrayOpCopySmallMutableArrayOpCtz16OpCtz32OpCtz64OpCtz8OpCtzOp DataToTagOpDeRefStablePtrOp DeRefWeakOpDelayOp DoubleAcosOp DoubleAcoshOp DoubleAddOp DoubleAsinOp DoubleAsinhOp DoubleAtanOp DoubleAtanhOp DoubleCosOp DoubleCoshOpDoubleDecode_2IntOpDoubleDecode_Int64Op DoubleDivOp DoubleEqOp DoubleExpM1Op DoubleExpOp DoubleFabsOp DoubleGeOp DoubleGtOp DoubleLeOp DoubleLog1POp DoubleLogOp DoubleLtOp DoubleMulOp DoubleNeOp DoubleNegOp DoublePowerOp DoubleSinOp DoubleSinhOp DoubleSqrtOp DoubleSubOp DoubleTanOp DoubleTanhOpDoubleToFloatOp DoubleToIntOpEqStableNameOp EqStablePtrOpFetchAddAddrOp_WordFetchAddByteArrayOp_IntFetchAndAddrOp_WordFetchAndByteArrayOp_IntFetchNandAddrOp_WordFetchNandByteArrayOp_IntFetchOrAddrOp_WordFetchOrByteArrayOp_IntFetchSubAddrOp_WordFetchSubByteArrayOp_IntFetchXorAddrOp_WordFetchXorByteArrayOp_IntFinalizeWeakOp FloatAcosOp FloatAcoshOp FloatAddOp FloatAsinOp FloatAsinhOp FloatAtanOp FloatAtanhOp FloatCosOp FloatCoshOpFloatDecode_IntOp FloatDivOp FloatEqOp FloatExpM1Op FloatExpOp FloatFabsOp FloatGeOp FloatGtOp FloatLeOp FloatLog1POp FloatLogOp FloatLtOp FloatMulOp FloatNeOp FloatNegOp FloatPowerOp FloatSinOp FloatSinhOp FloatSqrtOp FloatSubOp FloatTanOp FloatTanhOpFloatToDoubleOp FloatToIntOpForkOnOpForkOp FreezeArrayOpFreezeSmallArrayOpGetApStackValOp GetCCSOfOpGetCurrentCCSOpGetSizeofMutableByteArrayOpGetSizeofSmallMutableArrayOp GetSparkOpIndexArrayArrayOp_ArrayArrayIndexArrayArrayOp_ByteArray IndexArrayOpIndexByteArrayOp_AddrIndexByteArrayOp_CharIndexByteArrayOp_DoubleIndexByteArrayOp_FloatIndexByteArrayOp_IntIndexByteArrayOp_Int16IndexByteArrayOp_Int32IndexByteArrayOp_Int64IndexByteArrayOp_Int8IndexByteArrayOp_StablePtrIndexByteArrayOp_WideCharIndexByteArrayOp_WordIndexByteArrayOp_Word16IndexByteArrayOp_Word32IndexByteArrayOp_Word64IndexByteArrayOp_Word8IndexByteArrayOp_Word8AsAddrIndexByteArrayOp_Word8AsCharIndexByteArrayOp_Word8AsDoubleIndexByteArrayOp_Word8AsFloatIndexByteArrayOp_Word8AsIntIndexByteArrayOp_Word8AsInt16IndexByteArrayOp_Word8AsInt32IndexByteArrayOp_Word8AsInt64!IndexByteArrayOp_Word8AsStablePtr IndexByteArrayOp_Word8AsWideCharIndexByteArrayOp_Word8AsWordIndexByteArrayOp_Word8AsWord16IndexByteArrayOp_Word8AsWord32IndexByteArrayOp_Word8AsWord64IndexOffAddrOp_AddrIndexOffAddrOp_CharIndexOffAddrOp_DoubleIndexOffAddrOp_FloatIndexOffAddrOp_IntIndexOffAddrOp_Int16IndexOffAddrOp_Int32IndexOffAddrOp_Int64IndexOffAddrOp_Int8IndexOffAddrOp_StablePtrIndexOffAddrOp_WideCharIndexOffAddrOp_WordIndexOffAddrOp_Word16IndexOffAddrOp_Word32IndexOffAddrOp_Word64IndexOffAddrOp_Word8IndexSmallArrayOp Int16AddOp Int16EqOp Int16GeOp Int16GtOp Int16LeOp Int16LtOp Int16MulOp Int16NeOp Int16NegOp Int16QuotOpInt16QuotRemOp Int16RemOp Int16SllOp Int16SraOp Int16SrlOp Int16SubOp Int16ToIntOpInt16ToWord16Op Int32AddOp Int32EqOp Int32GeOp Int32GtOp Int32LeOp Int32LtOp Int32MulOp Int32NeOp Int32NegOp Int32QuotOpInt32QuotRemOp Int32RemOp Int32SllOp Int32SraOp Int32SrlOp Int32SubOp Int32ToIntOpInt32ToWord32Op Int8AddOpInt8EqOpInt8GeOpInt8GtOpInt8LeOpInt8LtOp Int8MulOpInt8NeOp Int8NegOp Int8QuotOp Int8QuotRemOp Int8RemOp Int8SllOp Int8SraOp Int8SrlOp Int8SubOp Int8ToIntOp Int8ToWord8Op IntAddCOpIntAddOpIntAndOpIntEqOpIntGeOpIntGtOpIntLeOpIntLtOp IntMul2OpIntMulMayOfloOpIntMulOpIntNeOpIntNegOpIntNotOpIntOrOp IntQuotOp IntQuotRemOpIntRemOpIntSllOpIntSraOpIntSrlOp IntSubCOpIntSubOp IntToAddrOp IntToDoubleOp IntToFloatOp IntToInt16Op IntToInt32Op IntToInt8Op IntToWordOpIntXorOpInterlockedExchange_AddrInterlockedExchange_WordIsCurrentThreadBoundOp IsEmptyMVarOp KeepAliveOp KillThreadOp LabelThreadOpMakeStableNameOpMakeStablePtrOpMaskAsyncExceptionsOp MaskStatusMaskUninterruptibleOp MkApUpd0_OpMkWeakNoFinalizerOpMkWeakOpMutableByteArrayContents_CharMutableByteArrayIsPinnedOp MyThreadIdOp Narrow16IntOpNarrow16WordOp Narrow32IntOpNarrow32WordOp Narrow8IntOp Narrow8WordOp NewAlignedPinnedByteArrayOp_CharNewArrayArrayOp NewArrayOpNewBCOOpNewByteArrayOp_Char NewIOPortrOp NewMVarOp NewMutVarOpNewPinnedByteArrayOp_CharNewSmallArrayOp NewTVarOp NoDuplicateOp NumSparksOrdOpParOpPdep16OpPdep32OpPdep64OpPdep8OpPdepOpPext16OpPext32OpPext64OpPext8OpPextOp PopCnt16Op PopCnt32Op PopCnt64Op PopCnt8OpPopCntOpPrefetchAddrOp0PrefetchAddrOp1PrefetchAddrOp2PrefetchAddrOp3PrefetchByteArrayOp0PrefetchByteArrayOp1PrefetchByteArrayOp2PrefetchByteArrayOp3PrefetchMutableByteArrayOp0PrefetchMutableByteArrayOp1PrefetchMutableByteArrayOp2PrefetchMutableByteArrayOp3PrefetchValueOp0PrefetchValueOp1PrefetchValueOp2PrefetchValueOp3 PutMVarOp RaiseIOOpRaiseOpReadArrayArrayOp_ArrayArrayReadArrayArrayOp_ByteArray"ReadArrayArrayOp_MutableArrayArray!ReadArrayArrayOp_MutableByteArray ReadArrayOpReadByteArrayOp_AddrReadByteArrayOp_CharReadByteArrayOp_DoubleReadByteArrayOp_FloatReadByteArrayOp_IntReadByteArrayOp_Int16ReadByteArrayOp_Int32ReadByteArrayOp_Int64ReadByteArrayOp_Int8ReadByteArrayOp_StablePtrReadByteArrayOp_WideCharReadByteArrayOp_WordReadByteArrayOp_Word16ReadByteArrayOp_Word32ReadByteArrayOp_Word64ReadByteArrayOp_Word8ReadByteArrayOp_Word8AsAddrReadByteArrayOp_Word8AsCharReadByteArrayOp_Word8AsDoubleReadByteArrayOp_Word8AsFloatReadByteArrayOp_Word8AsIntReadByteArrayOp_Word8AsInt16ReadByteArrayOp_Word8AsInt32ReadByteArrayOp_Word8AsInt64 ReadByteArrayOp_Word8AsStablePtrReadByteArrayOp_Word8AsWideCharReadByteArrayOp_Word8AsWordReadByteArrayOp_Word8AsWord16ReadByteArrayOp_Word8AsWord32ReadByteArrayOp_Word8AsWord64 ReadIOPortOp ReadMVarOp ReadMutVarOpReadOffAddrOp_AddrReadOffAddrOp_CharReadOffAddrOp_DoubleReadOffAddrOp_FloatReadOffAddrOp_IntReadOffAddrOp_Int16ReadOffAddrOp_Int32ReadOffAddrOp_Int64ReadOffAddrOp_Int8ReadOffAddrOp_StablePtrReadOffAddrOp_WideCharReadOffAddrOp_WordReadOffAddrOp_Word16ReadOffAddrOp_Word32ReadOffAddrOp_Word64ReadOffAddrOp_Word8ReadSmallArrayOp ReadTVarIOOp ReadTVarOpReallyUnsafePtrEqualityOpResizeMutableByteArrayOp_CharRetryOp SameIOPortOp SameMVarOp SameMutVarOpSameMutableArrayArrayOpSameMutableArrayOpSameMutableByteArrayOpSameSmallMutableArrayOp SameTVarOpSeqOpSetByteArrayOpSetThreadAllocationCounterShrinkMutableByteArrayOp_CharShrinkSmallMutableArrayOp_CharSizeofArrayArrayOp SizeofArrayOpSizeofByteArrayOpSizeofMutableArrayArrayOpSizeofMutableArrayOpSizeofMutableByteArrayOpSizeofSmallArrayOpSizeofSmallMutableArrayOpSparkOpStableNameToIntOp TagToEnumOp TakeMVarOp ThawArrayOpThawSmallArrayOpThreadStatusOpTouchOpTraceEventBinaryOp TraceEventOp TraceMarkerOp TryPutMVarOp TryReadMVarOp TryTakeMVarOpUnmaskAsyncExceptionsOpUnpackClosureOpUnsafeFreezeArrayArrayOpUnsafeFreezeArrayOpUnsafeFreezeByteArrayOpUnsafeFreezeSmallArrayOpUnsafeThawArrayOpUnsafeThawSmallArrayOpVecAddOpVecBroadcastOpVecDivOpVecIndexByteArrayOpVecIndexOffAddrOpVecIndexScalarByteArrayOpVecIndexScalarOffAddrOp VecInsertOpVecMulOpVecNegOp VecPackOp VecQuotOpVecReadByteArrayOpVecReadOffAddrOpVecReadScalarByteArrayOpVecReadScalarOffAddrOpVecRemOpVecSubOp VecUnpackOpVecWriteByteArrayOpVecWriteOffAddrOpVecWriteScalarByteArrayOpVecWriteScalarOffAddrOp WaitReadOp WaitWriteOp WhereFromOp Word16AddOp Word16AndOp Word16EqOp Word16GeOp Word16GtOp Word16LeOp Word16LtOp Word16MulOp Word16NeOp Word16NotOp Word16OrOp Word16QuotOpWord16QuotRemOp Word16RemOp Word16SllOp Word16SrlOp Word16SubOpWord16ToInt16OpWord16ToWordOp Word16XorOp Word32AddOp Word32AndOp Word32EqOp Word32GeOp Word32GtOp Word32LeOp Word32LtOp Word32MulOp Word32NeOp Word32NotOp Word32OrOp Word32QuotOpWord32QuotRemOp Word32RemOp Word32SllOp Word32SrlOp Word32SubOpWord32ToInt32OpWord32ToWordOp Word32XorOp Word8AddOp Word8AndOp Word8EqOp Word8GeOp Word8GtOp Word8LeOp Word8LtOp Word8MulOp Word8NeOp Word8NotOp Word8OrOp Word8QuotOpWord8QuotRemOp Word8RemOp Word8SllOp Word8SrlOp Word8SubOp Word8ToInt8Op Word8ToWordOp Word8XorOp WordAdd2Op WordAddCOp WordAddOp WordAndOpWordEqOpWordGeOpWordGtOpWordLeOpWordLtOp WordMul2Op WordMulOpWordNeOp WordNotOpWordOrOp WordQuotOpWordQuotRem2Op WordQuotRemOp WordRemOp WordSllOp WordSrlOp WordSubCOp WordSubOpWordToDoubleOp WordToFloatOp WordToIntOpWordToWord16OpWordToWord32Op WordToWord8Op WordXorOpWriteArrayArrayOp_ArrayArrayWriteArrayArrayOp_ByteArray#WriteArrayArrayOp_MutableArrayArray"WriteArrayArrayOp_MutableByteArray WriteArrayOpWriteByteArrayOp_AddrWriteByteArrayOp_CharWriteByteArrayOp_DoubleWriteByteArrayOp_FloatWriteByteArrayOp_IntWriteByteArrayOp_Int16WriteByteArrayOp_Int32WriteByteArrayOp_Int64WriteByteArrayOp_Int8WriteByteArrayOp_StablePtrWriteByteArrayOp_WideCharWriteByteArrayOp_WordWriteByteArrayOp_Word16WriteByteArrayOp_Word32WriteByteArrayOp_Word64WriteByteArrayOp_Word8WriteByteArrayOp_Word8AsAddrWriteByteArrayOp_Word8AsCharWriteByteArrayOp_Word8AsDoubleWriteByteArrayOp_Word8AsFloatWriteByteArrayOp_Word8AsIntWriteByteArrayOp_Word8AsInt16WriteByteArrayOp_Word8AsInt32WriteByteArrayOp_Word8AsInt64!WriteByteArrayOp_Word8AsStablePtr WriteByteArrayOp_Word8AsWideCharWriteByteArrayOp_Word8AsWordWriteByteArrayOp_Word8AsWord16WriteByteArrayOp_Word8AsWord32WriteByteArrayOp_Word8AsWord64 WriteIOPortOp WriteMutVarOpWriteOffAddrOp_AddrWriteOffAddrOp_CharWriteOffAddrOp_DoubleWriteOffAddrOp_FloatWriteOffAddrOp_IntWriteOffAddrOp_Int16WriteOffAddrOp_Int32WriteOffAddrOp_Int64WriteOffAddrOp_Int8WriteOffAddrOp_StablePtrWriteOffAddrOp_WideCharWriteOffAddrOp_WordWriteOffAddrOp_Word16WriteOffAddrOp_Word32WriteOffAddrOp_Word64WriteOffAddrOp_Word8WriteSmallArrayOp WriteTVarOpYieldOpPrimOpResultInfo ReturnsAlg ReturnsPrim PrimOpVecCatFloatVecIntVecWordVec $fEqPrimOp $fOrdPrimOp$fOutputablePrimCall$fOutputablePrimOpfreeNamesIfDeclfreeNamesIfFamInstfreeNamesIfRuleifaceDeclFingerprintsifaceDeclImplicitBndrs pprIfaceDecl pprIfaceExpr showToHeader showToIfacevisibleIfConDeclsAltPprIfaceATIfaceAltIfaceAnnTargetIfaceAnnotationifAnnotatedTargetifAnnotatedValue IfaceAxBranch ifaxbCoVarsifaxbEtaTyVars ifaxbIncompsifaxbLHSifaxbRHS ifaxbRoles ifaxbTyVars IfaceBangIfNoBangIfStrictIfUnpack IfUnpackCo IfaceBinding IfaceNonRecIfaceRecIfaceClassBodyIfAbstractClassIfConcreteClassifATs ifClassCtxtifMinDefifSigs IfaceClassOp IfaceClsInstifDFun ifInstCls ifInstOrph ifInstTysifOFlagIfaceCompleteMatch IfaceConAlt IfaceDataAlt IfaceDefault IfaceLitAlt IfaceConDeclIfCon ifConArgTys ifConCtxt ifConEqSpec ifConExTCvs ifConFields ifConInfix ifConNameifConSrcStricts ifConStrictsifConUserTvBinders ifConWrapper IfaceConDeclsIfAbstractTyCon IfDataTyCon IfNewTyCon IfaceDecl IfaceAxiom IfaceClass IfaceData IfaceFamilyIfaceId IfacePatSyn IfaceSynonym ifAxBranches ifBindersifBodyifCTypeifConsifCtxtifFDs ifFamFlavifFamInj ifFieldLabels ifGadtSyntax ifIdDetailsifIdInfoifNameifParent ifPatArgs ifPatBuilder ifPatExBndrs ifPatIsInfix ifPatMatcher ifPatProvCtxt ifPatReqCtxtifPatTyifPatUnivBndrs ifResKindifResVarifRoleifRolesifSynRhsifTyConifType IfaceEqSpec IfaceExprIfaceApp IfaceCase IfaceCastIfaceCo IfaceECaseIfaceExt IfaceFCallIfaceLamIfaceLclIfaceLetIfaceLit IfaceTick IfaceTuple IfaceFamInstifFamInstAxiom ifFamInstFam ifFamInstOrph ifFamInstTysIfaceFamTyConFlav!IfaceAbstractClosedSynFamilyTyConIfaceBuiltInSynFamTyConIfaceClosedSynFamilyTyConIfaceDataFamilyTyConIfaceOpenSynFamilyTyConIfaceIdDetailsIfDFunId IfRecSelId IfVanillaId IfaceIdInfo IfaceInfoItemHsArityHsCprHsInlineHsLFInfoHsLevity HsNoCafRefs HsStrictnessHsUnfold IfaceJoinInfoIfaceJoinPointIfaceNotJoinPoint IfaceLFInfoIfLFCon IfLFReEntrant IfLFThunk IfLFUnknown IfLFUnlifted IfaceLetBndr IfLetBndr IfaceRule ifActivation ifRuleArgs ifRuleAuto ifRuleBndrs ifRuleHead ifRuleName ifRuleOrph ifRuleRhs IfaceSrcBang IfSrcBang IfaceTickish IfaceHpcTickIfaceSCC IfaceSource IfaceTopBndrIfaceTyConParentIfDataInstance IfNoParentIfaceUnfolding IfCompulsory IfCoreUnfold IfDFunUnfold IfInlineRule ShowHowMuch ShowHeader ShowIfaceShowSomeShowSub ss_forall ss_how_much$fBinaryIfaceAT$fBinaryIfaceAlt$fBinaryIfaceAnnotation$fBinaryIfaceAxBranch$fBinaryIfaceBang$fBinaryIfaceBinding$fBinaryIfaceLetBndr$fBinaryIfaceExpr$fBinaryIfaceClassOp$fBinaryIfaceClsInst$fBinaryIfaceCompleteMatch$fBinaryIfaceConAlt$fBinaryIfaceConDecl$fBinaryIfaceConDecls$fBinaryIfaceDecl$fBinaryIfaceFamInst$fBinaryIfaceFamTyConFlav$fBinaryIfaceIdDetails$fBinaryIfaceInfoItem$fBinaryIfaceJoinInfo$fBinaryIfaceLFInfo$fBinaryIfaceRule$fBinaryIfaceSrcBang$fBinaryIfaceTickish$fBinaryIfaceTyConParent$fBinaryIfaceUnfolding$fHasOccNameIfaceClassOp$fHasOccNameIfaceConDecl$fHasOccNameIfaceDecl$fNFDataIfaceAT$fNFDataIfaceAlt$fNFDataIfaceAnnotation$fNFDataIfaceAxBranch$fNFDataIfaceBang$fNFDataIfaceBinding$fNFDataIfaceClassBody$fNFDataIfaceClassOp$fNFDataIfaceClsInst$fNFDataIfaceCompleteMatch$fNFDataIfaceConAlt$fNFDataIfaceConDecl$fNFDataIfaceConDecls$fNFDataIfaceDecl$fNFDataIfaceExpr$fNFDataIfaceFamInst$fNFDataIfaceFamTyConFlav$fNFDataIfaceIdDetails$fNFDataIfaceInfoItem$fNFDataIfaceJoinInfo$fNFDataIfaceLetBndr$fNFDataIfaceRule$fNFDataIfaceSrcBang$fNFDataIfaceTickish$fNFDataIfaceTyConParent$fNFDataIfaceUnfolding$fNamedThingIfaceClassOp$fNamedThingIfaceConDecl$fNamedThingIfaceDecl$fOutputableIfaceAT$fOutputableIfaceAnnotation$fOutputableIfaceClassOp$fOutputableIfaceClsInst$fOutputableIfaceCompleteMatch$fOutputableIfaceConAlt$fOutputableIfaceDecl$fOutputableIfaceExpr$fOutputableIfaceFamInst$fOutputableIfaceIdDetails$fOutputableIfaceInfoItem$fOutputableIfaceJoinInfo$fOutputableIfaceLFInfo$fOutputableIfaceRule$fOutputableIfaceTyConParent$fOutputableIfaceUnfolding$fOutputableShowHowMuch coreBindsSizecoreBindsStatsexprSize exprStats CoreStatsCScs_cocs_jbcs_tmcs_tycs_vb$fOutputableCoreStats simpleOptExpr so_uf_opts SimpleOpts megaSeqIdInfoseqBindsseqExprseqExprs seqRuleInfoseqRules seqUnfoldingtidyExpr tidyRules tidyUnfolding pprCoreAlt pprCoreBinderpprCoreBinderspprCoreBindingpprCoreBindingWithSizepprCoreBindingspprCoreBindingsWithSize pprCoreExprpprOptCo pprParendExprpprRules$fOutputableAlt$fOutputableBind$fOutputableBndrTaggedBndr$fOutputableBndrVar$fOutputableCoreRule$fOutputableExpr$fOutputableGenTickish$fOutputableIdInfo$fOutputableUnfolding$fOutputableUnfoldingGuidance$fOutputableUnfoldingSource bindersOfTopbindersOfTopBinds freeVarsOfRhsinitStgPprOpts isDllConApp isUpdatablenoExtFieldSilentpanicStgPprOptspprGenStgTopBindingpprGenStgTopBindings pprStgArg pprStgBinding pprStgExpr pprStgRhspprStgTopBindingpprStgTopBindingsshortStgPprOpts stgArgTypestgCaseBndrInScope stgRhsAritystripStgTicksTopstripStgTicksTopEAltTypeAlgAlt MultiValAltPolyAltPrimAltBinderPCgStgAlt CgStgBinding CgStgExprCgStgRhsCgStgTopBindingConstructorNumberNoNumberNumbered GenStgAlt GenStgBinding StgNonRecStgRec GenStgExprStgAppStgCase StgConAppStgLetStgLetNoEscapeStgLitStgOpAppStgTick GenStgRhs StgRhsClosure StgRhsConGenStgTopBinding StgTopLiftedStgTopStringLitInStgAltInStgArg InStgBinding InStgExprInStgRhsInStgTopBindingLlStgAlt LlStgBinding LlStgExprLlStgRhsLlStgTopBindingNoExtFieldSilent OutStgAlt OutStgArg OutStgBinding OutStgExpr OutStgRhsOutStgTopBindingOutputablePassStgAltStgArg StgLitArg StgVarArg StgBindingStgExprStgOp StgFCallOp StgPrimCallOp StgPrimOpStgPassCodeGenLiftLamsVanilla StgPprOpts stgSccEnabledStgRhs StgTopBinding UpdateFlag ReEntrant SingleEntry UpdatableXConApp XLetNoEscape XRhsClosure$fDataNoExtFieldSilent$fEqNoExtFieldSilent$fOrdNoExtFieldSilent$fOutputableAltType$fOutputableConstructorNumber$fOutputableNoExtFieldSilent$fOutputableStgArg$fOutputableUpdateFlag showStgStats$fEqCounterType$fOrdCounterTypeannBindingFreeVarsannTopBindingsFreeVars depSortStgPgmcollectDebugInformation addLabelSizedynamicLinkerLabelInfoexternallyVisibleCLabelforeignLabelStdcallInfogetConInfoTableLocationhasCAFhasHaskellNamehasIdLabelInfo isBytesLabelisCFunctionLabelisConInfoTableLabelisForeignLabel isGcPtrLabel isIdLabelisInfoTableLabel isLocalCLabel isMathFunisSomeRODataLabelisStaticClosureLabel isTickyLabel labelDynamic mayRedirectTomaybeLocalBlockLabelmkApEntryLabelmkApInfoTableLabelmkArrWords_infoLabelmkAsmTempDerivedLabelmkAsmTempDieLabelmkAsmTempEndLabelmkAsmTempLabelmkAsmTempProcEndLabelmkBHUpdInfoLabelmkBadAlignmentLabel mkBitmapLabelmkBlockInfoTableLabel mkBytesLabelmkCAFBlackHoleInfoTableLabel mkCCLabel mkCCSLabelmkClosureLabelmkClosureTableLabelmkCmmClosureLabelmkCmmCodeLabelmkCmmDataLabelmkCmmEntryLabelmkCmmInfoLabelmkCmmRetInfoLabel mkCmmRetLabelmkConInfoTableLabelmkDeadStripPreventermkDirty_MUT_VAR_LabelmkDynamicLinkerLabel mkEntryLabelmkForeignLabelmkHpcTicksLabel mkIPELabelmkIndStaticInfoLabelmkInfoTableLabelmkLocalBlockLabelmkLocalClosureLabelmkLocalClosureTableLabelmkLocalInfoTableLabelmkMAP_DIRTY_infoLabelmkMAP_FROZEN_CLEAN_infoLabelmkMAP_FROZEN_DIRTY_infoLabelmkMainCapabilityLabel#mkNonmovingWriteBarrierEnabledLabelmkOutOfBoundsAccessLabelmkPicBaseLabelmkPrimCallLabelmkRednCountsLabelmkRtsApFastLabelmkRtsCmmDataLabelmkRtsPrimOpLabelmkRtsSlowFastTickyCtrLabelmkSMAP_DIRTY_infoLabelmkSMAP_FROZEN_CLEAN_infoLabelmkSMAP_FROZEN_DIRTY_infoLabelmkSRTInfoLabel mkSRTLabelmkSelectorEntryLabelmkSelectorInfoLabelmkStringLitLabelmkTopTickyCtrLabelmkUpdInfoLabel needsCDeclppInternalProcLabel pprCLabelpprDebugCLabel toClosureLbl toEntryLbl toInfoLbltoSlowEntryLblCLabelConInfoTableLocationDefinitionSite UsageSiteDynamicLinkerLabelInfoCodeStubGotSymbolOffset GotSymbolPtr SymbolPtrForeignLabelSourceForeignLabelInExternalPackageForeignLabelInPackageForeignLabelInThisPackage InfoProvEntinfoProvEntClosureTypeinfoProvModule infoTableProv infoTablePtr infoTableTypeNeedExternDecl $fEqCLabel$fEqCmmLabelInfo$fEqConInfoTableLocation$fEqDynamicLinkerLabelInfo$fEqForeignLabelSource$fEqIdLabelInfo$fEqInfoProvEnt$fEqNeedExternDecl$fEqRtsLabelInfo $fOrdCLabel$fOrdCmmLabelInfo$fOrdConInfoTableLocation$fOrdDynamicLinkerLabelInfo$fOrdForeignLabelSource$fOrdIdLabelInfo$fOrdInfoProvEnt$fOrdNeedExternDecl$fOrdRtsLabelInfo$fOutputableCLabel $fOutputableConInfoTableLocation$fOutputableForeignLabelSource$fOutputableIdLabelInfo$fOutputablePPlatformCLabel $fShowCLabelblockLbl infoTblLbl newBlockIdnoUsage InstructionisJumpishInstr isMetaInstrjumpDestsOfInstr mkComment mkJumpInstr mkLoadInstrmkRegRegMoveInstr mkSpillInstrmkStackAllocInstrmkStackDeallocInstrpatchJumpInstrpatchRegsOfInstrpprInstrregUsageOfInstrtakeDeltaInstrtakeRegRegMoveInstrRegUsageRUwrites$fShowRegUsagebaseRegcccsRegcmmExprAlignment cmmExprType cmmExprWidth cmmLitType cmmRegType cmmRegWidthcurrentNurseryReg currentTSORegdeleteFromRegSet elemRegSet emptyRegSet extendRegSetfoldLocalRegsDefdfoldLocalRegsUsed globalRegType hpAllocReghpLimReghpRegisArgReg localRegTypemaybeInvertCmmExpr minusRegSetmkRegSetnodenodeReg nullRegSet plusRegSet regSetToList sizeRegSetspLimRegspReg timesRegSet AlignmentSpecNaturallyAligned UnalignedAreaOldYoungCmmExprCmmLitCmmLoad CmmMachOpCmmReg CmmRegOff CmmStackSlotCmmBlockCmmFloatCmmHighStackMarkCmmIntCmmLabelCmmLabelDiffOff CmmLabelOffCmmVec CmmGlobalCmmLocal DefinerOfRegs foldRegsDefd GlobalRegBaseRegCCCSCurrentNursery CurrentTSO DoubleRegEagerBlackholeInfoFloatRegGCEnter1GCFunHpHpAllocHpLimLongRegMachSp PicBaseRegSpSpLimUnwindReturnReg VanillaRegXmmRegYmmRegZmmReg GlobalRegSetLocalReg LocalRegSetRegSet UserOfRegs foldRegsUsedVGcPtr VNonGcPtr$fDefinerOfRegsGlobalRegCmmReg$fOrdGlobalReg$fDefinerOfRegsLocalRegCmmReg $fOrdLocalReg$fDefinerOfRegsr[]$fDefinerOfRegsrr$fEqAlignmentSpec$fEqArea $fEqCmmExpr $fEqCmmLit $fEqCmmReg $fEqGlobalReg $fEqLocalReg $fEqVGcPtr$fOrdAlignmentSpec $fOrdArea $fOrdCmmReg$fOutputableCmmLit$fShowAlignmentSpec $fShowArea $fShowCmmExpr $fShowCmmLit $fShowCmmReg$fShowGlobalReg$fShowLocalReg $fShowVGcPtr$fUniquableLocalReg$fUserOfRegsGlobalRegCmmReg$fUserOfRegsLocalRegCmmReg$fUserOfRegsrCmmExpr$fUserOfRegsr[]$fUserOfRegsrr activeStgRegs callerSavesfreeReg freeRegBaseglobalRegMaybe haveRegBasepprExprpprLit$fOutputableArea$fOutputableCmmReg$fOutputableGlobalReg$fOutputableLocalReg$fOutputablePPlatformCmmExpr$fOutputablePPlatformCmmLit$fOutputablePenvGlobalRegdeleteFromLRegSet elemLRegSet elemsLRegSet emptyLRegSet insertLRegSet nullLRegSet plusLRegSet sizeLRegSetLRegKeyLRegSetemptyModBreaksseqCompiledByteCode voidTupleInfoBCONPtr BCONPtrItbl BCONPtrLbl BCONPtrStr BCONPtrWordBCOPtr BCOPtrBCOBCOPtrBreakArray BCOPtrName BCOPtrPrimOp BreakIndex CCostCentre CgBreakInfo cgb_restycgb_varsCompiledByteCodebc_bcos bc_breaksbc_ffisbc_itblsbc_strsFFIInfoItblEnvItblPtrmodBreaks_breakInfo modBreaks_ccsmodBreaks_declsmodBreaks_flagsmodBreaks_locsmodBreaks_vars RegBitmap unRegBitmap TupleInfotupleNativeStackSize tupleRegs tupleSize UnlinkedBCOunlinkedBCOArityunlinkedBCOBitmapunlinkedBCOInstrsunlinkedBCOLitsunlinkedBCONameunlinkedBCOPtrs$fBitsRegBitmap $fEqRegBitmap $fEnumByteOff$fEnumRegBitmap $fEnumWordOff $fEqByteOff $fEqWordOff$fFiniteBitsRegBitmap$fIntegralByteOff $fRealByteOff$fIntegralRegBitmap$fRealRegBitmap$fIntegralWordOff $fRealWordOff$fNFDataBCONPtr$fNFDataBCOPtr$fNFDataFFIInfo$fNFDataItblPtr$fNFDataUnlinkedBCO $fNumByteOff$fNumRegBitmap $fNumWordOff $fOrdByteOff$fOrdRegBitmap $fOrdWordOff$fOutputableByteOff$fOutputableCgBreakInfo$fOutputableCompiledByteCode$fOutputableRegBitmap$fOutputableTupleInfo$fOutputableUnlinkedBCO$fOutputableWordOff $fShowByteOff $fShowFFIInfo $fShowItblPtr$fShowRegBitmap$fShowTupleInfo $fShowWordOffbyteCodeOfObjectisInterpretableisObjectisObjectLinkable linkableObjs nameOfObjectuninitializedLoaderLinkableLMlinkableModule linkableTimelinkableUnlinkedLoader loader_state LoaderState bcos_loaded closure_envitbl_env objs_loaded pkgs_loadedtemp_sosSptEntryUnlinkedBCOsDotADotDLLDotO$fOutputableLinkable$fOutputableSptEntry$fOutputableUnlinkedIServ IServConfigiservConfDynamic iservConfHook iservConfOptsiservConfProfilediservConfProgramiservConfTrace IServInstanceiservLookupSymbolCacheiservPendingFrees iservPipe iservProcess IServState IServPending IServRunningInterpinterpInstance interpLoaderInterpInstanceExternalInterpInternalInterp emptyCoreMap extendCoreMap foldCoreMap lookupCoreMap$fOutputableCoreMap$fTrieMapAltMap$fTrieMapCoreMap$fTrieMapCoreMapXstgCse$fTrieMapConAppMap$fTrieMapStgArgMap bindFreeVarsbndrRuleAndUnfoldingIdsbndrRuleAndUnfoldingVarsDSet dIdFreeVars exprFreeIdsexprFreeIdsDSetexprFreeIdsList exprFreeVarsexprFreeVarsDSetexprFreeVarsListexprSomeFreeVarsexprSomeFreeVarsListexpr_fvs exprsFreeIdsexprsFreeIdsDSetexprsFreeIdsList exprsFreeVarsexprsFreeVarsListexprsOrphNamesexprsSomeFreeVarsexprsSomeFreeVarsListfreeVars freeVarsBind freeVarsOf freeVarsOfAnnidFVs idFreeVars idRuleVarsidUnfoldingVars mkRuleInfoorphNamesOfAxiom orphNamesOfCoorphNamesOfCoConorphNamesOfFamInstorphNamesOfTypeorphNamesOfTypes ruleFreeVarsruleLhsFreeIdsruleLhsFreeIdsListruleRhsFreeVars rulesFreeVarsrulesFreeVarsDSetrulesRhsFreeIdsstableUnfoldingVarsvarTypeTyCoFVsvarTypeTyCoVarsCoreAltWithFVsCoreBindWithFVsCoreExprWithFVsCoreExprWithFVs'FVAnnanyRewritableCanEqLHSanyRewritableTyFamAppanyRewritableTyVar boxEqPredcheckValidClsArgs deNoteTypedeeperThanOrSame evVarPredexactTyCoVarsOfTypeexactTyCoVarsOfTypesfindDupTyVarTvs getDFunTyKey hasTyVarHeadimmSuperClassesisAmbiguousTyVarisBoolTyisCallStackPred isCallStackTyisCharTyisCycleBreakerTyVar isDoubleTyisFFIArgumentTy isFFIDynTyisFFIExportResultTyisFFIExternalTyisFFIImportResultTy isFFILabelTyisFFIPrimArgumentTyisFFIPrimResultTyisFFITyisFlexi isFloatTy isFloatingTy isFunPtrTyisImmutableTyVarisImprovementPred isIndirectisIntTy isIntegerTy isMetaTyVarTy isNaturalTyisNextArgVisibleisNextTyConArgVisibleisOverlappableTyVarisOverloadedTyisPromotableMetaTyVar isRhoExpTyisRhoTy isRigidTyisRuntimeUnkSkol isSigmaTy isSkolemTyVar isStringTy isTopTcLevelisTouchableMetaTyVar isTyFamFreeisTyVarClassPred isTyVarTyVarisUnitTyisWordTy maxTcLevel metaTyVarInfo metaTyVarRefmetaTyVarTcLevelmetaTyVarTcLevel_maybemkCheckExpType mkInfSigmaTymkMinimalBySCsmkPhiTy mkSigmaTy mkSpecSigmaTy mkSynFunTys mkTcAppTy mkTcAppTys mkTcCastTymkTyVarNamePairspickCapturedPredspickQuantifiablePreds pickyEqType promoteSkolempromoteSkolemXpromoteSkolemsX pushTcLevel sameDepthAssetMetaTyVarTcLevelsizeType sizeTypesstrictlyDeeperThan superSkolemTv synKnownTypetcEqKind tcEqTyConAppstcEqTypetcEqTypeNoKindCheck tcEqTypeVis tcFunArgTy tcFunResultTytcFunResultTyNtcGetCastedTyVar_maybe tcGetTyVartcGetTyVar_maybe tcIsForAllTy tcIsTcTyVar tcIsTyVarTytcRepGetNumAppTys tcSplitAppTytcSplitAppTy_maybe tcSplitAppTystcSplitDFunHead tcSplitDFunTytcSplitForAllInvisTVBinderstcSplitForAllInvisTyVarstcSplitForAllReqTVBinderstcSplitForAllTyVarBinder_maybetcSplitForAllTyVarBinderstcSplitForAllTyVarstcSplitFunTy_maybe tcSplitFunTystcSplitFunTysNtcSplitIOType_maybetcSplitMethodTytcSplitNestedSigmaTys tcSplitPhiTytcSplitPiTy_maybe tcSplitPiTystcSplitPredFunTy_maybetcSplitSigmaTytcSplitSomeForAllTyVarstcSplitTyConApptcTyConAppArgstcTyConAppTyContcTyConAppTyCon_maybetcTyConAppTyFamInstsAndVistcTyConVisibilities tcTyFamInststcTyFamInstsAndVis tcTyVarLevel tcTypeLevel topTcLeveltransSuperClasses ExpRhoType ExpSigmaTypeExpTypeCheckInfer InferResultIRir_lvlir_refir_uniqFlexiIndirectMetaInfoCycleBreakerTv RuntimeUnkTvTauTvTyVarTv SyntaxOpTypeSynAnySynFunSynListSynRhoSynTypeTcCoVar TcDTyCoVarSet TcDTyVarSetTcInvisTVBinderTcKindTcLevel TcPredType TcReqTVBinder TcRhoType TcSigmaType TcTauType TcThetaType TcTyCoVar TcTyCoVarSetTcTyCon TcTyVarBinderMetaTv RuntimeUnkSkolemTvmtv_infomtv_ref mtv_tclvl TcTyVarSetTcTypeTypeSize $fEqTcLevel $fOrdTcLevel$fOutputableExpType$fOutputableInferResult$fOutputableMetaDetails$fOutputableMetaInfo$fOutputableTcLevel$fOutputableTcTyVarDetails getLclEnvLocgetLclEnvTcLevel setLclEnvLocsetLclEnvTcLevelTcLclEnvclassInstancesdeleteDFunFromInstEnvdeleteFromInstEnv emptyInstEnv extendInstEnvextendInstEnvListfuzzyClsInstCmpidenticalClsInstHeadinstEnvClasses instEnvElts instIsVisibleinstanceBindFuninstanceDFunId instanceHeadinstanceRoughTcs instanceSig isIncoherentisOverlappable isOverlapping lookupInstEnvlookupUniqueInstEnv memberInstEnvmkImportedInstancemkLocalInstanceorphNamesOfClsInst pprInstancepprInstanceHdr pprInstancesupdateClsInstDFunClsInstis_cls is_cls_nmis_dfun is_dfun_nameis_flag is_orphanis_tcsis_tvsis_tysClsInstLookupResult DFunInstTypeInstEnvInstEnvs ie_globalie_local ie_visible InstMatchVisibleOrphanModules $fDataClsInst$fNamedThingClsInst$fOutputableClsInst$fOutputableClsInstEnvemptyModDetails ModDetailsmd_annsmd_complete_matches md_exports md_fam_instsmd_instsmd_rulesmd_types checkFunDepscheckInstCoverageimproveFromAnotherimproveFromInstEnv pprEquation FunDepEqnFDEqnfd_eqsfd_locfd_pred1fd_pred2fd_qtvs$fOutputableFunDepEqn checkAxInstCo optCoercionOptCoercionOptsoptCoercionEnabled<.>applyQuoteWrappercollectHsWrapBindersemptyEvBindMapemptyTcEvBindsevBindMapBindsevBindMapToVarSet evBindVarevCast evCoercion evDFunApp evDataConAppevId evSelectorevTermCoercionevTermCoercion_maybe evTypeable evVarsOfTerm extendEvBindsfilterEvBindMapfindNeededEvVars foldEvBindMaphsWrapDictBinders idHsWrapperisCoEvBindsVarisEmptyEvBindMapisEmptyTcEvBinds isIdHsWrapper isTcReflCoisTcReflexiveCo lookupEvBind maybeTcSubCo maybeTcSymComkEvCastmkEvScSelectors mkGivenEvBind mkTcAppCo mkTcAxInstComkTcAxiomRuleCo mkTcCoVarComkTcCoherenceLeftComkTcCoherenceRightComkTcFamilyTyConAppCo mkTcForAllCo mkTcForAllCos mkTcFunComkTcGReflLeftComkTcGReflLeftMComkTcGReflRightComkTcGReflRightMCo mkTcKindComkTcLRCo mkTcNomReflCo mkTcNthCo mkTcPhantomCo mkTcReflCo mkTcRepReflCo mkTcSubCo mkTcSymCo mkTcSymMCo mkTcTransComkTcTyConAppComkTcUnbranchedAxInstComkWantedEvBind mkWpCastN mkWpCastR mkWpEvApps mkWpEvVarAppsmkWpFunmkWpLamsmkWpLet mkWpTyApps mkWpTyLamsnonDetStrictFoldEvBindMap pprHsWrapperquoteWrapperTyVarTytcCoercionKindtcCoercionRoletcDowngradeRoleunwrapIPvarSetMinusEvBindMapwrapIPEvBind eb_is_giveneb_lhseb_rhs EvBindMapev_bind_varenv EvBindsVar CoEvBindsVar ebv_bindsebv_tcvsebv_uniq EvCallStack EvCsEmpty EvCsPushCallEvExprEvTermEvFun EvTypeableet_bindset_bodyet_givenet_tvsEvTypeableTrFunEvTypeableTyAppEvTypeableTyConEvTypeableTyLit HoleExprRefHER HsWrapperWpCast WpComposeWpEvAppWpEvLamWpFunWpHoleWpLetWpMultCoercionWpTyAppWpTyLam QuoteWrapper TcCoercion TcCoercionN TcCoercionP TcCoercionR TcEvBindsEvBinds TcMCoercion TcMCoercionN TcMCoercionR$fDataEvCallStack $fDataEvTerm$fDataEvTypeable$fDataHoleExprRef$fDataHsWrapper$fDataQuoteWrapper$fDataTcEvBinds$fOutputableEvBind$fOutputableEvBindMap$fOutputableEvBindsVar$fOutputableEvCallStack$fOutputableEvTerm$fOutputableEvTypeable$fOutputableHoleExprRef$fOutputableHsWrapper$fOutputableTcEvBinds$fUniquableEvBindsVar addDefaultaltsAreExhaustiveapplyTypeToArgs bindNonRec cheapEqExpr cheapEqExpr'collectMakeStaticArgscombineIdenticalAlts coreAltType coreAltsTypedataConRepFSInstPat diffBindsdiffExprdumpIdInfoOfProgrameqExpr exprIsCheap exprIsCheapX exprIsConLike exprIsDeadEnd exprIsDupableexprIsExpandable exprIsHNFexprIsTickedStringexprIsTickedString_maybeexprIsTopLevelBindable exprIsTrivialexprIsWorkFreeexprOkForSideEffectsexprOkForSpeculationexprType filterAltsfindAlt findDefaultgetIdFromTrivialExprgetIdFromTrivialExpr_maybe isCheapApp isDefaultAlt isEmptyTyisExpandableApp isExprLevPoly isJoinBindisUnsafeEqualityProof mergeAlts mkAltExprmkCast mkCastMCo mkDefaultCase mkLamType mkLamTypesmkPiMComkSingleAltCasemkTick mkTickNoHNFmkTicksneedsCaseBindingrefineDefaultAlt scaleAltsBy stripTicksE stripTicksT stripTicksTopstripTicksTopEstripTicksTopT tickHNFArgs trimConArgs tryEtaReduce zapLamBndrs CheapAppFunaddLiftedBindingaddTopStringLit collectFloatsdecomposeStgBindingendBindingGroupformerFreeVarsisLifted mkStgBindingrunLiftMstartBindingGroupsubstOccwithLiftedBndrwithLiftedBndrs withSubstBndrwithSubstBndrsEnve_dflags e_expansionse_subst FloatLangEndBindingGroup LiftedBindingPlainTopBindingStartBindingGroupLiftM$fApplicativeLiftM$fFunctorLiftM$fHasDynFlagsLiftM $fMonadLiftM$fMonadUniqueLiftM$fOutputableFloatLangcalcUnfoldingGuidancecallSiteInlinecertainlyWillInlinecouldBeSmallEnoughToInlineinlineBoringOksmallEnoughToInline ArgSummary NonTrivArgTrivArgValueArgCallCtxt BoringCtxtCaseCtxt DiscArgCtxtRhsCtxt RuleArgCtxt ValAppCtxtunfoldingCaseScalingunfoldingCaseThresholdunfoldingCreationThresholdunfoldingDictDiscountunfoldingFunAppDiscountunfoldingUseThresholdunfoldingVeryAggressive$fOutputableArgSummary$fOutputableCallCtxt$fOutputableExprSize liberateCase doStaticArgs cloneBndr cloneBndrs cloneIdBndr cloneIdBndrscloneRecIdBndrs deShadowBindsdelBndrdelBndrs extendIdSubstextendIdSubstListextendInScopeIdsextendInScopeListextendSubstListextendSubstWithVar getTCvSubst isEmptySubstlookupTCvSubst mkOpenSubstmkSubst setInScope substBind substBindSC substDVarSet substExpr substExprSC substIdInfo substIdOcc substIdType substInScope substRecBndrs substRuleInfosubstRulesForImportedIds substTickishsubstUnfoldingsubstUnfoldingSC zapSubstEnv$fOutputableSubstexitifyProgram cseOneExpr cseProgramarityTypeAritycollectBindersPushingCo etaExpand etaExpandATetaExpandToJoinPointetaExpandToJoinPointRuleexpandableArityType exprArityexprBotStrictness_maybeexprEtaExpandArity findRhsArity idArityType joinRhsArity manifestArity maxWithAritymkBotArityTypemkTopArityType pushCoArg pushCoArgs pushCoDataCon pushCoTyArg pushCoValArgpushCoercionIntoLambda typeArity ArityTypeAT $fEqArityType$fOutputableArityTypeoccurAnalyseExproccurAnalysePgm$fOutputableDetails$fOutputableOccEncl$fOutputableUsageDetailsmkCompulsoryUnfoldingmkCompulsoryUnfolding'mkCoreUnfoldingmkDFunUnfoldingmkFinalUnfoldingmkInlinableUnfoldingmkInlineUnfoldingmkInlineUnfoldingWithAritymkSimpleUnfolding mkUnfoldingmkWorkerUnfoldingmkWwInlineRule specUnfoldingcallArityAnalProgram callArityRHScombineTickScopesfoldExp foldExpDeepforeignTargetHintsisTickSubScopemapCollectSuccessorsmapExp mapExpDeep mapExpDeepMmapExpM mapSuccessors wrapRecExp wrapRecExpM wrapRecExpf CmmActual CmmFormalCmmNode CmmAssign CmmBranchCmmCall CmmComment CmmCondBranchCmmEntryCmmForeignCallCmmStore CmmSwitchCmmTickCmmUnsafeForeignCall CmmUnwindargscml_args cml_args_regscml_cont cml_false cml_likelycml_pred cml_ret_args cml_ret_off cml_targetcml_trueintrblresret_argsret_offtgt CmmReturnInfo CmmMayReturnCmmNeverReturns CmmTickScope CombinedScope GlobalScopeSubScope ConventionGCNativeDirectCallNativeNodeCall NativeReturnSlowForeignConvention ForeignTarget PrimTargetUpdFrameOffset$fDefinerOfRegsGlobalRegCmmNode$fDefinerOfRegsLocalRegCmmNode $fEqCmmNode$fEqCmmReturnInfo$fEqCmmTickScope$fEqConvention$fEqForeignConvention$fEqForeignTarget$fNonLocalCmmNode$fOrdCmmTickScope$fOutputableCmmTickScope$fUserOfRegsGlobalRegCmmNode$fUserOfRegsLocalRegCmmNode$fUserOfRegsrForeignTargetblockId pprBBlocksectionProtection topInfoTableCmmDecl CmmDeclSRTsCmmGraphCmmGroup CmmGroupSRTs CmmInfoTablecit_clocit_lblcit_profcit_repcit_srt CmmProgram CmmStackInfo StackInfo arg_space do_layout CmmStatic CmmFileEmbed CmmStaticLit CmmStringCmmUninitialised CmmStatics CmmTopInfoTopInfo info_tbls stack_info GenBasicBlock BasicBlock GenCmmDeclCmmDataCmmProc GenCmmGraphg_entryg_graph GenCmmGroup GenCmmStatics CmmStaticsRaw ListGraph ProfilingInfoNoProfilingInfo RawCmmDecl RawCmmGroup RawCmmStaticsSectionSectionProtectionReadOnlySectionReadWriteSectionWriteProtectedSection SectionTypeCStringData OtherSection ReadOnlyDataReadOnlyData16RelocatableReadOnlyDataTextUninitialisedData$fEqSectionProtection$fFunctorGenBasicBlock$fFunctorGenCmmDecl$fFunctorListGraph$fOutputableCmmStatic$fOutputableGenBasicBlock$fOutputableListGraph$fOutputablePenvGenBasicBlock$fOutputablePenvListGraph$fShowSectionType addrModeRegs addrOffset allArgRegs allFPArgRegs allIntArgRegs allMachRegNosallocatableRegsargRegscallClobberedRegsclassOfRealRegeaxebpebxecxediedxesiespfirstxmminstrClobberedRegslastintlastxmmlitToImmr10r11r12r13r14r15r8r9raxrbprbxrcxrdirdxrealRegSqueezeripRelrsirspshowRegspRel strImmLitvirtualRegSqueezexmmxmm0xmm1xmm10xmm11xmm12xmm13xmm14xmm15xmm2xmm3xmm4xmm5xmm6xmm7xmm8xmm9AddrMode AddrBaseIndexImmAddrEABase EABaseNone EABaseReg EABaseRipEAIndex EAIndexNoneImmImmCLblImmConstantDiffImmConstantSum ImmDoubleImmFloatImmIndexImmInt ImmIntegerImmLit allocateReg getFreeRegs initFreeRegs noFreeRegs releaseRegFreeRegs$fOutputableFreeRegs$fShowFreeRegs entryBlocks NatBasicBlockNatCmm NatCmmDeclHILO AddrRegImm AddrRegReg doubleToBytespprASCII pprFileEmbedpprSectionHeader pprString garbageLitgetLink getLitType getStatType getVarTypei1i128i16i32i64i8i8Ptr initLlvmOptsisFloatisGlobalisInt isPointerisVectorllvmWidthInBitsllvmWord llvmWordPtrnarrowFppLiftpLowerpVarLift pVarLower ppCommaJoinppDoubleppFloatppParams ppSpaceJoinppTypewidenFpLMAlignLMConstAliasConstantGlobalLMGlobalgetGlobalValue getGlobalVar LMSectionLMString LlvmAliasLlvmCallConventionCC_Ccc CC_Coldcc CC_FastccCC_GhcCC_Ncc CC_X86_Stdcc LlvmCallTypeStdCallTailCall LlvmCastOp LM_BitcastLM_Fpext LM_Fptosi LM_Fptoui LM_Fptrunc LM_Inttoptr LM_PtrtointLM_Sext LM_SitofpLM_Trunc LM_UitofpLM_Zext LlvmCmpOp LM_CMP_Eq LM_CMP_Feq LM_CMP_Fge LM_CMP_Fgt LM_CMP_Fle LM_CMP_Flt LM_CMP_Fne LM_CMP_Ne LM_CMP_Sge LM_CMP_Sgt LM_CMP_Sle LM_CMP_Slt LM_CMP_Uge LM_CMP_Ugt LM_CMP_Ule LM_CMP_Ult LlvmFuncAttr AlwaysInline InlineHintNakedNoImplicitFloat NoRedZoneNoReturnNoUnwindOptSizeReadNoneReadOnlySspSspReqLlvmFunctionDecldecName decParams decReturnType decVarargs funcAlignfuncCc funcLinkageLlvmFunctionDeclsLlvmLinkageType Appending ExternWeakExternalExternallyVisibleInternalLinkOncePrivateWeakLlvmLit LMFloatLitLMIntLit LMNullLit LMUndefLit LMVectorLit LlvmMachOp LM_MO_AShr LM_MO_Add LM_MO_And LM_MO_FAdd LM_MO_FDiv LM_MO_FMul LM_MO_FRem LM_MO_FSub LM_MO_LShr LM_MO_MulLM_MO_Or LM_MO_SDiv LM_MO_SRem LM_MO_Shl LM_MO_Sub LM_MO_UDiv LM_MO_URem LM_MO_XorLlvmOptsllvmOptsFillUndefWithGarbagellvmOptsPlatformllvmOptsSplitSections LlvmParamAttrByValInRegNestNoAlias NoCaptureSRetSignExtZeroExt LlvmParameterLlvmParameterListType FixedArgsVarArgs LlvmStaticLMAddLMBitc LMCommentLMPtoI LMStaticArray LMStaticLitLMStaticPointer LMStaticStr LMStaticStrucLMSubLMTrunc LMUninitTypeLlvmTypeLMAliasLMArrayLMDoubleLMFloat LMFloat128 LMFloat80 LMFunctionLMIntLMLabel LMMetadata LMPointerLMStruct LMStructULMVectorLMVoidLlvmVar LMGlobalVarLMLitVar LMLocalVar LMNLocalVar $fEqLMConst$fEqLlvmCallConvention$fEqLlvmCallType$fEqLlvmCastOp $fEqLlvmCmpOp$fEqLlvmFuncAttr$fEqLlvmFunctionDecl $fEqLlvmType$fEqLlvmParamAttr$fEqLlvmLinkageType $fEqLlvmLit$fEqLlvmMachOp$fEqLlvmParameterListType $fEqLlvmVar$fOutputableLlvmCallConvention$fOutputableLlvmCastOp$fOutputableLlvmCmpOp$fOutputableLlvmFuncAttr$fOutputableLlvmFunctionDecl$fOutputableLlvmLinkageType$fOutputableLlvmMachOp$fOutputableLlvmParamAttr$fOutputableLlvmType$fShowLlvmCallType$fShowLlvmParameterListType MetaAnnotMetaDecl MetaNamed MetaUnnamedMetaExprMetaNodeMetaStr MetaStructMetaVarMetaId $fEnumMetaId $fEqMetaAnnot $fEqMetaExpr $fEqMetaId $fOrdMetaId$fOutputableMetaId LlvmAtomicOpLAO_AddLAO_AndLAO_MaxLAO_MinLAO_NandLAO_OrLAO_SubLAO_UmaxLAO_UminLAO_XchgLAO_Xor LlvmBlock blockLabel blockStmts LlvmBlockId LlvmBlocksLlvmExpressionALoadAllocaAsm AtomicRMWCallCallMCmpXChgCompareExtractExtractV GetElemPtrInsertLlvmOpLoadMExprMallocPhi LlvmFunctionfuncArgs funcAttrsfuncBodyfuncDecl funcPrefixfuncSect LlvmFunctions LlvmModule modAliases modCommentsmodFuncs modFwdDecls modGlobalsmodMeta LlvmStatement AssignmentBranchBranchIfCommentFenceMetaStmtMkLabelNopReturnStoreSwitch UnreachableLlvmSyncOrdering SyncAcqRel SyncAcquire SyncMonotonic SyncRelease SyncSeqCst SyncUnordSingleThreaded$fEqLlvmAtomicOp$fEqLlvmExpression$fEqLlvmStatement$fEqLlvmSyncOrdering$fShowLlvmAtomicOp$fShowLlvmSyncOrderingppLit ppLlvmAlias ppLlvmAliases ppLlvmCommentppLlvmCommentsppLlvmFunctionppLlvmFunctionDeclppLlvmFunctionDeclsppLlvmFunctions ppLlvmGlobal ppLlvmGlobals ppLlvmMeta ppLlvmMetas ppLlvmModuleppName ppPlainName ppTypeLitppVar alwaysLivebaseNgetTBAAheapNlmGlobalRegArglmGlobalRegVarrxNstackNstgTBAAtbaatopN cmmTypeFormat floatFormat formatInBytes formatToWidth intFormat isFloatFormat isIntFormatFormatFF32FF64II16II32II64II8 $fEqFormat $fShowFormat mkVirtualReg regDotColor allRealRegsf0f1f22f26f27f6f8fRegfpg0g1g2gRegiReglRego0o1oRegspfpRel maxSpillSlotsspillSlotToOffsetbitMask showFreeRegs fits16Bits makeImmediater0r3r30r4tmpRegtoRegNotocHAHIGHERAHIGHESTAdW_ATE_addressdW_ATE_boolean dW_ATE_float dW_ATE_signeddW_ATE_signed_chardW_ATE_unsigneddW_ATE_unsigned_chardW_AT_comp_dirdW_AT_externaldW_AT_frame_basedW_AT_ghc_span_end_coldW_AT_ghc_span_end_linedW_AT_ghc_span_filedW_AT_ghc_span_start_coldW_AT_ghc_span_start_linedW_AT_ghc_tick_parent dW_AT_high_pcdW_AT_languagedW_AT_linkage_name dW_AT_low_pc dW_AT_namedW_AT_producerdW_AT_stmt_listdW_AT_use_UTF8dW_CFA_def_cfadW_CFA_def_cfa_expressiondW_CFA_def_cfa_offsetdW_CFA_def_cfa_offset_sfdW_CFA_def_cfa_sfdW_CFA_expression dW_CFA_offsetdW_CFA_offset_extended_sfdW_CFA_same_valuedW_CFA_set_locdW_CFA_undefineddW_CFA_val_expressiondW_CFA_val_offsetdW_CHILDREN_nodW_CHILDREN_yes dW_FORM_addrdW_FORM_block1 dW_FORM_data2 dW_FORM_data4 dW_FORM_flagdW_FORM_flag_present dW_FORM_ref4dW_FORM_ref_addrdW_FORM_stringdW_LANG_Haskell dW_OP_addr dW_OP_breg0dW_OP_call_frame_cfa dW_OP_consts dW_OP_deref dW_OP_lit0 dW_OP_minus dW_OP_mul dW_OP_plusdW_TAG_arg_variabledW_TAG_array_typedW_TAG_auto_variabledW_TAG_base_typedW_TAG_compile_unitdW_TAG_file_typedW_TAG_ghc_src_notedW_TAG_lexical_blockdW_TAG_pointer_typedW_TAG_structure_typedW_TAG_subprogramdW_TAG_subrange_typedW_TAG_subroutine_typedW_TAG_typedefdW_TAG_variabledwarfARangesSectiondwarfAbbrevLabeldwarfAbbrevSectiondwarfFrameLabeldwarfFrameSectiondwarfGhcSectiondwarfInfoLabeldwarfInfoSectiondwarfLineLabeldwarfLineSection dwarfRegNodwarfReturnRegNo dwarfSection allFpArgRegs allGpArgRegsAddrReg $fEqAddrMode$fEqImm$fEqSDoc$fShowAddrMode $fShowImm $fShowSDoctargetClassOfRealRegtargetClassOfRegtargetMkVirtualRegtargetRealRegSqueezetargetRegDotColortargetVirtualRegSqueezefpRelEAisUnconditionalJumpmoveSpriZeroInstrADDANDANDNBFBICALLCOMMENTDELTAFABSFADDFCMPFDIVFMOVFMULFNEGFSQRTFSUBFxTOyJMPJMP_TBLLDLDATANEWBLOCKNOPORORNRDYSDIVSETHISLLSMULSRASRLSTSUBUDIVUMULWRYXNORXORRIRIImmRIReg canShortcutgetJumpDestBlockId shortBlockId shortcutJumpshortcutStaticsJumpDest DestBlockIdDestImm$fOutputableJumpDest expandTopgetRegisterRegmangleIndexTreesetFormatOfRegisterAmode ChildCode64CondCode InstrBlockRegisterAnyFixedshowBits_d_xallocMoreStackcallerSavedRegistersd0d1d10d11d12d13d14d15d16d17d18d19d2d20d21d22d23d24d25d26d27d28d29d3d30d31d4d5d6d7d8d9ip0opReg opRegSExt opRegUExt stackAlignstackFrameHeaderSizewzrx0x1x10x11x12x13x14x15x16x17x18x19x2x20x21x22x23x24x25x26x27x28x29x3x30x31x4x5x6x7x8x9xzrExtModeESXTBESXTHESXTWESXTXEUXTBEUXTHEUXTWEUXTXExtShiftANDSANNASRBBCONDBICBICSBLCBNZCBZCMNCMPCSETDMBSYEONEORFCVTFCVTZSJLDPLDRLOCATIONLSLLSRMOVMOVKMSUBMULMULTILINE_COMMENTMVNORRPOP_STACK_FRAMEPUSH_STACK_FRAMERORSBFMSBFXSCVTFSTPSTRSXTBSXTHTSTUBFMUBFXUXTBUXTHOperandOpAddrOpImm OpImmShiftOpRegOpRegExt OpRegShiftRegShift ShiftModeSASRSLSLSLSRSRORTBlockTLabelTReg $fEqExtMode $fEqOperand $fEqShiftMode$fOutputableRegUsage $fShowExtMode $fShowInstr $fShowOperand$fShowShiftMode pprNatCmmDecl$fOutputableInstrbaseExpr blockTicksbodyToBlockListcccsExpr cmmAddWord cmmAndWord cmmConstrTag1 cmmEqWordcmmIndex cmmIndexExpr cmmIsTagged cmmLabelOff cmmLabelOffB cmmLabelOffW cmmLoadBWord cmmLoadGCWord cmmLoadIndex cmmLoadIndexW cmmMkAssign cmmMulWord cmmNeWord cmmNegate cmmOffset cmmOffsetB cmmOffsetExprcmmOffsetExprBcmmOffsetExprW cmmOffsetLit cmmOffsetLitB cmmOffsetLitW cmmOffsetW cmmOrWordcmmPointerMask cmmQuotWord cmmRegOff cmmRegOffB cmmRegOffW cmmSLtWord cmmSubWord cmmTagMask cmmToWord cmmUGeWord cmmUGtWord cmmULtWord cmmUShrWordcmmUntagcurrentNurseryExprcurrentTSOExprfoldlGraphBlockshasNoGlobalRegshpExpr hpLimExprisComparisonExprisLitisTrivialCmmExpr mAX_PTR_TAG mapGraphNodesmapGraphNodes1mkByteStringCLit mkDataLitsmkFileEmbedLit mkIntCLit mkLblExpr mkLiveness mkRODataLits mkStgWordCLit mkWordCLit modifyGraph ofBlockList ofBlockMappackHalfWordsCLitprimRepCmmTypeprimRepForeignHint regUsedIn regsOverlap revPostorder slotCmmTypespExpr spLimExprtAG_MASK toBlockListtoBlockListEntryFirst%toBlockListEntryFirstFalseFallthrough toBlockMap typeCmmTypetypeForeignHintzeroCLitzeroExpr addArgReps addIdReps argPrimRepassertNonVoidIdsassertNonVoidStgArgsblackHoleOnEntrycafBlackHoleInfoTableclosureFunInfoclosureLocalEntryLabelclosureReEntrantclosureSlowEntryLabelclosureUpdReqd fromNonVoidfunTag getCallMethodindStaticInfoTable isKnownFun isLFReEntrant isLFThunk isSmallFamilyisStaticClosureisToplevClosurelfDynTag lfUpdatable mkApLFInfo mkClosureInfo mkCmmInfo mkConLFInfomkDataConInfoTable mkLFArgument mkLFImportedmkLFLetNoEscape mkLFReEntrant mkLFStringLit mkLFThunkmkSelectorLFInfonodeMustPointToIt nonVoidIdsnonVoidStgArgsstaticClosureLabelstaticClosureNeedsLink tagForArity tagForCon CallMethod DirectEntryEnterItJumpToItReturnItSlowCallCallOptsco_loopification co_profileco_tickyCgLocCmmLocLneLoc ClosureInfoclosureInfoLabel closureLFInfo closureNameDynTagNonVoid SelfLoopInfo $fEqNonVoid$fOutputableNonVoid$fOutputablePPlatformCgLoc $fShowNonVoid argRepSizeW argRepStringidArgRepisNonVslowCallPatterntoArgRepArgRepFNPVV16V32V64$fOutputableArgRep baseRegOffsetfixStgRegistersget_GlobalReg_addrget_Regtable_addr_from_offsetregTableOffsetaliasify checkStackReg cmmToLlvmType dumpIfSetLlvm funInsert funLookupgenerateExternDecls getGlobalPtr getLlvmOpts getLlvmVergetMetaUniqueId getPlatform getUniqMeta getUsedVarsghcInternalFunctionsisFPR llvmDefLabel llvmFunAlign llvmFunArgsllvmFunSection llvmFunSig llvmFunTy llvmInfAlign llvmPtrBitsllvmStdFunAttrsllvmVersionListllvmVersionStrllvmVersionSupported markStackReg markUsedVar padLiveArgsparseLlvmVersion renderLlvmrunLlvm setUniqMetastrCLabel_llvmsupportedLlvmVersionLowerBoundsupportedLlvmVersionUpperBound tysToParams varInsert varLookupwidthToLlvmFloatwidthToLlvmInt withClearVarsLiveGlobalRegsLlvmBasicBlock LlvmCmmDeclLlvmDataLlvmM LlvmUnresData LlvmVersion UnresLabel UnresStatic$fApplicativeLlvmM$fFunctorLlvmM$fEqLlvmVersion$fHasDynFlagsLlvmM$fHasLoggerLlvmM $fMonadLlvmM$fMonadUniqueLlvmM$fOrdLlvmVersionaskLdaskOtoolfigureLlvmVersion isContainedInrunArrunAsrunCcrunClangrunCpprunInstallNameTool runLibtoolrunLink runLlvmLlc runLlvmOptrunMergeObjectsrunPp runRanlibrunUnlit runWindrestouchtraceToolCommand checkLinkInfo getLinkInfoghcLinkInfoNoteNameghcLinkInfoSectionNamehaveRtsOptsFlags mkExtraObjmkExtraObjToLinkIntoBinarymkNoteObjsToLinkIntoBinaryplatformSupportsSavingLinkOptscopycopyWithHeader initSysToolslazyInitLlvmConfigmaybeCreateManifestgenData genLlvmData infoSectionpprLlvmCmmDecl pprLlvmDatacmmImplementSwitchPlans pprCmmGrouppprCmms pprSection pprStatic$fOutputableForeignHint!$fOutputablePPlatformCmmInfoTable$fOutputablePPlatformCmmStatic$fOutputablePPlatformGenCmmDecl"$fOutputablePPlatformGenCmmStatics$fOutputableCmmReturnInfo$fOutputableCmmStackInfo$fOutputableConvention$fOutputableForeignConvention$fOutputablePPlatformBlock$fOutputablePPlatformBlock0$fOutputablePPlatformBlock1$fOutputablePPlatformBlock2$fOutputablePPlatformCmmNode$fOutputablePPlatformCmmTopInfo"$fOutputablePPlatformForeignTarget $fOutputablePPlatformGenCmmGraph$fOutputablePPlatformGraph' genLlvmProc $fEqSignage$fMonoidLlvmAccum$fSemigroupLlvmAccum $fShowSignage llvmCodeGencmmToC$fApplicativeTE $fFunctorTE $fMonadTE pprBasicBlockpprData pprDataItem pprFormatpprImm$fOutputablePPlatformInstr checkBlockaddEdgeaddImmediateSuccessoraddNodesBetween addWeightEdgeadjustEdgeWeightdelEdgeedgeList filterEdgesgetCfg getCfgNodes getCfgProc getEdgeInfogetSuccEdgesSortedgetSuccessorEdges getSuccessorshasNode infoEdgeListloopInfo loopLevels loopMembersmkGlobalWeights mkWeightInfo optimizeCFGpprEdgeWeights reverseEdgessanityCheckCfg setEdgeWeightshortcutWeightMapCFGCfgEdgeedgeFromedgeInfoedgeToEdgeInfo edgeWeighttransitionSource EdgeWeightweightToDoubleTransitionSource AsmCodeGen CmmSource trans_cmmNode trans_info$fEnumEdgeWeight$fEqBranchInfo $fEqCfgEdge $fEqEdgeInfo$fEqEdgeWeight$fEqTransitionSource$fFractionalEdgeWeight$fNumEdgeWeight$fNonLocalBlockNode $fOrdCfgEdge$fOrdEdgeWeight$fOutputableBranchInfo$fOutputableCfgEdge$fOutputableEdgeInfo$fOutputableEdgeWeight$fOutputableLoopInfo$fRealEdgeWeightcmmTopLiveness emptyRegMaperaseDeltasLive mapBlockTop mapBlockTopMmapGenBlockTopmapGenBlockTopMmapLiveCmmDeclmapSCCMpatchEraseLivepatchRegsLiveInstrpprLiveCmmDecl regLivenessreverseBlocksInTopsslurpConflictsslurpReloadCoalesce stripLivestripLiveBlockBlockMapInstrSRRELOADSPILLLiveBasicBlock LiveCmmDeclLiveInfo LiveInstrliveBorn liveDieRead liveDieWriteRegMap$fFunctorInstrSR$fFunctorLiveInstr$fInstructionInstrSR$fOutputableInstrSR$fOutputableLiveInstr$fOutputablePPlatformLiveInfo$fOutputablePenvLiveInstremptyBlockAssignmentlookupBlockAssignmentlookupFirstUsed regsOfLocupdateBlockAssignmentBlockAssignmentLocInBothInMemRA_Statera_assig ra_blockassig ra_configra_delta ra_fixups ra_freeregs ra_spillsra_stackra_us RegAllocStats ra_fixupListra_spillInstrs SpillReason SpillAlloc SpillClobber SpillJoinRM SpillJoinRR SpillLoad$fEqLoc$fEqReadingOrWriting$fOrdLoc$fOrdReadingOrWriting$fOutputableLoc $fShowLocbinSpillReasonscountRegRegMovesNatpprStats getAssigRgetBlockAssigR getConfig getDeltaR getFreeRegsR getUniqueRloadRrecordFixupBlock recordSpillrunR setAssigRsetBlockAssigR setDeltaR setFreeRegsRspillRRegM$fApplicativeRegM $fFunctorRegM $fMonadRegM cleanSpills$fOutputableStore$fUniquableStore accSpillSLregSpill SpillStatsspillStoreLoad$fOutputableSpillStats regCoalesce slurpJoinMovs chooseSpilllifeMapFromSpillCostInfoplusSpillCostInfoplusSpillCostRecordpprSpillCostRecordslurpSpillCostInfozeroSpillCostInfo SpillCostInfoSpillCostRecordaddSRM countSRMspprStatsConflictpprStatsLifeConflictpprStatsLifetimespprStatsSpillsRegAllocStatsColoredRegAllocStatsSpillRegAllocStatsStart raCoalescedraCoderaCodeCoalescedraFinalraGraphraGraphColored raLiveCmm raPatched raPlatformraSRMs raSpillClean raSpillCosts raSpillStats raSpilled$fFunctorRegAllocStats$fOutputableRegAllocStatsregAlloc cmmMachOpFoldcmmMachOpFoldMconstantFoldExprconstantFoldNodeclosureInfoPtrcmmGetClosureType cmmToRawCmmconInfoTableSizeB entryCodefixedInfoTableSizeW funInfoArity funInfoTable getConstrTag infoTableinfoTableClosureTypeinfoTableConstrTaginfoTableNonPtrs infoTablePtrsinfoTableSrtBitmapmaxRetInfoTableSizeWmaxStdInfoTableSizeWmkEmptyContInfoTableprofInfoTableSizeW srtEscapestdClosureTypeOffsetstdInfoTableSizeBstdInfoTableSizeWstdNonPtrsOffset stdPtrsOffsetstdSrtBitmapOffsetPtrOptspo_align_check po_profilearchWordFormatmakeFarBranchesADDCADDEADDISADDOADDZEANDCBCCBCCFARBCTRBCTRLCLRLICLRRICMPLCNTLZCRNORDIVEXTSFCFIDFCTIDZFCTIWZFETCHPCFRSPHWSYNCISYNCLALDFARLILISLWSYNCMFCRMFLRMFOVMRMTCTRMULHUMULLMULLONANDNOTORISRLWINMSLSRSTCSTFARSTUSUBFSUBFCSUBFESUBFOXORIS analyzeCmmBwd analyzeCmmFwd changedIffoldNodesBwdOOfoldRewriteNodesBwdOOgetFact joinFacts joinOutFacts mkFactBase rewriteCmmBwdDataflowLatticefact_bot fact_joinFact JoinedFactChanged NotChangedNewFactOldFact RewriteFun TransferFuncmmGlobalLivenesscmmLocalLivenesscmmLocalLivenessLgen_kill gen_killL liveLattice liveLatticeL CmmLocalLivecmmSinkattachContInfoTablescallProcPointsminimalProcPointSetprocPointAnalysissplitAtProcPoints ProcPointSetStatus ProcPoint ReachedBy$fOutputableStatuscmmLint cmmLintGraph$fApplicativeCmmLint$fFunctorCmmLint$fMonadCmmLint cmmCfgOptscmmCfgOptsProcremoveUnreachableBlocksProc replaceLabelselimCommonBlocksassignArgumentsPos assignStackrealArgRegsCovertupleRegsCover ParamLocation RegisterParam StackParam$fOutputableParamLocation catAGraphs copyInOflow copyOutOflow labelAGraphlgraphOfAGraphmkAssignmkBranch mkCallEntrymkCallReturnsTo mkCbranch mkFinalCallmkJump mkJumpExtramkJumpReturnsTomkLabelmkLastmkMiddlemkNop mkRawJumpmkReturnmkStoremkSwitch mkUnsafeCallmkUnwind noExtraStack outOfLine stackStubExprtoCallCgStmtCgForkCgLabelCgLast CmmAGraphCmmAGraphScopedTransferJumpJumpRetRet $fEqTransfer aGraphToGraphcodeOnlyemit emitAssign emitCommentemitDecl emitLabel emitOutOfLineemitProcWithConventionemitProcWithStackFrame emitStore emitStore'emitTick emitUnwindfixC forkAltPairforkAltsforkClosureBody forkLneBodygetBinds getCallOptsgetCmmgetCodegetCodeR getCodeScoped getHeapUsage getHpUsage getInfoDown getModuleName getProfile getPtrOpts getSelfLoop getSequelgetState getTickScopegetTickyCtrLabelgetUpdFrameOff getVirtHpheapHWMinitC initHpUsageinitUpdFrameOffmkCall mkCmmCall mkCmmIfGoto mkCmmIfGoto' mkCmmIfThen mkCmmIfThen'mkCmmIfThenElsemkCmmIfThenElse' newUniquerunCsetBinds setHpUsage setRealHpsetStatesetTickyCtrLabel setVirtHp tickScope withSelfLoop withSequelwithUpdFrameOffCgIdInfocg_idcg_lfcg_locCgInfoDownwards MkCgInfoDown cgd_dflagscgd_mod cgd_self_loop cgd_sequelcgd_tick_scope cgd_ticky cgd_updfr_offCgState MkCgState cgs_binds cgs_hp_usg cgs_stmtscgs_tops cgs_uniqsFCode HeapUsagerealHpvirtHp ReturnKindAssignedDirectly ReturnedToSequelAssignToVirtualHpOffset$fApplicativeFCode$fFunctorFCode$fHasDynFlagsFCode $fMonadFCode$fMonadUniqueFCode$fOutputablePPlatformCgIdInfo$fOutputableSequeladdToMem addToMemE addToMemLbl addToMemLblE assignTempcallerRestoreGlobalRegcallerSaveGlobalRegcallerSaveVolatileRegscgLitcmmInfoTableToInfoProvEntconvertInfoProvMapemitCmmLitSwitch emitDataCon emitDataLitsemitMultiAssignemitRODataLits emitRtsCallemitRtsCallGenemitRtsCallWithResult emitSwitchemitUpdRemSetPushemitUpdRemSetPushThunk mkSimpleLitmkTaggedObjectLoadnewByteStringCLit newStringCLitnewTempnewUnboxedTupleRegs tagToClosurewhenUpdRemSetEnabled emitPrimCalltickyAllocHeap tickyAllocPAPtickyAllocPrimtickyAllocThunktickyDirectCall tickyDynAlloctickyEnterDynCon tickyEnterFun tickyEnterLNEtickyEnterThunktickyHeapChecktickyPushUpdateFrametickyReturnNewContickyReturnOldCon tickySlowCalltickyStackChecktickyUnboxedTupleReturntickyUpdateBhCaftickyUpdateFrameOmittedwithNewTickyCounterConwithNewTickyCounterFunwithNewTickyCounterLNEwithNewTickyCounterStdThunkwithNewTickyCounterThunkcgBindinitHpc mkTickBoxcode lookupLabel lookupName loopDeclsnewFunctionName newImportnewLabelnewLocalwithNameCmmParseunECFunNLabelNVarN$fApplicativeCmmParse$fFunctorCmmParse$fHasDynFlagsCmmParse$fMonadCmmParse$fMonadUniqueCmmParseaddBindC addBindsC bindArgToRegbindArgsToRegs bindToReg getArgAmode getCgIdInfogetNonVoidArgAmodes idInfoToAmodeidToReg litIdInfo lneIdInfomaybeLetNoEscape mkRhsInit rebindToReg rhsIdInfoadjustHpBackwards directCallemitCallemitClosureAndInfoTableemitClosureProcAndInfoTable emitReturngetHpRelOffset mkArgDescrmkVirtConstrOffsetsmkVirtConstrSizesmkVirtHeapOffsetsmkVirtHeapOffsetsWithPaddingslowCall ClosureHeaderNoHeader StdHeader ThunkHeaderFieldOffOrPaddingFieldOffPaddingbinderInfoBndr closureGrowth goodToLifttagSkeletonTopBind BinderInfo BindsClosure BoringBinderSkeletonAltSkBothSk ClosureSkNilSkRhsSk$fOutputableBinderInfo$fOutputableBndrBinderInfo$fOutputableSkeleton stgLiftLams bciStackUseBCInstrALLOC_APALLOC_AP_NOUPD ALLOC_PAPBRK_FUNCASEFAILCCALLENTERLABELMKAPMKPAPPACKPUSH16PUSH16_WPUSH32PUSH32_WPUSH8PUSH8_W PUSH_ALTSPUSH_ALTS_TUPLEPUSH_ALTS_UNLIFTED PUSH_APPLY_D PUSH_APPLY_F PUSH_APPLY_L PUSH_APPLY_N PUSH_APPLY_P PUSH_APPLY_PPPUSH_APPLY_PPPPUSH_APPLY_PPPPPUSH_APPLY_PPPPPPUSH_APPLY_PPPPPP PUSH_APPLY_VPUSH_BCOPUSH_GPUSH_LPUSH_LLPUSH_LLL PUSH_PAD16 PUSH_PAD32 PUSH_PAD8 PUSH_PRIMOPPUSH_UBX PUSH_UBX16 PUSH_UBX32 PUSH_UBX8RETURN RETURN_TUPLERETURN_UNLIFTEDSLIDESTKCHECKSWIZZLETESTEQ_DTESTEQ_FTESTEQ_ITESTEQ_PTESTEQ_WTESTLT_DTESTLT_FTESTLT_ITESTLT_PTESTLT_WUNPACK LocalLabel getLocalLabelProtoBCO protoBCOArityprotoBCOBitmapprotoBCOBitmapSize protoBCOExpr protoBCOFFIsprotoBCOInstrs protoBCOName$fEqLocalLabel$fOrdLocalLabel$fOutputableBCInstr$fOutputableLocalLabel$fOutputableProtoBCO cmmDebugGencmmDebugLabels cmmDebugLink debugToMap toUnwindExpr DebugBlock dblBlocks dblCLabel dblHasInfoTbldblLabel dblParent dblPosition dblProcedure dblSourceTickdblTicks dblUnwind UnwindExprUwConstUwDerefUwLabelUwMinusUwPlusUwRegUwTimes UnwindPoint UnwindTable$fEqUnwindExpr$fOutputablePenvDebugBlock$fOutputablePenvUnwindExpr$fOutputablePenvUnwindPointADCADD_CCBSFBSRBSWAPBTCLTDCMOVCMPXCHGCVTSD2SSCVTSI2SDCVTSI2SSCVTSS2SD CVTTSD2SIQ CVTTSS2SIQFETCHGOTIDIVIMULIMUL2JXXJXX_GBLLEALOCKLZCNTMFENCEMOVSxLMOVZxLMUL2NEGIPDEPPEXTPOPPOPCNTPREFETCHPUSHSARSBBSETCCSHLSHRSQRTSUB_CCTESTTZCNTUNWINDX87StoreXADDXCHGPrefetchVariantLvl0Lvl1Lvl2NTAFR frAllocateReg frGetFreeRegsfrInitFreeRegs frReleaseReg $fFRFreeRegs $fFRFreeRegs0 $fFRFreeRegs1 $fFRFreeRegs2 $fFRFreeRegs3 joinToTargetsaddImmediateSuccessorNat addImportNataddNodeBetweenNat getBlockIdNat getCfgWeights getDebugBlock getDeltaNat getFileId getModLocgetNewLabelNat getNewRegNatgetNewRegPairNatgetPicBaseMaybeNat getPicBaseNatgetThisModuleNat getUniqueNatinitNat mapAccumLNat mkNatM_State setDeltaNat updateCfgNat DwarfFilesNatM NatM_Statenatm_cfg natm_confignatm_debug_map natm_delta natm_fileid natm_imports natm_modlocnatm_picnatm_usNcgImpl cmmTopCodeGenextractUnwindPointsgenerateJumpTableForInstrinvertCondBranchesncgAllocMoreStack ncgConfig ncgExpandTopncgMakeFarBranches$fApplicativeNatM $fFunctorNatM$fHasModuleNatM $fMonadNatM$fMonadUniqueNatM getRegister getSomeReg condFltCode condIntCode getCondCodegetAmodeassignMem_I64CodeassignReg_I64Code iselExpr64cmmMakeDynamicReferenceinitializePicBase_ppcinitializePicBase_x86needImportedSymbolspprGotDeclarationpprImportedSymbolCmmMakeDynamicReferenceM addImport ReferenceKind CallReference DataReference JumpReference$fCmmMakeDynamicReferenceMNatM$fEqReferenceKindncgX86 ncgX86_64$fInstructionInstrncgSPARCncgPPCbackendMaintainsCfg sequenceTop$fEqBlockChain$fOrdBlockChain$fOutputableBlockChainpprAbbrevDeclspprByte pprData4' pprDwWordpprDwarfARanges pprDwarfFrame pprDwarfInfopprHalf pprLEBInt pprLEBWordpprWord sectionOffset wordAlign DwarfARangedwArngEndLabeldwArngStartLabel DwarfFrame dwCieInit dwCieLabel dwCieProcsDwarfFrameBlockdwFdeBlkHasInfo dwFdeUnwindDwarfFrameProc dwFdeBlocks dwFdeHasInfo dwFdeProc DwarfInfo DwarfBlockDwarfCompileUnit DwarfSrcNoteDwarfSubprogram dwChildren dwCompDir dwHighLabeldwLabel dwLineLabel dwLowLabeldwMarkerdwNamedwParent dwProducer dwSrcSpan$fEnumDwarfAbbrev$fEqDwarfAbbrev$fOutputablePenvDwarfFrameBlockdwarfGen ncgAArch64 cmmNativeGen initNCGConfig nativeCodeGen$fApplicativeCmmOptM$fFunctorCmmOptM!$fCmmMakeDynamicReferenceMCmmOptM$fMonadCmmOptMpprIfPspprIfRnpprIfTcGhcPassGhcPsGhcRnGhcTcIdGhcPIsPassghcPass IsSrcSpanAnn NoGhcTcPassOutputableBndrIdPassParsedRenamed Typechecked $fDataGhcPass $fDataPass$fIsPassParsed$fIsPassRenamed$fIsPassTypechecked$fMapXRecGhcPass$fUnXRecGhcPassieLWrappedNameieNameieNamesieWrappedLName ieWrappedNameimportDeclQualifiedStyleisImportDeclQualifiedlieWrappedName pprImpExpreplaceLWrappedNamereplaceWrappedNamesimpleImportDeclEpAnnImportDeclimportDeclAnnAsimportDeclAnnImportimportDeclAnnPackageimportDeclAnnPragmaimportDeclAnnQualifiedimportDeclAnnSafeIEIEDoc IEDocNamedIEGroupIEModuleContents IEThingAbs IEThingAll IEThingWithIEVarXIE IEWildcard NoIEWildcard IEWrappedNameIEName IEPatternIEType ImportDecl XImportDeclideclAsideclExt ideclHiding ideclImplicit ideclName ideclPkgQualideclQualified ideclSafe ideclSourceideclSourceSrcImportDeclQualifiedStyle NotQualified QualifiedPost QualifiedPreLIELIEWrappedName LImportDecl$fDataEpAnnImportDecl$fDataIEWildcard$fDataIEWrappedName$fDataImportDeclQualifiedStyle$fEqIEWildcard$fEqIEWrappedName$fEqImportDeclQualifiedStyle$fHasOccNameIEWrappedName$fOutputableBndrIEWrappedName$fOutputableIE$fOutputableIEWrappedName$fOutputableImportDeclhsLitNeedsParenshsOverLitNeedsParensnegateOverLitValHsLitHsChar HsCharPrim HsDoublePrim HsFloatPrimHsInt HsInt64Prim HsIntPrim HsIntegerHsRatHsString HsStringPrim HsWord64Prim HsWordPrimXLit HsOverLitOverLitol_extol_val ol_witness OverLitVal HsFractional HsIntegral HsIsString$fDataOverLitVal $fEqHsLit $fEqHsOverLit$fEqOverLitVal$fOrdHsOverLit$fOrdOverLitVal$fOutputableOverLitValLPatPat hsIPNameFShsLinearhsMult hsPatSigType hsQTvExplicit hsScaledThinghsUnrestrictedisHsKindedTyVarmapHsOuterImplicit noTypeArgsnumVisibleArgsAmbiguousFieldOcc Ambiguous UnambiguousXAmbiguousFieldOccBangType ConDeclField cd_fld_doc cd_fld_ext cd_fld_names cd_fld_typeFieldOcc XFieldOcc extFieldOccrdrNameFieldOccHsArgHsArgPar HsTypeArgHsValArgHsArrowHsExplicitMult HsLinearArrowHsUnrestrictedArrow HsConDetailsInfixCon PrefixConRecCon HsContextHsCoreTyHsForAllTelescope HsForAllInvis HsForAllVisXHsForAllTelescopehsf_invis_bndrs hsf_vis_bndrs hsf_xinvishsf_xvisHsIPNameHsKindHsOuterFamEqnTyVarBndrsHsOuterSigTyVarBndrsHsOuterTyVarBndrsHsOuterExplicitHsOuterImplicitXHsOuterTyVarBndrs hso_bndrs hso_xexplicit hso_ximplicitHsPSRn hsps_imp_tvs hsps_nwcs HsPatSigTypeHsPS XHsPatSigType hsps_bodyhsps_extHsScaled HsSigTypeHsSig XHsSigType sig_bndrssig_bodysig_ext HsTupleSortHsBoxedOrConstraintTupleHsUnboxedTupleHsTyLitHsCharTyHsNumTyHsStrTy HsTyVarBndr KindedTyVar UserTyVar XTyVarBndrHsType HsAppKindTyHsAppTyHsBangTyHsDocTyHsExplicitListTyHsExplicitTupleTy HsForAllTyHsFunTy HsIParamTy HsKindSigHsListTyHsOpTyHsParTyHsQualTyHsRecTy HsSpliceTyHsStarTyHsSumTy HsTupleTyHsTyVar HsWildCardTyXHsTypehst_bodyhst_ctxthst_tele hst_xforall hst_xqualHsWildCardBndrsHsWCXHsWildCardBndrs hswc_bodyhswc_ext LBangType LConDeclField LFieldOcc LHsContextLHsKind LHsQTyVarsHsQTvs XLHsQTyVars hsq_explicithsq_ext LHsSigType LHsSigWcType LHsTyVarBndrLHsType LHsTypeArg LHsWcType$fDataHsConDetails$fDataHsIPName $fDataHsPSRn$fDataHsTupleSort $fDataHsTyLit $fEqFieldOcc $fEqHsIPName$fOutputableBndrFieldOcc$fOutputableBndrGenLocated$fOutputableBndrHsIPName$fOutputableFieldOcc$fOutputableHsArg$fOutputableHsConDetails$fOutputableHsIPName$fOutputableHsScaled$fOutputableHsTyLit hsConPatArgs hsRecFieldSel hsRecFieldshsRecFieldsArgsConLikePHsConPatDetails HsRecField HsRecField' hsRecFieldAnn hsRecFieldArg hsRecFieldLblhsRecPun HsRecFields rec_dotdotrec_flds HsRecUpdField LHsRecField LHsRecField'LHsRecUpdFieldAsPatBangPatConPatLazyPatListPatLitPatNPat NPlusKPatParPatSigPat SplicePatSumPatTuplePatVarPatViewPatWildPatXPatpat_argspat_con pat_con_ext$fFoldableHsRecField'$fFunctorHsRecField'$fOutputableHsRecField'$fOutputableHsRecFields$fTraversableHsRecField'pprLPat hasSpecPragshsSigDocisCompleteMatchSigisDefaultMethod isFixityLSig isInlineLSig isMinimalLSig isPragLSig isSCCFunSigisSpecInstLSig isSpecLSig isTypeLSig noSpecPragsABExportABE XABExportabe_extabe_monoabe_poly abe_pragsabe_wrap FixitySigHsBindHsBindLRAbsBindsFunBindPatBind PatSynBindVarBind XHsBindsLR abs_binds abs_ev_binds abs_ev_vars abs_exportsabs_extabs_sigabs_tvsfun_extfun_id fun_matchesfun_tickpat_extpat_lhspat_rhs pat_ticksvar_extvar_idvar_rhs HsIPBindsIPBinds HsLocalBindsHsLocalBindsLREmptyLocalBinds HsValBindsXHsLocalBindsLRHsPatSynDetails HsPatSynDirExplicitBidirectionalImplicitBidirectionalUnidirectional HsValBindsLRValBinds XValBindsLRIPBindXIPBind LFixitySigLHsBind LHsBindLRLHsBinds LHsBindsLR LHsLocalBindsLHsLocalBindsLRLIPBindLSig LTcSpecPragPSBpsb_argspsb_defpsb_dirpsb_extpsb_idRecordPatSynFieldrecordPatSynFieldrecordPatSynPatVarSig ClassOpSigCompleteMatchSigFixSigIdSig InlineSig MinimalSig PatSynSig SCCFunSig SpecInstSigSpecSigTypeSigXSig TcSpecPragSpecPrag TcSpecPragsIsDefaultMethod SpecPrags$fDataTcSpecPrag$fDataTcSpecPrags$fOutputableRecordPatSynFieldannProvenanceName_maybecollectRuleBndrSigTyscountTyClDeclsderivStrategyName docDeclDochsGroupInstDecls isClassDeclisClosedTypeFamilyInfo isDataDeclisDataFamilyDecl isFamilyDeclisOpenTypeFamilyInfo isSynDeclisTypeFamilyDeclnewOrDataToFlavour pprFlavourpprFullRuleNametyClDeclTyVarstyClGroupInstDeclstyClGroupKindSigstyClGroupRoleDeclstyClGroupTyClDecls HsAnnotationXAnnDecl AnnProvenanceModuleAnnProvenanceTypeAnnProvenanceValueAnnProvenance CImportSpec CFunctionCWrapper ClsInstDecl XClsInstDecl cid_bindscid_datafam_instscid_extcid_overlap_mode cid_poly_tycid_sigscid_tyfam_instsConDecl ConDeclGADT ConDeclH98XConDeclcon_args con_bndrscon_doc con_ex_tvscon_ext con_forall con_g_args con_g_ext con_mb_cxtcon_name con_names con_res_ty DataDeclRn tcdDataCusktcdFVsDataFamInstDecldfid_eqn DefaultDecl XDefaultDeclDerivClauseTysDctMulti DctSingleXDerivClauseTys DerivDecl XDerivDecl deriv_extderiv_overlap_modederiv_strategy deriv_type DerivStrategyAnyclassStrategyNewtypeStrategy StockStrategy ViaStrategyDocDeclDocCommentNamedDocCommentNextDocCommentPrevDocGroupFamEqnXFamEqn feqn_bndrsfeqn_ext feqn_fixity feqn_patsfeqn_rhs feqn_tycon FamilyDecl XFamilyDeclfdExtfdFixityfdInfofdInjectivityAnnfdLName fdResultSig fdTopLevelfdTyVars FamilyInfoClosedTypeFamily DataFamilyOpenTypeFamilyFamilyResultSigKindSigNoSigTyVarSigXFamilyResultSig ForeignDecl ForeignExport ForeignImport XForeignDeclfd_e_extfd_fefd_fifd_i_extfd_name fd_sig_tyCExportCImportXFunDepHsConDeclGADTDetails PrefixConGADT RecConGADTHsConDeclH98Details HsDataDefn XHsDataDefndd_NDdd_cTypedd_consdd_ctxt dd_derivsdd_ext dd_kindSigHsDeclAnnDDefDDerivDDocDForDInstDKindSigD RoleAnnotDRuleDSigDSpliceDTyClDValDWarningDXHsDecl HsDerivingHsDerivingClauseXHsDerivingClausederiv_clause_extderiv_clause_strategyderiv_clause_tysHsGroupXHsGrouphs_anndshs_defds hs_derivdshs_docshs_exths_fixdshs_fords hs_ruleds hs_splcds hs_tycldshs_valds hs_warndsHsRuleRnHsTyPatsInjectivityAnnXInjectivityAnnInstDeclClsInstD DataFamInstD TyFamInstD XInstDecl cid_d_extcid_instdfid_ext dfid_insttfid_ext tfid_instLAnnDecl LClsInstDeclLConDeclLDataFamInstDecl LDefaultDeclLDerivClauseTys LDerivDeclLDerivStrategyLDocDecl LFamilyDeclLFamilyResultSig LForeignDeclLHsDeclLHsDerivingClause LHsFunDepLInjectivityAnn LInstDeclLRoleAnnotDecl LRuleBndr LRuleDecl LRuleDecls LSpliceDeclLStandaloneKindSig LTyClDeclLTyFamDefltDeclLTyFamInstDecl LTyFamInstEqn LWarnDecl LWarnDecls NewOrDataDataTypeNewType RoleAnnotDeclXRoleAnnotDeclRuleBndr RuleBndrSig XRuleBndrRuleDeclHsRule XRuleDeclrd_actrd_extrd_lhsrd_namerd_rhsrd_tmvsrd_tyvs RuleDeclsHsRules XRuleDeclsrds_ext rds_rulesrds_src SpliceDeclStandaloneKindSigTyClDecl ClassDeclDataDeclFamDeclSynDecl XTyClDecl tcdATDefstcdATstcdCExttcdCtxttcdDExt tcdDataDefntcdDocstcdFDstcdFExttcdFam tcdFixitytcdLNametcdMethstcdRhstcdSExttcdSigs tcdTyVars TyClGroup XTyClGroup group_ext group_instds group_kisigs group_roles group_tycldsTyFamDefltDecl TyFamInstDeclXTyFamInstDecltfid_eqntfid_xtn TyFamInstEqnWarnDeclWarning XWarnDecl WarnDecls XWarnDeclswd_extwd_src wd_warnings$fDataCImportSpec$fDataDataDeclRn $fDataDocDecl$fDataForeignExport$fDataForeignImport$fDataHsRuleRn$fDataNewOrData $fEqNewOrData$fOutputableDocDecl$fOutputableFamilyInfo$fOutputableForeignExport$fOutputableForeignImport$fOutputableNewOrDataisComprehensionContext isInfixMatchisMonadCompContextisMonadStmtContext isPatSynCtxtisTypedBracket isTypedSplicematchSeparatorpprAStmtContextpprArrowMatchContextNounpprExternalSrcLocpprFieldLabelStringspprMatchContextpprMatchContextNounpprStmtContextprependQualifiedqualifiedDoModuleName_maybeApplicativeArgApplicativeArgManyApplicativeArgOneXApplicativeArgapp_arg_pattern app_stmtsarg_expr bv_pattern final_expr is_body_stmt stmt_contextxarg_app_arg_manyxarg_app_arg_oneApplicativeArgStmCtxPass ArithSeqInfoFromFromThen FromThenToFromToCmdLStmtCmdStmtCmdSyntaxTable ExprLStmtExprStmt FailOperatorFieldLabelStringsGRHSXGRHSXGRHSsgrhssExt grhssGRHSsgrhssLocalBinds GhciLStmtGhciStmt GuardLStmt GuardStmt HsArrAppTypeHsFirstOrderAppHsHigherOrderAppHsArrowMatchContext ArrowCaseAlt KappaExprProcExpr HsBracketDecBrGDecBrLExpBrPatBrTExpBrTypBrVarBr HsBracketRnHsCmdHsCmdApp HsCmdArrApp HsCmdArrForm HsCmdCaseHsCmdDoHsCmdIfHsCmdLam HsCmdLamCaseHsCmdLetHsCmdParXCmdHsCmdTopHsDoRnArithSeq ExplicitList ExplicitSum ExplicitTuple ExprWithTySigHsApp HsAppType HsBinTickHsCase HsConLikeOutHsDo HsGetFieldHsIPVarHsIfHsLam HsLamCaseHsLet HsMultiIf HsOverLabelHsParHsPragEHsProc HsProjectionHsRecFldHsRnBracketOut HsSpliceEHsStaticHsTcBracketOutHsTick HsUnboundVarHsVarNegAppOpApp RecordCon RecordUpdSectionLSectionRXExprgf_exprgf_extgf_fieldproj_ext proj_fldsrcon_conrcon_ext rcon_flds rupd_exprrupd_ext rupd_flds HsFieldLabel XHsFieldLabelhflExthflLabelHsMatchContextArrowMatchCtxtCaseAltFunRhsIfAlt LambdaExpr PatBindGuards PatBindRhsRecUpdStmtCtxt ThPatQuote ThPatSplice mc_fixitymc_fun mc_strictness HsPragSCCXHsPragE HsRecordBinds HsQuasiQuote HsSpliced HsTypedSpliceHsUntypedSpliceXSpliceHsSplicedThing HsSplicedExpr HsSplicedPat HsSplicedTy HsStmtContext ArrowExprDoExpr GhciStmtCtxtListCompMDoExpr MonadComp ParStmtCtxtPatGuard TransStmtCtxtHsTupArgMissingPresentXTupArgLGRHSLHsCmd LHsCmdTop LHsRecProj LHsRecUpdProj LHsTupArgLMatchLStmtLStmtLRMatchXMatchm_ctxtm_extm_grhssm_patsMG XMatchGroupmg_altsmg_ext mg_origin MatchGroupTc mg_arg_tys mg_res_ty ParStmtBlockPendingRnSplice'PendingTcSplice'RecProj RecUpdProjSpliceDecoration BareSplice DollarSpliceSplicePointNameStmtStmtLRApplicativeStmtBindStmtBodyStmtLastStmtLetStmtParStmtRecStmt TransStmtXStmtLR recS_bind_fnrecS_extrecS_later_ids recS_mfix_fn recS_rec_ids recS_ret_fn recS_stmtstrS_bind trS_bndrstrS_bytrS_exttrS_fmaptrS_formtrS_ret trS_stmts trS_usingThModFinalizers TransForm GroupFormThenFormUntypedSpliceFlavourUntypedDeclSpliceUntypedExpSpliceUntypedPatSpliceUntypedTypeSplice$fDataHsArrAppType$fDataMatchGroupTc$fDataSpliceDecoration$fDataThModFinalizers$fDataTransForm$fDataUntypedSpliceFlavour$fEqSpliceDecoration!$fOutputableBndrFieldLabelStrings$fOutputableFieldLabelStrings$fOutputableHsFieldLabel$fOutputableSpliceDecoration$fShowSpliceDecoration pprFunBindpprLExpr pprPatBind pprSplice pprSpliceDecl convertLit overLitType pmPprHsLit pp_st_suffix OverLitTc ol_rebindableol_type$fDataOverLitTc$fOutputableHsLit$fOutputableHsOverLitambiguousFieldOcc arrowToHsType dropWildCards emptyLHsQTvsfromMaybeContextgetBangStrictness getBangTypegetLHsInstDeclClass_maybegetLHsInstDeclHeadhsAllLTyVarNameshsExplicitLTyVarNameshsLTyVarLocNamehsLTyVarLocNames hsLTyVarName hsLTyVarNameshsOuterExplicitBndrshsOuterTyVarNames hsScopedTvs hsSigWcTypehsTvbAllKindedhsTyGetAppHead_maybe hsTyKindSighsTyVarBndrFlag hsTyVarNamehsTypeNeedsParens hsWcScopedTvs ignoreParensisUnrestrictedlhsTypeArgSrcSpanmkAmbiguousFieldOccmkAnonWildCardTymkEmptyWildCardBndrs mkFieldOcc mkHsAppKindTy mkHsAppTy mkHsAppTysmkHsExplicitSigTypemkHsForAllInvisTelemkHsForAllVisTelemkHsImplicitSigTypemkHsOpTymkHsOuterExplicitmkHsOuterImplicitmkHsPatSigTypemkHsQTvsmkHsWildCardBndrsparenthesizeHsContextparenthesizeHsTypepprAnonWildCardpprConDeclFields pprHsForAllpprHsOuterFamEqnTyVarBndrspprHsOuterSigTyVarBndrs pprHsType pprLHsContextrdrNameAmbiguousFieldOccselectorAmbiguousFieldOccsetHsTyVarBndrFlagsplitHsFunTypesplitLHsForAllTyInvissplitLHsForAllTyInvis_KPsplitLHsGadtTysplitLHsInstDeclTysplitLHsPatSynTysplitLHsQualTysplitLHsSigmaTyInvisunambiguousFieldOcc EpAnnForallTyOutputableBndrFlag$fNamedThingHsTyVarBndr$fOutputableAmbiguousFieldOcc!$fOutputableBndrAmbiguousFieldOcc$fOutputableBndrFlag()p $fOutputableBndrFlagSpecificityp$fOutputableConDeclField$fOutputableHsArrow$fOutputableHsForAllTelescope$fOutputableHsOuterTyVarBndrs$fOutputableHsPatSigType$fOutputableHsSigType$fOutputableHsTyVarBndr$fOutputableHsType$fOutputableHsWildCardBndrs$fOutputableLHsQTyVars emptyLHsBindsemptyLocalBindsemptyValBindsInemptyValBindsOuteqEmptyLocalBindsisEmptyIPBindsPRisEmptyIPBindsTcisEmptyLHsBindsisEmptyValBindsplusHsValBinds pprDeclList pprLHsBindspprLHsBindsForUser pprMinimalSigpprSpecpprTcSpecPragspprTicks pprVarSig ppr_monobindppr_sig pragBracketspragSrcBracketsAnnSigasDcolonasRest NHsValBindsLR NValBinds $fDataAnnSig$fOutputableABExport$fOutputableFixitySig$fOutputableHsBindLR$fOutputableHsIPBinds$fOutputableHsLocalBindsLR$fOutputableHsValBindsLR$fOutputableIPBind$fOutputablePatSynBind$fOutputableSig$fOutputableTcSpecPragcollectEvVarsPatcollectEvVarsPats hsRecFieldIdhsRecUpdFieldIdhsRecUpdFieldOcchsRecUpdFieldRdr isBangedLPatisIrrefutableHsPat isSimplePatlooksLazyPatBind mkCharLitPatmkNilPatmkPrefixConPatparenthesizePatpatNeedsParens pprConArgs pprParendLPatCoPat co_cpt_wrap co_pat_inner co_pat_tyConPatTc cpt_arg_tys cpt_binds cpt_dictscpt_tvscpt_wrap EpAnnSumPat sumPatParenssumPatVbarsAftersumPatVbarsBefore ListPatTc$fDataEpAnnSumPat$fOutputablePat pprSumOrTupleDataConBuilderInfixDataConBuilderPrefixDataConBuilder PatBuilder PatBuilderAppPatBuilderAppTypePatBuilderOpAppPatBuilderOverLit PatBuilderPar PatBuilderPat PatBuilderVar SumOrTupleSumTuple$fOutputableDataConBuilder$fOutputablePatBuilder appendGroups emptyRdrGroup emptyRnGroupfamResultKindSignaturefamilyDeclLNamefamilyDeclNameflattenRuleDeclsfoldDerivStrategy getConNamesgetRecConArgs_maybehsConDeclTheta hsDeclHasCuskhsGroupTopLevelFixitySigsinstDeclDataFamInstsmapDerivStrategypartitionBindsAndSigspprDataFamInstFlavourpprHsFamInstLHSpprTyClDeclFlavourpprTyFamInstDeclresultVariableNameroleAnnotDeclNamestandaloneKindSigNametcdName tyClDeclLNametyFamInstDeclLNametyFamInstDeclName HsRuleAnnra_rest ra_tmanns ra_tyannsXViaStrategyPs$fDataHsRuleAnn $fEqHsRuleAnn$fOutputableAnnDecl$fOutputableClsInstDecl$fOutputableConDecl$fOutputableDataFamInstDecl$fOutputableDefaultDecl$fOutputableDerivClauseTys$fOutputableDerivDecl$fOutputableDerivStrategy$fOutputableFamilyDecl$fOutputableForeignDecl$fOutputableFunDep$fOutputableHsDataDefn$fOutputableHsDecl$fOutputableHsDerivingClause$fOutputableHsGroup$fOutputableInstDecl$fOutputableRoleAnnotDecl$fOutputableRuleBndr$fOutputableRuleDecl$fOutputableRuleDecls$fOutputableSpliceDecl$fOutputableStandaloneKindSig$fOutputableTyClDecl$fOutputableTyClGroup$fOutputableTyFamInstDecl$fOutputableWarnDecl$fOutputableWarnDecls$fOutputableXViaStrategyPshsExprNeedsParens hsLMatchPatsisAtomicHsExprisEmptyMatchGroup isQuietHsCmd isQuietHsExprisSingletonMatchGroupmatchArrowContextErrStringmatchContextErrStringmatchGroupAritymkRnSyntaxExpr mkSyntaxExprnoExpr noSyntaxExprparenthesizeHsExpr pp_dotdotpp_rhspprArg pprBindStmtpprBindspprBypprCmd pprCmdArgpprComppprDebugParendExprpprDopprGRHSpprGRHSs pprHsBracketpprLCmdpprMatchpprMatchInCtxt pprMatchespprParendLExprpprPendingSplicepprQualspprStmt pprStmtInCtxt pprTransStmtpprTransformStmtppr_appsppr_cmd ppr_do_stmtsppr_exprppr_infix_exprppr_lcmd ppr_lexprppr_module_name_prefix ppr_quasi ppr_spliceppr_splice_declstripParensHsExprstripParensLHsExpr thBrackets thTyBrackets tupArgPresentAnnExplicitSum aesBarsAfter aesBarsBeforeaesCloseaesOpen AnnFieldLabelafDot AnnProjectionapCloseapOpenAnnsIfaiElse aiElseSemiaiIfaiThen aiThenSemiAnnsLetalInalLetCmdTopTc DelayedSplice EpAnnHsCase hsCaseAnnCase hsCaseAnnOfhsCaseAnnsRestEpAnnUnboundVarhsUnboundBackquotes hsUnboundHoleGrhsAnnga_sepga_vbar HsExpansion HsExpanded HsSplicedTHsWrapPendingRnSplicePendingTcSplice PostTcExpr PostTcTable RecStmtTc recS_bind_tyrecS_later_rets recS_rec_rets recS_ret_ty RecordUpdTc rupd_cons rupd_in_tys rupd_out_tys rupd_wrap SyntaxExprGhc SyntaxExprRnNoSyntaxExprRn SyntaxExprTcNoSyntaxExprTc syn_arg_wrapssyn_expr syn_res_wrap XBindStmtRn xbsrn_bindOp xbsrn_failOp XBindStmtTc xbstc_bindOpxbstc_boundResultMultxbstc_boundResultType xbstc_failOp XXExprGhcTc ExpansionExprWrapExpr$fDataAnnExplicitSum$fDataAnnFieldLabel$fDataAnnProjection $fDataAnnsIf $fDataAnnsLet$fDataDelayedSplice$fDataEpAnnHsCase$fDataEpAnnUnboundVar $fDataGrhsAnn$fDataHsExpansion$fDataHsSplicedT $fDataHsWrap$fOutputableApplicativeArg$fOutputableArithSeqInfo$fOutputableGrhsAnn$fOutputableHsArrowMatchContext$fOutputableHsBracket$fOutputableHsCmd$fOutputableHsCmdTop$fOutputableHsExpansion$fOutputableHsExpr$fOutputableHsMatchContext$fOutputableHsPragE$fOutputableHsSplice$fOutputableHsSplicedThing$fOutputableHsStmtContext$fOutputableMatch$fOutputableParStmtBlock$fOutputablePendingRnSplice$fOutputablePendingTcSplice$fOutputableStmtLR$fOutputableSyntaxExprRn$fOutputableSyntaxExprTc$fWrapXRecGhcPassaCmmParserErrorCmmUnknownCConvCmmUnknownMacroCmmUnknownPrimitiveCmmUnrecognisedHintCmmUnrecognisedSafetyHint SuggestDoSuggestInfixBindMaybeAtPatSuggestLetInDoSuggestMissingDoSuggestPatternSynonymsSuggestRecursiveDo SuggestTH&TypeApplicationsInPatternsOnlyDataConsLexErrLexErrorLexErrorInPragmaLexNumEscapeRangeLexStringCharLitLexStringCharLitEOFLexUnknownPragmaLexUnterminatedCommentLexUnterminatedOptionsLexUnterminatedQQ LexErrKindLexErrKind_CharLexErrKind_EOFLexErrKind_UTF8NumUnderscoreReasonNumUnderscore_FloatNumUnderscore_IntegralOperatorWhitespaceOccurrence#OperatorWhitespaceOccurrence_Prefix#OperatorWhitespaceOccurrence_Suffix'OperatorWhitespaceOccurrence_TightInfixOperatorWhitespaceSymbol%OperatorWhitespaceSymbol_PrefixDollar+OperatorWhitespaceSymbol_PrefixDollarDollar&OperatorWhitespaceSymbol_PrefixPercentPsErrorerrDescerrHintserrLoc PsErrorDescPsErrArrowCmdInExprPsErrArrowCmdInPatPsErrArrowExprInPatPsErrAtInPatPosPsErrBangPatWithoutSpacePsErrCaseCmdInFunAppCmdPsErrCaseInFunAppExprPsErrCaseInPat PsErrCmmLexerPsErrCmmParserPsErrDeclSpliceNotAtTopLevelPsErrDoCmdInFunAppCmdPsErrDoInFunAppExprPsErrDoNotationInPatPsErrDotsInRecordUpdatePsErrEmptyDoubleQuotesPsErrEmptyWhereInPatSynDeclPsErrExpectedHyphenPsErrExplicitForallPsErrIfCmdInFunAppCmdPsErrIfInFunAppExprPsErrIfTheElseInPatPsErrIllegalBangPatternPsErrIllegalDataTypeContextPsErrIllegalExplicitNamespacePsErrIllegalImportBundleFormPsErrIllegalPatSynExportPsErrIllegalQualifiedDoPsErrIllegalRoleName#PsErrIllegalTraditionalRecordSyntaxPsErrIllegalUnboxedStringInPatPsErrIllegalWhereInDataDeclPsErrImportPostQualifiedPsErrImportQualifiedTwicePsErrInferredTypeVarNotAllowedPsErrInvalidDataConPsErrInvalidInfixDataConPsErrInvalidInfixHolePsErrInvalidPackageNamePsErrInvalidRecordCon PsErrInvalidRuleActivationMarkerPsErrInvalidTypeSignature!PsErrInvalidWhereBindInPatSynDeclPsErrLambdaCasePsErrLambdaCaseInFunAppExprPsErrLambdaCaseInPatPsErrLambdaCmdInFunAppCmdPsErrLambdaInFunAppExprPsErrLambdaInPatPsErrLazyPatWithoutSpacePsErrLetCmdInFunAppCmdPsErrLetInFunAppExpr PsErrLetInPat PsErrLexerPsErrLinearFunctionPsErrMDoInFunAppExprPsErrMalformedDeclPsErrMalformedEntityStringPsErrMalformedTyOrClDeclPsErrMissingBlockPsErrMultiWayIf+PsErrMultipleNamesInStandaloneKindSignature"PsErrNoSingleWhereBindInPatSynDeclPsErrNotADataConPsErrNumUnderscoresPsErrOpFewArgsPsErrOverloadedRecordDotInvalid,PsErrOverloadedRecordUpdateNoQualifiedFields%PsErrOverloadedRecordUpdateNotEnabled PsErrParsePsErrParseErrorInCmdPsErrParseErrorInPatPsErrParseErrorOnInputPsErrPrecedenceOutOfRangePsErrPrimStringInvalidCharPsErrProcInFunAppExprPsErrQualifiedDoInCmdPsErrRecordSyntaxInPatSynDeclPsErrSemiColonsInCondCmdPsErrSemiColonsInCondExprPsErrSpaceInSCC PsErrSuffixATPsErrTupleSectionInPatPsErrTypeAppWithoutSpacePsErrUnallowedPragmaPsErrUnexpectedKindAppInDataCon#PsErrUnexpectedQualifiedConstructorPsErrUnexpectedTypeAppInDeclPsErrUnexpectedTypeInDeclPsErrUnpackDataConPsErrUnsupportedBoxedSumExprPsErrUnsupportedBoxedSumPatPsErrVarForTyConPsErrViewPatInExpr PsWarningPsWarnBidirectionalFormatCharsPsWarnHaddockIgnoreMultiPsWarnHaddockInvalidPosPsWarnImportPreQualifiedPsWarnOperatorWhitespace#PsWarnOperatorWhitespaceExtConflictPsWarnStarBinderPsWarnStarIsType PsWarnTabPsWarnTransitionalLayoutPsWarnUnrecognisedPragmatabCounttabFirst StarIsTypeTransLayoutReasonTransLayout_PipeTransLayout_Where$fEqLexErrKind$fEqNumUnderscoreReason$fOrdLexErrKind$fOrdNumUnderscoreReason$fShowLexErrKind$fShowNumUnderscoreReason activeContextallocateCommentsallocateFinalCommentsallocatePriorCommentscommentToAnnotation failLocMsgPfailMsgPgetCommentsFor getEofPosgetFinalCommentsFor getLexState getMessages getPStategetPriorCommentsFor getRealSrcLocinitParserState initPragStatelexTokenStreamlexerlexerDbg mkParensEpAnn mkParserOpts nextIsEOF popContext popLexState pushLexStatepushModuleContext setLastToken setSrcLoc srcParseFailwarnoptxsetxtestxunsetExtBitsALRTransitionalBitAlternativeLayoutRuleBit ArrowsBit BangPatBitBinaryLiteralsBitBlockArgumentsBit CApiFfiBitDatatypeContextsBitDoAndIfThenElseBitExplicitForallBitExplicitNamespacesBitFfiBit GadtSyntaxBit HaddockBitHexFloatLiteralsBitImportQualifiedPostBitInNestedCommentBit InRulePragBitInterruptibleFfiBitIpBit LambdaCaseBitLinearTypesBit MagicHashBitMonadComprehensionsBit MultiWayIfBitNPlusKPatternsBitNegativeLiteralsBitNoLexicalNegationBitNondecreasingIndentationBitNumericUnderscoresBitOverloadedLabelsBitOverloadedRecordDotBitOverloadedRecordUpdateBitPatternSynonymsBitQqBitQualifiedDoBitRawTokenStreamBitRecursiveDoBitRelaxedLayoutBitSafeHaskellBit StarIsTypeBitStaticPointersBitThBit ThQuotesBitTraditionalRecordSyntaxBitTransformComprehensionsBitUnboxedSumsBitUnboxedTuplesBitUnicodeSyntaxBitUsePosPragsBit HdkCommentHdkCommentNamedHdkCommentNextHdkCommentPrevHdkCommentSectionMonadPaddError addFatalError addWarningallocateCommentsPallocateFinalCommentsPallocatePriorCommentsPgetBitunPPState alr_contextalr_expecting_ocurlyalr_justClosedExplicitLetBlock alr_last_localr_next_tokenalr_pending_implicit_tokensbuffer comment_qcontexteof_poserrors hdk_commentsheader_commentslast_lenlast_loclast_tk lex_statelocoptionsprev_loc prev_loc2srcfiles tab_count tab_firstwarnings ParseResultPFailedPOk ParserOpts pExtsBitmap pWarningFlagsToken ITLarrowtail ITRarrowtail ITann_prag ITanyclassITasITat ITbackquoteITbangITbiglamITblockCommentITby ITcapiconvITcaseITcbrack ITccallconvITccurlyITcharITclass ITcloseQuoteITcloseTExpQuote ITclose_pragITcolon ITcolumn_pragITcommaITcomment_line_pragITcomplete_pragITconidITconsym ITcpabrackITcparen ITcparenbarITctype ITcubxparenITdarrowITdataITdcolon ITdefault ITdependencyITdeprecated_prag ITderivingITdoITdocCommentNamedITdocCommentNextITdocCommentPrev ITdocOptions ITdocSectionITdollarITdollardollarITdotITdotdot ITdupipvarid ITdynamicITelseITeofITequalITexportITfamilyITforall ITforeignITgroupIThidingITifITimportITinITinclude_pragITincoherent_pragITinfixITinfixlITinfixr ITinline_prag ITinstance ITintegerITinterruptibleITjavascriptcallconvITlabel ITlabelvaridITlamITlanguage_pragITlarrow ITlarrowtailITlcaseITlet ITlineComment ITline_pragITlollyITmdoITminimal_pragITminusITmodule ITnewtypeITnounpack_pragITobrackITocurlyITof ITopabrackIToparen IToparenbarITopenDecQuoteITopenExpQuoteITopenPatQuoteITopenTExpQuoteITopenTypQuoteIToptions_prag IToubxparenIToverlappable_pragIToverlapping_pragIToverlaps_prag ITpattern ITpercent ITprefixminusITprimcallconv ITprimchar ITprimdouble ITprimfloat ITprimint ITprimstring ITprimwordITprocITproj ITqQuasiQuoteITqconid ITqconsym ITqualified ITquasiQuoteITqvarid ITqvarsymITrarrow ITrarrowtail ITrationalITrec ITrequiresITrole ITrules_pragITsafe ITscc_pragITsemi ITsignature ITsimpleQuote ITsource_pragITspec_inline_prag ITspec_pragITstarITstatic ITstdcallconvITstockITstringITthenITtilde ITtyQuoteITtype ITtypeApp ITunderscoreITunit ITunknown ITunpack_pragITunsafeITusingITvaridITvarsymITvbar ITvccurlyITvia ITvocurlyITwarning_pragITwhere$fApplicativeP $fFunctorP $fEnumExtBits$fMonadP $fMonadPP$fOutputableToken$fShowHdkComment$fShowLayoutContext $fShowTokenpprError pprWarning failMsgPD getHomeUnitIdliftPPDunPD$fApplicativePD $fFunctorPD$fHasDynFlagsPD $fMonadPDcmmlexCmmToken CmmT_BoolAnd CmmT_BoolOr CmmT_CLOSURE CmmT_DotDotCmmT_DoubleColonCmmT_EOFCmmT_Eq CmmT_False CmmT_FloatCmmT_GeCmmT_GlobalRegCmmT_INFO_TABLECmmT_INFO_TABLE_CONSTRCmmT_INFO_TABLE_FUNCmmT_INFO_TABLE_RETCmmT_INFO_TABLE_SELECTORCmmT_IntCmmT_Le CmmT_NameCmmT_NeCmmT_ShlCmmT_Shr CmmT_SpecChar CmmT_String CmmT_True CmmT_bits128 CmmT_bits16 CmmT_bits256 CmmT_bits32 CmmT_bits512 CmmT_bits64 CmmT_bits8 CmmT_call CmmT_case CmmT_default CmmT_else CmmT_export CmmT_float32 CmmT_float64 CmmT_foreign CmmT_gcptr CmmT_gotoCmmT_if CmmT_import CmmT_jump CmmT_likely CmmT_never CmmT_prim CmmT_push CmmT_reserve CmmT_return CmmT_returns CmmT_section CmmT_switch CmmT_unwind$fShowCmmTokenchunkifycollectHsBindBinderscollectHsBindListBinderscollectHsBindsBinderscollectHsIdBinderscollectHsValBinderscollectLStmtBinderscollectLStmtsBinderscollectLocalBinderscollectMethodBinderscollectPatBinderscollectPatsBinderscollectStmtBinderscollectStmtsBinders emptyRecStmtemptyRecStmtIdemptyRecStmtNameemptyTransStmtgetPatSynBindshsDataFamInstBindershsForeignDeclsBindershsGroupBindershsLTyClDeclBindershsPatSynSelectorshsTyClForeignBindershsTypeToHsSigTypehsTypeToHsSigWcTypehsValBindsImplicitsisBangedHsBindisInfixFunBindisUnliftedHsBind lPatImplicitslStmtsImplicits missingTupArgmkBigLHsPatTup mkBigLHsTupmkBigLHsVarPatTupmkBigLHsVarTup mkBodyStmt mkChunkified mkClassOpSigs mkFunBindmkGroupByUsingStmtmkGroupUsingStmtmkHsApp mkHsAppType mkHsAppTypes mkHsAppWithmkHsApps mkHsAppsWith mkHsCaseAltmkHsCharPrimLit mkHsCmdIf mkHsCmdWrapmkHsComp mkHsCompAnns mkHsDictLetmkHsDo mkHsDoAnnsmkHsFractionalmkHsIf mkHsIntegral mkHsIsStringmkHsLammkHsLams mkHsOpAppmkHsParmkHsQuasiQuote mkHsSigEnv mkHsStringmkHsStringPrimLit mkHsVarBind mkHsWrapCo mkHsWrapCoR mkHsWrapPat mkHsWrapPatCo mkLHsCmdWrapmkLHsParmkLHsTupleExpr mkLHsVarTuple mkLHsWrap mkLHsWrapCo mkLastStmt mkLetStmt mkLocatedListmkMatch mkMatchGroupmkNPat mkNPlusKPatmkParPat mkPatSynBindmkPrefixFunRhs mkPsBindStmt mkRecStmt mkRnBindStmtmkSimpleGeneratedFunBind mkSimpleMatch mkTcBindStmt mkTopFunBindmkTransformByStmtmkTransformStmt mkTypedSplicemkUntypedSplice mkVarBindnlConPat nlConPatName nlConVarPatnlConVarPatNamenlHsApp nlHsAppKindTy nlHsAppTynlHsAppsnlHsCase nlHsDataConnlHsDo nlHsFunTynlHsIf nlHsIntLitnlHsLamnlHsLit nlHsOpAppnlHsPar nlHsParTynlHsSyntaxApps nlHsTyApp nlHsTyApps nlHsTyConApp nlHsTyVarnlHsVar nlHsVarApps nlInfixConPatnlListnlLitPatnlNullaryConPatnlParPat nlTuplePatnlVarPat nlWildConPat nlWildPat nlWildPatNamenl_HsVarspanHsLocaLBindsunguardedGRHSs unguardedRHS unitRecStmtTc CollectFlagCollNoDictBindersCollWithDictBinders CollectPass collectXXPat$fCollectPassGhcPassaBSENT_ERROR_IDaBSENT_SUM_FIELD_ERROR_IDcastBottomExprerrorIds floatBindingsmkAbsentErrorApp mkBigCoreTupmkBigCoreTupTymkBigCoreVarTupmkBigCoreVarTup1mkBigCoreVarTupTy mkBuildExpr mkConsExpr mkCoreApp mkCoreTupmkCoreTupBoxity mkCoreUbxSum mkCoreUbxTupmkCoreVarTupTy mkFoldrExpr mkIfThenElsemkImpossibleExpr mkIntExprInt mkIntegerExpr mkJustExpr mkListExpr mkNaturalExpr mkNilExprmkNonEmptyListExpr mkNothingExprmkRuntimeErrorAppmkSmallTupleCasemkSmallTupleSelectormkStringExprFSmkStringExprFSWith mkTupleCasemkTupleSelectormkTupleSelector1mkUncheckedIntExpr mkWildCasemkWildEvBindermkWildValBindernON_EXHAUSTIVE_GUARDS_ERROR_IDnO_METHOD_BINDING_ERROR_ID pAT_ERROR_IDrEC_CON_ERROR_IDrEC_SEL_ERROR_IDrUNTIME_ERROR_ID sortQuantVars tYPE_ERROR_IDunitExpr wrapFloat wrapFloats FloatBind FloatCaseFloatLet$fOutputableFloatBind evCallStackevDelayedErrordefaultSimpleOptsexprIsConApp_maybeexprIsLambda_maybeexprIsLiteral_maybejoinPointBinding_maybejoinPointBindings_maybesimpleOptExprWith simpleOptPgm so_co_opts$fOutputableSimpleOptEnvinitOptCoercionOptsinitParserOptsinitSimpleOptsaddIdSpecialisations addRuleInfo emptyRuleBaseextendRuleBaseListextendRuleInfogetRules initRuleOpts lookupRulemkRule mkRuleBase pprRuleBasepprRulesForUser roughTopNamesruleCheckProgram rulesOfBinds unionRuleBase builtinRules caseRules primOpRules$fAlternativeRuleM$fApplicativeRuleM$fFunctorRuleM$fMonadFailRuleM $fMonadRuleM$fMonadPlusRuleMcoerceId coerceNamecoercionTokenId ghcPrimIdslazyIdleftSectionName mkDataConRep mkDictFunId mkDictFunTy mkDictSelRhs mkFCallId noinlineIdnoinlineIdName nullAddrId proxyHashIdrealWorldPrimIdrightSectionNameseqIdunwrapNewTypeBodyvanillaDataConBoxer voidArgId wiredInIdswrapFamInstBodyDCBunarise$fOutputableUnariseVal coreToStg$fApplicativeCtsM $fFunctorCtsM $fEqHowBound $fEqLetInfo$fHasDynFlagsCtsM $fMonadCtsMpatSynToIfaceDecltidyToIfaceContexttidyToIfaceType toIfUnfolding toIfaceAlt toIfaceApp toIfaceBang toIfaceBind toIfaceBndrtoIfaceCoercion toIfaceCon toIfaceExpr toIfaceIdBndrtoIfaceIdDetails toIfaceIdInfo toIfaceKind toIfaceLFInfotoIfaceLetBndrtoIfaceSrcBangtoIfaceTickish toIfaceTvBndrtoIfaceTvBndrstoIfaceTyCoVarBinderstoIfaceTyCon_name toIfaceTyVar toIfaceType toIfaceVar findTypeShapeisWorkerSmallEnoughmkWWstr mkWorkerArgs mkWwBodiessplitArgType_maybe wantToUnboxDataConPatContextdcpc_codcpc_dc dcpc_tc_argsUnboxingDecision StopUnboxingUnbox wwTopBindsdmdAnalProgram DmdAnalOptsdmd_strict_dicts$fOutputableAnalEnvcprAnalProgram$fOutputableSigEnv$fDataABExport$fDataABExport0$fDataABExport1$fDataAmbiguousFieldOcc$fDataAmbiguousFieldOcc0$fDataAmbiguousFieldOcc1 $fDataAnnDecl$fDataAnnDecl0$fDataAnnDecl1$fDataAnnProvenance$fDataAnnProvenance0$fDataAnnProvenance1$fDataApplicativeArg$fDataApplicativeArg0$fDataApplicativeArg1$fDataArithSeqInfo$fDataArithSeqInfo0$fDataArithSeqInfo1$fDataClsInstDecl$fDataClsInstDecl0$fDataClsInstDecl1$fDataCmdTopTc $fDataCoPat $fDataConDecl$fDataConDecl0$fDataConDecl1$fDataConDeclField$fDataConDeclField0$fDataConDeclField1$fDataConPatTc$fDataDataFamInstDecl$fDataDataFamInstDecl0$fDataDataFamInstDecl1$fDataDefaultDecl$fDataDefaultDecl0$fDataDefaultDecl1$fDataDerivClauseTys$fDataDerivClauseTys0$fDataDerivClauseTys1$fDataDerivDecl$fDataDerivDecl0$fDataDerivDecl1$fDataDerivStrategy$fDataDerivStrategy0$fDataDerivStrategy1 $fDataFamEqn $fDataFamEqn0 $fDataFamEqn1$fDataFamilyDecl$fDataFamilyDecl0$fDataFamilyDecl1$fDataFamilyInfo$fDataFamilyInfo0$fDataFamilyInfo1$fDataFamilyResultSig$fDataFamilyResultSig0$fDataFamilyResultSig1$fDataFieldLabelStrings$fDataFieldLabelStrings0$fDataFieldLabelStrings1$fDataFieldOcc$fDataFieldOcc0$fDataFieldOcc1$fDataFixitySig$fDataFixitySig0$fDataFixitySig1$fDataForeignDecl$fDataForeignDecl0$fDataForeignDecl1 $fDataFunDep $fDataFunDep0 $fDataFunDep1 $fDataGRHS $fDataGRHS0 $fDataGRHS1 $fDataGRHS2 $fDataGRHS3 $fDataGRHS4 $fDataGRHSs $fDataGRHSs0 $fDataGRHSs1 $fDataGRHSs2 $fDataGRHSs3 $fDataGRHSs4 $fDataHsArg $fDataHsArrow$fDataHsArrow0$fDataHsArrow1$fDataHsArrowMatchContext$fDataHsBindLR$fDataHsBindLR0$fDataHsBindLR1$fDataHsBindLR2$fDataHsBracket$fDataHsBracket0$fDataHsBracket1 $fDataHsCmd $fDataHsCmd0 $fDataHsCmd1$fDataHsCmdTop$fDataHsCmdTop0$fDataHsCmdTop1$fDataHsConDeclGADTDetails$fDataHsConDeclGADTDetails0$fDataHsConDeclGADTDetails1$fDataHsDataDefn$fDataHsDataDefn0$fDataHsDataDefn1 $fDataHsDecl $fDataHsDecl0 $fDataHsDecl1$fDataHsDerivingClause$fDataHsDerivingClause0$fDataHsDerivingClause1 $fDataHsExpr $fDataHsExpr0 $fDataHsExpr1$fDataHsFieldLabel$fDataHsFieldLabel0$fDataHsFieldLabel1$fDataHsForAllTelescope$fDataHsForAllTelescope0$fDataHsForAllTelescope1 $fDataHsGroup$fDataHsGroup0$fDataHsGroup1$fDataHsIPBinds$fDataHsIPBinds0$fDataHsIPBinds1 $fDataHsLit $fDataHsLit0 $fDataHsLit1$fDataHsLocalBindsLR$fDataHsLocalBindsLR0$fDataHsLocalBindsLR1$fDataHsLocalBindsLR2$fDataHsMatchContext$fDataHsMatchContext0$fDataHsMatchContext1$fDataHsOuterTyVarBndrs$fDataHsOuterTyVarBndrs0$fDataHsOuterTyVarBndrs1$fDataHsOverLit$fDataHsOverLit0$fDataHsOverLit1$fDataHsPatSigType$fDataHsPatSigType0$fDataHsPatSigType1$fDataHsPatSynDir$fDataHsPatSynDir0$fDataHsPatSynDir1 $fDataHsPragE$fDataHsPragE0$fDataHsPragE1$fDataHsRecField'$fDataHsRecFields$fDataHsRecFields0$fDataHsRecFields1$fDataHsScaled$fDataHsScaled0$fDataHsScaled1$fDataHsSigType$fDataHsSigType0$fDataHsSigType1$fDataHsSplice$fDataHsSplice0$fDataHsSplice1$fDataHsSplicedThing$fDataHsSplicedThing0$fDataHsSplicedThing1$fDataHsStmtContext$fDataHsStmtContext0$fDataHsStmtContext1$fDataHsTupArg$fDataHsTupArg0$fDataHsTupArg1$fDataHsTyVarBndr$fDataHsTyVarBndr0$fDataHsTyVarBndr1 $fDataHsType $fDataHsType0 $fDataHsType1$fDataHsValBindsLR$fDataHsValBindsLR0$fDataHsValBindsLR1$fDataHsValBindsLR2$fDataHsWildCardBndrs$fDataHsWildCardBndrs0$fDataHsWildCardBndrs1$fDataIE $fDataIE0 $fDataIE1 $fDataIPBind $fDataIPBind0 $fDataIPBind1$fDataImportDecl$fDataImportDecl0$fDataImportDecl1$fDataInjectivityAnn$fDataInjectivityAnn0$fDataInjectivityAnn1$fDataInstDecl$fDataInstDecl0$fDataInstDecl1$fDataLHsQTyVars$fDataLHsQTyVars0$fDataLHsQTyVars1$fDataListPatTc $fDataMatch $fDataMatch0 $fDataMatch1 $fDataMatch2 $fDataMatch3 $fDataMatch4$fDataMatchGroup$fDataMatchGroup0$fDataMatchGroup1$fDataMatchGroup2$fDataMatchGroup3$fDataMatchGroup4$fDataNHsValBindsLR$fDataNHsValBindsLR0$fDataNHsValBindsLR1$fDataParStmtBlock$fDataParStmtBlock0$fDataParStmtBlock1$fDataParStmtBlock2 $fDataPat $fDataPat0 $fDataPat1$fDataPatSynBind$fDataPatSynBind0$fDataPatSynBind1$fDataPatSynBind2$fDataPendingRnSplice$fDataPendingTcSplice$fDataRecStmtTc$fDataRecordPatSynField$fDataRecordPatSynField0$fDataRecordPatSynField1$fDataRecordUpdTc$fDataRoleAnnotDecl$fDataRoleAnnotDecl0$fDataRoleAnnotDecl1$fDataRuleBndr$fDataRuleBndr0$fDataRuleBndr1$fDataRuleDecl$fDataRuleDecl0$fDataRuleDecl1$fDataRuleDecls$fDataRuleDecls0$fDataRuleDecls1 $fDataSig $fDataSig0 $fDataSig1$fDataSpliceDecl$fDataSpliceDecl0$fDataSpliceDecl1$fDataStandaloneKindSig$fDataStandaloneKindSig0$fDataStandaloneKindSig1 $fDataStmtLR $fDataStmtLR0 $fDataStmtLR1 $fDataStmtLR2 $fDataStmtLR3 $fDataStmtLR4 $fDataStmtLR5 $fDataStmtLR6$fDataSyntaxExprRn$fDataSyntaxExprTc$fDataTyClDecl$fDataTyClDecl0$fDataTyClDecl1$fDataTyClGroup$fDataTyClGroup0$fDataTyClGroup1$fDataTyFamInstDecl$fDataTyFamInstDecl0$fDataTyFamInstDecl1$fDataWarnDecl$fDataWarnDecl0$fDataWarnDecl1$fDataWarnDecls$fDataWarnDecls0$fDataWarnDecls1$fDataXBindStmtRn$fDataXBindStmtTc$fDataXViaStrategyPs$fDataXXExprGhcTc$fEqIE$fEqIE0$fEqIE1 AnnsModuleam_declsam_mainHsModulehsmodAnn hsmodDeclshsmodDeprecMessage hsmodExportshsmodHaddockModHeader hsmodImports hsmodLayout hsmodNameHsParsedModule hpm_module hpm_src_files$fDataAnnsModule$fDataHsModule$fEqAnnsModule$fOutputableHsModuleextendModSummaryNoDeps findTarget isBootSummarymsDynObjFilePath msHiFilePath msHsFilePath msObjFilePathms_home_allimps ms_home_impsms_home_srcimpsms_impsms_installed_mod ms_mod_nameExtendedModSummaryemsInstantiatedUnits emsModSummary ModSummary ms_hie_date ms_hs_date ms_hsc_src ms_hspp_buf ms_hspp_file ms_hspp_opts ms_iface_date ms_locationms_mod ms_obj_date ms_parsed_mod ms_srcimpsms_textual_imps$fOutputableExtendedModSummary$fOutputableModSummaryemptyMGextendMG extendMG' extendMGInstfilterToposortToModulesisTemplateHaskellOrQQNonBootmapMG mgBootModules mgElemModulemgExtendedModSummariesmgLookupModulemgModSummariesmgModSummaries' mkModuleGraphmkModuleGraph'needsTemplateHaskellOrQQ showModMsg ModuleGraphModuleGraphNodeInstantiationNode ModuleNode$fOutputableModuleGraphNodeemptyFullModIfaceemptyIfaceHashCacheemptyPartialModIfacemi_bootmi_fix mi_free_holesmi_semantic_modulemkIfaceHashCacherenameFreeHolesIfaceBackendExts IfaceDeclExts IfaceExportModIfaceModIfaceBackend mi_exp_hash mi_finsts mi_fix_fn mi_flag_hash mi_hash_fn mi_hpc_hash mi_iface_hash mi_mod_hash mi_opt_hash mi_orphanmi_orphan_hashmi_plugin_hash mi_warn_fn ModIface_mi_anns mi_arg_docsmi_complete_matches mi_decl_docsmi_declsmi_deps mi_doc_hdr mi_exports mi_ext_fields mi_fam_insts mi_final_exts mi_fixities mi_globalsmi_hpc mi_hsc_srcmi_insts mi_modulemi_rules mi_sig_ofmi_trust mi_trust_pkg mi_usages mi_used_thmi_warnsPartialModIfaceWhetherHasFamInstWhetherHasOrphans$fBinaryModIface_$fNFDataModIface_ addListToHptaddToHptallHptanyHpt delFromHpteltsHptemptyHomePackageTable filterHpt listToHpt lookupHptlookupHptByModulelookupHptDirectlymapHptpprHPT HomeModInfo hm_detailshm_iface hm_linkableHomePackageTable addEpsInStatsemptyPackageIfaceTableEpsStats n_decls_in n_decls_out n_ifaces_in n_insts_in n_insts_out n_rules_in n_rules_outExternalPackageStateEPSeps_PITeps_PTE eps_ann_enveps_complete_matcheseps_fam_inst_enveps_free_holes eps_inst_env eps_is_booteps_mod_fam_inst_env eps_rule_base eps_statsPackageCompleteMatchesPackageFamInstEnvPackageIfaceTablePackageInstEnvPackageRuleBasePackageTypeEnvCgGutscg_binds cg_dep_pkgs cg_foreigncg_foreign_files cg_hpc_info cg_modBreaks cg_modulecg_spt_entries cg_tyconsModGutsmg_anns mg_arg_docsmg_bindsmg_complete_matches mg_decl_docsmg_deps mg_doc_hdr mg_exportsmg_fam_inst_env mg_fam_insts mg_fix_env mg_foreignmg_foreign_files mg_hpc_info mg_hsc_src mg_inst_envmg_instsmg_loc mg_modBreaks mg_module mg_patsyns mg_rdr_envmg_rulesmg_safe_haskellmg_tcs mg_trust_pkg mg_usages mg_used_thmg_warns HscStatusHscNotGeneratingCode HscRecomp HscUpToDate HscUpdateBoot HscUpdateSig hscs_gutshscs_mod_locationhscs_old_iface_hashhscs_partial_iface metaRequestAW metaRequestD metaRequestE metaRequestP metaRequestTMetaHook MetaRequestMetaAWMetaDMetaEMetaPMetaT MetaResult exprCtOrigin grhssCtOrigin isGivenOrigin isSigMaybeisVisibleOrigin lexprCtOriginmatchesCtOrigin pprCtOriginpprSigSkolInfo pprSkolInfopprUserTypeCtxttoInvisibleOriginCtOrigin AnnOrigin AppOriginArithSeqOriginAssocFamPatOrigin BracketOriginCycleBreakerOrigin DefaultOriginDerivClauseOriginDerivOriginCoerce DerivOriginDCDoOrigin DoPatOriginExprHoleOrigin ExprSigOrigin FunDepOrigin1 FunDepOrigin2 GivenOriginHasFieldOrigin IPOccOriginIfOriginInstProvidedOrigin InstSCOrigin KindEqOrigin ListOrigin LiteralOrigin MCompOriginMCompPatOrigin NegateOriginNonLinearPatternOrigin OccurrenceOfOccurrenceOfRecSel OtherSCOriginOverLabelOriginPatCheckOrigin PatOrigin PatSigOrigin ProcOriginProvCtxtOriginRecordUpdOriginScOrigin SectionOriginShouldn'tHappenOriginSpecPragOriginStandAloneDerivOrigin StaticOrigin TupleOrigin TypeEqOriginTypeHoleOriginUsageEnvironmentOf ViewPatOrigin uo_actual uo_expecteduo_thing uo_visible SkolemInfo ArrowSkol BracketSkol DataConSkol DerivSkol FamInstSkol ForAllSkolIPSkol InferSkolInstSkolPatSkol QuantCtxtSkol ReifySkolRuleSkolRuntimeUnkSkolSigSkol SigTypeSkol TyConSkolUnifyForAllSkolUnkSkol UserTypeCtxt ClassSCCtxt ConArgCtxt DataKindCtxt DataTyCtxtDefaultDeclCtxtDerivClauseCtxt ExprSigCtxt ForSigCtxt FunSigCtxt GenSigCtxtGhciCtxt InfSigCtxt InstDeclCtxt KindSigCtxt PatSigCtxt PatSynCtxt RuleSigCtxt SigmaCtxt SpecInstCtxtStandaloneKindSigCtxtTyFamResKindCtxt TySynCtxt TySynKindCtxtTyVarBndrKindCtxt TypeAppCtxt$fOutputableCtOrigin$fOutputableSkolemInfoaddHoles addImplics addInsols addSimplesandCts andManyCtsandWCarisesFromGivensbumpCtLocDepthbumpSubGoalDepth canEqLHSKind canEqLHSTypecanEqLHS_maybecheckTelescopeSkolconsCtsctEqRel ctEvCoercion ctEvEqRelctEvEvIdctEvExpr ctEvFlavourctEvFlavourRolectEvIdctEvLoc ctEvOriginctEvPredctEvRolectEvTerm ctEvidence ctFlavourctFlavourContainsDerived ctFlavourRolectLoc ctLocDepthctLocEnv ctLocLevel ctLocOrigin ctLocSpanctLocTypeOrKind_maybectOriginctPredcteHoleBlockercteImpredicativecteInsolubleOccurscteOK cteProblemcteSolubleOccurs cteTypeFamilycterClearOccursCheck cterFromKindcterHasNoProblemcterHasOccursCheckcterHasOnlyProblemcterHasProblemcterRemoveProblemcterSetOccursCheckSolublectsEltsdropDerivedSimples dropDerivedWCdropMisleadingemptyCtsemptyWCeqCanDischargeFR eqCanEqLHS eqCanRewriteeqCanRewriteFReqMayRewriteFR extendCtsListgetPendingWantedScsgetUserTypeErrorMsgimplicationPrototypeinitialSubGoalDepth insolubleCt insolubleEqCtinsolubleImplic insolubleWC isDerived isDerivedCt isDroppableCt isEmptyCts isEmptyWCisGiven isGivenCt isGivenLocisInsolubleReasonisInsolubleStatusisOutOfScopeHoleisPendingScDictisPendingScInstisSolvedStatus isSolvedWCisUserTypeErrorCtisWanted isWantedCt listToCtsmaxSubGoalDepth mkGivenLocmkGivens mkImplicWC mkIrredCt mkKindLocmkNonCanonicalmkNonCanonicalCt mkSimpleWCmkTcEqPredLikeEvpprCtLocpprCts pprEvVarThetapprEvVarWithType pprEvVarssetCtLoc setCtLocEnvsetCtLocOrigin setCtLocSpansingleCtsnocCtssubGoalDepthExceededsuperClassesMightHelp toKindLoc tyCoVarsOfCttyCoVarsOfCtList tyCoVarsOfCtstyCoVarsOfCtsList tyCoVarsOfWCtyCoVarsOfWCListunionsWCupdateCtLocOriginwrapTypeCanEqLHSTyFamLHSTyVarLHSCheckTyEqProblemCheckTyEqResultCtCDictCanCEqCan CIrredCan CNonCanonical CQuantCancc_class cc_eq_relcc_evcc_lhs cc_pend_sc cc_reasoncc_rhs cc_tyargs CtEvidence CtDerivedCtGivenCtWanted ctev_dest ctev_evarctev_loc ctev_nosh ctev_pred CtFlavourDerivedGivenWanted CtFlavourRole CtIrredReasonAbstractTyConReasonHoleBlockerReasonIrredShapeReasonNonCanonicalReason ReprEqReasonShapeMismatchReasonCtLoc ctl_depthctl_env ctl_origin ctl_t_or_kCts HasGivenEqs LocalGivenEqs MaybeGivenEqs NoGivenEqsHolehole_lochole_occ hole_sorthole_tyHoleSortConstraintHoleExprHoleTypeHole ImplicStatusIC_BadTelescope IC_Insoluble IC_Solved IC_Unsolvedics_dead ImplicationImplicic_bindsic_envic_given ic_given_eqsic_info ic_need_inner ic_need_outeric_skols ic_statusic_tclvl ic_wantedic_warn_inaccessibleQCInstQCIqci_ev qci_pend_scqci_predqci_tvs ShadowInfoWDerivWOnly SubGoalDepthTcEvDest EvVarDestHoleDestWantedConstraintsWCwc_holeswc_impl wc_simpleXi $fEqCtFlavour$fEqHasGivenEqs$fEqShadowInfo$fEqSubGoalDepth$fMonoidCheckTyEqResult$fSemigroupCheckTyEqResult$fMonoidHasGivenEqs$fSemigroupHasGivenEqs$fOrdSubGoalDepth$fOutputableCanEqLHS$fOutputableCheckTyEqResult$fOutputableCt$fOutputableCtEvidence$fOutputableCtFlavour$fOutputableCtIrredReason$fOutputableHasGivenEqs$fOutputableHole$fOutputableHoleSort$fOutputableImplicStatus$fOutputableImplication$fOutputableQCInst$fOutputableSubGoalDepth$fOutputableTcEvDest$fOutputableWantedConstraintstypeCharCmpTyContypeCharToNatTyContypeConsSymbolTyContypeNatAddTyContypeNatCmpTyContypeNatCoAxiomRulestypeNatDivTyContypeNatExpTyContypeNatLogTyContypeNatModTyContypeNatMulTyContypeNatSubTyContypeNatToCharTyCon typeNatTyConstypeSymbolAppendTyContypeSymbolCmpTyContypeUnconsSymbolTyConghcPrimDeclDocsghcPrimExportsisKnownKeyNameisNumericClassisStandardClass knownKeyNameslookupKnownKeyNamelookupKnownNameInfomaybeCharLikeConmaybeIntLikeConprimOpIdHiePath hieNameOcc hieVersion pprBindSpan pprIdentifier pprNodeIdents toHieNameBindType InstanceBind RegularBind ContextInfo ClassTyDeclDeclEvidenceVarBindEvidenceVarUseIEThing MatchBind PatternBindRecFieldTyDecl TyVarBindUseValBindDeclTypeClassDecConDecDataDecFamDecInstDec PatSynDecSynDec EvBindDeps getEvBindDeps EvVarSourceEvImplicitBind EvInstBind EvLetBind EvPatternBind EvSigBind EvWrapperBindcls isSuperInstHieAST nodeChildrennodeSpansourcedNodeInfoHieASTsgetAstsHieArgsHieFilehie_asts hie_exports hie_hs_file hie_hs_src hie_module hie_typesHieName ExternalName KnownKeyName LocalNameHieTypeHAppTyHCastTy HCoercionTy HForAllTyHFunTyHLitTyHQualTy HTyConAppHTyVarTy HieTypeFixRoll HieTypeFlatExportImportImportAs ImportHiding IdentifierIdentifierDetails identInfo identTypeNodeAnnotationnodeAnnotConstr nodeAnnotTypeNodeIdentifiersNodeInfonodeAnnotationsnodeIdentifiersnodeType NodeOrigin GeneratedInfo SourceInfoRecFieldContextRecFieldAssign RecFieldDecl RecFieldMatch RecFieldOccScope LocalScope ModuleScopeSourcedNodeInfogetSourcedNodeInfoSpan TyVarScopeResolvedScopesUnresolvedScope TypeIndex$fBinaryBindType$fBinaryContextInfo$fBinaryDeclType$fBinaryEvBindDeps$fBinaryEvVarSource$fBinaryHieAST$fBinaryHieASTs$fBinaryHieArgs$fBinaryHieFile$fBinaryHieType$fBinaryIEType$fBinaryIdentifierDetails$fBinaryNodeAnnotation$fBinaryNodeInfo$fBinaryNodeOrigin$fBinaryRecFieldContext $fBinaryScope$fBinarySourcedNodeInfo$fBinaryTyVarScope $fDataScope$fEnumBindType$fEnumDeclType $fEnumIEType$fEnumNodeOrigin$fEnumRecFieldContext $fEqBindType$fEqContextInfo $fEqDeclType$fEqEvBindDeps $fEqHieName$fEqEvVarSource $fEqHieArgs $fEqHieType $fEqIEType$fEqIdentifierDetails$fEqNodeAnnotation$fEqNodeOrigin$fEqRecFieldContext $fEqScope$fEqTyVarScope$fFoldableHieAST$fFoldableHieASTs$fFoldableHieArgs$fFoldableHieType$fFoldableIdentifierDetails$fFoldableNodeInfo$fFoldableSourcedNodeInfo$fFunctorHieAST$fFunctorHieASTs$fFunctorHieArgs$fFunctorHieType$fFunctorIdentifierDetails$fFunctorNodeInfo$fFunctorSourcedNodeInfo$fMonoidIdentifierDetails$fSemigroupIdentifierDetails $fOrdBindType$fOrdContextInfo $fOrdDeclType$fOrdEvBindDeps $fOrdHieName$fOrdEvVarSource $fOrdIEType$fOrdNodeAnnotation$fOrdNodeOrigin$fOrdRecFieldContext $fOrdScope$fOrdTyVarScope$fOutputableBindType$fOutputableContextInfo$fOutputableDeclType$fOutputableEvBindDeps$fOutputableEvVarSource$fOutputableHieAST$fOutputableHieASTs$fOutputableHieName$fOutputableIEType$fOutputableIdentifierDetails$fOutputableNodeAnnotation$fOutputableNodeInfo$fOutputableNodeOrigin$fOutputableRecFieldContext$fOutputableScope$fOutputableSourcedNodeInfo$fOutputableTyVarScope$fTraversableHieAST$fTraversableHieASTs$fTraversableHieArgs$fTraversableHieType$fTraversableIdentifierDetails$fTraversableNodeInfo$fTraversableSourcedNodeInfo combineAstcombineNodeInfo combineScopescombineSourcedNodeInfo compressTypes definedInAsts emptyNodeInfofindEvidenceUse flattenAstfoldTypefreshTypeIndexgenerateReferencesMapgetBindSiteFromContextgetEvidenceBindDepsgetEvidenceTreegetEvidenceTreesAtPointgetNameBindinggetNameBindingInClass getNameScopegetNameScopeAndBindinggetScopeFromContext getTypeIndexhieTypeToIface initialHTS insertAstisEvidenceBindisEvidenceContext isEvidenceUse isOccurrenceleftOflocOnlymakeNode makeNodeA makeTypeNode makeTypeNodeA mergeAsts mergeSortAstsmkLScope mkLScopeA mkLScopeNmkScopemkScopeAmkSourcedNodeInfonodeInforecoverFullType renderHieTyperesolveTyVarScopeLocalresolveTyVarScopesresolveVisibilityrightOfscopeContainsSpanselectLargestContainedBy selectPointselectSmallestContainingsimpleNodeInfosmallestContainingSatisfyingsourcedNodeIdents startsRightOf EvidenceInfoevidenceDetails evidenceSpan evidenceType evidenceVar HieTypeStateHTS freshIndexhtyTabletyMapRefMap$fEqEvidenceInfo$fFunctorEvidenceInfo$fOrdEvidenceInfo$fOutputableEvidenceInfodiffAstdiffAstsdiffFilediffListeqDiffnormalizeIdentsvalidAstvalidateScopesDiff DiffIdentemptyInteractiveContextextendInteractiveContextextendInteractiveContextWithIdsicExtendGblRdrEnv icInScopeTTsicInteractiveModule icPrintUnqualsetInteractivePrintNamesubstInteractiveContextInteractiveContextic_cwd ic_default ic_dflags ic_fix_env ic_imports ic_instances ic_int_print ic_mod_indexic_monad ic_plugins ic_resume ic_rn_gbl_env ic_tythingsInteractiveImportIIDeclIIModule$fOutputableInteractiveImportHscEnvhsc_EPShsc_FChsc_HPThsc_IChsc_NC hsc_dflags hsc_hooks hsc_interp hsc_logger hsc_mod_graph hsc_pluginshsc_static_plugins hsc_targets hsc_tmpfshsc_type_env_var hsc_unit_dbs hsc_unit_env$fApplicativeHsc $fFunctorHsc$fHasDynFlagsHsc$fHasLoggerHsc $fMonadHsc $fMonadIOHsc hptAllThingshptAnnshptCompleteSigs hptInstanceshptRuleshptSomeThingsBelowUshscEPS hsc_home_unit hsc_unitslookupIfaceByModule lookupType mainModIsmkInteractiveHscEnvprepareAnnotationsrunHscrunInteractiveHscaddHomeModuleToFinderfindExactModulefindExposedPackageModulefindHomeModulefindImportedModulefindObjectLinkablefindObjectLinkableMaybefindPluginModuleflushFinderCachesmkHiOnlyModLocationmkHiPathmkHomeModLocationmkHomeModLocation2 mkObjPath mkStubPaths uncacheModule codeOutput ipInitCodeoutputForeignStubsprofilingInitCodeccTypeccsTypecostCentreFrom dynProfHdremitInfoTableProv emitSetCCCenterCostCentreFunenterCostCentreThunkinitCostCentresinitInfoTableProvinitUpdFrameProfldvEnterldvEnterClosureldvRecordCreate mkCCostCentremkCCostCentreStack profAlloc profDynAllocrestoreCurrentCostCentresaveCurrentCostCentre staticProfHdr storeCurCCSallocDynClosureallocDynClosureCmmallocHeapClosure altHeapCheckaltHeapCheckReturnsTo emitSetDynHdrentryHeapCheckentryHeapCheck'heapStackCheckGenmkStaticClosuremkStaticClosureFieldsnoEscapeHeapCheck bindConArgs buildDynCon cgTopRhsConcafAnal cafAnalDatadoSRTsemptySRT srtMapNonCAFsCAFEnvCAFSet ModuleSRTInfo dedupSRTsflatSRTs moduleSRTMap thisModuleSRTMap $fEqCAFLabel $fEqSRTEntry $fEqSomeLabel $fOrdCAFLabel $fOrdSRTEntry$fOrdSomeLabel$fOutputablePenvCAFLabel$fOutputablePenvModuleSRTInfo$fOutputablePenvSRTEntry$fOutputablePenvSomeLabel cgForeignCall emitCCallemitCloseNurseryemitForeignCallemitLoadThreadStateemitOpenNurseryemitPopTupleRegsemitPushTupleRegsemitRestoreRegs emitSaveRegsemitSaveThreadStateloadThreadStatesaveThreadStatecgOpAppshouldInlinePrimOpcmmLayoutStacksetInfoTableStackMap$fOutputableStackMap$fOutputableStackSlotcgExprcgTopRhsClosureemitBlackHoleCodeemitUpdateFramepushUpdateFramecodeGen parseCmmFile abandonStmtaddLibrarySearchPath addSptEntrybreakpointStatuscostCentreStackInfo createBCOsevalIOevalStmt evalStringevalStringToIOStringfindSystemLibraryfreeHValueRefsfromEvalResultgetBreakpointVar getClosure getModBreaks hscInterp initObjLinker interpCmdinterpreterDynamicinterpreterProfiled iservCall loadArchiveloadDLL lookupClosure lookupSymbol mallocData mkCostCentres mkEvalOptsmkFinalizedHValue newBreakArraypurgeLookupSymbolCache readIServremoveLibrarySearchPath resolveObjs seqHValue stopInterpstoreBreakpoint unloadObj withIServ withIServ_wormhole wormholeRef writeIServgetFrameworkOptsgetUnitFrameworkOpts loadFrameworkrunInjectRPaths libmLinkOpts linkDynLib exeFileName linkBinary linkBinary' linkStaticLibemptyClosureEnvextendClosureEnvlinkBCOlinkFaillookupIElookupStaticPtr nameToCLabel ClosureEnvmkITbls assembleBCOsassembleOneBCO bcoFreeNamesiNTERP_STACK_CHECK_THRESHmkTupleInfoLit$fApplicativeAssembler$fFunctorAssembler$fMonadAssembler byteCodeGen$fApplicativeBcM $fFunctorBcM $fEqDiscr$fHasDynFlagsBcM $fMonadBcM $fOrdDiscr$fOutputableDiscrdefaultWarnErrLoggergetSessionDynFlagsliftGhcT logWarnings modifyLogger modifySessionmodifySessionM popLogHookMprintException pushLogHookM putLogMsgMputMsgM reflectGhcreifyGhc withSessionwithTempSession withTimingMGhcunGhcGhcMonad getSession setSessionGhcTunGhcT WarnErrLogger$fApplicativeGhc $fFunctorGhc$fApplicativeGhcT $fFunctorGhcT $fGhcMonadGhc$fGhcMonadGhcT$fMonadCatchGhcT$fMonadThrowGhcT$fMonadMaskGhcT $fMonadIOGhcT$fMonadCatchGhc$fMonadThrowGhc$fMonadMaskGhc $fMonadIOGhc$fHasDynFlagsGhc$fHasDynFlagsGhcT$fHasLoggerGhc$fHasLoggerGhcT $fMonadFixGhc $fMonadGhc $fMonadGhcT addSimplCount bindsOnlyPassdebugTraceMsgSdoFreeSimplTick doSimplTick errorMsgSfatalErrorMsgSgetAnnotationsgetFirstAnnotations getHscEnvgetPackageFamInstEnvgetPrintUnqualified getRuleBase getSrcSpanM getUniqMaskgetVisibleOrphanModshasDetailedCountsisZeroSimplCountliftIOWithCountplusSimplCountpprPassDetails pprSimplCountputMsgSrunCoreMrunMayberunWhen simplCountNzeroSimplCountCoreMCorePluginPassCoreToDoCoreAddCallerCcsCoreCSE CoreDesugarCoreDesugarOptCoreDoCallArity CoreDoCpr CoreDoDemand CoreDoExitifyCoreDoFloatInwardsCoreDoFloatOutwards CoreDoNothing CoreDoPassesCoreDoPluginPassCoreDoPrintCoreCoreDoRuleCheckCoreDoSimplifyCoreDoSpecConstrCoreDoSpecialisingCoreDoStaticArgsCoreDoWorkerWrapperCoreLiberateCase CoreOccurAnalCorePrepCoreTidyfloatOutConstantsfloatOutLambdasfloatOutOverSatAppsfloatToTopLevelOnly SimplCount SimplMode sm_case_casesm_cast_swizzle sm_dflags sm_eta_expand sm_inline sm_loggersm_namessm_phase sm_pre_inlinesm_rules sm_uf_optsAltMerge BetaReductionCaseElim CaseIdentity CaseMerge CaseOfCase EtaExpansion EtaReductionFillInCaseDefault KnownBranchLetFloatFromLetPostInlineUnconditionallyPreInlineUnconditionally RuleFiredSimplifierDone UnfoldingDone$fAlternativeCoreM$fApplicativeCoreM$fFunctorCoreM$fEqTick$fHasDynFlagsCoreM$fHasLoggerCoreM$fHasModuleCoreM $fMonadCoreM$fMonadIOCoreM$fMonadPlusCoreM$fMonadUniqueCoreM $fOrdTick$fOutputableCoreToDo$fOutputableFloatOutSwitches$fOutputableSimplMode$fOutputableTick specProgram$fOutputableCallInfo$fOutputableCallInfoSet$fOutputableDictBind$fOutputableSpecArg$fOutputableSpecEnvspecConstrProgram$fOutputableArgOcc$fOutputableCall$fOutputableHowBound$fOutputableScUsage$fOutputableValue checkedTickfreeTick getFamEnvsgetOptCoercionOpts getSimplCount getSimplRulesinitSmplnewId newJoinIdtick traceSmplSimplM$fApplicativeSimplM$fFunctorSimplM$fHasDynFlagsSimplM$fHasLoggerSimplM$fMonadIOSimplM $fMonadSimplM$fMonadUniqueSimplM addFloats addJoinFloats addJoinFlts addLetFloats addLetFltsaddNewInScopeIds bumpCaseDepthdoFloatFromRhs emptyFloatsemptyJoinFloatsemptyLetFloats extendFloats getInScopegetModegetTopFloatBinds letFloatBinds lookupRecBndr mapLetFloatsmkContEx mkFloatBind mkRecFloats mkSimplEnv modifyInScope pprSimplEnvrefineFromInScope seDynFlagsseLoggerseUnfoldingOptssetInScopeFromEsetInScopeFromF setInScopeSetsetMode setSubstEnv simplBinder simplBinderssimplNonRecBndrsimplNonRecJoinBndr simplRecBndrssimplRecJoinBndrssubstId unitJoinFloat unitLetFloatupdModewrapJoinFloatswrapJoinFloatsX JoinFloat JoinFloats LetFloatsSimplEnv seCaseDepth seCvSubst seIdSubst seInScopeseMode seTvSubst SimplFloats sfInScope sfJoinFloats sfLetFloatsSimplSRContExDoneExDoneId$fOutputableFloatFlag$fOutputableLetFloats$fOutputableSimplFloats$fOutputableSimplSRabstractFloats activeRuleactiveUnfolding addCastTo addTyArgTo addValArgToargInfoAppArgs argInfoExprcontArgscontHoleScaling contHoleType contIsDupablecontIsRhsOrArg contIsStop contIsTrivialcontResultType countArgsgetUnfoldingInRuleMatchinterestingCallContext isExitJoinId isSimplifiedisStrictArgInfolazyArgContext mkArgInfo mkBoringStopmkCasemkLam mkLazyArgStop mkRhsStoppostInlineUnconditionallypreInlineUnconditionally prepareAltspushSimplifiedArgssimplEnvForGHCitryEtaExpandRhsupdModeForRulesupdModeForStableUnfoldingsArgInfoai_argsai_discsai_dmdsai_enclai_funai_rulesCastByTyArgValArgas_arg as_arg_tyas_dmd as_hole_tyDupFlagNoDupOkToDup Simplified SimplCont ApplyToTy ApplyToValCastItSelectStop StrictArg StrictBindTickItsc_altssc_arg sc_arg_tysc_bndrsc_bndrssc_bodysc_contsc_dupsc_envsc_fun sc_fun_ty sc_hole_ty StaticEnv$fOutputableArgInfo$fOutputableArgSpec$fOutputableDupFlag$fOutputableSimplCont simplExpr simplRules simplTopBinds asJoinCeilLvlfloatSpecLevel incMinorLvl isJoinCeilLvlisTopLvlltLvlltMajLvl setLevels tOP_LEVEL FloatSpecFloatMeStayPutLevel LevelTypeBndrLvl JoinCeilLvl LevelledBind LevelledBndr LevelledExpr $fEqLevel $fEqLevelType$fOutputableFloatSpec$fOutputableLevel floatOutwards$fOutputableFloatBinds floatInwardsaddCallerCostCentres ccfFuncName ccfModuleName NamePatternPCharPEnd PWildcard$fBinaryCallerCcFilter$fBinaryNamePattern$fOutputableCallerCcFilter$fOutputableNamePatternfingerprintDynFlagsfingerprintHpcFlagsfingerprintOptFlags cmmPipelinedisplayLintResultsdumpPassResultendPass endPassIOinteractiveInScope lintAnnots lintAxiomslintCoreBindingslintExprlintInteractiveExprlintPassResult lintUnfolding$fApplicativeLintM$fFunctorLintM$fEqStaticPtrCheck$fHasDynFlagsLintM$fMonadFailLintM $fMonadLintMemptyImportAvailsemptyRoleAnnotEnvgetEvBindsTcPluginM getRoleAnnotshasCompleteSigimpLevel isPartialSig lintGblEnvlookupRoleAnnot mkModDepsmkRoleAnnotEnv modDepsElts outerLevel peCategoryplusImportAvails pprPECategorypprTcTyThingCategory pushErrCtxtpushErrCtxtSameOriginremoveBindingShadowing runTcPluginMtcTyThingCategorytcVisibleOrphanModsthLevel topAnnStagetopSpliceStagetopStageunsafeTcPluginTcM ArrowCtxt NoArrowCtxt ClosedTypeIdDocLocArgDocDeclDocInstDoc ModuleDocenv_gblenv_lclenv_topenv_umErrCtxtFrontendResultFrontendTypecheck IdBindingInfo ClosedLet NonClosedLet NotLetBoundIfGIfGblEnvif_doc if_rec_typesIfLIfLclEnvif_boot if_id_envif_implicits_envif_locif_mod if_nsubst if_tv_envIfM ImportAvails imp_dep_pkgs imp_finstsimp_mods imp_orphsimp_trust_own_pkgimp_trust_pkgs IsGroupClosed NameShape ns_exportsns_map ns_mod_name PendingStuffRnPendingTypedRnPendingUntyped TcPending PromotionErrClassPEConstrainedDataConPE FamDataConPE NoDataKindsDC NoDataKindsTCPatSynPE RecDataConPETyConPE RecFieldEnvRhsNamesRnM RoleAnnotEnv SelfBootInfo NoSelfBootSelfBootsb_mdssb_tcs SpliceTypeTypedUntypedTHDocsTcBinderTcIdBndrTcIdBndr_ExpTypeTcTvBndr TcBinderStack tcg_ann_envtcg_anns tcg_binds tcg_cc_sttcg_complete_matches tcg_defaulttcg_dependent_files tcg_dfun_n tcg_doc_hdrtcg_dus tcg_ev_binds tcg_exportstcg_fam_inst_env tcg_fam_insts tcg_field_env tcg_fix_env tcg_fordstcg_hf_pluginstcg_hpc tcg_imp_specs tcg_imports tcg_inst_env tcg_inststcg_keep tcg_ksigstcg_main tcg_mergedtcg_mod tcg_patsyns tcg_rdr_env tcg_rn_declstcg_rn_exportstcg_rn_imports tcg_rules tcg_safeInfer tcg_self_boottcg_semantic_modtcg_sigstcg_src tcg_static_wctcg_tc_pluginstcg_tcstcg_th_coreplugins tcg_th_docstcg_th_foreign_filestcg_th_modfinalizerstcg_th_remote_statetcg_th_splice_used tcg_th_statetcg_th_topdeclstcg_th_topnames tcg_th_used tcg_top_loc tcg_tr_module tcg_type_env tcg_used_gres tcg_warnsTcIdTcIdSet TcIdSigInfo CompleteSig PartialSig psig_hs_ty psig_namesig_bndrsig_ctxtsig_loc TcIdSigInstTISI sig_inst_sigsig_inst_skols sig_inst_tausig_inst_theta sig_inst_wcs sig_inst_wcxtcl_arrow_ctxt tcl_bndrstcl_ctxttcl_envtcl_errstcl_in_gen_codetcl_lietcl_loctcl_rdr tcl_tclvl tcl_th_bndrs tcl_th_ctxt tcl_usageTcM TcPatSynInfoTPSIpatsig_body_typatsig_ex_bndrspatsig_implicit_bndrs patsig_name patsig_prov patsig_reqpatsig_univ_bndrsTcPlugin tcPluginInit tcPluginSolve tcPluginStop TcPluginMTcPluginResultTcPluginContradiction TcPluginOkTcPluginSolverTcRefTcRnTcRnIfTcSigFun TcSigInfoTcIdSig TcPatSynSig TcTyThingAGlobal APromotionErrATcIdATcTyConATyVartct_idtct_info TcTypeEnvThLevelThStageBrackComp RunSpliceSplice WhereFromImportByPluginImportBySystem ImportByUser$fApplicativeTcPluginM$fFunctorTcPluginM$fContainsDynFlagsEnv$fContainsHooksEnv$fContainsLoggerEnv$fContainsModuleEnv$fContainsModuleTcGblEnv $fEqDocLoc$fHasOccNameTcBinder$fMonadFailTcPluginM$fMonadTcPluginM $fOrdDocLoc$fOutputableIdBindingInfo$fOutputablePromotionErr$fOutputableTcBinder$fOutputableTcIdSigInfo$fOutputableTcIdSigInst$fOutputableTcPatSynInfo$fOutputableTcSigInfo$fOutputableTcTyThing$fOutputableThStage$fOutputableWhereFrom tcSubMult unifyKind unifyType tcInitTidyEnvaddDependentFilesaddErrAt addErrCtxt addErrCtxtMaddErrTc addErrTcMaddErrsaddLandmarkErrCtxtaddLandmarkErrCtxtMaddLocMaddLocMA addLongErrAt addMessagesaddModFinalizersWithLclEnv addTcEvBind addTopEvBinds addWarnAt addWarnTc addWarnTcMadd_warn askNoErrsattemptMcaptureConstraintscheckErr checkNoErrscheckTccheckTcMchooseUniqueOccTccloneEvBindsVarcloneLocalNamedebugTcdiscardConstraints discardErrs discardResultdiscardWarningsdoptM dumpOptTcRndumpTcRnemitAnonTypeHoleemitConstraintsemitHole emitHolesemitImplicationemitImplications emitInsolubleemitNamedTypeHole emitSimple emitSimplesemitStaticConstraintsescapeArrowScopeextendFixityEnvfailAt failIfErrsMfailIfMfailIfTc failIfTcMfailWith failWithTc failWithTcM finalSafeModefixSafeInstancesfoldAndRecoverMforkM forkM_maybe getCCIndexM getCCIndexTcMgetConstraintVar getCtLocMgetDeclaredDefaultTysgetEnvsgetEps getEpsAndHpt getEpsVar getErrCtxt getErrsVar getFixityEnv getGHCiMonad getGblEnv getGhcModegetGlobalRdrEnvgetHpt getIfModule getImportsgetInteractivePrintName getIsGHCi getLclEnv getLclTypeEnvgetLocalRdrEnv getRdrEnvsgetRecFieldEnvgetStagegetStageAndBindLevelgetTcEvBindsMapgetTcEvTyCoVars getTcLevel getTopEnvgoptMifErrsMinGeneratedCodeinitIfaceCheck initIfaceLclinitIfaceLclWithSubst initIfaceLoad initIfaceTcRninitTcinitTcInteractive initTcRnIf initTcWithGblisTouchableTcM keepAlivemapAndRecoverM mapAndReportMmkDecoratedSDocAt mkErrInfo mkIfLclEnv mkLongErrAt newArrowScopenewName newNameAtnewNoTcEvBinds newSysLocalIdnewSysLocalIds newSysName newTcEvBindsnewTcRefnewUniqueSupply popErrCtxtprintForUserTcRnpushLevelAndCaptureConstraints pushTcLevelM pushTcLevelM_ pushTcLevelsM readTcRefrecordThSpliceUse recordThUserecordUnsafeInferrecoverM reportError reportErrors reportWarningsetConstraintVar setCtLocMsetEnvs setErrCtxt setErrsVar setGblEnvsetImplicitEnvM setLclEnv setLclTypeEnvsetLocalRdrEnv setSrcSpan setSrcSpanAsetStagesetTcEvBindsMap setTcLevelsetXOptMtcCollectingUsagetcEmitBindingUsagetcIsHsBootOrSigtcIsHsigtcScalingUsagetcSelfBootInfo traceHiDiffstraceIf traceOptIf traceOptTcRntraceRntraceTctraceTcConstraintstryCaptureConstraintstryTctryTcDiscardingErrs unlessXOptM unsetGOptM unsetWOptM unsetXOptM updGblEnv updLclEnvupdTcRef updTopEnv updateEps updateEps_warnIf warnIfFlagwarnTcwarnTcM whenDOptM whenGOptM whenNoErrs whenWOptM whenXOptMwithDynamicNow withExceptionwithoutDynamicNowwoptM wrapLocAM wrapLocFstM wrapLocFstMAwrapLocM wrapLocMA wrapLocMA_ wrapLocM_ wrapLocSndM wrapLocSndMA writeTcRefxoptMIsExtraConstraintNoExtraConstraintYesExtraConstraint$fMonadUniqueIOEnv$fOutputableIsExtraConstraintcandidateKindVarscandidateQTyVarsOfKindcandidateQTyVarsOfKindscandidateQTyVarsOfTypecandidateQTyVarsOfTypescheckCoercionHolecheckForLevPolycheckForLevPolyXcheckingExpTypecheckingExpType_maybecloneMetaTyVarcloneTyVarTyVarcloneWC cloneWanted defaultTyVar delCandidatesdoNotQuantifyTyVarsemitDerivedEqsemitNewExprHole emitWanted emitWantedEqemitWantedEvVaremitWantedEvVarsensureNotLevPoly expTypeToTypefillCoercionHolefillInferResultformatLevPolyErrinferResultToTypeisFilledCoercionHoleisFilledMetaTyVarisFilledMetaTyVar_maybeisQuantifiableTvisUnfilledMetaTyVarnewAnonMetaTyVarnewCoercionHolenewCycleBreakerTyVarnewDictnewEvVar newEvVars newFlexiTyVarnewFlexiTyVarTynewFlexiTyVarTysnewImplicationnewInferExpTypenewMetaDetailsnewMetaKindVarnewMetaKindVarsnewMetaTyVarNamenewMetaTyVarTyAtLevelnewMetaTyVarTyVarX newMetaTyVarX newMetaTyVarsnewMetaTyVarsXnewMultiplicityVarnewNamedFlexiTyVarnewOpenBoxedTypeKindnewOpenFlexiTyVarnewOpenFlexiTyVarTynewOpenTypeKindnewPatSigTyVarnewSkolemTyVarnewTauTvDetailsAtLevel newTyVarTyVar newWanted newWanteds newWildCardXpartitionCandidatespromoteMetaTyVarTo promoteTcTypepromoteTyVarSetquantifyTyVars readExpTypereadExpType_maybe readMetaTyVarreadScaledExpTypescaledExpTypeToTypeskolemiseQuantifiedTyVarskolemiseUnboundMetaTyVartcInfertidyCt tidyEvVartidyHoletidySkolemInfounpackCoercionHoleunpackCoercionHole_maybewriteMetaTyVarwriteMetaTyVarRefzonkAndSkolemisezonkCo zonkCoVarzonkCtzonkDTyCoVarSetAndFV zonkEvVarzonkIdzonkImplicationzonkInvisTVBinder zonkSimpleszonkSkolemInfo zonkTcTyVarzonkTcTyVarToTyVar zonkTcTyVars zonkTcTypezonkTcTypeAndFV zonkTcTypeszonkTidyOriginzonkTidyTcTypezonkTidyTcTypeszonkTyCoVarKindzonkTyCoVarKindBinderzonkTyCoVarsAndFVzonkTyCoVarsAndFVListzonkWCCandidatesQTvsDVdv_cvsdv_kvsdv_tvs$fMonoidCandidatesQTvs$fSemigroupCandidatesQTvs$fOutputableCandidatesQTvs exactNameErrmkUnboundNameRdr notInScopeErrreportUnboundName unboundName unboundNameXunknownNameSuggestions WhereLookingWL_Any WL_Global WL_LocalOnly WL_LocalToploadSysInterfaceallocateGlobalBinderextendIfaceEnvsextendIfaceIdEnvextendIfaceTyVarEnvexternaliseNameifaceExportNameslookupIfaceToplookupIfaceTyVarlookupIfaceVar lookupOrig lookupOrigIOmkNameCacheUpdaternewGlobalBinder newIfaceName newIfaceNamesnewInteractiveBinder setNameModule tcIfaceLclId tcIfaceTyVar updNameCacheupdNameCacheTcNameCacheUpdaterNCUupdateNameCacheemptyNameShapeextendNameShapemaybeSubstNameShape mkNameShapenameShapeExportssubstNameShape buildClass buildDataCon buildPatSyn mkNewTyConRhsnewImplicitBindernewTyConRepNameMethInfo TcMethInfo rnModExports rnModIfacetcRnModExports tcRnModIfacegetDictFastStringgetSymbolTable getSymtabNamegetWithUserData putFastStringputNameputSymbolTableputWithUserData readBinIface readBinIface_ writeBinIface BinDictionary bin_dict_map bin_dict_nextBinSymbolTablebin_symtab_mapbin_symtab_next CheckHiWay IgnoreHiWay TraceBinIFace QuietBinIFace$fEqCheckHiWayhieMagic readHieFilereadHieFileWithVersion writeHieFile HieFileResulthie_file_resulthie_file_result_ghc_versionhie_file_result_version HieHeaderbadReexportedBootThingcheckBootDeclMmissingBootThingfinishTHlookupThName_maybe runAnnotationrunMetaDrunMetaErunMetaPrunMetaTrunQuasirunRemoteModFinalizers runTopSplice tcSpliceExprtcTopSpliceExprtcTypedBrackettcUntypedBracketannCtxt tcAnnotations tcGRHSsPat tcMatchesFuntcCheckMonoExprtcCheckMonoExprNCtcCheckPolyExprtcCheckPolyExprNCtcExpr tcInferRho tcInferRhoNC tcMonoExpr tcMonoExprNC tcPolyExpr tcSyntaxOp tcSyntaxOpGenhfIsLclpprHoleFitCand CandPlugin FitPluginHoleFit RawHoleFithfCandhfDochfId hfMatcheshfRefLvlhfTypehfWrapHoleFitCandidate GreHFCandIdHFCand NameHFCand candPlugin fitPluginHoleFitPluginR hfPluginInit hfPluginRun hfPluginStop TypedHoleth_hole th_implicsth_relevant_cts $fEqHoleFit$fEqHoleFitCandidate$fHasOccNameHoleFitCandidate$fNamedThingHoleFitCandidate $fOrdHoleFit$fOrdHoleFitCandidate$fOutputableHoleFit$fOutputableHoleFitCandidate$fOutputableTypedHoleaddHoleFitDocsfindValidHoleFitsgetHoleFitDispConfiggetHoleFitSortingAlggetLocalBindings pprHoleFit relevantCtssortHoleFitsByGraphsortHoleFitsBySizetcCheckHoleFittcFilterHoleFits tcSubsumeswithoutUnificationzonkSubsHoleFitDispConfigHoleFitSortingAlgtcIfaceAnnotationstcIfaceCompleteMatches tcIfaceDecl tcIfaceDeclstcIfaceFamInst tcIfaceInst tcIfaceRulesmkDependencies mkUsageInfo mkUsedNames classDecls collectDocs conArgDocs con_arg_docs declTypeDocs extractDocs extractTHDocs filterClasses filterDeclsgadtConArgDocs getInstLocgetMainDeclBinder h98ConArgDocs isUserSigisValDmkDeclsmkMaps nubByName sigNameNoLoc sigTypeDocs subordinatestopDeclstypeDocsungroup unionArgMapslintStgTopBindingsstg2stg$fApplicativeStgM $fFunctorStgM $fEqStgToDo $fMonadIOStgM $fMonadStgM$fMonadUniqueStgM rnSpliceDecl rnSplicePat rnSpliceTypernTopSpliceDeclsrnExprrnLExprrnStmtsAnnoBodyaddHaddockToModule$fApplicativeHdkA $fFunctorHdkA$fApplicativeHdkM $fFunctorHdkM$fHasHaddockGenLocated$fHasHaddockGenLocated0$fHasHaddockGenLocated1$fHasHaddockGenLocated2$fHasHaddockGenLocated3$fHasHaddockGenLocated4$fHasHaddockGenLocated5$fHasHaddockGenLocated6$fHasHaddockGenLocated7$fHasHaddockGenLocated8$fHasHaddockHsDataDefn$fHasHaddockHsDecl$fHasHaddockHsScaled$fHasHaddockHsWildCardBndrs$fHasHaddock[] $fMonadHdkM$fMonoidColumnBound$fSemigroupColumnBound$fMonoidHasInnerDocs$fSemigroupHasInnerDocs$fMonoidLocRange$fSemigroupLocRange$fMonoidLowerLocBound$fSemigroupLowerLocBound$fMonoidUpperLocBound$fSemigroupUpperLocBoundaddUnpackednessPannBindscheckCmdBlockArguments checkContextcheckEmptyGADTscheckExpBlockArgumentscheckImportDeclcheckImportSpeccheckMonadComp checkPatterncheckPattern_hints checkPrecPcheckRecordSyntaxcheckRuleTyVarBndrNames checkValDefcheckValSigLhs cvBindGroup cvTopDeclsdataConBuilderCondataConBuilderDetails ecpFromCmd ecpFromExp failOpFewArgsfailOpImportQualifiedTwice#failOpNotEnabledImportQualifiedPostfromSpecTyVarBndrfromSpecTyVarBndrs hintBangPatmkBangTy mkClassDecl mkConDeclH98 mkDataFamInstmkExport mkExtName mkFamDecl mkGadtDeclmkImpExpSubSpecmkImportmkInlinePragmamkInstDmkModuleImpExpmkMultTymkPatSynMatchGroup mkRdrGetFieldmkRdrProjectionmkRdrRecordConmkRdrRecordUpdmkRecConstrOrUpdatemkRoleAnnotDecl mkRuleBndrsmkRuleTyVarBndrs mkSpliceDeclmkStandaloneKindSigmkTyClDmkTyData mkTyFamInstmkTyFamInstEqn mkTySynonym mkTypeImpExp parseCImportplaceHolderPunRhsrunPVsetRdrNameSpacestarSymwarnPrepositiveQualifiedModulewarnStarIsType DisambECPFunArgInfixOp ecpFromCmd' ecpFromExp' mkHsAppPV mkHsAppTypePV mkHsAsPatPV mkHsBangPatPV mkHsCasePVmkHsDoPVmkHsExplicitListPVmkHsIfPV mkHsLamCasePV mkHsLamPV mkHsLazyPatPV mkHsLetPV mkHsLitPV mkHsNegAppPV mkHsOpAppPV mkHsOverLitPV mkHsParPVmkHsProjUpdatePV mkHsRecordPVmkHsSectionR_PV mkHsSplicePV mkHsTySigPV mkHsVarPV mkHsViewPatPVmkHsWildCardPVmkSumOrTuplePVrejectPragmaPV superFunArg superInfixOp DisambInfixOp mkHsConOpPVmkHsInfixHolePV mkHsVarOpPVDisambTDmkHsAppKindTyPVmkHsAppTyHeadPV mkHsAppTyPV mkHsOpTyPVmkUnpackednessPVECPunECPFbind ImpExpQcSpec ImpExpQcName ImpExpQcTypeImpExpQcWildcard ImpExpSubSpec ImpExpAbs ImpExpAll ImpExpAllWith ImpExpList LRuleTyTmVarPV RuleTyTmVarUnpackednessPragma$fApplicativePV $fFunctorPV$fDisambECPHsCmd$fDisambECPHsExpr$fDisambInfixOpHsExpr$fDisambECPPatBuilder$fDisambInfixOpRdrName$fDisambTDDataConBuilder$fDisambTDHsType $fMonadPPV $fMonadPVconvertToHsDeclsconvertToHsExprconvertToHsType convertToPatthRdrNameGuesses$fApplicativeCvtM $fFunctorCvtM $fCvtFlag()()$fCvtFlagSpecificitySpecificity $fMonadCvtMaddTicksToBinds hpcInitCode$fApplicativeTM $fFunctorTM$fEqTickDensity$fEqTickishType$fHasDynFlagsTM $fMonadTM ppSourceStats showAstDataBlankEpAnnotationsNoBlankEpAnnotations BlankSrcSpanBlankSrcSpanFileNoBlankSrcSpan$fEqBlankEpAnnotations$fEqBlankSrcSpan$fShowBlankEpAnnotations$fShowBlankSrcSpandefaultFrontendPlugin defaultPlugin flagRecompile impurePluginkeepRenamedSource lpModuleName mapPluginspluginRecompile'plugins purePlugin withPlugins withPlugins_CommandLineOption CorePluginfrontendFrontendPluginActionlpModulelpPlugin driverPlugin holeFitPlugininstallCoreToDosinterfaceLoadActionparsedResultActionpluginRecompilerenamedResultActionspliceRunActiontcPlugintypeCheckResultActionPluginRecompileForceRecompileMaybeRecompileNoForceRecompilePluginWithArgs paArgumentspaPluginspPlugin$fMonoidPluginRecompile$fSemigroupPluginRecompile$fOutputablePluginRecompileevalP getPipeEnvgetPipeSession getPipeStatepipeStateDynFlagspipeStateModIface setDynFlags setForeignOssetIfacesetModLocation setPlugins CompPipeline PhasePlusHscOut RealPhasePipeEnv output_spec src_basename src_filename src_suffix stop_phase PipeState foreign_oshsc_enviface maybe_locPipelineOutput Persistent SpecificFile Temporary$fApplicativeCompPipeline$fFunctorCompPipeline$fHasDynFlagsCompPipeline$fHasLoggerCompPipeline$fMonadCompPipeline$fMonadIOCompPipeline$fOutputablePhasePlus$fShowPipelineOutputDsForeignsHookcmmToRawCmmHookcreateIservProcessHookdsForeignsHookgetValueSafelyHookghcPrimIfaceHookhscCompileCoreExprHookhscFrontendHooklinkHook runMetaHook runPhaseHookrunRnSpliceHook stgToCmmHooktcForeignExportsHooktcForeignImportsHookcannotFindModulecheckWiredInTyConfindAndReadIfaceifCheckWiredInThing ifaceStats importDeclinitExternalPackageState loadInterfaceloadInterfaceForModuleloadInterfaceForNameloadInterfaceForNameMaybeloadModuleInterfaceloadModuleInterfacesloadPluginInterfaceloadSrcInterfaceloadSrcInterface_maybeloadUserInterfaceloadWiredInHomeIfacemoduleFreeHolesPreciseneedWiredInHomeIface pprModIfacepprModIfaceSimple readIface showIfacetcLookupImported_maybe writeIface$fOutputableWarningsaddTypecheckedBindscheckWellStagedgetInLocalScopegetTypeSigNamesiDFunIdioLookupDataCon isBrackStageisTypeClosedLetBndr lookupGlobalmkStableIdFromNamemkStableIdFromString mkWrapperName newDFunNamenewFamInstAxiomNamenewFamInstTyConName pprBinderspprInstInfoDetailssetGlobalTypeEnvsimpleInstInfoClsTysimpleInstInfoTysimpleInstInfoTyContcAddDataFamConPlaceholderstcAddPatSynPlaceholders tcCheckUsagetcExtendBinderStacktcExtendGlobalEnvtcExtendGlobalEnvImplicittcExtendGlobalValEnv tcExtendIdEnvtcExtendIdEnv1tcExtendIdEnv2tcExtendKindEnvtcExtendKindEnvListtcExtendLetEnvtcExtendLocalTypeEnvtcExtendNameTyVarEnvtcExtendRecEnvtcExtendRecIds tcExtendRulestcExtendSigIdstcExtendTyConEnvtcExtendTyVarEnvtcGetDefaultTys tcGetInstEnvstcInitOpenTidyEnvtcLookup tcLookupAxiom tcLookupClasstcLookupConLiketcLookupDataContcLookupGlobaltcLookupGlobalOnly tcLookupIdtcLookupIdMaybetcLookupInstancetcLookupLcl_maybetcLookupLocalIdstcLookupLocatedtcLookupLocatedClasstcLookupLocatedGlobaltcLookupLocatedGlobalIdtcLookupLocatedTyContcLookupPatSyntcLookupTcTyCon tcLookupTyCon tcLookupTyVartcMetaTytopIdLvl wrongThingErr InstBindingsib_binds ib_derived ib_extensions ib_pragmas ib_tyvarsInstInfoiBindsiSpec$fMonadThingsIOEnv$fOutputableInstInfo emptyZonkEnv hsLPatType hsLitType hsOverLitName hsPatType initZonkEnvlookupTyVarOccmkEmptyZonkEnv shortCutLit tcShortCutLit zonkCoToCo zonkEvBindszonkScaledTcTypesToTypesX zonkTcEvBindszonkTcMethInfoToMethInfoXzonkTcTypeToTypezonkTcTypeToTypeXzonkTcTypesToTypesX zonkTopBndrs zonkTopDecls zonkTopExpr zonkTopLExpr zonkTyBndrs zonkTyBndrsXzonkTyVarBinderXzonkTyVarBindersX zonkTyVarOccZonkEnv ZonkFlexi DefaultFlexiNoFlexiRuntimeUnkFlexiSkolemiseFlexi$fOutputableZonkEnvfreshenCoVarBndrsXfreshenTyVarBndrsgetOverlapFlaginstCallinstCallConstraints instDFunTypeinstStupidThetainstTyVarsWithinstantiateSigma mkOverLit newClsInstnewMethodFromNamenewOverloadedLittcExtendLocalInstEnv tcGetInststcInstInvisibleTyBindertcInstInvisibleTyBinderstcInstInvisibleTyBindersNtcInstSkolTyVarstcInstSkolTyVarsAttcInstSkolTyVarsXtcInstSuperSkolTyVarsX tcInstTypetcInstTypeBndrstcSkolDFunTypetcSuperSkolTyVars tcSyntaxNametopInstantiate topSkolemisebuildImplicationForbuildTvImplicationcanSolveByUnificationcheckConstraintscheckTvConstraints checkTyFamEq checkTyVarEq checkTypeEqemitResidualTvConstraintmatchActualFunTySigmamatchActualFunTysRhomatchExpectedAppTymatchExpectedFunKindmatchExpectedFunTysmatchExpectedListTymatchExpectedTyConAppswapOverTyVars tcSkolemise tcSkolemiseETtcSkolemiseScoped tcSubType tcSubTypePattcSubTypeSigma tcWrapResulttcWrapResultMono tcWrapResultOuTypeunifyExpectedTypemkTypeableBindstyConIsTypeable$fApplicativeKindRepM$fFunctorKindRepM$fMonadKindRepMcPprTerm cPprTermBaseconstrClosToName cvObtainTermcvReconstructTypefoldTermimproveRTTITypeisFullyEvaluatedTerm mapTermType termTyCoVarstermTypeTerm NewtypeWrapPrimRefWrap Suspensionbound_toctypedcsubTermstyvalvalRaw wrapped_termTermFold fNewtypeWrapfPrimfRefWrap fSuspensionfTerm$fOutputableTermaddFvRnaddNameClashErrRnaddNoNestedForallsContextsErrbadQualBndrErrbindLocalNamesbindLocalNamesFV checkCTupSizecheckDupAndShadowedNames checkDupNamescheckDupRdrNamescheckDupRdrNamesNcheckInferredVarscheckShadowedRdrNames checkTupSizecheckUnusedRecordWildcard dupNamesErrinHsDocContextmapFvRn mapMaybeFvRn mkFieldEnvnewLocalBndrRnnewLocalBndrsRnnoNestedForallsContextsErrpprHsDocContext typeAppErrunknownSubordinateErrwarnUnusedLocalBindswarnUnusedMatcheswarnUnusedTopBindswarnUnusedTypePatternswithHsDocContext HsDocContext ClassDeclCtxClassInstanceCtx ConDeclCtxDefaultDeclCtx DerivDeclCtxExprWithTySigCtx FamPatCtxForeignDeclCtxGHCiCtx GenericCtx HsTypeCtx HsTypePatCtxPatCtxRuleCtxSpecInstSigCtx SpliceTypeCtxStandaloneKindSigCtx TyDataCtx TyFamilyCtxTySynCtxTypBrCtx TypeSigCtxthNameToGhcName$fMonadThingsCoreMsptCreateStaticBindssptModuleInitCodemkBootModDetailsTc tidyProgram$fApplicativeDFFV $fFunctorDFFV $fMonadDFFV corePrepExpr corePrepPgmmkConvertNumLiteral$fOutputableFloatingBind$fOutputableFloats$fOutputableOkToSpeccheckFamInstConsistency reportConflictingInjectivityErrsreportInjectivityErrorstcExtendLocalFamInstEnvtcGetFamInstEnvstcInstNewTyCon_maybetcLookupDataFamInsttcLookupDataFamInst_maybetcTopNormaliseNewTypeTF_maybereportAllUnsolvedreportUnsolvedsolverDepthErrorTcSwarnAllUnsolvedwarnDefaulting$fMonoidReport$fSemigroupReport$fOutputableHoleChoice$fOutputableReport$fOutputableReportErrCtxt$fOutputableTypeErrorChoiceaddLocalFixitieslookupFieldFixityRnlookupFixityRnlookupFixityRn_helplookupTyFixityRn MiniFixityEnvaddUsedDataCons addUsedGRE addUsedGREscombineChildLookupResult dataTcOccslookupConstructorFieldslookupExprOccRnlookupFamInstNamelookupGlobalOccRnlookupGlobalOccRn_maybelookupGreAvailRnlookupIfThenElselookupInfoOccRnlookupInstDeclBndrlookupLocalOccRnlookupLocalOccRn_maybelookupLocalOccThLvl_maybelookupLocalTcNameslookupLocatedOccRnlookupLocatedTopBndrRnlookupLocatedTopBndrRnNlookupNameWithQualifier lookupOccRnlookupOccRn_maybelookupQualifiedDolookupQualifiedDoExprlookupQualifiedDoNamelookupRecFieldOcclookupRecFieldOcc_updatelookupSigCtxtOccRnlookupSigCtxtOccRnNlookupSigOccRnlookupSigOccRnNlookupSubBndrOcc_helper lookupSyntaxlookupSyntaxExprlookupSyntaxNamelookupSyntaxNameslookupTopBndrRnlookupTypeOccRnnewTopSrcBinderAmbiguousResultAmbiguousFieldsUnambiguousGreChildLookupResult FoundChildIncorrectParent NameNotFound HsSigCtxt ClsDeclCtxt HsBootCtxt LocalBindCtxt RoleAnnotCtxt TopSigCtxt$fEqFieldsOrSelectors$fMonoidDisambigInfo$fSemigroupDisambigInfo$fOutputableChildLookupResult$fOutputableDisambigInfo$fOutputableHsSigCtxtinstanceReturnsDictConisNotAssociatedmatchGlobalInst safeOverlap AssocInstInfo InClsInst NotAssociatedai_class ai_inst_env ai_tyvars ClsInstResult NoInstanceNotSureOneInst cir_mk_ev cir_new_thetacir_what InstanceWhatBuiltinEqInstanceBuiltinInstance LocalInstanceTopLevInstance iw_dfun_id iw_safe_over$fOutputableClsInstResult$fOutputableInstanceWhataddDictaddDictsByClass addErrTcS addInertCanaddInertForAlladdInertSafehask addSolvedDictappendWorkListbreakTyEqCycle_maybebumpStepCountTcScheckReductionDepthcheckWellStagedDFun csTraceTcSdelDictemitImplicationTcSemitNewDerivedEqemitNewDerivedsemitNewWantedEqemitTvImplicationTcSemitWork emitWorkNC emptyDictMap emptyInert emptyWorkListextendFamAppCacheextendWorkListCtextendWorkListCtsextendWorkListEqextendWorkListNonEqfailTcS filterDictsfindDictfindDictsByClassfindEq findFunEqfindFunEqsByTyCon findTyEqs foldDicts foldIrreds foldTyEqs freshGoalsgetDefaultInfo getEvExprgetFamInstEnvsgetGlobalRdrEnvTcSgetHasGivenEqs getInertCans getInertEqsgetInertGivensgetInertInsolsgetInnermostGivenEqLevel getInstEnvsgetPendingGivenScsgetSafeOverlapFailuresgetSolvedDictsgetTcEvBindsVar getTcSInertsgetUnsolvedInerts getWorkList insertFunEqinsertSafeOverlapFailureTcS instFlexi instFlexiXisEmptyWorkListisFresh isImprovablekickOutAfterUnificationlookupFamAppCachelookupFamAppInertlookupInertDictlookupSolvedDictmatchFam matchFamTcMmatchableGivensmightEqualLater nestImplicTcSnestTcSnewBoundEvVarId newDerivedNC newFlexiTcSTy newGivenEvVarnewGivenEvVars newWantedEqnewWantedEq_SInewWantedEvVarnewWantedEvVarNC newWantedNC newWanted_SIpanicTcSpprEq pprKickedprohibitedSuperClassSolvepushLevelNoWorkListremoveInertCtsreportUnificationsresetUnificationFlag rewriterViewrunTcPluginTcSrunTcSrunTcSDerivedsrunTcSEqualities runTcSInertsrunTcSWithEvBindsselectNextWorkItem setEvBindsetEvBindIfWanted setEvBindsTcS setInertCanssetSolvedDicts setTcSInertssetUnificationFlag setWantedEqsetWantedEvTermtouchabilityTest traceFireTcStraceTcS unifyTyVar updInertCans updInertDictsupdInertIrredsupdInertSafehask updInertTcSupdWorkListTcSwarnTcS workListSize wrapErrTcSwrapTcS wrapWarnTcSDictMap EqualCtList InertCansIC inert_blocked inert_dicts inert_eqs inert_funeqsinert_given_eq_lvlinert_given_eqs inert_insts inert_irredsinert_safehaskInertSetIS inert_cansinert_cycle_breakersinert_famapp_cacheinert_solved_dictsMaybeNewCachedFreshTcSTouchabilityTestResultTouchableOuterLevelTouchableSameLevel UntouchableWorkListWLwl_eqs wl_implicswl_rest$fApplicativeTcS $fFunctorTcS$fHasDynFlagsTcS$fHasModuleTcS$fMonadFailTcS $fMonadTcS$fMonadThingsTcS$fMonadUniqueTcS$fOutputableEqualCtList$fOutputableInertCans$fOutputableInertSet"$fOutputableTouchabilityTestResult$fOutputableWorkListrewriterewriteArgsNom rewriteKind rewriteType$fApplicativeRewriteM$fFunctorRewriteM$fHasDynFlagsRewriteM$fMonadRewriteMandWhenContinue canonicalize continueWithmakeSuperClassessolveCallStackstopWith unifyDerivedStopOrContinue ContinueWith$fFunctorStopOrContinue$fOutputableStopOrContinueisTouchableTcPluginM newDerivednewGiven tcPluginIO tcPluginTracecoreExprAsPmLitelemPmAltConSetemptyPmAltConSet eqPmAltConextendPmAltConSetgetRcm initNablasisEmptyPmAltConSetisPmAltConMatchStrictisRcmInitialisedliteralToPmLit negatePmLit overloadPmLitpmAltConImplBangspmAltConSetElems pmAltConTypepmLitAsStringLit pmLitTypeBotInfoIsBotIsNotBotMaybeBotNablaMkNabla nabla_tm_st nabla_ty_stNablasMkNablasPmAltCon PmAltConLikePmAltLit PmAltConAppPACApaca_conpaca_idspaca_tvs PmAltConSet PmEqualityDisjointEqualPossiblyOverlapPmLit pm_lit_ty pm_lit_val PmLitValue PmLitCharPmLitInt PmLitOverInt PmLitOverRatPmLitOverStringPmLitRat PmLitStringResidualCompleteMatchesRCM rcm_pragmas rcm_vanillaTmStateTmStts_dirtyts_factsts_repsTyStateTySt ty_st_inertty_st_nVarInfoVIvi_botvi_idvi_negvi_posvi_rcm $fEqBotInfo $fEqPmAltCon$fEqPmEquality $fEqPmLit$fMonoidNablas$fSemigroupNablas$fOutputableBotInfo$fOutputableNabla$fOutputableNablas$fOutputablePmAltCon$fOutputablePmAltConApp$fOutputablePmAltConSet$fOutputablePmEquality$fOutputablePmLit$fOutputablePmLitValue#$fOutputableResidualCompleteMatches$fOutputableTmState$fOutputableTyState$fOutputableVarInfo$fShowPmEquality CheckResult cr_approxcr_retcr_uncovGrdVec PmEmptyCasepe_varPmGRHSpg_grdspg_rhsPmGRHSs pgs_grhsspgs_lclsPmGrdPmBangPmConPmLet _pm_let_expr_pm_loc pm_con_args pm_con_con pm_con_dicts pm_con_tvspm_idPmMatchpm_grhsspm_pats PmMatchGroup PmPatBindPostPre Precision ApproximatePreciseRedSetsrs_bangsrs_covrs_divSrcInfo $fEqPrecision$fFunctorCheckResult$fMonoidPrecision$fSemigroupPrecision$fOutputableCheckResult$fOutputableGrdVec$fOutputablePmEmptyCase$fOutputablePmGRHS$fOutputablePmGRHSs$fOutputablePmGrd$fOutputablePmMatch$fOutputablePmMatchGroup$fOutputablePmPatBind$fOutputablePrecision$fOutputableRedSets$fOutputableSrcInfo$fShowPrecisionsolveSimpleGivenssolveSimpleWanteds$fOutputableInteractResult approximateWCcaptureTopConstraintsfindInferredDiffgrowThetaTyVarspushLevelAndSolveEqualitiespushLevelAndSolveEqualitiesXreportUnsolvedEqualitiessimplifyAmbiguityChecksimplifyAndEmitFlatConstraintssimplifyDefault simplifyInfersimplifyInteractive simplifyTopsimplifyTopImplicsimplifyTopWantedssimplifyWantedsTcMsolveEqualities solveWantedssolveWantedsAndDrop tcCheckGivenstcCheckWanteds tcNormalise InferModeApplyMREagerDefaultingNoRestrictions$fOutputableInferModeallDistinctTyVarsarityErrbadATErrcheckTyConTelescope checkTySynRhscheckValidAssocTyFamDefltcheckValidCoAxBranchcheckValidCoAxiomcheckValidInstHeadcheckValidInstancecheckValidMonoTypecheckValidThetacheckValidTyFamEqncheckValidTypevalidDerivPredRank$fEqTypeOrKindCtxt$fOutputableExpandMode$fOutputableRank$fOutputableTypeOrKindCtxt$fOutputableValidityEnv boxConTbl error_Expr genAuxBindsgen_Bounded_bindsgen_Data_bindsgen_Enum_binds gen_Eq_binds gen_Ix_bindsgen_Lift_bindsgen_Newtype_binds gen_Ord_bindsgen_Read_bindsgen_Show_bindsgetPossibleDataCons litConTblmkCoerceClassMethEqn mkRdrFunBindmkRdrFunBindECmkRdrFunBindSEordOpTbltyConInstArgTys BagDerivStuff DerivStuff DerivAuxBind DerivFamInstdeepSubtypesContainingfoldDataConArgsfunctorLikeTraversegen_Foldable_bindsgen_Functor_bindsgen_Traversable_binds FFoldTypeFT ft_bad_app ft_co_var ft_forallft_funft_trivft_tup ft_ty_appft_var canDoGenericscanDoGenerics1gen_Generic_bindsget_gen1_constrained_tys GenericKindGen0Gen1canDeriveAnyClasscheckOriginativeSideConditionsderivSpecMechanismToStrategyextendLocalInstEnvhasStockDerivingisDerivSpecAnyClassisDerivSpecNewtypeisDerivSpecStockisDerivSpecViaisStandaloneDerivisStandaloneWildcardDeriv mkDerivOrigin mkPredOrigin mkThetaOriginmkThetaOriginFromPredsnewDerivClsInstnon_coercible_class pprDerivSpecstd_class_via_coerciblesubstPredOrigin DerivContext InferContext SupplyContextDerivEnvdenv_cls denv_ctxt denv_inst_tysdenv_overlap_mode denv_stratdenv_tvs DerivInstTys dit_cls_tys dit_rep_tcdit_rep_tc_argsdit_tc dit_tc_argsDerivM DerivSpecDSds_clsds_loc ds_mechanismds_name ds_overlapds_standalone_wildcardds_thetads_tvsds_tysDerivSpecMechanismDerivSpecAnyClassDerivSpecNewtypeDerivSpecStock DerivSpecViadsm_newtype_ditdsm_newtype_rep_ty dsm_stock_ditdsm_stock_gen_fndsm_via_cls_tysdsm_via_inst_ty dsm_via_tyOriginativeDerivStatusCanDeriveAnyClassCanDeriveStockNonDerivableClassStockClassError PredOrigin ThetaOriginto_anyclass_givensto_anyclass_metasto_anyclass_skolsto_wanted_origins$fOutputableDerivContext$fOutputableDerivEnv$fOutputableDerivInstTys$fOutputableDerivSpec$fOutputableDerivSpecMechanism$fOutputablePredOrigin$fOutputableThetaOrigin isFlexiTyVarHFDC showMatchesshowProvshowTypeshowWrap showWrapVars HFSBySizeHFSBySubsumption HFSNoSorting$fEqHoleFitSortingAlg$fOrdHoleFitSortingAlginferConstraintssimplifyInstanceContextscalculateAvails checkConNamedodgyMsgdodgyMsgInsertextendGlobalRdrEnvRn findChildrenfindImportUsagegetLocalNonValBindersgetMinimalImports mkChildEnvnewRecordSelectorprintMinimalImportsreportUnusedNames rnImportsImportDeclUsage rnExportsbindHsForAllTelescopebindHsOuterTyVarBndrs bindHsQTyVarsbindLHsTyVarBndrbindLHsTyVarBndrsbindSigTyVarsFVcheckPrecMatchcheckSectionPrecextractConDeclGADTDetailsTyVarsextractDataDefnKindVarsextractHsOuterTvBndrsextractHsTyArgRdrKiTyVarsextractHsTyRdrTyVarsextractHsTyRdrTyVarsKindVarsextractHsTysRdrTyVarsextractRdrKindSigVars lookupField mkConOpPatRn mkNegAppRn mkOpAppRn mkOpFormRnnewTyVarNameRnnubLnubNrnConDeclFields rnContextrnHsKindrnHsPatSigTypernHsPatSigTypeBindingVars rnHsSigType rnHsSigWcTypernHsType rnHsWcTypernImplicitTvOccs rnLHsKind rnLHsType rnLHsTypeArgs rnLHsTypesrnLTyVarrnScaledLHsType FreeKiTyVarsHsPatSigTypeScoping AlwaysBind NeverBindNegationHandlingKeepNegationIntactReassociateNegationWarnUnusedForallsNoWarnUnusedForalls$fOutputableOpName$fOutputableRnTyKiEnv$fOutputableRnTyKiWhat$fOutputableWarnUnusedForallsapplyNameMakerisTopRecNameMakerliftCpsliftCpsWithContlocalRecNameMaker patSigErr rnBindPat rnHsRecFieldsrnHsRecUpdFieldsrnLit rnOverLitrnPat rnPatAndThenrnPatstopRecNameMakerCpsRnHsRecFieldContext HsRecFieldCon HsRecFieldPat HsRecFieldUpd NameMaker$fApplicativeCpsRn$fFunctorCpsRn $fMonadCpsRnmakeMiniFixityEnv renameSigsrnGRHSrnGRHSsrnLocalBindsAndThenrnLocalValBindsLHSrnLocalValBindsRHS rnMatchGroup rnMethodBindsrnSrcFixityDeclrnTopBindsBoot rnTopBindsLHS rnValBindsRHS addTcgDUs findSplice rnSrcDeclscheckThLocalName rnBracket rnSpliceExpr traceSplice SpliceInfospliceDescriptionspliceGenerated spliceIsDecl spliceSource$fOutputableMonadNames$fOutputableStmtTreedeleteFromLoadedEnvextendLoadedEnvextendLoadedPkgsinitLoaderStateloadCmdLineLibs loadDeclsloadExpr loadModuleloadName loadPackagesshowLoaderStateunloadwithExtendedLoadedEnv$fOutputableLibrarySpecforceLoadModuleInterfacesforceLoadNameModuleInterfaceforceLoadTyCongetHValueSafelygetValueSafelylessUnsafeCoerceloadFrontendPluginlookupRdrNameInModuleForPlugins tcHiBootIface tcIfaceExpr tcIfaceGlobaltcIfaceOneShottypecheckIfacetypecheckIfaceForInstantiatetypecheckIfacesForMerging addSigCtxtaddTyConFlavCtxtbindExplicitTKBndrs_Q_SkolbindExplicitTKBndrs_Q_TvbindExplicitTKBndrs_SkolbindExplicitTKBndrs_TvbindImplicitTKBndrs_Q_SkolbindImplicitTKBndrs_Q_TvbindImplicitTKBndrs_SkolbindImplicitTKBndrs_TvbindNamedWildCardBindersbindOuterFamEqnTKBndrsbindOuterFamEqnTKBndrs_Q_TvbindOuterSigTKBndrs_TvbindTyClTyVarscheckClassKindSigcheckDataKindSigetaExpandAlgTyCon funAppCtxt funsSigCtxtkcClassSigType kcDeclHeaderkindGeneralizeAllkindGeneralizeNonekindGeneralizeSome pprSigCtxtscopedSortOutertcCheckLHsTypetcClassSigTypetcDerivStrategytcExplicitTKBndrs tcFamTyPatstcHsClsInstType tcHsContext tcHsDerivtcHsLiftedTypetcHsLiftedTypeNC tcHsOpenTypetcHsOpenTypeNCtcHsPartialSigTypetcHsPatSigType tcHsSigType tcHsSigWcType tcHsTypeApptcInferLHsTypetcInferLHsTypeKindtcInferLHsTypeUnsaturated tcLHsKindSig tcLHsPredTypetcMulttcOuterTKBndrstcStandaloneKindSigtcbVisibilitieszonkAndScopedSort ContextKindAnyKindOpenKindTheKindDataSort DataDeclSortDataFamilySortDataInstanceSortHoleMode HM_FamPatHM_Sig HM_TyAppPatHM_VTAInitialKindStrategyInitialKindCheckInitialKindInfer SAKS_or_CUSKCUSKSAKS$fOutputableHoleMode$fOutputableSAKS_or_CUSK$fOutputableTcTyModeaddInlinePragArityaddInlinePragscompleteSigFromIdcompleteSigPolyId_maybe emptyPragEnv extendPragEnvisCompleteHsSig lookupPragEnv mkPragEnv tcIdSigName tcImpPrags tcInstSig tcSigInfoName tcSpecPrags tcSpecWrappertcTySigs tcUserTypeSig TcPragEnvtcPatSynBuilderBind tcPatSynDecladdDataConStupidTheta badFieldCon newLetBndr polyPatSig tcCheckPat tcCheckPat_O tcInferPattcLetPattcPats LetBndrSpec LetGblBndr LetLclBndr$fOutputableLetBndrSpec tcDefaultsbadBootDeclErrchooseInferredQuantifiers tcHsBootSigs tcLocalBinds tcPolyCheck tcTopBinds tcValBinds$fOutputableGeneralisationPlanaddTyConsToGblEnvcheckClassCyclescheckSynCycles inferRolesmkDefaultMethodTypemkOneRecordSelector mkRecSelBinds tcRecSelBinds RolesInfo$fApplicativeRoleM$fFunctorRoleM$fApplicativeSynCycleM$fFunctorSynCycleM $fMonadRoleM$fMonadSynCycleM checkUnitfindExtraSigImportsfindExtraSigImports'implicitRequirementsimplicitRequirements'implicitRequirementsShallowinstantiateSignaturemergeSignatures tcRnCheckUnittcRnInstantiateSignaturetcRnMergeSignaturespatSynBuilderOcc badMethodErrfindMethodBind instDeclCtxt1 instDeclCtxt2 instDeclCtxt3instantiateMethod mkHsSigFun tcATDefault tcClassDecl2tcClassMinimalDef tcClassSigsHsSigFunaddAmbiguousNameErr addArgWrap addExprCtxt addFunResCtxt appCtxtLoccountLeadingValArgsfieldNotInTypeinsideExpansion isHsValArg isVisibleArg lookupParentsnonBidirectionalErr notSelector obviousSigpprHsExprArgTc rebuildHsApps splitHsApps tcCheckIdtcInferAppHeadtcInferAppHead_maybe tcInferIdtyConOf tyConOfETAppCtxtVACall VAExpansionEValArgValArgQLva_argsva_exprva_funva_ty HsExprArgEPragETypeArgEWrapeva_arg eva_arg_tyeva_ctxt eva_hs_tyeva_tyTcPassTcpInstTcpRnTcpTc$fOutputableAppCtxt$fOutputableEValArg$fOutputableEWrap$fOutputableHsExprArgtcBodytcDoStmt tcDoStmtstcGRHS tcGuardStmt tcMatchLambda tcMatchesCasetcStmtstcStmtsAndThenTcCmdStmtCheckerTcExprStmtChecker TcMatchCtxtMCmc_bodymc_what TcStmtCheckertcProctcApp tcExprPrag tcInferSigmagetFixedTyVarstcRules checkCTargetcheckForeignArgscheckForeignRes checkSafeisForeignExportisForeignImportmustBeIO noCheckSafenonIOoknormaliseFfiType tcCheckFEType tcCheckFIType tcFExport tcFImporttcForeignExportstcForeignExports'tcForeignImportstcForeignImports' tcDeriving DerivInfo di_clausesdi_ctxt di_rep_tc di_scoped_tvs$fOutputableEarlyDerivSpec tcInstDecls1addConsistencyConstraintscheckValidTyCondataDeclChecks kcConDeclstcAddDataFamInstCtxttcAddTyFamInstCtxt tcConDeclstcMkDataFamInstCtxttcTyAndClassDeclstcTyFamInstEqnunravelFamInstPatswrongKindOfFamily DataDeclInfo DDataInstance DDataType tcInstDecls2tcInstDeclsDerivaddFingerprints checkOldIfacerecompileRequiredRecompileRequired MustCompile RecompBecauseUpToDate$fBinaryIfaceDeclExtras$fBinaryIfaceIdExtras$fEqRecompileRequired$fMonoidRecompileRequired$fSemigroupRecompileRequired$fOutputableIfaceDeclExtrascoAxiomToIfaceDecl mkFullIfacemkIfaceExports mkIfaceTcmkPartialIfacetyThingToIfaceDecl pprTyThing pprTyThingHdrpprTyThingInContextpprTyThingInContextLoc pprTyThingLocpprTypeForUserDsGblEnvds_cc_stds_complete_matchesds_fam_inst_envds_gbl_rdr_env ds_if_envds_modds_msgs ds_unqualDsLclEnvdsl_locdsl_meta dsl_nablasDsM DsMetaEnv DsMetaValDsBoundDsSplice$fContainsModuleDsGblEnv askNoErrsDsdiscardWarningsDsdsExtendMetaEnvdsGetCompleteMatchesdsGetFamInstEnvs dsGetMetaEnvdsLookupConLikedsLookupDataCondsLookupGlobaldsLookupGlobalIddsLookupMetaEnv dsLookupTyCon dsNoLevPolydsNoLevPolyExpr dsWhenNoErrsduplicateLocalDserrDs errDsCoreExprfailDs failWithDsfixDs getCCIndexDsM getGhcModeDs getPmNablas getSrcSpanDs idDsWrapperinitDsinitDsTcinitDsWithModGutsinitTcDsForSolvermkPrintUnqualifiedDsnewFailLocalDs newPredVarDs newSysLocalDsnewSysLocalDsNoLPnewSysLocalsDsnewSysLocalsDsNoLP newUniqueIdpprRuntimeTrace putSrcSpanDs putSrcSpanDsArunMatchResult updPmNablaswarnDs warnIfSetDsDsMatchContext DsWarning DsWrapper EquationInfoEqnInfoeqn_origeqn_patseqn_rhs MatchResult MR_Fallible MR_Infallible$fApplicativeMatchResult$fFunctorMatchResult$fOutputableDsMatchContext$fOutputableEquationInfoallPmCheckWarnings exhaustiveexhaustiveWarningFlagisMatchContextPmCheckedmkPmIdneedToRunPmCheck overlapping redundantBangtracePmaddPhiCtNablasaddPhiCtsNablasgenerateInhabitingPatterns isInhabited lookupRefutslookupSolutionPhiCtPhiBotCtPhiConCt PhiCoreCt PhiNotBotCt PhiNotConCtPhiTyCtPhiCts$fOutputablePhiCt"$fOutputableTopNormaliseTypeResult pprUncoveredcheckEmptyCase checkGRHSscheckMatchGroup checkPatBind CheckActionCAunCA$fFunctorCheckActionmatch matchSimplymatchSinglePatVar matchWrapperdsExprdsLExpr dsLExprNoLP dsLocalBinds dsSyntaxExpradjustMatchResultDsalwaysFailMatchResultcantFailMatchResultcombineMatchResultsdecideBangHooddsHandleMonadicFailureextractMatchResultfirstPat isTrueLHsExpr matchCanFailmkBigLHsPatTupId mkBigLHsTupIdmkBigLHsVarPatTupIdmkBigLHsVarTupIdmkBinaryTickBoxmkCastDsmkCoAlgCaseMatchResultmkCoLetMatchResultmkCoPrimCaseMatchResultmkCoSynCaseMatchResult mkCoreAppDs mkCoreAppsDs mkErrorAppDsmkEvalMatchResult mkFailExprmkGuardedMatchResult mkLHsPatTup mkOptTickBoxmkSelectorBindsmkVanillaTuplePatmkViewMatchResultselectMatchVarselectMatchVarsselectSimpleMatchVarLseqVarshareFailureHandler shiftEqnswrapBind wrapBinds MkCaseAlt alt_bndrsalt_pat alt_result alt_wrapper boxResultdsCCallmkFCall resultWrapperunboxArgdsLit dsOverLithsLitKey matchLiterals matchNPatsmatchNPlusKPats tidyLitPattidyNPatwarnAboutEmptyEnumerationswarnAboutIdentitieswarnAboutOverflowedLitwarnAboutOverflowedOverLitdsGRHSs dsGuarded dsHsWrapperdesugarEmptyCase desugarGRHSsdesugarMatchesdesugarPatBindaddCoreScrutTmCsaddHsScrutTmCsaddTyCspmcGRHSs pmcMatches pmcPatBind $fMonoidCIRB$fSemigroupCIRBdecomposeRuleLhs dsEvBindsdsEvTerm dsLHsBinds dsMkUserRuledsSpec dsTcEvBinds dsTcEvBinds_s dsTopLHsBinds dsBracket $fRepTV()()$fRepTVSpecificitySpecificitymatchConFamily matchPatSynmatchEquationsmatchSinglePat dsListComp dsMonadComp dsProcExpr dsValBinds enrichHiegetCompressedAsts mkHieFilemkHieFileWithSource $fDataPScoped$fHasLocFamEqn$fHasLocGenLocated$fHasLocGenLocated0$fHasLocGenLocated1 $fHasLocHsArg$fHasLocHsDataDefn$fHasLocPScoped $fHasLoc[]$fHasTypeGenLocated$fHasTypeGenLocated0$fHasTypeGenLocated1$fHiePassRenamed$fHiePassTypechecked$fModifyStateName$fModifyStateVar$fToHieAnnProvenance$fToHieArithSeqInfo $fToHieBag$fToHieBindContext$fToHieContext$fToHieContext0$fToHieContext1$fToHieContext2$fToHieContext3$fToHieContext4$fToHieEvBindContext $fToHieFamEqn$fToHieFamilyInfo$fToHieForeignExport$fToHieForeignImport $fToHieGRHSs$fToHieGenLocated$fToHieGenLocated0$fToHieGenLocated1$fToHieGenLocated10$fToHieGenLocated11$fToHieGenLocated12$fToHieGenLocated13$fToHieGenLocated14$fToHieGenLocated15$fToHieGenLocated16$fToHieGenLocated17$fToHieGenLocated18$fToHieGenLocated19$fToHieGenLocated2$fToHieGenLocated20$fToHieGenLocated21$fToHieGenLocated22$fToHieGenLocated23$fToHieGenLocated24$fToHieGenLocated25$fToHieGenLocated26$fToHieGenLocated27$fToHieGenLocated28$fToHieGenLocated29$fToHieGenLocated3$fToHieGenLocated30$fToHieGenLocated31$fToHieGenLocated32$fToHieGenLocated33$fToHieGenLocated34$fToHieGenLocated35$fToHieGenLocated36$fToHieGenLocated37$fToHieGenLocated38$fToHieGenLocated39$fToHieGenLocated4$fToHieGenLocated5$fToHieGenLocated6$fToHieGenLocated7$fToHieGenLocated8$fToHieGenLocated9 $fToHieHsArg$fToHieHsBracket$fToHieHsConDeclGADTDetails$fToHieHsConDetails$fToHieHsDataDefn$fToHieHsMatchContext$fToHieHsPatSynDir$fToHieHsScaled$fToHieHsStmtContext$fToHieHsTupArg$fToHieIEContext$fToHieIEContext0$fToHieIEContext1$fToHieIEContext2$fToHieMatchGroup $fToHieMaybe$fToHiePScoped$fToHiePatSynFieldContext$fToHiePendingRnSplice$fToHiePendingTcSplice$fToHieRContext$fToHieRContext0$fToHieRFContext$fToHieRFContext0$fToHieRFContext1$fToHieRFContext2$fToHieRScoped$fToHieRScoped0$fToHieRScoped1$fToHieRScoped2$fToHieRScoped3$fToHieRScoped4$fToHieRScoped5$fToHieRScoped6$fToHieSigContext$fToHieStandaloneKindSig$fToHieTScoped$fToHieTScoped0$fToHieTScoped1$fToHieTScoped2$fToHieTScoped3$fToHieTScoped4$fToHieTScoped5$fToHieTVScoped$fToHieTVScoped0$fToHieTyClGroup $fToHieVoid $fToHie[] dsForeigns core2core simplifyExpr HsComponentId hsComponentId hsPackageName HsModuleId HsModuleVar HsModuleSubstHsUnit hsunitBody hsunitName HsUnitDeclDeclDIncludeDHsUnitId IncludeDecl idModRenamingidSignatureIncludeidUnitId LHsModuleIdLHsModuleSubstLHsUnit LHsUnitDecl LHsUnitId LRenamingRenaming renameFromrenameTo$fOutputableHsComponentId parseBackpackparseDeclarationparseExpression parseHeaderparseIdentifier parseImport parseModuleparseModuleNoHaddock parsePatternparseSignatureparseStatement parseStmt parseTypeparseTypeSignature hasImportisDeclisImportisStmtcheckProcessArgsResult getOptionsgetOptionsFromFile mkPrelImportsoptionsErrorMsgs checkBootDeclcheckHiBootIface'getModuleInterfacegetRenamedStuff isGHCiMonadloadUnqualIfaces rnTopSrcDeclsrunTcInteractive tcRnDeclsitcRnExpr tcRnGetInfotcRnImportDeclstcRnLookupNametcRnLookupRdrName tcRnModuletcRnModuleTcRnMtcRnStmttcRnType tcTopSrcDecls RenamedStuff TcRnExprMode TM_DefaultTM_InstdeSugar deSugarExprbatchMsg doCodeGendumpIfaceStatshscAddSptEntries hscCheckSafehscCompileCmmFilehscCompileCoreExprhscCompileCoreExpr'hscDeclshscDeclsWithLocation hscDesugar hscDesugar'hscGenHardCodehscGetModuleInterface hscGetSafe hscImporthscIncrementalCompilehscInteractivehscIsGHCiMonad hscKcTypehscMaybeWriteIfacehscParse hscParse'hscParseDeclsWithLocation hscParseExprhscParseIdentifierhscParseStmtWithLocation hscParseTypehscParsedDecls hscParsedStmthscRnImportDeclshscSimpleIface' hscSimplify hscSimplify'hscStmthscStmtWithLocation hscTcExprhscTcRcLookupNamehscTcRnGetInfohscTcRnLookupRdrNamehscTypecheckRenameinitModDetails ioMsgMaybemakeSimpleDetails newHscEnv oneShotMsgshowModuleIndex tcRnModule'MessagerdefaultRunMetarunMeta' $fQuasiIOEnv$fReifyFlag()()!$fReifyFlagSpecificitySpecificityabandon abandonAllback compileExprcompileExprRemotecompileParsedExprcompileParsedExprRemotedynCompileExpr execOptionsexecStmt execStmt'forward getContextgetDocsgetHistoryModulegetHistorySpangetInfogetInstancesForTypegetNamesInScopegetRdrNamesInScopegetResumeContextmoduleIsBootOrNotObjectLinkablemoduleIsInterpretedobtainTermFromIdobtainTermFromVal parseExprparseImportDeclparseInstanceHead parseNamereconstructType resumeExecrunDeclsrunDeclsWithLocationrunParsedDeclssetupBreakpoint showModuleGetDocsFailureInteractiveNameNameHasNoModule NoDocsInIface$fOutputableGetDocsFailure compileFile compileOne compileOne'doCpp getLocationgetOutputFilenamehscPostBackendPhaselink linkingNeededphaseOutputFilename preprocessrunPhasewriteInterfaceOnlyModecyclicModuleErrdepanaldepanalEdepanalPartial downsweepemptyModNodeMaphscSourceToIsBootinstantiationNodesload'modNodeMapElemsmodNodeMapInsertmodNodeMapLookupmoduleGraphNodes noModErrorsummariseModule LoadHowMuchLoadAllTargetsLoadDependenciesOfLoadUpTo ModNodeMap unModNodeMap SummaryNode$fEqBuildModule $fEqNodeKey$fFoldableModNodeMap$fFoldableNodeMap$fFunctorModNodeMap$fFunctorNodeMap$fOrdBuildModule $fOrdNodeKey$fTraversableModNodeMap$fTraversableNodeMapaddSourceToTokens addTargetcompileToCoreModulecompileToCoreSimplified dataConTypedefaultCleanupHandlerdefaultErrorHandler desugarModulefindGlobalAnns findModule getBindingsgetGREgetInstsgetInteractiveDynFlags getModSummarygetModuleGraph getModuleInfogetNameToInstancesIndexgetPrintUnqualgetProgramDynFlagsgetRichTokenStream getTargetsgetTokenStream guessTargetinterpretPackageEnv isDictonaryIdisLoadedisModuleTrustedlookupGlobalName lookupModulemkPrintUnqualifiedForModulemodInfoExportsmodInfoExportsWithSelectors modInfoIfacemodInfoInstancesmodInfoIsExportedNamemodInfoLookupNamemodInfoModBreaks modInfoRdrEnv modInfoSafemodInfoTopLevelScopemodInfoTyThingsmoduleTrustReqsparseDynamicFlagsparseTargetFilesparserpprParenSymName removeTargetrunGhcT setGHCiMonadsetInteractiveDynFlagssetProgramDynFlagssetSessionDynFlags setTargetsshowRichTokenStreamtypecheckModulewithCleanupSessionworkingDirectoryChanged CoreModulecm_binds cm_modulecm_safecm_types coreModuleDesugaredModuledm_core_moduledm_typechecked_module GhcApiError ModuleInfo ParsedMod parsedSource ParsedModulepm_extra_src_filespm_mod_summarypm_parsed_source ParsedSource RenamedSourceTypecheckedMod moduleInfo renamedSourcetypecheckedSourceTypecheckedModuletm_checked_module_info tm_internals_tm_parsed_moduletm_renamed_sourcetm_typechecked_sourceTypecheckedSource$fDesugaredModDesugaredModule$fTypecheckedModDesugaredModule$fExceptionGhcApiError$fShowGhcApiError$fOutputableCoreModule$fParsedModDesugaredModule$fParsedModParsedModule$fParsedModTypecheckedModule!$fTypecheckedModTypecheckedModulepprTypeAndContentspprintClosureCommandshowTerm doMkDependHS doBackpack$fEqSessionType$fGhcMonadIOEnv.=renum!:foldBlockNodesF3 GHC.VersioncProjectVersionIntcProjectVersioncProjectPatchLevel2cProjectPatchLevel1cProjectPatchLevelcProjectGitCommitId getPaddedIntgetGNUArchEntries putArchEntryfileInfostderrSupportsAnsiColors'assertControl.ExceptionHandlercatchesallowInterrupt TypeError RecUpdError RecSelError RecConErrorPatternMatchFailNonTermination NoMethodErrorNestedAtomicallytryJust onException mapException handleJusthandlefinally catchJustbracket_bracketOnErrorbracketSomeAsyncExceptionDeadlockCompactionFailedBlockedIndefinitelyOnSTMBlockedIndefinitelyOnMVarAsyncException UserInterrupt ThreadKilled HeapOverflow StackOverflowAssertionFailedArrayExceptionIndexOutOfBoundsUndefinedElementAllocationLimitExceededasyncExceptionToExceptionasyncExceptionFromException MaskingStateUnmaskedMaskedInterruptibleMaskedUninterruptibleuninterruptibleMask_uninterruptibleMaskthrowIOmask_mask interruptiblegetMaskingStateevaluatecatch IOException GHC.Exception ErrorCallErrorCallWithLocationthrowArithExceptionRatioZeroDenominatorLossOfPrecision DivideByZeroDenormal UnderflowOverflow SomeExceptionfilterM short_usage$restrictedDamerauLevenshteinDistance hashInt32 maybeToListmapMaybe listToMaybe isNothingisJust fromMaybefromJust catMaybesGHC.IO.Handle.TypesHandlebytestring-0.11.3.1Data.ByteString.Internal ByteStringData.ByteString.Short.InternalShortByteString mkZFastStringokIdChar reservedOps reservedIdsokIdOccisDashesGHC.Utils.Encodingutf8DecodeCharskipBOMRDoc reduceDocfirst hasAsciiSpacehashInstantiationsputPrimsignalHandlersRefCount uniqueMaskisOneLineRealSpanisPointRealSpann_occn_uniqn_sortn_loc TaggedVal realUnique NotExportedExportedIdScopeBitFieldbitfieldvanillaCafInfocompareFractionalLit exnDmdTypePolyviewCalletaExpandDmdType defaultArgDmd multTrivialplusDivergencemultDivergencedecreaseArityDmdTypemk_derivgenSymmkUniqSMfitsIn kindPrimRep plusWithInf mulWithInfisBoxedRuntimeRep_maybe TypeOrderingTLTTGTTEQTEQXexpandSynTyConApp_maybesplitSomeForAllTyCoVarBndrs expand_syn coreFullViewisTyConKeyApp_maybeisNullaryTyConKeyAppsplitForAllTyVarsfun_kind_arg_flagstcKindRep_maybefvVarAcc pprTraceWithUnitVisibilityModuleNameProvidersMaprenameUnitInfoRevIndex UnitConfigunitConfigPlatformArchOSunitConfigWaysunitConfigAllowVirtualunitConfigProgramNameunitConfigGlobalDBunitConfigGHCDirunitConfigDBNameunitConfigAutoLinkunitConfigDistrustAllunitConfigHideAllunitConfigHideAllPluginsunitConfigDBCacheunitConfigFlagsDBunitConfigFlagsExposedunitConfigFlagsIgnoredunitConfigFlagsTrustedunitConfigFlagsPluginsUnitPrecedenceMap uv_renamingsuv_package_nameuv_requirements uv_explicit VisibilityMapadd_unit improveUnit'fromExposedModulesfromReexportedModulesfromFlag originVisible originEmpty mkUnitInfoMap findPackagesselectPackagessortByPreferencecompareByPreference reverseDeps removeUnitsdepsNotAvailabledepsAbiMismatchmergeDatabasesvalidateDatabasemkModuleNameProvidersMap mkUnusableModuleNameProvidersMap addListTomkModMap mkHomeUnit mkUnitStatelog_hook dump_hook trace_hookgenerated_dumpsdumpSDocWithStylechooseDumpFiledoDumpshowMsgEnvelopeGHC.LanguageExtensions.Type Extension minusWOpts minusWallOptsminusWeverythingOptsminusWcompatOptsstandardWarnings setLanguagesetSafeHaskellcombineSafeFlags safeFlagCheck allFlagsDepsunrecognisedWarningflagSpec flagSpec' depFlagSpecOp depFlagSpecdepFlagSpecOp' depFlagSpec'depFlagSpecCond flagGhciSpec flagGhciSpec'flagHiddenSpecflagHiddenSpec'hideFlagnegatableFlagsDeps dFlagsDeps fHoleFlagslanguageFlagsDepssafeHaskellFlagsDepsvalidHoleFitDefaultsmkFlagshouldMangleSelectorNamesparseIntdropEqExprSize _es_size_is_es_args _es_discountlitSizecallSizejumpSize traceInlineD:R:XBreakpointTickishPassStg TickishPass flavourIndexpprFlavourCoreppCostCentreLblppFlavourLblComponentInt16#Int#Word# plusAddr#MutVar#mkLitWordUncheckedmkLitInt8UncheckedmkLitWord8UncheckedmkLitInt16UncheckedmkLitWord16UncheckedmkLitInt32UncheckedmkLitWord32UncheckedmkLitInt64UncheckedmkLitWord64Unchecked narrowLit'FunTyConAlgTyCon FamilyTyCon SynonymTyCon PrimTyConPromotedDataContcRolesalgTcGadtSyntaxalgTcStupidThetaalgTcRhs algTcParentsynTcRhs famTcFlav famTcParentfamTcInj isUnlifteddataCon promDcRepInfotcTyConFlavourokParenttyConFieldLabelEnvfieldsOfAlgTcRhs kindTyConKeystcFlavourMustBeSaturated mkPrimTyCon'isIfaceTyConAppLiftedTypeKinddefaultNonStandardVars liftedRep_ty ppr_itv_bndrspprSpaceIfPromotedTyCon ppr_equalityppr_iface_tc_appif_print_coercionstcEqTypeNoSyns tc_eq_typetcTyConAppTyFamInstsAndVisXtcTyFamInstsAndVisX withTiming'VMaybeviewConsviewSnocsubstCoVarBndrUsingsubstTyVarBndrUsingsubstForAllCoBndrUncheckedsubstVarBndrUncheckeddataConSrcToImplBang dataConArgRepConCpr_ FlatConCprdcTagdataConKindEqSpec tc_unify_tys ty_co_match tc_match_tystc_match_tys_x don'tBeSoSurecloseOverKindsFVTypeMapX trieMapViewdowngradeRole_maybe ty_co_substmkForAllCo_NoReflmkRuntimeRepComkHomoForAllCos_NoRefl instCoercion instCoercionsextendLiftingContextEx exprIsHNFlike diffIdInfo diffUnfoldlocBindunboxedTupleSumKind cTupleArr unboxedSumArr mkSumTyConOccmkSumDataConOccmk_sumextractPromotedListpcDataConWithFixity pickBothGRE widenRealSpansizeAnn pprTopBindscollectValBinders exprOrphNamesexprFVsruleFVsexprsFVsexprSomeFreeVarsDSetexprsSomeFreeVarsDSetrulesFVsNormM toNameInstEnvfromNameInstEnvsoe_co_opt_opts soe_uf_optssoe_inl soe_subst substIdBndrdecideJoinPointHood AnalysisMode arityTypepedanticBottoms extendSigEnv lookupSigEnv myExprIsCheap FindRhsArityae_joins BotStrictnessEtaExpandArityae_modeam_sigsbotStrictnessArityEnvisDeadEndArityType minWithArity andArityTypeetaExpandArityEnvfindRhsArityEnv myIsCheapAppmkEtaWWEtaInfomkSmallTupleSelector1mkCoreAppTyped mkCoreTup1 mkExceptionId collect_bindshsDataDefnBinderssplitLHsQualTy_KPD:R:NoGhcTcGhcPassData.Typeable.InternalTypeablefindAnnPayloadsinsert_overlappinglibraryDirsForWayScDepth lGRHSCtOriginpprCtO pprPatBndrconPatNeedsParensisIrrefutableHsPat' tyCoFVsOfWC tyCoFVsOfCt tyCoFVsOfCtstyCoFVsOfImplic ModIfaceCore&&& AsmTempLabelAsmTempDerivedLabelIdLabelLocalBlockLabel CmmLabelInfoConEntry ConInfoTableRtsSelectorInfoTableRtsApInfoTable RtsApFastClosure InfoTableEntryLocalInfoTable LocalEntry RednCounts ClosureTableBytesBlockInfoTableRtsLabel ForeignLabelDynamicLinkerLabel PicBaseLabelDeadStripPreventer HpcTicksLabelSRTLabelLargeBitmapLabelCmmInfo CmmRetInfoCmmRetCmmCode CmmClosure CmmPrimCall labelTypeD:R:XRhsClosureCodeGendirectory-1.3.6.2System.DirectorygetTemporaryDirectorytmp_dirs_to_cleantmp_next_suffixtmp_files_to_cleanmergeFilesToClean liftIOEnvsafeTryminClosureSize scopeUniques scopeToPathsminJumpTableOffsetFlatSwitchPlanmaxJumpTableHoleminJumpTableSizeBody'lf_check_static_ptrslf_report_unsat_synslf_check_linearity AllowAnywhereAllowAtTopLevelRejectEverywherelintRhs lintCoreExpr lintJoinLams lintCastExprcheckCaseLinearity lintValApp withoutAnnots mk_cast_errReprFlagSymFlagopt_co1opt_co3 opt_phantomopt_co4opt_co2 opt_co4_wrapwrapRole chooseRoleBinOpAppNumOpsnumAddnumSubnumMul numLitTypeOpValshiftRightLogicalNative boundsCmp int8Result int16Result int32Result intCResult word8Result word16Result word32Result wordResult wordCResultsemiInversePrimOpextendNarrowPassthroughnarrowSubsumesAndsameArgIdempotentCommutisVarAppleftIdentityCPlatformrightIdentityCPlatformidentityCPlatform mkNumLiteralgetTargetPlatformis_ctypeShared powersetL powersetLS dotNodeEdges checkNode colorScan assignColors selectColor ElfHeadergw16gw32gwNwordSize entryNameentryBS SectionTablesectionTableOffsetsectionEntrySizesectionEntryCountsectionNameIndex readElfHeaderreadElfSectionTablereadElfSectionByIndexfindSectionFromName readElfNoteBS runGetOrThrowQextQext1Qext2Qext1ext2CBPGCGpruneDelis_null mkFreeVarSetBVsFVsannTopBindingsDepsdepSortquickSourcePoswithSpan myCollectArgsControl.Monad.Trans.RWS.StrictlocalRWST removeRhsCCCSCoreMapXCoreMapGCseEnv ce_conAppMapce_subst ce_bndrMap ce_in_scopeinitEnvmkStgLet ExtsBitmapGenSemicHdkSt ColumnBoundHdkWarnflattenBindsAndSigstyConToDataCon checkTyVarsensureValidOpExpcvtOpApp cvtOpAppPcvtSigTypeKind cvtTypeKindmk_apps cvtOpAppTcvtMaybeKindToFamilyResultSigcvtFamilyResultSigcvtInjectivityAnnotation mkHsForAllTy mkHsQualTytemplate-haskellCxt st_max_ticksst_co_opt_opts UnariseEnv extendRhounariseSumAltsmkUbxSumubxSumRubbishArg unariseFunArg unariseConArgsplitResultType_maybedubiousDataConInstArgTys mk_absent_letSigEnvae_sigs ae_virgin ae_fam_envsse_topsse_sigscprAnalcprAnal'cprTransformSpecial cprAnalBindcprDataStructureUnfolding_maybeextendSigEnvListextendSigEnvFromIdsextendSigEnvAllSameextendSigEnvForArg argCprType cprAnalAlt cprTransform ruleCantMatchmatchNcloneCaseBndrsExitifyM exitifyReccse_bindCSEnvnoCSE addBindergenLogminuslogExactdivide rootExactgenRoot splitThunk lc_threshold lc_uf_optslc_lvl lc_lvl_env lc_rec_env lc_scruts knownKeysMapknownKeyNamesOkay simplTick makeTrivialmakeTrivialBindingae_strict_dictsisInterestingTopLevelFn dmdAnalBindAnalEnvsetBindIdDemandInfodmdAnalBindLetUpuseLetUpdmdAnalBindLetDown dmdAnalRhsSigexprMayThrowPreciseExceptionforcesRealWorldextendAnalEnvs dmdTransformrewrites rewriteLinerewriteSymType rewriteAVX replaceOnce splitLineSpecArgSpecTypeSpecDict UnspecType UnspecArgDictBind spec_importstryWarnMissingSpecs specHeaderbindAuxiliaryDictmkDBbind_fvsrecWithDumpedDicts sc_uf_optsnoFloatIntoRhs mkHiePath orIfNotFoundhomeSearchCachefindInstalledHomeModulefindPackageModulefindPackageModule_ ForeignRef RemoteRefhandleSeqHValueStatus spawnIServshouldTickBindaddTickLHsExprLetBodybreakpointsEnabledtickSameFileOnlyppLlvmFunctionHeader ppLlvmBlocks ppLlvmBlockppLlvmBlockLabelppLlvmStatementppLlvmExpressionppCallnewLine exclamationrootN interesting expandBlockexpandBlockInstrs remapRegPairfRegHipprAlignForSectionpprSectionAlign pprSizeDeclthunkEntryLabel envVersionenvOpts envDynFlags envLogger envOutputenvMask envFreshMeta envUniqMeta envFunMap envAliases envUsedVars envVarMap envStackRegs llvmGhcCC modifyEnv saveAlias genStaticLit structStrlinkagellvmSectionType llvmSection LlvmAccumEOption exprToVarExprDatabasicBlocksCodeGenbasicBlockCodeGen stmtsToInstrs stmtToInstrs getInstrinct2 getInstrinctbarrier barrierUnlessgenCallgenCallWithOverflowgenCallExtract getFunPtrW getFunPtr arg_varsWarg_vars castVarsWcastVarscastVarcmmPrimOpFunctionsgenJump genAssigngenStore genStore_fast genStore_slow genBranch genCondBranch genExpectLit genSwitchi1Option wordOption genMachOpgenMachOp_fastgenMachOp_slowgenLoad genLoad_fast genLoad_slow getCmmReg getCmmRegValallocReggenLit funPrologue funEpilogue getHsFuncdoExpr expandCmmReg blockIdToLlvmtoI32 getTBAAMetagetTBAARegMetasingletonPaniccmmDataLlvmGens cmmLlvmGencmmMetaLlvmPreludecmmUsedLlvmGensmachOpNeedsCaststaticLitsToWords pprHexValpprRegpprReg_ofRegNo pprStFormatpprCondpprAddrpprRIpprFormatRegRegpprFormatRegRegReg pprRegRIRegNoInfoHeapStackCheck liBackEdgesliLevelsliLoopsTargetNodeInfoupdateEdgeWeight optHsPatterns staticPredCfgstaticBranchPredictioncheckIsReverseDependentcomputeLiveness livenessBlocklivenessForward livenessBack makeRAStatsCleanSCleanM sJumpValid sJumpValidAcc sReloadedBy sCleanedCountsCleanedSpillsAccSlot initCleanS cleanSpincleanBlockForward cleanForward cleanReloadcleanTopBackwardcollateJoinPoints findRegOfSlot accJumpValid isStoreReg emptyAssocaddAssocdelAssoc delAssoc1 elemAssoc closeAssocintersectAssoc cleanBackwardSpillMSpillSstateUS stateSpillSL regSpill_topregSpill_blockregSpill_instr spillRead spillWrite spillModify patchInstr initSpillSmakeSpillStatssinkReg buildAlloc takeVirtualsspillCost_length nodeDegree maxSpinCount regAlloc_spin buildGraphgraphAddConflictSetgraphAddCoalescepatchRegsFromGraph inlineSRT wordAlignedmkLivenessBitspprProcEndLabel BlockContext blockContextsneeds_probe_call pprProcLabelpprBlockEndLabelmakeRegMovementGraph expandNodehandleComponentmakeMovejoinToTargets'OutputableRegConstraintlinearRegAlloc processBlock initBlocklinearRAraInsn clobberRegsfindPrefRealReg newLocationloadTemplinearRegAlloc' integerExtend conversionNopidivirem coerceInt2FP coerceFP2Int coerceDbl2Flt coerceFlt2Dbl picRelativeaddSpUnwindingsjumpTableEntrygetSimpleAmodeaddAlignmentCheckgenCondBranch'evalArgsarg_to_int_vregs move_final assign_codeoutOfLineMachOpoutOfLineMachOp_table BlockChain FrontierMapneighbourOverlapp breakChainAtcombineNeighbourhood sequenceChain dropJumps DwarfAbbrev DwAbbrNull pprAbbrevpprLabelStringpprDwarfInfoOpenpprDwarfInfoClose pprFrameProc pprFrameBlockdwarfGlobalRegNo pprSetUnwind pprLEBRegNo pprUnwindExprpprUndefUnwindpprData4 pprString' escapeChar mkDwarfARangecompileUnitHeadercompileUnitFooterdebugSplitProcs procToDwarf blockToDwarf debugFrame procToFrameswizzleRegisterRep opRegWidth signExtendReg truncateReg NativeGenAcc ngs_natives ngs_unwinds cmmNativeGens checkLayoutcomputeUnwindingmakeImportsDoc sortBlocks mkDepBlocks updateFactCmmLiveBlockEntryLivenessBlockEntryLivenessL noLiveOnEntrynoLiveOnEntryL conflicts lintShiftOpmayNotMentionCallerSavedRegs dont_care copyTicksLitBoundmk_discrete_switchldvWordDecls addVarDecladdLabel addDynTag closeNursery openNurseryemitCallWithExtraStackslowArgsregisterTickyCtrbinderInfoOccursAsArgtagSkeletonExprrhsCard closureSizeidClosureFootprinttagSkeletonBindingtagSkeletonLetliftRhs generic_gc mkGcLabel DataCAFEnvgetLabelledBlocks depAnalSRTsgetCAFs getStaticFuns resolveCAFdoSCConeSRT buildSRTChain updInfoSRTsPrimopCmmEmit_ExternalPrimopCmmEmit_Internal emitPrimOp asUnsignedgenericWordAddCOpgenericWordSubCOpdoPrefetchByteArrayOpdoPrefetchMutableByteArrayOpdoPrefetchAddrOpdoPrefetchValueOpmkBasicPrefetchdoNewByteArrayOpdoCopyByteArrayOpdoCopyMutableByteArrayOpdoCopyByteArrayToAddrOpdoCopyMutableByteArrayToAddrOpdoCopyAddrToByteArrayOpdoSetByteArrayOp doNewArrayOp doCopyArrayOpdoCopyMutableArrayOpemitCloneArrayemitCloneSmallArray emitSetCardsdoAtomicByteArrayRMWdoAtomicReadByteArraydoAtomicReadAddrdoAtomicWriteByteArraydoAtomicWriteAddremitMemcpyCallemitMemmoveCallemitMemsetCallemitCopyUpdRemSetPushalignmentFromTypes emitCopyArrayemitCopySmallArraydoAtomicAddrRMWdoCasByteArray doBoundsCheckdoPtrArrayBoundsCheckdoSmallPtrArrayBoundsCheckdoByteArrayBoundsCheckcgTickwithSourceNoteHappyStksm_spsm_args sm_ret_offsm_regs fixupStackallocate manifestSpfalseStackCheckelimStackStoresBCEnvpushConstrAtomisSupportedCConvmkStackOffsets mkProtoBCO lf_unarisedcheckNoCurrentCCSStgToDoStgCSE StgLiftLams StgUnarise StgDoNothing getStgToDomjmzmu toUnicodeAnnmomc commentsPAlogWarningsReportErrorshandleWarningsThrowErrors ioMsgMaybe'extract_renamed_stuff hsc_typecheckhscIncrementalFrontendhscCheckSafeImportscheckSafeImports hscCheckSafe' checkPkgTrustmarkUnsafeInferhscGetSafeModehscSimpleIfaceextendIdZonkEnvRec candidateVars defaultTyVarszonkTcTypeMapperlabelledTraceOptTcRn wrapDocLoc add_warn_atloadInterfaceWithExceptionis_external_sigcomputeInterfacepprDeps cantFindErrmergeIfaceDeclisAbstractIfaceDeclmergeIfaceDecls tc_iface_declShIfEnvShIfM initRnIface rnIfaceGlobalrnIfaceNeverExportedrnIfaceClsInst ShNameSubst ns_module substNamesubstNameAvailInfosetNameFieldSelector mergeAvails uAvailInfos uAvailInfouName uHoleNameinitBinMemSize mkHEqBoxTy mkEqBoxTyNotClosedReason tcSynArgE tcSynArgAcheckForConflictscheckInjectiveEquation isTFHeadedbareTvInRHSViolatedunusedInjTvsInRHSinjectivityErrorHeraldreportUnusedInjectiveVarsErrreportTfHeadedErrreportBareVariableInRHSErrtyConArgsPolyKinded annotThType mkMetaTyVaremitQuoteWantedbrackTytcPendingSplicegetThSpliceOrigin seqSerialized lookupDeclDoc lookupArgDocgetExternalModIfacelookupThInstNameaddModFinalizerRef runRemoteTH readQResult getTHStatereifyInstances'defaultCallStacksdefaultTyVarTcSRewriteM RewriteEnvRewriteTvResultRTRNotFollowed RTRFollowed mkRewriteMsetEqRelnoBogusCoercionsrewrite_args_fastrewrite_args_slow rewrite_co split_pi_tys'ty_con_binders_ty_binders'lookupCycleBreakerVarpushCycleBreakerVarStackinsertCycleBreakerBindingforAllCycleBreakerBindings_mkTcSuseVarsrestoreTyVarCyclesCycleBreakerVarStackrunTcSWithEvBinds'SafeOverlapping matchTypeabledoFunTy doTyConApponlyNamedBndrsAppliedKindRepM KindRepEnv TypeRepTodo TypeableTyCon mod_rep_exprpkg_fingerprintmod_fingerprint todo_tyconsExportedKindRepsTodoplatformtrTyConDataCon trNameLitkindIsTypeablemkTypeRepTodoBindsmkPrimTypeableTodosghcPrimTypeableTyCons collect_stuff mkTrNameLitmkTyConRepBindsbuiltInKindRepsmkExportedKindReps runKindRepM getKindRep mkKindRepRhsmkTyConRepTyConRHSFieldsOrSelectorsFoundExactOrOrigExactOrOrigErrorNotExactOrOrig WantNormalWantBoth WantFieldlookupExactOcc_eitherlookupGlobalOccRn_overloadedlookupOneQualifiedNameGHCilookupQualifiedNameGHCiwarnRedundantRecordWildcardwarnUnusedRecordWildcard reportablefieldSelectorSuggestionsimportSuggestionsReportreport_unsolved importantmk_relevant_bindingsvalid_hole_fitsdeferringAnyBindingsmkCoercibleExplanation pprWithExplicitKindsWhenMismatchexpandSynonymsToMatch SolvedCtsSplitCtsTcPluginProgresspluginInputCtspluginSolvedCts pluginBadCts pluginNewCtsrunTcPluginsGivenrunTcPluginsWanted runTcPluginsnaturallyCoherentClass zonk_eq_typescan_eq_newtype_nc canEqCast canEqFailurecanEqHardFailurecanEqReflexiveTcTyMode mode_tykiAllowedDataResKind AnyBoxedKind LiftedKindisAllowedDataResKind SkolemModetc_infer_lhs_typetc_infer_hs_type_ektc_infer_hs_type tcInferTyAppstcInferTyApps_nosatcheckExpectedKindnewNamedWildTyVarkcInferDeclHeaderkcCheckDeclHeader_sig finish_tuplekcCheckDeclHeaderkcCheckDeclHeader_cuskTypeOrKindCtxt ExpandModeExpandNoExpandBoth OnlyTypeCtxt OnlyKindCtxtBothTypeAndKindCtxt ValidityEnv TelescopeAcctypeOrKindCtxttypeLevelUserTypeCtxtallConstraintsAllowedlinearityAllowed vdqAllowedinitialExpandModecheckEscapingKindillegalVDQTyErrlinearFunKindErrcheckHasFieldInstcheckValidTypePatsisTerminatingClassppr_tidycheck_arg_type runRnSplicegeneralizeOverLitValOpNameNormalOpNegateOp UnboundOpRecFldOppartition_nwcsrnImplicitTvBndrswildCardsAllowedcheckPolyKindslookupFixityOp filterInScopefilterInScopeMfilterFreeVarsToBindlookupFixityRn' MonadNamesStmtTreernStmtsWithPostProcessing postProcessStmtsForApplicativeDonoPostProcessStmtsrebindableContextrearrangeForApplicativeDomkStmtTreeHeuristicmkStmtTreeOptimalstmtTreeToStmtssegments splitSegmentmkApplicativeStmtneedJoin isReturnAppmkExpandedExprrnStmtwarnUnqualifiedImport gresFromIEwarnMissingSignatureswarnMissingKindSignaturesAssocTyFamInfoNonAssocTyFamEqnAssocTyFamDefltAssocTyFamInstClosedTyFamInfo ClosedTyFamNotClosedTyFamInstDeclFreeVarsMap KindSigEnvKindSig_FV_EnvpatchForeignImportcheckCanonicalInstances rnRoleAnnotsmkInstDeclFreeVarsMaprnInjectivityAnnextendPatSynEnvrnFamEqnmkDsEnvsFromTcGblpprLygSequenceeqPmLit eqConLike initNabla initTmState decEqualitymaxBuildLengthcheckLevPolyFunctionisBadLevPolyFunctionCIRBcirb_cov cirb_inacccirb_red cirb_bangs getLdiNablas noCheckDsaddRedundantBangs testRedSetsformatReportWarningsreportWarningslocallyExtendPmNablas addPhiCtsTopNormaliseTypeResultpmTopNormaliseTypeNormalisedByConstraints HadRedexesupdRcmvanillaCompleteMatchTCaddCompleteMatchesaddConLikeMatchesaddTyConMatchestntrGutspmIsClosedTypenormaliseSourceTypeWHNFisSourceTypeInWHNFlookupVarInfoNTinitFueladdTyCtstyOraclenameTyCt addPhiTmCtaddBotCtaddConCt addNotBotCt addNotConCtaddVarCt addCoreCtrepresentCoreExprmodifyT Control.Monad.Trans.State.StrictinhabitationTestvarNeedsTesting instantiateinstBotsplitReprTyConApp_maybeinstCompleteSetsinstCompleteSetinstConisDataConTriviallyInhabitedtriviallyInhabitedTyConsmatchConLikeResTy PmExprList pmExprAsListpprRefutableShapesprettifyRefuts getCleanNamepprPmVar NilTerminatedWcVarTerminated mkPmLetVar vanillaConGrd mkListGrds mkPmLitGrds desugarPat desugarPatV desugarLPatV desugarLPatdesugarListPatdesugarConPatOut desugarLGRHS desugarGuarddesugarLocalBinds desugarBinddesugarBoolGuarddsFractionalLitToRationalwarnAboutOverflowedLiteralsgetLHsIntegralLitgetIntegralLitgetSimpleIntegralLit getLHsCharLitgetNormalisedTyconName getTyconNamedsHsBind makeCorePairds_ev_typeablegetRep leftToRight topToBottomthrottlemkMetaWrappersrepFamilyResultSigrepFamilyResultSigToMaybeKindrepInjectivityAnnnullOuterImplicitnullOuterExplicit repTyVarBndr repMaybeLTy coreNothing coreNothing'coreJust coreJust' dsMcBindStmtmatchExpectedPatTy checkGADTtc_pat tcMatchestc_patsyn_finishmkPatSynRecSelBinds SynCycleMcheckTyConIsAcyclic localSigWarnrecursivePatSynErrcmd_arr tcCmdMatchestcCmdTop PlanResultrun_th_modfinalizers andThenCheck checkUnless checkListBycheck checkSuccesstcPreludeClashWarn getMainOccrunPlans tcUserStmt tcGhciStmts getGhciStepIOrnDumptcMissingParentClassWarn checkVersions checkPlugins checkHsigcheckHie checkFlagHashcheckOptimHash checkHpcHash checkModUsagegetOrphanHashesmkIfaceAnnCachecheckHsigIface check_instifaceDeclNeverExportedRefscheckImplementscheckPatSynParentgetInitialKind tcInjectivity getArgExpKind rejigConReswrongNumberOfParmsErrget_fam_decl_initial_kind getFamFlavtcDefaultAssocDecl mkGADTVars deriveClause derivePred cond_stdOK cond_args ConditionArgTyAlg argTyFoldfoldBalSeparateBagsDerivStuff AuxBindSpec DerivTag2Con DerivMaxTagDerivDataDataTypeDerivDataConstrauxBindSpecRdrNamemk_showString_appmk_showsPrec_app mk_shows_appgenAuxBindSpecOriginalgenAuxBindSpecDupgenAuxBindSpecSig mkFunBindSE mkFunBindEC postfixModTbl assoc_ty_idassoc_ty_id_maybenewAuxBinderRdrNameinferConstraintsStockinferConstraintsAnyclass simplifyDerivcheckCOrAsmOrLlvmcheckCOrAsmOrLlvmOrInterpmergeStaticObjectsObjects loadObjects dynLoadObjsmakeForeignNamedHValueRefs linkSomeBCOs getGCCPathsgccSearchDirCachegetSystemDirectories addEnvPathsPScopedHasType RFContextRScopedTVScopedToHie BindContext SigContext IEContextPatSynFieldContext listScopes patScopestScopestvScopesPScpe_envcpe_convertNumLit FloatTick cpeBodyNFCpeBodycpeBodyFloatsokCpeArg wrapTickscollectCostCentresGHC.Serialized Serialized toSerializedserializeWithDatafromSerializeddeserializeWithDatatraceTR instSchemefindEnclosingDeclsupdateFixityEnvpipeLoop llvmOptionssourceModifiedgetGhcVersionPathNamelink' runPipeline' BuildModuleCompilationGraphGHC.MVarMVarLogQueueMakeNewModSummarymakeNewModSummary StableModulesupsweep loadFinish discardProg discardICguessOutputFilefindPartiallyCompletedCyclesbuildCompGraph parUpsweep upsweep_mod getModLoopunfilteredEdgeswarnUnnecessarySourceImportsenableCodeGenForTHenableCodeGenWhenmsDepsparUpsweep_onegetPreprocessedImports normalise_hypcheckBrokenTablesNextToCodepartition_argscheckNewDynFlagsbindSuspensions SessionTypeBkpMBkpEnv bkp_session bkp_filename bkp_table bkp_level ExeSession TcSession CompSessionwithBkpSession hsunitDepsaddUnit getBkpEnv getBkpLevel innerBkpM updateEpsGhc_ getEpsGhcinitBkpMbackpackProgressMsg mkBackpackMsg backpackStyle msgTopPackage msgUnitId msgIncludehsunitModuleGraphhsModuleToModSummary newUnitId