h)^E      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                         !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!""""""""""""""""""""""""""""""""""""""""""#####$$$$$$$$$$%%%%%%%%%%%%%%%%%%%%%%%%%&'''''''''((((())))***********+,,,,,,,,,,,,,-------------....................                                                                                                          / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4     5 5 5 5 5 5 6 6 6 6 6 7 7 8 8 8 8 8 8 8 8 8 9 : : : : : : ; ; ; ; ; ; < = = = = > > > > > > > > = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = ==========================================??????@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@AAAAAABBCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDEEEEEEEEEEFGGGGGGGGHHHIIJJJJJIJKIIJKJKJJJJLJJJJJJJJJJJJJMMMMMMMMNNNNNOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOPPPPPPPPPPPPPPPPPPPPPPQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQRRRRRRRRRRRRSSSSSSSSSSSSSTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUVVVVVVVVVVVWWWWWWWWWWXXXXXXXXXXXX<<<<<<<<<<<<<<<<<YYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYZZZZZZZZZZZZZZZZZZZZZZZZ[[[[[[[[[\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\]]]]]]]]]]]]]]]]]]]]]]]]]]]]>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>^^^^^^^^^^^^^^^^____________________________________________________```````````````````````````aaaaaaaaaaaabbbbccccccccccccccddddeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffgggggggggggggggggggggggggggg                                                                     hhiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiijjjjjjjjjjjjjjkllllllllllllllllllllllllllllllllmmmmmmmmmmmmmmmmmnnnnnnnnnnnnnJnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnJJnnnnnnnnngg;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; 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"o"o"o"o"o"o"o"o"o"o"o"o"o"o"o"o"o"o"o"o"o"o"o"o"o"o"o"o"o"o"o"o"o"o"o"o"o"o"o"o"o"o"o"o"o"o"o"o"o"o"o"o"o"o"o"o"o"o"o"o"o"o"o"o"o"o"o"o"o"o"o"o"o"p"p"p"p"p"p"p"p"p"p"p"p"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#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#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#s#s#s#t#t#t#t#t#t#t#t#t#t#t#t#t#t#t#t#t#t#t#t#t#t#t#t#t#t#t#t#t#t#t#t#t#t#t#t#t#t#t#t#t#t#t#t#t#t#t#t#t#t#t#t#t#t#t#t$t$t$t$t$t$t$t$t$t$t$t$t$t$t$t$t$t$t$t$t$t$t$t$t$t$t$t$t$t$t$t$t$t$t$t$t$t$t$t$t$t$t$t$t$t$t$t$t$t$t$t$t$t$t$t$u$u$u$u$u$u$u$u$u$u$u$u$u$u$u$u$v$v$v$v$v$v$v$v$v$v$v$v$v$v$v$v$v$v$v$v$v$v$v$v$v$v$v$v$v$v$v$v$v$v$v$v$v$v$v$v$v$v$v$v$v$v$v$v$v$v$v$v$v$v$v$v$v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%I%I%I%I%I%I%I%I%I%I%I%I%I%I%I%I%I%I%I%I%I%I%I%I%I%I%I%I%I%I%I%I%I%I%I%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%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x&x&x&x&x&x&x&x&x&x&x&x&x&y&y&y&y&y&y&y&y&y&y&y&y&y&y&y&y&z&z&z&z&z&z&z&z&z&z&z&z&z&z&z&z&z&z&z&z&z&z&z&z&z&z&z&z&z&z&z&z&z&z&z&z&z&z&z&z&z&z&z&{&{&{&{&{&{&{&{&{&{&{&{&{&{&{&{&{&{&{&{&{&{&{&{&{&{&{&{&{&{&{&{&{&{&{&{&{&{&{&{&{&{&{&{&|&|&|&|&|&|&|&|&|&|&|&|&|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'|'}'}'}'}'}'}'}'}'}'}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(}(})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})})}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}*}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},},}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0~0~0~0~0~0~0~0~0~0~0~0~0~0~0~0~0~0~0000000000000000000000000000000000000000000000111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111112222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222233333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444445555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555566666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777778888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888899999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999::::::::::::::::G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G;G<G<G<L<<<<<<<<<J<J<J<J<J<J<J<I<I<I<I<K<K<K<K<I<I<I<K<I<I<K<K<K<K<K<K<K<K<K<K<K<K<K<K<K<K<K<K<K<K<K<J<K<K<K<K<K<K<K<K<K<K<K<K<K<K<K<J<K<J<K<K<K<J<J<J<K<J<J<M<M<J<K<J<J<J<J<J<J<J<J<J<J<J<I<I<J<J<J<I<K<<<<K<K<K<K<K<K<K<K<K<K<K<K<K<K<K<K<K<K<L<L<L<L=L=L=L=L=L=L=L=L=L=L=L=L=L=L=L=L=L=L=L=L=L=L=L=L=L=L=L=L=L=L=L=L=L=L=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=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>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> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > >???????????????????????????????????????????????????????????????????????????????????????????????????????J?J?J?J?J?J?J?J?J?J?J?J?J?J?J?J?J?J?J?J?J?J?J?J?J?J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@J@JAJAJAJAJAJAJAJAJAJAJAJAJAJAJAJAJAJAJAJAJAJAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC:C:C:C:C:C:C:C:C:C:C:C:C:C:C:C:C:C:C:C:C:C:C:C:C:C:C:C:C:C:C:C:C:C:C:C:C:C:C:C:C:C:C:C:C:C:C:C:C:C:C:C:C:C:C:C:C: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:DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDNDNDNDNDNENENENENENENENENENENENENENENENENENEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEIEIEIEIEIEIEIEIEIEIEIEIEIEIEIEIEIEIEIEIEIEIEIEIEIEIEIEIEIEIEIEIEIEIEIEIEIEIEIEIEIEIEIEIEIEIEIEIEIEIEIEIEIEIEIEIEIEIEIEIEIEIEIEIFIFIFIFIFIFIFIFIFIFIFIFIFIFIFIFIFIFIFIFIFIFIFIFIFIFIFIFIFIFIFIFIFIFIFIFIFIFIFIFIFIFIFIFIFIFIFIFIFIFIFIFIFIFIFIFIFIFIFIFIFIFIFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGHHHHHHHHHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHmHHHHHHHHHHHHHHHHHHIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL?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?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?MFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFMFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRHRHRHRHRHRHRHRHRHRHRHRHRHRHRHRHRHRHRHRHRHRHRHRHRHRHRHRHRHRRSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSnSnSnSnSnSnSnSnSnSnSnSnSnSnSnSnSnSnSnSnSnSnSnSnSnSnSnSnSnSnSnSnSnSnSnSnSnSnSnSnSnSnSnSnSnSnSnSnSnSnSnSnSnSnSnSnSnSnSnSnSnSnSnSnSnSnSnSnSnSnSnSnSnSnSnSnSnSnSnSnSnSnSnSnSnSnSnSnSnTnTnTnTnTnTnTnTnTnTnTnTnTnTnTnTnTnTnTnTnTnTnTnTnTnTnTnTnTnTnTnTnTnTnTnTnTnTnTnTnTnTnTnTnTnTnTnTnTnTnTnTnTnTnTnTnTnTnT9T9T9T9T9T9T9T9T9T9T9T9T9T9T9T9T9T9T9T9T9T9T9T9T9T9T9T9T9T9T9T9T9T9T9T9T9T9T9T9T9T9T9T9T9T9T9T9T9T9T9T9T9T9T9T9T9T9T9T9T9T9T9T9T9T9T9T9T9T9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9U9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9V9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9W9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Z9Z9Z9Z9Z9Z9Z9ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^________________________________________________________________________________________________________________________________````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffBfBfBfBfBfBfBfBfBfBfBfBfBfBfBfBfBfBfBfBfBfBfBfBfBfBfBfBfBfBfBfBfBfBfBfBfBfBfBfBfBfBfBfBfBfBffAfAfAfAfAfAfAfAfAfAfAfAfAfAfAfAfAfAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAgAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAhAiAiAiAiAiAiAiAiAiAiAiAiiiiiiiiiiiiiiiiiiiiiiihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihjhjhjhjhjhjhjhjhjhjhjhjhjhjhjhjhjhjhjhjhjhjhjhjhjhjhjhjhjhjhjhjhjhjhjhjhjhjhjhjhjhjhjhjhjhjhjhjhjhjhjhjhjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn8n8n8n8n8n8n8n8n8n8n8n8n8n8n8n8n8n8n8n8n8n8n8n8n8n8n8n8n8nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqrrrrrrrrrrrrrrrrrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsMsssssssssssssssssssssttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv v v v v v v v v v v v v v v v v v v w w w w w w w w w w w w w w w w w w w w wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~€ÀĀŀƀǀȀɀʀˀ̀̀΀πЀрҀӀԀՀր׀؀ـڀۀ܀݀ހ߀ÁāŁƁǁȁɁʁˁ́́΁ρЁсҁӁԁՁցׁ؁فځہ܁݁ށ߁‚ÂĂłƂǂȂɂʂ˂̂͂΂ςЂт҂ӂԂՂւׂ؂قڂۂ܂݂ނ߂ƒÃăŃƃǃȃɃʃ˃̃̓΃σЃу҃ӃԃՃփ׃؃كڃۃ܃݃ރ߃666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666„6Ä6Ą6ń6Ƅ6DŽ6Ȅ6Ʉ6ʄ6˄6̄6̈́6΄6τ6Є6ф6҄6ӄ6Ԅ6Մ6ք6ׄ6؄6ل6ڄ6ۄ6܄6݄6ބ6߄6666666666666666666666666666666666666666666666666666666666666666666…ÅąŅƅDžȅɅʅ˅̅ͅ΅υЅх҅ӅԅՅօׅ؅مڅۅ܅݅ޅ߅†ÆĆņƆdžȆɆʆˆ̆͆ΆφІц҆ӆԆՆֆ׆؆نچۆ܆݆ކ߆‡ÇćŇƇLJȇɇʇˇ͇̇·χЇч҇ӇԇՇևׇ؇هڇۇ܇݇އ߇ˆÈĈňƈLjȈɈʈˈ͈̈ΈψЈш҈ӈԈՈֈ׈؈وڈۈ܈݈ވ߈‰ÉĉʼnƉljȉɉʉˉ͉̉ΉωЉщ҉ӉԉՉ։׉؉ىډۉ܉݉މ߉ŠÊĊŊƊNJȊɊʊˊ̊͊ΊϊЊъҊӊԊՊ֊׊؊يڊۊ܊݊ފߊ‹ËċŋƋNjȋɋʋˋ̋͋΋ϋЋыҋӋԋՋ֋׋؋ًڋۋ܋݋ދߋŒÌČŌƌnjȌɌʌˌ̌͌ΌόЌьҌӌԌՌ֌׌،ٌڌی܌݌ތߌÍčōƍǍȍɍʍˍ͍̍΍ύЍэҍӍԍՍ֍׍؍ٍڍۍ܍ݍލߍŽÎĎŎƎǎȎɎʎˎ͎̎ΎώЎюҎӎԎՎ֎׎؎َڎێ܎ݎގߎÏďŏƏǏȏɏʏˏ̏͏ΏϏЏяҏӏԏՏ֏׏؏ُڏۏ܏ݏޏߏÐĐŐƐǐȐɐʐː̐͐ΐϐАѐҐӐԐՐ֐אِؐڐېܐݐސߐ‘ÑđőƑǑȑɑʑˑ̑͑ΑϑБёґӑԑՑ֑בّؑڑۑܑݑޑߑ’ÒĒŒƒǒȒɒʒ˒̒͒ΒϒВђҒӒԒՒ֒גْؒڒےܒݒޒߒ“ÓēœƓǓȓɓʓ˓͓̓ΓϓГѓғӓԓՓ֓דؓٓړۓܓݓޓ7ߓ77777777777”ÔĔŔƔǔȔɔʔ˔͔̔ΔϔДєҔӔԔՔ֔הؔٔڔ۔ܔݔޔߔ•ÕĕŕƕǕȕɕʕ˕͕̕ΕϕЕѕҕӕԕՕ֕וٕؕڕەܕݕޕߕ–ÖĖŖƖǖȖɖʖ˖̖͖ΖϖЖіҖӖ5Ԗ5Ֆ5֖5ז5ؖ5ٖ5ږ5ۖ5ܖ5ݖ5ޖ5ߖ555—×ėŗƗǗȗɗʗ˗̗͗ΗϗЗїҗӗԗ՗֗חؗٗڗۗܗݗޗߗ˜ØĘŘƘǘȘɘʘ˘̘͘ΘϘИјҘӘԘ՘֘טؘ٘ژۘܘݘޘߘ™ÙęřƙǙșəʙ˙̙͙ΙϙЙљҙәԙՙ֙יؙٙڙۙܙݙޙߙšÚĚŚƚǚȚɚʚ˚͚̚ΚϚКњҚӚԚ՚֚ךؚٚښۚܚݚޚߚ›ÛěśƛǛțɛʛ˛̛͛ΛϛЛћқӛԛ՛֛כ؛ٛڛۛܛݛޛߛœÜĜŜƜǜȜɜʜ˜̜͜ΜϜМќҜӜԜ՜֜ל؜ٜڜۜܜݜޜߜÝĝŝƝǝȝɝʝ˝̝͝ΝϝНѝҝӝԝ՝֝ם؝ٝڝ۝ܝݝޝߝžÞĞŞƞǞȞɞʞ˞̞͞ΞϞОўҞӞԞ՞֞מ؞ٞڞ۞ܞݞޞߞŸßğşƟǟȟɟʟ˟̟͟ΟϟПџҟӟԟ՟֟ן؟ٟڟ۟ܟݟޟߟ àĠŠƠǠȠɠʠˠ̠͠ΠϠРѠҠӠԠՠ֠נؠ٠ڠ۠ܠݠޠߠ¡áġšơǡȡɡʡˡ̡͡ΡϡСѡҡӡԡա֡סء١ڡۡܡݡޡߡ¢âĢŢƢǢȢɢʢˢ̢͢΢ϢТѢҢӢԢբ֢עآ٢ڢۢܢݢޢߢ£ãģţƣǣȣɣʣˣ̣ͣΣϣУѣңӣԣգ֣ףأ٣ڣۣܣݣޣߣ¤äĤŤƤǤȤɤʤˤ̤ͤΤϤФѤҤӤԤդ֤פؤ٤ڤۤܤݤޤߤ¥åĥťƥǥȥɥʥ˥̥ͥΥϥХѥҥӥԥե֥ץإ٥ڥۥܥݥޥߥ¦æĦŦƦǦȦɦʦ˦̦ͦΦϦЦѦҦӦԦզ֦צئ٦ڦۦܦݦަߦ§çħŧƧǧȧɧʧ˧̧ͧΧϧЧѧҧӧԧէ֧קا٧ڧۧܧݧާߧ¨èĨŨƨǨȨɨʨ˨̨ͨΨϨШѨҨӨԨը֨רب٨ڨۨܨݨިߨ©éĩũƩǩȩɩʩ˩̩ͩΩϩЩѩҩөԩթ֩שة٩ک۩ܩݩީߩªêĪŪƪǪȪɪʪ˪̪ͪΪϪЪѪҪӪԪժ֪תت٪ڪ۪ܪݪުߪ«ëīūƫǫȫɫʫ˫̫ͫΫϫЫѫҫӫԫի֫׫ث٫ګ۫ܫݫޫ߫¬ìĬŬƬǬȬɬʬˬ̬ͬάϬЬѬҬӬԬլ֬׬ج٬ڬ۬ܬݬެ߬­íĭŭƭǭȭɭʭ˭̭ͭέϭЭѭҭӭԭխ֭׭ح٭ڭۭܭݭޭ߭®îĮŮƮǮȮɮʮˮ̮ͮήϮЮѮҮӮԮծ֮׮خٮڮۮܮݮޮ߮¯ïįůƯǯȯɯʯ˯̯ͯίϯЯѯүӯԯկ֯ׯدٯگۯܯݯޯ߯°ðİŰưǰȰɰʰ˰̰ͰΰϰаѰҰӰ԰հְװذٰڰ۰ܰݰް߰±ñıűƱDZȱɱʱ˱̱ͱαϱбѱұӱԱձֱױرٱڱ۱ܱݱޱ߱²òIJŲƲDzȲɲʲ˲̲ͲβϲвѲҲӲԲղֲײزٲڲ۲ܲݲ޲߲³óijųƳdzȳɳʳ˳̳ͳγϳгѳҳӳԳճֳ׳سٳڳ۳ܳݳ޳߳´ôĴŴƴǴȴɴʴ˴̴ʹδϴдѴҴӴԴմִ״شٴڴ۴ܴݴ޴ߴµõĵŵƵǵȵɵʵ˵̵͵εϵеѵҵӵԵյֵ׵صٵڵ۵ܵݵ޵ߵ¶öĶŶƶǶȶɶʶ˶̶Ͷζ϶жѶҶӶԶնֶ׶ضٶڶ۶ܶݶ޶߶·÷ķŷƷǷȷɷʷ˷̷ͷηϷзѷҷӷԷշַ׷طٷڷ۷ܷݷ޷߷¸øĸŸƸǸȸɸʸ˸̸͸θϸиѸҸӸԸոָ׸ظٸڸ۸ܸݸ޸߸¹ùĹŹƹǹȹɹʹ˹̹͹ιϹйѹҹӹԹչֹ׹عٹڹ۹ܹݹ޹߹ºúĺźƺǺȺɺʺ˺̺ͺκϺкѺҺӺԺպֺ׺غٺںۺܺݺ޺ߺ»ûĻŻƻǻȻɻʻ˻̻ͻλϻлѻһӻԻջֻ׻ػٻڻۻܻݻ޻߻¼üļżƼǼȼɼʼ˼̼ͼμϼмѼҼӼԼռּ׼ؼټڼۼܼݼ޼߼½ýĽŽƽǽȽɽʽ˽̽ͽνϽнѽҽӽԽսֽ׽ؽٽڽ۽ܽݽ޽߽¾þľžƾǾȾɾʾ˾̾;ξϾоѾҾӾԾվ־׾ؾپھ۾ܾݾ޾߾¿ÿĿſƿǿȿɿʿ˿̿ͿοϿпѿҿӿԿտֿ׿ؿٿڿۿܿݿ޿߿                                                       Safe-Inferredt Safe-Inferredw>=;D9IL=;D9IL>= operation for . was a hot-spot in the ticky profile for the ManyConstructors test which called the cg function many times in  StgToCmm.hsghcTurn 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 , lazilyghc/Apply a monadic operation 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. Safe-Inferred -ghc+Copy and freeze a slice of a mutable array.ghc!Freeze a mutable array (no copy!)ghc)Index a small-array (no bounds checking!)ghcConvert a list into an array.ghcsizeghcinitial contentsghcarrayghcindexghc new elementghcsourceghcoffsetghclengthghcarrayghcindex   Safe-Inferred) Safe-Inferred p Safe-Inferred ghc ghc ghc ghc ghc Safe-Inferred_ghcmaybeFlipCond 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.(c) Matt Morrow 2009BSD3stableportable Safe-Inferred  ghc Dominators. Complexity as for idomghcPost-dominators. Complexity as for idom.ghcDominator tree. Complexity as for idom.ghcPost-dominator 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.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-Inferredf! Safe-Inferred 89:::" Safe-Inferred)*0158/ 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.ghc!Maybe type indexed by open/closedghc6Either type indexed by closed/open using type familiesghcUsed at the type level to indicate "open" vs "closed" structure.ghcAn "open" structure with a unique, unnamed control-flow edge flowing in or out. "Fallthrough" and concatenation are permitted at an open point.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.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.ghcFold a function over every node in a block, forward or backward. The fold function must be polymorphic in the shape of the nodes.))# Safe-Inferred $ Safe-InferredghcDefault 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 " ghc File name.ghcFile modification time.ghc File owner.ghc File group.ghc File mode.ghc File size.ghc File bytes.ghc n) ghc '(lengthAtLeast xs n) = (length xs >= n) ghc "(lengthIs xs n) = (length xs == n) ghc %(lengthIsNot xs n) = (length xs /= n) ghc &(lengthAtMost xs n) = (length xs <= n) ghc ((lengthLessThan xs n) == (length xs < n) ghcTrue if length xs == length ys ghcTrue if length xs <= length ys ghcTrue if length xs < length ys ghc=Utility function to go from a singleton list to it's element.Wether or not the argument is a singleton list is only checked in debug builds. ghcExtract the single element of a list and panic with the given message if there are more elements or the list was empty. Like  expectJust, but for lists. ghcSplit a list into chunks of n elements ghc8Replace the last element of a list with another element. ghcApply 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) ghc=Remove duplicates but keep elements in order. O(n * log n) ghc=Remove duplicates but keep elements in order. O(n * log n) ghc;Given two lists xs and ys, return `splitAt (length xs) ys`. ghcdrop from the end of a list 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-Get the last two elements in a list. Partial! ghc onJust x m f? applies f to the value inside the Just or returns the default. 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=Convert a word to title case by capitalising the first letterghcFind 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 explanation ghcSearch for possible matches to the users input in the given list, returning a small number of ranked results ghc*Determine the $log_2$ of exact powers of 2 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) ghcParse 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) ghcA sample hash function for Strings. We keep multiplying by the golden ratio and adding. The implementation is: hashString = foldl' f golden where f m c = fromIntegral (ord c) * magic + hashInt32 m magic = 0xdeadbeef2Where hashInt32 works just as hashInt shown above.Knuth argues that repeated multiplication by the golden ratio will minimize gaps in the hash space, and thus it's a good choice for combining together multiple keys to form one.Here we know that individual characters c are often small, and this produces frequent collisions if we use ord c alone. A particular problem are the shorter low ASCII and ISO-8859-1 character strings. We pre-multiply by a magic twiddle factor to obtain a good distribution. In fact, given the following test: testp :: Int32 -> 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.ghcA 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 + 32768    x      ]    x      ] 9  3 2 Safe-Inferred /80 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 D action, failing on error.@JKs     4/ Safe-Inferred 6?3 ghcA  5 is a pointer to some array of Latin-1 encoded chars. ghcLexical FastStringThis is a simple FastString wrapper with an Ord instance using   (i.e. which compares FastStrings on their String representation). Hence it is deterministic from one run to the other. ghcNon-deterministic FastStringThis is a simple FastString wrapper with an Ord instance using   (i.e. which compares FastStrings on their Uniques). Hence it is not deterministic from one run to the other. ghcA  : is a UTF-8 encoded string together with a unique ID. All  s are stored in a global hashtable to support fast O(1) comparison.It is also associated with a lazy reference to the Z-encoding of this string which is used by the compiler internally. ghcLazily computed Z-encoding of this string. See Note [Z-Encoding] in GHC.Utils.Encoding.Since  s are globally memoized this is computed at most once for any given string. ghc:Gives the Modified UTF-8 encoded bytes corresponding to a  ghc:Gives the Modified UTF-8 encoded bytes corresponding to a  ghcCompare FastString lexically2If you don't care about the lexical ordering, use   instead. ghc3Compare FastString by their Unique (not lexically).Much cheaper than   but non-deterministic! ghc Create a   by copying an existing  ghc Create a   from an existing  without copying. ghcCreates a UTF-8 encoded   from a : ghc Creates a   from a UTF-8 encoded [Word8]ghcCreates a (lazy) Z-encoded   from a = and account the number of forced z-strings into the passed . ghcReturns the length of the   in characters ghcReturns True if the   is empty ghc"Unpacks and decodes the FastString ghc!Returns a Z-encoded version of a  . This might be the original, if it was already Z-encoded. The first time this function is applied to a particular  , the results are memoized. ghc Outputs a   with no decoding at all,, that is, you get the actual bytes in the   written to the . ghcWrap an unboxed address into a  . ghc Encode a : into a newly allocated   using Latin-1 encoding. The original string must not contain non-Latin-1 characters (above codepoint 0xff). ghc Decode a   back into a : using Latin-1 encoding. This does not free the memory associated with  . ghcReturn the length of a  1 1 0 Safe-InferredY ghc$Is this an acceptable variable name? ghc'Is this an acceptable constructor name? ghc Is this an acceptable type name? ghcIs this an acceptable alphanumeric variable name, assuming it starts with an acceptable letter? ghcIs this an acceptable symbolic variable name, assuming it starts with an acceptable character? ghcIs this an acceptable alphanumeric constructor name, assuming it starts with an acceptable letter? ghcIs this an acceptable symbolic constructor name, assuming it starts with an acceptable character?ghcIs this string an acceptable id, possibly with a suffix of hashes, but not worrying about case or clashing with reserved words?ghcIs this character acceptable in an identifier (after the first letter)? See alexGetByte in GHC.Parser.LexerghcAll reserved identifiers. Taken from section 2.4 of the 2010 Report.ghcAll reserved operators. Taken from section 2.4 of the 2010 Report.ghcDoes this string contain only dashes and has at least 2 of them?  1 Safe-Inferred ghcReplicate an 8-bit character 2 Safe-Inferred  ghcA StringBuffer is an internal pointer to a sized chunk of bytes. The bytes are intended to be *immutable*. There are pure operations to read the contents of a StringBuffer.A StringBuffer may have a finalizer, depending on how it was obtained. ghcRead a file into a  . The resulting buffer is automatically managed by the garbage collector.ghcSkip the byte-order mark if there is one (see #1744 and #6016), and return the new position of the handle in bytes.This is better than treating #FEFF as whitespace, because that would mess up layout. We don't have a concept of zero-width whitespace in Haskell: all whitespace codepoints have a width of one column. ghc Encode a : into a   as UTF-8. The resulting buffer is automatically managed by the garbage collector. ghcConvert a UTF-8 encoded  into a 'StringBuffer. This really relies on the internals of both  and  .O(n) (but optimized into a memcpy by  bytestring under the hood) ghc/Return the first UTF-8 character of a nonempty  2 and as well the remaining portion (analogous to ). Warning:# The behavior is undefined if the   is empty. The result shares the same buffer as the original. Similar to 0, if the character cannot be decoded as UTF-8, '\0' is returned. ghcReturns true if the buffer contains Unicode bi-directional formatting characters. https://www.unicode.org/reports/tr9/#Bidirectional_Character_TypesBidirectional format characters are one of 'x202a' : "U+202A LEFT-TO-RIGHT EMBEDDING (LRE)" 'x202b' : "U+202B RIGHT-TO-LEFT EMBEDDING (RLE)" 'x202c' : "U+202C POP DIRECTIONAL FORMATTING (PDF)" 'x202d' : "U+202D LEFT-TO-RIGHT OVERRIDE (LRO)" 'x202e' : "U+202E RIGHT-TO-LEFT OVERRIDE (RLO)" 'x2066' : "U+2066 LEFT-TO-RIGHT ISOLATE (LRI)" 'x2067' : "U+2067 RIGHT-TO-LEFT ISOLATE (RLI)" 'x2068' : "U+2068 FIRST STRONG ISOLATE (FSI)" 'x2069' : "U+2069 POP DIRECTIONAL ISOLATE (PDI)"This list is encoded in  ghc/Return the first UTF-8 character of a nonempty   (analogous to ). Warning:# The behavior is undefined if the   is empty. Similar to 0, if the character cannot be decoded as UTF-8, '\0' is returned. ghc Return a  7 with the first UTF-8 character removed (analogous to ). Warning:# The behavior is undefined if the  ? is empty. The result shares the same buffer as the original. ghc Return a   with the first n bytes removed. Warning:2 If there aren't enough characters, the returned   will be invalid and any use of it may lead to undefined behavior. The result shares the same buffer as the original. ghc-Compute the difference in offset between two   s that share the same buffer. Warning:# The behavior is undefined if the  s use separate buffers. ghcCheck whether a   is empty (analogous to ). ghc%Computes a hash of the contents of a  . ghc Computes a   which points to the first character of the wanted line. Lines begin at 1. ghcDecode the first n bytes of a   as UTF-8 into a :. Similar to , if the character cannot be decoded as UTF-8, they will be replaced with '\0'. ghcReturn the previous n* characters (or fewer if we are less than n characters into the buffer. ghcn, the number of bytes ghcn, the number of bytes ghcn, the number of bytes  3"(c) The University of Glasgow 2001 BSD-style (see the file LICENSE)!David Terei stableportable Safe-Inferred, ghcRendering mode. ghcNormal ghcWith zig-zag cuts ghc%No indentation, infinitely long lines ghcAll on one line ghcA rendering style. ghcThe rendering mode ghcLength of line, in chars 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. 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. ghcA document of height and width 1, containing a literal character. 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. ghcSome text with any width. (text s = sizedText (length s) s) ghcSome text, but without any width. Use for non-printing text such as a HTML or Latex tags ghc*Empty text (one line high but no width). (emptyText = text "") ghc2The empty document, with no height and no width.   is the identity for  ,  ,   and  ), and anywhere in the argument list for  ,  ,  ,  ,   etc. ghcReturns L if the document is empty ghcApply   to   if boolean is true.ghc*Perform some simplification of a built up GDoc. ghcList version of  . ghcList version of  . ghcList version of  . 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 "hang d1 n d2 = sep [d1, nest n d2] ghcApply   to the arguments if the first   is not empty. ghc punctuate p [d1, ... dn] = [d1 <> p, d2 <> p, ... dn-1 <> p, dn] 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.   is associative, with identity  . ghc;Beside, separated by space, unless one of the arguments is  .   is associative, with identity  . ghcEither   or  . ghcEither   or  . ghc"Paragraph fill" version of  . ghc"Paragraph fill" version of  .ghcfirst returns its first argument if it is non-empty, otherwise its second. ghcThe default style (7mode=PageMode False, lineLength=100, ribbonsPerLine=1.5).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. ghc Render the Doc to a String using the given Style. ghcDefault TextDetails printer ghc The general rendering interface. ghcA ';' character ghcA ',' character ghcA : character ghcA space character ghcA '=' character ghcA '(' character ghcA ')' character ghcA '[' character ghcA ']' character ghcA '{' character ghcA '}' character ghc int n = text (show n) ghc integer n = text (show n) ghc float n = text (show n) ghc double n = text (show n) ghc rational n = text (show n) ghc%See Note [Print Hexadecimal Literals] ghcWrap document in '...' ghcWrap document in "..." ghcWrap document in (...) ghcWrap document in [...] ghcWrap document in {...} ghcRendering modeghc Line lengthghcRibbons per lineghcWhat to do with textghcWhat to do at the endghc The documentghcResult  5 5 6 64 Safe-Inferred  ghcA colour/style for use with coloured. ghc;Parse the colour scheme from a string (presumably from the  GHC_COLORS environment variable). ghcAllow colours to be combined (e.g. bold + red); In case of conflict, right side takes precedence.  = Safe-Inferred5?) ghc'Represents a pretty-printable document.To display an  , use  ,  ,  , or  . Avoid calling  . directly as it breaks the abstraction layer. ghcWhen we print a binder, we often want to print its type too. The OutputableBndr class encapsulates this idea. 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 ghcThe x in (x. e) ghc+The x in case scrut of x { (y,z) -> ... } ghc+The y,z in case scrut of x { (y,z) -> ... } ghcThe x in (let x = rhs in e) ghcWrapper for types having a Outputable instance when an OutputableP instance is required. ghc5Outputable class with an additional environment value See Note [The OutputableP class] ghc(Class designating that some type has an   representation ghc stop ghcUse   field as depth ghcStyle 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+C label style (used by C and LLVM backends) ghc%Asm label style (used by NCG backend) ghc!Print code; either C or assembler ghc$NB: This won't ever show package IDs 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 ghc!Style for printing error messages ghcDefault pretty-printing options ghc6Truncate a list that is longer than the current depth. ghc'Indicate if -dppr-debug mode is enabled ghc,Says what to do with and without -dppr-debug ghc7Says what to do with -dppr-debug; without, return empty 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. ghcAn efficient variant of   specialized for   that outputs to a  . ghcdoublePrec p n shows a floating point number n with p. digits of precision after the decimal point. ghcIndent   some specified amount ghc Join two  $ together horizontally without a gap ghc Join two  . together horizontally with a gap between them ghc Join two   together vertically; if there is no vertical overlap it "dovetails" the two onto one line ghc Join two   together vertically ghc Concatenate   horizontally ghc Concatenate  + horizontally with a space between each one ghc Concatenate   vertically with dovetailing ghcSeparate: is either like   or like  , depending on what fits ghcCatenate: is either like   or like  , depending on what fits ghcA paragraph-fill combinator. It's much like sep, only it keeps fitting things on one line until it can't fit any more. ghcThis behaves like  , but it uses  ( for horizontal conposition rather than  ghcThis behaves like  , but does not indent the second document when the header is empty. ghc.Apply the given colour/style for the argument.)Only takes effect if colours are enabled. ghc2Special combinator for showing character literals. ghc/Special combinator for showing string literals. ghc3Special combinator for showing bytestring literals. ghc0Special combinator for showing unboxed literals. ghc9Normalise, escape and render a string representing a pathe.g. "c:\whatever" ghcReturns the separated concatenation of the pretty printed things. ghcReturns the comma-separated concatenation of the pretty printed things. ghcReturns the comma-separated concatenation of the quoted pretty printed things. ,y,z] ==> `x', `y', `z' ghc&Converts an integer to a verbal index: speakNth 1 = text "first" speakNth 5 = text "fifth" speakNth 21 = text "21st" 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" ghcDetermines the pluralisation suffix appropriate for the length of a list: plural [] = char 's' plural ["Hello"] = empty plural ["Hello", "World"] = char 's' ghcDetermines the singular verb suffix appropriate for the length of a list: singular [] = empty singular["Hello"] = char 's' singular ["Hello", "World"] = empty 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 to do appropriate for the length of a list: doOrDoes [] = text "do" doOrDoes ["Hello"] = text "does" doOrDoes ["Hello", "World"] = text "do" 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 ghcDetermines the form of subject appropriate for the length of a list: thisOrThese [x] = text "This" thisOrThese [x,y] = text "These" thisOrThese [] = text "These" -- probably avoid this ghc"has" or "have"# depending on the length of a list. ghc The headerghcAmount to indent the hung bodyghc3The hung body, indented and placed below the header ghcThe punctuationghcThe list that will have punctuation added between every adjacent pair of elementsghcPunctuated list ghc#The pretty printing function to useghcThe things to be pretty printedghc  where the things have been pretty printed, comma-separated and finally packed into a paragraph. ghc#The pretty printing function to useghcThe things to be pretty printedghc  where the things have been pretty printed, bar-separated and finally packed into a paragraph.  Q Safe-Inferred5ghc=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).ghc(Some other fatal signal (SIGHUP,SIGTERM)ghc*Prints the short usage msg after the errorghcA problem with the command line arguments, but don't print usage.ghcThe  impossible happened.ghcThe user tickled something that's known not to work yet, but we're not counting it as a bug.ghcAn installation problem.ghc&An error in the user's code, probably.ghcShow an exception as a string.ghcShow an exception which can possibly throw other exceptions. Used when displaying exception thrown within TH code.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.ghc;Append a description of the given exception to this string.ghc7Throw an exception saying "bug in GHC" with a callstackghc&Throw an exception saying "bug in GHC"ghc3Throw an exception saying "this isn't finished yet"ghcThrow an exception saying "bug in pgm being compiled" (used for unusual program errors)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 catchghc-We use reference counting for signal handlersghcTemporarily install standard signal handlers for catching ^C, which just throw an exception in the current thread.ghcPanic with an assertion failure, recording the given file and line number. Should typically be accessed with the ASSERT family of macros** Safe-Inferred84ghcExpand occurrences of the $tooldir interpolation in a string on Windows, leave the string untouched otherwise.ghc.Returns a Unix-format path pointing to TopDir.ghc.whether we are use the ambiant mingw toolchainghctooldirghc,Maybe TopDir path (without the '-B' prefix).ghcTopDir (in Unix format  separated)ghc.whether we are use the ambiant mingw toolchainghctopdir Safe-Inferred8ghcThe predicates below look costly, but aren't, GHC+GCC do a great job at the big case below. Safe-Inferred9eR Safe-Inferred:Dghc2Edge weights to use when generating a CFG from CMMghcDefault edge weights  S Safe-Inferred )*:ghc-Simple data type to represent JSON documents.   Safe-Inferred value1 in map1" that shares a key with a mapping key |-> value2 in map2 is altered by f: value1 is replaced by f value1 value2 , where K& means that the new value is used and J$ means that the mapping is deleted.ghcIn essence foldM See Note [Deterministic UniqFM] to learn about nondeterminism. If you use this please provide a justification why it doesn't introduce nondeterminism.ghc Cast the key domain of a UniqFM.As long as the domains don't overlap in their uniques this is safe.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.ghcDetermines the pluralisation suffix appropriate for the length of a set in the same way that plural from Outputable does for lists.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-InferredV Safe-Inferred 68VPghcMaps indexed by  keys"PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP"PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPY Safe-Inferred 689:?^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 timeghcPerforms a deterministic fold over the UniqDFM. It's O(n log n) while the corresponding function on  is O(n).ghcPerforms 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 Converts  to a list, with elements in deterministic order. It's O(n log n) while the corresponding function on  is O(n).ghc>Partition UniqDFM into two UniqDFMs according to the predicateghc(Delete a list of elements from a UniqDFMghc7This allows for lossy conversion from UniqDFM to UniqFMghc(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,Map a function over every value in a UniqDFMghc Cast the key domain of a UniqFM.As long as the domains don't overlap in their uniques this is safe.ghcDeterministic, 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//\ Safe-Inferred6aghcWhat'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].$$ Safe-InferredhFghcGraph nodes. Represents a thing that can conflict with another thing. For the register allocater the nodes represent registers.ghc"A unique identifier for this node.ghcThe class of this node, determines the set of colors that can be used.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>Colors that this node would prefer to be, in descending order.ėghc>Neighbors that this node would like to be colored the same as.ŗ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.ȗ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.ɗghcAn empty graph.ʗghc5Modify the finite map holding the nodes in the graph.˗ghcAn empty node.ȗŗƗǗɗʗ—×ė˗ȗŗƗǗɗʗ—×ė˗ Safe-Inferred3seghcA  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:e m u3 == Just ele1, e m u4 == Nothing, e m u5 == Nothing.e m u1 u3 is a no-op, but e m u1 u2 merges {u1,u3} and {u2} to point to  Just ele2 and returns the old entry of {u1,u3},  Just ele1.e 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.eghclookupSUDFM env x looks up an entry for x, looking through all s until it finds a shared .$Examples in terms of the model (see e): >>> 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 == NothingeghcequateUSDFM 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 e): >>> 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)])eghcaddToUSDFM 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 e): >>> addToUSDFM [] u1 ele1 == [({u1}, Just ele1)] >>> addToUSDFM [({u1,u3}, Just ele1)] u3 ele2 == [({u1,u3}, Just ele2)]eeeeeeeeeeee] Safe-Inferred6sIZ Safe-InferredughcA non-deterministic set of FastStrings. See Note [Deterministic UniqFM] in GHC.Types.Unique.DFM for explanation why it's not deterministic and why it matters. Use DFastStringEnv if the set eventually gets converted into a list or folded over in a way where the order changes the generated code. Safe-InferredwNΗghc3The slots that are still available to be allocated.ϗghc#Assignment of vregs to stack slots.ЗghcIdentifier for a stack slot.ї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 allocatedЗ̗͗ΗϗїҗӗЗ̗͗ΗϗїҗӗT Safe-Inferred%&689:4ghc$Layout information for declarations.ghc$Explicit braces written by the user. 'class C a where { foo :: a; bar :: a } ghc0Virtual braces inserted by the layout algorithm. &class C a where foo :: a bar :: a ghcEmpty or compiler-generated blocks do not have layout information associated with them.ghcA location as produced by the parser. Consists of two components:The location in the file, adjusted for #line and {-# LINE ... #-} pragmas (RealSrcLoc)The location in the string buffer (BufPos) with monotonicity guarantees (see #17632)ghcWe attach SrcSpans to lots of things, so let's have a datatype for it.ghc Source SpanA  identifies either a specific portion of a text file or a human-readable description of a location.ghcStringBuffer Source SpanghcA  delimits a portion of a text file. It could be represented by a pair of (line,column) coordinates, but in fact we optimise slightly by using more compact representations for single-line and zero-length spans, both of which are quite common.-The end position is defined to be the column after the end of the span. That is, a span of (1,1)-(1,2) is one character long, and a span of (1,1)-(1,1) is zero characters long.Real Source SpanghcSource Locationghc30-based offset identifying the raw location in the  StringBuffer.The lexer increments the  every time a character (UTF-8 code point) is read from the input buffer. As UTF-8 is a variable-length encoding and  StringBuffer% needs a byte offset for indexing, a  cannot be used for indexing.The parser guarantees that  are monotonic. See #17632. This means that syntactic constructs that appear later in the  StringBuffer" are guaranteed to have a higher . Constrast that with , which does *not* make the analogous guarantee about higher line/column numbers.This is due to #line and {-# LINE ... #-} pragmas that can arbitrarily modify  . Notice how  setSrcLoc and resetAlrLastLoc in GHC.Parser.Lexer update  , modifying  but preserving .Monotonicity makes  useful to determine the order in which syntactic elements appear in the source. Consider this example (haddockA041 in the test suite):haddockA041.hs {-# LANGUAGE CPP #-} -- | Module header documentation module Comments_and_CPP_include where #include "IncludeMe.hs"IncludeMe.hs: -- | Comment on T data T = MkT -- ^ Comment on MkT#After the C preprocessor runs, the  StringBuffer will contain a program that looks like this (unimportant lines at the beginning removed):# 1 "haddockA041.hs" {-# LANGUAGE CPP #-} -- | Module header documentation module Comments_and_CPP_include where # 1 "IncludeMe.hs" 1 -- | Comment on T data T = MkT -- ^ Comment on MkT # 7 "haddockA041.hs" 2The line pragmas inserted by CPP make the error messages more informative. The downside is that we can't use RealSrcLoc to determine the ordering of syntactic elements.With RealSrcLoc, we have the following location information recorded in the AST: * The module name is located at haddockA041.hs:3:8-31 * The Haddock comment "Comment on T" is located at IncludeMe:1:1-17 * The data declaration is located at IncludeMe.hs:2:1-32Is the Haddock comment located between the module name and the data declaration? This is impossible to tell because the locations are not comparable; they even refer to different files.On the other hand, with , we have the following location information: * The module name is located at 846-870 * The Haddock comment "Comment on T" is located at 898-915 * The data declaration is located at 916-928Aside: if you're wondering why the numbers are so high, try running ghc -E haddockA041.hs and see the extra fluff that CPP inserts at the start of the file.For error messages,  is not useful at all. On the other hand, this is exactly what we need to determine the order of syntactic elements: 870 < 898, therefore the Haddock comment appears *after* the module name. 915 < 916, therefore the Haddock comment appears *before* the data declaration.We use  in in GHC.Parser.PostProcess.Haddock to associate Haddock comments with parts of the AST using location information (#17544).ghcReal Source Location'Represents a single point within a fileghcBuilt-in "bad"  values for particular locationsghcBuilt-in "bad"  values for particular locationsghcBuilt-in "bad"  values for particular locationsghcCreates a "bad" 4 that has no detailed information about its locationghcGives the filename of the ghc%Raises an error when used on a "bad" ghc%Raises an error when used on a "bad" ghc 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 caseghcBuilt-in "bad" ,s for common sources of location uncertaintyghcBuilt-in "bad" ,s for common sources of location uncertaintyghcBuilt-in "bad" ,s for common sources of location uncertaintyghcBuilt-in "bad" ,s for common sources of location uncertaintyghcCreate a "bad" " that has not location informationghc Create a  corresponding to a single pointghc Create a  between two points in a fileghcL0 if the span is known to straddle only one line.ghcL if the span is a single pointghc Create a  between two points in a fileghc Combines two  into one that spans at least all the characters within both spans. Returns UnhelpfulSpan if the files differ.ghc Combines two  into one that spans at least all the characters within both spans. Assumes the "file" part is the same in both inputsghcConvert a SrcSpan into one that represents only its first characterghc 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 FalseghcTrue if the span has a width of zero, as returned for "virtual" semicolons in the lexer. For "bad" , it returns FalseghcTests whether the first span "contains" the other span, meaning that it covers at least as much source code. True where spans are equal.ghc)Returns the location at the start of the  or a "bad"  if that is unavailableghc'Returns the location at the end of the  or a "bad"  if that is unavailableghcObtains the filename for a  if it is "good"ghcCombine locations from two % things and add them to a third thingghc.Tests whether the two located things are equalghc,Tests the ordering of the two located thingsghc Compare the  of two located things./Precondition: both operands have an associated .ghc4Always prints the location, even without -dppr-debugghcStrategies for ordering sghcStrategies for ordering sghcStrategies for ordering sghcDetermines whether a span encloses a given line and column indexghc4Determines whether a span is enclosed by another oneghc4Determines whether a span is enclosed by another oneghc Safe-Inferred'689:?K' ghcA Module is a pair of a   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. ghc6A generic module is a pair of a unit identifier 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. ghcUnit the module belongs to ghcModule name (e.g. A.B.C)ghc"This data type just pairs a value - with an IsBootInterface flag. In practice,  is usually a Module or  ModuleName'.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.ghc3A definite unit (i.e. without any free module hole)ghcA  is an   with the invariant that it only refers to a definite library; i.e., one we have generated code for.ghcThe full hashed unit identifier, including the component id and the hash.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.ghcCached unique of .ghc)The (indefinite) unit being instantiated.ghcThe sorted (by  ) instantiations of this unit.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.ghcInstalled 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.ghcFake hole unitghcA unit key in the databaseghcClass 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.ghcAn  is a  " whose unit is identified with an .ghcA  is like an  but we expect to find it in one of the home units rather than the package database.ghcA  is a  # whose unit is identified with an  .ghc2Compares unit ids lexically, rather than by their sghc+Retrieve the set of free module holes of a  .ghcCalculate 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.ghc Create a new ' given an explicit module substitution.ghc*Smart constructor for instantiated GenUnitghcGenerate 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.ghc2Generate a hash for a sorted module instantiation.ghc+Create a new simple unit identifier from a  . Internally, this is primarily used to specify wired-in unit identifiers.ghcMap over the unit type of a  ghc4Map over the unit identifier of unit instantiations.ghcReturn 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=Return the virtual UnitId of an on-the-fly instantiated unit.ghcA  % is definite if it has no free holes.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.          ^ Safe-Inferred ghcModule LocationWhere a module lives on the file system: the actual locations of the .hs, .hi, .dyn_hi, .o, .dyn_o and .hie 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.The paths of anything which can affect recompilation should be placed inside ModLocation.When a ModLocation is created none of the filepaths will have -boot suffixes. This is because in --make mode the ModLocation is put in the finder cache which is indexed by ModuleName, when a ModLocation is retrieved from the FinderCache the boot suffixes are appended. The other case is in -c mode, there the ModLocation immediately gets given the boot suffixes in mkOneShotModLocation.ghcThe source file, if we have one. Package modules probably don't have source files.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)ghc9Where the .dyn_hi file is, whether or not it exists yet.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)ghc5Where the .dy file is, whether or not it exists yet.ghc6Where the .hie file is, whether or not it exists yet.ghcAdd the -boot suffix to .hs, .hi and .o filesghc Remove the -boot suffix to .hs, .hi and .o filesghcAdd the -boot suffix if the Bool argument is TrueghcAdd 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 itselfb Safe-Inferred5_ Safe-InferredƬghcA map keyed off of ghcA map keyed off of  s (actually, their s) Has deterministic folds and can be deterministically converted to a listghcA map keyed off of  s (actually, their s)ghc A set of  sghcA map keyed off of  s//c Safe-Inferred %& ghcA  % 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 Test if a   corresponds to a given , modulo instantiation.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).ghc4Remove instantiations of the given instantiated unitghc;Remove instantiations of the given module instantiated unitghc$Test if a Module is not instantiatedghcCreate a hole Module       d Safe-Inferred|` Safe-Inferred!ghcInformation 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.UnitghcReturn home unit idghcReturn home unit instantiationsghcReturn 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.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.ghc4Map over the unit identifier for instantiating unitsghc/Test if we are type-checking an indefinite unit7(if it is not, we should never use on-the-fly renaming)ghc(Test if we are compiling a definite unit3(if it is, we should never use on-the-fly renaming)ghc9Test if we are compiling by instantiating a definite unitghc!Test if the unit is the home unitghc'Test if the unit-id is the home unit-idghc+Test if the unit-id is not the home unit-idghc9Test if the home unit is an instance of the given unit-idghc+Test if the module comes from the home unitghc+Test if the module comes from the 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 unitghcMake a module in home unitghcMake a module in home unitghcReturn 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.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.e Safe-Inferred6H ghcA String Literal in the source, including its original raw format for use by source to source manipulation tools.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.ghc/Special combinator for showing string literals.ghc7The integer should already be negated if it's negative.ghc=The arguments should already be negated if they are negative.ghcCompare fractional lits with small exponents for value equality but large values for syntactic equality.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.!! Safe-Inferred6aRghc Package-qualifier after renamingRenaming detects if "this" or the unit-id of the home-unit was used as a package qualifier.RghcNo package qualifierRghcImport from home-unitRghcImport from another unitRghc"Package-qualifier as it was parsedRghcNo package qualifierRghcRaw package qualifier string.RRRRRRRRRRRRRRa Safe-Inferredghc.hs fileghc .hs-boot fileghc .hsig fileghc Tests if an 9 is a boot file, primarily for constructing elements of  BuildModule. We conflate signatures and modules because they are bound in the same namespace; only boot interfaces can be disambiguated with `import {-# SOURCE #-}`. Safe-Inferred OghcSafe Haskell information for ModIface Simply a wrapper around SafeHaskellMode to sepperate iface and flagsOghcThe various Safe Haskell modesOghcinferred unsafeOghcdeclared and checkedOghcdeclared and checkedOghcdeclared and checkedOghcinferred as safeOghc-fno-safe-haskell stateOghcIs an import a safe import? OOOOOOOOOOOO OOOOOOOOOOOO[ Safe-Inferred6@ghc9An index into a given cost centre module,name,flavour setghc2Per-module state for tracking cost centre indices.See documentation of q for more details.ghcInitialize cost centre state.ghc-Get a new index for a given cost centre name.X Safe-InferredghcReadingghcWriting  V Safe-InferredghcRepresents the  as a bit set.+Assumes that all elements are non-negative.This is only efficient for values that are sufficiently small, for example in the lower hundreds.f Safe-Inferred6ghc A C type, used in CAPI FFI calls :   '{-# CTYPE' , , ,  '#-}',ghc,How to call a particular function in C-land.ghcMight 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.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 exceptions!! Safe-Inferred60ghcCaptures 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.000000000000000000000000000000l Safe-Inferred 6XghcFlag to indicate whether the FieldSelectors extension is enabled.ghc.Selector functions are available (the default)ghc$Selector functions are not availableghcFlag 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].ghcUser-visible label of the fieldghcWas 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.EnvghcRecord 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)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].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.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.ghc 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. Safe-Inferred 6:ghcSpecify whether to default kind variables, and type variables of kind  RuntimeRep Multiplicity.ghcDefault kind variables:default kind variables of kind Type to Type,default  RuntimeRep Multiplicity kind variables to  LiftedRepMany, respectively.When this strategy is used, it means that we have determined that the variables we are considering defaulting are all kind variables.;Usually, we pass this option when -XNoPolyKinds is enabled.ghc=Default (or don't default) non-standard variables, of kinds  RuntimeRep,  and  Multiplicity.ghc2Specify whether to default type variables of kind  RuntimeRep Multiplicity.ghc*Default type variables of the given kinds:default  RuntimeRep variables to  LiftedRepdefault  variables to default  Multiplicity variables to Manyghc/Try not to default type variables of the kinds  RuntimeRep Multiplicity.Note that these might get defaulted anyway, if they are kind variables and `-XNoPolyKinds` is enabled.ghc/Are we dealing with an expression or a pattern?Used only for the textual output of certain error messages; see the  FRRDataConArg constructor of FixedRuntimeRepContext.ghcFlag to see whether we're type-checking terms or kind-checking typesghc = $(f x y)ghc =* f x y, i.e. a naked top level expressionghcAn integer or infinityghcInline SpecificationghcRule Match Informationghc Phase NumberghcDefault Method Specificationghc Inside LambdaghcOccurs inside a non-linear lambda Substituting a redex for this occurrence is dangerous because it might duplicate work.ghcInteresting ContextghcFunction: is applied Data value: scrutinised by a case with at least one non-DEFAULT branchghc!identifier Occurrence Informationghc2There are many occurrences, or unknown occurrencesghcMarks unused variables. Sometimes useful for lambda and case-bound variables.ghc3Occurs exactly once (per branch), not inside a ruleghcThis identifier breaks a loop of mutually recursive functions. The field marks whether it is only a loop breaker due to a reference in a ruleghcEmbedding Projection pairghc7Are we dealing with an unboxed tuple or an unboxed sum?!Used when validity checking, see check_ubx_tuple_or_sum.ghc2A general-purpose pretty-printing precedence type.ghc'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.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.InstEnvghcThe 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',  `#-}`,ghcRecursivity Flagghc4Should an argument be passed evaluated *and* tagged.ghcIs a TyCon a promoted data constructor or just a normal type constructor?ghcIf 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.ghcA power-of-two alignmentghc A *zero-indexed* constructor tagghcA *one-index* constructor tagType of the tags associated with each constructor possibility or superclass selectorghcFullArgCount 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!ghcThe 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.ghcRepresentation 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 2ghcThe number of value arguments that can be applied to a value before it does "real work". So: fib 100 has arity 0 x -> fib x has arity 1 See also Note [Definition of arity] in GHC.Core.Opt.ArityghcTags are allocated from here for real constructors or for superclass selectorsghc$It is always safe to assume that an Id) has no lambda-bound variable informationghc=Pretty print an alternative in an unboxed sum e.g. "| a | |".ghc0Outputs string for pragma name for any of INLINE INLINABLENOINLINE. This differs from the Outputable instance for the InlineSpec type where the pragma name string as well as the accompanying SourceText (if any) is printed.ghcA representation of infinityghcAdd two sghc Multiply two sghc Subtract an  from an ghcTurn a positive number into an , where 0 represents infinityghcInject any integer into an ghcIf there is any  interesting identifier occurrence, then the aggregated occurrence info of that identifier is considered interesting.ghcIf any occurrence of an identifier is inside a lambda, then the occurrence info of that identifier marks it as occurring inside a lambdaghc#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.  Safe-Inferred%ghcTest if the given Integer is representable with a platform Intghc?Test if the given Integer is representable with a platform WordghcFor 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.ghcTry to locate "DerivedConstants.h" file in the given dirs and to parse the PlatformConstants from it.See Note [Platform constants] Safe-Inferred*=ghcGenerate a section type (e.g.  @progbits). See #13937.ghcTarget platformghc section typeghcpretty assembler fragmenti Safe-Inferred- ghcSettings for what GHC this is.ghcPaths to various files and directories used by GHC, including those that provide more settings.ghc)Settings for other executables GHC calls.Probably should further split down by phase, or split between platform-specific and platform-agnostic.ghcN.B. On Windows we don't have a linker which supports object merging, hence the @ . See Note [Object merging] in GHC.Driver.Pipeline.Execute for details.ghcLLVM: opt llvm optimiserghcLLVM: llc static compilerghcLLVM: c compilerghc?cached Fingerprint of sOpt_P See Note [Repeated -optP hashing]ghcLLVM: llvm optimiserghcLLVM: llc static compilerghcLLVM: c compilerghc iserv optionsghcDynamic library suffix Safe-Inferred0bghc TopDir pathghc&Settings filepath (for error messages)ghcRaw settings file contentsk Safe-Inferred1ghc*Compute the output file name of a program.StaticLink boolean is used to indicate if the program is actually a static library (e.g., on iOS).Use the provided filename (if any), otherwise use "main.exe" (Windows), "a.out (otherwise without StaticLink set), "liba.a". In every case, add the extension if it is missing.j Safe-Inferred; ghcCode generation backends.GHC supports several code generation backends serving different purposes (producing machine code, producing ByteCode for the interpreter) and supporting different platforms.ghcNative code generator backend.Compiles Cmm code into textual assembler, then relies on an external assembler toolchain to produce machine code.4Only supports a few platforms (X86, PowerPC, SPARC).See  GHC.CmmToAsm.ghc LLVM backend.Compiles Cmm code into LLVM textual IR, then relies on LLVM toolchain to produce machine code.It relies on LLVM support for the calling convention used by the NCG backend to produce code objects ABI compatible with it (see "cc 10" or "ghccc" calling convention in  7https://llvm.org/docs/LangRef.html#calling-conventions).3Support a few platforms (X86, AArch64, s390x, ARM).See  GHC.CmmToLlvmghcVia-C backend.Compiles Cmm code into C code, then relies on a C compiler to produce machine code.It produces code objects that are *not* ABI compatible with those produced by NCG and LLVM backends.Produced code is expected to be less efficient than the one produced by NCG and LLVM backends because STG registers are not pinned into real registers. On the other hand, it supports more target platforms (those having a valid C toolchain).See  GHC.CmmToCghcByteCode interpreter.#Produce ByteCode objects (BCO, see  GHC.ByteCode/) that can be interpreted. It is used by GHCi.?Currently some extensions are not supported (foreign primops).See GHC.StgToByteCodeghcNo code generated.Use this to disable code generation. It is particularly useful when GHC is used as a library for other purpose than generating code (e.g. to generate documentation with Haddock) or when the user requested it (via -fno-code) for some reason.ghc.Default backend to use for the given platform.ghc7Is the platform supported by the Native Code Generator?ghc5Will this backend produce an object file on the disk?ghcDoes this backend retain *all* top-level bindings for a module, rather than just the exported bindings, in the TypeEnv and compiled code (if any)?Interpreter backend does this, so that GHCi can call functions inside a module.When no backend is used we also do it, so that Haddock can get access to the GlobalRdrEnv for a module after typechecking it.   Safe-InferredBghc!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.ghcThis rewrites (tail) calls to avoid creating PLT entries for functions on riscv64. The replacement will load the address from the GOT, which is resolved to point to the real address of the function.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. Safe-InferredBDaaaaaaaaaaaaaaaa Safe-InferredCRaghc$The operator occurrence type in the PsOperatorWhitespaceMessage diagnostic.bghcThe operator symbol in the &PsOperatorWhitespaceExtConflictMessage diagnostic. abaabbbbb bbbbbabaa Safe-Inferred6J6ghc$A continguous chunk of documentation6ghc'|' is the decorator6ghc is the decorator6ghc'$ string' is the decorator6ghc%The decorator is the given number of os6ghcHaskell Documentation StringRich structure to support exact printing The location around each chunk doesn't include the decorators6ghc#The first chunk is preceded by "--  decorator" and each following chunk is preceded by "--" Example: -- | This is a docstring for foo$. It is the line with the decorator '|' and is always included -- This continues that docstring and is the second element in the NonEmpty list foo :: a -> a6ghc The docstring is preceded by "{- decorator" and followed by "-}" The chunk contains balanced pairs of '{-' and '-}'6ghcA docstring generated either internally or via TH Pretty printed with the '-- |' decorator This is because it may contain unbalanced pairs of '{-' and '-}' and not form a valid 66ghcAnnotate a pretty printed thing with its doc The docstring comes after if is 6 Otherwise it comes before. Note - we convert MultiLineDocString HsDocStringPrevious to HsDocStringNext because we can't control if something else will be pretty printed on the same line6ghc Create a 6 from a UTF8-encoded .6ghc:Pretty print with decorators, exactly as the user wrote it6ghc:Pretty print with decorators, exactly as the user wrote it6ghc.Just get the docstring, without any decoratorsghc&Don't add a newline to a single string6ghcJust get the docstring, without any decorators Seperates docstrings using "nn", which is how haddock likes to render them66666666666666666666666666666666666666666666666666 Safe-InferredMyOghcUntyped Phase descriptionOghc -EOghc -COghc -SOghc -cOghcWhen 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.OghcForeign language of the phase if the phase deals with a foreign code0OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO0OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO Safe-InferredW2ghc-Enumerates the simple on-or-off dynamic flags2ghc.Append dump output to files instead of stdout.2ghcdeprecated, no effect and behaviour is now default. Allowed switching of a special demand transformer for dictionary selectors2ghc)Use the cfg based block layout algorithm.2ghc+Layout based on last instruction per block.2ghc;Do W/W split for unlifting even if we won't unbox anything.2ghcIgnore manual SCC annotations3ghc -fPIC3ghc -fPIE3ghc -pie3ghcUse regular thunks even when we could use std ap thunks in order to get entry counts3ghc -fcompact-unwind3ghcSuppress timestamps in dumps3ghc-Suppress per binding Core size stats in dumps3ghcDebugging flags3ghc#Dump the cfg used for block layout.4ghcInitial STG (CoreToStg output)4ghcSTG after unarise4ghcSTG (after stg2stg)4ghc!Result of tag inference analysis.4ghcFinal STG (before cmm gen)4ghc!Return the names of a WarningFlagOne flag may have several names because of US/UK spelling. The first one is the "preferred one" that will be displayed in warning messages.4ghcWarning groups.As all warnings are in the Weverything set, it is ignored when displaying to the user which group a warning is in.4ghcWarning 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 4 allows for multiple hierarchies with no inherent relation to be defined.3The special-case Weverything group is not included.4ghcFind the smallest group in every hierarchy which a warning belongs to, excluding Weverything.4ghc+Warnings enabled unless specified otherwise4ghcThings you get with -W4ghcThings you get with -Wall4ghcThings you get with -Weverything, i.e. *all* known warnings flags4ghcThings 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.4ghc"Things you get with -Wunused-binds333333333333333333333444444444444444444444444444444444444444444444444444444444444444444444444222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222223333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333344444111111111111111111111111111111111111111111111111111111111111111111112222222222222222222222222222224444444444333333333333333333333444444444444444444444444444444444444444444444444444444444444444444444444222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222223333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333344444111111111111111111111111111111111111111111111111111111111111111111112222222222222222222222222222224444444444Nonef4ghcA way4Don't change the constructor order as it us used by 4 to create a unique tag (e.g. thr_debug_p) which is expected by other tools (e.g. Cabal).4ghc,for GHC API clients building custom variants4ghc'(RTS only) Multithreaded runtime system4ghc1Debugging, enable trace messages and extra checks4ghc:Profiling, enable cost-centre stacks and profiling reports4ghcDynamic linking4ghcTest if a way is enabled4ghcTest if a way is not enabled4ghc Add a way4ghc Remove a way4ghc)Check if a combination of ways is allowed4ghc'Unique tag associated to a list of ways4ghc-Unique build-tag associated to a list of waysRTS only ways are filtered out because they have no impact on the build.4ghc$Unique build-tag associated to a way4ghcReturn true for ways that only impact the RTS, not the generated code4ghc.Filter ways that have an impact on compilation4ghcFilter RTS-only ways (ways that don't have an impact on compilation)4ghc*Turn these flags on when enabling this way4ghc+Turn these flags off when enabling this way4ghc;Pass these options to the C compiler when enabling this way4ghc3Pass these options to linker when enabling this way4ghc=Pass these options to the preprocessor when enabling this way4ghcConsult the RTS to find whether it has been built with profiling enabled.5ghcConsult 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.5ghc/Consult the RTS to find whether it is threaded.5ghc/Consult the RTS to find whether it is debugged.5ghc.Consult the RTS to find whether it is tracing.5ghc Host ways.5ghcHost "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.44444444444444444444444455455554444444444444444444444445545555 Safe-Inferred %&l RghcInformation about an installed unit (units are identified by their internal UnitId)RghcInformation about an installed unit (units are identified by their database UnitKey)Rghc#Information about an installed unitWe parameterize on the unit identifier: * UnitKey: identifier used in the database (cf R5) * UnitId: identifier used to generate code (cf R)These two identifiers are different for wired-in packages. See Note [About units] in GHC.UnitRghc9Convert a DbUnitInfo (read from a package database) into RRghcMap over the unit parameterRghcMake a   from a R 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).Rghc$Create a UnitPprInfo from a UnitInfoRghc3Find all the include directories in the given unitsRghc2Find all the C-compiler options in the given unitsRghcFind all the library directories in the given units for the given waysRghc*Find all the frameworks in the given unitsRghcFind all the package framework paths in these and the preload packagesghc Either the  or  as appropriate for the way.:RRRRRRRRRRRRmRRRRRRRRR:RRRRRRRRRRRRmRRRRRRRRR Safe-Inferredo)5ghcA 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.5ghcPlatform5ghcWays5ghcGet platform constants5ghcIs profiling enabled5ghcWord size in bytes5ghc Unique build tag for the profile5555555555555555 Safe-Inferredpt˘ghcMaximum number of arguments after lambda lifting a recursive function.̘ghcMaximum number of arguments after lambda lifting non-recursive function.͘ghcLambda lift even when this turns a known call into an unknown call.Șɘʘ˘̘͘Șɘʘ˘̘͘ Safe-Inferredx5ghc8An ArgDescr describes the argument pattern of a function5ghcWe 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.5ghcTrue <=> 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]5ghcA description of the layout of a closure. Corresponds directly to the closure types in includes/rts/storage/ClosureTypes.h.5ghcWord offset, or word count5ghcByte offset, or byte count5ghcRound up the given byte count to the next byte count that's a multiple of the machine's word size.5ghc Round up base to a multiple of size.5ghc7Convert 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.5ghcFirst round the given byte count up to a multiple of the machine's word size and then convert the result to words.5ghcHalf word size in bytes5ghcSize of a closure header (StgHeader in includes/rts/storage/Closures.h)5ghcSize of the profiling part of a closure header (StgProfHeader in includes/rts/storage/Closures.h)ghcThe garbage collector requires that every closure is at least as big as this.5ghc(The total size of the closure, in words.5ghcThe byte offset into the card table of the card for a given element5ghc>Convert a number of elements to a number of cards, rounding up5ghc"The size of a card table, in bytes5ghc"The size of a card table, in words5ghc%Derives the RTS closure type from an 555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555 Safe-Inferred}Әghc&A bitmap represented by a sequence of 5 s on the target architecture. These are used for bitmaps in info tables and other generated code which need to be emitted as sequences of StgWords.Ԙghc%Make a bitmap from a sequence of bits՘ghc0Make a bitmap where the slots specified are the zeros in the bitmap. eg. [0,1,3], size 4 ==> 0x4 (we leave any bits outside the size as zero, just to make the bitmap easier to read). The list of Ints must& be already sorted and duplicate-free.֘ghcMagic number, must agree with BITMAP_BITS_SHIFT in InfoTables.h. Some kinds of bitmap pack a size/bitmap into a single word if possible, or fall back to an external pointer when the bitmap is too large. This value represents the largest size of bitmap that can be packed into a single word.՘ghc size in bitsghc*sorted indices of zeros free of duplicatesӘԘ՘֘ӘԘ՘֘ Safe-Inferred? ٘ghcTarget Profileژghc Optimize Cmm Control Flow or notۘghc"Do Cmm Linting Optimization or notܘghcEliminate common blocks or notݘghc&Perform sink after stack layout or notޘghc5Generate stack unwinding instructions (for debugging)ߘghc/Generate code to link against dynamic librariesghc1Should the Cmm pass replace Stg switch statementsghc#Should Cmm split proc points or notghc retrieve the target Cmm platform טؘ٘ژۘܘݘޘߘ טؘ٘ژۘܘݘޘߘ Safe-Inferred8d eeeeeeeeee eeeeeeeeeeu Safe-Inferred8 $$$$$$$$$ $$$$$$$$$w Safe-Inferred (8Tghc An unboxed @% type with two unboxed fields in the K case. Useful for defining  and  without overhead.%ghcStrict left fold.%ghc?Compare not only the values but also the structure of two lists%ghc?Compare not only the values but also the structure of two lists%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%5%5%5 Safe-Inferred5ghc9Pretty print a graph in a somewhat human readable format.ghcPretty print a graph in graphviz .dot format. Conflicts get solid edges. Coalescences get dashed edges.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 etc Safe-InferredghcLookup a node from the graph.ghc>Get a node from the graph, throwing an error if it's not thereghc-Add a node to the graph, linking up its edgesghc/Delete a node and all its edges from the graph.ghcModify a node in the graph. returns Nothing if the node isn't present.ghcGet the size of the graph, O(n)ghcUnion two graphs together.ghcAdd a conflict between nodes to the graph, creating the nodes required. Conflicts are virtual regs which need to be colored differently.ghcDelete a conflict edge. k1 -> k2 returns Nothing if the node isn't in the graphghcAdd 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.ghcAdd a coalescence edge to the graph, creating nodes if required. It is considered adventageous to assign the same color to nodes in a coalesence.ghc4Delete a coalescence edge (k1 -> k2) from the graph.ghcAdd 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 graphghcFreeze 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.ghcFreeze all the nodes in the graph for debugging the iterative allocator.ghc7Find all the nodes in the graph that meet some criteriaghcvalidate 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.ghcSlurp out a map of how many nodes had a certain number of conflict neighboursghcSet the color of a certain nodeghcIf 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 frozenghc(extra debugging info to display on errorghc-whether this graph is supposed to be colored.ghcgraph to validateghcvalidated graphghcTrue if this node is okghc9(conflict neighbours, num nodes with that many conflicts) Safe-Inferred( ghc*Edge direction based on DFS Classificationghc7Loop back towards the root node. Eg backjumps in loopsghcv -> vghc&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 graphghc User dataghcUser defined node idghc#Dependencies/successors of the nodeghcFind 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.ghcEfficiently construct a map which maps each key to it's set of transitive dependencies.ghcGiven a start vertex, a way to get successors from a node and a list of (directed) edges classify the types of edges.## Safe-InferredghcTry 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.+ė×—ŗƗǗȗɗʗ˗{ Safe-Inferred 8^&ghccombining functionghc initial stateghcinputsghcfinal state, outputs&ghccombining functionghc initial stateghcinputsghcfinal state, outputs$&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&$&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&3&3 Safe-Inferred 0ghcis -falignment-sanitisation enabled?1ghc.The width of the current platform's word size.1ghc3The width of the current platform's half-word size.1ghc7A bit-mask for the lower half-word of current platform.1ghcA width in bits.1ghcA width in bytes. %widthFromBytes (widthInBytes w) === w1ghc*Partial* A width from the number of bytes.1ghc:log_2 of the width in bytes, useful for generating shifts.1ghcNarrow 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) == 01ghcNarrow 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) == 001111111111111000001111111100000000111111111111110000011111111111111100111111111111100000111111110000000011111111111111000001111111111111110 Safe-Inferredighc#Native code generator configurationghcTarget platformghcContext for ASM code generationghc1The name of the module we are currently compilingghcMandatory proc alignmentghc/Generate code to link against dynamic librariesghc Enable Position-Independent Codeghc If inlining memcpy produces less than this threshold (in pseudo-instruction unit), do itghc Ditto for memsetghcSplit sectionsghcPerform ASM linting passghcPerform CMM constant foldingghc(x86) SSE instructionsghc(x86) BMI instructionsghcCFG edge weightsghc$Use CFG based block layout algorithmghc+Layout based on last instruction per block.ghcEnable Dwarf generationghcEnable unwindingsghc0Strip out block information from generated Dwarfghc0Expose symbol table entries for internal symbolsghc$Enable GHC-specific source note DIEsghc%Enable static control-flow predictionghcEnable shortcutting (don't jump to blocks only containing a jump)ghcCompute block unwinding tablesghc+Whether to enable the dead-code eliminationghcReturn Word sizeghc=Size in bytes of the pre-allocated spill space on the C stackghcReturn Word size## Safe-Inferred \ghc$The operation to perform atomically.]ghc'Atomic compare-and-swap. Arguments are [dest, expected, new]. Sequentially consistent. Possible future refactoring: should this be an] variant?]ghcAtomic swap. Arguments are  [dest, new]]ghcMachine-level primops; ones which we can reasonably delegate to the native code generators to handle.)Most operations are parameterised by the 0 that they operate on. Some operations have separate signed and unsigned versions, and float and integer versions.Note that there are variety of places in the native code generator where we assume that the code produced for a MachOp does not introduce new blocks.^ghcReturns L if the MachOp has commutable arguments. This is used in the platform-independent Cmm optimisations.If in doubt, return I. This generates worse code on the native routes, but is otherwise harmless.^ghcReturns L$ if the MachOp is associative (i.e. (x+y)+z == x+(y+z)=) This is used in the platform-independent Cmm optimisations.If in doubt, return I. This generates worse code on the native routes, but is otherwise harmless.^ghcReturns L if the MachOp is a comparison.If in doubt, return False. This generates worse code on the native routes, but is otherwise harmless.^ghcReturns Just w6 if the operation is an integer comparison with width w, or Nothing otherwise.^ghc.Returns the MachRep of the result of a MachOp.^ghcThis function is used for debugging only: we can check whether an application of a MachOp is "type-correct" by checking that the MachReps of its arguments are the same as the MachOp expects. This is used when linting a CmmExpr.^ghc!Return (results_hints,args_hints)^ghcThe alignment of a memcpy-ish operation.]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\\\\\\\\\]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]^^^\\\\\\\]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\\\\\\\\\]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]^^^\\\\\\\ Safe-Inferred ƘǘØŘĘ˜ ƘǘØŘĘ˜~ Safe-Inferred?R0ghcForeign export stubs0ghcWe don't have any stubs0ghc!There are some stubs. Parameters:?1) Header file prototypes for "foreign exported" functions2) C stubs to use when calling "foreign exported" functions0ghcInitializers to be run at startup See Note [Initializers and finalizers in Cmm] in GHC.Cmm.InitFini.0ghc Finalizers to be run at shutdown0ghc!initializerCStub fn_nm decls body is a 0: containing C initializer function (e.g. an entry of the  .init_array section) named fn_nm7 with the given body and the given set of declarations.0ghcfinalizerCStub fn_nm decls body is a 08 containing C finalizer function (e.g. an entry of the  .fini_array section) named fn_nm7 with the given body and the given set of declarations.0000000000000000000000000000g Safe-InferredghcGet the  associated with a known-key .; Safe-Inferred "6. 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" ghcAlters (replaces or removes) those elements of the map that are mentioned in the second map ghcCreate a name which is actually defined by the compiler itself ghc0Create a name brought into being by the compiler ghcMake a name for a foreign call ghc Make the ? into an internal name, regardless of what it was to begin with ghcCompare Names lexicographically This only works for Names that originate in the source code or have been tidied. ghc): an ordinary non-dependent arrow. The argument is visible in source code.!ghc Used for (=>): a non-dependent predicate arrow. The argument is invisible in source code.!ghcthe argument may not appear in source Haskell, it is only inferred.!ghc?the argument may appear in source Haskell, but isn't required.ghc,Not exported: may be discarded as dead code.ghcExported: kept aliveghcIdentifier ScopeghcKey for fast comparison Identical to the Unique in the name, cached here for speed!ghcThe type or kind of the  in question!ghcEquality Variable!ghcImplicit parameter Identifier!ghcDictionary Identifier!ghcDictionary Function Identifier!ghcEvidence Variable!ghcEvidence Identifier!ghc Kind Variable!ghc Type Variable!ghcType or Kind Variable!ghc!ghcCoercion Variable!ghcCompare Vars by their Uniques. This is what Ord Var does, provided here to make it explicit at the call-site that it can introduce non-determinism. See Note [Unique Determinism]!ghc Update a s type. Does not update the  multiplicity stored in an , if any. Because of the possibility for abuse, ASSERTs that there is no multiplicity to update.!ghc Update a (s type monadically. Does not update the  multiplicity stored in an , if any. Because of the possibility for abuse, ASSERTs that there is no multiplicity to update.!ghc Does this 1 classify an argument that is written in Haskell?!ghc Does this 5 classify an argument that is not written in Haskell?!ghc.Do these denote the same level of visibility? ! arguments are visible, others are not. So this function equates ! and !. Used for printing.!ghcMake a named binder!ghcMake a named binder var should be a type variable!ghcMake many named binders!ghc ! v == not (! v).!ghcIs this a term variable ( ) that is not! a coercion variable? Satisfies ! v ==> ! v == not (! v).!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.!ghc! returns True of s and s that must have a binding in this module. The converse is not quite right: there are some global s that must have bindings, such as record selectors. But that doesn't matter, because it's only used for assertions!ghcisExportedIdVar means "don't throw this away"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!o Safe-Inferred"ghc+Deterministic Type or Coercion Variable Set"ghcDeterministic Type Variable Set"ghcDeterministic Identifier Set"ghcDeterministic Variable Set"ghcType or Coercion Variable Set"ghcCoercion Variable Set"ghcType Variable Set"ghcIdentifier 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."ghc5map the function over the list, and union the results"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."ghc5Map the function over the list, and union the results"ghcTrue if empty intersection"ghcTrue if non-empty intersection"ghc2Partition DVarSet according to the predicate given"ghc'Delete a list of variables from DVarSet"ghc"Add a list of variables to DVarSet"ghcConvert a DVarSet to a VarSet by forgetting the order of insertion"ghctransCloVarSet for DVarSet"ghcThe things to be pretty printedghc4The pretty printing function to use on the elementsghc + where the things have been pretty printed""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""p Safe-Inferred"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."ghcRun a free variable computation, returning a list of distinct free variables in deterministic order."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 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."ghcAdd a variable - when free, to the returned free variables. Ignores duplicates and respects the filtering function."ghcReturn no free variables."ghc%Union two free variable computations."ghc5Mark the variable as not free by putting it in scope."ghc%Mark many free variables as not free."ghc#Filter a free variable computation."ghcMap a free variable computation over a list and union the results."ghc&Union many free variable computations."ghcAdd multiple variables - when free, to the returned free variables. Ignores duplicates and respects the filtering function.""""""""""""""""""""""""""""t Safe-Inferred, #ghc'Deterministic Type Variable Environment#ghcDeterministic Identifier Environment Sadly not always indexed by Id, but it is in the common case.#ghc"Deterministic Variable Environment#ghcCoercion Variable Environment#ghc%Type or Coercion Variable Environment#ghcType Variable Environment#ghcIdentifier Environment#ghcVariable Environment#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#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 ##ghc3A set of variables that are in scope at some point.Note that this is a superset of the variables that are currently in scope. See Note [The InScopeSet invariant]."Secrets of the Glasgow Haskell Compiler inliner" Section 3.2 provides the motivation for this abstraction.#ghcLook up a variable the #. This lets you map from the variable's identity (unique) to its full value.#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] and Note [The InScopeSet invariant].#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].#ghcRetrieve the left mapping#ghcRetrieve the right mapping#ghcApplies # to several variables: the two variable lists must be of equal length#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.#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)Tells whether a variable is locally bound#ghc)Tells whether a variable is locally bound#ghc$Wipe the left or right side renaming#ghc$Wipe the left or right side renaming#ghc"swap the meaning of left and right#####$$$$#$$$$$$$$$$$$$$$$$$$$$$$$$$$###$$$$$$$$$$$$$$$$$$$$$$$####################################################$$$$#$$$$$$$$$$$$$$$$$$$$$$$$$$$###$$$$$$$$$$$$$$$$$$$$$$$############################################### Safe-Inferred)*/1" 5666666666 6666656666x Safe-Inferredx %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 number of %s in dependency order: earlier % scope over later % In a single (def, use) pair, the defs also scope over the uses%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 set of names that are used somewhere%ghc)A set of names that are defined somewhere%ghc,True if there is a non-empty intersection. s1 % s2 doesn't compute s2 if s1 is empty%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 like &, but % are not eliminated from the % returned&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).%%%%%%%%%%%%%%%%%%%%%%%%%%%%%&&%%%%&&&&&&&&%%%.%%%%%%%%%%%%%%%%%%%%%%%%%%%%%&&%%%%&&&&&&&&%%%r Safe-Inferred #ghcDeterministic Name Environment#See Note [Deterministic UniqFM] in GHC.Types.Unique.DFM' for explanation why we need DNameEnv.#ghcName Environment+###########################################+########################################### Safe-InferredRghcFixity information for an . We keep the OccName in the range so that we can generate an interface from itRghc2Fixity environment mapping names to their fixitiesRghcCreates cached lookup for the  mi_fix_fn field of ModIfaceRRRRRRRRRRRRRRq Safe-Inferred6$"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)."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"ghcExplicitly annotated expression"ghc Explicitly annotated declaration"ghcGenerated by HPC for coverage"ghc.Annotated by the one of the prof-last* passes."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."ghcName of the cost centre itself"ghc Name of module defining this CC.ghc Extract the index from a flavour"ghc.Is this a cost-centre which records scc counts"ghc)Is this a cost-centre which can be sccd ?#ghcPrint a flavour in CoreghcPrint a flavour's index in Coreghc(Print the flavour component of a C labelghc.Print the flavour index component of a C label$""""""""""""""""######"####""""####"$""""""""""""""""######"####""""####" Safe-Inferred8*w5ghcA collection of annotations5ghcThe kind of annotation target found in the middle end of the compiler5ghcAn annotation target5ghcWe are annotating something with a name: a type or identifier5ghc%We are annotating a particular module5ghcRepresents an annotation after it has been sufficiently desugared from it's initial form of 5ghcThe target of the annotation5ghc An empty annotation environment.5ghcConstruct a new annotation environment that contains the list of annotations provided.5ghc,Add the given annotation to the environment.5ghc"Union two annotation environments.5ghc5Find the annotations attached to the given target as  values of your choice. If no deserializer is specified, only transient annotations will be returned.5ghc5Find the annotations attached to the given target as  values of your choice. If no deserializer is specified, only transient annotations will be returned.ghcFind payloads for the given 5 in an 5.5ghcDeserialize 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).5ghcThe "payload" of an annotation allows recovery of its value at a given type, and can be persisted to an interface file5555555555555555555555555555555555 Safe-Inferred 68_6ghcCaptures 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.6ghcexact print annotation used for capturing the locations of annotations in pragmas.6ghcA 6 can capture the locations of surrounding adornments, such as parens or backquotes. This data type identifies what particular pair are being used.6ghc'(' ')'6ghc '(#' '#)'6ghc'`'6ghc'[' ']'6ghcexact print annotations for a RdrName. There are many kinds of adornment that can be attached to a given RdrName. This type captures them, as detailed on the individual constructors.6ghc&Used for a name with an adornment, so `foo`, (bar)6ghc Used for (,,,), or @(,,,)#6ghc Used for  (# | | #)6ghc Used for (), (##), []6ghc Used for ->, as an identifier6ghc Used for an item with a leading '1. The annotation for unquoted item is stored in 6.6ghcUsed when adding a 6 to an existing 7' which has no Api Annotation (via the 7 constructor.6ghcExact print annotation for the Context data type.6ghclocation and encoding of the '=>' , if present.6ghc!zero or more opening parentheses.6ghc!zero or more closing parentheses.6ghc$Detail of the "brackets" used in an 6 exact print annotation.6ghc'(', ')'6ghc '(#', '#)'6ghc'[', ']'6ghcexact print annotation for an item having surrounding "brackets", such as tuples or lists6ghcAnnotation for the "container" of a list. This captures surrounding items such as braces if present, and introductory keywords such as 'where'.6ghc#start point of a list having layout6ghccontext, such as 'where' keyword6ghc)items appearing after the list, such as '=>' for a context6ghcAnnotation for items appearing in a list. They can have one or more trailing punctuations items, such as commas or semicolons.6ghcCaptures the location of punctuation occuring between items, normally in a list. It is captured as a trailing annotation.6ghc Trailing ';'6ghc Trailing ','6ghc Trailing '|'6ghcGeneral representation of a 0 type carrying a parameterised annotation type.7ghc,We mostly use 'SrcSpanAnn'' with an 'EpAnn''7ghc&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.7ghcWhen 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 7 constructor is used to do this. The GHC parser will only insert the 7 form.7ghc'If tools modify the parsed source, the 7 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.7ghcAn 7 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 7 instead.7ghcBase location for the start of the syntactic element holding the annotations.7ghcThe 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 7 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 7. But if a sub-element is not in its original position, the required spacing can be directly captured in the 7 field of the 7 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.7ghc?No Annotation for generated code, e.g. from TH, deriving, etc.7ghcBase location for the start of the syntactic element holding the annotations.7ghcAnnotations added by the Parser7ghc6Comments enclosed in the SrcSpan of the element this 7 is attached to7ghcSpacing 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 75 is the additional spaces to add in this case. See  8https://gitlab.haskell.org/ghc/ghc/wikis/api-annotations for details.7ghcdeltaLine should always be > 07ghcTokens embedded in the AST have an EpaLocation, unless they come from generated code (e.g. by TH).7ghcThe anchor for an 7. The Parser inserts the 7 variant, giving the exact location of the original item in the parsed source. This can be replaced by the 7 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 7 variant captures any comments between the prior output and the thing being marked here, since we cannot otherwise sort the relative order.7ghc$Captures an annotation, storing the 72 and its location. The parser only ever inserts 7 fields with a RealSrcSpan being the original location of the annotation in the source file. The 7 can also store a delta position if the AST has been modified and needs to be pretty printed again. The usual way an 7 is created is using the mj ("make jump") function, and then it can be inserted into the appropriate annotation.7ghc;a docstring that can be pretty printed using pprHsDocString7ghc(doc options (prune, ignore-exports, etc)7ghccomment starting by "--"7ghccomment in {- -}7ghc)empty comment, capturing location of EOF7ghc?The location of the prior token, used in exact printing. The 7 appears as an 7 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.7ghc'7ghc'=>', unicode variant7ghc'::'7ghc'::', unicode variant7ghch7ghc'..'7ghcUnicode variant7ghcfor function name in matches where there are multiple equations for the function.7ghc for CType7ghc'infix' or 'infixl' or 'infixr'7ghc'<-'7ghc'<-', unicode variant7ghcThe E unicode arrow7ghc 7ghc;where a name loses its location in the AST, this carries it7ghc'{-# 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.7ghc'(|'7ghc'(|', unicode variant7ghc'{'7ghc'[e|' or '[e||'7ghc'[|'7ghc'[|', unicode variant7ghc'('7ghc'['7ghc'(#'7ghcprefix  -- TemplateHaskell7ghcprefix   -- TemplateHaskell8ghc% -- for HsExplicitMult8ghc'%1' -- for HsLinearArrow8ghc->8ghc->, unicode variant8ghc';'8ghc'''8ghcstatic8ghc double '''8ghcC8ghc() for types8ghc e.g. INTEGER8ghc*String value, will need quotes when output8ghc'|'8ghcvia8ghc-<8ghc-<, unicode variant8ghc->8ghc->, unicode variant8ghc-<<8ghc-<<, unicode variant8ghc>>-8ghc>>-, unicode variant8ghc;Convert a normal annotation into its unicode equivalent one8ghcSmart constructor for a 7+. It preserves the invariant that for the 7 constructor 7 is always > 0.8ghc%Used in the parser only, extract the  from an 7!. The parser will never insert a 7#, so the partial function is safe.8ghc Maps the 6 to the related opening and closing AnnKeywordId. Used when actually printing the item.8ghc Convert a 6 to an 78ghc,Helper function used in the parser to add a 6" items to an existing annotation.8ghc,Helper function used in the parser to add a 6" items to an existing annotation.8ghcHelper function used in the parser to add a comma location to an existing annotation.8ghcHelper function (temporary) during transition of names Discards any annotations8ghcHelper function (temporary) during transition of names Discards any annotations8ghcHelper function (temporary) during transition of names Discards any annotations8ghcHelper function (temporary) during transition of names Discards any annotations8ghcShort form for 78ghcThe annotations need to all come after the anchor. Make sure this is the case.ghcThe annotations need to all come after the anchor. Make sure this is the case.8ghcCombine locations from two % things and add them to a third thing8ghcAdd additional comments to a 7, used for manipulating the AST prior to exact printing the changed one.8ghc#Replace any existing comments on a 7, used for manipulating the AST prior to exact printing the changed one.8ghcAdd additional comments, used for manipulating the AST prior to exact printing the changed one.8ghcReplace any existing comments, used for manipulating the AST prior to exact printing the changed one.8ghcTransfer comments and trailing items from the annotations in the first 6! argument to those in the second.8ghcRemove the exact print annotations payload, leaving only the anchor and comments.8ghcRemove the comments, leaving the exact print annotations payload6ghc!Api Annotations for comments only7778787877777777777777777777777777777777777777777777777777777777777777777777888888888888888888888888888888777777777777787777777788777777778877777777777778887777778888676676666666777776666666666666666666866666666666666666666666666666666666666666888888888888888888888888888888888888888888888888888877787878777777777777777777777777777777777777777777777777777777777777777777778888888888888888888888888888887777777777777877777777887777777788777777777777788877777788886766766666667777766666666666666666668666666666666666666666666666666666666666668888888888888888888888888888888888888888888888888888 Safe-Inferred 689:d9999999999999999999999999999999999999999s Safe-Inferrede#ghcUsed when we want to fingerprint a structure without depending on the fingerprints of external Names that it refers to.######v Safe-Inferred )*16g$ghc,For now, we work only with nominal equality.$ghccoaxrProves 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.$ghc-A more explicit representation for `t1 ~ t2`.$ghcA $: is a "coercion constructor", i.e. a named equality axiom.$ghcThe  [CoAxBranch] passed into the mapping function is a list of all previous branches, reversed$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$%$$$$$%%%%%%%%$$$$%$$$$$$$$$$$$%$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$%$$$$$%%%%%%%%$$$$%$$$$$$$$$$$$% Safe-Inferredj9ghcInformation 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."9999999999999:9::9999999::999999::"999999999:9::99999999999::999999:: Safe-InferredkIeghcThe class of a register. Used in the register allocator. We treat all registers in a class as being interchangeable.eeeeeeee Safe-Inferredmeghc"A register, either virtual or realeghcRealRegs 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.eghc4An identifier for a primitive real machine register.eghcThe patch function supplied by the allocator maps VirtualReg to RealReg regs, but sometimes we want to apply it to plain old Reg.eghcPrint a reg in a generic manner If you want the architecture specific names, then use the pprReg function from the appropriate Ppr module.eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee Safe-Inferrednt Safe-Inferredn Safe-Inferredrԗghc"A subcomponent of another registerؗghcA register of some classghcWorst 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..ghcFor 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.ghcThe 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.ghcpowerset (for lists)ghcpowersetLS (list of sets)ghcso we can put regs in UniqSetsۗܗݗޗߗؗٗڗԗ՗֗חۗܗݗޗߗؗٗڗԗ՗֗ח Safe-Inferredtghc!Determine the class of a registerghc4Determine all the regs that make up a certain class.ghcDetermine the common name of a reg returns Nothing if this reg is not part of the machine.ghc!Which regs alias what other regs.ghcOptimised versions of RegColorBase.{worst, squeese} specific to x86 Safe-Inferredxghc!If debug output is on, show some   on the screenghcpprTraceWith 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.ghcpprTraceIt desc x is equivalent to pprTrace desc (ppr x) xghcpprTraceException desc x action< runs action, printing a message if it throws an exception.ghc!If debug output is on, show some  7 on the screen along with a call stack when available.ghcJust warn about an assertion failure, recording the given file and line number.ghcFor when we want to show the user a non-fatal WARNING so that they can report a GHC bug, but don't want to panic.  y Safe-Inferred{&ghc9A finite mapping based on equality and association lists.&ghc0Assumes that the arguments contain no duplicates&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.&ghc7Lookup key, fail gracefully using Nothing if not found.&ghcRemove the duplicates from a list using the provided comparison function.Returns the list without duplicates, and accumulates all the duplicates in the second component of its result.&ghcRemove the duplicates from a list using the provided comparison function.&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&z Safe-Inferred6&ghcUsed where we may have an ordinary name or a record field label. See Note [GreNames] in GHC.Types.Name.Reader.&ghcA collection of && - several things that are "available"&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, ==, \/=]&ghcCompare lexicographically&ghc Does this & export the parent decl? This depends on the invariant that the parent is first if it appears at all.&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&ghc5Fields made available by the availability information&ghcNames and fields made available by the availability information.&ghcNames and fields made available by the availability information, other than the main decl itself.&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 trims an & to keep only a single name&ghcfilters &s by the given predicate&ghc filters an & by the given predicate&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&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-Inferred61&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.&ghc Import Declaration SpecificationDescribes a particular import declaration and is shared among all the  Provenances for that decl&ghcModule imported, e.g.  import Muggle Note the Muggle5 may well not be the defining module for this thing!&ghcImport alias, e.g. from as M (or Muggle if there is no as clause)&ghcWas this import qualified?&ghc-The location of the entire import declaration&ghcImport SpecificationThe & of something says how it came to be imported It's quite elaborate so that we can give accurate unused-name warnings.'ghcSee Note [Parents]'ghcGlobal Reader ElementAn element of the ''ghcSee Note [GreNames]'ghcSee Note [Parents]'ghcTrue  = the thing was defined locally'ghcIn scope through these imports'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]'ghc0Local Reader Environment See Note [LocalRdrEnv]'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 ':]',,  '`' ,  ,'ghcUnqualified name1Used for ordinary, unqualified occurrences, e.g. x, y or Foo. Create such a ' 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 ''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 ''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 'ghcMake a qualified '& in the given namespace and where the   and the   are taken from the first and second elements of the tuple respectively'ghcmake a ' where all the elements point to the same Provenance (useful for "hiding" imports, or imports with no details).'ghcSee Note [GreNames]'ghcA - for the GRE for internal use. Careful: the   of this $ is not necessarily the same as the ' (see Note [GreNames]).'ghcA 3 for the GRE suitable for output to the user. Its   will be the ' (see Note [GreNames]).'ghc.The SrcSpan of the name pointed to by the GRE.'ghc>The module in which the name pointed to by the GRE is defined.'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.'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).'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 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, but with an  % that might differ from that of the . See ' and Note [GreNames].'ghcIs this a record field defined with DuplicateRecordFields? (See Note [GreNames])'ghcIs this a record field defined with NoFieldSelectors? (See Note [NoFieldSelectors] in GHC.Rename.Env)'ghcIs this a record field defined with FieldSelectors? (See Note [NoFieldSelectors] in GHC.Rename.Env)'ghc2Returns the field label of this GRE, if it has one'ghc>Test if an unqualified version of this thing would be in scope'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 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.'ghc>Apply a transformation function to the GREs for these OccNames'ghcIs in scope unqualified?'ghc,Is in scope qualified with the given module?'ghcPrint out one place where the name was define/imported (With -dppr-debug, print them all)'ghc.Indicate if the given name is the "@" operator''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''&&&&'''''&&''&&&&&&&&&&&'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''&&&&'''''&&''&&&&&&&&&&&''''' Safe-Inferred>Oghc$The name the module is imported withOghc#the source span of the whole importOghcwhether this is a safe importOghc"whether this is an "hiding" importOghc(all the things the module could provide.4NB. BangPattern here: otherwise this leaks. (#15111)Oghc"whether this is a qualified importOghcIf a module was "imported" by the user, we associate it with more detailed usage information O; a module imported by the system only gets used for usage information.OghcRecords the modules directly imported by a module for extracting e.g. usage information, and also to give better error message OOOOOOOOOOOOO OOOOOOOOOOOOO} Safe-Inferred0ghcShould this name be considered in-scope, even though it technically isn't?This ensures that we don't filter out information because, e.g., Data.Kind.Type isn't imported. See Note [pretendNameIsInScope].',(,.((((.........-.....-/---,/'(/.+-('**********'+,(+0,,(,)---,/'/''**+*+*+++++++,*****+))++++++++++++++++++++++++++++++++++++****+++++*++++***++++**+++,****,,,,,,,,+++,*********++++++++*+****,,,,,,,,,,,****++**********++++++++++++++++++++++++++***************************++++++,,,,,,,,,,,,,)))))+++++,,,++,,,,,+++++++++)))))))))))))******************************'((''((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((())))(((((((((((((((((((((((((((((((((()))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))).,/),,,...-..---------------------------.................///..//.../,,/,/,/,///,/,***,,,/,///**///..././/,///*****00000000000000000000000000000////////000/00000000000000000000000--.,,,,/////00,,//////,-.-..-.-.......-...,---////////.///,-....-.//,//,////,/////////,,,,,,,+,/-./////,,,,-------/,///////////,,,,,,,/,-//.,--/,-.-./.,,,,,,,,,,,,,,,,,,,,,,,,,-----,-------------------------------------------------------------.................................................../.././//////////////////////000000',(,.((((.........-.....-/---,/'(/.+-('**********'+,(+0,,(,)---,/'/''**+*+*+++++++,*****+))++++++++++++++++++++++++++++++++++++****+++++*++++***++++**+++,****,,,,,,,,+++,*********++++++++*+****,,,,,,,,,,,****++**********++++++++++++++++++++++++++***************************++++++,,,,,,,,,,,,,)))))+++++,,,++,,,,,+++++++++)))))))))))))******************************'((''((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((())))(((((((((((((((((((((((((((((((((()))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))).,/),,,...-..---------------------------.................///..//.../,,/,/,/,///,/,***,,,/,///**///..././/,///*****00000000000000000000000000000////////000/00000000000000000000000--.,,,,/////00,,//////,-.-..-.-.......-...,---////////.///,-....-.//,//,////,/////////,,,,,,,+,/-./////,,,,-------/,///////////,,,,,,,/,-//.,--/,-.-./.,,,,,,,,,,,,,,,,,,,,,,,,,-----,-------------------------------------------------------------.................................................../.././//////////////////////000000G Safe-Inferred 6 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.ghcName of the constructorghcMake a  for the Typeable* representation of the given wired-in typeghc Is this the  for an unboxed tuple?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.:ghcPaints a picture of what a  represents, in broad strokes. This is used towards more informative error messages.:ghc e.g., the (->) .: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.:ghcUnlifted pointer:ghcSigned, 8-bit value:ghcSigned, 16-bit value:ghcSigned, 32-bit value:ghcSigned, 64 bit value:ghcSigned, word-sized value:ghcUnsigned, 8 bit value:ghcUnsigned, 16 bit value:ghcUnsigned, 32 bit value:ghcUnsigned, 64 bit value:ghcUnsigned, word-sized value:ghcA pointer, but not) to a Haskell value (use '(Un)liftedRep'):ghcA vector:ghc;Information pertaining to the expansion of a type synonym (type):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 :: * -> *:ghc$A closed type synonym family e.g. &type family F x where { F Int = Bool }: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:ghcDescribes the flavour of an algebraic type constructor. For classes and data families, this flavour includes a reference to the parent .:ghcAn ordinary algebraic type constructor. This includes unlifted and representation-polymorphic datatypes and newtypes and unboxed tuples, but NOT unboxed sums; see UnboxedSumTyCon.:ghcAn unboxed sum type constructor. This is distinct from VanillaAlgTyCon because we currently don't allow unboxed sums to be Typeable since there are too many of them. See #13276.: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: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: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 VecCount:ghcA constructor of VecElem:ghcA constructor of Levity:ghcA constructor of Levity: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.:ghcAn unboxed sum type.:ghcInformation about those s derived from a newtype declaration: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]:ghcL if the data type constructor has a known, fixed levity when fully applied to its arguments, False otherwise.This can only be I with UnliftedDatatypes, e.g. 5data A :: TYPE (BoxedRep l) where { MkA :: Int -> A }This boolean is cached to make it cheaper to check for levity and representation-polymorphism in tcHasFixedRuntimeRep.:ghcThe unique constructor for the newtype. It has no existentials:ghc.Is this a boxed, unboxed or constraint tuple?: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 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 .:ghcL if the newtype has a known, fixed representation when fully applied to its arguments, I# otherwise. This can only ever be I with UnliftedNewtypes.Example: newtype N (a :: TYPE r) = MkN a=Invariant: nt_fixed_rep nt = tcHasFixedRuntimeRep (nt_rhs nt)This boolean is cached to make it cheaper to check if a variable binding is representation-polymorphic in tcHasFixedRuntimeRep.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 - unboxed sums 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.TyCl:ghcA Unique of this TyCon. Invariant: identical to Unique of Name stored in tyConName field.:ghc Full binders:ghc Result kind:ghcKind of this TyCon:ghcArity:ghcA pre-allocated TyConApp tycon []:ghc TyVar bindersghcThe role for each type variable This list has length = tyConArity See also Note [TyCon Role signatures]:ghcThe C type that should be used for this type when using the FFI and CAPIghcWas 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 .... See Note [The stupid context] in GHC.Core.DataCon.ghcContains information about the data constructors of the algebraic type:ghc,Maps a label to information about the fieldghcThe flavour of this algebraic tycon. Gives the class or family declaration  for derived 8s representing class or family instances, respectively.ghc8Contains information about the expansion of the synonym:ghcName of result type variable, used for pretty-printing with --show-iface and for reifying TyCon in Template HaskellghcType 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 givenghcThe Typeable' representation. A cached version of  ( tc).ghcCorresponding data constructorghcSee comments with ::ghcScoped tyvars over the tycon's body The range is always a skolem or TcTyVar, be MonoTcTyCon only: see Note [Scoped tyvars in a TcTyCon]:ghcIs this TcTyCon already generalized? Used only to make zonking more efficientghc What sort of  this represents.:ghcMake a Required TyConBinder. It chooses between NamedTCB and AnonTCB based on whether the tv is mentioned in the dependent set:ghc Create an : from the data constructors, for a potentially levity-polymorphic datatype (with UnliftedDatatypes).:ghc Create an : from the data constructors.Use mkLevPolyDataConRhs+ if the datatype can be levity-polymorphic.:ghcExtract 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!ghcChecks the invariants of a :/ given the appropriate type class name, if any;ghcThe name (and defining module) for the Typeable representation (TyCon) of a type constructor.&See Note [Grand plan for Typeable] in GHC.Tc.Instance.Typeable.;ghcThe size of a : in bytes.This applies also when used in a constructor, where we allow packing the fields. For instance, in data Foo = Foo Float# Float# the two fields will take only 8 bytes, which for 64-bit arch will be equal to 1 word. See also mkVirtHeapOffsetsWithPadding for details of how data fields are laid out.;ghcReturn if Rep stands for floating type, returns Nothing for vector types.;ghc-The labels for the fields of this particular ghc-The labels for the fields of this particular ;ghc(Look up a field label belonging to this ghcMake a map from strings to FieldLabels from all the data constructors of this algebraic tycon;ghcGiven the name of the function type constructor and it's kind, create the corresponding . It is recommended to use n if you want this functionality;ghc#This is the making of an algebraic .;ghcSimpler specialization of ; for classes;ghcMakes a tycon suitable for use during type-checking. It stores a variety of details about the definition of the TyCon, but no right-hand side. It lives only during the type-checking of a mutually-recursive group of tycons; it is then zonked to a proper TyCon in zonkTcTyCon. See also Note [Kind checking recursive type and class declarations] in  GHC.Tc.TyCl.;ghc5No scoped type variables (to be used with mkTcTyCon).;ghcCreate an primitive  , such as Int#, Type or  RealWorld# Primitive TyCons are marshalable iff not lifted. If you'd like to change this, modify marshalablePrimTyCon.;ghcCreate a type synonym ;ghcCreate a type family ;ghc#Create a promoted data constructor  Somewhat dodgily, we give it the same Name as the data constructor itself; when we pretty-print the TyCon we add a quote; see the Outputable TyCon instance;ghc Test if the 8 is algebraic but abstract (invisible data constructors);ghc Does this 7 represent something that cannot be defined in Haskell?;ghcReturns True if the supplied  resulted from either a data or newtype declaration;ghcReturns True9 for vanilla AlgTyCons -- that is, those created with a data or newtype declaration.;ghcReturns True for the  of the  Constraint kind.;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;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;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;ghc Is this an : of a  that is generative and injective with respect to representational equality?;ghcIs this  that for a newtype;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.;ghc Is this a * representing a regular H98 type synonym (type)?;ghcIs this tycon neither a type family nor a synonym that expands to a type 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.;ghcTrue iff we can decompose (T a b c) into ((T a b) c) I.e. is it injective and generative w.r.t nominal equality? That is, if (T a b) ~N d e f, is it always the case that (T ~N d), (a ~N e) and (b ~N f)? Specifically NOT true of synonyms (open and otherwise)It'd be unusual to call mustBeSaturated on a regular H98 type synonym, because you should probably have expanded it first But regardless, it's not decomposable;ghcIs this an algebraic  declared with the GADT syntax?;ghcIs this an algebraic ( which is just an enumeration of values?;ghc Is this a ., synonym or otherwise, that defines a family?;ghc Is this a >, synonym or otherwise, that defines a family with instances?;ghcIs this a synonym 1 that can have may have further instances appear?;ghcIs this a synonym 1 that can have may have further instances appear?;ghc"Is this an open type family TyCon?;ghc0Is this a non-empty closed type family? Returns J( for abstract or empty closed families.;ghc; tc returns : is if tc is an injective tycon (where is states for which : tc is injective), or : otherwise.;ghc%Is this TyCon for an associated type?;ghcGet the enclosing class TyCon (if there is one) for the given TyCon.;ghcGet the enclosing class TyCon (if there is one) for the given TyConFlavour;ghc Is this the  for a boxed tuple?;ghc Is this the  for an unboxed sum?;ghc Is this the  for a promoted tuple?;ghcIs this a PromotedDataCon?;ghc T a .... See Note [The stupid context] in GHC.Core.DataCon.;ghc Extract the s bound by a vanilla type synonym and the corresponding (unsubstituted) right hand side.;ghcExtract the information pertaining to the right hand side of a type synonym (type) declaration.;ghcExtract the flavour of a type family (with all the extra information that it carries);ghcIs this  that for a class instance?;ghcIf this  is that for a class instance, return the class it is for. Otherwise returns Nothing;ghc#Return the associated types of the , if any;ghcIs this ! that for a data family instance?;ghcIf this  is that of a data family instance, return the family in question and the instance types. Otherwise, return Nothing;ghcIf this - is that of a data family instance, return a  which represents a coercion identifying the representation type with the type instance family. Otherwise, return Nothing;ghc Extract any : from this TyConghcCan this flavour of  appear unsaturated?;ghcIs this flavour of & an open type family or a data family?;ghcReturns whether or not this  is definite, or a hole that may be filled in at some later point. See Note [Skolem abstract data] :ghc whether the  has a fixed levity;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 of the ghcArity of the tuple ghc%Whether the tuple is boxed or unboxed;ghcKind of the resulting ghcArity of the sumghcs scoped over: see :;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 Must answer L to isFixedRuntimeRepKind (i.e., no representation polymorphism). (If you need a representation-polymorphic PrimTyCon, change tcHasFixedRuntimeRep, marshalablePrimTyCon, reifyTyCon for PrimTyCons.);ghcresult kind;ghcresult kind;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::::::::::::::::::::::::::::::::::;::::::$$$$:::::::::::::::::::::::::::::::::::::::;;;;;;;;::;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:;;;;;:;;:::::::::::::::::::::::::::::;;;;;;;;::::::::::::::::::::::;::::::$$$$:::::::::::::::::::::::::::::::::::::::;;;;;;;;::;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::::;;;;;;;;;::;;;;;;;;;;;;:;;;;;;;:;:::::;;;;;:;;:::::::::::::::::::::::::::::;;;;;;;; Safe-Inferred`ghc,True if there is a non-empty intersection. s1  s2 doesn't compute s2 if s1 is empty Safe-InferredDghcDeterministic TyCon Environment#See Note [Deterministic UniqFM] in GHC.Types.Unique.DFM( for explanation why we need DTyConEnv.DghcTyCon Environment&DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD&DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD Safe-Inferred Eghc Initialise a E with E.Eghc8The default upper bound (100) for the number of times a E is allowed to encounter each .Eghc1Change the upper bound for the number of times a E is allowed to encounter each .EEEEEEEEEEK Safe-Inferred69p(ghcA collection of sghc0The key type representing kinds in the compiler.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"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.ghc&A shorthand for data with an attached  element (the multiplicity).ghcA semantically more meaningful type to represent what may or may not be a useful .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 .ghcA  is concrete evidence of the equality/convertibility of two types.ghc creates a nullary <$. In general you should rather use J, which picks the shared nullary TyConApp from inside the TyCon (via tyConNullaryTy. But we have to build the TyConApp tc [] in that TyCon field; that's what  is for.ghcLike mkTyCoForAllTy, but does not check the occurrence of the binder See Note [Unused coercion variable in ForAllTy]<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<ghcA coercion to be filled in by the type-checker. See Note [Coercion holes]<ghc>See Note [Phantom coercions]. Only in Phantom roled coercions<ghcFrom the fact that any two coercions are considered equivalent. See Note [ProofIrrelProv]. Can be used in Nominal or Representational coercions<ghcFrom a plugin, which asserts that this coercion is sound. The string is for the use of the plugin.<ghc;See Note [Coercion holes] Only present during typechecking<ghc< is like , but there can only be ! in the < field.<ghcA type labeled < might have knot-tied tycons in it. See Note [Type checking recursive type and class declarations] in  GHC.Tc.TyCl<ghc;Vanilla type or kind variable (*never* a coercion variable)<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<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.<ghcA  type. Note [When we quantify over a coercion variable] 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.<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<ghc/Type synonym used for types of kind RuntimeRep.<ghc3The key representation of types within the compiler<ghcRemove the binder's variable from the set, if the binder has a variable.<ghc,Does this binder bind an invisible argument?<ghc)Does this binder bind a visible 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.<ghc0Special, common, case: Arrow type with mult Many<ghcMake nested arrow types<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<ghc+A view function that looks through nothing.<ghcApply a function to both the Mult and the Type in a 'Scaled Type'<<<<<<<<<<<<<<<<<<<!!!!!!<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<ghcReturns free variables of types, including kind variables as a non-deterministic set. For type synonyms it does not expand the synonym.ghcGiven 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.>ghcAdd the kind variables free in the kinds of the tyvars in the given set. Returns a deterministically ordered list.>ghcAdd the kind variables free in the kinds of the tyvars in the given set. Returns a deterministic set.>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.>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.>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>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>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>ghc+Get the free vars of a type in scoped order>ghc*Get the free vars of types in scoped order>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-InferredQY?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.?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 ??ghcTidy a list of Types-See Note [Strictness in tidyType and friends]?ghc Tidy a Type-See Note [Strictness in tidyType and friends]?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)?ghcTidy a Coercion-See Note [Strictness in tidyType and friends]???????????????????????????????? Safe-Inferredi#>ghcA substitution of s for !s?ghcA substitution of s for s and 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.?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?ghcComposes two substitutions, applying the second one provided first, like in function composition.?ghcMake a TCvSubst with specified tyvar subst and empty covar subst?ghcMake a TCvSubst with specified covar subst and empty tyvar subst?ghcReturns the free variables of the types in the range of a substitution as a non-deterministic set.?ghc#Generates the in-scope set for the ? from the types in the incoming environment. No CoVars, please!?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!?ghcType substitution, see ??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.?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.?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 covars within a type?ghcType substitution, see ??ghcType substitution, see ??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].?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].?ghcThis checks if the substitution satisfies the invariant from 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 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.?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  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.?ghcSubstitute within several s The substitution has to satisfy the invariants described in Note [The substitution invariant].ghcLike ?, 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.ghcSubstitute a tyvar in a binding position, returning an extended subst and a new tyvar. Use the supplied function to substitute in the kindghcSubstitute a covar in a binding position, returning an extended subst and a new covar. Use the supplied function to substitute in the kindghc"Use this to substitute in the kind???>?????????????????????????????????????????????????????????????????????????????????????>??????????????????????????????????????????????????????????????????????????????????L Safe-Inferredq<ghc 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).<ghc Primitive 3s that are defined in, and exported from, GHC.Prim.=ghcThe 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 ghcCreate a primitive  with the given , arguments of kind  with the given $-s, and the given result kind representation.Only use this in GHC.Builtin.Types.Prim.ghcCreate a primitive nullary  with the given ! and result kind representation.Only use this in GHC.Builtin.Types.Prim.ghcCreate a primitive  like 2, except the last argument is levity-polymorphic.Only use this in GHC.Builtin.Types.Prim.=ghcGiven a Role, what TyCon is the type of equality predicates at that role?ghcroles of the arguments (must be non-empty), not including the implicit argument of kind Levity, which always has $ roleghc(representation of the fully-applied type==========================================================<====<<<==<====================================>>>>>>>>>>>>>>>>>>>>============================>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>==========================================================<====<<<==<====================================>>>>>>>>>>>>>>>>>>>>============================>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Safe-InferreduUšÚĚŚƚǚȚɚʚ˚͚̚ΚϚКњҚӚԚ՚֚ךؚٚښۚܚݚޚߚ›ÛěśƛǛțɛʛ˛̛͛ΛϛЛћқӛԛ՛֛כ؛ٛڛۛܛݛޛߛœÜĜŜƜǜȜɜʜ˜̜͜ΜϜМќҜӜԜ՜֜ל؜ٜڜۜܜݜޜߜÝĝŝƝǝȝɝʝ˝̝͝ΝϝНѝҝӝԝ՝֝ם؝ٝڝ۝ܝݝޝߝšÚĚŚƚǚȚɚʚ˚͚̚ΚϚКњҚӚԚ՚֚ߚךؚٚښۚܚݚޚ›ÛěśƛǛțɛʛ˛̛͛ΛϛЛћқӛԛ՛֛כ؛ٛڛۛܛݛޛߛÜœĜŜƜǜȜɜʜ˜̜͜ΜϜМќҜӜԜ՜֜ל؜ٜڜۜܜݜޜߜÝĝŝƝǝȝɝʝ˝̝͝ΝϝНѝҝӝԝ՝֝ם؝ٝڝ۝ܝݝޝߝJ Safe-Inferred ((ghcGiven a = and a list of argument types, partition the arguments into: ! or ! (i.e., invisible) arguments and! (i.e., visible) argumentsghc Extract the  of a type. For example, getLevity Int = Lifted, or !getLevity (Array# Int) = Unlifted.Panics if this is not possible. Does not look through type family applications.ghc The same as fst . splitTyConAppghcAttempts to tease a type apart into a type constructor and the application of a number of arguments to that constructorghcThis 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 ?ghcIs this the type :?ghcGives the typechecker view of a type. This unwraps synonyms but leaves  Constraint alone. c.f. , which turns  Constraint into  . Returns J> if no unwrapping happens. See also Note [coreView vs tcView]ghcThis function strips off the top layer only of a type synonym application (if any) its underlying representation type. Returns J? if there is nothing to look through. This function considers  Constraint to be a synonym of Type.=This function does not look through type family applications.By being non-recursive and inlined, this case analysis gets efficiently joined onto the case analysis that the caller is already doingghcA key function: builds a < or < as appropriate to its arguments. Applies its arguments to the constructor from left to right.ghc(mkTyConTy tc) returns (TyConApp tc []) but arranges to share that TyConApp among all calls See Note [Sharing nullary TyConApps] in GHC.Core.TyConghcMake 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.Repghc&Applies a type to another, as in e.g. k aghc!An ordering relation between two s (known below as t1 :: k1 and t2 :: k2)ghc 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.ghc t1 > t2?ghcThis describes how a "map" operation over a type/coercion should behave?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?ghcThis 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.TyClghcexpandSynTyConApp_maybe tc tys! expands the RHS of type synonym tc instantiated at arguments tys , or returns J if tc is not a synonym.ghc A helper for 3 to avoid inlining this cold path into call-sites.Precondition: the call is saturated or over-saturated; i.e. length tvs <= length arg_tysghc Iterates  until there is no more to synonym to expand. See Note [Inlining coreView].?ghcExpand 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.? 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 synonymTyConsOfTypeghc&An INLINE helper for function such as ? below.isTyConKeyApp_maybe key ty returns Just tys iff the type  ty = T tys, where T's unique = key?ghcExtract the RuntimeRep classifier of a type from its kind. For example, kindRep * = LiftedRep; Panics if this is not possible. Treats * and Constraint as the same?ghcGiven a kind (TYPE rr), extract its RuntimeRep classifier rr. For example,  kindRep_maybe * = Just LiftedRep Returns J if the kind is not of form (TYPE rr) Treats * and Constraint as the same?ghcReturns True if the kind classifies types which are allocated on the GC'd heap and False otherwise. Note that this returns False for representation-polymorphic kinds, which may be specialized to a kind that classifies AddrRep or even unboxed kinds.?ghc9Returns True if the kind classifies unlifted types (like 'Int#') and False otherwise. Note that this returns False for representation-polymorphic kinds, which may be specialized to a kind that classifies unlifted types.?ghcSee .ghc`isBoxedRuntimeRep_maybe (rep :: RuntimeRep)` returns `Just lev` if rep% expands to `Boxed lev` and returns J otherwise.Types with this runtime rep are represented by pointers on the GC'd heap.?ghcCheck whether a type of kind :! is lifted, unlifted, or unknown.isLiftedRuntimeRep rr returns: Just Lifted if rr is LiftedRep :: RuntimeRep Just Unlifted if rr is definitely unlifted, e.g. IntRepNothing if not known (e.g. it's a type variable or a type family application).?ghcCheck whether a type of kind : is lifted.? is:True of LiftedRep :: RuntimeRepFalse of type variables, type family applications, and of other reps such as IntRep :: RuntimeRep.?ghcCheck whether a type of kind : is unlifted.True of definitely unlifted :s such as :, :, :, ... False of :,6False for type variables and type family applications.ghc'An INLINE helper for functions such as ? and ?.%Checks whether the type is a nullary  application, for a  with the given .?ghcIs a tyvar of type :??ghcIs a tyvar of type ??ghcIs a tyvar of type  Multiplicity?@ghc2Attempts to obtain the type variable underlying a , and panics with the given message if this is not a type variable type. See also @@ghc2Attempts to obtain the type variable underlying a @ghcIf the type is a tyvar, possibly under a cast, returns it, along with the coercion. Thus, the co is :: kind tv ~N kind ty@ghc2Attempts to obtain the type variable underlying a , without any expansion@ghcAttempt 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!@ghcDoes the AppTy split as in @7, but assumes that any Core view stuff is already done@ghcDoes the AppTy split as in tcSplitAppTy_maybe, but assumes that any coreView stuff is already done. Refuses to look through (c => t)@ghc1Attempts to take a type application apart, as in @%, and panics if this is not possible@ghcRecursively 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.@ghcLike @(, but doesn't look through type synonyms@ghc>Is this a numeric literal. We also look through type synonyms.@ghc=Is this a symbol literal. We also look through type synonyms.@ghc;Is this a char literal? We also look through type synonyms.@ghc2Is this a type literal (symbol, numeric, or char)?@ghcIs this type a custom user error? If so, give us the kind and the error message.@ghc=Render a type corresponding to a user type error into a SDoc.@ghcAttempts to extract the multiplicity, argument and result types from a type, and panics if that is not possible. See also @@ghcAttempts to extract the multiplicity, argument and result types from a type@ghcExtract the function result type and panic if that is not possible@ghc Just like @/ 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 possible@ghc(piResultTys f_ty [ty1, .., tyn]) gives the type of (f ty1 .. tyn) where f :: f_ty @" 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 as type.@ghc), as that's not a TyCon in the type-checker.If you only need the , consider using tcTyConAppTyCon_maybe.@ghcLike , but doesn't look through synonyms. This assumes the synonyms have already been dealt with.@ghcLike @, 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 FunTy@ghcAttempts to tease a list type apart and gives the type of the elements if successful (looks through type synonyms)@ghc 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.ghcLike , but avoids checking the coercion for reflexivity, as that can be expensive.ghcGiven a  RuntimeRep , applies TYPE to it. On the fly it rewrites TYPE LiftedRep --> liftedTypeKind (a synonym) TYPE UnliftedRep --> unliftedTypeKind (ditto) TYPE ZeroBitRep --> zeroBitTypeKind (ditto) NB: no need to check for TYPE (BoxedRep Lifted), TYPE (BoxedRep Unlifted) because those inner types should already have been rewritten to LiftedRep and UnliftedRep respectively, by mkTyConAppsee Note [TYPE and RuntimeRep] in GHC.Builtin.Types.Prim. See Note [Using synonyms to compress types] in GHC.Core.TypeghcGiven a , apply BoxedRep to it On the fly, rewrite BoxedRep Lifted --> liftedRepTy (a synonym) BoxedRep Unlifted --> unliftedRepTy (ditto) See Note [TYPE and RuntimeRep] in GHC.Builtin.Types.Prim. See Note [Using synonyms to compress types] in GHC.Core.TypeghcGiven a `[RuntimeRep]`, apply TupleRep to it On the fly, rewrite TupleRep [] -> zeroBitRepTy (a synonym) See Note [TYPE and RuntimeRep] in GHC.Builtin.Types.Prim. See Note [Using synonyms to compress types] in GHC.Core.Type@ghc Make a dependent forall over an ! variable@ghcLike @, but tv should be a tyvar@ghcLike </, but assumes all variables are dependent and !, a common case@ghcLike @#, but tvs should be a list of tyvar@ghcLike ,, but assumes the variable is dependent and !, a common case@ghcLike </, but assumes all variables are dependent and !, a common case@ghcLike mkForAllTys, but assumes all variables are dependent and visible@ghcGiven 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.@ghcTake a ForAllTy apart, returning the list of tycovars and the result type. 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.ghc'Splits the longest initial sequence of <s that satisfy  argf_pred', returning the binders transformed by  argf_pred@ghcLike @, but only splits <s with ! type variable binders. Furthermore, each returned tyvar is annotated with ().@ghcLike @, but only splits <s with ! type variable binders. Furthermore, each returned tyvar is annotated with its .ghcLike @, 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.@ghc Bool -> Double) == [(Int, VisArg), (Bool, VisArg)] getRuntimeArgTys (Identity Int -> Bool -> Double) == [(Identity Int, VisArg), (Bool, VisArg)] getRuntimeArgTys (Int -> Identity (Bool -> Identity Double)) == [(Int, VisArg), (Bool, VisArg)] getRuntimeArgTys (forall a. Show a => Identity a -> a -> Int -> Bool) == [(Show a, InvisArg), (Identity a, VisArg),(a, VisArg),(Int, VisArg)] Note that, in the last case, the returned types might mention an out-of-scope type variable. This function is used only when we really care about the kinds' of the returned types, so this is OK.*Warning**: this function can return an infinite list. For example:  newtype N a = MkN (a -> N a) getRuntimeArgTys (N a) == repeat (a, VisArg) @ghcLike @ but split off only named binders and returns !s rather than s@ghcLike @, but returns only *invisible* binders, including constraints. Stops at the first visible binder.@ghcSame as @$, but stop when - you have found n +s, - or you run out of invisible binders@ghcGiven a  and a list of argument types, filter out any invisible (i.e., ! or ! ) arguments.@ghcGiven a . and a list of argument types, filter out any ! arguments.@ghcGiven a list of things paired with their visibilities, partition the things into (invisible things, visible things).@ghcGiven a + and a list of argument types to which the 5 is applied, determine each argument's visibility (!, !, or !).)Wrinkle: consider the following scenario: T :: forall k. k -> 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.@ghcGiven 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 @ comes in handy, since  f Type Bool$ would be represented in Core using <s. (See also #15792).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 !).@ghcMake an anonymous binder@ghc)Does this binder bind a variable that is not erased? Returns L for anonymous binders.@ghc)Extract a relevant type, if there is one.@ghcGiven 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)@ghcGet the type on the LHS of a coercion induced by a type/data family instance.@ghcDoes this type classify a core (unlifted) Coercion? At either role nominal or representational (t1 ~# t2) or (t1 ~R# t2) See Note [Types for coercions, predicates, and evidence] in GHC.Core.TyCo.Rep@ghcTries to compute the / of the given type. Returns either a definite , or J if we aren't sure (e.g. the type is representation-polymorphic).+Panics if the kind does not have the shape TYPE r.@ghc,Is the given type definitely unlifted? See Type#type_classification for what an unlifted type is.0Panics on representation-polymorphic types; See @ for a more approximate predicate that behaves better in the presence of representation polymorphism.@ghcState token type.@ghcReturns:I if the type is  guaranteed unlifted orL if it lifted, OR we aren't sure (e.g. in a representation-polymorphic case)@ghcReturns:I if the type is  guaranteed lifted orL if it is unlifted, OR we aren't sure (e.g. in a representation-polymorphic case)@ghcSee Type#type_classification for what a boxed type is. Panics on representation-polymorphic types; See @ for a more approximate predicate that behaves better in the presence of representation polymorphism.@ghc3Is this a type of kind RuntimeRep? (e.g. LiftedRep)@ghc+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#]@ghc 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]@ghc5Type equality on source types. Does not look through newtypes, s or type families, 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.@ghc7Compare types with respect to a (presumably) non-empty #.@ghcType equality on lists of types, looking through type synonyms but not newtypes.@ghc 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]ghcLike ?, but considers  Constraint to be distinct from 8. For a version that treats them as the same type, see ?.@ghcIs this kind equivalent to ?This considers  Constraint to be distinct from 8. For a version that treats them as the same type, see .@ghcIs this kind equivalent to TYPE (BoxedRep l) for some  l :: Levity?This considers  Constraint to be distinct from 8. For a version that treats them as the same type, see .@ghcIs this kind equivalent to TYPE r (for some unknown r)?This considers  Constraint to be distinct from *.@ghcReturns True if a type has a syntactically fixed runtime rep, as per Note [Fixed RuntimeRep] in GHC.Tc.Utils.Concrete.This function is equivalent to (A . @), but much faster. Precondition: The type has kind (TYPE blah)AghcLooking past all pi-types, does the end result have a fixed runtime rep, as per Note [Fixed RuntimeRep] in GHC.Tc.Utils.Concrete? Examples: False for %(forall r (a :: TYPE r). String -> a) True for <(forall r1 r2 (a :: TYPE r1) (b :: TYPE r2). a -> b -> Type)AghcAll type constructors occurring in the type; looking through type synonyms, but not newtypes. When it finds a Class, it returns the class TyCon.AghcRetrieve the free variables in this type, splitting them based on whether they are used visibly or invisibly. Invisible ones come first.AghcChecks that a kind of the form ,  Constraint or 'TYPE r is concrete. See A. Precondition: The type has kind (TYPE blah).AghcTests whether the given type is concrete, i.e. it whether it consists only of concrete type constructors, concrete type variables, and applications.3See Note [Concrete types] in GHC.Tc.Utils.Concrete.AghcDoes this classify a type allowed to have values? Responds True to things like *, TYPE Lifted, TYPE IntRep, TYPE v, Constraint.$True of any sub-kind of OpenTypeKindAghcDoes 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.)AghcScale a payload by ManyAghcScale a payload by OneAghc8Scale a payload by Many; used for type arguments in coreAghc isLinear t returns True of a if t is a type of (curried) function where at least one argument is linear (or otherwise non-unrestricted). We use this function to check whether it is safe to eta reduce an Id in CorePrep. It is always safe to return L , because L deactivates the optimisation.ghc"the variables bound by the synonymghcthe RHS of the synonymghc2the type arguments the synonym is instantiated at.@ghcbindersghcfree variables of result@ghcresult kindAghcShould 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)!!!!!!!!<<!!!!<<<@@@@!@@@@@@@<<<<<<<<@@@@@@@@@@@@@@@<<@@@@@@@@@@@@@@@@@@@@<<@@@@@@@@@@@@@??@@@@@@@@@@@@@@?????????<<<<<<<<<@!!!!!!@@!!!!@@@@!!<<<@=@@@@@@@@@@@@A@?????????@@@@@@@@@@@??@@@@?AAAAAA??AAA@@@A@@@@@>>>>>>>>>>>>AA?>>>>>@@@@@@@@@@@A??????????????????????????????????????????????????????????????????????????;AAA!!!!!!!!!!<<!!!<<<@@@@!!@@@@@@@<<<<<<<<@@@@@@@@@@@@@@@<<@@@@@@@@@@@@@@@@@@@@<<@@@@@@@@@@@@@??@@@@@@@@@@@@@@?????????<<<<<<<<<@!!!!!!@@!!!!@@@@!!<<<@=@@@@@@@@@@@@A@?????????@@@@@@@@@@@??@@@@?AAAAAA??AAA@@@A@@@@@>>>>>>>>>>>>AA?>>>>>@@@@@@@@@@@A??????????????????????????????????????????????????????????????????????????;AAA Safe-Inferred 6%AghcNumeric literal typeAghcBignat (see Note [BigNum literals])AghcInt# - according to target machineAghcInt8# - exactly 8 bitsAghcInt16# - exactly 16 bitsAghcInt32# - exactly 32 bitsAghcInt64# - exactly 64 bitsAghcWord# - according to target machineAghcWord8# - exactly 8 bitsAghcWord16# - exactly 16 bitsAghcWord32# - exactly 32 bitsAghcWord64# - exactly 64 bitsAghc So-called A s are one of:An unboxed numeric literal or floating-point literal which is presumed to be surrounded by appropriate constructors (Int#2, etc.), so that the overall thing makes sense.#We maintain the invariant that the ? in the A constructor is actually in the (possibly target-dependent) range. The mkLit{Int,Word}*Wrap smart constructors ensure this by applying the target machine's wrapping semantics. Use these in situations where you know the wrapping semantics are correct.The literal derived from the label mentioned in a "foreign label" declaration (A)A A3 to be used in place of values that are never used. A characterA stringThe NULL pointerAghcChar#" - at least 31 bits. Create with BAghcAny numeric literal that can be internally represented with an Integer.AghcA string-literal: stored and emitted UTF-8 encoded, we'll arrange to decode it at runtime. Also emitted with a '\0' terminator. Create with BAghcThe NULL pointer, the only pointer value that can be represented as a Literal. Create with BAghcA nonsense value of the given representation. See Note [Rubbish literals].The Type argument, rr, is of kind RuntimeRep. The type of the literal is forall (a:TYPE rr). aINVARIANT: the Type has no free variables and so substitution etc can ignore itAghcFloat#. Create with BAghcDouble#. Create with BAghcA label literal. Parameters::1) The name of the symbol mentioned in the declaration2) The size (in bytes) of the arguments the label expects. Only applicable with stdcall labels. Just x => ? will be appended to label name when emitting assembly.3) Flag indicating whether the symbol references a function or a dataAghcCoerce a literal number into another using wrapping semantics.BghcNarrow a literal number by converting it into another number type and then converting it back to its original type.Bghc>Check that a given number is in the range of a numeric literalBghcGet the literal rangeBghcCreate a numeric A of the given typeBghc Creates a A of type Int#Bghc Creates a A of type Int#. If the argument is out of the (target-dependent) range, it is wrapped. See Note [Word Int underflow overflow]Bghc Creates a A of type Int# without checking its range.Bghc Creates a A of type Int#, as well as a 9ean flag indicating overflow. That is, if the argument is out of the (target-dependent) range the argument is wrapped and the overflow flag will be set. See Note [Word Int underflow overflow]Bghc Creates a A of type Word#Bghc Creates a A of type Word#. If the argument is out of the (target-dependent) range, it is wrapped. See Note [Word Int underflow overflow]Bghc Creates a A of type Word# without checking its range.Bghc Creates a A of type Word#, as well as a 9ean flag indicating carry. That is, if the argument is out of the (target-dependent) range the argument is wrapped and the carry flag will be set. See Note [Word Int underflow overflow]Bghc Creates a A of type Int8#Bghc Creates a A of type Int8#8. If the argument is out of the range, it is wrapped.Bghc Creates a A of type Int8# without checking its range.Bghc Creates a A of type Word8#Bghc Creates a A of type Word8#8. If the argument is out of the range, it is wrapped.Bghc Creates a A of type Word8# without checking its range.Bghc Creates a A of type Int16#Bghc Creates a A of type Int16#8. If the argument is out of the range, it is wrapped.Bghc Creates a A of type Int16# without checking its range.Bghc Creates a A of type Word16#Bghc Creates a A of type Word16#8. If the argument is out of the range, it is wrapped.Bghc Creates a A of type Word16# without checking its range.Bghc Creates a A of type Int32#Bghc Creates a A of type Int32#8. If the argument is out of the range, it is wrapped.Bghc Creates a A of type Int32# without checking its range.Bghc Creates a A of type Word32#Bghc Creates a A of type Word32#8. If the argument is out of the range, it is wrapped.Bghc Creates a A of type Word32# without checking its range.Bghc Creates a A of type Int64#Bghc Creates a A of type Int64#8. If the argument is out of the range, it is wrapped.Bghc Creates a A of type Int64# without checking its range.Bghc Creates a A of type Word64#Bghc Creates a A of type Word64#8. If the argument is out of the range, it is wrapped.Bghc Creates a A of type Word64# without checking its range.Bghc Creates a A of type Float#Bghc Creates a A of type Double#Bghc Creates a A of type Char#Bghc Creates a A of type Addr#, which is appropriate for passing to e.g. some of the "error" functions in GHC.Err such as GHC.Err.runtimeErrorBghcTests whether the literal represents a zero of whatever type it isBghcTests whether the literal represents a one of whatever type it isBghc Returns the ? contained in the A', for when that makes sense, i.e. for ; and numbers.Bghc Returns the ? contained in the A', for when that makes sense, i.e. for ; and numbers.BghcApply a function to the ? contained in the A', for when that makes sense, e.g. for ; and numbers. For fixed-size integral literals, the result will be wrapped in accordance with the semantics of the target type. See Note [Word Int underflow overflow]ghc0Narrow a literal number (unchecked result range)Bghc-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.Bghc-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.BghcTrue 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.Bghc?True if code space does not go bad if we duplicate this literalBghcFind the Haskell  the literal occupiesBghcNeeded for the Ord instance of AltCon, which in turn is needed in .AAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBABBBBBABBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBABBBBBABBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB Safe-Inferred BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB1B1B1 Safe-Inferred89:CCCBCCCCCBCC Safe-Inferred)*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.eghcA SwitchPlan abstractly describes how a Switch statement ought to be implemented. See Note [createSwitchPlan]eghc>A value of type SwitchTargets contains the alternatives for a  CmmSwitch value, and knows whether the value is signed, the possible range, an optional default value and a map from values to jump labels.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.ghcMinimum non-zero offset for a jump table. See Note [Jump Table Offset].eghcThe 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 valueseghc7Changes all labels mentioned in the SwitchTargets valueeghcReturns the list of non-default branches of the SwitchTargets valueeghc3Return the default label of the SwitchTargets valueeghc+Return the range of the SwitchTargets valueeghc.Return whether this is used for a signed valueeghcswitchTargetsToTable creates a dense jump table, usable for code generation.Also returns an offset to add to the value; the list is 0-based on the result of that addition.The conversion from Integer to Int is a bit of a wart, as the actual scrutinee might be an unsigned word, but it just works, due to wrap-around arithmetic (as verified by the CmmSwitchTest test case).fghc [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.Cghc"The label of a first node or blockCghcGives control-flow successorsCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC: Safe-Inferred ; 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;Stores the arguments in a type application as a list. See &Note [Suppressing invisible arguments].CghcShow forall flag1Unconditionally show the forall quantifier with (C ) or when (C) the names used are free in the binder or when compiling with -fprint-explicit-foralls.CghcDo we want to suppress kind annotations on binders? See Note [Suppressing binder signatures]Cghc!See Note [Holes in IfaceCoercion]CghcThe various types of TyCons which have special, built-in syntax.Cghca regular tyconCghca tuple, e.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).Cghcan unboxed sum, e.g. (# a | b | c #)CghcA 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]DghcMake an C from an C.Dghc Build the :: from the binders and the result kind. Keep in sync with : in GHC.Core.TyCon.Dghc?Given a kind K, is K of the form (TYPE ('BoxedRep 'LiftedRep))?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.Dghc Extract an   from an C.Dghc"Extract the variable name from an C.Dghc Extract an   from an C.Dghc"Extract the variable name from an C.ghcDefault : variables to :,  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, Levity 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.ghcThe type 'Lifted :: Levity'.Dghc The type 'Many :: Multiplicity'.DghcLike D, but always uses an explicit forall.Dghc;Render the "forall ... ." or "forall ... ->" bit of a type.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  pprTyTcApp')Coercions (from D)ghcPretty-print an unboxed sum type. The sum should be saturated: as many visible arguments as the arity of the sum.)NB: this always strips off the invisible : arguments, even with `-fprint-explicit-runtime-reps` and `-fprint-explicit-kinds`.ghcPretty-print a tuple type (boxed tuple, constraint tuple, unboxed tuple). The tuple should be saturated: as many visible arguments as the arity of the tuple.)NB: this always strips off the invisible : arguments, even with `-fprint-explicit-runtime-reps` and `-fprint-explicit-kinds`.DghcPrints "(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 -> aDghcPrints a context or ()- if empty You give it the context precedenceghcif printing coercionsghc otherwiseghcdefault :/ variables?ghcdefault  Multiplicity variables?ghc*visibility of the first binder in the listCC CCCCCCCCCCCC CCCCCCCCCCCCCCCCCCCCCCCCCCCC CCCCCCCDCCCCC CCC CCC CCCCCCCCCCC!!!!!!CCCDDDDDDCDDDDDCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDCC CCCCCCCCCCCC CCCCCCCCCCCCCCCCCCCCCCCCCCCC CCCCCCCDCCCCC CCC CCC CCCCCCCCCCC!!!!!!!!CCCDDDDDDCDDDDDCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDN Safe-InferredBJEghcPrint a user-level forall; see Note [When to print foralls] in GHC.Iface.Type.EghcdebugPprType 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.Eghc#Display all kind information (with -fprint-explicit-kinds) when the provided 9 argument is L. See 'Note [Kind arguments in error messages] in  GHC.Tc.Errors.EghcThis variant preserves any use of TYPE in a type, effectively locally setting -fprint-explicit-runtime-reps.EghcPretty 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 #DDDDEEEEEEEEEEEDEEEEEE#DDDDEEEEEEEEEEEDEEEEEE Safe-Inferred68GGghcTrie of [RoughMatchTc] Examples*  insert [OtherTc] 1 insert [OtherTc] 2 lookup [OtherTc] == [1,2] Gghc/The position only matches the specified KnownTcGghc1The position definitely doesn't match any KnownTcGghcThe position can match anythingGghc!Order of result is deterministic.GghcN.B. Returns a & for matches, which allows us to avoid rebuilding all of the lists we find in ,, which would otherwise be necessary due to  if we returned a list. We use a list for unifiers becuase the tail is computed lazily and we often only care about the first couple of potential unifiers. Constructing a bag forces the tail which performs much too much work.>See Note [Matching a RoughMap] See Note [Matches vs Unifiers]ghcPlace a G# in normal form, turning all empty s into "s. Necessary after removing items.GghcFilter all elements that might match a particular key with the given predicate.GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG Safe-InferredK4 EghcPattern SynonymSee Note [Pattern synonym representation] See Note [Pattern synonym signature contexts]ghcArgument typesEghcBuild a new pattern synonymEghcThe  of the E+, giving it a unique, rooted identificationEghc Should the E be presented infix?EghcArity of the pattern synonymEghcIs this a 'vanilla' pattern synonym (no existentials, no provided constraints)?Eghc5Extract the type for any given labelled field of the DataConEghcPrint the type of a pattern synonym. The foralls are printed explicitlyEghc&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 synonymEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE Safe-InferredMEghcmkMultSup w1 w2" returns a multiplicity such that mkMultSup w1 w2 >= w1 and mkMultSup w1 w2 >= w2.. See Note [Overapproximating multiplicities].Eghc 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.??EEEE<< x) ~ (b -> y).%ghcMake 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]%ghcApply 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.%ghcApply a type constructor to a list of coercions. It is the caller's responsibility to get the roles correct on argument coercions.%ghcMake a reflexive coercionEghc9The result of stepping in a normalisation function. See F.EghcNothing more to doEghc2Utter failure. The outer function should fail too.EghcWe stepped, yielding new bits; ^ ev is evidence; Usually a co :: old type ~ new typeEghcA function to check if we can reduce a type by one step. Used with F.EghcTests if this MCoercion is obviously generalized reflexive Guaranteed to work very quickly.Eghc'Compose two MCoercions via transitivityEghcGet the reverse of an EghcCast a type by an EghcLike F, but with an EghcThis 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]Eghc2Attempts to obtain the type variable underlying a EghcAttempts to tease a coercion apart into a type constructor and the application of a number of coercion arguments to that constructorEghc-Attempt to take a coercion application apart.EghcLike E(, but only returns Just for tyvar binderEghcLike E(, but only returns Just for covar binderghcGiven a coercion &co1 :: (a :: TYPE r1) ~ (b :: TYPE r2), produce a coercion rep_co :: r1 ~ r2.EghcReturns the type coerced if this coercion is a generalized reflexive coercion. Guaranteed to work very quickly.EghcReturns 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. EEghcExtracts the coerced type from a reflexive coercion. This potentially walks over the entire coercion, so avoid doing this in a loop.Eghc*Make a representational reflexive coercionEghcApplies multiple  s to another  , from left to right. See also %.ghcLike %, but the inner coercion shouldn't be an obvious reflexive coercion. For example, it is guaranteed in E. The kind of the tycovar should be the left-hand kind of the kind coercion.EghcMake nested ForAllCosEghcMake a Coercion quantified over a type/coercion variable; the variable has the same type in both sides of the coercionghcLike E, but the inner coercion shouldn't be an obvious reflexive coercion. For example, it is guaranteed in E.EghcExtract 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.)EghcReturn the left-hand type of the axiom, when the axiom is instantiated at the types given.Eghc5Instantiate the left-hand side of an unbranched axiomEghc$Make a coercion from a coercion holeEghc Extract the nth field of a FunCoEghcIf you're about to call mkNthCo r n co, then r should be whatever nthCoRole n co returns.FghcGiven ty :: k1,  co :: k1 ~ k2 , produces co' :: ty ~r (ty |> co)FghcGiven ty :: k1,  co :: k1 ~ k2 , produces co' :: (ty |> co) ~r tyFghcGiven 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.FghcGiven 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.ghcChanges a role, but only a downgrade. See Note [Role twiddling functions]FghcLike , but panics if the change isn't a downgrade. See Note [Role twiddling functions]FghcConverts a coercion to be nominal, if possible. See Note [Role twiddling functions]Fghclike mkKindCo, but aggressively & recursively optimizes to avoid using a KindCo constructor. The output role is nominal.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 FghcCreates 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.FghccastCoercionKind1 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]FghcCreates 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.FghcGiven 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. @FghcMake a forall , where both types related by the coercion are quantified over the same variable.FghcIf `instNewTyCon_maybe T ts = Just (rep_ty, co)` then `co :: T ts ~R# rep_ty`-Checks for a newtype, and for being saturatedFghcTry 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 satisfiedFghcA E that unwraps newtypes, careful not to fall into a loop. If it would fall into a loop, it produces E.FghcA general function for normalising the top-level of a type. It continues to use the provided E until that function fails, and then this function returns. The roles of the coercions produced by the E must all be the same, which is the role returned from the call to F.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 happenFghcSyntactic equality of coercionsFghc Compare two s, with respect to an RnEnv2Fghc,Extend a lifting context with a new mapping.FghcExtend a lifting context with a new mapping, and extend the in-scope setghcExtend a lifting context with existential-variable bindings. See Note [extendLiftingContextEx]Fghc+Erase the environments in a lifting contextFghcLike ? , but works on a lifting contextghcThe "lifting" operation which substitutes coercions for type variables in a type to produce a coercion.For the inverse operation, see  liftCoMatchFghc,Is a var in the domain of a lifting context?Fghc"Apply "sym" to all coercions in a EFghc;Extract the underlying substitution from the LiftingContextFghcGet the # from a %FghcApply % to multiple sFghcGet a coercion's kind and role.Fghc"Retrieve the role from a coercion.FghcCreates a primitive type equality predicate. Invariant: the types are not CoercionsFghc3Makes a lifted equality predicate at the given roleFghc?Creates a primitive type equality predicate with explicit kindsFghcCreates a primitive representational type equality predicate with explicit kindsFghcAssuming 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.Fghc&Is there a coercion hole in this type?Fghc*Is there a coercion hole in this coercion?FghcSet the type of a < %ghc!role of the created coercion, "r"ghc:: phi1 ~N phi2ghc g1 :: phi1ghc g2 :: phi2ghc :: g1 ~r g2%ghcrole of the built coercion, "r"ghct1 :: k1ghct2 :: k2ghc :: t1 ~r t2%ghc :: t1 ~r t2ghc%:: s1 ~N s2, where s1 :: k1, s2 :: k2ghc:: t1 s1 ~r t2 s2Eghc"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 nominalFghc original LCghcnew variable to map...ghc...to this lifted versionFghc Original LCghcnew variable to map...ghcto this coercionghcoriginal lifting contextghcex. var / value pairsFghccoercion getterghccallbackghccoercion getterghccallbackghccoercion getterghccallback<<<<<<<<<<<!$$$$FEEEE%%%%%%%FFF%%E%%EEEEEEEFFF%%%EE%%%E%%F%EE%E%%%%F%FFFF%FFFFFFFFFFFEEEEEFFF%FEE%EEEEEEEFFFF%%EE%EEEEEEEEEEEEEEEEE!!EEEE>>>>>><>>??????????%FFFFFFFFFFFFFE%EFFFFFFFFF%EEEEEEE??FFEFFFF<<<<<<<<<<<!$$$$FEEEE%%%%%%%FFF%%E%%EEEEEEEFFF%%%EE%%%E%%F%EE%E%%%%F%FFFF%FFFFFFFFFFFEEEEEFFF%FEE%EEEEEEEFFFF%%EE%EEEEEEEEEEEEEEEEE!!EEEE>>>>>><>>??????????%FFFFFFFFFFFFFE%EFFFFFFFFF%EEEEEEE??FFEFFFF Safe-Inferred? Fghc>A choice of equality relation. This is separate from the type $ because $3 does not define a (non-trivial) equality relation.FghcA predicate in the solver. The solver tries to prove Wanted predicates from Given ones.FghcA typeclass predicate.FghcA type equality predicate.FghcAn irreducible predicate.FghcA quantified predicate. sym kco )Fghc Create a F from a pair of a  and a 'Type.Pre-condition: the RHS type of the coercion matches the provided type (perhaps up to zonking).Use F! when you only have the coercion.Fghc4Get the original, unreduced type corresponding to a F.This is obtained by computing the LHS kind of the stored coercion, which may be slow.FghcTurn a  into a F- by inspecting the RHS type of the coercion. Prefer using F when you already know the RHS type of the coercion, to avoid computing it anew.Fghc1Downgrade the role of the coercion stored in the F.Fghc1Downgrade the role of the coercion stored in the F, from $ to $.Fghc0Compose a reduction with a coercion on the left.Pre-condition: the provided coercion's RHS type must match the LHS type of the coercion that is stored in the reduction.FghcThe reflexive reduction.Fghc Create a F from a kind cast, in which the casted type is the rewritten type.Given ty :: k1, mco :: k1 ~ k2, produces the F ty ~res_co~> (ty |> mco) at the given $.Fghc Create a F from a kind cast, in which the casted type is the rewritten type.Given ty :: k1, mco :: k1 ~ k2, produces the F ty ~res_co~> (ty |> mco) at the given $.Fghc Create a F from a kind cast, in which the casted type is the original (non-rewritten) type.Given ty :: k1, mco :: k1 ~ k2, produces the F (ty |> mco) ~res_co~> ty at the given $.Fghc Create a F from a kind cast, in which the casted type is the original (non-rewritten) type.Given ty :: k1, mco :: k1 ~ k2, produces the F (ty |> mco) ~res_co~> ty at the given $.Fghc Apply a cast to the result of a F.Given a F ty1 ~co1~> (ty2 :: k2) and a kind coercion kco with LHS kind k2, produce a new F ty1 ~co2~> ( ty2 |> kco ) of the given $; (which must match the role of the coercion stored in the F argument).Fghc Apply a cast to the result of a F , using an .Given a F ty1 ~co1~> (ty2 :: k2) and a kind coercion mco with LHS kind k2, produce a new F ty1 ~co2~> ( ty2 |> mco ) of the given $; (which must match the role of the coercion stored in the F argument).GghcApply a cast to a F1, casting both the original and the reduced type.Given cast_co and F  ty ~co~> xi, this function returns the F ,(ty |> cast_co) ~return_co~> (xi |> cast_co) of the given $; (which must match the role of the coercion stored in the F argument).Pre-condition: the  passed in is the same as the LHS type of the coercion stored in the F.GghcApply casts on both sides of a F (of the given $).Use G when you want to cast both the original and reduced types in a F using the same coercion.Pre-condition: the  passed in is the same as the LHS type of the coercion stored in the F.Gghc Apply one F to another. Combines % and .GghcCreate a function F. Combines % and <.Gghc Create a F& associated to a  type, from a kind F and a body F. Combines % and .Gghc Create a F of a quantified type from a F of the body. Combines E and <.Gghc Create a F# from a coercion between coercions. Combines % and @.GghcCreate a reflexive F whose RHS is the given , with the specified $.GghcCreate F. from individual lists of coercions and types.The lists should be of the same length, and the RHS type of each coercion should match the specified type in the other list.Gghc Combines E and @.Gghc TyConAppCo for F s: combines % and .GghcReduce the arguments of a 9 .GghcObtain F from a list of Fs by unzipping.Fghcheterogeneous reductionghc kind coercionFghc desired roleghc current roleGghc original typeghccoercion to cast withghc'rewritten type, with rewriting coercionGghc original typeghc!coercion to cast with on the leftghc'rewritten type, with rewriting coercionghc"coercion to cast with on the rightGghcmultiplicity reductionghcargument reductionghcresult reductionGghckind reductionghcbody reductionGghc!role of the created coercion, "r"ghcco :: phi1 ~N phi2ghc g1 :: phi1ghc g2 :: phi2ghcres_co :: g1 ~r g2)FFFFFFFFFFFGFFFFFFFFGGFFFFFGGGGGGGGGFGFFG)FFFFFFFFFFFGFFFFFFFFGGFFFFFGGGGGGGGGFGFFG Safe-Inferred ZGghcA G is a G which allows us to distinguish between binding forms whose binders have different types. For example, if we are doing a B lookup on (x :: Int) -> ()), we should not pick up an entry in the B 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.Gghc DeBruijn a represents a modulo alpha-renaming. This is achieved by equipping the value with a G, 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.GghcA G 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.Gghc 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.ghc!An equality relation between two s (known below as t1 :: k2 and t2 :: k2)ghc t1 /= t2ghct1 ~ t2? and there are not casts in either, therefore we can conclude k1 ~ k2ghct1 ~ t2 yet one of the types contains a cast so they may differ in kindghc TypeMapX a is the base map from  DeBruijn Type to a, but without the B optimization. See Note [Computing equality on types] in GHC.Core.Type.Gghc 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 G inside another B, 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.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).Gghc Extend a G$ 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.GghcConstruct a deBruijn environment with the given variables in scope. e.g. mkDeBruijnEnv [a,b,c] constructs a context  forall a b c.GghcSynthesizes a  DeBruijn a from an a9, by assuming that there are no bound binders (an empty G<). This is usually what you want if there isn't already a G in scope.(BBBBBBBBBGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG(BBBBBBBBBGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG Safe-Inferred8΢GghcA regular type variableGghc#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.GghcWhy are two types G? G takes precedence: This is used (only) in Note [Infinitary substitution in lookup] in GHC.Core.InstEnv As of Feb 2022, we never differentiate between MARTypeFamily and MARTypeVsConstraint; it's really only MARInfinite that's interesting here.Gghcmatching e.g. F Int ~? BoolGghcmatching e.g. a ~? Maybe aGghcmatching Type ~? Constraint See Note [coreView vs tcView] in GHC.Core.TypeGghcSee Note [Unification result]Gghc2Some unification functions are parameterised by a G, which says whether or not to allow a certain unification to take place. A G 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 <.GghctcMatchTy 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 @ 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]GghcLike G, but allows the kinds of the types to differ, and thus matches them as well. See also Note [tcMatchTy vs tcMatchTyKi]GghcThis is similar to G, but extends a substitution See also Note [tcMatchTy vs tcMatchTyKi]GghcLike G but over a list of types. See also Note [tcMatchTy vs tcMatchTyKi]GghcLike G but over a list of types. See also Note [tcMatchTy vs tcMatchTyKi]GghcLike G, but extending a substitution See also Note [tcMatchTy vs tcMatchTyKi]GghcLike G, but extending a substitution See also Note [tcMatchTy vs tcMatchTyKi]ghc=Same as tc_match_tys_x, but starts with an empty substitutionghc Worker for G and GGghcThis one is called from the expression matcher, which already has a MatchEnv in handGghcAllow 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) Gghc-Allow the binding of any variable to any typeGghcGiven a list of pairs of types, are any two members of a pair surely apart, even after arbitrary type function evaluation and substitution?GghcSimple unification of two types; all type variables are bindable Precondition: the kinds are already equalGghcLike G, but also unifies the kindsGghcUnify two types, treating type family applications as possibly unifying with anything and looking through injective type family applications. Precondition: kinds are the sameGghcLike G but also unifies the kindsGghctcUnifyTysFG bind_tv tys1 tys2! attempts to find a substitution s% (whose domain elements all respond G 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.ghcThis function is actually the one to call the unifier -- a little too general for outside clients, though.ghc(Converts any SurelyApart to a MaybeApartGghcG is sort of inverse to %. In particular, if  liftCoMatch vars ty co == Just s, then liftCoSubst s ty == co , where == there means that the result of % 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 @. That is, it's possible that this will succeed for t1 and fail for t2, even when t1 @ 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.ghc does all the actual work for G. GghcSubstitution to extendghcTemplateghcTargetGghcTemplateghcTargetghcOne-shot; in principle the template variables could be free in the targetGghcTemplateghcTargetghcOne-shot substitutionGghcSubstitution to extendghcTemplateghcTargetghcOne-shot substitutionGghcSubstitution to extendghcTemplateghcTargetghcOne-shot substitutionghc match kinds?ghc match kinds?Gghctemplate variablesghctype substitution to extendghcTemplateghcTargetGghcTrue  =" do two-way unification; False  =: do one-way matching. See end of sec 5.2 from the paperGghcA regular one-shot (idempotent) substitution that unifies the erased types. See comments for GghcTrue  = unify; False  = matchghcTrue  = doing an injectivity checkghcTrue  = treat the kinds as wellghcsubstitution to extendghcambient helpful infoghcincoming substghcty, type to matchghc+co :: lty ~r rty, coercion to match againstghc :: kind(lsubst(ty)) ~N kind(lty)ghc :: kind(rsubst(ty)) ~N kind(rty)ghcJust env ==> liftCoSubst Nominal env ty == co, modulo roles. Also: Just env ==> lsubst(ty) == lty and rsubst(ty) == rty, where lsubst = lcSubstLeft(env) and rsubst = lcSubstRight(env))GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG)GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG Safe-Inferred )*8ځ ghc1a monad for the normalisation functions, reading N, a %, and a $.Nghc;Result of testing two type family equations for injectiviy.NghcEither RHSs are distinct or unification of RHSs leads to unification of LHSsNghcRHSs 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.Oghc Create a N from  indices. INVARIANTS: * The fs_tvs are distinct in each FamInst of a range value of the map (so we can safely unify them)Oghc/Makes no particular effort to detect conflicts.OghcCheck whether two type family axioms don't violate injectivity annotation.OghcCreate a coercion constructor (axiom) suitable for the given newtype . The % should be that of a new coercion $, 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.OghcCheck 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).OghcDo an apartness check, as described in the "Closed Type Families" paper (POPL '14). This should be used when determining if an equation ($) of a closed type family can be used to reduce a certain target type family application.OghcGet 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.OghcTry to simplify a type-family application, by *one* step If topReduceTyFamApp_maybe env r F tys = Just (HetReduction (Reduction co rhs) res_co) then co :: F tys ~R# rhs res_co :: typeKind(F tys) ~ typeKind(rhs) Type families and data families; always Representational roleOghc 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 fire;NNNNNNNNNNNNNNNNNNNNNONNOOOOOOOOOOOOOONNNNNOOOOONNNOOOOOOOO;NNNNNNNNNNNNNNNNNNNNNONNOOOOOOOOOOOOOONNNNNOOOOONNNOOOOOOOOm Safe-Inferred6qghcAn  is a tyvar/type pair representing an equality made in rejigging a GADT constructorghcData Constructor Representation See Note [Data constructor workers and wrappers]ghcA data constructor : , ,ghcReturns an Id which looks like the Haskell-source constructor by using the wrapper if it exists (see H') and failing over to the worker (see )ghcThe "full signature" of the  returns, in order:1) The result of H2) 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 ghcThe "stupid theta" of the  , such as  data Eq a in: data Eq a => T a = ...See Note [The stupid context].ghcReturns just the instantiated value argument types of a , (excluding dictionary args)ghc-The labels for the fields of this particular ghc*Source-level arity of the data constructorghcs for the type variables of the constructor, in the order the user wrote themghcThe type variables of the constructor, in the order the user wrote themghcThe existentially-quantified type/coercion variables of the constructor including dependent (kind-) GADT equalitiesghcThe type constructor that we are building via this data constructorghcGet 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 ghcThe  of the +, giving it a unique, rooted identificationHghcSource Unpackedness$What unpackedness the user requestedHghc{-# UNPACK #-} specifiedHghc{-# NOUNPACK #-} specifiedHghcno unpack pragmaHghcSource Strictness)What strictness annotation the user wroteHghc Lazy, ie CHghc Strict, ie !Hghcno strictness annotationHghcHaskell Implementation BangBangs of data constructor arguments as generated by the compiler after consulting HsSrcBang, flags, etc.Hghc(Lazy field, or one with an unlifted typeHghcStrict but not unpacked fieldHghc;Strict and unpacked field co :: arg-ty ~ product-ty HsBangHghcHaskell 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)ghcTag, used for ordering sHghcMake a non-dependent HghcSubstitute 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.HghcFilter out any s mentioned in an .HghcCompare strictness annotationsHghcBuild a new data constructorHghcThe tag used for ordering sHghcThe 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.HghcThe representation type of the data constructor, i.e. the sort type that will represent values of this type at runtimeHghc Should the  be presented infix?Hghc 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.HghcFinds 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 typeHghcGiven a data constructor dc with n( universally quantified type variables a_{1}, a_{2}, ..., a_{n}&, and given a list of argument types dc_args of length m where m <= n, then: dataConInstUnivs dc dc_args  Will return: ?[dc_arg_{1}, dc_arg_{2}, ..., dc_arg_{m}, a_{m+1}, ..., a_{n}] ;That is, return the list of universal type variables with a_{1}, a_{2}, ..., a_{m} instantiated with  dc_arg_{1},  dc_arg_{2}, ...,  dc_arg_{m}. It is possible for m to be less than n, in which case the remaining n - m elements will simply be universal type variables (with their kinds possibly instantiated). Examples:Given the data constructor D :: forall a b. Foo a b and dc_args  [Int, Bool], then dataConInstUnivs D dc_args will return  [Int, Bool].Given the data constructor D :: forall a b. Foo a b and dc_args [Int], then @dataConInstUnivs D dc_args will return [Int, b].Given the data constructor E :: forall k (a :: k). Bar k a and dc_args [Type], then @dataConInstUnivs D dc_args will return [Type, (a :: Type)].This is primarily used in GHC.Tc.Deriv.* in service of instantiating data constructors' field types. See 2Note [Instantiating field types in stock deriving] for a notable example of this.HghcReturns the argument types of the wrapper, excluding all dictionary arguments and without substituting for any type variablesHghcReturns constraints in the wrapper type, other than those in the dataConEqSpecHghcReturns the arg types of the worker, including *all* non-dependent evidence, after any flattening has been done and without substituting for any type variablesHghc The string package:module.name identifying a constructor, which is attached to its info table and used by the GHCi debugger and the heap profilerHghcVanilla 8s are those that are nice boring Haskell 98 constructorsHghc Is this the  of a newtype?HghcShould this DataCon be allowed in a type even without -XDataKinds? Currently, only Lifted & UnliftedHghcWere the type variables of the data con written in a different order than the regular order (universal tyvars followed by existential tyvars)?This is not a cheap test, so we minimize its use in GHC as much as possible. Currently, its only call site in the GHC codebase is in  mkDataConRep in MkId , and so H is only called at most once during a data constructor's lifetime.HghcExtract 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.Hghc"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 IdghcRepresentationHghcA 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 typesHghcA product type, perhapsHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH Safe-Inferred7JghcGets rid of the stuff that prevents us from understanding the runtime representation of a type. Including: 1. Casts 2. Newtypes 3. Foralls 4. Synonyms But not type/data families, because we don't have the envs to hand.JghcGive the demands on the arguments of a Core constructor application (Con dc args) at runtime. Assumes the constructor is not levity polymorphic. For example unboxed tuples won't work.Jghc True if the type has zero width.JghcGiven the arguments of a sum type constructor application, return the unboxed sum rep type.E.g.+(# Int# | Maybe Int | (# Int#, Float# #) #)We call `ubxSumRepType [ [IntRep], [LiftedRep], [IntRep, FloatRep] ]`, which returns [WordSlot, PtrSlot, WordSlot, FloatSlot]INVARIANT: Result slots are sorted (via Ord SlotTy), except that at the head of the list we have the slot for the tag.ghcReturns the bigger type if one fits into the other. (commutative)Note that lifted and unlifted pointers are *not* in a fits-in relation for the reasons described in Note [Don't merge lifted and unlifted slots] in GHC.Stg.Unarise.Jghc,Discovers the primitive representation of a . Returns a list of :: it's a list because of the possibility of no runtime representation (void) or multiple (unboxed tuple/sum) See also Note [Getting from RuntimeRep to PrimRep]Jghc,Discovers the primitive representation of a . Returns a list of :: it's a list because of the possibility of no runtime representation (void) or multiple (unboxed tuple/sum) See also Note [Getting from RuntimeRep to PrimRep] Returns Nothing if rep can't be determined. Eg. levity polymorphic types.JghcLike J*, but assumes that there is precisely one : output; an empty list of PrimReps becomes a VoidRep. This assumption holds after unarise, see Note [Post-unarisation invariants]. Before unarise it may or may not hold. See also Note [RuntimeRep and PrimRep] and Note [VoidRep]Jghc%Find the runtime representation of a . Defined here to avoid module loops. Returns a list of the register shapes necessary. See also Note [Getting from RuntimeRep to PrimRep]JghcLike J3, but assumed that there is precisely zero or one : output See also Note [Getting from RuntimeRep to PrimRep] and Note [VoidRep]ghcTake a kind (of shape TYPE rr) and produce the :s of values of types of this kind. See also Note [Getting from RuntimeRep to PrimRep]JghcTake a kind (of shape TYPE rr) and produce the :s of values of types of this kind. See also Note [Getting from RuntimeRep to PrimRep] Returns Nothing if rep can't be determined. Eg. levity polymorphic types.Jghc7Take a type of kind RuntimeRep and extract the list of : that it encodes. See also Note [Getting from RuntimeRep to PrimRep] The [PrimRep] is the final runtime representation after unarisationJghc7Take a type of kind RuntimeRep and extract the list of : that it encodes. See also Note [Getting from RuntimeRep to PrimRep] The [PrimRep] is the final runtime representation after unarisation Returns Nothing if rep can't be determined. Eg. levity polymorphic types.ghc Convert a : to a  of kind RuntimeRepJghcConvert a PrimRep back to a Type. Used only in the unariser to give types to fresh Ids. Really, only the type's representation matters. See also Note [RuntimeRep and PrimRep]1JJJJJJJJJ::::::::::::::::::JJJJJJJJJJJJJJJJJJJJJJ1JJJJJJJJJ::::::::::::::::::JJJJJJJJJJJJJJJJJJJJJJ Safe-Inferred ([HghcA demand transformer> is a monotone function from an incoming evaluation context (I) to a H, describing how the denoted thing (i.e. expression, function) uses its arguments and free variables, and whether it diverges.See Note [Understanding DmdType and DmdSig] and Note [What are demand signatures?].HghcThe depth of the wrapped H encodes the arity at which it is safe to unleash. Better construct this through I.. See Note [Understanding DmdType and DmdSig]HghcCharacterises how an expressionEvaluates its free variables (H)Evaluates its arguments (H)$Diverges on every code path or not (H)Equality is defined modulo s in H#. See Note [Demand type Equality].Hghc-Demand on explicitly-mentioned free variablesHghcDemand on argumentsHghc?Whether evaluation diverges. See Note [Demand type Divergence]HghcH 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.Hghc5Definitely throws an imprecise exception or diverges.HghcDefinitely throws a *precise* exception, an imprecise exception or diverges. Never converges, hence I! See scenario 1 in Note [Precise exceptions and strictness analysis].Hghc7Might diverge, throw any kind of exception or converge.IghcA sub-demand describes an evaluation context5, e.g. how deep the denoted thing is evaluated. See I for examples. The nested I 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 Is dn of a I  P(d1,d2,...) apply  absolutely: If dn is a used once demand (cf. I), then that means that the denoted sub-expression is used once in the entire evaluation context described by the surrounding I. 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]. See also Note [Why Boxity in SubDemand and not in Demand?].IghcPolymorphic demand, the denoted thing is evaluated arbitrarily deep, with the specified cardinality at every level. The  applies only to the outer evaluation context as well as all inner evaluation context. See Note [Boxity in Poly] for why we want it to carry . Expands to  via  and to I via I.Poly b n is semantically equivalent to  Prod b [n :* Poly b n, ...] or Call n (Poly Boxed n)@.  and I do these rewrites.In Note [Demand notation]: L === P(L,L,...) and  L === CL(L), B === P(B,B,...) and  B === CB(B), !A === !P(A,A,...) and  !A === !CA(A)(, and so on.We'll only see I with I (B), I (A), I (L) and sometimes I (S) through I, never I (M) or I$ (1) (grep the source code). Hence I, which is closed under lub and plus.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, see Note [Call demands are relative]. That Note also explains why it doesn't make sense for n( to be absent, hence we forbid it with I3. Absent call demands can still be expressed with I. Used only for values of function type. Use the smart constructor  whenever possible!Ighc Prod b ds describes the evaluation context of a case scrutinisation on an expression of product type, where the product components are evaluated according to ds. The  b6 says whether or not the box of the product was used.IghcA 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 I7inality. The "how deep" component is represented by a I+. 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).s 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 I, but it's scaled by I, which is an interval on  Multiplicity, the upper bound of which could be used to infer uniqueness types. Also we treat I and I specially, as the concept of a I doesn't apply when there isn't any evaluation at all. If you don't care, simply use I.Ighc6A bottoming demand, produced by a diverging function (I), hence there is no I% that describes how it was evaluated.Ighc-An absent demand: Evaluated exactly 0 times (I), hence there is no I% that describes how it was evaluated.ghc.Don't use this internal data constructor; use I# instead. Since BotDmd deals with I and AbsDmd deals with I*, the cardinality component is CardNonAbsIghc A subtype of I* for which the upper bound is never 1 (no I or I!). The only four inhabitants are I, I, I, I!. Membership can be tested with . See I for use sites and explanation.Ighc A subtype of I* for which the upper bound is never 0 (no I or I!). The only four inhabitants are I, I, I, I!. Membership can be tested with . See  and  for use sites and explanation.IghcDescribes an interval of evaluation cardinalities. See Note [Evaluation cardinalities] See Note [Bit vector representation for Card]Ighcc :* sd" is a demand that says "evaluated c times, and each time it was evaluated, it was at least as deep as sd".Matching on this pattern synonym is a complete match. If the matched demand was I, it will match as C_00 :* seqSubDmd. If the matched demand was I, it will match as C_10 :* botSubDmd.. The builder of this pattern synonym simply discards the I if the I was absent and returns I or I< instead. It will assert that the discarded sub-demand was  and , respectively.Call sites should consider whether they really want to look at the I" of an absent demand and match on I and/or I otherwise. Really, any other I? would be allowed and might work better, depending on context.IghcEvery possible cardinality; the top element, {0,1,n}. Pretty-printed as L.IghcStrict and used (possibly) many times, {1,n}. Pretty-printed as S.Ighc.Used at most once, {0,1}. Pretty-printed as M.Ighc/Strict and used once, {1}. Pretty-printed as 1.Ighc Bottom, {}. Pretty-printed as A.Ighc!Absent, {0}. Pretty-printed as A.IghcTrue  = lower bound is 1.IghcTrue  = upper bound is 0.IghcTrue  = upper bound is 1.ghc Is this a I?ghc Is this a I?IghcIntersect with [0,1].IghcDenotes D on I.IghcDenotes n on lower and upper bounds of I.IghcDenotes o on lower and upper bounds of I.ghc3Only meant to be used in the pattern synonym below!ghc(The uniform field demand when viewing a I as a I , as in I.IghcA smart constructor for I6, applying rewrite rules along the semantic equality ,Prod b [n :* Poly Boxed n, ...] === Poly b n, simplifying to I Is when possible. Examples: Rewrites P(L,L) (e.g., arguments Boxed, [L,L]) to L Rewrites  !P(L!L,L!L) (e.g., arguments Unboxed,  [L!L,L!L]) to !LDoes not rewrite P(1L), P(L!L), !P(L) or P(L,A)Ighc viewProd n sd interprets sd as a I of arity n , expanding I demands as necessary.ghcA smart constructor for 6, applying rewrite rules along the semantic equality Call n (Poly n) === Poly n, simplifying to I Is when possible.ghc viewCall sd interprets sd as a  , expanding I subdemands as necessary.ghcSets  to  for non- sub-demands and recurses into I.IghcSets  to  for the I, recursing into Is.IghcDenotes D on I.IghcDenotes D on I.IghcDenotes n on I.IghcDenotes n on I.Ighc;Used to suppress pretty-printing of an uninformative demandIghc8Contrast with isStrictUsedDmd. See Note [Strict demands]Ighc7Not absent and used strictly. See Note [Strict demands]IghcIs the value used at most once?IghcWe 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.IghcFirst argument of 'GHC.Exts.maskAsyncExceptions#': 1C1(L). Called exactly once.IghcFirst argument of 'GHC.Exts.atomically#': SCS(L)-. Called at least once, possibly many times.IghcFirst argument of catch#: MCM(L). Evaluates its arg lazily, but then applies it exactly once to one argument.IghcSecond argument of catch#:  MCM(C1(L)). Calls its arg lazily, but then applies it exactly once to an additional argument.IghcMake a I evaluated at-most-once.IghcMake a I' evaluated at-least-once (e.g. strict).IghcIf 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.IghcMake a I) lazy, setting all lower bounds (outside s) to 0.ghcMake a I) lazy, setting all lower bounds (outside s) to 0.Ighc Wraps the I with a one-shot call demand: d -> C1(d).IghcmkCalledOnceDmds n d returns C1(C1...(C1 d)) where there are n C1's.IghcPeels one call level from the sub-demand, and also returns how many times we entered the lambda body.Ighc"See Note [Computing one-shot info]Ighc"See Note [Computing one-shot info]Ighc(saturatedByOneShots n CM(CM(...)) = True  = There are at least n nested CM(..) calls. See Note [Demand on the worker] in GHC.Core.Opt.WorkWrapghc6See 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.Ighc True if the H indicates that evaluation will not return. See Note [Dead ends].IghckeepAliveDmdType 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.Ighc%Compute the least upper bound of two H*s elicited /by the same incoming demand/!IghcThe 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.ghcThe demand type of an unspecified expression that is guaranteed to throw a (precise or imprecise) exception or diverge.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 .ghc)A conservative approximation for a given H in case of an arity decrease. Currently, it's just nopDmdType.IghcWhen 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 (I9) and boxed in all free variables and arguments * has I H> result See Note [Precise exceptions and strictness analysis]#So we can simply take a variant of I,  . Why not I? Because then the result of e can never be I4! That means failure to drop dead-ends, see #18086.IghcSee I.IghcTurns a H computed for the particular  into a H unleashable at that arity. See Note [Understanding DmdType and DmdSig].IghcTrue if the signature diverges or throws an exception in a saturated call. See Note [Dead ends].Ighc9True when the signature indicates all arguments are boxedIghcReturns true if an application to n value args would diverge or throw an exception.If a function having I 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].Ighc Add extra (I7) arguments to a strictness signature. In contrast to I, this prepends8 additional argument demands. This is used by FloatOut.IghcWe 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 I, this appends extra arg demands if necessary. This works by looking at the H (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.Ighc Extrapolate a demand signature (H ) into a H.Given a function's H and a I for the evaluation context, return how the function evaluates its free variables and arguments.Ighc A special H for data constructors that feeds product demands into the constructor arguments.Ighc A special H for dictionary selectors that feeds the demand on the result into the indicated dictionary component (if saturated). See Note [Demand transformer for a dictionary selector].Ighc1Remove the demand environment from the signature.Ighc#Remove all `C_01 :*` info (but not CM sub-demands) from the demandIghc#Remove all `C_01 :*` info (but not CM. sub-demands) from the strictness signatureIghcDrop all boxityIghcSee Note [Demand notation] Current syntax was discussed in #19016.IghcSee Note [Demand notation]IghcSee Note [Demand notation]Ighc)We have to respect Poly rewrites through  and I.Ighc See Note [Demand type Equality].Ighcdepending on saturationIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIHIIIHHHHIIIIIHHHHHIIIIIIHIIIIIIIIHHIIIIIIIIIIIIIHIIIHHHHIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIHIIIHHHHIIIIIHHHHHIIIIIIHIIIIIIIIHHIIIIIIIIIIIIIHIIIHHHHIIIIIIIIII Safe-Inferred (d JghcThe arity of the wrapped J is the arity at which it is safe to unleash. See Note [Understanding DmdType and DmdSig] in GHC.Types.DemandJghcThe result of J.JghcThe abstract domain A_t+ from the original 'CPR for Haskell' paper.JghcNumber of value arguments the denoted expression eats before returning the JJghcJ) eventually unleashed when applied to J argumentsghc The number of field Cprs equals H&. If all of them are top, better use %, as ensured by the pattern synonym J.ghcFlatConCpr tag is an efficient encoding for  tag [TopCpr..]5. Purely for compiler perf. Can be constructed with J.Jghc Unpacks a J-shaped J and returns the field Js wrapped in a J. Otherwise, it returns J with the appropriate J to assume for each field. The use of J( allows O(1) space for the common, non-J case.JghcTurns a J computed for the particular  into a J unleashable at that arity. See Note [Understanding DmdType and DmdSig] in GHC.Types.DemandJghcBNF: cpr ::= '' -- TopCpr | n -- FlatConCpr n | n '(' cpr1 ',' cpr2 ',' ... ')' -- ConCpr n [cpr1,cpr2,...] | 'b' -- BotCpr*Examples: * `f x = f x` has result CPR b" * `1(1,)` is a valid (nested) J! denotation for `(I# 42#, f 42)`.JghcBNF: cpr_ty ::= cpr -- short form if arty == 0 | '\' arty '.' cpr -- if arty > 0Examples: * `f x y z = f x y z` has denotation `3.b` * `g !x = (x+1, x+2)` has denotation `1.1(1,1)`.JghcOnly print the CPR resultJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJ Safe-InferrediJghcStandardFormInfo tells whether this thunk has one of a small number of standard formsJghcInformation 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.Jghc9Maps names in the current module to their LambdaFormInfosJghcCodegen-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.JghcExported Non-CAFFY closures in the current module. Everything else is either not exported of CAFFY.Jghc;LambdaFormInfos of exported closures in the current module.Jghc,The C stub which is used for IPE informationJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJ Safe-Inferredq_RghcA constructor-like thingRghcIs this a 'vanilla' constructor-like thing (no existentials, no provided constraints)?RghcNumber of argumentsRghc"Names of fields used for selectorsRghcReturns just the instantiated value argument types of a R, (excluding dictionary args)Rghc! s for the type variables of the R. 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.Rghc0Existentially quantified type/coercion variablesRghcThe "stupid theta" of the R , such as  data Eq a in: data Eq a => T a = ...It is empty for R* as they do not allow such contexts. See Note [The stupid context] in GHC.Core.DataCon.RghcR returns True except for uni-directional pattern synonyms, which have no builderRghc7Returns the strictness information for each constructorRghc%Returns the type of the whole patternRghcThe "full signature" of the R 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 typeRghc5Extract the type for any given labelled field of the RRghc-The ConLikes that have *all* the given fieldsRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR Safe-Inferredr\ghcA list of conlikes which represents a complete pattern match. These arise from COMPLETE signatures. See also Note [Implementation of COMPLETE pragmas].\ghc The set of R values\ghc6The optional, concrete result TyCon the set applies to\\\\\\\\\\\\\\@ Safe-Inferred )*/156y? ghcSee 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.ghc*Maps the "normal" id type for a given passghcThe trivial wrapper that carries no additional information See Note [XRec and SrcSpans in the AST]ghc4We can map over the underlying type contained in an XRec( while preserving the annotation as is.ghcWe can strip off the XRec to access the underlying data. See Note [XRec and SrcSpans in the AST]ghcGHC'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]ghcA placeholder type for TTG extension points that are not currently unused to represent any particular value.!This should not be confused with ', which are found in unused extension  constructors8 and therefore should never be inhabited. In contrast,  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.ghc=Used when constructing a term with an unused extension point.ghc Eliminate a &. See Note [Constructor cannot occur]. Safe-Inferred156"AghcGoverns 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.AghcPlace 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. NB: We generally try to move these as close to the relevant runtime expression as possible. This means they get pushed through tyoe arguments. E.g. we create `(tick f) Bool` instead of `tick (f Bool)`.AghcAs  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.AghcIn 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.AghcSpecifies 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.AghcNo 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 obligationsAghcSoft 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.AghcCost 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.AghcAn  {-# SCC #-} profiling annotation, either automatically added by the desugarer as a result of -auto-all, or added by the user.AghcA "tick" used by HPC to track the execution of each subexpression in the original source code.AghcA 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)AghcA 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.Aghcthe cost centreAghcbump the entry count?Aghc;scopes over the enclosed expression (i.e. not just a tick)Aghcthe 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.AghcSource coveredAghc4Name for source location (uses same names as CCs)Aghc)Tickish in Cmm context (annotations only)ghc;Allows attaching extra information to points in expressionsUsed as a data type index for the GenTickish annotations. See Note [Tickish passes]AghcA "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.Aghc/Returns the intended scoping rule for a TickishAghcReturns whether the tick scoping rule is at least as permissive as the given scoping rule.AghcReturns 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.AghcReturns True" for a tick that is both counting and> scoping and can be split into its (tick, scope) parts using A and mkNoTick respectively.AghcReturn 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.Aghc)Placement behaviour we want for the ticksAghcReturns whether one tick "contains" the other one, therefore making the second tick redundant.ghc6Keep track of the type of breakpoints in STG, for GHCi&AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA&AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA Safe-Inferred '67JghcA clone of the K0 type but allowing annotation at every tree nodeJghcA clone of the K0 type but allowing annotation at every tree nodeJghcA clone of the K0 type but allowing annotation at every tree nodeJghc;Annotated core: allows annotation at every node in the treeJghc Binders are tagged with a tJghc$Case alternatives where binders are JsJghc!Binding groups where binders are JsJghc'Argument expressions where binders are JsJghcExpressions where binders are JsJghcThe common case for the type of binders and variables when we are manipulating the Core language within GHCJghcJ& says when unfolding should take placeKghc 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.UnfoldKghc+We have no information about the unfolding.Kghc: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.Kghc%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.Kghc;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 templateKghcThe # in the K is a superset of variables that are currently in scope. See Note [The InScopeSet invariant].Kghc Rule optionsKghcTarget platformKghc-Enable more advanced numeric constant foldingKghcCut down precision of Rational values to that of Float/Double if disabledKghcEnable rules for bignumsKghcA K 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 itselfKghcBuilt-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.)Kghc1Name of the rule, for communication with the userKghcWhen the rule is activeKghc Name of the F at the head of this ruleKghc7Name at the head of each argument to the left hand sideKghcVariables quantified overKghcLeft hand side argumentsKghcRight hand side of the rule Occurrence info is guaranteed correct See Note [OccInfo in unfoldings and rules]KghcTrue  = 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.Kghc  the rule was defined in, used to test if we should see an orphan rule.Kghc%Whether or not the rule is an orphan.KghcTrue 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 K, 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.KghcNumber of arguments that K1 consumes, if it fires, including type argumentsKghcThis function does the rewrite. It given too many arguments, it simply discards them; the returned J is just the rewrite of K applied to the first K argsKghc?A full rule environment which we can apply rules from. Like a K, 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...)KghcGathers a collection of Ks. Maps (the name of) an  to its rulesKghcIs this instance an orphan? If it is not an orphan, contains an  ? witnessing the instance's non-orphanhood. See Note [Orphans]KghcBinding, used for top level bindings in a module and local bindings in a let.Kghc3A case alternative constructor (i.e. pattern match)Kghc A literal: case e of { 1 -> ... } Invariant: always an *unlifted* literal See Note [Literal alternatives]KghcTrivial alternative: case e of { _ -> ... }KghcA case split alternative. Consists of the constructor leading to the alternative, the variables bound from the constructor, and the expression to be executed given that binding. The default alternative is (DEFAULT, [], rhs)KghcType synonym for expressions that occur in function argument positions. Only K should contain a K at top level, general K should notKghcThis 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 C 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 F as it's names.Finally the syntax tree is  desugared from the expressive  type into this K 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 K. See Note [Core let/app invariant] See Note [Representation polymorphism invariants]Lambda abstraction See Note [Representation 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 [Representation 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 K* 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 K 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 coercionKghcReturns true if K is orphan.KghcReturns true if K is not an orphan.KghcThe number of arguments the K4 must be applied to before the rule can match on itKghcThe  of the F' at the head of the rule left hand sideKghcSet the  of the F' at the head of the rule left hand sideKghcThere is no known KKghc body) == (x -> f body)LghcAttempt to remove the last N arguments of a function call. Strip off any ticks or coercions encountered along the way and any at the end.LghcLike  collectArgs, but also collects looks through floatable ticks if it means that we can find more arguments.Lghc$Will this variable exist at runtime?Lghc/Will this argument expression exist at runtime?LghcReturns True for value arguments, false for type args NB: coercions are value arguments (zero width, to be sure, like State#, but still value args).LghcReturns True iff the expression is a K or K expression at its top levelLghcReturns True iff the expression is a K expression at its top levelLghcReturns True iff the expression is a K; expression at its top level. Note this does NOT include Ks.Lghc8The number of binders that bind values rather than typesLghcThe number of argument expressions that are values rather than types at their top levelLghcTakes a nested application expression and returns the function being applied and the arguments to which it is appliedLghcAs L but for J rather than KLghcAs L but for J rather than KKKKKKKKKKKKKKKKKKKKKKJJJJJJJJJJJJL!KKKKKKK!K!!!KKKKKKK!K!!KLLLLLLLLLLLLLLLLLLLLLLLLLLLLL!LLLLLLLLLLLLLLLLLLLLLLLLLKKKKKKKKKKKKKKKKKJJJJKKKKKKKKKKKKKKKKKKKLKKKKKLKLLLLLLLLKJJJJJJJJJJJJJJJJJLLLLLLLLKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKJJJJJJJJJJJJL!KKKKKKK!K!!!KKKKKKK!K!!KLLLLLLLLLLLLLLLLLLLLLLLLLLLLL!LLLLLLLLLLLLLLLLLLLLLLLLLKKKKKKKKKKKKKKKKKJJJJKKKKKKKKKKKKKKKKKKKLKKKKKLKLLLLLLLLKJJJJJJJJJJJJJJJJJLLLLLLLLKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK4L4L4L4L4? Safe-Inferred5ghcIdentifier 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 L, L, L and M.!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.ghc Check if an  says L.ghcJust a synonym for L. Written separately so it can be exported in the hs-boot file.ghcBasic . that carries no useful information whatsoeverLghcTick box for Hpc-style coverageLghc%Constant applicative form InformationRecords whether an Id+ makes Constant Applicative Form referencesLghcIndicates that the Id is for either: A function or static constructor that refers to one or more CAFs, orA real live CAFLghc9A function or static constructor that refers to no CAFs.LghcRule Information$Records the specializations of this Id, that we know about in the form of rewrite Ks that target themLghcInline 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 L is , so the info serves entirely as a way to inhibit inlining until we want itLghcArity InformationAn L 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. Invariant: the  of an Id must never exceed the number of value arguments that appear in the type of the Id'. See Note [Arity and function types].ghcEncodes 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 infoLghcSpecialisations of the Ids function which exist. See Note [Specialisations and RULES in IdInfo]LghcThe Id s unfoldingLghc"Any inline pragma attached to the IdLghcHow the Id occurs in the programLghcA strictness signature. Digests how a function uses its arguments if applied to at least L arguments.LghcInformation on whether the function will ultimately return a freshly allocated constructor.LghcID demand informationghcBitfield 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.LghcRecursive Selector ParentLghcThe Id for a record selectorLghcThe Id is for a data constructor workerLghcThe Id is for a data constructor wrapperLghcThe Id9 is a superclass selector, or class operation of a classLghcThe Id is for a primitive operatorLghcThe Id is for a foreign call. Type will be simple: no type families, newtypes, etcLghcThe Id4 is for a HPC tick box (both traditional and binary)Lghc$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 dictionaryLghc&A coercion variable This only covers  un-lifted coercions, of type (t1 ~# t2) or (t1 ~R# t2), not their lifted variantsLghcAn Id< for a join point taking n arguments Note [Join points] in GHC.Core+ Can also work as a WorkerLikeId if given s. See Note [CBV Function Ids] The [CbvMark] is always empty (and ignored) until after Tidy.LghcAn Id for a worker like function, which might expect some arguments to be passed both evaluated and tagged. Worker like functions are create by W/W and SpecConstr and we can expect that they aren't used unapplied. See Note [CBV Function Ids] See Note [Tag Inference] The [CbvMark] is always empty (and ignored) until after Tidy for ids from the current module.LghcWhen applied, will this Id ever have a representation-polymorphic type?Lghc+Info about a lambda-bound variable, if the Id is oneLghcId 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.MghcId CAF infoMghcHow 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 argumentsMghcEssentially returns the L field, but does not expose the unfolding of a strong loop breaker.This is the right thing to call if you plan to decide whether an unfolding will inline.Mghc True of a non-loop-breaker Id that has a stable; unfolding that is (a) always inlined; that is, with an J guidance, or (b) a DFunUnfolding which never needs to be inlinedMghcMore informative  we can use when we know the Id has no CAF referencesMghc$It is always safe to assume that an Id has an arity of 0Mghc1Assume that no specializations exist: always safeMghcRetrieve the locally-defined free variables of both the left and right hand sides of the specialization rulesMghcChange the name of the function the rule is keyed on all of the KsghcAssumes that the Id$ has CAF references: definitely safeMghcThis 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) arg1MghcRemove all demand info on the Mghc.Remove usage (but not strictness) info on the MghcRemove usage environment info from the strictness signature on the Mghc'Zap info that depends on free variablesghcZaps any core unfolding, but  preserves/ evaluated-ness, i.e. an unfolding of OtherConMghcMarks an IdInfo describing an Id that is never representation-polymorphic (even when applied). The Type is only there for checking that it's really never representation-polymorphic.LLLLLLLLLLLLLLLLLLLLLLLLLLLMLMMMMMMMMMMLMLMMMMMMMMMMMLMMLLMMMMMMMLLLMMMMJMMLLLLLMMMLLLLLLLLLLLLLLLLLLMLMMMMMMMMMMLMLMMMMLMLMLMMLMMMLLMLMLLMMMMMLMMLLLMMMMJLMMLLLLLLMMM M1M1M1M1M1M1M1M1M1M1M1M1F Safe-Inferred #MghcLike M, but skips non-Ids. Useful for scaling a mixed list of ids and tyvars.MghcNot only does this set the  ;, it also evaluates the type to try and reduce space usageMghc'For an explanation of global vs. local s, see GHC.Types.Var.Var#globalvslocalMghcMake a global % without any extra information at allMghcMake a global - with no global information but some generic Mghc'For an explanation of global vs. local s, see GHC.Types.Var#globalvslocalMghcMake a local CoVarMghcLike M6, but checks the type to see if it should make a covarMghcCreate a local  that is marked as exported. This prevents things attached to it from being removed as dead code. See Note [Exported LocalIds]MghcCreate a system local . These are local s (see Var#globalvslocal3) that are created by the compiler out of thin airMghcLike M+, but checks to see if we have a covar typeMghcCreate a user local . These are local s (see GHC.Types.Var#globalvslocal8) with a name and location that the user might recognizeMghcLike M', but checks if we have a coercion typeMghcWorkers get local names. CoreTidy$ will externalise these if necessaryMghc Create a template local: a family of system local s in bijection with Ints, typically used in unfoldingsMghc-Create a template local for a series of typesMghcCreate a template local for a series of type, but start from a specified template localMghcIf the , is that for a record selector, extract the L. Panic otherwise.MghcAn Id for which we might require all callers to pass strict arguments properly tagged + evaluated.See Note [CBV Function Ids]MghcDoesn't return strictness marksMghc*Get from either the worker or the wrapper  to the '. Currently used only in the desugarer. INVARIANT: idDataCon (dataConWrapId d) = d : remember, , can return either the wrapper or the workerMghcReturns True of an  which may not have a binding, even though it is defined in this module.MghcM tells whether an s info is implied by other declarations, so we don't need to put its signature in an interface file, even if it's mentioned in some other interface unfolding.MghcReturns true if an application to n args diverges or throws an exception See Note [Dead ends] in GHC.Types.Demand.Mghc Accesses the Id's L.Mghc This predicate says whether the  has a strict demand placed on it or has a type such that it can always be evaluated strictly (i.e an unlifted type, as of GHC 7.6). We need to check separately whether the  has a so-called "strict type" because if the demand for the given id hasn't been computed yet but id# has a strict type, we still want  isStrictId id to be True.Nghc Returns the s unfolding, but does not expose the unfolding of a strong loop breaker. See M.?If you really want the unfolding of a strong loopbreaker, call N.NghcExpose the unfolding if there is one, including for loop breakersNghc5If all marks are NotMarkedStrict we just set nothing.Nghc2Remove any cbv marks on arguments from a given Id.Nghc-Turn this id into a WorkerLikeId if possible.Nghc:Similar to trimUnfolding, but also removes evaldness info.NghcLike N, but taking the Horrible State Hack in to account See Note [The state-transformer hack] in GHC.Core.Opt.ArityNghc/Returns whether the lambda associated with the  is certainly applied at most once This one is the "business end", called externally. It works on type variables as well as Ids, returning True Its main purpose is to encapsulate the Horrible State Hack See Note [The state-transformer hack] in GHC.Core.Opt.ArityNghc1Should we apply the state hack to values of this ?!!!!!MMMMMMMMMMMMMMMMMMMMMMMM!!MMMMM!!!!MM!MMMMMNNNNNNNMNNMMMMM!!!MMMMMMMMMMMMMMMMMNMMMM!MMMMMMNNNNNNNNNNNNNNNMMMNNNNNNNNNNNNNNMMNNNNNNMMNNNNNNMMNN!!!!!MMMMMMMMMMMMMMMMMMMMMMMM!!MMMMM!!!!MM!MMMMMNNNNNNNMNNMMMMM!!!MMMMMMMMMMMMMMMMMNMMMM!MMMMMMNNNNNNNNNNNNNNNMMMNNNNNNNNNNNNNNMMNNNNNNMMNNNNNNMMNNM1M1M1M1M1M1N1N1N1N1N1N1N1N1N1H Safe-Inferred  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 .RghcClass 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 RghcDetermine 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!RghcReturns 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.RghctyThingParent_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.RghcThe Names that a TyThing should bring into scope. Used to build the GlobalRdrEnv for the InteractiveContext.RghcGet the  from a 4 if it is a type constructor thing. Panics otherwiseRghcGet the $ from a 2 if it is a coercion axiom thing. Panics otherwiseRghcGet the  from a 4 if it is a data constructor thing. Panics otherwiseRghcGet the R from a 5 if it is a data constructor thing. Panics otherwiseRghcGet the  from a < if it is a id *or* data constructor thing. Panics otherwiseRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR Safe-Inferred \ghc A map from s to s, constructed by typechecking local declarations or interface files\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\ Safe-Inferred !- 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.ghc  emptySubst =  #ghcConstructs a new % assuming the variables in the given # are 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)ghcSubstitutes an occurrence of an identifier for its counterpart recorded in the .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.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.   Safe-Inferred #jSghcEssentially a GlobalRdrEnv, but with additional cached values to allow efficient re-calculation when the imports change. Fields are strict to avoid space leaks (see T4029) All operations are in GHC.Runtime.Context. See Note [icReaderEnv recalculation]SghcThe final environmentSghc:Just the things defined at the prompt (excluding imports!)Sghc stepping modeSghcfilename (for errors)Sghcline number (for errors))SSSSSSSSSSSSSSSSSSRRSSSSSSSSSSSSSSSSSSSSS)SSSSSSSSSSSSSSSSSSRRSSSSSSSSSSSSSSSSSSSSS Safe-Inferred $ghccomplete bipartite graphghccomplete graphghc Resolves all 0, by pushing them in, and simplifies `D D @ = @`ghcShallow empty check.NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNn Safe-Inferred" 0ghc'Type constructor for n-ary unboxed sum.ghc=Data constructor for i-th alternative of a n-ary unboxed sum.ghcSpecialization of  for tuplesghc "type LiftedRep = 'BoxedRep 'Liftedghc &type UnliftedRep = 'BoxedRep 'Unliftedghc .type UnliftedType = TYPE ('BoxedRep 'Unlifted)ghcBuild the type of a small tuple that holds the specified type of thing Flattens 1-tuples. See Note [One-tuples].SghcMake a fake, recovery  from an existing one. Used when recovering from errors in type declarationsSghcBuilt-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(,,,)).SghcIf the given name is that of a constraint tuple, return its arity.ghcCached 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.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.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.SghcSpecialization of  for sumsghcCreate type constructor and data constructors for n-ary unboxed sum.ghc@type ZeroBitRep = 'Tuple '[]Tghc,Make a tuple type. The list of types should not include any RuntimeRep specifications. Boxed 1-tuples are flattened. See Note [One-tuples]Tghc,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.MakeTghcMake a *promoted* list.ghcExtract the elements of a promoted list. Panics if the type is not a promoted listTghc>Replaces constraint tuple names with corresponding boxed ones.ghcdeclared infix?ghc datacon nameghc univ tyvarsghc ex tycovarsghcuser-written tycovarsghcargsTghcof the elements of the listghcelementsghcThe promoted listSSSSTTSSTTSTTSTTTTTTTTTTTTSSSSSSSTTTSTTTSSSSSSSSSSSSSSSS,TS.STSTTTTTSTSTSTSTTSTTTTTTSSSSSSSSSSSSSSTSSSSSSSSSTS;SSSSSSSSSSSSSSSSSSSSSSSSSTTTTTTTTTTTTTTSSSSTTSSTTSTTSTTTTTTTTTTTTSSSSSSSTTTSTTTSSSSSSSSSSSSSSSS,TS.STSTTTTTSTSTSTSTTSTTTTTTSSSSSSSSSSSSSSTSSSSSSSSSTS;SSSSSSSSSSSSSSSSSSSSSSSSSTTTTTTTTTTTTTT Safe-Inferred 7>eghcPer-module cache of original  s given seghcThe 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.eghc-Update the name cache with the given functioneghc-Update the name cache with the given functionAdditionally, it ensures that the given Module and OccName are evaluated. If not, chaos can ensue: we read the name-cache then pull on mod (say) which does some stuff that modifies the name cache This did happen, with tycon_mod in GHC.IfaceToCore.tcIfaceAlt (DataAlt..) eeeeeeeeeeee eeeeeeeeeeee9 Safe-Inferred 8YghcTrue 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.Yghc Returns the * of the wrapper associated with the given  . See Note [Primop wrappers]. YTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYTTTTYYZYYYYYYYYYYYYYYZZTTTTT YTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYTTTTYYZYYYYYYYYYYYYYYZZTTTTT Safe-Inferred H Zghc Header information only, not rhsZghc,Show only some sub-components. Specifically, []Print all sub-components.(n:ns)Print sub-component n with  ShowSub = ns!; elide other sub-components to ...6 May 14: the list is max 1 element long at the momentZghcEverything including GHC-internal information (used in --show-iface)ZghcIface type for LambdaFormInfo. Fields not relevant for imported Ids are omitted in this type.ZghcThis corresponds to HsSrcBangZghcThis corresponds to an HsImplBang; that is, the final implementation decision about the data constructor arg[ghcName of associated axiom and branches for pretty printing purposes, or J for an empty closed family without an axiom See Note [Pretty printing via Iface syntax] in GHC.Types.TyThing.Ppr[ghcA binding top-level , in an interface file (e.g. the name of an [).[ghcPretty Print an IfaceExprThe first argument should be a function that adds parens in context that need an atomic value (e.g. function args)!!!!!!CC CCCCCCCCCCCC CCCCCCCCCCCCCCCCCCCCCCCCCCCC CCCCCCCCCCCC CCC CCC CCCCCCCCCCCCCCCCCCCCDDDDDDDCDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[ZZZZZZZZZZZ[[[[[[ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ[[[[[[[ZZZZZZZHHHHHHHH[[[[[[[[[[[[ZZZZZZZZ[[[[[[[[[[[ZZZZZZZZZZ[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[ZZZZZZZZZZZ[[[[[[ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ[[[[[[[ZZZZZZZHHHHHHHH[[[[[[[[[[[[ZZZZZZZZ[[[[[[[[[[[ZZZZZZZZZZ[[3 Safe-Inferred MfghcA 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 NNghcEvaluate all the fields of the - that are generally demanded by the compilerNNNNNNNNNNNNNN Safe-Inferred  P;ghc?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 resultffffffffffffffffffffffffffff Safe-Inferred'/16 WzghcSTG pretty-printing optionszghcEnable cost-centres{ghc,Used as a data type index for the stgSyn AST{ghc)Use internally by the lambda lifting pass{ghcTag inference information on binders. See Note [Tag inference passes] in GHC.Stg.InferTags{ghcTag inference information put on relevant StgApp nodes See Note [Tag inference passes] in GHC.Stg.InferTags{ghcWhen `-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.{ghcLike , but with an   instance that returns  .{ghcA top-level binding.{ghcDoes this constructor application refer to anything in a different *Windows* DLL? If so, we can't allocate it statically{ghc Type of an StgArg8Very half baked because we have lost the type arguments.{ghcGiven 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].{ghcUsed when constructing a term with an unused extension point that should not appear in pretty-printed output at all.{ghc3STG pretty-printing options used for panic messages{ghc3STG pretty-printing options used for short messagesghc,Code gen needs to track non-global free vars{ghc ([Alt b], Maybe (Expr b))əghc3Strip ticks of a given type from an STG expression.ʙghcStrip ticks of a given type from an STG expression returning only the expression. ÙęřƙǙəʙș™ ÙęřƙǙəʙș™ Safe-Inferred Z˙˙ Safe-Inferred)*/1 [ۙghcSimple convert env to a env of the 'InferTaggedBinders pass with no other changes.י֙ՙԙәҙΙљϙЙܙڙؙٙۙݙޙߙ5666666666י֙ՙԙәҙΙљϙЙܙڙؙٙۙݙޙߙ Safe-Inferred)*1 ]ghcCompute the argument with the given set of ids treated as requiring capture as free variables.ghcCompute the argument with the given id treated as requiring capture as free variables in closures.ghcOriginal argumentsghc&var args to be evaluated ahead of timeghcFunction that reconstructs the expressions when passed the list of evaluated arguments. Safe-Inferred fvghcLocalFVs: set of variable that are: (a) bound locally (by a lambda, non-top-level let, or case); that is, it appears in the  field of 1 (b) appear free in the expression It is a  deterministic set because it is used to annotate closures with their free variables, and we want closure layout to be deterministic.4Invariant: the LocalFVs returned is a subset of the  field of EnvghcTopFVs: set of variables that are: (a) bound at the top level of this module, and (b) appear free in the expression It is a non-deterministic set because we use it only to perform dependency analysis on the top-level bindings.ghcSet of locally-bound, not-top-level binders in scope. That is, variables bound by a let (but not let-no-escape), a lambda (in a StgRhsClsoure), a case binder, or a case alternative. These are the variables that must be captured in a function closure, if they are free in the RHS. Example f = x. let g = y. x+1 let h = z. g z + 1 in h x In the body of h we have locals = {x, g, z}. Note that f is top level and does not appear in locals.ghcDependency sort a STG program, and annotate it with free variables The returned bindings: * Are in dependency order * Each StgRhsClosure is correctly annotated (in its extension field) with the free variables needed in the closure * Each StgCase is correctly annotated (in its extension field) with the variables that must be saved across the caseghc!Dependency analysis on STG terms.Dependencies of a binding are just free variables in the binding. This includes imported ids and ids in the current module. For recursive groups we just return one set of free variables which is just the union of dependencies of all bindings in the group.Implementation: pass bound variables (NestedIds) to recursive calls, get free variables (TopFVs) back. We ignore imported TopFVs as they do not change the ordering but it improves performance (see nameIsExternalFrom call in vars_fvs).h Safe-Inferred  ghc< is an abstract type that supports the following operations:Pretty printingIn a C file, does it need to be declared before use? (i.e. is it guaranteed to be already in scope in the places we need to refer to it?)If it needs to be declared, what type (code or data) should it be declared to have?.Is it visible outside this object file or not?#Is it "dynamic" (see details below)Eq and Ord, so that we can make sets of CLabels (currently only used in outputting C as far as I can tell, to avoid generating more than one declaration for any given label).3Converting an info table label into an entry label.CLabel usage is a bit messy in GHC as they are used in a number of different contexts:!By the C-- AST to identify labelsBy the unregisterised C code generator ("PprC") for naming functions (hence the name )9By the native and LLVM code generators to identify labelsFor extra fun, each of these uses a slightly different subset of constructors (e.g.  and / are used only in the NCG and LLVM backends).In general, we use  to represent Haskell things early in the pipeline. However, later optimization passes will often represent blocks they create with  where there is no obvious  to hang off the label.ighcInfo Table Provenance Entry See Note [Mapping Info Tables to Source Positions]ghcWhat type of Cmm label we're dealing with. Determines the suffix appended to the name when a CLabel.CmmLabel is pretty printed.ghc'misc rts info tables, suffix _infoghc(misc rts entry points, suffix _entryghc'misc rts ret info tables, suffix _infoghc&misc rts return points, suffix _retghc'misc rts data bits, eg CHARLIKE_closureghc misc rts codeghcclosures eg CHARLIKE_closureghc)a prim call to some hand written Cmm codeghcSelector thunksghc AP thunksghc_fast versions of generic applyighc=Which module is the info table from, and which number was it.ghcLabel for closureghc*Info tables for closures; always read-onlyghc Entry pointghcSlow entry pointghc)Like InfoTable but not externally visibleghc%Like Entry but not externally visibleghc7Label of place to keep Ticky-ticky hit info for this IdghcConstructor entry point, when `-fdistinct-info-tables` is enabled then each usage of a constructor will be given a unique number and a fresh info table will be created in the module where the constructor is used. The argument is used to keep track of which info table a usage of a constructor should use. When the argument is J then it uses the info table which is defined in the module where the datatype is declared, this is the usual case. When it is (Just (m, k)) it will use the kth info table defined in module m. The point of this inefficiency is so that you can work out where allocations of data constructors are coming from when you are debugging.ghcCorresponding info tableghc!Table of closures for Enum tyconsghc5Content of a string literal. See Note [Bytes label].ghcLike LocalInfoTable but for a proc-point block instead of a closure entry-point. See Note [Proc-point local block entry-points].ghcUsed for dynamic allocationsghc,Used to track dynamic hits of tag inference.ighc'Record where a foreign label is stored.ighcLabel is in a named packageighcLabel is in some external, system package that doesn't also contain compiled Haskell code, and is not associated with any .hi files. We don't have to worry about Haskell code being inlined from external packages. It is safe to treat the RTS package as "external".ighcLabel is in the package currently being compiled. This is only used for creating hacky tmp labels during code generation. Don't use it in any code that might be inlined across a package boundary (ie, core code) else the information will be wrong relative to the destination module.ighc Indicate if  GHC.CmmToC has to generate an extern declaration for the label (e.g. "extern StgWordArray(foo)"). The type is fixed to StgWordArray.Symbols from the RTS don't need "extern" declarations because they are exposed via "rtsinclude&Stg.h" with the appropriate type. See j.The fixed StgWordArray type led to "conflicting types" issues with user provided Cmm files (not in the RTS) that declare data of another type (#15467 and test for #17920). Hence the Cmm parser considers that labels in data sections don't need the "extern" declaration (just add one explicitly if you need it).See  https://gitlab.haskell.org/ghc/ghc/-/wikis/commentary/compiler/backends/ppr-c#prototypes/ for why extern declaration are needed at all.ghcA label related to the definition of a particular Id or Con in a .hs file.ghcA label from a .cmm file that is not associated with a .hs level Id.ghcA label with a baked-in / algorithmically generated name that definitely comes from the RTS. The code for it must compile into libHSrts.a / libHSrts.so If it doesn't have an algorithmically generated name then use a CmmLabel instead and give it an appropriate UnitId argument.ghcA label associated with a block. These aren't visible outside of the compilation unit in which they are defined. These are generally used to name blocks produced by Cmm-to-Cmm passes and the native code generator, where we don't have a 4 to associate the label to and therefore can't use .ghcA C (or otherwise foreign) label.ghcLocal temporary label used for native (or LLVM) code generation; must not appear outside of these contexts. Use primarily for debug informationghcA label "derived" from another  by the addition of a suffix. Must not occur outside of the NCG or LLVM code generators.ghcA per-module metadata label.ghcThese labels are generated and used inside the NCG only. They are special variants of a label used for dynamic linking see module GHC.CmmToAsm.PIC for details.ghcThis label is generated and used inside the NCG only. It is used as a base for PIC calculations on some platforms. It takes the form of a local numeric assembler label '1'; and is pretty-printed as 1b, referring to the previous definition of 1: in the assembler source file.ghcA label before an info table to prevent excessive dead-stripping on darwinghc"Per-module table of tick locationsghcStatic reference tableghc"A bitmap (function or case return)ighcFor debugging problems with the CLabel representation. We can't make a Show instance for CLabel because lots of its components don't have instances. The regular Outputable instance only shows the label name, and not its other info.ighcDecicdes between external and local labels based on the names externality.ighcMake a foreign labelighc-Update the label size field in a ForeignLabelighc+Whether label is a top-level string literalighc8Whether label is a non-haskell label (defined in C code)ighcWhether label is a static closure label (can come from haskell or cmm)ighc Whether label is a .rodata labelighc2Whether label is points to some kind of info tableighc1Whether label is points to constructor info tableighc,Get the label size field from a ForeignLabeljghc*A label indicating the end of a procedure.jghcConstruct a label for a DWARF Debug Information Entity (DIE) describing another symbol.jghc7If a label is a local block label then return just its C , otherwise J.jghcCheck whether a label corresponds to a C function that has a prototype in a system header somewhere, or is built-in to the C compiler. For these labels we avoid generating our own C prototypes.jghcIs a CLabel visible outside this object file or not? From the point of view of the code generator, a name is externally visible if it has to be declared as exported in the .o file's symbol table; that is, made non-static.ghcWork out the general type of data at the address of this label whether it be code, data, or static GC object.jghcIs a . defined in the current module being compiled?Sometimes we can optimise references within a compilation unit in ways that we couldn't for inter-module references. This provides a conservative estimate of whether a  lives in the current module.jghcDoes a  need dynamic linkage?When referring to data in code, we need to know whether that data resides in a DLL or not. [Win32 only.]  labelDynamic returns True if the label is located in a DLL, be it a data reference or not.jghc;Generate a label for a procedure internal to a module (if Opt_ExposeAllSymbols/ is enabled). See Note [Internal proc labels].jghcDon't depend on this if you need determinism. No determinism in the ncg backend, so we use the unique for Ord. Even if it pains me slightly.ghcencodes the suffix of the labelghc"what package the label belongs to.ghc.does the label need an "extern .." declarationghc)identifier giving the prefix of the labelghcencodes the suffix of the labelghcname of the imported label.ghc possible '9n' suffix for stdcall functions When generating C, the 'n' suffix is omitted, but when generating assembler we must add it to the label.ghc%what package the foreign label is in.ghcsuffixjghcthe current moduleghcthe internal proc labeliiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiijjjjiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiijjjjjjjjjjiiiijjiiiijjjj ijiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiijjjjiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiijjjjjjjjjjiiiijjiiiijjjj ijiii Safe-Inferred dmghcA map storing all the different uses of a specific data constructor and the approximate source position that usage arose from. The > is an incrementing identifier which distinguishes each usage of a constructor in a module. It is paired with the source position the constructor was used at, if possible and a string which names the source location. This is the same information as is the payload for the  constructor.mghc A map from a ? to the best approximate source position that name arose from.mghcPosition and information about an info table. For return frames these are the contents of a . mmmmmmmmm mmmmmmmmm Safe-Inferred ghc3Try to find the best source position surrounding a {. 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  Safe-Inferred CCjjjCCjjj Safe-Inferred aghcCommon 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.ghcGet 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.ghcApply a given mapping to all the register references in this instruction.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.ghcGive the possible destinations of this jump instruction. Must be defined for all jumpish instructions.ghcChange the destination of this jump instruction. Used in the linear allocator when adding fixup blocks for join points.ghc5An instruction to spill a register into a spill slot.ghc6An instruction to reload a register from a spill slot.ghc?See if this instruction is telling us the current C stack deltaghcCheck 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.ghcCopy the value in a register to another one. Must work for all register classes.ghcTake the source and destination from this reg -> reg move instruction or Nothing if it's not oneghcMake 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.ghcPretty-print an instructionghcHolds 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).ghcNo regs read or written to.ghcthe reg to spillghcthe current stack deltaghcspill slot to useghc instructionsghcthe reg to reload.ghcthe current stack deltaghcthe spill slot to useghc instructionsghcsource registerghcdestination register Safe-Inferred  jghcSets of registersjghc'Parameters: 1. Identifier 2. TypejghcA stack area is either the stack slot where a variable is spilled or the stack space where function arguments and results are passed.jghcReturns an alignment in bytes of a CmmExpr when it's a statically known integer constant, otherwise returns an alignment of 1 byte. The caller is responsible for using with a sensible CmmExpr argument.jjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjkkkkkkkkkkkkkjjjjjjjkkjjjjjjjkkkkkjkjjj]^^^^^^^^^^^^^^^^^^^^^^^^^^^]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]\]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]\\\\\\\\\\\\\\\^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^0000000000000001111111111111000001111111111111111111111111111111111111jjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjkkkkkkkkkkkkkjjjjjjjkkjjjjjjjkkkkkjkjjj Safe-Inferred llllllllllll Safe-Inferred llllllllllll Safe-Inferred cllllllllll Safe-Inferred llllllllll Safe-Inferred llllllllll Safe-Inferred 2llllllllll Safe-Inferred wllllllllll Safe-Inferred llllllllll Safe-Inferred lghcReturns L if this global register is stored in a caller-saves machine register.lghcHere 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.llllllllll Safe-Inferred   Safe-Inferred)* B   Safe-Inferred %& ~ kghc6All the information about the breakpoints for a modulekghcThe array of flags, one per breakpoint, indicating which breakpoints are enabled.kghc3An array giving the source span of each breakpoint.kghcAn array giving the names of the free variables at each breakpoint.kghcAn array giving the names of the declarations enclosing each breakpoint. See Note [Field modBreaks_decls]kghc1Array pointing to cost centre for each breakpointkghc6info about each breakpoint from the bytecode generatorkghcC CostCentre typekghcBreakpoint indexkghcInformation about a breakpoint that we know at code-generation timekghcConstruct an empty ModBreaks;kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk;kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk Safe-Inferred  ghc CoreMapX a is the base map from DeBruijn CoreExpr to a, but without the B 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 N inside another B, this is the type you want.Nghc CoreMap a is a map from J to a3. If you are a client, this is the type you want.NNNNNNNBBBBBBBBBBGGGGBBBNNNNNNNBBBBBBBBBBGGGGBBB 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 obsolete Safe-Inferred e&\ghcEvery node in an expression annotated with its (non-global) free variables, both Ids and TyVars, and type.\ghcEvery node in an expression annotated with its (non-global) free variables, both Ids and TyVars, and type. NB: see Note [The FVAnn invariant]\ghcEvery node in a binding group annotated with its (non-global) free variables, both Ids and TyVars, and type.\ghcFind all locally-defined free Ids or type variables in an expression returning a non-deterministic set.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.\ghcFind all locally-defined free Ids or type variables in an expression returning a deterministic set.\ghcFind all locally-defined free Ids or type variables in an expression returning a deterministically ordered list.\ghc2Find all locally-defined free Ids in an expression\ghcFind all locally-defined free Ids in an expression returning a deterministic set.\ghcFind all locally-defined free Ids in an expression returning a deterministically ordered list.\ghcFind all locally-defined free Ids in several expressions returning a deterministic set.\ghcFind all locally-defined free Ids in several expressions returning a deterministically ordered list.\ghcFind all locally-defined free Ids or type variables in several expressions returning a non-deterministic set.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.\ghcFind all locally-defined free Ids or type variables in several expressions returning a deterministically ordered list.\ghc4Find all locally defined free Ids in a binding group\ghc=Finds free variables in an expression selected by a predicate\ghcFinds free variables in an expression selected by a predicate returning a deterministically ordered list.ghcFinds free variables in an expression selected by a predicate returning a deterministic set.\ghcFinds free variables in several expressions selected by a predicate\ghcFinds free variables in several expressions selected by a predicate returning a deterministically ordered list.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 \).\ghcFinds the free external# names of several expressions: see  for details\ghcorphNamesOfAxiom 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.ghcThose locally-defined variables free in the left and/or right hand sides of the rule, depending on the first argument. Returns an " computation.ghcThose locally-defined variables free in the left and/or right hand sides from several rules, depending on the first argument. Returns an " computation.\ghcThose variables free in the right hand side of a rule returned as a non-deterministic set\ghcThose locally-defined free s in the right hand side of several rules returned as a non-deterministic set\ghcThis finds all locally-defined free Ids on the left hand side of a rule and returns them as a non-deterministic set\ghcThis finds all locally-defined free Ids on the left hand side of a rule and returns them as a deterministically ordered list\ghcThose variables free in the both the left right hand sides of a rule returned as a non-deterministic set\ghcThose variables free in the both the left right hand sides of rules returned as a deterministic set\ghcThose variables free in both the left right hand sides of several rules\ghcMake a L containing a number of K!s, suitable for putting into an \ghcInverse function to \\ghc$Extract the vars reported in a FVAnn\ghc Annotate a J with its (non-global) free type and value variables at every tree node.\ghc Says which Ks are interesting\ghc Says which Ks are interestingghc Says which Ks are interestingghc Says which Ks are interesting4\\\\\\\\\\\\"\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\4\\\\\\\\\\\\"\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\ Safe-Inferred *mghcRecover the type of a well-typed Core expression. Fails when applied to the actual K7 expression as it cannot really be said to have a typemghc4Returns the type of the alternatives right hand sidemghcReturns the type of the first alternative, which should be the same as for all alternativesmghcMakes 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.mghcm% for multiple type or value argumentsmghcDetermines the type resulting from applying an expression with given typemghcWrap the given expression in the coercion safely, dropping identity coercions and coalescing nested coercionsmghcWraps the given expression in the source annotation, dropping the annotation if possible.mghc b }&depending on whether we have to use a case or let" binding for the expression (see n). 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 nghcTests whether we have to use a case rather than let7 binding for this expression as per the invariants of J: see GHC.Core#let_app_invariantnghcThis guy constructs the value that the scrutinee must have given that you are in one particular branch of a casenghc$Extract the default case alternativenghcFind the case alternative corresponding to a particular constructor: panics if no such constructor existsnghcMerge alternatives preserving order; alternatives in the first argument shadow ones in the secondnghcGiven: )case (C a b x y) of C b x y -> ...We want to drop the leading type argument of the scrutinee leaving the arguments to match against the patternnghc$Refine the default alternative to a K, if there is a unique way to do so. See Note [Refine DEFAULT case alternatives]nghcn' 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.nghcn' 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.nghcA special version of n used during Note [Speculative evaluation]. When the predicate arg fun_ok returns False for b, then b! is never considered ok-for-spec.nghc: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).nghc Similar to n but includes CONLIKE functions as well as data constructors. Conlike arguments are considered interesting by the inliner.ghcReturns true for values or value-like expressions. These are lambdas, constructors / CONLIKE functions (as determined by the function argument) or PAPs.nghcCan we bind this J at the top level?nghcCheck if the expression is zero or more Ticks wrapped around a literal string.nghcExtract 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.nghcA cheap equality test which bales out fast! If it returns True the arguments are definitely equal, otherwise, they may or may not be equal.nghc9Cheap expression equality test, can ignore ticks by type.nghc-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.%Only used in GHC.Core.Lint.lintAnnotsghcFinds differences between core expressions, modulo alpha and renaming. Setting top means that the IdInfo6 of bindings will be checked for differences as well.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 messagesnghcCan we eta-reduce the given function to the specified arity? See Note [Eta reduction conditions].nghcTrue 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.nghcIf 1normSplitTyConApp_maybe _ ty = Just (tc, tys, co) then ty |> co = tc tys. It's #, but looks through coercions via O. Hence the "norm" prefix.nghc-collectMakeStaticArgs (makeStatic t srcLoc e) yields Just (makeStatic, t, srcLoc, e).Returns Nothing for every other expression.nghcDoes this binding bind a join point (or a recursive group of join points)?nghcDo we expect there to be any benefit if we make this var strict in order for it to get treated as as cbv argument? See Note [Which Ids should be strictified] See Note [CBV Function Ids] for more background.nghcCase alternative constructorghc!Things bound by the pattern matchghc*The type arguments to the case alternativenghcType 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 Alternativesnghc$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)ghcL', if a default alt was replaced with a KmmmmmmmnnnnnnnnnnnnnnnmmmmmEnnnnnnnnmnnnnnnnnmnnnnnnnnnnLmnnnnmmnnnnnnnnnnmmmmmmmnnnnnnnnnnnnnnnmmmmmEnnnnnnnnmnnnnnnnnmnnnnnnnnnnLmnnnnmmnnnnnnnnnn Safe-Inferred  "ghc-The analysis monad consists of the following  components:: Reader-like context. Contains a substitution, info about how how lifted identifiers are to be expanded into applications and configuration options.% .: 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.)ghcWe need to detect when we are lifting something out of the RHS of a recursive binding (c.f. GHC.Stg.Lift.Monad#floats), in which case that binding needs to be added to the same top-level recursive group. This requires we detect a certain nesting structure, which is encoded by  and . Although  will only ever care if the current binding to be lifted (through ) will occur inside such a binding group or not, e.g. doesn't care about the nesting level as long as its greater than 0.ghc)Environment threaded around in a scoped, Reader-like fashion.ghc Read-only.ghc(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.ghcLifted s don't occur as free variables in any closure anymore, because they are bound at the top-level. Every occurrence must supply the formerly free variables of the lifted , so they in turn become free variables of the call sites. This environment tracks this expansion from lifted s to their free variables.!s to !s. Invariant: /s not present in this map won't be substituted.ghc uncurry  .  = idghcFlattens an expression in [] into an STG program, see GHC.Stg.Lift.Monad#floats4. Important pre-conditions: The nesting of opening StartBindinGroups and closing EndBindinGroups is balanced. Also, it is crucial that every binding group has at least one recursive binding inside. Otherwise there's no point in announcing the binding group in the first place and an ASSERT will trigger.ghcOmitting this makes for strange closure allocation schemes that crash the GC.ghcWrites a plain { to the output.ghc&Starts a recursive binding group. See GHC.Stg.Lift.Monad#floats and .ghc$Ends a recursive binding group. See GHC.Stg.Lift.Monad#floats and .ghcLifts a binding to top-level. Depending on whether it's declared inside a recursive RHS (see GHC.Stg.Lift.Monad#floats and ), this might be added to an existing recursive top-level binding group.ghcTakes a binder and a continuation which is called with the substituted binder. The continuation will be evaluated in a  context in which that binder is deemed in scope. Think of it as a  computation: After the continuation finishes, the new binding won't be in scope anymore.ghcSee .ghc Similarly to , this function takes a set of variables to abstract over, the binder to lift (and generate a fresh, substituted name for) and a continuation in which that fresh, lifted binder is in scope.It takes care of all the details involved with copying and adjusting the binder and fresh name generation.ghcSee .ghcSubstitutes a binder  occurrence), which was brought in scope earlier by  / .ghc:Whether the given binding was decided to be lambda lifted.ghcReturns an empty list for a binding that was not lifted and the list of all local variables the binding abstracts over (so, exactly the additional arguments at adjusted call sites) otherwise.ghc 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. Safe-Inferred ghcFor a binding we: * Look at the args * Mark any argument as call-by-value if: - It's argument to a worker and demanded strictly - Unless it's an unlifted type already * Update the id See Note [CBV Function Ids] See Note [Attaching CBV Marks to ids]wxwxwxwx Safe-Inferred J͢͢ Safe-Inferred  wghc$An environment for substituting for swghc'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.SubstwghcFind the in-scope set: see GHC.Core.TyCo.Subst" Note [The substitution invariant]wghcRemove all substitutions for s and Ks that might have been built up while preserving the in-scope setwghcAdd a substitution for an  to the w: you must ensure that the in-scope set is such that TyCoSubst Note [The substitution invariant] holds after extending the substitution like thiswghcAdds multiple  substitutions to the w : see also wwghcAdd a substitution for a  to the w 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.wghcAdds multiple  substitutions to the w : see also wwghcAdd a substitution from a ! to a K to the w4: you must ensure that the in-scope set satisfies GHC.Core.TyCo.Subst Note [The substitution invariant] after extending the substitution like thiswghcAdd a substitution appropriate to the thing being substituted (whether an expression, type, or coercion). See also w, w, wwghcAdd a substitution as appropriate to each of the terms being substituted (whether expressions, types, or coercions). See also w.wghcFind the substitution for an  in the wwghcSimultaneously 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 a2wghcAdd the K to the in-scope set: as a side effect, and remove any existing substitutions for itwghcAdd the K s to the in-scope set: see also wwghcOptimized version of w that can be used if you are certain all the things being added are s and hence none are s or !swghc.substExpr applies a substitution to an entire J1. 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]wghc"Apply a substitution to an entire J$, additionally returning an updated w2 that should be used by subsequent substitutions.wghc"Apply a substitution to an entire J$, additionally returning an updated w2 that should be used by subsequent substitutions.wghcDe-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 w 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 herewghcSubstitutes a K" for another one according to the w- given, returning the result and an updated w3 that should be used by subsequent substitutions.  is preserved by this process, although it is substituted into appropriately.wghcApplies w to a number of Ks, accumulating a new w left-to-rightwghc,Substitute in a mutually recursive group of swghcVery similar to w , but it always allocates a new  for each variable in its output. It substitutes the IdInfo though.wghcApplies w to a number of 8s, accumulating a final substitution from left to rightwghc$Clone a mutually recursive group of swghcSee J.wghcSee ?wghcSubstitute into some ! with regard to the supplied new .wghcSubstitutes 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 unexpectedwghcSubstitutes 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 unexpectedwghcSubstitutes for the  s within the L given the new function ghc"Substitution to use for the IdInfoghc Substitution and Id to transformghc-Transformed pair NB: unfolding may be zapped8ww?w#wwwwwwwwwwwwwwwwwwwwwwwww?wwwwwwwwwwwwwwwwwwwwwwwww8ww?w#wwwwwwwwwwwwwwwwwwwwwwwww?wwwwwwwwwwwwwwwwwwwwwwwww Safe-Inferred "3ghcState Monad used inside exitifyghc8Traverses the AST, simply to find all joinrecs and call exitify8 on them. The really interesting function is exitifyRecghcGiven a recursive group of a joinrec, identifies @exit paths@ and binds them as join-points outside the joinrec. Safe-Inferred &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. We use a different env for cse on the rhs and for extendCSEnvWithBinding for reasons explain in See Note [Separate envs for let rhs and body]ghcGiven a binder `let x = e`, this function determines whether we should add `e -> x` to the cs_mapghc 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.ghcextendCSEnv env e triv_expr will replace any occurrence of e with  triv_expr going forward.ghcAdd clones to the substitution to deal with shadowing. See Note [Shadowing] for more details. You should call this whenever you go under a binder. Safe-Inferred 'ghcBuild a PrimOp Idghc 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.lghcA 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.lghcA convention maps a list of values (function arguments or return values) to registers or stack locations.lghc 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.lghcnon-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.lghca 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.lghc/Slow entry points: all args pushed on the stacklghcEntry to the garbage collector: uses the node reg! (TODO: I don't think we need this --SDM)ghcOutput all scope paths.ghcReturns 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.mghcChecks whether two tick scopes are sub-scopes of each other. True if the two scopes are equal.mghcCombine 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.llllllllllllllllllllllllllllllllAlllllllllllllllllllmmllllmmllllmmllllllllllllllllllllllllllllllllAlllllllllllllllllllmmllllmmllllmm Safe-Inferred)*18 : mghc%Static data, after SRTs are generatedmghc8a literal value, size given by cmmLitRep of the literal.mghc uninitialised data, N bytes longmghc1string of 8-bit values only, not zero terminated.mghcan embedded binary filemghc!Info table as a haskell data typemghcCmmTopInfo is attached to each CmmDecl (see defn of CmmGroup), and contains the extra info (beyond the executable code) that belongs to that CmmDecl.mghcA top-level chunk, abstracted over the type of the contents of the basic blocks (Cmm or instructions are the likely instantiations).mghcRaw1 cmm group (TODO (osa): not sure what that means)mghcCmm group with SRTsmghcCmm group before SRT generationmghc?Should a data in this section be considered constant at runtimemghcThe branch block id is that of the first block in the branch, which is that branch's entry pointmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm5555555mmm5llllllllllllllllllllllllllllllllllllllAlllllllllllllllllmmllllmmmmjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjj]^^^^^^^^^^^^^^^^^^^^^^^^^^^]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]\]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]\\\\\\\\\\\\\\\000000000000000kjkjjjjjjjjkkkkkkkkkkkkkkjjjkkkkkj^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^1111111111111000001111111111111111111111111111111111111mmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm5555555mmm5 Safe-Inferred AӣghcregSqueeze_class reg Calculate the maximum number of register colors that could be denied to a node of this class due to having this reg as a neighbour.ޣghc&The complete set of machine registers.ߣghcTake the class of a register.ghcGet the name of the register with this number. NOTE: fixme, we dont track which "way" the XMM registers are usedghcthese are the regs which we cannot assume stay alive over a C call.ghcon 64bit platforms we pass the first 8 float/double arguments in the xmm registers.٣ghc3desired stack offset in bytes, positive or negativeӣԣɣʣˣ̣ͣΣϣУѣңգ֣ƣǣȣף٣ݣޣߣ£ãģţأܣڣۣӣԣɣʣˣ̣ͣΣϣУѣңգ֣ƣǣȣף٣ݣޣߣ£ãģţأܣڣۣ Safe-Inferred D Safe-Inferred Dv Safe-Inferred EghcReturns the info table associated with the CmmDecl's entry point, if any.ghcReturn the list of BlockIds in a CmmDecl that are entry points for this proc (i.e. they may be jumped to from outside this proc). Safe-Inferred E mmmmmmm mmmmmmm Safe-Inferred G-ghc#Get bytes of a Float representationghc$Get bytes of a Double representationghcEmit a ".string" directiveghcEmit a ".incbin" directive+A NULL byte is added after the binary data. Safe-Inferred ghcLlvm cast operations.ghcInteger truncateghcInteger extend (zero fill)ghcInteger extend (sign fill)ghcFloat truncateghc Float extendghcFloat to unsigned IntegerghcFloat to signed IntegerghcUnsigned Integer to FloatghcSigned Int to FloatghcPointer to IntegerghcInteger to Pointerghc6Cast between types where no bit manipulation is neededghcLlvm compare operations.ghcEqual (Signed and Unsigned)ghcNot equal (Signed and Unsigned)ghcUnsigned greater thanghcUnsigned greater than or equalghcUnsigned less thanghcUnsigned less than or equal¤ghcSigned greater thanäghcSigned greater than or equalĤghcSigned less thanŤghcSigned less than or equalƤghc Float equalǤghcFloat not equalȤghcFloat greater thanɤghcFloat greater than or equalʤghcFloat less thanˤghcFloat less than or equal̤ghc)Llvm binary operators machine operations.ͤghc1add two integer, floating point or vector values.Τghcsubtract two ...Ϥghc multiply ..Фghc$unsigned integer or vector division.Ѥghcsigned integer ..Ҥghc*unsigned integer or vector remainder (mod)Ӥghc signed ...Ԥghc(add two floating point or vector values.դghcsubtract two ...֤ghc multiply ...פghc divide ...ؤghc remainder ...٤ghc Left shiftڤghc3Logical shift right Shift right, filling with zeroۤghcArithmetic shift right The most significant bits of the result will be equal to the sign bit of the left operand.ܤghcAND bitwise logical operation.ݤghcOR bitwise logical operation.ޤghcXOR bitwise logical operation.ߤghcLinkage 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.ghcGlobal values with internal linkage are only directly accessible by objects in the current module. In particular, linking code into a module with an internal global value may cause the internal to be renamed as necessary to avoid collisions. Because the symbol is internal to the module, all references can be updated. This corresponds to the notion of the static keyword in C.ghc 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.ghcweak linkage is exactly the same as linkonce linkage, except that unreferenced weak globals may not be discarded. This is used for globals that may be emitted in multiple translation units, but that are not guaranteed to be emitted into every translation unit that uses them. One example of this are common globals in C, such as int X; at global scope.ghc 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.ghcThe 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.ghcThe symbol participates in linkage and can be used to resolve external symbol references.ghc Alias for 3 but with explicit textual form in LLVM assembly.ghcSymbol is private to the module and should not appear in the symbol tableghcFunctions can have a fixed amount of parameters, or a variable amount.ghc1Different calling conventions a function can use.ghcThe 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).ghcThis 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.ghcThis 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.ghcThe GHC-specific  registerised calling convention.ghcAny calling convention may be specified by number, allowing target-specific calling conventions to be used. Target specific calling conventions start at 64.ghc X86 Specific  convention. LLVM includes a specific alias for it rather than just using CC_Ncc.ghc#Different types to call a function.ghc(Normal call, allocate a new stack frame.ghc7Tail call, perform the call in the current stack frame.ghcLlvm 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#fnattrsghcThis attribute indicates that the inliner should attempt to inline this function into callers whenever possible, ignoring any active inlining size threshold for this caller.ghcThis 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.ghcThis attribute indicates that the inliner should never inline this function in any situation. This attribute may not be used together with the alwaysinline attribute.ghcThis 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.ghcThis function attribute indicates that the function never returns normally. This produces undefined behavior at runtime if the function ever does dynamically return.ghcThis 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.ghcThis 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.ghcThis 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.ghcThis 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.ghcThis 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.ghcThis attribute indicates that the code generator should not use a red zone, even if the target-specific ABI normally permits it.ghc>This attributes disables implicit floating point instructions.ghcThis attribute disables prologue / epilogue emission for the function. This can have very system-specific consequences.ghcLLVM Parameter Attributes.Parameter attributes are used to communicate additional information about the result or parameters of a functionghcThis 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).ghcThis 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).ghcThis 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).ghcThis indicates that the pointer parameter should really be passed by value to the function.ghcThis indicates that the pointer parameter specifies the address of a structure that is the return value of the function in the source program.ghcThis indicates that the pointer does not alias any global or any other parameter.ghcThis indicates that the callee does not make any copies of the pointer that outlive the callee itselfghcThis indicates that the pointer parameter can be excised using the trampoline intrinsics.ghcAn LLVM Functionghc!Unique identifier of the functionghcLinkageType of the functionghc&The calling convention of the functionghcType of the returned valueghc'Indicates if this function uses varargsghcParameter types and attributesghc(Function align value, must be power of 2ghcLlvm Static Data.These represent the possible global level variables and constants.ghcA comment in a static sectionghc#A static variant of a literal valueghcFor uninitialised dataghcDefines a static ǥghcA static arrayghcA static structure typeghcA static structure typeghcA pointer to other dataghcTruncateghcPointer to Pointer conversionghcPointer to Integer conversionghcConstant addition operationghcConstant subtraction operationghcLlvm Literal Data.(These can be used inline in expressions.ghc'Refers to an integer constant (i64 42).ghcFloating point literalghc.Literal NULL, only applicable to pointer typesghcVector literalghc>Undefined value, random bit pattern. Useful for optimisations.ghcLLVM VariablesghcVariables with a global scope.ghc,Variables local to a function or parameters.ghcNamed local variables. Sometimes we need to be able to explicitly name variables (e.g for function arguments).ghcA constant variableghcMutable global variableghcConstant global variableghcAlias of another variableghcAn LLVM section definition. If Nothing then let LLVM decide the sectionghc Llvm Typesghc&An integer with a given width in bits.ghc32 bit floating pointghc64 bit floating pointghc 80 bit (x86 only) floating pointghc128 bit floating pointghcA pointer to a ghc An array of ghc A vector of ghcA  can represent a label (address)ghc Void typeghcPacked structure type¥ghcUnpacked structure typeåghc A type aliasĥghc LLVM Metadataťghc3Function type, used to create pointers to functionsƥghc A type aliasǥghcA String in LLVMȥghc4A global mutable variable. Maybe defined or externalʥghcReturns the variable of the ȥ˥ghcReturn the value of the ȥϥghc Return the  of the Хghc Return the  of a ѥghc Return the  of the ҥghc Return the ߤ for a ӥghc0Add a pointer indirection to the supplied type.  and  cannot be lifted.ԥghcLift a variable to  type.եghc:Remove the pointer indirection of the supplied type. Only  constructors can be lowered.֥ghcLower a variable of  type.ץghcTest if the given  is an integerإghcTest if the given  is a floating point type٥ghcTest if the given  is an  constructڥghcTest if the given  is an  constructۥghc Test if a  is global.ܥghcWidth in bits of an , returns 0 if not applicableghc"The target architectures word sizeghc"The target architectures word sizeghcConvert 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].ˤʤɤȤǤƤŤĤä¤̤ޤݤܤۤڤ٤ؤפ֤դԤӤҤѤФϤΤͤߤťĥå¥ƥǥȥ˥ʥɥ̥ͥΥϥХѥҥӥԥե֥ץإ٥ڥۥܥݥޥߥȥ˥ʥɥǥƥťĥå¥̥ͥΥϥХѥҥӥԥե֥ץإ٥ڥۥܥݥޥߥߤ̤ޤݤܤۤڤ٤ؤפ֤դԤӤҤѤФϤΤͤˤʤɤȤǤƤŤĤä¤ Safe-Inferred dghcMetadata declarations. Metadata can only be declared in global scope.ghcNamed metadata. Only used for communicating module information to LLVM. ('!name = !{ [!] }' form).ghcMetadata node declaration. ('!0 = metadata !{ }' form).ghcAssociates some metadata with a specific label for attaching to an instruction.ghcLLVM metadata expressionsghc)A reference to an un-named metadata node.   Safe-Inferred ;ghcLlvm ExpressionsghcAllocate amount * sizeof(tp) bytes on the stack * tp: LlvmType to reserve room for * amount: The nr of tp's which must be allocatedghcPerform the machine operator op on the operands left and right * op: operator * left: left operand * right: right operandghcPerform a compare operation on the operands left and right * op: operator * left: left operand * right: right operandghcExtract a scalar element from a vector * val: The vector * idx: The index of the scalar within the vectorghcExtract a scalar element from a structure * val: The structure * idx: The index of the scalar within the structure Corresponds to "extractvalue" instruction.ghcInsert a scalar element into a vector * val: The source vector * elt: The scalar to insert * index: The index at which to insert the scalarghcAllocate amount * sizeof(tp) bytes on the heap * tp: LlvmType to reserve room for * amount: The nr of tp's which must be allocatedghcLoad the value at location ptrghc(Atomic load of the value at location ptrghcNavigate 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.ghcCast 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 toghcAtomic read-modify-write operation * op: Atomic operation * addr: Address to modify * operand: Operand to operation * ordering: Ordering requirementghcCompare-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.ghcCall 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.ghcCall 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.ghcMerge 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.ghcInline assembly expression. Syntax is very similar to the style used by GCC. * assembly: Actual inline assembly code. * constraints: Operand constraints. * return ty: Return type of function. * vars: Any variables involved in the assembly code. * sideeffect: Does the expression have side effects not visible from the constraints list. * alignstack: Should the stack be conservatively aligned before this expression is executed.ghc/A LLVM expression with metadata attached to it.ghcLlvm StatementsghcAssign an expression to a variable: * dest: Variable to assign to * source: Source expressionghcMemory fence operationghc!Always branch to the target labelghcBranch 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 falseghcComment Plain comment.ghcSet a label on this position. * name: Identifier of this label, unique for this moduleghcStore 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 inghcMultiway 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.ghcReturn a result. * result: The variable or constant to returnghcAn instruction for the optimizer that the code following is not reachableghcRaise an expression to a statement (if don't want result or want to use Llvm unnamed values.ghcA nop LLVM statement. Useful as its often more efficient to use this then to wrap LLvmStatement in a Just or [].ghc.A LLVM statement with metadata attached to it.ghc'LLVM atomic operations. Please see the  atomicrmw instruction in the LLVM documentation for a complete description.ĦghcLLVM ordering types for synchronization purposes. (Introduced in LLVM 3.0). Please see the LLVM documentation for a better description.Ŧghc(Some partial order of operations exists.Ʀghc?A single total order for operations at a single address exists.Ǧghc"Acquire synchronization operation.Ȧghc"Release synchronization operation.ɦghc,Acquire + Release synchronization operation.ʦghc&Full sequential Consistency operation.ͦghcAn LLVM FunctionϦghc(The signature of this declared function.ЦghcThe functions argumentsѦghcThe function attributes.Ҧghc%The section to put the function into,Ӧghc Prefix dataԦghcThe body of the functions.զghc6An LLVM Module. This is a top level container in LLVM.צghc/Comments to include at the start of the module.ئghcLLVM Alias type definitions.٦ghcLLVM meta data.ڦghc*Global variables to include in the module.ۦghcLLVM Functions used in this module but defined in other modules.ܦghc&LLVM Functions defined in this module.ަghcA block of LLVM code.ghcThe code label for this blockghcA list of LlvmStatement's representing the code for this block. This list must end with a control flow statement.ghc Block labelsæ¦ĦʦɦȦǦƦŦ˦̦ͦԦӦҦѦЦϦΦզܦۦڦ٦ئצ֦ݦަߦަߦݦզܦۦڦ٦ئצ֦ͦԦӦҦѦЦϦΦ̦˦ĦʦɦȦǦƦŦæ¦ Safe-Inferred ghc%Get the integer format of this width.ghc#Get the float format of this width.ghc-Check if a format represent an integer value.ghc4Check if a format represents a floating point value.ghcConvert a Cmm type to a Format.ghcGet the Width of a Format. Safe-Inferred { Safe-Inferred nghcregSqueeze_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.00 Safe-Inferred  Safe-Inferred ghcLanguage ID used for Haskell.ghc.Mapping of registers to DWARF register numbersghc2Virtual register number to use for return address.§çħŧƧǧȧɧʧ˧̧ͧΧϧЧѧҧӧԧէ֧קا٧ڧۧܧݧާߧ§çħŧƧǧȧɧʧ˧̧ͧΧϧЧѧҧӧԧէ֧קا٧ڧۧܧާݧߧ Safe-Inferred ghcregSqueeze_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. Safe-Inferred l Safe-Inferred ghcArmv6 | 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 | '---------------------------------------------------------------------------' Safe-Inferred ľghc,SXTW Operand Operand | SXTX Operand Operandghc;ADC Operand Operand Operang -- rd = rn + rm + C | ADCS ...ghcADDS Operand Operand Operand -- rd = rn + rm | ADR ... | ADRP ...ghcMADD ... | MNEG ...ghc6NEGS ... | NGC ... | NGCS ... | SBC ... | SBCS ...ghc&SMADDL ... | SMNEGL ... | SMSUBL ...ghcSUBS ...ghcUMADDL ... -- Xd = Xa + Wn  Wm | UMNEGL ... -- Xd = - Wn  Wm | UMSUBL ... -- Xd = Xa - Wn  Wm | UMULH ... -- Xd = (Xn  Xm)_127:64 | UMULL ... -- Xd = Wn  Wmghc,MOVN Operand Operand | MOVZ Operand OperandghcTODO: verify this!ghcAll registers are 8 byte wide.ghcThe number of bytes that the stack pointer should be aligned to.ghc reg move instruction or Nothing if it's not oneghc'Make an unconditional jump instruction.ghcGet 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]¨ƨŨĨèǨϨΨ̨ͨ˨ʨɨȨШӨҨѨԨڨ٨ب֨ըۨߨިݨܨר©éĩũƩǩȩɩʩ˩̩ͩΩϩЩѩҩөԩթ֩שة٩ک۩ܩݩީߩԨڨ٨ب֨ըۨߨިݨܨרШӨҨѨǨϨΨ̨ͨ˨ʨɨȨ¨ƨŨĨè©éĩũƩǩȩɩʩ˩̩ͩΩϩЩѩҩөԩթ֩שة٩ک۩ܩݩީߩ Safe-Inferred 4 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. Safe-Inferred )* C ghcWe make a top-level decl for the string, and return a label pointing to itghcWe make a top-level decl for the embedded binary file, and return a label pointing to itghcBuild a data-segment data blockghcUseful for creating an index into an array, with a statically known offset. The type is the element type; used for making the multiplierghcUseful for creating an index into an array, with an unknown offset.ghc*Load a naturally-aligned non-pointer word.ghc$Load a naturally-aligned GC pointer.ê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.ĪghcReturns 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].ʪ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. -GBMҪghc1Extract all tick annotations from the given blockӪԪ֪ժתت٪ڪªêĪŪƪȪǪ̪ɪͪʪ˪ЪΪѪϪҪӪԪ֪ժתت٪ڪªêĪŪƪȪǪ̪ɪͪʪ˪ЪΪѪϪҪ Safe-Inferred)* ܪ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.ߪghcFixup global registers so that they assign to locations within the RegTable if they aren't pinned for the current target.ߪ۪ުݪܪߪ۪ުݪܪ Safe-Inferred)* ֱghcTraverses the m, making sure that l# are suitable for code generation. Safe-Inferred )*  Safe-Inferred)* L Safe-Inferred 5ghc LoopLevel mappingghc*(backEdge, loopBody), body includes headerҫghcInformation about edgesghc%Unknown, but not heap or stack check.ghcHeap or stack check֫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 conditions]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.ghcConvenience function, generate edge info based on weight not originating from cmm.ghcAdjust the weight between the blocks using the given function. If there is no such edge returns the original map.ghcSet the weight between the blocks to the given weight. If there is no such edge returns the original map.ghc!Is this block part of this graph?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.ghcFilter the CFG with a custom function f. Parameters are `f from to edgeInfo`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 => -> Cghc5Adds a new edge, overwrites existing edges if presentghcAdds a edge with the given weight to the cfg If there already existed an edge it is overwritten. `addWeightEdge from to weight cfg`ghc4Destinations from bid ordered by weight (descending)ghc1Get successors of a given node with edge weights.ghc/Returns a unordered list of all edges with infoghc5Returns a unordered list of all edges without weightsghc4Get successors of a given node without edge weights.ghc8Invariant: The edge **must** exist already in the graph.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.ghcGenerate weights for a Cmm proc based on some simple heuristics.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.ghcDetermine loop membership of blocks based on SCC analysis This is faster but only gives yes/no answers.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.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.ghcUpdate branch weights based on certain heuristics. See Note [Static Branch Prediction] TODO: This should be combined with optimizeCFGghcEdges are sorted ascending pointwise by weight, source and destinationghcCareful! Since we assume there is at most one edge from A to B the Eq instance does not consider weight..۫ܫ߫ݫޫҫӫիԫ֫׫ث٫ګ.۫ܫ߫ݫޫҫӫիԫ֫׫ث٫ګ Safe-Inferred8  ghc(A basic block with liveness information.ghcStash regs live on entry to each basic block in the info part of the cmm code.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)An instruction with liveness information.ghcThe register allocator also wants to use SPILL/RELOAD meta instructions, so we'll keep those here.ghcA real machine instructionghcspill this reg to a stack slotghc!reload this reg from a stack slotghc5A top level thing which carries liveness information.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]ghc7map a function across all the basic blocks in this codeghcmap 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)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 NatCmmDeclghcPretty-print a ghcMap over instruction type in ghcStrip away liveness information from a basic block, and make real spill instructions out of SPILL, RELOAD pseudos along the way.ghcErase Delta instructions.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.ghcConvert a NatCmmDecl to a LiveCmmDecl, with liveness informationghcCheck 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..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.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%& SghcThe register allocator stateghcthe current mapping from basic blocks to the register assignments at the beginning of that block.ghcfree machine registersghc assignment of temps to locationsghccurrent stack delta¬ghcfree stack slots for spillingìghc?unique supply for generating names for join point fixup blocks.Ĭ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.Ŭghc#Native code generator configurationƬghc<(from,fixup,to) : We inserted fixup code between from and toǬ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!vreg was loaded from a spill slotϬghc,reg-reg move inserted during join to targetsЬghc,reg-mem move inserted during join to targetsѬ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.Ҭghcvreg is in a registerӬghcvreg is held in a stack slotԬghc0vreg is held in both a register and a stack slotլ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.֬ghc1Find the register mapping for a specific BlockId.׬ghc?Lookup which register a virtual register was first assigned to.جghcAn initial empty լ٬ghc/Add new register mappings for a specific block.ڬghc'Get the reg numbers stored in this Loc.լ֬׬ج٬ѬҬԬӬڬˬ̬ͬάϬЬǬȬɬʬ¬ìĬŬƬլ֬׬ج٬ѬҬԬӬڬˬ̬ͬάϬЬǬȬɬʬ¬ìĬŬƬ 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-Inferred 8 Pghc"The register allocator monad type.ghcSmart constructor for , as described in Note [The one-shot state monad trick] in GHC.Utils.Monad.ghc'Get native code generator configurationghc 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.ghcCleaner monad.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;Clean out unneeded spill/reloads from this top level thing.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$Construct the initial cleaner state.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 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.ghcAdd a v1 = v2 register renaming to the map. The register with the lowest lexical name is set as the canonical version.ghcDetermine the canonical name for a register by following v1 = v2 renamings in this map.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. Safe-Inferred)* - ghcMap of ghc1Records the expected cost to spill some register.ghcAn empty map of spill costs.ghcAdd two spill cost infos.ghcAdd two spill cost records.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)ghc-Take all the virtual registers from this set.ghc&Choose a node to spill from this graphghc 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 zeroghc+Extract a map of register lifetimes from a .ghcDetermine the degree (number of neighbors) of this node which have the same class.ghcShow a spill cost record, including the degree from the graph and final calculated spill cost.   Safe-Inferred 8 2ghc9Holds interesting statistics from the register allocator.ghcInitial code, with liveness.ghcThe initial, uncolored graph.ghc/Information to help choose which regs to spill.ghcTarget platformghc(Code we tried to allocate registers for.ghcThe regs that were coalesced.ghcSpiller stats.ghc#Code with spill instructions added.ghcCoalesced and colored graph.ghcCode with coalescings applied.ghc"Code with vregs replaced by hregs.ghc-Code with unneeded spill/reloads cleaned out.ghc Final code.ghc0Spill/reload/reg-reg moves present in this code.ghc;Do all the different analysis on this list of RegAllocStatsghcDump a table of how many spill loads / stores were inserted for each vreg.ghcDump a table of how long vregs tend to live for in the initial code.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.ghc Count spillreloadreg-reg moves. Lets us see how well the register allocator has done.ghcglobal register conflict graph Safe-Inferred  :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.ghc7The top level of the graph coloring register allocator.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 ;, Safe-Inferred )*8 >ghcThe 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 js.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.ghcConstruct a constructor/finalizer function. Instead of emitting a initializer/finalizer array we rather just emit a single function, annotated with the appropriate C attribute, which then calls each of the initializers. Safe-Inferred)*1 FF ghc abstracted over n (the node type)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).ghc abstracted over n (the node type)ghc*The result of joining OldFact and NewFact.ghc!Result is different than OldFact.ghcResult is the same as OldFact.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.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.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.CBCB Safe-Inferred )* Jghc>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.ghc:A mapping from block labels to the variables live on entryghc&The variables live on entry to a blockghcThe dataflow latticeghc'Calculated liveness info for a CmmGraphghcOn entry to the procedure, there had better not be any LocalReg's live-in. If you see this error it most likely means you are trying to use a variable without it being defined in the given scope.ghcThe dataflow latticeghcOn entry to the procedure, there had better not be any LocalReg's live-in. Safe-Inferred)* Kughcconflicts (r,e) node is False if and only if the assignment r = e' can be safely commuted past statement node. Safe-Inferred )*8 Lghc2Check for obviously out-of-bounds shift operationsghcAs noted in Note [Register parameter passing], the arguments and l; of a foreign call mustn't mention caller-saved registers. Safe-Inferred)* L Safe-Inferred)* Nghc$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-Inferred NghcGiven a list of arguments, and a function that tells their types, return a list showing where each argument is passed Safe-Inferred)* S ghcUnlabeled graph with tick scopeghc+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 m (closed at both ends) by providing a label for the entry point and a tick scope; see .ghc.creates a sequence "goto id; id:" as an AGraphghc(creates an open AGraph from a given nodeghc)creates a closed AGraph from a given nodeghc0A labelled code block; should end in a last nodeghc*allocate a fresh label for the entry pointghc5use the given BlockId as the label of the entry pointghcAssumes natural alignmentghcA jump where the caller says what the live GlobalRegs are. Used for low-level hand-written Cmm.ʱghc Construct a l7 node for the given register and unwinding expression.*˱ɱƱDZȱ±ñıαűʱ̱ͱϱб*˱ɱƱDZȱ±ñıαűʱ̱ͱϱб Safe-Inferred)* \3ghc(Expressions, used for unwind informationghc literal valueghcregister plus offsetghcpointer dereferencing®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 J= when the register's previous value cannot be reconstructed.îghcA label associated with an ®ghcIntermediate data structure holding debug-relevant context information about a block.ŮghcDebug information about a block of code. Ticks scope over nested blocks.ǮghcEntry label of containing procȮghc Hoopl labelɮghc Output labelʮghcHas an info table?ˮghc9The parent of this proc. See Note [Splitting DebugBlocks]̮ghcTicks defined in this blockͮghcBest source tick covering blockήghc+Output position relative to other blocks. Nothing# means the block was optimized outЮghc Nested blocksѮ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).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).Ӯ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 lookupsծghcConversion of Cmm expressions to unwind expressions. We check for unsupported operator usages and simplify the expression as far as possible.ŮƮǮȮɮʮˮ̮ͮήϮЮѮҮӮԮ®îĮծŮƮǮȮɮʮˮ̮ͮήϮЮѮҮӮԮ®îĮծ Safe-Inferred fp ghcN.B. when used with the  , the source operand is interpreted to be a 32-bit sign-extended value. True 64-bit operands need to be moved with MOVABS , which we currently don't use.ghcThe format argument is the size of operand 1 (the number of bits we keep) We always zero *all* high bits, even though this isn't how the actual instruction works. The code generator also seems to rely on this behaviour and it's faster to execute on many cpus as well so for now I'm just documenting the fact.ghcX86 call instructionghcReturns which registers are read and written as a (read, written) pair.ghc8Is this register interesting for the register allocator?ghcApplies the supplied function to all registers in instructions. Typically used to change virtual registers to real registers.ghcMake a spill instruction.ghc Make a spill reload instruction.ghc?See if this instruction is telling us the current C stack deltaghc Make a reg-reg move instruction.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.ghc)Make an unconditional branch instruction.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-Inferred jSghcOutput 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-Inferred8 pԯghcTwo 32-bit regs used as a single virtual 64-bit register and the code to set them appropriately֯ghc8Two 32-bit regs used as a single virtual 64-bit registerghcHaving a CFG with additional information is essential for some operations. However we can't reconstruct all information once we generated instructions. So instead we update the CFG as we go.ghc  is only for printing internal labels. See Note [Internal proc labels] in CLabel.ghcThe list of block ids records the redirected jumps to allow us to update the CFG.ghcgiven the instruction sequence of a block, produce a list of the block's î2s See Note [What is this unwinding business?] in GHC.Cmm.DebugBlock= and Note [Unwinding information in the NCG] in this module.ghcTurn the sequence of jcc l1; jmp l2 into jncc l2;  when possible.ghcGet CFG edge weightsghc%Record that we added a block between from and old.ghcPlace  after block' and change any edges block -> X to  -> Xghc Return a virtual 64-bit registerghc7Convert a 64-bit LocalReg into two virtual 32-bit regs.9Used to handle 64-bit "registers" on 32-bit architecturesghc'Get native code generator configurationghc ([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.ghcEdges 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.ghcCFG if we have one.ghcFunction to serialize Safe-Inferred  '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!ghcInformation about unwind instructions for a procedure. This corresponds to a "Common Information Entry" (CIE) in DWARF.ghcA DWARF address range. This is used by the debugger to quickly locate which compilation unit a given address belongs to. This type assumes a non-segmented address-space.ghc;Abbreviation codes used for encoding above records in the  .debug_info section.ghc)Pseudo, used for marking the end of listsŰghcIndividual dwarf records. Each one will be encoded as an entry in the  .debug_info section.Ұghc)label of DIE belonging to the parent tickghc1Generate assembly for the given abbreviation codeհghcAbbreviation declaration. This explains the binary encoding we use for representing Ű1. Be aware that this must be updated along with ְ.ְghc Generate assembly for DWARF dataghc+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 childrenװ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.ghcWrites 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 j' 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  undefinedٰghc)Align assembly at (machine) word boundaryڰghc1Assembly for a single byte of constant DWARF data۰ghc(Assembly for a two-byte constant integerghc"Assembly for a constant DWARF flagܰghc*Assembly for 4 bytes of dynamic DWARF dataghc+Assembly for 4 bytes of constant DWARF dataݰghcAssembly for a DWARF word of dynamic data. This means 32 bit, as we are generating 32 bit DWARF.ްghcAssembly for a machine word of dynamic data. Depends on the architecture we are currently generating code for.߰ghcPrints 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.ghcSame as  pprLEBWord, but for a signed numberghcGenerates 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 characterghcGenerate 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.ghc4the register to produce an unwinding table entry forghc&the old and new values of the register/ŰưǰȰɰʰ˰̰ͰΰϰаѰҰӰ԰ְհ°ðİװذڰ۰ܰݰްٰ߰/ŰưǰȰɰʰ˰̰ͰΰϰаѰҰӰ԰ְհ°ðİװذڰ۰ܰݰްٰ߰ Safe-Inferred 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 )*/16 Oghc1Constraint type to bundle up the requirement for   on both the id and the  of it. See Note [NoGhcTc].Oghc.Maps the "normal" id type for a given GHC passOghcAllows 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].PghcUsed as a data type index for the hsSyn AST; also serves as a singleton type for PassghcMarks 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]OOOOOOOOOOOOPPPPPPPPPPPPPPPOOOOOOOOOOOOPPPPP Safe-Inferred e9bghcWhether o is a synonym for .bghcSomething is promoted to the type-level without a promotion tick.bghc"Explain how something is in scope.bghc8It was locally bound at this particular source location.bghc6It was imported by this particular import declaration.bghcSuggest how to fix an import.bghcSome module exports what we want, but we aren't explicitly importing it.bghcSome module exports what we want, but we are explicitly hiding it.bghcAn b< for a '.hsig' file. This is generated by GHC in case of a DriverUnexpectedSignature and suggests a way to instantiate a particular signature, where the first argument is the signature name and the second is the module where the signature was defined. Example:src/MyStr.hsig:2:11: error: Unexpected signature: @MyStr@ (Try passing -instantiated-with="MyStr= MyStr" replacing  MyStr as necessary.)bghc$A type for hints emitted by GHC. A hint suggests a possible way to deal with a particular warning or error.bghcAn "unknown" hint. This type constructor allows arbitrary -- hints to be embedded. The typical use case would be GHC plugins -- willing to emit hints alongside their custom diagnostics.bghcSuggests adding a particular language extension. GHC will do its best trying to guess when the user is using the syntax of a particular language extension without having the relevant extension enabled.Example: If the user uses the keyword "mdo" (and we are in a monadic block), but the relevant extension is not enabled, GHC will emit a 'SuggestExtension RecursiveDo'.Test case(s): parser should_failT12429, parser should_fail$T8501c, parser should_failT18251e, ... (and many more)bghcSuggests that a monadic code block is probably missing a "do" keyword.Example: main = putStrLn "hello" putStrLn "world"Test case(s): parser should_failT8501a, parser should_fail)readFail007, parser should_failInfixAppPatErr, parser should_failT984bghc;Suggests that a "let" expression is needed in a "do" block.Test cases: None (that explicitly test this particular hint is emitted).bghcSuggests to add an ".hsig" signature file to the Cabal manifest.Triggered by: -, if Cabal is being used.Example: See comment of DriverUnexpectedSignature.Test case(s): driver/T12955bghcSuggests to explicitly list the instantiations for the signatures in the GHC invocation command.Triggered by: ", if Cabal is not being used.Example: See comment of DriverUnexpectedSignature.Test case(s): driver/T12955bghc'Suggests to use spaces instead of tabs.Triggered by: .)Examples: None Test Case(s): Nonebghc4Suggests adding a whitespace after the given symbol.+Examples: None Test Case(s): parsershould_compile T18834a.hsbghcSuggests adding a whitespace around the given operator symbol, as it might be repurposed as special syntax by a future language extension. The second parameter is how such operator occurred, if in a prefix, suffix or tight infix position.Triggered by: .;Example: h a b = a+b -- not OK, no spaces around n.Test Case(s): parsershould_compile T18834b.hsbghc.Suggests wrapping an expression in parentheses)Examples: None Test Case(s): NonebghcSuggests to increase the -fmax-pmcheck-models limit for the pattern match checker.Triggered by: Test case(s): pmcheckshould_compile)TooManyDeltas pmcheckshould_compile)TooManyDeltas pmcheckshould_compileT11822bghcSuggests adding a type signature, typically to resolve ambiguity or help GHC inferring types.bghcSuggests to explicitly discard the result of a monadic action by binding the result to the '_' wilcard.>Example: main = do _ <- getCurrentTimebghcSuggests adding an identifier to the export list of a signature.bghcSuggests increasing the limit for the number of iterations in the simplifier.bghcSuggests to explicitly import Type from the + module, because using "*" to mean  relies on the StarIsType extension, which will become deprecated in the future.Triggered by:  Example: None Test case(s): wcompat-warnings/WCompatWarningsOn.hsbghcSuggests placing the  qualified keyword after the module name.Triggered by: = Example: None Test case(s): module/mod184.hsbghc0Suggests using TemplateHaskell quotation syntax.Triggered by:  only if TemplateHaskell is enabled. Example: None Test case(s): parser should_fail T13450TH.hsbghc;Suggests alternative roles in case we found an illegal one.Triggered by: 2 Example: None Test case(s): roles should_fail Roles7.hsbghcSuggests qualifying the o1 operator in modules where StarIsType is enabled.Triggered by:  Test case(s): warningsshould_compile StarBinder.hsbghc0Suggests that a type signature should have form  variable ::  type( in order to be accepted by GHC.Triggered by:  Test case(s): parser should_failT3811bghc:Suggests to move an orphan instance or to newtype-wrap it.Triggered by:  Test cases(s): warningsshould_compile&T9178 typecheckshould_compileT4912bghcSuggests to use a standalone deriving declaration when GHC can't derive a typeclass instance in a trivial way.Triggered by: ! Test cases(s): typecheck should_fail tcfail086bghcSuggests the user to fill in the wildcard constraint to disambiguate which constraint that is.6Example: deriving instance _ => Eq (Foo f a)Triggered by: $ Test cases(s): partial-sigs should_fail T13324_fail2bghc)Suggests to use an identifier other than forall Triggered by: bghcSuggests to use the appropriate Template Haskell tick: a single tick for a term-level ,, or a double tick for a type-level .Triggered by: .bghcSuggests enabling -ddump-splices to help debug an issue when a  is not in scope or is used in multiple different namespaces (e.g. both as a data constructor and a type constructor).Concomitant with  NoExactName or SameName errors, see e.g. "GHC.Rename.Env.lookupExactOcc_either". Test cases: T5971, T7241, T13937.bghcSuggests adding a tick to refer to something which has been promoted to the type level, e.g. a data constructor.Test cases: T9778, T19984.bghcSomething is split off from its corresponding declaration. For example, a datatype is given a role declaration in a different module.&Test cases: T495, T8485, T2713, T5533.bghcSuggest a similar name that the user might have meant, e.g. suggest  when the user has written travrese.Test case: mod73.bghcRemind the user that the field selector has been suppressed because of -XNoFieldSelectors.4Test cases: NFSSuppressed, records-nofieldselectors.bghc,Suggest importing from a module, removing a hiding clause, or explain to the user that we couldn't find a module with the given  .,Test cases: mod28, mod36, mod87, mod114, ...bghcSuggest importing a data constructor to bring it into scope Triggered by: Test cases: ccfail004bghcSuggest to enable the input extension. This is the hint that GHC emits if this is not a "known" fix, i.e. this is GHC giving its best guess on what extension might be necessary to make a certain program compile. For example, GHC might suggests to enable BlockArguments when the user simply formatted incorrectly the input program, so GHC here is trying to be as helpful as possible. If the input   is not empty, it will contain some extra information about the why the extension is required, but it's totally irrelevant/redundant for IDEs and other tools.bghcSuggest to enable the input extensions. The list is to be intended as  disjuctive' i.e. the user is suggested to enable any) of the extensions listed. If the input   is not empty, it will contain some extra information about the why the extensions are required, but it's totally irrelevant/redundant for IDEs and other tools.bghcSuggest to enable the input extensions. The list is to be intended as  conjunctive' i.e. the user is suggested to enable all& the extensions listed. If the input   is not empty, it will contain some extra information about the why the extensions are required, but it's totally irrelevant/redundant for IDEs and other tools.bghcSuggest to enable the input extension in order to fix a certain problem. This is the suggestion that GHC emits when is more-or-less clear "what's going on". For example, if both DeriveAnyClass and GeneralizedNewtypeDeriving5 are turned on, the right thing to do is to enabled DerivingStrategies, so in contrast to b GHC will be a bit more "imperative" (i.e. "Use X Y Z in order to ... "). If the input   is not empty, it will contain some extra information about the why the extensions are required, but it's totally irrelevant/redundant for IDEs and other tools.bghcThe bindings we have available in scope when suggesting an explicit type signature.bghc8An unknown binding (i.e. too complicated to turn into a )bghc4Suggests a single extension without extra user info.bghcLike b. but allows supplying extra info for the user.bghcSuggests to enable every extension in the list.bghcLike b. but allows supplying extra info for the user.bghcSuggests to enable any extension in the list.bghcLike b. but allows supplying extra info for the user.bghcWhether a constructor name is printed out as a bare symbol, e.g. :.*True for symbolic names in infix position.Used for pretty-printing.bghc$Display info about the treatment of o under NoStarIsType.%With StarIsType, three properties of o 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 o! 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 o as  out of habit. So it is important to give a hint whenever an assumption about o is violated. Unfortunately, it is somewhat difficult to deal with (c), so we limit ourselves to (a) and (b).b returns appropriate hints 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 o0 or its Unicode variant, we will suggest using '; otherwise we won't suggest anything.bghc8fixity declaration, role annotation, type signature, ...ghcthe ' for the declaration sitebbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb Safe-Inferred)*89:? g$bghcUsed to describe warnings and errors o The message has a file/line/column heading, plus "warning:" or "error:", added by mkLocMessage o With b the message is suppressed o Output is intended for end usersbghcIgnore this message, for example in case of suppression of warnings users don't want to see. See Note [Suppressing Messages]bghcThe class for a diagnostic message. The main purpose is to classify a message within GHC, to distinguish it from a debug/dump message vs a proper diagnostic, for which we include a b.bghcLog message intended for compiler developers No file/line/column stuffbghcLog messages intended for end users. No file/line/column stuff.bghcDiagnostics from the compiler. This constructor is very powerful as it allows the construction of a b- with a completely arbitrary permutation of b and b,. As such, users are encouraged to use the mkMCDiagnostic smart constructor instead. Use this constructor directly only if you need to construct and manipulate diagnostic messages directly, for example inside ". In all the other circumstances,  especially when emitting compiler diagnostics, use the smart constructor.bghcAn 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 b that carries specific information like where the error happened, etc. Finally, multiple bs are aggregated into b that are returned to the user.bghc=The SrcSpan is used for sorting errors into line-number orderbghc The reason why a b was emitted in the first place. Diagnostic messages are born within GHC with a very precise reason, which can be completely statically-computed (i.e. this is an error or a warning no matter what), or influenced by the specific state of the DynFlags) at the moment of the creation of a new b#. For example, a parsing error is always going to be an error, whereas a 'WarningWithoutFlag Opt_WarnUnusedImports' might turn into an error due to '-Werror' or '-Werror=warn-unused-imports'. Interpreting a b together with its associated b gives us the full picture.bghcBorn as a warning.bghc"Warning was enabled with the flag.bghcBorn as an error.bghc A generic b message, without any further classification or provenance: By looking at a b we don't know neither where it was generated nor how to intepret its payload (as it's just a structured document). All we can do is to print it out and look at its b.bghc A generic Hint message, to be used with b.bghcA class identifying a diagnostic. Dictionary.com defines a diagnostic as:"a message output by a computer diagnosing an error in a computer program, computer system, or component device".A b carries the actual description of the message (which, in GHC's case, it can be an error or a warning) and the reason why such message was generated in the first place. See also Note [Rendering Messages].bghcA b 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.bghcA collection of messages emitted by GHC during error reporting. A diagnostic message is typically a warning or an error. See Note [Messages]. INVARIANT: All the messages in this collection must be relevant, i.e. their b should not be b. The smart constructor b# will filter out any message which b is b.bghcAdds a Message to the input collection of messages. See Note [Discarding Messages].bghcJoins two collections of messages together. See Note [Discarding Messages].bghc Joins many b s togetherbghcCreates a new b out of a list of  .bghcCreates a new b out of a single  bghc Joins two b together. The resulting b will have a number of entries which is the sum of the lengths of the input.bghc5Apply a transformation function to all elements of a b.bghcHelper function to use when no hints can be provided. Currently this function can be used to construct plain b and add hints to them, but once #18516 will be fully executed, the main usage of this function would be in the implementation of the b9 typeclass method, to report the fact that a particular b has no hints.cghcCreate an error b holding just a single  cghc Create a b% from a list of bulleted SDocs and a bcghcCreate an error b from a list of bulleted SDocsghc Shows an b.cghc5Make an unannotated error message with location info.cghc;Make a possibly annotated error message with location info.cghcReturns L if this is, intrinsically, a failure. See Note [Intrinsic And Extrinsic Failures].cghc5Are there any hard errors here? -Werror warnings are not; detected. If you want to check for -Werror warnings, use c.cghcReturns L if the envelope contains a message that will stop compilation: either an intrinsic error or a fatal (-Werror) warningcghc.Are there any errors or -Werror warnings here?cghcPartitions the b and returns a tuple which first element are the warnings, and the second the errors.cghcoptional annotationghcWhat kind of message?ghclocationghcmessagebbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbccccbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb bbbbbbccccccccccccbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbccccbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb bbbbbbcccccccccccc Safe-Inferred =ghcLog hooks stackghcDump hooks stackghcTrace hooks stackghc= to the given valuecghcUpdate LogFlagscghc Set LogFlagscghcSet the trace flushing functionThe currently set trace flushing function is passed to the updating functioncghc!Calls the trace flushing functionghc.Default trace flushing function (flush stderr)cghc Log somethingcghcDump somethingcghcTrace somethingcghcPush a log hookcghcPop a log hookcghcPush a dump hookcghcPop a dump hookcghcPush a trace hookcghcPop a trace hookcghcMake the logger thread-safecghcLike c but appends an extra newline.cghcThe boolean arguments let's the pretty printer know if it can optimize indent by writing ascii ' ' characters without going through decoding.cghcDefault action for  dumpAction hookghcWrite out a dump.If --dump-to-file is set then this goes to a file. otherwise emit to stdout (via the the LogAction parameter).When hdr is empty, we print in a more compact format (no separators and blank lines)cghc#Run an action with the handle of a 3, if we are outputting to a file, otherwise J.ghc>Choose where to put a dump file based on LogFlags and DumpFlagcghcDefault action for  traceAction hookcghc Log somethingcghcDump somethingcghcLog a trace messagecghc$Log a dump message (not a dump file)cghc!Dump if the given DumpFlag is setcghc!Dump if the given DumpFlag is setUnlike c!, has a PrintUnqualified argumentcghc9Ensure that a dump file is created even if it stays emptycccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc8 Safe-Inferred Y ghcUnfolding optionsghc0The 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 expressionnghc2Threshold above which unfoldings are not *created*nghc2Threshold above which unfoldings are not *inlined*nghc,Discount for lambdas that are used (applied)nghcDiscount for dictionariesnghc!Force inlining in many more casesnghcDon't consider depth up to xnghcPenalize depth with 1/xnghc9Only report inlining decisions for names with this prefixghc)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%KJ nnnnnnnnn nnnnnnnnnnnnnnnnn%KJ nnnnnnnnn nnnnnnnnnnnnnnnnn Safe-Inferred (8 cghcMonomorphic version of  Validity' specialised for  s.cghcEverything is finecghc%A problem, and some indication of whycghcEnabled warningscghcFatal warningscghcTreat warnings as errorscghcReverse error reporting ordercghcMax reported error countcghcError printing contextcghc Computes the right b for the input b& out of the 'DiagOpts. This function has to be called when a diagnostic is constructed, i.e. with a 'DiagOpts "snapshot" taken as close as possible to where a particular diagnostic message is built, otherwise the computed b9 might not be correct, due to the mutable nature of the DynFlags in GHC.cghcMake a b for a given b, consulting the 'DiagOpts.cghc Varation of c which can be used when we are sure the input b is b.cghcWrap a b in a b,, recording its location. If you know your b is an error, consider using c), which does not require looking at the ccghcWrap a b in a b, recording its location. Precondition: the diagnostic is, in fact, an error. That is, (diagnosticReason msg == ErrorWithoutFlag.cghc= 2 or -ddump-timings).See Note [withTiming] for more.ghc Worker for d and d.dghcLike d but with  SevOutput rather then SevInfodghc+Trace a command (when verbosity level >= 3)dghcThe name of the phaseghc.A function to force the result (often either const () or rnf)ghc!The body of the phase to be timeddghcThe name of the phaseghc.A function to force the result (often either const () or rnf)ghc!The body of the phase to be timedghcThe 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 timedccccdddbbbbbbbbbbbbbbbbbbbbb bbbbbcbcddddccccccccccbbcccccccccccccbcddddddddddddddddccccdddbbbbbbbbbbbbbbbbbbbbb bbbbbcbcddddccccccccccbbcccccccccccccbcdddddddddddddddd Safe-Inferred dghcUsed when a temp file is created. This determines which component Set of FilesToClean will get the temp filedghcA file with lifetime TFL_CurrentModule will be cleaned up at the end of upweep_moddghcA file with lifetime TFL_GhcSession will be cleaned up at the end of runGhc(T)dghc do ...The tmpDir: will be a new subdirectory of the given directory, e.g.  src/sdist.342.dghcDirectory name template. See  openTempFile.ghc#Callback that can use the directorydghc)Temp directory to create the directory inghcDirectory name template. See  openTempFile.ghc#Callback that can use the directorydddddddddddddddddddddddddddddddddddddddddddddddd Safe-Inferred #dghcCurrent profiledghcThe module being compiled. This field kept lazy for Cmm/Parser.y which preloads it with a panicdghc&Temp Dir for files used in compilationdghcContext for StgToCmm phasedghcThe verbosity of debug messagesdghcThreshold at which Binary literals (e.g. strings) are either dumped to a file and a CmmFileEmbed literal is emitted (over threshold), or become a CmmString Literal (under or at threshold). CmmFileEmbed is only supported with the NCG, thus a Just means two things: We have a threshold, and will be using the NCG. Conversely, a Nothing implies we are not using NCG and disables CmmFileEmbed. See Note [Embedding large binary blobs] in GHC.CmmToAsm.Ppr, and  cgTopBinding in GHC.StgToCmm.dghc0Max size, in bytes, of inline array allocations.dghcTicky profiling enabled (cf -ticky)dghcTrue indicates ticky prof traces allocs of each named thing in addition to allocs _by_ that thingdghcTrue indicates ticky uses name-specific counters for join-points (let-no-escape)dghcTrue indicates ticky uses name-specific counters for dynamic thunksdghcTrue indicates ticky will count number of avoided tag checks by tag inference.dghcLoopification enabled (cf -floopification)dghcInsert alignment check (cf -falignment-sanitisation)dghc)perform code generation for code coveragedghc)Check if cost-centre profiling is enableddghctrue means generate C Stub for IPE map, See note [Mapping Info Tables to Source Positions]dghc;true means omit heap checks when no allocation is performeddghc=true means don't generate interface programs (implied by -O0)dghctrue if -fPICdghctrue if -fPIEdghctrue if -fexternal-dynamic-refs>, meaning generate code for linking against dynamic librariesdghc>decides whether to check array bounds in StgToCmm.Prim or notdghc!Verify tag inference predictions.dghcAllowed to emit larger than native size arithmetic (only LLVM and C backends)dghc(Allowed to generate QuotRem instructionsdghcAllowed to generate QuotRemdghc2Allowed to generate AddWordC, SubWordC, Add2, etc.dghc'Allowed to generate IntMul2 instructiondghc%Allowed to generate Fabs instructionsdghc+Disable use of precomputed standard thunks.dghcError (if any) to raise when vector instructions are used, see #StgToCmm.Prim.checkVecCompatibilitydghc$check for Advanced Vector Extensionsdghc&check for Advanced Vector Extensions 2dghc,check for Advanced Vector 512-bit Extensions(dddddddddddddddddddddddddddddddddddddddd(dddddddddddddddddddddddddddddddddddddddd Safe-Inferred /  dghcOutput should be to a temporary file: we're going to run more compilation steps on this output later.dghcWe want a persistent file, i.e. a file in the current directory derived from the input filename, but with the appropriate extension. eg. in "ghc -c Foo.hs" the output goes into ./Foo.o.dghcThe output must go into the specific outputFile in DynFlags. We don't store the filename in the constructor as it changes when doing -dynamic-too.dghc>No output should be created, like in Interpreter or NoBackend.dghcStop just after this phasedghc!basename of original input sourcedghc!basename of original input sourcedghc its extensiondghc%says where to put the pipeline outputdghcLift a f action into an m action.dddddddddddddddddddddddddddddddd Safe-Inferred "ghc 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 reg move instruction or Nothing if it's not oneέح֭߭ӭϭЭѭҭԭڭխ׭٭ۭܭݭޭέح֭߭ӭϭЭѭҭԭڭխ׭٭ۭܭݭޭ Safe-Inferred 5jȯɯʯ˯̯ͯȯɯʯ˯̯ͯ Safe-Inferred ;үghcFor 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/ C 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-Inferred DD Safe-Inferred E$ghcOutput the ELF .size directive.ghc7Print appropriate alignment for the given section type.ghcProcedure name Safe-Inferred F(ghc>Helper to check whether the data resides in a DLL or not, see  labelDynamicghcSays what we have to add to our 'PIC base register' in order to get the address of a label.   Safe-Inferred )* Wghc+Memory addressing modes 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.ghc#Condition codes passed up the tree.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.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 j' 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]ghc1Generate C call to the given function in ghc-primghc-Generate C call to the given function in libcghc0Generate C call to the given function in the RTSghcGenerate a real C call to the given address with the given conventionghcThis 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.ghcCount trailing zeroesghcCount trailing zeroes#64-bit width on 32-bit architectureghcCount trailing zeroes!Generic case (width <= word size)ghc Copy memoryUnroll memcpy calls if the number of bytes to copy isn't too large (cf ncgInlineThresholdMemcpy). Otherwise, call C's memcpy.ghcSet memory to the given byteUnroll memset calls if the number of bytes to copy isn't too large (cf ncgInlineThresholdMemset). Otherwise, call C's memset.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.ghcfunction to callghcwhere to put the resultghcarguments (of mixed type)ghcThe block we are inghcThe block we are inghcMachOpghcwhere to put the resultghcarguments (of mixed type)ghcthe block we are inghcMachOpghcwhere to put the resultghcarguments (of mixed type)ghcaddress of the function to callghccalling conventionghcwhere to put the resultghcarguments (of mixed type)ghcaddress of function to callghccalling conventionghcwhere to put the resultghcarguments (of mixed type)ghcCFG if presentghcBlocks with info tablesghcList of basic blocks Safe-Inferred Xghc-Instruction instance for x86 instruction set. Safe-Inferred)* [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.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.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 (pre-order?) yields the insns in the correct order.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 ")* d 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.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 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 Safe-Inferred d}ghc Instruction instance for aarch64 Safe-Inferred %)* d   Safe-Inferred ? fJghcEach module is given a unique ) to redirect compilation messages to. A J value contains the result of compilation, and denotes the end of the message queue.ghc(Internal helper for writing log messagesghc0Return all items in the queue in ascending order Safe-Inferred i dghc6A command-line warning message and the reason it arosedghcA command-line error messagedghcUsed when filtering warnings: if a reason is given it can be filtered out when displaying.eghc4GHC flag modes describing when a flag has an effect.eghc-The flag only affects the non-interactive GHCeghc)The flag only affects the interactive GHCeghc#The flag affects multiple ghc modeseghc.This flag should not be seen in cli completionghc Parse an IntLooks for "433" or "=342", with no trailing gubbins * n or =n => Just n * gibberish => NothingghcDiscards a leading equals signeghc%Parse a response file into arguments.eghccmdline parser specghcargsghcresponse file handler1eeddddddddeeeeeeeeeeeeeeeeeeeeddddddddddddeeeeeee1eeddddddddeeeeeeeeeeeeeeeeeeeeddddddddddddeeeeeee Safe-Inferred  nghcFlag in string formnghcFlag in internal formnghcExtra action to run when the flag is found Typically, emit a warning or errornghc%In which ghc mode the flag has effectnghc&Don't try to build dynamic objects toonghc*Will still try to generate dynamic objectsnghc5Currently generating dynamic objects (in the backend)oghc+Flags for manipulating packages visibility.oghc-package,  -package-idoghc  -hide-packageoghc%Flags for manipulating package trust.oghc -trustoghc  -distrustoghc6Flags for manipulating the set of non-broken packages.oghc -ignore-packageoghcRepresents 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)]oghc%Bring all exposed modules into scope?oghc Bring module m into scope under name n.oghcWe accept flags which make packages visible, but how they select the package varies; this data type reflects what selection criterion is used.oghc-package, by  PackageNameoghc -package-id, by  oghc-What to do in the link step, if there is one.oghcDon't link at alloghcLink object code into a binaryoghcUse the in-memory dynamic linker (works for both bytecode and object code).oghcLink objects into a dynamic lib (DLL on Windows, DSO on ELF platforms)oghcLink objects into a static liboghc(Link objects into a merged "GHCi object"oghcThe o 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.oghc--make , GHCi, etc.oghc  ghc -c Foo.hsoghcghc -M, see GHC.Unit.Finder for why we need thisoghc!See Note [LLVM configuration] in  GHC.SysTools.oghcno SCC annotations addedoghc,top-level and nested functions are annotatedoghc"top-level functions annotated onlyoghc!exported functions annotated onlyoghcannotate call-sitesoghc"Contains not only a collection of 2s but also a plethora of information relating to the compilation of a single file or GHC sessionoghcThe backend to use (if any).7Whenever you change the backend, also make sure to set o 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].oghcN.B. It's important that this field is lazy since we load the LLVM configuration lazily. See Note [LLVM configuration] in  GHC.SysTools.oghcLLVM optimisation leveloghc,Verbosity level: see Note [Verbosity levels]oghc%How much debug information to produceoghcNumber of simplifier phasesoghcMax simplifier iterationsoghcAdditional demand analysisoghcThe number of modules to compile in parallel in --make mode, where Nothing ==> compile as many in parallel as there are CPUs.oghcEnable RTS timing statistics?oghcThe heap size to set.oghcMaximum number of bindings from the type envt to show in type error messagesoghcMaximum number of hole fits to show in typed hole error messagesoghcMaximum number of refinement hole fits to show in typed hole error messagesoghcMaximum level of refinement for refinement hole fits in typed hole error messagesoghcMaximum number of unmatched patterns to show in non-exhaustiveness warningsoghcSoft limit on the number of models the pattern match checker checks a pattern against. A safe guard against exponential blow-up.oghcMultiplier for simplifier ticksoghcWhether DmdAnal should optimistically put an Unboxed demand on returned products with at most this number of fieldsoghcThreshold for SpecConstroghc2Max number of specialisations for any one functionoghcMax number of specialisations for recursive types Not optional; otherwise ForceSpecConstr can diverge.oghcBinary literals (e.g. strings) whose size is above this threshold will be dumped in a binary file by the assembler code generator. 0 and Nothing disables this feature. See .oghcThreshold for LiberateCaseoghc%Arg count for lambda floating See oghcMaximum number of arguments after lambda lifting a recursive function.oghcMaximum number of arguments after lambda lifting a non-recursive function.oghcLambda lift even when this turns a known call into an unknown call.oghc4Align Cmm functions at this boundary or use default.oghcSimplification history sizeoghcTypechecker maximum stack depthoghcNumber of iterations in the constraints solver Typically only 1 is neededoghcTarget home unit-idoghcId of the unit to instantiateoghcModule instantiationsoghc8What the package is called, use with multiple home unitsoghc&Target way flags from the command lineoghcIndicate if we are now generating dynamic output because of -dynamic-too. This predicate is used to query the appropriate fields (outputFile/dynOutputFile, ways, etc.)oghc1This defaults to 'non-module'. It can be set by  or 'ghc.GHCi.UI.runStmt'% based on where its output is going.oghc Override the o set by  or 'ghc.GHCi.UI.runStmt' . Set by -ddump-file-prefixpghcPath to store the .mix filespghcthe -fplugin flags given on the command line, in *reverse* order that they're specified on the command line.pghcthe -ffrontend-opt flags given on the command line, in *reverse* order that they're specified on the command line.pghcThe  -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.pghcThe -ignore-package flags from the command line. In *reverse* order that they're specified on the command line.pghcThe -package and  -hide-package flags from the command-line. In *reverse* order that they're specified on the command line.pghcThe -plugin-package-id flags from command line. In *reverse* order that they're specified on the command line.pghcThe -trust and  -distrust flags. In *reverse* order that they're specified on the command line.pghcFilepath to the package environment file (if overriding default)pghcSafe Haskell modepghcUnfolding control See Note [Discounts and thresholds] in GHC.Core.Unfoldpghc8GHCi scripts specified by -ghci-script, in reverse orderpghc-what kind of {-# SCC #-} to add automaticallypghc(Machine dependent flags (-m stuff)pghc8Run-time linker information (what options we need, etc.)pghcRun-time C compiler informationpghcRun-time assembler informationpghc0Max size, in bytes, of inline array allocations.pghcOnly inline memcpy if it generates no more than this many pseudo (roughly: Cmm) instructions.pghcOnly inline memset if it generates no more than this many pseudo (roughly: Cmm) instructions.pghc/Reverse the order of error messages in GHC/GHCipghc*Limit the maximum number of errors to showpghc9Unique supply configuration for testing build determinismpghc/Temporary: CFG Edge weights for fast iterationspghcUsed 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.pghc!See Note [Implicit include paths]pghcAppend 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.pghcAppend 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"pghcThese includes are not considered while fingerprinting the flags for iface | See Note [Implicit include paths]pghcConcatenate and flatten the list of global and quoted includes returning just a flat list of paths.pghc "unbuild" a  from a o. This shouldn't be needed in the vast majority of code. But GHCi questionably uses this to produce a default o1 from which to compute a flags diff for printing.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 versionqghcAre we building with -fPIE or -fPIC enabled?qghcUsed by  to partially initialize a new o valueqghc The normal o. Note that they are not suitable for use in this form and must be fully initialized by  first.qghcThe language extensions implied by the various language variants. When updating this be sure to update the flag documentation in docs users_guideexts.qghcTest whether a 3 is setqghcSet a 3qghcUnset a 3qghcTest whether a 2 is set Note that o (i.e., dynamic objects built with `-dynamic-too`) always implicitly enables Opt_PIC, Opt_ExternalDynamicRefs, and disables Opt_SplitSections.qghcSet a 2qghcUnset a 2qghcTest whether a 1 is setqghcSet a 1qghcUnset a 1qghcTest whether a 1 is set as fatalqghcMark a 1 as fatal (do not set the flag)qghcMark a 1 as not fatalqghcTest whether a  is setqghcSet a qghcUnset a qghcSet or unset a 7, unless it has been explicitly set or unset before.ghc(Set the Haskell language standard to useqghcIs the -fpackage-trust mode onqghc9Is Safe Haskell on in some way (including inference mode)qghc(Is the Safe Haskell safe language in useqghc.Is the Safe Haskell safe inference mode activeqghc(Test if Safe Imports are on in some formghcSet a 'Safe Haskell' flagqghcAre all direct imports required to be safe for this Safe Haskell mode? Direct imports are when the code explicitly imports a moduleqghcAre 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.ghcCombine 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.qghcA 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 offqghcA 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 offqghc3Retrieve the options corresponding to a particular opt_* field in the correct orderqghcGets the verbosity flag for the current verbosity level. This is fed to other tools, so GHC-specific verbosity flags like  -ddump-most are not includedghc Sets the o to be appropriate to the optimisation level and signals if any changes took placeqghc Sets the o, to be appropriate to the optimisation levelqghcParse dynamic flags from a list of command line arguments. Returns the parsed o=, the left-over arguments, and a list of warnings. Throws a  if errors occurred during parsing (such as unknown flags or missing arguments).qghcLike q 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.qghcA helper to parse a set of flags from a list of command-line arguments, handling response files.qghcParses 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.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.qghcAll dynamic flags option strings without the deprecated ones. These are the user facing strings for enabling and disabling options.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.qghcMake a list of flags for shell completion. Filter all available flags into two groups, for interactive GHC vs all other.ghcDefine a new flag.ghc!Define a new flag with an effect.ghcDefine a warning flag.ghc%Define a warning flag with an effect.ghc,Define a new deprecated flag with an effect.ghcDefine a new deprecated flag.ghc!Define a deprecated warning flag.ghc8Define a deprecated warning name substituted by another.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 n 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.qghc Find the n for a 1.qghcThese -W flags can all be reversed with  -Wno-ghcThese - flags can all be reversed with  -no-ghcThese -d flags can all be reversed with  -dno-qghcThese -f flags can all be reversed with  -fno-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-qghcThese -f 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.qghcThese -X blah$ flags can all be reversed with -XNo blahghcThese 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.ghcThings you get with `-dlint`.qghcGet target profileqghc1Resolve any internal inconsistencies in a set of o. Returns the consistent o6 as well as a list of warnings to report to the user.qghc,Indicate if cost-centre profiling is enabledqghc1Indicate whether we need to generate source notesqghcShould we use `-XLinker -rpath` when linking or not? See Note [-fno-use-rpaths]qghc&Initialize the pretty-printing optionsqghcInitialize the pretty-printing options using the default user styleqghc/Pretty-print the difference between 2 DynFlags.For now only their general flags but it could be extended. Useful mostly for debugging.qghco to retrieve the options fromghc%Relevant record accessor: one of the opt_* accessorsghc#Correctly ordered extracted optionsqghcUpdated o-, left-over arguments, and list of warnings.qghcUpdated o-, left-over arguments, and list of warnings.qghcvalid flags to match againstghc current stateghcarguments to parseghc(leftovers, errors, warnings)qghcvalid 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 flag333333333333333333333444444444444444444444444444444444444444444444444444444444444444444444444222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222223333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333311111111111111111111111111111111111111111111111111111111111111111111222222222222222222222222222222bbbb4444nnnooooooqqqqqqqqqqqqqqqqqqqqqqqqqqnnnnqqqqoooooppooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppqqqnnnnnnoooonnnnnnoooopoooooooqooooooooooqooooonoooonnnnnnnqqqqqq4qqqqqqqqqqqqqqoooooooooppppppppppppppppppppppppppppppppppppppppppppqqqqqqqqqqqqqqqqnqqqqqnnqqqqqqqqqqqqqqqqqqqqqqqqqqqqnnnnnnnnnnnnnnqpppppppppqq333333333333333333333444444444444444444444444444444444444444444444444444444444444444444444444222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222223333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333311111111111111111111111111111111111111111111111111111111111111111111222222222222222222222222222222bbbb4444nnnooooooqqqqqqqqqqqqqqqqqqqqqqqqqqnnnnqqqqoooooppooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppqqqnnnnnnoooonnnnnnoooopoooooooqooooooooooqooooonoooonnnnnnnqqqqqq4qqqqqqqqqqqqqqoooooooooppppppppppppppppppppppppppppppppppppppppppppqqqqqqqqqqqqqqqqnqqqqqnnqqqqqqqqqqqqqqqqqqqqqqqqqqqqnnnnnnnnnnnnnnqpppppppppqq Safe-Inferred ' tghcSubstitution on module variables, mapping module names to module identifiers.tghc!The result of performing a lookuptghc-Found the module uniquely, nothing else to dotghc,Multiple modules with the same name in scopetghcNo 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 hiddentghcNo modules found, but there were some unusable ones with an exact name matchtghc6Nothing found, here are some suggested different namesghcFor 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'A reverse dependency index, mapping an   to the   s which have a dependency on it.tghc"The reason why a unit is unusable.tghcWe ignored it explicitly using -ignore-package.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.tghcThis unit transitively depends on a unit which was shadowed by an ABI-incompatible unit.tghc Unit databasetghc A mapping of   to R>. This list is adjusted so that only valid units are here. R5 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 I.)tghcThe set of transitively reachable units according to the explicitly provided command line arguments. A fully instantiated VirtUnit may only be replaced by a RealUnit from this set. See Note [VirtUnit to RealUnit improvement]tghc A mapping of R to  . If several units have the same package name (e.g. different instantiations), then we return one of them... This is used when users refer to packages in Backpack includes. And also to resolve package qualifiers with the PackageImports extension.tghc7A mapping from database unit keys to wired in unit ids.tghcA mapping from wired in unit ids to unit keys from the database.tghcThe units we're going to link in eagerly. This list should be in reverse dependency order; that is, a unit is always mentioned before the units it depends on.tghcUnits which we explicitly depend on (from a command line flag). We'll use this to generate version macros and the unused packages warning. The original flag which was used to bring the unit into scope is recorded for the -Wunused-packages warning.tghcThis is a full map from   to all modules which may possibly be providing it. These providers may be hidden (but we'll still want to report them in error messages), or it may be an ambiguous import.tghc A map, like t$, but controlling plugin visibility.tghcA map saying, for each requirement, what interfaces must be merged together when we use them. For example, if our dependencies are p[A=] and q[A=,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.tghc0Indicate if we can instantiate units on-the-fly.This should only be true when we are type-checking an indefinite unit. See Note [About units] in GHC.Unit.ghc Map from  & to a set of module providers (i.e. a   and its t).NB: the set is in fact a 'Map Module ModuleOrigin', probably to keep only one origin for a given  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 unitsghc< records the various aspects of visibility of a particular  .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 .tghcGiven 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!tghcModule 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.)tghc6Module is unavailable because the package is unusable.tghc7Module is public, and could have come from some places.tghc Just False) means that this module is in someone's exported-modules$ list, but that package is hidden;  Just True means that it is available; Nothing means neither applies.tghcIs the module available from a reexport of an exposed package? There could be multiple.tghc]:B maps to  p[A=q():A]:B with A=q():A; similarly,  maps to q():A.ughcSubstitutes holes in a  , suitable for renaming when an include occurs; see Note [Representation of module/name variables].p[A=] maps to p[A=] with A=.ughcLike u, but requires only ClosureUnitInfoMap so it can be used by GHC.Unit.State.ughc(Like 'renameHoleUnit, but requires only ClosureUnitInfoMap so it can be used by GHC.Unit.State.ughc Injects an  to   (see also u.ughc9Print unit-ids with UnitInfo found in the given UnitStateughc8Add package dependencies on the wired-in packages we useghc Home unit idghcHome unit instance ofghcHome unit instantiationsmRRRRRRRRRRRRRRRRRRRRRtttttttttttttttttttttttuuuuuuutuuuuuuuuuuuuuuuutttttttttttttttttttttttuuuutuuuuuuuuuuuuuuutttttttttttttttttttttttuuuuuuutuuuuuuuuuuuuuuuutttttttttttttttttttttttuuuutuuuuuuuuuuuuuuu Safe-Inferred %ughcu 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 unusedughc'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).ughcHome-package modules directly imported by the module being compiled.ughc5Packages directly needed by the module being compiledughcDo 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.NamesughcThis 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. See Note [Tracking Trust Transitively] in GHC.Rename.NamesughcDomain is all modules which have hs-boot files, and whether we should import the boot version of interface file. Only used in one-shot mode to populate eps_is_boot.ughc Signature modules below this oneughcOrphan modules below us in the import tree (and maybe including us for imported modules)ughcFamily instance modules below us in the import tree (and maybe including us for imported modules)ughcRecords modules for which changes may force recompilation of this module See wiki: https://gitlab.haskell.org/ghc/ghc/wikis/commentary/compiler/recompilation-avoidanceThis differs from Dependencies. A module X may be in the dep_mods of this module (via an import chain) but if we don't use anything from X it won't appear in our UsageughcModule from another packageughcModule from the current packageughcA file upon which the module depends, e.g. a CPP #include, or using TH's addDependentFileughc-A requirement which was merged into this one.ughc#External package module depended onughc:Cached module ABI fingerprint (corresponds to mi_mod_hash)ughc)Was this module imported as a safe importughcName of the moduleughcEntities we depend on, sorted by occurrence name and fingerprinted. NB: usages are for parent names only, e.g. type constructors but not the associated data constructors.ughcFingerprint for the export list of this module, if we directly imported it (and hence we depend on its export list)ughcExternal file dependency. From a CPP #include or TH addDependentFile. Should be absolute.ughc of the file contents.ughcAn optional string which is used in recompilation messages if file in question has changed.ughcThe *interface* hash of the module, not the ABI hash. This changes when anything about the interface (and hence the module) has changed.ughcDependency information about ALL modules and packages below this one in the import hierarchy. This is the serialisable version of u.(Invariant: the dependencies of a module M never includes M.0Invariant: none of the lists contain duplicates.Invariant: lists are ordered canonically (e.g. using stableModuleCmp)1See Note [Transitive Information in Dependencies]ughcAll home-package modules which are directly imported by this one. This may include modules from other units when using multiple home unitsughcAll packages directly imported by this module I.e. packages to which this module's direct imports belong. Does not include other home units when using multiple home units. Modules from these units will go in uughcAll units needed for pluginsughc4Transitive closure of hsig files in the home packageughcAll modules which have boot files below this one, and whether we should use the boot file or not. This information is only used to populate the eps_is_boot field. See Note [Structure of dep_boot_mods]ughcTransitive closure of orphan modules (whether home or external pkg).(Possible optimization: don't include family instance orphans as they are anyway included in u. But then be careful about code which relies on dep_orphs having the complete list!) This does NOT include us, unlike u.ughcTransitive closure of depended upon modules which contain family instances (whether home or external). This is used by checkFamInstConsistency%. This does NOT include us, unlike u9. See Note [The type family instance consistency story].ughcExtract information from the rename and typecheck phases to produce a dependencies information for the module being compiled.0The fourth argument is a list of plugin modules.ughcUpdate module dependencies containing orphans (used by Backpack)ughcUpdate module dependencies containing family instances (used by Backpack)ughcPretty-print unit dependencies)uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu)uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu Safe-Inferred       mRRRRRRRRRRRRRRRRRRRRRttttttttttttttttttttttttttttttttttttttttttttttttuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu  Safe-Inferred "9vghc1Locations and information the finder cares about.Should be taken from DynFlags via initFinderOpts.vghc9Where are we allowed to look for Modules and Source filesvghcWhen looking up a home module:L-: search interface files (e.g. in '-c' mode)I-: search source files (e.g. in '--make' mode)vghcDon't check that an imported interface file actually exists if it can only be at one location. The interface will be reported as v even if the file doesn't exist, so this is only useful in specific cases (e.g. to generate dependencies with `ghc -M`)vghcIf we encounter unknown modules, should we suggest modules that have a similar name.vghc/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 ).vghcThe module was foundvghc The requested unit was not foundvghc"_Error_: both in multiple packagesvghc Not foundvghcPlaces where I lookedvghcJust p => module is in this unit's manifest, but couldn't find the .hi filevghc7Module is in these units, but the *module* is hiddenvghc5Module is in these units, but the *unit* is hiddenvghc,Module is in these units, but it is unusablevghcPossible mis-spelled modulesvghcThe v 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.(vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv(vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv Safe-Inferred 'vghc"A module name: search for the filevghcA filename: preprocess & parse it to find the module name. If specified, the Phase indicates how to compile this file (which phase to start from). Nothing indicates the starting phase should be determined from the suffix of the filename.vghcA compilation target.A target may be supplied with the actual text of the module. If so, use this instead of the file contents (this is for use in an IDE where the file hasn't been saved by the user yet).7These fields are strict because Targets are long lived.vghcmodule or filenamevghcobject code allowed?vghc%id of the unit this target is part ofvghcOptional in-memory buffer containing the source code GHC should use for this target instead of reading it from disk.Since GHC version 8.10 modules which require preprocessors such as Literate Haskell or CPP to run are also supported.If a corresponding source file does not exist on disk this will result in a  SourceError exception if targetId = TargetModule _! is used. However together with targetId = TargetFile _/ GHC will not complain about the file missing. vvvvvvvvvvvv vvvvvvvvvvvv Safe-Inferred /ughcAn entry to be inserted into a module's static pointer table. See Note [Grand plan for static forms] in GHC.Iface.Tidy.StaticPtrTable.ughc3Objects which have yet to be linked by the compilerughcAn object file (.o)ughcStatic archive file (.a)ughc3Dynamically linked library file (.so, .dll, .dylib)ughcA byte-code object, lives only in memory. Also carries some static pointer table entries which should be loaded along with the BCOs. See Note [Grand plan for static forms] in GHC.Iface.Tidy.StaticPtrTable.ughcInformation we can use to dynamically link modules into the compilerughcTime at which this linkable was built (i.e. when the bytecodes were produced, or the mod date on the files)ughcThe linkable module itselfughc3Those files and chunks of code we have yet to link.4INVARIANT: A valid linkable always has at least one u item.ughc6Current global mapping from Names to their true valuesughcThe current global mapping from RdrNames of DataCons to info table addresses. When a new Unlinked is linked into the running image, or an existing module in the image is replaced, the itbl_env must be updated appropriately.ughc7The currently loaded interpreted modules (home package)vghc8And the currently-loaded compiled modules (home package)vghcThe currently-loaded packages; always object code haskell libraries, system libraries, transitive dependenciesvghcWe need to remember the name of previous temporary DLL/.so libraries so we can link them (see #10322)vghc6Is this an actual file on disk we can link in somehow?vghc1Is this a bytecode linkable with no file on disk?vghcRetrieve the filename of the linkable if possible. Panic if it is a byte-code objectvghcRetrieve the compiled byte-code if possible. Panic if it is a file-based linkable0vvvuuuuuvvvvuuuuuuvvuuuuuuuuvvvvvvvuuuuuuuuuuuuu0vvvuuuuuvvvvuuuuuuvvuuuuuuuuvvvvvvvuuuuuuuuuuuuu Safe-Inferred 48vghcExternal interpreter instancevghcValues 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).vghc5Configuration needed to spawn an external interpretervghcExternal program to runvghcCommand-line optionsvghcUse Profiling wayvghcUse Dynamic wayvghcHookvghc!Trace action executed after spawnvghc State of an external interpretervghcNot spawned yetvghcRunningvghcExternal 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).vghcExternal interpretervghcInternal interpretervghc Interpretervghc)Interpreter instance (internal, external)vghcInterpreter loadervvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvM Safe-Inferred ]ghc;tcEqType implements typechecker equality, as described in 4Note [Typechecker equality vs definitional equality].ghcIs this type variable a concrete type variable, i.e. it is a metavariable with r r?rghc7Reason why a type cannot be marshalled through the FFI.rghc0Reason why a type in an FFI signature is invalidrghcWhat caused us to create a r? metavariable? See Note [ConcreteTv] in GHC.Tc.Utils.Concrete.rghcA r< used to enforce the representation-polymorphism invariants.See   for more information.rghcWhat restrictions are on this metavariable around unification? These are checked in GHC.Tc.Utils.Unify.startSolvingByUnification.rghcThis MetaTv is an ordinary unification variable A TauTv is always filled in with a tau-type, which never contains any ForAlls.rghcA variant of TauTv, except that it should not be unified with a type, only with a type variable See Note [TyVarTv] in GHC.Tc.Utils.TcMTyperghc6A unification variable used in the GHCi debugger. It is/ allowed to unify with a polytype, unlike TauTvrghcA unification variable that can only be unified with a concrete type, in the sense of Note [Concrete types] in GHC.Tc.Utils.Concrete. See Note [ConcreteTv] in GHC.Tc.Utils.Concrete. See also Note [The Concrete mechanism] in GHC.Tc.Utils.Concrete for an overview of how this works in context.rghcWhat 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 r tree. So if you pass in >SynAny `SynFun` (SynList `SynFun` SynType Int) `SynFun` SynAny/you'll get three types back: one for the first r, the element) type of the list, and one for the last r". You don't get anything for the r, 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.rghcAny typerghc5A rho type, skolemised or instantiated as appropriaterghc6A list type. You get back the element type of the listrghc A function.rghc A known type.rghcLike r, but for an expected type.See r.rghcAn r which has a fixed RuntimeRep.For a r r , the stored r' must have a fixed RuntimeRep. For an r r, the r field must be of the form  Just frr_orig.rghcThis  is for debugging onlyrghc5See Note [TcLevel of ExpType] in GHC.Tc.Utils.TcMTyperghcSee Note [FixedRuntimeRep context in ExpType] in GHC.Tc.Utils.TcMTyperghc-The type that fills in this hole should be a Type, that is, its kind should be TYPE rr for some rr :: RuntimeRep.Additionally, if the r field is  Just frr_orig then rr must be concrete, in the sense of Note [Concrete types] in GHC.Tc.Utils.Concrete.rghcAn expected type to check against during type-checking. See Note [ExpType] in GHC.Tc.Utils.TcMType&, where you'll also find manipulators.rghcA r is a r# which has a syntactically fixed : in the sense of Note [Fixed RuntimeRep] in GHC.Tc.Utils.Concrete.In particular, this means that:J does not panic, does not return J.0This property is important in functions such as matchExpectedFunTys, where we want to provide argument types which have a known runtime representation. See Note [Return arguments with a fixed RuntimeRep.rghcA type which has a syntactically fixed RuntimeRep as per Note [Fixed RuntimeRep] in GHC.Tc.Utils.Concrete.rghcMake an r suitable for checking.rghcLike r but accepts a regular TcTyperghcLike mkFunTys but for rrghcFinds 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 LHSrghcLike r, 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 r (C (T @(F Int) (F Bool))) will return: [ (L, F, [Int]) , (I, F, [Bool]) ] F Int is paired with L since it appears as an  invisible argument to C , whereas F Bool is paired with I since it appears an a visible argument to C. See also 'Note [Kind arguments in error messages] in  GHC.Tc.Errors.rghcIn 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 r for more details on how this works (as this function is called inside of r).rghcCheck that a type does not contain any type family applications.rghcIs this type variable a concrete type variable, i.e. it is a metavariable with r r? Returns the r( stored in the type variable if so, or J otherwise.rghc?Is this type concrete type variable, i.e. a metavariable with r r?rghcIs this type a concrete type variable? If so, return the associated  and r.sghcReturns the (kind, type) variables in a type that are as-yet-unknown: metavariables and RuntimeUnkssghc-Make a sigma ty where all type variables are !>. That is, they cannot be used with visible type application.sghcMake a sigma ty where all type variables are "specified". That is, they can be used with visible type applicationsghc$Splits a forall type into a list of <s and the inner type. Always succeeds, even if it returns an empty list.sghcSplits a type into a TyBinder and a body, if possible. Panics otherwisesghcLike s, but splits off only named binders, returning just the tyvars.sghcLike s, but only splits <s with ! type variable binders.sghcLike s, but only splits a < if argf_pred argf is L, 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.sghcLike s, but only splits <s with != type variable binders. All split tyvars are annotated with ().sghcLike s, but only splits <s with ! type variable binders. All split tyvars are annotated with their .sghcLike s$, but splits off only named binders.sghc'Is this a ForAllTy with a named binder?sghc4Split 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.sghcSplit a sigma type into its parts, going underneath as many arrows and foralls as possible. See Note [tcSplitNestedSigmaTys]sghcLike @, but only returns the .sghcSplit 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 -> ressghc?Strips off n *visible* arguments and returns the resulting typesghcReturns 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.sghcIf the type is a tyvar, possibly under a cast, returns it, along with the coercion. Thus, the co is :: kind tv ~N kind typesghc Just like , but will return True for types of different kinds as long as their non-coercion structure is identical.sghcCheck whether two TyConApps are the same; if the number of arguments are different, just checks the common prefix of arguments.ghcType equality comparing both visible and invisible arguments and expanding type synonyms.sghcLike , but returns True if the visible part of the types are equal, even if they are really unequal (in the invisible bits)sghcLike pickyEqTypeVis$, but returns a Bool for convenienceghcReal worker for . No kind check!sghcLike s, but also says L for r typessghc8Is the type inhabited by machine floating-point numbers?Used to check that we don't use floating-point literal patterns in Core.See #9238 and Note [Rules for floating-point comparisons] in GHC.Core.Opt.ConstantFold.sghc Is a type :?sghcFor 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.sghcIf the tycon is applied to the types, is the next argument visible?sghc2Should this type be applied to a visible argument?rghc Expected typeghc Actual typeghc7Is 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 onlyrrrrrrrrrrrrrrrrrrrrrr>>>>>>>>>>DEDEEEEEEErss>sssrrrrrrrrrrrrrrrrrrrrrr>>>>>>>>>>DEDEEEEEEErss>sssr0 Safe-Inferred6 poxghcWhere to store evidence for expression holes See Note [Holes] in GHC.Tc.Types.Constraintxghc Evidence for  CallStack implicit parameters.xghcEvCsPushCall origin loc stk represents a call from origin, occurring at loc, in a calling context stk.xghcInstructions on how to make a Typeable0 dictionary. See Note [Typeable evidence terms]xghcDictionary 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..xghcDictionary for Typeable (s t), given a dictionaries for s and t.xghcDictionary for Typeable (s % w -> t), given a dictionaries for w, s, and t.xghc%Dictionary for a type literal, e.g. Typeable "foo" or  Typeable 3 The x is evidence of, e.g.,  KnownNat 3 (see #10348)xghcThis version does a slow check, calculating the related types and seeing if they are equal.xghcIf the EqRel is ReprEq, makes a SubCo; otherwise, does nothing. Note that the input coercion should always be nominal.xghcIf a  is $, flip the orientation of a coercionxghcSmart constructor to create a x x.PRECONDITION: the "from" type of the first wrapper must have a syntactically fixed RuntimeRep (see Note [Fixed RuntimeRep] in GHC.Tc.Utils.Concrete).xghcIdentifies the  lambda-bound dictionaries of an x. 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 x. 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!xghc,Any sort of evidence Id, including coercionsxghcd |> coyghc Create a K that unwraps an implicit-parameter dictionary to expose the underlying value. We expect the K- to have the form `IP sym ty`, and return a K `co :: IP sym ty ~ ty`yghc Create a K> that wraps a value in an implicit-parameter dictionary. See y.yghcConvert the QuoteWrapper into a normal HsWrapper which can be used to apply its contents.yghc-The Semigroup instance is a bit fishy, since  WpCompose, as a data constructor, is "syntactic" and not associative. Concretely, if a, b, and c aren't WpHole: (a <> b) <> c ?= a <> (b <> c)> (a `WpCompose` b) `WpCompose` c /= @ a `WpCompose` (b `WpCompose` c)However these two associations are are "semantically equal" in the sense that they produce equal functions when passed to GHC.HsToCore.Binds.dsHsWrapper.xghc&where to write the erroring expressionghc expected type of that expressionghcfor debug output onlyxghcthe "from" type of the first wrapper MUST have a fixed RuntimeRepghceither type of the second wrapper (used only when the second wrapper is the identity)xxxxxxxxxxxxxxxxxxxxxxxxyxxxxxxxxxxxxxxxxxxxxxxxxxxxxyyxxxxxxxxxxxxxxxxxxxxyyxyyyxxxxxxxxxxxxxxghcDoes a computation in the FCode monad, with a current environment and a list of local declarations. Returns the resulting list of declarations.ghcMake a global definition for the string, and return its label߲ݲ޲߲ݲ޲ Safe-Inferred ghc0lower bound (inclusive), upper bound (exclusive)ghcaddToMem 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.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.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.ghcUse signed comparisonsghc&value of pointer which was overwrittenghc the thunk5lܪª5lܪª Safe-Inferred ghcCheck all arguments marked as already tagged for a function are tagged by inserting runtime checks.ghcCheck all required-tagged arguments of a constructor are tagged *at compile time*.ghcCall barf if we failed to predict a tag correctly. This is immensly useful when debugging issues in tag inference as it will result in a program abort when we encounter an invalid call/heap object, rather than leaving it be and segfaulting arbitrary or producing invalid results. We check if either: * A tag is present * Or the object is a 25 (for which zero is the proper tag)ghcJump to the first block if the argument closure is subject to tagging requirements. Otherwise jump to the 2nd one. Safe-Inferred ghc;Emit top-level tables for HPC and return code to initialise Safe-Inferred  Safe-Inferred +ƫūë«īǫȫɫ˫ͫʫ̫Ϋϫƫūë«īǫȫɫ˫ͫʫ̫Ϋϫ Safe-Inferred ghc:FVS, StgArg because for thunks these can also be literals.ghcArgsghc(Number of arguments for a ticky counter.Ticky currently treats args to constructor allocations differently than those for functions/LNE bindings.ghcRegister 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; } } ghcPredicted a pointer would be tagged correctly (GHC will crash if not so no miss case)ghc2Pass a boolean expr indicating if tag was present.ghcCalled when for `case v of ...` we can avoid entering v based on tag inference information.ghcFVsghcArgsghcstaticghc updateableghc Free varsghc updateableghcFree vars + functionghclbl for the counterghcarityghcfun descghcarg descghc json descghcinfo table lblghc!size of the full header, in bytesghcsize of the payload, in bytes   Safe-Inferred 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$Return multiple values to the sequelIf the sequel is Return  return (x,y)If the sequel is AssignTo [p,q]  p=x; q=y;ghcemitCall 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*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.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."ƫūë«īǫȫɫ˫ͫ"ƫūë«īǫȫɫ˫ͫ Safe-Inferred ghc:A local block label (e.g. identifying a case alternative).ºúĺźƺǺȺɺʺ˺̺ͺκϺкѺҺӺԺպֺ׺غٺںۺܺݺ޺ߺºúĺźƺǺȺɺʺ˺̺ͺκϺкѺҺӺԺպֺ׺غٺںۺܺݺ޺ߺ Safe-Inferred 1 ghc%The type used in binder positions in {s.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.ghcGets the bound  out a .ghcReturns J for s and K the flag indicating occurrences as argument or in a nullary applications otherwise.ghcTags every binder with its  and let bindings with their s.ghcTags binders of an { 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 I.ghcCombines several heuristics to decide whether to lambda-lift a given let-binding to top-level. See GHC.Stg.Lift.Analysis#when for details.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"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.ghc free vars ghchow often the RHS was entered ghcIs the binding a let-no-escape?ghcLet bodyghc Binding groupghc9RHS skeletons, argument occurrences and annotated bindingghcIs 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 bindingghcAn 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: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.{{{{{{{{ Safe-Inferred ghc=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-Inferred6 ŠghcCollect class instance matches, including matches that we know are overridden but might still be useful to override other instances (which we call "guards").'See Note [Instance overlap and guards].ghcMinimal matches: we have knocked out all strictly more general matches that are overlapped by a match in this list.ghcGuards: matches that we know we won't pick in the end, but might still be useful for ruling out other instances, as per #20946. See Note [Instance overlap and guards], (A).tghcSet 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).tghct 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.tghcA 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.tghc Class nametghcTop of type args The class itself is always the first element of this listtghcis_dfun_name = idName . is_dfun.We use t for the visibility check, t, which needs to know the   which the dictionary is defined in. However, we cannot use the   attached to t since doing so would mean we would potentially pull in an entire interface file unnecessarily. This was the cause of #12367.tghcA fuzzy comparison function for class instances, intended for sorting instances before displaying them to the user.tghcCollects 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 s 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 definedtghcTest if an instance is visible, by checking that its origin module is in t2. See Note [Instance lookup and orphan instances]tghcChecks for an exact match of ClsInst in the instance environment. We use this when we do signature checking in  GHC.Tc.Moduletghc/Makes no particular effort to detect conflicts.tghcTrue 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-renamingtghcLook 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'.tghcSee 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.SolverghcRemove from the argument list any InstMatches for which another element of the list is more specific, and overlaps it, using the rules of Nove [Rules for instance lookup]ghcComputes whether the first class instance overrides the second, i.e. the first is more specific and can overlap the second.More precisely, instA  instB returns L precisely when:instA is more specific than instB,instB is not more specific than instA,instA is overlapping OR instB is overlappable.ghcAdd a new solution, knocking out strictly less specific ones See Note [Rules for instance lookup] and Note [Instance overlap and guards].Property/: the order of insertion doesn't matter, i.e. ;insert_overlapping inst1 (insert_overlapping inst2 matches) gives the same result as ;insert_overlapping inst2 (insert_overlapping inst1 matches).tghcthe name of the classghc)the rough match signature of the instanceghcthe  of the dictionary bindingghcthe  of the dictionary.ghcmay this instance overlap?ghcis this instance an orphan?!ttttttttttttttttttttttttttttttttttttttttttttttttttttttttttGGttt!ttttttttttttttttttttttttttttttttttttttttttttttttttttttttttGGttt Safe-Inferred YtghcThe t/ 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.tghcLocal type environment for this particular module Includes Ids, TyCons, PatSynstghcDFunId"s for the instances in this moduletghcDomain may include Ids from other modulestghcAnnotations present in this module: currently they only annotate things also declared in this moduletghc&Complete match pragmas for this moduletghcConstructs an empty ModDetails tttttttttt tttttttttt Safe-Inferred8 Ʋ:: Safe-Inferred ghc.Do we force the result to be representational?ghcDo we apply a sym to the result?ghcCoercion optimisation optionsghc.Enable coercion optimisation (reduce its size)ghcoptCoercion applies a substitution to a coercion, *and* optimises it to reduce its sizeghcOptimize a coercion, making no assumptions. All coercions in the lifting context are already optimized (and sym'd if nec'y)ghcOptimize a coercion, knowing the coercion's role. No other assumptions.ghc=Optimize a coercion, knowing the coercion's non-Phantom role.ghc Optimize a non-phantom coercion.ghc Optimize a non-phantom coercion.ghcOptimize a phantom coercion. The input coercion may not necessarily be a phantom, but the output sure will be.ghcCheck to make sure that an AxInstCo is internally consistent. Returns the conflicting branch, if it exists See Note [Conflict checking with AxiomInstCo]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" role Safe-Inferred ghcEnable process jobs support on Windows if it can be expected to work (e.g. process >= 1.6.9.0).ghc Version of &System.Process.readProcessWithExitCode> that takes a key-value tuple to insert into the environment.ghcRun 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/10777ghcBreak 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")ghcstdoutghc program pathghc program argsghcaddition to the environmentghc(exit_code, stdout, stderr) Safe-Inferred ghc,Grab compiler info and cache it in DynFlags.ghc-Grab assembler info and cache it in DynFlags. Safe-Inferred)*/1 ghcThis constraint encodes the fact that no matter what pass we use the Let/Closure extension points are the same as these for 'InferTaggedBinders.ghcId we are binding to. Safe-Inferred vghc3Show a SDoc as a String with the default user stylevghc4Allows caller to specify the PrintUnqualified to usev vv vv vv v Safe-Inferred  Safe-Inferred Ԇghc4Initialize STG pretty-printing options from DynFlags Safe-Inferred ԼҘҘ Safe-Inferred 2ghc4Initialize STG pretty-printing options from DynFlags Safe-Inferred Քvghc!Initialize LogFlags from DynFlagsvv Safe-Inferred ghc Create a new v from DynFlags.vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv Safe-Inferred ~vv Safe-Inferred ghcInitialize the native code generator configuration from the DynFlags Safe-Inferred 9  Safe-Inferred ? ghcLike +, but doesn't catch asynchronous exceptionsvghcAtomically update the reference. Does not force the evaluation of the new variable contents. For strict update, use v.vghcStrict variant of v.wghc2Perform a computation with a different environmentwghc1Perform a computation with an altered environment ....(case x of ...) .. }̢̢ Safe-Inferred ghcThe analysis mode. See .ghc*Each of the entry-points of the analyser (3) has different requirements. The entry-points are wwwFor 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 during w.ghcUsed for finding an expression's eta-expanding arity quickly, without fixed-point iteration (w).ghc.Used for regular, fixed-point arity analysis (w). See Note [Arity analysis] for details about fixed-point iteration. INVARIANT: Disjoint with ae_joins.wghc;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: optimistic one-shot-ness]We rely on this lattice structure for fixed-point iteration in w. For the semantics of w, see Note [ArityType].wghc 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 N. In both cases,  should win over &, see Note [Combining case branches].If div is dead-ending (I), then application to  length os? arguments will surely diverge, similar to the situation with H.wghcmanifestArity sees how many leading value lambdas there are, after looking through castswghc!An approximate, fast, version of wwghc+The number of value args for the arity typewghcTrue  =+ eta-expansion will add at least one lambdaghcSee Note [Dead ends] in GHC.Types.Demand. Bottom implies a dead end.wghcExpand a non-bottoming arity type so that it has at least the given arity.ghcTrim an arity type so that it has at most the given arity. Any excess s are truncated to I, even if they end in ABot.wghcThe Arity returned is the number of value args the expression can be applied to without doing much workghcLeast upper bound in the w lattice. See the haddocks on w for the lattice.Used for branches of a case.ghcThe ArityEnv used by w. Pedantic about bottoms and no application is ever considered cheap.ghcThe ArityEnv used by w.ghc8Whether the analysis should be pedantic about bottoms. w always is.ghc A version of n that considers results from arity analysis and optionally the expression's type. Under w, no expressions are cheap.ghc A version of n that considers results from arity analysis. See Note [Arity analysis] for what's in the signature environment and why it's important.wghc 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'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].wghcSplit an expression into the given number of binders and a body, eta-expanding if necessary. Counts value *and* type binders.wghc(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&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 .wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww Safe-Inferred( 6wghc warn unsupported Llvm versionghctarget triple passed to LLVMghc>mirror DynFlags LlvmConfig. see Note [LLVM configuration] in  GHC.SysTools. This can be strict since GHC.Driver.Config.CmmToLlvm.initLlvmCgConfig verifies the files are present. Safe-InferredghcPrint out a whole LLVM module.ghcPrint out a multi-line comment, can be inside a function or on its ownghc;Print out a comment, can be inside a function or on its ownghc7Print out a list of global mutable variable definitionsghc.Print out a global mutable variable definitionghc&Print out a list of LLVM type aliases.ghcPrint out an LLVM type alias.ghc"Print out a list of LLVM metadata.¸ghc&Print out an LLVM metadata definition.øghc)Print out a list of function definitions.ĸghc Print out a function definition.ghc'Print out a function definition header.Ÿghc)Print out a list of function declaration.ƸghcPrint out a function declaration. Declarations define the function type but don't define the actual body of the function.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)Return the variable name or value of the * in Llvm IR textual representation (e.g. @x, %y or 42).ȸghc)Return the variable name or value of the * in a plain textual representation (e.g. x, y or 42).ɸghcPrint a literal value. No type.ghc Blank line.ghcExclamation point.¸ŸƸøĸʸɸ˸Ǹȸ¸ŸƸøĸʸɸ˸Ǹȸ Safe-Inferred\զ֦צئ٦ڦۦܦͦΦϦЦѦҦӦԦ̦ݦަߦ¦æĦŦƦǦȦɦʦߤ¤äĤŤƤǤȤɤʤˤ̤ͤΤϤФѤҤӤԤդ֤פؤ٤ڤۤܤݤޤ¥åĥťƥȥɥʥ˥ǥޥߥۥХϥҥѥԥ֥ӥեץإ٥ڥܥʸɸ˸ǸȸŸƸøĸ¸զ֦צئ٦ڦۦܦͦΦϦЦѦҦӦԦ̦ݦަߦ¦æĦŦƦǦȦɦʦߤ¤äĤŤƤǤȤɤʤˤ̤ͤΤϤФѤҤӤԤդ֤פؤ٤ڤۤܤݤޤ¥åĥťƥȥɥʥ˥ǥޥߥۥХϥҥѥԥ֥ӥեץإ٥ڥܥʸɸ˸ǸȸŸƸøĸ¸ Safe-Inferred ̸ghc;Get the LlvmVar function variable storing the real register͸ghc;Get the LlvmVar function argument storing the real registerθghc>A list of STG Registers that should always be considered aliveϸghc'STG Type Based Alias Analysis hierarchyghcId 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.Ѹ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.Ҹ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.Ӹ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.Ը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.ոghcThe TBAA metadata identifierָghcGet the correct TBAA metadata information for this register type ͸̸θϸԸѸҸӸиոָ ͸̸θϸԸѸҸӸиոָ Safe-Inferred8"=׸ghcThe Llvm monad. Wraps LlvmEnv state as well as the IO monadghc LLVM versionghcConfiguration for LLVM code genghcLoggerghc 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)ٸ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.Top level LLVM Data (globals and type aliases)۸ghcUnresolved code. Of the form: (data label, data type, unresolved data)ܸghc#Global registers live on proc entry߸ghc)Translate a basic CmmType to an LlvmType.ghc*Translate a Cmm Float Width to a LlvmType.ghc(Translate a Cmm Bit Width to a LlvmType.ghcGHC Call Convention for LLVMghc#Llvm Function type for Cmm functionghcLlvm Function signatureghcAlignment to use for functionsghc Alignment to use for into tablesghcSection to use for a functionghcA Function's argumentsghc=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.ghcLlvm standard fun attributesghcConvert a list of types to a list of function parameters (each with no parameter attributes)ghc Pointer widthghcThe (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.ghcGet target platformghcLifting of IO actions. Not exported, as we want to encapsulate IO.ghcGet initial Llvm environment.ghcGet environment (internal)ghcModify environment (internal)ghc9Clear variables from the environment for a subcomputationghc3Insert variables or functions into the environment.ghc3Insert variables or functions into the environment.ghc1Lookup variables or functions in the environment.ghc1Lookup variables or functions in the environment.ghc(Set a register as allocated on the stackghc2Check whether a register is allocated on the stackghc1Allocate a new global unnamed metadata identifierghc/Get the LLVM version we are generating code forghcDumps the document if the corresponding flag has been set by the userghc.Prints the given contents to the output handleghcMarks a variable as "used"ghc,Return all variables marked as "used" so farghcSaves that at some point we didn't know the type of the label and generated a reference to a type variable insteadghc%Sets metadata node for a given uniqueghc#Gets metadata node for given uniqueghcHere 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.ghcPretty print a .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.ghcDerive the definition label. It has an identified structure type.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!ghc!Is a variable one of the special $llvm globals?ghc=Here we take a global variable definition, rename it with a $def, suffix, and generate the appropriate alias.6޸ݸܸ۸ڸٸظ׸߸6޸ݸܸ۸ڸٸظ׸߸ Safe-Inferred'ghcPrepend the working directory to the search path. Note [Filepaths and Multiple Home Units]ghcRun compiler of C-like languages and raw objects (such as gcc or clang).ghc8Run the linker with some arguments and return the outputghcRun the LLVM OptimiserghcRun the LLVM CompilerghcRun the clang compiler (used as an assembler for the LLVM backend on OS X as LLVM doesn't support the OS X system assembler)ghc
Initialize the Llvm code generator configuration from DynFlags Safe-Inferred+RghcThe string appended to a variable name to create its structure type aliasghc The LLVM visibility of the labelghc4Pass a CmmStatic section to an equivalent Llvm code.ghcProduce an initializer or finalizer array declaration. See Note [Initializers and finalizers in Cmm] in GHC.Cmm.InitFini for details.ghc-Format the section type part of a Cmm Sectionghc-Format a Cmm Section into a LLVM section nameghcHandle static dataghc(Generate Llvm code for a static literal.Will either generate the code or leave it unresolved if it is a  which isn't yet known. Safe-Inferred,lghcPretty print LLVM data code¹ghcPretty print LLVM codeùghcThe section we are putting info tables and their entry code into, should be unique since we process the assembly pattern matching this.¹ù¹ù Safe-Inferred )*B:ghcA 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 expressionĹghc)Top-level of the LLVM proc Code generatorghcGenerate 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 "(Crɹ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 necessaryɹɹ Safe-Inferred)*8H ghcData 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.˹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 statsghcMake 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 56QPghc4Maps of docs that were added via Template Haskell's putDoc.Pghc4The added module header documentation, if it exists.Pghc(The documentation added to declarations.Pghc.The documentation added to function arguments.Pghc6The documentation added to class and family instances.PghcModule header.PghcDocs for declarations: functions, data types, instances, methods etc. A list because sometimes subsequent haddock comments can be combined into onePghc>Docs for arguments. E.g. function arguments, method arguments.PghcMap from chunk name to content.This map will be empty unless we have an explicit export list from which we can reference the chunks.PghcHaddock options from OPTIONS_HADDOCK or from  -haddock-opts.PghcThe 4! used in the module, for example 4.Pghc7The full set of language extensions used in the module.PghcA simplified version of .PghcAnnotate a value with the probable identifiers found in it These will be used by haddock to generate links.The identifiers are bundled along with their location in the source file. This is useful for tooling to know exactly where they originate.This type is currently used in two places - for regular documentation comments, with a set to 6<, and for adding identifier information to warnings, where a is  StringLiteralPghc8A docstring with the (probable) identifiers found in it.PghcExtract a mapping from the lexed identifiers to the names they may correspond to.PghcPretty print a thing with its doc The docstring will include the comment decorators '-- |', '{-|' etc and will come either before or after depending on how it was written i.e it will come after the thing if it is a '-- ^' or '{-^' and before otherwise.PghcSee  pprWithHsDocPghc6Print a doc with its identifiers, useful for debuggingPghcFor compatibility with the existing @-ddump-parsed' output, we only show the docstring.Use pprHsDoc to show P 's internals.PghcWe might re-export avails from multiple modules with a single export declaration. E.g. when we have 7module M (module X) where import R0 as X import R1 as X;PPPPPPPPPP6666666666666666666666666PPPPPPPPPPPPPPPPPPPPPPPP"PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP Safe-Inferred 56SRghc Warning information for a moduleRghcNothing deprecatedRghcWhole module deprecatedRghcSome specific things deprecatedRghc Warning Text6reason/explanation from a WARNING or DEPRECATED pragmaRghcConstructs the cache for the  mi_warn_fn field of a ModIface RRRRRRRRRRR RRRRRRRRRRR Safe-Inferred16^!ghcImported or Exported WildcardghcImported or exported entity.ghcImported or Exported Variableghc+Imported or exported Thing with Absent list+The thing is a Class/Type (can't tell) - 7s : 7, 8,8ghc8Imported or exported Thing with All imported or exportedThe thing is a Class"Type and the All refers to methods constructors7s : 7 , 7,7#, 8ghc: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] - 7s : 7%, 7%, 7%, 8ghc$Imported or exported module contents (Export Only)7s : 7ghcDoc section headingghcSome documentationghcReference to named docghcLocated Import or Exportghc(Located name with possible adornment - 7s : 8 , 7€ghcA 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 extraĀghc pattern Xŀghc type (:+:)πghcImport DeclarationA single Haskell import declaration.рghc7s77, 7 for ideclSource8,8, 7,7, 87,7, 7) attached to location in ideclHidingԀghc Module name.ՀghcPackage qualifier.րghcIsBoot  = {-# SOURCE #-} import׀ghcTrue => safe import؀ghcIf/how the import is qualified.ـghc$True => implicit import (of Prelude)ڀghc as Moduleۀghc(True => hiding, names)܀ghcIf/how an import is  qualified.݀ghc qualified! appears in prepositive position.ހghc qualified" appears in postpositive position.߀ghcNot qualified.ghcLocated Import DeclarationghcGiven two possible located  qualified tokens, compute a style (in a conforming Haskell program only one of the two can be not J). This is called from  GHC.Parser.ghcConvenience function to answer the question if an import decl. is qualified.ghcWhen in a list this may have7 : 7ghcWhen in a list this may have7 : 8:€ŀĀÀƀ̀̀ˀʀɀȀǀ΀πۀڀـ؀׀րՀԀӀҀрЀ܀߀ހ݀:܀߀ހ݀πۀڀـ؀׀րՀԀӀҀрЀ΀ƀ̀̀ˀʀɀȀǀ€ŀĀÀ Safe-Inferred/6d5AghcOverloaded Literal ValueAghcInteger-looking literals;AghcFrac-looking literalsAghcString-looking literalsAghcHaskell Overloaded LiteralAghcHaskell LiteralAghc CharacterAghcUnboxed characterAghcStringAghc Packed bytesAghcGenuinely an Int; arises from GHC.Tc.Deriv.Generate, and from TRANSLATIONAghcliteral Int#Aghcliteral Word#Aghcliteral Int64#Aghcliteral Word64#AghcGenuinely an integer; arises only from TRANSLATION (overloaded literals are done with HsOverLit)AghcGenuinely a rational; arises only from TRANSLATION (overloaded literals are done with HsOverLit)Aghc Unboxed FloatAghcUnboxed DoubleAghcA p l returns L if a literal l- needs to be parenthesized under precedence p.AghcA p ol returns L if an overloaded literal ol, needs to be parenthesized under precedence p.AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA Safe-Inferred/156EPghcAmbiguous 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". See Note [Located RdrNames] in  GHC.Hs.Expr.Pghc!Located Ambiguous Field OccurencePghcField OccurrenceRepresents an *occurrence* of a field. This may or may not be a binding occurrence (e.g. this type is used in P and RecordPatSynField' which bind their fields, but also in  HsRecField5 for record construction and patterns, which do not).We store both the ' the user originally wrote, and after the renamer we use the extension field to store the selector function.PghcLocated Field OccurrencePghcDescribes 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).PghcConstructor Declaration FieldPghcSee Note [ConDeclField passs]Pghc7 : 7Pghc%Located Constructor Declaration FieldPghcHaskell Tuple SortQghcThis is used in the syntax. In constructor declaration. It must keep the arrow representation.Qghc2Denotes the type of arrows in the surface languageQghca -> b or a C bQghca %1 -> b or a %1 C b, or a E bQghca %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 Q9 so as to preserve the syntax as written in the program.QghcHaskell Type LiteralQghc Haskell TypeQghc7 : 7 , 7,7= For details on above see Note [exact print annotations] in GHC.Parser.AnnotationQghc7 : NoneQghc7 : NoneQghc7 : 8,Qghc7 : 7 '[' , 7 ']'Qghc7 : 7  '(' or '(#' , 7  ')' or '#)'Qghc7 : 7 '(#' , 7 '#)'@Qghc7 : NoneQghc7 : 7 '(' , 7 ')'Qghc  (?x :: ty)7 : 7Qghc7 : NoneQghc  (ty :: kind)7 : 7 '(' , 7,7 ')'Qghc7 : 7 '$(' , 7 ')'Qghc7 : NoneQghc7 : 7 '{-# UNPACK' or '{-# NOUNPACK' , 7 '#-}' 7 '!'Qghc7 : 7 '{' , 7 '}'Qghc7 : 7 "'[" , 7 ']'Qghc7 : 7 "'(" , 7 ')'Qghc7 : NoneQghc7 : NoneQghcHaskell 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.Qghc7 : 7 , 7, 7QghcThese names are used early on to store the names of implicit parameters. They completely disappear after type-checking.Qghc A type signature that obeys the forall&-or-nothing rule. In other words, an Q that uses an Q to represent its outermost type variable quantification. See #Note [Representing type signatures].Qghc'Located Haskell Signature Wildcard TypeQghcLocated Haskell Wildcard TypeQghcLocated Haskell Signature TypeQghcThe extension field for Q2, which is only used in the renamer onwards. See ,Note [Pattern signature binders and scoping].QghcWildcard namesQghcImplicitly bound variable namesQghcTypes 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].QghcAfter renamer: QQghcMain payload (the type itself)QghcHaskell Wildcard BindersQghc.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 Q flag.QghcUsed for signatures, e.g., f :: forall a {b}. blah We use  for the Q flag to allow distinguishing between specified and inferred type variables.Qghc6The outermost type variables in a type that obeys the forall-or-nothing rule. See Note [forall-or-nothing rule].QghcImplicit forall, e.g., f :: a -> b -> bQghcExplicit forall, e.g., f :: forall a b. a -> b -> bQghc)Located Haskell Quantified Type VariablesQghc$Located Haskell Type Variable BinderQghc The type variable binders in an Q . See also 1Note [Variable Specificity and Forall Visibility] in GHC.Tc.Gen.HsType.Qghc A visible forall (e.g., forall a -> {...}). These do not have any notion of specificity, so we use () as a placeholder value.Qghc An invisible forall (e.g., forall a {b} c. {...}), where each binder has a .QghcLocated Haskell KindQghc Haskell KindQghcLocated Haskell TypeQghcHaskell ContextQghcLocated Haskell ContextQghc Bang TypeIn the parser, strictness and packedness annotations bind more tightly than docstrings. This means that when consuming a Q (and looking for Q8) we must be ready to peer behind a potential layer of Q . See #15206 for motivation and  getBangType for an example.QghcLocated Bang TypeQghc Does this Q' come with an explicit kind annotation?QghcAn empty list that can be used to indicate that there are no type arguments allowed in cases where HsConDetails is applied to Void.QghcQ id fixity args! pretty-prints an application of id to args , using the fixity to tell whether id. should be printed prefix or infix. Examples: pprHsArgsApp T Prefix [HsTypeArg Bool, HsValArg Int] = T @Bool Int pprHsArgsApp T Prefix [HsTypeArg Bool, HsArgPar, HsValArg Int] = (T @Bool) Int pprHsArgsApp (++) Infix [HsValArg Char, HsValArg Double] = Char ++ Double pprHsArgsApp (++) Infix [HsValArg Char, HsValArg Double, HsVarArg Ordering] = (Char ++ Double) Ordering ghc.Pretty-print a prefix identifier to a list of Ps.ghcPretty-print an P in isolation.QghcThis instance is meant for debug-printing purposes. If you wish to pretty-print an application of Ps, use Q instead.Pghc May have 7 : 7 when in a listQghc7 : 7Qghc May have 7 : 7 when in a listQghc7 : 8 For details on above see Note [exact print annotations] in GHC.Parser.AnnotationQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQPQQQQQQQQQQQPPPPQQPQQHHHHHHHHHHHHHHPPPPPPPPPPPPQPPPPPPPPPPPQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQPQQQQQQQQQQQPPPPQQPQQHHHHHHHHHHHHHHPPPPPPPPPPPPQPPPPPPPPPPPQQQQB Safe-Inferred(/189:qghcPattern : fghcHaskell Field Binding : ,For details on above see Note [exact print annotations] in GHC.Parser.Annotationfghc!Filled in by renamer when punningfghcNote [Punning]fghcHaskell Record Update FieldfghcHaskell Record Fieldfghc#Located Haskell Record Update FieldfghcLocated Haskell Record FieldfghcLocated Haskell Record FieldfghcHaskell Record FieldsHsRecFields is used only for patterns and expressions (not data type declarations)fghc#Haskell Constructor Pattern DetailsfghcWildcard Pattern The sole reason for a type on a WildPat is to support hsPatType :: Pat Id -> TypefghcVariable PatternfghcLazy Pattern ^ -  : fghcAs pattern ^ -  : fghcBang pattern ^ -  : fghcSyntactic List :  '['&,  ']'fghcTuple sub-patterns :  '(' or '(#',  ')' or '#)'fghcAnonymous sum pattern :  '(#',  '#)'fghcConstructor Patternfghc : fghc :  '$('  ')'fghcLiteral Pattern Used for *non-overloaded* literal patterns: Int#, Char#, Int, Char, String, etc.fghcNatural Pattern :  nfghc n+k patternfghc : fghcParenthesised patternghc :  '('&,  ')'fghc View Patternfghc&Splice Pattern (Includes quasi-quotes)fghcPattern with a type signature+fffffffffffffffffffffffffffffffffffffffff+fffffffffffffffffffffffffffffffffffffffff Safe-Inferred(/5^ghc!Haskell Pattern Synonym Direction^ghcRecord Pattern Synonym Field^ghc'Field label visible in rest of the file^ghc=Filled in by renamer, the name used internally by the pattern^ghcHaskell Pattern Synonym Details^ghcFixity Signature^ghcLocated Fixity Signature^ghcSignatures and pragmas^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 A pattern synonym type signature ,pattern Single :: () => (Show a) => a -> [a] :  , , ,^ghcA 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 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 binding^ghcAn ordinary fixity declaration  infixl 8 *** :  , ^ghcAn inline pragma {#- INLINE f #-} :   '{-# INLINE' and '[' , , , , , ^ghcA specialisation pragma "{-# SPECIALISE f :: Int -> Int #-} : ,  '{-# SPECIALISE' and '[', , ,  ']' and '#-}', ^ghc6A specialisation pragma for instance declarations only ${-# SPECIALISE instance Eq [Int] #-}(Class tys); should be a specialisation of the current instance declaration : , ,^ghc$A minimal complete definition pragma ${-# MINIMAL a | (b, c | (d | e)) #-} : , ,, ^ghc+A "set cost centre" pragma for declarations {-# SCC funName #-}or &{-# SCC funName "cost_centre_name" #-}^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.^ghcLocated Signature^ghcImplicit parameter bindings. : ^ghc"Located Implicit Parameter Binding May have  :  when in a list^ghc#Haskell Implicit Parameter Bindings^ghc : , ,, , '{',  '}',Pattern Synonym binding^ghcName of the pattern synonym^ghcFormal parameter names^ghcRight-hand side^ghcDirectionality_ghc1Haskell Binding with separate Left and Right id's_ghcFunction-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 H 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._ghcVariable BindingDictionary binding and suchlike. All VarBinds are introduced by the type checker_ghcPatterns Synonym Binding_ghc The payload_ghcTicks to put on the rhs, if any_ghcTicks to put on the rhs, if any, and ticks to put on the bound variables._ghcLocated only for consistency_ghcLocated Haskell Binding with separate Left and Right identifier types_ghcLocated Haskell Bindings with separate Left and Right identifier types_ghcHaskell Binding_ghcLocated Haskell Bindings_ghcLocated Haskell Binding_ghcHaskell Value bindings with separate Left and Right identifier types (not implicit parameters) Used for both top level and nested bindings May contain pattern synonym bindings_ghcValue Bindings InBefore renaming RHS; idR is always RdrName Not dependency analysed Recursive by default_ghcValue Bindings OutAfter renaming RHS; idR can be Name or Id Dependency analysed, later bindings in the list may depend on earlier ones._ghcHaskell Value Bindings_ghcHaskell Local Bindings with separate Left and Right identifier typesBindings in a 'let' expression or a 'where' clause_ghcHaskell Value Bindings_ghc#Haskell Implicit Parameter Bindings_ghcEmpty Local Bindings_ghcLocated Haskell local bindings_ghcHaskell Local Bindings_ghc7Extracts the name for a SPECIALIZE instance pragma. In _, the src field of ^ signature contains the SourceText for a SPECIALIZE instance pragma of the form: "SourceText {-# SPECIALIZE"Extraction ensures that all variants of the pragma name (with a Z or an S+) are output exactly as used in the pragma._ghc :  , , ,   '{', '}'^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^_______________________________________________________________________________^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^___________^^^^^^^^^ Safe-Inferred(/156؊_ghcRole Annotation Declaration_ghc :  , _ghc#Located Role Annotation Declaration_ghcAnnotation Provenance_ghcAnnotation Declaration_ghc :  ,   _ghcLocated Annotation Declaration_ghcWarning pragma Declaration_ghc"Located Warning pragma Declaration_ghcWarning pragma Declarations_ghcLocated Warning Declarations_ghc!Documentation comment Declaration_ghc)Located Documentation comment Declaration_ghc Rule Binder_ghc : , ,_ghcLocated Rule Binder_ghcRule Declaration_ghc-After renamer, free-vars from the LHS and RHS_ghcNote [Pragma source text] in GHC.Types.Basic_ghcForall'd type vars_ghcForall'd term vars, before typechecking; after typechecking this includes all forall'd vars_ghc : , ,  ,  , , , ,_ghcLocated Rule Declaration_ghcRule Declarations_ghcLocated Rule Declarations_ghcForeign Declaration_ghc :  , , , _ghcLocated Foreign Declaration_ghcDefault Declaration_ghcs :  , ,_ghcLocated Default Declaration_ghcWhich technique the user explicitly requested when deriving an instance._ghcGHC'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., %, 1, * when -XDeriveFunctor is enabled, etc.)_ghc -XDeriveAnyClass_ghc -XGeneralizedNewtypeDeriving_ghc  -XDerivingVia`ghcA  _.`ghc+Stand-alone 'deriving instance' declaration`ghcThe instance type to derive. It uses an Q9 because the context is allowed to be a single wildcard: !deriving instance _ => Eq (Foo a)4Which signifies that the context should be inferred.`ghc :  , ,  , ,  , ,`ghc3Located stand-alone 'deriving instance' declaration`ghcInstance Declaration`ghcLocated Instance Declaration`ghcClass Instance Declaration -  :  ,  , ,, For details on above see Note [exact print annotations] in GHC.Parser.Annotation`ghc : &, ,`ghc"Located Class Instance Declaration`ghcFamily 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 vars`ghcFixity used in the declaration`ghc : `ghc Data Family Instance Declaration`ghc :  , , ,  , , `ghc(Located Data Family Instance Declaration`ghc Type Family Instance Declaration`ghc :  , ,`ghc(Located Type Family Instance Declaration`ghc)Located type family default declarations.`ghc 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`ghcThe outermost type variable binders, be they explicit or implicit. The  is used to anchor exact print annotations, AnnForall and AnnDot.`ghcUser-written context (if any)`ghcArguments; never infix`ghc Result type`ghcA possible Haddock comment.`ghcTrue  = 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`ghcExistentials only`ghcArguments; can be infix`ghc$Located data Constructor Declaration`ghc newtype Blah ...`ghc  data Blah ...`ghc!Located Standalone Kind Signature`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 Q. For example,  deriving () means "derive zero classes" rather than "derive an instance of the 0-tuple".` use Q 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 single type. Moreover, that type can only be a type constructor without any arguments. Example:  deriving Eq`ghcA deriving clause with a comma-separated list of types, surrounded by enclosing parentheses. Example: deriving (Eq, C a)`ghc A single deriving clause of a data declaration. : ,  , ,  , ,`ghc;The user-specified strategy (if any) to use when deriving `.`ghcThe types to derive.`ghcHaskell Deriving clause`ghcHaskell Data type Definition`ghc:Declares a data type or newtype, giving its constructors  data/newtype T a =  constrs! data/newtype instance T [a] =  constrs `ghcContext`ghcOptional kind signature.(Just k) for a GADT-style data, or  data instance decl, with explicit kind sigAlways Nothing for H98-syntax decls`ghcData constructorsFor data T a = T1 | T2 a the ` s all have `. For data T a where { T1 :: T a } the  LConDecls all have `.`ghc Optional  'deriving' clause`ghcJ if we're in an hs-boot file and the user said "type family Foo x where .."`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 : , `ghcLocated Injectivity Annotation`ghctype Family Declaration`ghc : , , , , , , , , , `ghcLocated type Family Declaration`ghctype Family Result Signatureaghc :aghc : ,, aghc : ,, , aghc$Located type Family Result SignatureaghcType or Class Groupaghcdoes this have a CUSK? See Note [CUSKs: complete user-supplied kind signatures]aghcA type or class declaration.aghc type/data family T :: *->* : , , ,, ,, ,, ,, aghctype declaration : , ,aghcdata declaration : , , , , ,aghc :  , , , The tcdFDs will have ,   For details on above see Note [exact print annotations] in GHC.Parser.AnnotationaghcPost renameer, FVsaghcType constructoraghcType variables; for an associated type these include outer bindersaghcFixity used in the declarationaghcRHS of type declarationaghcPost renamer, CUSK flag, FVsaghcPost renamer, FVsaghc Context...aghcFunctional depsaghcMethods' signaturesaghcDefault methodsaghcAssociated types;aghcAssociated type defaultsaghc Haddock docsaghc&Located Declaration of a Type or ClassaghcSplice DeclarationaghcLocated Splice Declarationaghc Haskell GroupA a is categorised into a a" before being fed to the renamer.aghcA Haskell DeclarationaghcType or Class DeclarationaghcInstance declarationaghcDeriving declarationaghcValue declarationaghcSignature declarationaghcStandalone kind signatureaghc 'default' declarationaghcForeign declarationaghcWarning declarationaghcAnnotation declarationaghcRule declarationaghc+Splice declaration (Includes quasi-quotes)aghc"Documentation comment declarationaghcRole annotation declarationaghcTrue  = argument is a data/newtype declaration.aghc!type or type instance declarationaghc type classaghctype/data family declarationaghctype family declarationaghcopen type family infoaghcclosed type family infoaghcdata family declarationaghc Convert a ` to a :aghcA short description of a DerivStrategy'.`ghc May have  :  when in a list`ghc May have  : # when in a GADT constructor list`ghc The optional deriving clauses of a data declaration. Clauses is plural because one can specify multiple deriving clauses using the -XDerivingStrategies language extension. The list of `s corresponds to exactly what the user requested to derive, in order. If no deriving clauses were specified, the list is empty.aghcWhen in a list this may have : aaaaaaaaaaaaaaaaa```````````aaaa```````````````a````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa````````````````````````````a```````````````````````````````````````````_____`a_________________________aa____aaaa___________________`````````````````````______a___________________a____`aaaaa````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```````````aaaa```````````````a````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa````````````````````````````a```````````````````````````````````````````_____`a_________________________aa____aaaa___________________`````````````````````______a___________________a____`aaaaa````aaaaaaaaaaaaaaaaA Safe-Inferred /16 ghcLocated Haskell ExpressionghcSyntax 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 etcghcGuarded Right-Hand Sides8GRHSs are used both for pattern bindings and for Matches :  , , , , ,ghcHaskell SpliceghcA Haskell expression.fghc  ModuleName. do { ... }fghc  ModuleName.'mdo { ... } ie recursive do-expressionfghc&A command-line Stmt in GHCi pat <- rhsfghcHaskell arrow match context.fghcA proc expressionfghc(A case alternative inside arrow notationfghc1A case or cases alternative inside arrow notationfghcAn arrow kappa abstractionfghcHaskell Statement Context.fghc1Context for HsDo (do-notation and comprehensions)fghc!Pattern guard for specified thingfghcA branch of a parallel stmtfghcA branch of a transform stmtfghc'do-notation in an arrow-command contextfghcHaskell Match ContextContext of a pattern match. This is more subtle than it would seem. See Note [FunBind vs PatBind].gghc8A pattern matching on an argument of a function bindinggghcPatterns of a lambdagghc)Patterns and guards in a case alternativegghcPatterns and guards in case and casesgghc$Guards of a multi-way if alternativegghc%A pattern match inside arrow notationgghc"A pattern binding eg [y] <- e = egghcGuards of pattern bindings, e.g., (Just b) | Just _ <- x = e | otherwise = e'gghcRecord update [used only in GHC.HsToCore.Expr to tell matchWrapper what sort of runtime error message to generate]gghc=Pattern of a do-stmt, list comprehension, pattern guard, etcgghc!A Template Haskell pattern splicegghc1A Template Haskell pattern quotation [p| (a,b) |]gghcA pattern synonym declarationgghcfunction binder of fgghc fixing of fgghcwas f' banged? See Note [FunBind vs PatBind]gghcArithmetic Sequence Informationgghc1Haskell (Untyped) Quote = Expr + Pat + Type + VargghcHaskell Spliced Thing-Values that can result from running a splice.gghcHaskell Spliced ExpressiongghcHaskell Spliced TypegghcHaskell Spliced Patterngghc&Finalizers produced by a splice with See Note [Delaying modFinalizers in untyped splices] in GHC.Rename.Splice. For how this is used.gghcA 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.gghc$splice or $$splicegghc bare splicegghcApplicative Argumentgghc!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 failgghcTrue  = was a BodyStmt, False  =1 was a BindStmt. See Note [Applicative BodyStmt]gghc,context of the do expression, used in pprArggghcThe 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 J.See Note [Monad fail : Rebindable syntax, overloaded strings] for the type of expression in the K 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.gghcParenthesised Statement Blockgghc>Exact print annotations when in qualifier lists or guards -  :  , , , , , ,gghcg2 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.Exprgghc :   '{', '}',gghc : gghcGhci StatementgghcGhci Located StatementgghcGuard StatementgghcGuard Located StatementgghcExpression StatementgghcExpression Located StatementgghcCommand StatementgghcCommand Located Statementgghcdo block Statementgghc3Located Statement with separate Left and Right id'sgghcLocated do block StatementgghcGuarded Right Hand Side.gghcLocated Guarded Right-Hand Sidegghc Guarded RHSsgghcThe where clausegghc Located Match May have  :  when in a listhghcHaskell Record BindingshghcHaskell Top-level CommandhghcTop-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 CommandhghcHaskell arrow application type.hghcFirst order arrow application ->=) 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]hghc.Parenthesised expr; see Note [Parens in HsSyn]ggggghhhggggggghhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhffffffffffffffffffgggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggghhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhgggggggggggggghgggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggghggggggggggggggggggggggggfgggggggggggggggghfffffffffffffffffhhhhhhhhhhhhhhhhhh Safe-Inferred%/ighc0Convert a literal from one index type to anotherighcpmPprHsLit 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)AAAAAAAAAAAAAAAAAAAAAAAAAAAiiiiiiiiiiiiiiiiiiiiiiiiiiii Safe-Inferred / _________________________^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^___^___^___^^___________aaa____```_____`aaaa__________aaaaaaaaaaaaaaaaa```````````a```````````````````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa````````````````````````````````````````````````````````````````````````_______________aaaa___________________`````````````````````_____________________________a`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaagggggggghhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhgggggggggggghhhhhhhhhhhhfggggggggggggggggggggggggggggggggggggggggggggggggggggggghhhhhhhhhhhhhhhhhhhhgffffffghggggghhhhhhghhhgggggggggggggggggggggggggggggggggggggggggggggfffffffffffhhhhhhhhhhhhhhhhhhhhhhhhhhhhAAAAAAAAAAAAAAAAAAAAAAAAAAAfffffffffffffffffffffffffffffffffffffffffQHHHHHHHHHHHHHHQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQPQQQQQQQQQQPPPPPQPPPPPPPPPPPPPPPPPPPPPPPQQQQQQQQQQ Safe-Inferred(/9dyghcReturn the attached flagyghcSet the attached flagyghcDo all type variables in this Q come with kind annotations?yghcConvert an arrow into its corresponding multiplicity. In essence this erases the information of whether the programmer wrote an explicit multiplicity or a shorthand.yghc7Get 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) ^^^^^^^^yghcRetrieve 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.).yghc Compute the  associated with an P.yghcDecompose 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.yghc$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.yghc;Decompose a GADT type into its constituent parts. Returns (outer_bndrs, mb_ctxt, body), where: outer_bndrs are Q if the type has explicit, outermost type variable binders. Otherwise, they are Q.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.yghcDecompose 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 y, this function does not look through parentheses, hence the suffix _KP (short for "Keep Parentheses").yghcDecompose 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 y, this function does not look through parentheses, hence the suffix _KP (short for "Keep Parentheses").yghcDecompose 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.ghcDecompose a type of the form context => body into its constituent parts.Unlike y, this function does not look through parentheses, hence the suffix _KP (short for "Keep Parentheses").yghc3Decompose 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.yghc3Decompose a type class instance type (of the form forall  tvs. context => instance_head ) into the  instance_head.yghc3Decompose 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).yghcPrints the explicit forall in a type family equation if one is written. If there is no explicit forall, nothing is printed.yghcPrints the outermost forall in a type signature if one is written. If there is no outermost forall, nothing is printed.yghc3Prints a forall; When passed an empty list, prints forall ./ forall -> only when  -dppr-debug is enabled.yghcy p t returns L if the type t% needs parentheses under precedence p.yghcy p ty checks if y p ty is true, and if so, surrounds ty with an Q . Otherwise, it simply returns ty.yghcy p ctxt checks if ctxt is a single constraint c such that y p c is true, and if so, surrounds c with an Q to form a parenthesized ctxt . Otherwise, it simply returns ctxt unchanged.yghc Location of forall and -> for HsForAllVis Location of forall and h for HsForAllInvisQQQQQQQQyQQQyyyyQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQyQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQPQQQQyQQQQQQQPPPPQQPyyQQHHHHHHHHHHHHHHyyPPPPPPPPyPPPPQPPPPPPyPPPPPyyyyyyyyyQyyyyyyyyyyQyQyyyyyyyyyyyyyyyyyyyyyyyyyyyyQyyyyyyyyyyyQQQQQQQQyQQQyyyyQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQyQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQPQQQQyQQQQQQQPPPPQQPyyQQHHHHHHHHHHHHHHyyPPPPPPPPyPPPPQPPPPPPyPPPPPyyyyyyyyyQyyyyyyyyyyQyQyyyyyyyyyyyyyyyyyyyyyyyyyyyyQyyyyyyyyyyy Safe-Inferred/6Dyghc!Type checker Specification PragmayghcThe Id to be specialised, a wrapper that specialises the polymorphic function, and inlining spec for the specialised functionyghc*Located Type checker Specification Pragmasyghc#Type checker Specialisation Pragmasy conveys  SPECIALISE/ pragmas from the type checker to the desugareryghcSuper-specialised: a default method should be macro-expanded at every call sitezghcAbstraction Bindings Exportzghc(Any INLINE pragma is attached to this IdzghcSee Note [ABExport wrapper] Shape: (forall abs_tvs. abs_ev_vars => abe_mono) ~ abe_polyzghcSPECIALISE pragmaszghcTypechecked, generalised bindings, used in the output to the type checker. See Note [AbsBinds].zghcIncludes equality constraintszghcAbsBinds 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 typezghc#Evidence bindings Why a list? See GHC.Tc.TyCl.Instance4 Note [Typechecking plan for instance declarations]zghcTypechecked user bindingszghcUsing SourceText in case the pragma was spelled differently or used mixed caseghcAfter the type-checker, the FunBind extension field 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'.ghcAfter the renamer (but before the type-checker), the FunBind extension field contains the locally-bound free variables of this defn. See Note [Bind free vars]_________________________^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^___^___^___^^___________zzzzzzzzzzzzzzzzyyyyzyyyyyzzzzzzzzzzzzzzzzzzzzzzzzz3zzzzzzzzzzzzzzzzyyyyzyyyyyzzzzzzzzzzzzzzzzzzzzzzzzz Safe-Inferred/6N/{ghcThis 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 pattern{ghcExistentially bound type variables in correctly-scoped order e.g. [k:* x:k]{ghcDitto *coercion variables* and *dictionaries* One reason for putting coercion variable here I think is to ensure their kinds are zonked{ghc%Bindings involving those dictionaries{ghcExtra wrapper to pass to the matcher Only relevant for pattern-synonyms; ignored for data cons{ghc8Extension constructor for Pat, added after typechecking.{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.{ghcPattern expansion: original pattern, and desugared pattern, for RebindableSyntax and other overloaded syntax such as OverloadedLists. See Note [Rebindable syntax and HsExpansion].{ghcCoercion Pattern If co :: t1 ~ t2, p :: t2, then (CoPat co p) :: t1{ghc)Why not LPat? Ans: existing locn will do{ghcType of whole pattern, t1ghc)Print with type info if -dppr-debug is on|ghc%Is the pattern any of combination of:(pat) pat :: Type~pat!pat x (variable)|ghc| p pat returns L if the pattern pat% needs parentheses under precedence p.ghc p cp returns L if the constructor patterns cp% needs parentheses under precedence p.|ghc0Parenthesize a pattern without token information|ghc| p pat checks if | p pat is true, and if so, surrounds pat with a f. Otherwise, it simply returns pat.ghc Are we in a -XStrict1 context? See Note [-XStrict and irrefutability]ffffffffffffffffffff{{{{|{{{{{{{f{{{{{{{{fffffffffffffffffff|f|||||||||||||||||fffffffffffffffffffff{{{{|{{{{{{{f{{{{{{{{fffffffffffffffffff|f|||||||||||||||||f Safe-Inferred 1SYghcAn 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 P (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/6X zghcThe locations of forall and h for forall'd type vars Using AddEpAnn to capture possible unicode variantszghcThe locations of forall and h for forall'd term vars Using AddEpAnn to capture possible unicode variantszghcPartition 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 .zghcThe fixity signatures for each top-level declaration and class method in an a7. See Note [Top-level fixity signatures in an HsGroup]zghcDoes this declaration have a complete, user-supplied kind signature? See Note [CUSKs: complete user-supplied kind signatures]zghc-Maybe return name of the result type variablezghcReturn K fields> if a data constructor declaration uses record syntax (i.e., P ), where fields- are the field selectors. Otherwise, return J.zghc Eliminate a _.zghc Map over the via type if dealing with _. Otherwise, return the _ unchanged.aaaaaaaaaaaaaaaaa```````````a```````````````a````zaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaazaaaaazzazzazz````````````aaa``````````````````````z``````zzz```````````````````````````````_____`azzzz____________________zzzzz_____aza____aaaa___________________`````````````````````zzz______a___________________a____z`aaaaa````zzzaaaaaaaaaaaaaaazzzazzaaaaaaaaaaaaaaaaa```````````a```````````````a````zaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaazaaaaazzazzazz````````````aaa``````````````````````z``````zzz```````````````````````````````_____`azzzz____________________zzzzz_____aza____aaaa___________________`````````````````````zzz______a___________________a____z`aaaaa````zzzaaaaaaaaaaaaaaazzzazz Safe-Inferred /156e0|ghcPending Type-checker Splice|ghcPending Renamer Splice|ghcMatch separator location|ghc'('|ghc')'|ghc)HsWrap appears only in typechecker output|ghcExtra data fields for a h, added by the type checker|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.|ghcThe function to use in rebindable syntax. See Note [NoSyntaxExpr].|ghcPost-Type checking TableWe use a PostTcTable where there are a bunch of pieces of evidence, more than is convenient to keep individually.|ghcPost-Type checking ExpressionPostTcExpr is an evidence expression attached to the syntax tree by the type checker (c.f. postTcType).|ghcThis is used for rebindable-syntax pieces that are too polymorphic for tcSyntaxOp (trS_fmap and the mzip in ParStmt)|ghcMake a 'SyntaxExpr GhcRn' from an expression Used only in getMonadFailOp. See Note [Monad fail : Rebindable syntax, overloaded strings] in GHC.Rename.Expr|ghcMake a  from a 4 (the "rn" is because this is used in the renamer).}ghc} p e returns L if the expression e% needs parentheses under precedence p.}ghc4Parenthesize an expression without token information}ghc} p e checks if } p e is true, and if so, surrounds e with an h. Otherwise, it simply returns e.}ghc.Is there only one RHS in this list of matches?}ghc(Just print the original expression (the a).gggggggghhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhgggggggggggghhhhhhhhhhhhfggggggggggggggggggggggggggggggggggggggggggggggggggggggghhhhhhhhhhhhhhhhhhhhgffffffghggggghhhhhhghhhgggggggggggggggggggggggggggggggggggggggggggggfffffffffffhhhhhhhhhhhhhhhhhhhhhhhhhhhh||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||i}iiiii}|}|||||}|||}|}}}}}|}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||i}iiiii}|}|||||}|||}|}}}}}|}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}} Safe-Inferredj]ghcPretty-print an b.ghcPretty-print a b.#Generic helpers for the HsSyn type.((c) The University of Glasgow, 1992-2006 Safe-Inferred()*/1{A$}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.}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}ghc e => (e)}ghcA simple case alternative with a single pattern, no binds, no guards; pre-typechecking}ghcWrap in parens if } appPrec says it needs them So f x becomes (f x), but 3 stays as 3.~ghcA useful function for building OpApps. The operator is always a variable, and we don't know the fixity yet.~ghc NB: Only for  .~ghc Wildcard pattern - after parsing~ghc!Wildcard pattern - after renaming~ghc4The Big equivalents for the source tuple expressions~ghc1The Big equivalents for the source tuple patterns~ghcLifts a "small" constructor into a "big" constructor by recursive decomposition~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 Convert an Q to an Q.~ghc Convert an Q to an Q.~ghcConvert ^ to ^. The former is what is parsed, but the latter is what we need in class/instance declarations~ghc8Not infix, with place holders for coercion and free vars~ghc!In Name-land, with empty bind_fvs~ghcIf any of the matches in the _ are infix, the _ is considered infix.~ghc Return the 0 encompassing the contents of any enclosed binds~ghcConvenience function using ~. This is for generated bindings only, do not use for user-written code.~ghc#Make a prefix, non-strict function f~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.~ghc5Is a binding a strict variable or pattern bind (e.g. !x = ...)?~ghcCollect  binders only, or "s + pattern synonyms, respectively~ghc Collect both s and pattern-synonym binders~ghcSame as ~#, but works over a list of bindingsghcCollect s, or /s + pattern synonyms, depending on boolean flag~ghcUsed exclusively for the bindings of an instance decl which are all FunBinds~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]~ghcSee Note [SrcSpan for binders]~ghcCollects record pattern-synonym selectors only; the pattern synonym names are collected by ~.~ghcthe < returned are for the whole declarations, not just the namesghcthe < returned are for the whole declarations, not just the names~ghc5"Small" constructor function, of maximum input arity ghc/Possible "big" list of things to construct fromghc:Constructed thing made possible by recursive decomposition}}}}}}}}}}}}}~~}}~~~~~~}~}}}}~~}~~}~}}~~~~~~~~~~~~~~~~~~~}~~~~~~~~~~}}}~~~}}~~~~~~~~~~~~}}~~~~yy~~~~~~~~~~}}~~~~~}}~~~~~~~~~~~~~~~~~~~~~~~~~}}}}}}~~~~~~~~~~}}}}}}}}}}}}}~~}}~~~~~~}~}}}}~~}~~}~}}~~~~~~~~~~~~~~~~~~~}~~~~~~~~~~}}}~~~}}~~~~~~~~~~~~}}~~~~yy~~~~~~~~~~}}~~~~~}}~~~~~~~~~~~~~~~~~~~~~~~~~}}}}}}~~~~~~~~~~ Safe-InferredP2~ghcSort the variables, putting type and covars first, in scoped order, and then other IdsIt is a deterministic sort, meaining it doesn't look at the values of Uniques. For explanation why it's important See Note [Unique Determinism] in GHC.Types.Unique.~ghc1Bind a binding group over an expression, using a let or case as appropriate (see GHC.Core#let_app_invariant)~ghcCreate 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 result~ghcBind a list of binding groups over an expression. The leftmost binding group becomes the outermost group in the resulting expression~ghcConstruct 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 first~ghcConstruct an expression which represents the application of a number of expressions to another. The leftmost expression in the list is applied firstRespects the let/app invariant by building a case expression where necessary See Note [Core let/app invariant] in GHC.Core~ghcConstruct an expression which represents the application of one expression to the otherRespects 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 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 an application (e1 e2), or a strict binding (case e2 of x -> e1 x) using the latter when necessary to respect the let/app invariant See Note [Core let/app invariant] in GHC.CoreghcMake 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.EnvghcMake a case expression whose case binder is unused The alts and res_ty should not have any occurrences of WildIdghc1Build a strict application (case e2 of x -> e1 x)ghc Create a J" which will evaluate to the given Intghc Create a J" which will evaluate to the given Int. Don't check that the number is in the range of the target platform Intghc Create a J" which will evaluate to the given Intghc Create a J which will evaluate to the a Word with the given valueghc Create a J" which will evaluate to the given Integerghc Create a J" which will evaluate to the given Naturalghc Create a J" which will evaluate to the given Floatghc Create a J" which will evaluate to the given Doubleghc Create a J" which will evaluate to the given Charghc Create a J" which will evaluate to the given Stringghc Create a J which will evaluate to a string morally equivalent to the given  FastStringghcBuild the type of a small tuple that holds the specified variables One-tuples are flattened; see Note [Flattening one-tuples]ghcBuild a small tuple holding the specified expressions One-tuples are flattened; see Note [Flattening one-tuples]ghcBuild 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]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]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 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]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]ghcThe unit expressionghc 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 ?? times. And all the argument variables must have multiplicity ?.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 ?? times. And all the argument variables must have multiplicity ?.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 } |]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 } |]ghcA 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.ghcAs , but for a tuple that is small enough to be guaranteed not to need nesting.ghc/Applies the floats from right to left. That is wrapFloats [b1, b2, @, bn] u = let b1 in let b2 in @ in let bn in ughc Makes a list [] for lists of the specified typeghc Makes a list (:) for lists of the specified typeghcMake a list containing the given expressions, where the list has the given typeghcMake a fully applied  expressionghcMake a build6 expression applied to a locally-bound worker functionghc&Makes a Nothing for the specified typeghc/Makes a Just from a value of the specified typeghc!Exception with type "forall a. a"Any exceptions added via this function needs to be added to the RTS's initBuiltinGcRoots() function.ghcAn  for an Id, such as  or  raiseOverflow, that throws an (imprecise) exception after being supplied one value arg for every argument I9 in the list. The demands end up in the demand signature. 8Sets the demand signature to unleash the given arg dmds ISets the arity info so that it matches the length of arg demands/Sets a bottoming CPR sig with the correct arityIt's important that all 3 agree on the arity, which is what this defn ensures. ~ghcfunctionghc arguments~ghcfunctionghcargumentghc scrutineeghcres_tyghcaltsghcguardghcthenghcelseghcThe $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 expressionghc-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 tuple argsghcBody of the caseghc,A variable of the same type as the scrutineeghc ScrutineeghcElement type of the listghcFold result typeghcCons! function expression for the foldghcNil expression for the foldghc#List expression being folded acressghc!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 worker~~~~~~~n~~~~~~~~~~~~~~~n~~~~~~~~~4~4 Safe-Inferred΢Ϣ΢Ϣ Safe-Inferred(ghcTarget platformghcGenerate CStub or notghcIds for `unpackCString[Utf8]#`ghc StaticPtrInfo dataconghc StaticPtr dataconghc!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.ghcsptModuleInitCode module fps. is a C stub to insert the static entries of module into the static pointer table.fps is a list associating each binding corresponding to a static entry with its fingerprint.   Safe-Inferred LghcSimple optimiser optionsLghcUnfolding 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 InScopeSetghcFast OutVarSet tracking which recursive RHSs we are analysing. See Note [Eta reduction in recursive RHSs]ghcCoercion optimiser optionsghc)Default options for the Simple optimiser.ghcReturns 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 validghcReturns '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 return LLL LLL Safe-Inferred :ghcData Constructor BoxerghcStrict fields by defaultghc?Disable automatic field unboxing (e.g. if we aren't optimising)ghcUnbox strict fieldsghcUnbox small strict fieldsghcUsed for imported data constructors See Note [Bangs on imported data constructors]ghcConjure a fresh local binder.ghc/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 decisionsghc%a string which will form part of the K's nameghcthe type of the K&:::/&:::/ Safe-InferredcghcA 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 Safe-Inferred Safe-Inferred 18ghc3If the argument expression is (potential chain of) K, return the head of the app chain, and collect ticks/args along the chain.ŢŢ Safe-Inferred"<<<<<<<"<<<<<<< Safe-Inferred^ghc Used to make K for an 1 defined in the module being compiled. See also KghcFind 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 KThis is used for the fast-match-check for rules; if the top names don't match, the rest can'tghcruleCantMatch 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 [_$_]ghcGather all the rules for locally bound identifiers from the supplied bindingsghcThe 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!Initialize RuleOpts from DynFlagsghcReport partial matches for rules beginning with the specified string for the purposes of error reportingghc0Target; can have more elements than the templateghc Rule optionsghcRule activation testghc Rule patternghcRules for an IdghcBindings to check inghcResulting check message Safe-Inferred1ghc7True if it's a bad idea to float bindings into this RHS Safe-Inferred(8А"ghc9Explicit "type-class"-like dictionary for numeric primopsghcAdd two numbersghcSub two numbersghcMultiply two numbersghcAnd two numbersghcOr two numbersghcNegate a numberghc Literal typeghcMatch a literalghcMatch a primopghc(Match the application of a binary 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).ghc+Match BigNat#, Integer and Natural literalsghcMatch numeric literalsghc8Match the application of a DataCon to a numeric literal.Can be used to match e.g.: IS 123# IP bigNatLiteral W# 123##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 literalghcMatch the scrutinee of a case and potentially return a new scrutinee and a function to apply to each literal alternative.ZZ Safe-Inferred56 Safe-Inferred/56 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)ghcHaskell ModuleAll we actually declare here is the top-level structure for a module.ghc7s7,87,8, 7 for explicit braces and semi around hsmodImports,hsmodDecls if this style is used.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)ghc Export listNothing+: export list omitted, so export everythingJust [] : export nothing Just [...]: as you would expect...7s : 7% ,7ghcWe snaffle interesting stuff out of the imported interfaces early on, adding that info to TyDecls/etc; so this list is often empty, downstream.ghc1Type, class, value, and interface signature declsghc9reason/explanation for warning/deprecation of this module7s : 7% ,7ghc-Haddock module info and description, unparsed7s : 7% ,7gggggggffffffffffffffffffffgQaaa____```_____`aaaaHHHHHHHHHHHHHH__________aaaaaaaaaaaaaaaaa```````````a```````````````````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa````````````````````````````````````````````````````````````````````````_______________aaaa___________________`````````````````````_____________________________a`aaaaaaaaaaaaaaa_________________________^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhfffffffffffffffffQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQPQQQQQQQQQQPPPPPQPPPPPPPPPPPPPPPPPPPPPPPhhhhhhggggggg_ggggghhhhhhhhhhhhfgggggggggggggggggggggggggg_ggggggggggggggggggggggggggggg_AAAAAAAAAAAAAAAAAAAAhhhAAAA^___^___^^hhhhhhhhhhhhhhhhhgffffffghggggghhhhhhghhhgggggggggggggggggggggggggggggggggggggggggggggfffffffffffaaaaaaaaaaaaaaaaaaaaaffffQQQQQQQQQQhhaAAA___________hhhhhhhhhhhhhhhhhhhhhhhhhhzzzzzzzzzzzzzzzzyyyyzyyyyyzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||i}iiiii}|}|||||}|||}|}}}}}|}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}πۀڀـ؀׀րՀԀӀҀЀр€ŀÀĀ܀߀݀ހ΀ƀ̀̀ˀʀɀǀȀiiiiiiiiiiiiii{|{{{{{{{{{{{{{{{{{{f||||||||||||||||||yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy}}}}}}~~}}}}}}}}}}}}}~~}}~~~~~~}~}}}}~~}~~}~}}~~~~~~~~~~~~~~~~~~~}~~~~~~~~}}}~~~}}~~~~~~~~~~~~}}~~~~~~~~~~~~~~}}~~~~~}}~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~PPPPPPPPPPPPPPPPPPPPPPPPPPPPP6666666666666PPPPP666666666666OOOOOPPPPOOOPOOOOPPPPP7888888888888888888888888888888777777777777777777777777777777777777777777777777777777777777777777778787877777767777777777777777777777777777777777777777777767676666666777776666666666666666666666666666666666666666666666666666666666668888888888888888888888888888888888888888888888888888888888888888800 Safe-InferredghcData for a module node in a  ModuleGraph/. Module nodes of the module graph are one of:A regular Haskell source moduleA hi-boot source moduleghcIdentity of the moduleghc8The module source either plain Haskell, hs-boot, or hsigghc5Location of the various files belonging to the moduleghcContent hash of source fileghc#Timestamp of object, if we have oneghc+Timestamp of dynamic object, if we have oneghcTimestamp of hi file, if we have one See Note [When source is considered modified] and #9243ghc%Timestamp of hie file, if we have oneghcSource imports of the moduleghc7Non-source imports of the module from the module *text*ghc 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.See Note [Strictness in ModIface] to learn about why some fields are strict and others are not.ghcName of the module we are forÍghcAre we a sig of another mod?čghcBoot? Signature?ōghcThe dependencies of the module. This is consulted for directly-imported modules, but not for anything else (hence lazy)ƍ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Ǎ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 thingsȍghcModule required TH splices when it was compiled. This disables recompilation avoidance (see #481).ɍghcFixities NOT STRICT! we read this field lazily from the interface fileʍghcWarnings NOT STRICT! we read this field lazily from the interface fileˍghcAnnotations NOT STRICT! we read this field lazily from the interface file̍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 changes͍ghc6Binds 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.΍ghcSorted class instanceύghcSorted family instancesЍghc Sorted rulesэghc:True if this program uses Hpc at any point in the program.ҍ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Սghc:Docstrings and related data for use by haddock, the ghci :doc command, and other tools.Just _  = the module was built with -haddock.֍ghcEither () or ۍ% for a fully instantiated interface.׍ghcAdditional 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.؍ghc8Hash of the .hs source, used for recompilation checking.ڍghcSelects a IfaceDecl representation. For fully instantiated interfaces we also maintain a fingerprint, which is used for recompilation checks.ghc9Partial interface built based on output of core pipeline.ۍghcExtends a PartialModIface with information which is either: * Computed after codegen * Or computed just before writing the iface to disk. (Hashes) In order to fully instantiate it.ݍghcHash of the whole interfaceލghcHash of the ABI onlyߍghcHash of the important flags used when compiling the module, excluding optimisation flagsghcHash of optimisation flagsghcHash of hpc flagsghcHash of pluginsghcWhether this module has orphansghcWhether this module has family instances. See Note [The type family instance consistency story].ghcHash of export listghc:Hash for orphan rules, class and family instances combinedghcCached lookup for ʍghcCached lookup for ɍghcCached lookup for ̍. The Nothing in  means that the thing isn't in decls. It's useful to know that when seeing if we are up to date wrt. the old interface. The  + is the parent of the name, if it has one.ghcOld-style accessor for whether or not the ModIface came from an hs-boot file.ghc-Lookups up a (possibly cached) fixity from a . If one cannot be found, 0 is returned instead.ghcThe semantic module for this interface; e.g., if it's a interface for a signature, if  is p[A= A]:A,  will be  A.ghc:The "precise" free holes, e.g., the signatures that this  depends on.ghcGiven a set of free holes, and a unit identifier, rename the free holes according to the instantiation of the unit identifier. For example, if we have A and B free, and our unit identity is p[A= C ,B=impl:B]%, the renamed free holes are just C.ghcConstructs cache for the  field of a :ÍčōƍǍȍɍʍˍ͍̍΍ύЍэҍӍԍՍ֍׍؍ۍ܍ݍލߍڍٍ:ÍčōƍǍȍɍʍˍ͍̍΍ύЍэҍӍԍՍ֍׍؍ۍ܍ݍލߍڍٍ Safe-Inferredyghc;Helps us find information about modules in the home packageghc7Information about modules in the package being compiledghcThe basic loaded interface file: every loaded module has one of these, even if it is imported from another packageghc1Extra information that has been created from the / for the module, typically during typecheckingghcThe actual artifact we would like to link to access things in this module. might be Nothing: If this is an .hs-boot moduleTemporarily during compilation if we pruned away the old linkable because it was out of date.After a complete compilation (), all  fields in the  will be Just.When re-linking a module (), we construct the  by building a new t from the old  (only).ghc$Constructs an empty HomePackageTable Safe-Inferred&ghc: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 filesghcIn 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 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 warningsghc 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.ghcResult of typechecking all the external package interface files we have sucked in. The domain of the mapping is external-package modulesghc The total t3 accumulated from all the external-package modulesghc The total N3 accumulated from all the external-package modulesghc The total RuleEnv3 accumulated from all the external-package modulesghc The total 53 accumulated from all the external-package modulesghc The total \3 accumulated from all the external-package modulesghcThe family instances accumulated from external packages, keyed off the module that declared themghc5Stastics about what was loaded from external packagesghcInformation about the currently loaded external packages. This is mutable because packages will be demand-loaded during a compilation run as required.ghcHelps us find information about modules in the imported packagesghc%Constructs an empty PackageIfaceTableghc&Add stats for one newly-read interface## Safe-Inferred 89:/ ĎghcExternal unitsŎghc0Stack of unit databases for the target platform.+This field is populated with the result of u.J4 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!ƎghcThe dynamic flag settingsǎghcThe 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 homeUnitEnv_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.)Ȏghc Home-unitˎghcInformation about the currently loaded external packages. This is mutable because packages will be demand-loaded during a compilation run as required.ΎghcPlatformώghc2GHC name/version (used for dynamic library suffix)юghc Get home-unit+Unsafe because the home-unit may not be setՎghcLookup R 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.֎ghcLookup R for every preload unit from the UnitState and for every unit used to instantiate the home unit.؎ghc+Test if the module comes from the home unitghc*Rename a unit id in the internal unit env. oldUnit newUnit UnitEnv, it is assumed that the oldUnit. exists in the map, otherwise we panic. The o3 associated with the home unit will have its field  set to newUnit.?Ɏʎˎ͎̎ΎώЎюӎҎԎŽÎĎŎƎǎȎ׎َڎ܎ێݎގߎ֎Վ؎?Ɏʎˎ͎̎ΎώЎюӎҎԎŽÎĎŎƎǎȎ׎َڎ܎ێݎގߎ֎Վ؎ Safe-Inferred4ghcCreates 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-Inferred59ghcFind 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. Safe-Inferred5ghcReturn the "link info" stringSee Note [LinkInfo section]   Safe-Inferred6ghc IO StringghcAllocate and store the given bytes in memory, returning a pointer to the memory in the remote process.ghc4Create a set of BCOs that may be mutually recursive.ghcSend a Seq message to the iserv process to force a value #2950ghcProcess the result of a Seq or ResumeSeq message. #2950ghcloadDLL loads a dynamic library using the OS's native linker (i.e. dlopen() on Unix, LoadLibrary() on Windows). It takes either an absolute pathname to the file, or a relative filename (e.g. "libfoo.so" or "foo.dll"). In the latter case, loadDLL searches the standard locations for the appropriate library.Returns:0Nothing => success Just err_msg => failureųghcSend a 0 and receive the response from the iserv processƳghc#Read a value from the iserv processdzghc!Send a value to the iserv processghcSpawn an external interpreterȳghcStop the interpreterɳghc Creates a & that will automatically release the ! when it is no longer referenced.˳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.ϳghcInterpreter uses Profiling wayгghcInterpreter uses Dynamic wayvvvvvvvvvvvvvvvvvvvvvvvvvvγгϳ³óijȳųƳdzʳɳ˳̳ͳγгϳ³óijȳųƳdzʳɳ˳̳ͳ Safe-InferredFghc On macOS we rely on the linkers -dead_strip_dylibs flag to remove unused libraries from the dynamic library. We do this to reduce the number of load commands that end up in the dylib, and has been limited to 32K (32768) since macOS Sierra (10.14).-dead_strip_dylibs does not dead strip -rpath entries, as such passing -l and -rpath to the linker will result in the unnecesasry libraries not being included in the load commands, however the -rpath entries are all forced to be included. This can lead to 100s of -rpath entries being included when only a handful of libraries end up being truly linked.Thus after building the library, we run a fixup phase where we inject the -rpath for each found library (in the given library search paths) into the dynamic library through  -add_rpath.#See Note [Dynamic linking on macOS] Safe-InferredGghc7Some platforms require that we explicitly link against libm if any math-y things are used (which we assume to include all programs). See #14022. Safe-InferredHghcLinking a static lib will not really link anything. It will merely produce a static archive of all dependent static libraries. The resulting library will still need to be linked with any remaining link flags. Safe-InferredJݳghc9Initialise coercion optimiser configuration from DynFlags޳ghc7Initialise Simple optimiser configuration from DynFlags߳ghc!Extract BCO options from DynFlagsghc+Extract GHCi options from DynFlags and stepݳ޳߳ݳ޳߳ Safe-Inferred(eghc8What part (2) of Note [Worker/wrapper for CPR] collects. A Bool capturing whether the transformation did anything useful.-The list of transit variables (see the Note).The result builder expression for the wrapper. The original case binder if not useful.0The result unpacking expression for the worker.  if not useful.ghc Returned by 9. See also Note [Detecting recursive data constructors].ghcThe algorithm detected a loopghcThe algorithm detected no loop, went out of fuel or hit an .hs-boot fileghcDescribes the outer shape of an argument to be unboxed or left as-is Depending on how s is instantiated (e.g., I or J).ghc/We ran out of strictness info. Leave untouched.ghc'The argument/field was absent. Drop it.ghcThe argument is used strictly or the returned product was constructed, so unbox it. The 4 carries the bits necessary for instantiation with n. The [s] carries the bits of information with which we can continue unboxing, e.g. s will be I or J.ghcThe argument can't be unboxed, but we want it to be passed evaluated to the worker.ghcThe information needed to build a pattern for a DataCon to be unboxed. The pattern can be generated from  and  via n. 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 ~ tyghcGiven a function definition data T = MkT Int Bool Char f :: (a, b) -> Int -> T f = \x y -> E mkWwBodies _ f7 ['x::(a,b)','y::Int'] '(a,b)' ['1P(L,L)', '1P(L)'] '1' returnsThe wrapper body context for the call to the worker function, lacking only the  for the worker function: W[_] :: Id -> CoreExpr W[work_fn] = \x y -> -- args of the wrapper (cloned_arg_vars) case x of (a, b) -> -- unbox wrapper args (wrap_fn_str) case y of I# n -> -- case a b n of -- call to the worker fun (call_work) (# i, b, c #) -> MkT i b c -- rebox result (wrap_fn_cpr)The worker body context that wraps around its hole reboxing defns for x and y, as well as returning CPR transit variables of the unboxed MkT result in an unboxed tuple: w[_] :: CoreExpr -> CoreExpr w[fn_rhs] = \a b n -> -- args of the worker (work_lam_args) let { y = I# n; x = (a, b) } in -- reboxing wrapper args (work_fn_str) case x y of -- call to the original RHS (call_rhs) MkT i b c -> (# i, b, c #) -- return CPR transit vars (work_fn_cpr)NB: The wrap_rhs hole is to be filled with the original wrapper RHS x y -> E". This is so that we can also use w to transform stable unfoldings, the lambda args of which may be different than x and y.Id details for the worker function like demands on arguments and its join arity.All without looking at E (except for beta reduction, see Note [Join points and beta-redexes]), which allows us to apply the same split to function body and its unfolding(s) alike.ghc Version of L that does beta reduction on-the-fly. PRECONDITION: The arg expressions are not free in any of the lambdas binders.ghc'Whether the worker needs an additional `Void#` arg as per Note [Protecting the last value argument] or Note [Preserving float barriers].ghc Inserts a `Void#` arg before the first argument.Why as the first argument? See Note [SpecConst needs to add void args first] in SpecConstr.ghc Unwraps the  decision encoded in the given I and returns a - as well the nested demands on fields of the  to unbox.ghc*Unboxing strategy for constructed results.ghcTries to find a suitable absent filler to bind the given absent identifier to. See Note [Absent fillers].If mkAbsentFiller _ id == Just e, then e, is an absent filler with the same type as id/. Otherwise, no suitable filler could be found.ghcExactly H3, 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!ghcisRecDataCon _ fuel dc, where tc = dataConTyCon dc returnsDefinitelyRecursive if the analysis found that tc" is reachable through one of dc's arg_tys.NonRecursiveOrUnsure if the analysis found that tc& is not reachable through one of dc$'s fields (so surely non-recursive).NonRecursiveOrUnsure when fuel /= Infinity and fuel expansions of nested data TyCons were not enough to prove non-recursivenss, nor arrive at an occurrence of tc thus proving recursiveness. (So not sure if non-recursive.)NonRecursiveOrUnsure when we hit an abstract TyCon (one without visible DataCons), such as those imported from .hs-boot files. Similarly for stuck type and data families.If fuel = Infinity and there are no boot files involved, then the result is never Nothing. and the analysis is a depth-first search. If fuel = > f, then the analysis behaves like a depth-limited DFS and returns Nothing! if the search was inconclusive.See Note [Detecting recursive data constructors] for which recursive DataCons we want to flag.ghcEntrypoint to CPR WW. See Note [Worker!wrapper for CPR] for an overview.ghc*Part (1) of Note [Worker/wrapper for CPR].ghc3See if we want to unbox the result and hand off to .ghcImplements the main bits of part (2) of Note [Worker/wrapper for CPR]ghc5Implements part (3) of Note [Worker/wrapper for CPR].8If `move_transit_vars [a,b] = (unbox, tup)` then * a and b are the *transit vars* to be returned from the worker to the wrapper * `unbox scrut alt = (case  scrut of (# a, b #) ->  alt)` * `tup = (# a, b #)` There is a special case for when there's 1 transit var, see Note [No unboxed tuple for single, unlifted transit var].ghcThe multiplicity of a case binder unboxing a constructed result. See Note [Linear types and CPR]ghcThe original functionghc"Manifest args of original functionghcResult type of the original function, after being stripped of argsghcStrictness of original functionghcInfo about function resultghcConsider unliftingghcType of the argumentghcHow the arg was used## Safe-InferredisghcSee 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-InferredghcAnalysis optionsghcTrue on first iteration only. See Note [Initialising strictness]ghcMemoised result of ghcOptions for the demand analysisghcUse strict dictionariesghcUse strict dictionariesghcOutputs 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])ghcWe attach useful (e.g. not I) N3 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  idDmdSigInfo) and expects to receive a H in return, which it uses to annotate the binding group with their N.ghc-Annotates uninteresting top level functions () with I!, 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 L<. 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 D 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.ghcThe result type after applying M many arguments. Returns J% when the type doesn't have exactly M many arrows.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. M;), 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 H 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 analysis environmentghc The variableghc!The evaluation context of the varghcThe demand type unleashed by the variable in this context. The returned DmdEnv includes the demand on this function plus demand on its free variables See Note [What are demand signatures?] in GHC.Types.DemandghcType of the let-bound IdghcHow the Id is used Safe-InferredghcAn environment storing J$s for local Ids. Puts binders with J in a space-saving IntSet+. See Note [Efficient Top sigs in SigEnv].ghcAll these Ids have J . Like a VarSet, but more efficient.ghc#Ids that have something other than J.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.ghcMemoised result of 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"ghc5Precise, hand-written CPR transformers for select IdsghcGet a (possibly nested) J for an application of a & worker, given a saturated number of Js for its field expressions. Implements the Nested part of Note [Nested CPR].ghc$See Note [Trimming to mAX_CPR_SIZE].ghcProcess 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 J (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 J? according to how a strict argument will be unboxed. Examples:A head-strict demand 1!L would translate to 1A product demand  1!P(1!L,L) would translate to 1(1,)A product demand  1!P(1L,L) would translate to 1(,)3, because the first field will not be unboxed.ghcexpression to be denoted by a Jghcthe updated expression and its Jghcexpression to be denoted by a Jghcthe updated expression and its JghcCPR type of the scrutineeghccurrent alternativeghcThe analysis environmentghc The functionghcinfo about incoming value argumentsghc"The demand type of the application Safe-Inferred  Safe-Inferred| Safe-Inferred %&8$ghcFinds external references. Remember to remove the names defined by this group of BCOs themselves Safe-Inferred%ghcA restricted form of ƃ for code generation purposesghcModule being compiledghcAlgebraic data types (including ones that started life as classes); generate constructors and info tables. Includes newtypes, just for the benefit of External CoreghcThe tidied main bindings, including previously-implicit bindings for record and class selectors, and data constructor wrappers. But *not* data constructor workers; reason: we regard them as part of the code-gen of tyconsghcForeign export stubsƒghc>Dependent packages, used to generate #includes for C code genÃghc%Program coverage tick box informationăghcModule breakpointsŃghcStatic pointer table entries for static forms defined in the module. See Note [Grand plan for static forms] in GHC.Iface.Tidy.StaticPtrTableƃghcA 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.ȃghcModule being compiledɃghcWhether it's an hs-boot moduleʃghc$For error messages from inner passes˃ghcWhat it exports̃ghc*What it depends on, directly or otherwise̓ghc$What was used? Used for interfaces.΃ghcDid we run a TH splice?σghcTop-level lexical environmentЃghcFixities declared in this module. Used for creating interface files.уghc=TyCons declared in this module (includes TyCons for classes)҃ghc'Class instances declared in this moduleӃghc(Family instances declared in this moduleԃghc(Pattern synonyms declared in this moduleՃghcBefore the core pipeline starts, contains See Note [Overall plumbing for rules] in GHC.Core.RulesփghcBindings for this module׃ghc'Foreign exports declared in this module؃ghc(Files to be compiled with the C compilerكghcWarnings declared in the moduleڃghc#Annotations declared in this moduleۃghcComplete Matches܃ghc!Coverage tick boxes in the module݃ghcBreakpoints for the moduleރghc Class instance environment for  home-package% modules (including this one); c.f.  tcg_inst_env߃ghc&Type-family instance environment for  home-package% modules (including this one); c.f. tcg_fam_inst_envghcSafe Haskell modeghcDo we need to trust our own package for Safe Haskell? See Note [Trust Own Package] in GHC.Rename.NamesghcDocumentation.+ƃǃȃɃʃ˃̃̓΃σЃу҃ӃԃՃփ׃؃كڃۃ܃݃ރ߃ƒÃăŃ+ƃǃȃɃʃ˃̃̓΃σЃу҃ӃԃՃփ׃؃كڃۃ܃݃ރ߃ƒÃăŃ Safe-Inferred ghc(Action to perform in backend compilationghc+Update the boot and signature file results.ghcRecompile this module.ghc#Information for the code generator.ghc Module infoghcPartial interfaceghcOld interface hash for this compilation, if an old interface file exists. Pass to hscMaybeWriteIface when writing the interface to avoid updating the existing interface when the interface isn't changed.ghc-Status of a module in incremental compilationghc*Nothing to do because code already exists.ghcRecompilation of module, or update of interface is required. Optionally pass the old interface hash to avoid updating the existing interface when it has not changed.   Safe-Inferredghc ..., we are checking the type a because it's the type of a term variable bound in a lambda, so we use . ghcThe context in which a representation-polymorphism check was performed.Does not include the type on which the check was performed; see   for that. ghc  stores the origin of a skolem type variable, so that we can display this information to the user in case of a type error.The  field allows us to report all skolem type variables bound in the same place in a single report. ghc  stores the origin of a skolem type variable (e.g. bound by a user-written forall, the header of a data declaration, a deriving clause, ...).This information is displayed when reporting an error message, such as "Couldn't match k with l" 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.InstanceghcTesting whether the constraint associated with an instance declaration in a signature file is satisfied upon instantiation.Test cases: backpack should_failbkpfail{11,43}.bkpĄghc 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.Ƅghc"Some kind of type variable binder.Used for reporting errors, in   and TcSolverReportMsg.ȄghcSome thing which has a type.This datatype is used when we want to report to the user that something has an unexpected type.ghcReport Redundant Constraints.ghc"Don't report redundant constraintsghcReport redundant constraints, and here is the SrcSpan for the constraints E.g. f :: (Eq a, Ord b) => blah The span is for the (Eq a, Ord b)ghcUserTypeCtxt describes the origin of the polymorphic type in the places where we need an expression to have that typeghc8Wrap up the origin of a skolem type variable with a new 8, so that we can common up skolem type variables whose   shares a certain .ghcDid a constraint arise from expanding a Wanted constraint to look at superclasses?ghc)Extract a suitable CtOrigin from a HsExprghc-Extract a suitable CtOrigin from a MatchGroupghc-Extract a suitable CtOrigin from guarded RHSsghc7Extract a suitable CtOrigin from a list of guarded RHSsghcShort one-linersghcPrint the context for a FixedRuntimeRep# representation-polymorphism check.6Note that this function does not include the specific :4 which is not fixed. That information is stored in   and is reported separately. ghcrebindable syntax operatorghc!function used in the view patternghcfunctionghcargumentghcname of the functionghc equationsghc!the entire lambda-case expressionghcargument position (1-indexed)ghcThe 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)ghc)Module in which the instance was declaredghcThe declared typeclass instanceghcused to common up skolem variables bound at the same location (only used in pprSkols)ghc ... Differentiated from TypeHole because a ConstraintHole is simplified differently. See Note [Do not simplify ConstraintHoles] in GHC.Tc.Solver.ghcA 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].ghcWhat flavour of hole is this?ghcThe name of this holeghcType to be printed to the user For expression holes: type of expr For type holes: the missing typeghcWhere hole was writtenghcA delayed error, to be reported after constraint solving, in order to benefit from deferred unifications.ghc A hole (in a type or in a term).See Note [Holes].ghc+A type could not be ensured to be concrete.;See Note [The Concrete mechanism] in GHC.Tc.Utils.Concrete.ghcA  is a type that can appear on the left of a canonical equality: a type variable or exactly-saturated type family application.ghcA -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.)ghc?Are we sure that more solving will never solve this constraint?ghc8No problems in checking the validity of a type equality.ghcCheck whether a م is marked successful.ghcCheck whether a م has a ؅ghcCheck whether a م has one ؅ and no otherghcMark a م as not having an insoluble occurs-check: any occurs check under a type family or in a representation equality is soluble.ghcRetain only information about occurs-check failures, because only that matters after recurring into a kind.ghcReturns the evidence  for the argument  when this  is a .Returns J otherwise.ghcMakes a new equality predicate with the same role as the given evidence.ghcGet the flavour of the given ghc(Get the equality relation for the given ghcIs 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 Convert a  back into a KghcRetrieve the kind of a ghcAre two s equal?ghcReturns free variables of constraints as a non-deterministic setghcReturns 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 constraints as a deterministically ordered list. 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 constraints as a composable FV computation. 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 a bag 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 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 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.ghcReturns free variables of WantedConstraints 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.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]Æ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]ԆghcChecks whether a the given wanted constraints are solved, i.e. that there are no simple constraints left and all the implications are solved.ghc#Gather all the type variables from Ӆ that it would be unhelpful to default. For the moment, these are only r metavariables participating in a nominal equality whose other side is not concrete; it's usually better to report those as errors instead of defaulting.ghcReturns True of equality constraints that are definitely insoluble, as well as TypeError constraints. Can return L for Given constraints, unlike .This function is critical for accurate pattern-match overlap warnings. See Note [Pattern match warnings with insoluble Givens] in GHC.Tc.SolverNote that this does not traverse through the constraint to find nested custom type errors: it only detects TypeError msg :: Constraint, and not e.g. Eq (TypeError msg).ghcDoes this hole represent an "out of scope" error? See Note [Insoluble holes]ghc)Get the equality relation relevant for a ghcGet the role relevant for a ghc$Extract the set of rewriters from a  See Note [Wanteds rewrite Wanteds] If the provided CtEvidence is not for a Wanted, just return an empty set.ghcSet the type of CtEvidence.-This function ensures that the invariants on  hold, by updating the evidence and the ctev_pred in sync with each other. See Note [CtEvidence invariants].ghcMakes a ? from all the coercion holes that occur in the given coercion.ghcMakes a ; from all the coercion holes that occur in the given type.ghcMakes a < from all the coercion holes that occur in the given types.ghc-Extract the flavour, role, and boxity from a ghc$Extract the flavour and role from a ghc+Take a CtLoc and moves it to the kind levelghc of the familyghcexactly saturating the family†͆Ɔ̆φņdžȆɆʆˆΆÆĆڅۅ܅݅ޅ߅م؅ӅԅՅօׅІӆԆՆֆц҆ن݆׆؆چۆ܆ŅƅɅʅ΅҅Džȅ˅̅ͅυЅхÅ…ą߆ކ†͆Ɔ̆φņdžȆɆʆˆΆÆĆڅۅ܅݅ޅ߅م؅ӅԅՅօׅІӆԆՆֆц҆ن݆׆؆چۆ܆ŅƅɅʅ΅҅Džȅ˅̅ͅυЅхÅ…ą߆ކ Safe-InferredtghcSubtract 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. ghcCompute 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. $$$$$$$$$$ Safe-Inferred 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)ghc.Check the known-key names list of consistency.ghcGiven a  lookup its associated ) if it corresponds to a known-key thing.ghcIs a  known-key?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).ghcGiven a  lookup any associated arbitrary SDoc's to be displayed by GHCi's ':info' command.   Safe-Inferred"689:83ghc's get converted into 's before being written into .hie files. See  and  fromHieName6 for logic on how to convert between these two types.ghcScope 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 fileghctype or data familyghc type synonymghcdata declarationghcconstructor declarationghcpattern synonymghcclass declarationghcinstance declarationghcTypes of imports and exportsghcEq/Ord instances compare on the converted HieName, as non-exported names may have different uniques after a roundtripghcbound by a pattern matchghcbound by a type signatureghcbound by a hswrapperghcbound by an implicit variableghc%Bound by some instance of given classghcA direct let bindingghc0Different contexts under which identifiers existghcregular variableghc import/exportghc Value bindingghcPattern 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 Declarationghc Type variableghc Record fieldghc/Constraint/Dictionary evidence variable bindingghcUsage of evidence variableghc,Information associated with every identifierWe need to include types with identifiers because sometimes multiple identifiers occur in the same span(Overloaded Record Fields and so on)ghc'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'The Haskell types of this node, if any.ghc%All the identifiers and their detailsghcA node annotationghc name of the AST node constructorghcname of the AST node TypeghcSource of node infoghcNodeInfos grouped by sourceǶghc/Mapping from filepaths to the corresponding AST˶ghcA list of type arguments along with their respective visibilities (ie. is this an argument that would return L for isVisibleArgFlag?).Ͷghc(Roughly isomorphic to the original core Type.жghcA flattened version of Type.9See Note [Efficient serialization of redundant type info]ֶghctype with constraint: t1 => t2 (see  IfaceDFunTy)۶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 Initial Haskell source file path޶ghcThe module this HIE file is for߶ghcTypes referenced in the .9See Note [Efficient serialization of redundant type info]ghc$Type-annotated abstract syntax treesghc"The names that this module exportsghc'Raw bytes of the initial Haskell sourceghcCurrent version of .hie filesghc3names 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 signatureghc,whether or not the binding is in an instanceghc#scope over which the value is boundghcspan of entire bindingghcscope in the pattern9 (the variable bound can be used further in the pattern)ghc%rest of the scope outside the patternghcspan of entire bindingghctype of declarationghcspan of entire bindingghc!how did this bind come into beingghc#scope over which the value is boundghcspan of the binding site¶ƶŶĶöǶɶȶʶ˶̶Ͷζ϶жٶض׶ֶնԶӶҶѶڶ۶߶ݶ޶ܶ۶߶ݶ޶ܶڶжٶض׶ֶնԶӶҶѶ϶Ͷζ˶̶ʶǶɶȶ¶ƶŶĶö Safe-Inferred "(8 ghc>One must contain the other. Leaf nodes cannot contain anythingghc/Insert an AST in a sorted list of disjoint AstsghcMerge two nodes together.,Precondition and postcondition: elements in  are ordered.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""bghcLook for any identifiers which occur outside of their supposed scopes. Returns a list of error messages.   Safe-Inferred )*?"ŇLJɇʇȇ·ˇƇ͇̇χ҇ЇӇч‡ÇćՇԇŇLJɇʇȇ·ˇƇ͇̇χ҇ЇӇч‡ÇćՇԇ Safe-Inferred ?(m݇ghcSee Note [Safe Haskell Overlapping Instances Implementation] in GHC.Tc.SolverghcReturns 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 case x of PatSyn z -> ... } However, no more than one RealDataCon in the list, otherwise contradiction because of generativity.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 .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 EghcA 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.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.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.ghcWhich  needs to be checked for inhabitants because of new negative constraints (e.g. x D E or x D K).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.ghcA disjunctive bag of "s, representing a refinement type.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.ghcType oracle; things like a~Intghc"Term oracle; things like x~Nothingghc+An initial nabla that is always satisfiableghc!Initial state of the term oracle.È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!See also Note [Coverage checking Newtype matches] in GHC.HsToCore.Pmc.Solver.ghcWhen  can be decided. True  = Equal, False  = Disjoint.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 undecidableLjghc Type of a ghc/Undecidable equality for values represented by R4s. See Note [Undecidable Equality for PmAltCons]. Rs aren't enforced to be generative, so two syntactically different Rs 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 undecidableʈ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Έghc Type of a ψ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.ֈghcNot user-facing.܈ghcSyntactic equality.ވghcSyntactic equality.ghcNot user-facing.ghcNot user-facing.ňƈˆÈĈ\LjΈψЈȈɈʈˈ͈̈ш҈ӈԈՈňƈˆÈĈ\LjΈψЈȈɈʈˈ͈̈ш҈ӈԈՈ Safe-Inferred(8UghcUsed as tree payload post-checking. The redundancy info we elaborated.ghc;Used as tree payload pre-checking. The LYG guards to check.ghc#Pattern-match coverage check resultghc,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)ghc&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.ghcRedundancy sets, used to determine redundancy of RHSs and bang patterns (later digested into a CIRB).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.ghcIf any of the  is empty, the corresponding  pin-points a bang pattern in source that is redundant. See Note [Dead bang patterns].ghc(A guard tree denoting a pattern binding.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 guard tree denoting Match5: A payload describing the pats and a bunch of GRHS.ghcA guard tree denoting  MatchGroup.ghcA sequence of s.ghcMeans by which we identify a source construct for later pretty-printing in a warning message.   for the equation to show,  for the location.ghcA very simple language for pattern guards. Let bindings, bang patterns, and matching variables against flat constructor patterns. The LYG guard language.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 .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.ghc PmLet x expr corresponds to a  let x = expr guard. This actually binds x.ghcFormat a LYG sequence (e.g. Matches of a  MatchGroup or GRHSs) as {  firstalt; ...;  lastalt }ghcShould not be user-facing.ghcFormat LYG guards as | True <- x, let x = 42, !z\ňƈˆÈĈLjΈψЈȈɈʈˈ͈̈ш҈ӈԈՈ1 Safe-Inferred]HghcThe result of .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 "...".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)*FĉghcStores the information to be reported in a representation-polymorphism error message.ƉghcWhat is the original type we checked for representation-polymorphism, and what specific check did we perform?ljghcWhich non-concrete type did we try to unify this concrete type variable with?ˉghc3Whether we ran out of fuel generating the bindings.̉ghc.A collection of hole fits and refinement fits.ЉghcA collection of valid hole fits or refinement fits, in which some fits might have been suppressed.ӉghcWhether we have suppressed any fits because there were too many.ԉghcThis datatype collates instances that match or unifier, in order to report an error message for an unsolved typeclass constraint.؉ghc!Explain a problem with an import.ىghc/Couldn't find a module with the requested name.ډghc9The imported modules don't export what we're looking for.ۉghcA message that aims to explain why two types couldn't be seen to be representationally equal.܉ghcNot knowing the role of a type constructor prevents us from concluding that two types are representationally equal.Example:foo :: Applicative m => m (Sum Int) foo = coerce (pure $ 1 :: Int)We don't know what role m2 has, so we can't coerce `m Int` to `m (Sum Int)`.#Test cases: T8984, TcCoercibleFail.݉ghcThe fact that a - is abstract prevents us from decomposing a TyConApp: and deducing that two types are representationally equal.Test cases: none.މghc Down Int foo = coerceTest cases: TcCoercibleFail.߉ghcReport an error involving a .This could be an out of scope data constructor or variable, a typed hole, or a wildcard in a type.ghcReport an out-of-scope data constructor or variable masquerading as an expression hole.Report a typed hole, or wildcard, with additional information.ghc2Configuration for pretty-printing valid hole fits.ghc Some form of "not in scope" error. See also the  constructor of ߉.ghcA run-of-the-mill "not in scope" error.ghc An exact  was not in scope.This usually indicates a problem with a Template Haskell splice.Test cases: T5971, T18263.ghcalways at least 2 elementsghc"Couldn't find a top-level binding.Happens when specifying an annotation for something that is not in scope.,Test cases: annfail01, annfail02, annfail11.ghcA class doesnt have a method with this name, or, a class doesn't have an associated type with this name, or, a record doesn't have a record field with this name.ghc;Additional information that can be appended to an existing .ghc?Some type variables remained ambiguous: print them to the user.ghc:Specify some information about a type variable, e.g. its  SkolemInfo.ghc?Remind the user that a particular type family is not injective.ghc6Explain why we couldn't coerce between two types. See ۉ.ghc&Display the expected and actual types.ghcDisplay the expected and actual types, after expanding type synonyms.ghc'Explain how a kind equality originated.ghc:Add some information to disambiguate errors in which two Names( would otherwise appear to be identical.)See Note [Disambiguating (X ~ X) errors].ghcReport some type variables that might be participating in an occurs-check failure.ghcTrue  => start the message with "Ambiguous type variable ..." False  =? create a message of the form "The type variable is ambiguous."ghcAmbiguous kind and type variables, respectively. Guaranteed to not both be empty.ghcWhether the two "s also came from the same package.ghc(Additional information to be given in a & message, which is then passed on to mk_supplementary_ea_msg.ghcAn error reported after constraint solving. This is usually, some sort of unsolved constraint error, but we try to be specific about the precise problem we encountered.ghc+Wrap a message with additional information.Prefer using the Ԍ smart constructorghc4Quantified variables appear out of dependency order.Example:forall (a :: k) k. ...:Test cases: BadTelescope2, T16418, T16247, T16726, T18451.ghcWe came across a custom type error and we have decided to report it.Example:9type family F a where F a = TypeError (Text "error")err :: F () err = ()1Test cases: CustomTypeErrors0{1,2,3,4,5}, T12104.ghcWe want to report an out of scope variable or a typed hole. See ߉.ghc7A type equality between a type variable and a polytype.(Test cases: T12427a, T2846b, T10194, ...ghc"Couldn't unify two types or kinds.Example:93 + 3# -- can't match a lifted type with an unlifted typeTest cases: T1396, T8263, ...ghcA type has an unexpected kind.Test cases: T2994, T7609, ...ghc?A mismatch between two types, which arose from a type equality.Test cases: T1470, tcfail212.ghc:A violation of the representation-polymorphism invariants.See ĉ and FixedRuntimeRepContext for more information.ghc)A skolem type variable escapes its scope.Example:7data Ex where { MkEx :: a -> MkEx } foo (MkEx x) = x#Test cases: TypeSkolEscape, T11142.ghcTrying to unify an untouchable variable, e.g. a variable from an outer scope.Test case: Simple14ghcAn equality between two types is blocked on a kind equality beteen their kinds.Test cases: none.ghc9Something was not applied to sufficiently many arguments.Example:instance Eq Maybe where {..}Test case: T11563.ghc,Trying to use an unbound implicit parameter.Example:foo :: Int foo = ?paramTest case: tcfail130.ghcCouldn't solve some Wanted constraints using the Givens. This is the most commonly used constructor, used for generic "No instance for ..." and "Could not deduce ... from" messages.ghcA constraint couldn't be solved because it contains ambiguous type variables.Example:!class C a b where f :: (a,b) x = fst fTest case: T4921.ghcCould not solve a constraint; there were several unifying candidate instances but no matching instances. This is used to report as much useful information as possible about why we couldn't choose any instance, e.g. because of ambiguous type variables.ghcCould not solve a constraint using available instances because the instances overlap.,Test cases: tcfail118, tcfail121, tcfail218.ghcCould not solve a constraint from instances because instances declared in a Safe module cannot overlap instances from other modules (with -XSafeHaskell).%Test cases: SH_Overlap{1,2,5,6,7,11}.ghc6Should this be phrased in terms of expected vs actual?ghc0The constraint in which the mismatch originated.ghc8First type (the expected type if if mismatch_ea is True)ghc4Second type (the actual type if mismatch_ea is True)ghcWhat thing is  the kind of?ghcThe overall expected typeghcThe overall actual typeghcWhat thing is  the kind of?ghc)The Wanted constraints we couldn't solve. N.B.: the  at the head of the list has been tidied, perhaps not the others.ghc!Some additional info consumed by mk_supplementary_ea_msg.ghcA predicate with its arising location; used to encapsulate a constraint that will give rise to a diagnostic.ghc Context needed when reporting a , such as the enclosing implication constraints or whether we are deferring type errors.ghcEnclosing implications (innermost first) ic_skols and givens are tidied, rest are notŠghcWe make some errors (depending on cec_defer) into warnings, and emit evidence bindings into Š for unsolved constraintsÊghc*Whether to defer type errors until runtimeĊghc*Reason for reporting holes in expressions.Ŋghc$Reason for reporting holes in types.Ɗghc(Reason for reporting out of scope holes.NJghcTrue  = -Wredundant-constraintsȊghcTrue  = -fprint-expanded-synonymsɊghcTrue  = More important errors have occurred, so create bindings if need be, but don't issue any more errors/warnings See Note [Suppressing error messages]ʊghcA , together with context (e.g. enclosing implication constraints) that are needed in order to report it.̊ghcContext for what we wish to report. This can change as we enter implications, so is stored alongside the content.͊ghc%The content of the message to report.Ίghc%Additional information to print in a Ҋ<, after the important messages and after the error context.See Note [Error report].ҊghcA collection of main error messages and supplementary information.In practice, we will: - display the important messages first, - then the error context (e.g. by way of a call to ), - then the supplementary information (e.g. relevant bindings, valid hole fits), - then the hints ("Possible fix: ...").So this is mostly just a way of making sure that the error context appears early on rather than at the end of the message.$See Note [Error report] for details.׊ghc2Is the object we are dealing with exported or not?Used for reporting "missing signature" warnings, see .ڊghc/What kind of thing is missing a type signature?Used for reporting "missing signature" warnings, see tcRnMissingSignature.݊ghcwhether -XCUSKs is enabledފghcIf , the associated type of a typeclass is not parameterized over the last type variable of the classߊghc'The associated type family of the classghcIf , the associated type of a typeclass contains the last type variable of the class in a kind, which is not (yet) allowed by GHC.ghc'The associated type family of the classghcA type representing whether or not the input type has associated data family instances.ghc;Whether a sole extra-constraint wildcard is allowed, e.g. _ => .. as opposed to ( .., _ ) => ...ghc6A context in which we don't allow anonymous wildcards.ghc-The type must not have some datatype context.ghcThe data constructor must not have exotic unlifted or polymorphic arguments.ghc3The data constructor must be a vanilla constructor.ghcThe type must have some type parameters. check (d) from Note [Requirements for deriving Generic and Rep] in GHC.Tc.Deriv.Generics.ghc9The data constructor must not have existential arguments.ghcThe derivation applies a type to an argument involving the last parameter but the applied type is not of kind * -> *.ghc The given  must be truly polymorphic in the last argument of the data type.ghc The given 7 must not use the type variable in a function argument"ghc The given  must not contain function typesghc The given  must use the type variable only as the last argument of a data typeghc The given ; is a GADT so we cannot directly derive an istance for it.ghc The given ( has existentials type vars in its type.ghc The given  has constraints in its type.ghc The given  has a higher-rank type.ghc8Why a particular typeclass instance couldn't be derived.ghc*The typeclass instance is not well-kinded.ghc=The instance type | We cannot derive instances in boot filesghc&We cannot use GND on non-newtype typesghc-We cannot derive instances of nullary classesghc,Last arg must be newtype or data applicationghc The given  is not a class.ghc"The given (representation of the)  has no data constructors.ghc/GHC simply doesn't how to how derive the input 9 for the given .ghc The given  must be an enumeration. See Note [Enumeration types] in GHC.Core.TyConghc The given  must have  precisely one constructor.ghc.The given data type must have some parameters.ghc2The given data type must not have a class context.ghcWe couldn't derive an instance for a particular data constructor for a variety of reasons.ghcWe couldn't derive a Generic6 instance for the given type for a variety of reasonsghcWe couldn't derive an instance either because the type was not an enum type or because it did have more than one constructor.ghcA data type to describe why a variable is not closed. See Note [Not-closed error messages] in GHC.Tc.Gen.ExprghcWhy the particular injectivity error arose together with more information, if any.ghcIn what context did we require a type to have a fixed runtime representation?Used by  for throwing representation polymorphism errors when validity checking.See Note [Representation polymorphism checking] in GHC.Tc.Utils.ConcreteghcData constructor fields must have a fixed runtime representation.Tests: T11734, T18534.ghcPattern synonym signature arguments must have a fixed runtime representation.Test: RepPolyPatSynArg.ghcPattern synonym signature scrutinee must have a fixed runtime representation.Test: RepPolyPatSynRes.ghc Where a shadowed name comes fromghc(The shadowed name is local to the moduleghc?The shadowed name is global, typically imported from elsewhere.ghcWhich parts of a record field are affected by a particular error or warning.ghc>Whether the error pertains to a function argument or a result.ËghcSpecifies which calling convention is unsupported on the current platformNjghcSpecifies which backend code generators where expected for an FFI declarationȋghcC, Asm, or LLVMɋghcC, Asm, LLVM, or interpretedʋghc8An error which might arise during typechecking/renaming.ˋghcSimply wraps a generic b message a. It can be used by plugins to provide custom diagnostic messages originated during typechecking/renaming.̋ghcTcRnMessageWithInfo is a constructor which is used when extra information is needed to be provided in order to qualify a diagnostic and where it was originated (and why). It carries an extra t which can be used to pretty-print some names and it wraps a , which includes any extra context associated with this diagnostic.͋ghcTcRnSolverReport is the constructor used to report unsolved constraints after constraint solving, as well as other errors such as hole fit errors.See the documentation of the 8 datatype for an overview of the different errors.΋ghcTcRnRedundantConstraints is a warning that is emitted when a binding has a user-written type signature which contains superfluous constraints.Example:f :: (Eq a, Ord a) => a -> a -> a f x y = (x < y) || x == y -- `Eq a` is superfluous: the `Ord a` constraint suffices. Bool foo MkFalse = False foo MkTrue = True -- Inaccessible: requires True ~ FalseTest cases: T7293, T7294, T15558, T17646, T18572, T18610, tcfail167.ЋghcA type which was expected to have a fixed runtime representation does not have a fixed runtime representation.Example:data D (a :: TYPE r) = MkD aTest cases: T11724, T18534, RepPolyPatSynArg, RepPolyPatSynUnliftedNewtype, RepPolyPatSynRes, T20423ыghcTcRnImplicitLift is a warning (controlled with -Wimplicit-lift) that occurs when a Template Haskell quote implicitly uses lift.Example: warning1 :: Lift t => t -> Q Exp warning1 x = [| x |]Test cases: th/T17804ҋghcTcRnUnusedPatternBinds is a warning (controlled with -Wunused-pattern-binds) that occurs if a pattern binding binds no variables at all, unless it is a lone wild-card pattern, or a banged pattern.Example: Just _ = rhs3 -- Warning: unused pattern binding (_, _) = rhs4 -- Warning: unused pattern binding _ = rhs3 -- No warning: lone wild-card pattern !() = rhs4 -- No warning: banged pattern; behaves like seq+Test cases: rename/{T13646,T17c,T17e,T7085}ӋghcTcRnDodgyImports is a warning (controlled with -Wdodgy-imports) that occurs when a datatype T is imported with all constructors, i.e. 'T(..)', but has been exported abstractly, i.e. T.Test cases: renameshould_compileT7167ԋghcTcRnDodgyExports is a warning (controlled by -Wdodgy-exports) that occurs when a datatype T is exported with all constructors, i.e. 'T(..)', but is it just a type synonym or a type/data family.Example: module Foo ( T(..) -- Warning: T is a type synonym , A(..) -- Warning: A is a type family , C(..) -- Warning: C is a data family ) wheretype T = Int type family A :: * -> * data family C :: * -> *Test cases: warningsshould_compileDodgyExports01ՋghcTcRnMissingImportList is a warning (controlled by -Wmissing-import-lists) that occurs when an import declaration does not explicitly list all the names brought into scope.Test cases: renameshould_compileT4489֋ghcWhen a module marked trustworthy or unsafe (using -XTrustworthy or -XUnsafe) is compiled with a plugin, the TcRnUnsafeDueToPlugin warning (controlled by -Wunsafe) is used as the reason the module was inferred to be unsafe. This warning is not raised if the -fplugin-trustworthy flag is passed.Test cases: plugins/T19926׋ghcTcRnModMissingRealSrcSpan is an error that occurrs when compiling a module that lacks an associated .Test cases: None؋ghcTcRnIdNotExportedFromModuleSig is an error pertaining to backpack that occurs when an identifier required by a signature is not exported by the module or signature that is being used as a substitution for that signature.Example(s): NoneTest cases: backpack should_fail bkpfail36ًghcTcRnIdNotExportedFromLocalSig is an error pertaining to backpack that occurs when an identifier which is necessary for implementing a module signature is not exported from that signature.Example(s): NoneTest cases: backpack should_fail#bkpfail30 backpack should_fail#bkpfail31 backpack should_fail bkpfail34ڋghcTcRnShadowedName is a warning (controlled by -Wname-shadowing) that occurs whenever an inner-scope value has the same name as an outer-scope value, i.e. the inner value shadows the outer one. This can catch typographical errors that turn into hard-to-find bugs. The warning is suppressed for names beginning with an underscore.Examples(s): f = ... let f = id in ... f ... -- NOT OK, f is shadowed f x = do { _ignore <- this; _ignore <- that; return (the other) } -- suppressed via underscoreTest cases: typecheckshould_compileT10971a renameshould_compilern039 renameshould_compilern064 renameshould_compileT1972 rename should_failT2723 renameshould_compile$T3262 driver/werrorۋghcTcRnDuplicateWarningDecls is an error that occurs whenever a warning is declared twice.Examples(s): None.Test cases: None.܋ghcTcRnDuplicateWarningDecls is an error that occurs whenever the constraint solver in the simplifier hits the iterations' limit.Examples(s): None.Test cases: None.݋ghcTcRnIllegalPatSynDecl is an error that occurs whenever there is an illegal pattern synonym declaration. Examples(s):varWithLocalPatSyn x = case x of P -> () where pattern P = () -- not valid, it can't be local, it must be defined at top-level.Test cases: patsyn should_faillocalދghcTcRnLinearPatSyn is an error that occurs whenever a pattern synonym signature uses a field that is not unrestricted.Example(s): NoneTest cases: linear should_fail LinearPatSyn2ߋghcTcRnEmptyRecordUpdate is an error that occurs whenever a record is updated without specifying any field. Examples(s):$(deriveJSON defaultOptions{} ''Bad) -- not ok, no fields selected for update of defaultOptionsTest cases: th/T12788ghcTcRnIllegalFieldPunning is an error that occurs whenever field punning is used without the NamedFieldPuns extension enabled. Examples(s):data Foo = Foo { a :: Int }foo :: Foo -> Int foo Foo{a} = a -- Not ok, punning used without extension.Test cases: parser should_failRecordDotSyntaxFail12ghcTcRnIllegalWildcardsInRecord is an error that occurs whenever wildcards (..) are used in a record without the relevant extension being enabled. Examples(s):data Foo = Foo { a :: Int }foo :: Foo -> Int foo Foo{..} = a -- Not ok, wildcards used without extension.Test cases: parser should_failRecordWildCardsFailghcTcRnIllegalWildcardInType is an error that occurs when a wildcard appears in a type in a location in which wildcards aren't allowed. Examples:Type synonyms: type T = _!Class declarations and instances: class C _ instance C _Standalone kind signatures:type D :: _ data DTest cases: ExtraConstraintsWildcardInTypeSplice2 ExtraConstraintsWildcardInTypeSpliceUsed ExtraConstraintsWildcardNotLast ExtraConstraintsWildcardTwice NestedExtraConstraintsWildcard NestedNamedExtraConstraintsWildcard PartialClassMethodSignature PartialClassMethodSignature2 T12039 T13324_fail1 UnnamedConstraintWildcard1 UnnamedConstraintWildcard2 WildcardInADT1 WildcardInADT2 WildcardInADT3 WildcardInADTContext1 WildcardInDefault WildcardInDefaultSignature WildcardInDeriving WildcardInForeignExport WildcardInForeignImport WildcardInGADT1 WildcardInGADT2 WildcardInInstanceHead WildcardInInstanceSig WildcardInNewtype WildcardInPatSynSig WildcardInStandaloneDeriving WildcardInTypeFamilyInstanceRHS WildcardInTypeSynonymRHS saks_fail003 T15433aghcTcRnDuplicateFieldName is an error that occurs whenever there are duplicate field names in a record.Examples(s): None.Test cases: None.ghcTcRnIllegalViewPattern is an error that occurs whenever the ViewPatterns syntax is used but the ViewPatterns language extension is not enabled..Examples(s): data Foo = Foo { a :: Int }8foo :: Foo -> Int foo (a -> l) = l -- not OK, the  ViewPattern extension is not enabled.Test cases: parser should_failViewPatternsFailghcTcRnCharLiteralOutOfRange is an error that occurs whenever a character is out of range.Examples(s): NoneTest cases: NoneghcTcRnIllegalWildcardsInConstructor is an error that occurs whenever the record wildcards '..'6 are used inside a constructor without labeled fields.Examples(s): NoneTest cases: NoneghcTcRnIgnoringAnnotations is a warning that occurs when the source code contains annotation pragmas but the platform in use does not support an external interpreter such as GHCi and therefore the annotations are ignored.Example(s): NoneTest cases: NoneghcTcRnAnnotationInSafeHaskell is an error that occurs if annotation pragmas are used in conjunction with Safe Haskell.Example(s): NoneTest cases: annotations should_failT10826ghcTcRnInvalidTypeApplication is an error that occurs when a visible type application is used with an expression that does not accept "specified" type arguments.Example(s): foo :: forall {a}. a -> a foo x = x bar :: () bar = let x = foo @Int 42 in ()Test cases: overloadedrecflds should_fail1overloadedlabelsfail03 typecheck should_fail/ExplicitSpecificity1 typecheck should_fail0ExplicitSpecificity10 typecheck should_fail/ExplicitSpecificity2 typecheck should_fail!T17173 typecheck should_failVtaFailghcExample(s): foo :: forall a. a foo = tagToEnum# 0#Test cases: typecheck should_fail tcfail164ghc=TcRnTagToEnumResTyNotAnEnum is an error that occurs when the  'tagToEnum#' function is given a result type that is not an enumeration type.Example(s): foo :: Int -- not an enumeration TyCon foo = tagToEnum# 0#Test cases: typecheck should_fail tcfail164ghcTcRnArrowIfThenElsePredDependsOnResultTy is an error that occurs when the predicate type of an ifThenElse expression in arrow notation depends on the type of the result.Example(s): NoneTest cases: NoneghcTcRnIllegalHsBootFileDecl is an error that occurs when an hs-boot file contains declarations that are not allowed, such as bindings.Example(s): NoneTest cases: NoneghcTcRnRecursivePatternSynonym is an error that occurs when a pattern synonym is defined in terms of itself, either directly or indirectly.3Example(s): pattern A = B pattern B = ATest cases: patsyn should_failT16900ghcTcRnPartialTypeSigTyVarMismatch is an error that occurs when a partial type signature attempts to unify two different types.7Example(s): f :: a -> b -> _ f x y = [x, y]Test cases: partial-sigs should_failT14449ghcTcRnPartialTypeSigBadQuantifier is an error that occurs when a type variable being quantified over in the partial type signature of a function gets unified with a type that is free in that function's context.Example(s): foo :: Num a => a -> a foo xxx = g xxx where g :: forall b. Num b => _ -> b g y = xxx + yTest cases: partial-sig should_failT14479ghcTcRnMissingSignature is a warning that occurs when a top-level binding or a pattern synonym does not have a type signature.Controlled by the flags: -Wmissing-signatures -Wmissing-exported-signatures -Wmissing-pattern-synonym-signatures -Wmissing-exported-pattern-synonym-signatures -Wmissing-kind-signaturesTest cases: T11077 (top-level bindings) T12484 (pattern synonyms) T19564 (kind signatures)ghcTcRnPolymorphicBinderMissingSig is a warning controlled by -Wmissing-local-signatures that occurs when a local polymorphic binding lacks a type signature.Example(s): id a = aTest cases: warningsshould_compileT12574ghcTcRnOverloadedSig is an error that occurs when a binding group conflicts with the monomorphism restriction.Example(s): data T a = T a mono = ... where x :: Applicative f => f a T x = ...Test cases: typecheckshould_compileT11339ghcTcRnTupleConstraintInst is an error that occurs whenever an instance for a tuple constraint is specified.Examples(s): class C m a class D m a f :: (forall a. Eq a => (C m a, D m a)) => m a f = undefined)Test cases: quantified-constraints/T15334ghcTcRnAbstractClassInst is an error that occurs whenever an instance of an abstract class is specified.Examples(s): -- A.hs-boot module A where class C a- B.hs module B where import {-# SOURCE #-} A instance C Int where- A.hs module A where import B class C a where f :: a:- Main.hs import A main = print (f :: Int)Test cases: typecheck should_failT13068ghcTcRnNoClassInstHead is an error that occurs whenever an instance head is not headed by a class.Examples(s): instance cTest cases: typecheckrename!T5513 typecheckrenameT16385ghcTcRnUserTypeError is an error that occurs due to a user's custom type error, which can be triggered by adding a  TypeError< constraint in a type signature or typeclass instance.Examples(s): f :: TypeError (Text "This is a type error") f = undefinedTest cases: typecheck should_fail.CustomTypeErrors02 typecheck should_failCustomTypeErrors03ghcTcRnConstraintInKind is an error that occurs whenever a constraint is specified in a kind.4Examples(s): data Q :: Eq a => Type where {}Test cases: dependent should_failT13895 polykinds/T16263 saks should_fail(saks_fail004 typecheck should_fail#T16059a typecheck should_failT18714ghcTcRnUnboxedTupleTypeFuncArg is an error that occurs whenever an unboxed tuple or unboxed sum type is specified as a function argument, when the appropriate extension (`-XUnboxedTuples` or `-XUnboxedSums`) isn't enabled.Examples(s): -- T15073.hs import T15073a newtype Foo a = MkFoo a deriving P- T15073a.hs class P a where p :: a -> (# a #)Test cases: deriving should_fail$T15073.hs deriving should_fail&T15073a.hs typecheck should_failT16059dghcTcRnLinearFuncInKind is an error that occurs whenever a linear function is specified in a kind.(Examples(s): data A :: * %1 -> *Test cases: linear should_fail#LinearKind linear should_fail$LinearKind2 linear should_fail LinearKind3ghcTcRnForAllEscapeError is an error that occurs whenever a quantified type's kind mentions quantified type variable.Examples(s): type T :: TYPE (BoxedRep l) data T = MkTTest cases: unlifted-datatypes should_failUnlDataNullaryPolyghcTcRnVDQInTermType is an error that occurs whenever a visible dependent quantification is specified in the type of a term.Examples(s): a = (undefined :: forall k -> k -> Type) @IntTest cases: dependent should_fail"T15859 dependent should_fail(T16326_Fail1 dependent should_fail(T16326_Fail2 dependent should_fail(T16326_Fail3 dependent should_fail(T16326_Fail4 dependent should_fail(T16326_Fail5 dependent should_fail(T16326_Fail6 dependent should_fail(T16326_Fail7 dependent should_fail(T16326_Fail8 dependent should_fail(T16326_Fail9 dependent should_fail)T16326_Fail10 dependent should_fail)T16326_Fail11 dependent should_fail)T16326_Fail12 dependent should_fail"T17687 dependent should_failT18271ghcTcRnBadQuantPredHead is an error that occurs whenever a quantified predicate lacks a class or type variable head.Examples(s): class (forall a. A t a => A t [a]) => B t where type A t a :: Constraint)Test cases: quantified-constraints/T16474ghcTcRnIllegalTupleConstraint is an error that occurs whenever an illegal tuple constraint is specified.Examples(s): g :: ((Show a, Num a), Eq a) => a -> a g = undefinedTest cases: typecheck should_fail tcfail209aghcTcRnNonTypeVarArgInConstraint is an error that occurs whenever a non type-variable argument is specified in a constraint.;Examples(s): data T instance Eq Int => Eq TTest cases: ghciscriptsT13202 ghciscriptsT13202a polykinds/T12055a typecheck should_fail"T10351 typecheck should_fail"T19187 typecheck should_fail!T6022 typecheck should_failT8883ghcTcRnIllegalImplicitParam is an error that occurs whenever an illegal implicit parameter is specified.Examples(s): type Bla = ?x::Int data T = T instance Bla => Eq T8Test cases: polykinds/T11466 typecheck should_fail!T8912 typecheck should_fail%tcfail041 typecheck should_fail%tcfail211 typecheck should_failtcrun045ghcTcRnIllegalConstraintSynonymOfKind is an error that occurs whenever an illegal constraint synonym of kind is specified.Examples(s): type Showish = Show f :: (Showish a) => a -> a f = undefinedTest cases: typecheck should_fail tcfail209ghcTcRnIllegalClassInst is an error that occurs whenever a class instance is specified for a non-class.Examples(s): type C1 a = (Show (a -> Bool)) instance C1 Int whereTest cases: polykinds/T13267ghcTcRnOversaturatedVisibleKindArg is an error that occurs whenever an illegal oversaturated visible kind argument is specified.Examples(s): type family F2 :: forall (a :: Type). Type where F2 @a = Maybe aTest cases: typecheck should_fail"T15793 typecheck should_failT16255ghcTcRnBadAssociatedType is an error that occurs whenever a class doesn't have an associated type.=Examples(s): $(do d <- instanceD (cxt []) (conT ''Eq appT conT ''Foo) [tySynInstD $ tySynEqn Nothing (conT ''Rep appT conT ''Foo) (conT ''Maybe)] return [d]) ======> instance Eq Foo where type Rep Foo = MaybeTest cases: th/T12387aghcTcRnForAllRankErr is an error that occurs whenever an illegal ranked type is specified.Examples(s): foo :: (a,b) -> (a~b => t) -> (a,b) foo p x = pTest cases: - ghci should_runT15806 - indexed-types should_fail SimpleFail15 - typecheck should_failT11355 - typecheck should_failT12083a - typecheck should_failT12083b - typecheck should_failT16059c - typecheck should_failT16059e - typecheck should_failT17213 - typecheck should_failT18939_Fail - typecheck should_failT2538 - typecheck should_failT5957 - typecheck should_failT7019 - typecheck should_failT7019a - typecheck should_failT7809 - typecheck should_failT9196 - typecheck should_failtcfail127 - typecheck should_failtcfail184 - typecheck should_failtcfail196 - typecheck should_fail tcfail197ghcTcRnMonomorphicBindings is a warning (controlled by -Wmonomorphism-restriction) that arise when the monomorphism restriction applies to the given bindings.Examples(s): {-# OPTIONS_GHC -Wmonomorphism-restriction #-}bar = 10foo :: Int foo = bar&main :: IO () main = print foo)The example above emits the warning (for bar), because without monomorphism restriction the inferred type for bar: is 'bar :: Num p => p'. This warning tells us that if= we were to enable '-XMonomorphismRestriction' we would make bar less polymorphic, as its type would become 'bar :: Int', so GHC warns us about that.Test cases: typecheckshould_compileT13785ghcTcRnOrphanInstance is a warning (controlled by -Wwarn-orphans) that arises when a typeclass instance is an "orphan", i.e. if it appears in a module in which neither the class nor the type being instanced are declared in the same module.Examples(s): NoneTest cases: warningsshould_compile!T9178 typecheckshould_compileT4912ghcTcRnFunDepConflict is an error that occurs when there are functional dependencies conflicts between instance declarations.Examples(s): NoneTest cases: typecheck should_fail!T2307 typecheck should_fail%tcfail096 typecheck should_fail tcfail202ghcTcRnDupInstanceDecls is an error that occurs when there are duplicate instance declarations.Examples(s): class Foo a where foo :: a -> Int)instance Foo Int where foo = id/instance Foo Int where foo = const 42Test cases: cabalT12733"T12733 typecheck should_fail%tcfail035 typecheck should_fail$tcfail023 backpack should_fail%bkpfail18 typecheck should_fail+TcNullaryTCFail typecheck should_fail%tcfail036 typecheck should_failtcfail073 module/mod51 module/mod52 module/mod44ghcTcRnConflictingFamInstDecls is an error that occurs when there are conflicting family instance declarations.Examples(s): None.Test cases: indexed-types should_fail4ExplicitForAllFams4b indexed-types should_fail&NoGood indexed-types should_fail$Over indexed-types should_fail1OverDirectThisMod indexed-types should_fail3OverIndirectThisMod indexed-types should_fail-SimpleFail11a indexed-types should_fail-SimpleFail11b indexed-types should_fail-SimpleFail11c indexed-types should_fail-SimpleFail11d indexed-types should_fail,SimpleFail2a indexed-types should_fail,SimpleFail2b indexed-types should_fail-T13092/T13092 indexed-types should_fail/T13092c/T13092c indexed-types should_fail&T14179 indexed-types should_fail&T2334A indexed-types should_fail%T2677 indexed-types should_fail&T3330b indexed-types should_fail%T4246 indexed-types should_fail&T7102a indexed-types should_failT9371 polykinds/T7524 typecheck should_failUnliftedNewtypesOverlapghcTcRnBangOnUnliftedType is a warning (controlled by -Wredundant-strictness-flags) that occurs when a strictness annotation is applied to an unlifted type.Example(s): data T = MkT !Int# -- Strictness flag has no effect on unlifted typesTest cases: typecheckshould_compile"T20187a typecheckshould_compileT20187bghcTcRnMultipleDefaultDeclarations is an error that occurs when a module has more than one default declaration.Example: default (Integer, Int) default (Double, Float) -- 2nd default declaration not allowedText cases: module/mod58ghcTcRnBadDefaultType is an error that occurs when a type used in a default declaration does not have an instance for any of the applicable classes..Example(s): data Foo default (Foo)Test cases: typecheck should_failT11974bghcTcRnPatSynBundledWithNonDataCon is an error that occurs when a module's export list bundles a pattern synonym with a type that is not a proper `data` or  `newtype` construction.Example(s): module Foo (MyClass(.., P)) where pattern P = Nothing class MyClass a where foo :: a -> IntTest cases: patsyn should_fail export-classghcTcRnPatSynBundledWithWrongType is an error that occurs when the export list of a module has a pattern synonym bundled with a type that does not match the type of the pattern synonym.Example(s): module Foo (R(P,x)) where data Q = Q Int data R = R pattern P{x} = Q xText cases: patsyn should_fail)export-ps-rec-sel patsyn should_fail+export-type-synonym patsyn should_fail export-typeghc0TcRnDupeModuleExport is a warning controlled by -Wduplicate-exports that occurs when a module appears more than once in an export list.Example(s): module Foo (module Bar, module Bar) import BarText cases: NoneghcTcRnExportedModNotImported is an error that occurs when an export list contains a module that is not imported.Example(s): NoneText cases: module/mod135 module/mod8 rename should_fail#rnfail028 backpack should_fail bkpfail48ghcTcRnNullExportedModule is a warning controlled by -Wdodgy-exports that occurs when an export list contains a module that has no exports.Example(s): module Foo (module Bar) where import Bar ()Test cases: NoneghcTcRnMissingExportList is a warning controlled by -Wmissing-export-lists that occurs when a module does not have an explicit export list.Example(s): NoneTest cases: typecheck should_failMissingExportList03ghcTcRnExportHiddenComponents is an error that occurs when an export contains constructor or class methods that are not visible.Example(s): NoneTest cases: NoneghcTcRnDuplicateExport is a warning (controlled by -Wduplicate-exports) that occurs when an identifier appears in an export list more than once.Example(s): NoneTest cases: module/MultiExport module/mod128 module/mod14 module/mod5 overloadedrecflds should_fail(DuplicateExports patsynshould_compileT11959ghcTcRnExportedParentChildMismatch is an error that occurs when an export is bundled with a parent that it does not belong toExample(s): module Foo (T(a)) where data T a = TrueTest cases: module/T11970 module/T11970B module/mod17 module/mod3 overloadedrecflds should_failNoParentghcTcRnConflictingExports is an error that occurs when different identifiers that have the same name are being exported by a module.Example(s): module Foo (Bar.f, module Baz) where import qualified Bar (f) import Baz (f)Test cases: module/mod131 module/mod142 module/mod143 module/mod144 module/mod145 module/mod146 module/mod150 module/mod155 overloadedrecflds should_fail)T14953 overloadedrecflds should_fail/overloadedrecfldsfail10 rename should_fail!rnfail029 rename should_fail$rnfail040 typecheck should_fail#T16453E2 typecheck should_fail$tcfail025 typecheck should_fail tcfail026ghcTcRnAmbiguousField is a warning controlled by -Wambiguous-fields occurring when a record update's type cannot be precisely determined. This will not be supported by -XDuplicateRecordFields in future releases.Example(s): data Person = MkPerson { personId :: Int, name :: String } data Address = MkAddress { personId :: Int, address :: String } bad1 x = x { personId = 4 } :: Person -- ambiguous bad2 (x :: Person) = x { personId = 4 } -- ambiguous good x = (x :: Person) { personId = 4 } -- not ambiguousTest cases: overloadedrecflds should_failoverloadedrecfldsfail06ghcTcRnMissingFields is a warning controlled by -Wmissing-fields occurring when the intialisation of a record is missing one or more (lazy) fields.Example(s): data Rec = Rec { a :: Int, b :: String, c :: Bool } x = Rec { a = 1, b = "two" } -- missing field cTest cases: deSugarshould_compileT13870 deSugarshould_compileds041 patsynshould_compileT11283 renameshould_compileT5334 renameshould_compileT12229 renameshould_compile T5892a warnings should_fail WerrorFail2ghcTcRnFieldUpdateInvalidType is an error occurring when an updated field's type mentions something that is outside the universally quantified variables of the data constructor, such as an existentially quantified type.Example(s): data X = forall a. MkX { f :: a } x = (MkX ()) { f = False }Test cases: patsyn should_fail+records-exquant typecheck should_failT3323ghcTcRnNoConstructorHasAllFields is an error that occurs when a record update has fields that no single constructor encompasses.Example(s): data Foo = A { x :: Bool } | B { y :: Int } foo = (A False) { x = True, y = 5 }Test cases: overloadedrecflds should_fail/overloadedrecfldsfail08 patsyn should_fail4mixed-pat-syn-record-sels typecheck should_failT7989ghcTcRnSpecialClassInst is an error that occurs when a user attempts to define an instance for a built-in typeclass such as  Coercible, , or KnownNat, outside of a signature file.Test cases: deriving should_failT9687 deriving should_failT14916 polykinds/T8132 typecheck should_fail+TcCoercibleFail2 typecheck should_fail!T12837 typecheck should_failT14390ghcTcRnUselessTypeable is a warning (controlled by -Wderiving-typeable) that occurs when trying to derive an instance of the  class. Deriving  is no longer necessary (hence the "useless") as all types automatically derive  in modern GHC versions.Example(s): None.Test cases: warningsshould_compileDerivingTypeableghcTcRnDerivingDefaults is a warning (controlled by -Wderiving-defaults) that occurs when both DeriveAnyClass and GeneralizedNewtypeDeriving2 are enabled, and therefore GHC defaults to DeriveAnyClass/, which might not be what the user wants.Example(s): None.Test cases: typecheckshould_compile!T15839a derivingshould_compileT16179ghcTcRnNonUnaryTypeclassConstraint is an error that occurs when GHC encounters a non-unary constraint when trying to derive a typeclass.Example(s): class A deriving instance A data B deriving A -- We cannot derive A, is not unary (i.e. 'class A a').Test cases: deriving should_failT7959 deriving should_fail$drvfail005 deriving should_fail$drvfail009 deriving should_fail drvfail006ghcTcRnPartialTypeSignatures is a warning (controlled by -Wpartial-type-signatures) that occurs when a wildcard '_' is found in place of a type in a signature or a type class derivation5Example(s): foo :: _ -> Int foo = ...!deriving instance _ => Eq (Foo a)Test cases: dependentshould_compile!T11241 dependentshould_compile!T15076 dependentshould_compile#T14880-2 typecheckshould_compile!T17024 typecheckshould_compile$T10072 partial-sigs should_fail(TidyClash2 partial-sigs should_fail.Defaulting1MROff partial-sigs should_fail:WildcardsInPatternAndExprSig partial-sigs should_fail$T10615 partial-sigs should_fail%T14584a partial-sigs should_fail'TidyClash partial-sigs should_fail$T11122 partial-sigs should_fail$T14584 partial-sigs should_fail$T10045 partial-sigs should_fail;PartialTypeSignaturesDisabled partial-sigs should_fail$T10999 partial-sigs should_failExtraConstraintsWildcardInExpressionSignature partial-sigs should_failExtraConstraintsWildcardInPatternSplice partial-sigs should_fail4WildcardInstantiations partial-sigs should_run$T15415 partial-sigsshould_compile$T10463 partial-sigsshould_compile%T15039a partial-sigsshould_compile%T16728b partial-sigsshould_compile%T15039c partial-sigsshould_compile$T10438 partial-sigsshould_compile)SplicesUsed partial-sigsshould_compile$T18008 partial-sigsshould_compile*ExprSigLocal partial-sigsshould_compile%T11339a partial-sigsshould_compile$T11670 partial-sigsshould_compile;WarningWildcardInstantiations partial-sigsshould_compile$T16728 partial-sigsshould_compile$T12033 partial-sigsshould_compile%T15039b partial-sigsshould_compile$T10403 partial-sigsshould_compile$T11192 partial-sigsshould_compile%T16728a partial-sigsshould_compile)TypedSplice partial-sigsshould_compile%T15039d partial-sigsshould_compile$T11016 partial-sigsshould_compile'T13324_compile2 linear should_failLinearPartialSig polykinds/T14265 polykinds/T14172ghcTcRnCannotDeriveInstance is an error that occurs every time a typeclass instance can't be derived. The 9 will contain the specific reason this error arose.Example(s): None.Test cases: genericsT10604.T10604_no_PolyKinds deriving should_fail%drvfail009 deriving should_fail+drvfail-functor2 deriving should_fail'T10598_fail3 deriving should_fail-deriving-via-fail2 deriving should_fail,deriving-via-fail deriving should_failT16181ghcTcRnLazyGADTPattern is an error that occurs when a user writes a nested GADT pattern match inside a lazy (~) pattern.Test case: gadt/lazypatghcTcRnArrowProcGADTPattern is an error that occurs when a user writes a GADT pattern inside arrow proc notation.Test case: arrows should_fail arrowfail004.ghcTcRnForallIdentifier is a warning (controlled with -Wforall-identifier) that occurs when a definition uses forall as an identifier.2Example: forall x = () g forall = ()2Test cases: T20609 T20609a T20609b T20609c T20609dghcTcRnTypeEqualityOutOfScope is a warning (controlled by -Wtype-equality-out-of-scope) that occurs when the type equality (a ~ b) is not in scope.Test case: T18862bghcTcRnTypeEqualityRequiresOperators is a warning (controlled by -Wtype-equality-requires-operators) that occurs when the type equality (a ~ b) is used without the TypeOperators extension.Example: {-# LANGUAGE NoTypeOperators #-} f :: (a ~ b) => a -> bTest case: T18862aghcTcRnIllegalTypeOperator is an error that occurs when a type operator is used without the TypeOperators extension.Example: {-# LANGUAGE NoTypeOperators #-} f :: Vec a n -> Vec a m -> Vec a (n + m)Test case: T12811ghcTcRnGADTMonoLocalBinds is a warning controlled by -Wgadt-mono-local-binds that occurs when pattern matching on a GADT when -XMonoLocalBinds is off.Example(s): NoneTest cases: T20485, T20485aghcThe TcRnNotInScope constructor is used for various not-in-scope errors. See  for more details. ghcTcRnUntickedPromotedThing is a warning (controlled with -Wunticked-promoted-constructors) that is triggered by an unticked occurrence of a promoted data constructor. Examples:data A = MkA type family F (a :: A) where { F MkA = Bool }type B = [ Int, Bool ]Test cases: T9778, T19984.ghcTcRnIllegalBuiltinSyntax is an error that occurs when built-in syntax appears in an unexpected location, e.g. as a data constructor or in a fixity declaration. Examples: infixl 5 : data P = (,)/Test cases: rnfail042, T14907b, T15124, T15233.ghcTcRnWarnDefaulting is a warning (controlled by -Wtype-defaults) that is triggered whenever a Wanted typeclass constraint is solving through the defaulting of a type variable.Example:one = show 1 -- We get Wanteds Show a0, Num a0, and default a0 to Integer.Test cases: none (which are really specific to defaulting), but see e.g. tcfail204.ghc6TcRnIncorrectNameSpace is an error that occurs when a  is used in the incorrect  NameSpace, e.g. a type constructor or class used in a term, or a term variable used in a type.Example: f x = IntTest cases: T18740a, T20884.ghc* is an "internal" type (used only inside  that wraps a ʋ while also providing any extra info needed to correctly pretty-print this diagnostic later on.ghc&Extra context associated to the error.Œghc1Extra supplementary info associated to the error.ӌghc Create a "not in scope" error message for the given '.Ԍghc#Append additional information to a .֌ghcDisplay some relevant bindings.ghcalways a class constraintghc/ambiguous kind and type variables, respectivelyghcThe type constructor that occurs in the typeclass instance declaration.ghcThe typeclass kind.ghcThe number of typeclass arguments that GHC kept. See Note [tc_args and tycon arity] in GHC.Tc.Deriv. | Generic instances can only be derived using the stock strategy in Safe Haskell.ghc5Type constructor for which the instance is requestedghcWhether or not -XDeriveAnyClass is enabled already. | Stock deriving won't work, but perhas DeriveAnyClass will.̋ghcThe t will allow us to pretty-print some diagnostics with more detail.΋ghcThe contextual skolem info. The boolean controls whether we want to show it in the user message. (Nice to keep track of the info in either case, for other users of the GHC API.)ϋghc+The implication containing a contradiction.ghcThe contradiction(s).܋ghc The limit.ghcthe wildcard name, or J for an anonymous wildcardghcfirst type variableghcsecond type variableghc function nameghc3user-written name of type variable being quantifiedghc function nameghc(type the variable unified with, if knownghcpartial type signatureghcTrue: -Wmissing-signatures overrides -Wmissing-exported-signatures, or -Wmissing-pattern-synonym-signatures overrides -Wmissing-exported-pattern-synonym-signaturesghc2whether this is an unboxed tuple or an unboxed sumghc&Occurrence name shared by both exportsghcName of first exportghc.Provenance for definition site of first exportghcExport decl of first exportghcName of second exportghc/Provenance for definition site of second exportghcExport decl of second exportghc Field updateghc Record typeghcRecordghcRecord selectorsghcPattern synonymghcPattern selectorsghc6Whether the error is due to Safe Haskell being enabledghc6The typeclass we are trying to derive an instance forghc The typeclass arguments, if any.ghc The derivation strategy, if any.ghc*Is '-XGeneralizedNewtypeDeriving' enabled?ghcThe specific reason why we couldn't derive an instance for the class.ghcwhat the problem isghcthe name that is not in scopeghcimport errors that are relevantghchints, e.g. enable DataKinds to refer to a promoted data constructorghc?what kind of thing this is (a binding, fixity declaration, ...)ghc/Wanted constraints in which defaulting occurredghc!The type variable being defaultedghcThe default typeghcwhether the error is happening in a Template Haskell tick (so we should give a Template Haskell hint)ghc&Extra info associated with the messageʋˋ̋͋΋ϋЋыҋӋԋՋ֋׋؋ًڋۋ܋݋ދߋŒÌČŌƌnjȌɌʌˌފߊ̌ڊۊ܊݊׊؊ي‰ÉĉʼnƉljΌόьЌҊӊԊՊ֊ΊϊЊъʊˊ̊͊ŠÊĊŊƊNJȊɊ͌ҌԌЉщ҉Ӊ͉̉ΉωՌȉɉʉˉ֌ӌ؉ىډ߉ۉ܉݉މԉՉ։׉ËċŋƋNjȋɋ‹ʋˋ̋͋΋ϋЋыҋӋԋՋ֋׋؋ًڋۋ܋݋ދߋŒÌČŌƌnjȌɌʌˌފߊ̌ڊۊ܊݊׊؊ي‰ÉĉʼnƉljΌόьЌҊӊԊՊ֊ΊϊЊъʊˊ̊͊ŠÊĊŊƊNJȊɊ͌ҌԌЉщ҉Ӊ͉̉ΉωՌȉɉʉˉ֌ӌ؉ىډ߉ۉ܉݉މԉՉ։׉ËċŋƋNjȋɋ‹ Safe-Inferred %&'V ghcWhat warning flag is associated with the given missing signature?ghcPretty-print a ʊ, containing a  with its enclosing .ghcPretty-print a , with its enclosing .ghcDirectly display the given matching and unifying instances, with a header for each: `Matching instances Potentially matching instances`.ghcDisplay a summary of available instances, omitting those involving out-of-scope types, in order to explain why we couldn't solve a particular constraint, e.g. due to instance overlap or out-of-scope types.To directly display a collection of matching/unifying instances, use .ghcDisplay a summary of available instances, omitting out-of-scope ones.Use 3 to automatically set the pretty-printing options.ghcCompute a message informing the user of any instances that are overlapped but were not discarded because the instance overlapping them wasn't strictly more specific.ghc6Pretty-print an informational message, to accompany a .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.ghc:the type which doesn't have a fixed runtime representationghcIf False, only prints the why.ghcWhether to print all potential instances Safe-InferreddɑghcBring the exports of a particular module (filtered by an import decl) into scopeʑghcBring into scope the entire top-level envt of of this module, including the things imported into it.ˑghcInteractive context, recording information about the state of the context in which statements are executed in a GHCi session.͑ghcThe o: used to evaluate interactive expressions and statements.Α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]ϑghcThe GHCi top-level scope (icReaderEnv) 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.БghcTyThings defined by the user, in reverse order of definition (ie most recent at the front). Also used in GHC.Tc.Module.runTcInteractive to fill the type checker environment. See Note [ic_tythings]ёghcEssentially the cached '.The GlobalRdrEnv contains everything in scope at the command line, both imported and everything in ic_tythings, with the correct shadowing.The IcGlobalRdrEnv contains extra data to allow efficient recalculation when the set of imports change. See Note [icReaderEnv recalculation]ґ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.ӑghc#Fixities declared in let statementsԑghc$The current default types, set by a  'default' declarationՑghc The stack of breakpoint contexts֑ghc#The monad that GHCi is executing inבghcThe function that is used for printing results of expressions in ghci and -e mode.ؑghcvirtual CWD of the programّghcCache of loaded plugins. We store them here to avoid having to load them everytime we switch to the interctive context.ڑghc'Constructs an empty InteractiveContext.ݑghcThis function returns the list of visible TyThings (useful for e.g. showBindings).It picks only those TyThings that are not shadowed by later definitions on the interpreter, to not clutter :showBindings with shadowed ids, which would show up as Ghci9.foo.Some TyThings define many names; we include them if _any_ name is still available unqualified.ޑghcGet the PrintUnqualified function based on the flags and this InteractiveContextߑghcextendInteractiveContext is called with new TyThings recently defined to update the InteractiveContext to include them. By putting new things first, unqualified use will pick the most recently defined thing with a given name, while still keeping the old names in scope in their qualified form (Ghci1.foo).ghcAdd TyThings to the GlobalRdrEnv, earlier ones in the list shadowing later ones, and shadowing existing entries in the GlobalRdrEnv.ˑ̑͑ΑϑБёґӑԑՑ֑בّؑȑɑʑڑߑۑܑݑޑˑ̑͑ΑϑБёґӑԑՑ֑בّؑȑɑʑڑߑۑܑݑޑ Safe-Inferred#ghc"`where'3 clause at the same depth as implicit layout block"ghc"`|'- at the same depth as implicit layout block")ghcErrors from the Cmm parserghcUnknown Cmm primitiveghc Unknown macroghcUnknown calling conventionghcUnrecognised safetyghcUnrecognised hintghc Lexical errorghcUnknown pragmaghcLexical error in pragmaghc$Numeric escape sequence out of rangeghc)Lexical error in string/character literalghc2Unexpected end-of-file in string/character literalghcUnterminated `{-'ghcUnterminated OPTIONS pragmaghcUnterminated quasiquotationghc End of inputghcUTF-8 decoding errorghcError at given characterghcNegative application pattern?ghc*The list of type arguments for the patternghcExtra information for the expression GHC is currently inspecting/parsing. It can be used to generate more informative parser diagnostics and hints.ghcIf K9, this is an infix pattern with the binded operator nameghc9Did the parser likely fail due to an incomplete do block?ghc Is the parsed pattern recursive?ghcExtra details about a parse error, which helps us in determining which should be the hints to suggest.ďghc Is there a 'do' in the last 100 characters?ŏghc Is there an mdo in the last 100 characters?ƏghcIs PatternSynonyms enabled?Ǐghc!Did we parse a "pattern" keyword?ɏghcAn "unknown" message from the parser. This type constructor allows arbitrary messages to be embedded. The typical use case would be GHC plugins willing to emit custom diagnostics.ʏghc&A group of parser messages emitted in 5. See Note [Messages from GHC.Parser.Header].ˏ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.̏ghcPsWarnTab is a warning (controlled by the -Wwarn-tabs flag) that occurs when tabulations (tabs) are found within a file.Test case(s): parser should_fail"T12610 parsershould_compile"T9723b parsershould_compile"T9723a parsershould_compile#read043 parser should_fail$T16270 warningsshould_compileT9230͏ghcPsWarnTransitionalLayout is a warning (controlled by the -Walternative-layout-rule-transitional flag) that occurs when pipes ('|' ) or 'where'3 are at the same depth of an implicit layout block. Example(s):f :: IO () f | True = do let x = () y = () return () | True = return ()Test case(s): layout/layout006 layout/layout003 layout/layout001ΏghcUnrecognised pragmaЏghc Invalid Haddock comment positionяghc,Multiple Haddock comment for the same entityҏghc;Found binding occurrence of "*" while StarIsType is enabledӏghcUsing "*" for Type without StarIsType enabledԏghcPre qualified import with WarnPrepositiveQualifiedModule enabled׏ghc4LambdaCase syntax used without the extension enabled؏ghc(A lambda requires at least one parameterُghc5Underscores in literals without the extension enabledڏghc%Invalid character in primitive stringۏghc Missing block܏ghc Lexer errorݏghcSuffix occurrence of @ޏghc Parse errorsߏghcCmm lexer errorghc#Unsupported boxed sum in expressionghc Unsupported boxed sum in patternghc Unexpected qualified constructorghc Tuple section in pattern contextghc*Bang-pattern without BangPattterns enabledghc%Operator applied to too few argumentsghc Import: multiple occurrences of  qualifiedghcPost qualified import without ImportQualifiedPostghc#Explicit namespace keyword without ExplicitNamespacesghc1Expecting a type constructor but found a variableghc.Illegal export form allowed by PatternSynonymsghcMalformed entity stringghcDots used in record updateghcPrecedence out of rangeghc!Invalid use of record dot syntax hghcOverloadedRecordUpdate is not enabled.ghcCan't use qualified fields when OverloadedRecordUpdate is enabled.ghc;Cannot parse data constructor in a data/newtype declarationghc;Cannot parse data constructor in a data/newtype declarationghcIllegal DataKinds quote mark in data/newtype constructor declarationghc$UNPACK applied to a data constructorghc7Unexpected kind application in data/newtype declarationghcNot a record constructorghc)Illegal unboxed string literal in patternghc3Illegal primitive floating point literal in patternghcDo-notation in patternghcIf-then-else syntax in patternghcLambda-case in patternghccase..of in patternghclet-syntax in patternghcLambda-syntax in patternghc"Arrow expression-syntax in patternghcArrow command-syntax in patternghc"Arrow command-syntax in expressionghcView-pattern in expressionghc&Type-application without space before @ghcLazy-pattern (C) without space after itghcBang-pattern (!) without space after itghc#Pragma not allowed in this positionghcQualified do block in commandghc.Invalid infix hole, expected an infix operatorghc0Unexpected semi-colons in conditional expressionghc-Unexpected semi-colons in conditional commandghc @-operator in a pattern positionghc1Unexpected lambda command in function applicationghc/Unexpected case command in function applicationghc2Unexpected case(s) command in function applicationghc-Unexpected if command in function applicationghc.Unexpected let command in function applicationghc-Unexpected do command in function applicationghc+Unexpected do block in function applicationghc,Unexpected mdo block in function applicationghc4Unexpected lambda expression in function applicationghc2Unexpected case expression in function applicationghc5Unexpected case(s) expression in function applicationghc1Unexpected let expression in function applicationghc0Unexpected if expression in function applicationghc2Unexpected proc expression in function applicationghc+Malformed head of type or class declarationghcIllegal 'where' keyword in data declarationghcIllegal datatype contextghcParse error on inputghc!Malformed ... declaration for ...ghc,Unexpected type application in a declarationghcNot a data constructorghc1Record syntax used in pattern synonym declarationghcEmpty 'where'& clause in pattern-synonym declarationghcInvalid binding name in 'where'& clause of pattern-synonym declarationghcMultiple bindings in 'where'& clause of pattern-synonym declarationghc"Declaration splice not a top-levelghc(Inferred type variables not allowed hereghc,Multiple names in standalone kind signaturesghcIllegal import bundle formghcIllegal role nameghcInvalid type signatureghcUnexpected type in declarationghcExpected a hyphenghcFound a space in a SCCghcFound two single quotesghcInvalid package nameghcInvalid rule activation markerghc1Linear function found but LinearTypes not enabledghc8Multi-way if-expression found but MultiWayIf not enabledghc=Explicit forall found but no extension allowing it is enabledghc.Found qualified-do without QualifiedDo enabledghcCmm parser errorghc!Illegal traditional record syntax+TODO: distinguish errors without using SDocghcParse error in command+TODO: distinguish errors without using SDocghcParse error in patternghcParse error in right operator section pattern TODO: embed the proper operator, if possibleghcIllegal linear arrow or multiplicity annotation in GADT record syntaxghcPsErrUnsupportedOptionsPragma is an error that occurs when an unknown OPTIONS_GHC pragma is supplied is found.+Example(s): {-# OPTIONS_GHC foo #-} Test case(s):tests safeHaskellflags/SafeFlags28 tests safeHaskellflags/SafeFlags19 tests safeHaskellflags/SafeFlags29 testsparser!should_fail/T19923c testsparser!should_fail/T19923b testsparser%should_fail/readFail044 testsdriverT2499Őghc Builds a & with the information provided by the .ghcThe pattern argumentsghc Is the parsed pattern recursive?̏ghc4Number of other occurrences other than the first oneghcconditional 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" exprghc Is TH on?ghcis Unicode forall?ǏƏŏďϏȏߏޏݏ܏ۏڏُ؏׏ՏяЏϏΏ͏ˏɏҏԏӏ֏̏ʏÐĐՐȏߏޏݏ܏ۏڏُ؏׏ՏяЏϏΏ͏ˏɏҏԏӏ֏̏ʏǏƏŏďϏÐĐŐ Safe-Inferred %&)*ΐϐАѐҐӐԐՐΐϐАѐҐӐԐՐ Safe-InferredL)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.ghc)Add a warning to the accumulator. Use Π! to get the accumulated warnings.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.ghc5Check if a given flag is currently set in the bitmap.ghcGo through the  comment_q in PState; and remove all comments that belong within the given spanghcGo through the  comment_q in PState and remove all comments that come before or within the given spanghcGo through the  comment_q in PState8 and remove all comments that come after the given spanghcVarious 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.ghcFor 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.ghc!The parsing monad, isomorphic to StateT PState Maybe.ghcHaddock comment as produced by the lexer. These are accumulated in  and then processed in GHC.Parser.PostProcess.Haddock. The location of the 6s spans over the contents of the docstring - i.e. it does not include the decorator ("-- |", "{-|" etc.)ghcParser options.See Ġ to construct this.ghcbitmap of permitted extensionsghc)Options to construct diagnostic messages.ghcsupported extensions (only used for suggestions in error messages)ghcThe result of running a parser.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).ghc (|ghc |)ghc -<ghc >-ghc -<<ghc >>-ghc*Used when the lexer can't make sense of itghcend of file tokenghcThe HsDocString contains more details about what this is and how to pretty print itghc(doc options (prune, ignore-exports, etc)ghccomment starting by "--"ghccomment in {- -}ghcThe parser has consumed a (possibly empty) prefix of the input and failed.The carried parsing state can be used to resume parsing. It is the state right before failure, including the fatal parse error. Π and ͠' must return a non-empty bag of errors.ghcThe parser has consumed a (possibly empty) prefix of the input and produced a result. Use Π9 to check for accumulated warnings and non-fatal errors.8The carried parsing state can be used to resume parsing.ghcIncludes the trailing '-}' decorators drop the last two elements with the callback if you don't want them to be includedghcTest whether a 1 is setĠghc1Given exactly the information needed, set up the Ơghc.Set parser options for parsing OPTIONS pragmasǠghcCreates a parse state from a  value͠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.ՠghcGiven a  that surrounds a HsPar or HsParTy , generate 7 values for the opening and closing bordering on the start and end of the spanghcContinuation that gets the rest of the input and the lexed commentghcstarting value for accumulator (reversed) - When we want to include a decorator '{-' in the commentĠghc%permitted language extensions enabledghcdiagnostic optionsghc"Supported Languages and Extensionsghcare 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.ŸßğşƟǟȟɟʟ˟̟͟ΟϟПџҟӟԟ՟֟ן؟ٟڟ۟ܟݟޟߟҠӠĠǠƠ֠נؠѠ͠ΠϠРǞžÞўӞОԞƞ͞ޞ֞˞ҞȞݞߞ՞ɞ̞ĞŞʞΞϞמ؞ٞڞ۞ܞà ŠԠՠȠɠʠˠ٠̠ŸßğşƟǟȟɟʟ˟̟͟ΟϟПџҟӟԟ՟֟ן؟ٟڟ۟ܟݟޟߟҠӠĠǠƠ֠נؠѠ͠ΠϠРǞžÞўӞОԞƞ͞ޞ֞˞ҞȞݞߞ՞ɞ̞ĞŞʞΞϞמ؞ٞڞ۞ܞà ŠԠՠȠɠʠˠ٠̠ Safe-Inferred()*/1P=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.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 @t (visible kind application)ghc Disambiguate f # x (infix operator)ghc Disambiguate {-# UNPACK #-} t (unpack/nounpack pragma)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]ghcInfix operator representationghc Function argument representationghcReturn 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 "... -> ..." (lambda)ghcDisambiguate "let ... in ..."ghcBring superclass constraints on InfixOp into scope. See Note [UndecidableSuperClasses for associated types]ghc%Disambiguate "f # x" (infix operator)ghcDisambiguate "case ... of ..."ghcDisambiguate "case" and "cases"ghcBring superclass constraints on FunArg into scope. See Note [UndecidableSuperClasses for associated types]ghc)Disambiguate "f x" (function application)ghc.Disambiguate "f @t" (visible type application)ghc'Disambiguate "if ... then ... else ..."ghc'Disambiguate "do { ... }" (do notation)ghc$Disambiguate "( ... )" (parentheses)ghc2Disambiguate a variable "f" or a data constructor MkF.ghc"Disambiguate a monomorphic literalghc"Disambiguate an overloaded literalghcDisambiguate a wildcardghc'Disambiguate "a :: t" (type annotation)ghc$Disambiguate "[a,b,c]" (list syntax)ghc5Disambiguate "$(...)" and "[quasi|...|]" (TH splices)ghcDisambiguate "f { a = b, ... }" syntax (record construction and record updates)ghcDisambiguate "-a" (negation)ghc-Disambiguate "(# a)" (right operator section)ghc&Disambiguate "(a -> b)" (view pattern)ghcDisambiguate "a@b" (as-pattern)ghc Disambiguate "~a" (lazy pattern)ghc Disambiguate "!a" (bang pattern)ghc,Disambiguate tuple sections and unboxed sumsghcValidate infixexp LHS to reject unwanted {-# SCC ... #-} pragmasghcDisambiguate infix operators. See Note [Ambiguous syntactic categories]ghcResult of parsing {-# UNPACK #-} or {-# NOUNPACK #-}.ghcEssentially a wrapper for a RuleBndr GhcPsghcmkClassDecl 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).ghcConverts a list of Qs annotated with their  to binders without annotations. Only accepts specified variables, and errors if any of the provided binders has an ! annotation.ghc Converts Q annotated with its  to one without annotations. Only accepts specified variables, and errors if the provided binder has an ! annotation.ghcAdd the annotation for a 'where' keyword to existing  HsLocalBindsghcFunction definitions are restructured here. Each is assumed to be recursive initially, and non recursive definitions are discovered by the dependency analyser.ghcReinterpret a type constructor, including type operators, as a data constructor. See Note [Parsing data constructors is hard]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.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.ghcCheck whether the given list of type parameters are all type variables (possibly with a kind signature).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.ghcValidate 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] ɡghcAnnotate a type with either an {-# UNPACK #-} or a {-# NOUNPACK #-} pragma.ʡghcCheck for monad comprehensions1If the flag MonadComprehensions is set, return a f# context, otherwise use the usual f contextghcEnsure that a literal pattern isn't of type Addr#, Float#, Double#.ghcRejects declarations such as  data T = 'MkT (note the leading tick).ϡghcCheck if a fixity is valid. We support bypassing the usual bound checks for some special operators.ghc#Hint about bang patterns, assuming  BangPatterns is off.ϡghc precedenceghc operators~}}}}ӡԡСҡѡšա֡סء¡ϡáġĐʡơǡȡ١ڡܡۡݡޡߡˡ̡ɡ͡Ρ~}}}}ӡԡСҡѡšա֡סء¡ϡáġĐʡơǡȡ١ڡܡۡݡޡߡˡ̡ɡ͡Ρ Safe-Inferred(8 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 Q%. To avoid duplicating the logic in  here, we simply reuse  and perform surgery on the Q it returns to turn it into an Q.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 Q/s, this simply returns the third argument (an Q). Otherwise, return an Q using the provided Q and Q.ghcIf passed an empty ., this simply returns the third argument (an Q). Otherwise, return an Q using the provided Q and Q.ghc lc returns J if lc is empty and K lc otherwise.This is much like , except that it returns a @ (Q P). This is used specifically for constructing superclasses, datatype contexts (#20011), and contexts in GADT constructor types (#20590). We wish to avoid using K [] in the case of an empty contexts, as the pretty-printer always prints K" contexts, even if they're empty.ghcThe location of the returned Q" 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 Q# if it needs an explicit contextghcThe converted contextghcThe converted tau typeghc8The complete type, qualified with a context if necessary Safe-Inferred gghc#Extract identifier from Alex state.ghcLex  for warning messagesghc!Lex identifiers from a docstring.ghcadornment lengthghc Token lengthghc2The remaining input beginning with the found tokenghcA precise identifier parserghcA precise identifier parser Safe-Inferred'38?ۋghc,Represents a predicate on the column number.ColumnBound | Int -> Bool --------------+----------------- ColumnFrom n | (>=n)+The semigroup instance corresponds to (&&).ghcWarnings accumulated in HdkM.ghcThe state of HdkM.ghcAdd Haddock documentation accumulated in the parser state to a parsed HsModule.Reports badly positioned comments when -Winvalid-haddock is enabled.ghcThe inverse of z 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-Inferredghc%Extracts the flags needed for parsing Safe-InferredwܻghcReturn the UnitId of the home-unit. This is used to create labels.ջֻ׻ػٻڻۻܻջֻ׻ػٻڻۻܻ Safe-Inferred99 Safe-InferredDߐghc5Why TemplateHaskell rejected the splice. Used in the  constructor of a .ghc/Diagnostics messages emitted during desugaring.ghcSimply wraps a generic b message.ghcDsEmptyEnumeration is a warning (controlled by the -Wempty-enumerations flag) that is emitted if an enumeration is empty. Example(s):main :: IO () main = do let enum = [5 .. 3] print enumHere enum8 would yield an empty list, because 5 is greater than 3. Test case(s): warningsshould_compileT10930 warningsshould_compileT18402 warningsshould_compileT10930b numericshould_compileT10929 numericshould_compileT7881 deSugar should_runT18172ghcDsIdentitiesFound is a warning (controlled by the -Widentities flag) that is emitted on uses of Prelude numeric conversions that are probably the identity (and hence could be omitted). Example(s):main :: IO () main = do let x = 10 print $ conv 10where conv :: Int -> Int conv x = fromIntegral x Here calling conv is essentially the identity function, and therefore can be omitted.Test case(s): deSugarshould_compileT4488ghcThe list of unbound bindersghcThe original bindersghcThe original LHSghcThe optimised LHSאِؐڐېܐސݐߐߐܐސݐڐېאِؐ Safe-Inferred)* 7(ghc Pass to a  the information whether or not the '-fbuilding-cabal-package' flag is set.ghcA message from the driver.ghcSimply wraps a generic b message a.ghcA parse error in parsing a Haskell file header during dependency analysisghcDriverMissingHomeModules is a warning (controlled with -Wmissing-home-modules) that arises when running GHC in --make mode when some modules needed for compilation are not included on the command line. For example, if A imports B, `ghc --make A.hs` will cause this warning, while `ghc --make A.hs B.hs` will not.Useful for cabal to ensure GHC won't pick up modules listed neither in 'exposed-modules' nor in 'other-modules'.Test case: warningsshould_compile MissingModghcDriverUnknown is a warning that arises when a user tries to reexport a module which isn't part of that unit.ghcDriverUnknownHiddenModules is a warning that arises when a user tries to hide a module which isn't part of that unit.ghcDriverUnusedPackages occurs when when package is requested on command line, but was never needed during compilation. Activated by -Wunused-packages.Test cases: warningsshould_compileUnusedPackagesghcDriverUnnecessarySourceImports (controlled with -Wunused-imports) occurs if there are {-# SOURCE #-} imports which are not necessary. See warnUnnecessarySourceImports in .Test cases: warningsshould_compileT10637ghc5DriverDuplicatedModuleDeclaration occurs if a module A& is declared in multiple files.Test cases: None.ghc(DriverModuleNotFound occurs if a module A can't be found.Test cases: None.ghc0DriverFileModuleNameMismatch occurs if a module A is defined in a file with a different name. The first field is the name written in the source code; the second argument is the name extracted from the filename.Test cases: modulemod178, driver/bug1677ghc>DriverUnexpectedSignature occurs when GHC encounters a module A= that imports a signature file which is neither in the  signatures section of a '.cabal' file nor in any package in the home modules.Example:*- MyStr.hsig is defined, but not added to  signatures in the '.cabal' file. signature MyStr where data Str- A.hs, which tries to import the signature. module A where import MyStrTest cases: driver/T12955ghcDriverFileNotFound occurs when the input file (e.g. given on the command line) can't be found.Test cases: None.ghc1DriverStaticPointersNotSupported occurs when the StaticPointers9 extension is used in an interactive GHCi context.Test cases: ghciscripts StaticPtrghcDriverBackpackModuleNotFound occurs when Backpack can't find a particular module during its dependency analysis. Test cases: -ghcDriverUserDefinedRuleIgnored is a warning that occurs when user-defined rules are ignored. This typically happens when Safe Haskell. Test cases:tests safeHaskell%safeInfered/UnsafeWarn05 tests safeHaskell%safeInfered/UnsafeWarn06 tests safeHaskell%safeInfered/UnsafeWarn07 tests safeHaskell(safeInfered/UnsafeInfered11 tests safeHaskellsafeLanguage/SafeLang03ghcDriverMixedSafetyImport is an error that occurs when a module is imported both as safe and unsafe. Test cases:tests safeHaskellsafeInfered/Mixed03 tests safeHaskellsafeInfered/Mixed02ghcDriverCannotLoadInterfaceFile is an error that occurs when we cannot load the interface file for a particular module. This can happen for example in the context of Safe Haskell, when we have to load a module to check if it can be safely imported.Test cases: None.ghcDriverInferredSafeImport is a warning (controlled by the Opt_WarnSafe flag) that occurs when a module is inferred safe.Test cases: None.ghcDriverMarkedTrustworthyButInferredSafe is a warning (controlled by the Opt_WarnTrustworthySafe flag) that occurs when a module is marked trustworthy in SafeHaskell but it has been inferred safe.Test cases: tests safeHaskell)safeInfered/TrustworthySafe02 tests safeHaskellsafeInfered/TrustworthySafe03ghcDriverInferredSafeImport is a warning (controlled by the Opt_WarnInferredSafeImports flag) that occurs when a safe-inferred module is imported from a safe module.Test cases: None.ghcDriverCannotImportUnsafeModule is an error that occurs when an usafe module is being imported from a safe one.Test cases: None.ghcDriverMissingSafeHaskellMode is a warning (controlled by the Opt_WarnMissingSafeHaskellMode flag) that occurs when a module is using SafeHaskell features but SafeHaskell mode is not enabled.Test cases: None.ghcDriverPackageNotTrusted is an error that occurs when a package is required to be trusted but it isn't.Test cases: tests safeHaskellcheck/Check01 tests safeHaskellcheck/Check08 tests safeHaskellcheck/Check06 tests safeHaskellcheckpkg01ImpSafeOnly09 tests safeHaskellcheckpkg01ImpSafe03 tests safeHaskellcheckpkg01ImpSafeOnly07 tests safeHaskellcheckpkg01 ImpSafeOnly08ghcDriverCannotImportFromUntrustedPackage is an error that occurs in the context of Safe Haskell when trying to import a module coming from an untrusted package.Test cases: tests safeHaskellcheck/Check09 tests safeHaskellcheckpkg01ImpSafe01 tests safeHaskellcheckpkg01ImpSafe04 tests safeHaskellcheckpkg01ImpSafeOnly03 tests safeHaskellcheckpkg01ImpSafeOnly05 tests safeHaskellflags/SafeFlags17 tests safeHaskellflags/SafeFlags22 tests safeHaskellflags/SafeFlags23 tests safeHaskellghci/p11 tests safeHaskellghci/p12 tests safeHaskellghci/p17 tests safeHaskellghci/p3 tests safeHaskell'safeInfered/UnsafeInfered01 tests safeHaskell'safeInfered/UnsafeInfered02 tests safeHaskell'safeInfered/UnsafeInfered02 tests safeHaskell'safeInfered/UnsafeInfered03 tests safeHaskell'safeInfered/UnsafeInfered05 tests safeHaskell'safeInfered/UnsafeInfered06 tests safeHaskell'safeInfered/UnsafeInfered09 tests safeHaskell'safeInfered/UnsafeInfered10 tests safeHaskell'safeInfered/UnsafeInfered11 tests safeHaskell$safeInfered/UnsafeWarn01 tests safeHaskell$safeInfered/UnsafeWarn03 tests safeHaskell$safeInfered/UnsafeWarn04 tests safeHaskell$safeInfered/UnsafeWarn05 tests safeHaskell"unsafeLibs/BadImport01 tests safeHaskell"unsafeLibs/BadImport06 tests safeHaskell"unsafeLibs/BadImport07 tests safeHaskell"unsafeLibs/BadImport08 tests safeHaskell"unsafeLibs/BadImport09 tests safeHaskellunsafeLibs/Dep05 tests safeHaskellunsafeLibs/Dep06 tests safeHaskellunsafeLibs/Dep07 tests safeHaskellunsafeLibs/Dep08 tests safeHaskellunsafeLibs/Dep09 tests safeHaskellunsafeLibs/Dep10ghcA collection of driver messagesghcThe umbrella type that encompasses all the different messages that GHC might output during the different compilation stages. See Note [GhcMessage].ghc!A message from the parsing phase.ghc(A message from typecheck/renaming phase.ghc/A message from the desugaring (HsToCore) phase.ghcA message from the driver.ghcAn "escape" hatch which can be used when we don't know the source of the message or if the message is not one of the typed ones. The b and  constraints ensure that if we know, at pattern-matching time, the originating type, we can attempt a cast and access the fully-structured error. This would be the case for a GHC plugin that offers a domain-specific error type but that doesn't want to place the burden on IDEs/application code to "know" it. The b constraint ensures that worst case scenario we can still render this into something which can be eventually converted into a b.ghcA single warning message.  INVARIANT: It must have b severity.ghc!A collection of error messages.  INVARIANT: Each  in the collection should have b severity.‘ghc#A collection of warning messages.  INVARIANT: Each  in the collection should have b severity.ÑghcCreates a new  out of any diagnostic. This function is also provided to ease the integration of #18516 by allowing diagnostics to be wrapped into the general (but structured)  type, so that the conversion can happen gradually. This function should not be needed within GHC, as it would typically be used by plugin or library authors (see comment for the  type constructor)đghc9Abstracts away the frequent pattern where we are calling  ioMsgMaybe2 on the result of 'IO (Messages TcRnMessage, a)'.őghc9Abstracts away the frequent pattern where we are calling  ioMsgMaybe0 on the result of 'IO (Messages DsMessage, a)'.Ƒghcalloc_limit -= Hp + WDS(1) - cn->start; // Set cn->free to the next unoccupied word in the block cn->free = Hp + WDS(1); ghc3Produce code to load the current thread state from  CurrentTSOghcopenNursery 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-Inferredy!ghcOut of line fake primop that's actually just a foreign call to other (presumably) C--.ghc#Real primop turned into inline C--.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.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.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-Inferred ghcGenerate Cmm code for a tick. Depending on the type of Tickish, this will either generate actual Cmm instrumentation code, or simply pass on the annotation as a  CmmTickish.ϻ߲ϻ߲ Safe-Inferredлλѻһӻлλѻһӻ Safe-Inferred1FԻԻ Safe-Inferred 0ghcGenerate a source note spanning from "a" to "b" (inclusive), then proceed with parsing. This allows debugging tools to reason about locations in Cmm code.9 9  Safe-Inferred %&8ghcMaps 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 onlyghcarityghc bitmap sizeghcbitmapghcTrue  =* is a return point, rather than a functionkk Safe-Inferredghc Using Cabal? Safe-Inferred 8?ghc-A function called to log warnings and errors.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.ÒghcA 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.ɒghc+Call the argument with the current session.ʒghc#Grabs the DynFlags from the Session˒ghcSet 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.͒ghc3Call an action with a temporarily modified Session.ΒghcModify the loggerϒghcPush a log hook on the stackВghcPop a log hook from the stackђghcPut a log messageҒghcPut a log messageӒghcTime an actionԒghc+A monad that allows logging of diagnostics.ՒghcReflect a computation in the Ò monad into the D monad.>You can use this to call functions returning an action in the Ò monad inside an D 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) sؒghcPrint the all diagnostics in a '. Useful inside exception handlers.ƒǒȒÒĒŒגՒ֒ʒ’ɒ˒̒͒ΒϒВҒђӒԒْؒƒǒȒÒĒŒגՒ֒ʒ’ɒ˒̒͒ΒϒВҒђӒԒْؒ Safe-Inferred8wghcThe 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 itselfghcJust 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 constants to top level, even if they do not escape a lambdaghcTrue  = 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.ghcName(s) of the phaseghcUnfolding optionsghcWhether RULES are enabledghcWhether inlining is enabledghcWhether case-of-case is enabledghc Whether eta-expansion is enabledghc!Do we swizzle casts past lambdas?ghcWhether pre-inlining is enabledghcLift an v operation into wghcLift an D operation into w while consuming its wÓ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.Ɠghc%Output a String message to the screenǓghcOutput a message to the screenȓghcOutput 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.̓ghc8Output a string debugging message at verbosity level of -v or higher͓ghc2Outputs a debugging message at verbosity level of -v or higherghcMaskwwwo“ÓēǓƓɓȓœ˓ʓ͓̓wwwo“ÓēǓƓɓȓœ˓ʓ͓̓ Safe-InferredEghcA  is a binding along with a cached set containing its free variables (both type variables and dictionaries)ghcAn argument that we might want to specialise. See Note [Specialising Calls] for the nitty gritty details.ghcType arguments that should be specialised, due to appearing free in the type of a .ghc.Type arguments that should remain polymorphic.ghcDictionaries that should be specialised. mkCallUDs ensures that only "interesting" dictionary arguments get a SpecDict; see Note [Interesting dictionary arguments]ghc/Value arguments that should not be specialised.ghcSpecialise calls to type-class overloaded functions occurring in a program.ghc.Specialise a set of calls to imported bindingsghcReturns whether or not to show a missed-spec warning. If -Wall-missed-specializations is on, show the warning. Otherwise, if -Wmissed-specializations is on, only show a warning if there is at least one imported function being specialized, and if all imported functions are marked with an inline pragma Use the most specific warning as the reason.ghc(Given binders from an original function f , and the s corresponding to its usage, compute everything necessary to build a specialisation.?We will use the running example from Note [Specialising Calls]:=f :: forall a b c. Int -> 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 Jghc!Identify the free variables of a JghcFlatten a set of "dumped" s, and some other binding pairs, into a single recursive binding.ww Safe-InferredghcUnfolding optionsghcwildCardPats are always boring Safe-Inferredghc!Max #ticks in this simplifier runghcThe action to retrieve an up-to-date EPS RuleBase See Note [Overall plumbing for rules]ghcCoercion optimiser optionsghcMake a join id with given type and arity but without call-by-value annotations.ww Safe-InferredqghcA substitution result.ghcFast OutVarSet tracking which recursive RHSs we are analysing. See Note [Eta reduction in recursive RHSs] in GHC.Core.Opt.Arity.´ôŴƴǴϴдĴȴʴ˴ɴʹ̴δѴߴ״ٴڴ۴شҴݴӴմܴԴִ޴´ôŴƴǴϴдĴȴʴ˴ɴʹ̴δѴߴ״ٴڴ۴شҴݴӴմܴԴִ޴ Safe-Inferred}޵ߵ۵ݵܵصٵڵ͵εеѵҵϵԵӵɵʵ˵̵׵յµĵõȵƵǵŵֵ޵ߵ۵ݵܵصٵڵ͵εеѵҵϵԵӵɵʵ˵̵׵յµĵõȵƵǵŵֵ Safe-Inferred*ghcPush 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-Inferredghc5Clone the binders bound by a single-alternative case.آ٢բ֢עޢۢܢڢҢӢԢݢߢآ٢բ֢עޢۢܢڢҢӢԢݢߢ Safe-InferredW7 Safe-Inferred '6;=?  ޓߓ  ޓߓ  Safe-Inferred%&CghcProduce 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 o. Safe-Inferred?   Safe-Inferred8%ghcAllow  makeStatic to occur anywhere.ghcAllow  makeStatic calls at the top-level only.ghc Reject any  makeStatic occurrence.ghcSee Note [Checking StaticPtrs]ghc,See Note [Linting type synonym applications]ghcSee Note [Linting linearity]ghc Type-check a J!. See Note [Core Lint guarantee].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.ghcThis function checks that we are able to perform eta expansion for functions with no binding, in order to satisfy invariant I3 from Note [Representation polymorphism invariants] in GHC.Core.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.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.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 L!, display linter warnings. If I, ignore linter warnings.ghc The source of the linted programghc"The linted program, pretty-printedghc#The source of the linted expressionghcTrue  = is a compulsory unfoldingghcTreat these as in scopeghc6the function (head of the application) we are checkingghc the arguments to the applicationghc0the instantiated type of the overall applicationghcThe source of the linted axiomsghc*s that should be treated as being in scopeghc Action to runghc>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 )*?ghcThe current collection of docs that Template Haskell has built up via putDoc.ghcThis is a mirror of Template Haskell's DocLoc, but the TH names are resolved to GHC names.ghc$A plugin for controlling defaulting.ghc.Initialize plugin, when entering type-checker.ghcDefault some typesghc9Clean up after the plugin, when exiting the type-checker.ghc pure $ TcPluginOK [] [] 5 if your plugin does not provide this functionality.ghc+Rewrite saturated type family applications.The plugin is expected to supply a mapping from type family names to rewriting functions. For each type family , the plugin should provide a function which takes in the given constraints and arguments of a saturated type family application, and return a possible rewriting. See + for the expected shape of such a function.Use  \ _ -> emptyUFM 4 if your plugin does not provide this functionality.ghc9Clean up after the plugin, when exiting the type-checker.ghc5 is the monad in which type-checking plugins operate.ghcFor rewriting type family applications, a type-checking plugin provides a function of this type for each type family .The function is provided with the current set of Given constraints, together with the arguments to the type family. The type family application will always be fully saturated.ghcThe solve function of a type-checking plugin takes in Given and Wanted constraints, and should return a  indicating which Wanted constraints it could solve, or whether any are insoluble.Ŕghc>IsGroupClosed describes a group of mutually-recursive bindingsǔ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?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 .ghcType alias for ; the convention is we'll use this for mutable bits of data in  which are updated during typechecking and returned at the end.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  (= ).ghcModule being compiledghcIf a signature, the backing module See also Note [Identity versus semantic module]ghc4What kind of module (regular Haskell, hs-boot, hsig)ghc$Top level envt; used during renamingghcTypes used for defaulting. Nothing => no default declghcJust for things in this moduleghcJust for things in this module See Note [The interactive package] in GHC.Runtime.ContextghcGlobal 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.ContextghcInstance envt for all  home-package modules; Includes the dfuns in tcg_insts NB. BangPattern is to fix a leak, see #15111ghcDitto for family instances NB. BangPattern is to fix a leak, see #15111ghcAnd for annotationsghcWhat is exportedghcInformation 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)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.ghcTrue( <=> A Template Haskell splice was used.2Splices disable recompilation avoidance (see #481)ghcThe set of runtime dependencies required by this module See Note [Object File Dependencies]ghc&Allows us to choose unique DFun names.ghcThe requirements we merged with; we always have to recompile if any of these changed.ghcRenamed decls, maybe. Nothing! <=> Don't retain renamed decls.ghc"dependencies from addDependentFileghc'Top-level declarations from addTopDeclsghcForeign files emitted from TH.ghc>Exact names bound in top-level declarations in tcg_th_topdeclsghc#Template Haskell module finalizers.+They can use particular local environments.ghc,Core plugins added by Template Haskell code.ghcTemplate Haskell stateghc#Docs added in Template Haskell via putDoc.ghcMaybe Haddock header docsghcTrue if any part of the prog uses hpc instrumentation. NB. BangPattern is to fix a leak, see #15111ghc5Whether this module has a corresponding hi-boot fileghcThe Name of the main function, if this module is the main module.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.ghcUnreported reasons why tcg_safe_infer is False. INVARIANT: If this Messages is non-empty, then tcg_safe_infer is False. It may be that tcg_safe_infer is False but this is empty, if no reasons are supplied (#19714), or if those reasons have already been reported by GHC.Driver.Main.markUnsafeInferghcA list of user-defined type-checking plugins for constraint solving.•ghcA collection of all the user-defined type-checking plugins for rewriting type family applications, collated by their type family s.Õghc;A list of user-defined plugins for type defaulting plugins.ĕghc8A list of user-defined plugins for hole fit suggestions.ŕghc%The RealSrcSpan this module came fromƕghcWanted constraints of static forms. See Note [Constraints in static forms].Ǖghc,Tracking indices for cost centre annotationsɕghc2See Note [Generating fresh names for FFI wrappers]ʕ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.ٕghcA ٕ carries the necessary context for performing rewrites (i.e. type family reductions and following filled-in metavariables) in the solver.ەghc"In which context are we rewriting?Type-checking plugins might want to use this location information when emitting new Wanted constraints when rewriting type family applications. This ensures that such Wanted constraints will, when unsolved, give rise to error messages with the correct source location.ݕghcAt what role are we rewriting?3See Note [Rewriter EqRels] in GHC.Tc.Solver.Rewriteޕghc"See Note [Wanteds rewrite Wanteds]ghc0Historical "type-checking monad" (now it's just ).ghc+Historical "renaming monad" (now it's just ).ghcA  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,The plugin has not found any contradictions,The first field is for constraints that were solved. The second field contains new work, that should be processed by the constraint solver.ghcThe plugin found a contradiction. The returned constraints are removed from the inert set, and recorded as insoluble.7The returned list of constraints should never be empty.ghcGet target platformghcMatches on either a global  or a r.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#No signature or a partial signatureghc;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.ghc Check the  for consistency. Currently, only checks axioms, but should check other aspects, too.ghcRewriter environmentghcGivensghctype family argumentsghcGivensghcWantedsߕ•ÕĕŕƕǕȕɕsssssՕ֕ו͕ؕ̕ΕϕЕѕҕӕԕٕڕەܕݕޕʕ˕uuuuuuuuuuu”ӔԔՔ֔הؔٔڔ˔͔̔ΔϔДєҔǔȔɔʔÔĔŔƔs\\ߔޔ۔ݔܔsʋߕ•ÕĕŕƕǕȕɕsssssՕ֕ו͕ؕ̕ΕϕЕѕҕӕԕٕڕەܕݕޕʕ˕uuuuuuuuuuu”ӔԔՔ֔הؔٔڔ˔͔̔ΔϔДєҔǔȔɔʔÔĔŔƔs\\ߔޔ۔ݔܔsʋ Safe-Inferred %& +ghc*Setup the initial typechecking environmentghcRun a & action in the context of an existing GblEnv.ghcDo it flag is trueghcUpdate the external package state. Returns the second result of the modifier function.This is an atomic operation and forces evaluation of the modified EPS in order to avoid space leaks.ghc"Update the external package state.This is an atomic operation and forces evaluation of the modified EPS in order to avoid space leaks.ghc"A convenient wrapper for taking a MaybeErr SDoc a. and throwing an exception if it is an error.ghc3Trace when a certain flag is enabled. This is like  but accepts a string as a label and formats the trace message uniformly.ghcDump if the given 3 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.ghcAdd current location if -dppr-debug (otherwise the full location is usually way too much)ghc*Like logInfoTcRn, but for user consumptionо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.ھghctcCollectingUsage thing_inside runs  thing_inside and returns the usage information which was collected as part of the execution of  thing_inside . Careful: tcCollectingUsage thing_inside itself does not report any usage information, it's up to the caller to incorporate the returned usage information into the larger context appropriately.۾ghc tcScalingUsage mult thing_inside runs  thing_inside* and scales all the usage information by mult.߾ghcDrop elements of the input that fail, so the result list can be shorter than the argument listghcApply the function to all elements on the input list If all succeed, return the list of results Otherwise fail, propagating all errorsghc2The accumulator is not updated if the action failsghc(Display a warning if a condition is met.ghc(Display a warning if a condition is met.ghc+Display a diagnostic if a condition is met.ghc,Display a diagnostic in the current context.ghc(Display a diagnostic in a given context.ghcA variation of $ that takes a function to produce a  TcRnDsMessage5 given some additional context about the diagnostic.ghcDisplay a diagnostic for the current source location, taken from the  monad.ghc1Display a diagnostic for a given source location.ghcDisplay a diagnostic, with an optional flag, for the current source location.ghcCreates an EvBindsVar incapable of holding any bindings. It still tracks covar usages (see comments on ebv_tcvs in GHC.Tc.Types.Evidence!), thus must be made monadicallyghc5Throw out any constraints emitted by the thing_insideghcThe name says it all. The returned TcLevel is the *inner* TcLevel.ghcAdds the given modFinalizers to the global environment and set them to use the current local environment.ghcMark that safe inference has failed See Note [Safe Haskell Overlapping Instances Implementation] although this is used for more than just that failure case.ghc.Figure out the final correct safe haskell modeghc9Switch instances to safe instances if we're in Safe mode.ghcRun an = (top-level interface monad) computation inside an existing ; (typecheck-renaming monad) computation by initializing an Օ based on .ghc? can be used when there's no chance that the action will call typecheckIface% when inside a module loop and hence  tcIfaceGlobal.ghc'This is used when we are doing to call typecheckModule on an ModIface, if it's part of a loop with some other modules then we need to use their IORef TypeEnv vars when typechecking but crucially not our own.ghc.Initialize interface typechecking, but with a ' to apply when typechecking top-level  s (see lookupIfaceTop)ghcRun thing_inside in an interleaved thread. It shares everything with the parent thread, so this is DANGEROUS.+It throws an error if the computation failsIt's used for lazily type-checking interface signatures, which is pretty benign.&See Note [Masking exceptions in forkM]ghc]: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.)ghcRename just the exports of a ?. Useful when we're doing shaping prior to signature merging.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 Z?, with special handling for an associated dictionary function. Safe-InferredO:ghcRead an interface file header, checking the magic number, version, and way. Returns the hash of the source file and a BinHandle which points at the start of the rest of the interface file data.ghcRead an interface file.ghcThis 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.ghcWrite an interface fileghc(Put a piece of data with an initialised  field. This is necessary if you want to serialise Names or FastStrings. It also writes a symbol table and the dictionary. This segment should be read using .ghc:Initial ram buffer to allocate for writing interface files Safe-InferredQghc7The header for HIE files - Capital ASCII letters "HIE".ghcWrite a ۶ to the given ., with a proper header and symbol tables for s and  sghcRead a ۶ from a . Can use an existing e. Allows you to specify which versions of hieFile to attempt to read. M* case returns the failing header versions.ghcRead a ۶ from a . Can use an existing e. Safe-Inferred`{ghc Given a type ty :: ki, this function ensures that ty has a fixed  RuntimeRep), by emitting a new equality constraint ki ~ concrete_tv for a concrete metavariable  concrete_tv.Returns a coercion co :: ty ~# concrete_ty as evidence. If ty obviously has a fixed  RuntimeRep, e.g  ki = IntRep*, then this function immediately returns <$, without emitting any constraints.ghcLike *, but we perform an eager syntactic check.Throws an error in the  monad if the check fails.This is useful if we are not actually going to use the coercion returned from ; it would generally be unsound to allow a non-reflexive coercion but not actually make use of it in a cast.The goal is to eliminate all uses of this function and replace them with , making use of the returned coercion. This is what is meant by going from PHASE 1 to PHASE 2, in Note [The Concrete mechanism].ghc>Internal function to check whether the given type has a fixed  RuntimeRep.Use  to allow rewriting, or  to perform a syntactic check.ghcEnsure that the given type ty can unify with a concrete type, in the sense of Note [Concrete types].Returns a coercion co :: ty ~# conc_ty, where conc_ty is concrete.If the type is already syntactically concrete, this immediately returns a reflexive coercion. Otherwise, it creates a new concrete metavariable  concrete_tv# and emits an equality constraint ty ~# concrete_tv*, to be handled by the constraint solver.:Invariant: the kind of the supplied type must be concrete.We assume the provided type is already at the kind-level (this only matters for error messages).ghc'Ensure that the given type is concrete.This is an eager syntactic check, and never defers any work to the constraint solver.Invariant: the kind of the supplied type must be concrete. Invariant: the output type is equal to the input type, up to zonking.We assume the provided type is already at the kind-level (this only matters for error messages).ghcTry to turn the provided type into a concrete type, by ensuring unfilled metavariables are appropriately marked as concrete.Returns a zonked type which is "as concrete as possible", and a list of problems encountered when trying to make it concrete.INVARIANT: the returned type is equal to the input type, up to zonking. INVARIANT: if this function returns an empty list of NotConcreteReasons, then the returned type is concrete, in the sense of Note [Concrete types].ghcContext to be reported to the user if the type ends up not having a fixed  RuntimeRep.ghc-The type to check (we only look at its kind).ghc (co, ty') where  ty' :: ki', ki is concrete, and co :: ty ~# ty' . That is, ty' has a syntactically fixed RuntimeRep in the sense of Note [Fixed RuntimeRep].ghcContext to be reported to the user if the type does not have a syntactically fixed  RuntimeRep.ghc-The type to check (we only look at its kind).ghc!The check to perform on the kind.ghc#The context which required a fixed  RuntimeRep1, e.g. an application, a lambda abstraction, ...ghc The type ty4 to check (the check itself only looks at its kind).ghcReturns  (co, frr_ty) with co :: ty ~# frr_ty and frr_ty has a fixed  RuntimeRep. Safe-Inferred ` Safe-InferredgjsghcHoleFit 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 _ _`).sghcA fit that is just displayed as is. Here so thatHoleFitPlugins can inject any fit they want.sghcThe elements id in the TcMsghcThe candidate that was checked.sghc$The type of the id, possibly zonked.sghc The number of holes in this fit.sghcThe wrapper for the match.sghc;What the refinement variables got matched with, if anythingsghc,Documentation of this HoleFit, if available.sghc7A HoleFitPlugin is a pair of candidate and fit plugins.sghcHoleFitCandidates 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 errorghc=A plugin for modifying hole fits *after* they've been found.ghcA plugin for modifying the candidate hole fits *before* they're checked.ghcAny relevant Cts to the holeghcThe nested implications of the hole with the innermost implication first.ghcThe hole itself, if available. sssssssssssssts sssssssssssssts Safe-Inferred )*hghc8A wrapper around the interpretation function for phases.–ÖĖŖƖǖȖɖʖ˖̖͖ΖϖЖіҖ–ÖĖŖƖǖȖɖʖ˖̖͖ΖϖЖіҖ5 Safe-Inferred j8 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 behaviourӖghcActual type: Maybe ([LForeignDecl GhcTc] -> DsM (ForeignStubs, OrdList (Id, CoreExpr))) ߖޖݖܖۖږٖؖז֖ՖӖԖ  ӖԖՖ֖זٖؖږۖܖݖޖߖ Safe-Inferred m ghcDesugaring monad. See also TcM.ghc>Local state of the desugarer, extended as we lexically descendghcTemplate Haskell bindingsghc%To put in pattern-matching error msgsghc(See Note [Long-distance information] in GHC.HsToCore.Pmc. The set of reaching values Nablas is augmented as we walk inwards, refined through each pattern match in turnghcGlobal read-only context and state of the desugarer. The statefulness is implemented through s.ghc2See Note [Generating fresh names for FFI wrappers]\\ Safe-Inferred 8nghchave 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 qI 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 bindersghc$Mandatory when compiling to bytecodeghcUseful for building up  getStgToDoghcInformation to be exposed in interface files which is produced by the stg2stg passes.ghc$Spec of what stg-to-stg passes to doghc9Should we lint the STG at various stages of the pipeline? Safe-Inferredrghc4Initialize STG pretty-printing options from DynFlagsghc;Which Stg-to-Stg passes to run. Depends on flags, ways etc.ghcAre we preparing for bytecode? Safe-InferredtZ¼ghc!Top level driver for C-- pipelineghcThe Cmm pipeline for a single m . Returns:in the case of a m: M3 of the resulting (possibly proc-point-split) m s and their CafEnv. CAF analysis necessarily happens *before* proc-point splitting, as described in Note [SRTs].in the case of a m, the unmodified m and a  containing¼¼ Safe-Inferred)*tüü Safe-Inferred ('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 .ghcIf we have an explicit export list, we extract the documentation structure from that. Otherwise we use the renamed exports and declarations.ghcFigure out the documentation structure by correlating the module exports with the located declarations.ghcExtract named documentation chunks from the renamed declarations.If there is no explicit export list, we simply return an empty map since there would be no way to link to a named chunk.ghcCreate decl and arg doc-maps by looping through the declarations. For each declaration, find its names, its subordinates, and its doc strings.ghcThe "OccEnv Name" is the default method environment for this module Ultimately, the a special "defaultMethodOcc" name is used for the signatures on bindings for default methods. Unfortunately, this name isn't generated until typechecking, so it is not in the renamed AST. We have to look it up from the  parameter constructed from the typechecked AST. See also Note [default method Name] in GHC.Iface.RecompghcGet 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.ghcExtract constructor argument docs from inside constructor decls.ghcAll the sub declarations of a class (that we handle), ordered by source location, with documentation attached if it exists.ghc;Extract function argument docs from inside top-level decls.ghc1Extract function argument docs from inside types.ghc1Extract function argument docs from inside types.ghcThe top-level declarations of a module that we care about, ordered by source location, with documentation attached if it exists.ghcTake all declarations except pragmas, infix decls, rules from an a.ghc7Collect docs and attach them to the right declarations.;A declaration may have multiple doc strings attached to it.This is an example.ghc7Filter out declarations that we don't handle in HaddockghcGo through all class declarations and filter their sub-declarationsghc%Was this signature given by the user?ghcTake a field of declarations from a data structure and create HsDecls using the given constructorghcExtracts out individual maps of documentation added via Template Haskell's putDoc.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 argumentsghcThe current moduleghcImportsghcExplicit export listghc All exportsghcDefault MethodsghcThe current moduleghcExplicit export listghcThe default method environmentghcAll exports, unorderedghc#Do we have an explicit export list?ghcDefault method environment for this module. See Note [default method Name] in GHC.Iface.RecompghcThe default method environment Safe-Inferred 8ghcWhether the number of times functions are entered should be counted.ghc1Decide 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 A 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-InferredCghcThe PRType (ty, tas) is short for (piResultTys ty (reverse tas))¢ghc Compute the  of an  P in a pure fashion.âghc Compute the  of an  P in a pure fashion.¢âĢ¢âĢ Safe-Inferred ghcSource Statistics Safe-Inferred ghc The type constructor for queriesghc,Should EpAnnotations be removed from output.ghc+Should source spans be removed from output.ghc*Show the full AST as the compiler sees it.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.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?GghcG 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. ghcA static plugin with its arguments. For registering compiled-in plugins through the GHC API. ghc>A plugin with its arguments. The result of loading the plugin.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.ghcPlugins 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 .ghcThe object files required by the loaded plugins See Note [Plugin dependencies]ghc9the actual plugin together with its commandline argumentsghc9the actual plugin together with its commandline argumentsghc the module containing the pluginghcthe actual callable pluginghc%command line arguments for the pluginghcModify 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.ghcAn optional typechecker plugin, which may modify the behaviour of the constraint solver.ghcAn optional defaulting plugin, which may specify the additional type-defaulting rules.ghcAn optional plugin to handle hole fits, which may re-order or change the list of valid hole fits and refinement hole fits. 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.ghc3Specify how the plugin should affect recompilation.ghc8Modify the module when it is parsed. This is called by GHC.Driver.Main when the parser has produced no or only non-fatal errors. Compilation will fail if the messages produced by this function contain any errors.ghcModify each group after it is renamed. This is called after each a has been renamed.ghcModify the module when it is type checked. This is called at the very end of typechecking.ghc4Modify the TH splice or quasiqoute before it is run.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.ghc2Result of running the parser and the parser pluginghc/Parsed module, potentially modified by a pluginghcWarnings and errors from parser, potentially modified by a pluginghc*Errors and warnings produced by the parserghcCommand line options gathered from the -PModule.Name:stuff syntax are given to you as this typeghcDefault 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.?  GH  ?  GH   Safe-Inferred (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.ghc>Check if we need to try the dynamic interface for -dynamic-tooghcWrite interface fileghc readIface tries just the one file.Failed err  => file not found, or unreadable, or illegible Succeeded iface  = successfully found and parsedghc'Read binary interface, and print it outghcShow a ModIface but don't display details; suitable for ModIfaces stored in the EPT.ghcShow a ModIface+The UnitState is used to pretty-print unitsghc/Reason for loading the iface (used for tracing)ghc=The unique identifier of the on-disk module we're looking forghcThe *actual* module we're looking for. We use this to check the consistency of the requirements of the module we read out.ghc Looking for .hi-boot or .hi file  Safe-Inferred ghc#tcCheckUsage name mult thing_inside runs  thing_inside, checks that the usage of name is a submultiplicity of mult, and removes name from the usage environment. See also Note [Wrapper returned from tcSubMult] in GHC.Tc.Utils.Unify, which applies to the wrapper returned from this function.ghcGet a # that includes mappings for all vars free in the given type. Useful when tidying open types.ghcMake a name for the dict fun for an instance decl. It's an *external* name, like other top-level names, and hence must be made with newGlobalBinder.ghc mkWrapperName ref what nameBase8See Note [Generating fresh names for ccall wrapper] for ref 's purpose.RRRRӔԔՔ֔הؔٔڔܽRRRRӔԔՔ֔הؔٔڔܽ 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.%~}y}R%~}y}R Safe-Inferred% 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 constraintghcGiven ty::forall k1 k2. k, instantiate all the invisible forall-binders returning ty kk1  kk2 :: k[kk1k1, kk2k1]ghcUsed only in *types*ghc This takes a ~# b and returns a ~~ b.ghc This takes a ~# b and returns a ~ b.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.ghcGive fresh uniques to a bunch of TyVars, but they stay as TyVars, rather than becoming TcTyVars Used in , and ghcGive fresh uniques to a bunch of CoVars Used in "GHC.Tc.Instance.Family.newFamInst"ghcCheck that the result type of an expression has a fixed runtime representation.'Used only for arrow operations such as arr, first, etc.ghcwhy do we need this?ghcname of the methodghc)types with which to instantiate the classghc%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#ǿȿ#ǿȿ Safe-InferredŃghc looks for just one function arrow, returning an uninstantiated sigma-type.Invariant: the returned argument type has a syntactically fixed RuntimeRep in the sense of Note [Fixed RuntimeRep] in GHC.Tc.Utils.Concrete.4See Note [Return arguments with a fixed RuntimeRep].ghcLike , but used when you have an "actual" type, for example in function application.INVARIANT: the returned arguemnt types all have a syntactically fixed RuntimeRep in the sense of Note [Fixed RuntimeRep] in GHC.Tc.Utils.Concrete. See Note [Return arguments with a fixed RuntimeRep].ghcUse this function to split off arguments types when you have an "expected" type.*This function skolemises at each polytype.Invariant: this function only applies the provided function to a list of argument types which all have a syntactically fixed RuntimeRep in the sense of Note [Fixed RuntimeRep] in GHC.Tc.Utils.Concrete. See Note [Return arguments with a fixed RuntimeRep].ghcFill an r with the given type.If !co = fillInferResult t1 infer_res, then co :: t1 ~# t2 , where t2 is the type stored in the r field of  infer_res.0This function enforces the following invariants:%Level invariant. The stored type t2* is at the same level as given by the r field. FRR invariant. Whenever the r field is not Nothing, t2 is guaranteed to have a syntactically fixed RuntimeRep, in the sense of Note [Fixed RuntimeRep] in GHC.Tc.Utils.Concrete.ghc Variant of  that takes an ExpTypeghcChecks (TYVAR-TV), (COERCION-HOLE) and (CONCRETE) of Note [Unification preconditions]; returns True if these conditions are satisfied. But see the Note for other preconditions, too.ghc-Breaks apart a function kind into its pieces. ۽ghc'If present, the thing that has type ty1ghc)See Note [Herald for matchExpectedFunTys]ghcThe thing with type TcSigmaTypeghcTotal number of value args in the call, and types of values args to which function has been applied already (reversed) (Both are used only for error messages)ghcType to analyse: a TcRhoTypeghc)See Note [Herald for matchExpectedFunTys]ghcthe thing with type TcSigmaTypeghcActualghcExpectedghcUsed when instantiatingghcUsed when skolemisingghcThe expression that has type actual (if known)ghc Actual typeghc Expected typeghcThe wrapper has type: spec_ty ~> expected_ty Just like tcTopSkolemise, but calls deeplySkolemise instead of topSkolemise See Note [Deep skolemisation]ghcThe wrapper has type: spec_ty ~> expected_ty See Note [Skolemisation] for the differences between tcSkolemiseScoped and tcTopSkolemiseghcThe wrapper has type: spec_ty ~> expected_ty See Note [Skolemisation] for the differences between tcSkolemiseScoped and tcTopSkolemiseghctype, only for errorsghcn: number of desired arrowsghc fun_ kindghc-co :: fun_kind ~ (arg1 -> ... -> argn -> res)#ٽ۽ڽ#ٽ۽ڽ Safe-Inferred %&ghc&A monad within which we will generate KindRep+s. Here we keep an environment containing KindReps which we've already generated so we can re-use them opportunistically.ghcMaps kinds to KindRep bindings. This binding may either be defined in some other module (in which case the Maybe (LHsExpr Id will be J) or a binding which we generated in the current module (in which case it will be K the RHS of the binding).ghcTarget platformghcof TyConghc To construct TrName,s The various TyCon and DataCons of KindRepghc A group of s in need of type-rep bindings.ghcBuild exported KindRep% bindings for the given set of kinds.ghcModule's typerep bindingghcPackage name fingerprintghcModule name fingerprintghcThe s in need of bindings kindsghcInformation we need about a / to generate its representation. We carry the 4 in order to share it between the generation of the TyCon and KindRep bindings.ghcGenerate the Typeable bindings for a module. This is the only entry-point of this module and is invoked by the typechecker driver in  tcRnSrcDecls.&See Note [Grand plan for Typeable] in GHC.Tc.Instance.Typeable.ghc6Generate TyCon bindings for a set of type constructorsghc [a] -> a sumNumList [] = 0 sumNumList (x : xs) = x + sumList xsand add a breakpoint to it:ghci> break sumNumList ghci> sumNumList ([0 .. 9] :: [Int])+ghci shows us more precise types than just as:Stopped in Main.sumNumList, debugger.hs:3:23-39 _result :: Int = _ x :: Int = 0 xs :: [Int] = _ghc&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  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"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 K 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.ghcA common way to invoke .ghcChecks to see if we need to warn for -Wunused-record-wildcards or -Wredundant-record-wildcardsghcProduce 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.ghcMake a map from selector names to field labels and parent tycon names, to be used when reporting unused record fields.ghc$Should we report the fact that this  is unused? The   may differ from  due to DuplicateRecordFields.ghc?Ensure that a boxed or unboxed tuple has arity no larger than .ghc8Ensure that a constraint tuple has arity no larger than .ghcThe error msg if the signature is not allowed to contain manually written inferred variables.%% Safe-InferredrghcAttempt 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.ghcAttempt 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.1One must be careful to consistently use the same e> to create identifier that might be compared. (C.f. how the . Monad enforces that variables from separate  invocations are never intermingled; it would be valid to use the same tricks for s and es.)For now, the easiest and recommended way to ensure a consistent e< is used it to retrieve the preexisting one from an active  . A single  is created per GHC "session", and this ensures everything in that sesssion will getthe same name cache.( GH   ''''''&'&'&&&&&&&&&&&''''''&&&''''''''''''''''''''''''&''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''           !!!  !  ! !! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!MMMMMMMMMMMNNNNNNNMMNMMMMMNNMMMMMMMMMMMMMMMMMMMMMMMMMMMMNNNNNNMNMMMMMMMMMMMMMNMMMMMMNNNNNNNNNNMMNNNNNNNNNNNNMMNNNNNMMNNNNNNMMNNMLLLLLLLLLLLLLLLLLLLLLLLLLJLLLLLLLLLLLLMMMMMMLMLMMMMMMMMMMMLMMMMMMMMMMMMMMMMMMMMMLMMRRRRRRRwwwoo“ÓēǓƓɓȓœ˓ʓ͓̓KKKKKKKKKKKKKKKKKKKKKJJJJJJJJJJJJKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKJKKKKKKJJJKKKKJJJJJJJJJJJJJJJJJKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLKKKKKKKKKLKKKKKLKLLLLLLLLKLLLLLLLLKKKKKKKKKKKKKKAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBABBBBBABBBBBBBBBBBBBBBBBBBBBBBBBBBBHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHmmEmnnnnnnnmnnnnmnnnmnnnnmnmnmnmmmnnnnnnnnnnmmmnnnnnnnnnnmnnnnnnnmnnnnnnn~~~~~~~~~~~~~~~"\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\#ww?wwwwwwwwwwwwwwwwwwwwwwwwwwwwwww?wwwwwwwwwwwwwwwww55555555555555555oppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooppoooo2333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333332222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222ooooooooooobbbboo344444444444444444444444444444444444444444444444444444444444444444444444433333333333333333333444412222222222222222222222222222221111111111111111111111111111111111111111111111111111111111111111111nnnoooooonnnnnnnnnnnnnnnnooooooooooooooonoooonnnnnnnooooooooonnnnnnnnnnnnnnnnnpppppqq4qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqpqqqqqqqqqqqqqqqqqqqqqqppppppppppppppppppppppppppppppppppppppppppppqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqppppqqv vv vmttttttttttttttRRRRRRRRttttttttttttttttttttttttttttttttttuRRRRRRRRRRRRRuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu       ??<<<<<<<<<@>@???@@@?<>>>>>>>>>>>>>>>>?@@<<<<<<<<<<<<<<<E%E<>>>>><>????????%FFFFFFFFFFFFFFFFFFFFFF%EEEEEEE??FFEFFFFSSSSTTSSTTSTTSTTTTTTTTTTTTSSSSSSSTTTSTTTSSSSSSSSSSSSSSSS,TS.STSTTTTTSTSTSTSTTSTTTTTTSSSSSSSSSSSSSSTSSSSSSSSSTSSSSSSSSSSSSSSSSSSSSSSSSSSTTTTTTTTTTTTTT"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""############$$$$#$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$##########################################%%%%%%%%%%%%&%%%%%%%%%%%%%%%%%%%%%%%%&&&&&&&&&###########################################]x            sssssssssssstssƃ߃ރ݃܃ۃڃك؃׃փՃԃӃ҃уЃσ΃̓̃˃ʃɃǃȃŃăÃ؍׍֍ՍԍӍҍэЍύ΍͍̍ˍʍɍȍǍƍōč͍ۍߍލݍ܍ڍٍb              !!!  !   ! !! !     !!!!!MMM!!!MMMMMMMM!NNNNNNNMMNMM!MMMNNMMMMMMMMMMMMMMMMMMMMM!MMM!!!!!MMMMNNNNNNMNMMMMMMMMMMMMMNMMMMMMNNNNNNNNNNMMNNNNNNNNNNNNMMNNNNNMMNNNNNNMMNNM#ww?wwwwwwwwwwwwwwwwwwwwwwwwwwwwwww?wwwwwwwwwwwwwwwww!!!!???<<<!!!!!!!!!<<<<<<@>@???@@!@!?>>>>>>>>>>>>>>>?@@<<<<<<<<<<E%E<>>>>><>?????????%FFFFFFFFFFFFFFFFFFFFFF%EEEEEEE??FFEFFFFb Safe-Inferred'8"q ghc$Always true if we compile with -profghcWhich unfoldings to exposeghctrim off the arity, one-shot-ness, strictness etc which were retained for the benefit of the code generatorghcAre rules exposed or not?ghc?Options for generated static pointers, if enabled (/= Nothing).ghcDon't expose unfoldingsghcOnly expose required unfoldingsghcExpose all unfoldingsghcCollect cost centres defined in the current module, including those in unfoldings. Safe-Inferred" Safe-Inferred(ghc.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 J 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 J 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 floatsghcCreate a function that converts Bignum literals into their final CoreExpr Safe-Inferred ()*6$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 TcCoercionghcLike , but returns the arguments back if there is no data family to unwrap. Returns a Representational coercionghcConverts 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 ((gres, co), 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.ghcReport a list of injectivity errors together with their source locations. Looks only at one equation; does not look for conflicts *among* equations.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].ghcReport error message for a pair of equations violating an injectivity annotation. No error message if there are no branches.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 N N Safe-Inferred 'HXghc&Accumulated messages in reverse order.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 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 all unsolved goals as warnings (but without deferring any errors to run-time). See Note [Safe Haskell Overlapping Instances Implementation] in  GHC.Tc.Solverghc,Report unsolved goals as errors or warnings.ghcMake a report from a single .ghc Returns True  == the SolverReportErrCtxt indicates that something is deferredghcShould we completely ignore this constraint in error reporting? It *must* be the case that any constraint for which this returns True somehow causes an error to be reported elsewhere. See Note [Constraints to ignore].ghcMakes an error item from a constraint, calculating whether or not the item should be suppressed. See Note [Wanteds rewrite Wanteds] in GHC.Tc.Types.Constraint. Returns Nothing if we should just ignore a constraint. See Note [Constraints to ignore].ghc#zonkTidyTcLclEnvs takes a bunch of s$s, each from a Hole. It returns a ( :-> ) mapping which gives the zonked, tidied type for each Id in any of the binder stacks in the ss. Since there is a huge overlap between these stacks, is is much, much faster to do them all at once, avoiding duplication.ghcWrap an input ʋ with additional contextual information, such as relevant bindings or valid hole fits.ghcPretty-print supplementary information, to add to an error report.ghc(Display a collection of valid hole fits.ghc'Add a "Constraints include..." message."See Note [Constraints include ...]ghcConstructs a new hole error, unless this is deferred. See Note [Constructing Hole Errors].ghcFor all the skolem type variables in a type, zonk the skolem info and group together all the type variables with the same origin.ghcAdds deferred bindings (as errors). See Note [Adding deferred bindings].ghcReport a representation-polymorphism error to the user: a type is required to havehave a fixed runtime representation, but doesn't.See Note [Reporting representation-polymorphism errors] in GHC.Tc.Types.Origin.ghc&Whether to report something using the FixedRuntimeRep mechanism.ghcThis function tries to reconstruct why a "Coercible ty1 ty2" constraint is left over.ghc&Whether to print 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 . If so, it first checks whether the equality is a visible equality; if it's not, definitely print the kinds. Even if the equality is a visible equality, check the expected/actual types to see if the types have equal visible components. If the  is not a 6, fall back on the actual mismatched types themselves.ghcIf the  is a type mismatch between an actual and an expected type, return the actual and expected types (in that order)./Prefer using this over manually inspecting the  datatype if you just want this information, as the datatype itself is subject to change across GHC versions.ghcRetrieves all "expected"/"actual" messages from a .&Prefer using this over inspecting the  datatype if you just need this information, as the datatype itself is subject to change across GHC versions.ghc The main payload of the message.ghcThe context to add, after the main diagnostic but before the supplementary information. Nothing  = don't add any context.ghcSupplementary information, to be added at the end of the message.ghcThe context we're in, i.e. the implications and the tidy environmentghcUnsolved simple constraintsghcThe holeghcWe return the new context with a possibly updated tidy environment, and the valid hole fits. Safe-InferredJghc returns (True, fixity) if it finds a 0 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).ghcLook up the fixity of an 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). Safe-Inferred'[ghcWhen looking up GREs, we may or may not want to include fields that were defined in modules with NoFieldSelectors( enabled. See Note [NoFieldSelectors].ghcInclude normal names, and fields with selectors, but ignore fields without selectors.ghcInclude normal names and all fields (regardless of whether they have selectors).ghcInclude only fields, with or without selectors, ignoring any non-fields in scope.ghcResult of looking up an occurrence that might be an ambiguous field.ghcOccurrence picked out a single name, which may or may not belong to a field (or might be unbound, if an error has been reported already, per Note [ Unbound vs Ambiguous Names ]).ghcOccurrence picked out two or more fields, and no non-fields. For now this is allowed by DuplicateRecordFields in certain circumstances, as the type-checker may be able to disambiguate later.ghcFound an Exact Or Orig NameghcThe RdrName was an Exact or Orig, but there was an error looking up the Nameghc)The RdrName is neither an Exact nor Origghc Lookup an Exact RdrName. See Note [Looking up Exact RdrNames]. This never adds an error, but it may return one, see Note [Errors in lookup functions]ghcLook up an occurrence of a field in record construction or pattern matching (but not update). When the -XDisambiguateRecordFields flag is on, take account of the data constructor name to disambiguate which field to use.See Note [DisambiguateRecordFields] and Note [NoFieldSelectors].ghcLook up an occurrence of a field in a record update, returning the selector name..Unlike construction and pattern matching with -XDisambiguateRecordFields (see ), there is no data constructor to help disambiguate, so this may be ambiguous if the field is in scope multiple times. However we ignore non-fields in scope with the same name if -XDisambiguateRecordFields: is on (see Note [DisambiguateRecordFields for updates]).!Here a field is in scope even if NoFieldSelectors was enabled at its definition site (see Note [NoFieldSelectors]).ghc,Used in export lists to lookup the children.ghc5Specialised version of msum for RnM ChildLookupResultghc Look up a '% used as a variable in an expression.This may be a local variable, global variable, or one or more record selector functions. It will not return record fields created with the NoFieldSelectors) extension (see Note [NoFieldSelectors]).If the name is not in scope at the term level, but its promoted equivalent is in scope at the type level, the lookup will succeed (so that the type-checker can report a more informative error later). See Note [Promotion].ghcLike -, but with a more informative result if the '! happens to be a record selector:Nothing -> 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,Lookup a name in relation to the names in a ghc,Lookup a name in relation to the names in a 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 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 scopeghcThe standard nameghcPossibly a non-standard name<< Safe-InferredbghcIndicates if Instance met the Safe Haskell overlapping instances safety check.See Note [Safe Haskell Overlapping Instances] in GHC.Tc.Solver See Note [Safe Haskell Overlapping Instances Implementation] in GHC.Tc.SolverghcExtra information about the parent instance declaration, needed when type-checking associated types. The 9. is the enclosing class, the [TyVar] are the scoped* type variable of the instance decl. The  VarEnv Type. maps class variables to their instance types.ghcThe scoped6 tyvars of the instance Why scoped? See bind_me in ghcMaps class tyvars to their instance types See Note [Matching in the consistent-instantiation check]ghc,Assumes that we've checked that this is the Typeable4 class, and it was applied to the correct argument.ghcRepresentation for a type ty of the form  arg -> ret.ghc 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 synonymsghc>See Note [Wanteds rewrite Wanteds] in GHC.Tc.Types.Constraintghc old evidenceghc"new predicate + coercion, of type  typeof old evidence ~ new predicate  0 Safe-Inferred<ghc=Perform some IO, typically to interact with an external tool.ghc)Output useful for debugging the compiler.ghc.Create a new Wanted constraint with the given .ghc:Create a new given constraint, with the supplied evidence.#This should only be invoked within  tcPluginSolve.ghc!Create a fresh evidence variable.#This should only be invoked within  tcPluginSolve.ghcCreate a fresh coercion hole. This should only be invoked within  tcPluginSolve.ghcBind an evidence variable.#This should only be invoked within  tcPluginSolve.'vvvvvvvvvvv'vvvvvvvvvvv Safe-Inferredq ghcRepresents 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 pluginsghc7A solved pair of constraints, with evidence for wantedsghc8A pair of (given, wanted) constraints to pass to 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 pair of (given, wanted) constraints, invoke each of the typechecker constraint-solving 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-InferredS 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 constraintghcQuantify over any constraint that satisfies pickQuantifiablePredsghcType-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.)ghcSimplify top-level constraints, but without reporting any unsolved constraints nor unsafe overlapping.ghcDefault any remaining  CallStack constraints to empty  CallStacks.ghcReturn (Just new_inerts) if the Givens are satisfiable, Nothing if definitely contradictory.>See Note [Pattern match warnings with insoluble Givens] above.ghc4Return True if the Wanteds are soluble, False if notghcNormalise a type as much as possible using the given constraints. See Note [tcNormalise].ghcWhen 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]ghcLike , but in the TcS monad. Safe-Inferred?ghcCheck a list of binders to see if they make a valid telescope. See Note [Bad TyCon telescopes]ghc0Information about a type being validity-checked.ghcWhen validity-checking an application of a type synonym, should we check the arguments, check the expanded type, or both? See Note [Correctness and performance of type synonym validity checking]ghcOnly check the expanded type.ghcOnly check the arguments.ghc/Check both the arguments and the expanded type.ghcIndicates whether a ? represents type-level contexts, kind-level contexts, or both.ghcA + that only represents type-level positions.ghcA + that only represents kind-level positions.ghcA 8 that can represent both type- and kind-level positions.ghcCheck whether the type signature contains custom type errors, and fail if so.1Note that some custom type errors are acceptable:in the RHS of a type synonym, e.g. to allow users to define type synonyms for custom type errors with large messages (#20181),inside a type family application, as a custom type error might evaporate after performing type family reduction (#20241).ghcDetermine whether a  can represent type-level contexts, kind-level contexts, or both.ghcReturns L if the supplied  is unambiguously not the context for a kind of a type. If the  can refer to both types and kinds, this function conservatively returns L.An example of something that is unambiguously the kind of a type is the Show a => 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 L 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 L if the supplied  is unambiguously not the context for a kind of a type, where all function arrows currently must be unrestricted.ghcReturns L 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 L.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.ghc2See Note [Validity checking of HasField instances]ghcDo validity checks on a type family equation, including consistency with any enclosing class instance head, termination, and lack of polytypes.ghc.Checks that an associated type family default:  Cls cls_ty_1 ... cls_ty_m (TC tc_arg_1 ... tc_arg_n) where ...  corresponds to cls_ty_1 ... cls_ty_m. corresponds to TC. corresponds to tc_arg_1 ... tc_arg_n.See &Note [DerivEnv and DerivSpecMechanism] in GHC.Tc.Deriv.Utils for a more in-depth explanation, including the relationship between  and .A ? value can be seen as a more structured representation of the  denv_inst_tys in a DerivEnv , as the  denv_inst_tys is equal to dit_cls_tys ++ [ dit_tc dit_tc_args]?. Other parts of the instance declaration can be found in the DerivEnv. For example, the Cls* in the example above corresponds to the denv_cls field of DerivEnv./Similarly, the type variables that appear in a + value are the same type variables as the denv_tvs in the parent DerivEnv. Accordingly, if we are inferring an instance context, the type variables will be , skolems. Otherwise, they will be ordinary s. See Note [Overlap and deriving] in GHC.Tc.Deriv.Infer.ghc,Other arguments to the class except the lastghcType constructor for which the instance is requested (last arguments to the type class)ghc!Arguments to the type constructorghcThe 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 .ghcThe cached results of instantiating each data constructor's field types using H data_con  . See 2Note [Instantiating field types in stock deriving].This field is only used for stock-derived instances and goes unused for newtype-derived instances. It is put here mainly for the sake of convenience.ghcA 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].ghcTake a & of s and generate the code for auxiliary bindings based on the declarative descriptions in the supplied s. 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.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.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].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]ghc;Look up a data constructor's instantiated field types in a . See 2Note [Instantiating field types in stock deriving].ghc tycon arg_tys' constructs a cache that maps each of tycon's data constructors to their field types, with are to be instantiated with arg_tys. See 2Note [Instantiating field types in stock deriving].ghc#Apply a substitution to all of the s contained in a . See 2Note [Instantiating field types in stock deriving]' for why we need to substitute into a  in the first place.ghc Zonk the s in a  value to s. See Note [What is zonking?] in GHC.Tc.Utils.TcMType.This is only used in the final zonking step when inferring the context for a derived instance. See Note [Overlap and deriving] in GHC.Tc.Deriv.Infer.&& Safe-Inferred  ghcDoes not contain variableghcThe variable itselfghc$The variable itself, contravariantlyghc Function typeghcTuple 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.ghc.Type app, variable other than in last argumentghc Forall typeghc#Return all syntactic subterms of a  that are applied to the  argument. This determines what constraints should be inferred for derived *, 5, and 6 instances in GHC.Tc.Deriv.Infer. For instance, if we have: :data Foo a = MkFoo Int a (Maybe a) (Either Int (Maybe a)) Then the following would hold: a Int would return [], since Int' does not contain the type variable a at all. a a would return []. Although the type a contains the type variable a , it is not applied to a!, which is the criterion that  checks for. a (Maybe a) would return [Maybe], as Maybe is applied to a. a (Either Int (Maybe a)) would return [Either Int, Maybe]%. Both of these types are applied to a through composition. As used in GHC.Tc.Deriv.Infer, the ! argument will always come from , so it is important that the  comes from H to match. Make sure not to take the  from :, as these differ from the H when the data type is a GADT. (See #22167 for what goes wrong if : is used.)ghcVariable to look forghc How to foldghcType to process Safe-Inferred ·ghcSee 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 Called by 6; generates a list of types, each of which must be a * in order for the Generic1- instance to work. For instance, if we have: :data Foo a = MkFoo Int a (Maybe a) (Either Int (Maybe a)) Then  a (f (g a)) would return  [Either Int], as a derived Generic1 instance would need to call  at that type. Invoking  a* on any of the other fields would return []. is very similar in spirit to  in GHC.Tc.Deriv.Functor. Just like with , it is important that the  argument come from H%. (See #22167 for what goes wrong if : is used.)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 2ghc A list of  constraints to simplify when inferring a derived instance's context. For the stock, newtype, and via- deriving strategies, these will consist of  s, and for DeriveAnyClass, these will consist of 0s. Here is an example to illustrate the latter: class Foo a where bar :: forall b. Ix b => a -> b -> String default bar :: forall y. (Show a, Ix y) => a -> y -> String bar x y = show x ++ show (range (y, y)) baz :: Eq a => a -> a -> Bool default baz :: Ord a => a -> a -> Bool baz x y = compare x y == EQ data Quux q = Quux deriving anyclass Foo Then it would generate two s, one for each method: [ SubTypePredSpec { stps_ty_actual = forall y. (Show (Quux q), Ix y) => Quux q -> y -> String , stps_ty_expected = forall b. (Ix b) => Quux q -> b -> String , stps_ty_origin = DerivClauseCtxt } , SubTypePredSpec { stps_ty_actual = Ord (Quux q) => Quux q -> Quux q -> Bool , stps_ty_expected = Eq (Quux q) => Quux q -> Quux q -> Bool , stps_ty_origin = DerivClauseCtxt } ] (Note that the type variable q is bound by the data type Quux , and thus appears free in the s and s.)See ?Note [Gathering and simplifying constraints for DeriveAnyClass] in GHC.Tc.Deriv.Infer! for an explanation of how these /s are used to compute implication constraints.ghcA  specifies a constraint to emitted when inferring the instance context for a derived instance in .ghc An ordinary  that directly stores a , which will be emitted as a wanted constraint in the constraint solving machinery. This is the simple case, as there are no skolems, metavariables, or given constraints involved.ghc A special  that is only used by DeriveAnyClass. This will check if stps_ty_actual0 is a subtype of (i.e., more polymorphic than) stps_ty_expected in the constraint solving machinery, emitting an implication constraint as a side effect. For more details on how this works, see ?Note [Gathering and simplifying constraints for DeriveAnyClass] in GHC.Tc.Deriv.Infer.ghc"The constraint to emit as a wantedghcThe origin of the constraintghc(Whether the constraint is a type or kindghc#The actual type. In the context of DeriveAnyClass-, this is the default method type signature.ghc%The expected type. In the context of DeriveAnyClass., this is the original method type signature.ghcThe origin of the constraintghc-Describes how to generate instance bindings ()) and associated type family instances (+) for a particular stock-derived instance.ghcDescribes how to generate instance bindings for a stock-derived instance."This function takes two arguments: : the source location where the instance is being derived. This will eventually be instantiated with the  field of a .: information about the argument types to which a class is applied in a derived instance. This will eventually be instantiated with the  field of a ."This function returns four things: _ P6: The derived instance's function bindings (e.g., !compare (T x) (T y) = compare x y)[^ P]: A list of instance specific signatures/pragmas. Most likely INLINE pragmas for class methods.& : Auxiliary bindings needed to support the derived instance. As examples, derived % and ,+ instances sometimes require top-level con2tag functions. See Note [Auxiliary binders] in GHC.Tc.Deriv.Generate.[]: A list of Names for which -Wunused-binds should be suppressed. This is used to suppress unused warnings for record selectors when deriving -, 1, or Generic . See +Note [Deriving and unused record selectors].ghcDescribes how to generate associated type family instances for a stock-derived instance. This function takes the same arguments as the  function but returns a list of Ns instead. Generating type family instances is done separately from  since the type family instances must be generated before the instance bindings can be typechecked. See Note [Staging of tcDeriving] in  GHC.Tc.Deriv.ghcRecords 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.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 J).A standalone deriving declaration with an extra-constraints wildcard as the context (in which case  mb_wildcard is K 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.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"Standard" classesghc GeneralizedNewtypeDerivingghc DeriveAnyClassghc  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].ghcHow to generate the instance bindings and associated type family instances.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].ghcThe newtype rep type.ghc0All arguments to the class besides the last one.ghcThe last argument to the class.ghcThe via typeghcContains all of the information known about a derived instance when determining what its EarlyDerivSpec should be. See &Note [DerivEnv and DerivSpecMechanism].ghc Is this an overlapping instance?ghcUniversally quantified type variables in the instance. If the  denv_ctxt is , these will be  skolems. If the  denv_ctxt is , these will be ordinary  s. See Note [Overlap and deriving] in GHC.Tc.Deriv.Infer.&All type variables that appear in the , , , and  should come from .ghc-Class for which we need to derive an instanceghcAll arguments to  in the derived instance.ghc 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].ghcThe   used to skolemise the denv_tvs in the case where the  is .ghcK if user requests a particular deriving strategy. Otherwise, J.ghc0To 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 .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))ghcReturn ! if processing with a standalone deriving declaration or  if processing a deriving clause.ghc wc returns  if wc is L, and  if wc is I. Useful for error-reporting.ghcSet the  in a .ghc Zonk the s in a  to s. See Note [What is zonking?] in GHC.Tc.Utils.TcMType.This is only used in the final zonking step when inferring the context for a derived instance. See Note [Overlap and deriving] in GHC.Tc.Deriv.Infer.ghc Convert a  to its corresponding _.ghc Zonk the s in a  to s. See Note [What is zonking?] in GHC.Tc.Utils.TcMType.This is only used in the final zonking step when inferring the context for a derived instance. See Note [Overlap and deriving] in GHC.Tc.Deriv.Infer.ghcBuild a list of s, using the supplied  and  values for each .ghc"Capture wanted constraints from a .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!ghc2Information about the type arguments to the class.ghcc if deriving an instance for this type is possible. Otherwise, it's c err, where err explains what went wrong.ghc9Used to inform error messages as to whether we are in a deriving clause or a standalone deriving declarationghc0The specs from which constraints will be createdghc? 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").ghcL  = allow higher rank arguments and empty data types (with no data constructors) even in the absence of the -XEmptyDataDeriving extension. Safe-Inferred %&aghcSort 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.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.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.ghc.Checks whether a MetaTyVar is flexible or not.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.ghcThe hole to check againstghcThe type of the hole to check against (possibly modified, e.g. refined with additional holes for refinement hole-fits.)ghcThe type to check whether fits.ghc;Whether it was a match, and the wrapper from hole_ty to ty.ghcThe tidy_env for zonkingghc!Enclosing implications for givensghcThe unsolved simple constraints in the implication for the hole.#s#s Safe-Inferred ghcLike #, 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 (r>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 srs, 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.ghcThe   used to skolemise the  argumentsghc9Used to inform error messages as to whether we are in a deriving clause or a standalone deriving declarationghcThe tyvars bound by inst_ty.ghc%The constraints to solve and simplifyghc1Needed constraints (after simplification), i.e. []. Safe-Inferred 1 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),u summarizing the identifiers that were imported by this declaration, and A boolean 4 which is true if the imported module used HPC.ghcRename raw package importsghcRename raw package importsghcCalculate the u> induced by an import of a particular interface, but without u.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 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]ghcJ 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 1*ghc9Name of an operator in an operator application or sectionghcA normal identifierghcPrefix negationghcAn unbound indentifierghcA record field occurrenceghcShould GHC warn if a quantified type variable goes unused? Usually, the answer is "yes", but in the particular case of binding Q$, we avoid emitting warnings. See 8Note [Suppress -Wunused-foralls when binding LHsQTyVars].ghcAlways bind any free tyvars of the given type, regardless of whether we have a forall at the top.For pattern type sigs, we do want to bring those type variables into scope, even if there's a forall at the top which usually stops that happening, e.g: \ (x :: forall a. a -> b) -> eHere we do bring b into scope.RULES can also use #, 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.ghcWhen 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 new renamed type variables corresponding to source-level ones. Duplicates are permitted, but will be removed. This is intended especially for the case of handling the implicitly bound free variables of a type signature.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  for 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.ghc finds the type/kind variables of a HsType/HsKind. It's used when making the forall6s explicit. See Note [Kind and type-variable binders]ghcExtracts the free type/kind variables from the kind signature of a HsType. This is used to implicitly quantify over k in type T = Nothing :: Maybe k. The left-to-right order of variables is preserved. See Note [Kind and type-variable binders] and Note [Ordering of implicit variables] and Note [Implicit quantification in type synonyms].ghcExtracts free type and kind variables from types in a list. When the same name occurs multiple times in the types, all occurrences are returned.ghcExtracts 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] an associated type declghcSurface-syntax free vars that we will implicitly bind. May have duplicates, which are removed here.ghcK _ => an associated type declghcSurface-syntax free vars that we will implicitly bind. Duplicate variables will cause a compile-time error regarding repeated bindings.ghcname of the wildcard, or J for an anonymous wildcardghctypeghcK _ => an associated type declghcExplicitly bound hereghcPotential implicit bindersghcFinal implicit binders44 Safe-Inferred%(8.,ghcBuild a { out of an extension constructor, and the two components of the expansion: original and desugared patternsghcTurn 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.ghcsource patternghcexpanded patternghcsuitably wrapped { Safe-Inferred /. Safe-Inferred ? 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.ghcTracks whether we are renaming an equation in a closed type family equation ( ) or not ().ghcTracks 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] 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 alreadyghcFor 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-InferredB<ghc/Rename a splice pattern. See Note [rnSplicePat]ghcThe splice data to be loggedghcEnsure that we are not using a term-level name in a type-level namespace or vice-versa. Throws a  error if there is a problem.ghcReturns the result of running a splice and the modFinalizers collected during the execution.5See Note [Delaying modFinalizers in untyped splices].ghcoutputs splice information for 2 flags which have different output formats: `-ddump-splices` and `-dth-dec-file` Safe-Inferred /Q^ghcRename some StmtsghcA tree of statements using a mixture of applicative and bind constructs.ghcThe s of return and pure. These may not be  returnName and pureName due to  QualifiedDo or RebindableSyntax.ghcmaybe 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.We don't need join if there's a single LastStmt in the form of return E,  return $ E, pure E or pure $ E.ghc(Just e, Just False), if the expression is  return/pure e-, and the third argument is Nothing, (Just e, Just True) if the expression is return/pure $ e-, and the third argument is Nothing, (Just (pure e), Nothing) if the expression is  return/pure e!, and the third argument is Just pure_expr, (Just (pure $ e), Nothing) if the expression is return/pure $ e!, and the third argument is Just pure_expr, 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.ghc'How to rename the body of the statementghc The statementghc0Rename the stuff that this statement scopes overghcThe free variables used in later statements. If the boolean is L, this might be an underestimate because we are in GHCi, and might thus be missing some "used later" FVs. See Note [What is "used later" in a rec stmt]ghc the "tail"ghcfree variables of the tailghcThe argsghcTrue  = need a joinghcThe body statementsghcsource expressionghcexpanded expressionghcsuitably wrapped | Safe-Inferred %&]XghcLoad the module containing the given Name and get its associated . Throws a . if loading fails or the name cannot be found.ghc"Temporarily extend the loaded env.ghcDisplay the loader state.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.ghcMerge runs of consecutive of u. 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.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.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 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.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.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.ghc%returns the set of linkables requiredghcThe linkables to *keep*.vvvuuuuuvvvvvvvuuuuuvvvv Safe-InferredgNghcLoads 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.ghc=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 Left actual_type.. 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 failedghcCoerce 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-InferredvghcReturns true if an [ is for data T (an abstract data type)ghc Merge two [s 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 [s by  .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.ghcTypecheck 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])̽ghcTrue  =# discard IdInfo on IfaceId bindingsghc,For associated type/data family declarationsghcTrue  =# discard IdInfo on IfaceId bindingsghcIs this unfolding compulsory? See Note [Checking for representation polymorphism] in GHC.Core.Lint̽ƽʽɽ˽Ƚǽ̽ƽʽɽ˽Ƚǽ Safe-Inferred (1ghcLocal 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'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 .ghc) describes how to typecheck an explicit (Q) or implicit () binder in a type. It is just a record of flags that describe what sort of  to create.ghc1Describes the kind expected in a certain context.ghca specific kindghcany kind will doghcsomething of the form TYPE _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 moduleghcTypecheck 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 applicationghcCheck 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 Q . 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 [kcCheckDeclHeader_sig]ghcSkolemise the Qs in an Q with the supplied .ghcBring into scope the binders of a PolyTcTyCon Used for the type variables of a type or class decl in the "kind checking" and "type checking" pass, but not in the initial-kind run.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.ghcSpecialised version of , but with empty WantedConstraints, so no filtering is needed i.e. kindGeneraliseAll = kindGeneralizeSome emptyWCghcSpecialized 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].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.TyClghc2Checks that the result kind of a class is exactly  Constraint<, rejecting type synonyms and type families that reduce to  Constraint . See #16826.ghcMake an appropriate message for an error in a function argument. Used for both expressions and types.ghc3Add a "In the data declaration for T" or some such. 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, result kind)ghcFunction (for printing only)ghcFunctionghcArgsghc(f 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 headerghcThe result kindghcA suitably-kinded TcTyConghcof 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, fully generalised TcTyCon Postcondition to (kcCheckDeclHeader_sig sig_kind n f hs_tvs kc_res_ki): kind(returned PolyTcTyCon) = sig_kindghcneedn't be zonked Safe-InferredghcFind the location of the top-level context of a HsType. For example:  forall a b. (Eq a, Ord b) => blah ^^^^^^^^^^^^^  If there is none, return Nothingghc0If there are no wildcards, return a LHsSigWcType,s,s Safe-Inferred ghc 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).ghcatternsghctypes of the patternsghcchecker for the bodyghc(origin to use if the type needs inst'ingghcFully refined result typeghcTranslated patternghcType of the patternghcThe TyCon that this data constructor actually returns. In the case of a data family, this is the representation TyCon.ghcThe type of the pattern. In the case of a data family, this would mention the family TyConghc existentialsghcargument types   Safe-Inferred" Safe-Inferred ghcWarn the user about polymorphic local binders that lack type signatures.ghcThe location of the first pattern synonym binding (for error reporting) Safe-Inferred 8ghcA monad for type synonym cycle checking, which keeps track of the TyCons which are known to be acyclic, or a failure message reporting that a cycle was found.ghc Test if a 8 is acyclic, short-circuiting if we've seen it already.ghcChecks if any of the passed in s have cycles. Takes the   of the home package (as we can avoid checking those TyCons: cycles never go through foreign packages) and the corresponding LTyClDecl Name for each (, so we can give better error messages.   Safe-Inferred  ghcGiven a t. of an instantiated signature (note that the t 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 t 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 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 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.ghcTop-level driver for signature instantiation (run when compiling an hsig file.)ghcTop-level driver for signature merging (run after typechecking an hsig file).ghc The list of s of *non-exported* [s which this [ may refer to. A non-exported [1 should be kept after thinning if an *exported* [ (or ΍, perhaps) refers to it; we can't decide to keep it by looking at the exports of a module after thinning. Keep this synchronized with  rnIfaceDecl.ghcGiven a local ), merge all inherited requirements from u) 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.)ghcCheck if module implements a signature. (The signature is always un-hashed, which is why its components are specified explicitly.)ghcGiven , instantiate a  from the indefinite library to use the actual implementations of the relevant entities, checking that the implementation matches the signature.   Safe-Inferred ghc PatSyn NameghcPatSyn type (UniBidirExplicitBidir)ghc Whether infixghcPattern of the PatSynghcPattern arguments and types. These must have a syntactically fixed RuntimeRep as per Note [Fixed RuntimeRep] in GHC.Tc.Utils.Concrete.ghc Pattern type ghc*->*ghc5Typechecking for case command alternatives. Used for h.ghcTypechecking for h and h.ghc2Type-checked Arrow class methods (arr, (>>>), ...)ghcType of the scrutinee.ghccase alternatives Safe-Inferred)*1NghcCheck for representation-polymorphism in the remaining argument types of a variable or data constructor, after it has been instantiated and applied to some arguments." (type passed in)ghc1the operator we are checking (for error messages)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 expression׽ؽӽԽսֽϽнҽѽνͽrrrrrrr׽ؽӽԽսֽϽнҽѽνͽrrrrrrr 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 ghc%Stuff needed to process a datatype's  `deriving` clausesghcThe data tycon for normal datatypes, or the *representation* tycon for data familiesghc4Variables that scope over the deriving clause. See !Note [Scoped tyvars in a TcTyCon] in GHC.Core.TyCon.ghc error contextghc(Process the derived classes in a single deriving clause.ghc Process a single predicate in a deriving clause.This returns a @& because the user might try to derive Typeable, which is a no-op nowadays.ghc Generate the  for the required instance, plus any auxiliary bindings required (see Note [Auxiliary binders] in GHC.Tc.Deriv.Generate) and any additional free variables that should be marked (see +Note [Deriving and unused record selectors] in GHC.Tc.Deriv.Utils).ghcGenerate the associated type family instances for a derived instance.ghcIf , add a snippet about how not even GeneralizedNewtypeDeriving would make this declaration work. This only kicks in when an explicit deriving strategy is not given. Safe-Inferred (5ghcGet 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].ghcReject nullary data constructors where a type variables would escape through the result kind See Note [Check for escaping result kind]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 ѫ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 8ghcThis 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 J, like this, because sometimes we have nothing to put in the hole and so want to be sure there is in fact no hole.ghcThe patterns for an equation NB: We have already applied decideBangHood3 to these patterns. See Note [decideBangHood] in GHC.HsToCore.Utilsghc-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.ghcWhat to do after matchghcRun a  action inside the  monad.ghcRun a  action inside the D monad.ghc5Build a set of desugarer environments derived from a .ghcRun a & action in the context of an existing ƃghc0Get the current pattern match oracle state. See .ghcSet the pattern match oracle state within the scope of the given action. See .ghcEmit a diagnostic for the current source location. In case the diagnostic is a warning, the latter will be ignored and discarded if the relevant 1 is not set in the DynFlags. See Note [Discarding Messages] in .ghcIssue an error, but return the expression for (), so that we can continue reporting errors.ghcThe COMPLETE pragmas that are in scope.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.ghcSee .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.ghcheaderghcinformation to outputghc expression4 !"bc4 !"bc Safe-InferredghcGenerate a fresh  of a given typeghc=All warning flags that need to run the pattern match checker.ghcCheck whether the redundancy checker should run (redundancy only)ghcCheck whether the exhaustiveness checker should run (exhaustiveness only)ghc6Check whether unnecessary bangs should be warned aboutghcDenotes whether an exhaustiveness check is supported, and if so, via which 1 it's controlled. Returns J if check is not supported.ghcCheck whether any part of pattern match checking is enabled for this f (does not matter whether it is the redundancy check or the exhaustiveness check).ghc4Return True when any of the pattern match warnings () are enabled, in which case we need to run the pattern match checker.   Safe-Inferred(;2ghc)See Note [Case split inhabiting patterns]ghcA high-level pattern-match constraint. Corresponds to  from Figure 3 of the LYG paper.ghcA type constraint "T ~ U".ghc PhiCoreCt x e encodes "x ~ e", equating x with the J e.ghcPhiConCt x K tvs dicts ys encodes K @tvs dicts ys <- x , matching x against the  application K @tvs dicts ys , binding tvs, dicts and possibly unlifted fields ys in the process. See Note [Strict fields and variables of unlifted type].ghcPhiNotConCt x K! encodes "x D K", asserting that x can't be headed by K.ghc PhiBotCt x encodes "x ~ E", equating x to E. by K.ghcPhiNotBotCt x y! encodes "x D E", asserting that x can't be E.ghcThe return value of ghc was able to simplify the type with some local constraint from the type oracle, but F! couldn't identify a type redex.ghc5 may or may not been able to simplify the type, but F made progress either way and got rid of at least one outermost type or data family redex or newtype. The first field is the last type that was reduced solely through type family applications (possibly just the d type). This is the one that is equal (in source Haskell) to the initial type. The third field is the type that we get when also looking through data family applications and newtypes. This would be the representation type in Core (modulo casts). The second field is the list of Newtype s that we looked through in the chain of reduction steps between the Source type and the Core type. We also keep the type of the DataCon application and its field, so that we don't have to reconstruct it in inhabitationCandidates and 1. For an example, see Note [Type normalisation].ghcAdd a bunch of  s to all the  s. Lifts  over many .ghcaddPmCtsNablas for a single PmCt.ghcTest if any of the s is inhabited. Currently this is pure, because we preserve the invariant that there are no uninhabited s. But that could change in the future, for example by implementing this function in terms of notNull  $ generateInhabitingPatterns 1 ds.ghcUpdate the COMPLETE sets of , or J4 if there was no change as per the update function.ghc A pseudo-\1 for the vanilla complete set of the given data . Ex.: vanillaCompleteMatchTC @ ==> Just (Maybe, {K,J})ghcInitialise from 1 (containing all COMPLETE pragmas) if the given  were empty.ghcAdds the declared \ from COMPLETE pragmas, as well as the vanilla data defn if it is a .ghcAdds * the \% from COMPLETE pragmas * and the vanilla \ 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 O, 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 L if the argument K 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 K= 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!)ghcThe fuel for the inhabitation test. See Note [Fuel for the inhabitation test].ghcAdds new constraints to  and returns J# 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 J# if we find a contradiction (e.g.  Int ~ Bool).See Note [Pattern match warnings with insoluble Givens] in GHC.Tc.Solver.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 J 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 I 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].ghc%generateInhabitingPatterns vs n nabla returns a list of at most n% (but perhaps empty) refinements of nabla that represent inhabited patterns. Negative information is only retained if literals are involved or for recursive GADTs. Safe-Inferred )*8ghc*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-Inferred ghcUse -XStrict to add a ! or remove a ~ See Note [decideBangHood]ghc 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 bindsghcOriginal pattern55 Safe-InferredZ Safe-Inferred  Safe-Inferred  ghc'See Note [FractionalLit representation]ghcPost-typechecker, the  field of an A8 contains (an expression for) the literal value itself.ghcEmit warnings on overloaded integral literals which overflow the bounds implied by their type.ghcEmit warnings on integral literals which overflow the bounds implied by their type.ghcEmit warnings on integral literals which overflow the bounds implied by their type.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.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'the literal value and name of its tyconghc!Type of the whole case expressionghc All PgLits   Safe-Inferredghc Guarded RHSsghc Type of RHSghcRefined pattern match checking models, one for the pattern part and one for each GRHS. Safe-Inferred %)*%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 patternghcDesugar the non-empty ges of a .ghc.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 )*54ghc6A datatype to accomodate the different call sites of . Used for extracting s from a concrete 7 through :. Since this is only possible for a couple of well-known 7s, this is a GADT.ghc TypeRep a   Safe-Inferred1@ 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 L if the list of implicitly bound type variables is empty. If a type explicitly quantifies its outermost type variables, always return L.This is used in various places to determine if a Template Haskell K should be headed by a ForallT or not.ghcIf a type explicitly quantifies its outermost type variables, return L if the list of explicitly bound type variables is empty. If a type implicitly quantifies its outermost type variables, always return L.This is used in various places to determine if a Template Haskell K 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-InferredA! Safe-Inferred #(EZghc matchSimply is a wrapper for  which deals with the situation where we want to match a single expression against a single pattern. It returns an expression.ghc'Use this pattern synonym to match on a f.2N.B.: View patterns can occur inside HsExpansions.ghc&The scrutinee the match id is bound toghc Scrutineeghc Match kindghcPattern it should matchghcReturn this if it matchesghcReturn this if it doesn'tghcFor shadowing warning messagesghc0Scrutinee(s) see Note [matchWrapper scrutinees]ghcMatches being desugaredghcResults (usually passed to )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! Safe-InferredFghc'the desugared rhs of the bind statementghc S in (>>=) :: Q -> (R -> S) -> T Safe-Inferred -FR Safe-InferredKghcReplace the body of the function with this block to test the hsExprType function in GHC.Tc.Utils.Zonk: putSrcSpanDs loc $ do { core_expr <- dsExpr e ; massertPpr (exprType core_expr @& hsExprType e) (ppr e  + dcolon  +6 ppr (hsExprType e) $$ ppr core_expr  + dcolon  +2 ppr (exprType core_expr)) ; return core_expr }ghc4The 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. Safe-Inferred 8Z.ghcThe .hs file has been touched, or the .o/.hi file does not existghcThe .o/.hi files are up to date, but something else has changed to force recompilation; the String says what (one-line summary)ghc0The item contained is validated to be up to dateghcThe item is are absent altogether or out of date, for the reason given.ghc7everything is up to date, recompilation is not requiredghcNeed to compile the moduleghcTop level function to check if the version of an old interface file is equivalent to the current source file the user asked us to compile. If the same, we can avoid recompilation.We return on the outside whether the interface file is up to date, providing evidence that is with a . In the case that it isn't, we may also return a found or provided . Why we don't always return the old one, if it exists, is unclear to me, except that I tried it and some tests failed (see #18205).ghc$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.ghc1Add fingerprints for top-level declarations to a .$See Note [Fingerprinting IfaceDecls]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 annotationsghc the reason we need to recompile.ghcThe old item, if it exists,, Safe-Inferred[ghcFind object files corresponding to the transitive closure of given home modules and direct object files for pkg dependencies Safe-Inferred^4ghcFully instantiate an interface. Adds fingerprints and potentially code generator produced information.CmmCgInfos 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-Inferreda5ghcPretty-prints a N8 (type/data family instance) with its defining location.ghcPretty-prints a  with its defining location.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 . Safe-Inferred")*/16gghcUsed to collect type infoghcThe main worker class See Note [Updating HieAst for changes in the GHC AST] for more information on how to add/modify instances for this.ghcconveniently calculate locations for things without locations attachedghcFirst scope remains constant Second scope is used to build up the scope of a tyvar over things to its right, ala RScopedghc Pattern scopeghcScope 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 bindingsghccontext for type signaturesghc#context for pattern synonym fields.ghccontext for imports/exportsghccontext for imports/exportsghccontext for record fieldsghc 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.ghc2Each element scopes over the elements to the rightghc specialised to  thingsghc specialised to Qghc specialised to  thingsghc!This instance tries to construct ¶ nodes which include the type of the expression. It is not yet possible to do this efficiently for all expression forms, so we skip filling in the type for those inputs.7See Note [Computing the type of every node in the tree]ghcuse site of the patternghc*pattern to the right of a, not including a Safe-Inferredhļżļż Safe-InferredjPǼghcRename a module from one name to another. The identity renaming means that the module should be brought into scope.˼ghcAn include of another unitϼghc 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.)ѼghcA declaration in a package, e.g. a module or signature definition, or an include.ռghc Top level unit declaration in a Backpack file. ߼޼ݼڼܼۼټԼռּ׼ؼмѼҼӼ˼̼ͼμϼƼǼȼɼʼ ߼޼ݼڼܼۼټԼռּ׼ؼмѼҼӼ˼̼ͼμϼƼǼȼɼʼ Safe-Inferred)*1oghcConstruct 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 AnnCloseghcParse 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.ghcInstead 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-InferredqghcReturns True! if passed string is a statement.ghcReturns True, if passed string has an import declaration.ghcReturns True+ if passed string is an import declaration.ghcReturns True' if passed string is a declaration but  not a splice. Safe-Inferredv ghc#Parse the imports of a source file. Throws a  if parsing fails.ghc6Parse OPTIONS and LANGUAGE pragmas of the source file. Throws a 5 if flag parsing fails (including unsupported flags.)ghc6Parse OPTIONS and LANGUAGE pragmas of the source file. Throws a 5 if flag parsing fails (including unsupported flags.)ghc4Complain about non-dynamic flags in OPTIONS pragmas. Throws a  if the input list is non-empty claiming that the input flags are unknown.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 fileghcParsed options, if any.ghc Input Bufferghc)Source filename. Used for location info.ghcwarnings and parsed options. Safe-Inferred`ghcCompares two things for equivalence between boot-file and normal code, reporting an error if they don't match up.ghc3How should we infer a type? See Note [TcRnExprMode]ghc-Instantiate inferred quantifiers only (:type)ghcInstantiate all quantifiers, and do eager defaulting (:type +d)ghc9A plan is an attempt to lift some code into the IO monad.ghc1Top level entry point for typechecker and renamerghcRuns TH finalizers and renames and typechecks the top-level declarations that they could introduce.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%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-isghcThe 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 ().ghcTry 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:tcRnExpr just finds the type of an expression for :typeghc)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.ghc8Find all the Names that this RdrName could mean, in GHCighc!Dump, with a banner, if -ddump-rnghc.Extract the renamed information from TcGblEnv.ghcTrue  =& an hs-boot file (could also be a sig)ghcInstances of this ...ghc should also be instances of this##0 Safe-Inferredghc"Main entry point to the desugarer. Safe-Inferred )*%ghclog warning in the monad, and if there are errors then throw a SourceError exception.ghcLog warnings and throw errors, assuming the messages contain at least one error (e.g. coming from PFailed)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 modeghcRun 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).ghcGenerate a striped down interface file, e.g. for boot files or when ghci generates interface files. See Note [simpleTidyPgm - mkBootModDetailsTc]ghcCompile to hard-code.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.ghcCompile a declsghcCompile a declsghcLoad the given static-pointer table entries into the interpreter. See Note [Grand plan for static forms] in GHC.Iface.Tidy.StaticPtrTable.ghc*Typecheck an expression (but don't run it)ghc-Find the kind of a type, after generalisation ghcKeep renamed source?ghcIs this a simple interface generated after the core pipeline, or one with information from the backend? See: Note [Writing interface files]ghcThe old interface hash, used to decide if we need to actually write the new interface.ghcJust f  = _stub.c is fghc(Bindings come already annotated with fvsghc The statementghc The sourceghc Starting lineghcThe parsed statementghc The statementghc The statementghc The sourceghc Starting lineghcThe expressionghcNormalise the typeghcThe type as a stringghc-Resulting type (possibly normalised) and kind Safe-Inferred')*2ghc(Releases the external interpreter state.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].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].ghcReturns M in the case that the instances were found to be class instances, or N if they are family instances.ŽĽý½ŽĽý½ Safe-Inferred %&ghcFailure modes for .ghc  returned J.ghcThe module was loaded without -haddock,ghcThe  was defined interactively.ghc,Finds the enclosing top level function name ghc=Update fixity environment in the current interactive context.ghcdefault ExecOptionsghc3Run 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).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 imports9, and updates the icReaderEnv environment to reflect it.We retain in scope all the things defined at the prompt, and kept in ic_tythings. (Indeed, they shadow stuff from ic_imports.)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.ghcReturns True if the specified module is interpreted, and hence has its full top-level scope available.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.ghc:Parses a string as an identifier, and returns the list of s that the identifier can refer to in the current interactive context.ghcGet the type of an expression Returns the type as described by ghcGet the kind of a typeghcParse an expression, the parsed expression can be further processed and passed to compileParsedExpr.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.ghcL: The module was compiled. I: The module was :loaded.ghc a statement (bind or expression)SSSSSSSSSSSSSRRSSSSSSSSSSSSSSSSSSSSγSSSSSSSSSSSSSRRSSSSSSSSSSSSSSSSSSSSγ Safe-Inferred')*?V ghcThe default mechanism to run a pipeline, see Note [The Pipeline Monad]ghc5Default interpretation of each phase, in terms of IO.ghcCalculate the ModLocation from the provided DynFlags. This function is only used in one-shot mode and therefore takes into account the effect of -o/-ohi flags (which do nothing in --make mode)ghcComputes the next output filename for something in the compilation pipeline. This is controlled by several variables: O!: the last phase to be run (e.g.  stopPhase). This is used to tell if we're in the last phase or not, because in that case flags like -o may be important.d: is this intended to be a d or d build output? Temporary files just go in a fresh temporary name.:3: what was the basename of the original input file?o: the obvious thingO8: 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?)ghcLLVM Options. These are flags to be passed to opt and llc, to ensure consistency we list them in pairs, so that they form groups.ghcRun CPP/UnitEnv is needed to compute MIN_VERSION macrosghcWhat phase to run after one of the backend code generators has runghcSee Note [Object merging].ghcFind out path to  ghcversion.h fileghcThe next phaseghc8A ModLocation, if we are compiling a Haskell source fileghcpairs of (opt, llc) arguments$$ Safe-Inferred '/+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 pragmasghcCompileCompile 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.ghcCheck if the start is *before* the current phase, otherwise skip with a defaultghcThe preprocessor pipelineghc7The complete compilation pipeline, from start to finishghcEverything after preprocessghcinput filenameghc8optional buffer to use instead of reading the input fileghcstarting phaseghc!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 oneghc'the complete HomeModInfo, if successfulghcinteractive or batchghcLoggerghc dynamic flagsghcunit environmentghcattempt linking in batch mode?ghc what to linkghc dynamic flagsghcunit environmentghcattempt linking in batch mode?ghc what to link9dddddddd–ÖĖŖƖǖȖɖʖ˖̖͖ΖϖЖіҖddd9dddddddd–ÖĖŖƖǖȖɖʖ˖̖͖ΖϖЖіҖddd Safe-Inferred%&')*389:?$ghc Convenience named arguments for 5 only used to make code more readable, not exported.ghc(Environment used when compiling a moduleghcAbstraction over the operations of a semaphore which allows usage with the -j1 caseghc;Simple wrapper around MVar which allows a functor instance.ghcA ModuleGraphNode which also has a hs-boot file, and the list of nodes on any path from module to its boot file.ghc>Describes which modules of the module graph need to be loaded.ghc&Load all targets and its dependencies.ghc0Load only the given module and its dependencies.ghcLoad only the dependencies of the given module, but not the module itself.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 o . These o are determined by the current session o and the OPTIONS and LANGUAGE pragmas of the parsed module. Thus if you want changes to the o 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.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 .ghcFinish up after a load.ghcIf there is no -o option, guess the name of target executable by using top-level source file name as a base.ghcPrune the HomePackageTable+Before doing an upsweep, we can throw away:all ModDetails, all linked codeall unlinked code that is out of date with respect to the source fileThis is VERY IMPORTANT otherwise we'll end up requiring 2x the space at the end of the upsweep, because the topmost ModDetails of the old HPT holds on to the entire type environment from the previous compilation. Note [GHC Heap Invariants]ghc Unloadingghc Block until the result is ready.ghcGiven the build plan, creates a graph which indicates where each NodeKey should get its direct dependencies from. This might not be the corresponding build action if the module participates in a loop. This step also labels each node with a number for the output. See Note [Upsweep] for a high-level description.ghcCompile a single module. Always produce a Linkable for it if successful. If no compilation happened, return the old Linkable.ghcAdd the entries from a BCO linkable to the SPT table, see See Note [Grand plan for static forms] in GHC.Iface.Tidy.StaticPtrTable.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 cyclicghcIf 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.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.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.ghc3Populate the Downsweep cache with the root modules.ghc.Wrap an action to catch and handle exceptions.ghcWait for some dependencies to finish and then read from the given MVar.ghc?Wait for dependencies to finish, and then return their results.ghc1Start a thread which reads from the LogQueueQueueghcBuild and run a pipelineghc;Run the given actions and then wait for them all to finish.ghcExecute each action in order, limiting the amount of parrelism by the given semaphore. ghcexcluded modulesghcallow duplicate rootsghcexcluded modulesghcallow duplicate rootsghcexcluded modulesghcallow duplicate rootsghcpossibly empty Bag of errors and a module graph.ghc0The number of workers we wish to run in parallelghc3The base HscEnv, which is augmented for each moduleghc7A cache to incrementally write final interface files toghcDrop hi-boot nodes? (see below)ghcRoot module name. If Nothing, use the full graph.ghc Old summariesghcMap of old summariesghc1optional source code buffer and modification timeghc)The HPT in this HscEnv needs rehydrating.ghc+These are the modules we want to rehydrate.ghcHow many capabilities to useghcThe basic HscEnv which is augmented with specific info for each moduleghc2Optional custom messager to use to report progressghc'The build plan for all the module nodes66 Safe-Inferred '(>ghc?An error thrown if the GHC API is used in an incorrect fashion.ghc"Container for information about a  .ghc.A CoreModule consists of just the fields of a ƃ that are needed for the  interface.ghc Module nameghc2Type environment for types declared in this moduleghc DeclarationsghcSafe Haskell modeghcThe result of successful desugaring (i.e., translation to core). Also contains all the information of a typechecked module.ghcThe result of successful typechecking. It also contains the parser result.ghc!The result of successful parsing.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.ghcThis function is no longer necessary, cleanup is now done by runGhc/runGhcT.ghcRun 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.ghcInitialise 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.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_78333ghcSets the program o. 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.ghcReturns the program o.ghcSet the o 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.ghcGet the o* used to evaluate interactive expressions.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 v via ghcSplitting 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.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.ghcChecks the set of new DynFlags for possibly erroneous option combinations when invoking  and friends, and if found, returns a fixed copy (if possible).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"Returns the current set of targetsghcAdd another target.ghcRemove a targetghcAttempts 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 nameghcUnwrap   or retrieve the   of the current .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 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.ghcParse a module. Throws a  on parse error.ghc%Typecheck and rename a parsed module. Throws a  if either fails.ghcDesugar a typechecked module.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.ghc Get the module dependency graph.ghcReturn True <==> module is loaded.ghc8Return the bindings for the current interactive session.ghc9Return the instances for the current interactive session.ghc#Request information about a loaded  ghc2The list of top-level entities defined in a moduleghcReturns the instances defined by the specified module. Warning: currently unimplemented for package modules.ghc!Retrieve module safe haskell modeghcLooks 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 .ghc"get the GlobalRdrEnv for a sessionghcRetrieve 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.ghcprint a 0, adding parentheses if the name is an operator.ghc9Return module source as token stream, including comments.A   can be turned into a  using 2 if your session is fully initialised. Throws a  on parse error.ghc.Give even more information on the source than  This function allows reconstructing the source completely with .ghcGiven a source location and a StringBuffer corresponding to this location, return a rich token stream with the source associated to the tokens.ghc/Take a rich token stream such as produced from  and return source code almost identical to the original code (except for insignificant whitespace.)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.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.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.ghcReturn if a module is trusted and the pkgs it depends on to be trusted.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.ghc.Get the monad GHCi lifts user statements into.ghc Returns the  for a . The 2 may refer to any entity known to GHC, including s defined using runStmt.ghc&A pure interface to the module parser.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 id2ghcSee argument to .ghcThe action to perform.ghcSee argument to .ghcThe action to perform.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)dÒƒǒȒؒoooooppoooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooopppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppp2222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222233333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333bbbbqoooooooooooʒccccϒВΒђҒvvvvvvvvvOȑɑʑْRRRRÍčōƍǍȍɍʍˍ͍̍΍ύЍэҍӍԍՍ֍׍؍OOOOOOO SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSRSSkkkkkkkkk    '''MMM!!!MMMMMMMM:::;;;;;;;;;;;;=HHHHHHHH99999:ttttN@@DEEERRRR0gggggggffffffffffffffffffffgQaaa____```_____`aaaaOOOO77787878777777777777777777777777777777777777777777777777777777777777777777778888888888888888888888888888887777HHHHHHHHHHHHHH6__________OPPPPaaaaaaaaaaaaaaaaa```````````a```````````````````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa````````````````````````````````````````````````````````````````````````zz__________zzzzz_____aaaa___________________`````````````````````_____________________________a`aaaaaaaaaaaaaaaPPPPPPPPPPPPPPPPPPPPPPPPPPPPP6666666666666_____OO___zz_________________zzzzzzzzzzzzzz^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh{|{{{{{{{{{{f{{{{{{{{ffffffffffffffffQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQyQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQPQQQQQQQQQQPPPPPyQPPPPPPPPPPPPPPPPPPPPPPP}}}}}}777777777777777777777777777777777777777777776767666666677777666666666666666666666666666666666666666666666666666666666666hhhhhhggggggg_gggggOhhhhhhhhhhhhfgggggggggggggggg||||gggggggggg|||||||||_πۀڀـ؀׀րՀԀӀҀЀрggggggggggggggggggggggggggggg_AAAAAAAAAAAAAAAAAAAA€ŀÀĀhhhAAAAPOOOO^___^___^^hhhhhhhhhhhhhhhhhgffffffghggggghhhhhhghhhgggggggggggggggggggggggggggggggggggggggggggggfffffffffffiiiiiiiiiyyyyzyyyyy|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||܀߀݀ހ΀ƀ̀̀ˀʀɀǀȀzi~~}iifazaaaaaaazaaaaazzazzazzzzzzazzazazzzaazzzzzzzazziPPPPP666666666666fff|f|||||||||||||||||iiQQyyyyyyQQQyyyyQyyyyyyyyyyQyyyyyyyyyyQyQyyyyyyyyyyyyyyyyyyyyyyyyyyyyQyyyyyyyyyyy}}}}}}}}}}}}}~~}}~~~~~~}~}}}}~~}~~}~}}~~~~~~~~~~~~~~~~~~~}~~~~~~~~}}}~~~}}~~~~~~~~~~~~}}~~~~~~~~~~~~~~}}~~~~~}}~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~88888888888888888888888888888888888888888888888888888888888888888hhaAAA}PPPPP___________|}hhhhhhhhhhhhhhhhhhhhhhhhhhiiiiizzzzzzzzzzzzzzzzzzzzzzzz|||||}|||}|}}}}}|}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}00000000000dÒƒǒȒؒoooooppoooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooopppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppp2222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222233333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333bbbbqoooooooooooʒccccϒВΒђҒvvvvvvvvvOȑɑʑْRRRRÍčōƍǍȍɍʍˍ͍̍΍ύЍэҍӍԍՍ֍׍؍OOOOOOO SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSRSSkkkkkkkkk    '''MMM!!!MMMMMMMM:;:;;;;;;;;;;;:=HHHHHHHH99999:ttttN@@DEEERRRR0000000000077787878777777777777777777777777777777777777777777777777777777777777777777778888888888888888888888888888887777 Safe-Inferred7PghcThe :print & friends commandsghcGive names, and bind in the interactive environment, to all the suspensions included (inductively) in a term Safe-Inferred7 Safe-Inferred "Eghc&Backpack environment. NB: this has a  and not an &, because we are going to update the  as we go.ghc The sessionghc,The filename of the bkp file we're compilingghc2Table of source units which we know how to compileghcWhen a package we are compiling includes another package which has not been compiled, we bump the level and compile that.ghcBackpack monad is a ƒ7 which also maintains a little extra state beyond the , c.f. .ghc9Tiny enum for all types of Backpack operations we may do.ghcA compilation operation which will result in a runnable executable being produced.ghcA type-checking operation which produces only interface files, no object files.ghcA compilation operation which produces both interface files and object files.ghc'Entry point to compile a Backpack file.ghcCreate a temporary Session to do some sort of type checking or compilation.ghcCompute the dependencies with instantiations of a syntactic HsUnit; e.g., wherever you see dependency p[A= A] in a unit file, return the   corresponding to p[A= A]. The  include_sigs4 parameter controls whether or not we also include dependency signature" declarations in this calculation.%Invariant: this NEVER returns UnitId.ghc=Register a new virtual unit database containing a single unitghcGet the current .ghc:Get the nesting level, when recursively compiling modules.ghcRun a 0 computation, with the nesting level bumped one.ghcUpdate the EPS from a ƒ(. TODO move to appropriate library spot.ghcGet the EPS from a ƒ.ghcRun  in Ò.ghcPrint a compilation progress message, but with indentation according to level (for nested compilation).ghc Creates a ? for Backpack compilation; this is basically a carbon copy of  but calling , which handles indentation.ghc  for Backpack messages; here we usually want the module to be qualified (so we can tell how it was instantiated.) But we try not to qualify packages so we can use simple names for them.ghc2Message when we initially process a Backpack unit.ghc,Message when we instantiate a Backpack unit.ghc(Message when we include a Backpack unit.ghcThis is our version of GHC.Driver.Make.downsweep, but with a few modifications: Every module is required to be mentioned, so we don't do any funny business with targets or recursively grabbing dependencies. (We could support this in principle).We support inline modules, whose summary we have to synthesize ourself.We don't bother trying to support GHC.Driver.Make for now, it's more trouble than it's worth for inline modules.ghcUp until now, GHC has assumed a single compilation target per source file. Backpack files with inline modules break this model, since a single file may generate multiple output files. How do we decide to name these files? Should there only be one output file? This function our current heuristic, which is we make a "fake" module and use that.ghc>Create a new, externally provided hashed unit id from a hash.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " """""""""""#####$$$$$$$$$$%%%%%%%%%%%%%%%%%%%%%%%%%&'''''''''((((())))***********+,,,,,,,,,,,,,-------------..................../////////////////////////////////////////////////////////////////    0000000000000001111111111222222222222222222222222222333333333333333333333333333333333333333333333333333333333333333333333333333344444444444444444444444444455555566666778888888889::::::;;;;;;<====>>>>>>>>============================================================================================================================================================================================================================================================================================================??????@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@AAAAAABBCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDEEEEEEEEEEFGGGGGGGGHHHKKKKKKKKKKKKKKKKJJJJJJJJJJJJJJJJJJMMMMMMMMNNNNNOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOPPPPPPPPPPPPPPPPPPPPPPQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQRRRRRRRRRRRRSSSSSSSSSSSSSTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUVVVVVV VVVVVWWWWWWWWWWXXXXXXXXXXXX<<<<<<<<<<<<<<<<<YYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYZZZZZZZZZZZZZZZZZZZZZZZZ[[[[[[[[[\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\]]]]]]]]]]]]]]]]]]]]]]]]]]]]>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>^^^^^^^^^^^^^^^^____________________________________________________```````````````````````````aaaaaaaaaaaabbbbccccccccccccccddddeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff                                                                                                                                  !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!""""g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g" " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " "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#j#j#j#j#j#j#j#j#j#j#j#j#j#j#k###### #### ###################$$$$$$$$$$l$l$l$l$l$l$l$l$l$l$l$l$l$l$l$l$l$l$l$l$l$l$l$l$l$l$l$l$l$l$l$l$m$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$n$n$n$n$n$n$n$n$n$n$n$n$n$n$n$n$n$n$n$n$n$n$n$n$n$n$n$n$n$n$n$n$n$n$n$n$n$n$n$n$n$n$n$n%n%n%n%n%n%n%n%n%n%g%g%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;%;&;&;&;&;&;&;&;&;&;&;&;&;&;&;&;&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'o'o'o'o'o'o'o'o'o'o'o'o'o'o'o'o'o'o'o'o'o'o'o'o'o'o'o'o'o'o'o'o'o'o'o'o'o'o'o'o'o'o'o'o'o'o'o'o'o'o'o(o(o(o(o(o(o(o(o(o(o(o(o(o(o(o(o(o(o(o(o(o(o(p(p(p(p(p(p(p(p(p(p(p(p(p(p(q(q(q(q(q(q(q(q(q(q(q(q(qq(q(q(q(q(q(q(q(q(q(q(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(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(s(s)s)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)u u u)u)u)u)u)u)u)u)u)u)u u u)u v)v)v)v)v)v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*I*I*I*I*I*I*I*I*I*I*I*I*I*I*I*I*I*I*I*I*I*I*I*I*I*I*I*I*I*I*I*I*I*I*I*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+x+x+x+x+x+x+x+x+x+x+x+x+x+x+x+x+x+x+x+x+x+x+x+x+x+x+x+x+x+x+x+x+x(x+x(x(x(x+x+x+x+x+x+x+x+x+x+x+y+y+y+y+y+y+y+y+y+y+y+y+y+y+y+y+z+z+z+z+z+z+z+z+z+z+z+z+z+z+z+z+z+z+z+z+z+z+z+z+z+z+z+z+z+z+z+z+z+z+z+z+z+z+z+z+z+z+z+{+{+{+{+{+{+{+{+{+{+{+{+{+{,{,{,{,{,{,{,{,{,{,{,{,{,{,{,{,{,{,{,{,{,{,{,{,{,{,{,{,{,{,{,|,|,|,|,|,|,|,|,|,|,|,|,|,|,|,|,|,|,|,|,|,|,|,|,|,|,|,||,|,|,|,|,|,|,|,|,|,|,|,|,|,|,|,|,|,|,|,|,|,|,|,|,|,|,|,|,|,|,|,|,|,|,|,|,|,|,|,|,|,|,|,|,|,|,|,|,|,|,|,|,|,|,|,|,|,|,|,|,|,|,|,|,|,|,|,|,|,|,|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}-}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}.}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}/}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}2}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}4}4}4}4}4}4}4}4}4}4}4}4}4}4}4}4}4}4}4}4}4}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}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5~5~5~5~5~5~5~5~5~5~5~5~5~5~5~5~5~5~55555555666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777778888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888899999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<=====================================================================&===========================================================>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>G>G>G>G>G>G>G>G>G>G>G>G>G>G>G>G>G>G>G>G>G>G>G>G>G>G>G>G>G>G>G>G>G>G>G>G>G>G>G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G?G@G@G@G@G@G@G@G@G@G@G@G@G@G@G@G@G@G@G@G@G@G@G@G@G@G@G@G@G@G@G@G@G@G@G@G@G@G@G@G@G@G@G@G@G@G@G@G@G@G@G@G'G@G@G@G@G@G@G@G@G@G@G@G@G@G@G@G@G@G@G@G@G@G@G@G@G@L@@@@@@@@KK@K@K@K@K@K@K@K@K@K@K@K@K@K@K@K@K@K@K@K@K@K@K@K@K@K@K@K@K@K@K@K@K@K@K@K@K@K@K@K@K@K@K@K@K@K@KAKAKAKAKAKAKAKAKAKAKAKAKAKAKAKAKAKAKAKAKAKAKAKAKAKAKAKAKAKAKAKAKAKAKAKAKAKAKAKAKAKAKAKAKAKAKAKAKAKAKAKAKAKAKAKAKAKAKAKAKAKAKAKAKAKAKALALALALALALALALALALALALALALALALALALALALALALALALALALALALALALALALALALALALALALALALALALALALALALALALALALALALALALALALALALALALALALBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLBLCLCLCLCLCLCLCLCLCLCLCLCLCLCLCLCLCLCLCLCLCLC C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDJDJDJDJDJDJDJDJDJDJJDJDJDJDJDJDJDJDJDJDJDJDJDJDJDJDJDJDJDJDJDJDJDJDJDJDJDJDJDJDJDJDJDJDJDJDJDJDJDJDJDJDJDJDJDJDJDJDJDJDJDJDJDJDJDJDJDJDJDJDJDJDJDJDJDJDJDJDJDJDJDJDJDJDJDJDJDJDJEJEJEJEJEJEJEJEJEJEJEJEJEJEJEJEJEJEJEJEJEJEJEJEJEJEJEJEJEJJEJEJEJEJEJEJEJEJEJEJEJEJEJEJEJEJEJEJEJEJEJEJEJEJEJEJEJEJEJEJEJEJEJEJEJEJEJEJEJEJEJEJEJEJEJEJEJEJEJEJEJEJEJEJEJEJEJEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG GGGGGGGGGGGG:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:G:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H::H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:H:I:I:I:I:I:I:I:I:I:I:IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIININININININININININININININININININININININIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJIJJJJJJJJJJJJJKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKGKKKKKKKKKKKKKKKKKKKKKKKKLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLmLmLmLmLmLmLmLmLmLmLmLmLmLmLmLmLmLmLmLmLmLmLmLmLmLmLmLmLmLmLmLmLmLmLmLmLmLmLmLmLmLmLmLmLmLmLmLmLmLmLmLmLmLmLmLmLmLmLmLmLmLmLmLmLmLmLmLmLmLmLmLmLmMmMmMmMmMmMmMmMmMmMmMmMmMmMmMmMmMmMmMmMmMmMmMmMmMmMmMmMmMmMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP?P?P?P?P?P?P?P?P?P?P?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?Q?Q?Q?Q?Q?Q?Q?Q?Q?Q?Q?Q?Q?Q?Q?Q?Q?Q?Q?Q?Q?Q?Q?Q?Q?Q?Q?Q?Q?Q?Q?Q?Q?Q?Q?Q?Q?Q?Q?Q?Q?Q?Q?Q?Q?Q?Q?Q?Q?Q?Q?Q?QFQFQFQFQFQFQFQFQFQF'F'FQF'FQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFRFRFRFRFRFRFRFRFRFRFRFRFRFRFRFRFRFRFRFRFRFRFRFRFRFRFRFRFRFRFRFRFRFRFRFRFRFRFRFRFRFRFRFRFRFRFRFRFRFRFRFRFRFRFRFRFRFRFRFRFRFRFRFRFRFRFRFRFRFRFRFRFRFRFRFRFRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRKKRRRRRRRRRRRRRRRRRRRRRRSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUU=UUUUUUVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVHVHVHVHVHVHVHVHVHVHVHVHVHVHVHVHVHVHVHVHVHVHVHVHVHVHVHVHVHVVVVVVVVVVWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnWnXnXnXnXnXnXnXnXnXnXnXnXnXnXnXnXnXnXnXnXnXnXnXnXnXnXnXnXnXnXnXnXnXnXnXnXnXnXnXnXnXnXnXnXnXnXnXnX9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9X9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Y9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9Z9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9[9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9\9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]9]]]]]^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^________________________________________________________________________________________________________________________________`````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbcccccccccccccccccccccccccccVccccccccccccccccccccccccccccccccccccccc"cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccdddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd>>dddddddddddddddddddddddddddddddddddddddddeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeTeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffgggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggghhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh5hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiBiBiBiBiBiBiBiBiBiBiBiBiBiBiBiBiBiBiBiBiBiBjBjBjBjBjBjBjBjBjBjBjBjBjBjBjBjBjBjBjBjBjBjBjBjBjjAjAjAjAjAjAjAjAjAjAjAjAjAjAjAjAjAjAjAjAjAjAjAjAjAjAjAjAjAjAjAIAjAjAjAjAjAjAjAjAjAjAjAjAjAjAjAjAjAjAjAjAjAjAjAjAjAjAjAjAjAjAjAjAjAjAjAjAjAjAjAjAjAjAjAjAjAjAjAjAjAjAjAAjAjAjAjAjAjAjAjAjAjAjAjAjAjAjAjAjAjAjAjAjAjAjAkAkAkAkAkAkAkAkAkAkAkAkAkAkAkAkAkAkAkAkAkAAkAkAkAkAkAkAkAkAkAkAkAkAkAkAkAkAkAkAkAkAkAkAkAkAAkAkAkAkAkAkAkAkAkAkAkAkAkAkAkAkAkAkAkAkAkAkAkAkAkAkAkAkAkAkAkAkAkAkAkAkAkAkAEAEAkAkAkAkAkAkAkAkAkAkAkAkAkAkAkAkAkAkAkAkAkAkAkAkAkAkAkAkAkAkAkAkAkAkAkAkAkAkAkAkAkAkAkAkAkAkAkAkAkAkAkAkAlAlAlAlAlAlAlAlAlAlAlAlAlAlAlAlAlAlAlAlAlAlAlAlAlAlA=AlAlAlAlAlAlAlAlAlAlAlAlAlllllllllllllllllllllllhlhlhlhlhlhlhlhlhlhlhlhlhlhlhlhlhlhlhlhlhlhlhlhlhlhlhlhlhlhlhlhlhlhlhlhlhlhlhlhlhlhlhlhlhlhlhlhlhlhlhlhlhlhlhlhlhlhlhlhlhlhlhlhlhlhlhlhlhlhlhlhmhmhmhmhmhmhmhmhmhmhmhmhmhmhmhmhmhmhmhmhmhmhmhmhmhmhmhmhmhmhmhmhmhmhmhmhmhmhmhmhmhmhmhmhmhmhmhmhmhmhmhmhmhmhmhmhmhmhmhmhmhmhmhmhmhmhmhmhmhmhmhmhmhmhmhmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmnnnmnmnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn::::nnnnnnnnnnnnnnnnnnnnnoooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooopppppppppppppppppppppppppppppppppppppmpppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppqqqqqqqqq8q8q8q8q8q8q8q8q8q8q8q88q8q8q8q8q8q8q8q8q8q8q8q8q8q8q8q8qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrsssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttMtMtMtMtMtMtMtMtMtMtMtMtMtMtMtMtMtMtMtMtMtMtMtMtMtMtMtMtMtMtMtMtMtMtMtMtMtMtMtMtMtMtMtMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMuMvMvMvMvMvMvMvMvMvMvMvMvMvMvMvMvMvMvMvMvMvMvMvMvMvMvMvMvMvMvMvMvMvMvMvMvMvMvMvMvMvMvMvMvMvMvMvMvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwiwwwwwxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy y y y y y y y y y y y y y y y y y y y y y y y y y y y y y y y y y y y y y y yyyyyyyyyyyyyCCCyyyyyyyCyyyyyyyyyyyyyyyyyDDyDyyyyyyyyyyyyyyyyyyyyyyyyzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{|||||||||||=|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~i€ÀĀŀƀǀȀɀʀˀ̀̀΀πЀрҀӀԀՀր׀؀ـڀۀ܀݀ހ߀ÁāPŁƁǁȁɁʁˁ́́΁ρρЁсҁӁԁՁցׁ؁فځہ܁݁ށ߁‚ÂĂłƂǂȂɂʂ˂̂͂΂ςЂт҂ӂԂՂւׂ؂قڂۂ܂݂ނ߂ƒÃăŃƃǃȃɃʃ˃̃̓΃σЃу҃ӃԃՃփ׃؃كڃۃ܃݃ރ߃„ÄĄńƄDŽȄɄʄ˄̄̈́΄τЄф҄ӄԄՄքׄ؄لڄۄ܄݄ބ߄…ÅąŅƅDžȅɅʅ˅6̅6ͅ6΅6υ6Ѕ6х6҅6Ӆ6ԅ6Յ6օ6ׅ6؅6م6څ6ۅ6܅6݅6ޅ6߅6666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666†6Æ6Ć6ņ66Ɔ6dž6Ȇ6Ɇ6ʆ6ˆ6̆6͆6Ά6φ6І6ц6҆6ӆ6Ԇ6Ն6ֆ6׆6؆6ن6چ6ۆ6܆6݆6ކ6߆666666666666666666666666666666666666666‡ÇćŇƇLJȇɇʇˇ͇̇·χЇч҇҇ӇԇՇևׇ؇هڇۇ܇݇އ߇ˆÈĈňƈLjȈɈʈˈ͈̈ΈψЈш҈ӈԈՈֈ׈؈وڈۈ܈݈ވ߈‰ÉĉʼnƉljȉɉʉˉ͉̉ΉωЉщ҉ӉԉՉ։׉؉ىډۉ܉݉މ߉ŠÊĊŊƊNJȊɊʊˊ̊̊͊ΊϊЊЊъҊӊԊՊ֊׊׊؊؊يڊڊۊ܊݊݊ފߊ‹ËċŋƋNjȋɋʋˋ̋͋΋ϋЋыҋӋԋՋՋ֋׋؋ًڋۋ܋݋ދߋŒÌČŌƌnjȌɌʌˌ̌͌ΌόЌьҌӌԌՌ֌׌،ٌڌی܌݌ތߌOÍčōƍǍȍɍʍˍ͍̍΍ύЍэҍӍԍՍ֍׍؍ٍڍۍ܍ݍލߍŽÎĎŎƎǎȎɎʎˎ͎̎ΎώЎюҎӎԎՎՎ֎׎؎َڎێ܎ݎގߎÏďŏƏǏȏɏʏˏ̏͏ΏϏЏяҏӏԏՏ֏׏؏ُڏۏ܏ݏޏޏߏÐĐŐƐǐȐɐʐː̐͐ΐϐАѐҐӐԐՐ֐אِؐڐېܐݐސߐ‘ÑđőƑǑȑɑʑˑ̑͑ΑϑБёґӑԑՑ֑בّؑڑۑܑݑޑߑ’ÒĒŒƒƒǒǒȒɒʒ˒̒͒ΒϒВђҒӒԒՒ֒גْؒڒےܒݒޒߒSS“ÓēœƓǓȓɓʓ˓͓̓ΓϓГѓғӓԓՓ֓דؓٓړۓܓݓޓߓO”ÔĔŔƔǔȔɔʔ˔͔̔ΔϔДєҔӔԔՔ֔הؔٔڔ۔ܔݔޔߔgggg777777777777•ÕĕŕƕǕȕɕʕ˕͕̕ΕϕЕѕҕӕԕՕ֕וٕؕڕەەܕݕޕߕv–ÖĖŖƖǖȖɖʖ˖̖͖ΖϖЖіҖӖԖՖ֖זٖؖږۖܖܖݖޖߖv—×ėŗƗǗȗɗɗʗ˗̗͗ΗϗЗїҗӗԗ՗֗חؗٗڗ5ۗ5ܗ5ݗ5ޗ5ߗ5555555555                 ˜ØhhhĘŘƘǘȘɘʘiii˘̘͘ΘϘhИјҘӘԘȘʘ՘֘טؘ٘ژۘRܘݘ ޘߘ™ÙyyyyyyęyyřřƙǙǙșəʙ˙̙͙ΙϙЙљҙәԙՙ֙יؙٙڙۙܙݙޙߙ++PšÚĚŚƚǚȚɚʚ˚͚̚ΚϚКњҚӚԚ՚֚ךؚٚښۚܚݚޚߚ›ÛěśƛǛțɛʛ˛̛͛ΛϛЛћқӛԛ՛֛כ؛ٛڛۛܛݛޛߛœÜĜŜƜǜȜɜʜ˜̜͜ΜϜМќҜӜԜ՜֜ל؜ٜڜۜܜݜޜߜÝĝŝƝǝȝɝʝ˝̝͝ΝϝНѝҝӝԝ՝֝ם؝ٝڝ۝ܝݝޝߝžÞĞŞƞǞȞɞʞ˞̞͞ΞϞОўҞӞԞ՞֞מ؞ٞڞ۞ܞݞޞߞŸßğşƟǟȟɟʟ˟̟͟ΟϟППџҟӟԟ՟֟ן؟ٟڟ۟ܟݟޟߟ àĠŠƠǠȠɠʠˠ̠͠ΠϠРѠҠӠԠՠ֠נؠ٠ڠ۠ܠݠޠߠG¡áġšơǡȡɡʡˡ̡͡ΡϡСѡҡӡԡա֡סء١ڡۡܡݡޡߡ¢âĢŢƢǢȢɢʢˢ̢͢΢ϢТѢҢӢԢբ֢עآ٢ڢۢܢݢޢߢ£ããģţƣǣǣȣɣʣˣ̣ͣΣϣУѣңӣԣգ֣ףأ٣ڣۣܣݣޣߣl¤äĤŤƤǤȤɤʤˤˤ̤ͤΤϤФѤҤˤˤ̤ͤΤϤФѤҤpӤԤդ֤פؤ٤ڤۤܤݤޤߤ¥åĥťƥǥȥɥʥ˥̥ͥΥϥХѥҥӥԥե֥ץإ٥ڥۥܥݥޥߥ¦æĦŦƦǦȦɦʦ˦O̦ͦΦϦЦѦҦӦԦզ֦צئ٦ڦۦܦݦOަߦƤŤȤʤˤˤ̤ͤΤϤФҤѤ§çħŧƧǧȧɧʧ˧̧ͧΧϧЧѧҧӧԧէ֧קا٧ڧۧܧݧާߧʤˤˤ̤ФϤΤͤҤѤx¨èĨŨ ƨǨȨɨʨ˨̨ͨΨϨШѨҨӨԨը֨רب٨ڨۨܨݨިߨӣԣգ֣ףأ٣ڣۣܣݣޣߣ©éĩũƩǩȩɩʩ˩̩ͩΩϩЩѩҩөԩթ֩שة٩ک۩ܩݩީߩªêĪŪƪܦǪȪɪʪ˪̪ͪΪϪЪѪҪӪԪժժ֪תت٪ڪ۪ܪݪުߪK«ëīūƫǫȫɫʫ˫̫ͫΫϫЫѫҫӫԫի֫֫::׫ث٫ګګ۫ܫݫޫ߫m¬ìĬŬƬǬȬɬʬˬ̬ͬάϬЬѬҬӬԬլ֬׬ج٬ڬ۬ܬݬެ߬èϨ ­íĭŭƭߣӣԣգ֣ףأ٣ڣۣܣޣݣǭƩǩȩɩ˩ʩ̩ͩȭɭʭ˭̭ͭέϭЭѭѭҭҭӭԭխ֭׭ح٭ڭۭܭݭޭ߭ƩǩبɨŨϨ­èƭӣԣգ֣ףأ٣ڣۣܣݣޣߣȩɩ˩ʩ̩ͩݬȩɩʩ˩ͩʤ®îĮŮƮǮȮɮʮˮ̮ͮήϮЮѮҮӮԮծ֮׮خٮڮۮܮݮޮ߮¯ïįůƯǯȯɯʯ˯̯ͯίϯЯѯүӯԯկ֯ׯدٯگۯܯݯޯ߯Φ°ðİŰưǰȰɰʰ˰̰ͰΰϰаѰҰӰ԰հְװذٰڰ۰ܰݰް@߰yɰ°ưǰ˰±±ñıűƱDZVȱɱʱ˱̱ͱαϱбѱұӱԱձֱױرٱڱ۱ܱݱޱ߱²òIJŲƲDzDzȲɲʲ˲˲̲ͲβϲвѲҲӲԲղֲײزٲڲ۲ܲݲyCC޲߲yyDDDz:³óijųƳdzȳɳʳ˳̳ͳγϳгѳҳӳԳճֳ׳سٳڳ۳ܳݳ޳߳E´ôĴŴŴƴǴ ȴɴʴ˴˴̴ʹδδϴдѴҴӴԴմִ״شٴڴ۴ܴݴݴ޴ߴʹµõĵŵƵǵȵɵʵ˵̵͵͵εϵеѵҵӵԵյֵ׵صٵڵ۵ܵݵ޵ߵ¶öĶŶƶǶȶɶʶ˶̶Ͷζ϶жѶҶӶԶնֶ׶ضٶڶ۶ܶݶ޶߶ ·÷ķŷƷǷȷɷʷ˷̷ͷηϷзѷҷӷԷշַ׷طٷڷ۷ܷݷ޷߷¸øĸŸƸǸȸɸʸ˸̸͸θϸиѸҸӸԸոָ׸ظٸڸ۸ܸݸ޸߸¹ùĹŹƹǹȹɹɹʹ˹̹͹ιϹйѹҹӹԹչֹ׹عٹڹ۹ܹݹ޹߹ºúĺźƺƺǺǺȺɺʺ˺̺ͺκϺкѺҺӺԺպֺ׺غٺںۺܺݺ޺ߺ»ûĻŻƻǻȻɻʻ˻̻ͻλϻлѻһӻԻջֻ׻ػٻڻۻܻݻ޻߻ݔޔh¼üļżƼǼȼɼʼ˼̼ͼμϼмѼҼӼԼռּ׼ؼټڼۼܼݼ޼߼½ýĽŽƽǽȽɽʽ˽̽ͽνϽнѽҽӽԽսֽ׽ؽٽڽ۽ܽݽ޽߽¾þľžžƾǾȾȾɾʾ˾˾̾;;ξϾоѾҾӾԾվ־׾ؾپھ۾ܾݾ޾߾                                  ¿ ÿ Ŀ ſ ƿ ǿ ȿ ɿ ʿ ˿ ̿ Ϳ ο Ͽ п ѿ ҿ ӿ Կ տ ֿ׿ؿٿڿۿܿݿ޿߿j}Sҿ׆ۼܼݼɻ˻λлԽսҽؼټڔɻһڽpEyy"      %%%%& -. /000002 3333QCPPYYtTTU>elwww;DDDDEEEEpqqqq|GGGGGGGuGGGGGGGGGGGGGGGGGGG LLLJJJJJJJJJJJJJJJJJJJ:::::::::::IIIIIIIIIImmΦհK????nnnnnnnnn=hhhhhhhohhhphhhhhhhhhhohhhhhhhhhhhmhhhhhhhhhh  wڤ88888888 p< MMMM y'P  666         ɳghc GHC.PreludeGHC.Utils.TraceGHC.Utils.MonadGHC.Driver.PluginsGHC.Utils.FingerprintGHC.Utils.MiscGHC.Utils.Exception GHC.Unit.InfoGHC.Core.TyCo.FVsGHC.Data.IOEnvGHC.HsToCore.Monad GHC.PlatformGHC.Data.StreamGHC.Core.Opt.SpecConstrGHC.Data.Graph.Directed GHC.SysToolsGHC.Data.MaybeGHC.SysTools.BaseDirGHC.ByteCode.AsmGHC.Types.BasicGHCGHC.Runtime.InterpreterGHC.Platform.ConstantsGHC.Data.UnionFindGHC.Data.StrictGHC.Data.SmallArrayGHC.Data.FiniteMapGHC.Data.FastMutInt GHC.Data.BoolGHC.CmmToAsm.X86.CondGHC.CmmToAsm.CFG.DominatorsGHC.CmmToAsm.AArch64.CondGHC.Cmm.Dataflow.CollectionsGHC.Cmm.Dataflow.BlockGHC.Settings.ConfigGHC.Settings.ConstantsGHC.SysTools.ArGHC.SysTools.TerminalGHC.Types.HpcInfoGHC.Utils.CliOptionGHC.Utils.ConstantsGHC.Utils.GlobalVarsGHC.Utils.IO.UnsafeGHC.Utils.Monad.State.LazyGHC.Utils.Monad.State.StrictGHC.Utils.Panic.PlainGHC.Data.FastStringGHC.Utils.LexemeGHC.Utils.BufHandleGHC.Data.StringBuffer GHC.Utils.PprGHC.Utils.Ppr.ColourGHC.Driver.HooksGHC.Tc.Types.OriginGHC.Core.Opt.CallerCCGHC.Core.UnfoldGHC.Builtin.PrimOpsGHC.Iface.TypeGHC.Types.Name.OccurrenceGHC.Unit.Module.NameGHC.Utils.OutputableGHC.Unit.TypesGHC.Types.Id.Info!Language.Haskell.Syntax.ExtensionLanguage.Haskell.Syntax.ExprLanguage.Haskell.Syntax.PatGHC.Types.UniqueGHC.Types.Name GHC.Types.Var GHC.Types.IdGHC.Core.TyConGHC.Types.TyThingGHC.Core.Coercion GHC.Core.TypeGHC.Core.TyCo.RepGHC.Builtin.Types.PrimGHC.Tc.Utils.TcTypeGHC.Core.TyCo.PprGHC.Types.Unique.FMGHC.Types.Unique.SupplyGHC.Utils.PanicGHC.CmmToAsm.CFG.WeightGHC.Utils.JsonGHC.Types.SrcLocGHC.Utils.BinaryGHC.Data.EnumSetGHC.Utils.Binary.TypeableGHC.Iface.Ext.FieldsGHC.Types.Unique.DFMGHC.Data.FastString.EnvGHC.Types.CostCentre.StateGHC.Types.Unique.SetGHC.Types.Unique.DSetGHC.Unit.Module.LocationGHC.Unit.Module.Env GHC.Unit.HomeGHC.Types.SourceFileGHC.Unit.ParserGHC.Unit.ModuleGHC.Types.BreakInfoGHC.Types.SourceTextGHC.Types.ForeignCallGHC.Builtin.UniquesGHC.Cmm.CLabel GHC.SettingsGHC.Driver.BackendGHC.Linker.Static.UtilsGHC.Types.FieldLabelGHC.Core.DataConGHC.Builtin.TypesGHC.Types.Var.Set GHC.Utils.FVGHC.Types.CostCentreGHC.Types.Name.EnvGHC.Iface.Recomp.BinaryGHC.Types.Var.Env GHC.Data.PairGHC.Core.Coercion.AxiomGHC.Data.OrdListGHC.Types.Name.SetGHC.Data.List.SetOpsGHC.Types.Avail GHC.Data.BagGHC.Types.Name.ReaderGHC.Builtin.NamesGHC.Types.ForeignStubsGHC.Types.Fixity GHC.Cmm.TypeGHC.Driver.FlagsGHC.Platform.WaysGHC.Platform.ProfileGHC.Runtime.Heap.LayoutGHC.Types.AnnotationsGHC.Stg.InferTags.TagSigGHC.Hs.DocStringGHC.Parser.AnnotationGHC.Data.BooleanFormulaGHC.Core.ClassGHC.Types.Id.MakeGHC.CoreToIfaceGHC.Core.MultiplicityGHC.Core.TyCo.SubstGHC.Core.TyCo.TidyLanguage.Haskell.Syntax.LitGHC.Types.TickishGHC.Types.LiteralGHC.Data.TrieMapGHC.Cmm.Dataflow.LabelGHC.Cmm.BlockIdGHC.Cmm.Dataflow.GraphGHC.Core.TyCon.EnvGHC.Core.PatSynGHC.Core.UtilsGHC.Core.TyCon.RecWalkGHC.Core.PredicateGHC.Core.ReductionGHC.Core.Map.TypeGHC.Core.RoughMapGHC.Core.UnifyGHC.Types.DemandGHC.Types.RepType GHC.Types.CprGHC.StgToCmm.TypesGHC.CoreGHC.Core.SimpleOptGHC.Data.Graph.UnVarGHC.Core.Map.Expr GHC.Core.SeqGHC.Core.FamInstEnvGHC.Driver.PhasesGHC.Types.SafeHaskellGHC.Unit.Module.ImportedGHC.Hs.ExtensionGHC.Types.Unique.Map GHC.Hs.DocLanguage.Haskell.Syntax.TypeGHC.Unit.Module.Warnings GHC.Unit.PprGHC.Types.PkgQualGHC.Types.Fixity.EnvGHC.Core.ConLikeGHC.Runtime.Eval.TypesGHC.Core.Opt.ConstantFoldGHC.Iface.Syntax GHC.Core.FVsGHC.Builtin.PrimOps.IdsGHC.Types.CompleteMatchGHC.Types.TypeEnvGHC.Cmm.MachOpLanguage.Haskell.Syntax.BindsLanguage.Haskell.Syntax.DeclsGHC.Tc.Types.RankGHC.Parser.Errors.BasicGHC.Types.HintGHC.Types.ErrorGHC.Utils.LoggerGHC.Utils.ErrorGHC.Utils.TmpFsGHC.StgToCmm.ConfigGHC.Driver.Pipeline.MonadGHC.Driver.CmdLineGHC.Types.Unique.SDFMGHC.Types.Name.CacheGHC.Driver.Env.KnotVarsGHC.Platform.Reg.ClassGHC.Platform.RegGHC.Cmm.SwitchGHC.Core.UsageEnvGHC.Core.Stats GHC.Core.Ppr GHC.Hs.Pat GHC.Hs.Expr GHC.Hs.Lit GHC.Cmm.ExprGHC.ByteCode.TypesGHC.Platform.X86_64GHC.Platform.X86GHC.Platform.S390XGHC.Platform.RISCV64GHC.Platform.PPCGHC.Platform.NoRegsGHC.Platform.ARMGHC.Platform.AArch64GHC.Platform.Regs GHC.Cmm.Node GHC.Types.IPEGHC.CmmGHC.Driver.Session GHC.Tc.TypesGHC.Tc.Errors.Hole.FitTypesGHC.Core.InstEnvGHC.Unit.Module.ModDetailsGHC.Unit.StateGHC.Unit.Module.DepsGHC.Linker.TypesGHC.Runtime.Interpreter.TypesGHC.Types.TargetGHC.Unit.Finder.TypesGHC.Driver.PprGHC.Driver.Config.LoggerGHC.Driver.Config.DiagnosticGHC.Core.Opt.MonadGHC.Core.SubstGHC.Core.Opt.ArityGHC.Core.Opt.OccurAnalGHC.Core.Unfold.Make GHC.Core.TidyGHC.Tc.Types.Evidence GHC.Hs.Type GHC.Hs.Binds GHC.Hs.DeclsGHC.Stg.Syntax GHC.Hs.Utils GHC.Core.MakeGHC.Types.Hint.PprGHC.Parser.TypesGHC.Core.Coercion.OptGHC.Core.Rules GHC.Hs.ImpExpGHC.Hs.InstancesGHC.HsGHC.Unit.Module.ModGutsGHC.Tc.Types.ConstraintGHC.Tc.Solver.TypesGHC.Tc.Solver.InertSetGHC.HsToCore.Pmc.Solver.TypesGHC.HsToCore.Pmc.TypesGHC.HsToCore.Pmc.PprGHC.Tc.Errors.TypesGHC.Unit.Module.ModSummaryGHC.Unit.Module.GraphGHC.Unit.Module.ModIfaceGHC.Unit.Home.ModInfoGHC.Unit.Module.StatusGHC.Unit.External GHC.Unit.EnvGHC.Types.Name.PprGHC.Types.MetaGHC.Parser.Errors.TypesGHC.Parser.Errors.PprGHC.HsToCore.Errors.TypesGHC.Driver.Errors.TypesGHC.Runtime.ContextGHC.Driver.Env.TypesGHC.Tc.Errors.PprGHC.HsToCore.Errors.PprGHC.Driver.Errors.PprGHC.Types.SourceErrorGHC.Driver.ErrorsGHC.Driver.EnvGHC.Driver.Monad GHC.Core.LintGHC.Driver.Pipeline.PhasesGHC.Driver.Config.HsToCoreGHC.Parser.CharClassGHC.CmmToAsm.PPC.CondGHC.Types.Unique.MemoFunGHC.Data.Graph.Base GHC.CmmToAsm.Reg.Linear.StackMapGHC.CmmToAsm.Reg.Graph.BaseGHC.CmmToAsm.Reg.Graph.X86GHC.CmmToAsm.Reg.UtilsGHC.Data.Graph.PprGHC.Data.Graph.OpsGHC.Data.Graph.Color GHC.Hs.Stats GHC.Utils.AsmGHC.Settings.IOGHC.CmmToLlvm.Mangler$GHC.CmmToAsm.Reg.Graph.TrivColorableGHC.CmmToAsm.ConfigGHC.CmmToAsm.CPrimGHC.Stg.Lift.ConfigGHC.Driver.Config.Stg.LiftGHC.Data.BitmapGHC.Cmm.ConfigGHC.Driver.Config.CmmGHC.Iface.Recomp.Flags GHC.Stg.Subst GHC.Hs.DumpGHC.Core.TyCon.SetGHC.Driver.Config.StgToCmmGHC.Driver.Config.FinderGHC.SysTools.ProcessGHC.SysTools.InfoGHC.SysTools.ElfGHC.Driver.Pipeline.LogQueue GHC.Stg.Utils GHC.Stg.StatsGHC.Stg.InferTags.TypesGHC.Stg.InferTags.RewriteGHC.Stg.InferTags GHC.Stg.FVs GHC.Stg.DebugGHC.Driver.Config.Stg.DebugGHC.Driver.Config.Stg.Ppr GHC.Stg.CSEGHC.Builtin.Names.THGHC.Stg.BcPrepGHC.Tc.Instance.FunDepsGHC.Parser.LexerGHC.Parser.PostProcess GHC.ThToHsGHC.Parser.HaddockLexGHC.Driver.Config.ParserGHC.HsToCore.DocsGHC.Stg.Lift.MonadGHC.Hs.Syn.Type GHC.CoreToStgGHC.Core.Opt.LiberateCaseGHC.Core.Opt.StaticArgsGHC.Tc.Types.EvTermGHC.Stg.UnariseGHC.Core.Opt.SetLevelsGHC.Core.Opt.FloatInGHC.Core.Opt.ExitifyGHC.Core.Opt.CSEGHC.Builtin.Types.LiteralsGHC.HsToCore.TypesGHC.CmmToAsm.InstrGHC.Cmm.Ppr.ExprGHC.Cmm.LRegSetGHC.CmmToAsm.X86.RegsGHC.CmmToAsm.Reg.Linear.X86_64GHC.CmmToAsm.Reg.Linear.X86GHC.CmmToAsm.UtilsGHC.CmmToAsm.TypesGHC.CmmToAsm.PprGHC.Llvm.TypesGHC.Llvm.MetaDataGHC.Llvm.SyntaxGHC.CmmToAsm.FormatGHC.CmmToAsm.X86.RegInfoGHC.CmmToAsm.PPC.RegsGHC.CmmToAsm.Reg.Linear.PPCGHC.CmmToAsm.Dwarf.ConstantsGHC.CmmToAsm.AArch64.RegsGHC.CmmToAsm.Reg.TargetGHC.CmmToAsm.Reg.Linear.AArch64GHC.CmmToAsm.AArch64.InstrGHC.CmmToAsm.AArch64.RegInfoGHC.CmmToAsm.AArch64.Ppr GHC.Cmm.UtilsGHC.StgToCmm.CgUtilsGHC.Cmm.Switch.ImplementGHC.Cmm.Ppr.Decl GHC.Cmm.PprGHC.StgToCmm.SequelGHC.StgToCmm.ClosureGHC.StgToCmm.ArgRepGHC.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.OptGHC.Cmm.InitFini GHC.CmmToC GHC.Cmm.InfoGHC.CmmToAsm.PPC.InstrGHC.CmmToAsm.PPC.RegInfoGHC.CmmToAsm.PPC.PprGHC.Cmm.DebugBlockGHC.CmmToAsm.X86.InstrGHC.CmmToAsm.X86.Ppr GHC.CmmToAsm.Reg.Linear.FreeRegs%GHC.CmmToAsm.Reg.Linear.JoinToTargetsGHC.CmmToAsm.Reg.LinearGHC.CmmToAsm.MonadGHC.CmmToAsm.PICGHC.CmmToAsm.X86.CodeGenGHC.CmmToAsm.X86GHC.CmmToAsm.PPC.CodeGenGHC.CmmToAsm.PPCGHC.CmmToAsm.BlockLayoutGHC.Driver.Config.CmmToAsmGHC.CmmToAsm.Dwarf.TypesGHC.CmmToAsm.DwarfGHC.CmmToAsm.AArch64.CodeGenGHC.CmmToAsm.AArch64GHC.Cmm.DataflowGHC.Cmm.Liveness GHC.Cmm.SinkGHC.Cmm.ProcPoint GHC.Cmm.LintGHC.Cmm.ContFlowOptGHC.Cmm.CommonBlockElimGHC.Cmm.CallConv GHC.Cmm.GraphGHC.StgToCmm.MonadGHC.StgToCmm.ExtCodeGHC.StgToCmm.EnvGHC.StgToCmm.LitGHC.StgToCmm.UtilsGHC.StgToCmm.TagCheckGHC.StgToCmm.HpcGHC.StgToCmm.InfoTableProvGHC.Iface.Tidy.StaticPtrTableGHC.Unit.FinderGHC.HsToCore.CoverageGHC.Driver.ConfigGHC.Core.Opt.WorkWrap.UtilsGHC.Core.Opt.WorkWrapGHC.Core.Opt.CprAnalGHC.Core.Opt.Simplify.MonadGHC.Core.Opt.Simplify.EnvGHC.ByteCode.LinkerGHC.Linker.UnitGHC.Iface.ErrorsGHC.HsToCore.UsageGHC.Core.Opt.SpecialiseGHC.Core.Opt.Simplify.UtilsGHC.Builtin.UtilsGHC.Iface.Ext.TypesGHC.Iface.Ext.UtilsGHC.Iface.Ext.DebugGHC.Core.Opt.SimplifyGHC.Core.Opt.FloatOutGHC.Core.Opt.DmdAnalGHC.Core.Opt.CallArityGHC.CmmToLlvm.Config GHC.Llvm.PprGHC.CmmToLlvm.RegsGHC.CmmToLlvm.BaseGHC.SysTools.TasksGHC.Linker.MacOSGHC.Linker.ExtraObjGHC.Linker.WindowsGHC.Linker.DynamicGHC.Linker.StaticGHC.Driver.Config.CmmToLlvmGHC.CmmToLlvm.DataGHC.CmmToLlvm.PprGHC.CmmToLlvm.CodeGen GHC.CmmToLlvm GHC.CmmToAsmGHC.Driver.CodeOutputGHC.StgToCmm.ProfGHC.StgToCmm.ForeignGHC.StgToCmm.TickyGHC.StgToCmm.LayoutGHC.Stg.Lift.Analysis GHC.Stg.LiftGHC.ByteCode.InstrGHC.ByteCode.InfoTableGHC.StgToByteCodeGHC.StgToCmm.HeapGHC.StgToCmm.DataConGHC.Cmm.Info.BuildGHC.StgToCmm.PrimGHC.Cmm.LayoutStackGHC.StgToCmm.BindGHC.StgToCmm.Expr GHC.StgToCmmGHC.Cmm.Parser.Monad GHC.Cmm.LexerGHC.Cmm.ParserGHC.Core.LateCC GHC.Stg.LintGHC.Stg.PipelineGHC.Driver.Config.Stg.PipelineGHC.Cmm.PipelineGHC.Driver.GenerateCgIPEStubGHC.Core.Opt.PipelineGHC.Driver.Backpack.Syntax GHC.ParserGHC.Parser.PostProcess.HaddockGHC.Parser.UtilsGHC.Parser.Header GHC.Tc.ModuleGHC.Tc.Gen.MatchGHC.Rename.ExprGHC.Tc.Errors.HoleGHC.Tc.Gen.SpliceGHC.IfaceToCoreGHC.Tc.Gen.ExprGHC.Tc.Utils.UnifyGHC.Tc.Utils.EnvGHC.Tc.Utils.MonadGHC.Iface.Load GHC.Iface.EnvGHC.Rename.SpliceGHC.Tc.Utils.TcMTypeGHC.Tc.Utils.ConcreteGHC.Tc.TyCl.BuildGHC.Types.Name.ShapeGHC.Iface.RenameGHC.Iface.BinaryGHC.Iface.Ext.BinaryGHC.Rename.UnboundGHC.Rename.FixityGHC.Tc.Gen.AnnotationGHC.HsToCore.ExprGHC.HsToCore.MatchGHC.HsToCore.BindsGHC.HsToCore.UtilsGHC.HsToCore.Pmc.UtilsGHC.HsToCore.GuardedRHSsGHC.HsToCore.Foreign.CallGHC.Iface.RecompGHC.Iface.MakeGHC.Types.TyThing.PprGHC.Iface.Ext.AstGHC.Linker.LoaderGHC.Tc.Utils.ZonkGHC.HsToCore.Match.LiteralGHC.HsToCore.Pmc.DesugarGHC.Tc.Utils.InstantiateGHC.Tc.Instance.FamilyGHC.Tc.Instance.TypeableGHC.Rename.UtilsGHC.Rename.EnvGHC.Tc.Instance.ClassGHC.Tc.Solver.MonadGHC.Tc.Solver.RewriteGHC.Tc.Solver.CanonicalGHC.Tc.Solver.InteractGHC.Rename.DocGHC.Rename.HsTypeGHC.Rename.Pat GHC.Tc.Errors GHC.Tc.SolverGHC.HsToCore.Pmc.SolverGHC.HsToCore.Pmc.CheckGHC.HsToCore.PmcGHC.HsToCore.Match.ConstructorGHC.HsToCore.ListCompGHC.HsToCore.QuoteGHC.HsToCore.ArrowsGHC.Tc.ValidityGHC.Tc.Gen.HsTypeGHC.Rename.NamesGHC.Rename.BindGHC.Rename.ModuleGHC.Runtime.LoaderGHC.Tc.Gen.SigGHC.Tc.TyCl.PatSynGHC.Tc.Gen.PatGHC.Tc.Gen.BindGHC.Tc.TyCl.UtilsGHC.Tc.Gen.HeadGHC.Tc.Gen.AppGHC.Tc.Gen.ArrowGHC.Tc.Gen.ExportGHC.Tc.Utils.BackpackGHC.Tc.TyCl.ClassGHC.Tc.Deriv.GenerateGHC.Tc.Deriv.FunctorGHC.Tc.Deriv.GenericsGHC.Tc.Deriv.UtilsGHC.Tc.Deriv.Infer GHC.Tc.DerivGHC.Tc.TyCl.Instance GHC.Tc.TyClGHC.Tc.Gen.RuleGHC.Tc.Gen.ForeignGHC.Tc.Gen.DefaultGHC.Iface.TidyGHC.HsToCore.Foreign.Decl GHC.HsToCoreGHC.Driver.Config.TidyGHC.CoreToStg.PrepGHC.Driver.Main GHC.PluginsGHC.Runtime.Heap.Inspect GHC.Tc.PluginGHC.Runtime.EvalGHC.Driver.PipelineGHC.Driver.Pipeline.ExecuteGHC.Driver.MakeGHC.Runtime.DebuggerGHC.Driver.MakeFileGHC.Driver.Backpack GHC.Linker GhcExceptionSDoc Data.ListunconsheadtailnullpprWithUnitState cc_flavour AnnKeywordIdAnnOpen AnnHeaderAnnValAnnCloseputIfaceTopBndrgetIfaceTopBndrAnnDeclAnnType AnnBackquoteAnnTildeMxexports_from_availfunTyCon mkTyConTyCoreMapAnnComma ModBreaksIdHsExprRdrNamesUniqueRdrName mkCoreApps mkCoreConApps mkIntExpr mkWordExpr mkCharExpr mkStringExpr mkFloatExpr mkDoubleExpr mkCoreLams mkCoreLetsSubst NoExtField SourceNoteCoreSyn mkCoreLetsubstTy Data.KindTypeDriverUnexpectedSignature PsWarnTabPsWarnOperatorWhitespaceDsMaxPmCheckModelsReachedDataKindPsWarnStarIsTypePsWarnImportPreQualifiedPsErrEmptyDoubleQuotesPsErrIllegalRoleNamePsWarnStarBinderPsErrInvalidTypeSignatureTcRnOrphanInstanceDerivBadErrConstructorTcRnForallIdentifierTcRnIncorrectNameSpaceTcRnTypeCannotBeMarshaled GHC.UtilsErrorConfigFloatOutSwitches setDumpPrefixrunGhcData.MapStrictGHC.UnittypeLevity_maybeGHC.STGDebug idPrimRepliftedIdsExpanderGHC.ExtsoneShotGHC.LlvmHsImpExpIE AnnotationAnnBangAnnEqualAnnAt AnnRarrow AnnDcolon AnnPattern AnnForallAnnDot AnnDarrow AnnDefaultAnnInfix AnnInstanceAnnVbarAnnSemi AnnLarrowAnnWhere tcMonoBindsAnnFunIdAnnRole AnnModule AnnForeign AnnImport AnnExport AnnDerivingAnnStock AnnAnyClass AnnNewtypeAnnData AnnNewType AnnDotdotAnnCLose AnnFamilyAnnOpenP AnnClosePAnnClassLanguage.Haskell.TH.SyntaxaddModFinalizerAnnThenAnnByAnnGroupAnnUsingAnnLetAnnRec Annlarrowtail Annrarrowtail AnnLarrowtail AnnRarrowtailAnnOpenB AnnCloseBAnnLamAnnCaseAnnOfAnnCasesAnnIfAnnElseAnnInAnnDoAnnColonAnnMinusAnnOpenE AnnOpenEQ AnnCloseQAnnProc AnnStaticLanguage.Haskell.SyntaxcvBindsAndSigsBitsshiftRtopSortModuleGraphload HscNoRecomp GHC.Tc.Utils imp_dep_modsInertSet ConPatOut mkErrorReportcheckTypeHasFixedRuntimeRepMonadexpandTypeSynonymsHeader GHC.DriverMakeSessiontcg_type_env_varTcGblEnv initGhcMonadcheckClosedInStaticFormdecideGeneralisationPlaninitializePlugins newFamInstControl.Monad.STSTrunSTcheckConsistentFamInstinferConstraints simplifyInfer singleton GHC.Types addExternal rnImportDeclDynFlagsbackend SourceErrorbaseGHC.Base++ghc-primGHC.PrimseqGHC.Listfilterzip System.IOprint 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 FractionalIntegralFunctorNumOrdGHC.ReadReadReal RealFloatRealFracGHC.ShowShowMonadFix MonadFail Applicative Data.FoldableFoldableData.Traversable Traversable SemigroupMonoidBoolStringCharDoubleFloatInt ghc-bignumGHC.Num.IntegerInteger GHC.MaybeMaybeOrderingRational~IOWord Data.EitherEitherPluginFrontendPluginFalseNothingJustTrueLeftRightLTEQGTGHC.Fingerprint.Type Fingerprintcompare<<=>maxmin/=&&||notGHC.Stack.Types HasCallStackGHC.Exception.Type SomeExceptionGHC.ErrerrorerrorWithoutStackTrace undefinedliftA2<*<$=<<idconst.flip$!untilasTypeOf Data.VersionVersion+*abssignumsubtract Data.Maybemaybelastinitfoldl1'scanlscanl1scanrscanr1iteraterepeat replicatecycle takeWhile dropWhiletakedropsplitAtspanbreakreverselookup!!zip3zipWithzipWith3unzipunzip3 showsPrecshowshowListShowSshowsshowChar showString showParensuccpredtoEnumfromEnumminBoundmaxBoundproperFractiontruncateroundceilingfloor/recipquotremdivmodquotRemdivModevenodd^^^gcdlcmText.ParserCombinators.ReadPReadSGHC.Bits FiniteBits finiteBitSizecountLeadingZeroscountTrailingZeros.&..|.xor complementshiftrotatezeroBitsbitsetBitclearBit complementBittestBit bitSizeMaybebitSizeisSigned unsafeShiftL unsafeShiftRrotateLrotateRpopCount bitDefaulttestBitDefaultpopCountDefaulttoIntegralSized floatRadix floatDigits floatRange decodeFloat encodeFloatexponent significand scaleFloatisNaN isInfiniteisDenormalizedisNegativeZeroisIEEEatan2piexplogsqrt**logBasesincostanasinacosatansinhcoshtanhasinhacoshatanh readsPrecreadList readParenlexeither Text.ReadreadsreadGHC.FingerprintfingerprintStringfingerprintFingerprintsData.Semigroup.InternalEndoappEndofoldMapfoldrfoldlfoldl'foldr1foldl1lengthelemmaximumminimumsumproductfoldrMfoldlMmapM_ sequence_concat concatMapandoranyallnotElem Data.Tuplefstsndcurryuncurry Data.OldListlinesunlineswordsunwordsArithExceptionOverflow UnderflowLossOfPrecision DivideByZeroDenormalRatioZeroDenominator Exception toException fromExceptiondisplayException GHC.Exception ErrorCallErrorCallWithLocationthrowGHC.IO.ExceptionIOError IOException userErrorGHC.IO MaskingStateUnmaskedMaskedInterruptibleMaskedUninterruptibleFilePathcatchthrowIO interruptiblegetMaskingStatemask_maskuninterruptibleMask_uninterruptibleMaskevaluate GHC.IORefIORefArrayExceptionIndexOutOfBoundsUndefinedElementAsyncException StackOverflow HeapOverflow ThreadKilled UserInterruptSomeAsyncExceptionAssertionFailedCompactionFailedAllocationLimitExceededDeadlockBlockedIndefinitelyOnSTMBlockedIndefinitelyOnMVarasyncExceptionToExceptionasyncExceptionFromExceptionioError Data.Functor<$> GHC.Conc.SyncthrowToControl.Exception.BaseNestedAtomicallyNonTermination TypeError NoMethodError RecUpdError RecConError RecSelErrorPatternMatchFail catchJusthandle handleJust mapExceptiontrytryJust onExceptionbracketfinallybracket_bracketOnErrorControl.ExceptionHandlercatchesallowInterruptputCharputStrputStrLngetChargetLine getContentsinteractreadFile writeFile appendFilereadLnreadIO fingerprint0fingerprintData getFileHashtraverse sequenceAmapMsequence versionBranch versionTags Control.Monad mapAndUnzipM GHC.ByteOrder ByteOrder BigEndian LittleEndianControl.Monad.IO.ClassMonadIOliftIO Data.Data mkNoRepTypeSpecConstrAnnotation NoSpecConstrForceSpecConstrsortWithcontainers-0.6.6 Data.GraphSCC AcyclicSCC CyclicSCC flattenSCCs flattenSCCdirectory-1.3.7.1System.DirectorycopyFiletransformers-0.5.6.2Control.Monad.Trans.MaybeMaybeTghc-boot-9.4.3 GHC.BaseDir expandTopDirGHC.Data.SizedSeqSizedSeqssEltssizeSSGHC.Platform.ArchOSOS OSUnknownOSLinuxOSDarwin OSSolaris2 OSMinGW32 OSFreeBSD OSDragonFly OSOpenBSDOSNetBSD OSKFreeBSDOSHaikuOSQNXNTOOSAIXOSHurd PPC_64ABIELF_V1ELF_V2ArmABISOFTSOFTFPHARD ArmISAExtVFPv2VFPv3VFPv3D16NEONIWMMX2ArmISAARMv5ARMv6ARMv7Arch ArchUnknownArchX86 ArchX86_64ArchPPC ArchPPC_64 ArchS390XArchARM ArchAArch64 ArchAlpha ArchMipseb ArchMipsel ArchRISCV64ArchJavaScriptArchOS archOS_arch archOS_OSGHC.Unit.DatabaseGenericUnitInfounitIdunitInstanceOfunitInstantiations unitPackageIdunitPackageNameunitPackageVersionunitComponentName unitAbiHash unitDependsunitAbiDependsunitImportDirs unitLibrariesunitExtDepLibsSysunitExtDepLibsGhcunitLibraryDirsunitLibraryDynDirsunitExtDepFrameworksunitExtDepFrameworkDirsunitLinkerOptions unitCcOptions unitIncludesunitIncludeDirsunitHaddockInterfacesunitHaddockHTMLsunitExposedModulesunitHiddenModulesunitIsIndefinite unitIsExposed unitIsTrustedghc-boot-th-9.4.3GHC.ForeignSrcLang.TypeForeignSrcLang RawObjectLangAsm LangObjcxxLangObjcLangCLangCxx ghci-9.4.3GHCi.RemoteTypes ForeignHValueHValue GHCi.Message EvalResult EvalException EvalSuccess EvalStatus_ EvalComplete EvalBreak EvalStatusEvalExprEvalThisEvalAppMessageShutdown RtsRevertCAFs InitLinker LookupSymbol LookupClosureLoadDLL LoadArchiveLoadObj UnloadObjAddLibrarySearchPathRemoveLibrarySearchPath ResolveObjsFindSystemLibrary CreateBCOsFreeHValueRefs AddSptEntry MallocData MallocStringsPrepFFIFreeFFIMkConInfoTableEvalStmt ResumeStmt AbandonStmt EvalStringEvalStringToStringEvalIO MkCostCentresCostCentreStackInfo NewBreakArraySetupBreakpointBreakpointStatusGetBreakpointVarStartTHRunTHRunModFinalizers GetClosureSeq ResumeSeq runMaybeTPlatformConstantspc_CONTROL_GROUP_CONST_291pc_STD_HDR_SIZEpc_PROF_HDR_SIZE pc_BLOCK_SIZEpc_BLOCKS_PER_MBLOCKpc_TICKY_BIN_COUNTpc_OFFSET_StgRegTable_rR1pc_OFFSET_StgRegTable_rR2pc_OFFSET_StgRegTable_rR3pc_OFFSET_StgRegTable_rR4pc_OFFSET_StgRegTable_rR5pc_OFFSET_StgRegTable_rR6pc_OFFSET_StgRegTable_rR7pc_OFFSET_StgRegTable_rR8pc_OFFSET_StgRegTable_rR9pc_OFFSET_StgRegTable_rR10pc_OFFSET_StgRegTable_rF1pc_OFFSET_StgRegTable_rF2pc_OFFSET_StgRegTable_rF3pc_OFFSET_StgRegTable_rF4pc_OFFSET_StgRegTable_rF5pc_OFFSET_StgRegTable_rF6pc_OFFSET_StgRegTable_rD1pc_OFFSET_StgRegTable_rD2pc_OFFSET_StgRegTable_rD3pc_OFFSET_StgRegTable_rD4pc_OFFSET_StgRegTable_rD5pc_OFFSET_StgRegTable_rD6pc_OFFSET_StgRegTable_rXMM1pc_OFFSET_StgRegTable_rXMM2pc_OFFSET_StgRegTable_rXMM3pc_OFFSET_StgRegTable_rXMM4pc_OFFSET_StgRegTable_rXMM5pc_OFFSET_StgRegTable_rXMM6pc_OFFSET_StgRegTable_rYMM1pc_OFFSET_StgRegTable_rYMM2pc_OFFSET_StgRegTable_rYMM3pc_OFFSET_StgRegTable_rYMM4pc_OFFSET_StgRegTable_rYMM5pc_OFFSET_StgRegTable_rYMM6pc_OFFSET_StgRegTable_rZMM1pc_OFFSET_StgRegTable_rZMM2pc_OFFSET_StgRegTable_rZMM3pc_OFFSET_StgRegTable_rZMM4pc_OFFSET_StgRegTable_rZMM5pc_OFFSET_StgRegTable_rZMM6pc_OFFSET_StgRegTable_rL1pc_OFFSET_StgRegTable_rSppc_OFFSET_StgRegTable_rSpLimpc_OFFSET_StgRegTable_rHppc_OFFSET_StgRegTable_rHpLimpc_OFFSET_StgRegTable_rCCCS!pc_OFFSET_StgRegTable_rCurrentTSO%pc_OFFSET_StgRegTable_rCurrentNurserypc_OFFSET_StgRegTable_rHpAllocpc_OFFSET_stgEagerBlackholeInfopc_OFFSET_stgGCEnter1pc_OFFSET_stgGCFunpc_OFFSET_Capability_rpc_OFFSET_bdescr_startpc_OFFSET_bdescr_freepc_OFFSET_bdescr_blockspc_OFFSET_bdescr_flagspc_SIZEOF_CostCentreStack#pc_OFFSET_CostCentreStack_mem_alloc pc_REP_CostCentreStack_mem_alloc#pc_OFFSET_CostCentreStack_scc_count pc_REP_CostCentreStack_scc_countpc_OFFSET_StgHeader_ccspc_OFFSET_StgHeader_ldvwpc_SIZEOF_StgSMPThunkHeaderpc_OFFSET_StgEntCounter_allocspc_REP_StgEntCounter_allocspc_OFFSET_StgEntCounter_allocdpc_REP_StgEntCounter_allocd#pc_OFFSET_StgEntCounter_registeredppc_OFFSET_StgEntCounter_link#pc_OFFSET_StgEntCounter_entry_countpc_SIZEOF_StgUpdateFrame_NoHdrpc_SIZEOF_StgMutArrPtrs_NoHdrpc_OFFSET_StgMutArrPtrs_ptrspc_OFFSET_StgMutArrPtrs_size"pc_SIZEOF_StgSmallMutArrPtrs_NoHdr!pc_OFFSET_StgSmallMutArrPtrs_ptrspc_SIZEOF_StgArrBytes_NoHdrpc_OFFSET_StgArrBytes_bytespc_OFFSET_StgTSO_alloc_limitpc_OFFSET_StgTSO_cccspc_OFFSET_StgTSO_stackobjpc_OFFSET_StgStack_sppc_OFFSET_StgStack_stack pc_OFFSET_StgUpdateFrame_updatee"pc_OFFSET_StgFunInfoExtraFwd_aritypc_REP_StgFunInfoExtraFwd_aritypc_SIZEOF_StgFunInfoExtraRev"pc_OFFSET_StgFunInfoExtraRev_aritypc_REP_StgFunInfoExtraRev_aritypc_MAX_SPEC_SELECTEE_SIZEpc_MAX_SPEC_AP_SIZEpc_MIN_PAYLOAD_SIZEpc_MIN_INTLIKEpc_MAX_INTLIKEpc_MIN_CHARLIKEpc_MAX_CHARLIKEpc_MUT_ARR_PTRS_CARD_BITSpc_MAX_Vanilla_REGpc_MAX_Float_REGpc_MAX_Double_REGpc_MAX_Long_REGpc_MAX_XMM_REGpc_MAX_Real_Vanilla_REGpc_MAX_Real_Float_REGpc_MAX_Real_Double_REGpc_MAX_Real_XMM_REGpc_MAX_Real_Long_REGpc_RESERVED_C_STACK_BYTESpc_RESERVED_STACK_WORDSpc_AP_STACK_SPLIM pc_WORD_SIZE pc_CINT_SIZE pc_CLONG_SIZEpc_CLONG_LONG_SIZEpc_BITMAP_BITS_SHIFT pc_TAG_BITS pc_LDV_SHIFTpc_ILDV_CREATE_MASKpc_ILDV_STATE_CREATEpc_ILDV_STATE_USEpc_USE_INLINE_SRT_FIELDparseConstantsHeader$fShowPlatformConstants$fReadPlatformConstants$fEqPlatformConstants$fOrdPlatformConstantsshiftLLinkInfoPoint writePoint readPointfreshreprfindunion equivalent $fEqPointPairAnd fromMaybe$fAlternativeMaybe$fApplicativeMaybe $fMonoidMaybe$fSemigroupMaybe$fEqPair $fOrdPair $fShowPair $fFunctorPair$fFoldablePair$fTraversablePair $fDataPair $fEqMaybe $fOrdMaybe $fShowMaybe$fFunctorMaybe$fFoldableMaybe$fTraversableMaybe $fDataMaybeStreamSYieldDoneEffectStreamrunStreamInternal runStreamyieldcollectconsumefromList mapAccumL_$fMonadStreamS$fApplicativeStreamS$fFunctorStreamS$fMonadIOStream $fMonadStream$fApplicativeStream$fFunctorStreamSmallMutableArray SmallArray newSmallArraywriteSmallArrayfreezeSmallArrayunsafeFreezeSmallArrayindexSmallArray listToArray insertListinsertListWith deleteList foldRightfoldRightWithKey FastMutInt newFastMutIntreadFastMutIntwriteFastMutIntatomicFetchAddFastMutOverridingBoolAutoNeverAlways overrideWith$fShowOverridingBool$fReadOverridingBool$fEqOverridingBool$fOrdOverridingBool$fEnumOverridingBool$fBoundedOverridingBoolCondALWAYSEQQGEGEUGTTGULELEULTTLUNENEGPOSCARRYOFLOPARITY NOTPARITYcondToUnsigned maybeFlipCondmaybeInvertCond$fEqCondRootedGraphEdgePathNodedompdomdomTreepdomTreeidomipdompddfsrpddfsfromAdj fromEdgestoAdjtoEdgesparents ancestorsasGraphasTree$fApplicativeS$fMonadS $fFunctorSSLTSLESGESGTULTULEUGEUGTOLTOLEOGEOGTUOLTUOLEUOGEUOGTNEVERVSVC UniqueMap UniqueSetIsMapKeyOfmapNullmapSize mapMember mapLookupmapFindWithDefaultmapEmpty mapSingleton mapInsert mapInsertWith mapDeletemapAlter mapAdjustmapUnionmapUnionWithKey mapDifferencemapIntersection mapIsSubmapOfmapMap mapMapWithKeymapFoldlmapFoldrmapFoldlWithKeymapFoldMapWithKey mapFiltermapFilterWithKeymapElemsmapKeys mapToList mapFromListmapFromListWithIsSetElemOfsetNullsetSize setMembersetEmpty setSingleton setInsert setDeletesetUnion setDifferencesetIntersection setIsSubsetOf setFiltersetFoldlsetFoldrsetElems setFromList setInsertList setDeleteList setUnions mapInsertList mapDeleteList mapUnions$fIsSetUniqueSet$fIsMapUniqueMap $fEqUniqueMap$fOrdUniqueMap$fShowUniqueMap$fFunctorUniqueMap$fFoldableUniqueMap$fTraversableUniqueMap $fEqUniqueSet$fOrdUniqueSet$fShowUniqueSet$fSemigroupUniqueSet$fMonoidUniqueSetBlockBlockCOBlockCCBlockOCBNilBMiddleBCatBSnocBConsMaybeOJustONothingO IndexedCOCO ExtensibilityOpenClosed isEmptyBlock emptyBlock blockCons blockSnoc blockJoinHead blockJoinTail blockJoin blockAppend firstNodelastNodeblockSplitHeadblockSplitTail blockSplit blockToList blockFromListreplaceFirstNodereplaceLastNodemapBlock mapBlock' mapBlock3'foldBlockNodesFfoldBlockNodesB3foldBlockNodesB$fFunctorMaybeOcBuildPlatformStringcHostPlatformString cProjectNamecBooterVersioncStage hiVersionmAX_TUPLE_SIZEmAX_CTUPLE_SIZE mAX_SUM_SIZEmAX_REDUCTION_DEPTHmAX_SOLVER_ITERATIONS wORD64_SIZE fLOAT_SIZE dOUBLE_SIZEtARGET_MAX_CHARArchive ArchiveEntryfilenamefiletimefileownfilegrpfilemodefilesizefiledataafilter isBSDSymdef isGNUSymdefparseAr writeBSDAr writeGNUArloadArloadObj $fEqArchive $fShowArchive$fSemigroupArchive$fMonoidArchive$fEqArchiveEntry$fShowArchiveEntrystderrSupportsAnsiColors AnyHpcUsageHpcInfo NoHpcInfohpcInfoTickCount hpcInfoHashhpcUsed emptyHpcInfo isHpcUsedOption FileOptionshowOpt $fEqOption ghciSupported debugIsOn isWindowsHost isDarwinHostExceptionMonadcatchIOhandleIOtryIOreadHexFingerprintfingerprintByteStringv_unsafeHasPprDebugv_unsafeHasNoDebugOutputv_unsafeHasNoStateHackunsafeHasPprDebugunsafeHasNoDebugOutputunsafeHasNoStateHackglobal consIORefglobalM sharedGlobal sharedGlobalMinlinePerformIO zipWith3M zipWith3M_ zipWith4MzipWithAndUnzipM mapAndUnzip3M mapAndUnzip4M mapAndUnzip5M mapAccumLMmapSndMliftFstMliftSndM concatMapM mapMaybeM fmapMaybeM fmapEitherManyMallMorMfoldlM_ maybeMapMwhenMunlessM filterOutMStatestategetgetsputmodify evalState execStaterunState $fMonadState$fApplicativeState$fFunctorStatePlainGhcException PlainSignalPlainUsageErrorPlainCmdLineError PlainPanic PlainSorryPlainInstallationErrorPlainProgramErrorshowPlainGhcExceptionpanicsorrypgmError cmdLineErrorcmdLineErrorIO assertPanicassertmassertassertM$fShowPlainGhcException$fExceptionPlainGhcExceptionHasDebugCallStack DirectionForwards BackwardsSuffix applyWhennTimesconst2fstOf3sndOf3thdOf3fst3snd3third3uncurry3liftFstliftSndfirstMfirst3MsecondM filterOut partitionWith chkAppendzipEqual zipWithEqual zipWith3Equal zipWith4EqualzipLazy zipWithLazy zipWith3Lazy filterByList filterByListspartitionByListstretchZipWithmapFstmapSnd mapAndUnzip mapAndUnzip3zipWithAndUnzip zipAndUnzipatLength lengthExceeds lengthAtLeastlengthIs lengthIsNot lengthAtMostlengthLessThan listLengthCmp equalLength compareLengthleLengthltLength isSingletonnotNullonly expectOnly chunkList changeLastmapLastM mapAccumM whenNonEmpty mergeListsBy isSortedByminWithnubSortordNubordNubOntransitiveClosurefoldl2all2count countWhiletakeListdropList splitAtListdropTaildropWhileEndLEspanEndlast2 lastMaybeonJustsnocViewsplit capitaliseisEqualthenCmpeqListBy eqMaybeBycmpList removeSpaces<&&><||> fuzzyMatch fuzzyLookup unzipWithseqList strictMap strictZipWithstrictZipWith3looksLikeModuleNamelooksLikePackageName exactLog2 readRationalreadSignificandExponentPairreadHexRationalreadHexSignificandExponentPairdoesDirNameExistgetModificationUTCTimemodificationTimeIfExistsfileHashIfExistswithAtomicRenamesplitLongestPrefix escapeSpacesreslashmakeRelativeToabstractConstrabstractDataTypecharToC hashString mapMaybe'MaybeErr SucceededFailed firstJust firstJusts firstJustsM expectJust whenIsJustorElse rightToMaybe liftMaybeT tryMaybeT isSuccessfailME$fMonadMaybeErr$fApplicativeMaybeErr$fFunctorMaybeErr PtrStringLexicalFastStringNonDetFastString FastStringuniqn_charsfs_sbsfs_zenc FastZStringbytesFSfastStringToByteStringfastStringToShortByteStringfastZStringToByteStringunsafeMkByteStringhPutFZSzString lengthFZSlexicalCompareFS uniqCompareFS mkFastString#mkFastStringBytesmkFastStringByteStringmkFastStringShortByteString mkFastStringmkFastStringByteListlengthFSnullFSunpackFS zEncodeFSappendFSconcatFSheadFSconsFSunconsFS uniqueOfFSnilFSisUnderscoreFSgetFastStringTablegetFastStringZEncCounterhPutFS mkPtrString# mkPtrStringunpackPtrStringlengthPSfsLit$fNFDataFastString$fDataFastString$fShowFastString$fMonoidFastString$fSemigroupFastString$fIsStringFastString$fEqFastString$fOrdNonDetFastString$fOrdLexicalFastString$fEqLexicalFastString$fShowLexicalFastString$fDataLexicalFastString$fEqNonDetFastString$fShowNonDetFastString$fDataNonDetFastString$fNFDataFastZString GHC.Lexeme startsConId startsConSym startsVarId startsVarSymisLexConisLexVarisLexIdisLexSym isLexConId isLexVarId isLexConSym isLexVarSymokVarOccokConOccokTcOcc okVarIdOcc okVarSymOcc okConIdOcc okConSymOcc BufHandle newBufHandlebPutCharbPutStrbPutFSbPutFZS bPutPtrString bPutReplicatebFlush StringBufferbuflencurhGetStringBufferhGetStringBufferBlockhPutStringBufferappendStringBuffersstringToStringBufferstringBufferFromByteStringnextCharbidirectionalFormatCharscontainsBidirectionalFormatChar currentCharprevCharstepOn offsetBytesbyteDiffatEndfingerprintStringBufferatLinelexemeToStringlexemeToFastStringdecodePrevNCharsparseUnsignedInteger$fShowStringBufferModePageMode ZigZagModeLeftMode OneLineMode asciiSpaceStylemode lineLengthribbonsPerLine TextDetailsChrStrPStrZStrLStrRStrDocchartextftextptextztext sizedText zeroWidthText emptyTextemptyisEmptysemicommacolonspaceequalslparenrparenlbrackrbracklbracerbraceintintegerfloatdoublerationalhexquotesquote doubleQuotesparensbracketsbraces maybeParenshcathsepvcatnesthang hangNotEmpty punctuate$$$+$<><+>sepcatfcatfsepstyle renderStyle txtPrinter fullRenderprintDoc printDoc_ bufLeftRender $fShowDocSchemesHeadersMessagesWarningsErrorsFatalsMargin PprColour renderColourrenderColourAfresh colCustomcolResetcolBold colBlackFgcolRedFg colGreenFg colYellowFg colBlueFg colMagentaFg colCyanFg colWhiteFg defaultScheme parseScheme$fMonoidPprColour$fSemigroupPprColour StaticPlugin LoadedPluginPlugins emptyPlugins ContainsHooks extractHooksHasHooksgetHooksHooks emptyHooksFixedRuntimeRepOriginFixedRuntimeRepContext SkolemInfoSkolemInfoAnonunkSkolCallerCcFilterparseCallerCcFilter UnfoldingOptsupdateCaseScalingupdateCaseThresholdupdateVeryAggressiveupdateDictDiscountupdateFunAppDiscountupdateUseThresholdupdateCreationThresholddefaultUnfoldingOptsPrimOp IfaceBndr IfaceCoercion IfaceTyLit IfaceTyCon IfaceType IfaceAppArgs HasOccNameoccNameOccName mkVarOccFSmkRecFldSelOcc occNameString ModuleName SDocContextPprStyleUnitModuleGenUnit GenModuleUnitId pprModule moduleUnit moduleNameOutputableBndrpprBndr pprPrefixOcc pprInfixOccbndrIsJoin_maybe BindingSite LambdaBindCaseBind CasePatBindLetBindPDoc OutputablePpdoc OutputablepprSDC sdocStyle sdocColSchemesdocLastColoursdocShouldUseColorsdocDefaultDepthsdocLineLengthsdocCanUseUnicodesdocHexWordLiterals sdocPprDebugsdocPrintUnicodeSyntaxsdocPrintCaseAsLetsdocPrintTypecheckerElaborationsdocPrintAxiomIncompssdocPrintExplicitKindssdocPrintExplicitCoercionssdocPrintExplicitRuntimeRepssdocPrintExplicitForallssdocPrintPotentialInstancessdocPrintEqualityRelationssdocSuppressTickssdocSuppressTypeSignaturessdocSuppressTypeApplicationssdocSuppressIdInfosdocSuppressCoercionssdocSuppressUnfoldingssdocSuppressVarKindssdocSuppressUniquessdocSuppressModulePrefixessdocSuppressStgExtssdocErrorSpanssdocStarIsTypesdocLinearTypessdocImpredicativeTypessdocPrintTypeAbbreviationssdocUnitIdForUser QualifyName NameUnqualNameQualNameNotInScope1NameNotInScope2QueryQualifyPackageQueryQualifyModuleQueryQualifyNamePrintUnqualified QueryQualifyqueryQualifyNamequeryQualifyModulequeryQualifyPackageDepth AllTheWayPartWay DefaultDepth LabelStyleCStyleAsmStylePprUserPprDumpPprCodereallyAlwaysQualifyNamesalwaysQualifyNamesneverQualifyNamesalwaysQualifyModulesneverQualifyModulesalwaysQualifyPackagesneverQualifyPackagesreallyAlwaysQualify alwaysQualify neverQualifydefaultUserStyledefaultDumpStyle mkDumpStyledefaultErrStyle mkErrStylecmdlineParserStyle mkUserStyle withUserStyle withErrStylesetStyleColouredrunSDocdefaultSDocContext withPprStyle pprDeeper pprDeeperList pprSetDepth getPprStylesdocWithContext sdocOptionupdSDocContextqualName qualModule qualPackage queryQual codeStyleasmStyle dumpStyle userStyle getPprDebug ifPprDebug whenPprDebug printSDoc printSDocLnbufLeftRenderSDocpprCoderenderWithContextshowSDocOneLineshowSDocUnsafe showPprUnsafepprDebugAndThen docToSDocword doublePrec angleBracketscparen blankLinedcolonarrowlollipoplarrowdarrowarrowtlarrowtarrowttlarrowttlambda underscoredotvbarmulArrow forAllLitbullet unicodeSyntaxppWhenppUnless ppWhenOptionppUnlessOptioncolouredkeyword pprHsChar pprHsString pprHsBytesprimCharSuffixprimFloatSuffix primIntSuffixprimDoubleSuffixprimWordSuffixprimInt8SuffixprimWord8SuffixprimInt16SuffixprimWord16SuffixprimInt32SuffixprimWord32SuffixprimInt64SuffixprimWord64Suffix pprPrimChar pprPrimInt pprPrimWord pprPrimInt8 pprPrimInt16 pprPrimInt32 pprPrimInt64 pprPrimWord8 pprPrimWord16 pprPrimWord32 pprPrimWord64 pprPrefixVar pprInfixVarpprFastFilePathpprFilePathString pprWithCommas pprWithBars interppSP interpp'SP interpp'SP' pprQuotedListquotedListWithOrquotedListWithNor intWithCommasspeakNthspeakNspeakNOfpluralsingularisOrAredoOrDoes itsOrTheir thisOrThese hasOrHave$fIsStringSDoc$fOutputableExtension$fOutputableSerialized$fOutputableSCC$fOutputableFingerprint$fOutputableIntMap$fOutputableMap$fOutputableFastString$fOutputable(,,,,,,)$fOutputable(,,,,,)$fOutputable(,,,,)$fOutputable(,,,)$fOutputable(,,)$fOutputableEither$fOutputableMaybe$fOutputable(,)$fOutputableIntSet$fOutputableSet$fOutputableNonEmpty$fOutputable[]$fOutputableUTCTime$fOutputable()$fOutputableDouble$fOutputableFloat$fOutputableWord$fOutputableWord64$fOutputableWord32$fOutputableWord16$fOutputableInteger$fOutputableInt$fOutputableInt64$fOutputableInt32$fOutputableOrdering$fOutputableBool$fOutputableChar$fOutputableSDoc$fOutputablePprStyle$fOutputableQualifyName$fOutputablePenvSet$fOutputablePenvSDoc$fOutputablePenvSCC$fOutputablePenvMap$fOutputablePenv(,,)$fOutputablePenv(,)$fOutputablePenvMaybe$fOutputablePenv[]$fOutputablePenvPDoc$fEqBindingSite$fEqLabelStyle$fOrdLabelStyle$fShowLabelStyle$fOutputableLexicalFastString$fOutputableNonDetFastString IdDetailsIdInfo pprIdDetailsisCoVarDetails coVarDetails vanillaIdInfo HsUniToken HsNormalTok HsUnicodeTok LHsUniTokenHsTokenHsTokLHsTokenNoGhcTcXXIE XIEDocNamedXIEDocXIEGroupXIEModuleContents XIEThingWith XIEThingAll XIEThingAbsXIEVar XXImportDecl XCImportDecl XXFieldOcc XCFieldOccXXConDeclField XConDeclField XXTyVarBndr XKindedTyVar XUserTyVarXXHsForAllTelescopeXHsForAllInvis XHsForAllVisXXType XWildCardTyXTyLitXExplicitTupleTyXExplicitListTyXRecTyXBangTyXDocTy XSpliceTyXKindSigXStarTy XIParamTyXParTyXOpTyXSumTyXTupleTyXListTyXFunTy XAppKindTyXAppTyXTyVarXQualTy XForAllTyXXHsPatSigTypeXHsPSXXHsWildCardBndrsXHsWC XXHsSigTypeXHsSigXXHsOuterTyVarBndrsXHsOuterExplicitXHsOuterImplicit XXLHsQTyVarsXHsQTvs XHsFieldBindXXPatXCoPatXSigPat XNPlusKPatXNPatXLitPat XSplicePatXViewPatXConPatXSumPat XTuplePatXListPatXBangPatXParPatXAsPatXLazyPatXVarPatXWildPat XXOverLitXOverLitXXLit XHsDoublePrim XHsFloatPrimXHsRat XHsInteger XHsWord64Prim XHsInt64Prim XHsWordPrim XHsIntPrimXHsInt XHsStringPrim XHsString XHsCharPrimXHsCharXXApplicativeArgXApplicativeArgManyXApplicativeArgOneXXParStmtBlock XParStmtBlockXXCmdXCmdWrapXCmdDoXCmdLetXCmdIf XCmdLamCaseXCmdCaseXCmdParXCmdLamXCmdApp XCmdArrForm XCmdArrAppXXStmtLRXRecStmt XTransStmtXParStmtXLetStmt XBodyStmtXApplicativeStmt XBindStmt XLastStmtXXGRHSXCGRHSXXGRHSsXCGRHSsXXMatchXCMatch XXMatchGroupXMGXXCmdTopXCmdTopXXQuoteXVarBrXTypBrXDecBrGXDecBrLXPatBrXExpBrXXSpliceXSpliced XQuasiQuoteXUntypedSplice XTypedSpliceXXTupArgXMissingXPresentXXAmbiguousFieldOcc XAmbiguous XUnambiguousXXPragEXSCC XXDotFieldOcc XCDotFieldOccXXExprXPragEXBinTickXTickXStaticXProcXSpliceEXUntypedBracket XTypedBracket XArithSeqXExprWithTySig XProjection XGetField XRecordUpd XRecordCon XExplicitListXDoXLetXMultiIfXIfXCase XExplicitSumXExplicitTuple XSectionR XSectionLXParXNegAppXOpApp XAppTypeEXAppXLamCaseXLamXLitE XOverLitEXIPVar XOverLabelXRecSel XUnboundVarXVarXXInjectivityAnnXCInjectivityAnnXXRoleAnnotDeclXCRoleAnnotDecl XXAnnDecl XHsAnnotation XXWarnDeclXWarning XXWarnDecls XWarnings XXRuleBndr XRuleBndrSig XCRuleBndr XXRuleDeclXHsRule XXRuleDecls XCRuleDecls XXForeignDeclXForeignExportXForeignImport XXDefaultDecl XCDefaultDecl XViaStrategyXNewtypeStrategyXAnyClassStrategyXStockStrategy XXDerivDecl XCDerivDecl XXInstDecl XTyFamInstD XDataFamInstD XClsInstD XXClsInstDecl XCClsInstDeclXXTyFamInstDeclXCTyFamInstDeclXXFamEqnXCFamEqn XXConDecl XConDeclH98 XConDeclGADTXXDerivClauseTys XDctMulti XDctSingleXXHsDerivingClauseXCHsDerivingClause XXHsDataDefn XCHsDataDefn XXFamilyDecl XCFamilyDeclXXFamilyResultSig XTyVarSig XCKindSigXNoSig XXTyClGroup XCTyClGroupXXFunDepXCFunDep XXTyClDecl XClassDecl XDataDeclXSynDeclXFamDecl XXSpliceDecl XSpliceDecl XXHsGroup XCHsGroupXXHsDecl XRoleAnnotDXDocDXSpliceDXRuleDXAnnD XWarningDXForDXDefD XKindSigDXSigDXValDXDerivDXInstDXTyClDXXStandaloneKindSigXStandaloneKindSig XXFixitySig XFixitySigXXSigXCompleteMatchSig XSCCFunSig XMinimalSig XSpecInstSigXSpecSig XInlineSigXFixSigXIdSig XClassOpSig XPatSynSigXTypeSigXXIPBindXCIPBind XXHsIPBindsXIPBinds XXPatSynBindXPSB XXHsBindsLR XPatSynBindXVarBindXPatBindXFunBind XXValBindsLR XValBindsXXHsLocalBindsLRXEmptyLocalBinds XHsIPBinds XHsValBindsLIdPIdPWrapXRecwrapXRecMapXRecmapXRecUnXRecunXRecAnnoXRecDataConCantHappen noExtFielddataConCantHappen$fOutputableNoExtField$fOutputableDataConCantHappen$fDataDataConCantHappen$fEqDataConCantHappen$fOrdDataConCantHappen$fDataNoExtField$fEqNoExtField$fOrdNoExtField$fDataHsUniToken $fDataHsTokenLHsExpr SyntaxExprGRHSs MatchGroupHsSpliceLPatPat Uniquable getUnique uNIQUE_BITSmkUniqueGrimilygetKey incrUnique stepUnique mkLocalUniqueminLocalUniquemaxLocalUnique newTagUniquemkUnique unpkUniqueisValidKnownKeyUniquehasKeyeqUniqueltUniquenonDetCmpUniquepprUniqueAlways $fShowUnique$fOutputableUnique $fEqUnique$fUniquableUnique$fUniquableInt$fUniquableFastString NamedThing getOccNamegetNameName tidyNameOcc nameOccName setNameUnique nameUnique InvisTVBinderTcTyVarTyCoVarTyVar SpecificityVarBndrVar AnonArgFlagArgFlagidName TyConRepNameTyCon tyConNamemkPrelTyConRepNametyConRepName_maybe isFunTyConisUnboxedTupleTyCon isTupleTyConTyThingmkAnIdmkATyCon MCoercionN CoercionN ThetaTypePredTypeMultScaled MCoercion TyCoBinderTyLitUnivCoProvenanceCoercionmkNakedTyConTy mkForAllTy mkFunTyManypartitionInvisibleTypes getLevitytyConAppTyCon_maybesplitTyConApp_maybe mkTYPEappisLiftedTypeKindisMultiplicityTy isLevityTyisRuntimeRepTytcViewcoreView piResultTy mkTyConAppmkCastTymkAppTy isCoercionTyisPredTyTcTyVarDetails MetaDetailstcEqTypeisConcreteTyVarisTyConableTyVar isMetaTyVarvanillaSkolemTvUnkpprTcTyVarDetailspprTyVarpprTyLitpprCopprKindpprType NonDetUniqFM getNonDetUniqFMemptyUFM isNullUFMunitUFMunitDirectlyUFMzipToUFM listToUFMlistToUFM_DirectlylistToIdentityUFM listToUFM_CaddToUFM addListToUFMaddListToUFM_DirectlyaddToUFM_Directly addToUFM_C addToUFM_AccalterUFMaddListToUFM_C adjustUFMadjustUFM_Directly delFromUFMdelListFromUFMdelListFromUFM_DirectlydelFromUFM_DirectlyplusUFM plusUFM_C plusUFM_CD plusUFM_CD2mergeUFMplusMaybeUFM_C plusUFMListsequenceUFMListminusUFM minusUFM_C intersectUFMintersectUFM_C disjointUFMfoldUFMmapUFM mapMaybeUFMmapUFM_Directly filterUFMfilterUFM_Directly partitionUFMsizeUFMelemUFMelemUFM_Directly lookupUFMlookupUFM_DirectlylookupWithDefaultUFMlookupWithDefaultUFM_DirectlyufmToSet_DirectlyanyUFMallUFM seqEltsUFM nonDetEltsUFM nonDetKeysUFMnonDetStrictFoldUFMnonDetStrictFoldUFM_DirectlyMnonDetStrictFoldUFM_DirectlynonDetUFMToList ufmToIntMapunsafeIntMapToUFMunsafeCastUFMKey equalKeysUFM pprUniqFMpprUFMpprUFMWithKeys pluralUFM$fOutputableUniqFM$fMonoidUniqFM$fSemigroupUniqFM$fTraversableNonDetUniqFM$fFoldableNonDetUniqFM$fFunctorNonDetUniqFM $fDataUniqFM $fEqUniqFM$fFunctorUniqFM MonadUniquegetUniqueSupplyM getUniqueM getUniquesMUniqSM UniqSupplymkSplitUniqSupplyinitUniqSupply uniqFromMasksplitUniqSupplylistSplitUniqSupplyuniqFromSupplyuniqsFromSupplytakeUniqFromSupplyinitUsinitUs_$fMonadFixUniqSM$fMonadFailUniqSM$fApplicativeUniqSM $fMonadUniqSM$fFunctorUniqSM$fMonadUniqueUniqSMSignal UsageError CmdLineErrorPanicPprPanicSorryPprSorryInstallationError ProgramErrorPprProgramError showExceptionsafeShowExceptionshowGhcExceptionUnsafeshowGhcExceptionthrowGhcExceptionthrowGhcExceptionIOhandleGhcExceptionpprPanicpanicDocsorryDoc pgmErrorDoctryMostwithSignalHandlers callStackDocprettyCallStackDocassertPprPanic assertPpr massertPpr assertPprM$fShowGhcException$fExceptionGhcException expandToolDir findTopDir tryFindTopDir findToolDirWeights uncondWeightcondBranchWeight switchWeight callWeightlikelyCondWeightunlikelyCondWeightinfoTablePenalty backEdgeBonusdefaultWeights parseWeightsToJsonjsonJsonDocJSNullJSBoolJSIntJSStringJSArrayJSObject renderJSONescapeJsonString $fToJsonInt $fToJson[] LayoutInfoExplicitBraces VirtualBraces NoLayoutInfo PsLocatedPsSpan psRealSpan psBufSpanPsLoc psRealLocpsBufPos RealLocatedLocated GenLocatedLUnhelpfulSpanReasonUnhelpfulNoLocationInfoUnhelpfulWiredInUnhelpfulInteractiveUnhelpfulGeneratedUnhelpfulOtherSrcSpan RealSrcSpan UnhelpfulSpanBufSpan bufSpanStart bufSpanEnd srcSpanFileSrcLoc RealSrcLoc UnhelpfulLocBufPosbufPosmkSrcLoc mkRealSrcLoc getBufPosnoSrcLocgeneratedSrcLocinteractiveSrcLocmkGeneralSrcLoc srcLocFile srcLocLine srcLocCol advanceSrcLoc advanceBufPos sortLocatedsortRealLocated lookupSrcLoc lookupSrcSpan removeBufSpan getBufSpan noSrcSpanwiredInSrcSpaninteractiveSrcSpangeneratedSrcSpanisGeneratedSrcSpanmkGeneralSrcSpan srcLocSpanrealSrcLocSpan mkRealSrcSpan mkSrcSpancombineSrcSpanscombineRealSrcSpanssrcSpanFirstCharacter isGoodSrcSpan isOneLineSpanisZeroWidthSpan containsSpansrcSpanStartLinesrcSpanEndLinesrcSpanStartCol srcSpanEndCol srcSpanStart srcSpanEndrealSrcSpanStartrealSrcSpanEndsrcSpanFileName_maybesrcSpanToRealSrcSpanunhelpfulSpanFSpprUnhelpfulSpanReason pprUserSpanpprUserRealSpanmapLocunLocgetLocnoLocmkGeneralLocated combineLocsaddCLoc eqLocated cmpLocated cmpBufSpan pprLocatedpprLocatedAlwaysrightmost_smallestleftmost_smallestleftmost_largestspans isSubspanOfisRealSubspanOfliftLgetRealSrcSpan unRealSrcSpanpsLocatedToLocated advancePsLocmkPsSpan psSpanStart psSpanEnd mkSrcSpanPsleftmostColumn$fShowRealSrcLoc$fOutputableRealSrcLoc$fOutputableSrcLoc$fOutputableRealSrcSpan$fShowRealSrcSpan$fOrdRealSrcSpan$fToJsonRealSrcSpan$fDataRealSrcSpan$fSemigroupBufSpan$fOutputableUnhelpfulSpanReason$fOutputableSrcSpan$fNFDataSrcSpan$fToJsonSrcSpan $fDataSrcSpan$fOutputableGenLocated$fOutputableGenLocated0$fEqLayoutInfo$fOrdLayoutInfo$fShowLayoutInfo$fDataLayoutInfo $fEqPsSpan $fOrdPsSpan $fShowPsSpan $fDataPsSpan $fEqPsLoc $fOrdPsLoc $fShowPsLoc$fEqGenLocated$fOrdGenLocated$fShowGenLocated$fDataGenLocated$fFunctorGenLocated$fFoldableGenLocated$fTraversableGenLocated $fEqSrcSpan $fShowSrcSpan$fEqUnhelpfulSpanReason$fShowUnhelpfulSpanReason $fEqBufSpan $fOrdBufSpan $fShowBufSpan $fDataBufSpan$fEqRealSrcSpan $fEqSrcLoc $fShowSrcLoc $fEqBufPos $fOrdBufPos $fShowBufPos $fDataBufPos$fEqRealSrcLoc$fOrdRealSrcLoc SymbolTable DictionaryUserData ud_get_name ud_get_fsud_put_nonbinding_nameud_put_binding_name ud_put_fsFixedLengthEncoding unFixedLengthBinaryput_Bin BinHandleBinData dataHandle handleData getUserData setUserData withBinBuffercastBinputAtgetAt openBinMemtellBinseekBin writeBinMem readBinMemfoldGetputBytegetByte putULEB128 getULEB128 putSLEB128 getSLEB128lazyPutlazyGet lazyPutMaybe lazyGetMaybe newReadState newWriteState putDictionary getDictionaryputFS$fNFDataBinData$fBinaryIntMap$fBinarySrcSpan$fBinaryUnhelpfulSpanReason$fBinaryRealSrcSpan$fBinaryGenLocated$fBinaryFingerprint$fBinaryFastString$fBinaryByteString $fBinaryBin $fBinaryRatio$fBinaryInteger$fBinaryDiffTime $fBinaryDay$fBinaryUTCTime$fBinaryEither $fBinaryMaybe$fBinaryMaybe0$fBinary(,,,,,,)$fBinary(,,,,,)$fBinary(,,,,) $fBinary(,,,) $fBinary(,,) $fBinary(,) $fBinaryArray$fBinaryNonEmpty $fBinarySet $fBinary[] $fBinaryInt $fBinaryChar $fBinaryBool $fBinary() $fBinaryInt64 $fBinaryInt32 $fBinaryInt16 $fBinaryInt8$fBinaryWord64$fBinaryWord32$fBinaryWord16 $fBinaryWord8$fBinaryFixedLengthEncoding$fBinaryFixedLengthEncoding0$fBinaryFixedLengthEncoding1$fBinaryFixedLengthEncoding2$fBinaryBinData$fEqBin$fOrdBin $fShowBin $fBoundedBin$fBinaryLexicalFastString$fBinaryNonDetFastStringEnumSetmemberinsertdeletetoList difference$fBinaryEnumSet$fSemigroupEnumSet$fMonoidEnumSetgetSomeTypeRep$fBinarySerialized$fBinaryTypeLitSort$fBinaryKindRep$fBinaryRuntimeRep$fBinaryVecElem$fBinaryVecCount$fBinaryTypeRep$fBinarySomeTypeRep $fBinaryTyConExtensibleFieldsgetExtensibleFields FieldNameemptyExtensibleFields readField readFieldWith writeFieldwriteFieldWith deleteField$fNFDataExtensibleFields$fBinaryExtensibleFieldsstableModuleNameCmp pprModuleName moduleNameFSmoduleNameString mkModuleNamemkModuleNameFSmoduleNameSlashesmoduleNameColonsparseModuleName$fNFDataModuleName$fDataModuleName$fBinaryModuleName$fOutputableModuleName$fOrdModuleName$fEqModuleName$fUniquableModuleName$fShowModuleNameUniqDFM emptyUDFMunitUDFM addToUDFMaddToUDFM_DirectlyaddToUDFM_C_Directly addToUDFM_C addListToUDFM delFromUDFM plusUDFM_CplusUDFM lookupUDFMlookupUDFM_DirectlyelemUDFMfoldUDFMnonDetStrictFoldUDFMeltsUDFM filterUDFMfilterUDFM_DirectlyudfmRestrictKeys udfmToList equalKeysUDFM isNullUDFMsizeUDFM intersectUDFMudfmIntersectUFM disjointUDFMdisjointUdfmUfm minusUDFM udfmMinusUFM ufmMinusUDFM partitionUDFMdelListFromUDFM udfmToUfm listToUDFMlistToUDFM_Directly adjustUDFMadjustUDFM_Directly alterUDFMmapUDFM mapMaybeUDFManyUDFMallUDFMalwaysUnsafeUfmToUdfmunsafeCastUDFMKey pprUniqDFMpprUDFM $fEqTaggedVal$fOutputableUniqDFM$fTraversableUniqDFM$fFoldableUniqDFM $fDataUniqDFM$fFunctorUniqDFM$fDataTaggedVal$fFunctorTaggedVal$fFoldableTaggedVal$fTraversableTaggedValDFastStringEnv FastStringEnv emptyFsEnv unitFsEnv extendFsEnvextendFsEnvList lookupFsEnv alterFsEnvmkFsEnv elemFsEnv plusFsEnv plusFsEnv_C extendFsEnv_CmapFsEnvextendFsEnv_AccextendFsEnvList_C delFromFsEnvdelListFromFsEnv filterFsEnvlookupFsEnv_NF emptyDFsEnv dFsEnvEltsmkDFsEnv lookupDFsEnvCostCentreIndexunCostCentreIndexCostCentreStatenewCostCentreState getCCIndex$fEqCostCentreIndex$fOrdCostCentreIndex$fDataCostCentreIndex$fBinaryCostCentreIndexUniqSet emptyUniqSet unitUniqSet mkUniqSetaddOneToUniqSetaddListToUniqSetdelOneFromUniqSetdelOneFromUniqSet_DirectlydelListFromUniqSetdelListFromUniqSet_Directly unionUniqSetsunionManyUniqSets minusUniqSetintersectUniqSetsdisjointUniqSetsrestrictUniqSetToUFMuniqSetMinusUFMuniqSetMinusUDFMelementOfUniqSetelemUniqSet_Directly filterUniqSetfilterUniqSet_DirectlypartitionUniqSet uniqSetAny uniqSetAll sizeUniqSetisEmptyUniqSet lookupUniqSetlookupUniqSet_DirectlynonDetEltsUniqSetnonDetKeysUniqSetnonDetStrictFoldUniqSet mapUniqSet getUniqSetunsafeUFMToUniqSet pprUniqSet$fOutputableUniqSet $fEqUniqSet $fDataUniqSet$fSemigroupUniqSet$fMonoidUniqSetUniqDSet emptyUniqDSet unitUniqDSet mkUniqDSetaddOneToUniqDSetaddListToUniqDSetdelOneFromUniqDSetdelListFromUniqDSetunionUniqDSetsunionManyUniqDSets minusUniqDSetuniqDSetMinusUniqSetintersectUniqDSetsuniqDSetIntersectUniqSetnonDetStrictFoldUniqDSetelementOfUniqDSetfilterUniqDSet sizeUniqDSetisEmptyUniqDSetlookupUniqDSetuniqDSetToListpartitionUniqDSet mapUniqDSet getUniqDSet pprUniqDSet$fOutputableUniqDSet $fEqUniqDSet$fDataUniqDSetModuleWithIsBootModuleNameWithIsBoot GenWithIsBootGWIBgwib_mod gwib_isBootIsBootInterfaceNotBootIsBootDefinite unDefinite DefUnitIdunitIdFSInstantiationsGenInstantiationsInstantiatedUnitGenInstantiatedUnit instUnitFS instUnitKeyinstUnitInstanceOf instUnitInsts instUnitHolesRealUnitVirtUnitHoleUnitUnitKeyIsUnitIdunitFSInstantiatedModuleHomeUnitModuleInstalledModule moduleUnitIdmkModulepprInstantiatedModule isHoleUnit stableUnitCmpunitFreeModuleHolesmoduleFreeHolesmkInstantiatedUnit mkVirtUnitmkInstantiatedUnitHashfsToUnit unitString stringToUnit mapGenUnitmapInstantiationstoUnitId virtualUnitIdunitIsDefinite unitIdStringstringToUnitId primUnitId bignumUnitId baseUnitId rtsUnitId thisGhcUnitIdinteractiveUnitIdthUnitIdthUnitprimUnit bignumUnitbaseUnitrtsUnit thisGhcUnitinteractiveUnit mainUnitIdmainUnitisInteractiveModulewiredInUnitIds$fNFDataGenModule$fBinaryGenModule$fIsUnitIdUnitKey$fOutputableUnitId$fUniquableUnitId $fOrdUnitId $fEqUnitId$fBinaryUnitId$fIsUnitIdUnitId$fOutputableGenModule$fUniquableGenUnit $fEqGenUnit$fOrdGenInstantiatedUnit$fEqGenInstantiatedUnit$fIsUnitIdGenUnit$fBinaryGenInstantiatedUnit$fOutputableGenInstantiatedUnit$fOutputableGenModule0$fBinaryGenUnit $fShowGenUnit$fOutputableGenUnit$fNFDataGenUnit $fDataGenUnit $fOrdGenUnit$fOutputableGenModule1$fUniquableGenModule$fBinaryIsBootInterface$fOutputableGenWithIsBoot$fBinaryGenWithIsBoot$fEqGenWithIsBoot$fOrdGenWithIsBoot$fShowGenWithIsBoot$fFunctorGenWithIsBoot$fFoldableGenWithIsBoot$fTraversableGenWithIsBoot$fEqIsBootInterface$fOrdIsBootInterface$fShowIsBootInterface$fDataIsBootInterface$fFunctorDefinite $fEqDefinite $fOrdDefinite$fOutputableDefinite$fBinaryDefinite$fUniquableDefinite$fIsUnitIdDefinite $fDataUnitId $fEqGenModule$fOrdGenModule$fDataGenModule$fFunctorGenModule ModLocation ml_hs_file ml_hi_fileml_dyn_hi_file ml_obj_fileml_dyn_obj_file ml_hie_file addBootSuffixremoveBootSuffixaddBootSuffix_maybeaddBootSuffixLocn_maybeaddBootSuffixLocnaddBootSuffixLocnOut$fOutputableModLocation$fShowModLocationInstalledModuleEnvDModuleNameEnv ModuleNameEnv ModuleSet ModuleEnvfilterModuleEnv elemModuleEnvextendModuleEnvextendModuleEnvWithextendModuleEnvListextendModuleEnvList_CplusModuleEnv_CdelModuleEnvList delModuleEnv plusModuleEnvlookupModuleEnvlookupWithDefaultModuleEnv mapModuleEnvpartitionModuleEnv mkModuleEnvemptyModuleEnv moduleEnvKeys moduleEnvEltsmoduleEnvToList unitModuleEnvisEmptyModuleEnv mkModuleSetextendModuleSetextendModuleSetListemptyModuleSetisEmptyModuleSet moduleSetElts elemModuleSetintersectModuleSetminusModuleSet delModuleSetunionModuleSetunionManyModuleSets unitModuleSetemptyInstalledModuleEnvlookupInstalledModuleEnvextendInstalledModuleEnvfilterInstalledModuleEnvdelInstalledModuleEnvinstalledModuleEnvEltsmergeInstalledModuleEnvplusInstalledModuleEnv $fOrdNDModule$fOutputableNDModule$fOutputableModuleEnv$fOutputableInstalledModuleEnv $fEqNDModuleHomeUnit GenHomeUnitDefiniteHomeUnitIndefiniteHomeUnit homeUnitIdhomeUnitInstantiationshomeUnitInstanceOfhomeUnitInstanceOfMaybehomeUnitAsUnit homeUnitMapisHomeUnitIndefiniteisHomeUnitDefiniteisHomeUnitInstantiating isHomeUnit isHomeUnitId notHomeUnitIdisHomeUnitInstanceOf isHomeModuleisHomeInstalledModulenotHomeInstalledModulenotHomeInstalledModuleMaybe notHomeModulenotHomeModuleMaybe mkHomeModulemkHomeInstalledModulehomeModuleNameInstantiationhomeModuleInstantiation HscSource HsSrcFile HsBootFileHsigFilehscSourceToIsBoothscSourceString isHsBootOrSig isHsigFile$fBinaryHscSource $fEqHscSource$fOrdHscSource$fShowHscSource parseUnit parseUnitIdparseHoleyModule parseModSubst HasModule getModuleContainsModule extractModulemoduleIsDefinitemoduleStableStringstableModuleCmpinstalledModuleEqgetModuleInstantiationgetUnitInstantiationsuninstantiateInstantiatedUnituninstantiateInstantiatedModule isHoleModule mkHoleModule BreakInfobreakInfo_modulebreakInfo_number StringLiteralsl_stsl_fssl_tcFractionalExponentBaseBase2Base10 FractionalLitFLfl_textfl_negfl_signifl_exp fl_exp_base IntegralLitILil_textil_negil_value SourceText NoSourceTextpprWithSourceText mkIntegralLitnegateIntegralLitmkFractionalLitfractionalLitFromRationalrationalFromFractionalLitmkTHFractionalLitnegateFractionalLitintegralFractionalLitmkSourceFractionalLit$fBinarySourceText$fOutputableSourceText$fOutputableIntegralLit$fOrdIntegralLit$fEqIntegralLit$fOutputableFractionalLit$fOrdFractionalLit$fEqFractionalLit$fBinaryStringLiteral$fOutputableStringLiteral$fEqStringLiteral$fDataStringLiteral$fDataFractionalLit$fShowFractionalLit$fEqFractionalExponentBase$fOrdFractionalExponentBase$fDataFractionalExponentBase$fShowFractionalExponentBase$fDataIntegralLit$fShowIntegralLit$fDataSourceText$fShowSourceText$fEqSourceTextCType CLabelString CCallConvCApiConv StdCallConv PrimCallConvJavaScriptCallConv CCallTarget StaticTarget DynamicTarget CCallSpec CExportSpec CExportStaticSafetyPlaySafePlayInterruptible PlayRisky ForeignCallCCallisSafeForeignCallplaySafeplayInterruptibleisDynamicTargetdefaultCCallConvccallConvToIntccallConvAttributepprCLabelStringisCLabelString$fBinarySafety$fOutputableSafety$fBinaryCCallConv$fOutputableCCallConv$fBinaryCCallTarget$fBinaryCCallSpec$fOutputableCCallSpec$fBinaryForeignCall$fOutputableForeignCall$fBinaryCExportSpec$fOutputableCExportSpec$fBinaryHeader$fOutputableHeader $fBinaryCType$fOutputableCType $fEqCType $fDataCType $fEqHeader $fDataHeader$fDataCExportSpec$fEqForeignCall $fEqCCallSpec$fEqCCallTarget$fDataCCallTarget $fEqCCallConv$fDataCCallConv$fEnumCCallConv $fEqSafety $fShowSafety $fDataSafety $fEnumSafetypprTrace pprTraceM pprTraceDebug pprTraceWith pprTraceItpprTraceException pprSTrace warnPprTracepprTraceUserWarningDefaultingStrategyDefaultKindVarsNonStandardDefaultingNonStandardDefaultingStrategyDefaultNonStandardTyVars TryNotToDefaultNonStandardTyVars ExprOrPat ExpressionPatternLevityLiftedUnlifted TypeOrKind TypeLevel KindLevelSpliceExplicitFlagExplicitSpliceImplicitSplice IntWithInf InlineSpecInline InlinableNoInlineOpaqueNoUserInlinePrag RuleMatchInfoConLikeFunLike InlinePragmainl_src inl_inlineinl_satinl_actinl_rule Activation AlwaysActive ActiveBefore ActiveAfter FinalActive NeverActive CompilerPhase InitialPhasePhase FinalPhasePhaseNum SuccessFlag DefMethSpec VanillaDM GenericDM TailCallInfoAlwaysTailCalledNoTailCallInfo InsideLam IsInsideLam NotInsideLamInterestingCxt IsInterestingNotInteresting BranchCountOccInfoManyOccsIAmDeadOneOccIAmALoopBreakerocc_tail occ_in_lamocc_n_br occ_int_cxtocc_rules_onlyEPfromEPtoEPUnboxedTupleOrSumUnboxedTupleTypeUnboxedSumType TupleSort BoxedTuple UnboxedTupleConstraintTuplePprPrec OverlapMode NoOverlap Overlappable OverlappingOverlaps Incoherent OverlapFlag overlapMode isSafeOverlapOrigin FromSource GeneratedRecFlag Recursive NonRecursiveCbvMark MarkedCbv NotMarkedCbvBoxityBoxedUnboxed TopLevelFlagTopLevel NotTopLevelRuleNameFunctionOrData IsFunctionIsData PromotionFlag NotPromoted IsPromotedSwapFlag NotSwapped IsSwapped OneShotInfo NoOneShotInfo OneShotLam AlignmentalignmentBytesConTagZConTag FullArgCount JoinArityRepArityArity LeftOrRightCLeftCRightpickLR fIRST_TAG mkAlignment alignmentOf noOneShotInfo isOneShotInfohasNoOneShotInfo worstOneShot bestOneShotflipSwap isSwappedunSwap isPromoted pprRuleName isNotTopLevel isTopLevelisBoxed isMarkedCbvisRecisNonRec boolToRecFlag isGeneratedsetOverlapModeMaybehasIncoherentFlaghasOverlappableFlaghasOverlappingFlagtopPrecsigPrecfunPrecopPrecstarPrecappPrec maybeParentupleSortBoxityboxityTupleSort tupleParens sumParenspprAlternativeunboxedTupleOrSumExtension oneBranch noOccInfo isNoOccInfo isManyOccs seqOccInfo tailCallInfozapOccTailCallInfoisAlwaysTailCalledstrongLoopBreakerweakLoopBreakerisWeakLoopBreakerisStrongLoopBreaker isDeadOccisOneOcc zapFragileOcc successIf succeededfailed beginPhase activeAfter nextPhase laterPhaseactivateAfterInitialactivateDuringFinalisActiveactiveInFinalPhase isNeverActiveisAlwaysActive competesWith isConLike isFunLikenoUserInlineSpecdefaultInlinePragmaalwaysInlinePragmaneverInlinePragmaalwaysInlineConLikePragmainlinePragmaSpecinlinePragmaSourceinlineSpecSourcedfunInlinePragmaisDefaultInlinePragmaisInlinePragmaisInlinablePragmaisNoInlinePragmaisAnyInlinePragmaisOpaquePragmainlinePragmaSatinlinePragmaActivationinlinePragmaRuleMatchInfosetInlinePragmaActivationsetInlinePragmaRuleMatchInfoinlinePragmaName pprInlinepprInlineDebuginfinity intGtLimit subWithInftreatZeroAsInf mkIntWithInf isTypeLevel isKindLevel mightBeLiftedmightBeUnlifteddefaultNonStandardTyVars$fBinaryLeftOrRight$fOutputableLeftOrRight$fOutputablePenvAlignment$fOutputableAlignment$fOutputableOneShotInfo$fOutputableSwapFlag$fBinaryPromotionFlag$fOutputablePromotionFlag$fBinaryFunctionOrData$fOutputableFunctionOrData$fOutputableTopLevelFlag$fBinaryBoxity$fOutputableBoxity$fBinaryCbvMark$fOutputableCbvMark$fBinaryRecFlag$fOutputableRecFlag$fOutputableOrigin$fBinaryOverlapMode$fOutputableOverlapMode$fBinaryOverlapFlag$fOutputableOverlapFlag$fBinaryTupleSort$fOutputableTupleSort$fOutputableUnboxedTupleOrSum$fMonoidInterestingCxt$fSemigroupInterestingCxt$fMonoidInsideLam$fSemigroupInsideLam$fOutputableTailCallInfo$fOutputableOccInfo$fOutputableDefMethSpec$fOutputableSuccessFlag$fSemigroupSuccessFlag$fOutputableCompilerPhase$fBinaryActivation$fOutputableActivation$fBinaryRuleMatchInfo$fOutputableRuleMatchInfo$fBinaryInlineSpec$fOutputableInlineSpec$fBinaryInlinePragma$fOutputableInlinePragma$fNumIntWithInf$fOutputableIntWithInf$fOrdIntWithInf$fOutputableTypeOrKind$fOutputableLevity$fOutputableExprOrPat)$fOutputableNonStandardDefaultingStrategy$fOutputableDefaultingStrategy $fEqExprOrPat $fEqLevity$fEqTypeOrKind$fDataSpliceExplicitFlag$fEqIntWithInf$fEqInlinePragma$fDataInlinePragma$fEqInlineSpec$fDataInlineSpec$fShowInlineSpec$fEqRuleMatchInfo$fDataRuleMatchInfo$fShowRuleMatchInfo$fEqActivation$fDataActivation$fEqCompilerPhase $fEqOccInfo$fEqTailCallInfo $fEqInsideLam$fEqInterestingCxt$fEqUnboxedTupleOrSum $fEqTupleSort$fDataTupleSort $fEqPprPrec $fOrdPprPrec $fShowPprPrec$fEqOverlapFlag$fDataOverlapFlag$fEqOverlapMode$fDataOverlapMode $fEqOrigin $fDataOrigin $fEqRecFlag $fDataRecFlag $fEqCbvMark $fEqBoxity $fDataBoxity$fDataTopLevelFlag$fEqFunctionOrData$fOrdFunctionOrData$fDataFunctionOrData$fEqPromotionFlag$fDataPromotionFlag$fEqOneShotInfo $fEqAlignment$fOrdAlignment$fEqLeftOrRight$fDataLeftOrRightdataConTyRepNameUniquedataConWorkerUniquemkPreludeDataConUniquetyConRepNameUniquemkPreludeTyConUniqueinitExitJoinUniquemkVarOccUniquemkDataOccUnique mkTvOccUnique mkTcOccUniquemkRegSingleUniquemkRegPairUniquemkRegSubUniquemkRegClassUniquemkPseudoUniqueEmkBuiltinUniquemkPreludeMiscIdUniquemkPrimOpWrapperUniquemkPrimOpIdUniquemkPreludeClassUniquemkAlphaTyVarUniquemkTupleDataConUniquemkTupleTyConUniquemkCTupleDataConUniquemkCTupleTyConUniquemkSumDataConUniquemkSumTyConUniqueknownUniqueName PlatformMisc!platformMisc_targetPlatformStringplatformMisc_ghcWithInterpreterplatformMisc_libFFIplatformMisc_llvmTarget BmiVersionBMI1BMI2 SseVersionSSE1SSE2SSE3SSE4SSE42PlatformWordSizePW4PW8PlatformplatformArchOSplatformWordSizeplatformByteOrderplatformUnregisterisedplatformHasGnuNonexecStackplatformHasIdentDirective platformHasSubsectionsViaSymbolsplatformIsCrossCompilingplatformLeadingUnderscoreplatformTablesNextToCodeplatformHasLibmplatform_constants wordAlignment isSseEnabled isSse2EnabledplatformConstantsgenericPlatformplatformWordSizeInBytesplatformWordSizeInBits platformArch platformOSisARM target32Bit osElfTarget osMachOTargetplatformUsesFrameworksosSubsectionsViaSymbolsplatformMinIntplatformMaxIntplatformMaxWordplatformInIntRangeplatformInWordRangeplatformCConvNeedsExtensionplatformSONameplatformHsSOName platformSOExtlookupPlatformConstants$fReadPlatformWordSize$fShowPlatformWordSize$fEqBmiVersion$fOrdBmiVersion$fEqSseVersion$fOrdSseVersion$fReadPlatform$fShowPlatform $fEqPlatform $fOrdPlatform$fEqPlatformWordSize$fOrdPlatformWordSizeCLabel pprCLabelGhcNameVersionghcNameVersion_programNameghcNameVersion_projectVersion FileSettingsfileSettings_ghcUsagePathfileSettings_ghciUsagePathfileSettings_toolDirfileSettings_topDir"fileSettings_globalPackageDatabase ToolSettings$toolSettings_ldSupportsCompactUnwindtoolSettings_ldSupportsBuildIdtoolSettings_ldSupportsFilelisttoolSettings_ldIsGnuLdtoolSettings_ccSupportsNoPietoolSettings_useInplaceMinGWtoolSettings_arSupportsDashLtoolSettings_pgm_LtoolSettings_pgm_PtoolSettings_pgm_FtoolSettings_pgm_ctoolSettings_pgm_cxxtoolSettings_pgm_atoolSettings_pgm_ltoolSettings_pgm_lmtoolSettings_pgm_dlltoolSettings_pgm_TtoolSettings_pgm_windrestoolSettings_pgm_libtooltoolSettings_pgm_artoolSettings_pgm_otool"toolSettings_pgm_install_name_tooltoolSettings_pgm_ranlibtoolSettings_pgm_lotoolSettings_pgm_lctoolSettings_pgm_lcctoolSettings_pgm_itoolSettings_opt_LtoolSettings_opt_PtoolSettings_opt_P_fingerprinttoolSettings_opt_FtoolSettings_opt_ctoolSettings_opt_cxxtoolSettings_opt_atoolSettings_opt_ltoolSettings_opt_lmtoolSettings_opt_windrestoolSettings_opt_lotoolSettings_opt_lctoolSettings_opt_lcctoolSettings_opt_itoolSettings_extraGccViaCFlagsSettingssGhcNameVersion sFileSettingssTargetPlatform sToolSettings sPlatformMisc sRawSettings dynLibSuffix sProgramNamesProjectVersion sGhcUsagePathsGhciUsagePathsToolDirsTopDirsGlobalPackageDatabasePathsLdSupportsCompactUnwindsLdSupportsBuildIdsLdSupportsFilelist sLdIsGnuLdsGccSupportsNoPiesUseInplaceMinGWsArSupportsDashLsPgm_LsPgm_PsPgm_FsPgm_csPgm_cxxsPgm_asPgm_lsPgm_lmsPgm_dllsPgm_T sPgm_windres sPgm_libtoolsPgm_ar sPgm_otoolsPgm_install_name_tool sPgm_ranlibsPgm_losPgm_lcsPgm_lccsPgm_isOpt_LsOpt_PsOpt_P_fingerprintsOpt_FsOpt_csOpt_cxxsOpt_asOpt_lsOpt_lm sOpt_windressOpt_losOpt_lcsOpt_lccsOpt_isExtraGccViaCFlagssTargetPlatformStringsGhcWithInterpretersLibFFIBackendNCGLLVMViaC Interpreter NoBackendplatformDefaultBackendplatformNcgSupportedbackendProducesObjectbackendRetainsAllBindings $fEqBackend $fOrdBackend $fShowBackend $fReadBackend exeFileNameEdgeTypeForwardCrossBackwardSelfLoop DigraphNode node_payloadnode_keynode_dependenciesgraphFromEdgedVerticesOrdgraphFromEdgedVerticesUniq findCyclestronglyConnCompG$stronglyConnCompFromEdgedVerticesOrd%stronglyConnCompFromEdgedVerticesUniq%stronglyConnCompFromEdgedVerticesOrdR&stronglyConnCompFromEdgedVerticesUniqRtopologicalSortG reachableG outgoingG reachablesG allReachable hasVertexG verticesGedgesG transposeGemptyG classifyEdges$fOutputableEdge$fOutputableNode$fOutputableGraph$fOutputableEdgeType$fEqTime $fOrdTime $fNumTime$fOutputableTime $fEqEdgeType $fOrdEdgeTypeFieldSelectorsNoFieldSelectorsDuplicateRecordFieldsNoDuplicateRecordFields FieldLabelflLabelflHasDuplicateRecordFieldsflHasFieldSelector flSelector FieldLabelEnvFieldLabelStringfieldSelectorOccNamefieldLabelPrintableNameflIsOverloaded!$fOutputableDuplicateRecordFields$fBinaryDuplicateRecordFields$fOutputableFieldSelectors$fBinaryFieldSelectors$fBinaryFieldLabel$fOutputableFieldLabel$fHasOccNameFieldLabel$fDataFieldLabel$fEqFieldLabel$fShowFieldSelectors$fEqFieldSelectors$fDataFieldSelectors$fShowDuplicateRecordFields$fEqDuplicateRecordFields$fDataDuplicateRecordFieldsEqSpec DataConRepDataConpromoteDataCon dataConWrapIdisUnboxedSumDataCondataConFullSigdataConStupidThetadataConInstOrigArgTysdataConFieldLabelsdataConSourceAritydataConUserTyVarBindersdataConUserTyVarsdataConExTyCoVars dataConTyCon dataConWorkId dataConNamesumTyCon sumDataConcTupleSelIdNamecTupleTyConNamecTupleDataConName cTupleDataCon tupleTyCon tupleDataConpromotedTupleDataCon integerTy naturalTytupleTyConName multMulTyConunrestrictedFunTyConmanyDataConTyCon manyDataConTyoneDataConTyCon oneDataConTymultiplicityTymultiplicityTyConunboxedTupleKind anyTypeOfKindint8ElemRepDataConTyint16ElemRepDataConTyint32ElemRepDataConTyint64ElemRepDataConTyword8ElemRepDataConTyword16ElemRepDataConTyword32ElemRepDataConTyword64ElemRepDataConTyfloatElemRepDataConTydoubleElemRepDataConTy vec2DataConTy vec4DataConTy vec8DataConTyvec16DataConTyvec32DataConTyvec64DataConTyintRepDataConTyint8RepDataConTyint16RepDataConTyint32RepDataConTyint64RepDataConTywordRepDataConTyword8RepDataConTyword16RepDataConTyword32RepDataConTyword64RepDataConTyaddrRepDataConTyfloatRepDataConTydoubleRepDataConTyliftedDataConTyunliftedDataConTy liftedRepTy unliftedRepTy zeroBitRepTyvecRepDataConTyContupleRepDataConTyConboxedRepDataConTyConliftedDataConTyCon runtimeRepTylevityTyruntimeRepTyCon levityTyCon vecCountTyCon vecElemTyConconstraintKindliftedRepTyConunliftedRepTyConliftedTypeKindTyConunliftedTypeKindTyConliftedTypeKindunliftedTypeKindzeroBitTypeKindliftedTypeKindTyConNameunitTycoercibleTyConheqTyConmkBoxedTupleTycharTytypeSymbolKind listTyConmkCTupleSelIdUniquemkCostCentreUnique TidyOccEnvOccSetOccEnv occNameSpace occNameFS NameSpacetcNameclsName tcClsNamedataName srcDataNametvNamevarNameisDataConNameSpaceisTcClsNameSpace isTvNameSpaceisVarNameSpaceisValNameSpace pprNameSpacepprNonVarNameSpacepprNameSpaceBrief pprOccName mkOccName mkOccNameFSmkVarOcc mkDataOcc mkDataOccFS mkTyVarOcc mkTyVarOccFSmkTcOcc mkTcOccFSmkClsOcc mkClsOccFS demoteOccNamepromoteOccName emptyOccEnv unitOccEnv extendOccEnvextendOccEnvList lookupOccEnvmkOccEnv elemOccEnv foldOccEnvnonDetOccEnvElts plusOccEnv plusOccEnv_CextendOccEnv_CextendOccEnv_Acc mapOccEnv mkOccEnv_C delFromOccEnvdelListFromOccEnv filterOccEnv alterOccEnv minusOccEnv minusOccEnv_C pprOccEnv emptyOccSet unitOccSetmkOccSet extendOccSetextendOccSetList unionOccSetsunionManyOccSets minusOccSet elemOccSet isEmptyOccSetintersectOccSet filterOccSet occSetToEnvsetOccNameSpaceisVarOccisTvOccisTcOccisValOcc isDataOcc isDataSymOccisSymOcc parenSymOccstartsWithUnderscoreisDerivedOccNameisDefaultMethodOccisTypeableBindOccmkDataConWrapperOcc mkWorkerOcc mkMatcherOcc mkBuilderOccmkDefaultMethodOccmkClassOpAuxOcc mkDictOccmkIPOcc mkSpecOccmkForeignExportOcc mkRepEqOccmkClassDataConOcc mkNewTyCoOcc mkInstTyCoOcc mkEqPredCoOcc mkCon2TagOcc mkTag2ConOcc mkMaxTagOcc mkDataTOcc mkDataCOcc mkTyConRepOccmkGenRmkGen1RmkDataConWorkerOccmkSuperDictAuxOccmkSuperDictSelOcc mkLocalOcc mkInstTyTcOcc mkDFunOcc mkMethodOccemptyTidyOccEnvinitTidyOccEnvdelTidyOccEnvListavoidClashesOccEnv tidyOccName$fBinaryNameSpace$fBinaryOccName$fUniquableOccName$fOutputableBndrOccName$fOutputableOccName$fNFDataOccName $fDataOccName $fOrdOccName $fEqOccName$fHasOccNameOccName$fOutputableOccEnv $fDataOccEnv $fEqNameSpace$fOrdNameSpace BuiltInSyntax UserSyntax nameNameSpace nameSrcLoc nameSrcSpan isWiredInName isWiredInwiredInNameTyThing_maybeisBuiltInSyntaxisExternalNameisInternalName isHoleName isDynLinkName nameModulenameModule_maybenameIsLocalOrFromnameIsExternalOrFromnameIsHomePackagenameIsHomePackageImportnameIsFromExternalPackage isTyVarName isTyConName isDataConName isValName isVarName isSystemNamemkInternalNamemkClonedInternalNamemkDerivedInternalNamemkExternalName mkWiredInName mkSystemNamemkSystemNameAtmkSystemVarName mkSysTvName mkFCallName setNameLoc localiseName stableNameCmp pprFullName pprTickyNamepprNameUnqualifiedpprModulePrefix pprDefinedAtpprNameDefnLocnameStableString getSrcLoc getSrcSpan getOccStringgetOccFS pprInfixName pprPrefixName$fNFDataNameSort$fOutputableNameSort$fOutputableBndrName$fOutputableName $fBinaryName $fDataName$fUniquableName $fOrdName$fEqName$fHasOccNameName $fNFDataName$fNamedThingGenLocated$fNamedThingName ReqTVBinder TyVarBinder TyCoVarBinderBndrVisArgInvisArg InferredSpec SpecifiedSpec InvisibleRequiredvarTypevarMultOutIdOutCoVarOutTyVarOutVarInIdInCoVarInTyVarInVarJoinIdEqVarIpIdDictIdDFunIdEvVarEvIdKindVarTypeVarTKVarNcIdCoVar SpecifiedInferred nonDetCmpVar varUnique varMultMaybe setVarUnique setVarName setVarType updateVarTypeupdateVarTypeMisVisibleArgFlagisInvisibleArgFlagisInferredArgFlagsameVistyVarSpecToBinderstyVarSpecToBindertyVarReqToBinderstyVarReqToBinder binderVar binderVars binderArgFlag binderTypemkTyCoVarBinder mkTyVarBindermkTyCoVarBindersmkTyVarBinders isTyVarBinder mapVarBndr mapVarBndrs lookupVarBndr tyVarName tyVarKindsetTyVarUnique setTyVarName setTyVarKindupdateTyVarKindupdateTyVarKindMmkTyVar mkTcTyVartcTyVarDetailssetTcTyVarDetailsidInfo idDetails mkGlobalVar mkLocalVarmkCoVarmkExportedLocalVar lazySetIdInfo setIdDetails globaliseId setIdExportedsetIdNotExportedupdateIdTypeButNotMultupdateIdTypeAndMultupdateIdTypeAndMultM setIdMultisTyVar isTcTyVar isTyCoVarisIdisCoVar isNonCoVarId isLocalId isLocalVar isGlobalIdmustHaveLocalBinding isExportedId$fHasOccNameVar $fDataVar$fOrdVar$fEqVar$fUniquableVar$fNamedThingVar$fOutputableVar$fBinarySpecificity$fBinaryArgFlag$fOutputableArgFlag$fBinaryAnonArgFlag$fOutputableAnonArgFlag$fNamedThingVarBndr$fBinaryVarBndr$fOutputableVarBndr$fOutputableVarBndr0 $fDataVarBndr$fEqAnonArgFlag$fOrdAnonArgFlag$fDataAnonArgFlag $fEqArgFlag $fOrdArgFlag $fDataArgFlag$fEqSpecificity$fOrdSpecificity$fDataSpecificity DTyCoVarSet DTyVarSetDIdSetDVarSet TyCoVarSetCoVarSetTyVarSetIdSetVarSet emptyVarSet unitVarSet extendVarSetextendVarSetListintersectVarSet unionVarSet unionVarSets elemVarSet minusVarSet delVarSet delVarSetList isEmptyVarSetmkVarSetlookupVarSet_Directly lookupVarSetlookupVarSetByName sizeVarSet filterVarSetdelVarSetByKeyelemVarSetByKeypartitionVarSetmapUnionVarSetintersectsVarSetdisjointVarSet subVarSet anyVarSet allVarSet mapVarSetnonDetStrictFoldVarSet fixVarSettransCloVarSet seqVarSet pluralVarSet pprVarSet emptyDVarSet unitDVarSet mkDVarSet extendDVarSet elemDVarSet dVarSetElems subDVarSet unionDVarSet unionDVarSetsmapUnionDVarSetintersectDVarSetdVarSetIntersectVarSetdisjointDVarSetintersectsDVarSetisEmptyDVarSet delDVarSet minusDVarSetdVarSetMinusVarSetnonDetStrictFoldDVarSet anyDVarSet allDVarSet mapDVarSet filterDVarSet sizeDVarSetpartitionDVarSetdelDVarSetList seqDVarSetextendDVarSetListdVarSetToVarSettransCloDVarSetFVInterestingVarFun fvVarList fvDVarSetfvVarSetunitFVemptyFVunionFVdelFVdelFVsfilterFV mapUnionFVunionsFVmkFVs CollectedCCsCostCentreStack CCFlavourCafCCExprCCDeclCCHpcCCLateCCCcName CostCentreNormalCC AllCafsCCcc_namecc_modcc_loc cmpCostCentreisCafCC isSccCountCC sccAbleCCccFromThisModulemkUserCCmkAutoCC mkAllCafsCCemptyCollectedCCs collectCC currentCCS dontCareCCS isCurrentCCSisCafCCSmaybeSingletonCCSmkSingletonCCSpprCostCentreCorecostCentreUserNamecostCentreUserNameFScostCentreSrcSpan$fBinaryCCFlavour$fBinaryCostCentre$fOutputableCostCentre$fOrdCostCentre$fEqCostCentre$fOutputableCostCentreStack$fEqCostCentreStack$fOrdCostCentreStack$fDataCostCentre $fEqCCFlavour$fOrdCCFlavour$fDataCCFlavourDNameEnvNameEnvdepAnalnonDetNameEnvElts emptyNameEnvisEmptyNameEnv unitNameEnv extendNameEnvextendNameEnvList lookupNameEnv alterNameEnv mkNameEnv mkNameEnvWith elemNameEnv plusNameEnv plusNameEnv_CplusNameEnv_CDplusNameEnv_CD2extendNameEnv_C mapNameEnvextendNameEnv_AccextendNameEnvList_CdelFromNameEnvdelListFromNameEnv filterNameEnv anyNameEnvdisjointNameEnvseqEltsNameEnvlookupNameEnv_NF emptyDNameEnvisEmptyDNameEnvlookupDNameEnvdelFromDNameEnvfilterDNameEnv mapDNameEnvadjustDNameEnv alterDNameEnvextendDNameEnvextendDNameEnv_C eltsDNameEnv foldDNameEnvplusDNameEnv_CnonDetStrictFoldDNameEnvfingerprintBinMemcomputeFingerprintputNameLiterally DTyVarEnvDIdEnvDVarEnvCoVarEnv TyCoVarEnvTyVarEnvIdEnvVarEnvTidyEnvRnEnv2 InScopeSetemptyInScopeSetgetInScopeVars mkInScopeSetextendInScopeSetextendInScopeSetListextendInScopeSetSet delInScopeSetelemInScopeSet lookupInScopelookupInScope_Directly unionInScope varSetInScopeuniqAwayunsafeGetFreshLocalUniquemkRnEnv2extendRnInScopeSetList rnInScope rnInScopeSetrnEnvLrnEnvRrnBndrs2rnBndr2 rnBndr2_varrnBndrLrnBndrRrnEtaLrnEtaRdelBndrLdelBndrR delBndrsL delBndrsRrnOccLrnOccR rnOccL_maybe rnOccR_maybeinRnEnvLinRnEnvRlookupRnInScope nukeRnEnvL nukeRnEnvRrnSwap emptyTidyEnvmkEmptyTidyEnvdelTidyEnvList elemVarEnvelemVarEnvByKeydisjointVarEnv alterVarEnv extendVarEnvextendVarEnv_CextendVarEnv_AccextendVarEnvList plusVarEnv_C plusVarEnv_CDplusMaybeVarEnv_C delVarEnvList delVarEnv minusVarEnv plusVarEnvplusVarEnvList lookupVarEnvlookupVarEnv_Directly filterVarEnvlookupWithDefaultVarEnv mapVarEnvmkVarEnvmkVarEnv_Directly emptyVarEnv unitVarEnv isEmptyVarEnvpartitionVarEnvrestrictVarEnv zipVarEnvlookupVarEnv_NF modifyVarEnvmodifyVarEnv_Directly emptyDVarEnv dVarEnvElts mkDVarEnv extendDVarEnv minusDVarEnv lookupDVarEnv foldDVarEnvnonDetStrictFoldDVarEnv mapDVarEnv filterDVarEnv alterDVarEnv plusDVarEnv plusDVarEnv_C unitDVarEnv delDVarEnvdelDVarEnvListisEmptyDVarEnv elemDVarEnvextendDVarEnv_C modifyDVarEnvpartitionDVarEnvextendDVarEnvList anyDVarEnv$fOutputableInScopeSetpFstpSndunPairtoPairswappLiftFstpLiftSnd$fOutputablePair $fMonoidPair$fSemigroupPair$fApplicativePairBuiltInSynFamily sfMatchFam sfInteractTopsfInteractInert CoAxiomRule coaxrNamecoaxrAsmpRoles coaxrRole coaxrProvesTypeEqnRoleNominalRepresentationalPhantom CoAxBranchcab_loccab_tvs cab_eta_tvscab_cvs cab_rolescab_lhscab_rhs cab_incompsCoAxiom co_ax_unique co_ax_name co_ax_roleco_ax_tcco_ax_branchesco_ax_implicitBranches MkBranches unMkBranches UnbranchedBranched BranchFlag BranchIndex manyBranches unbranched fromBranches numBranchesmapAccumBranchestoBranchedAxiomtoUnbranchedAxiomcoAxiomNumPatscoAxiomNthBranch coAxiomArity coAxiomName coAxiomRolecoAxiomBranchescoAxiomSingleBranch_maybecoAxiomSingleBranch coAxiomTyConcoAxBranchTyVarscoAxBranchCoVars coAxBranchLHS coAxBranchRHScoAxBranchRolescoAxBranchSpanisImplicitCoAxiomcoAxBranchIncompsplaceHolderIncomps fsFromRoletrivialBuiltInFamily $fBinaryRole$fOutputableRole$fOutputableCoAxBranch $fDataCoAxiom$fNamedThingCoAxiom$fOutputableCoAxiom$fUniquableCoAxiom $fEqCoAxiom$fOutputableCoAxiomRule$fOrdCoAxiomRule$fEqCoAxiomRule$fUniquableCoAxiomRule$fDataCoAxiomRule$fDataCoAxBranch$fEqRole $fOrdRole $fDataRoleLiftingContexttopNormaliseNewType_maybe coercionType coercionRKind coercionLKind coercionKindseqCo liftCoSubstmkCoercionType coVarRolecoVarKindsTypesRoledecomposePiCos isReflexiveCoisReflCo isGReflCo mkAxiomRuleComkProofIrrelComkSubComkKindCo mkNomReflCo mkGReflComkInstComkLRComkNthCo mkTransComkSymComkUnivCo mkPhantomCo mkAxiomInstCo mkCoVarComkFunCo mkForAllComkAppCo mkTyConAppComkReflCoOrdListSnocOLConsOLNilOLnilOLunitOLsnocOLconsOLconcatOLheadOLlastOLisNilOLappOLfromOL fromOLReversemapOLmapOL'foldrOLfoldlOLtoOL reverseOL strictlyEqOL strictlyOrdOL$fTraversableOrdList$fFoldableOrdList$fMonoidOrdList$fSemigroupOrdList$fOutputableOrdList$fFunctorOrdList NonCaffySet ncs_nameSetDefUsesDefUseUsesDefsFreeVarsNameSetisEmptyNameSet emptyNameSet unitNameSet mkNameSetextendNameSetList extendNameSet unionNameSet unionNameSets minusNameSet elemNameSetdelFromNameSet filterNameSetintersectNameSetdisjointNameSetdelListFromNameSetintersectsNameSet nameSetAny nameSetAllnameSetElemsStable isEmptyFVsemptyFVsplusFVsplusFVaddOneFV intersectFVsemptyDUsusesOnlymkDUsplusDUduDefsallUsesduUsesfindUses$fSemigroupNonCaffySet$fMonoidNonCaffySetAssocgetNth unionLists minusListassocDefaultUsingassoc assocDefault assocUsing assocMaybe hasNoDups equivClasses removeDupsnubOrdBy findDupsEqisInisn'tInGreName NormalGreName FieldGreNameAvails AvailInfoAvailAvailTCstableAvailCmpstableGreNameCmpavail availFieldavailTCavailsToNameSetavailsToNameSetWithSelectorsavailsToNameEnvavailExportsDecl availName availGreName availNamesavailNamesWithSelectorsavailNonFldNames availFlds availGreNamesavailSubordinateGreNamesgreNameMangledNamegreNamePrintableNamegreNameSrcSpangreNameFieldLabelpartitionGreNames plusAvail trimAvail filterAvails filterAvail nubAvails$fBinaryGreName$fHasOccNameGreName$fOutputableGreName$fBinaryAvailInfo$fOutputableAvailInfo $fEqAvailInfo$fDataAvailInfo $fDataGreName $fEqGreNameBagemptyBagunitBag lengthBagelemBag unionManyBags unionBagsconsBagsnocBag isEmptyBagisSingletonBag filterBag filterBagMallBaganyBaganyBagM concatBag catBagMaybes partitionBagpartitionBagWithfoldBagmapBag concatMapBagconcatMapBagPair mapMaybeBagmapBagMmapBagM_ flatMapBagMflatMapBagPairMmapAndUnzipBagM mapAccumBagL mapAccumBagLM listToBag nonEmptyToBag bagToList headMaybe $fMonoidBag$fSemigroupBag $fIsListBag$fTraversableBag $fFoldableBag $fDataBag$fOutputableBag $fFunctorBag ImpItemSpecImpAllImpSome is_explicitis_iloc ImpDeclSpecis_modis_asis_qualis_dloc ImportSpecImpSpecis_declis_itemParentNoParentParentIspar_is GlobalRdrEltGREgre_namegre_pargre_lclgre_imp GlobalRdrEnv LocalRdrEnvUnqualQualOrigExact rdrNameOcc rdrNameSpace demoteRdrNamepromoteRdrName mkRdrUnqual mkRdrQualmkOrigmkUnqual mkVarUnqualmkQual getRdrName nameRdrName isRdrDataCon isRdrTyVarisRdrTc isSrcRdrNameisUnqualisQual isQual_maybeisOrig isOrig_maybeisExact isExact_maybeemptyLocalRdrEnvextendLocalRdrEnvextendLocalRdrEnvListlookupLocalRdrEnvlookupLocalRdrOccelemLocalRdrEnvlocalRdrEnvEltsinLocalRdrEnvScopeminusLocalRdrEnvgresFromAvailslocalGREsFromAvail gresFromAvail greOccNamegreMangledNamegrePrintableNamegreDefinitionSrcSpangreDefinitionModulegreQualModName greRdrNames greSrcSpangreParent_maybegresToAvailInfo availFromGREemptyGlobalRdrEnvglobalRdrEnvEltspprGlobalRdrEnvlookupGlobalRdrEnvlookupGRE_RdrNamelookupGRE_RdrName'lookupGRE_NamelookupGRE_GreNamelookupGRE_FieldLabellookupGRE_Name_OccNamegetGRE_NameQualifier_maybes isLocalGRE isRecFldGREisDuplicateRecFldGREisNoFieldSelectorGREisFieldSelectorGRE greFieldLabelunQualOKpickGREspickGREsModExpplusGlobalRdrEnvmkGlobalRdrEnv transformGREsextendGlobalRdrEnv shadowNames bestImport unQualSpecOK qualSpecOK importSpecLocimportSpecModuleisExplicitItempprNameProvenanceopIsAt $fOrdRdrName $fEqRdrName$fOutputableBndrRdrName$fOutputableRdrName$fHasOccNameRdrName$fOutputableLocalRdrEnv$fOutputableParent$fOutputableImportSpec$fOutputableGlobalRdrElt$fHasOccNameGlobalRdrElt$fDataGlobalRdrElt$fEqImportSpec$fDataImportSpec$fEqImpItemSpec$fDataImpItemSpec$fEqImpDeclSpec$fDataImpDeclSpec $fEqParent $fDataParent $fDataRdrNameallNameStringsitName mkUnboundName isUnboundNamebasicKnownKeyNamesgenericTyConNamespRELUDEgHC_PRIMgHC_PRIM_PANICgHC_PRIM_EXCEPTION gHC_TYPES gHC_MAGICgHC_MAGIC_DICT gHC_CSTRING gHC_CLASSESgHC_PRIMOPWRAPPERSgHC_BASEgHC_ENUMgHC_GHCIgHC_GHCI_HELPERSgHC_SHOWgHC_READgHC_NUM gHC_MAYBEgHC_NUM_INTEGERgHC_NUM_NATURALgHC_NUM_BIGNATgHC_LIST gHC_TUPLE dATA_EITHER dATA_VOID dATA_LIST dATA_STRING dATA_FOLDABLEdATA_TRAVERSABLEgHC_CONCgHC_IOgHC_IO_ExceptiongHC_STgHC_IX gHC_STABLEgHC_PTRgHC_ERRgHC_REAL gHC_FLOATgHC_TOP_HANDLER sYSTEM_IOdYNAMICtYPEABLEtYPEABLE_INTERNALgENERICS rEAD_PREClEXgHC_INTgHC_WORDmONAD mONAD_FIX mONAD_ZIP mONAD_FAILaRROW gHC_DESUGARrANDOMgHC_EXTS gHC_IS_LISTcONTROL_EXCEPTION_BASE gHC_GENERICS gHC_TYPEERROR gHC_TYPELITSgHC_TYPELITS_INTERNAL gHC_TYPENATSgHC_TYPENATS_INTERNAL dATA_COERCE dEBUG_TRACE uNSAFE_COERCE gHC_SRCLOC gHC_STACKgHC_STACK_TYPES gHC_STATICPTRgHC_STATICPTR_INTERNALgHC_FINGERPRINT_TYPEgHC_OVER_LABELS gHC_RECORDS rOOT_MAINmkInteractiveModule pRELUDE_NAME mAIN_NAME mkPrimModulemkBignumModule mkBaseModule mkBaseModule_mkThisGhcModulemkThisGhcModule_ mkMainModule mkMainModule_main_RDR_Unqualeq_RDRge_RDRle_RDRlt_RDRgt_RDR compare_RDR ltTag_RDR eqTag_RDR gtTag_RDR eqClass_RDR numClass_RDR ordClass_RDR enumClass_RDRmonadClass_RDRmap_RDR append_RDR foldr_RDR build_RDR returnM_RDR bindM_RDR failM_RDRleft_RDR right_RDR fromEnum_RDR toEnum_RDR enumFrom_RDRenumFromTo_RDRenumFromThen_RDRenumFromThenTo_RDRratioDataCon_RDRintegerAdd_RDRintegerMul_RDR ioDataCon_RDRnewStablePtr_RDR bindIO_RDR returnIO_RDRfromInteger_RDRfromRational_RDR minus_RDR times_RDRplus_RDR toInteger_RDRtoRational_RDRfromIntegral_RDRfromString_RDR fromList_RDR fromListN_RDR toList_RDR compose_RDRand_RDRnot_RDR dataToTag_RDRsucc_RDRpred_RDR minBound_RDR maxBound_RDR range_RDR inRange_RDR index_RDRunsafeIndex_RDRunsafeRangeSize_RDR readList_RDRreadListDefault_RDRreadListPrec_RDRreadListPrecDefault_RDR readPrec_RDR parens_RDR choose_RDRlexP_RDR expectP_RDR readField_RDRreadFieldHash_RDRreadSymField_RDRpunc_RDR ident_RDR symbol_RDRstep_RDRalt_RDR reset_RDRprec_RDR pfail_RDR showsPrec_RDR shows_RDRshowString_RDR showSpace_RDRshowCommaSpace_RDR showParen_RDR error_RDR u1DataCon_RDRpar1DataCon_RDRrec1DataCon_RDR k1DataCon_RDR m1DataCon_RDR l1DataCon_RDR r1DataCon_RDRprodDataCon_RDRcomp1DataCon_RDR unPar1_RDR unRec1_RDRunK1_RDR unComp1_RDRfrom_RDR from1_RDRto_RDRto1_RDRdatatypeName_RDRmoduleName_RDRpackageName_RDRisNewtypeName_RDR selName_RDR conName_RDR conFixity_RDRconIsRecord_RDRprefixDataCon_RDRinfixDataCon_RDRleftAssocDataCon_RDRrightAssocDataCon_RDRnotAssocDataCon_RDRuAddrDataCon_RDRuCharDataCon_RDRuDoubleDataCon_RDRuFloatDataCon_RDRuIntDataCon_RDRuWordDataCon_RDR uAddrHash_RDR uCharHash_RDRuDoubleHash_RDRuFloatHash_RDR uIntHash_RDR uWordHash_RDRfmap_RDR replace_RDRpure_RDRap_RDR liftA2_RDRfoldable_foldr_RDR foldMap_RDRnull_RDRall_RDR traverse_RDR mempty_RDR mappend_RDR varQual_RDR tcQual_RDR clsQual_RDR dataQual_RDR wildCardName runMainIOName runRWNameorderingTyConNameordLTDataConNameordEQDataConNameordGTDataConName specTyConNameeitherTyConNameleftDataConNamerightDataConName voidTyConName v1TyConName u1TyConName par1TyConName rec1TyConName k1TyConName m1TyConName sumTyConName prodTyConName compTyConName rTyConName dTyConName cTyConName sTyConName rec0TyConName d1TyConName c1TyConName s1TyConName repTyConName rep1TyConName uRecTyConNameuAddrTyConNameuCharTyConNameuDoubleTyConNameuFloatTyConName uIntTyConNameuWordTyConNameprefixIDataConNameinfixIDataConNameleftAssociativeDataConNamerightAssociativeDataConNamenotAssociativeDataConNamesourceUnpackDataConNamesourceNoUnpackDataConNamenoSourceUnpackednessDataConNamesourceLazyDataConNamesourceStrictDataConNamenoSourceStrictnessDataConNamedecidedLazyDataConNamedecidedStrictDataConNamedecidedUnpackDataConNamemetaDataDataConNamemetaConsDataConNamemetaSelDataConName divIntName modIntNamecstringLengthName eqStringNameunpackCStringNameunpackCStringAppendNameunpackCStringFoldrNameunpackCStringUtf8NameunpackCStringAppendUtf8NameunpackCStringFoldrUtf8Name inlineIdName eqClassNameeqName ordClassNamegeNamefunctorClassNamefmapNamemonadClassName thenMName bindMName returnMNamemonadFailClassName failMNameapplicativeClassNameapAName pureAName thenANamefoldableClassNametraversableClassNamesemigroupClassName sappendNamemonoidClassName memptyName mappendName mconcatName joinMNamealternativeClassName joinMIdKey apAClassOpKeypureAClassOpKeythenAClassOpKeyalternativeClassKey groupWithNameconsiderAccessibleName dollarNameotherwiseIdName foldrName buildName augmentNamemapName appendName assertNamefromStringName numClassNamefromIntegerName minusName negateName bnbVarQual bnnVarQual bniVarQualbignatFromWordListName bignatEqNamebignatCompareNamebignatCompareWordNamenaturalToWordNamenaturalPopCountNamenaturalShiftRNamenaturalShiftLNamenaturalAddNamenaturalSubNamenaturalSubThrowNamenaturalSubUnsafeNamenaturalMulNamenaturalQuotRemNamenaturalQuotNamenaturalRemNamenaturalAndNamenaturalAndNotName naturalOrNamenaturalXorNamenaturalTestBitNamenaturalBitNamenaturalGcdNamenaturalLcmNamenaturalLog2NamenaturalLogBaseWordNamenaturalLogBaseNamenaturalPowModNamenaturalSizeInBaseNameintegerFromNaturalNameintegerToNaturalClampNameintegerToNaturalThrowNameintegerToNaturalNameintegerToWordNameintegerToIntNameintegerToWord64NameintegerToInt64NameintegerFromWordNameintegerFromWord64NameintegerFromInt64NameintegerAddNameintegerMulNameintegerSubNameintegerNegateNameintegerAbsNameintegerPopCountNameintegerQuotNameintegerRemNameintegerDivNameintegerModNameintegerDivModNameintegerQuotRemNameintegerEncodeFloatNameintegerEncodeDoubleNameintegerGcdNameintegerLcmNameintegerAndName integerOrNameintegerXorNameintegerComplementNameintegerBitNameintegerTestBitNameintegerShiftLNameintegerShiftRNamerationalTyConNameratioTyConNameratioDataConName realClassNameintegralClassNamerealFracClassNamefractionalClassNamefromRationalName toIntegerNametoRationalNamefromIntegralNamerealToFracNamemkRationalBase2NamemkRationalBase10NamefloatingClassNamerealFloatClassNameintegerToFloatNameintegerToDoubleNamenaturalToFloatNamenaturalToDoubleNamerationalToFloatNamerationalToDoubleName ixClassNametrModuleTyConNametrModuleDataConNametrNameTyConNametrNameSDataConNametrNameDDataConNametrTyConTyConNametrTyConDataConNamekindRepTyConNamekindRepTyConAppDataConNamekindRepVarDataConNamekindRepAppDataConNamekindRepFunDataConNamekindRepTYPEDataConNamekindRepTypeLitSDataConNamekindRepTypeLitDDataConNametypeLitSortTyConNametypeLitSymbolDataConNametypeLitNatDataConNametypeLitCharDataConNametypeableClassNametypeRepTyConNamesomeTypeRepTyConNamesomeTypeRepDataConName typeRepIdName mkTrTypeName mkTrConName mkTrAppName mkTrFunNametypeNatTypeRepNametypeSymbolTypeRepNametypeCharTypeRepNametrGhcPrimModuleNamestarKindRepNamestarArrStarKindRepNamestarArrStarArrStarKindRepNamewithDictClassNameerrorMessageTypeErrorFamNametypeErrorTextDataConNametypeErrorAppendDataConNametypeErrorVAppendDataConNametypeErrorShowTypeDataConNameunsafeEqualityProofNameunsafeEqualityTyConNameunsafeReflDataConNameunsafeCoercePrimName toDynName dataClassNameassertErrorName traceName enumClassName enumFromNameenumFromToNameenumFromThenNameenumFromThenToNameboundedClassName concatName filterNamezipNameisListClassName fromListName fromListNName toListName getFieldName setFieldName showClassName readClassName genClassName gen1ClassNamedatatypeClassNameconstructorClassNameselectorClassNamegenericClassNamesghciIoClassNameghciStepIoMName ioTyConName ioDataConName thenIOName bindIOName returnIOName failIOName printName int8TyConNameint16TyConNameint32TyConNameint64TyConNameword8TyConNameword16TyConNameword32TyConNameword64TyConName ptrTyConNamefunPtrTyConNamestablePtrTyConNamenewStablePtrNamemonadFixClassNamemfixNamearrAName composeAName firstANameappAName choiceAName loopAName guardMName liftMNamemzipNametoAnnotationWrapperNamemonadPlusClassNamerandomClassNamerandomGenClassNameisStringClassNameknownNatClassNameknownSymbolClassNameknownCharClassNamefromLabelClassOpName ipClassNamehasFieldClassNamecallStackTyConNameemptyCallStackNamepushCallStackNamesrcLocDataConNamepLUGINSpluginTyConNamefrontendPluginTyConNamemakeStaticNamestaticPtrInfoTyConNamestaticPtrInfoDataConNamestaticPtrTyConNamestaticPtrDataConNamefromStaticPtrNamefingerprintDataConNamevarQualtcQualclsQualdcQualmk_known_key_nameboundedClassKey enumClassKey eqClassKeyfloatingClassKeyfractionalClassKeyintegralClassKey monadClassKey dataClassKeyfunctorClassKey numClassKey ordClassKey readClassKey realClassKeyrealFloatClassKeyrealFracClassKey showClassKey ixClassKeytypeableClassKeywithDictClassKeymonadFixClassKeymonadFailClassKeymonadPlusClassKeyrandomClassKeyrandomGenClassKeyisStringClassKeyapplicativeClassKeyfoldableClassKeytraversableClassKey genClassKey gen1ClassKeydatatypeClassKeyconstructorClassKeyselectorClassKeyknownNatClassNameKeyknownSymbolClassNameKeyknownCharClassNameKeyghciIoClassKeysemigroupClassKeymonoidClassKey ipClassKeyhasFieldClassNameKeyaddrPrimTyConKeyarrayPrimTyConKey boolTyConKeybyteArrayPrimTyConKeystringTyConKeycharPrimTyConKey charTyConKeydoublePrimTyConKeydoubleTyConKeyfloatPrimTyConKey floatTyConKey funTyConKeyintPrimTyConKey intTyConKeyint8PrimTyConKey int8TyConKeyint16PrimTyConKey int16TyConKeyint32PrimTyConKey int32TyConKeyint64PrimTyConKey int64TyConKeyintegerTyConKeynaturalTyConKey listTyConKeyforeignObjPrimTyConKey maybeTyConKeyweakPrimTyConKeymutableArrayPrimTyConKeymutableByteArrayPrimTyConKeyorderingTyConKeymVarPrimTyConKeyioPortPrimTyConKey ratioTyConKeyrationalTyConKeyrealWorldTyConKeystablePtrPrimTyConKeystablePtrTyConKey eqTyConKey heqTyConKeystatePrimTyConKeystableNamePrimTyConKeystableNameTyConKeyeqPrimTyConKeyeqReprPrimTyConKeyeqPhantPrimTyConKeymutVarPrimTyConKey ioTyConKeywordPrimTyConKey wordTyConKeyword8PrimTyConKey word8TyConKeyword16PrimTyConKeyword16TyConKeyword32PrimTyConKeyword32TyConKeyword64PrimTyConKeyword64TyConKey kindConKey boxityConKey typeConKeythreadIdPrimTyConKeybcoPrimTyConKey ptrTyConKeyfunPtrTyConKeytVarPrimTyConKeycompactPrimTyConKeystackSnapshotPrimTyConKeyeitherTyConKey voidTyConKeynonEmptyTyConKeyliftedTypeKindTyConKeyunliftedTypeKindTyConKey tYPETyConKeyconstraintKindTyConKeylevityTyConKeyruntimeRepTyConKeyvecCountTyConKeyvecElemTyConKeyliftedRepTyConKeyunliftedRepTyConKeyzeroBitRepTyConKeyzeroBitTypeTyConKeypluginTyConKeyfrontendPluginTyConKeytrTyConTyConKeytrModuleTyConKeytrNameTyConKeykindRepTyConKeytypeLitSortTyConKey v1TyConKey u1TyConKey par1TyConKey rec1TyConKey k1TyConKey m1TyConKey sumTyConKey prodTyConKey compTyConKey rTyConKey dTyConKey cTyConKey sTyConKey rec0TyConKey d1TyConKey c1TyConKey s1TyConKey repTyConKey rep1TyConKey uRecTyConKey uAddrTyConKey uCharTyConKeyuDoubleTyConKeyuFloatTyConKey uIntTyConKey uWordTyConKeyerrorMessageTypeErrorFamKeycoercibleTyConKeyproxyPrimTyConKey specTyConKey anyTyConKeysmallArrayPrimTyConKeysmallMutableArrayPrimTyConKeystaticPtrTyConKeystaticPtrInfoTyConKeycallStackTyConKeytypeRepTyConKeysomeTypeRepTyConKeysomeTypeRepDataConKeytypeSymbolAppendFamNameKeyunsafeEqualityTyConKeymultiplicityTyConKeyunrestrictedFunTyConKeymultMulTyConKeyint8X16PrimTyConKeyint16X8PrimTyConKeyint32X4PrimTyConKeyint64X2PrimTyConKeyint8X32PrimTyConKeyint16X16PrimTyConKeyint32X8PrimTyConKeyint64X4PrimTyConKeyint8X64PrimTyConKeyint16X32PrimTyConKeyint32X16PrimTyConKeyint64X8PrimTyConKeyword8X16PrimTyConKeyword16X8PrimTyConKeyword32X4PrimTyConKeyword64X2PrimTyConKeyword8X32PrimTyConKeyword16X16PrimTyConKeyword32X8PrimTyConKeyword64X4PrimTyConKeyword8X64PrimTyConKeyword16X32PrimTyConKeyword32X16PrimTyConKeyword64X8PrimTyConKeyfloatX4PrimTyConKeydoubleX2PrimTyConKeyfloatX8PrimTyConKeydoubleX4PrimTyConKeyfloatX16PrimTyConKeydoubleX8PrimTyConKeytypeSymbolKindConNameKeytypeCharKindConNameKeytypeNatAddTyFamNameKeytypeNatMulTyFamNameKeytypeNatExpTyFamNameKeytypeNatSubTyFamNameKeytypeSymbolCmpTyFamNameKeytypeNatCmpTyFamNameKeytypeCharCmpTyFamNameKeytypeLeqCharTyFamNameKeytypeNatDivTyFamNameKeytypeNatModTyFamNameKeytypeNatLogTyFamNameKeytypeConsSymbolTyFamNameKeytypeUnconsSymbolTyFamNameKeytypeCharToNatTyFamNameKeytypeNatToCharTyFamNameKeycharDataConKeyconsDataConKeydoubleDataConKeyfalseDataConKeyfloatDataConKey intDataConKeynothingDataConKeyjustDataConKey eqDataConKey nilDataConKeyratioDataConKeyword8DataConKeystableNameDataConKeytrueDataConKeywordDataConKey ioDataConKey heqDataConKeynonEmptyDataConKeycrossDataConKey inlDataConKey inrDataConKeygenUnitDataConKeyleftDataConKeyrightDataConKeyordLTDataConKeyordEQDataConKeyordGTDataConKeycoercibleDataConKeystaticPtrDataConKeystaticPtrInfoDataConKeyfingerprintDataConKeysrcLocDataConKeytrTyConDataConKeytrModuleDataConKeytrNameSDataConKeytrNameDDataConKeytrGhcPrimModuleKeytypeErrorTextDataConKeytypeErrorAppendDataConKeytypeErrorVAppendDataConKeytypeErrorShowTypeDataConKeyprefixIDataConKeyinfixIDataConKeyleftAssociativeDataConKeyrightAssociativeDataConKeynotAssociativeDataConKeysourceUnpackDataConKeysourceNoUnpackDataConKeynoSourceUnpackednessDataConKeysourceLazyDataConKeysourceStrictDataConKeynoSourceStrictnessDataConKeydecidedLazyDataConKeydecidedStrictDataConKeydecidedUnpackDataConKeymetaDataDataConKeymetaConsDataConKeymetaSelDataConKeyvecRepDataConKeytupleRepDataConKeysumRepDataConKeyboxedRepDataConKeyboxedRepDataConTyConKeytupleRepDataConTyConKeyruntimeRepSimpleDataConKeysliftedDataConKeyunliftedDataConKeyvecCountDataConKeysvecElemDataConKeyskindRepTyConAppDataConKeykindRepVarDataConKeykindRepAppDataConKeykindRepFunDataConKeykindRepTYPEDataConKeykindRepTypeLitSDataConKeykindRepTypeLitDDataConKeytypeLitSymbolDataConKeytypeLitNatDataConKeytypeLitCharDataConKeyunsafeReflDataConKey oneDataConKeymanyDataConKeyintegerISDataConKeyintegerINDataConKeyintegerIPDataConKeynaturalNSDataConKeynaturalNBDataConKey wildCardKeyabsentErrorIdKey augmentIdKey appendIdKey buildIdKey foldrIdKeyrecSelErrorIdKeyseqIdKeyabsentSumFieldErrorIdKey eqStringIdKeynoMethodBindingErrorIdKeynonExhaustiveGuardsErrorIdKeyruntimeErrorIdKey patErrorIdKeyrealWorldPrimIdKeyrecConErrorIdKeyunpackCStringUtf8IdKeyunpackCStringAppendUtf8IdKeyunpackCStringFoldrUtf8IdKeyunpackCStringIdKeyunpackCStringAppendIdKeyunpackCStringFoldrIdKey voidPrimIdKeytypeErrorIdKey divIntIdKey modIntIdKeycstringLengthIdKeyraiseOverflowIdKeyraiseUnderflowIdKeyraiseDivZeroIdKey concatIdKey filterIdKeyzipIdKey bindIOIdKey returnIOIdKeynewStablePtrIdKey printIdKey failIOIdKey nullAddrIdKey voidArgIdKeyotherwiseIdKey assertIdKeyleftSectionKeyrightSectionKey rootMainKey runMainKey thenIOIdKey lazyIdKeyassertErrorIdKey oneShotKeyrunRWKeytraceKey inlineIdKeymapIdKeygroupWithIdKey dollarIdKeycoercionTokenIdKey noinlineIdKeyconsiderAccessibleIdKeyintegerToFloatIdKeyintegerToDoubleIdKeynaturalToFloatIdKeynaturalToDoubleIdKeyrationalToFloatIdKeyrationalToDoubleIdKey coerceKey unboundKeyfromIntegerClassOpKeyminusClassOpKeyfromRationalClassOpKeyenumFromClassOpKeyenumFromThenClassOpKeyenumFromToClassOpKeyenumFromThenToClassOpKey eqClassOpKey geClassOpKeynegateClassOpKeybindMClassOpKeythenMClassOpKeyfmapClassOpKeyreturnMClassOpKey mfixIdKeyfailMClassOpKeyfromLabelClassOpKey arrAIdKey composeAIdKey firstAIdKey appAIdKey choiceAIdKey loopAIdKeyfromStringClassOpKeytoAnnotationWrapperIdKeyfromIntegralIdKeyrealToFracIdKeytoIntegerClassOpKeytoRationalClassOpKey guardMIdKey liftMIdKey mzipIdKeyghciStepIoMClassOpKeyisListClassKeyfromListClassOpKeyfromListNClassOpKeytoListClassOpKey proxyHashKey mkTyConKey mkTrTypeKey mkTrConKey mkTrAppKeytypeNatTypeRepKeytypeSymbolTypeRepKeytypeCharTypeRepKey typeRepIdKey mkTrFunKey trTYPEKeytrTYPE'PtrRepLiftedKeytrRuntimeRepKeytr'PtrRepLiftedKeytrLiftedRepKeystarKindRepKeystarArrStarKindRepKeystarArrStarArrStarKindRepKey toDynIdKeybitIntegerIdKey eqSCSelIdKey heqSCSelIdKeycoercibleSCSelIdKeysappendClassOpKeymemptyClassOpKeymappendClassOpKeymconcatClassOpKeyemptyCallStackKeypushCallStackKeyfromStaticPtrClassOpKey makeStaticKeyunsafeEqualityProofIdKeyunsafeCoercePrimIdKeygetFieldClassOpKeysetFieldClassOpKeyintegerFromNaturalIdKeyintegerToNaturalClampIdKeyintegerToNaturalThrowIdKeyintegerToNaturalIdKeyintegerToWordIdKeyintegerToIntIdKeyintegerToWord64IdKeyintegerToInt64IdKeyintegerAddIdKeyintegerMulIdKeyintegerSubIdKeyintegerNegateIdKeyintegerAbsIdKeyintegerPopCountIdKeyintegerQuotIdKeyintegerRemIdKeyintegerDivIdKeyintegerModIdKeyintegerDivModIdKeyintegerQuotRemIdKeyintegerEncodeFloatIdKeyintegerEncodeDoubleIdKeyintegerGcdIdKeyintegerLcmIdKeyintegerAndIdKeyintegerOrIdKeyintegerXorIdKeyintegerComplementIdKeyintegerBitIdKeyintegerTestBitIdKeyintegerShiftLIdKeyintegerShiftRIdKeyintegerFromWordIdKeyintegerFromWord64IdKeyintegerFromInt64IdKeynaturalToWordIdKeynaturalPopCountIdKeynaturalShiftRIdKeynaturalShiftLIdKeynaturalAddIdKeynaturalSubIdKeynaturalSubThrowIdKeynaturalSubUnsafeIdKeynaturalMulIdKeynaturalQuotRemIdKeynaturalQuotIdKeynaturalRemIdKeynaturalAndIdKeynaturalAndNotIdKeynaturalOrIdKeynaturalXorIdKeynaturalTestBitIdKeynaturalBitIdKeynaturalGcdIdKeynaturalLcmIdKeynaturalLog2IdKeynaturalLogBaseWordIdKeynaturalLogBaseIdKeynaturalPowModIdKeynaturalSizeInBaseIdKeybignatFromWordListIdKey bignatEqIdKeybignatCompareIdKeybignatCompareWordIdKeymkRationalBase2IdKeymkRationalBase10IdKeynumericClassKeysfractionalClassKeysstandardClassKeysderivableClassKeysinteractiveClassNamesinteractiveClassKeyspretendNameIsInScope ForeignStubsNoStubsCHeader getCHeaderCStubgetCStubgetInitializers getFinalizersinitializerCStubfinalizerCStub appendStubC$fSemigroupCStub $fMonoidCStub$fSemigroupCHeader$fMonoidCHeader LexicalFixityPrefixInfixFixityDirectionInfixLInfixRInfixNFixity maxPrecedence minPrecedence defaultFixity negateFixity funTyFixity compareFixity$fBinaryFixityDirection$fOutputableFixityDirection$fBinaryFixity $fEqFixity$fOutputableFixity$fOutputableLexicalFixity$fDataLexicalFixity$fEqLexicalFixity $fDataFixity$fEqFixityDirection$fDataFixityDirectionDoAlignSanitisation ForeignHintNoHintAddrHint SignedHintLengthWidthW8W16W32W64W128W256W512CmmType cmmEqTypecmmEqType_ignoring_ptrhood typeWidthcmmBitscmmFloatb8b16b32b64b128b256b512f32f64bWord bHalfWordgcWordcInt isFloatType isGcPtrType isBitsType isWordAnyisWord64isWord32 isFloat32 isFloat64 wordWidth halfWordWidth halfWordMask cIntWidth widthInBits widthInByteswidthFromBytes widthInLognarrowUnarrowSvecvec2vec4vec8vec16vec2f64vec2b64vec4f32vec4b32vec8b16vec16b8cmmVec vecLength vecElemType isVecTyperEP_CostCentreStack_mem_allocrEP_CostCentreStack_scc_countrEP_StgEntCounter_allocsrEP_StgEntCounter_allocd$fOutputableWidth$fOutputableCmmCat$fOutputableCmmType$fEqForeignHint $fShowCmmType $fEqCmmCat $fShowCmmCat $fEqWidth $fOrdWidth $fShowWidth WarningFlagOpt_WarnDuplicateExportsOpt_WarnDuplicateConstraintsOpt_WarnRedundantConstraintsOpt_WarnHiShadowsOpt_WarnImplicitPreludeOpt_WarnIncompletePatternsOpt_WarnIncompleteUniPatterns Opt_WarnIncompletePatternsRecUpdOpt_WarnOverflowedLiteralsOpt_WarnEmptyEnumerationsOpt_WarnMissingFieldsOpt_WarnMissingImportListOpt_WarnMissingMethodsOpt_WarnMissingSignaturesOpt_WarnMissingLocalSignaturesOpt_WarnNameShadowingOpt_WarnOverlappingPatternsOpt_WarnTypeDefaultsOpt_WarnMonomorphismOpt_WarnUnusedTopBindsOpt_WarnUnusedLocalBindsOpt_WarnUnusedPatternBindsOpt_WarnUnusedImportsOpt_WarnUnusedMatchesOpt_WarnUnusedTypePatternsOpt_WarnUnusedForallsOpt_WarnUnusedRecordWildcardsOpt_WarnRedundantBangPatterns Opt_WarnRedundantRecordWildcardsOpt_WarnWarningsDeprecationsOpt_WarnDeprecatedFlags!Opt_WarnMissingMonadFailInstancesOpt_WarnSemigroupOpt_WarnDodgyExportsOpt_WarnDodgyImportsOpt_WarnOrphansOpt_WarnAutoOrphansOpt_WarnIdentities Opt_WarnTabsOpt_WarnUnrecognisedPragmasOpt_WarnMisplacedPragmasOpt_WarnDodgyForeignImportsOpt_WarnUnusedDoBindOpt_WarnWrongDoBind)Opt_WarnAlternativeLayoutRuleTransitionalOpt_WarnUnsafe Opt_WarnSafeOpt_WarnTrustworthySafeOpt_WarnMissedSpecsOpt_WarnAllMissedSpecs%Opt_WarnUnsupportedCallingConventionsOpt_WarnUnsupportedLlvmVersionOpt_WarnMissedExtraSharedLibOpt_WarnInlineRuleShadowingOpt_WarnTypedHolesOpt_WarnPartialTypeSignatures!Opt_WarnMissingExportedSignatures$Opt_WarnUntickedPromotedConstructorsOpt_WarnDerivingTypeableOpt_WarnDeferredTypeErrors#Opt_WarnDeferredOutOfScopeVariables"Opt_WarnNonCanonicalMonadInstances&Opt_WarnNonCanonicalMonadFailInstances#Opt_WarnNonCanonicalMonoidInstances'Opt_WarnMissingPatternSynonymSignatures Opt_WarnUnrecognisedWarningFlags$Opt_WarnSimplifiableClassConstraintsOpt_WarnCPPUndefOpt_WarnUnbangedStrictPatternsOpt_WarnMissingHomeModulesOpt_WarnPartialFieldsOpt_WarnMissingExportListOpt_WarnInaccessibleCodeOpt_WarnStarIsTypeOpt_WarnStarBinderOpt_WarnImplicitKindVarsOpt_WarnSpaceAfterBang!Opt_WarnMissingDerivingStrategies"Opt_WarnPrepositiveQualifiedModuleOpt_WarnUnusedPackagesOpt_WarnInferredSafeImportsOpt_WarnMissingSafeHaskellMode Opt_WarnCompatUnqualifiedImportsOpt_WarnDerivingDefaultsOpt_WarnInvalidHaddock%Opt_WarnOperatorWhitespaceExtConflictOpt_WarnOperatorWhitespaceOpt_WarnAmbiguousFieldsOpt_WarnImplicitLiftOpt_WarnMissingKindSignatures/Opt_WarnMissingExportedPatternSynonymSignatures Opt_WarnRedundantStrictnessFlagsOpt_WarnForallIdentifier,Opt_WarnUnicodeBidirectionalFormatCharactersOpt_WarnGADTMonoLocalBindsOpt_WarnTypeEqualityOutOfScope%Opt_WarnTypeEqualityRequiresOperators GeneralFlagOpt_DumpToFileOpt_D_dump_minimal_importsOpt_DoCoreLintingOpt_DoLinearCoreLintingOpt_DoStgLintingOpt_DoCmmLintingOpt_DoAsmLintingOpt_DoAnnotationLintingOpt_DoBoundsCheckingOpt_NoLlvmMangler Opt_FastLlvmOpt_NoTypeableBindsOpt_DistinctConstructorTablesOpt_InfoTableMapOpt_WarnIsErrorOpt_ShowWarnGroupsOpt_HideSourcePathsOpt_PrintExplicitForallsOpt_PrintExplicitKindsOpt_PrintExplicitCoercionsOpt_PrintExplicitRuntimeRepsOpt_PrintEqualityRelationsOpt_PrintAxiomIncompsOpt_PrintUnicodeSyntaxOpt_PrintExpandedSynonymsOpt_PrintPotentialInstancesOpt_PrintTypecheckerElaboration Opt_CallArityOpt_ExitificationOpt_StrictnessOpt_LateDmdAnalOpt_KillAbsenceOpt_KillOneShotOpt_FullLaziness Opt_FloatInOpt_LateSpecialiseOpt_SpecialiseOpt_SpecialiseAggressivelyOpt_CrossModuleSpecialiseOpt_InlineGenericsOpt_InlineGenericsAggressively Opt_StaticArgumentTransformationOpt_CSE Opt_StgCSEOpt_StgLiftLamsOpt_LiberateCaseOpt_SpecConstrOpt_SpecConstrKeenOpt_DoLambdaEtaExpansionOpt_IgnoreAssertsOpt_DoEtaReduction Opt_CaseMergeOpt_CaseFoldingOpt_UnboxStrictFieldsOpt_UnboxSmallStrictFieldsOpt_DictsCheapOpt_EnableRewriteRulesOpt_EnableThSpliceWarnings Opt_RegsGraphOpt_RegsIterativeOpt_PedanticBottoms Opt_LlvmTBAAOpt_LlvmFillUndefWithGarbageOpt_IrrefutableTuples Opt_CmmSinkOpt_CmmStaticPredOpt_CmmElimCommonBlocksOpt_CmmControlFlowOpt_AsmShortcuttingOpt_OmitYieldsOpt_FunToThunkOpt_DictsStrictOpt_DmdTxDictSelOpt_LoopificationOpt_CfgBlocklayoutOpt_WeightlessBlocklayout Opt_CprAnalOpt_WorkerWrapperOpt_WorkerWrapperUnliftOpt_SolveConstantDictsOpt_AlignmentSanitisationOpt_CatchNonexhaustiveCasesOpt_NumConstantFoldingOpt_CoreConstantFoldingOpt_FastPAPCallsOpt_DoTagInferenceChecksOpt_SimplPreInliningOpt_IgnoreInterfacePragmasOpt_OmitInterfacePragmasOpt_ExposeAllUnfoldingsOpt_WriteInterface Opt_WriteHieOpt_AutoSccsOnIndividualCafsOpt_ProfCountEntriesOpt_ProfLateInlineCcsOpt_ProfLateCcsOpt_ProfManualCcsOpt_PpOpt_ForceRecompOpt_IgnoreOptimChangesOpt_IgnoreHpcChangesOpt_ExcessPrecisionOpt_EagerBlackHoling Opt_NoHsMainOpt_SplitSections Opt_StgStatsOpt_HideAllPackagesOpt_HideAllPluginPackagesOpt_PrintBindResult Opt_HaddockOpt_HaddockOptionsOpt_BreakOnExceptionOpt_BreakOnErrorOpt_PrintEvldWithShowOpt_PrintBindContentsOpt_GenManifestOpt_EmbedManifestOpt_SharedImplibOpt_BuildingCabalPackageOpt_IgnoreDotGhciOpt_GhciSandboxOpt_GhciHistoryOpt_GhciLeakCheckOpt_ValidateHieOpt_LocalGhciHistoryOpt_NoItOpt_HelpfulErrorsOpt_DeferTypeErrorsOpt_DeferTypedHolesOpt_DeferOutOfScopeVariablesOpt_PICOpt_PIEOpt_PICExecutableOpt_ExternalDynamicRefs Opt_TickyOpt_Ticky_Allocd Opt_Ticky_LNEOpt_Ticky_Dyn_Thunk Opt_Ticky_Tag Opt_Ticky_AP Opt_RPathOpt_RelativeDynlibPathsOpt_CompactUnwindOpt_HpcOpt_FamAppCacheOpt_ExternalInterpreterOpt_OptimalApplicativeDoOpt_VersionMacrosOpt_WholeArchiveHsLibsOpt_SingleLibFolderOpt_ExposeInternalSymbols Opt_KeepCAFs Opt_KeepGoing Opt_ByteCode Opt_LinkRtsOpt_ErrorSpansOpt_DeferDiagnosticsOpt_DiagnosticsShowCaretOpt_PprCaseAsLetOpt_PprShowTicksOpt_ShowHoleConstraintsOpt_ShowValidHoleFitsOpt_SortValidHoleFitsOpt_SortBySizeHoleFitsOpt_SortBySubsumHoleFitsOpt_AbstractRefHoleFitsOpt_UnclutterValidHoleFitsOpt_ShowTypeAppOfHoleFitsOpt_ShowTypeAppVarsOfHoleFitsOpt_ShowDocsOfHoleFitsOpt_ShowTypeOfHoleFitsOpt_ShowProvOfHoleFitsOpt_ShowMatchesOfHoleFitsOpt_ShowLoadedModulesOpt_HexWordLiteralsOpt_SuppressCoercionsOpt_SuppressVarKindsOpt_SuppressModulePrefixesOpt_SuppressTypeApplicationsOpt_SuppressIdInfoOpt_SuppressUnfoldingsOpt_SuppressTypeSignaturesOpt_SuppressUniquesOpt_SuppressStgExtsOpt_SuppressTicksOpt_SuppressTimestampsOpt_SuppressCoreSizesOpt_AutoLinkPackagesOpt_ImplicitImportQualifiedOpt_KeepHscppFilesOpt_KeepHiDiffsOpt_KeepHcFilesOpt_KeepSFilesOpt_KeepTmpFilesOpt_KeepRawTokenStreamOpt_KeepLlvmFilesOpt_KeepHiFilesOpt_KeepOFilesOpt_BuildDynamicTooOpt_DistrustAllPackagesOpt_PackageTrustOpt_PluginTrustworthyOpt_G_NoStateHackOpt_G_NoOptCoercionDumpFlagOpt_D_dump_cmmOpt_D_dump_cmm_from_stgOpt_D_dump_cmm_rawOpt_D_dump_cmm_verbose_by_procOpt_D_dump_cmm_verboseOpt_D_dump_cmm_cfgOpt_D_dump_cmm_cbeOpt_D_dump_cmm_switchOpt_D_dump_cmm_procOpt_D_dump_cmm_spOpt_D_dump_cmm_sinkOpt_D_dump_cmm_cafOpt_D_dump_cmm_procmapOpt_D_dump_cmm_splitOpt_D_dump_cmm_infoOpt_D_dump_cmm_cpsOpt_D_dump_cfg_weightsOpt_D_dump_asmOpt_D_dump_asm_nativeOpt_D_dump_asm_livenessOpt_D_dump_asm_regallocOpt_D_dump_asm_regalloc_stagesOpt_D_dump_asm_conflictsOpt_D_dump_asm_statsOpt_D_dump_c_backendOpt_D_dump_llvmOpt_D_dump_core_statsOpt_D_dump_deriv Opt_D_dump_dsOpt_D_dump_ds_preoptOpt_D_dump_foreignOpt_D_dump_inliningsOpt_D_dump_verbose_inliningsOpt_D_dump_rule_firingsOpt_D_dump_rule_rewritesOpt_D_dump_simpl_traceOpt_D_dump_occur_analOpt_D_dump_parsedOpt_D_dump_parsed_ast Opt_D_dump_rnOpt_D_dump_rn_astOpt_D_dump_simplOpt_D_dump_simpl_iterationsOpt_D_dump_specOpt_D_dump_prepOpt_D_dump_late_ccOpt_D_dump_stg_from_coreOpt_D_dump_stg_unarisedOpt_D_dump_stg_cgOpt_D_dump_stg_tagsOpt_D_dump_stg_finalOpt_D_dump_call_arityOpt_D_dump_exitifyOpt_D_dump_stranalOpt_D_dump_str_signaturesOpt_D_dump_cpranalOpt_D_dump_cpr_signatures Opt_D_dump_tcOpt_D_dump_tc_astOpt_D_dump_hieOpt_D_dump_typesOpt_D_dump_rulesOpt_D_dump_cseOpt_D_dump_worker_wrapperOpt_D_dump_rn_traceOpt_D_dump_rn_statsOpt_D_dump_opt_cmmOpt_D_dump_simpl_statsOpt_D_dump_cs_traceOpt_D_dump_tc_traceOpt_D_dump_ec_traceOpt_D_dump_if_traceOpt_D_dump_splicesOpt_D_th_dec_fileOpt_D_dump_BCOsOpt_D_dump_tickedOpt_D_dump_rttiOpt_D_source_statsOpt_D_verbose_stg2stg Opt_D_dump_hiOpt_D_dump_hi_diffsOpt_D_dump_mod_cyclesOpt_D_dump_mod_mapOpt_D_dump_timings!Opt_D_dump_view_pattern_commoningOpt_D_verbose_core2coreOpt_D_dump_debugOpt_D_dump_jsonOpt_D_ppr_debugOpt_D_no_debug_outputOpt_D_dump_faststringsOpt_D_faststring_statsLanguage Haskell98 Haskell2010GHC2021optimisationFlags warnFlagNames warningGroupswarningHierarchiessmallestWarningGroupsstandardWarnings minusWOpts minusWallOptsminusWeverythingOptsminusWcompatOptsunusedBindsFlags$fBinaryLanguage$fOutputableLanguage$fEqWarningFlag$fOrdWarningFlag$fShowWarningFlag$fEnumWarningFlag$fEqGeneralFlag$fShowGeneralFlag$fEnumGeneralFlag $fEqDumpFlag$fShowDumpFlag$fEnumDumpFlag $fEqLanguage$fEnumLanguage$fShowLanguage$fBoundedLanguageWaysWay WayCustom WayThreadedWayDebugWayProfWayDynhasWay hasNotWayaddWay removeWayallowed_combinationwaysTag waysBuildTagwayTag wayRTSOnlyfullWaysrtsWayswayDescwayGeneralFlagswayUnsetGeneralFlagswayOptcwayOptlwayOptPhostIsProfiled hostIsDynamichostIsThreadedhostIsDebugged hostIsTracinghostWays hostFullWays$fEqWay$fOrdWay $fShowWay $fReadWayProfileprofilePlatform profileWaysprofileConstantsprofileIsProfilingprofileWordSizeInBytesprofileBuildTag $fEqProfile $fOrdProfile $fShowProfile $fReadProfileArgDescrArgSpecArgGen ArgUnknownLivenessConstrDescriptionClosureTypeInfoConstrFunThunk ThunkSelector BlackHole IndStaticIsStaticSMRepHeapRep ArrayPtrsRepSmallArrayPtrsRep ArrayWordsRepStackRepRTSRep StgHalfWordStgWordWordOffByteOffroundUpToWords roundUpTo wordsToBytesbytesToWordsRoundUp fromStgWord toStgWordfromStgHalfWord toStgHalfWord halfWordSizehalfWordSizeInBits mkHeapRepmkRTSRep mkStackRep blackHoleRep indStaticRep arrPtrsRepsmallArrPtrsRep arrWordsRep isStaticRep isStackRepisConRep isThunkRepisFunRepisStaticNoCafCon fixedHdrSize fixedHdrSizeW profHdrSizearrWordsHdrSizearrWordsHdrSizeWarrPtrsHdrSizearrPtrsHdrSizeWsmallArrPtrsHdrSizesmallArrPtrsHdrSizeW thunkHdrSizehdrSizehdrSizeW nonHdrSize nonHdrSizeWheapClosureSizeWcard cardRoundUpcardTableSizeBcardTableSizeWrtsClosureType rET_SMALLrET_BIGaRG_GEN aRG_GEN_BIG$fOutputableStgWord$fOutputableStgHalfWord$fOutputableArgDescr$fOutputableClosureTypeInfo$fOutputableSMRep $fEqSMRep$fEqClosureTypeInfo $fEqArgDescr$fEqStgHalfWord $fEqStgWord $fBitsStgWordAnnEnv CoreAnnTarget AnnTarget NamedTarget ModuleTarget AnnPayload ann_target ann_value emptyAnnEnvmkAnnEnvextendAnnEnvList plusAnnEnvfindAnnsfindAnnsByTypeRepdeserializeAnns$fBinaryAnnTarget$fOutputableAnnTarget$fOutputableAnnotation$fFunctorAnnTargetTagSigTagInfoTagDunnoTagTuple TagProper TagTagged isTaggedSig seqTagSig seqTagInfo$fBinaryTagInfo$fOutputableTagInfo$fBinaryTagSig$fOutputableBndr(,)$fOutputableTagSig $fEqTagSig $fEqTagInfoHsDocStringChunkLHsDocStringChunkHsDocStringDecoratorHsDocStringNextHsDocStringPreviousHsDocStringNamedHsDocStringGroup HsDocStringMultiLineDocStringNestedDocStringGeneratedDocString LHsDocStringpprWithDocStringmkHsDocStringChunk mkHsDocStringChunkUtf8ByteString unpackHDSCmkGeneratedHsDocStringisEmptyDocStringdocStringChunkspprHsDocStringpprHsDocStringsexactPrintHsDocStringrenderHsDocStringrenderHsDocStrings$fBinaryHsDocStringDecorator $fOutputableHsDocStringDecorator$fOutputableHsDocStringChunk$fBinaryHsDocStringChunk$fBinaryHsDocString$fOutputableHsDocString$fEqHsDocString$fDataHsDocString$fShowHsDocString$fEqHsDocStringChunk$fOrdHsDocStringChunk$fDataHsDocStringChunk$fShowHsDocStringChunk$fEqHsDocStringDecorator$fOrdHsDocStringDecorator$fShowHsDocStringDecorator$fDataHsDocStringDecoratorNoEpAnnsEpAnnCO AnnSortKey NoAnnSortKey AnnPragmaapr_open apr_closeapr_rest NameAdornment NameParensNameParensHashNameBackquotes NameSquareNameAnn NameAnnCommas NameAnnBars NameAnnOnly NameAnnRArrow NameAnnQuoteNameAnnTrailingnann_adornment nann_open nann_name nann_close nann_trailing nann_commas nann_bars nann_quote nann_quoted AnnContext ac_darrowac_openac_close ParenType AnnParens AnnParensHashAnnParensSquareAnnParen ap_adornmentap_openap_closeAnnList al_anchoral_openal_closeal_rest al_trailing AnnListItem lann_trailing TrailingAnn AddSemiAnn AddCommaAnn AddVbarAnn LocatedAn SrcSpanAnnC SrcSpanAnnP SrcSpanAnnL SrcSpanAnnN SrcSpanAnnALocatedCLocatedPLocatedLLocatedNLocatedASrcAnn SrcSpanAnn' SrcSpanAnnannlocA LEpaComment EpAnnComments EpaCommentsEpaCommentsBalanced priorCommentsfollowingCommentsAnchorOperationUnchangedAnchor MovedAnchorAnchoranchor anchor_opEpAnn EpAnnNotUsedentryannscommentsDeltaPosSameLine DifferentLine deltaColumn deltaLine TokenLocation NoTokenLocTokenLoc EpaLocationEpaSpanEpaDeltaAddEpAnn EpaCommentTok EpaDocComment EpaDocOptionsEpaLineCommentEpaBlockComment EpaEofComment EpaCommentac_tok ac_prior_tokHasENoEIsUnicodeSyntax UnicodeSyntax NormalSyntax AnnAnyclassAnnAs AnnCloseBU AnnCloseC AnnCloseQU AnnClosePH AnnCloseS AnnCommaTuple AnnDarrowU AnnDcolonU AnnForallU AnnHiding AnnLarrowU AnnLollyUAnnMdoAnnName AnnOpenBUAnnOpenC AnnOpenEQUAnnOpenS AnnOpenPH AnnDollarAnnDollarDollarAnnPackageName AnnPercent AnnPercentOne AnnQualified AnnRarrowUAnnSafeAnnSimpleQuote AnnSignature AnnThTyQuoteAnnUnit AnnValStrAnnViaAnnlarrowtailUAnnrarrowtailUAnnLarrowtailUAnnRarrowtailU unicodeAnndeltaPos getDeltaLineepaLocationRealSrcSpanepaLocationFromSrcAnn spanAsAnchorrealSpanAsAnchor emptyComments parenTypeKwstrailingAnnToAddEpAnnaddTrailingAnnToLaddTrailingAnnToAaddTrailingCommaToNl2nn2lla2nala2lal2lna2lareLocreLocAreLocLreLocCreLocN realSrcSpanla2rextraToAnnListreAnnreAnnCreAnnL getLocAnngetLocAnoLocA noAnnSrcSpan noSrcSpanAnoAnnaddAnnsaddAnnsA widenSpan widenAnchor widenAnchorRwidenLocatedAn epAnnAnnsL epAnnAnnsannParen2AddEpAnn epAnnComments sortLocatedAmapLocA combineLocsAcombineSrcSpansAaddCLocA addCLocAAgetFollowingCommentssetFollowingCommentssetPriorComments noCommentsplaceholderRealSpancommentaddCommentsToSrcAnnsetCommentsSrcAnnaddCommentsToEpAnnsetCommentsEpAnn transferAnnsA commentsOnlyAremoveCommentsA$fOutputableAnnKeywordId$fOutputableIsUnicodeSyntax$fOutputableEpaComment$fOutputableDeltaPos$fOutputableAnchorOperation$fOutputableAnchor$fSemigroupAnchor $fOrdAnchor$fOutputableEpAnnComments$fSemigroupEpAnnComments$fOutputableEpAnn $fMonoidEpAnn$fSemigroupEpAnn$fOutputableEpaLocation$fOutputableAddEpAnn$fOutputableBndrGenLocated$fOutputableSrcSpanAnn'$fSemigroupSrcSpanAnn'$fOutputableTrailingAnn$fOutputableAnnListItem$fMonoidAnnListItem$fSemigroupAnnListItem$fOutputableAnnList$fMonoidAnnList$fSemigroupAnnList$fOutputableAnnContext$fOutputableNameAdornment$fOutputableNameAnn$fMonoidNameAnn$fSemigroupNameAnn$fOutputableAnnPragma$fOutputableAnnSortKey$fMonoidAnnSortKey$fSemigroupAnnSortKey$fOutputableNoEpAnns$fSemigroupNoEpAnns$fDataNoEpAnns $fEqNoEpAnns $fOrdNoEpAnns$fDataAnnSortKey$fEqAnnSortKey$fDataAnnPragma $fEqAnnPragma $fDataNameAnn $fEqNameAnn$fEqNameAdornment$fOrdNameAdornment$fDataNameAdornment$fDataAnnContext$fDataAnnParen $fEqParenType$fOrdParenType$fDataParenType $fDataAnnList $fEqAnnList$fDataAnnListItem$fEqAnnListItem$fDataTrailingAnn$fEqTrailingAnn$fDataSrcSpanAnn'$fEqSrcSpanAnn'$fDataAddEpAnn $fEqAddEpAnn$fDataTokenLocation$fEqTokenLocation$fDataEpaLocation$fEqEpaLocation $fDataEpAnn $fEqEpAnn$fFunctorEpAnn$fDataEpAnnComments$fEqEpAnnComments $fDataAnchor $fEqAnchor $fShowAnchor$fDataAnchorOperation$fEqAnchorOperation$fShowAnchorOperation$fShowDeltaPos $fEqDeltaPos $fOrdDeltaPos$fDataDeltaPos$fEqEpaComment$fDataEpaComment$fShowEpaComment$fEqEpaCommentTok$fDataEpaCommentTok$fShowEpaCommentTok$fEqHasE $fOrdHasE $fDataHasE $fShowHasE$fEqIsUnicodeSyntax$fOrdIsUnicodeSyntax$fDataIsUnicodeSyntax$fShowIsUnicodeSyntax$fEqAnnKeywordId$fOrdAnnKeywordId$fDataAnnKeywordId$fShowAnnKeywordIdBooleanFormulaOrParensLBooleanFormulamkVarmkFalsemkTruemkAndmkOrisFalseisTrueevalsimplify isUnsatisfied impliesAtomimpliespprBooleanFormulapprBooleanFormulaNice$fBinaryBooleanFormula$fOutputableBooleanFormula$fEqBooleanFormula$fDataBooleanFormula$fFunctorBooleanFormula$fFoldableBooleanFormula$fTraversableBooleanFormulaClassMinimalDefATValidityInfoNoATVIATVI ClassATItemATI DefMethInfo ClassOpItemFunDepClass classTyCon classNameclassKey classTyVarsclassMinimalDefmkClassmkAbstractClass classArityclassAllSelIds classSCSelIds classSCSelId classMethods classOpItemsclassATs classATItems classSCTheta classTvsFds classHasFds classBigSigclassExtraBigSigisAbstractClasspprDefMethInfo pprFundeps pprFunDep $fDataClass$fOutputableClass$fNamedThingClass$fUniquableClass $fEqClass DataConBoxer mkDictSelIdmkDataConWorkId TyConFlavour ClassFlavour TupleFlavour SumFlavourDataTypeFlavourNewtypeFlavourAbstractTypeFlavourDataFamilyFlavourOpenTypeFamilyFlavourClosedTypeFamilyFlavourTypeSynonymFlavourBuiltInTypeFlavourPromotedDataConFlavour PrimElemRep Int8ElemRep Int16ElemRep Int32ElemRep Int64ElemRep Word8ElemRep Word16ElemRep Word32ElemRep Word64ElemRep FloatElemRep DoubleElemRepPrimRepVoidRep LiftedRep UnliftedRepInt8RepInt16RepInt32RepInt64RepIntRepWord8Rep Word16Rep Word32Rep Word64RepWordRepAddrRepFloatRep DoubleRepVecRep FamTyConFlavDataFamilyTyConOpenSynFamilyTyConClosedSynFamilyTyConAbstractClosedSynFamilyTyConBuiltInSynFamTyCon Injectivity NotInjective Injective AlgTyConFlavVanillaAlgTyConUnboxedSumTyCon ClassTyConDataFamInstTyConRuntimeRepInfoNoRRI RuntimeRepVecCountVecElem LiftedInfo UnliftedInfo AlgTyConRhs AbstractTyCon DataTyCon TupleTyConSumTyConNewTyCon data_consdata_cons_sizeis_enumdata_fixed_levdata_contup_sortnt_rhs nt_etad_rhsnt_co nt_fixed_rep tyConUnique tyConBinders tyConResKind tyConKind tyConAritytyConNullaryTy tyConTyVars tyConCType algTcFields famTcResVartcTyConScopedTyVars tcTyConIsPoly TyConBndrVisNamedTCBAnonTCBTyConTyCoBinder TyConBindermkAnonTyConBindermkAnonTyConBindersmkNamedTyConBindermkNamedTyConBindersmkRequiredTyConBindertyConBinderArgFlagtyConBndrVisArgFlagisNamedTyConBinderisVisibleTyConBinderisVisibleTcbVisisInvisibleTyConBinder mkTyConKindtyConInvisTVBinderstyConVisibleTyVarsmkLevPolyDataTyConRhsmkDataTyConRhsvisibleDataCons isNoParenttyConRepModOcc isVoidRep isGcPtrRepprimRepCompatibleprimRepsCompatible primRepSizeBprimElemRepSizeBprimElemRepToPrimRepprimRepIsFloattyConFieldLabelslookupTyConFieldLabel mkFunTyCon mkAlgTyCon mkClassTyCon mkTupleTyCon mkSumTyCon mkTcTyConnoTcTyConScopedTyVars mkPrimTyConmkSynonymTyCon mkFamilyTyConmkPromotedDataConisAbstractTyCon isPrimTyCon isAlgTyConisVanillaAlgTyConisConstraintKindCon isDataTyConisInjectiveTyConisGenerativeTyConisGenInjAlgRhs isNewTyConunwrapNewTyCon_maybeunwrapNewTyConEtad_maybeisTypeSynonymTyCon isTauTyConisFamFreeTyConisForgetfulSynTyConmustBeSaturatedisGadtSyntaxTyConisEnumerationTyCon isFamilyTyConisOpenFamilyTyConisTypeFamilyTyConisDataFamilyTyConisOpenTypeFamilyTyCon%isClosedSynFamilyTyConWithAxiom_maybetyConInjectivityInfoisBuiltInSynFamTyCon_maybe isTyConAssoctyConAssoc_maybetyConFlavourAssoc_maybetyConTuple_maybeisBoxedTupleTyConisUnboxedSumTyConisLiftedAlgTyConisPromotedTupleTyConisPromotedDataConisPromotedDataCon_maybe isKindTyConisLiftedTypeKindTyConNameisImplicitTyContyConCType_maybe isTcTyConsetTcTyConKindtcHasFixedRuntimeRepisConcreteTyConexpandSynTyCon_maybeisTyConWithSrcDataCons tyConDataConstyConDataCons_maybetyConSingleDataCon_maybetyConSingleDataContyConSingleAlgDataCon_maybetyConAlgDataCons_maybetyConFamilySize algTyConRhstyConFamilyResVar_maybe tyConRoles newTyConRhsnewTyConEtadAritynewTyConEtadRhsnewTyConCo_maybe newTyConConewTyConDataCon_maybetyConStupidThetasynTyConDefn_maybesynTyConRhs_maybefamTyConFlav_maybe isClassTyContyConClass_maybetyConATsisFamInstTyContyConFamInstSig_maybetyConFamInst_maybetyConFamilyCoercion_maybetyConRuntimeRepInfo mkTyConTagMap tyConFlavourtcFlavourIsOpenpprPromotionQuote tyConSkolem$fBinaryTyConBndrVis$fOutputableTyConBndrVis$fBinaryInjectivity$fOutputableFamTyConFlav$fBinaryPrimElemRep$fOutputablePrimElemRep$fBinaryPrimRep$fOutputablePrimRep $fDataTyCon$fNamedThingTyCon$fOutputableTyConFlavour$fOutputableTyCon$fUniquableTyCon $fEqTyCon$fOutputableAlgTyConFlav$fEqTyConFlavour $fDataPrimRep $fEqPrimRep $fOrdPrimRep $fShowPrimRep$fDataPrimElemRep$fEqPrimElemRep$fOrdPrimElemRep$fShowPrimElemRep$fEnumPrimElemRep$fEqInjectivity tYPETyContidyToIfaceTcArgstoIfaceCoercionX toIfaceTcArgs toIfaceTyContoIfaceForAllBndr toIfaceTyLit toIfaceTypeX TyCoFoldertcf_view tcf_tyvar tcf_covartcf_holetcf_tycobinder CoercionHole ch_co_varch_ref PhantomProvProofIrrelProv PluginProv CorePrepProv MCoercionRMReflMCo KindCoercion CoercionP CoercionRReflGRefl TyConAppCoAppCoForAllCoFunCoCoVarCo AxiomInstCo AxiomRuleCoUnivCoSymCoTransCoNthCoLRCoInstCoKindCoSubCoHoleCoTyBinderNamedAnonKnotTiedNumTyLitStrTyLit CharTyLitTyVarTyAppTyTyConAppForAllTyFunTyLitTyCastTy CoercionTyft_afft_multft_argft_resFRRTypeRuntimeRepType KindOrTypenonDetCmpTyLitcmpTyLit delBinderVarisInvisibleBinderisVisibleBinder isNamedBinder isTyBinder mkTyVarTy mkTyVarTys mkTyCoVarTy mkTyCoVarTysmkFunTy mkScaledFunTy mkVisFunTy mkInvisFunTymkVisFunTyManymkInvisFunTyMany mkVisFunTysmkVisFunTysManymkInvisFunTysMany mkForAllTysmkInvisForAllTysmkPiTymkPiTys coHoleCoVarsetCoHoleCoVarfoldTyConoViewtypeSize coercionSizeprovSize scaledMult scaledThing mapScaledType$fOutputableTyLit$fUniquableCoercionHole$fOutputableCoercionHole$fDataCoercionHole$fOutputableUnivCoProvenance$fOutputableMCoercion$fOutputableCoercion$fOutputableType$fOutputableScaled$fOutputableTyCoBinder$fDataTyCoBinder $fDataScaled $fDataType$fDataCoercion$fDataUnivCoProvenance$fDataMCoercion $fEqTyLit $fDataTyLit primTyConsunexposedPrimTyConsexposedPrimTyConscharPrimTyConNameintPrimTyConNameint8PrimTyConNameint16PrimTyConNameint32PrimTyConNameint64PrimTyConNamewordPrimTyConNameword8PrimTyConNameword16PrimTyConNameword32PrimTyConNameword64PrimTyConNameaddrPrimTyConNamefloatPrimTyConNamedoublePrimTyConNamemkTemplateKindVarmkTemplateKindVarsmkTemplateTyVarsFrommkTemplateTyVarsmkTemplateTyConBindersmkTemplateKiTyVarsmkTemplateKiTyVarmkTemplateKindTyConBindersmkTemplateAnonTyConBinders alphaTyVars alphaTyVar betaTyVar gammaTyVar deltaTyVaralphaTyVarSpec betaTyVarSpecgammaTyVarSpecdeltaTyVarSpecalphaTysalphaTybetaTygammaTydeltaTyalphaTyVarsUnliftedRepalphaTyVarUnliftedRepalphaTysUnliftedRepalphaTyUnliftedRepruntimeRep1TyVarruntimeRep2TyVarruntimeRep3TyVarruntimeRep1TyVarInfruntimeRep2TyVarInf runtimeRep1Ty runtimeRep2Ty runtimeRep3TyopenAlphaTyVar openBetaTyVaropenGammaTyVaropenAlphaTyVarSpecopenBetaTyVarSpecopenGammaTyVarSpec openAlphaTy openBetaTy openGammaTy levity2TyVar levity1TyVarlevity1TyVarInflevity2TyVarInf levity1Ty levity2TylevPolyAlphaTyVarlevPolyBetaTyVarlevPolyAlphaTyVarSpeclevPolyBetaTyVarSpeclevPolyAlphaTy levPolyBetaTymultiplicityTyVar1multiplicityTyVar2 funTyConName tYPETyConNamefunctionWithMultiplicity charPrimTy charPrimTyCon intPrimTy intPrimTyCon int8PrimTy int8PrimTyCon int16PrimTyint16PrimTyCon int32PrimTyint32PrimTyCon int64PrimTyint64PrimTyCon wordPrimTy wordPrimTyCon word8PrimTyword8PrimTyCon word16PrimTyword16PrimTyCon word32PrimTyword32PrimTyCon word64PrimTyword64PrimTyCon addrPrimTy addrPrimTyCon floatPrimTyfloatPrimTyCon doublePrimTydoublePrimTyCon mkStatePrimTystatePrimTyConrealWorldTyCon realWorldTyrealWorldStatePrimTy mkProxyPrimTyproxyPrimTyCon eqPrimTyConeqReprPrimTyConeqPhantPrimTyCon equalityTyConarrayPrimTyConmutableArrayPrimTyConmutableByteArrayPrimTyConbyteArrayPrimTyConsmallArrayPrimTyConsmallMutableArrayPrimTyCon mkArrayPrimTybyteArrayPrimTymkSmallArrayPrimTymkMutableArrayPrimTymkMutableByteArrayPrimTymkSmallMutableArrayPrimTymutVarPrimTyConmkMutVarPrimTyioPortPrimTyConmkIOPortPrimTy mVarPrimTyCon mkMVarPrimTy tVarPrimTyCon mkTVarPrimTystablePtrPrimTyConmkStablePtrPrimTystableNamePrimTyConmkStableNamePrimTycompactPrimTyCon compactPrimTystackSnapshotPrimTyConstackSnapshotPrimTy bcoPrimTy bcoPrimTyCon weakPrimTyCon mkWeakPrimTythreadIdPrimTythreadIdPrimTyCon int8X16PrimTyint8X16PrimTyCon int16X8PrimTyint16X8PrimTyCon int32X4PrimTyint32X4PrimTyCon int64X2PrimTyint64X2PrimTyCon int8X32PrimTyint8X32PrimTyConint16X16PrimTyint16X16PrimTyCon int32X8PrimTyint32X8PrimTyCon int64X4PrimTyint64X4PrimTyCon int8X64PrimTyint8X64PrimTyConint16X32PrimTyint16X32PrimTyConint32X16PrimTyint32X16PrimTyCon int64X8PrimTyint64X8PrimTyConword8X16PrimTyword8X16PrimTyConword16X8PrimTyword16X8PrimTyConword32X4PrimTyword32X4PrimTyConword64X2PrimTyword64X2PrimTyConword8X32PrimTyword8X32PrimTyConword16X16PrimTyword16X16PrimTyConword32X8PrimTyword32X8PrimTyConword64X4PrimTyword64X4PrimTyConword8X64PrimTyword8X64PrimTyConword16X32PrimTyword16X32PrimTyConword32X16PrimTyword32X16PrimTyConword64X8PrimTyword64X8PrimTyCon floatX4PrimTyfloatX4PrimTyCondoubleX2PrimTydoubleX2PrimTyCon floatX8PrimTyfloatX8PrimTyCondoubleX4PrimTydoubleX4PrimTyConfloatX16PrimTyfloatX16PrimTyCondoubleX8PrimTydoubleX8PrimTyCon runTyCoVarstyCoVarsOfTypetyCoVarsOfTypes tyCoVarsOfCo tyCoVarsOfMCo tyCoVarsOfCos deepTcvFoldershallowTyCoVarsOfTypeshallowTyCoVarsOfTypesshallowTyCoVarsOfCoshallowTyCoVarsOfCosshallowTyCoVarsOfTyVarEnvshallowTyCoVarsOfCoVarEnv coVarsOfType coVarsOfTypes coVarsOfCo coVarsOfCoscloseOverKindscloseOverKindsListcloseOverKindsDSettyCoVarsOfTypeDSettyCoVarsOfTypeListtyCoVarsOfTypesDSettyCoVarsOfTypesList tyCoFVsOfType tyCoFVsBndrtyCoFVsVarBndrstyCoFVsVarBndrtyCoFVsOfTypestyCoVarsOfCoDSettyCoVarsOfCoList tyCoFVsOfCo tyCoFVsOfCosalmostDevoidCoVarOfCoinjectiveVarsOfTypeinjectiveVarsOfTypesinvisibleVarsOfTypeinvisibleVarsOfTypesanyFreeVarsOfTypeanyFreeVarsOfTypesanyFreeVarsOfConoFreeVarsOfTypenoFreeVarsOfTypesnoFreeVarsOfCo scopedSorttyCoVarsOfTypeWellScopedtyCoVarsOfTypesWellScoped CvSubstEnv TvSubstEnvTCvSubstemptyTvSubstEnvemptyCvSubstEnvcomposeTCvSubstEnvcomposeTCvSubst emptyTCvSubstmkEmptyTCvSubstisEmptyTCvSubst mkTCvSubst mkTvSubst mkCvSubst getTvSubstEnv getCvSubstEnv getTCvInScopegetTCvSubstRangeFVs isInScope elemTCvSubstnotElemTCvSubst setTvSubstEnv setCvSubstEnv zapTCvSubstextendTCvInScopeextendTCvInScopeListextendTCvInScopeSetextendTCvSubstextendTCvSubstWithClone extendTvSubstextendTvSubstBinderAndInScopeextendTvSubstWithClone extendCvSubstextendCvSubstWithCloneextendTvSubstAndInScopeextendTvSubstListextendTCvSubstList unionTCvSubst zipTvSubst zipCvSubst zipTCvSubst mkTvSubstPrszipTyEnvzipCoEnv substTyWithsubstTyWithUncheckedsubstTyWithInScope substCoWithsubstCoWithUncheckedsubstTyWithCoVars substTysWithsubstTysWithCoVarssubstTyAddInScopeisValidTCvSubstcheckValidSubstsubstTyUnchecked substScaledTysubstScaledTyUncheckedsubstTyssubstScaledTyssubstTysUncheckedsubstScaledTysUnchecked substThetasubstThetaUnchecked substTyVar substTyVars substTyCoVars lookupTyVarsubstCosubstCoUncheckedsubstCossubstForAllCoBndrsubstForAllCoBndrUsing substCoVar substCoVars lookupCoVarsubstTyVarBndrsubstTyVarBndrs substVarBndr substVarBndrssubstCoVarBndrsubstVarBndrUsingcloneTyVarBndrcloneTyVarBndrs substTyCoBndr$fOutputableTCvSubst tidyVarBndrs tidyVarBndravoidNameClashestidyTyCoVarBindertidyTyCoVarBinderstidyFreeTyCoVarstidyOpenTyCoVarstidyOpenTyCoVartidyTyCoVarOcc tidyTypestidyType tidyOpenTypes tidyOpenType tidyTopTypetidyCotidyCos TyCoMapper tcm_tyvar tcm_covartcm_holetcm_tycobinder tcm_tyconManyOnekindRep kindRep_maybeisBoxedTypeKindpickyIsLiftedTypeKindisUnliftedTypeKindisBoxedRuntimeRepruntimeRepLevity_maybeisLiftedRuntimeRepisUnliftedRuntimeRepisLiftedLevityisUnliftedLevityisRuntimeRepVar isLevityVarisMultiplicityVarmapTyComapTyCoXgetTyVar isTyVarTygetTyVar_maybegetCastedTyVar_mayberepGetTyVar_maybemkAppTyssplitAppTy_mayberepSplitAppTy_maybetcRepSplitAppTy_maybe splitAppTy splitAppTysrepSplitAppTys mkNumLitTy isNumLitTy mkStrLitTy isStrLitTy mkCharLitTy isCharLitTyisLitTyuserTypeError_maybepprUserTypeErrorTy splitFunTysplitFunTy_maybe splitFunTys funResultTyfunArgTy piResultTys applyTysXtyConAppTyConPicky_maybe tyConAppTyContyConAppArgs_maybe tyConAppArgs tyConAppArgN splitTyConApptcSplitTyConApp_mayberepSplitTyConApp_maybetcRepSplitTyConApp_maybesplitListTyConApp_maybenewTyConInstRhssplitCastTy_maybetyConBindersTyCoBinders mkCoercionTyisCoercionTy_maybestripCoercionTymkTyCoInvForAllTy mkInfForAllTymkTyCoInvForAllTysmkInfForAllTysmkSpecForAllTymkSpecForAllTysmkVisForAllTysmkTyConBindersPreferAnonsplitForAllTyCoVarssplitForAllReqTVBinderssplitForAllInvisTVBinders isForAllTy isForAllTy_ty isForAllTy_coisPiTyisFunTysplitForAllTyCoVar dropForAllssplitForAllTyCoVar_maybesplitForAllTyVar_maybesplitForAllCoVar_maybesplitPiTy_maybe splitPiTy splitPiTysgetRuntimeArgTyssplitForAllTyCoVarBindersinvisibleTyBndrCountsplitInvisPiTyssplitInvisPiTysNfilterOutInvisibleTypesfilterOutInferredTypespartitionInvisibles tyConArgFlags appTyArgFlagsisTauTy isAtomicTy mkAnonBinderisAnonTyCoBindertyCoBinderVar_maybetyCoBinderType tyBinderTypebinderRelevantType_maybemkFamilyTyConApp coAxNthLHS isFamFreeTy isCoVarType buildSynTyConisUnliftedType isStateTypemightBeLiftedTypemightBeUnliftedType isBoxedTypeisRuntimeRepKindedTydropRuntimeRepArgsgetRuntimeRep_maybe getRuntimeRepgetLevity_maybeisUnboxedTupleTypeisUnboxedSumType isAlgTypeisDataFamilyAppType isStrictTypeisPrimitiveTypeisValidJoinPointTypeseqTypeseqTypeseqTypeeqTypeXeqTypes eqVarBndrs nonDetCmpTypenonDetCmpTypesnonDetCmpTypeXnonDetCmpTypesX nonDetCmpTctypeKind tcTypeKindtcIsConstraintKindtcIsLiftedTypeKindtcIsBoxedTypeKindtcIsRuntimeTypeKindtcReturnsConstraintKindtypeHasFixedRuntimeRepresultHasFixedRuntimeRepoccCheckExpand tyConsOfTypesplitVisVarsOfTypesplitVisVarsOfTypesisFixedRuntimeRepKind isConcreteclassifiesTypeWithValuestyConAppNeedsKindSig unrestrictedlineartymultirrelevantMultmkScaled scaledSetisManyDataConTyisOneDataConTy isLinearType$fEqTypeOrdering$fOrdTypeOrdering$fEnumTypeOrdering$fBoundedTypeOrdering OverLitVal HsIntegral HsFractional HsIsString HsOverLitOverLitol_extol_valHsLitHsChar HsCharPrimHsString HsStringPrimHsInt HsIntPrim HsWordPrim HsInt64Prim HsWord64Prim HsIntegerHsRat HsFloatPrim HsDoublePrimXLitnegateOverLitValhsLitNeedsParenshsOverLitNeedsParens $fEqHsLit$fOutputableOverLitVal$fOrdOverLitVal$fEqOverLitVal$fOrdHsOverLit $fEqHsOverLit$fDataOverLitValTickishPlacement PlaceRuntime PlaceNonLamPlaceCostCentreTickishScopingNoScope SoftScopeCostCentreScope GenTickishProfNoteHpcTick Breakpoint profNoteCC profNoteCount profNoteScope tickModuletickId breakpointExt breakpointId breakpointFVs sourceSpan sourceName CmmTickish StgTickish CoreTickish XTickishId tickishCounts tickishScopedtickishScopesLiketickishFloatabletickishCanSplit mkNoCount mkNoScope tickishIsCode isProfTick tickishPlacetickishContains$fOutputableTickishPlacement$fEqTickishPlacement$fShowTickishPlacement$fEqTickishScoping$fDataGenTickish$fOrdGenTickish$fEqGenTickish$fDataGenTickish0$fDataGenTickish1$fOrdGenTickish0$fEqGenTickish0 LitNumType LitNumBigNat LitNumInt LitNumInt8 LitNumInt16 LitNumInt32 LitNumInt64 LitNumWord LitNumWord8 LitNumWord16 LitNumWord32 LitNumWord64LiteralLitChar LitNumber LitString LitNullAddr LitRubbishLitFloat LitDoubleLitLabellitNumIsSigned litNumBitSizemkLitNumberWrap litNumWrap litNumCoerce litNumNarrowlitNumCheckRange litNumRange mkLitNumbermkLitInt mkLitIntWrapmkLitIntUnchecked mkLitIntWrapC mkLitWord mkLitWordWrapmkLitWordUncheckedmkLitWordWrapC mkLitInt8 mkLitInt8WrapmkLitInt8Unchecked mkLitWord8mkLitWord8WrapmkLitWord8Unchecked mkLitInt16mkLitInt16WrapmkLitInt16Unchecked mkLitWord16mkLitWord16WrapmkLitWord16Unchecked mkLitInt32mkLitInt32WrapmkLitInt32Unchecked mkLitWord32mkLitWord32WrapmkLitWord32Unchecked mkLitInt64mkLitInt64WrapmkLitInt64Unchecked mkLitWord64mkLitWord64WrapmkLitWord64Unchecked mkLitFloat mkLitDouble mkLitChar mkLitString mkLitBigNat isLitRubbish isMinBound isMaxBound inCharRange isZeroLitisOneLitlitValueisLitValue_maybe mapLitValue narrowInt8LitnarrowInt16LitnarrowInt32LitnarrowInt64LitnarrowWord8LitnarrowWord16LitnarrowWord32LitnarrowWord64LitconvertToWordLitconvertToIntLit charToIntLit intToCharLit floatToIntLit intToFloatLitdoubleToIntLitintToDoubleLitfloatToDoubleLitdoubleToFloatLit nullAddrLit litIsTrivial litIsDupable litFitsInChar litIsLifted literalType pprLiteral$fBinaryLitNumType $fOrdLiteral $fEqLiteral$fOutputableLiteral$fBinaryLiteral $fDataLiteral$fDataLitNumType$fEnumLitNumType$fEqLitNumType$fOrdLitNumTypeGenMap LiteralMapListMapMaybeMapTrieMapKeyemptyTMlookupTMalterTMmapTMfilterTMfoldTMXTinsertTMdeleteTM foldMapTM isEmptyTM>.>|>|>> foldMaybe filterMaybelkListxtListlkGxtGmapGfdG$fTrieMapUniqDFM $fTrieMapMap$fTrieMapIntMap$fFoldableMaybeMap$fTrieMapMaybeMap$fOutputableListMap$fFoldableListMap$fTrieMapListMap$fFoldableGenMap$fTrieMapGenMap$fOutputableGenMapFactBaseLabelMapLabelSetLabel mkHooplLabel lookupFact$fOutputablePenvLabel$fOutputableLabel$fUniquableLabel $fShowLabel$fOutputableLabelSet$fIsSetLabelSet$fTrieMapLabelMap$fOutputablePenvLabelMap$fOutputableLabelMap$fIsMapLabelMap $fEqLabelMap $fOrdLabelMap$fShowLabelMap$fFunctorLabelMap$fFoldableLabelMap$fTraversableLabelMap $fEqLabelSet $fOrdLabelSet$fShowLabelSet$fMonoidLabelSet$fSemigroupLabelSet $fEqLabel $fOrdLabelBlockId mkBlockIdGraph'GNilGUnitGManyNonLocal entryLabel successorsBody emptyBodybodyListaddBlockmapGraphmapGraphBlocks labelsDefinedrevPostorderFrom$fNonLocalBlockShowForAllFlagShowForAllMustShowForAllWhenPrintExplicitKinds UseBndrParensSuppressBndrSigIfaceUnivCoProvIfacePhantomProvIfaceProofIrrelProvIfacePluginProvIfaceCorePrepProv IfaceReflCo IfaceGReflCo IfaceFunCoIfaceTyConAppCo IfaceAppCo IfaceForAllCo IfaceCoVarCoIfaceAxiomInstCoIfaceAxiomRuleCo IfaceUnivCo IfaceSymCo IfaceTransCo IfaceNthCo IfaceLRCo IfaceInstCo IfaceKindCo IfaceSubCoIfaceFreeCoVar IfaceHoleCoIfaceMCoercion IfaceMReflIfaceMCoIfaceTyConInfoifaceTyConIsPromotedifaceTyConSortIfaceTyConSortIfaceNormalTyConIfaceTupleTyCon IfaceSumTyConIfaceEqualityTyConifaceTyConNameifaceTyConInfoIA_NilIA_ArgIfaceForAllSpecBndrIfaceForAllBndrIfaceTyConBinder IfaceNumTyLit IfaceStrTyLitIfaceCharTyLit IfaceContext IfacePredType IfaceMultIfaceFreeTyVar IfaceTyVar IfaceLitTy IfaceAppTy IfaceFunTy IfaceForAllTy IfaceTyConApp IfaceCastTyIfaceCoercionTy IfaceTupleTy IfaceKind IfaceOneShotIfaceNoOneShot IfaceLamBndr IfaceTvBndr IfaceIdBndr IfExtName IfLclName ifaceBndrNamemkIfaceForAllTvBndrmkIfaceTyConKindifaceForAllSpecToBndrsifaceForAllSpecToBndrmkIfaceTyConInfoisIfaceLiftedTypeKindsplitIfaceSigmaTysuppressIfaceInvisiblesstripIfaceInvisVarsifForAllBndrVarifForAllBndrNameifTyConBinderVarifTyConBinderNamemkIfaceTySubstinDomIfaceTySubstsubstIfaceAppArgssubstIfaceTyVarstripInvisArgsappArgsIfaceTypesappArgsIfaceTypesArgFlagspprIfacePrefixAppisIfaceTauType pprIfaceBndrspprIfaceLamBndrpprIfaceIdBndrpprIfaceTvBndrpprIfaceTyConBinders pprIfaceTypepprParendIfaceTypepprPrecIfaceType ppr_fun_arrowmany_typprIfaceAppArgspprParendIfaceAppArgspprIfaceForAllPartpprIfaceForAllPartMustpprIfaceForAllpprIfaceSigmaTypepprUserIfaceForAllpprIfaceTypeApp pprTyTcApppprIfaceCoTcApp pprIfaceTyLitpprIfaceCoercionpprParendIfaceCoercionpprIfaceContextArrpprIfaceContext$fNFDataIfaceOneShot$fBinaryIfaceOneShot$fOutputableIfaceOneShot$fNFDataIfaceTyLit$fBinaryIfaceTyLit$fOutputableIfaceTyLit$fNFDataIfaceTyConSort$fBinaryIfaceTyConSort$fOutputableIfaceTyConSort$fNFDataIfaceTyConInfo$fBinaryIfaceTyConInfo$fOutputableIfaceTyConInfo$fNFDataIfaceTyCon$fBinaryIfaceTyCon$fOutputableIfaceTyCon$fNFDataIfaceAppArgs$fNFDataIfaceBndr$fNFDataIfaceMCoercion$fNFDataIfaceUnivCoProv$fNFDataIfaceCoercion$fNFDataIfaceType$fBinaryDefMethSpec$fBinaryIfaceUnivCoProv$fBinaryIfaceCoercion$fBinaryIfaceMCoercion$fBinaryIfaceType$fBinaryIfaceAppArgs$fOutputableIfaceCoercion$fOutputableIfaceAppArgs$fOutputableIfaceType$fBinaryIfaceBndr$fMonoidIfaceAppArgs$fSemigroupIfaceAppArgs$fOutputableIfaceBndr$fEqIfaceTyCon$fEqIfaceTyConInfo$fEqIfaceTyConSort$fEqIfaceTyLit DTyConEnvTyConEnvnonDetTyConEnvElts emptyTyConEnvisEmptyTyConEnv unitTyConEnvextendTyConEnvextendTyConEnvListlookupTyConEnv alterTyConEnv mkTyConEnvmkTyConEnvWith elemTyConEnv plusTyConEnvplusTyConEnv_CplusTyConEnv_CDplusTyConEnv_CD2extendTyConEnv_C mapTyConEnvextendTyConEnv_AccextendTyConEnvList_CdelFromTyConEnvdelListFromTyConEnvfilterTyConEnv anyTyConEnvdisjointTyConEnvlookupTyConEnv_NFemptyDTyConEnvisEmptyDTyConEnvlookupDTyConEnvdelFromDTyConEnvfilterDTyConEnv mapDTyConEnvmapMaybeDTyConEnvadjustDTyConEnvalterDTyConEnvextendDTyConEnv foldDTyConEnv pprParendType pprTidiedType pprPrecType pprPrecTypeX pprParendKind pprParendCo pprClassPredpprThetapprParendThetapprThetaArrowTy pprSigmaType pprForAll pprUserForAll pprTCvBndrs pprTCvBndr pprTyVars debugPprType pprDataCons pprTypeApppprWithExplicitKindsWhen pprWithTYPEpprSourceTyCon PatSynBuilder PatSynMatcherPatSynmkPatSyn patSynName patSynIsInfix patSynArityisVanillaPatSyn patSynArgspatSynFieldLabelspatSynFieldTypepatSynUnivTyVarBinderspatSynExTyVarspatSynExTyVarBinders patSynSigBndr patSynSig patSynMatcher patSynBuilderpatSynResultTypepatSynInstArgTyspatSynInstResTy pprPatSynType $fDataPatSyn$fOutputableBndrPatSyn$fOutputablePatSyn$fNamedThingPatSyn$fUniquablePatSyn $fEqPatSyn IsSubmultSubmultUnknown isMultMul mkMultAdd mkMultMul scaleScaled mkMultSupsubmult$fOutputableIsSubmult$fShowIsSubmult $fEqIsSubmultmkFunctionType RecTcChecker initRecTcdefaultRecTcMaxBoundsetRecTcMaxBound checkRecTc$fOutputableRecTcChecker LiftCoEnvLCNormaliseStepResultNS_DoneNS_AbortNS_StepNormaliseStepper coVarNamesetCoVarUnique setCoVarNameetaExpandCoAxBranch pprCoAxiompprCoAxBranchUserpprCoAxBranchLHS pprCoAxBranchtidyCoAxBndrsForUsercoToMCocheckReflexiveMCo isGReflMCo mkTransMCo mkTransMCoL mkTransMCoRmkSymMCo mkCastTyMComkHomoForAllMComkPiMCos mkFunResMComkGReflLeftMComkGReflRightMComkCoherenceRightMCo isReflMCo decomposeCodecomposeFunCogetCoVar_maybesplitTyConAppCo_maybemultToCosplitAppCo_maybesplitFunCo_maybesplitForAllCo_maybesplitForAllCo_ty_maybesplitForAllCo_co_maybe coVarLType coVarRType coVarTypes coVarKindisReflCoVar_maybeisGReflCo_maybeisReflCo_maybeisReflexiveCo_maybe mkRepReflComkAppCos mkForAllCosmkHomoForAllCos mkCoVarCos isCoVar_maybe mkAxInstComkUnbranchedAxInstCo mkAxInstRHSmkUnbranchedAxInstRHS mkAxInstLHSmkUnbranchedAxInstLHSmkHoleCo mkNthCoFunCo nthCoRolemkGReflRightCo mkGReflLeftComkCoherenceLeftComkCoherenceRightCo downgradeRolesetNominalRole_maybe tyConRolesXtyConRolesRepresentationalnthRoleltRolepromoteCoercioncastCoercionKind2castCoercionKind1castCoercionKindmkFamilyTyConAppComkPiCosmkPiCo mkFunResComkCoCastinstNewTyCon_maybe mapStepResultcomposeSteppersunwrapNewTypeSteppertopNormaliseTypeX eqCoercion eqCoercionXliftCoSubstWithExliftCoSubstWithemptyLiftingContextmkSubstLiftingContextextendLiftingContextextendLiftingContextAndInScopezapLiftingContextsubstForAllCoBndrUsingLCliftCoSubstTyVarliftCoSubstVarBndrUsing isMappedByLC substLeftCo substRightCo swapLiftCoEnv lcSubstLeft lcSubstRightliftEnvSubstLeftliftEnvSubstRight lcTCvSubst lcInScopeSet coercionKindscoercionKindRole coercionRolemkHeteroCoercionType mkPrimEqPredmkPrimEqPredRolemkHeteroPrimEqPredmkHeteroReprPrimEqPredmkReprPrimEqPred buildCoercionhasCoercionHoleTyhasCoercionHoleCohasThisCoercionHoleTy setCoHoleType$fOutputableNormaliseStepResult$fOutputableLiftingContextEqRelNomEqReprEqPred ClassPredEqPred IrredPred ForAllPredclassifyPredType mkClassPredisDictTygetClassPredTysgetClassPredTys_maybe classMethodTyclassMethodInstTy eqRelRole getEqPredTysgetEqPredTys_maybe getEqPredRole predTypeEqRel isEvVarType isEqPredClass isClassPredisEqPred isEqPrimPred isCTupleClass isIPTyCon isIPClass isIPLikePredhasIPSuperClassesisCallStackPredTyisCallStackPred isCallStackTyisIPPred_maybeisEvVarisDictId$fOutputableEqRel $fEqEqRel $fOrdEqRelArgsReductions Reductions ReductionR ReductionN HetReduction ReductionreductionCoercionreductionReducedTypemkHetReductionhomogeniseHetRedn mkReductionreductionOriginalType coercionRedn downgradeRedn mkSubRedn mkTransRedn mkReflRednmkGReflRightRednmkGReflRightMRednmkGReflLeftRednmkGReflLeftMRednmkCoherenceRightRednmkCoherenceRightMRedn mkCastRedn1 mkCastRedn2 mkAppRedn mkFunRedn mkForAllRednmkHomoForAllRednmkProofIrrelRedn mkReflCoRedn mkReductions mkAppRednsmkTyConAppRednmkClassPredRedn unzipRednssimplifyArgsWorker$fOutputableReductionVarMapBndrMapDeBruijnDCmEnv LooseTypeMapTypeMapTypeMapG CoercionMapGeqDeBruijnType eqDeBruijnVar foldTypeMap emptyTypeMap lookupTypeMap extendTypeMaplookupTypeMapWithScopeextendTypeMapWithScopemkDeBruijnContextemptyCME extendCME extendCMEs lookupCME deBruijnizelkBndrxtBndrlkVarxtVar lkDFreeVar xtDFreeVarlkDNamedxtDNamed$fTrieMapTyLitMap $fEqDeBruijn $fEqDeBruijn0 $fEqDeBruijn1 $fEqDeBruijn2 $fEqDeBruijn3$fTrieMapVarMap$fTrieMapBndrMap$fTrieMapTypeMapX$fTrieMapLooseTypeMap$fTrieMapTypeMap$fTrieMapCoercionMapX$fTrieMapCoercionMapRoughMapRoughMatchLookupTc RML_KnownTc RML_NoKnownTc RML_WildCard RoughMatchTc RM_KnownTc RM_WildCardroughMatchTcToLookupisRoughWildcardtypeToRoughMatchLookupTctypeToRoughMatchTcemptyRMlookupRM lookupRM'unionRMinsertRMfilterRMfilterMatchingRMelemsRMfoldRMsizeRM$fOutputableRoughMatchTc$fOutputableRoughMatchLookupTc$fOutputableRoughMap$fFunctorRoughMap$fDataRoughMatchLookupTc$fDataRoughMatchTcBindFlagBindMeApartMaybeApartReason MARTypeFamily MARInfiniteMARTypeVsConstraint UnifyResultM Unifiable MaybeApart SurelyApart UnifyResultBindFun tcMatchTy tcMatchTyX_BM tcMatchTyKi tcMatchTyX tcMatchTys tcMatchTyKis tcMatchTysX tcMatchTyKisXruleMatchTyKiX matchBindFun alwaysBindFun roughMatchTcsroughMatchTcsLookupinstanceCantMatchtypesCantMatch tcUnifyTy tcUnifyTyKitcUnifyTyWithTFs tcUnifyTys tcUnifyTyKis tcUnifyTysFG liftCoMatch flattenTys flattenTysX$fSemigroupMaybeApartReason$fOutputableMaybeApartReason$fOutputableUnifyResultM$fMonadUnifyResultM$fApplicativeUnifyResultM $fMonadFailUM $fMonadUM$fApplicativeUM $fFunctorUM $fEqBindFlag$fFunctorUnifyResultMStrictnessMark MarkedStrictNotMarkedStrictSrcUnpackedness SrcUnpack SrcNoUnpack NoSrcUnpack SrcStrictnessSrcLazy SrcStrict NoSrcStrict HsImplBangHsLazyHsStrictHsUnpack HsSrcBang DataConEnv NoDataConRepDCR dcr_wrap_id dcr_boxer dcr_arg_tys dcr_stricts dcr_bangsmkEqSpec eqSpecTyVar eqSpecType eqSpecPair eqSpecPreds substEqSpec filterEqSpeceqHsBangisBanged isSrcStrict isSrcUnpackedisMarkedStrictcbvFromStrictMark mkDataCon dataConTag dataConTagZdataConOrigTyCondataConRepTypedataConIsInfixdataConUnivTyVarsdataConUnivAndExTyCoVars dataConEqSpec dataConThetadataConWrapId_maybedataConImplicitTyThingsdataConFieldTypedataConFieldType_maybedataConSrcBangsdataConRepArityisNullarySrcDataConisNullaryRepDataCondataConRepStrictnessdataConImplBangs dataConBoxerdataConInstSigdataConOrigResTydataConWrapperTypedataConNonlinearTypedataConDisplayTypedataConInstArgTysdataConInstUnivsdataConOrigArgTysdataConOtherThetadataConRepArgTysdataConIdentityisTupleDataConisBoxedTupleDataConisUnboxedTupleDataConisVanillaDataCon isNewDataConspecialPromotedDc classDataCondataConCannotMatchdataConUserTyVarsArePermutedsplitDataProductType_maybe$fOutputableHsImplBang$fBinarySrcStrictness$fOutputableSrcStrictness$fBinarySrcUnpackedness$fOutputableSrcUnpackedness$fOutputableHsSrcBang$fBinaryStrictnessMark$fOutputableStrictnessMark$fOutputableEqSpec $fDataDataCon$fOutputableBndrDataCon$fOutputableDataCon$fNamedThingDataCon$fUniquableDataCon $fEqDataCon$fEqStrictnessMark$fDataHsSrcBang$fEqSrcUnpackedness$fDataSrcUnpackedness$fEqSrcStrictness$fDataSrcStrictness$fDataHsImplBang TypeShapeTsFunTsProdTsUnkDmdTransformerDmdSig PlusDmdArgDmdTypedt_envdt_argsdt_divDmdEnv DivergenceDivergesExnOrDivDunno SubDemandPolyProdDemandBotDmdAbsDmd CardNonOnce CardNonAbsCard:*C_0NC_1NC_01C_11C_10C_00isStrictisAbs isUsedOnce oneifyCardlubCardplusCardmultCard topSubDmdmkProdviewProdtopDmdabsDmdbotDmdseqDmdunboxDeeplyDmd lubSubDmdlubDmd multSubDmdmultDmd plusSubDmdplusDmdisTopDmdisAbsDmd isStrictDmd isStrUsedDmd isUsedOnceDmd isWeakDmdevalDmdstrictOnceApply1DmdstrictManyApply1Dmd lazyApply1Dmd lazyApply2Dmd oneifyDmd strictifyDmdstrictifyDictDmd lazifyDmdmkCalledOnceDmdmkCalledOnceDmds peelCallDmd peelManyCallsmkWorkerDemand argsOneShots argOneShotssaturatedByOneShots lubDivergencetopDivexnDivbotDiv isDeadEndDiv emptyDmdEnvreuseEnvkeepAliveDmdEnv lubDmdType mkPlusDmdArg toPlusDmdArg plusDmdType botDmdType nopDmdType dmdTypeDepth splitDmdTy multDmdTypepeelFV addDemand findIdDemanddeferAfterPreciseExceptionkeepAliveDmdTypemkDmdSigForAritymkClosedDmdSig splitDmdSig dmdSigDmdEnvhasDemandEnvSigbotSignopSigisTopSig isDeadEndSigonlyBoxedArgumentsisDeadEndAppSigtrimBoxityDmdSigprependArgsDmdSigetaConvertDmdSigdmdTransformSigdmdTransformDataConSigdmdTransformDictSelSig zapDmdEnvSigzapUsageDemandzapUsedOnceDemandzapUsedOnceSig trimToType trimBoxity seqDemand seqDemandList seqDmdType seqDmdSig $fBinaryCard$fOutputableCard $fShowCard$fBinarySubDemand$fBinaryDemand$fOutputableSubDemand$fOutputableDemand $fEqSubDemand$fBinaryDivergence$fOutputableDivergence$fBinaryDmdType$fOutputableDmdType $fEqDmdType$fBinaryDmdSig$fOutputableDmdSig$fOutputableTypeShape $fEqDmdSig$fEqDivergence $fEqDemand$fEqCardSlotTy PtrLiftedSlotPtrUnliftedSlotWordSlot Word64Slot FloatSlot DoubleSlot UnaryType NvUnaryType isNvUnaryTypetypePrimRepArgs unwrapTypecountFunRepArgscountConRepArgsdataConRuntimeRepStrictness isZeroBitTy ubxSumRepType layoutUbxSum typeSlotTy primRepSlot slotPrimRep typePrimReptypePrimRep_maybe typePrimRep1 tyConPrimRep tyConPrimRep1kindPrimRep_mayberuntimeRepPrimRepruntimeRepPrimRep_maybe primRepToType mightBeFunTy$fOutputableSlotTy $fEqSlotTy $fOrdSlotTyCprSig getCprSigUnpackConFieldsResult AllFieldsSame ForeachFieldCprTypect_artyct_cprCprConCprtopCprbotCpr flatConCprasConCpr topCprType botCprTypeflatConCprType lubCprType applyCprTy abstractCprTy trimCprTyunpackConFieldsCprmkCprSigForArity topCprSig isTopCprSigmkCprSig seqCprSig $fBinaryCpr$fOutputableCpr$fBinaryCprType$fOutputableCprType $fEqCprType$fOutputableCprSig $fEqCprSig$fBinaryCprSig$fEqCpr DoExtDynRefsDoSCCProfilingStandardFormInfoNonStandardThunk SelectorThunkApThunkLambdaFormInfo LFReEntrantLFThunkLFCon LFUnknown LFUnlifted LFLetNoEscape ModuleLFInfos CmmCgInfos cgNonCafs cgLFInfos cgIPEStub$fOutputableStandardFormInfo$fOutputableLambdaFormInfo$fEqStandardFormInfoAnnBind AnnNonRecAnnAltAnnExpr'AnnVarAnnLitAnnAppAnnCastAnnTick AnnCoercionAnnExpr TaggedAlt TaggedArg TaggedExpr TaggedBind TaggedBndrTBCoreAltCoreBindCoreArgCoreExprCoreBndr CoreProgramUnfoldingGuidanceUnfWhen UnfIfGoodArgsUnfNeverug_arity ug_unsat_ok ug_boring_okug_argsug_sizeug_resUnfoldingSource InlineRhs InlineStableInlineCompulsory Unfolding NoUnfolding BootUnfoldingOtherCon DFunUnfolding CoreUnfoldingdf_bndrsdf_condf_argsuf_tmpluf_src uf_is_top uf_is_value uf_is_conlikeuf_is_work_free uf_expandable uf_guidanceIdUnfoldingFun InScopeEnvRuleFunRuleOpts roPlatformroNumConstantFoldingroExcessRationalPrecision roBignumRulesCoreRuleRule BuiltinRuleru_nameru_actru_fnru_roughru_bndrsru_argsru_rhsru_auto ru_origin ru_orphanru_localru_nargsru_tryRuleEnvre_basere_visible_orphsRuleBaseIsOrphan NotOrphan MOutCoercionOutArgOutAltOutExprOutBind OutCoercionOutKindOutTypeOutBndr InCoercionInArgInAltInExprInBindInKindInTypeInBndrBindNonRecRecAltConDataAltLitAltDEFAULTAltArgExprLitAppLamLetCaseCastTickisOrphan notOrphanchooseOrphanAnchor mkRuleEnv emptyRuleEnv isBuiltinRule isAutoRule ruleArityruleName ruleModuleruleActivation ruleIdName isLocalRule setRuleIdName needSaturated unSaturatedOk boringCxtOkboringCxtNotOk noUnfoldingevaldUnfolding bootUnfolding mkOtherConisStableSourceunfoldingTemplatemaybeUnfoldingTemplate otherConsisValueUnfoldingisEvaldUnfoldingisConLikeUnfoldingisCheapUnfoldingisExpandableUnfoldingexpandUnfolding_maybeisCompulsoryUnfoldingisStableUnfoldingisInlineUnfoldinghasSomeUnfoldingisBootUnfoldingneverUnfoldGuidancehasCoreUnfolding canUnfoldcmpAltltAlt cmpAltCon deTagExprmkAppsmkCoApps mkVarAppsmkConAppmkTyApps mkConApp2mkTyArgmkIntLit mkIntLitWrap mkWordLit mkWordLitWrap mkWord8LitmkWord64LitWord64mkInt64LitInt64 mkCharLit mkStringLit mkFloatLitmkFloatLitFloat mkDoubleLitmkDoubleLitDoublemkLamsmkLetsmkLet mkLetNonRecmkLetRecmkTyBindmkCoBind varToCoreExprvarsToCoreExprs exprToType bindersOfbindersOfBinds rhssOfBind rhssOfAlts flattenBindscollectBinderscollectTyBinderscollectTyAndValBinderscollectNBinders collectArgs wrapLamBody stripNArgscollectArgsTicks isRuntimeVar isRuntimeArgisValArg isTyCoArgisCoArg isTypeArg valBndrCount valArgCountcollectAnnArgscollectAnnArgsTicks deAnnotate deAnnotate'deAnnAlt deAnnBindcollectAnnBndrscollectNAnnBndrs$fOutputableAltCon $fOrdAltCon$fBinaryIsOrphan$fOutputableTaggedBndr$fEqUnfoldingGuidance$fDataIsOrphan $fDataBind $fDataExpr $fDataAlt $fEqAltCon $fDataAltCon SimpleOpts simpleOptExpr so_uf_opts LevityInfo TickBoxOpTickBox TickBoxIdCafInfoMayHaveCafRefs NoCafRefsRuleInfoInlinePragInfo ArityInforuleInforealUnfoldingInfoinlinePragInfooccInfo dmdSigInfo cprSigInfo demandInfolfInfotagSig RecSelParent RecSelData RecSelPatSyn VanillaIdRecSelId DataConWorkId DataConWrapId ClassOpIdPrimOpIdFCallId TickBoxOpIdCoVarId WorkerLikeId sel_tycon sel_naughtyisJoinIdDetails_maybe levityInfo oneShotInfo arityInfocafInfo callArityInfo tagSigInfo setRuleInfosetInlinePragInfo setOccInfo unfoldingInfosetUnfoldingInfohasInlineUnfolding setArityInfosetCallArityInfo setCafInfo setLFInfo setTagSigsetOneShotInfo setDemandInfo setDmdSigInfo setCprSigInfo noCafIdInfo unknownArity ppArityInfo pprStrictness emptyRuleInfoisEmptyRuleInforuleInfoFreeVars ruleInfoRulessetRuleInfoHeadmayHaveCafRefs ppCafInfo zapLamInfo zapDemandInfo zapUsageInfozapUsageEnvInfozapUsedOnceInfozapFragileInfo trimUnfoldingzapTailCallInfozapCallArityInfosetNeverRepPolysetLevityInfoWithTypeisNeverRepPolyIdInfo$fOutputableRecSelParent$fOutputableCafInfo$fOutputableTickBoxOp$fOutputableIdDetails$fOutputableLevityInfo$fEqLevityInfo $fEqCafInfo $fOrdCafInfo$fEqRecSelParentidUniqueidTypeidMult idScaledType scaleIdBy scaleVarBy setIdName setIdUnique setIdType localiseId setIdInfo modifyIdInfomaybeModifyIdInfo mkGlobalIdmkVanillaGlobalmkVanillaGlobalWithInfo mkLocalId mkLocalCoVarmkLocalIdOrCoVarmkLocalIdWithInfomkExportedLocalIdmkExportedVanillaId mkSysLocalmkSysLocalOrCoVar mkSysLocalMmkSysLocalOrCoVarM mkUserLocalmkUserLocalOrCoVar mkWorkerIdmkTemplateLocalmkScaledTemplateLocalmkTemplateLocalsmkTemplateLocalsNumrecordSelectorTyConrecordSelectorTyCon_maybeisRecordSelectorisDataConRecordSelectorisPatSynRecordSelectorisNaughtyRecordSelector isClassOpIdisClassOpId_maybe isPrimOpIdisDFunIdisPrimOpId_maybe isFCallIdisFCallId_maybeisDataConWorkIdisDataConWorkId_maybeisDataConWrapIdisDataConWrapId_maybeisDataConId_maybeisWorkerLikeIdisJoinIdisJoinId_maybe idDataCon hasNoBinding isImplicitIdidIsFrom isDeadBinder idJoinArityasJoinId zapJoinIdasJoinId_maybeidArity setIdArity idCallAritysetIdCallArity idFunRepArity isDeadEndIdidDmdSig setIdDmdSigidCprSig setIdCprSig zapIdDmdSig isStrictIdidTagSig_maybe idUnfoldingrealIdUnfoldingsetIdUnfolding idDemandInfosetIdDemandInfo setIdTagSig setIdCbvMarksidCbvMarks_maybeidCbvMarkArityasNonWorkerLikeIdasWorkerLikeIdsetCaseBndrEvaldzapIdUnfoldingidSpecialisation idCoreRules idHasRulessetIdSpecialisation idCafInfo setIdCafInfoidLFInfo_maybe setIdLFInfo idOccInfo setIdOccInfo zapIdOccInfoidInlinePragmasetInlinePragmamodifyInlinePragmaidInlineActivationsetInlineActivationidRuleMatchInfo isConLikeId idOneShotInfoidStateHackOneShotInfo isOneShotBndrstateHackOneShot typeOneShotisStateHackTypeisProbablyOneShotLambdasetOneShotLambdaclearOneShotLambdasetIdOneShotInfoupdOneShotInfo zapLamIdInfozapFragileIdInfozapIdDemandInfozapIdUsageInfozapIdUsageEnvInfozapIdUsedOnceInfozapIdTailCallInfozapStableUnfoldingtransferPolyIdInfoisNeverRepPolyId UnVarGraphUnVarSet emptyUnVarSet elemUnVarSetisEmptyUnVarSet delUnVarSetdelUnVarSetList mkUnVarSet varEnvDomextendUnVarSetextendUnVarSetList unionUnVarSetunionUnVarSetsemptyUnVarGraphunionUnVarGraphunionUnVarGraphscompleteBipartiteGraph completeGraph neighbors hasLoopAtdelNode$fOutputableUnVarSet$fOutputableUnVarGraph $fEqUnVarSeteqDeBruijnExpr eqCoreExpr lookupCoreMap extendCoreMap foldCoreMap emptyCoreMap$fTrieMapAltMap$fTrieMapCoreMapX$fOutputableCoreMap$fTrieMapCoreMap megaSeqIdInfo seqRuleInfoseqRulesseqExprseqExprsseqBinds seqUnfolding FamInstMatch fim_instancefim_tysfim_cosInjectivityCheckResultInjectivityAcceptedInjectivityUnified FamInstEnv FamInstEnvs FamFlavor SynFamilyInstDataFamilyInstFamInstfi_axiom fi_flavorfi_famfi_tcsfi_tvsfi_cvsfi_tysfi_rhs famInstAxiom famInstRHS famInstTyConfamInstsRepTyConsfamInstRepTyCon_maybedataFamInstRepTyCon pprFamInst pprFamInstsmkImportedFamInstfamInstEnvSizeemptyFamInstEnvsemptyFamInstEnvfamInstEnvEltsfamilyInstancesfamilyNameInstancesunionFamInstEnvextendFamInstEnvListextendFamInstEnvinjectiveBranches mkCoAxBranchmkBranchedCoAxiommkUnbranchedCoAxiommkSingleCoAxiommkNewTypeCoAxiomlookupFamInstEnvByTyConlookupFamInstEnvlookupFamInstEnvConflicts$lookupFamInstEnvInjectivityConflicts isDominatedByreduceTyFamApp_maybeapartnessChecktopNormaliseTypetopNormaliseType_maybenormaliseTcApptopReduceTyFamApp_maybe normaliseType$fOutputableFamInst$fNamedThingFamInst$fOutputableFamInstEnv$fOutputableFamInstMatch$fApplicativeNormM $fMonadNormM$fFunctorNormMUnlitCppHsPpHscCcxxCcCobjcCobjcxxHCcAsLlvmOptLlvmLlc LlvmMangleCmmCppCmm MergeForeignStopLn StopPhaseStopPreprocessStopCStopAsNoStopstopPhaseToPhaseisStopLneqPhase happensBefore startPhase phaseInputExtisHaskellishSuffixisBackpackishSuffixisHaskellSigSuffixisHaskellSrcSuffix isCishSuffixisHaskellUserSrcSuffixisObjectSuffixisDynLibSuffixisSourceSuffixisHaskellishTargetisHaskellishFilenameisHaskellSrcFilenameisCishFilenameisHaskellUserSrcFilenameisSourceFilenameisHaskellSigFilenameisObjectFilenameisDynLibFilenamephaseForeignLanguage$fOutputablePhase $fEqPhase $fShowPhaseIfaceTrustInfoSafeHaskellModeSf_None Sf_UnsafeSf_TrustworthySf_SafeSf_SafeInferred Sf_Ignore IsSafeImport getSafeMode setSafeModenoIfaceTrustInfo$fOutputableSafeHaskellMode$fShowSafeHaskellMode$fBinaryIfaceTrustInfo$fOutputableIfaceTrustInfo$fEqSafeHaskellModeImportedModsValimv_nameimv_span imv_is_safe imv_is_hidingimv_all_exports imv_qualified ImportedByImportedByUserImportedBySystem ImportedModsimportedByUserOutputableBndrId NoGhcTcPassIdGhcPIsPassghcPassGhcTcGhcRnGhcPsPassParsedRenamed TypecheckedGhcPass IsSrcSpanAnnpprIfPspprIfRnpprIfTcnoHsTok noHsUniTok $fDataGhcPass$fMapXRecGhcPass$fUnXRecGhcPass$fIsPassTypechecked$fIsPassRenamed$fIsPassParsed $fDataPassUniqMap emptyUniqMap isNullUniqMap unitUniqMap listToUniqMaplistToUniqMap_C addToUniqMapaddListToUniqMapaddToUniqMap_CaddToUniqMap_Acc alterUniqMapaddListToUniqMap_C adjustUniqMapdelFromUniqMapdelListFromUniqMap plusUniqMap plusUniqMap_CplusMaybeUniqMap_CplusUniqMapList minusUniqMapintersectUniqMapdisjointUniqMap mapUniqMap filterUniqMappartitionUniqMap sizeUniqMap elemUniqMap lookupUniqMaplookupWithDefaultUniqMap anyUniqMap allUniqMapnonDetEltsUniqMapnonDetFoldUniqMap$fOutputableUniqMap$fMonoidUniqMap$fSemigroupUniqMap $fDataUniqMap $fEqUniqMap$fFunctorUniqMapExtractedTHDocsethd_mod_headerethd_decl_docs ethd_arg_docsethd_inst_docsDocs docs_mod_hdr docs_decls docs_argsdocs_structuredocs_named_chunksdocs_haddock_opts docs_languagedocs_extensions DocStructureDocStructureItemDsiSectionHeading DsiDocChunkDsiNamedChunkRef DsiExports DsiModExportLHsDocWithHsDocIdentifiers hsDocStringhsDocIdentifiersHsDochsDocIds pprWithDocpprMaybeWithDoc pprHsDocDebug emptyDocs$fBinaryWithHsDocIdentifiers $fOutputableWithHsDocIdentifiers$fOutputableDocStructureItem$fBinaryDocStructureItem$fOutputableDocs $fBinaryDocs$fEqWithHsDocIdentifiers$fDataWithHsDocIdentifiersAmbiguousFieldOcc Unambiguous AmbiguousXAmbiguousFieldOccLAmbiguousFieldOccFieldOcc XFieldOccfoExtfoLabel LFieldOcc LHsTypeArgHsArgHsValArg HsTypeArgHsArgPar HsConDetails PrefixConRecConInfixCon ConDeclField cd_fld_ext cd_fld_names cd_fld_type cd_fld_doc LConDeclField HsTupleSortHsUnboxedTupleHsBoxedOrConstraintTupleHsScaledHsLinearArrowTokensHsPct1HsLollyHsArrowHsUnrestrictedArrow HsLinearArrowHsExplicitMultHsTyLitHsNumTyHsStrTyHsCharTyHsCoreTyHsType HsForAllTyHsQualTyHsTyVarHsAppTy HsAppKindTyHsFunTyHsListTy HsTupleTyHsSumTyHsOpTyHsParTy HsIParamTyHsStarTy HsKindSig HsSpliceTyHsDocTyHsBangTyHsRecTyHsExplicitListTyHsExplicitTupleTy HsWildCardTyXHsType hst_xforallhst_telehst_body hst_xqualhst_ctxt HsTyVarBndr UserTyVar KindedTyVar XTyVarBndrHsIPName HsSigTypeHsSig XHsSigTypesig_ext sig_bndrssig_body LHsSigWcType LHsWcType LHsSigTypeHsPSRn hsps_nwcs hsps_imp_tvs HsPatSigTypeHsPS XHsPatSigTypehsps_ext hsps_bodyHsWildCardBndrsHsWCXHsWildCardBndrshswc_ext hswc_bodyHsOuterFamEqnTyVarBndrsHsOuterSigTyVarBndrsHsOuterTyVarBndrsHsOuterImplicitHsOuterExplicitXHsOuterTyVarBndrs hso_ximplicit hso_xexplicit hso_bndrs LHsQTyVarsHsQTvs XLHsQTyVarshsq_ext hsq_explicit LHsTyVarBndrHsForAllTelescope HsForAllVis HsForAllInvisXHsForAllTelescopehsf_xvis hsf_vis_bndrs hsf_xinvishsf_invis_bndrsLHsKindHsKindLHsType HsContext LHsContextBangType LBangType hsQTvExplicit hsPatSigTypemapHsOuterImplicit hsIPNameFSisHsKindedTyVarhsMult hsScaledThing noTypeArgsnumVisibleArgs pprHsArgsApp$fOutputableBndrHsIPName$fOutputableHsIPName$fOutputableHsTyLit$fOutputableHsConDetails$fOutputableHsArg$fOutputableBndrFieldOcc$fOutputableFieldOcc$fDataHsConDetails$fDataHsTupleSort $fDataHsTyLit $fEqHsIPName$fDataHsIPName $fDataHsPSRn $fEqFieldOccWarnings NoWarningsWarnAllWarnSome WarningTxt DeprecatedTxtpprWarningTxtForMsgmkIfaceWarnCacheemptyIfaceWarnCache plusWarns$fBinaryWarningTxt$fOutputableWarningTxt$fBinaryWarnings $fEqWarnings$fDataWarningTxt$fEqWarningTxt UnitPprInfo unitPprIdunitPprPackageNameunitPprPackageVersionunitPprComponentName$fOutputableUnitPprInfo PackageName unPackageName PackageIdUnitInfo UnitKeyInfo GenUnitInfo mkUnitKeyInfo mapUnitInfounitPackageIdStringunitPackageNameString pprUnitInfomkUnit mkUnitPprInfocollectIncludeDirscollectExtraCcOptscollectLibraryDirscollectFrameworkscollectFrameworksDirs unitHsLibs$fOutputablePackageId$fUniquablePackageId$fOutputablePackageName$fUniquablePackageName$fEqPackageName $fEqPackageIdPkgQual NoPkgQualThisPkgOtherPkg RawPkgQual NoRawPkgQual$fOutputableRawPkgQual$fOutputablePkgQual $fDataPkgQual $fOrdPkgQual $fEqPkgQual$fDataRawPkgQualFixItem FixityEnvemptyFixityEnv lookupFixitymkIfaceFixCacheemptyIfaceFixCache$fOutputableFixItem RealDataCon PatSynConisVanillaConLike conLikeArityconLikeFieldLabelsconLikeInstOrigArgTysconLikeUserTyVarBindersconLikeExTyCoVars conLikeNameconLikeStupidThetaconLikeHasBuilderconLikeImplBangs conLikeResTyconLikeFullSigconLikeFieldTypeconLikesWithFieldsconLikeIsInfix $fDataConLike$fOutputableBndrConLike$fOutputableConLike$fNamedThingConLike$fUniquableConLike $fEqConLike MonadThings lookupThinglookupId lookupDataCon lookupTyConAnIdAConLikeATyConACoAxiompprShortTyThingpprTyThingCategorytyThingCategoryimplicitTyThingsimplicitConLikeThingsimplicitClassThingsimplicitTyConThingsimplicitCoTyConisImplicitTyThingtyThingParent_maybetyThingsTyCoVarstyThingAvailInfo tyThingTyContyThingCoAxiomtyThingDataContyThingConLike tyThingId$fNamedThingTyThing$fOutputableTyThing$fMonadThingsReaderTHistoryhistoryApStackhistoryBreakInfohistoryEnclosingDeclsResumeBindingsResume resumeStmt resumeContextresumeBindingsresumeFinalIds resumeApStackresumeBreakInfo resumeSpan resumeDecl resumeCCS resumeHistoryresumeHistoryIxIcGlobalRdrEnvigre_envigre_prompt_env ExecResult ExecComplete ExecBreak execResultexecAllocation breakNames breakInfo SingleStepRunToCompletionRunAndLogSteps ExecOptionsexecSingleStepexecSourceFileexecLineNumberexecWrapisStep wiredInTyConsmkWiredInTyConNamemkWiredInIdName eqTyConName eqTyCon_RDR heqTyConNamecoercibleTyConName charTyConName intTyConName boolTyConName listTyConNamenilDataConNameconsDataConNamenonEmptyTyConNamenonEmptyDataConNamemaybeTyConNamenothingDataConNamejustDataConName wordTyConNamefloatTyConNamedoubleTyConNameanyTyConanyTymakeRecoveryTyConconstraintKindTyConNameunliftedTypeKindTyConNameliftedRepTyConNameunliftedRepTyConNamemultiplicityTyConNameoneDataConNamemanyDataConName boolTyCon_RDR false_RDRtrue_RDR intTyCon_RDR charTyCon_RDRstringTyCon_RDRintDataCon_RDR listTyCon_RDRconsDataCon_RDRtypeSymbolKindConconstraintKindTyContypeToTypeKindisBuiltInOcc_maybe mkTupleStr cTupleTyConcTupleTyConNamesisCTupleTyConNamecTupleTyConNameArity_maybecTupleDataConNames cTupleSelIdtupleDataConNamemkPromotedPairTyisPromotedPairType unitTyCon unitTyConKey unitDataCon unitDataConId soloTyCon pairTyCon unboxedUnitTyunboxedUnitTyConunboxedUnitDataConunboxedSumKindeqTyConeqClass eqDataConheqClass heqDataConcoercibleClasscoercibleDataCon oneDataCon manyDataConunrestrictedFunTyConNameunliftedDataConTyConsumRepDataConTyConboxingDataCon_maybe charTyCon charDataConstringTyintTyintTyCon intDataConwordTy wordTyCon wordDataConword8Ty word8TyCon word8DataConfloatTy floatTyCon floatDataCondoubleTy doubleTyCon doubleDataConboolTy boolTyCon falseDataCon trueDataConfalseDataConId trueDataConId orderingTyCon ordLTDataCon ordEQDataCon ordGTDataConordLTDataConIdordEQDataConIdordGTDataConIdmkListTy nilDataCon consDataCon nonEmptyTyConnonEmptyDataCon maybeTyConnothingDataCon justDataConmkPromotedMaybeTy mkMaybeTyisPromotedMaybeTy mkTupleTy mkTupleTy1mkSumTypromotedTrueDataConpromotedFalseDataConpromotedNothingDataConpromotedJustDataConpromotedLTDataConpromotedEQDataConpromotedGTDataConpromotedConsDataConpromotedNilDataConmkPromotedListTyintegerTyConNameintegerISDataConNameintegerIPDataConNameintegerINDataConName integerTyConintegerISDataConintegerIPDataConintegerINDataConnaturalTyConNamenaturalNSDataConNamenaturalNBDataConName naturalTyConnaturalNSDataConnaturalNBDataCon filterCTuplePrimCallPrimOpResultInfo ReturnsPrim ReturnsAlg PrimOpVecCatIntVecWordVecFloatVecCharGtOpCharGeOpCharEqOpCharNeOpCharLtOpCharLeOpOrdOp Int8ToIntOp IntToInt8Op Int8NegOp Int8AddOp Int8SubOp Int8MulOp Int8QuotOp Int8RemOp Int8QuotRemOp Int8SllOp Int8SraOp Int8SrlOp Int8ToWord8OpInt8EqOpInt8GeOpInt8GtOpInt8LeOpInt8LtOpInt8NeOp Word8ToWordOp WordToWord8Op Word8AddOp Word8SubOp Word8MulOp Word8QuotOp Word8RemOpWord8QuotRemOp Word8AndOp Word8OrOp Word8XorOp Word8NotOp Word8SllOp Word8SrlOp Word8ToInt8Op Word8EqOp Word8GeOp Word8GtOp Word8LeOp Word8LtOp Word8NeOp Int16ToIntOp IntToInt16Op Int16NegOp Int16AddOp Int16SubOp Int16MulOp Int16QuotOp Int16RemOpInt16QuotRemOp Int16SllOp Int16SraOp Int16SrlOpInt16ToWord16Op Int16EqOp Int16GeOp Int16GtOp Int16LeOp Int16LtOp Int16NeOpWord16ToWordOpWordToWord16Op Word16AddOp Word16SubOp Word16MulOp Word16QuotOp Word16RemOpWord16QuotRemOp Word16AndOp Word16OrOp Word16XorOp Word16NotOp Word16SllOp Word16SrlOpWord16ToInt16Op Word16EqOp Word16GeOp Word16GtOp Word16LeOp Word16LtOp Word16NeOp Int32ToIntOp IntToInt32Op Int32NegOp Int32AddOp Int32SubOp Int32MulOp Int32QuotOp Int32RemOpInt32QuotRemOp Int32SllOp Int32SraOp Int32SrlOpInt32ToWord32Op Int32EqOp Int32GeOp Int32GtOp Int32LeOp Int32LtOp Int32NeOpWord32ToWordOpWordToWord32Op Word32AddOp Word32SubOp Word32MulOp Word32QuotOp Word32RemOpWord32QuotRemOp Word32AndOp Word32OrOp Word32XorOp Word32NotOp Word32SllOp Word32SrlOpWord32ToInt32Op Word32EqOp Word32GeOp Word32GtOp Word32LeOp Word32LtOp Word32NeOp Int64ToIntOp IntToInt64Op Int64NegOp Int64AddOp Int64SubOp Int64MulOp Int64QuotOp Int64RemOp Int64SllOp Int64SraOp Int64SrlOpInt64ToWord64Op Int64EqOp Int64GeOp Int64GtOp Int64LeOp Int64LtOp Int64NeOpWord64ToWordOpWordToWord64Op Word64AddOp Word64SubOp Word64MulOp Word64QuotOp Word64RemOp Word64AndOp Word64OrOp Word64XorOp Word64NotOp Word64SllOp Word64SrlOpWord64ToInt64Op Word64EqOp Word64GeOp Word64GtOp Word64LeOp Word64LtOp Word64NeOpIntAddOpIntSubOpIntMulOp IntMul2OpIntMulMayOfloOp IntQuotOpIntRemOp IntQuotRemOpIntAndOpIntOrOpIntXorOpIntNotOpIntNegOp IntAddCOp IntSubCOpIntGtOpIntGeOpIntEqOpIntNeOpIntLtOpIntLeOpChrOp IntToWordOp IntToFloatOp IntToDoubleOp WordToFloatOpWordToDoubleOpIntSllOpIntSraOpIntSrlOp WordAddOp WordAddCOp WordSubCOp WordAdd2Op WordSubOp WordMulOp WordMul2Op WordQuotOp WordRemOp WordQuotRemOpWordQuotRem2Op WordAndOpWordOrOp WordXorOp WordNotOp WordSllOp WordSrlOp WordToIntOpWordGtOpWordGeOpWordEqOpWordNeOpWordLtOpWordLeOp PopCnt8Op PopCnt16Op PopCnt32Op PopCnt64OpPopCntOpPdep8OpPdep16OpPdep32OpPdep64OpPdepOpPext8OpPext16OpPext32OpPext64OpPextOpClz8OpClz16OpClz32OpClz64OpClzOpCtz8OpCtz16OpCtz32OpCtz64OpCtzOp BSwap16Op BSwap32Op BSwap64OpBSwapOpBRev8OpBRev16OpBRev32OpBRev64OpBRevOp Narrow8IntOp Narrow16IntOp Narrow32IntOp Narrow8WordOpNarrow16WordOpNarrow32WordOp DoubleGtOp DoubleGeOp DoubleEqOp DoubleNeOp DoubleLtOp DoubleLeOp DoubleAddOp DoubleSubOp DoubleMulOp DoubleDivOp DoubleNegOp DoubleFabsOp DoubleToIntOpDoubleToFloatOp DoubleExpOp DoubleExpM1Op DoubleLogOp DoubleLog1POp DoubleSqrtOp DoubleSinOp DoubleCosOp DoubleTanOp DoubleAsinOp DoubleAcosOp DoubleAtanOp DoubleSinhOp DoubleCoshOp DoubleTanhOp DoubleAsinhOp DoubleAcoshOp DoubleAtanhOp DoublePowerOpDoubleDecode_2IntOpDoubleDecode_Int64Op FloatGtOp FloatGeOp FloatEqOp FloatNeOp FloatLtOp FloatLeOp FloatAddOp FloatSubOp FloatMulOp FloatDivOp FloatNegOp FloatFabsOp FloatToIntOp FloatExpOp FloatExpM1Op FloatLogOp FloatLog1POp FloatSqrtOp FloatSinOp FloatCosOp FloatTanOp FloatAsinOp FloatAcosOp FloatAtanOp FloatSinhOp FloatCoshOp FloatTanhOp FloatAsinhOp FloatAcoshOp FloatAtanhOp FloatPowerOpFloatToDoubleOpFloatDecode_IntOp NewArrayOp ReadArrayOp WriteArrayOp SizeofArrayOpSizeofMutableArrayOp IndexArrayOpUnsafeFreezeArrayOpUnsafeThawArrayOp CopyArrayOpCopyMutableArrayOp CloneArrayOpCloneMutableArrayOp FreezeArrayOp ThawArrayOp CasArrayOpNewSmallArrayOpShrinkSmallMutableArrayOp_CharReadSmallArrayOpWriteSmallArrayOpSizeofSmallArrayOpSizeofSmallMutableArrayOpGetSizeofSmallMutableArrayOpIndexSmallArrayOpUnsafeFreezeSmallArrayOpUnsafeThawSmallArrayOpCopySmallArrayOpCopySmallMutableArrayOpCloneSmallArrayOpCloneSmallMutableArrayOpFreezeSmallArrayOpThawSmallArrayOpCasSmallArrayOpNewByteArrayOp_CharNewPinnedByteArrayOp_Char NewAlignedPinnedByteArrayOp_CharMutableByteArrayIsPinnedOpByteArrayIsPinnedOpByteArrayContents_CharMutableByteArrayContents_CharShrinkMutableByteArrayOp_CharResizeMutableByteArrayOp_CharUnsafeFreezeByteArrayOpSizeofByteArrayOpSizeofMutableByteArrayOpGetSizeofMutableByteArrayOpIndexByteArrayOp_CharIndexByteArrayOp_WideCharIndexByteArrayOp_IntIndexByteArrayOp_WordIndexByteArrayOp_AddrIndexByteArrayOp_FloatIndexByteArrayOp_DoubleIndexByteArrayOp_StablePtrIndexByteArrayOp_Int8IndexByteArrayOp_Int16IndexByteArrayOp_Int32IndexByteArrayOp_Int64IndexByteArrayOp_Word8IndexByteArrayOp_Word16IndexByteArrayOp_Word32IndexByteArrayOp_Word64IndexByteArrayOp_Word8AsChar IndexByteArrayOp_Word8AsWideCharIndexByteArrayOp_Word8AsIntIndexByteArrayOp_Word8AsWordIndexByteArrayOp_Word8AsAddrIndexByteArrayOp_Word8AsFloatIndexByteArrayOp_Word8AsDouble!IndexByteArrayOp_Word8AsStablePtrIndexByteArrayOp_Word8AsInt16IndexByteArrayOp_Word8AsInt32IndexByteArrayOp_Word8AsInt64IndexByteArrayOp_Word8AsWord16IndexByteArrayOp_Word8AsWord32IndexByteArrayOp_Word8AsWord64ReadByteArrayOp_CharReadByteArrayOp_WideCharReadByteArrayOp_IntReadByteArrayOp_WordReadByteArrayOp_AddrReadByteArrayOp_FloatReadByteArrayOp_DoubleReadByteArrayOp_StablePtrReadByteArrayOp_Int8ReadByteArrayOp_Int16ReadByteArrayOp_Int32ReadByteArrayOp_Int64ReadByteArrayOp_Word8ReadByteArrayOp_Word16ReadByteArrayOp_Word32ReadByteArrayOp_Word64ReadByteArrayOp_Word8AsCharReadByteArrayOp_Word8AsWideCharReadByteArrayOp_Word8AsIntReadByteArrayOp_Word8AsWordReadByteArrayOp_Word8AsAddrReadByteArrayOp_Word8AsFloatReadByteArrayOp_Word8AsDouble ReadByteArrayOp_Word8AsStablePtrReadByteArrayOp_Word8AsInt16ReadByteArrayOp_Word8AsInt32ReadByteArrayOp_Word8AsInt64ReadByteArrayOp_Word8AsWord16ReadByteArrayOp_Word8AsWord32ReadByteArrayOp_Word8AsWord64WriteByteArrayOp_CharWriteByteArrayOp_WideCharWriteByteArrayOp_IntWriteByteArrayOp_WordWriteByteArrayOp_AddrWriteByteArrayOp_FloatWriteByteArrayOp_DoubleWriteByteArrayOp_StablePtrWriteByteArrayOp_Int8WriteByteArrayOp_Int16WriteByteArrayOp_Int32WriteByteArrayOp_Int64WriteByteArrayOp_Word8WriteByteArrayOp_Word16WriteByteArrayOp_Word32WriteByteArrayOp_Word64WriteByteArrayOp_Word8AsChar WriteByteArrayOp_Word8AsWideCharWriteByteArrayOp_Word8AsIntWriteByteArrayOp_Word8AsWordWriteByteArrayOp_Word8AsAddrWriteByteArrayOp_Word8AsFloatWriteByteArrayOp_Word8AsDouble!WriteByteArrayOp_Word8AsStablePtrWriteByteArrayOp_Word8AsInt16WriteByteArrayOp_Word8AsInt32WriteByteArrayOp_Word8AsInt64WriteByteArrayOp_Word8AsWord16WriteByteArrayOp_Word8AsWord32WriteByteArrayOp_Word8AsWord64CompareByteArraysOpCopyByteArrayOpCopyMutableByteArrayOpCopyByteArrayToAddrOpCopyMutableByteArrayToAddrOpCopyAddrToByteArrayOpSetByteArrayOpAtomicReadByteArrayOp_IntAtomicWriteByteArrayOp_IntCasByteArrayOp_IntCasByteArrayOp_Int8CasByteArrayOp_Int16CasByteArrayOp_Int32CasByteArrayOp_Int64FetchAddByteArrayOp_IntFetchSubByteArrayOp_IntFetchAndByteArrayOp_IntFetchNandByteArrayOp_IntFetchOrByteArrayOp_IntFetchXorByteArrayOp_Int AddrAddOp AddrSubOp AddrRemOp AddrToIntOp IntToAddrOpAddrGtOpAddrGeOpAddrEqOpAddrNeOpAddrLtOpAddrLeOpIndexOffAddrOp_CharIndexOffAddrOp_WideCharIndexOffAddrOp_IntIndexOffAddrOp_WordIndexOffAddrOp_AddrIndexOffAddrOp_FloatIndexOffAddrOp_DoubleIndexOffAddrOp_StablePtrIndexOffAddrOp_Int8IndexOffAddrOp_Int16IndexOffAddrOp_Int32IndexOffAddrOp_Int64IndexOffAddrOp_Word8IndexOffAddrOp_Word16IndexOffAddrOp_Word32IndexOffAddrOp_Word64ReadOffAddrOp_CharReadOffAddrOp_WideCharReadOffAddrOp_IntReadOffAddrOp_WordReadOffAddrOp_AddrReadOffAddrOp_FloatReadOffAddrOp_DoubleReadOffAddrOp_StablePtrReadOffAddrOp_Int8ReadOffAddrOp_Int16ReadOffAddrOp_Int32ReadOffAddrOp_Int64ReadOffAddrOp_Word8ReadOffAddrOp_Word16ReadOffAddrOp_Word32ReadOffAddrOp_Word64WriteOffAddrOp_CharWriteOffAddrOp_WideCharWriteOffAddrOp_IntWriteOffAddrOp_WordWriteOffAddrOp_AddrWriteOffAddrOp_FloatWriteOffAddrOp_DoubleWriteOffAddrOp_StablePtrWriteOffAddrOp_Int8WriteOffAddrOp_Int16WriteOffAddrOp_Int32WriteOffAddrOp_Int64WriteOffAddrOp_Word8WriteOffAddrOp_Word16WriteOffAddrOp_Word32WriteOffAddrOp_Word64InterlockedExchange_AddrInterlockedExchange_WordCasAddrOp_AddrCasAddrOp_WordCasAddrOp_Word8CasAddrOp_Word16CasAddrOp_Word32CasAddrOp_Word64FetchAddAddrOp_WordFetchSubAddrOp_WordFetchAndAddrOp_WordFetchNandAddrOp_WordFetchOrAddrOp_WordFetchXorAddrOp_WordAtomicReadAddrOp_WordAtomicWriteAddrOp_Word NewMutVarOp ReadMutVarOp WriteMutVarOpAtomicModifyMutVar2OpAtomicModifyMutVar_Op CasMutVarOpCatchOpRaiseOp RaiseIOOpMaskAsyncExceptionsOpMaskUninterruptibleOpUnmaskAsyncExceptionsOp MaskStatus AtomicallyOpRetryOp CatchRetryOp CatchSTMOp NewTVarOp ReadTVarOp ReadTVarIOOp WriteTVarOp NewMVarOp TakeMVarOp TryTakeMVarOp PutMVarOp TryPutMVarOp ReadMVarOp TryReadMVarOp IsEmptyMVarOp NewIOPortOp ReadIOPortOp WriteIOPortOpDelayOp WaitReadOp WaitWriteOpForkOpForkOnOp KillThreadOpYieldOp MyThreadIdOp LabelThreadOpIsCurrentThreadBoundOp NoDuplicateOpThreadStatusOpMkWeakOpMkWeakNoFinalizerOpAddCFinalizerToWeakOp DeRefWeakOpFinalizeWeakOpTouchOpMakeStablePtrOpDeRefStablePtrOp EqStablePtrOpMakeStableNameOpStableNameToIntOp CompactNewOpCompactResizeOpCompactContainsOpCompactContainsAnyOpCompactGetFirstBlockOpCompactGetNextBlockOpCompactAllocateBlockOpCompactFixupPointersOp CompactAddCompactAddWithSharing CompactSizeReallyUnsafePtrEqualityOpParOpSparkOpSeqOp GetSparkOp NumSparks KeepAliveOp DataToTagOp TagToEnumOp AddrToAnyOp AnyToAddrOp MkApUpd0_OpNewBCOOpUnpackClosureOp ClosureSizeOpGetApStackValOp GetCCSOfOpGetCurrentCCSOp ClearCCSOp WhereFromOp TraceEventOpTraceEventBinaryOp TraceMarkerOpSetThreadAllocationCounterVecBroadcastOp VecPackOp VecUnpackOp VecInsertOpVecAddOpVecSubOpVecMulOpVecDivOp VecQuotOpVecRemOpVecNegOpVecIndexByteArrayOpVecReadByteArrayOpVecWriteByteArrayOpVecIndexOffAddrOpVecReadOffAddrOpVecWriteOffAddrOpVecIndexScalarByteArrayOpVecReadScalarByteArrayOpVecWriteScalarByteArrayOpVecIndexScalarOffAddrOpVecReadScalarOffAddrOpVecWriteScalarOffAddrOpPrefetchByteArrayOp3PrefetchMutableByteArrayOp3PrefetchAddrOp3PrefetchValueOp3PrefetchByteArrayOp2PrefetchMutableByteArrayOp2PrefetchAddrOp2PrefetchValueOp2PrefetchByteArrayOp1PrefetchMutableByteArrayOp1PrefetchAddrOp1PrefetchValueOp1PrefetchByteArrayOp0PrefetchMutableByteArrayOp0PrefetchAddrOp0PrefetchValueOp0 maxPrimOpTag primOpTag allThePrimOps tagToEnumKey primOpFixity primOpDocsprimOpOutOfLineprimOpOkForSpeculationprimOpOkForSideEffects primOpIsCheap primOpIsDivprimOpCodeSize primOpTypeprimOpResultType primOpOccprimOpWrapperIdisComparisonPrimOp primOpSiggetPrimOpResultInfo$fOutputablePrimOp $fOrdPrimOp $fEqPrimOp$fOutputablePrimCall primOpRules ShowHowMuch ShowHeaderShowSome ShowIfaceAltPprShowSub ss_how_much ss_forall IfaceJoinInfoIfaceNotJoinPointIfaceJoinPoint IfaceLetBndr IfLetBndr IfaceBinding IfaceNonRecIfaceRec IfaceConAlt IfaceDefault IfaceDataAlt IfaceLitAltIfaceAlt IfaceTickish IfaceHpcTickIfaceSCC IfaceSource IfaceExprIfaceLclIfaceExtIfaceCo IfaceTupleIfaceLamIfaceApp IfaceCase IfaceECaseIfaceLet IfaceCastIfaceLitIfaceLitRubbish IfaceFCall IfaceTick IfaceLFInfo IfLFReEntrant IfLFThunkIfLFCon IfLFUnknown IfLFUnliftedIfaceIdDetails IfVanillaIdIfWorkerLikeId IfRecSelIdIfDFunIdIfaceUnfolding IfCoreUnfold IfCompulsory IfInlineRule IfDFunUnfold IfaceInfoItemHsArityHsDmdSigHsCprSigHsInlineHsUnfold HsNoCafRefsHsLevityHsLFInfoHsTagSig IfaceIdInfoIfaceCompleteMatchIfaceAnnTargetIfaceAnnotationifAnnotatedTargetifAnnotatedValue IfaceRule ifRuleName ifActivation ifRuleBndrs ifRuleHead ifRuleArgs ifRuleRhs ifRuleAuto ifRuleOrph IfaceFamInst ifFamInstFam ifFamInstTysifFamInstAxiom ifFamInstOrph IfaceClsInst ifInstCls ifInstTysifDFunifOFlag ifInstOrph IfaceSrcBang IfSrcBang IfaceBangIfNoBangIfStrictIfUnpack IfUnpackCo IfaceEqSpec IfaceConDeclIfCon ifConName ifConWrapper ifConInfix ifConExTCvsifConUserTvBinders ifConEqSpec ifConCtxt ifConArgTys ifConFields ifConStrictsifConSrcStricts IfaceConDeclsIfAbstractTyCon IfDataTyCon IfNewTyCon IfaceAxBranch ifaxbTyVarsifaxbEtaTyVars ifaxbCoVarsifaxbLHS ifaxbRolesifaxbRHS ifaxbIncompsIfaceAT IfaceClassOpIfaceFamTyConFlavIfaceDataFamilyTyConIfaceOpenSynFamilyTyConIfaceClosedSynFamilyTyCon!IfaceAbstractClosedSynFamilyTyConIfaceBuiltInSynFamTyConIfaceTyConParent IfNoParentIfDataInstanceIfaceClassBodyIfAbstractClassIfConcreteClass ifClassCtxtifATsifSigsifMinDef IfaceDeclIfaceId IfaceData IfaceSynonym IfaceFamily IfaceClass IfaceAxiom IfacePatSynifNameifType ifIdDetailsifIdInfo ifBinders ifResKindifCTypeifRolesifCtxtifCons ifGadtSyntaxifParentifSynRhsifResVar ifFamFlavifFamInjifFDsifBodyifTyConifRole ifAxBranches ifPatIsInfix ifPatMatcher ifPatBuilderifPatUnivBndrs ifPatExBndrs ifPatProvCtxt ifPatReqCtxt ifPatArgsifPatTy ifFieldLabels IfaceTopBndrvisibleIfConDeclsifaceDeclImplicitBndrsifaceDeclFingerprints showToHeader showToIface pprIfaceDecl pprIfaceExprfreeNamesIfDeclfreeNamesIfRulefreeNamesIfFamInst$fNFDataIfaceTyConParent$fBinaryIfaceTyConParent$fOutputableIfaceTyConParent$fNFDataIfaceClassOp$fBinaryIfaceClassOp$fOutputableIfaceClassOp$fHasOccNameIfaceClassOp$fNamedThingIfaceClassOp$fNFDataIfaceAxBranch$fBinaryIfaceAxBranch$fNFDataIfaceFamTyConFlav$fBinaryIfaceFamTyConFlav$fNFDataIfaceBang$fBinaryIfaceBang$fNFDataIfaceSrcBang$fBinaryIfaceSrcBang$fNFDataIfaceConDecl$fBinaryIfaceConDecl$fHasOccNameIfaceConDecl$fNamedThingIfaceConDecl$fNFDataIfaceConDecls$fBinaryIfaceConDecls$fNFDataIfaceClsInst$fBinaryIfaceClsInst$fOutputableIfaceClsInst$fNFDataIfaceFamInst$fBinaryIfaceFamInst$fOutputableIfaceFamInst$fNFDataIfaceAnnotation$fBinaryIfaceAnnotation$fOutputableIfaceAnnotation$fNFDataIfaceCompleteMatch$fBinaryIfaceCompleteMatch$fOutputableIfaceCompleteMatch$fBinaryIfaceLFInfo$fOutputableIfaceLFInfo$fNFDataIfaceTickish$fBinaryIfaceTickish$fNFDataIfaceConAlt$fBinaryIfaceConAlt$fOutputableIfaceConAlt$fNFDataIfaceJoinInfo$fBinaryIfaceJoinInfo$fOutputableIfaceJoinInfo$fNFDataIfaceLetBndr$fNFDataIfaceBinding$fNFDataIfaceAlt$fNFDataIfaceExpr$fNFDataIfaceUnfolding$fNFDataIfaceInfoItem$fBinaryIfaceLetBndr$fBinaryIfaceBinding$fBinaryIfaceExpr$fBinaryIfaceAlt$fBinaryIfaceUnfolding$fBinaryIfaceInfoItem$fOutputableIfaceUnfolding$fOutputableIfaceInfoItem$fOutputableIfaceExpr$fNFDataIfaceIdDetails$fNFDataIfaceAT$fNFDataIfaceClassBody$fNFDataIfaceDecl$fBinaryIfaceIdDetails$fBinaryIfaceAT$fBinaryIfaceDecl$fOutputableIfaceIdDetails$fOutputableIfaceAT$fOutputableIfaceDecl$fHasOccNameIfaceDecl$fNamedThingIfaceDecl$fNFDataIfaceRule$fBinaryIfaceRule$fOutputableIfaceRule$fOutputableShowHowMuchCoreAltWithFVsCoreExprWithFVs'CoreExprWithFVsCoreBindWithFVsFVAnn exprFreeVarsexprFreeVarsDSetexprFreeVarsList exprFreeIds exprsFreeIdsexprFreeIdsDSetexprFreeIdsListexprsFreeIdsDSetexprsFreeIdsList exprsFreeVarsexprsFreeVarsList bindFreeVarsexprSomeFreeVarsexprSomeFreeVarsListexprsSomeFreeVarsexprsSomeFreeVarsListexpr_fvsexprsOrphNamesorphNamesOfTypeorphNamesOfTypes orphNamesOfCoorphNamesOfCoConorphNamesOfAxiomorphNamesOfFamInstruleRhsFreeVarsrulesRhsFreeIdsruleLhsFreeIdsruleLhsFreeIdsList ruleFreeVarsrulesFreeVarsDSet rulesFreeVars mkRuleInfo freeVarsOf freeVarsOfAnnvarTypeTyCoVarsvarTypeTyCoFVs idFreeVars dIdFreeVarsidFVsbndrRuleAndUnfoldingVarsDSetbndrRuleAndUnfoldingIds idRuleVarsidUnfoldingVarsstableUnfoldingVars freeVarsBindfreeVarsprimOpIdallThePrimOpIdsCompleteMatches CompleteMatch cmConLikes cmResultTyConvanillaCompleteMatchcompleteMatchAppliesAtType$fOutputableCompleteMatchTypeEnv emptyTypeEnv typeEnvElts typeEnvTyConstypeEnvCoAxioms typeEnvIdstypeEnvPatSynstypeEnvDataConstypeEnvClasses mkTypeEnvmkTypeEnvWithImplicitstypeEnvFromEntities lookupTypeEnv extendTypeEnvextendTypeEnvListextendTypeEnvWithIds plusTypeEnv AtomicMachOpAMO_AddAMO_SubAMO_AndAMO_NandAMO_OrAMO_Xor CallishMachOp MO_F64_Pwr MO_F64_Sin MO_F64_Cos MO_F64_Tan MO_F64_Sinh MO_F64_Cosh MO_F64_Tanh MO_F64_Asin MO_F64_Acos MO_F64_Atan MO_F64_Asinh MO_F64_Acosh MO_F64_Atanh MO_F64_Log MO_F64_Log1P MO_F64_Exp MO_F64_ExpM1 MO_F64_Fabs MO_F64_Sqrt MO_F32_Pwr MO_F32_Sin MO_F32_Cos MO_F32_Tan MO_F32_Sinh MO_F32_Cosh MO_F32_Tanh MO_F32_Asin MO_F32_Acos MO_F32_Atan MO_F32_Asinh MO_F32_Acosh MO_F32_Atanh MO_F32_Log MO_F32_Log1P MO_F32_Exp MO_F32_ExpM1 MO_F32_Fabs MO_F32_Sqrt MO_I64_ToI MO_I64_FromI MO_W64_ToW MO_W64_FromW MO_x64_Neg MO_x64_Add MO_x64_Sub MO_x64_Mul MO_I64_Quot MO_I64_Rem MO_W64_Quot MO_W64_Rem MO_x64_And MO_x64_Or MO_x64_Xor MO_x64_Not MO_x64_Shl MO_I64_Shr MO_W64_Shr MO_x64_Eq MO_x64_Ne MO_I64_Ge MO_I64_Gt MO_I64_Le MO_I64_Lt MO_W64_Ge MO_W64_Gt MO_W64_Le MO_W64_Lt MO_UF_Conv MO_S_Mul2 MO_S_QuotRem MO_U_QuotRem MO_U_QuotRem2MO_Add2 MO_AddWordC MO_SubWordC MO_AddIntC MO_SubIntC MO_U_Mul2MO_ReadBarrierMO_WriteBarrierMO_TouchMO_Prefetch_Data MO_Memcpy MO_Memset MO_Memmove MO_Memcmp MO_PopCntMO_PdepMO_PextMO_ClzMO_CtzMO_BSwapMO_BRev MO_AtomicRMW MO_AtomicReadMO_AtomicWrite MO_CmpxchgMO_XchgMO_SuspendThreadMO_ResumeThreadMachOpMO_AddMO_SubMO_EqMO_NeMO_MulMO_S_MulMayOflo MO_S_QuotMO_S_RemMO_S_NegMO_U_MulMayOflo MO_U_QuotMO_U_RemMO_S_GeMO_S_LeMO_S_GtMO_S_LtMO_U_GeMO_U_LeMO_U_GtMO_U_LtMO_F_AddMO_F_SubMO_F_NegMO_F_Mul MO_F_QuotMO_F_EqMO_F_NeMO_F_GeMO_F_LeMO_F_GtMO_F_LtMO_AndMO_OrMO_XorMO_NotMO_ShlMO_U_ShrMO_S_Shr MO_SF_Conv MO_FS_Conv MO_SS_Conv MO_UU_Conv MO_XX_Conv MO_FF_Conv MO_V_Insert MO_V_ExtractMO_V_AddMO_V_SubMO_V_Mul MO_VS_Quot MO_VS_Rem MO_VS_Neg MO_VU_Quot MO_VU_Rem MO_VF_Insert MO_VF_Extract MO_VF_Add MO_VF_Sub MO_VF_Neg MO_VF_Mul MO_VF_QuotMO_AlignmentCheck pprMachOp mo_wordAdd mo_wordSub mo_wordEq mo_wordNe mo_wordMul mo_wordSQuot mo_wordSRem mo_wordSNeg mo_wordUQuot mo_wordURem mo_wordSGe mo_wordSLe mo_wordSGt mo_wordSLt mo_wordUGe mo_wordULe mo_wordUGt mo_wordULt mo_wordAnd mo_wordOr mo_wordXor mo_wordNot mo_wordShl mo_wordSShr mo_wordUShr mo_u_8To32 mo_s_8To32 mo_u_16To32 mo_s_16To32 mo_u_8ToWord mo_s_8ToWord mo_u_16ToWord mo_s_16ToWord mo_s_32ToWord mo_u_32ToWord mo_WordTo8 mo_WordTo16 mo_WordTo32 mo_WordTo64mo_32To8 mo_32To16isCommutableMachOpisAssociativeMachOpisComparisonMachOpmaybeIntComparisonisFloatComparisonmaybeInvertComparisonmachOpResultType machOpArgRepspprCallishMachOpcallishMachOpHintsmachOpMemcpyishAlign$fEqCallishMachOp$fShowCallishMachOp$fEqAtomicMachOp$fShowAtomicMachOp $fEqMachOp $fShowMachOp HsPatSynDirUnidirectionalImplicitBidirectionalExplicitBidirectionalRecordPatSynFieldrecordPatSynFieldrecordPatSynPatVarHsPatSynDetails FixitySig LFixitySigSigTypeSig PatSynSig ClassOpSigIdSigFixSig InlineSigSpecSig SpecInstSig MinimalSig SCCFunSigCompleteMatchSigXSigLSigIPBindXIPBindLIPBind HsIPBindsIPBinds PatSynBindPSBpsb_extpsb_idpsb_argspsb_defpsb_dirHsBindLRFunBindPatBindVarBind XHsBindsLRfun_extfun_id fun_matchesfun_tickpat_extpat_lhspat_rhs pat_ticksvar_extvar_idvar_rhs LHsBindLR LHsBindsLRHsBindLHsBindsLHsBind HsValBindsLRValBinds XValBindsLR HsValBindsLHsLocalBindsLRHsLocalBindsLREmptyLocalBindsXHsLocalBindsLR LHsLocalBinds HsLocalBinds isFixityLSig isTypeLSig isSpecLSigisSpecInstLSig isPragLSig isInlineLSig isMinimalLSig isSCCFunSigisCompleteMatchSighsSigDocextractSpecPragName$fOutputableRecordPatSynField RoleAnnotDeclXRoleAnnotDeclLRoleAnnotDecl AnnProvenanceValueAnnProvenanceTypeAnnProvenanceModuleAnnProvenance HsAnnotationXAnnDeclLAnnDeclWarnDeclWarning XWarnDecl LWarnDecl WarnDecls XWarnDeclswd_extwd_src wd_warnings LWarnDeclsDocDeclDocCommentNextDocCommentPrevDocCommentNamedDocGroupLDocDeclRuleBndr RuleBndrSig XRuleBndr LRuleBndrHsRuleRnRuleDeclHsRule XRuleDeclrd_extrd_namerd_actrd_tyvsrd_tmvsrd_lhsrd_rhs LRuleDecl RuleDeclsHsRules XRuleDeclsrds_extrds_src rds_rules LRuleDecls ForeignExportCExport CImportSpec CFunctionCWrapper ForeignImportCImport ForeignDecl XForeignDeclfd_i_extfd_name fd_sig_tyfd_fifd_e_extfd_fe LForeignDecl DefaultDecl XDefaultDecl LDefaultDecl DerivStrategy StockStrategyAnyclassStrategyNewtypeStrategy ViaStrategyLDerivStrategy DerivDecl XDerivDecl deriv_ext deriv_typederiv_strategyderiv_overlap_mode LDerivDeclInstDeclClsInstD DataFamInstD TyFamInstD XInstDecl cid_d_extcid_instdfid_ext dfid_insttfid_ext tfid_inst LInstDecl ClsInstDecl XClsInstDeclcid_ext cid_poly_ty cid_bindscid_sigscid_tyfam_instscid_datafam_instscid_overlap_mode LClsInstDeclFamEqnXFamEqnfeqn_ext feqn_tycon feqn_bndrs feqn_pats feqn_fixityfeqn_rhsDataFamInstDecldfid_eqnLDataFamInstDecl TyFamInstDeclXTyFamInstDecltfid_xtntfid_eqnLTyFamInstDeclLTyFamDefltDeclTyFamDefltDecl TyFamInstEqnHsTyPats LTyFamInstEqnHsConDeclGADTDetails PrefixConGADT RecConGADTHsConDeclH98DetailsConDecl ConDeclGADT ConDeclH98XConDecl con_g_ext con_names con_bndrs con_mb_cxt con_g_args con_res_tycon_doccon_extcon_name con_forall con_ex_tvscon_argsLConDecl NewOrDataNewTypeDataTypeStandaloneKindSigLStandaloneKindSigDerivClauseTys DctSingleDctMultiXDerivClauseTysLDerivClauseTysHsDerivingClauseXHsDerivingClausederiv_clause_extderiv_clause_strategyderiv_clause_tysLHsDerivingClause HsDeriving HsDataDefn XHsDataDefndd_extdd_NDdd_ctxtdd_cType dd_kindSigdd_cons dd_derivs FamilyInfo DataFamilyOpenTypeFamilyClosedTypeFamilyInjectivityAnnXInjectivityAnnLInjectivityAnn FamilyDecl XFamilyDeclfdExtfdInfo fdTopLevelfdLNamefdTyVarsfdFixity fdResultSigfdInjectivityAnn LFamilyDeclFamilyResultSigNoSigKindSigTyVarSigXFamilyResultSigLFamilyResultSig TyClGroup XTyClGroup group_ext group_tyclds group_roles group_kisigs group_instds DataDeclRn tcdDataCusktcdFVs LHsFunDepXFunDepTyClDeclFamDeclSynDeclDataDecl ClassDecl XTyClDecltcdFExttcdFamtcdSExttcdLName tcdTyVars tcdFixitytcdRhstcdDExt tcdDataDefntcdCExttcdCtxttcdFDstcdSigstcdMethstcdATs tcdATDefstcdDocs LTyClDecl SpliceDecl LSpliceDeclHsGroupXHsGrouphs_exths_valds hs_splcds hs_tyclds hs_derivdshs_fixdshs_defdshs_fords hs_warndshs_annds hs_ruledshs_docsHsDeclTyClDInstDDerivDValDSigDKindSigDDefDForDWarningDAnnDRuleDSpliceDDocD RoleAnnotDXHsDeclLHsDeclhsGroupInstDecls isDataDecl isSynDecl isClassDecl isFamilyDeclisTypeFamilyDeclisOpenTypeFamilyInfoisClosedTypeFamilyInfoisDataFamilyDecltyClDeclTyVarscountTyClDeclstyClGroupTyClDeclstyClGroupInstDeclstyClGroupRoleDeclstyClGroupKindSigs pprFlavournewOrDataToFlavourderivStrategyNamecollectRuleBndrSigTyspprFullRuleName docDeclDocannProvenanceName_maybe$fOutputableNewOrData$fOutputableFamilyInfo$fOutputableForeignImport$fOutputableForeignExport$fOutputableDocDecl$fDataHsRuleRn$fDataForeignExport$fDataForeignImport$fDataCImportSpec $fEqNewOrData$fDataNewOrData$fDataDataDeclRn $fDataDocDeclRank ArbitraryRank LimitedRankMonoTypeRankZeroMonoTypeTyConArgMonoTypeSynArgMonoTypeConstraintMustBeMonoType$fOutputableRankOperatorWhitespaceOccurrence#OperatorWhitespaceOccurrence_Prefix#OperatorWhitespaceOccurrence_Suffix'OperatorWhitespaceOccurrence_TightInfixOperatorWhitespaceSymbol&OperatorWhitespaceSymbol_PrefixPercent%OperatorWhitespaceSymbol_PrefixDollar+OperatorWhitespaceSymbol_PrefixDollarDollarpprOperatorWhitespaceSymbol StarIsType StarIsNotTypeUntickedPromotedThingUntickedConstructorUntickedExplicitList SimilarNameSimilarRdrName HowInScopeLocallyBoundAtImportSuggestionCouldImportFromCouldUnhideFromInstantiationSuggestionGhcHint UnknownHintSuggestExtensionSuggestMissingDoSuggestLetInDoSuggestAddSignatureCabalFileSuggestSignatureInstantiationsSuggestUseSpacesSuggestUseWhitespaceAfterSuggestUseWhitespaceAroundSuggestParenthesesSuggestIncreaseMaxPmCheckModelsSuggestAddTypeSignaturesSuggestBindToWildcard SuggestAddInlineOrNoInlinePragmaSuggestAddPhaseToCompetingRuleSuggestAddToHSigExportList#SuggestIncreaseSimplifierIterationsSuggestUseTypeFromDataKindSuggestQualifiedAfterModuleNameSuggestThQuotationSyntax SuggestRolesSuggestQualifyStarOperatorSuggestTypeSignatureFormSuggestFixOrphanInstanceSuggestAddStandaloneDerivationSuggestFillInWildcardConstraintSuggestRenameForallSuggestAppropriateTHTickSuggestDumpSlicesSuggestAddTickSuggestMoveToDeclarationSiteSuggestSimilarNamesRemindFieldSelectorSuppressedSuggestImportingDataConSuggestPlacePragmaInHeadersuppressed_selectorsuppressed_parentsLanguageExtensionHintSuggestSingleExtensionSuggestAnyExtensionSuggestExtensionsSuggestExtensionInOrderToAvailableBindings NamedBindingsUnnamedBindingsuggestExtensionsuggestExtensionWithInfosuggestExtensionssuggestExtensionsWithInfosuggestAnyExtensionsuggestAnyExtensionWithInfouseExtensionInOrderTopprUntickedConstructor isBareSymbolnoStarIsTypeHintsSeverity SevIgnore SevWarningSevError MessageClassMCOutputMCFatal MCInteractiveMCDumpMCInfo MCDiagnostic MsgEnvelope errMsgSpan errMsgContexterrMsgDiagnosticerrMsgSeverityDiagnosticReasonWarningWithoutFlagWarningWithFlagErrorWithoutFlagDiagnosticMessage diagMessage diagReason diagHintsDiagnosticHint DiagnosticdiagnosticMessagediagnosticReasondiagnosticHints DecoratedSDoc unDecoratedMessages getMessages emptyMessages mkMessagesisEmptyMessages singleMessage addMessage unionMessagesunionManyMessages mkDecoratedmkSimpleDecoratedunionDecoratedSDocmapDecoratedSDocnoHintsmkPlainDiagnostic mkPlainErrormkDecoratedDiagnosticmkDecoratedError pprMessageBag mkLocMessagemkLocMessageAnngetCaretDiagnosticisIntrinsicErrorMessageisWarningMessage errorsFoundisExtrinsicErrorMessageerrorsOrFatalWarningsFoundgetWarningMessagesgetErrorMessagespartitionMessages$fOutputableDiagnosticHint$fOutputableDiagnosticReason$fDiagnosticDiagnosticMessage$fToJsonSeverity$fOutputableSeverity$fToJsonMessageClass$fShowMsgEnvelope$fOutputableMessages$fSemigroupMessages$fMonoidMessages$fFunctorMessages$fFoldableMessages$fTraversableMessages$fFunctorMsgEnvelope$fFoldableMsgEnvelope$fTraversableMsgEnvelope$fEqMessageClass$fShowMessageClass $fEqSeverity$fShowSeverity$fEqDiagnosticReason$fShowDiagnosticReasonContainsLogger extractLogger HasLogger getLoggerLoggerlogFlags DumpFormat FormatHaskell FormatCore FormatSTGFormatByteCode FormatCMM FormatASMFormatC FormatLLVM FormatText TraceAction DumpAction LogActionLogFlagslog_default_user_contextlog_default_dump_contextlog_dump_flagslog_show_caretlog_show_warn_groupslog_enable_timestampslog_dump_to_file log_dump_dirlog_dump_prefixlog_dump_prefix_overridelog_enable_debug log_verbositydefaultLogFlagslog_dopt log_set_doptlogHasDumpFlaglogVerbAtLeastupdateLogFlags setLogFlagsloggerTraceFlushUpdateloggerTraceFlush initLogger putLogMsg putDumpFile putTraceMsg pushLogHook popLogHook pushDumpHook popDumpHook pushTraceHook popTraceHookmakeThreadSafe jsonLogActiondefaultLogActiondefaultLogActionHPrintDocdefaultLogActionHPutStrDocdefaultDumpActionwithDumpFileHandledefaultTraceActionlogMsg logDumpFile logTraceMsg logDumpMsgputDumpFileMaybeputDumpFileMaybe' touchDumpFile$fShowDumpFormat$fEqDumpFormatValidity Validity'IsValidNotValidDiagOptsdiag_warning_flagsdiag_fatal_warning_flagsdiag_warn_is_errordiag_reverse_errorsdiag_max_errors diag_ppr_ctx diag_woptdiag_fatal_woptdiagReasonSeveritymkMCDiagnosticerrorDiagnostic mkMsgEnvelopemkErrorMsgEnvelopemkPlainMsgEnvelopemkPlainErrorMsgEnvelopeandValidallValid getInvalidsformatBulleted pprMessagespprMsgEnvelopeBagWithLocpprLocMsgEnvelope sortMsgBagghcExiterrorMsg fatalErrorMsgcompilationProgressMsgshowPass withTimingwithTimingSilent debugTraceMsgputMsgprintInfoForUserprintOutputForUserlogInfo logOutputprettyPrintGhcErrorstraceCmd$fEqPrintTimings$fShowPrintTimings$fFunctorValidity'TempDirTempFileLifetimeTFL_CurrentModuleTFL_GhcSession FilesToClean ftcGhcSessionftcCurrentModuleTmpFsemptyFilesToClean initTmpFs forkTmpFsFrommergeTmpFsInto cleanTempDirscleanTempFilescleanCurrentModuleTempFilesaddFilesToCleanchangeTempFilesLifetime newTempName newTempDirnewTempLibNamewithSystemTempDirectorywithTempDirectory$fShowTempFileLifetimeStgToCmmConfigstgToCmmProfilestgToCmmThisModulestgToCmmTmpDirstgToCmmContextstgToCmmDebugLevelstgToCmmBinBlobThreshstgToCmmMaxInlAllocSizestgToCmmDoTickystgToCmmTickyAllocdstgToCmmTickyLNEstgToCmmTickyDynThunkstgToCmmTickyTagstgToCmmLoopificationstgToCmmAlignCheckstgToCmmOptHpcstgToCmmFastPAPCallsstgToCmmSCCProfilingstgToCmmEagerBlackHolestgToCmmInfoTableMapstgToCmmOmitYieldsstgToCmmOmitIfPragmas stgToCmmPIC stgToCmmPIEstgToCmmExtDynRefsstgToCmmDoBoundsCheckstgToCmmDoTagCheckstgToCmmAllowBigArithstgToCmmAllowQuotRemInstrstgToCmmAllowQuotRem2!stgToCmmAllowExtendedAddSubInstrsstgToCmmAllowIntMul2InstrstgToCmmAllowFabsInstrsstgToCmmTickyAPstgToCmmVecInstrsErr stgToCmmAvx stgToCmmAvx2stgToCmmAvx512fstgToCmmPlatformPipelineOutput Temporary Persistent SpecificFile NoOutputFilePipeEnv stop_phase src_filename src_basename src_suffix start_phase output_specMonadUseuseTPipelineClass$fShowPipelineOutputEwMWarn warnReasonwarnMsgErrerrMsg WarnReasonNoReasonReasonDeprecatedFlagReasonUnrecognisedFlagOptKindNoArgHasArgSepArg OptPrefix OptIntSuffix IntSuffix WordSuffix FloatSuffixPassFlag AnySuffix GhcFlagModeOnlyGhcOnlyGhciAllModes HiddenFlagFlagflagName flagOptKind flagGhcModedefFlag defGhcFlag defGhciFlag defHiddenFlag hoistFlagrunEwMaddErraddWarn addFlagWarngetArg getCurLocliftEwM processArgsparseResponseFileerrorsToGhcException$fToJsonWarnReason$fOutputableWarnReason $fMonadIOEwM $fMonadEwM$fApplicativeEwM $fFunctorEwM$fEqWarnReason$fShowWarnReasonUniqSDFM emptyUSDFM lookupUSDFM equateUSDFM addToUSDFM traverseUSDFM$fOutputableShared$fOutputableUniqSDFM OrigNameCache NameCache nsUniqCharnsNamestakeUniqFromNameCachelookupOrigNameCacheextendOrigNameCache'extendOrigNameCache initNameCacheupdateNameCache'updateNameCacheKnotVars NoKnotVars kv_domain kv_lookup emptyKnotVarsknotVarsFromModuleEnv knotVarElemslookupKnotVarsknotVarsWithout$fOutputableKnotVars$fFunctorKnotVarsRegClass RcIntegerRcFloatRcDouble$fOutputableRegClass$fUniquableRegClass $fEqRegClassReg RegVirtualRegRealRealReg RealRegSingle VirtualReg VirtualRegI VirtualRegHi VirtualRegF VirtualRegDRegNorenameVirtualRegclassOfVirtualReggetHiVirtualRegFromLogetHiVRegFromLoregNosOfRealReg realRegsAlias regSingle realRegSingle isRealReg takeRealReg isVirtualRegtakeVirtualRegliftPatchFnToRegReg$fOutputableVirtualReg$fUniquableVirtualReg$fOrdVirtualReg$fOutputableRealReg$fUniquableRealReg$fOutputableReg$fUniquableReg$fEqReg$fOrdReg $fShowReg $fEqRealReg $fShowRealReg $fOrdRealReg$fEqVirtualReg$fShowVirtualReg SwitchPlanUnconditionallyIfEqualIfLT JumpTable SwitchTargetsmkSwitchTargetsmapSwitchTargetsswitchTargetsCasesswitchTargetsDefaultswitchTargetsRangeswitchTargetsSignedswitchTargetsToTableswitchTargetsToListswitchTargetsFallThrougheqSwitchTargetWithbackendSupportsSwitchcreateSwitchPlan$fShowSwitchPlan$fShowSwitchTargets$fEqSwitchTargetsUsageEnvUsageZeroBottomMUsageaddUsage scaleUsageunitUEzeroUEbottomUEaddUEscaleUEsupUEsupUEsdeleteUElookupUE$fOutputableUsage$fOutputableUsageEnv CoreStatsCScs_tmcs_tycs_cocs_vbcs_jbcoreBindsStats exprStats coreBindsSizeexprSize$fOutputableCoreStatspprCoreBindingspprCoreBindingpprCoreBindingsWithSizepprCoreBindingWithSize pprParendExpr pprCoreExprpprOptCo pprCoreAltpprOccpprOccWithTick pprCoreBinderpprCoreBinderspprRulespprRule$fOutputableGenTickish$fOutputableCoreRule$fOutputableUnfolding$fOutputableUnfoldingSource$fOutputableUnfoldingGuidance$fOutputableIdInfo$fOutputableBndrTaggedBndr$fOutputableBndrVar$fOutputableAlt$fOutputableExpr$fOutputableBind HsFieldBindhfbAnnhfbLHShfbRHShfbPun HsRecUpdField HsRecFieldLHsRecUpdField LHsRecField LHsFieldBind HsRecFieldsrec_flds rec_dotdotHsConPatDetailsConLikePWildPatVarPatLazyPatAsPatParPatBangPatListPatTuplePatSumPatConPatViewPat SplicePatLitPatNPat NPlusKPatSigPatXPat pat_con_extpat_conpat_args hsConPatArgs hsRecFieldshsRecFieldsArgs hsRecFieldSel$fOutputableHsFieldBind$fOutputableHsRecFields$fFunctorHsFieldBind$fFoldableHsFieldBind$fTraversableHsFieldBindpprLPat HsDoFlavourDoExprMDoExpr GhciStmtCtxtListComp MonadCompHsArrowMatchContextProcExpr ArrowCaseAltArrowLamCaseAlt KappaExpr HsStmtContextHsDoStmtPatGuard ParStmtCtxt TransStmtCtxt ArrowExprHsMatchContextFunRhs LambdaExprCaseAlt LamCaseAltIfAltArrowMatchCtxt PatBindRhs PatBindGuardsRecUpdStmtCtxt ThPatSplice ThPatQuotemc_fun mc_fixity mc_strictness ArithSeqInfoFromFromThenFromTo FromThenToHsQuoteExpBrPatBrDecBrLDecBrGTypBrVarBrXQuoteUntypedSpliceFlavourUntypedExpSpliceUntypedPatSpliceUntypedTypeSpliceUntypedDeclSpliceHsSplicedThing HsSplicedExpr HsSplicedTy HsSplicedPatThModFinalizersSpliceDecoration DollarSplice BareSplice HsTypedSpliceHsUntypedSplice HsQuasiQuote HsSplicedXSpliceApplicativeArgApplicativeArgOneApplicativeArgManyXApplicativeArgxarg_app_arg_oneapp_arg_patternarg_expr is_body_stmtxarg_app_arg_many app_stmts final_expr bv_pattern stmt_context FailOperator ParStmtBlock TransFormThenForm GroupFormStmtLRLastStmtBindStmtApplicativeStmtBodyStmtLetStmtParStmt TransStmtRecStmtXStmtLRtrS_exttrS_form trS_stmts trS_bndrs trS_usingtrS_bytrS_rettrS_bindtrS_fmaprecS_ext recS_stmtsrecS_later_ids recS_rec_ids recS_bind_fn recS_ret_fn recS_mfix_fnGhciStmt GhciLStmt GuardStmt GuardLStmtExprStmt ExprLStmtCmdStmtCmdLStmtStmtLStmtLRLStmtGRHSXGRHSLGRHSXGRHSsgrhssExt grhssGRHSsgrhssLocalBindsMatchXMatchm_extm_ctxtm_patsm_grhssLMatch MatchGroupTc mg_arg_tys mg_res_tyMG XMatchGroupmg_extmg_alts mg_origin HsRecordBindsHsCmdTop LHsCmdTop HsArrAppTypeHsHigherOrderAppHsFirstOrderAppHsCmd HsCmdArrApp HsCmdArrFormHsCmdAppHsCmdLamHsCmdPar HsCmdCase HsCmdLamCaseHsCmdIfHsCmdLetHsCmdDoXCmdLHsCmdLamCaseVariantLamCaseLamCasesHsTupArgPresentMissingXTupArg LHsTupArgHsPragE HsPragSCCXHsPragE DotFieldOcc XDotFieldOccdfoExtdfoLabelHsVar HsUnboundVarHsRecSel HsOverLabelHsIPVarHsLam HsLamCaseHsApp HsAppTypeOpAppNegAppHsParSectionLSectionR ExplicitTuple ExplicitSumHsCaseHsIf HsMultiIfHsLetHsDo ExplicitList RecordCon RecordUpd HsGetField HsProjection ExprWithTySigArithSeqHsTypedBracketHsUntypedBracket HsSpliceEHsProcHsStaticXExprrcon_extrcon_con rcon_fldsrupd_ext rupd_expr rupd_fldsgf_extgf_exprgf_fieldproj_ext proj_fldsCmdSyntaxTable LHsRecUpdProj RecUpdProj LHsRecProjRecProjFieldLabelStringsLFieldLabelStringspprFieldLabelStringspprPrefixFieldLabelStringspprPrefixFieldLabelStringpprPrefixFastStringlamCaseKeywordpprExternalSrcLoc pprHsArrType isInfixMatch isTypedSplice isPatSynCtxtqualifiedDoModuleName_maybeisComprehensionContextisDoComprehensionContextisMonadStmtContextisMonadDoStmtContextisMonadCompContextisMonadDoCompContextmatchSeparatorpprMatchContextpprMatchContextNounpprMatchContextNounspprArrowMatchContextNounpprArrowMatchContextNounspprAStmtContextpprStmtContextpprAHsDoFlavourpprHsDoFlavourprependQualified$fOutputableDotFieldOcc!$fOutputableBndrFieldLabelStrings$fOutputableFieldLabelStrings$fOutputableSpliceDecoration$fDataThModFinalizers$fDataUntypedSpliceFlavour$fDataSpliceDecoration$fEqSpliceDecoration$fShowSpliceDecoration$fDataTransForm$fDataMatchGroupTc$fDataHsArrAppType$fDataLamCaseVariant$fEqLamCaseVariant pprFunBind pprPatBind pprSpliceDecl pprSplicepprExprpprLExpr OverLitTc$sel:ol_rebindable:OverLitTc$sel:ol_witness:OverLitTc$sel:ol_type:OverLitTc OverLitRn$sel:ol_rebindable:OverLitRn$sel:ol_from_fun:OverLitRn pprXOverLit overLitType convertLit pp_st_suffix pmPprHsLit$fOutputableHsOverLit$fOutputableHsLit InfoProvEnt infoTablePtrinfoProvEntClosureType infoTableTypeinfoProvModule infoTableProvDynamicLinkerLabelInfoCodeStub SymbolPtr GotSymbolPtrGotSymbolOffsetConInfoTableLocation UsageSiteDefinitionSiteForeignLabelSourceForeignLabelInPackageForeignLabelInExternalPackageForeignLabelInThisPackageNeedExternDecl isIdLabel isTickyLabelpprDebugCLabelgetConInfoTableLocation mkSRTLabelmkRednCountsLabel mkTagHitLabelmkClosureLabelmkInfoTableLabel mkEntryLabelmkClosureTableLabelmkConInfoTableLabel mkBytesLabelmkBlockInfoTableLabelmkDirty_MUT_VAR_Label#mkNonmovingWriteBarrierEnabledLabelmkUpdInfoLabelmkBHUpdInfoLabelmkIndStaticInfoLabelmkMainCapabilityLabelmkMAP_FROZEN_CLEAN_infoLabelmkMAP_FROZEN_DIRTY_infoLabelmkMAP_DIRTY_infoLabelmkTopTickyCtrLabelmkCAFBlackHoleInfoTableLabelmkArrWords_infoLabelmkSMAP_FROZEN_CLEAN_infoLabelmkSMAP_FROZEN_DIRTY_infoLabelmkSMAP_DIRTY_infoLabelmkBadAlignmentLabelmkOutOfBoundsAccessLabelmkMUT_VAR_CLEAN_infoLabelmkSRTInfoLabelmkCmmInfoLabelmkCmmEntryLabelmkCmmRetInfoLabel mkCmmRetLabelmkCmmCodeLabelmkCmmClosureLabelmkCmmDataLabelmkRtsCmmDataLabelmkLocalBlockLabelmkRtsPrimOpLabelmkSelectorInfoLabelmkSelectorEntryLabelmkApInfoTableLabelmkApEntryLabelmkPrimCallLabelmkForeignLabel addLabelSize isBytesLabelisForeignLabelisStaticClosureLabelisSomeRODataLabelisInfoTableLabelisConInfoTableLabelforeignLabelStdcallInfo mkBitmapLabel mkCCLabel mkCCSLabel mkIPELabelmkRtsApFastLabelmkRtsSlowFastTickyCtrLabelmkHpcTicksLabelmkDynamicLinkerLabeldynamicLinkerLabelInfomkPicBaseLabelmkDeadStripPreventermkStringLitLabelmkInitializerStubLabelmkInitializerArrayLabelmkFinalizerStubLabelmkFinalizerArrayLabelmkAsmTempLabelmkAsmTempDerivedLabelmkAsmTempEndLabelmkAsmTempProcEndLabelmkAsmTempDieLabel toClosureLbltoSlowEntryLbl toEntryLbl toInfoLblhasHaskellNamehasIdLabelInfohasCAF needsCDeclmaybeLocalBlockLabel isMathFunexternallyVisibleCLabelisCFunctionLabel isGcPtrLabel isLocalCLabel labelDynamicppInternalProcLabel mayRedirectTo$fOutputableModuleLabelKind$fOutputableForeignLabelSource$fOrdTickyIdInfo$fOutputableTickyIdInfo $fOutputableConInfoTableLocation$fOutputableIdLabelInfo$fOutputablePPlatformCLabel $fOrdCLabel$fOutputableCLabel $fShowCLabel$fEqInfoProvEnt$fOrdInfoProvEnt $fEqCLabel$fEqDynamicLinkerLabelInfo$fOrdDynamicLinkerLabelInfo$fEqCmmLabelInfo$fOrdCmmLabelInfo$fEqRtsLabelInfo$fOrdRtsLabelInfo$fEqIdLabelInfo$fOrdIdLabelInfo$fEqConInfoTableLocation$fOrdConInfoTableLocation$fEqTickyIdInfo$fShowTickyIdInfo$fEqForeignLabelSource$fOrdForeignLabelSource$fOrdNeedExternDecl$fEqNeedExternDecl$fEqModuleLabelKind$fOrdModuleLabelKind newBlockIdblockLbl infoTblLbl GlobalReg VanillaRegFloatReg DoubleRegLongRegXmmRegYmmRegZmmRegSpSpLimHpHpLimCCCS CurrentTSOCurrentNurseryHpAllocEagerBlackholeInfoGCEnter1GCFunBaseRegMachSpUnwindReturnReg PicBaseRegVGcPtr VNonGcPtr DefinerOfRegs foldRegsDefd UserOfRegs foldRegsUsed GlobalRegSet LocalRegSetRegSetLocalRegCmmLitCmmIntCmmFloatCmmVecCmmLabel CmmLabelOffCmmLabelDiffOffCmmBlockCmmHighStackMarkAreaOldYoungCmmRegCmmLocal CmmGlobal AlignmentSpecNaturallyAligned UnalignedCmmExprCmmLoad CmmMachOp CmmStackSlot CmmRegOff cmmExprType cmmLitType cmmExprWidthcmmExprAlignmentmaybeInvertCmmExpr cmmRegType cmmRegWidth localRegType emptyRegSet nullRegSet elemRegSet extendRegSetdeleteFromRegSetmkRegSet minusRegSet plusRegSet timesRegSet sizeRegSet regSetToListfoldLocalRegsUsedfoldLocalRegsDefdbaseRegspReghpReghpLimRegspLimRegnodeReg currentTSORegcurrentNurseryReg hpAllocRegcccsRegnode globalRegTypeisArgReg$fOutputableCmmLit$fUniquableLocalReg $fOrdLocalReg $fEqLocalReg$fUserOfRegsr[]$fUserOfRegsrr$fDefinerOfRegsr[]$fDefinerOfRegsrr$fOrdGlobalReg $fEqGlobalReg$fDefinerOfRegsGlobalRegCmmReg$fUserOfRegsGlobalRegCmmReg$fDefinerOfRegsLocalRegCmmReg$fUserOfRegsLocalRegCmmReg$fUserOfRegsrCmmExpr $fEqCmmExpr $fShowCmmExpr $fEqCmmReg $fOrdCmmReg $fShowCmmReg$fShowGlobalReg $fEqVGcPtr $fShowVGcPtr$fShowLocalReg $fEqCmmLit $fShowCmmLit$fEqArea $fOrdArea $fShowArea$fEqAlignmentSpec$fOrdAlignmentSpec$fShowAlignmentSpecmodBreaks_flagsmodBreaks_locsmodBreaks_varsmodBreaks_decls modBreaks_ccsmodBreaks_breakInfo CCostCentre BreakIndex CgBreakInfocgb_vars cgb_restyBCONPtr BCONPtrWord BCONPtrLbl BCONPtrItbl BCONPtrStrBCOPtr BCOPtrName BCOPtrPrimOp BCOPtrBCOBCOPtrBreakArray UnlinkedBCOunlinkedBCONameunlinkedBCOArityunlinkedBCOInstrsunlinkedBCOBitmapunlinkedBCOLitsunlinkedBCOPtrsItblPtrItblEnv TupleInfo tupleSize tupleRegstupleNativeStackSize RegBitmap unRegBitmapFFIInfoCompiledByteCodebc_bcosbc_itblsbc_ffisbc_strs bc_breaksseqCompiledByteCode voidTupleInfoemptyModBreaks$fOutputableTupleInfo$fNFDataBCONPtr$fOutputableUnlinkedBCO$fNFDataBCOPtr$fNFDataUnlinkedBCO$fOutputableCgBreakInfo$fOutputableCompiledByteCode $fShowItblPtr$fNFDataItblPtr$fShowTupleInfo$fEnumRegBitmap $fEqRegBitmap$fShowRegBitmap$fIntegralRegBitmap$fNumRegBitmap$fOrdRegBitmap$fRealRegBitmap$fBitsRegBitmap$fFiniteBitsRegBitmap$fOutputableRegBitmap $fEnumWordOff $fEqWordOff $fShowWordOff$fIntegralWordOff $fNumWordOff $fOrdWordOff $fRealWordOff$fOutputableWordOff $fEnumByteOff $fEqByteOff $fShowByteOff$fIntegralByteOff $fNumByteOff $fOrdByteOff $fRealByteOff$fOutputableByteOff $fShowFFIInfo$fNFDataFFIInfo callerSaves activeStgRegs haveRegBaseglobalRegMaybefreeReg freeRegBase CmmTickScope GlobalScopeSubScope CombinedScope ForeignTarget PrimTarget CmmReturnInfo CmmMayReturnCmmNeverReturnsForeignConvention ConventionNativeDirectCallNativeNodeCall NativeReturnSlowGCUpdFrameOffset CmmFormal CmmActualCmmNodeCmmEntry CmmCommentCmmTick CmmUnwind CmmAssignCmmStoreCmmUnsafeForeignCall CmmBranch CmmCondBranch CmmSwitchCmmCallCmmForeignCallcml_predcml_true cml_false cml_likely cml_targetcml_cont cml_args_regscml_args cml_ret_args cml_ret_offtgtresargsret_argsret_offintrblforeignTargetHints wrapRecExpmapExp mapExpDeep wrapRecExpMmapExpM mapExpDeepM wrapRecExpffoldExp foldExpDeep mapSuccessorsmapCollectSuccessorsisTickSubScopecombineTickScopes$fUserOfRegsrForeignTarget$fOutputableCmmTickScope$fOrdCmmTickScope$fEqCmmTickScope$fDefinerOfRegsGlobalRegCmmNode$fDefinerOfRegsLocalRegCmmNode$fUserOfRegsGlobalRegCmmNode$fUserOfRegsLocalRegCmmNode$fNonLocalCmmNode$fEqForeignTarget$fEqForeignConvention$fEqCmmReturnInfo$fEqConvention $fEqCmmNodeInfoTableProvMapprovDC provClosureprovInfoTablesDCMap ClosureMapIpeSourceLocationemptyInfoTableProvMap ListGraph GenBasicBlock BasicBlock RawCmmStatics CmmStatics GenCmmStatics CmmStaticsRaw CmmStatic CmmStaticLitCmmUninitialised CmmString CmmFileEmbedSectionSectionProtectionReadWriteSectionReadOnlySectionWriteProtectedSection SectionTypeText ReadOnlyDataRelocatableReadOnlyDataUninitialisedDataReadOnlyData16 InitArray FiniArrayCString OtherSection ProfilingInfoNoProfilingInfo CmmInfoTablecit_lblcit_repcit_profcit_srtcit_clo CmmStackInfo StackInfo arg_space do_layout CmmTopInfoTopInfo info_tbls stack_info GenCmmGraphCmmGraphg_entryg_graph RawCmmDecl CmmDeclSRTsCmmDecl GenCmmDeclCmmProcCmmData RawCmmGroup CmmGroupSRTsCmmGroup GenCmmGroup CmmProgram topInfoTablesectionProtectionblockId pprBBlock$fOutputableCmmStatic$fOutputablePenvGenBasicBlock$fOutputableGenBasicBlock$fOutputablePenvListGraph$fOutputableListGraph$fFunctorListGraph$fFunctorGenBasicBlock$fFunctorGenCmmDecl$fEqSectionProtection$fShowSectionType$fEqCmmInfoTable$fEqProfilingInfo CheapAppFunexprType coreAltType coreAltsType mkLamType mkLamTypesapplyTypeToArgs mkCastMComkPiMComkCastmkTickmkTicksisSaturatedConApp mkTickNoHNF tickHNFArgs stripTicksTopstripTicksTopEstripTicksTopT stripTicksE stripTicksT bindNonRecneedsCaseBinding mkAltExpr mkDefaultCasemkSingleAltCase findDefault addDefault isDefaultAltfindAlt mergeAlts trimConArgs filterAltsrefineDefaultAltcombineIdenticalAlts scaleAltsBy exprIsTrivialgetIdFromTrivialExprgetIdFromTrivialExpr_maybe exprIsDeadEnd exprIsDupableexprIsWorkFree exprIsCheap exprIsCheapXexprIsExpandable isCheapAppisExpandableAppexprOkForSpeculationexprOkForSideEffectsexprOkForSpecEvalaltsAreExhaustive exprIsHNF exprIsConLikeexprIsTopLevelBindableexprIsTickedStringexprIsTickedString_maybedataConRepInstPatdataConRepFSInstPat cheapEqExpr cheapEqExpr'eqExpr diffBinds tryEtaReducecanEtaReduceToArity isEmptyTynormSplitTyConApp_maybecollectMakeStaticArgs isJoinBinddumpIdInfoOfProgrammkStrictFieldSeqsshouldStrictifyIdForCbvshouldUseCbvForIdisUnsafeEqualityProofCallCtxt BoringCtxtRhsCtxt DiscArgCtxt RuleArgCtxt ValAppCtxtCaseCtxt ArgSummaryTrivArg NonTrivArgValueArgunfoldingCreationThresholdunfoldingUseThresholdunfoldingFunAppDiscountunfoldingDictDiscountunfoldingVeryAggressiveunfoldingCaseThresholdunfoldingCaseScalingunfoldingReportPrefixupdateReportPrefixinlineBoringOkcalcUnfoldingGuidancecouldBeSmallEnoughToInlinesmallEnoughToInlinecallSiteInline$fOutputableExprSize$fOutputableArgSummary$fOutputableCallCtxt CompilerInfoGCCClang AppleClang AppleClang51 UnknownCC LinkerInfoGnuLDGnuGoldLlvmLLDDarwinLD SolarisLDAixLD UnknownLDPkgDbRef GlobalPkgDb UserPkgDb PkgDbPathFlagSpec flagSpecName flagSpecFlagflagSpecActionflagSpecGhcMode TurnOnFlagCmdLinePFlushOut FatalMessagerDynamicTooStateDT_DontDT_OKDT_DynRtsOptsEnabled RtsOptsNone RtsOptsIgnoreRtsOptsIgnoreAllRtsOptsSafeOnly RtsOptsAll DynLibLoader DeployableSystemDependent PackageDBFlag PackageDBNoUserPackageDBNoGlobalPackageDBClearPackageDBs PackageFlag ExposePackage HidePackage TrustFlag TrustPackageDistrustPackageIgnorePackageFlag IgnorePackage ModRenamingmodRenamingWithImplicit modRenamings PackageArg UnitIdArgGhcLinkNoLink LinkBinary LinkInMemory LinkDynLib LinkStaticLib LinkMergedObjGhcMode CompManagerOneShotMkDepend LlvmConfig llvmTargets llvmPasses LlvmTarget lDataLayoutlCPU lAttributesProfAuto NoProfAuto ProfAutoAll ProfAutoTopProfAutoExports ProfAutoCallsContainsDynFlagsextractDynFlags HasDynFlags getDynFlagsghcModeghcLinkghcNameVersion fileSettingstargetPlatform toolSettings platformMisc rawSettingstmpDir llvmConfig llvmOptLevel verbosity debugLevel simplPhasesmaxSimplIterations ruleCheckstrictnessBefore parMakeCountenableTimeStats ghcHeapSizemaxRelevantBindsmaxValidHoleFitsmaxRefHoleFitsrefLevelHoleFitsmaxUncoveredPatternsmaxPmCheckModelssimplTickFactor dmdUnboxWidthspecConstrThresholdspecConstrCountspecConstrRecursivebinBlobThresholdliberateCaseThreshold floatLamArgsliftLamsRecArgsliftLamsNonRecArgs liftLamsKnowncmmProcAlignment historySize importPathsmainModuleNameIs mainFunIsreductionDepthsolverIterations homeUnitId_homeUnitInstanceOf_homeUnitInstantiations_workingDirectorythisPackageName hiddenModulesreexportedModules targetWays_ splitInfo objectDirdylibInstallNamehiDirhieDirstubDirdumpDir objectSuf_hcSufhiSuf_hieSuf dynObjectSuf_ dynHiSuf_ outputFile_dynOutputFile_outputHi dynOutputHi dynLibLoader dynamicNow dumpPrefixdumpPrefixForceldInputs includePaths libraryPathsframeworkPathscmdlineFrameworksrtsOptsrtsOptsEnabledrtsOptsSuggestionshpcDirpluginModNamespluginModNameOptsfrontendPluginOpts depMakefiledepIncludePkgDepsdepIncludeCppDepsdepExcludeMods depSuffixespackageDBFlagsignorePackageFlags packageFlagspluginPackageFlags trustFlags packageEnv dumpFlags generalFlags warningFlagsfatalWarningFlagslanguage safeHaskell safeInfer safeInferredthOnLoc newDerivOnLocderiveViaOnLocoverlapInstLocincoherentOnLoc pkgTrustOnLoc warnSafeOnLocwarnUnsafeOnLoctrustworthyOnLoc extensionsextensionFlags unfoldingOpts maxWorkerArgs ghciHistSizeflushOutghcVersionFilehaddockOptions ghciScripts pprUserLengthpprCols useUnicodeuseColor canUseColor colSchemeprofAutocallerCcFiltersinteractivePrint sseVersion bmiVersionavxavx2avx512cdavx512eravx512favx512pfrtldInfortccInfo rtasmInfomaxInlineAllocSizemaxInlineMemcpyInsnsmaxInlineMemsetInsns reverseErrors maxErrors initialUniqueuniqueIncrement cfgWeights IncludeSpecsincludePathsQuoteincludePathsGlobalincludePathsQuoteImplicitaddGlobalIncludeaddQuoteIncludeaddImplicitQuoteIncludeflattenIncludessettings programNameprojectVersion ghcUsagePath ghciUsagePathtopDirextraGccViaCFlagsglobalPackageDatabasePathpgm_Lpgm_Ppgm_Fpgm_cpgm_cxxpgm_apgm_lpgm_lmpgm_dllpgm_T pgm_windres pgm_libtoolpgm_lccpgm_ar pgm_otoolpgm_install_name_tool pgm_ranlibpgm_lopgm_lcpgm_iopt_Lopt_Popt_P_signatureopt_Fopt_copt_cxxopt_aopt_lopt_lm opt_windresopt_lccopt_loopt_lcopt_iversionedAppDirversionedFilePath isOneShotisNoLinkpackageFlagsChangedpositionIndependentdynamicTooState setDynamicNow initDynFlagsdefaultDynFlagsdefaultFatalMessagerdefaultFlushOutlanguageExtensions hasPprDebughasNoDebugOutputhasNoStateHackhasNoOptCoerciondoptdopt_set dopt_unsetgoptgopt_set gopt_unsetwoptwopt_set wopt_unset wopt_fatalwopt_set_fatalwopt_unset_fatalxoptxopt_set xopt_unsetxopt_set_unlessExplSpecxopt_DuplicateRecordFieldsxopt_FieldSelectorslang_setpackageTrustOn safeHaskellOnsafeHaskellModeEnabledsafeLanguageOn safeInferOn safeImportsOnsafeDirectImpsReqsafeImplicitImpsReq unsafeFlagsunsafeFlagsForInfergetOpts getVerbFlags setOutputFilesetDynOutputFile setOutputHisetDynOutputHiaddPluginModuleName updOptLevelparseDynamicFlagsCmdLineparseDynamicFilePragmagetCmdLineStateputCmdLineState runCmdLinePprocessCmdLinePparseDynamicFlagsFullallNonDeprecatedFlagsflagsAll flagsDynamic flagsPackageflagsForCompletionturnOnturnOff flagSpecOf wWarningFlagsfFlags fLangFlagssupportedLanguagesAndExtensionsxFlags impliedGFlagsimpliedOffGFlags impliedXFlagsglasgowExtsFlagssetGeneralFlag'unSetGeneralFlag' setUnitIdaugmentByWorkingDirectorysetFlagsFromEnvFile setTmpDir picCCOpts pieCCLDOptspicPOpts compilerInfo targetProfilemakeDynFlagsConsistentsetUnsafeGlobalDynFlagsisSse4_2Enabled isAvxEnabled isAvx2EnabledisAvx512cdEnabledisAvx512erEnabledisAvx512fEnabledisAvx512pfEnabled isBmiEnabled isBmi2EnabledsccProfilingEnabledneedSourceNotesuseXLinkerRPathinitSDocContextinitDefaultSDocContext outputFile objectSufwayspprDynFlagsDiffupdatePlatformConstants$fOutputableGhcMode$fOutputablePackageArg$fOutputableModRenaming$fOutputablePackageFlag$fOutputableOnOff$fFunctorCmdLineP$fApplicativeCmdLineP$fMonadCmdLineP$fHasDynFlagsExceptT$fHasDynFlagsMaybeT$fHasDynFlagsReaderT$fHasDynFlagsWriterT$fEqCompilerInfo$fEqLinkerInfo$fEqPackageDBFlag $fEqPkgDbRef$fEqDeprecation$fOrdDeprecation $fEqOnOff $fShowOnOff$fEqDynamicTooState$fShowDynamicTooState$fOrdDynamicTooState$fShowRtsOptsEnabled$fEqDynLibLoader$fEqPackageFlag $fEqTrustFlag$fEqIgnorePackageFlag$fEqModRenaming$fEqPackageArg$fShowPackageArg $fEqGhcLink $fShowGhcLink $fEqGhcMode $fEqProfAuto$fEnumProfAuto$fShowIncludeSpecsTypeSizeTypeCannotBeMarshaledReason NotADataTypeNewtypeDataConNotInScopeUnliftedFFITypesNeededNotABoxedMarshalableTyConForeignLabelNotAPtrNotSimpleUnliftedTypeIllegalForeignTypeReasonTypeCannotBeMarshaledForeignDynNotPtrSafeHaskellMustBeInIOIOResultExpectedUnexpectedNestedForallLinearTypesNotAllowedOneArgExpectedAtLeastOneArgExpectedTcLevelConcreteTvOrigin ConcreteFRRMetaInfoTauTvTyVarTv RuntimeUnkTvCycleBreakerTv ConcreteTvFlexiIndirectSkolemTv RuntimeUnkMetaTvmtv_infomtv_ref mtv_tclvl SyntaxOpTypeSynAnySynRhoSynListSynFunSynType ExpRhoTypeExpSigmaTypeFRR ExpTypeFRR ExpSigmaType InferResultIRir_uniqir_lvlir_frrir_refExpTypeCheckInfer TcDTyCoVarSet TcDTyVarSet TcTyCoVarSet TcTyVarSetTcKind TcTauType TcRhoTypeTcSigmaTypeFRR TcSigmaType TcThetaType TcPredType TcTyConBinder PolyTcTyCon MonoTcTyConTcTyCon TcReqTVBinderTcInvisTVBinder TcTyVarBinder TcTypeFRR TcTyCoVarTcTypeTcCoVarmkCheckExpType synKnownType mkSynFunTys maxTcLevel topTcLevel isTopTcLevel pushTcLevelstrictlyDeeperThandeeperThanOrSame sameDepthAs tcTyVarLevel tcTypeLevel tcTyFamInststcTyFamInstsAndVistcTyConAppTyFamInstsAndVis isTyFamFreeanyRewritableTyVaranyRewritableTyFamAppexactTyCoVarsOfTypeexactTyCoVarsOfTypes tcIsTcTyVarisPromotableMetaTyVarisTouchableMetaTyVarisImmutableTyVar isSkolemTyVarskolemSkolInfoisOverlappableTyVarisAmbiguousTyVarisCycleBreakerTyVarisConcreteTyVar_maybeisConcreteTyVarTyisConcreteTyVarTy_maybe isMetaTyVarTy metaTyVarInfometaTyVarTcLevelmetaTyVarTcLevel_maybe metaTyVarRefsetMetaTyVarTcLevel isTyVarTyVarisFlexi isIndirectisRuntimeUnkSkolmkTyVarNamePairsfindDupTyVarTvs ambigTkvsOfTy mkSigmaTy mkInfSigmaTy mkSpecSigmaTymkPhiTy getDFunTyKey mkTcAppTys mkTcAppTy mkTcCastTy tcSplitPiTystcSplitPiTy_maybetcSplitForAllTyVarBinder_maybetcSplitForAllTyVarstcSplitForAllInvisTyVarstcSplitSomeForAllTyVarstcSplitForAllReqTVBinderstcSplitForAllInvisTVBinderstcSplitForAllTyVarBinders tcIsForAllTytcSplitPredFunTy_maybe tcSplitPhiTytcSplitSigmaTytcSplitNestedSigmaTystcTyConAppTyContcTyConAppTyCon_maybetcTyConAppArgstcSplitTyConApp tcSplitFunTystcSplitFunTy_maybetcSplitFunTysN tcFunArgTy tcFunResultTytcFunResultTyNtcSplitAppTy_maybe tcSplitAppTy tcSplitAppTystcRepGetNumAppTystcGetCastedTyVar_maybetcGetTyVar_maybe tcGetTyVar tcIsTyVarTy tcSplitDFunTytcSplitDFunHeadtcSplitMethodTytcEqKindtcEqTypeNoKindCheck tcEqTyConApps tcEqTypeVis pickyEqTypeisTyVarClassPredcheckValidClsArgs hasTyVarHead evVarPred boxEqPredpickCapturedPredsmkMinimalBySCstransSuperClassesimmSuperClassesisImprovementPred isSigmaTyisRhoTy isRhoExpTyisOverloadedTy isFloatTy isDoubleTy isIntegerTy isNaturalTyisIntTyisWordTyisBoolTyisUnitTyisCharTyisFloatingPrimTy isStringTy isRigidTy deNoteTypetcSplitIOType_maybeisFFIArgumentTyisFFIExternalTyisFFIImportResultTyisFFIExportResultTy isFFIDynTy isFFILabelTyisFFIPrimArgumentTyisFFIPrimResultTy isFunPtrTysizeType sizeTypestcTyConVisibilitiesisNextTyConArgVisibleisNextArgVisible$fOutputableMetaDetails$fOutputableMetaInfo$fOutputableTcLevel$fOutputableTcTyVarDetails$fOutputableInferResult$fOutputableExpType $fEqTcLevel $fOrdTcLevel TcIdSigInfo SelfBootInfoTcLclEnv getLclEnvLoc setLclEnvLocgetLclEnvTcLevelsetLclEnvTcLevelHoleFit RawHoleFithfIdhfCandhfTypehfRefLvlhfWrap hfMatcheshfDoc HoleFitPluginHoleFitCandidateIdHFCand NameHFCand GreHFCandPotentialUnifiers NoUnifiersOneOrMoreUnifiersClsInstLookupResult InstMatch DFunInstTypeVisibleOrphanModulesInstEnvs ie_globalie_local ie_visibleInstEnvClsInst is_cls_nmis_tcs is_dfun_nameis_tvsis_clsis_tysis_dfunis_flag is_orphanfuzzyClsInstCmpisOverlappable isOverlapping isIncoherentinstanceDFunIdupdateClsInstDFunupdateClsInstDFuns pprInstancepprInstanceHdr pprInstances instanceHeadorphNamesOfClsInst instanceSigmkLocalInstancemkImportedInstance emptyInstEnv mkInstEnv instEnvEltsinstEnvClasses instIsVisibleclassInstancesclassNameInstances memberInstEnv unionInstEnvextendInstEnvList extendInstEnv filterInstEnv anyInstEnv mapInstEnvdeleteFromInstEnvdeleteDFunFromInstEnvidenticalClsInstHeadlookupUniqueInstEnvgetPotentialUnifiers nullUnifiers lookupInstEnvinstanceBindFun$fOutputableClsInst$fNamedThingClsInst$fOutputableInstEnv$fMonoidPotentialUnifiers$fSemigroupPotentialUnifiers$fOutputablePotentialUnifiers$fOutputableInstMatches $fDataClsInst ModDetails md_exportsmd_typesmd_insts md_fam_instsmd_rulesmd_annsmd_complete_matchesemptyModDetails ShHoleSubstUnitErr CloseUnitErrPackageFlagErr TrustFlagErrModuleSuggestionSuggestVisible SuggestHidden LookupResult LookupFoundLookupMultiple LookupHiddenLookupUnusableLookupNotFoundUnusableUnitReasonIgnoredWithFlagBrokenDependenciesCyclicDependenciesIgnoredDependenciesShadowedDependencies UnitInfoMap UnitDatabaseunitDatabasePathunitDatabaseUnits UnitState unitInfoMappreloadClosurepackageNameMapwireMap unwireMap preloadUnits explicitUnitshomeUnitDependsmoduleNameProvidersMappluginModuleNameProvidersMaprequirementContextallowVirtualUnitsPreloadUnitClosure ModuleOrigin ModHidden ModUnusable ModOrigin fromOrigUnitfromExposedReexportfromHiddenReexportfromPackageFlagemptyUnitState lookupUnit lookupUnit' lookupUnitId lookupUnitId'unsafeLookupUnitunsafeLookupUnitIdlookupPackageNamesearchPackageIdresolvePackageImport listUnitInfo initUnitsreadUnitDatabases getUnitDbRefsresolveUnitDatabasereadUnitDatabasepprFlag pprReason unwireUnitlookupModuleInAllUnitslookupModuleWithSuggestionslookupModulePackage!lookupPluginModuleWithSuggestionslistVisibleModuleNames closeUnitDepscloseUnitDeps'mayThrowUnitErrrequirementMergespprUnitIdForUserpprUnitInfoForUserpprUnitspprUnitsSimple pprModuleMap improveUnitinstUnitToUnitrenameHoleModulerenameHoleUnitrenameHoleModule'renameHoleUnit'instModuleToModuleimplicitPackageDeps$fMonoidUnitVisibility$fSemigroupUnitVisibility$fOutputableUnitVisibility$fOutputableUnitDatabase$fOutputableUnusableUnitReason$fMonoidModuleOrigin$fSemigroupModuleOrigin$fOutputableModuleOrigin$fOutputableUnitErr ImportAvailsimp_modsimp_direct_dep_modsimp_dep_direct_pkgsimp_trust_own_pkgimp_trust_pkgs imp_boot_mods imp_sig_mods imp_orphs imp_finstsUsagePackageModuleUsageHomeModule UsageFileUsageHomeModuleInterfaceUsageMergedRequirementusg_mod usg_mod_hashusg_safe usg_mod_name usg_entities usg_exports usg_file_path usg_file_hashusg_file_labelusg_iface_hash Dependenciesdep_direct_modsdep_direct_pkgsdep_plugin_pkgs dep_sig_modsdep_trusted_pkgs dep_boot_mods dep_orphs dep_finstsmkDependenciesdep_orphs_updatedep_finsts_updatenoDependenciespprDeps$fBinaryDependencies $fBinaryUsage $fEqUsage$fEqDependencies LibrarySpecObjectsDLLDLLPath FrameworkSptEntryUnlinkedDotODotADotDLLBCOsObjFile LinkableSetLinkableLM linkableTimelinkableModulelinkableUnlinked LoadedPkgInfoloaded_pkg_uidloaded_pkg_hs_objsloaded_pkg_non_hs_objsloaded_pkg_trans_deps PkgsLoaded LoaderState closure_envitbl_env bcos_loaded objs_loaded pkgs_loadedtemp_sosLoader loader_stateuninitializedLoader mkLinkableSetunionLinkableSetisObjectLinkable linkableObjsisObjectisInterpretablenameOfObject_maybe nameOfObjectbyteCodeOfObject$fOutputableSptEntry$fOutputableUnlinked$fOutputableLinkable$fOutputableLibrarySpec$fOutputableLoadedPkgInfo IServInstance iservPipe iservProcessiservLookupSymbolCacheiservPendingFrees IServConfigiservConfProgram iservConfOptsiservConfProfilediservConfDynamic iservConfHookiservConfTrace IServState IServPending IServRunningIServInterpInstanceExternalInterpInternalInterpInterpinterpInstance interpLoaderInputFileBufferTargetId TargetModule TargetFileTargettargetIdtargetAllowObjCode targetUnitIdtargetContents pprTarget pprTargetId$fOutputableTargetId$fOutputableTarget $fEqTargetId FinderOptsfinder_importPathsfinder_lookupHomeInterfacesfinder_bypassHiFileCheck finder_waysfinder_enableSuggestionsfinder_workingDirectoryfinder_thisPackageNamefinder_hiddenModulesfinder_reexportedModules finder_hieDir finder_hieSuf finder_hiDir finder_hiSuffinder_dynHiSuffinder_objectDirfinder_objectSuffinder_dynObjectSuffinder_stubDir FindResultFound NoPackage FoundMultipleNotFoundfr_pathsfr_pkgfr_mods_hiddenfr_pkgs_hidden fr_unusablesfr_suggestionsInstalledFindResultInstalledFoundInstalledNoPackageInstalledNotFound FinderCache fcModuleCache fcFileCacheFinderCacheState$fShowFinderOptsshowSDocshowPprshowSDocForUser printForUser initLogFlags initDiagOpts IOEnvFailureIOEnvfailM failWithMrunIOEnvfixMtryMtryAllMtryMostMunsafeInterleaveMuninterruptibleMaskM_ newMutVar writeMutVar readMutVar updMutVar updMutVarMatomicUpdMutVaratomicUpdMutVar'getEnvsetEnvupdEnv$fMonadPlusIOEnv$fAlternativeIOEnv$fHasModuleIOEnv$fHasLoggerIOEnv$fHasHooksIOEnv$fHasDynFlagsIOEnv$fApplicativeIOEnv$fMonadFailIOEnv $fMonadIOEnv$fMonadIOIOEnv$fFunctorIOEnv$fExceptionIOEnvFailure$fShowIOEnvFailure$fMonadThrowIOEnv$fMonadCatchIOEnv$fMonadMaskIOEnv$fMonadFixIOEnvCoreToDoCoreM SimplCount IdSubstEnv isEmptySubst emptySubst mkEmptySubstmkSubst substInScope zapSubstEnv extendIdSubstextendIdSubstList extendSubstextendSubstWithVarextendSubstList lookupIdSubstdelBndrdelBndrs mkOpenSubst extendInScopeextendInScopeListextendInScopeIds setInScope substExprSC substExpr substBindSC substBind deShadowBinds substBndr substBndrs substRecBndrs cloneIdBndr cloneIdBndrs cloneBndrs cloneBndrcloneRecIdBndrs getTCvSubst substIdType substIdInfosubstUnfoldingSCsubstUnfolding substIdOcc substRuleInfosubstRulesForImportedIds substDVarSet substTickish$fOutputableSubst ArityTypeAT manifestArity joinRhsArity exprArity typeArityexprBotStrictness_maybemkBotArityTypemkManifestArityTypearityTypeArityexpandableArityType maxWithArityexprEtaExpandArity findRhsArity idArityType etaExpand etaExpandAT pushCoArgs pushCoArg pushCoTyArg pushCoValArgpushCoercionIntoLambda pushCoDataConcollectBindersPushingCoetaExpandToJoinPointetaExpandToJoinPointRule$fOutputableArityType$fOutputableEtaInfo $fEqArityTypeoccurAnalyseExproccurAnalysePgmzapLambdaBndrs$fOutputableOccEncl$fOutputableUsageDetails$fOutputableDetailsmkFinalUnfoldingmkCompulsoryUnfoldingmkCompulsoryUnfolding'mkSimpleUnfoldingmkDFunUnfoldingmkWrapperUnfoldingmkWorkerUnfoldingmkInlineUnfoldingmkInlineUnfoldingWithAritymkInlinableUnfolding specUnfolding mkUnfoldingmkCoreUnfoldingcertainlyWillInlinetidyCbvInfoToptidyExpr tidyRules tidyBndrs QuoteWrapper HoleExprRefHER EvCallStack EvCsEmpty EvCsPushCall EvTypeableEvTypeableTyConEvTypeableTyAppEvTypeableTrFunEvTypeableTyLitEvExprEvTermEvFunet_tvset_givenet_bindset_bodyEvBindeb_lhseb_rhs eb_is_given EvBindMapev_bind_varenv EvBindsVar CoEvBindsVarebv_uniq ebv_bindsebv_tcvs TcEvBindsEvBinds HsWrapperWpHole WpComposeWpFunWpCastWpEvLamWpEvAppWpTyLamWpTyAppWpLetWpMultCoercion TcMCoercionR TcMCoercionN TcMCoercion TcCoercionP TcCoercionR TcCoercionN TcCoercion mkTcReflCo mkTcSymCo mkTcSymMCo mkTcTransCo mkTcNomReflCo mkTcRepReflComkTcTyConAppCo mkTcAppCo mkTcFunCo mkTcAxInstComkTcUnbranchedAxInstCo mkTcForAllCo mkTcForAllCos mkTcNthComkTcLRCo mkTcSubCotcDowngradeRolemkTcAxiomRuleComkTcGReflRightComkTcGReflRightMComkTcGReflLeftComkTcGReflLeftMComkTcCoherenceLeftComkTcCoherenceRightCo mkTcPhantomCo mkTcKindCo mkTcCoVarComkTcFamilyTyConAppCotcCoercionKindtcCoercionRole isTcReflCoisTcReflexiveCo maybeTcSubCo maybeTcSymCo<.>mkWpFun mkWpCastR mkWpCastN mkWpTyApps mkWpEvApps mkWpEvVarApps mkWpTyLamsmkWpLamsmkWpLet idHsWrapper isIdHsWrapperhsWrapDictBinderscollectHsWrapBindersisCoEvBindsVaremptyEvBindMap extendEvBindsisEmptyEvBindMap lookupEvBindevBindMapBinds foldEvBindMapnonDetStrictFoldEvBindMapfilterEvBindMapevBindMapToVarSetvarSetMinusEvBindMap evBindVarmkWantedEvBind mkGivenEvBindevId evCoercionevCast evDFunApp evDataConApp evSelector evTypeablemkEvCastmkEvScSelectorsemptyTcEvBindsisEmptyTcEvBindsevTermCoercion_maybeevTermCoercionfindNeededEvVars evVarsOfTerm pprHsWrapperunwrapIPwrapIPquoteWrapperTyVarTyapplyQuoteWrapper$fOutputableEvTypeable$fOutputableEvTerm$fOutputableEvBind$fUniquableEvBindsVar$fOutputableEvBindsVar$fOutputableTcEvBinds$fOutputableEvBindMap$fDataTcEvBinds$fOutputableHsWrapper$fMonoidHsWrapper$fSemigroupHsWrapper$fOutputableEvCallStack$fDataHoleExprRef$fOutputableHoleExprRef$fDataQuoteWrapper$fDataEvCallStack$fDataHsWrapper$fDataEvTypeable $fDataEvTermOutputableBndrFlag EpAnnForallTy getBangTypegetBangStrictnessfromMaybeContextmkHsForAllVisTelemkHsForAllInvisTelemkHsQTvs emptyLHsQTvs hsSigWcType dropWildCardshsOuterTyVarNameshsOuterExplicitBndrsmkHsOuterImplicitmkHsOuterExplicitmkHsImplicitSigTypemkHsExplicitSigTypemkHsWildCardBndrsmkHsPatSigTypemkEmptyWildCardBndrshsTyVarBndrFlagsetHsTyVarBndrFlaghsTvbAllKindedhsLinearhsUnrestrictedisUnrestricted arrowToHsType pprHsArrow hsWcScopedTvs hsScopedTvs hsTyVarName hsLTyVarName hsLTyVarNameshsExplicitLTyVarNameshsAllLTyVarNameshsLTyVarLocNamehsLTyVarLocNames hsTyKindSig ignoreParensmkAnonWildCardTymkHsOpTy mkHsAppTy mkHsAppTys mkHsAppKindTysplitHsFunTypehsTyGetAppHead_maybelhsTypeArgSrcSpansplitLHsPatSynTysplitLHsSigmaTyInvissplitLHsGadtTysplitLHsForAllTyInvissplitLHsForAllTyInvis_KPsplitLHsQualTysplitLHsInstDeclTygetLHsInstDeclHeadgetLHsInstDeclClass_maybe mkFieldOccmkAmbiguousFieldOccrdrNameAmbiguousFieldOccselectorAmbiguousFieldOccunambiguousFieldOccambiguousFieldOccpprAnonWildCardpprHsOuterFamEqnTyVarBndrspprHsOuterSigTyVarBndrs pprHsForAll pprLHsContextpprConDeclFields pprHsTypehsTypeNeedsParensparenthesizeHsTypeparenthesizeHsContext$fOutputableHsPatSigType$fOutputableHsWildCardBndrs$fOutputableHsForAllTelescope$fOutputableLHsQTyVars$fOutputableHsType$fOutputableHsSigType!$fOutputableBndrAmbiguousFieldOcc$fOutputableAmbiguousFieldOcc$fOutputableConDeclField$fOutputableHsArrow$fNamedThingHsTyVarBndr$fOutputableHsTyVarBndr$fOutputableHsOuterTyVarBndrs $fOutputableBndrFlagSpecificityp$fOutputableBndrFlag()p TcSpecPragSpecPrag LTcSpecPrag TcSpecPragsIsDefaultMethod SpecPragsAnnSigasDcolonasRestABExportABEabe_polyabe_monoabe_wrap abe_pragsAbsBindsabs_tvs abs_ev_vars abs_exports abs_ev_binds abs_bindsabs_sig NHsValBindsLR NValBinds pprLHsBindspprLHsBindsForUser pprDeclListemptyLocalBindseqEmptyLocalBindsisEmptyValBindsemptyValBindsInemptyValBindsOut emptyLHsBindsisEmptyLHsBindsplusHsValBinds ppr_monobindpprTicksisEmptyIPBindsPRisEmptyIPBindsTc noSpecPrags hasSpecPragsisDefaultMethodppr_sig pragBracketspragSrcBrackets pprVarSigpprSpecpprTcSpecPrags pprMinimalSig$fOutputableFixitySig$fOutputableSig$fOutputableIPBind$fOutputableHsIPBinds$fOutputablePatSynBind$fOutputableHsBindLR$fOutputableHsLocalBindsLR$fOutputableHsValBindsLR$fOutputableTcSpecPrag$fOutputableABExport$fDataTcSpecPrags$fDataTcSpecPrag $fDataAnnSig HsRuleAnn ra_tyanns ra_tmannsra_restXViaStrategyPspartitionBindsAndSigs emptyRdrGroup emptyRnGrouphsGroupTopLevelFixitySigs appendGroupstyFamInstDeclNametyFamInstDeclLName tyClDeclLNametcdName hsDeclHasCuskpprTyClDeclFlavourfamilyDeclLNamefamilyDeclNamefamResultKindSignatureresultVariableNamestandaloneKindSigName getConNamesgetRecConArgs_maybehsConDeclThetapprTyFamInstDeclpprDataFamInstFlavourpprHsFamInstLHSinstDeclDataFamInstsfoldDerivStrategymapDerivStrategyflattenRuleDeclsroleAnnotDeclName$fOutputableRoleAnnotDecl$fOutputableAnnDecl$fOutputableWarnDecl$fOutputableWarnDecls$fOutputableRuleBndr$fOutputableRuleDecl$fOutputableRuleDecls$fOutputableForeignDecl$fOutputableDefaultDecl$fOutputableDerivStrategy$fOutputableDerivDecl$fOutputableInstDecl$fOutputableClsInstDecl$fOutputableDataFamInstDecl$fOutputableTyFamInstDecl$fOutputableConDecl$fOutputableStandaloneKindSig$fOutputableHsDataDefn$fOutputableDerivClauseTys$fOutputableHsDerivingClause$fOutputableFamilyDecl$fOutputableFunDep$fOutputableTyClGroup$fOutputableTyClDecl$fOutputableSpliceDecl$fOutputableHsGroup$fOutputableHsDecl$fOutputableXViaStrategyPs$fDataHsRuleAnn $fEqHsRuleAnn StgPprOpts stgSccEnabledOutputablePassStgOp StgPrimOp StgPrimCallOp StgFCallOp UpdateFlag ReEntrant Updatable SingleEntry XLetNoEscape XRhsClosureBinderPStgPassVanillaLiftLamsInferTaggedBinders InferTaggedCodeGenConstructorNumberNoNumberNumbered OutStgAlt OutStgRhs OutStgExpr OutStgArg OutStgBindingOutStgTopBindingInStgAltInStgRhs InStgExprInStgArg InStgBindingInStgTopBindingTgStgAltTgStgRhs TgStgExpr TgStgBindingTgStgTopBindingCgStgAltCgStgRhs CgStgExpr CgStgBindingCgStgTopBindingLlStgAltLlStgRhs LlStgExpr LlStgBindingLlStgTopBindingStgAltStgRhsStgExpr StgBinding StgTopBindingAltTypePolyAlt MultiValAltAlgAltPrimAlt GenStgAltalt_con alt_bndrsalt_rhsNoExtFieldSilent GenStgRhs StgRhsClosure StgRhsCon GenStgExprStgAppStgLit StgConAppStgOpAppStgCaseStgLetStgLetNoEscapeStgTickStgArg StgVarArg StgLitArg GenStgBinding StgNonRecStgRecGenStgTopBinding StgTopLiftedStgTopStringLit isDllConApp stgArgTypestgCaseBndrInScopenoExtFieldSilent stgRhsArity freeVarsOfRhs isUpdatablepanicStgPprOptsshortStgPprOptspprGenStgTopBindingpprGenStgTopBindings pprStgBindingpprStgTopBindingpprStgTopBindings pprStgArg pprStgExpr pprStgRhs$fOutputableStgArg$fOutputableNoExtFieldSilent$fOutputableAltType$fOutputableConstructorNumber$fOutputableUpdateFlag$fOutputableStgOp$fOutputableGenStgRhs$fOutputableGenStgExpr$fOutputableGenStgBinding$fDataNoExtFieldSilent$fEqNoExtFieldSilent$fOrdNoExtFieldSilentConPatTc cpt_arg_tyscpt_tvs cpt_dicts cpt_bindscpt_wrapHsPatExpansion HsPatExpanded XXPatGhcTcCoPat ExpansionPat co_cpt_wrap co_pat_inner co_pat_ty EpAnnSumPat sumPatParenssumPatVbarsBeforesumPatVbarsAfter hsRecFieldIdhsRecUpdFieldRdrhsRecUpdFieldIdhsRecUpdFieldOcc pprParendLPat pprConArgsmkPrefixConPatmkNilPat mkCharLitPat isBangedLPatlooksLazyPatBindisIrrefutableHsPat isSimplePatpatNeedsParensgParPatparenthesizePatcollectEvVarsPatscollectEvVarsPat$fOutputablePat$fOutputableHsPatExpansion$fDataHsPatExpansion$fDataEpAnnSumPatPendingTcSplicePendingRnSpliceSplicePointName DelayedSplice HsSplicedT XBindStmtTc xbstc_bindOpxbstc_boundResultTypexbstc_boundResultMult xbstc_failOp XBindStmtRn xbsrn_bindOp xbsrn_failOp RecStmtTc recS_bind_tyrecS_later_rets recS_rec_rets recS_ret_tyGrhsAnnga_vbarga_sepCmdTopTc HsExpansion HsExpanded XXExprGhcTcWrapExpr ExpansionExpr ConLikeTcHsTick HsBinTickAnnsIfaiIfaiThenaiElse aiThenSemi aiElseSemi AnnProjectionapOpenapClose AnnFieldLabelafDotAnnExplicitSumaesOpen aesBarsBefore aesBarsAfteraesCloseEpAnnUnboundVarhsUnboundBackquotes hsUnboundHole EpAnnHsCase hsCaseAnnCase hsCaseAnnOfhsCaseAnnsRest HsBracketTcbrack_renamed_quotebrack_tybrack_quote_wrapperbrack_pending_splicesHsWrap RecordUpdTc rupd_cons rupd_in_tys rupd_out_tys rupd_wrap SyntaxExprTcNoSyntaxExprTcsyn_expr syn_arg_wraps syn_res_wrap SyntaxExprRnNoSyntaxExprRn SyntaxExprGhc PostTcTable PostTcExprnoExpr noSyntaxExpr mkSyntaxExprmkRnSyntaxExpr tupArgPresent isQuietHsExprpprBinds ppr_lexprppr_exprppr_infix_exprppr_infix_expr_rnppr_infix_expr_tcppr_appspprDebugParendExprpprParendLExprhsExprNeedsParensgHsParparenthesizeHsExprstripParensLHsExprstripParensHsExprisAtomicHsExprpprLCmdpprCmd isQuietHsCmdppr_lcmdppr_cmd pprCmdArgisEmptyMatchGroupisSingletonMatchGroupmatchGroupArity hsLMatchPats pprMatchespprMatchpprGRHSspprGRHSpp_rhspprStmt pprBindStmtpprArgpprTransformStmt pprTransStmtpprBypprDo pprArrowExprppr_module_name_prefix ppr_do_stmtspprComppprQualspprPendingSpliceppr_splice_decl ppr_quasi ppr_splice thBrackets thTyBracketsppr_with_pending_tc_splices pp_dotdotmatchContextErrStringmatchArrowContextErrStringmatchDoContextErrStringpprMatchInCtxt pprStmtInCtxt$fWrapXRecGhcPassa$fOutputableHsStmtContext$fOutputableHsArrowMatchContext$fOutputableLamCaseVariant$fOutputableHsMatchContext$fOutputableArithSeqInfo$fOutputableHsQuote$fOutputableHsSplice$fOutputableHsSplicedThing$fOutputableApplicativeArg$fOutputableStmtLR$fOutputableParStmtBlock$fOutputableMatch$fOutputableHsCmdTop$fOutputableHsCmd$fOutputableHsPragE$fOutputableHsExpr$fOutputableSyntaxExprRn$fOutputableSyntaxExprTc$fOutputableHsExpansion$fOutputableXXExprGhcTc$fOutputableGrhsAnn$fDataDelayedSplice$fOutputablePendingRnSplice$fOutputablePendingTcSplice$fDataHsSplicedT $fDataGrhsAnn$fDataHsExpansion $fDataAnnsIf$fDataAnnProjection$fDataAnnFieldLabel$fDataAnnExplicitSum$fDataEpAnnUnboundVar$fDataEpAnnHsCase $fDataHsWrap CollectPass collectXXPatcollectXXHsBindsLR CollectFlagCollNoDictBindersCollWithDictBindersmkHsPar mkSimpleMatchunguardedGRHSs unguardedRHS mkMatchGroupmkLamCaseMatchGroup mkLocatedListmkHsApp mkHsAppWithmkHsApps mkHsAppsWith mkHsAppType mkHsAppTypesmkHsLammkHsLams mkHsCaseAlt nlHsTyApp nlHsTyAppsmkLHsParmkParPatnlParPat mkHsIntegralmkHsFractional mkHsIsStringmkHsDo mkHsDoAnnsmkHsComp mkHsCompAnnsmkHsIf mkHsCmdIfmkNPat mkNPlusKPatemptyTransStmtmkTransformStmtmkTransformByStmtmkGroupUsingStmtmkGroupByUsingStmt mkLastStmt mkBodyStmt mkPsBindStmt mkRnBindStmt mkTcBindStmt unitRecStmtTc emptyRecStmtemptyRecStmtNameemptyRecStmtId mkRecStmt mkLetStmt mkHsOpAppmkUntypedSplice mkTypedSplicemkHsQuasiQuote mkHsStringmkHsStringPrimLitmkHsCharPrimLit mkConLikeTcnlHsVarnl_HsVar nlHsDataConnlHsLit nlHsIntLitnlVarPatnlLitPatnlHsAppnlHsSyntaxAppsnlHsApps nlHsVarApps nlConVarPatnlConVarPatName nlInfixConPatnlConPat nlConPatNamenlNullaryConPat nlWildConPat nlWildPat nlWildPatNamenlHsDo nlHsOpAppnlHsLamnlHsParnlHsIfnlHsCasenlList nlHsAppTy nlHsTyVar nlHsFunTy nlHsParTy nlHsTyConApp nlHsAppKindTymkLHsTupleExpr mkLHsVarTuple nlTuplePat missingTupArgmkBigLHsVarTup mkBigLHsTupmkBigLHsVarPatTupmkBigLHsPatTup mkChunkifiedchunkifyhsTypeToHsSigTypehsTypeToHsSigWcType mkHsSigEnv mkClassOpSigs mkLHsWrapmkHsWrap mkHsWrapCo mkHsWrapCoR mkLHsWrapCo mkHsCmdWrap mkLHsCmdWrap mkHsWrapPat mkHsWrapPatCo mkHsDictLet mkFunBind mkTopFunBind mkHsVarBind mkVarBind mkPatSynBindisInfixFunBindspanHsLocaLBindsmkSimpleGeneratedFunBindmkPrefixFunRhsmkMatchisUnliftedHsBindisBangedHsBindcollectLocalBinderscollectHsIdBinderscollectHsValBinderscollectHsBindBinderscollectHsBindsBinderscollectHsBindListBinderscollectMethodBinderscollectLStmtsBinderscollectStmtsBinderscollectLStmtBinderscollectStmtBinderscollectPatBinderscollectPatsBindershsGroupBindershsTyClForeignBindershsLTyClDeclBindershsForeignDeclsBindershsPatSynSelectorsgetPatSynBindshsDataFamInstBinderslStmtsImplicitshsValBindsImplicits lPatImplicits$fCollectPassGhcPass FloatBindFloatLet FloatCase MkStringIdsunpackCStringIdunpackCStringUtf8Id sortQuantVars mkCoreAppmkWildEvBindermkWildValBinder mkWildCase mkIfThenElsecastBottomExpr mkLitRubbishmkUncheckedIntExpr mkIntExprInt mkIntegerExpr mkNaturalExprmkStringExprFSgetMkStringIdsmkStringExprFSWithmkCoreVarTupTy mkCoreTup mkCoreUbxTupmkCoreTupBoxity mkCoreUbxSummkBigCoreVarTupmkBigCoreVarTup1mkBigCoreVarTupTy mkBigCoreTupmkBigCoreTupTyunitExprmkTupleSelectormkTupleSelector1mkSmallTupleSelector mkTupleCasemkSmallTupleCase wrapFloat wrapFloats floatBindings mkNilExpr mkConsExpr mkListExprmkNonEmptyListExpr mkFoldrExpr mkBuildExpr mkNothingExpr mkJustExprmkRuntimeErrorAppmkImpossibleExprerrorIdsrEC_SEL_ERROR_IDrUNTIME_ERROR_IDrEC_CON_ERROR_ID pAT_ERROR_IDnO_METHOD_BINDING_ERROR_IDnON_EXHAUSTIVE_GUARDS_ERROR_ID tYPE_ERROR_IDaBSENT_SUM_FIELD_ERROR_IDaBSENT_ERROR_IDmkAbsentErrorApp$fOutputableFloatBind perhapsAsPat$fOutputableGhcHintDataConBuilderPrefixDataConBuilderInfixDataConBuilder PatBuilder PatBuilderPat PatBuilderPar PatBuilderAppPatBuilderAppTypePatBuilderOpApp PatBuilderVarPatBuilderOverLit SumOrTupleSumTuple pprSumOrTuple$fOutputablePatBuilder$fOutputableDataConBuilderOptCoercionOptsoptCoercionEnabled optCoercion checkAxInstCo so_co_optsdefaultSimpleOptssimpleOptExprWith simpleOptPgmjoinPointBinding_maybejoinPointBindings_maybeexprIsConApp_maybeexprIsLiteral_maybeexprIsLambda_maybe$fOutputableSimpleOptEnvBangOptsbang_opt_strict_databang_opt_unbox_disablebang_opt_unbox_strictbang_opt_unbox_smallDataConBangOpts FixedBangOpts SrcBangOptsDCB wiredInIds ghcPrimIds mkDictSelRhsvanillaDataConBoxer mkDataConRepunwrapNewTypeBodywrapFamInstBody mkFCallId mkDictFunId mkDictFunTy coerceNameleftSectionNamerightSectionNamenoinlineIdName proxyHashId nullAddrIdseqIdlazyId noinlineIdcoerceIdrealWorldPrimId voidPrimId voidArgIdcoercionTokenId toIfaceTvBndrtoIfaceTvBndrs toIfaceIdBndr toIfaceBndrtoIfaceTyCoVarBinders toIfaceKind toIfaceType toIfaceTyVartoIfaceTyCon_nametoIfaceCoerciontidyToIfaceTypetidyToIfaceContextpatSynToIfaceDecl toIfaceBangtoIfaceSrcBangtoIfaceLetBndrtoIfaceIdDetails toIfaceIdInfo toIfUnfolding toIfaceExprtoIfaceTickish toIfaceBind toIfaceAlt toIfaceCon toIfaceApp toIfaceVar toIfaceLFInfomkRule roughTopNamespprRulesForUserextendRuleInfo addRuleInfoaddIdSpecialisations rulesOfBindsgetRules emptyRuleBase mkRuleBaseextendRuleBaseList extendRuleEnv pprRuleBase lookupRule initRuleOptsruleCheckProgram builtinRules caseRules$fMonadPlusRuleM$fAlternativeRuleM$fMonadFailRuleM $fMonadRuleM$fApplicativeRuleM$fFunctorRuleM IEWildcard NoIEWildcardIEVar IEThingAbs IEThingAll IEThingWithIEModuleContentsIEGroupIEDoc IEDocNamedXIELIELIEWrappedName IEWrappedNameIEName IEPatternIETypeEpAnnImportDeclimportDeclAnnImportimportDeclAnnPragmaimportDeclAnnSafeimportDeclAnnQualifiedimportDeclAnnPackageimportDeclAnnAsImportDeclPkgQual ImportDecl XImportDeclideclExtideclSourceSrc ideclName ideclPkgQual ideclSource ideclSafeideclQualified ideclImplicitideclAs ideclHidingImportDeclQualifiedStyle QualifiedPre QualifiedPost NotQualified LImportDeclimportDeclQualifiedStyleisImportDeclQualifiedsimpleImportDeclieNameieNamesieWrappedLName ieWrappedNamelieWrappedNameieLWrappedNamereplaceWrappedNamereplaceLWrappedName pprImpExp$fOutputableIEWrappedName$fOutputableBndrIEWrappedName$fHasOccNameIEWrappedName$fOutputableIE$fOutputableImportDecl$fEqIEWildcard$fDataIEWildcard$fEqIEWrappedName$fDataIEWrappedName$fDataEpAnnImportDecl$fEqImportDeclQualifiedStyle$fDataImportDeclQualifiedStyle$fDataXViaStrategyPs$fDataXXPatGhcTc$fDataXXExprGhcTc$fEqIE$fEqIE0$fEqIE1$fDataIE $fDataIE0 $fDataIE1$fDataImportDecl$fDataImportDecl0$fDataImportDecl1$fDataAmbiguousFieldOcc$fDataAmbiguousFieldOcc0$fDataAmbiguousFieldOcc1$fDataFieldOcc$fDataFieldOcc0$fDataFieldOcc1$fDataConDeclField$fDataConDeclField0$fDataConDeclField1 $fDataHsArg$fDataHsScaled$fDataHsScaled0$fDataHsScaled1 $fDataHsArrow$fDataHsArrow0$fDataHsArrow1$fDataHsLinearArrowTokens$fDataHsLinearArrowTokens0$fDataHsLinearArrowTokens1 $fDataHsType $fDataHsType0 $fDataHsType1$fDataHsTyVarBndr$fDataHsTyVarBndr0$fDataHsTyVarBndr1$fDataHsForAllTelescope$fDataHsForAllTelescope0$fDataHsForAllTelescope1$fDataHsPatSigType$fDataHsPatSigType0$fDataHsPatSigType1$fDataHsWildCardBndrs$fDataHsWildCardBndrs0$fDataHsWildCardBndrs1$fDataHsSigType$fDataHsSigType0$fDataHsSigType1$fDataHsOuterTyVarBndrs$fDataHsOuterTyVarBndrs0$fDataHsOuterTyVarBndrs1$fDataLHsQTyVars$fDataLHsQTyVars0$fDataLHsQTyVars1$fDataHsRecFields$fDataHsRecFields0$fDataHsRecFields1$fDataHsFieldBind$fDataConPatTc $fDataPat $fDataPat0 $fDataPat1$fDataOverLitTc$fDataOverLitRn$fDataHsOverLit$fDataHsOverLit0$fDataHsOverLit1 $fDataHsLit $fDataHsLit0 $fDataHsLit1$fDataXBindStmtTc$fDataXBindStmtRn$fDataSyntaxExprTc$fDataSyntaxExprRn$fDataPendingTcSplice$fDataPendingRnSplice$fDataCmdTopTc$fDataRecordUpdTc$fDataArithSeqInfo$fDataArithSeqInfo0$fDataArithSeqInfo1$fDataHsBracketTc $fDataHsQuote$fDataHsQuote0$fDataHsQuote1$fDataHsSplicedThing$fDataHsSplicedThing0$fDataHsSplicedThing1$fDataHsSplice$fDataHsSplice0$fDataHsSplice1$fDataHsMatchContext$fDataHsMatchContext0$fDataHsMatchContext1$fDataHsDoFlavour$fDataHsArrowMatchContext$fDataHsStmtContext$fDataHsStmtContext0$fDataHsStmtContext1$fDataApplicativeArg$fDataApplicativeArg0$fDataApplicativeArg1$fDataParStmtBlock$fDataParStmtBlock0$fDataParStmtBlock1$fDataParStmtBlock2$fDataRecStmtTc $fDataStmtLR $fDataStmtLR0 $fDataStmtLR1 $fDataStmtLR2 $fDataStmtLR3 $fDataStmtLR4 $fDataStmtLR5 $fDataStmtLR6 $fDataGRHS $fDataGRHS0 $fDataGRHS1 $fDataGRHS2 $fDataGRHS3 $fDataGRHS4 $fDataGRHSs $fDataGRHSs0 $fDataGRHSs1 $fDataGRHSs2 $fDataGRHSs3 $fDataGRHSs4 $fDataMatch $fDataMatch0 $fDataMatch1 $fDataMatch2 $fDataMatch3 $fDataMatch4$fDataMatchGroup$fDataMatchGroup0$fDataMatchGroup1$fDataMatchGroup2$fDataMatchGroup3$fDataMatchGroup4$fDataHsCmdTop$fDataHsCmdTop0$fDataHsCmdTop1 $fDataHsCmd $fDataHsCmd0 $fDataHsCmd1$fDataHsTupArg$fDataHsTupArg0$fDataHsTupArg1 $fDataHsExpr $fDataHsExpr0 $fDataHsExpr1 $fDataHsPragE$fDataHsPragE0$fDataHsPragE1$fDataDotFieldOcc$fDataDotFieldOcc0$fDataDotFieldOcc1$fDataFieldLabelStrings$fDataFieldLabelStrings0$fDataFieldLabelStrings1$fDataRoleAnnotDecl$fDataRoleAnnotDecl0$fDataRoleAnnotDecl1 $fDataAnnDecl$fDataAnnDecl0$fDataAnnDecl1$fDataAnnProvenance$fDataAnnProvenance0$fDataAnnProvenance1$fDataWarnDecl$fDataWarnDecl0$fDataWarnDecl1$fDataWarnDecls$fDataWarnDecls0$fDataWarnDecls1$fDataRuleBndr$fDataRuleBndr0$fDataRuleBndr1$fDataRuleDecl$fDataRuleDecl0$fDataRuleDecl1$fDataRuleDecls$fDataRuleDecls0$fDataRuleDecls1$fDataForeignDecl$fDataForeignDecl0$fDataForeignDecl1$fDataDefaultDecl$fDataDefaultDecl0$fDataDefaultDecl1$fDataDerivStrategy$fDataDerivStrategy0$fDataDerivStrategy1$fDataDerivDecl$fDataDerivDecl0$fDataDerivDecl1$fDataInstDecl$fDataInstDecl0$fDataInstDecl1$fDataClsInstDecl$fDataClsInstDecl0$fDataClsInstDecl1 $fDataFamEqn $fDataFamEqn0 $fDataFamEqn1$fDataDataFamInstDecl$fDataDataFamInstDecl0$fDataDataFamInstDecl1$fDataTyFamInstDecl$fDataTyFamInstDecl0$fDataTyFamInstDecl1$fDataHsConDeclGADTDetails$fDataHsConDeclGADTDetails0$fDataHsConDeclGADTDetails1 $fDataConDecl$fDataConDecl0$fDataConDecl1$fDataDerivClauseTys$fDataDerivClauseTys0$fDataDerivClauseTys1$fDataHsDerivingClause$fDataHsDerivingClause0$fDataHsDerivingClause1$fDataHsDataDefn$fDataHsDataDefn0$fDataHsDataDefn1$fDataFamilyInfo$fDataFamilyInfo0$fDataFamilyInfo1$fDataInjectivityAnn$fDataInjectivityAnn0$fDataInjectivityAnn1$fDataFamilyDecl$fDataFamilyDecl0$fDataFamilyDecl1$fDataFamilyResultSig$fDataFamilyResultSig0$fDataFamilyResultSig1$fDataTyClGroup$fDataTyClGroup0$fDataTyClGroup1 $fDataFunDep $fDataFunDep0 $fDataFunDep1$fDataTyClDecl$fDataTyClDecl0$fDataTyClDecl1$fDataSpliceDecl$fDataSpliceDecl0$fDataSpliceDecl1 $fDataHsGroup$fDataHsGroup0$fDataHsGroup1 $fDataHsDecl $fDataHsDecl0 $fDataHsDecl1$fDataHsPatSynDir$fDataHsPatSynDir0$fDataHsPatSynDir1$fDataStandaloneKindSig$fDataStandaloneKindSig0$fDataStandaloneKindSig1$fDataFixitySig$fDataFixitySig0$fDataFixitySig1 $fDataSig $fDataSig0 $fDataSig1 $fDataIPBind $fDataIPBind0 $fDataIPBind1$fDataHsIPBinds$fDataHsIPBinds0$fDataHsIPBinds1$fDataPatSynBind$fDataPatSynBind0$fDataPatSynBind1$fDataPatSynBind2$fDataRecordPatSynField$fDataRecordPatSynField0$fDataRecordPatSynField1$fDataABExport$fDataAbsBinds$fDataHsBindLR$fDataHsBindLR0$fDataHsBindLR1$fDataHsBindLR2$fDataNHsValBindsLR$fDataNHsValBindsLR0$fDataNHsValBindsLR1$fDataHsValBindsLR$fDataHsValBindsLR0$fDataHsValBindsLR1$fDataHsValBindsLR2$fDataHsLocalBindsLR$fDataHsLocalBindsLR0$fDataHsLocalBindsLR1$fDataHsLocalBindsLR2HsParsedModule hpm_module hpm_src_files AnnsModuleam_mainam_declsHsModulehsmodAnn hsmodLayout hsmodName hsmodExports hsmodImports hsmodDeclshsmodDeprecMessagehsmodHaddockModHeader$fOutputableHsModule$fDataAnnsModule$fEqAnnsModule$fDataHsModuleCgGuts cg_module cg_tyconscg_bindscg_ccs cg_foreigncg_foreign_files cg_dep_pkgs cg_hpc_info cg_modBreakscg_spt_entriesModGuts mg_module mg_hsc_srcmg_loc mg_exportsmg_deps mg_usages mg_used_th mg_rdr_env mg_fix_envmg_tcsmg_insts mg_fam_insts mg_patsynsmg_rulesmg_binds mg_foreignmg_foreign_filesmg_warnsmg_annsmg_complete_matches mg_hpc_info mg_modBreaks mg_inst_envmg_fam_inst_envmg_boot_exportsmg_safe_haskell mg_trust_pkgmg_docsmg_mnwibExpectedFunTyOriginExpectedFunTySyntaxOpExpectedFunTyViewPatExpectedFunTyArgExpectedFunTyMatchesExpectedFunTyLamExpectedFunTyLamCaseFRRArrowContext ArrowCmdResTy ArrowCmdAppArrowCmdArrApp ArrowCmdCaseArrowFun StmtOriginMonadComprehension DoNotationFRRRecordUpdate FRRBinder FRRPatBind FRRPatSynArgFRRCase FRRDataConArgFRRNoBindingResArg FRRTupleArgFRRTupleSection FRRUnboxedSum FRRBodyStmtFRRBodyStmtGuard FRRBindStmtFRRBindStmtGuardFRRArrowFRRExpectedFunTyfrr_type frr_contextCtOrigin GivenOrigin InstSCOrigin OtherSCOrigin OccurrenceOfOccurrenceOfRecSel AppOriginSpecPragOrigin TypeEqOrigin KindEqOrigin IPOccOriginOverLabelOrigin LiteralOrigin NegateOriginArithSeqOriginAssocFamPatOrigin SectionOriginHasFieldOrigin TupleOrigin ExprSigOrigin PatSigOrigin PatOriginProvCtxtOriginRecordUpdOrigin ViewPatOriginScOriginDerivClauseOrigin DerivOriginDCDerivOriginCoerceStandAloneDerivOrigin DefaultOriginDoOrigin DoPatOrigin MCompOriginMCompPatOrigin ProcOriginArrowCmdOrigin AnnOrigin FunDepOrigin1 FunDepOrigin2 InjTFOrigin1ExprHoleOriginTypeHoleOriginPatCheckOrigin ListOriginIfThenElseOrigin BracketOrigin StaticOriginShouldn'tHappenOrigin GhcBug20076InstProvidedOriginNonLinearPatternOriginUsageEnvironmentOfCycleBreakerOrigin FRROriginWantedSuperclassOriginInstanceSigOriginAmbiguityCheckOrigin uo_actual uo_expecteduo_thing uo_visible TyVarBndrsHsTyVarBndrsRn TypedThing HsTypeRnThing TypeThing HsExprRnThing NameThingSigSkol SigTypeSkol ForAllSkol DerivSkolInstSkol FamInstSkolPatSkolIPSkolRuleSkol InferSkol BracketSkolUnifyForAllSkol TyConSkol DataConSkol ReifySkol QuantCtxtSkolRuntimeUnkSkolArrowReboundIfSkolUnkSkolReportRedundantConstraintsNoRRCWantRRC UserTypeCtxt FunSigCtxt InfSigCtxt ExprSigCtxt KindSigCtxtStandaloneKindSigCtxt TypeAppCtxt ConArgCtxt TySynCtxt PatSynCtxt PatSigCtxt RuleSigCtxt ForSigCtxtDefaultDeclCtxt InstDeclCtxt SpecInstCtxt GenSigCtxtGhciCtxt ClassSCCtxt SigmaCtxt DataTyCtxtDerivClauseCtxtTyVarBndrKindCtxt DataKindCtxt TySynKindCtxtTyFamResKindCtxtreportRedundantConstraintsredundantConstraintsSpanpprUserTypeCtxt isSigMaybe unkSkolAnon mkSkolemInfo getSkolemInfo pprSkolInfopprSigSkolInfoisVisibleOrigintoInvisibleOrigin isGivenOriginisWantedWantedFunDepOriginisWantedSuperclassOrigin lexprCtOrigin exprCtOriginmatchesCtOrigin grhssCtOrigin pprCtOriginisPushCallStackOrigincallStackOriginFSpprFixedRuntimeRepContextpprFRRArrowContextpprExpectedFunTyOriginpprExpectedFunTyHerald$fOutputableTypedThing$fOutputableTyVarBndrs$fOutputableSkolemInfoAnon$fOutputableSkolemInfo$fUniquableSkolemInfo$fOutputableStmtOrigin$fOutputableFRRArrowContext"$fOutputableFixedRuntimeRepContext$fOutputableCtOrigin$fEqUserTypeCtxt$fEqReportRedundantConstraintsCtLoc ctl_originctl_env ctl_t_or_k ctl_depth SubGoalDepth CtFlavourRole CtFlavourGivenWanted RewriterSet CtEvidenceCtGivenCtWanted ctev_pred ctev_evarctev_loc ctev_destctev_rewritersTcEvDest EvVarDestHoleDest UserGiven HasGivenEqs NoGivenEqs LocalGivenEqs MaybeGivenEqs ImplicStatus IC_Solved IC_InsolubleIC_BadTelescope IC_Unsolvedics_dead ImplicationImplicic_tclvlic_infoic_skolsic_given ic_given_eqsic_warn_inaccessibleic_env ic_wantedic_binds ic_need_inner ic_need_outer ic_statusWantedConstraintsWC wc_simplewc_impl wc_errorsCheckTyEqProblemCheckTyEqResult CtIrredReasonIrredShapeReasonNonCanonicalReason ReprEqReasonShapeMismatchReasonAbstractTyConReasonNotConcreteReasonNonConcreteTyConNonConcretisableTyVar ContainsCastContainsForallContainsCoercionTyNotConcreteErrorNCE_FRRnce_locnce_frr_origin nce_reasonsHoleSortExprHoleTypeHoleConstraintHoleHole hole_sorthole_occhole_tyhole_loc DelayedErrorDE_HoleDE_NotConcreteQCInstQCIqci_evqci_tvsqci_pred qci_pend_scCanEqLHSTyVarLHSTyFamLHSCtCDictCan CIrredCanCEqCan CNonCanonical CQuantCancc_evcc_class cc_tyargs cc_pend_sc cc_fundeps cc_reasoncc_lhscc_rhs cc_eq_relCtsXiisInsolubleReasoncteOKcterHasNoProblemcteImpredicative cteTypeFamilycteInsolubleOccurscteSolubleOccurs cteProblemcterHasProblemcterHasOnlyProblemcterRemoveProblemcterHasOccursCheckcterClearOccursCheckcterSetOccursCheckSoluble cterFromKindmkNonCanonicalmkNonCanonicalCt mkIrredCtmkGivens ctEvidencectLocctOriginctPred ctRewritersctEvIdwantedEvId_maybemkTcEqPredLikeEv ctFlavourctEqRelcanEqLHS_maybe canEqLHSType canEqLHSKind eqCanEqLHS tyCoVarsOfCttyCoVarsOfCtEvtyCoVarsOfCtListtyCoVarsOfCtEvList tyCoVarsOfCtstyCoVarsOfCtsListtyCoVarsOfCtEvsList tyCoVarsOfWCtyCoVarsOfWCList isGivenLoc isWantedCt isGivenCtgetUserTypeErrorMsgisUserTypeErrorisPendingScDictisPendingScInstsuperClassesMightHelpgetPendingWantedScssingleCtandCts listToCtsctsEltsconsCtssnocCts extendCtsList andManyCtsemptyCts isEmptyCtspprCtsemptyWC mkSimpleWC mkImplicWC isEmptyWC isSolvedWCandWCunionsWC addSimples addImplics addInsolsaddHolesaddNotConcreteErroraddDelayedErrorsdropMisleadingisSolvedStatusisInsolubleStatusinsolubleImplicnonDefaultableTyVarsOfWC insolubleWCinsolubleWantedCt insolubleEqCt insolubleCtisOutOfScopeHoleimplicationPrototypegetUserGivensFromImplicscheckTelescopeSkolcheckImplicationInvariants pprEvVars pprEvVarThetapprEvVarWithTypewrapTypectEvPredctEvLoc ctEvOrigin ctEvEqRelctEvRolectEvTerm ctEvRewritersctEvExpr ctEvCoercionctEvEvId ctEvUniquetcEvDestUnique setCtEvLocarisesFromGivenssetCtEvPredTypeisWantedisGivenemptyRewriterSetisEmptyRewriterSetaddRewriterSetrewriterSetFromCorewriterSetFromTyperewriterSetFromTypes ctEvFlavourctEvFlavourRole ctFlavourRole eqCanRewriteeqCanRewriteFRinitialSubGoalDepthbumpSubGoalDepthmaxSubGoalDepthsubGoalDepthExceeded mkKindLoc toKindLoc mkGivenLocctLocEnv ctLocLevel ctLocDepth ctLocOrigin ctLocSpanctLocTypeOrKind_maybe setCtLocSpanbumpCtLocDepthsetCtLocOriginupdateCtLocOrigin setCtLocEnvpprCtLoc$fOutputableCanEqLHS$fOutputableHoleSort$fOutputableCheckTyEqResult$fMonoidCheckTyEqResult$fSemigroupCheckTyEqResult$fOutputableCtIrredReason$fOutputableImplicStatus$fMonoidHasGivenEqs$fSemigroupHasGivenEqs$fOutputableHasGivenEqs$fOutputableTcEvDest$fOutputableCtFlavour$fOutputableCtEvidence$fOutputableQCInst$fOutputableCt$fOutputableNotConcreteError$fOutputableHole$fOutputableDelayedError$fOutputableImplication$fOutputableWantedConstraints$fEqSubGoalDepth$fOrdSubGoalDepth$fOutputableSubGoalDepth $fEqCtFlavour$fOutputableRewriterSet$fSemigroupRewriterSet$fMonoidRewriterSet$fEqHasGivenEqs EqualCtListFunEqMapDictMapTcAppMapisEmptyTcAppMap emptyTcAppMap insertTcApp alterTcAppfilterTcAppMap tcAppMapToBag foldTcAppMap emptyDictMapfindDictfindDictsByClassdelDictaddDictaddDictsByClass filterDictspartitionDicts dictsToBag foldDicts emptyFunEqs findFunEqfindFunEqsByTyCon foldFunEqs insertFunEqaddToEqualCtListfilterEqualCtListInertEqs InertCansIC inert_eqs inert_funeqs inert_dicts inert_instsinert_safehask inert_irredsinert_given_eq_lvlinert_given_eqsIS inert_cansinert_cycle_breakersinert_famapp_cacheinert_solved_dictsCycleBreakerVarStackWorkListWLwl_eqswl_rest wl_implicsappendWorkList workListSizeextendWorkListEqextendWorkListNonEqextendWorkListImplicextendWorkListCtextendWorkListCtsisEmptyWorkList emptyWorkListselectWorkItem emptyInert foldTyEqsdelEqfindEqpartitionInertEqspartitionFunEqs addInertItemkickOutRewritableLHSmatchableGivensmightEqualLaterprohibitedSuperClassSolvepushCycleBreakerVarStackinsertCycleBreakerBindingforAllCycleBreakerBindings_$fOutputableWorkList$fOutputableInertCans$fOutputableInertSet PmAltConSetPmAltCon PmAltConLikePmAltLit PmEqualityEqualDisjointPossiblyOverlap PmLitValuePmLitIntPmLitRat PmLitChar PmLitString PmLitOverInt PmLitOverRatPmLitOverStringPmLit pm_lit_ty pm_lit_valResidualCompleteMatchesRCM rcm_vanilla rcm_pragmasBotInfoIsBotIsNotBotMaybeBot PmAltConAppPACApaca_conpaca_tvspaca_idsVarInfoVIvi_idvi_posvi_negvi_botvi_rcmTmStateTmStts_factsts_repsts_dirtyTyStateTyStty_st_n ty_st_inertNablasMkNablasNablaMkNabla nabla_ty_st nabla_tm_st initNablasgetRcmisRcmInitialised lookupVarInfolookupVarInfoNT trvVarInfo lookupRefutslookupSolution pmLitTypeemptyPmAltConSetisEmptyPmAltConSetelemPmAltConSetextendPmAltConSetpmAltConSetElems eqPmAltCon pmAltConTypeisPmAltConMatchStrictpmAltConImplBangsliteralToPmLit negatePmLit overloadPmLitpmLitAsStringLitcoreExprAsPmLit$fOutputableTyState$fOutputableBotInfo#$fOutputableResidualCompleteMatches$fOutputablePmLitValue$fOutputablePmLit$fOutputablePmEquality $fEqPmLit$fOutputablePmAltCon $fEqPmAltCon$fOutputablePmAltConApp$fOutputablePmAltConSet$fOutputableVarInfo$fOutputableTmState$fOutputableNabla$fMonoidNablas$fSemigroupNablas$fOutputableNablas$fEqPmEquality$fShowPmEquality $fEqBotInfoPostPre CheckResultcr_retcr_uncov cr_approxRedSetsrs_covrs_divrs_bangs Precision ApproximatePrecise PmPatBind PmEmptyCasepe_varPmGRHSpg_grdspg_rhsPmGRHSspgs_lcls pgs_grhssPmMatchpm_patspm_grhss PmMatchGroupGrdVecSrcInfoPmGrdPmConPmBangPmLetpm_id pm_con_con pm_con_tvs pm_con_dicts pm_con_args_pm_loc _pm_let_expr$fOutputableSrcInfo$fOutputablePmGrd$fOutputableGrdVec$fOutputablePmGRHS$fOutputablePmGRHSs$fOutputablePmMatch$fOutputablePmMatchGroup$fOutputablePmEmptyCase$fOutputablePmPatBind$fMonoidPrecision$fSemigroupPrecision$fOutputablePrecision$fOutputableRedSets$fOutputableCheckResult$fFunctorCheckResult $fEqPrecision$fShowPrecision pprUncovered HsDocContext TypeSigCtxStandaloneKindSigCtxPatCtxSpecInstSigCtxDefaultDeclCtxForeignDeclCtx DerivDeclCtxRuleCtx TyDataCtxTySynCtx TyFamilyCtx FamPatCtx ConDeclCtx ClassDeclCtxExprWithTySigCtxTypBrCtx HsTypeCtx HsTypePatCtxGHCiCtx SpliceTypeCtxClassInstanceCtx GenericCtxFixedRuntimeRepErrorInfoFRR_Infofrr_info_originfrr_info_not_concreteRelevantBindingsrelevantBindingNamesAndTys ranOutOfFuel ValidHoleFitsholeFitsrefinementFitsFitsMbSuppressedFitsfitsfitsSuppressedPotentialInstancesmatchesunifiers ImportError MissingModuleModulesDoNotExport CoercibleMsg UnknownRolesTyConIsAbstractOutOfScopeNewtypeConstructor HoleErrorOutOfScopeHoleHoleFitDispConfigHFDCshowWrap showWrapVarsshowTypeshowProv showMatchesNotInScopeError NotInScope NoExactNameSameNameMissingBindingNoTopLevelBindingUnknownSubordinateTcSolverReportInfo Ambiguity TyVarInfoNonInjectiveTyFamReportCoercibleMsgExpectedActual!ExpectedActualAfterTySynExpansion WhenMatchingSameOccOccursCheckInterestingTyVarslead_with_ambig_msg ambig_tyvars ea_expected ea_actualea_expanded_expectedea_expanded_actualsameOcc_same_pkg sameOcc_lhs sameOcc_rhs CND_ExtraTcSolverReportMsgTcReportWithInfo BadTelescope UserTypeErrorReportHoleErrorCannotUnifyWithPolytypeMismatch KindMismatchTypeEqMismatchFixedRuntimeRepError SkolemEscapeUntouchableVariableBlockedEqualityExpectingMoreArgumentsUnboundImplicitParamsCouldNotDeduceAmbiguityPreventsSolvingCtCannotResolveInstanceOverlappingInstances UnsafeOverlap mismatch_ea mismatch_item mismatch_ty1 mismatch_ty2kmismatch_whatkmismatch_expectedkmismatch_actualteq_mismatch_ppr_explicit_kindsteq_mismatch_itemteq_mismatch_ty1teq_mismatch_ty2teq_mismatch_expectedteq_mismatch_actualteq_mismatch_whatcnd_user_givens cnd_wanted cnd_extracannotResolve_itemcannotResolve_unifierscannotResolve_candidatescannotResolve_importErrorscannotResolve_suggestionscannotResolve_relevant_bindingsoverlappingInstances_itemoverlappingInstances_matchesoverlappingInstances_unifiersunsafeOverlap_itemunsafeOverlap_matchesunsafeOverlapped ErrorItemEIei_pred ei_evdest ei_flavourei_loc ei_m_reason ei_suppressSolverReportErrCtxtCECcec_enclcec_tidy cec_bindscec_defer_type_errorscec_expr_holescec_type_holescec_out_of_scope_holescec_warn_redundantcec_expand_syns cec_suppressSolverReportWithCtxt reportContext reportContentSolverReportSupplementarySupplementaryBindingsSupplementaryHoleFitsSupplementaryCts SolverReportsr_important_msgssr_supplementarysr_hintsExported IsNotExported IsExportedMissingSignatureMissingTopLevelBindingSigMissingPatSynSigMissingTyConKindSig!AssociatedTyNotParamOverLastTyVar$YesAssociatedTyNotParamOverLastTyVar#NoAssociatedTyNotParamOverLastTyVarAssociatedTyLastVarInKindYesAssocTyLastVarInKindNoAssocTyLastVarInKindHasAssociatedDataFamInsts YesHasAdfs NoHasAdfs"SoleExtraConstraintWildcardAllowed%SoleExtraConstraintWildcardNotAllowedBadAnonWildcardContextWildcardNotLastInConstraint!ExtraConstraintWildcardNotAllowedWildcardsNotAllowedAtAll HasWildcardYesHasWildcard NoHasWildcardDeriveGenericsErrReason*DerivErrGenericsMustNotHaveDatatypeContext%DerivErrGenericsMustNotHaveExoticArgs$DerivErrGenericsMustBeVanillaDataCon&DerivErrGenericsMustHaveSomeTypeParams'DerivErrGenericsMustNotHaveExistentialsDerivErrGenericsWrongArgKindDeriveInstanceBadConstructorDerivErrBadConExistentialDerivErrBadConCovariantDerivErrBadConFunTypesDerivErrBadConWrongArgDerivErrBadConIsGADTDerivErrBadConHasExistentialsDerivErrBadConHasConstraintsDerivErrBadConHasHigherRankTypeDeriveInstanceErrReasonDerivErrNotWellKindedDerivErrSafeHaskellGenericInstDerivErrDerivingViaWrongKindDerivErrNoEtaReduceDerivErrBootFileFoundDerivErrDataConsNotAllInScopeDerivErrGNDUsedOnDataDerivErrNullaryClassesDerivErrLastArgMustBeAppDerivErrNoFamilyInstanceDerivErrNotStockDeriveableDerivErrHasAssociatedDatatypes!DerivErrNewtypeNonDeriveableClassDerivErrCannotEtaReduceEnoughDerivErrOnlyAnyClassDeriveableDerivErrNotDeriveableDerivErrNotAClassDerivErrNoConstructorsDerivErrLangExtRequiredDerivErrDunnoHowToDeriveForTypeDerivErrMustBeEnumType%DerivErrMustHaveExactlyOneConstructorDerivErrMustHaveSomeParametersDerivErrMustNotHaveClassContextDerivErrBadConstructorDerivErrGenericsDerivErrEnumOrProductDeriveAnyClassEnabledYesDeriveAnyClassEnabledNoDeriveAnyClassEnabledUsingGeneralizedNewtypeDerivingYesGeneralizedNewtypeDerivingNoGeneralizedNewtypeDerivingSuggestPartialTypeSignaturesYesSuggestPartialTypeSignaturesNoSuggestPartialTypeSignaturesNotClosedReasonNotLetBoundReason NotTypeClosed NotClosedSuggestUndecidableInstancesYesSuggestUndecidableInstacesNoSuggestUndecidableInstacesHasKinds YesHasKinds NoHasKindsInjectivityErrReasonInjErrRhsBareTyVarInjErrRhsCannotBeATypeFamInjErrRhsOverlapInjErrCannotInferFromRhsFixedRuntimeRepProvenanceFixedRuntimeRepDataConFieldFixedRuntimeRepPatSynSigArgFixedRuntimeRepPatSynSigResShadowedNameProvenanceShadowedNameProvenanceLocalShadowedNameProvenanceGlobalRecordFieldPartRecordFieldConstructorRecordFieldPatternRecordFieldUpdate ArgOrResultResultUnsupportedCallConventionStdCallConvUnsupportedPrimCallConvUnsupportedJavaScriptCallConvUnsupportedExpectedBackends COrAsmOrLlvmCOrAsmOrLlvmOrInterp TcRnMessageTcRnUnknownMessageTcRnMessageWithInfoTcRnSolverReportTcRnRedundantConstraintsTcRnInaccessibleCode"TcRnTypeDoesNotHaveFixedRuntimeRepTcRnImplicitLiftTcRnUnusedPatternBindsTcRnDodgyImportsTcRnDodgyExportsTcRnMissingImportListTcRnUnsafeDueToPluginTcRnModMissingRealSrcSpanTcRnIdNotExportedFromModuleSigTcRnIdNotExportedFromLocalSigTcRnShadowedNameTcRnDuplicateWarningDeclsTcRnSimplifierTooManyIterationsTcRnIllegalPatSynDeclTcRnLinearPatSynTcRnEmptyRecordUpdateTcRnIllegalFieldPunningTcRnIllegalWildcardsInRecordTcRnIllegalWildcardInTypeTcRnDuplicateFieldNameTcRnIllegalViewPatternTcRnCharLiteralOutOfRange!TcRnIllegalWildcardsInConstructorTcRnIgnoringAnnotationsTcRnAnnotationInSafeHaskellTcRnInvalidTypeApplicationTcRnTagToEnumMissingValArgTcRnTagToEnumUnspecifiedResTyTcRnTagToEnumResTyNotAnEnum(TcRnArrowIfThenElsePredDependsOnResultTyTcRnIllegalHsBootFileDeclTcRnRecursivePatternSynonymTcRnPartialTypeSigTyVarMismatchTcRnPartialTypeSigBadQuantifierTcRnMissingSignatureTcRnPolymorphicBinderMissingSigTcRnOverloadedSigTcRnTupleConstraintInstTcRnAbstractClassInstTcRnNoClassInstHeadTcRnUserTypeErrorTcRnConstraintInKind TcRnUnboxedTupleOrSumTypeFuncArgTcRnLinearFuncInKindTcRnForAllEscapeErrorTcRnVDQInTermTypeTcRnBadQuantPredHeadTcRnIllegalTupleConstraintTcRnNonTypeVarArgInConstraintTcRnIllegalImplicitParam"TcRnIllegalConstraintSynonymOfKindTcRnIllegalClassInstTcRnOversaturatedVisibleKindArgTcRnBadAssociatedTypeTcRnForAllRankErrTcRnMonomorphicBindingsTcRnFunDepConflictTcRnDupInstanceDeclsTcRnConflictingFamInstDeclsTcRnFamInstNotInjectiveTcRnBangOnUnliftedTypeTcRnMultipleDefaultDeclarationsTcRnBadDefaultTypeTcRnPatSynBundledWithNonDataConTcRnPatSynBundledWithWrongTypeTcRnDupeModuleExportTcRnExportedModNotImportedTcRnNullExportedModuleTcRnMissingExportListTcRnExportHiddenComponentsTcRnDuplicateExportTcRnExportedParentChildMismatchTcRnConflictingExportsTcRnAmbiguousFieldTcRnMissingFieldsTcRnFieldUpdateInvalidTypeTcRnNoConstructorHasAllFieldsTcRnMixedSelectorsTcRnMissingStrictFieldsTcRnNoPossibleParentForFieldsTcRnBadOverloadedRecordUpdateTcRnStaticFormNotClosedTcRnSpecialClassInstTcRnUselessTypeableTcRnDerivingDefaultsTcRnNonUnaryTypeclassConstraintTcRnPartialTypeSignaturesTcRnCannotDeriveInstanceTcRnLazyGADTPatternTcRnArrowProcGADTPatternTcRnTypeEqualityOutOfScope!TcRnTypeEqualityRequiresOperatorsTcRnIllegalTypeOperatorTcRnGADTMonoLocalBindsTcRnNotInScopeTcRnUntickedPromotedThingTcRnIllegalBuiltinSyntaxTcRnWarnDefaultingTcRnForeignImportPrimExtNotSetTcRnForeignImportPrimSafeAnn TcRnForeignFunctionImportAsValue TcRnFunPtrImportWithoutAmpersandTcRnIllegalForeignDeclBackendTcRnUnsupportedCallConvTcRnIllegalForeignTypeTcRnInvalidCIdentifierTcRnMessageDetailedErrInfoerrInfoContexterrInfoSupplementarypprFixedRuntimeRepProvenancehasKindssuggestUndecidableInstancessuggestPartialTypeSignaturesusingGeneralizedNewtypeDerivingderiveAnyClassEnabled hasWildcardhasAssociatedDataFamInstsassociatedTyLastVarInKind!associatedTyNotParamOverLastTyVar getUserGivenserrorItemOriginerrorItemEqRelerrorItemCtLoc errorItemPreddiscardProvCtxtGivensmkTcRnNotInScopemkTcReportWithInfonoValidHoleFitspprRelevantBindings$fOutputableExported$fOutputableErrorItem$fMonoidSolverReport$fSemigroupSolverReport%$fEqAssociatedTyNotParamOverLastTyVar$fEqAssociatedTyLastVarInKind$fEqHasAssociatedDataFamInsts$fEqHasWildcard$fEqDeriveAnyClassEnabled#$fEqUsingGeneralizedNewtypeDeriving"$fShowSuggestPartialTypeSignatures $fEqSuggestPartialTypeSignatures!$fShowSuggestUndecidableInstances$fEqSuggestUndecidableInstances$fShowHasKinds $fEqHasKinds$fEqUnsupportedCallConvention$fEqExpectedBackends ModSummaryms_mod ms_hsc_src ms_location ms_hs_hash ms_obj_datems_dyn_obj_date ms_iface_date ms_hie_date ms_srcimpsms_textual_impsms_ghc_prim_import ms_parsed_mod ms_hspp_file ms_hspp_opts ms_hspp_buf ms_unitidms_installed_mod ms_mod_namems_impsms_plugin_impsms_home_srcimps ms_home_imps msHsFilePath msHiFilePathmsDynHiFilePath msObjFilePathmsDynObjFilePath isBootSummaryms_mnwibmsDeps findTarget$fOutputableModSummary ModNodeKey SummaryNode ModuleGraphModNodeKeyWithUid mnkModuleName mnkUnitIdNodeKey NodeKey_UnitNodeKey_Module NodeKey_LinkModuleGraphNodeInstantiationNode ModuleNodeLinkNodemoduleGraphNodeModulemoduleGraphNodeModSummoduleGraphNodeUnitId nodeKeyUnitIdmapMGunionMG mgTransDepsmgModSummariesmgModSummaries'mgLookupModuleemptyMGisTemplateHaskellOrQQNonBootextendMG extendMGInst extendMG' mkModuleGraphfilterToposortToModules showModMsgsummaryNodeSummarynodeDependenciesmoduleGraphNodes mkNodeKeymsKey$fOutputableModNodeKeyWithUid$fOutputableNodeKey$fOrdModuleGraphNode$fEqModuleGraphNode$fOutputableModuleGraphNode$fFunctorNodeMap$fTraversableNodeMap$fFoldableNodeMap $fEqNodeKey $fOrdNodeKey$fEqModNodeKeyWithUid$fOrdModNodeKeyWithUidWhetherHasFamInstWhetherHasOrphans IfaceExport ModIface_ModIface mi_module mi_sig_of mi_hsc_srcmi_deps mi_usages mi_exports mi_used_th mi_fixitiesmi_warnsmi_annsmi_decls mi_globalsmi_insts mi_fam_instsmi_rulesmi_hpcmi_trust mi_trust_pkgmi_complete_matchesmi_docs mi_final_exts mi_ext_fields mi_src_hashIfaceBackendExts IfaceDeclExtsModIfaceBackend mi_iface_hash mi_mod_hash mi_flag_hash mi_opt_hash mi_hpc_hashmi_plugin_hash mi_orphan mi_finsts mi_exp_hashmi_orphan_hash mi_warn_fn mi_fix_fn mi_hash_fnPartialModIfacemi_bootmi_mnwibmi_fixmi_semantic_module mi_free_holesrenameFreeHolesemptyPartialModIfaceemptyFullModIfacemkIfaceHashCacheemptyIfaceHashCache forceModIface$fNFDataModIfaceBackend$fNFDataModIface_$fBinaryModIface_HomePackageTable HomeModInfohm_iface hm_details hm_linkableemptyHomePackageTable lookupHptlookupHptDirectlyeltsHpt filterHptallHptanyHptmapHpt delFromHptaddToHptaddHomeModInfoToHpt addListToHpt listToHpt listHMIToHptlookupHptByModulepprHPTHscBackendAction HscUpdate HscRecomp hscs_gutshscs_mod_locationhscs_partial_ifacehscs_old_iface_hashHscRecompStatus HscUpToDateHscRecompNeeded$fOutputableHscBackendActionEpsStats n_ifaces_in n_decls_in n_decls_out n_rules_in n_rules_out n_insts_in n_insts_outExternalPackageStateEPS eps_is_booteps_PITeps_free_holeseps_PTE eps_inst_enveps_fam_inst_env eps_rule_base eps_ann_enveps_complete_matcheseps_mod_fam_inst_env eps_statsExternalUnitCacheeuc_epsPackageIfaceTablePackageCompleteMatchesPackageFamInstEnvPackageInstEnvPackageRuleBasePackageTypeEnvemptyPackageIfaceTableinitExternalUnitCacheinitExternalPackageState addEpsInStats UnitEnvGraph unitEnv_graph HomeUnitGraph HomeUnitEnvhomeUnitEnv_unitshomeUnitEnv_unit_dbshomeUnitEnv_dflagshomeUnitEnv_hpthomeUnitEnv_home_unitUnitEnvue_epsue_current_unitue_home_unit_graph ue_platform ue_namever initUnitEnvunsafeGetHomeUnit updateHpt updateHugue_transitiveHomeDepspreloadUnitsInfo'preloadUnitsInfo mkHomeUnitEnvisUnitEnvInstalledModulelookupHugByModulehugEltsaddHomeModInfoToHug lookupHugunitEnv_insertunitEnv_deleteunitEnv_adjustunitEnv_mapWithKey unitEnv_newunitEnv_singleton unitEnv_mapunitEnv_memberunitEnv_lookup_maybeunitEnv_lookup unitEnv_keys unitEnv_elts unitEnv_hptsunitEnv_foldWithKeyue_units ue_setUnits ue_unit_dbs ue_setUnitDbsue_hpt ue_setFlagsue_setUnitFlags ue_unitFlags ue_homeUnitue_unsafeHomeUnitue_unitHomeUnitue_currentHomeUnitEnvue_setActiveUnitue_currentUnitue_findHomeUnitEnvue_updateHomeUnitEnvue_renameUnitIdassertUnitEnvInvariant$fOutputableHomeUnitEnv$fOutputableUnitEnvGraph$fFunctorUnitEnvGraph$fFoldableUnitEnvGraph$fTraversableUnitEnvGraphmkPrintUnqualified mkQualModule mkQualPackagepkgQualMetaHook MetaResult MetaRequestMetaEMetaPMetaTMetaDMetaAW metaRequestE metaRequestP metaRequestT metaRequestD metaRequestAWFileHeaderPragmaType OptionsPrag IncludePrag LanguagePragDocOptionsPragTransLayoutReasonTransLayout_WhereTransLayout_PipeCmmParserErrorCmmUnknownPrimitiveCmmUnknownMacroCmmUnknownCConvCmmUnrecognisedSafetyCmmUnrecognisedHintLexErrLexErrorLexUnknownPragmaLexErrorInPragmaLexNumEscapeRangeLexStringCharLitLexStringCharLitEOFLexUnterminatedCommentLexUnterminatedOptionsLexUnterminatedQQ LexErrKindLexErrKind_EOFLexErrKind_UTF8LexErrKind_CharNumUnderscoreReasonNumUnderscore_IntegralNumUnderscore_FloatPsErrInPatDetails PEIP_NegApp PEIP_TypeArgsPEIP_RecPatternPEIP_OtherPatDetails ParseContextis_infixincomplete_do_blockPatIncompleteDoBlockYesIncompleteDoBlockNoIncompleteDoBlockPatIsRecursiveYesPatIsRecursiveNoPatIsRecursivePsErrParseDetailsped_th_enabledped_do_in_last_100ped_mdo_in_last_100ped_pat_syn_enabledped_pattern_parsed PsMessagePsUnknownMessagePsHeaderMessagePsWarnBidirectionalFormatCharsPsWarnTransitionalLayoutPsWarnUnrecognisedPragmaPsWarnMisplacedPragmaPsWarnHaddockInvalidPosPsWarnHaddockIgnoreMulti#PsWarnOperatorWhitespaceExtConflictPsErrLambdaCasePsErrEmptyLambdaPsErrNumUnderscoresPsErrPrimStringInvalidCharPsErrMissingBlock PsErrLexer PsErrSuffixAT PsErrParse PsErrCmmLexerPsErrUnsupportedBoxedSumExprPsErrUnsupportedBoxedSumPat#PsErrUnexpectedQualifiedConstructorPsErrTupleSectionInPatPsErrIllegalBangPatternPsErrOpFewArgsPsErrImportQualifiedTwicePsErrImportPostQualifiedPsErrIllegalExplicitNamespacePsErrVarForTyConPsErrIllegalPatSynExportPsErrMalformedEntityStringPsErrDotsInRecordUpdatePsErrPrecedenceOutOfRangePsErrOverloadedRecordDotInvalid%PsErrOverloadedRecordUpdateNotEnabled,PsErrOverloadedRecordUpdateNoQualifiedFieldsPsErrInvalidDataConPsErrInvalidInfixDataCon!PsErrIllegalPromotionQuoteDataConPsErrUnpackDataConPsErrUnexpectedKindAppInDataConPsErrInvalidRecordConPsErrIllegalUnboxedStringInPat#PsErrIllegalUnboxedFloatingLitInPatPsErrDoNotationInPatPsErrIfThenElseInPatPsErrLambdaCaseInPatPsErrCaseInPat PsErrLetInPatPsErrLambdaInPatPsErrArrowExprInPatPsErrArrowCmdInPatPsErrArrowCmdInExprPsErrViewPatInExprPsErrTypeAppWithoutSpacePsErrLazyPatWithoutSpacePsErrBangPatWithoutSpacePsErrUnallowedPragmaPsErrQualifiedDoInCmdPsErrInvalidInfixHolePsErrSemiColonsInCondExprPsErrSemiColonsInCondCmdPsErrAtInPatPosPsErrLambdaCmdInFunAppCmdPsErrCaseCmdInFunAppCmdPsErrLambdaCaseCmdInFunAppCmdPsErrIfCmdInFunAppCmdPsErrLetCmdInFunAppCmdPsErrDoCmdInFunAppCmdPsErrDoInFunAppExprPsErrMDoInFunAppExprPsErrLambdaInFunAppExprPsErrCaseInFunAppExprPsErrLambdaCaseInFunAppExprPsErrLetInFunAppExprPsErrIfInFunAppExprPsErrProcInFunAppExprPsErrMalformedTyOrClDeclPsErrIllegalWhereInDataDeclPsErrIllegalDataTypeContextPsErrParseErrorOnInputPsErrMalformedDeclPsErrUnexpectedTypeAppInDeclPsErrNotADataConPsErrRecordSyntaxInPatSynDeclPsErrEmptyWhereInPatSynDecl!PsErrInvalidWhereBindInPatSynDecl"PsErrNoSingleWhereBindInPatSynDeclPsErrDeclSpliceNotAtTopLevelPsErrInferredTypeVarNotAllowed+PsErrMultipleNamesInStandaloneKindSignaturePsErrIllegalImportBundleFormPsErrUnexpectedTypeInDeclPsErrExpectedHyphenPsErrSpaceInSCCPsErrInvalidPackageName PsErrInvalidRuleActivationMarkerPsErrLinearFunctionPsErrMultiWayIfPsErrExplicitForallPsErrIllegalQualifiedDoPsErrCmmParser#PsErrIllegalTraditionalRecordSyntaxPsErrParseErrorInCmd PsErrInPatPsErrParseRightOpSectionInPat"PsErrIllegalGadtRecordMultiplicityPsErrInvalidCApiImportPsErrParseLanguagePragmaPsErrUnsupportedExtPsErrParseOptionsPragmaPsErrUnknownOptionsPragmaPsError PsWarningnoParseContextincompleteDoBlockfromParseContext$fShowLexErrKind$fEqLexErrKind$fOrdLexErrKind$fShowNumUnderscoreReason$fEqNumUnderscoreReason$fOrdNumUnderscoreReason$fEqParseContext$fEqPatIncompleteDoBlockpsHeaderMessageDiagnosticpsHeaderMessageReasonpsHeaderMessageHintssuggestParensAndBlockArgspp_unexpected_fun_appparse_error_in_pat forallSympprFileHeaderPragmaType$fDiagnosticPsMessage BindsTypeUnliftedTypeBinds StrictBindsExhaustivityCheckTypeNegLiteralExtEnabledYesUsingNegLiteralsNotUsingNegLiteralsThRejectionReasonThAmbiguousRecordUpdatesThAbstractClosedTypeFamilyThForeignLabelThForeignExportThMinimalPragmas ThSCCPragmasThNoUserInlineThExoticFormOfTypeThAmbiguousRecordSelectorsThMonadComprehensionSyntax ThCostCentresThExpressionFormThExoticStatementThExoticLiteralThExoticPatternThGuardedLambdasThNegativeOverloadedPatternsThHaddockDocumentationThWarningAndDeprecationPragmasThSplicesWithinDeclBracketsThNonLinearDataConDsArgNum DsMessageDsUnknownMessageDsEmptyEnumerationDsIdentitiesFoundDsOverflowedLiteralsDsRedundantBangPatternsDsOverlappingPatternsDsInaccessibleRhsDsNonExhaustivePatternsDsTopLevelBindsNotAllowed)DsUselessSpecialiseForClassMethodSelector&DsUselessSpecialiseForNoInlineFunction#DsMultiplicityCoercionsNotSupported DsOrphanRuleDsRuleLhsTooComplicatedDsRuleIgnoredDueToConstructorDsRuleBindersNotBoundDsMultipleConForNewtype#DsLazyPatCantBindVarsOfUnliftedTypeDsNotYetHandledByTHDsAggregatedViewExpressionsDsUnbangedStrictPatterns"DsCannotMixPolyAndUnliftedBindings DsWrongDoBindDsUnusedDoBind"DsRecBindsNotAllowedForUnliftedTysDsRuleMightInlineFirstDsAnotherRuleMightFireFirstMaxPmCheckModelsMaxUncoveredPatternsMaxBoundMinBoundnegLiteralExtEnabledBuildingCabalPackageYesBuildingCabalPackageNoBuildingCabalPackage DriverMessageDriverUnknownMessageDriverPsHeaderMessageDriverMissingHomeModulesDriverUnknownReexportedModulesDriverUnknownHiddenModulesDriverUnusedPackagesDriverUnnecessarySourceImports!DriverDuplicatedModuleDeclarationDriverModuleNotFoundDriverFileModuleNameMismatchDriverFileNotFound DriverStaticPointersNotSupportedDriverBackpackModuleNotFoundDriverUserDefinedRuleIgnoredDriverMixedSafetyImportDriverCannotLoadInterfaceFileDriverInferredSafeModule&DriverMarkedTrustworthyButInferredSafeDriverInferredSafeImportDriverCannotImportUnsafeModuleDriverMissingSafeHaskellModeDriverPackageNotTrusted&DriverCannotImportFromUntrustedPackageDriverRedirectedNoMainDriverHomePackagesNotClosedDriverMessages GhcMessage GhcPsMessageGhcTcRnMessage GhcDsMessageGhcDriverMessageGhcUnknownMessageWarnMsg ErrorMessagesWarningMessagesghcUnknownMessagehoistTcRnMessagehoistDsMessagecheckBuildingCabalPackage$fEqBuildingCabalPackageInteractiveImportIIDeclIIModuleInteractiveContext ic_dflags ic_mod_index ic_imports ic_tythings ic_gre_cache ic_instances ic_fix_env ic_default ic_resumeic_monad ic_int_printic_cwd ic_pluginsemptyInteractiveContext icReaderEnvicInteractiveModule icInScopeTTs icPrintUnqualextendInteractiveContextextendInteractiveContextWithIdssetInteractivePrintNamereplaceImportEnvsubstInteractiveContext$fOutputableInteractiveImportHscEnv hsc_dflags hsc_targets hsc_mod_graphhsc_IChsc_NChsc_FChsc_type_env_vars hsc_interp hsc_plugins hsc_unit_env hsc_logger hsc_hooks hsc_tmpfs$fContainsDynFlagsHscEnv$fHasLoggerHsc$fHasDynFlagsHsc $fFunctorHsc$fApplicativeHsc $fMonadHsc $fMonadIOHsc!pprTypeDoesNotHaveFixedRuntimeRep pprScopeErrortidySkolemInfotidySkolemInfoAnonwithHsDocContextinHsDocContextpprHsDocContext$fOutputableImportError$fOutputableSolverReportErrCtxt$fDiagnosticTcRnMessage badMonadBindpprEqn pprContextdots$fDiagnosticDsMessagesuggestInstantiatedWith$fDiagnosticDriverMessage$fDiagnosticGhcMessagemkSrcErrsrcErrorMessages throwErrors throwOneErrorhandleSourceError$fExceptionSourceError$fShowSourceError printMessageshandleFlagWarningsprintOrThrowDiagnosticsmkDriverPsHeaderMessagerunHscrunHsc'mkInteractiveHscEnvrunInteractiveHsc hsc_home_unithsc_home_unit_maybe hsc_unitshsc_HPThsc_HUEhsc_HUGhsc_all_home_unit_ids hscUpdateHPT hscUpdateHUGhscEPShptCompleteSigshptAllInstanceshptInstancesBelowhptRuleshptAnns hptAllThingshptSomeThingsBelowUsprepareAnnotations lookupTypelookupIfaceByModule mainModIs hscInterphscUpdateLoggerFlagshscUpdateFlags hscSetFlagshscSetActiveHomeUnithscSetActiveUnitIdhscActiveUnitId discardIC WarnErrLoggerGhcTunGhcTGhcunGhcGhcMonad getSession setSession withSessiongetSessionDynFlags modifySessionmodifySessionMwithTempSession modifyLogger pushLogHookM popLogHookMputMsgM putLogMsgM withTimingMlogDiagnostics reflectGhcreifyGhcliftGhcTprintExceptiondefaultWarnErrLogger $fGhcMonadGhc$fHasLoggerGhc$fHasDynFlagsGhc $fMonadFixGhc $fMonadIOGhc $fMonadGhc$fApplicativeGhc$fGhcMonadGhcT$fHasLoggerGhcT$fHasDynFlagsGhcT $fMonadIOGhcT $fMonadGhcT$fApplicativeGhcT $fFunctorGhcT$fMonadThrowGhcT$fMonadCatchGhcT$fMonadMaskGhcT $fFunctorGhc$fMonadThrowGhc$fMonadCatchGhc$fMonadMaskGhcPreInlineUnconditionallyPostInlineUnconditionally UnfoldingDone RuleFiredLetFloatFromLet EtaExpansion EtaReduction BetaReduction CaseOfCase KnownBranch CaseMergeAltMergeCaseElim CaseIdentityFillInCaseDefaultSimplifierDoneCorePluginPassfloatOutLambdasfloatOutConstantsfloatOutOverSatAppsfloatToTopLevelOnly SimplModesm_namessm_phase sm_uf_optssm_rules sm_inline sm_case_case sm_eta_expandsm_cast_swizzle sm_pre_inline sm_logger sm_dflagsCoreDoSimplifyCoreDoPluginPassCoreDoFloatInwardsCoreDoFloatOutwardsCoreLiberateCaseCoreDoPrintCoreCoreDoStaticArgsCoreDoCallArity CoreDoExitify CoreDoDemand CoreDoCprCoreDoWorkerWrapperCoreDoSpecialisingCoreDoSpecConstrCoreCSECoreDoRuleCheck CoreDoNothing CoreDoPasses CoreDesugarCoreDesugarOptCoreTidyCorePrepCoreAddCallerCcsCoreAddLateCcs CoreOccurAnalpprPassDetailsrunWhenrunMaybe bindsOnlyPass simplCountNzeroSimplCountisZeroSimplCounthasDetailedCountsdoFreeSimplTick doSimplTickplusSimplCount pprSimplCountrunCoreMliftIOWithCount getHscEnv getRuleBasegetVisibleOrphanModsgetPrintUnqualified getSrcSpanM addSimplCount getUniqMaskgetPackageFamInstEnvgetAnnotationsgetFirstAnnotationsmsgputMsgS errorMsgSfatalErrorMsgSdebugTraceMsgS$fOutputableSimplMode$fOutputableFloatOutSwitches $fOrdTick$fEqTick$fOutputableTick$fHasModuleCoreM$fHasLoggerCoreM$fHasDynFlagsCoreM$fMonadIOCoreM$fMonadUniqueCoreM$fMonadPlusCoreM$fAlternativeCoreM$fApplicativeCoreM $fMonadCoreM$fOutputableCoreToDo$fFunctorCoreM ccfModuleName ccfFuncName NamePatternPChar PWildcardPEndaddCallerCostCentres$fBinaryNamePattern$fOutputableNamePattern$fBinaryCallerCcFilter$fOutputableCallerCcFilterendPass endPassIOdumpPassResultlintPassResultdisplayLintResultslintInteractiveExprinteractiveInScopelintCoreBindings lintUnfoldinglintExpr lintAxioms lintAnnots$fHasDynFlagsLintM$fMonadFailLintM $fMonadLintM$fApplicativeLintM$fFunctorLintM$fEqStaticPtrCheckTHDocsDocLocDeclDocArgDocInstDoc ModuleDoc RoleAnnotEnvDefaultingPlugin dePluginInit dePluginRun dePluginStopFillDefaultingDefaultingPluginResultDefaultingProposaldeProposalTyVardeProposalCandidates deProposalCtsTcPluginRewriteResultTcPluginNoRewriteTcPluginRewriteTotcPluginReductiontcRewriterNewWantedsTcPluginSolveResulttcPluginInsolubleCtstcPluginSolvedCtstcPluginNewCtsTcPlugin tcPluginInit tcPluginSolvetcPluginRewrite tcPluginStop TcPluginM runTcPluginMTcPluginRewriterTcPluginSolver TcPatSynInfoTPSI patsig_namepatsig_implicit_bndrspatsig_univ_bndrs patsig_reqpatsig_ex_bndrs patsig_provpatsig_body_ty TcIdSigInstTISI sig_inst_sigsig_inst_skolssig_inst_theta sig_inst_tau sig_inst_wcs sig_inst_wcx CompleteSig PartialSigsig_bndrsig_ctxtsig_loc psig_name psig_hs_ty TcSigInfoTcIdSig TcPatSynSigTcSigFun WhereFrom ImportByUserImportBySystemImportByPlugin ClosedTypeIdRhsNames IsGroupClosed IdBindingInfo NotLetBound ClosedLet NonClosedLet PromotionErrTyConPEClassPE FamDataConPEConstrainedDataConPEPatSynPE RecDataConPE NoDataKindsDC TcTyThingAGlobalATcIdATyVarATcTyCon APromotionErrtct_idtct_info ArrowCtxt NoArrowCtxtThLevel PendingStuffRnPendingUntypedRnPendingTyped TcPendingThStageSplice RunSpliceCompBrack SpliceTypeTypedUntypedTcBinderTcIdBndrTcIdBndr_ExpTypeTcTvBndr TcBinderStackTcIdSetTcIdTcRef ThBindEnv TcTypeEnvErrCtxttcl_loctcl_ctxttcl_in_gen_code tcl_tclvl tcl_th_ctxt tcl_th_bndrstcl_arrow_ctxttcl_rdrtcl_env tcl_usage tcl_bndrstcl_lietcl_errs NoSelfBootSelfBootsb_mdssb_tcs RecFieldEnvtcg_modtcg_semantic_modtcg_src tcg_rdr_env tcg_default tcg_fix_env tcg_field_env tcg_type_env tcg_inst_envtcg_fam_inst_env tcg_ann_env tcg_exports tcg_importstcg_dus tcg_used_grestcg_keep tcg_th_usedtcg_th_splice_usedtcg_th_needed_deps tcg_dfun_n tcg_mergedtcg_rn_exportstcg_rn_imports tcg_rn_declstcg_dependent_filestcg_th_topdeclstcg_th_foreign_filestcg_th_topnamestcg_th_modfinalizerstcg_th_coreplugins tcg_th_statetcg_th_remote_state tcg_th_docs tcg_ev_binds tcg_tr_module tcg_bindstcg_sigs tcg_imp_specs tcg_warnstcg_annstcg_tcs tcg_ksigs tcg_insts tcg_fam_insts tcg_rules tcg_fords tcg_patsyns tcg_doc_hdrtcg_hpc tcg_self_boottcg_maintcg_safe_infertcg_safe_infer_reasonstcg_tc_plugin_solverstcg_tc_plugin_rewriterstcg_defaulting_pluginstcg_hf_plugins tcg_top_loc tcg_static_wctcg_complete_matches tcg_cc_sttcg_next_wrapper_numFrontendResultFrontendTypecheckIfLclEnvif_modif_bootif_loc if_nsubstif_implicits_env if_tv_env if_id_envIfGblEnvif_doc if_rec_types RewriteEnvREre_loc re_flavour re_eq_rel re_rewritersEnvenv_topenv_umenv_gblenv_lclTcMRnMIfLIfGIfMTcRnTcRnIf NameShape ns_mod_name ns_exportsns_map TcPluginOkTcPluginContradictiontcVisibleOrphanMods bootExports pushErrCtxtpushErrCtxtSameOriginremoveBindingShadowing getPlatformtopStage topAnnStagetopSpliceStageimpLevel outerLevelthLeveltcTyThingTyCon_maybepprTcTyThingCategorytcTyThingCategory pprPECategory peCategory mkModDepsemptyImportAvailsplusImportAvails isPartialSighasCompleteSigunsafeTcPluginTcMmkRoleAnnotEnvemptyRoleAnnotEnvlookupRoleAnnot getRoleAnnots lintGblEnv$fContainsModuleEnv$fContainsLoggerEnv$fContainsHooksEnv$fContainsDynFlagsEnv$fHasOccNameTcBinder$fOutputableTcBinder$fOutputableThStage$fOutputablePromotionErr$fOutputableIdBindingInfo$fOutputableTcTyThing$fOutputableWhereFrom$fOutputableTcIdSigInfo$fOutputableTcIdSigInst$fOutputableTcPatSynInfo$fOutputableTcSigInfo$fOutputableDefaultingProposal$fContainsModuleTcGblEnv$fFunctorTcPluginM$fApplicativeTcPluginM$fMonadTcPluginM$fMonadFailTcPluginM $fEqDocLoc $fOrdDocLocHoleFitPluginR hfPluginInit hfPluginRun hfPluginStop candPlugin fitPlugin FitPlugin CandPlugin TypedHoleth_relevant_cts th_implicsth_holepprHoleFitCandhfIsLcl$fOutputableTypedHole$fOrdHoleFitCandidate$fHasOccNameHoleFitCandidate$fNamedThingHoleFitCandidate$fOutputableHoleFitCandidate$fEqHoleFitCandidate $fOrdHoleFit$fOutputableHoleFit $fEqHoleFit PhaseHookTPhaseT_Unlit T_FileArgsT_CppT_HsPp T_HscRecompT_Hsc T_HscPostTc T_HscBackendT_CmmCppT_CmmT_CcT_As T_LlvmOpt T_LlvmLlc T_LlvmMangleT_MergeForeigndsForeignsHooktcForeignImportsHooktcForeignExportsHookhscFrontendHookhscCompileCoreExprHookghcPrimIfaceHook runPhaseHook runMetaHooklinkHookrunRnSpliceHookgetValueSafelyHookcreateIservProcessHook stgToCmmHookcmmToRawCmmHookDsForeignsHookfrontendFrontendPluginAction staticPlugins loadedPluginsloadedPluginDeps CorePluginPluginRecompileForceRecompileNoForceRecompileMaybeRecompilespPluginlpPluginlpModulePluginWithArgspaPlugin paArgumentsinstallCoreToDostcPlugindefaultingPlugin holeFitPlugin driverPluginpluginRecompileparsedResultActionrenamedResultActiontypeCheckResultActionspliceRunActioninterfaceLoadAction ParsedResultparsedResultModuleparsedResultMessages PsMessages psWarningspsErrorsCommandLineOption lpModuleNamepluginRecompile' purePlugin impurePlugin flagRecompile defaultPluginkeepRenamedSourcepluginsWithArgs withPlugins mapPlugins withPlugins_defaultFrontendPlugin$fMonoidPluginRecompile$fSemigroupPluginRecompile$fOutputablePluginRecompile initBangOptsis_ident is_symbolis_anyis_spaceis_loweris_upperis_digit is_alphanumhexDigit octDecDigit is_decdigit is_hexdigit is_octdigit is_bindigit condNegate condUnsignedmemoiseUniqueFunnodeId nodeClass nodeColor nodeConflictsnodeExclusionsnodePreference nodeCoalescegraphMapTriv initGraphgraphMapModifynewNodeStackMapstackMapNextFreeSlotstackMapAssignment StackSlot emptyStackMapgetStackSlotFor getStackUseRegSubSubL16SubL8SubL8HClassG32ClassG16ClassG8ClassF64worstboundsqueese $fShowRegSub $fEnumRegSub $fOrdRegSub $fEqRegSub$fShowRegClass$fEnumRegClass classOfReg regsOfClassregNameregAliastoRegMap toVRegMap dumpGraphdotGraph lookupNodegetNodeaddNodemodNodesize addConflict delConflict addConflicts addExclusion addExclusions addCoalesce delCoalesce addPreference coalesceGraph coalesceNodes freezeNodefreezeOneInGraphfreezeAllInGraph scanGraph validateGraphslurpNodeConflictCountsetColor colorGraph ppSourceStats sectionType SettingsErrorSettingsError_MissingDataSettingsError_BadData initSettings llvmFixupAsm trivColorable NCGConfig ncgPlatform ncgAsmContext ncgThisModulencgProcAlignmentncgExternalDynamicRefsncgPICncgInlineThresholdMemcpyncgInlineThresholdMemsetncgSplitSectionsncgRegsIterative ncgRegsGraph ncgAsmLintingncgDoConstantFolding ncgSseVersion ncgBmiVersionncgDumpRegAllocStagesncgDumpAsmStatsncgDumpAsmConflicts ncgCfgWeightsncgCfgBlockLayoutncgCfgWeightlessLayoutncgDwarfEnabledncgDwarfUnwindingsncgDwarfStripBlockInfoncgExposeInternalSymbolsncgDwarfSourceNotesncgCmmStaticPredncgEnableShortcuttingncgComputeUnwindingncgEnableDeadCodeElimination ncgWordWidthncgSpillPreallocSizeplatformWordWidth popCntLabel pdepLabel pextLabel bSwapLabel bRevLabelclzLabelctzLabelword2FloatLabelatomicRMWLabel xchgLabel cmpxchgLabelatomicReadLabelatomicWriteLabel StgLiftConfigc_targetProfilec_liftLamsRecArgsc_liftLamsNonRecArgsc_liftLamsKnown$fShowStgLiftConfig$fReadStgLiftConfig$fEqStgLiftConfig$fOrdStgLiftConfiginitStgLiftConfigBitmapmkBitmapintsToReverseBitmapmAX_SMALL_BITMAP_SIZE CmmConfig cmmProfilecmmOptControlFlow cmmDoLintingcmmOptElimCommonBlks cmmOptSinkcmmGenStackUnwindInstrcmmExternalDynamicRefscmmDoCmmSwitchPlanscmmSplitProcPoints cmmPlatform initCmmConfigfingerprintDynFlagsfingerprintOptFlagsfingerprintHpcFlagsnoWarnLookupIdSubstBlankEpAnnotationsNoBlankEpAnnotations BlankSrcSpanBlankSrcSpanFileNoBlankSrcSpanshowAstDataFull showAstData$fEqBlankEpAnnotations$fShowBlankEpAnnotations$fEqBlankSrcSpan$fShowBlankSrcSpanTyConSetisEmptyTyConSet emptyTyConSet unitTyConSet mkTyConSetextendTyConSetListextendTyConSet unionTyConSetunionTyConSets minusTyConSet elemTyConSetdelFromTyConSetfilterTyConSetintersectTyConSetdisjointTyConSetdelListFromTyConSetintersectsTyConSetinitStgToCmmConfiginitFinderOpts BuildMessageBuildMsg BuildErrorEOFenableProcessJobsreadCreateProcessWithExitCode' replaceVarreadProcessEnvWithExitCode c_locale_env getGccEnv runSomethingrunSomethingResponseFilerunSomethingFilteredrunSomethingWith handleProcbuilderMainLoop readerProc parseError breakColon breakIntColon linesPlatformneededLinkArgs getLinkerInfogetLinkerInfo'getCompilerInfogetAssemblerInfogetCompilerInfo'readElfSectionByNamereadElfNoteAsString makeElfNote LogQueueQueueLogQueue logQueueIdlogQueueMessageslogQueueSemaphore newLogQueuefinishLogQueue writeLogQueue parLogActionnewLogQueueQueue initLogQueue allLogQueues logThread mkUnarisedIds mkUnarisedIdmkStgAltTypeFromStgAlts bindersOfX bindersOfTopbindersOfTopBindsidArgsstripStgTicksTopstripStgTicksTopE showStgStats$fEqCounterType$fOrdCounterTypeTagEnvTEte_envte_get TagSigEnv InferStgAlt InferStgRhs InferStgExprInferStgBindingInferStgTopBindingcombineAltInfo getBinderIdinitEnv makeTaggednoSig lookupSig lookupInfo isDunnoSig isTaggedInfo extendSigEnv$fOutputableTagEnvrewriteTopBinds$fMonadUniqueRM $fFunctorRM $fMonadRM$fApplicativeRM inferTagsdepSortWithAnnotStgPgmannBindingFreeVars StgDebugOptsstgDebug_infoTableMap"stgDebug_distinctConstructorTablescollectDebugInformationinitStgDebugOptsinitStgPprOptsstgCse$fTrieMapStgArgMap$fTrieMapConAppMaptemplateHaskellNamesthSynthLibqqLib mkTHModulelibFunlibTcthFunthTcthClsthConqqFun liftClassNamequoteClassName qTyConName nameTyConNamefieldExpTyConName patTyConNamefieldPatTyConName expTyConName decTyConName decsTyConName typeTyConNamematchTyConNameclauseTyConNamefunDepTyConName predTyConName codeTyConNameinjAnnTyConNameoverlapTyConNamemodNameTyConName returnQName bindQName sequenceQName newNameNameliftNameliftStringName mkNameName mkNameG_vName mkNameG_dNamemkNameG_tcName mkNameLName mkNameSName mkModNameName unTypeNameunTypeCodeNameunsafeCodeCoerceName liftTypedName charLName stringLName integerLName intPrimLName wordPrimLNamefloatPrimLNamedoublePrimLName rationalLNamestringPrimLName charPrimLNamelitPNamevarPNametupPNameunboxedTupPNameunboxedSumPNameconPName infixPName tildePName bangPNameasPName wildPNamerecPName listPNamesigPName viewPName fieldPatName matchName clauseNamevarENameconENamelitENameappEName appTypeEName infixEName infixAppName sectionLName sectionRNamelamEName lamCaseEName lamCasesENametupENameunboxedTupENameunboxedSumEName condEName multiIfENameletEName caseENamedoENamemdoEName compEName fromEName fromThenEName fromToENamefromThenToEName listENamesigEName recConEName recUpdEName staticENameunboundVarEName labelENameimplicitParamVarEName getFieldENameprojectionEName fieldExpName guardedBName normalBName normalGEName patGEName bindSNameletSName noBindSNameparSNamerecSNamefunDNamevalDName dataDName newtypeDName tySynDName classDNameinstanceWithOverlapDName standaloneDerivWithStrategyDNamesigDName kiSigDName defaultDNamedefaultSigDName forImpDName pragInlDNamepragOpaqueDName pragSpecDNamepragSpecInlDNamepragSpecInstDName pragRuleDNamepragCompleteDName pragAnnDName dataInstDNamenewtypeInstDNametySynInstDNameopenTypeFamilyDNameclosedTypeFamilyDNamedataFamilyDName infixLDName infixRDName infixNDNameroleAnnotDName patSynDNamepatSynSigDNameimplicitParamBindDNamecxtNamenoSourceUnpackednessNamesourceNoUnpackNamesourceUnpackNamenoSourceStrictnessNamesourceLazyNamesourceStrictName normalCNamerecCName infixCName forallCName gadtCName recGadtCNamebangName bangTypeNamevarBangTypeNameunidirPatSynNameimplBidirPatSynNameexplBidirPatSynNameprefixPatSynNameinfixPatSynNamerecordPatSynName forallTNameforallVisTNamevarTNameconTName tupleTNameunboxedTupleTNameunboxedSumTName arrowTName mulArrowTName listTNameappTName appKindTNamesigTName equalityTNamelitTName promotedTNamepromotedTupleTNamepromotedNilTNamepromotedConsTName wildCardTName infixTNameimplicitParamTName numTyLitName strTyLitName charTyLitName plainTVName kindedTVNameplainInvisTVNamekindedInvisTVNamespecifiedSpecNameinferredSpecName nominalRNamerepresentationalRName phantomRName inferRName starKNameconstraintKName noSigName kindSigName tyVarSigNameinjectivityAnnName cCallName stdCallName cApiCallName primCallNamejavaScriptCallName unsafeNamesafeNameinterruptibleName ruleVarNametypedRuleVarName funDepName tySynEqnNamevalueAnnotationNametypeAnnotationNamemoduleAnnotationNamederivClauseNamestockStrategyNameanyclassStrategyNamenewtypeStrategyNameviaStrategyName expQTyConNamedecsQTyConNametypeQTyConName patQTyConName stmtTyConName conTyConNamebangTypeTyConNamevarBangTypeTyConNameruleBndrTyConNametySynEqnTyConName roleTyConNamederivClauseTyConName kindTyConNametyVarBndrUnitTyConNametyVarBndrSpecTyConNamederivStrategyTyConName quoteExpName quotePatName quoteDecName quoteTypeNamenoInlineDataConNameinlineDataConNameinlinableDataConNameconLikeDataConNamefunLikeDataConNameallPhasesDataConNamefromPhaseDataConNamebeforePhaseDataConNameoverlappableDataConNameoverlappingDataConNameoverlapsDataConNameincoherentDataConName liftClassKey quoteClassKey expTyConKey matchTyConKeyclauseTyConKey qTyConKey expQTyConKey patTyConKey stmtTyConKey conTyConKey typeQTyConKey typeTyConKey decTyConKeybangTypeTyConKeyvarBangTypeTyConKeyfieldExpTyConKeyfieldPatTyConKey nameTyConKey patQTyConKeyfunDepTyConKey predTyConKey predQTyConKeytyVarBndrUnitTyConKey decsQTyConKeyruleBndrTyConKeytySynEqnTyConKey roleTyConKeyinjAnnTyConKey kindTyConKeyoverlapTyConKeyderivClauseTyConKeyderivStrategyTyConKey decsTyConKeytyVarBndrSpecTyConKey codeTyConKeymodNameTyConKeynoInlineDataConKeyinlineDataConKeyinlinableDataConKeyconLikeDataConKeyfunLikeDataConKeyallPhasesDataConKeyfromPhaseDataConKeybeforePhaseDataConKeyoverlappableDataConKeyoverlappingDataConKeyoverlapsDataConKeyincoherentDataConKey returnQIdKey bindQIdKeysequenceQIdKey liftIdKey newNameIdKey mkNameIdKeymkNameG_vIdKeymkNameG_dIdKeymkNameG_tcIdKey mkNameLIdKey mkNameSIdKey unTypeIdKeyunTypeCodeIdKeyliftTypedIdKeymkModNameIdKeyunsafeCodeCoerceIdKey charLIdKey stringLIdKey integerLIdKey intPrimLIdKeywordPrimLIdKeyfloatPrimLIdKeydoublePrimLIdKeyrationalLIdKeystringPrimLIdKeycharPrimLIdKeyliftStringIdKey litPIdKey varPIdKey tupPIdKeyunboxedTupPIdKeyunboxedSumPIdKey conPIdKey infixPIdKey tildePIdKey bangPIdKeyasPIdKey wildPIdKey recPIdKey listPIdKey sigPIdKey viewPIdKey fieldPatIdKey matchIdKey clauseIdKey varEIdKey conEIdKey litEIdKey appEIdKey appTypeEIdKey infixEIdKey infixAppIdKey sectionLIdKey sectionRIdKey lamEIdKey lamCaseEIdKeylamCasesEIdKey tupEIdKeyunboxedTupEIdKeyunboxedSumEIdKey condEIdKey multiIfEIdKey letEIdKey caseEIdKeydoEIdKey compEIdKey fromEIdKeyfromThenEIdKey fromToEIdKeyfromThenToEIdKey listEIdKey sigEIdKey recConEIdKey recUpdEIdKey staticEIdKeyunboundVarEIdKey labelEIdKeyimplicitParamVarEIdKey mdoEIdKeygetFieldEIdKeyprojectionEIdKey fieldExpIdKey guardedBIdKey normalBIdKey normalGEIdKey patGEIdKey bindSIdKey letSIdKey noBindSIdKey parSIdKey recSIdKey funDIdKey valDIdKey dataDIdKey newtypeDIdKey tySynDIdKey classDIdKeyinstanceWithOverlapDIdKeyinstanceDIdKey sigDIdKey forImpDIdKey pragInlDIdKeypragSpecDIdKeypragSpecInlDIdKeypragSpecInstDIdKeypragRuleDIdKey pragAnnDIdKeydataFamilyDIdKeyopenTypeFamilyDIdKeydataInstDIdKeynewtypeInstDIdKeytySynInstDIdKeyclosedTypeFamilyDIdKey infixLDIdKey infixRDIdKey infixNDIdKeyroleAnnotDIdKey!standaloneDerivWithStrategyDIdKeydefaultSigDIdKey patSynDIdKeypatSynSigDIdKeypragCompleteDIdKeyimplicitParamBindDIdKey kiSigDIdKey defaultDIdKeypragOpaqueDIdKeycxtIdKeynoSourceUnpackednessKeysourceNoUnpackKeysourceUnpackKeynoSourceStrictnessKey sourceLazyKeysourceStrictKey normalCIdKey recCIdKey infixCIdKey forallCIdKey gadtCIdKey recGadtCIdKey bangIdKeybangTKey varBangTKeyunidirPatSynIdKeyimplBidirPatSynIdKeyexplBidirPatSynIdKeyprefixPatSynIdKeyinfixPatSynIdKeyrecordPatSynIdKey forallTIdKeyforallVisTIdKey varTIdKey conTIdKey tupleTIdKeyunboxedTupleTIdKeyunboxedSumTIdKey arrowTIdKey listTIdKey appTIdKey appKindTIdKey sigTIdKeyequalityTIdKey litTIdKeypromotedTIdKeypromotedTupleTIdKeypromotedNilTIdKeypromotedConsTIdKeywildCardTIdKeyimplicitParamTIdKey infixTIdKey numTyLitIdKey strTyLitIdKeycharTyLitIdKey plainTVIdKey kindedTVIdKeyplainInvisTVIdKeykindedInvisTVIdKey nominalRIdKeyrepresentationalRIdKey phantomRIdKey inferRIdKey starKIdKeyconstraintKIdKey noSigIdKey kindSigIdKey tyVarSigIdKeyinjectivityAnnIdKey cCallIdKey stdCallIdKey cApiCallIdKey primCallIdKeyjavaScriptCallIdKey unsafeIdKey safeIdKeyinterruptibleIdKey funDepIdKeymulArrowTIdKey tySynEqnIdKey quoteExpKey quotePatKey quoteDecKey quoteTypeKey ruleVarIdKeytypedRuleVarIdKeyvalueAnnotationIdKeytypeAnnotationIdKeymoduleAnnotationIdKeyderivClauseIdKeystockStrategyIdKeyanyclassStrategyIdKeynewtypeStrategyIdKeyviaStrategyIdKeyspecifiedSpecKeyinferredSpecKeylift_RDR liftTyped_RDRunsafeCodeCoerce_RDR mkNameG_dRDR mkNameG_vRDRconE_RDRlitE_RDRappE_RDR infixApp_RDR stringL_RDR intPrimL_RDR wordPrimL_RDRfloatPrimL_RDRdoublePrimL_RDRstringPrimL_RDR charPrimL_RDRbcPrep FunDepEqnFDEqnfd_qtvsfd_eqsfd_pred1fd_pred2fd_locinstFDimproveFromAnother pprEquationimproveFromInstEnvcheckInstCoveragecloseWrtFunDeps checkFunDeps$fOutputableFunDepEqn$fFunctorFunDepEqnMonadPaddError addWarning addFatalErrorgetBitallocateCommentsPallocatePriorCommentsPallocateFinalCommentsPExtBitsFfiBitInterruptibleFfiBit CApiFfiBit ArrowsBitThBit ThQuotesBitIpBitOverloadedLabelsBitExplicitForallBit BangPatBitPatternSynonymsBit HaddockBit MagicHashBitRecursiveDoBitQualifiedDoBitUnicodeSyntaxBitUnboxedParensBitDatatypeContextsBitMonadComprehensionsBitTransformComprehensionsBitQqBitRawTokenStreamBitAlternativeLayoutRuleBitALRTransitionalBitRelaxedLayoutBitNondecreasingIndentationBitSafeHaskellBitTraditionalRecordSyntaxBitExplicitNamespacesBit LambdaCaseBitBinaryLiteralsBitNegativeLiteralsBitHexFloatLiteralsBitStaticPointersBitNumericUnderscoresBit StarIsTypeBitBlockArgumentsBitNPlusKPatternsBitDoAndIfThenElseBit MultiWayIfBit GadtSyntaxBitImportQualifiedPostBitLinearTypesBitNoLexicalNegationBitOverloadedRecordDotBitOverloadedRecordUpdateBit InRulePragBitInNestedCommentBitUsePosPragsBitPunPPStatebufferoptionswarningserrors tab_first tab_countlast_tkprev_loc prev_loc2last_loclast_lenloccontext lex_statesrcfilesalr_pending_implicit_tokensalr_next_token alr_last_loc alr_contextalr_expecting_ocurlyalr_justClosedExplicitLetBlockeof_posheader_comments comment_q hdk_comments HdkCommentHdkCommentNextHdkCommentPrevHdkCommentNamedHdkCommentSection ParserOpts pExtsBitmap pDiagOptspSupportedExts ParseResultTokenITasITcaseITclassITdata ITdefault ITderivingITdoITelseIThiding ITforeignITifITimportITinITinfixITinfixlITinfixr ITinstanceITletITmodule ITnewtypeITof ITqualifiedITthenITtypeITwhereITforallITexportITlabel ITdynamicITsafeITinterruptibleITunsafe ITstdcallconv ITccallconv ITcapiconvITprimcallconvITjavascriptcallconvITmdoITfamilyITroleITgroupITbyITusing ITpatternITstaticITstock ITanyclassITviaITunit ITsignature ITdependency ITrequires ITinline_prag ITopaque_prag ITspec_pragITspec_inline_prag ITsource_prag ITrules_pragITwarning_pragITdeprecated_prag ITline_prag ITcolumn_prag ITscc_prag ITunpack_pragITnounpack_prag ITann_pragITcomplete_prag ITclose_pragIToptions_pragITinclude_pragITlanguage_pragITminimal_pragIToverlappable_pragIToverlapping_pragIToverlaps_pragITincoherent_pragITctypeITcomment_line_pragITdotdotITcolonITdcolonITequalITlamITlcaseITlcasesITvbarITlarrowITrarrowITdarrowITlollyITminus ITprefixminusITbangITtildeITat ITtypeApp ITpercentITstarITdotITprojITbiglamITocurlyITccurly ITvocurly ITvccurlyITobrack ITopabrack ITcpabrackITcbrackIToparenITcparen IToubxparen ITcubxparenITsemiITcomma ITunderscore ITbackquote ITsimpleQuoteITvaridITconidITvarsymITconsymITqvaridITqconid ITqvarsym ITqconsym ITdupipvarid ITlabelvaridITcharITstring ITinteger ITrational ITprimchar ITprimstring ITprimint ITprimword ITprimfloat ITprimdoubleITopenExpQuoteITopenPatQuoteITopenDecQuoteITopenTypQuote ITcloseQuoteITopenTExpQuoteITcloseTExpQuoteITdollarITdollardollar ITtyQuote ITquasiQuote ITqQuasiQuoteITprocITrec IToparenbar ITcparenbar ITlarrowtail ITrarrowtail ITLarrowtail ITRarrowtail ITunknownITeof ITdocComment ITdocOptions ITlineCommentITblockCommentPFailedPOkwarnoptfailMsgP failLocMsgP getPState setSrcLoc getRealSrcLoc setLastToken adjustChar nextIsEOF pushLexState popLexState getLexState activeContextxtestxsetxunset mkParserOptsdisableHaddock initPragStateinitParserStategetCommentsForgetPriorCommentsForgetFinalCommentsFor getEofPos addPsMessagegetPsErrorMessages getPsMessages popContextpushModuleContext srcParseFaillexerlexerDbglexTokenStream mkParensEpAnnallocateCommentsallocatePriorCommentsallocateFinalCommentscommentToAnnotation$fOutputableToken$fMonadP$fApplicativeP $fFunctorP $fMonadPP $fEnumExtBits$fShowHdkComment$fShowLayoutContext $fShowTokenPV ImpExpQcSpec ImpExpQcName ImpExpQcTypeImpExpQcWildcard ImpExpSubSpec ImpExpAbs ImpExpAll ImpExpList ImpExpAllWithDisambTDmkHsAppTyHeadPV mkHsAppTyPVmkHsAppKindTyPV mkHsOpTyPVmkUnpackednessPV DisambECPInfixOpFunArg ecpFromCmd' ecpFromExp'mkHsProjUpdatePV mkHsLamPV mkHsLetPV superInfixOp mkHsOpAppPV mkHsCasePV mkHsLamCasePV superFunArg mkHsAppPV mkHsAppTypePVmkHsIfPVmkHsDoPV mkHsParPV mkHsVarPV mkHsLitPV mkHsOverLitPVmkHsWildCardPV mkHsTySigPVmkHsExplicitListPV mkHsSplicePV mkHsRecordPV mkHsNegAppPVmkHsSectionR_PV mkHsViewPatPV mkHsAsPatPV mkHsLazyPatPV mkHsBangPatPVmkSumOrTuplePVrejectPragmaPV DisambInfixOp mkHsVarOpPV mkHsConOpPVmkHsInfixHolePVFbindECPunECPUnpackednessPragma RuleTyTmVar LRuleTyTmVarmkTyClDmkInstD mkClassDeclmkTyData mkTySynonymmkStandaloneKindSigmkTyFamInstEqn mkDataFamInst mkTyFamInst mkFamDecl mkSpliceDeclmkRoleAnnotDeclfromSpecTyVarBndrsfromSpecTyVarBndrannBindsfixValbindsAnn cvTopDecls cvBindGroupmkPatSynMatchGroup mkConDeclH98 mkGadtDeclsetRdrNameSpace mkRuleBndrsmkRuleTyVarBndrscheckRuleTyVarBndrNamescheckRecordSyntaxcheckEmptyGADTscheckExpBlockArgumentscheckCmdBlockArguments checkContextcheckImportDecl checkPatterncheckPattern_detailsplaceHolderPunRhs checkValDefcheckValSigLhsmkBangTyaddUnpackednessPcheckMonadComp ecpFromExp ecpFromCmddataConBuilderCondataConBuilderDetails checkPrecPmkRecConstrOrUpdatemkRdrRecordUpdmkRdrRecordConmkInlinePragmamkOpaquePragmamkImport parseCImportmkExport mkExtNamemkModuleImpExp mkTypeImpExpcheckImportSpecmkImpExpSubSpecwarnPrepositiveQualifiedModule#failOpNotEnabledImportQualifiedPostfailOpImportQualifiedTwicewarnStarIsType failOpFewArgsrunPV hintBangPatmkMultTymkTokenLocationstarSym mkRdrGetFieldmkRdrProjection $fMonadPPV $fMonadPV$fApplicativePV $fFunctorPV$fDisambTDDataConBuilder$fDisambTDHsType$fDisambInfixOpRdrName$fDisambInfixOpHsExpr$fDisambECPPatBuilder$fDisambECPHsExpr$fDisambECPHsCmdconvertToHsDeclsconvertToHsExpr convertToPatconvertToHsTypethRdrNameGuesses $fMonadCvtM$fApplicativeCvtM$fCvtFlagSpecificitySpecificity $fCvtFlag()() $fFunctorCvtMlexStringLiterallexHsDocinitParserOpts extractDocsmkDocStructuremkDocStructureFromExportListmkDocStructureFromDeclsgetNamedChunksmkMapsgetMainDeclBinder sigNameNoLoc getInstLoc subordinates conArgDocs h98ConArgDocsgadtConArgDocs con_arg_docsisValD classDecls declTypeDocs nubByNametypeDocs sigTypeDocstopDeclsungroup collectDocs filterDecls filterClasses isUserSigmkDecls extractTHDocs unionArgMapsLiftM FloatLangStartBindingGroupEndBindingGroupPlainTopBinding LiftedBindinge_confige_subst e_expansionsdecomposeStgBinding mkStgBinding collectFloatsrunLiftM getConfigaddTopStringLitstartBindingGroupendBindingGroupaddLiftedBinding withSubstBndrwithSubstBndrswithLiftedBndrwithLiftedBndrssubstOccisLiftedformerFreeVars$fOutputableFloatLang$fMonadUniqueLiftM$fFunctorLiftM$fApplicativeLiftM $fMonadLiftM hsLPatType hsPatType hsLitType lhsExprType hsExprType hsWrapperType coreToStg$fHasDynFlagsCtsM $fMonadCtsM$fApplicativeCtsM $fFunctorCtsM $fEqHowBound $fEqLetInfo liberateCase doStaticArgsevDelayedError evCallStackunarise$fOutputableUnariseVal FloatSpecFloatMeStayPut LevelTypeBndrLvl JoinCeilLvlLevel LevelledBndr LevelledBind LevelledExprfloatSpecLevel tOP_LEVEL incMinorLvl asJoinCeilLvlltLvlltMajLvlisTopLvl isJoinCeilLvl setLevels $fEqLevel$fOutputableLevel$fOutputableFloatSpec $fEqLevelType floatInwardsexitifyProgram cseProgram cseOneExpr typeNatTyConstypeNatAddTyContypeNatSubTyContypeNatMulTyContypeNatDivTyContypeNatModTyContypeNatExpTyContypeNatLogTyContypeNatCmpTyContypeSymbolCmpTyContypeSymbolAppendTyContypeConsSymbolTyContypeUnconsSymbolTyContypeCharToNatTyContypeNatToCharTyContypeNatCoAxiomRulestypeCharCmpTyConDsM DsMetaValDsBoundDsSplice DsMetaEnvDsLclEnvdsl_metadsl_loc dsl_nablasDsGblEnvds_modds_fam_inst_envds_gbl_rdr_env ds_unqualds_msgs ds_if_envds_complete_matchesds_cc_stds_next_wrapper_num$fContainsModuleDsGblEnv InstructionregUsageOfInstrpatchRegsOfInstrisJumpishInstrjumpDestsOfInstrpatchJumpInstr mkSpillInstr mkLoadInstrtakeDeltaInstr isMetaInstrmkRegRegMoveInstrtakeRegRegMoveInstr mkJumpInstrmkStackAllocInstrmkStackDeallocInstrpprInstr mkCommentRegUsageRUwritesnoUsage$fShowRegUsagepprLit$fOutputablePenvGlobalReg$fOutputableGlobalReg$fOutputableArea$fOutputableLocalReg$fOutputablePPlatformCmmLit$fOutputableCmmReg$fOutputablePPlatformCmmExprLRegKeyLRegSet emptyLRegSet nullLRegSet insertLRegSet elemLRegSetdeleteFromLRegSet sizeLRegSet plusLRegSet elemsLRegSetEAIndex EAIndexNoneEABase EABaseNone EABaseReg EABaseRipAddrMode AddrBaseIndexImmAddrImmImmInt ImmIntegerImmCLblImmLitImmIndexImmFloat ImmDoubleImmConstantSumImmConstantDiffvirtualRegSqueezerealRegSqueeze strImmLitlitToImm addrOffset addrModeRegsspRelfirstxmmlastxmmlastintargRegs allMachRegNosclassOfRealRegshowRegeaxebxecxedxesiediebpespraxrbxrcxrdxrsirdirbprspr8r9r10r11r12r13r14r15xmm0xmm1xmm2xmm3xmm4xmm5xmm6xmm7xmm8xmm9xmm10xmm11xmm12xmm13xmm14xmm15ripRelxmmcallClobberedRegs allArgRegs allIntArgRegs allFPArgRegsinstrClobberedRegsallocatableRegsFreeRegs noFreeRegs releaseReg initFreeRegs getFreeRegs allocateReg$fShowFreeRegs$fOutputableFreeRegs entryBlocks NatBasicBlock NatCmmDeclNatCmm floatToBytes doubleToBytespprASCII pprString pprFileEmbedpprSectionHeader LlvmCastOpLM_TruncLM_ZextLM_Sext LM_FptruncLM_Fpext LM_Fptoui LM_Fptosi LM_Uitofp LM_Sitofp LM_Ptrtoint LM_Inttoptr LM_Bitcast LlvmCmpOp LM_CMP_Eq LM_CMP_Ne LM_CMP_Ugt LM_CMP_Uge LM_CMP_Ult LM_CMP_Ule LM_CMP_Sgt LM_CMP_Sge LM_CMP_Slt LM_CMP_Sle LM_CMP_Feq LM_CMP_Fne LM_CMP_Fgt LM_CMP_Fge LM_CMP_Flt LM_CMP_Fle LlvmMachOp LM_MO_Add LM_MO_Sub LM_MO_Mul LM_MO_UDiv LM_MO_SDiv LM_MO_URem LM_MO_SRem LM_MO_FAdd LM_MO_FSub LM_MO_FMul LM_MO_FDiv LM_MO_FRem LM_MO_Shl LM_MO_LShr LM_MO_AShr LM_MO_AndLM_MO_Or LM_MO_XorLlvmLinkageTypeInternalLinkOnceWeak Appending ExternWeakExternallyVisibleExternalPrivateLlvmParameterListType FixedArgsVarArgsLlvmCallConventionCC_Ccc CC_Fastcc CC_ColdccCC_GhcCC_Ncc CC_X86_Stdcc LlvmCallTypeStdCallTailCall LlvmFuncAttr AlwaysInline InlineHintOptSizeNoReturnNoUnwindReadNoneReadOnlySspSspReq NoRedZoneNoImplicitFloatNaked LlvmParamAttrZeroExtSignExtInRegByValSRetNoAlias NoCaptureNest LlvmParameterLlvmFunctionDeclsLlvmFunctionDecldecName funcLinkagefuncCc decReturnType decVarargs decParams funcAlign LlvmStatic LMComment LMStaticLit LMUninitType LMStaticStr LMStaticArray LMStaticStrucLMStaticStrucULMStaticPointerLMTruncLMBitcLMPtoILMAddLMSubLlvmLitLMIntLit LMFloatLit LMNullLit LMVectorLit LMUndefLitLlvmVar LMGlobalVar LMLocalVar LMNLocalVarLMLitVarLMConstGlobalConstantAliasLMAlign LMSectionLlvmTypeLMIntLMFloatLMDouble LMFloat80 LMFloat128 LMPointerLMArrayLMVectorLMLabelLMVoidLMStruct LMStructULMAlias LMMetadata LMFunction LlvmAliasLMStringLMGlobal getGlobalVargetGlobalValueppTypeppParams garbageLit getVarType getLitType getStatTypegetLinkpLiftpVarLiftpLower pVarLowerisIntisFloat isPointerisVectorisGloballlvmWidthInBitsi128i64i32i16i8i1i8PtrllvmWord llvmWordPtrppDoublenarrowFpwidenFpppFloat ppCommaJoin ppSpaceJoin$fOutputableLlvmParamAttr$fOutputableLlvmFuncAttr$fOutputableLlvmCallConvention$fOutputableLlvmLinkageType$fOutputableLlvmFunctionDecl$fOutputableLlvmType$fOutputableLlvmMachOp$fOutputableLlvmCmpOp$fOutputableLlvmCastOp$fEqLlvmCastOp $fEqLlvmCmpOp$fEqLlvmMachOp $fEqLlvmVar $fEqLlvmLit$fEqLlvmFunctionDecl $fEqLlvmType$fEqLlvmLinkageType$fEqLlvmParameterListType$fShowLlvmParameterListType$fEqLlvmCallConvention$fEqLlvmCallType$fShowLlvmCallType$fEqLlvmFuncAttr$fEqLlvmParamAttr $fEqLMConstMetaDecl MetaNamed MetaUnnamed MetaAnnotMetaExprMetaStrMetaNodeMetaVar MetaStructMetaId$fOutputableMetaId $fEqMetaAnnot $fEqMetaExpr $fEqMetaId $fOrdMetaId $fEnumMetaIdLlvmExpressionAllocaLlvmOpCompareExtractExtractVInsertMallocLoadALoad GetElemPtr AtomicRMWCmpXChgCallCallMPhiAsmMExpr LlvmStatement AssignmentFenceBranchBranchIfCommentMkLabelStoreSwitchReturn UnreachableNopMetaStmt LlvmAtomicOpLAO_XchgLAO_AddLAO_SubLAO_AndLAO_NandLAO_OrLAO_XorLAO_MaxLAO_MinLAO_UmaxLAO_UminLlvmSyncOrdering SyncUnord SyncMonotonic SyncAcquire SyncRelease SyncAcqRel SyncSeqCstSingleThreaded LlvmFunctions LlvmFunctionfuncDeclfuncArgs funcAttrsfuncSect funcPrefixfuncBody LlvmModule modComments modAliasesmodMeta modGlobals modFwdDeclsmodFuncs LlvmBlocks LlvmBlock blockLabel blockStmts LlvmBlockId$fEqLlvmStatement$fEqLlvmExpression$fShowLlvmAtomicOp$fEqLlvmAtomicOp$fShowLlvmSyncOrdering$fEqLlvmSyncOrderingFormatII8II16II32II64FF32FF64 intFormat floatFormat isIntFormat isFloatFormat cmmTypeFormat formatToWidth formatInBytes $fShowFormat $fEqFormat mkVirtualReg regDotColor AddrRegReg AddrRegImmLOHIHAHIGHERAHIGHESTAtoRegNo fits16Bits makeImmediatefRegr0sptocr3r4r30f1tmpRegdW_LANG_HaskelldW_TAG_array_typedW_TAG_lexical_blockdW_TAG_pointer_typedW_TAG_compile_unitdW_TAG_structure_typedW_TAG_typedefdW_TAG_subroutine_typedW_TAG_subrange_typedW_TAG_base_typedW_TAG_file_typedW_TAG_subprogramdW_TAG_variabledW_TAG_auto_variabledW_TAG_arg_variabledW_TAG_ghc_src_note dW_AT_namedW_AT_stmt_list dW_AT_low_pc dW_AT_high_pcdW_AT_languagedW_AT_comp_dirdW_AT_producerdW_AT_externaldW_AT_frame_basedW_AT_use_UTF8dW_AT_linkage_namedW_AT_ghc_tick_parentdW_AT_ghc_span_filedW_AT_ghc_span_start_linedW_AT_ghc_span_start_coldW_AT_ghc_span_end_linedW_AT_ghc_span_end_coldW_CHILDREN_nodW_CHILDREN_yes dW_FORM_addr dW_FORM_data2 dW_FORM_data4dW_FORM_string dW_FORM_flagdW_FORM_block1dW_FORM_ref_addr dW_FORM_ref4dW_FORM_flag_presentdW_ATE_addressdW_ATE_boolean dW_ATE_float dW_ATE_signeddW_ATE_signed_chardW_ATE_unsigneddW_ATE_unsigned_chardW_CFA_set_locdW_CFA_undefineddW_CFA_same_valuedW_CFA_def_cfadW_CFA_def_cfa_offsetdW_CFA_def_cfa_expressiondW_CFA_expressiondW_CFA_offset_extended_sfdW_CFA_def_cfa_sfdW_CFA_def_cfa_offset_sfdW_CFA_val_offsetdW_CFA_val_expression dW_CFA_offset dW_OP_addr dW_OP_deref dW_OP_consts dW_OP_minus dW_OP_mul dW_OP_plus dW_OP_lit0 dW_OP_breg0dW_OP_call_frame_cfadwarfInfoSectiondwarfAbbrevSectiondwarfLineSectiondwarfFrameSectiondwarfGhcSectiondwarfARangesSection dwarfSectiondwarfInfoLabeldwarfAbbrevLabeldwarfLineLabeldwarfFrameLabel dwarfRegNodwarfReturnRegNoAddrReg allGpArgRegs allFpArgRegs$fEqSDoc $fShowSDoc $fEqAddrMode$fShowAddrMode$fEqImm $fShowImmtargetVirtualRegSqueezetargetRealRegSqueezetargetClassOfRealRegtargetMkVirtualRegtargetRegDotColortargetClassOfRegshowBitsOperandOpRegOpRegExt OpRegShiftOpImm OpImmShiftOpAddrRegShiftExtShift ShiftModeSLSLSLSRSASRSRORExtModeEUXTBEUXTHEUXTWEUXTXESXTBESXTHESXTWESXTXTBlockTLabelTRegInstrCOMMENTMULTILINE_COMMENTANNLOCATIONLDATANEWBLOCKDELTASXTBUXTBSXTHUXTHPUSH_STACK_FRAMEPOP_STACK_FRAMEADDCMNCMPMSUBMULSDIVSMULHSMULLSUBUDIVSBFMUBFMSBFXUBFXANDANDSASRBICBICSEONEORLSLLSRMOVMOVKMVNORNORRRORTSTSTRLDRSTPLDPCSETCBZCBNZJBBLBCONDDMBSYFCVTSCVTFFCVTZSFABSstackFrameHeaderSize spillSlotSize stackAlign maxSpillSlotsspillSlotToOffsetcallerSavedRegistersallocMoreStackopRegxzrwzrip0_xx0x1x2x3x4x5x6x7x8x9x10x11x12x13x14x15x16x17x18x19x20x21x22x23x24x25x26x27x28x29x30x31_dd0d1d2d3d4d5d6d7d8d9d10d11d12d13d14d15d16d17d18d19d20d21d22d23d24d25d26d27d28d29d30d31 opRegUExt opRegSExt$fOutputableRegUsage $fShowInstr $fEqOperand $fShowOperand $fEqShiftMode$fShowShiftMode $fEqExtMode $fShowExtModeJumpDest DestBlockIdgetJumpDestBlockId canShortcutshortcutStatics shortcutJump$fOutputableJumpDest pprNatCmmDecl$fOutputableInstrprimRepCmmType slotCmmType typeCmmTypeprimRepForeignHinttypeForeignHint mkIntCLitzeroCLitzeroExpr mkWordCLitmkByteStringCLitmkFileEmbedLit mkDataLits mkRODataLits mkStgWordCLitpackHalfWordsCLit mkLblExpr cmmOffsetExpr cmmOffset cmmRegOff cmmOffsetLit cmmLabelOffcmmIndex cmmIndexExpr cmmLoadIndex cmmLoadBWord cmmLoadGCWord cmmRegOffB cmmOffsetBcmmOffsetExprB cmmLabelOffB cmmOffsetLitBcmmOffsetExprW cmmOffsetW cmmRegOffW cmmOffsetLitW cmmLabelOffW cmmLoadIndexW cmmOrWord cmmAndWord cmmNeWord cmmEqWord cmmULtWord cmmUGeWord cmmUGtWord cmmSLtWord cmmUShrWord cmmAddWord cmmSubWord cmmMulWord cmmQuotWord cmmNegate cmmToWord cmmMkAssignisTrivialCmmExprhasNoGlobalRegsisLitisComparisonExprtAG_MASK mAX_PTR_TAG cmmTagMaskcmmPointerMaskcmmUntag cmmIsTaggedcmmIsNotTagged cmmConstrTag1 regsOverlap regUsedIn mkLiveness modifyGraph toBlockMap ofBlockMap toBlockListtoBlockListEntryFirst%toBlockListEntryFirstFalseFallthrough ofBlockListbodyToBlockList mapGraphNodesmapGraphNodes1foldlGraphBlocks revPostorder blockTicksbaseExprspExpr spLimExprhpExpr hpLimExprcurrentTSOExprcurrentNurseryExprcccsExpr baseRegOffsetget_GlobalReg_addrregTableOffsetget_Regtable_addr_from_offsetfixStgRegisterscmmImplementSwitchPlanspprCmms pprCmmGroup pprStatic pprSection$fOutputableForeignHint!$fOutputablePPlatformCmmInfoTable$fOutputablePPlatformCmmStatic"$fOutputablePPlatformGenCmmStatics$fOutputablePPlatformGenCmmDecl $fOutputablePPlatformGenCmmGraph$fOutputablePPlatformGraph'$fOutputablePPlatformBlock$fOutputablePPlatformBlock0$fOutputablePPlatformBlock1$fOutputablePPlatformBlock2$fOutputableCmmReturnInfo"$fOutputablePPlatformForeignTarget$fOutputableForeignConvention$fOutputableConvention$fOutputablePPlatformCmmNode$fOutputablePPlatformCmmTopInfo$fOutputableCmmStackInfo $fOutputablePPlatformInfoProvEnt SelfLoopInfoSequelAssignTo$fOutputableSequel ClosureInfo closureName closureLFInfoclosureInfoLabel CallMethodEnterItJumpToItReturnItInferedReturnItSlowCall DirectEntryDynTagNonVoidCgLocCmmLocLneLoc isKnownFun fromNonVoid nonVoidIdsassertNonVoidIdsnonVoidStgArgsassertNonVoidStgArgs addIdReps addArgReps argPrimRep mkLFArgumentmkLFLetNoEscape mkLFReEntrant mkLFThunk mkConLFInfomkSelectorLFInfo mkApLFInfo mkLFImported mkLFStringLit isSmallFamily tagForCon tagForAritylfDynTag isLFThunk isLFReEntrantnodeMustPointToIt getCallMethod mkCmmInfo mkClosureInfoblackHoleOnEntryisStaticClosureclosureUpdReqd lfUpdatableclosureReEntrantclosureFunInfofunTagisToplevClosurestaticClosureLabelclosureSlowEntryLabelclosureLocalEntryLabelmkClosureInfoTableLabelmkDataConInfoTablecafBlackHoleInfoTableindStaticInfoTablestaticClosureNeedsLink$fOutputablePPlatformCgLoc$fOutputableNonVoid$fOutputableCallMethod $fEqNonVoid $fShowNonVoidArgRepNVFV16V32V64 argRepStringtoArgRepisNonV argRepSizeWidArgRepslowCallPattern$fOutputableArgRep $fEqArgRepEdgeInfotransitionSource edgeWeightTransitionSource CmmSource AsmCodeGen trans_cmmNode trans_infoCfgEdgeedgeFromedgeToedgeInfoCFG EdgeWeightweightToDouble mkWeightInfoadjustEdgeWeight setEdgeWeight getCfgNodeshasNodesanityCheckCfg filterEdgesshortcutWeightMapaddImmediateSuccessoraddEdge addWeightEdgedelEdgegetSuccEdgesSortedgetSuccessorEdges getEdgeInfo reverseEdges infoEdgeListedgeList getSuccessorspprEdgeWeightsaddNodesBetween getCfgProcgetCfg optimizeCFG loopMembers loopLevelsloopInfomkGlobalWeights$fOutputableEdgeWeight$fOutputableBranchInfo$fOutputableEdgeInfo$fOutputableCfgEdge $fOrdCfgEdge $fEqCfgEdge$fOutputableLoopInfo$fNonLocalBlockNode $fEqEdgeInfo$fEqTransitionSource$fEqBranchInfo$fEqEdgeWeight$fOrdEdgeWeight$fEnumEdgeWeight$fNumEdgeWeight$fRealEdgeWeight$fFractionalEdgeWeightLiveBasicBlockLiveInfoliveBorn liveDieRead liveDieWrite LiveInstrInstrSRSPILLRELOAD LiveCmmDeclBlockMapRegMap emptyRegMap mapBlockTop mapBlockTopMmapSCCMmapGenBlockTopmapGenBlockTopMslurpConflictsslurpReloadCoalesce stripLivepprLiveCmmDeclmapLiveCmmDeclstripLiveBlockeraseDeltasLivepatchEraseLivepatchRegsLiveInstrcmmTopLiveness regLivenessreverseBlocksInTops$fOutputableInstrSR$fInstructionInstrSR$fOutputablePenvLiveInstr$fOutputableLiveInstr$fOutputablePPlatformLiveInfo$fFunctorLiveInstr$fFunctorInstrSRRA_State ra_blockassig ra_freeregsra_assigra_deltara_stackra_us ra_spills ra_config ra_fixups RegAllocStatsra_spillInstrs ra_fixupList SpillReason SpillAlloc SpillClobber SpillLoad SpillJoinRR SpillJoinRMLocInMemInBothBlockAssignmentlookupBlockAssignmentlookupFirstUsedemptyBlockAssignmentupdateBlockAssignment regsOfLoc$fOutputableLoc$fEqLoc $fShowLoc$fOrdLoc$fEqReadingOrWriting$fOrdReadingOrWritingbinSpillReasonscountRegRegMovesNatpprStatsRegMrunRspillRloadR getFreeRegsR setFreeRegsR getAssigR setAssigRgetBlockAssigRsetBlockAssigR setDeltaR getDeltaR getUniqueR recordSpillrecordFixupBlock $fMonadRegM$fApplicativeRegM $fFunctorRegM cleanSpills$fOutputableStore$fUniquableStore SpillStatsspillStoreLoadregSpill accSpillSL$fOutputableSpillStats regCoalesce slurpJoinMovs SpillCostInfoSpillCostRecordzeroSpillCostInfoplusSpillCostInfoplusSpillCostRecordslurpSpillCostInfo chooseSpilllifeMapFromSpillCostInfopprSpillCostRecordRegAllocStatsStartRegAllocStatsSpillRegAllocStatsColored raLiveCmmraGraph raSpillCosts raPlatformraCode raCoalesced raSpillStats raSpilledraGraphColoredraCodeCoalesced raPatched raSpillCleanraFinalraSRMspprStatsSpillspprStatsLifetimespprStatsConflictpprStatsLifeConflict countSRMsaddSRM$fOutputableRegAllocStats$fFunctorRegAllocStatsregAllocconstantFoldNodeconstantFoldExpr cmmMachOpFoldcmmMachOpFoldM InitOrFini IsInitArray IsFiniArrayisInitOrFiniArraycmmToC $fMonadTE$fApplicativeTE $fFunctorTEmkEmptyContInfoTable cmmToRawCmm srtEscapeclosureInfoPtr entryCode getConstrTagcmmGetClosureType infoTableinfoTableConstrTaginfoTableSrtBitmapinfoTableClosureType infoTablePtrsinfoTableNonPtrs funInfoTable funInfoAritystdInfoTableSizeWfixedInfoTableSizeWprofInfoTableSizeWmaxStdInfoTableSizeWmaxRetInfoTableSizeWstdInfoTableSizeBstdSrtBitmapOffsetstdClosureTypeOffset stdPtrsOffsetstdNonPtrsOffsetconInfoTableSizeBLDLDFARLASTFARSTUSTCLISLIMRCMPLBCCBCCFARJMPMTCTRBCTRBCTRLADDOADDCADDEADDZEADDISSUBFSUBFOSUBFCSUBFEMULLMULLOMFOVMULHUDIVANDCNANDORORISXORXORISEXTSCNTLZNOTSLSRSRARLWINMCLRLICLRRIFADDFSUBFMULFDIVFNEGFCMPFCTIWZFCTIDZFCFIDFRSPCRNORMFCRMFLRFETCHPCHWSYNCISYNCLWSYNCNOPRIRIRegRIImmarchWordFormatmakeFarBranches UnwindExprUwConstUwRegUwDerefUwLabelUwPlusUwMinusUwTimes UnwindTable UnwindPoint DebugBlock dblProceduredblLabel dblCLabel dblHasInfoTbl dblParentdblTicks dblSourceTick dblPosition dblUnwind dblBlocks cmmDebugGencmmDebugLabels cmmDebugLink debugToMap toUnwindExpr$fOutputablePenvUnwindExpr$fOutputablePenvUnwindPoint$fOutputablePenvDebugBlock$fEqUnwindExprDestImmPrefetchVariantNTALvl0Lvl1Lvl2UNWINDCMOVMOVZxLMOVSxLLEAADCSBBMUL2IMULIMUL2IDIVADD_CCSUB_CCNEGIBSWAPSHLSARSHRBTX87StoreCVTSS2SDCVTSD2SS CVTTSS2SIQ CVTTSD2SIQCVTSI2SSCVTSI2SDSQRTTESTSETCCPUSHPOPJXXJXX_GBLJMP_TBLCALLCLTDFETCHGOTPOPCNTLZCNTTZCNTBSFBSRPDEPPEXTPREFETCHLOCKXADDCMPXCHGXCHGMFENCEpprData pprFormatpprImm pprDataItemFR frAllocateReg frGetFreeRegsfrInitFreeRegs frReleaseReg $fFRFreeRegs $fFRFreeRegs0 $fFRFreeRegs1 $fFRFreeRegs2 joinToTargets RegCode64Reg64NatM DwarfFiles NatM_Statenatm_us natm_delta natm_importsnatm_pic natm_config natm_modloc natm_fileidnatm_debug_mapnatm_cfgNcgImpl ncgConfig cmmTopCodeGengenerateJumpTableForInstrncgAllocMoreStackncgMakeFarBranchesextractUnwindPointsinvertCondBranches mkNatM_StateinitNat mapAccumLNat getUniqueNat getDeltaNat getCfgWeights setDeltaNatgetThisModuleNat addImportNat updateCfgNataddNodeBetweenNataddImmediateSuccessorNat getBlockIdNatgetNewLabelNat getNewRegNat getNewReg64 localReg64getPicBaseMaybeNat getPicBaseNat getModLoc getFileId getDebugBlock$fHasModuleNatM$fMonadUniqueNatM $fMonadNatM$fApplicativeNatM $fFunctorNatMCmmMakeDynamicReferenceM addImport ReferenceKind DataReference CallReference JumpReferencecmmMakeDynamicReferenceneedImportedSymbolspprGotDeclarationpprImportedSymbolinitializePicBase_ppcinitializePicBase_x86$fCmmMakeDynamicReferenceMNatM$fEqReferenceKind InstrBlockncgX86 ncgX86_64$fInstructionInstrncgPPC sequenceTopbackendMaintainsCfg$fOutputableBlockChain$fOrdBlockChain$fEqBlockChain initNCGConfigDwarfFrameBlockdwFdeBlkHasInfo dwFdeUnwindDwarfFrameProc dwFdeProc dwFdeHasInfo dwFdeBlocks DwarfFrame dwCieLabel dwCieInit dwCieProcs DwarfARangedwArngStartLabeldwArngEndLabel DwarfInfoDwarfCompileUnitDwarfSubprogram DwarfBlock DwarfSrcNote dwChildrendwName dwProducer dwCompDir dwLowLabel dwHighLabel dwLineLabeldwLabeldwParentdwMarker dwSrcSpanpprAbbrevDecls pprDwarfInfopprDwarfARanges pprDwarfFrame wordAlignpprBytepprHalf pprData4' pprDwWordpprWord pprLEBWord pprLEBInt sectionOffset$fOutputablePenvDwarfFrameBlock$fEqDwarfAbbrev$fEnumDwarfAbbrevdwarfGen ncgAArch64 RewriteFun TransferFunDataflowLatticefact_bot fact_join JoinedFactChanged NotChangedNewFactOldFactFact changedIf analyzeCmmBwd analyzeCmmFwd rewriteCmmBwdgetFact joinOutFacts joinFacts mkFactBasefoldNodesBwdOOfoldRewriteNodesBwdOO CmmLocalLive liveLatticecmmLocalLivenesscmmGlobalLivenessgen_kill liveLatticeLcmmLocalLivenessL gen_killLcmmSinkStatus ReachedBy ProcPoint ProcPointSetprocPointAnalysiscallProcPointsminimalProcPointSetsplitAtProcPointsattachContInfoTables$fOutputableStatuscmmLint cmmLintGraph$fMonadCmmLint$fApplicativeCmmLint$fFunctorCmmLint cmmCfgOptscmmCfgOptsProc replaceLabelsremoveUnreachableBlocksProcelimCommonBlocks ParamLocation RegisterParam StackParamassignArgumentsPos assignStackrealArgRegsCovertupleRegsCover$fOutputableParamLocationTransferJumpRetJumpRetCgStmtCgLabelCgLastCgForkCmmAGraphScoped CmmAGraph catAGraphsmkLabelmkMiddlemkLast outOfLinelgraphOfAGraph labelAGraphmkNopmkAssignmkStoremkJump mkRawJump mkJumpExtra mkCbranchmkSwitchmkReturnmkBranch mkFinalCallmkCallReturnsTomkJumpReturnsTo mkUnsafeCallmkUnwind stackStubExpr copyInOflow copyOutOflow mkCallEntry noExtraStacktoCall $fEqTransferVirtualHpOffset HeapUsagevirtHprealHpCgState MkCgState cgs_stmtscgs_tops cgs_binds cgs_hp_usg cgs_uniqs ReturnKindAssignedDirectly ReturnedToCgIdInfocg_idcg_lfcg_locFCodeinitCrunCfixCheapHWM initHpUsagegetStatesetState getHpUsage setHpUsage setVirtHp getVirtHp setRealHpgetBindssetBinds newUniquenewTempinitFCodeState getSelfLoop withSelfLoop withSequel getSequelwithUpdFrameOffgetUpdFrameOffgetTickyCtrLabelsetTickyCtrLabel getTickScope tickScopegetStgToCmmConfig getProfile getContext getModuleNameforkClosureBody forkLneBodycodeOnlyforkAlts forkAltPairgetCodeRgetCode getCodeScoped getHeapUsage emitLabel emitCommentemitTick emitUnwind emitAssign emitStore emitStore'emitemitDecl emitOutOfLineemitProcWithStackFrameemitProcWithConventiongetCmmmkCmmIfThenElsemkCmmIfThenElse' mkCmmIfGoto mkCmmIfGoto' mkCmmIfThen mkCmmIfThen'mkCall mkCmmCall aGraphToGraph$fOutputablePPlatformCgIdInfo$fMonadUniqueFCode $fMonadFCode$fApplicativeFCode$fFunctorFCodeCmmParseunECVarNFunNLabelN loopDeclswithNamenewLocalnewLabelnewFunctionName newImport lookupLabel lookupNamecode$fMonadUniqueCmmParse$fMonadCmmParse$fApplicativeCmmParse$fFunctorCmmParse litIdInfo lneIdInfo rhsIdInfo mkRhsInit idInfoToAmodemaybeLetNoEscapeaddBindC addBindsC getCgIdInfogetCgInfo_maybe bindToReg rebindToReg bindArgToRegbindArgsToRegsidToReg newStringCLitnewByteStringCLitcgLit mkSimpleLit addToMemLbl addToMemLblEaddToMem addToMemEmkTaggedObjectLoad tagToClosureemitBarf emitRtsCallemitRtsCallWithResultemitRtsCallGencallerSaveVolatileRegscallerSaveGlobalRegcallerRestoreGlobalReg emitDataLitsemitRODataLits emitDataCon assignTempnewUnboxedTupleRegsemitMultiAssign emitSwitchemitCmmLitSwitchwhenUpdRemSetEnabledemitUpdRemSetPushemitUpdRemSetPushThunkcmmInfoTableToInfoProvEntconvertInfoProvMapcheckFunctionArgTagscheckConArgsStaticcheckConArgsDyn whenCheckTagsemitTagAssertionemitArgTagCheckcheckArgcheckArgStatic mkTickBoxinitHpcemitIpeBufferListNode StaticPtrOpts opt_platform opt_gen_cstub opt_mk_stringopt_static_ptr_info_dataconopt_static_ptr_dataconsptCreateStaticBindssptModuleInitCodeinitFinderCacheflushFinderCacheslookupFileCachefindImportedModulefindPluginModulefindExactModulefindExposedPackageModuleaddModuleToFinderaddHomeModuleToFinder uncacheModulefindHomeModulemkHomeModLocationmkHomeModLocation2mkHiOnlyModLocation mkObjPathmkHiPath mkStubPathsfindObjectLinkableMaybefindObjectLinkableBCOOpts bco_n_jobs interpCmd withIServ withIServ_evalStmt abandonStmtevalIO evalStringevalStringToIOString mallocData mkCostCentres createBCOs addSptEntrycostCentreStackInfo newBreakArraystoreBreakpointbreakpointStatusgetBreakpointVar getClosure seqHValue initObjLinker lookupSymbol lookupClosurepurgeLookupSymbolCacheloadDLL loadArchive unloadObjaddLibrarySearchPathremoveLibrarySearchPath resolveObjsfindSystemLibrary iservCall readIServ writeIServ stopInterpmkFinalizedHValuefreeHValueRefswormhole wormholeReffromEvalResult getModBreaksinterpreterProfiledinterpreterDynamicCoverageConfigcoverageConfig_loggercoverageConfig_dynFlagscoverageConfig_mInterpaddTicksToBinds hpcInitCode $fMonadTM$fApplicativeTM $fFunctorTM$fEqTickishType$fEqTickDensityinitOptCoercionOptsinitSimpleOpts initBCOOpts initEvalOptsIsRecDataConResultDefinitelyRecursiveNonRecursiveOrUnsureUnboxingDecision StopUnboxing DropAbsentUnboxUnliftDataConPatContextdcpc_dc dcpc_tc_argsdcpc_coWwOptsMkWwOpts wo_fam_envswo_simple_opts wo_cpr_anal wo_modulewo_unlift_strict initWwOpts mkWwBodiesisWorkerSmallEnoughneedsVoidWorkerArgaddVoidWorkerArg badWorker goodWorker isGoodWorkerwantToUnboxArgmkWWstr mkWWstr_onemkAbsentFillerdubiousDataConInstArgTys findTypeShape isRecDataCon$fOutputableIsRecDataConResult$fEqIsRecDataConResult$fShowIsRecDataConResult wwTopBindsspecConstrProgram$fOutputableValue$fOutputableHowBound$fOutputableCall$fOutputableArgOcc$fOutputableScUsage$fOutputableCallPatcprAnalProgram$fOutputableSigEnv$fOutputableAnalEnvSimplMinitSmpl traceSmpl getSimplRules getFamEnvsgetOptCoercionOptsnewId newJoinId getSimplCounttick checkedTickfreeTick$fMonadIOSimplM$fHasLoggerSimplM$fHasDynFlagsSimplM$fMonadUniqueSimplM $fMonadSimplM$fApplicativeSimplM$fFunctorSimplM JoinFloats JoinFloat LetFloatsSimplSRDoneExDoneIdContEx SimplFloats sfLetFloats sfJoinFloats sfInScopeSimplEnvseMode seTvSubst seCvSubst seIdSubstseRecIds seInScope seCaseDepth emptyFloats isEmptyFloats pprSimplEnv mkSimplEnvgetMode seDynFlagsseLoggerseUnfoldingOptssetModeupdMode bumpCaseDepth getInScope setInScopeSetsetInScopeFromEsetInScopeFromFaddNewInScopeIds modifyInScopeenterRecGroupRHSs setSubstEnvmkContExdoFloatFromRhsemptyLetFloatsemptyJoinFloats unitLetFloat unitJoinFloat mkFloatBind extendFloats addLetFloats addJoinFloats addFloats addLetFlts letFloatBinds addJoinFlts mkRecFloatswrapJoinFloatsXwrapJoinFloatsgetTopFloatBinds mapLetFloatssubstIdrefineFromInScope lookupRecBndr simplBinders simplBindersimplNonRecBndr simplRecBndrssimplNonRecJoinBndrsimplRecJoinBndrs$fOutputableSimplSR$fOutputableFloatFlag$fOutputableLetFloats$fOutputableSimplFloats ClosureEnvemptyClosureEnvextendClosureEnvlinkBCOlookupStaticPtrlookupIElinkFail nameToCLabelgetUnitLinkOptscollectLinkOptscollectArchivesgetLibs badIfaceFilehiModuleNameMismatchWarn homeModErrorcannotFindInterfacecantFindInstalledErrmayShowLocationscannotFindModule cantFindErr mkUsedNames mkUsageInfo specProgram$fOutputableSpecEnv$fOutputableDictBind$fOutputableSpecArg$fOutputableCallInfo$fOutputableCallInfoSetValArgTyArgCastByas_dmdas_arg as_hole_ty as_arg_tyArgInfoai_funai_argsai_rulesai_enclai_dmdsai_discsDupFlagNoDup SimplifiedOkToDup StaticEnv SimplContStopCastIt ApplyToVal ApplyToTySelect StrictBind StrictArgTickItsc_dup sc_hole_tysc_argsc_envsc_cont sc_arg_tysc_bndrsc_altssc_bodysc_fun sc_fun_ty BindContextBC_LetBC_JoinbindContextLevel isSimplified addValArgTo addTyArgTo addCastToisStrictArgInfoargInfoAppArgspushSimplifiedArgs argInfoExpr mkBoringStop mkRhsStop mkLazyArgStopcontIsRhsOrArg contIsStop contIsDupable contIsTrivialcontResultType contHoleTypecontHoleScaling countArgscontArgs mkArgInfolazyArgContextinterestingCallContextsimplEnvForGHCiupdModeForStableUnfoldingsupdModeForRulesactiveUnfoldinggetUnfoldingInRuleMatch activeRulepreInlineUnconditionallypostInlineUnconditionallymkLamtryEtaExpandRhsabstractFloats prepareAltsmkCase isExitJoinId$fOutputableDupFlag$fOutputableArgSpec$fOutputableArgInfo$fOutputableSimplCont knownKeyNameslookupKnownKeyNameisKnownKeyNamelookupKnownNameInfoghcPrimExportsghcPrimDeclDocsmaybeCharLikeConmaybeIntLikeConisNumericClassisStandardClassHieName ExternalName LocalName KnownKeyName TyVarScopeResolvedScopesUnresolvedScopeScope LocalScope ModuleScopeDeclTypeFamDecSynDecDataDecConDec PatSynDecClassDecInstDecBindType RegularBind InstanceBindRecFieldContext RecFieldDeclRecFieldAssign RecFieldMatch RecFieldOccImportImportAs ImportHidingExport EvBindDeps getEvBindDeps EvVarSource EvPatternBind EvSigBind EvWrapperBindEvImplicitBind EvInstBind EvLetBind isSuperInstcls ContextInfoUse MatchBindIEThingTyDeclValBind PatternBind ClassTyDeclDecl TyVarBindRecFieldEvidenceVarBindEvidenceVarUseIdentifierDetails identType identInfoNodeIdentifiers IdentifierNodeInfonodeAnnotationsnodeTypenodeIdentifiersNodeAnnotationnodeAnnotConstr nodeAnnotType NodeOrigin SourceInfo GeneratedInfoSourcedNodeInfogetSourcedNodeInfoHieASTsourcedNodeInfonodeSpan nodeChildrenHieASTsgetAstsHiePathHieArgs HieTypeFixRoll HieTypeFlatHieTypeHTyVarTyHAppTy HTyConApp HForAllTyHFunTyHQualTyHLitTyHCastTy HCoercionTy TypeIndexHieFile hie_hs_file hie_module hie_typeshie_asts hie_exports hie_hs_srcSpan hieVersion pprNodeIdents pprIdentifier pprBindSpan hieNameOcc toHieName$fBinaryHieArgs$fBinaryHieType$fBinaryNodeOrigin$fOutputableNodeOrigin$fBinaryNodeAnnotation$fOutputableNodeAnnotation$fOrdNodeAnnotation$fBinaryEvBindDeps$fOrdEvBindDeps$fEqEvBindDeps$fOutputableEvVarSource$fBinaryEvVarSource$fBinaryIEType$fOutputableIEType$fBinaryRecFieldContext$fOutputableRecFieldContext$fBinaryBindType$fOutputableBindType$fBinaryDeclType$fOutputableDeclType $fBinaryScope$fOutputableScope$fBinaryTyVarScope$fOutputableTyVarScope$fBinaryContextInfo$fOutputableContextInfo$fBinaryIdentifierDetails$fMonoidIdentifierDetails$fSemigroupIdentifierDetails$fOutputableIdentifierDetails$fOutputableNodeInfo$fBinaryNodeInfo$fOutputableSourcedNodeInfo$fBinarySourcedNodeInfo$fOutputableHieAST$fBinaryHieAST$fOutputableHieASTs$fBinaryHieASTs$fBinaryHieFile$fOutputableHieName $fOrdHieName $fEqHieName$fFunctorHieASTs$fFoldableHieASTs$fTraversableHieASTs$fFunctorHieAST$fFoldableHieAST$fTraversableHieAST$fFunctorSourcedNodeInfo$fFoldableSourcedNodeInfo$fTraversableSourcedNodeInfo$fFunctorNodeInfo$fFoldableNodeInfo$fTraversableNodeInfo$fEqIdentifierDetails$fFunctorIdentifierDetails$fFoldableIdentifierDetails$fTraversableIdentifierDetails$fEqContextInfo$fOrdContextInfo$fEqTyVarScope$fOrdTyVarScope $fEqScope $fOrdScope $fDataScope $fEqDeclType $fOrdDeclType$fEnumDeclType $fEqBindType $fOrdBindType$fEnumBindType$fEqRecFieldContext$fEnumRecFieldContext$fOrdRecFieldContext $fEqIEType $fEnumIEType $fOrdIEType$fEqEvVarSource$fOrdEvVarSource$fOutputableEvBindDeps$fEqNodeAnnotation$fEqNodeOrigin$fEnumNodeOrigin$fOrdNodeOrigin$fEqHieTypeFix$fFunctorHieType$fFoldableHieType$fTraversableHieType $fEqHieType$fFunctorHieArgs$fFoldableHieArgs$fTraversableHieArgs $fEqHieArgs HieTypeStateHTStyMaphtyTable freshIndex EvidenceInfo evidenceVar evidenceSpan evidenceTypeevidenceDetailsRefMapgenerateReferencesMap renderHieTyperesolveVisibilityfoldType selectPointfindEvidenceUsegetEvidenceTreesAtPointgetEvidenceTreehieTypeToIface initialHTSfreshTypeIndex compressTypesrecoverFullType getTypeIndexresolveTyVarScopesresolveTyVarScopeLocalgetNameBinding getNameScopegetNameBindingInClassgetNameScopeAndBindinggetScopeFromContextgetBindSiteFromContext flattenAstsmallestContainingSatisfyingselectLargestContainedByselectSmallestContaining definedInAstsgetEvidenceBindDepsisEvidenceBindisEvidenceContext isEvidenceUse isOccurrencescopeContainsSpan combineAst insertAstnodeInfo emptyNodeInfosourcedNodeIdentscombineSourcedNodeInfocombineNodeInfo mergeAstsrightOfleftOf startsRightOf mergeSortAstssimpleNodeInfolocOnlymkScopeAmkScopemkLScope mkLScopeA mkLScopeN combineScopesmkSourcedNodeInfo makeNodeAmakeNode makeTypeNodeA makeTypeNode$fOutputableEvidenceInfo$fEqEvidenceInfo$fOrdEvidenceInfo$fFunctorEvidenceInfo DiffIdentDiffdiffFilediffAstsdiffAstnormalizeIdentsdiffListeqDiffvalidAstvalidateScopes simplTopBinds simplExpr simplImpRules floatOutwards$fOutputableFloatBinds DmdAnalOptsdmd_strict_dictsdmd_unbox_widthdmd_max_worker_argsdmdAnalProgramcallArityAnalProgram callArityRHS LlvmCgConfigllvmCgPlatform llvmCgContextllvmCgFillUndefWithGarbagellvmCgSplitSectionllvmCgBmiVersionllvmCgLlvmVersion llvmCgDoWarnllvmCgLlvmTargetllvmCgLlvmConfig LlvmVersion llvmVersionNE$fEqLlvmVersion$fOrdLlvmVersion ppLlvmModuleppLlvmComments ppLlvmComment ppLlvmGlobals ppLlvmGlobal ppLlvmAliases ppLlvmAlias ppLlvmMetas ppLlvmMetappLlvmFunctionsppLlvmFunctionppLlvmFunctionDeclsppLlvmFunctionDeclppName ppPlainNameppLitppVar ppTypeLitlmGlobalRegVarlmGlobalRegArg alwaysLivestgTBAAtopNstackNheapNrxNbaseNtbaagetTBAALlvmM UnresStatic UnresLabelLlvmData LlvmUnresDataLiveGlobalRegsLlvmBasicBlock LlvmCmmDecl cmmToLlvmTypewidthToLlvmFloatwidthToLlvmInt llvmFunTy llvmFunSig llvmFunAlign llvmInfAlignllvmFunSection llvmFunArgsisFPR padLiveArgsllvmStdFunAttrs tysToParams llvmPtrBitsparseLlvmVersionsupportedLlvmVersionLowerBoundsupportedLlvmVersionUpperBoundllvmVersionSupportedllvmVersionStrllvmVersionListrunLlvm withClearVars varInsert funInsert varLookup funLookup markStackReg checkStackReggetMetaUniqueId getLlvmVer dumpIfSetLlvm renderLlvm markUsedVar getUsedVars setUniqMeta getUniqMetaghcInternalFunctionsstrCLabel_llvm getGlobalPtr llvmDefLabelgenerateExternDeclsaliasify$fMonadUniqueLlvmM$fHasLoggerLlvmM $fMonadLlvmM$fApplicativeLlvmM$fFunctorLlvmMrunUnlitaugmentImportsrunCpprunPprunCc isContainedInaskLdrunAs runLlvmOpt runLlvmLlcrunClangfigureLlvmVersionrunLinkrunMergeObjects runLibtoolrunAraskOtoolrunInstallNameTool runRanlib runWindrestouchtraceToolCommandrunInjectRPathsgetUnitFrameworkOptsgetFrameworkOpts loadFramework mkExtraObjmkExtraObjToLinkIntoBinarymkNoteObjsToLinkIntoBinary getLinkInfoplatformSupportsSavingLinkOptsghcLinkInfoSectionNameghcLinkInfoNoteName checkLinkInfohaveRtsOptsFlagslazyInitLlvmConfig initSysTools copyHandlecopyWithHeadermaybeCreateManifest linkDynLib libmLinkOpts linkBinary linkBinary' linkStaticLibinitLlvmCgConfig genLlvmDatagenData pprLlvmDatapprLlvmCmmDecl infoSection genLlvmProc$fMonoidLlvmAccum$fSemigroupLlvmAccum $fEqSignage $fShowSignage llvmCodeGen nativeCodeGen cmmNativeGen!$fCmmMakeDynamicReferenceMCmmOptM$fMonadCmmOptM$fApplicativeCmmOptM$fFunctorCmmOptM codeOutputoutputForeignStubsprofilingInitCode ipInitCodeccsTypeccType storeCurCCS mkCCostCentremkCCostCentreStackcostCentreFrom staticProfHdr dynProfHdrinitUpdFrameProfsaveCurrentCostCentrerestoreCurrentCostCentre profDynAlloc profAllocenterCostCentreThunkenterCostCentreFuninitCostCentresinitInfoTableProv emitSetCCCldvRecordCreateldvEnterClosureldvEnter emitPrimCallwithNewTickyCounterFunwithNewTickyCounterLNEwithNewTickyCounterThunkwithNewTickyCounterStdThunkwithNewTickyCounterConemitTickyCounterTagtickyPushUpdateFrametickyUpdateFrameOmittedtickyEnterDynContickyEnterThunktickyUpdateBhCaf tickyEnterFun tickyEnterLNEtickyReturnOldContickyReturnNewContickyUnboxedTupleReturntickyDirectCalltickyKnownCallTooFewArgstickyKnownCallExacttickyKnownCallExtraArgs tickySlowCalltickySlowCallPat tickyDynAlloctickyAllocHeaptickyAllocPrimtickyAllocThunk tickyAllocPAPtickyHeapChecktickyStackCheck tickyTagged tickyUntagged tickyTagSkip$fToJsonTickyClosureType ClosureHeaderNoHeader StdHeader ThunkHeaderFieldOffOrPaddingFieldOffPadding emitReturnemitCalladjustHpBackwards directCallslowCallgetHpRelOffsetmkVirtHeapOffsetsWithPaddingmkVirtHeapOffsetsmkVirtConstrOffsetsmkVirtConstrSizes mkArgDescr getArgAmodegetNonVoidArgAmodesemitClosureProcAndInfoTableemitClosureAndInfoTable cgForeignCall emitCCallemitForeignCallemitSaveThreadStatesaveThreadState emitSaveRegsemitRestoreRegsemitPushTupleRegsemitPopTupleRegsemitCloseNurseryemitLoadThreadStateloadThreadStateemitOpenNursery BinderInfo BindsClosure BoringBinderSkeleton ClosureSkRhsSkAltSkBothSkNilSkbinderInfoBndrtagSkeletonTopBind goodToLift closureGrowth$fOutputableSkeleton$fOutputableBndrBinderInfo$fOutputableBinderInfo stgLiftLamsBCInstrSTKCHECKPUSH_LPUSH_LLPUSH_LLLPUSH8PUSH16PUSH32PUSH8_WPUSH16_WPUSH32_WPUSH_G PUSH_PRIMOPPUSH_BCO PUSH_ALTSPUSH_ALTS_UNLIFTEDPUSH_ALTS_TUPLE PUSH_PAD8 PUSH_PAD16 PUSH_PAD32 PUSH_UBX8 PUSH_UBX16 PUSH_UBX32PUSH_UBX PUSH_APPLY_N PUSH_APPLY_V PUSH_APPLY_F PUSH_APPLY_D PUSH_APPLY_L PUSH_APPLY_P PUSH_APPLY_PPPUSH_APPLY_PPPPUSH_APPLY_PPPPPUSH_APPLY_PPPPPPUSH_APPLY_PPPPPPSLIDEALLOC_APALLOC_AP_NOUPD ALLOC_PAPMKAPMKPAPUNPACKPACKLABELTESTLT_ITESTEQ_ITESTLT_WTESTEQ_WTESTLT_FTESTEQ_FTESTLT_DTESTEQ_DTESTLT_PTESTEQ_PCASEFAILCCALLSWIZZLEENTERRETURNRETURN_UNLIFTED RETURN_TUPLEBRK_FUN LocalLabel getLocalLabelProtoBCO protoBCONameprotoBCOInstrsprotoBCOBitmapprotoBCOBitmapSize protoBCOArity protoBCOExpr protoBCOFFIs bciStackUse$fOutputableLocalLabel$fOutputableBCInstr$fOutputableProtoBCO$fEqLocalLabel$fOrdLocalLabelmkITbls bcoFreeNames assembleBCOsassembleOneBCOmkTupleInfoLitiNTERP_STACK_CHECK_THRESH$fMonadAssembler$fApplicativeAssembler$fFunctorAssembler byteCodeGen$fOutputableDiscr$fHasDynFlagsBcM $fMonadBcM$fApplicativeBcM $fFunctorBcM $fEqDiscr $fOrdDiscrallocDynClosureallocDynClosureCmmallocHeapClosure emitSetDynHdrmkStaticClosureFieldsmkStaticClosureentryHeapCheckentryHeapCheck' altHeapCheckaltHeapCheckReturnsTonoEscapeHeapCheckheapStackCheckGen cgTopRhsCon buildDynCon bindConArgsSRTMap ModuleSRTInfo thisModule dedupSRTsflatSRTs moduleSRTMapCAFEnvCAFSet cafAnalDatacafAnalemptySRT srtMapNonCAFsdoSRTs$fOutputablePenvSomeLabel$fOutputablePenvModuleSRTInfo $fEqSomeLabel$fOrdSomeLabel $fEqSRTEntry $fOrdSRTEntry$fEqCAFfyLabel$fOrdCAFfyLabel$fOutputablePenvSRTEntry$fOutputablePenvCAFfyLabelcgOpAppshouldInlinePrimOpcmmLayoutStacksetInfoTableStackMap$fOutputableStackMap$fOutputableStackSlotcgBindcgExprcgTopRhsClosureemitBlackHoleCodepushUpdateFrameemitUpdateFramecodeGenPDunPDliftP failMsgPD getHomeUnitId$fHasDynFlagsPD $fMonadPD$fApplicativePD $fFunctorPDCmmToken CmmT_SpecChar CmmT_DotDotCmmT_DoubleColonCmmT_ShrCmmT_ShlCmmT_GeCmmT_LeCmmT_EqCmmT_Ne CmmT_BoolAnd CmmT_BoolOr CmmT_CLOSURECmmT_INFO_TABLECmmT_INFO_TABLE_RETCmmT_INFO_TABLE_FUNCmmT_INFO_TABLE_CONSTRCmmT_INFO_TABLE_SELECTOR CmmT_else CmmT_export CmmT_section CmmT_gotoCmmT_if CmmT_call CmmT_jump CmmT_foreign CmmT_never CmmT_prim CmmT_reserve CmmT_return CmmT_returns CmmT_import CmmT_switch CmmT_case CmmT_default CmmT_push CmmT_unwind CmmT_bits8 CmmT_bits16 CmmT_bits32 CmmT_bits64 CmmT_bits128 CmmT_bits256 CmmT_bits512 CmmT_float32 CmmT_float64 CmmT_gcptrCmmT_GlobalReg CmmT_Name CmmT_StringCmmT_Int CmmT_FloatCmmT_EOF CmmT_False CmmT_True CmmT_likelycmmlex$fShowCmmToken parseCmmFile countEntriesccState collectCCsaddLateCostCentresMGaddLateCostCentresPgmaddLateCostCentreslintStgTopBindingsStgToDoStgCSE StgLiftLamsStgStats StgUnarise StgBcPrep StgDoNothing StgCgInfosStgPipelineOptsstgPipeline_phasesstgPipeline_lintstgPipeline_pprOpts stgPlatformstg2stg$fMonadUniqueStgM $fShowStgToDo $fReadStgToDo $fEqStgToDo $fOrdStgToDo $fFunctorStgM$fApplicativeStgM $fMonadStgM $fMonadIOStgMinitStgPipelineOpts cmmPipelinegenerateCgIPEStub core2core simplifyExpr LRenamingRenaming renameFromrenameTo IncludeDeclidUnitId idModRenamingidSignatureInclude LHsUnitDecl HsUnitDeclDeclDIncludeDLHsUnitHsUnit hsunitName hsunitBody LHsModuleId HsModuleId HsModuleVarLHsModuleSubst HsModuleSubst LHsUnitIdHsUnitId HsComponentId hsPackageName hsComponentId$fOutputableHsComponentIdparseIdentifieraddHaddockToModule$fMonoidLowerLocBound$fSemigroupLowerLocBound$fMonoidUpperLocBound$fSemigroupUpperLocBound$fMonoidColumnBound$fSemigroupColumnBound$fMonoidLocRange$fSemigroupLocRange$fApplicativeHdkA$fHasHaddockGenLocated$fHasHaddockGenLocated0$fHasHaddockHsWildCardBndrs$fHasHaddockHsScaled$fHasHaddockGenLocated1$fHasHaddockGenLocated2$fHasHaddockGenLocated3$fHasHaddockGenLocated4$fHasHaddockHsDataDefn$fHasHaddockHsDecl$fHasHaddockGenLocated5$fHasHaddockGenLocated6$fHasHaddockGenLocated7$fHasHaddockGenLocated8$fHasHaddock[] $fFunctorHdkA $fFunctorHdkM$fApplicativeHdkM $fMonadHdkM$fShowColumnBound$fShowUpperLocBound$fShowLowerLocBound$fSemigroupHasInnerDocs$fMonoidHasInnerDocsparseModuleNoHaddockparseSignature parseImportparseStatementparseDeclarationparseExpression parsePatternparseTypeSignature parseStmt parseType parseBackpack parseHeader parseModuleisStmt hasImportisImportisDecl getImports mkPrelImportsgetOptionsFromFile getOptionstoArgscheckProcessArgsResultbadReexportedBootThingmissingBootThingcheckBootDeclM tcMatchesFun tcGRHSsPatAnnoBodyrnStmtsrnLExprrnExprHoleFitSortingAlgsortHoleFitsByGraphsortHoleFitsBySizezonkSubsgetHoleFitDispConfiggetHoleFitSortingAlg pprHoleFitaddHoleFitDocsgetLocalBindingstcFilterHoleFits tcSubsumeswithoutUnificationtcCheckHoleFitfindValidHoleFitsfinishTHrunRemoteModFinalizersrunQuasilookupThName_mayberunMetaDrunMetaTrunMetaPrunMetaEtcTopSpliceExpr runAnnotation runTopSplicetcUntypedBrackettcTypedBracket tcSpliceExpr tcIfaceDeclstcIfaceCompleteMatchestcIfaceAnnotationstcIfaceFamInst tcIfaceInst tcIfaceRules tcIfaceDecl tcSyntaxOpGen tcSyntaxOp tcInferRho tcInferRhoNCtcExpr tcPolyExprtcCheckMonoExprtcCheckMonoExprNC tcMonoExpr tcMonoExprNCtcCheckPolyExprtcCheckPolyExprNC tcSubMult unifyKind unifyType tcInitTidyEnvIsExtraConstraintYesExtraConstraintNoExtraConstraintinitTc initTcWithGblinitTcInteractive initTcRnIf discardResult getTopEnv updTopEnv getGblEnv updGblEnv setGblEnv getLclEnv updLclEnv setLclEnv restoreLclEnvgetEnvssetEnvsupdEnvs restoreEnvsxoptMdoptMgoptMwoptMsetXOptM unsetXOptM unsetGOptM unsetWOptM whenDOptM whenGOptM whenWOptM whenXOptM unlessXOptM getGhcModewithoutDynamicNow updTopFlags getEpsVargetEps updateEps updateEps_getHpt getEpsAndHug withException newArrowScopeescapeArrowScopenewUniqueSupplycloneLocalNamenewName newNameAt newSysName newSysLocalIdnewSysLocalIdsnewTcRef readTcRef writeTcRefupdTcReftraceTctraceRn traceOptTcRn dumpOptTcRndumpTcRnprintForUserTcRntraceIf traceOptIf getIsGHCi getGHCiMonadgetInteractivePrintNametcIsHsBootOrSigtcIsHsigtcSelfBootInfogetGlobalRdrEnv getRdrEnvs getFixityEnvextendFixityEnvgetRecFieldEnvgetDeclaredDefaultTysaddDependentFilesinGeneratedCode setSrcSpan setSrcSpanAaddLocMaddLocMAwrapLocM wrapLocAM wrapLocMA wrapLocFstM wrapLocFstMA wrapLocSndM wrapLocSndMA wrapLocM_ wrapLocMA_ getErrsVar setErrsVarfailWithfailAtaddErrAtaddErrscheckErr addMessagesdiscardWarnings mkTcRnMessagereportDiagnosticsreportDiagnostic checkNoErrs whenNoErrsifErrsM failIfErrsM getErrCtxt setErrCtxt addErrCtxt addErrCtxtMaddLandmarkErrCtxtaddLandmarkErrCtxtM popErrCtxt getCtLocM setCtLocM askNoErrstryCaptureConstraintscaptureConstraintstcCollectingUsagetcScalingUsagetcEmitBindingUsageattemptMrecoverMmapAndRecoverM mapAndReportMfoldAndRecoverMtryTc discardErrstryTcDiscardingErrsaddErrTc addErrTcM failWithTc failWithTcMcheckTccheckTcMfailIfTc failIfTcMwarnIf diagnosticTc diagnosticTcMaddDiagnosticTcaddDiagnosticTcMaddDetailedDiagnosticaddTcRnDiagnostic addDiagnosticaddDiagnosticAt mkErrInfodebugTc addTopEvBinds newTcEvBindsnewNoTcEvBindscloneEvBindsVargetTcEvTyCoVarsgetTcEvBindsMapsetTcEvBindsMap addTcEvBindchooseUniqueOccTcgetConstraintVarsetConstraintVaremitStaticConstraintsemitConstraints emitSimple emitSimplesemitImplicationemitImplications emitInsolubleemitDelayedErrorsemitHole emitHolesemitNotConcreteErrordiscardConstraintspushLevelAndCaptureConstraints pushTcLevelM_ pushTcLevelM getTcLevel setTcLevelisTouchableTcM getLclTypeEnv setLclTypeEnvtraceTcConstraintsemitAnonTypeHoleemitNamedTypeHole recordThUserecordThSpliceUserecordThNeededRuntimeDeps keepAlivegetStagegetStageAndBindLevelsetStageaddModFinalizersWithLclEnvrecordUnsafeInfer finalSafeModefixSafeInstancesgetLocalRdrEnvsetLocalRdrEnv mkIfLclEnv initIfaceTcRn initIfaceLoadinitIfaceLoadModuleinitIfaceCheck initIfaceLclinitIfaceLclWithSubst getIfModulefailIfMforkMsetImplicitEnvM getCCIndexM getCCIndexTcM$fMonadUniqueIOEnv$fOutputableIsExtraConstraintloadSysInterfacenewGlobalBinderrnTopSpliceDecls rnSpliceDecl rnSplicePat rnSpliceTypeCandidatesQTvsDVdv_kvsdv_tvsdv_cvs ConcreteHolenewMetaKindVarnewMetaKindVars newEvVarsnewEvVarnewWantedWithLoc newWanted newWantedscloneWantedCtEv cloneWantedcloneWC emitWanted emitWantedEqs emitWantedEqemitWantedEvVaremitWantedEvVarsemitNewExprHolenewDictnewImplicationnewCoercionHolefillCoercionHoleisFilledCoercionHoleunpackCoercionHoleunpackCoercionHole_maybecheckCoercionHolenewConcreteHolenewInferExpTypenewInferExpTypeFRRreadExpType_maybereadScaledExpType readExpTypecheckingExpType_maybecheckingExpTypescaledExpTypeToType expTypeToTypeinferResultToTypetcInfer tcInferFRRensureMonoType promoteTcTypenewMetaTyVarNamenewAnonMetaTyVarnewSkolemTyVar newTyVarTyVarcloneTyVarTyVarnewConcreteTyVarnewPatSigTyVarnewCycleBreakerTyVarnewMetaDetailsnewTauTvDetailsAtLevelcloneMetaTyVar readMetaTyVarisFilledMetaTyVar_maybeisFilledMetaTyVarisUnfilledMetaTyVarwriteMetaTyVarwriteMetaTyVarRefnewMultiplicityVar newFlexiTyVarnewNamedFlexiTyVarnewFlexiTyVarTynewFlexiTyVarTysnewOpenTypeKindnewOpenFlexiTyVarTynewOpenFlexiTyVarnewOpenBoxedTypeKind newMetaTyVarsnewMetaTyVarsX newMetaTyVarXnewMetaTyVarTyVarX newWildCardXnewMetaTyVarTyAtLevelcandidateKindVars delCandidatespartitionCandidatescandidateQTyVarsWithBinderscandidateQTyVarsOfTypecandidateQTyVarsOfTypescandidateQTyVarsOfKindcandidateQTyVarsOfKindsquantifyTyVarsisQuantifiableTvzonkAndSkolemiseskolemiseQuantifiedTyVar defaultTyVardoNotQuantifyTyVarspromoteMetaTyVarTopromoteTyVarSetzonkTcTypeAndFVzonkTyCoVarsAndFVzonkDTyCoVarSetAndFVzonkTyCoVarsAndFVList zonkTcTyVarszonkTyCoVarKindzonkImplication zonkEvVarzonkWC zonkSimpleszonkCtzonkSkolemInfozonkSkolemInfoAnon zonkTcType zonkTcTypeszonkCo zonkTcTyVarzonkTcTyVarsToTcTyVarszonkTcTyVarToTcTyVarzonkInvisTVBinderzonkId zonkCoVarzonkTidyTcTypezonkTidyTcTypeszonkTidyOriginzonkTidyOriginszonkTidyFRRInfostidyCttidyHoletidyDelayedError tidyEvVaranyUnfilledCoercionHoles$fOutputableCandidatesQTvs$fMonoidCandidatesQTvs$fSemigroupCandidatesQTvs"$fMonoidUnfilledCoercionHoleMonoid%$fSemigroupUnfilledCoercionHoleMonoidhasFixedRuntimeRephasFixedRuntimeRep_syntacticmakeTypeConcretenewInteractiveBinderallocateGlobalBinderifaceExportNames lookupOriglookupNameCacheexternaliseName setNameModule tcIfaceLclIdextendIfaceIdEnv tcIfaceTyVarlookupIfaceTyVarlookupIfaceVarextendIfaceTyVarEnvextendIfaceEnvslookupIfaceTop newIfaceName newIfaceNamestrace_iftrace_hi_diffsMethInfo TcMethInfo mkNewTyConRhs buildDataCon buildPatSyn buildClassnewImplicitBindernewTyConRepNameemptyNameShape mkNameShapeextendNameShapenameShapeExportssubstNameShapemaybeSubstNameShape tcRnModIfacetcRnModExports rnModIface rnModExports BinDictionary bin_dict_next bin_dict_mapBinSymbolTablebin_symtab_nextbin_symtab_map TraceBinIFace QuietBinIFace CheckHiWay IgnoreHiWayreadBinIfaceHeader readBinIfacegetWithUserData writeBinIfaceputWithUserDataputSymbolTablegetSymbolTableputName getSymtabName putFastStringgetDictFastString$fEqCheckHiWaytcLookupImported_maybe importDeclcheckWiredInTyConifCheckWiredInThingneedWiredInHomeIfaceloadSrcInterfaceloadSrcInterface_maybeloadModuleInterfaceloadModuleInterfacesloadInterfaceForNameloadInterfaceForModuleloadWiredInHomeIfaceloadUserInterfaceloadPluginInterface loadInterfacemoduleFreeHolesPrecisefindAndReadIface writeIface readIface ifaceStats showIfacepprModIfaceSimple pprModIface$fOutputableWarningstypecheckIfacetypecheckIfacesForMergingtypecheckIfaceForInstantiate tcHiBootIface tcIfaceExprtcIfaceOneShot tcIfaceGlobal HieHeader HieFileResulthie_file_result_versionhie_file_result_ghc_versionhie_file_resulthieMagic writeHieFilereadHieFileWithVersion readHieFile LookingForLFlf_whichlf_where WhereLooking WL_Anywhere WL_Global WL_LocalTop WL_LocalOnly WhatLooking WL_AnythingWL_Constructor WL_RecFieldWL_NonemkUnboundNameRdrreportUnboundName'reportUnboundName unboundName unboundNameX notInScopeErrunknownNameSuggestionsnameSpacesRelated$fEqWhatLooking MiniFixityEnvaddLocalFixitieslookupFixityRnlookupFixityRn_helplookupTyFixityRnlookupFieldFixityRn tcAnnotationsannCtxt DsWarning MatchResult MR_Infallible MR_Fallible DsWrapper EquationInfoEqnInfoeqn_patseqn_origeqn_rhsDsMatchContext idDsWrapperrunMatchResultfixDsinitDsTcinitDsinitDsWithModGutsinitTcDsForSolver newUniqueIdduplicateLocalDs newPredVarDs newSysLocalDsnewFailLocalDsnewSysLocalsDs getGhcModeDs getPmNablas updPmNablas getSrcSpanDs putSrcSpanDs putSrcSpanDsA diagnosticDs errDsCoreExpr failWithDsfailDsmkPrintUnqualifiedDsdsLookupGlobaldsLookupGlobalId dsLookupTyCondsLookupDataCondsLookupConLikedsGetFamInstEnvs dsGetMetaEnvdsGetCompleteMatchesdsLookupMetaEnvdsExtendMetaEnvdiscardWarningsDspprRuntimeTrace getCCIndexDsM$fMonadThingsIOEnv$fOutputableDsMatchContext$fApplicativeMatchResult$fOutputableEquationInfo$fFunctorMatchResult dsLocalBinds dsSyntaxExprdsLExprdsExprmatchSinglePatVar matchSimply matchWrappermatch dsHsWrapper MkCaseAltalt_pat alt_wrapper alt_resultselectSimpleMatchVarLselectMatchVarsselectMatchVarfirstPat shiftEqns matchCanFailalwaysFailMatchResultcantFailMatchResultextractMatchResultcombineMatchResultsadjustMatchResultDs wrapBindswrapBindseqVarmkCoLetMatchResultmkViewMatchResultmkEvalMatchResultmkGuardedMatchResultmkCoPrimCaseMatchResultmkCoAlgCaseMatchResultmkCoSynCaseMatchResult mkErrorAppDs mkFailExpr mkCoreAppDs mkCoreAppsDsmkCastDsmkSelectorBinds mkLHsPatTupmkVanillaTuplePatmkBigLHsVarTupId mkBigLHsTupIdmkBigLHsVarPatTupIdmkBigLHsPatTupIdshareFailureHandlerdsHandleMonadicFailure mkOptTickBoxmkBinaryTickBoxdecideBangHood isTrueLHsExprtracePmtraceWhenFailPmmkPmIdallPmCheckWarnings overlapping exhaustive redundantBangexhaustiveWarningFlagisMatchContextPmCheckedneedToRunPmCheck dsGuardeddsGRHSsdsCCallmkFCallunboxArg boxResult resultWrapper RecompReasonUnitDepRemovedModulePackageChangedSourceFileChangedThisUnitIdChanged ImpurePluginPluginsChangedPluginFingerprintChangedModuleInstChanged HieMissing HieOutdatedSigsMergeChanged ModuleChanged ModuleRemoved ModuleAddedModuleChangedRawModuleChangedIface FileChanged CustomReason FlagsChangedOptimFlagsChangedHpcFlagsChangedMissingBytecodeMissingObjectFileMissingDynObjectFileMissingDynHiFileMismatchedDynHiFileObjectsChangedLibraryChanged CompileReason MustCompile RecompBecauseMaybeValidated UpToDateItem OutOfDateItemRecompileRequiredUpToDateNeedsRecompileneedsRecompileBecauseoutOfDateItemBecauserecompileRequired recompThen checkOldIfaceaddFingerprints$fOutputableRecompReason$fOutputableCompileReason$fMonoidRecompileRequired$fSemigroupRecompileRequired$fOutputableRecompileRequired$fBinaryIfaceIdExtras$fBinaryIfaceDeclExtras$fOutputableIfaceDeclExtras$fEqRecompileRequired$fFunctorMaybeValidated$fEqCompileReason$fEqRecompReasonmkPartialIface mkFullIface mkIfaceTcmkIfaceExportstyThingToIfaceDeclcoAxiomToIfaceDecl pprTyThingLoc pprTyThingHdrpprTyThingInContextpprTyThingInContextLoc pprTyThing mkHieFilemkHieFileWithSourcegetCompressedAsts enrichHie$fModifyStateVar$fModifyStateName$fHasLocHsDataDefn $fHasLocHsArg $fHasLoc[]$fHasLocGenLocated$fHasLocGenLocated0$fHasLocGenLocated1$fHasLocPScoped$fToHieGenLocated$fToHieGenLocated0$fToHieIEContext$fToHieIEContext0$fToHieIEContext1$fToHieGenLocated1$fToHieRScoped$fToHieGenLocated2$fToHieGenLocated3$fToHieAnnProvenance$fToHieGenLocated4$fToHieGenLocated5$fToHieGenLocated6$fToHieForeignExport$fToHieForeignImport$fToHieGenLocated7$fToHieGenLocated8$fToHieGenLocated9$fToHieGenLocated10$fToHieGenLocated11$fToHieGenLocated12$fToHieGenLocated13$fToHieGenLocated14$fToHieGenLocated15$fToHieGenLocated16$fToHieGenLocated17$fToHiePendingTcSplice$fToHiePendingRnSplice$fToHieHsQuote$fToHieGenLocated18$fToHieArithSeqInfo$fToHieGenLocated19$fToHieGenLocated20$fToHieTScoped$fToHieTVScoped $fToHieHsArg$fToHieGenLocated21$fToHieTVScoped0$fToHieTScoped0$fToHieStandaloneKindSig$fToHieGenLocated22$fToHieTScoped1$fToHieTScoped2$fToHieGenLocated23$fToHieGenLocated24$fToHieHsScaled$fToHieGenLocated25$fToHieRScoped0$fToHieGenLocated26$fToHieGenLocated27$fToHieGenLocated28$fToHieHsDataDefn$fToHieGenLocated29 $fToHieFamEqn$fToHieTScoped3$fToHieTScoped4$fToHieGenLocated30$fToHieRScoped1$fToHieFamilyInfo$fToHieGenLocated31$fToHieGenLocated32$fToHieTyClGroup$fToHieHsConDeclGADTDetails$fToHieHsConDetails$fToHieRContext$fToHieTScoped5$fToHieContext$fToHieGenLocated33$fToHieEvBindContext$fToHieContext0$fToHieContext1$fToHieContext2$fToHieContext3$fToHieIEContext2 $fToHieMaybe $fToHieBag $fToHie[] $fToHieVoid$fToHiePatSynFieldContext$fToHieContext4$fToHieGenLocated34$fToHieSigContext$fToHieGenLocated35$fToHieGenLocated36$fToHieRScoped2$fToHieRFContext$fToHieRFContext0$fToHieRContext0$fToHieRScoped3$fToHieRScoped4$fToHieRScoped5$fToHieRScoped6$fToHieHsTupArg$fToHieGenLocated37$fToHiePScoped$fToHieHsStmtContext$fToHieHsMatchContext$fToHieHsPatSynDir$fToHieGenLocated38$fToHieBindContext$fHiePassTypechecked$fHiePassRenamed$fHasTypeGenLocated$fHasTypeGenLocated0$fHasTypeGenLocated1$fHasLocFamEqn$fToHieRScoped7$fToHieGenLocated39 $fToHieGRHSs$fToHieGenLocated40$fToHieMatchGroup $fDataPScopedgetLoaderStateextendLoadedEnvdeleteFromLoadedEnvloadNamewithExtendedLoadedEnvshowLoaderStateinitLoaderStateloadCmdLineLibsloadExpr loadDecls loadModuleunload loadPackages InstBindings ib_tyvarsib_binds ib_pragmas ib_extensions ib_derivedInstInfoiSpeciBinds lookupGloballookupGlobal_maybeioLookupDataConaddTypecheckedBindstcLookupLocatedGlobaltcLookupGlobaltcLookupGlobalOnlytcLookupDataContcLookupPatSyntcLookupConLike tcLookupClass tcLookupTyCon tcLookupAxiomtcLookupLocatedGlobalIdtcLookupLocatedClasstcLookupLocatedTyContcLookupInstance tcGetInstEnvssetGlobalTypeEnvtcExtendGlobalEnvImplicittcExtendGlobalEnvtcExtendTyConEnv tcTyThBinderstcExtendGlobalValEnvtcExtendRecEnvtcLookupLocatedtcLookupLcl_maybetcLookup tcLookupTyVar tcLookupIdtcLookupIdMaybetcLookupLocalIdstcLookupTcTyCongetInLocalScopetcExtendKindEnvListtcExtendKindEnvtcExtendTyVarEnvtcExtendNameTyVarEnvisTypeClosedLetBndrtcExtendRecIdstcExtendSigIdstcExtendLetEnv tcExtendIdEnvtcExtendIdEnv1tcExtendIdEnv2tcExtendLocalTypeEnv tcCheckUsagetcExtendBinderStacktcInitOpenTidyEnvtcAddDataFamConPlaceholderstcAddPatSynPlaceholdersgetTypeSigNames tcExtendRulescheckWellStagedtopIdLvltcMetaTy isBrackStagetcGetDefaultTysiDFunIdpprInstInfoDetailssimpleInstInfoClsTysimpleInstInfoTysimpleInstInfoTyCon newDFunNamenewFamInstTyConNamenewFamInstAxiomNamemkStableIdFromStringmkStableIdFromName mkWrapperName pprBinders wrongThingErr$fOutputableInstInfo ZonkFlexi DefaultFlexiSkolemiseFlexiRuntimeUnkFlexiNoFlexiZonkEnv tcShortCutLit shortCutLit hsOverLitName emptyZonkEnvmkEmptyZonkEnv initZonkEnv zonkTopBndrs zonkTyBndrs zonkTyBndrsXzonkTyVarBindersXzonkTyVarBinderX zonkTopExpr zonkTopLExpr zonkTopDecls zonkTcEvBinds zonkEvBinds zonkTyVarOcc lookupTyVarXzonkTcTypeToTypezonkTcTypeToTypeXzonkTcTypesToTypesX zonkCoToCozonkScaledTcTypesToTypesXzonkTcMethInfoToMethInfoX$fOutputableZonkEnvdsLit dsOverLitwarnAboutIdentitieswarnAboutOverflowedOverLitwarnAboutOverflowedLitwarnAboutEmptyEnumerations tidyLitPattidyNPat matchLiteralshsLitKey matchNPatsmatchNPlusKPatsdesugarPatBinddesugarEmptyCasedesugarMatches desugarGRHSsnewMethodFromName topSkolemisetopInstantiateinstantiateSigmainstTyVarsWithinstCallinstCallConstraints instDFunTypeinstStupidThetatcInstInvisibleTyBinderstcInstInvisibleTyBindersNtcInstInvisibleTyBinder tcInstTypetcInstTypeBndrstcSkolDFunTypetcSuperSkolTyVarstcInstSkolTyVarstcInstSkolTyVarsXtcInstSuperSkolTyVarsXtcSkolemiseInvisibleBndrsfreshenTyVarBndrsfreshenCoVarBndrsXnewOverloadedLit mkOverLit tcSyntaxNamegetOverlapFlag tcGetInsts newClsInsttcExtendLocalInstEnvmatchActualFunTySigmamatchActualFunTysRhomatchExpectedFunTysmatchExpectedListTymatchExpectedTyConAppmatchExpectedAppTy tcWrapResult tcWrapResultOtcWrapResultMonounifyExpectedType tcSubTypePat tcSubType tcSubTypeNCtcSubTypeSigmatcSubTypeAmbiguitytcSkolemiseScopedtcTopSkolemisetcSkolemiseExpTypecheckConstraintscheckTvConstraintsemitResidualTvConstraintbuildTvImplicationbuildImplicationForuTypestartSolvingByUnificationswapOverTyVarsmatchExpectedFunKind checkTyVarEq checkTyFamEq checkTypeEqcheckFamInstConsistencytcInstNewTyCon_maybetcLookupDataFamInsttcLookupDataFamInst_maybetcTopNormaliseNewTypeTF_maybetcExtendLocalFamInstEnvreportInjectivityErrors reportConflictingInjectivityErrstcGetFamInstEnvsmkTypeableBindstyConIsTypeable$fFunctorKindRepM$fApplicativeKindRepM$fMonadKindRepMnewLocalBndrRnnewLocalBndrsRnbindLocalNamesbindLocalNamesFVcheckDupRdrNamescheckDupRdrNamesN checkDupNamescheckShadowedRdrNamescheckDupAndShadowedNamescheckInferredVarsnoNestedForallsContextsErraddNoNestedForallsContextsErraddFvRnmapFvRn mapMaybeFvRnwarnUnusedTopBindscheckUnusedRecordWildcardwarnUnusedLocalBindswarnUnusedMatcheswarnUnusedTypePatternswarnForallIdentifier mkFieldEnvaddNameClashErrRn dupNamesErrbadQualBndrErr typeAppErrbadFieldConErr checkTupSize checkCTupSize wrapGenSpan genHsAppsgenHsApp genLHsVargenHsVar genAppTypegenHsIntegralLit genHsTyLit HsSigCtxt TopSigCtxt LocalBindCtxt ClsDeclCtxt HsBootCtxt RoleAnnotCtxtAmbiguousResultUnambiguousGreAmbiguousFieldsChildLookupResult NameNotFoundIncorrectParent FoundChildnewTopSrcBinderlookupTopBndrRnlookupLocatedTopConstructorRnlookupLocatedTopConstructorRnNlookupLocatedTopBndrRnlookupLocatedTopBndrRnNlookupInstDeclBndrlookupFamInstNamelookupConstructorFieldslookupRecFieldOcclookupRecFieldOcc_updatelookupSubBndrOcc_helpercombineChildLookupResultlookupLocatedOccRnlookupLocatedOccRnConstrlookupLocatedOccRnRecFieldlookupLocatedOccRnNonelookupLocalOccRn_maybelookupLocalOccThLvl_maybe lookupOccRnlookupLocalOccRnlookupTypeOccRnlookupOccRn_maybelookupExprOccRnlookupGlobalOccRn_maybelookupGlobalOccRnlookupInfoOccRnlookupGreAvailRnaddUsedDataCons addUsedGRE addUsedGREslookupSigOccRnlookupSigOccRnNlookupSigCtxtOccRnNlookupSigCtxtOccRnlookupLocalTcNames dataTcOccslookupIfThenElselookupSyntaxNamelookupSyntaxExpr lookupSyntaxlookupSyntaxNameslookupQualifiedDoExprlookupQualifiedDolookupNameWithQualifierlookupQualifiedDoName$fMonoidDisambigInfo$fSemigroupDisambigInfo$fOutputableDisambigInfo$fOutputableChildLookupResult$fOutputableHsSigCtxt$fEqFieldsOrSelectors InstanceWhatBuiltinEqInstanceBuiltinTypeableInstanceBuiltinInstance LocalInstanceTopLevInstance iw_dfun_id iw_safe_over ClsInstResult NoInstanceOneInstNotSure cir_new_theta cir_mk_evcir_what AssocInstInfo NotAssociated InClsInstai_class ai_tyvars ai_inst_envisNotAssociated safeOverlapinstanceReturnsDictConmatchGlobalInst$fOutputableInstanceWhat$fOutputableClsInstResultMaybeNewFreshCachedTouchabilityTestResultTouchableSameLevelTouchableOuterLevel UntouchableTcSaddInertForAll addInertCankickOutAfterUnificationaddInertSafehaskinsertSafeOverlapFailureTcSgetSafeOverlapFailures addSolvedDictgetSolvedDictssetSolvedDicts updInertTcS getInertCans setInertCans updInertCans updInertDictsupdInertSafehaskupdInertIrreds getInertEqsgetInnermostGivenEqLevelgetInertInsolsgetInertGivensgetPendingGivenScsgetUnsolvedInertsgetHasGivenEqsremoveInertCtslookupFamAppInertlookupInertDictlookupSolvedDictlookupFamAppCacheextendFamAppCache foldIrredswrapTcS wrapErrTcS wrapWarnTcSfailTcSwarnTcS addErrTcSpanicTcStraceTcSrunTcPluginTcSgetGlobalRdrEnvTcSbumpStepCountTcS csTraceTcS traceFireTcSrunTcSrunTcSEarlyAbortrunTcSEqualities runTcSInertsrunTcSWithEvBinds setEvBindsTcS nestImplicTcSnestTcSemitImplicationTcSemitTvImplicationTcS getTcSInerts setTcSInertspushLevelNoWorkListupdWorkListTcS emitWorkNCemitWorkgetTcEvBindsVar unifyTyVarreportUnificationstouchabilityTestgetDefaultInfo getWorkListselectNextWorkItem getInstEnvsgetFamInstEnvscheckWellStagedDFunpprEq pprKickedresetUnificationFlagsetUnificationFlag newFlexiTcSTy instFlexi instFlexiXisFresh freshGoals getEvExpr setEvBind setWantedEqsetWantedEvTermsetEvBindIfWanted newGivenEvVarnewBoundEvVarIdnewGivenEvVarsemitNewWantedEq newWantedEqnewWantedEvVarNC newWantedNCcheckReductionDepthmatchFam matchFamTcMbreakTyEqCycle_maybe rewriterView$fHasDynFlagsTcS$fMonadThingsTcS$fHasModuleTcS$fMonadUniqueTcS$fMonadFailTcS $fMonadIOTcS $fMonadTcS$fApplicativeTcS"$fOutputableTouchabilityTestResult $fFunctorTcSrewriterewriteArgsNom rewriteType$fHasDynFlagsRewriteM$fApplicativeRewriteM$fMonadRewriteM$fFunctorRewriteMStopOrContinue ContinueWith canonicalizesolveCallStackmakeSuperClasses continueWithstopWithandWhenContinue unifyWanted$fOutputableStopOrContinue$fFunctorStopOrContinuesolveSimpleGivenssolveSimpleWanteds$fOutputableInteractResultrnLHsDoc rnLDocDecl rnDocDeclrnHsDoc FreeKiTyVarsNegationHandlingReassociateNegationKeepNegationIntactWarnUnusedForallsNoWarnUnusedForallsHsPatSigTypeScoping AlwaysBind NeverBind rnHsSigWcTypernHsPatSigType rnHsWcTypernHsPatSigTypeBindingVars rnHsSigTypernImplicitTvOccs rnLHsType rnLHsTypesrnScaledLHsTypernHsType rnLHsKindrnHsKind rnLHsTypeArgs rnContextrnMaybeContextrnLTyVarbindSigTyVarsFV bindHsQTyVarsbindHsOuterTyVarBndrsbindHsForAllTelescopebindLHsTyVarBndrsbindLHsTyVarBndrnewTyVarNameRnrnConDeclFields lookupField mkOpAppRn mkNegAppRn mkOpFormRn mkConOpPatRncheckPrecMatchcheckSectionPrecfilterInScopeMextractHsTyArgRdrKiTyVarsextractHsTyRdrTyVarsextractHsTyRdrTyVarsKindVarsextractHsTysRdrTyVarsextractRdrKindSigVarsextractConDeclGADTDetailsTyVarsextractDataDefnKindVarsextractHsOuterTvBndrsnubLnubN$fOutputableRnTyKiWhat$fOutputableRnTyKiEnv$fOutputableWarnUnusedForalls$fOutputableOpNameHsRecFieldContext HsRecFieldCon HsRecFieldPat HsRecFieldUpd NameMakerCpsRnliftCpsliftCpsWithConttopRecNameMakerisTopRecNameMakerlocalRecNameMakerrnPatsrnPatapplyNameMaker rnBindPat rnPatAndThen rnHsRecFieldsrnHsRecUpdFieldsrnLit rnOverLit $fMonadCpsRn$fApplicativeCpsRn$fFunctorCpsRnreportUnsolvedreportAllUnsolvedwarnAllUnsolvedwarnDefaultingsolverReportMsg_ExpectedActuals solverReportInfo_ExpectedActuals InferModeApplyMREagerDefaultingNoRestrictionscaptureTopConstraintssimplifyTopImplic simplifyToppushLevelAndSolveEqualitiespushLevelAndSolveEqualitiesXsolveEqualitiessimplifyAndEmitFlatConstraintsreportUnsolvedEqualitiessimplifyTopWantedssimplifyAmbiguityChecksimplifyInteractivesimplifyDefault tcCheckGivenstcCheckWanteds tcNormalisefindInferredDiffgrowThetaTyVarssimplifyWantedsTcM solveWanteds approximateWC$fOutputableInferModeGenerateInhabitingPatternsModeCaseSplitTopLevel MinimalCoverPhiCtsPhiCtPhiTyCt PhiCoreCtPhiConCt PhiNotConCtPhiBotCt PhiNotBotCtaddPhiCtsNablasaddPhiCtNablas isInhabitedgenerateInhabitingPatterns"$fOutputableTopNormaliseTypeResult$fOutputablePhiCt*$fOutputableGenerateInhabitingPatternsMode"$fEqGenerateInhabitingPatternsMode$$fShowGenerateInhabitingPatternsMode CheckActionCAunCAcheckMatchGroup checkGRHSscheckEmptyCase checkPatBind$fFunctorCheckAction pmcPatBindpmcGRHSs pmcMatchesaddTyCsaddCoreScrutTmCsaddHsScrutTmCs $fMonoidCIRB$fSemigroupCIRB$fEqFormatReportWarningsMode dsTopLHsBinds dsLHsBindsdsSpec dsMkUserRuledecomposeRuleLhs dsTcEvBinds_s dsTcEvBinds dsEvBindsdsEvTermmatchConFamily matchPatSynmatchEquationsmatchSinglePat dsListComp dsMonadComp dsBracket$fRepTVSpecificitySpecificity $fRepTV()() dsProcExpr dsValBinds HFSNoSorting HFSBySizeHFSBySubsumptionrelevantCtEvidence isFlexiTyVar$fEqHoleFitSortingAlg$fOrdHoleFitSortingAlgcheckValidTypecheckValidMonoType checkTySynRhscheckValidThetaarityErrcheckValidInstHeadvalidDerivPredcheckValidInstancecheckValidCoAxiomcheckValidCoAxBranchcheckValidTyFamEqncheckValidAssocTyFamDefltcheckTyConTelescopeallDistinctTyVars$fOutputableTypeOrKindCtxt$fOutputableExpandMode$fOutputableValidityEnv$fEqTypeOrKindCtxtDataSort DataDeclSortDataInstanceSortDataFamilySort ContextKindTheKindAnyKindOpenKind SAKS_or_CUSKSAKSCUSKInitialKindStrategyInitialKindCheckInitialKindInferHoleModeHM_Sig HM_FamPatHM_VTA HM_TyAppPat funsSigCtxt addSigCtxt pprSigCtxt tcHsSigWcTypekcClassSigTypetcClassSigType tcHsSigTypetcStandaloneKindSig tcHsDerivtcDerivStrategytcHsClsInstType tcHsTypeApp tcFamTyPats tcHsOpenTypetcHsLiftedTypetcHsOpenTypeNCtcHsLiftedTypeNCtcCheckLHsTypetcInferLHsTypetcInferLHsTypeKindtcInferLHsTypeUnsaturatedtcMult tcHsContext tcLHsPredTypebindNamedWildCardBinders kcDeclHeadercheckForDuplicateScopedTyVars outerTyVarsouterTyVarBndrsscopedSortOuterbindOuterSigTKBndrs_TvbindOuterFamEqnTKBndrs_Q_TvbindOuterFamEqnTKBndrstcOuterTKBndrstcExplicitTKBndrsbindExplicitTKBndrs_SkolbindExplicitTKBndrs_TvbindExplicitTKBndrs_Q_SkolbindExplicitTKBndrs_Q_TvbindImplicitTKBndrs_SkolbindImplicitTKBndrs_TvbindImplicitTKBndrs_Q_SkolbindImplicitTKBndrs_Q_TvbindTyClTyVarsbindTyClTyVarsAndZonkzonkAndScopedSortkindGeneralizeAlletaExpandAlgTyConcheckDataKindSigcheckClassKindSigtcbVisibilitiestcHsPartialSigTypetcHsPatSigType tcLHsKindSig funAppCtxtaddTyConFlavCtxt$fOutputableHoleMode$fOutputableTcTyMode$fOutputableSAKS_or_CUSKImportDeclUsage rnImportsrenameRawPkgQual renamePkgQualcalculateAvailsextendGlobalRdrEnvRngetLocalNonValBindersnewRecordSelector mkChildEnv findChildrenreportUnusedNamesfindImportUsagegetMinimalImportsprintMinimalImports checkConName rnTopBindsLHSrnTopBindsLHSBootrnTopBindsBootrnLocalBindsAndThenrnLocalValBindsLHS rnValBindsRHSrnLocalValBindsRHSmakeMiniFixityEnv rnMethodBinds renameSigs rnMatchGrouprnGRHSsrnGRHSrnSrcFixityDecl rnSrcDecls addTcgDUs rnWarningTxt findSplice SpliceInfospliceDescription spliceSource spliceIsDeclspliceGeneratedrnTypedBracketrnUntypedBracket rnSpliceExpr traceSplicecheckThLocalName$fOutputableMonadNames$fOutputableStmtTreeloadFrontendPluginforceLoadModuleInterfacesforceLoadNameModuleInterfaceforceLoadTyCongetValueSafelygetHValueSafelylessUnsafeCoercelookupRdrNameInModuleForPlugins TcPragEnv tcIdSigName tcSigInfoNamecompleteSigPolyId_maybetcTySigs tcUserTypeSiglhsSigWcTypeContextSpanlhsSigTypeContextSpancompleteSigFromIdisCompleteHsSig tcInstSig emptyPragEnv lookupPragEnv extendPragEnv mkPragEnvaddInlinePragArityaddInlinePrags tcSpecPrags tcSpecWrapper tcImpPragstcPatSynBuilderBind tcPatSynDecl LetBndrSpec LetLclBndr LetGblBndrtcLetPattcPats tcInferPat tcCheckPat tcCheckPat_O newLetBndraddDataConStupidTheta polyPatSig$fOutputableLetBndrSpec tcTopBinds tcHsBootSigs tcLocalBinds tcValBinds tcPolyCheckchooseInferredQuantifiers$fOutputableGeneralisationPlan RolesInfocheckSynCyclescheckClassCycles inferRolesaddTyConsToGblEnvmkDefaultMethodType tcRecSelBinds mkRecSelBindsmkOneRecordSelector$fMonadSynCycleM$fApplicativeSynCycleM $fMonadRoleM$fApplicativeRoleM$fFunctorRoleM$fFunctorSynCycleMpatSynBuilderOccAppCtxt VAExpansionVACallEValArgValArgQLva_exprva_funva_argsva_ty HsExprArgETypeArgEPragEWrapeva_ctxteva_arg eva_arg_ty eva_hs_tyeva_tyTcPassTcpRnTcpInstTcpTc appCtxtLocinsideExpansion addArgWrap splitHsApps rebuildHsApps isHsValArgcountLeadingValArgs isVisibleArgcountVisAndInvisValArgscountHsWrapperInvisArgspprHsExprArgTctcInferAppHeadtcInferAppHead_maybe obviousSigtyConOf tyConOfET lookupParentsfieldNotInType notSelector tcCheckId tcInferIdnonBidirectionalErr addFunResCtxt addExprCtxt$fOutputableAppCtxt$fOutputableEWrap$fOutputableEValArg$fOutputableHsExprArg TcStmtCheckerTcCmdStmtCheckerTcExprStmtChecker TcMatchCtxtMCmc_whatmc_body tcMatchesCase tcMatchLambdatcGRHS tcDoStmtstcBodytcStmtstcStmtsAndThen tcGuardStmttcDoStmtcheckPatCounts tcInferSigmatcApp tcExprPragtcProcgetFixedTyVars rnExportsfindExtraSigImportsimplicitRequirementsimplicitRequirementsShallow checkUnit tcRnCheckUnittcRnMergeSignaturesmergeSignaturestcRnInstantiateSignatureinstantiateSignatureHsSigFun tcClassSigs tcClassDecl2tcClassMinimalDefinstantiateMethod mkHsSigFunfindMethodBind badMethodErr instDeclCtxt1 instDeclCtxt2 instDeclCtxt3 tcATDefault DerivInstTys dit_cls_tysdit_tc dit_tc_args dit_rep_tcdit_rep_tc_argsdit_dc_inst_arg_env AuxBindSpec DerivTag2Con DerivMaxTagDerivDataDataTypeDerivDataConstr gen_Eq_binds gen_Ord_bindsgen_Enum_bindsgen_Bounded_binds gen_Ix_bindsgen_Read_bindsgen_Show_bindsgen_Data_bindsgen_Lift_bindsgen_Newtype_bindsgen_Newtype_fam_instsmkCoerceClassMethEqn genAuxBinds mkRdrFunBindmkRdrFunBindECmkRdrFunBindSEordOpTbl boxConTbl litConTbl error_ExprgetPossibleDataConsderivDataConInstArgTysbuildDataConInstArgEnvsubstDerivInstTyszonkDerivInstTys$fOutputableDerivInstTys FFoldTypeFTft_trivft_var ft_co_varft_funft_tup ft_ty_app ft_bad_app ft_forallgen_Functor_bindsfunctorLikeTraversedeepSubtypesContainingfoldDataConArgsgen_Foldable_bindsgen_Traversable_binds GenericKindGen0Gen1gen_Generic_bindsget_gen1_constrained_tys canDoGenericscanDoGenerics1gen_Generic_fam_inst ThetaSpecPredSpecSimplePredSpecSubTypePredSpecsps_pred sps_originsps_type_or_kindstps_ty_actualstps_ty_expected stps_origin StockGenFnsstock_gen_bindsstock_gen_fam_instsOriginativeDerivStatusCanDeriveStockStockClassErrorCanDeriveAnyClassNonDerivableClass DerivContext InferContext SupplyContextDerivSpecMechanismDerivSpecStockDerivSpecNewtypeDerivSpecAnyClass DerivSpecVia dsm_stock_ditdsm_stock_gen_fnsdsm_newtype_ditdsm_newtype_rep_tydsm_via_cls_tysdsm_via_inst_ty dsm_via_ty DerivSpecDSds_locds_nameds_tvsds_thetads_clsds_tys ds_skol_info ds_user_ctxt ds_overlapds_standalone_wildcard ds_mechanismDerivEnvdenv_overlap_modedenv_tvsdenv_cls denv_inst_tys denv_ctxtdenv_skol_info denv_stratDerivMisStandaloneDerivisStandaloneWildcardDerivaskDerivUserTypeCtxt mkDerivOrigin pprDerivSpecsetDerivSpecTheta zonkDerivSpecderivSpecMechanismToStrategyisDerivSpecStockisDerivSpecNewtypeisDerivSpecAnyClassisDerivSpecViazonkDerivSpecMechanismmkDirectThetaSpec substPredSpeccaptureThetaSpecConstraintshasStockDerivingcheckOriginativeSideConditionsstd_class_via_coerciblenon_coercible_classnewDerivClsInstextendLocalInstEnv$fOutputableDerivContext$fOutputableDerivEnv$fOutputableDerivSpecMechanism$fOutputableDerivSpec$fOutputablePredSpecsimplifyInstanceContexts DerivInfo di_rep_tc di_scoped_tvs di_clausesdi_ctxt tcDeriving$fOutputableEarlyDerivSpec tcInstDecls1 DataDeclInfo DDataType DDataInstancetcTyAndClassDecls kcConDeclstcTyFamInstEqncheckFamTelescopeunravelFamInstPatsaddConsistencyConstraintsdataDeclChecks tcConDeclscheckValidTyContcAddTyFamInstCtxttcMkDataFamInstCtxttcAddDataFamInstCtxtwrongKindOfFamilytcInstDeclsDeriv tcInstDecls2tcRulesisForeignImportisForeignExportnormaliseFfiTypetcForeignImportstcForeignImports' tcFImport tcCheckFIType checkCTargettcForeignExportstcForeignExports' tcFExport tcCheckFETypecheckForeignArgscheckForeignResnonIOokmustBeIO checkSafe noCheckSafe tcDefaults RenamedStuff TcRnExprModeTM_Inst TM_Default tcRnModuletcRnModuleTcRnMcheckHiBootIface' checkBootDecl rnTopSrcDecls tcTopSrcDeclsrunTcInteractivetcRnStmt isGHCiMonadtcRnExprtcRnImportDeclstcRnType tcRnDeclsigetModuleInterfacetcRnLookupRdrNametcRnLookupName tcRnGetInfoloadUnqualIfaces withTcPluginswithHoleFitPluginsgetRenamedStuffTidyOptsopt_name_cacheopt_collect_ccsopt_unfolding_optsopt_expose_unfoldings opt_trim_idsopt_expose_rulesopt_static_ptr_optsUnfoldingExposure ExposeNone ExposeSome ExposeAllmkBootModDetailsTc tidyProgram $fMonadDFFV$fApplicativeDFFV $fFunctorDFFV$fShowUnfoldingExposure$fEqUnfoldingExposure$fOrdUnfoldingExposure dsForeignsdeSugar deSugarExpr initTidyOptsinitStaticPtrOpts corePrepPgm corePrepExprmkConvertNumLiteral$fOutputableFloatingBind$fOutputableOkToSpec$fOutputableFloatsMessager newHscEnvnewHscEnvWithHUG ioMsgMaybehscTcRnLookupRdrNamehscTcRcLookupNamehscTcRnGetInfohscIsGHCiMonadhscGetModuleInterfacehscRnImportDeclshscParse hscParse'hscTypecheckRenamehscTypecheckAndGetWarnings tcRnModule' hscDesugar hscDesugar'makeSimpleDetailshscRecompStatusinitModDetailshscDesugarAndSimplifyhscMaybeWriteIface oneShotMsgbatchMsg batchMultiMsg hscCheckSafe hscGetSafe hscSimplify hscSimplify'hscSimpleIface'hscGenHardCodehscInteractivehscCompileCmmFile doCodeGenhscStmthscStmtWithLocation hscParsedStmthscDeclshscParseModuleWithLocationhscParseDeclsWithLocationhscDeclsWithLocationhscParsedDeclshscAddSptEntries hscImport hscTcExpr hscKcType hscParseExprhscParseStmtWithLocation hscParseTypehscParseIdentifierhscTidyhscCompileCoreExprhscCompileCoreExpr'dumpIfaceStatsshowModuleIndexwriteInterfaceOnlyModedefaultRunMetarunMeta' $fQuasiIOEnv!$fReifyFlagSpecificitySpecificity$fReifyFlag()()thNameToGhcNamethNameToGhcNameIO$fMonadThingsCoreMTermFoldfTermfPrim fSuspension fNewtypeWrapfRefWrapTermPrim Suspension NewtypeWrapRefWraptydcvalsubTermsvalRawctypebound_to wrapped_termtermTypeisFullyEvaluatedTermconstrClosToNamefoldTerm mapTermType termTyCoVarscPprTerm cPprTermBase cvObtainTermcvReconstructTypeimproveRTTIType$fOutputableTerm tcPluginIO tcPluginTracegetTargetPlatformisTouchableTcPluginMnewGivenGetDocsFailureNameHasNoModule NoDocsInIfaceInteractiveNamegetResumeContextgetHistoryModulegetHistorySpan execOptionsexecStmt execStmt'runDeclsrunDeclsWithLocationrunParsedDeclsparseImportDecl resumeExecsetupBreakpointbackforwardabandon abandonAll setContextmoduleIsInterpretedgetInfogetNamesInScopegetRdrNamesInScope parseNamegetDocsgetInstancesForTypeparseInstanceHead parseExpr compileExprcompileExprRemotecompileParsedExprRemotecompileParsedExprdynCompileExpr showModulemoduleIsBootOrNotObjectLinkableobtainTermFromValobtainTermFromIdreconstructType$fOutputableGetDocsFailurecompileEmptyStubcompileForeign HookedUse runHookedUse runPipelinerunPhaserunLlvmManglePhaserunMergeForeignrunLlvmLlcPhaserunLlvmOptPhase runAsPhase runCcPhaserunHscBackendPhase runUnlitPhase getFileArgs runCppPhase runHscPhasemkOneShotModLocation runHscTcPhaserunHscPostTcPhase runHsPpPhasephaseOutputFilenameNewgetOutputFilename llvmOptionsoffsetIncludePathsdoCppgetBackendDefshscPostBackendPhase compileStubjoinObjectFilesgetHCFilePackageslinkDynLibCheckgeneratePackageVersionMacrosfixchargenerateMacrostouchObjectFilegetGhcVersionPathName$fMonadUseTPhaseHookedUse$fFunctorHookedUse$fApplicativeHookedUse$fMonadHookedUse$fMonadIOHookedUse$fMonadThrowHookedUse$fMonadCatchHookedUse preprocess compileOne compileOne'link linkingNeeded compileFile mkPipeEnvpreprocessPipeline fullPipeline hscPipelinehscBackendPipelinehscGenBackendPipeline asPipeline viaCPipeline llvmPipelinellvmLlcPipelinellvmManglePipelinecmmCppPipelinehscPostBackendPipeline pipelineStartSummariseResultFoundInstantiationFoundHomeWithError FoundHomeNotThere ModNodeMap unModNodeMap ModIfaceCacheiface_clearCacheiface_addToCache LoadHowMuchLoadAllTargetsLoadUpToLoadDependenciesOfdepanaldepanalEdepanalPartialinstantiationNodes noIfaceCache newIfaceCache loadWithCacheload'emptyModNodeMapmodNodeMapInsertmodNodeMapElemsmodNodeMapLookupmodNodeMapSingletonmodNodeMapUnionWith downsweepcheckHomeUnitsClosed summariseFilesummariseModule noModErrorcyclicModuleErr'$fOutputableModuleGraphNodeWithBootFile$fOutputableBuildPlan$fFunctorResultVar$fFunctorModNodeMap$fTraversableModNodeMap$fFoldableModNodeMap GhcApiError ModuleInfo CoreModule cm_modulecm_typescm_bindscm_safeTypecheckedSource RenamedSource ParsedSourceDesugaredModuledm_typechecked_moduledm_core_moduleTypecheckedModuletm_parsed_moduletm_renamed_sourcetm_typechecked_sourcetm_checked_module_info tm_internals_ ParsedModulepm_mod_summarypm_parsed_sourcepm_extra_src_files coreModuleTypecheckedMod renamedSourcetypecheckedSource moduleInfo ParsedMod parsedSourcedefaultErrorHandlerdefaultCleanupHandlerrunGhcTwithCleanupSessionsetSessionDynFlagssetUnitDynFlagssetTopSessionDynFlagssetProgramDynFlagsgetProgramDynFlagssetInteractiveDynFlagsgetInteractiveDynFlagsparseDynamicFlagsparseTargetFiles setTargets getTargets addTarget removeTarget guessTargetworkingDirectoryChanged getModSummarytypecheckModule desugarModulecompileToCoreModulecompileToCoreSimplifiedgetModuleGraphisLoadedisLoadedModule getBindingsgetInstsgetPrintUnqual getModuleInfomodInfoTyThingsmodInfoTopLevelScopemodInfoExportsmodInfoExportsWithSelectorsmodInfoInstancesmodInfoIsExportedNamemkPrintUnqualifiedForModulemodInfoLookupName modInfoIface modInfoRdrEnv modInfoSafemodInfoModBreaks isDictonaryIdlookupGlobalNamefindGlobalAnnsgetGREgetNameToInstancesIndex dataConTypepprParenSymNamegetTokenStreamgetRichTokenStreamaddSourceToTokensshowRichTokenStream findModulefindQualifiedModulerenamePkgQualMrenameRawPkgQualM lookupModulelookupQualifiedModuleisModuleTrustedmoduleTrustReqs setGHCiMonadparserinterpretPackageEnv$fParsedModParsedModule$fOutputableCoreModule$fParsedModTypecheckedModule$fParsedModDesugaredModule$fTypecheckedModDesugaredModule!$fTypecheckedModTypecheckedModule$fDesugaredModDesugaredModule$fExceptionGhcApiError$fShowGhcApiErrorpprintClosureCommandshowTermpprTypeAndContents doMkDependHS doBackpack$fGhcMonadIOEnv$fEqSessionType.=renum!:foldBlockNodesF3 GHC.VersioncProjectGitCommitIdcProjectVersioncProjectVersionIntcProjectPatchLevelcProjectPatchLevel1cProjectPatchLevel2 getPaddedIntgetGNUArchEntries putArchEntryfileInfostderrSupportsAnsiColors'filterM forceState short_usage$restrictedDamerauLevenshteinDistance hashInt32isJust isNothingfromJust maybeToList listToMaybe catMaybesmapMaybebytestring-0.11.3.1Data.ByteString.Internal ByteStringData.ByteString.Short.InternalShortByteString mkZFastStringGHC.IO.Handle.TypesHandleokIdOccokIdChar reservedIds reservedOpsisDashesskipBOMGHC.Utils.Encodingutf8DecodeCharRDoc reduceDocfirst hasAsciiSpacesignalHandlersRefCountis_ctype uniqueMaskgenSymmkUniqSM TaggedValSharedEntryisOneLineRealSpanisPointRealSpanputPrimhashInstantiationscompareFractionalLitshouldMangleSelectorNames plusWithInf mulWithInfrewrites rewriteLinerewriteSymType rewriteAVX rewriteCall replaceOnce splitLineunlines'libraryDirsForWayminClosureSizeVMaybeviewConsviewSnoc dotNodeEdges checkNode colorScan assignColors selectColormk_derivn_sortn_occn_uniqn_loc NotExportedIdScope realUniquefvVarAcc flavourIndexpprFlavourCoreppCostCentreLblppFlavourLblComponentData.Typeable.InternalTypeablefindAnnPayloads widenRealSpan powersetL powersetLS pickBothGREFunTyConAlgTyCon FamilyTyCon SynonymTyCon PrimTyConPromotedDataContcRolesalgTcGadtSyntaxalgTcStupidThetaalgTcRhs algTcFlavoursynTcRhs famTcFlav famTcParentfamTcInj primRepNamedataCon promDcRepInfotcTyConFlavourokParenttyConFieldLabelEnvfieldsOfAlgTcRhs kindTyConKeysisConcreteTyConFlavourtcFlavourMustBeSaturatedcloseOverKindsFVsubstForAllCoBndrUncheckedsubstVarBndrUncheckedsubstTyVarBndrUsingsubstCoVarBndrUsing pcPrimTyCon pcPrimTyCon0pcPrimTyCon_LevPolyLastArg TypeOrderingTLTTEQTEQXTGTexpandSynTyConApp_maybe expand_syn coreFullViewisTyConKeyApp_maybeisBoxedRuntimeRep_maybeisNullaryTyConKeyApp mk_cast_tymkTYPEapp_maybemkBoxedRepApp_maybemkTupleRepApp_maybesplitSomeForAllTyCoVarBndrssplitForAllTyVarsfun_kind_arg_flagstcKindRep_maybe narrowLit'Int16#Int#Word# plusAddr#FlatSwitchPlanmaxJumpTableHoleminJumpTableSizeminJumpTableOffsetBody'isIfaceTyConAppLiftedTypeKinddefaultIfaceTyVarsOfKind liftedRep_ty lifted_ty ppr_itv_bndrspprSpaceIfPromotedTyCon ppr_equalityppr_iface_tc_apppprSumpprTupleif_print_coercionsrm_empty normaliseRMRMEmptypsArgsmkRuntimeRepComkForAllCo_NoReflmkHomoForAllCos_NoRefldowngradeRole_maybe instCoercion instCoercionsextendLiftingContextEx ty_co_substliftCoSubstTyVarBndrUsingliftCoSubstCoVarBndrUsing TypeEqualityTNEQTypeMapX trieMapView tc_match_tystc_match_tys_x tc_unify_tys don'tBeSoSure ty_co_matchNormMdcTagdataConKindEqSpecfitsIn kindPrimRepprimRepToRuntimeRep defaultFvDmdviewCall isCardNonOnce isCardNonAbs seqSubDmd botSubDmd viewDmdPair polyFieldDmdunboxDeeplySubDmd lazifySubDmdplusDivergencemultDivergence exnDmdTypeetaExpandDmdType defaultArgDmddecreaseArityDmdTypeConCpr_ FlatConCpr TickishPassD:R:XBreakpointTickishPassStgcollectValBindersBitFieldbitfieldvanillaCafInfozapFragileUnfoldingCBPGCGpruneDelis_nullunboxedTupleSumKind cTupleArr mkSumTyConOccmkSumDataConOcc unboxedSumArrmk_sumzeroBitRepTyConextractPromotedListpcDataConWithFixity&&&sizeAnn pprTopBindsD:R:XRhsClosureCodeGenfindDefaultStgwithClosureLclswithLclmkSeqsLocalFVslocalsTopFVs AsmTempLabelAsmTempDerivedLabelIdLabelLocalBlockLabel CmmLabelInfoCmmInfo CmmRetInfoCmmRetCmmCode CmmClosure CmmPrimCallRtsSelectorInfoTableRtsApInfoTable RtsApFastClosure InfoTableLocalInfoTable LocalEntry IdTickyInfoConEntry ConInfoTable ClosureTableBytesBlockInfoTableTickyRednCountsTickyInferedTagRtsLabel ForeignLabel ModuleLabelDynamicLinkerLabel PicBaseLabelDeadStripPreventer HpcTicksLabelSRTLabelLargeBitmapLabel labelTypequickSourcePoswithSpanCoreMapXCoreMapGCseEnv ce_conAppMapce_subst ce_bndrMap ce_in_scopemkStgLetexprFVsexprsFVsexprSomeFreeVarsDSetexprsSomeFreeVarsDSet exprOrphNamesruleFVsrulesFVs exprIsHNFlikediffExpr diffIdInfo diffUnfoldlocBindControl.Monad.Trans.RWS.StrictRWST removeRhsCCCSlocalcomputeCbvInfo substIdBndrExitifyM exitifyReccse_bindCSEnvnoCSE extendCSEnv addBinder mkPrimOpId primOpIds scopeToPaths scopeUniquespprAlignForSectionpprSectionAlign pprSizeDeclTargetNodeInfo liBackEdgesliLevelsliLoopsNoInfoHeapStackCheckupdateEdgeWeight optHsPatterns staticPredCfgstaticBranchPredictioncheckIsReverseDependentcomputeLiveness livenessBlocklivenessForward livenessBackmkRegM makeRAStatsCleanS sJumpValid sJumpValidAcc sReloadedBy sCleanedCountsCleanedSpillsAccCleanMSlot cleanSpincleanBlockForward cleanForward cleanReloadcleanTopBackwardcollateJoinPoints findRegOfSlot initCleanS accJumpValid isStoreReg emptyAssocaddAssocdelAssoc delAssoc1 elemAssoc closeAssocintersectAssoc cleanBackwardSpillSstateUS stateSpillSLSpillM regSpill_topregSpill_blockregSpill_instr spillRead spillWrite spillModify patchInstr initSpillSmakeSpillStats buildAllocsinkReg takeVirtualsspillCost_length nodeDegree maxSpinCount regAlloc_spin buildGraphgraphAddConflictSetgraphAddCoalescepatchRegsFromGraphmachOpNeedsCaststaticLitsToWords pprHexVal pprCtorArray RewriteFun' TransferFun' sortBlocks mkDepBlocks updateFactBlockEntryLivenessLBlockEntryLivenessCmmLive noLiveOnEntrynoLiveOnEntryL conflicts lintShiftOpmayNotMentionCallerSavedRegs dont_care copyTicks BlockContext blockContexts interestingneeds_probe_call pprProcLabelpprProcEndLabelpprBlockEndLabel BlockChain FrontierMapneighbourOverlapp breakChainAtcombineNeighbourhood sequenceChain dropJumps DwarfAbbrev DwAbbrNull pprAbbrevpprLabelStringpprDwarfInfoOpenpprDwarfInfoClose pprFrameProc pprFrameBlockdwarfGlobalRegNo pprSetUnwind pprLEBRegNo pprUnwindExprpprUndefUnwindpprData4 pprString' escapeChar mkDwarfARangecompileUnitHeadercompileUnitFooterdebugSplitProcs procToDwarf blockToDwarf debugFrame procToFrameD:R:NoGhcTcGhcPassshowMsgEnvelopelog_hook dump_hook trace_hookgenerated_dumps trace_flushdefaultTraceFlushdumpSDocWithStylechooseDumpFileExprSize _es_size_is_es_args _es_discountlitSizecallSizejumpSize traceInline withTiming'tmp_dirs_to_cleantmp_next_suffixtmp_files_to_cleanmergeFilesToCleangetTemporaryDirectory entryNameentryBS SectionTablesectionTableOffsetsectionEntrySizesectionEntryCountsectionNameIndex ElfHeadergw16gw32gwNwordSize readElfHeaderreadElfSectionTablereadElfSectionByIndexfindSectionFromName readElfNoteBS runGetOrThrow inlineSRT wordAlignedmkLivenessBitsmakeRegMovementGraph expandNodehandleComponentmakeMovejoinToTargets'OutputableRegConstraintlinearRegAlloc processBlock initBlocklinearRAraInsn clobberRegsfindPrefRealReg newLocationloadTemplinearRegAlloc'ncgLabelDynamic picRelativeAmodeRegisterCondCodeaddSpUnwindings stmtToInstrsgetRegisterRegis32BitIntegerjumpTableEntry getSomeReggetAmodegetSimpleAmodeaddAlignmentCheckgenCondBranch'evalArgs genPrimCCall genLibCCall genRTSCCallgenCCallgenCtz genCtz64_32 genCtzGeneric genMemCpy genMemSet stmtsToInstrsgenForeignCallgenPrim genSimplePrim genCCall32 genCCall64swizzleRegisterRep opRegWidth signExtendReg truncateRegwriteLogQueueInternalparseIntdropEqGHC.LanguageExtensions.Type Extension setLanguagesetSafeHaskellcombineSafeFlagsupdOptLevelChanged safeFlagCheck allFlagsDepsunrecognisedWarningflagSpec flagSpec'warnSpec warnSpec' depFlagSpecOp depFlagSpec depWarnSpec subWarnSpecdepFlagSpecOp' depFlagSpec'depFlagSpecCond flagGhciSpec flagGhciSpec'flagHiddenSpecflagHiddenSpec'hideFlagnegatableFlagsDeps dFlagsDeps fHoleFlagslanguageFlagsDepssafeHaskellFlagsDepsvalidHoleFitDefaults enableDLintmkFlagUnitPrecedenceMapRevIndexModuleNameProvidersMap UnitConfigunitConfigPlatformArchOSunitConfigWaysunitConfigAllowVirtualunitConfigProgramNameunitConfigGlobalDBunitConfigGHCDirunitConfigDBNameunitConfigAutoLinkunitConfigDistrustAllunitConfigHideAllunitConfigHideAllPluginsunitConfigDBCacheunitConfigFlagsDBunitConfigFlagsExposedunitConfigFlagsIgnoredunitConfigFlagsTrustedunitConfigFlagsPluginsUnitVisibility uv_renamingsuv_package_nameuv_requirements uv_explicit VisibilityMapfromExposedModulesfromReexportedModulesfromFlag originVisible originEmpty mkUnitInfoMap findPackagesselectPackagesrenameUnitInfosortByPreferencecompareByPreference reverseDeps removeUnitsdepsNotAvailabledepsAbiMismatchmergeDatabasesvalidateDatabasemkModuleNameProvidersMap mkUnusableModuleNameProvidersMap addListTomkModMapadd_unit improveUnit' mkHomeUnittcEqTypeNoSyns tc_eq_typetcTyFamInstsAndVisXtcTyConAppTyFamInstsAndVisXthunkEntryLabelfcs_upframeoffset fcs_sequel fcs_selfloop fcs_ticky fcs_tickscopeDecls addVarDecladdLabel addDynTagLitBoundmk_discrete_switch needsArgTag TickyThunkTickyLNE tickyArgArityregisterTickyCtrTickyFun emitTickyDataemitCallWithExtraStackslowArgsbinderInfoOccursAsArgtagSkeletonExprrhsCard closureSizeidClosureFootprinttagSkeletonLettagSkeletonBindingliftRhs InstMatches instMatches instGuardspruneOverlappedMatches overridesinsert_overlappingReprFlagSymFlagopt_co1opt_co2opt_co3 opt_co4_wrapopt_co4 opt_phantomwrapRole chooseRole InferExtEq inferTagRhssafeTry lc_threshold lc_uf_optslc_lvl lc_lvl_env lc_rec_env lc_scrutsae_mode AnalysisMode arityTypepedanticBottoms lookupSigEnv myExprIsCheap BotStrictnessEtaExpandArity FindRhsArityisDeadEndArityType minWithArity andArityTypebotStrictnessArityEnvfindRhsArityEnv myIsCheapAppmkEtaWWEtaInfodecideJoinPointHoodppLlvmFunctionHeader ppLlvmBlocks ppLlvmBlockppLlvmBlockLabelppLlvmStatementppLlvmExpressionppCallnewLine exclamationrootN envVersion envConfig envLogger envOutputenvMask envFreshMeta envUniqMeta envFunMap envAliases envUsedVars envVarMap envStackRegs llvmGhcCC modifyEnv saveAliasisBuiltinLlvmVar structStrlinkagegenGlobalLabelArrayllvmSectionType llvmSection genStaticLit LlvmAccumEOption exprToVarExprDatabasicBlocksCodeGenbasicBlockCodeGen 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 cmmLlvmGencmmMetaLlvmPreludecmmUsedLlvmGens NativeGenAcc ngs_natives ngs_unwinds cmmNativeGens checkLayoutcomputeUnwindingmakeImportsDocppr_hs_args_prefix_appppr_single_hs_argsplitLHsQualTy_KPD:R:XFunBindGhcPassGhcPassD:R:XFunBindGhcPassGhcPass0 pprPatBndrconPatNeedsParensisIrrefutableHsPat'pprImportSuggestionpprSimilarName collect_bindshsDataDefnBindersmkCoreAppTypedmkValApp mkStrictApp mkCoreTup1mkSmallTupleSelector1 mkExceptionIddivergingIdInfosoe_co_opt_opts soe_uf_optssoe_inl soe_subst soe_rec_idsdataConSrcToImplBang dataConArgRep UnariseEnv extendRhounariseSumAltsmkUbxSumubxSumRubbishArg unariseFunArg unariseConArg myCollectArgs ruleCantMatchmatchNnoFloatIntoRhsNumOpsnumAddnumSubnumMulnumAndnumOrnumNeg numLitTypeOpValBinOpAppshiftRightLogicalNative boundsCmp int8Result int16Result int32Result intCResult word8Result word16Result word32Result wordResult wordCResultsemiInversePrimOpextendNarrowPassthroughnarrowSubsumesAndsameArgIdempotentCommutisBignumLiteralisNumberLiteralisLitNumConAppleftIdentityCPlatformrightIdentityCPlatformidentityCPlatform mkNumLiteral home_imps ModIfaceCorehandleSeqHValueStatus spawnIServ ForeignRef RemoteRefCprWwResultOnenop_fn mkAppsBetawantToUnboxResult mkWWcpr_entry mk_res_bndr mkWWcpr_oneunbox_one_resultmove_transit_varscprCaseBndrMult splitThunkae_opts ae_virgin ae_rec_dcisInterestingTopLevelFn dmdAnalBindAnalEnvsetBindIdDemandInfodmdAnalBindLetUpuseLetUpdmdAnalBindLetDown dmdAnalRhsSigexprMayThrowPreciseExceptionforcesRealWorldresultType_maybeextendAnalEnvs dmdTransformfinaliseLetBoxitySigEnvse_topsse_sigsae_sigs ae_fam_envscprAnalcprAnal'cprTransformBespokecprTransformDataConWork mAX_CPR_SIZE cprAnalBindcprDataStructureUnfolding_maybeextendSigEnvListextendSigEnvFromIdsextendSigEnvAllSameextendSigEnvForArg argCprType cprAnalAlt cprTransformScDepth lGRHSCtOriginpprCtO tyCoFVsOfCt tyCoFVsOfCtEv tyCoFVsOfCtstyCoFVsOfCtEvs tyCoFVsOfWCtyCoFVsOfImplicminuslogExactdivide rootExactgenRootgenLogknownKeyNamesOkay knownKeysMaplookupCycleBreakerVar initNabla initTmState decEqualityeqPmLit eqConLikepprLygSequence PmExprList pmExprAsListpprRefutableShapesprettifyRefuts getCleanNamepprPmVar NilTerminatedWcVarTerminatedmissingSignatureWarningFlagpprSolverReportWithCtxtpprTcSolverReportMsgpprPotentialInstancespotentialInstancesErrMsgpotentials_msg_with_options%overlapping_but_not_more_specific_msgpprTcSolverReportInfoexpandSynonymsToMatchformat_frr_errcannotMakeDerivedInstanceHeraldicExtendGblRdrEnv ExtsBitmapGenSemicnested_comment_logictyConToDataCon checkTyVarscheckUnboxedLitPatcheckNotPromotedDataConensureValidOpExpcvtOpApp cvtOpAppPcvtSigTypeKind cvtTypeKindmk_apps cvtOpAppTcvtMaybeKindToFamilyResultSigcvtFamilyResultSigcvtInjectivityAnnotation mkHsForAllTy mkHsQualTytemplate-haskellCxtmkHsContextMaybe getIdentifier ColumnBoundHdkWarnHdkStflattenBindsAndSigshptModulesBelow orIfNotFoundhomeSearchCachefindInstalledHomeModulefindPackageModulefindPackageModule_ mkDynObjPath mkDynHiPath mkHiePathemitInitializerDeclsldvWord generic_gc mkGcLabel DataCAFEnv CAFfyLabelgetLabelledBlocks depAnalSRTsgetCAFs getStaticFuns resolveCAFSRTEntrydoSCConeSRT buildSRTChain updInfoSRTs closeNursery openNurseryPrimopCmmEmit_ExternalPrimopCmmEmit_Internal asUnsigned emitPrimOpgenericWordAddCOpgenericWordSubCOpdoPrefetchByteArrayOpdoPrefetchMutableByteArrayOpdoPrefetchAddrOpdoPrefetchValueOpmkBasicPrefetchdoNewByteArrayOpdoCopyByteArrayOpdoCopyMutableByteArrayOpdoCopyByteArrayToAddrOpdoCopyMutableByteArrayToAddrOpdoCopyAddrToByteArrayOpdoSetByteArrayOp doNewArrayOp doCopyArrayOpdoCopyMutableArrayOpemitCloneArrayemitCloneSmallArray emitSetCardsdoAtomicByteArrayRMWdoAtomicReadByteArraydoAtomicReadAddrdoAtomicWriteByteArraydoAtomicWriteAddremitMemcpyCallemitMemmoveCallemitMemsetCallemitCopyUpdRemSetPushalignmentFromTypes emitCopyArrayemitCopySmallArraydoAtomicAddrRMWdoCasByteArray doBoundsCheckdoPtrArrayBoundsCheckdoSmallPtrArrayBoundsCheckdoByteArrayBoundsChecksm_spsm_args sm_ret_offsm_regs fixupStackallocate manifestSpfalseStackCheckelimStackStorescgTickwithSourceNoteHappyStkBCEnvpushConstrAtomisSupportedCConvmkStackOffsets mkProtoBCO liftIOEnvDictBindSpecArgSpecTypeSpecDict UnspecType UnspecArg spec_importstryWarnMissingSpecs specHeaderbindAuxiliaryDictmkDBbind_fvsrecWithDumpedDicts sc_uf_opts wildCardPat st_max_ticksst_query_rulebasest_co_opt_opts simplTick makeTrivialmakeTrivialBindingcloneCaseBndrs AllowAnywhereAllowAtTopLevelRejectEverywherelf_check_static_ptrslf_report_unsat_synslf_check_linearitylintRhs lintCoreExpr lintJoinLams lintCastExprcheckCanEtaExpandcheckCaseLinearity lintValApp withoutAnnotsinitL mk_cast_errlabelledTraceOptTcRn wrapDocLocadd_diagnostic candidateVars defaultTyVarszonkTcTypeMapperfieldSelectorSuggestionsimportSuggestions ShNameSubst ns_module substNamesubstNameAvailInfosetNameFieldSelector mergeAvails uAvailInfos uAvailInfouName uHoleNameShIfEnvShIfM initRnIface rnIfaceGlobalrnIfaceNeverExportedrnIfaceClsInstinitBinMemSize checkFRR_with unifyConcreteensureConcrete lf_platformcheckNoCurrentCCS getStgToDocpsToptte_countEntriesshouldTickBindaddTickLHsExprLetBodybreakpointsEnabledtickSameFileOnlyPRTypeQextQext1Qext2Qext1ext2loadInterfaceWithExceptionis_external_sigcomputeInterfaceload_dynamic_too_maybeextendIdZonkEnvRec mkHEqBoxTy mkEqBoxTyhasFixedRuntimeRepResfillInferResulttcDeeplySkolemiseKindRepM KindRepEnvplatformtrTyConDataCon trNameLit TypeRepTodoExportedKindRepsTodo mod_rep_exprpkg_fingerprintmod_fingerprint todo_tycons TypeableTyConmkTypeRepTodoBindsmkPrimTypeableTodosghcPrimTypeableTyCons collect_stuff mkTrNameLitmkTyConRepBindskindIsTypeablebuiltInKindRepsmkExportedKindReps runKindRepM getKindRep mkKindRepRhsmkTyConRepTyConRHStraceTR instSchemewarnRedundantRecordWildcardwarnUnusedRecordWildcard reportableGHC.Serialized Serialized toSerializedfromSerializedserializeWithDatadeserializeWithDatacollectCostCentrescpe_envcpe_convertNumLit FloatTick cpeBodyNFCpeBodycpeBodyFloatsokCpeArg wrapTickscheckForConflictscheckInjectiveEquation isTFHeadedbareTvInRHSViolatedunusedInjTvsInRHSreportUnusedInjectiveVarsErrreportTfHeadedErrreportBareVariableInRHSErr AccReportMsgsreport_unsolved importantdeferringAnyBindingsignoreConstraint mkErrorItemzonkTidyTcLclEnvspprSolverReportSupplementarypprValidHoleFitspprConstraintsInclude mkHoleErrorzonkAndGroupSkolTvsmaybeAddDeferredBindingsmkFRRErrfixedRuntimeRepOrigin_maybemkCoercibleExplanationshouldPprWithExplicitKinds validHoleFitslookupFixityRn'FieldsOrSelectors WantNormalWantBoth WantFieldFoundExactOrOrigExactOrOrigErrorNotExactOrOriglookupExactOcc_eitherlookupGlobalOccRn_overloadedlookupOneQualifiedNameGHCilookupQualifiedNameGHCiSafeOverlapping matchTypeabledoFunTy doTyConApponlyNamedBndrsAppliedmkTcScheckWellStagedInstanceWhatuseVarsnewWantedEvVarrestoreTyVarCyclesrunTcSWithEvBinds'RewriteTvResultRTRNotFollowed RTRFollowedRewriteM mkRewriteMsetEqRelrewrite_args_fastrewrite_args_slow rewrite_corewrite_reduction split_pi_tys'ty_con_binders_ty_binders' zonk_eq_typescan_eq_newtype_nc canEqCast canEqFailurecanEqHardFailurecanEqReflexiverewriteEvidenceTcPluginProgresspluginInputCtspluginSolvedCts pluginBadCts pluginNewCts SolvedCtsSplitCtsrunTcPluginsGivenrunTcPluginsWantedrunTcPluginSolversnaturallyCoherentClassdefaultCallStackspickQuantifiablePredsdefaultTyVarTcS TelescopeAcc ValidityEnv ExpandModeExpandNoExpandBothTypeOrKindCtxt OnlyTypeCtxt OnlyKindCtxtBothTypeAndKindCtxtcheckUserTypeErrortypeOrKindCtxttypeLevelUserTypeCtxtallConstraintsAllowedlinearityAllowed vdqAllowedinitialExpandModecheckHasFieldInstcheckValidTypePatsisTerminatingClasscheck_arg_typeauxBindSpecRdrNamemk_showString_appmk_showsPrec_app mk_shows_appgenAuxBindSpecOriginalgenAuxBindSpecDupgenAuxBindSpecSig mkFunBindSE mkFunBindEC postfixModTbl assoc_ty_idassoc_ty_id_maybenewAuxBinderRdrNameArgTyAlg argTyFoldfoldBal cond_stdOK cond_args ConditioninferConstraintsStockinferConstraintsAnyclass simplifyDerivwarnUnqualifiedImport gresFromIEwarnMissingSignatureswarnMissingKindSignaturescheckPatSynParentOpNameNormalOpNegateOp UnboundOpRecFldOppartition_nwcsrnImplicitTvBndrswildCardsAllowedcheckPolyKindslookupFixityOp filterInScopefilterFreeVarsToBind checkWildCard mkExpandedPatgeneralizeOverLitValInstDeclFreeVarsMap KindSigEnvKindSig_FV_EnvClosedTyFamInfo ClosedTyFamNotClosedTyFamAssocTyFamInfoNonAssocTyFamEqnAssocTyFamDefltAssocTyFamInstpatchForeignImportcheckCanonicalInstances rnRoleAnnotsmkInstDeclFreeVarsMaprnInjectivityAnnextendPatSynEnvrnFamEqncheck_namespace runRnSpliceStmtTree MonadNames postProcessStmtsForApplicativeDonoPostProcessStmtsrebindableContextrearrangeForApplicativeDomkStmtTreeHeuristicmkStmtTreeOptimalstmtTreeToStmtssegments splitSegmentmkApplicativeStmtneedJoin isReturnAppmkExpandedExprrnStmtsegmentRecStmtsmergeStaticObjects loadObjects dynLoadObjsmakeForeignNamedHValueRefs linkSomeBCOs getGCCPathsgccSearchDirCachegetSystemDirectories addEnvPathsloadDependenciesisAbstractIfaceDeclmergeIfaceDeclmergeIfaceDecls tc_iface_decltcUnfoldingRhsAllowedDataResKind AnyBoxedKind LiftedKindisAllowedDataResKind SkolemModeTcTyMode mode_tykitc_infer_lhs_typetc_infer_hs_type_ektc_infer_hs_type tcInferTyAppstcInferTyApps_nosatcheckExpectedKindnewNamedWildTyVarkcInferDeclHeaderkcCheckDeclHeader_sigkindGeneralizeSomekindGeneralizeNone finish_tuplekcCheckDeclHeaderkcCheckDeclHeader_cuskmatchExpectedPatTy checkGADTtc_pat tcPatSynPatmatchExpectedConTy localSigWarnrecursivePatSynErr SynCycleMcheckTyConIsAcycliccheckHsigIface check_instifaceDeclNeverExportedRefscheckImplementstc_patsyn_finishmkPatSynRecSelBinds tcMatchescmd_arr tcCmdMatchestcCmdMatchLambdatcCmdTop#hasFixedRuntimeRep_remainingValArgs quickLookArg tcTupArgs tcSynArgE tcSynArgAcheckCOrAsmOrLlvmcheckCOrAsmOrLlvmOrInterp deriveClause derivePred genInstBinds genFamInstsderivingThingFailWithgetInitialKind tcInjectivity getArgExpKind rejigConRescheckEscapingKindwrongNumberOfParmsErrget_fam_decl_initial_kind getFamFlavtcDefaultAssocDecl mkGADTVarsmkDsEnvsFromTcGblTopNormaliseTypeResultpmTopNormaliseTypeNormalisedByConstraints HadRedexes addPhiCtsupdRcmvanillaCompleteMatchTCaddCompleteMatchesaddConLikeMatchesaddTyConMatchestntrGutspmIsClosedTypenormaliseSourceTypeWHNFisSourceTypeInWHNFinitFueladdTyCtstyOraclenameTyCt addPhiTmCtaddBotCtaddConCt addNotBotCt addNotConCtaddVarCt addCoreCtrepresentCoreExprmodifyT Control.Monad.Trans.State.StrictinhabitationTestvarNeedsTesting instantiateinstBotsplitReprTyConApp_maybeinstCompleteSetsinstCompleteSetinstConisDataConTriviallyInhabitedtriviallyInhabitedTyConKeysmatchConLikeResTy leftToRight topToBottomthrottledsFractionalLitToRationalwarnAboutOverflowedLiteralsgetLHsIntegralLitgetIntegralLitgetSimpleIntegralLit getLHsCharLitgetNormalisedTyconName getTyconName mkPmLetVar vanillaConGrd mkListGrds mkPmLitGrds desugarPat desugarPatV desugarLPatV desugarLPatdesugarListPatdesugarConPatOut desugarLGRHS desugarGuarddesugarLocalBinds desugarBinddesugarBoolGuardFormatReportWarningsModeformatReportWarningsCIRB collectInModecirb_cov cirb_inacccirb_red cirb_bangs getLdiNablas noCheckDsaddRedundantBangs testRedSetsreportWarningslocallyExtendPmNablasdsHsBind makeCorePairds_ev_typeablegetRepmkMetaWrappersrepFamilyResultSigrepFamilyResultSigToMaybeKindrepInjectivityAnnnullOuterImplicitnullOuterExplicit repTyVarBndr repMaybeLTy coreNothing coreNothing'coreJust coreJust' TcViewPat dsMcBindStmtmaxBuildLength checkVersions checkPlugins checkHsigcheckHie checkFlagHashcheckOptimHash checkHpcHash checkModUsagegetOrphanHashesmkIfaceAnnCache mkObjectUsageHasTypeToHieTVScopedPScopedRScoped SigContextPatSynFieldContext IEContext RFContext listScopes patScopestScopestvScopesPSmjmzmu toUnicodeAnnmomc commentsPA PlanResultrun_th_modfinalizers andThenCheck checkUnless checkListBycheck checkSuccesstcPreludeClashWarn getMainOccrunPlans tcUserStmt tcGhciStmts getGhciStepIOrnDumptcMissingParentClassWarnlogWarningsReportErrorshandleWarningsThrowErrors ioMsgMaybe'extract_renamed_stuff hsc_typecheck checkObjects checkByteCode genModDetailshscCheckSafeImportscheckSafeImports hscCheckSafe' checkPkgTrustmarkUnsafeInferhscGetSafeModehscSimpleIface mkMetaTyVaremitQuoteWantedbrackTytcPendingSplicegetThSpliceOrigin seqSerialized lookupDeclDoc lookupArgDocgetExternalModIfacelookupThInstNameaddModFinalizerRef runRemoteTH readQResult getTHState annotThTypetyConArgsPolyKindedreifyInstances'findEnclosingDeclsupdateFixityEnv phaseIfAfterlink'MakeNewModSummarymakeNewModSummaryMakeEnv AbstractSem ResultVarModuleGraphNodeWithBootFile loadFinishguessOutputFile pruneCache waitResultinterpretBuildPlan upsweep_mod addSptEntrieswarnUnnecessarySourceImportsenableCodeGenForTHenableCodeGenWhen mkRootMap wrapAction wait_deps_hug wait_deps label_selfrunParPipelinesrunAllPipelinesrunLoopupsweepgetPreprocessedImports rehydratecheckBrokenTablesNextToCodepartition_args normalise_hypcheckNewDynFlagsunitIdOrHomeUnitbindSuspensionsBkpEnv bkp_session bkp_filename bkp_table bkp_levelBkpM SessionType ExeSession TcSession CompSessionwithBkpSession hsunitDepsaddUnit getBkpEnv getBkpLevel innerBkpM updateEpsGhc_ getEpsGhcinitBkpMbackpackProgressMsg mkBackpackMsg backpackStyle msgTopPackage msgUnitId msgIncludehsunitModuleGraphhsModuleToModSummary newUnitId