l**a      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcde f g h i j k l m n o p q r s t u v w x y z { | } ~        !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~   !!!!!"""""""""""""""###$$$$$$$$$$$$$$$$$$$$$$$$$%%%%%%%%%%%%%%%%%%&&&&&&&&&&&&&&&&&&&&&&&&&&& & & & & &&&&&&&&&&''''''''' '!'"'#'$'%'&'''(')'*'+','-'.'/'0'1'2'3'4'5'6'7'8'9':';'<'='>'?'@'A'B'C'D'E'F'G'H'I'J'K'L'M'N'O'P'Q'R'S'T'U'V'W'X'Y'Z'['\]^_`abcdefghijklmnopqrstuv(w(x(y(z({(|(}(~(((()))))))))))))**************+++++++++++++++++++++++,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,------------------------------------------------------- - - - - ----------------... .!.".#.$.%.&.'.(.).*.+.,.-.../.0.1.2.3.4.5.6.7.8/9/:/;/</=/>/?/@/A/B/C/D/E/F/G/H/I0J0K0L0M0N0O0P0Q0R0S0T0U0V0W0X0Y0Z0[0\0]0^0_0`0a0b0c0d0e1f1g1h1i1j1k1l1m1n1o1p1q1r1s1t1u1v1w1x1y1z1{1|1}1~1122222222233333333333333444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444445555555555555 5 5 5 5 5555555555555555555 5!5"5#5$5%5&5'5(5)5*5+5,5-5.5/505152535455565758595:5;5<5=5>5?5@5A5B5C5D5E5F5G5H5I5J5K5L5M5N5O5P5Q5R5S5T5U5V5W5X5Y5Z5[5\5]5^5_5`5a5b5c5d5e5f5g5h5i5j5k5l5m5n5o5p5q5r5s5t6u6v6w6x6y6z6{6|6}6~66666666666666666666666777777777777777788888888888888888888888888888888888888888888888888888888999999::::::::::::::::::::::::::::::;;;;;;;; ; ; ; ; ;;;;;;;;;;;;;;;;;;; ;!;";#;$;%;&;';(;);*;+;,;-;.;/;0;1;2;3<4<5<6<7<8<9<:<;<<<=<><?<@<A<B<C<D<E<F<G<H<I<J=K=L=M=N=O>P>Q>R>S>T>U>V>W>X>Y>Z>[>\>]>^>_>`>a>b>c>d>e>f>g>h>i>j>k>l>m>n>o>p>q>r>s>t>u>v>w>x>y>z>{>|>}>~>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>??????????????????????@@@@@@@@@AAAA A A A A AAAAAAAAAAAAAAAAAAA A!A"A#A$A%A&A'A(A)A*A+A,A-A.A/A0A1A2A3B4B5B6B7C8C9C:C;C<C=C>C?C@CACBCCCDCECFCGCHCICJCKCLCMCNCOCPCQCRCSCTCUCVCWCXCYCZC[C\C]C^C_C`CaCbCcCdCeCfCgChCiCjCkClCmCnCoCpCqCrCsCtCuDvDwDxDyDzD{D|D}D~DDDDDDDDDDDEEEEEEEEEEEEEEFFGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG G G G G GGGGGGGGGGGGGGGGGGG G!G"G#G$G%G&G'G(G)G*G+G,G-G.G/G0G1G2G3G4G5G6G7G8G9G:G;G<G=G>G?G@GAGBGCGDGEGFGGGHGIGJGKGLGMGNGOGPGQGRGSGTGUGVGWGXGYGZG[G\G]G^G_G`GaGbGcGdGeGfGgGhGiGjGkGlGmGnGoGpGqGrGsGtGuGvGwGxGyGzG{G|G}G~GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGHHHHHHHHHHHHHH H H H H HHHHHHHHHHHHHHHHHHH H!H"H#H$H%H&H'H(H)H*H+H,H-H.H/H0H1H2H3H4H5H6H7H8H9H:H;H<H=H>H?H@HAHBHCHDHEIFIGIHIIIJIKILJMJNJOJPJQJRJSJTJUJVJWJXJYJZJ[J\J]J^J_J`JaJbJcJdJeJfJgJhJiJjJkJlJmKnKoKpKqKrKsKtKuKvKwKxKyKzK{K|K}K~KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL L L L L L L L L L L L L L L L L L L L L L L L F F F F F F F F F F !F "F #F $F %F &F 'F (F )F *F +F ,F -F .F /F 0F 1F 2F 3F 4F 5F 6F 7F 8F 9F :F ;F <F =F >F ?F @F AF BF CF DF EF FF GF HF IF JF KF LF MF NF OF PF QF RF SF TF UF VF WF XF YF ZF [F \F ]F ^F _F `F aF bF cF dF eF fF gF hF iF jF kM lM mM nM oM pM qM rM sM tM uM vM wM xM yM zM {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 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 N !N "N #N $N %N &N 'N (N )N *N +N ,N -N .N /N 0N 1N 2N 3N 4N 5N 6N 7N 8N 9N :N ;N <N =N >N ?N @N AN BN CN DN EN FN GN HN IN JN KN LN MN NN ON PN QN RN SN TN UN VN WN XN YN ZN [N \N ]N ^N _N `N aN bN cN dN eN fN gN hN iN jN kN lN mN nN oN pN qN rN sN tN uN vN wN xN yN zN {N |N }N ~N N N N N N N N N N N N N N O O O O O O O O O O O O O O O O O O O O O O O O O O O O P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P 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 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 0R 1R 2R 3R 4R 5R 6R 7R 8R 9R :R ;R <R =R >R ?R @R AR BR CR DR ER FR GR HR IR JR KR LR MR NR OR PR QR RR SR TR UR VR WR XR YR ZR [R \R ]S ^S _S `S aS bS cS dS eS fS gS hS iS jS kS lS mS nS oS pS qS rS sS tS uS vS wS xS yS zS {S |S }S ~S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S T T T U U U U U U U U U U U U U U U U V V V V V W W X X X X X X X X X X X X X X X U U T T Y Y Y Y Y Y Y Y Y Z Z Z Z Z Z Z Z Z Z [ [ [ [ [ [ [ [ [ [ [ [ [ [ ![ "[ #[ $[ %[ &[ '[ ([ )[ *[ +[ ,[ -[ .[ /[ 0[ 1[ 2[ 3[ 4[ 5[ 6[ 7[ 8[ 9[ :[ ;[ <[ =[ >[ ?[ @[ A[ B[ C\ D\ E\ F\ G\ H\ I\ J\ K\ L\ M\ N\ O\ P\ Q\ R\ S\ T\ U\ V\ W\ X\ Y\ Z\ [\ \\ ]\ ^\ _\ `\ a\ b\ c\ d\ e\ f\ g\ h\ i\ j\ k\ l\ m\ n\ o\ p\ q\ r\ s\ t\ u\ v\ w\ x\ y\ z\ {\ |\ }\ ~\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ ] ] ] ] ] ] ] ] ^ ^ ^ ^ _ _ _ _ _ ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` a a a a a a a a a a a a a a a a a a a a a a a a b b b b b b b b !b "b #b $b %b &b 'b (b )b *b +b ,b -b .b /b 0b 1b 2b 3b 4b 5b 6b 7b 8b 9b :b ;b <b =b >b ?b @b Ab Bb Cb Db Eb Fb Gb Hb Ib Jb Kb Lb Mb Nb Ob Pb Qb Rb Sb Tb Ub Vb Wb Xb Yb Zb [b \b ]b ^b _b `b ab bb cb db eb fb gb hb ib jc kc lc mc nc oc pc qc rc sc tc uc vc wc xc yc zc {c |c }c ~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 e e e e e e e e e e e e f g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g 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 h h h h h h i i i i i iiiiiiiijk k k k k kkkkkkkkkkkkkkkkkkk k!k"k#k$k%k&k'k(k)k*k+k,k-k.k/k0k1k2k3k4k5k6k7k8k9k:k;k<k=k>k?k@lAlBlClDlElFlGlHlIlJlKlLlMlNlOlPlQlRmSmTmUmVmWmXmYmZm[m\m]m^m_m`mambmcmdmenfngnhninjnknlnmnnnonpnqnrnsntnunvnwnxnynzn{n|n}n~nnnnnnnnnooooooooooooooooooooooooppppppppppppppppppppppppppppppppppppppppppqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq q q q q qqqqqqqqqqqqqqqqqqq q!q"q#q$q%q&q'q(q)q*q+q,q-q.q/q0q1q2q3q4q5q6q7q8q9q:q;q<q=q>q?q@qAqBqCqDqEqFqGqHqIqJqKqLqMqNqOqPqQqRqSqTqUqVqWqXqYqZq[q\q]q^q_q`qaqbqcqdqeqfqgqhqiqjqkqlqmrnrorprqrrrsrtrurvrwrxryrzr{r|r}r~rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrssstttttttttttttttttttttttttttttttttttttttttttttttttttttttttt t t t t ttttttttttttttttttt t!t"t#t$t%t&t't(t)t*t+t,t-t.t/t0t1t2t3t4t5t6t7t8t9t:t;t<t=t>t?t@tAtBtCtDtEtFtGtHtItJtKtLtMtNtOtPtQtRtStTtUtVtWtXtYtZt[t\t]t^t_t`tatbtctdtetftgthtitjtktltmtntotptqtrtstttutvtwtxtytzt{t|t}t~ttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttuuuuuuuuuuuuuuuuuuu u u u u uuuuuuuuuuuuuuuvvvv v!v"v#v$v%v&v'v(v)v*v+v,v-v.v/v0v1v2v3v4v5v6v7v8v9v:v;v<v=v>v?v@vAvBvCvDvEvFvGvHvIvJvKvLvMvNvOvPvQvRvSvTvUvVvWvXvYvZv[v\v]v^v_v`vavbvcvdvevfvgvhvivjvkvlvmvnvovpvqvrvsvtvuvvvwvxvyvzv{v|v}v~vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv v v v v vvvvvvvvvvvvvvvvvvv v!v"v#v$v%v&v'v(v)v*v+v,v-v.v/v0v1v2v3v4v5v6v7v8v9v:v;v<v=v>v?v@vAvBwCwDwEwFwGwHwIwJwKwLwMwNwOwPwQwRwSwTwUwVwWwXwYwZw[w\w]w^w_w`wawbwcwdwewfwgwhwiwjwkxlxmxnxoxpxqxrxsxtxuxvxwxxxyxzx{x|x}x~xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxyyyyyyyyyyyyyyyyyyyyyyyyyyyyzzzzzzzzzzzzzzzzzzzzzzzzzz{{{{{{{{{{{{{{{{{{{{{|||||||||||||||||||||||| | | | | |||||||||}}}}}}}}}} }!}"}#}$}%}&}'}(})}*}+},}-}.}/}0}1}2}3}4}5}6}7}8}9}:~;~<~=~>~?~@~A~B~C~D~E~F~G~H~I~J~K~L~M~N~O~P~Q~RSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~IIIIIIIIIIIIIIIIIIIIII I I I I IIIIIIIIIIIIIIIIIII I!I"I#I$I%I&I'I(I)I*I+I,I-I.I/I0I1I2I3I4I5I6I7I8I9I:I;I<I=I>I?I@IAIBICIDIEIFIGIHIIIJIKILIMINIOIPIQIRISITIUIVIWIXIYIZI[I\I]I^I_I`IaIbIcIdIeIfIgIhIiIjIkIlImInIoIpIqIrIsItIuIvIwIxIyIzI{I|I}I~IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII I I I I IIIIIIIIIIIIIIIIIII I!I"I#I$I%I&I'I(I)I*I+I,I-I.I/I0I1I2I3I4I5I6I7I8I9I:I;I<I=I>I?I@IAIBICIDIEIFIGIHIIIJIKILIMINIOIPIQIRISITIUIVIWIXIYIZI[I\I]I^I_I`IaIbIcIdIeIfIgIhIiIjIkIlImInIoIpIqIrIsItIuIvIwIxIyIzI{I|I}I~IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII I I I I IIIIIIIIIIIIIIIIIII I!I"I#I$I%I&I'I(I)I*I+I,I-I.I/I0I1I2I3I4I5I6I7I8I9I:I;I<I=I>I?I@IAIBICIDIEIFIGIHIIIJIKILIMINIOIPIQIRISITIUIVIWIXIYIZI[I\I]I^I_I`IaIbIcIdIeIfIgIhIiIjIkIlImInIoIpIqIrIsItIuIvIwIxIyIzI{I|I}I~IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII I I I I IIIIIIIIIIIIIIIIIII I!I"I#I$I%I&I'I(I)I*I+I,I-I.I/I0I1I2I3I4I5I6I7I8I9I:I;I<I=I>I?I@IAIBICIDIEIFIGIHIIIJIKILIMINIOIPIQIRISITIUIVIWIXIYIZI[I\I]I^I_I`IaIbIcIdIeIfIgIhIiIjIkIlImInIoIpIqIrIsItIuIvIwIxIyIzI{I|I}I~IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                           ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~  !!!!!!!!!! ! ! ! ! !!!!!!!!!!!!!!!!!!! !!!"!#!$!%!&!'!(!)!*!+!,!-!.!/!0!1!2!3!4!5!6!7!8!9!:!;!<!=!>!?!@!A!B!C!D!E!F!G!H!I!J!K!L!M!N!O!P!Q!R!S!T!U!V!W!X!Y!Z![!\!]!^!_!`!a!b!c!d!e!f!g!h!i!j!k!l!m!n!o!p!q!r!s!t!u!v!w!x!y!z!{!|!}!~!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"""""""""" " " " " """"""""""""""""""" "!"""#"$"%"&"'"(")"*"+","-"."/"0"1"2"3"4"5"6"7"8"9":";"<"=">"?"@"A"B"C"D"E"F"G"H"I"J"K"L"M"N"O"P"Q"R"S"T"U"V"W"X"Y"Z"["\"]"^"_"`"a"b"c"d"e"f"g"h"i"j"k"l"m"n"o"p"q"r"s"t"u"v"w"x"y"z"{"|"}"~"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""########## # # # # ################### #!#"###$#%#&#'#(#)#*#+#,#-#.#/#0#1#2#3#4#5#6#7#8#9#:#;#<#=#>#?#@#A#B#C#D#E#F#G#H#I#J#K#L#M#N#O#P#Q#R#S#T#U#V#W#X#Y#Z#[#\#]#^#_#`#a#b#c#d#e#f#g#h#i#j#k#l#m#n#o#p#q#r#s#t#u#v#w#x#y#z#{#|#}#~#################################################################################################################################$$$$$$$$$$ $ $ $ $ $$$$$$$$$$$$$$$$$$$ $!$"$#$$$%$&$'$($)$*$+$,$-$.$/$0$1$2$3$4$5$6$7$8$9$:$;$<$=$>$?$@$A$B$C$D$E$F$G$H$I$J$K$L$M$N$O$P$Q$R$S$T$U$V$W$X$Y$Z$[$\$]$^$_$`$a$b$c$d$e$f$g$h$i$j$k$l$m$n$o$p$q$r$s$t$u$v$w$x$y$z${$|$}$~$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$%%%%%%%%%% % % % % %%%%%%%%%%%%%%%%%%% %!%"%#%$%%%&%'%(%)%*%+%,%-%.%/%0%1%2%3%4%5%6%7%8%9%:%;%<%=%>%?%@%A%B%C%D%E%F%G%H%I%J%K%L%M%N%O%P%Q%R%S%T%U%V%W%X%Y%Z%[%\%]%^%_%`%a%b%c%d%e%f%g%h%i%j%k%l%m%n%o%p%q%r%s%t%u%v%w%x%y%z%{%|%}%~%%%%%%%%%%%% % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % & & & & & & & & & &  &  &  &  &  & & & &&&&&&&&&&&&&&&& &!&"&#&$&%&&&'&(&)&*&+&,&-&.&/&0&1&2&3&4&5&6&7&8&9&:&;&<&=&>&? &@ &A&B&C&D&E&F&G&H&I&J&K&L&M&N&O&P&Q&R&S&T&U&V&W&X&Y&Z&[&\&]&^&_&`&a&b&c&d&e&f&g&h&i&j&k&l&m&n&o&p&q&r&s&t&u&v&w&x&y&z&{&|&}&~&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&'''''''''' ' ' ' ' ''''''''''''''''''' '!'"'#'$'%'&'''(')'*'+','-'.'/'0'1'2'3'4'5'6'7'8'9':';'<'='>'?'@'A'B'C'D'E'F'G'H'I'J'K'L'M'N'O'P'Q'R'S'T'U'V'W'X'Y'Z'['\']'^'_'`'a'b'c'd'e'f'g'h'i'j'k'l'm'n'o'p'q'r's't'u'v'w'x'y'z'{'|'}'~'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''(((((((((( ( ( ( ( ((((((((((((((((((( (!("(#($ (% (& (' (( () (* (+!(,!(-!(.!(/!(0!(1!(2!(3!(4!(5!(6!(7!(8!(9!(:!(;!(<!(=!(>!(?!(@!(A!(B!(C!(D!(E!(F!(G!(H!(I!(J!(K!(L!(M!(N!(O!(P!(Q!(R!(S!(T!(U!(V!(W!(X!(Y!(Z!([!(\!(]!(^!(_!(`!(a!(b!(c!(d!(e!(f!(g!(h!(i!(j!(k!(l!(m!(n!(o!(p!(q!(r!(s!(t!(u!(v!(w!(x!(y!(z!({!(|!(}!(~!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!("("("("("("("("("("("("("("("("("("("("("("("("("("("("("("("("("("("("("("("("("("("("("("("("("("("("("("("("("("("("("("("("("("("("("("("("("("("("("("("("("("("("("("("("("("("("("("("("("("("("("("("("(")")")")")")")")")") ") ") ") ") ")")")")")")")")")")")")")")")")#)#)#) #)!#)"#)##)$#)%#)&#)'#)(#))#)*#)+#),#)-#).#)/#)0#)1#)2#)3#)4#)5#)6#)7#)8#)9#):#);#)<#)=#)>#)?#)@#)A#)B#)C#)D#)E#)F#)G#)H#)I#)J#)K#)L#)M#)N#)O#)P#)Q#)R#)S#)T#)U#)V#)W#)X#)Y#)Z$)[$)\$)]$)^$)_$)`$)a$)b$)c$)d$)e$)f$)g$)h$)i$)j$)k$)l$)m$)n$)o$)p$)q$)r$)s$)t$)u$)v$)w$)x$)y$)z$){$)|$)}$)~$)$)$)$)$)$)$)$)$)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)&)&)&)&)&)&)&)&)&)&)&)&)&)&)&)&)&)&)&)&)&)&)&)&)&)&)&)&)&)&)&)&)&)&)&)&)&)&)&)&)&)&)&)&)&)&)&)&)&)&)&)&)&)'))))))))))))))))))))))))********** * * * * ******************* *!*"*#*$*%*&*'*(*)***+*,*-*.*/*0*1*2*3*4*5*6*7*8*9*:*;*<*=*>*?*@*A*B*C*D*E*F*G*H*I*J*K*L*M*N*O*P*Q*R*S*T*U*V*W*X*Y(*Z)*[)*\)*])*^)*_)*`).*Safe *a*b*c*d*e*f*g*h*i*j*k*l*m*b*h*i*j*k*l*m *a*b*c*d*e*f*g*h*i*j*k*l*mSafeThe version of Agda.Safe   None234IL"Bifunctoriality for pairs.# mapFst f = f -*- id$ mapSnd g = id -*- g%Lifted pairing.&)Swap. (Only in Data.Tuple from base-4.3),Monadic version of ".-Monadic #..Monadic $. !"#$%&'()*+,-./ !"#$%&'()*+,-."#$%&'()*+,-. !/ !"#$%&'()*+,-./"2%3NoneI 4Like  Bifunctor, but preserving sharing.8Like *n, but preserving sharing.<The Change monad.*oThe ChangeT monad transformer.>The class of change monads.ARun a <0 computation, returning result plus change flag.BBlindly run an updater.CMark a computation as dirty.EFReplace result of updating with original input if nothing has changed.*pEval an updater (using E).KA mock change monad. 456789:;<*q*r=*s*o*t*u>?@ABCDE*pFGHIJKL456789:;<=>?@ABCDE<>?@A=EBCD89:;4567456789:;<*q*r=*s*o*t*u>?@ABCDE*pFGHIJKLSafeTIs the operator associative?UIs the operator commutative?VIs the operator idempotent?W'Is the element a zero for the operator?X'Is the element a unit for the operator?YHDoes the first operator distribute (from the left) over the second one?ZIDoes the first operator distribute (from the right) over the second one?[7Does the first operator distribute over the second one?\Generates natural numbers.]Generates positive numbers.^6Generates a list of elements picked from a given list._}If the given list is non-empty, then an element from the list is generated, and otherwise an arbitrary element is generated.`Generates values of *vB type, using the given generator to generate the contents of the *w constructor.a Coarbitrary "generator" for *v.bGenerates two elements.cGenerates three elements.dRuns the tests, and returns *x if all tests were successful.TUVWXYZ[\]^_`abcd:A label for the tests. Used for informational purposes.TUVWXYZ[\]^_`abcdTUVWXYZ[\]`a^_bcdTUVWXYZ[\]^_`abcd None9;<=?I efghijklmnoef efonmlkjihg efghijklmno SafepStar semirings ( 5https://en.wikipedia.org/wiki/Semiring#Star_semirings).r Semirings ( &https://en.wikipedia.org/wiki/Semiring). pqrstuvwxpqrstuv rstuvxpqwpqrstuvwx Safeyz{*y*z*{*|*}*~*********************************************************************************************************************************++++++++++ + + + + +++++++yz{yz{yz{ Safe9;|While +- is for rendering data in Haskell syntax, |L is for displaying data to the world, i.e., the user and the environment.BAtomic data has no inner document structure, so just implement } as pretty a = text $ ... a ....Use instead of + when printing to world.&Space separated list of pretty things.align max rows lays out the elements of rowsp in two columns, with the second components aligned. The alignment column of the second components is at most max2 characters to the right of the left-most column.Precondition: max > 0.|}~C++++++++++ +!+"+#+$+%+&+'+(+)+*+++,+-+.+/+0+1+2+3+4+5+6+7+8+9+:+;+<+=+>+?+@+A+B+C+D+E+F+G+H+I+J+K+L+M+N+O+P|}~|}~|}~ None0If f a contains many copies of a they will all be the same pointer in the result. If the function is well-behaved (i.e. preserves the implicit equivalence, this shouldn't matter).+Q+R+S+T+U+Q+R+S+T+UNone29;I4<We test our properties on integer sets ordered by inclusion.Inclusion comparison wrapper.Pointwise comparison wrapper.Decidable partial orderings.6The result of comparing two things (of the same type). Less than.Less or equal than.EqualGreater or equal. Greater than.No information (incomparable).8Comparing the information content of two elements of '. More precise information is smaller.Includes equality: x  x == True. Opposites.related a po b iff related b (oppPO po) a.rCombining two pieces of information (picking the least information). Used for the dominance ordering on tuples.orPO1 is associative, commutative, and idempotent. orPO has dominant element POAny, but no neutral element.Chains (transitivity)  x R y S z.seqPO1 is associative, commutative, and idempotent. seqPO has dominant element POAny and neutral element (unit) POEQ.Embed +V.%Represent a non-empty disjunction of +Vs as .A ! information is a disjunction of +V informations.Any +W is a .+Are two elements related in a specific way? related a o b holds iff comparable a b is contained in o.Any two elements are  in the way  computes. -flip comparable a b == oppPO (comparable a b)@Auxiliary function: lists to sets = sorted duplicate-free lists. is inclusion of the associated +V sets.( amounts to the union of the associated +VJ sets. Except that 'orPO POLT POGT == POAny' which should also include . is associative. is commutative. is idempotent.The dominant element wrt.  is . Soundness of .6As QuickCheck test, this property is inefficient, see .-A more efficient way of stating soundness of . The unit of  is . The zero of  is . is associative. is also commutative. is idempotent. distributes over .The result of % is a sorted list without duplicates.From +V to  and back is the identity.From  to  Orderings and back is the identity.From  Orderings to ) and back is the identity. Except for [LT,GT], which is a non-canonical representative of .2Pairs are related iff both components are related. Comparing 0s amounts to compare their representation as +V sets..Less is ``less general'' (i.e., more precise).(Sets are partially ordered by inclusion.Sublist for ordered lists.4The pointwise ordering for lists of the same length.qThere are other partial orderings for lists, e.g., prefix, sublist, subset, lexicographic, simultaneous order.&Pointwise partial ordering for tuples.related (x1,x2) o (y1,y2) iff related x1 o x2 and related y1 o y2.$Partial ordering for disjoint sums: Left _ and Right _ are unrelated.+X and *w _ are unrelated.Partial ordering for Maybe a is the same as for  Either () a.1Partial ordering forms a monoid under sequencing.All tests as collected by *z.Using *z| is convenient and superior to the manual enumeration of tests, since the name of the property is added automatically.A4A4None2BOT!GRun a parser on a list of tokens. Returns the list of complete matches.LConsumes and returns the next character. Fails if there is no input left.PLook-ahead: returns the part of the input that is left, without consuming it. Always fails.Symmetric choice.}Local, exclusive, left-biased choice: If left parser locally produces any result at all, then right parser is not used.zTransforms a parser into one that does the same, but in addition returns the exact characters read. IMPORTANT NOTE: ] gives a runtime error if its first argument is built using any occurrences of readS_to_P.TConsumes and returns the next character, if it satisfies the specified predicate.+Parses and returns the specified character.(Parses and returns the specified string.BParses the first zero or more characters satisfying the predicate.AParses the first one or more characters satisfying the predicate.+Combines all parsers in the specified list.Skips all whitespace. count n p parses n occurrences of p/ in sequence. A list of results is returned.between open close p parses open, followed by p and finally close. Only the value of p is returned. option x p will either parse p or return x without consuming any input. optional p optionally parses p and always returns ().4Parses zero or more occurrences of the given parser.3Parses one or more occurrences of the given parser.Like , but discards the result.Like , but discards the result. sepBy p sep$ parses zero or more occurrences of p, separated by sep*. Returns a list of values returned by p. sepBy1 p sep# parses one or more occurrences of p, separated by sep*. Returns a list of values returned by p. endBy p sep$ parses zero or more occurrences of p, separated and ended by sep. endBy p sep# parses one or more occurrences of p, separated and ended by sep. chainr p op x$ parses zero or more occurrences of p, separated by op#. Returns a value produced by a right9 associative application of all functions returned by op!. If there are no occurrences of p, x is returned. chainl p op x$ parses zero or more occurrences of p, separated by op#. Returns a value produced by a left9 associative application of all functions returned by op!. If there are no occurrences of p, x is returned.Like (, but parses one or more occurrences of p.Like (, but parses one or more occurrences of p. manyTill p end$ parses zero or more occurrences of p, until end3 succeeds. Returns a list of values returned by p.+YhConverts a parser into a Haskell ReadS-style function. This is the main way in which you can "run" a " parser: the expanded type is 1 readP_to_S :: ReadP a -> String -> [(a,String)] +ZConverts a Haskell ReadS-style function into a parser. Warning: This introduces local backtracking in the resulting parser, and therefore a possible inefficiency.8+[+\+]+^+_+`+a+b+c+d+e +Y+Z+f    !  !  2+[+\+]+^+_+`+a+b+c+d+e +Y+Z+f    55Safe0z"Impossible" errors, annotated with a file name and a line number corresponding to the source code location of the error.nAbort by throwing an "impossible" error. You should not use this function directly. Instead use the macro in  undefined.h.)Catch an "impossible" error, if possible.None3Not very efficient (goes via a list), but it'll do.!Big conjunction over a map."Filter a map based on the keys.# Unzip a map.  !"#$  !"#$  !"#$ !"#$Safe% unionWith for collections of size <= 1.& Unzipping a list of length <= 1.'Filtering a singleton list. filterMaybe p a = +g (+h p [a])( Version of +i" with different argument ordering.) Version of +jB with different argument ordering. Often, we want to case on a *v%, do something interesting in the *w( case, but only a default action in the +X* case. Then, the argument ordering of  caseMaybe is preferable. $caseMaybe m d f = flip (maybe d) m f*Monadic version of +j.+Monadic version of +k.,Monadic version of ). That is, *$ with a different argument ordering.-, with flipped branches..A more telling name for +, for the *v collection type. Or: ) without the +X case./) without the *w case.0, without the +X case.1, without the *w case.2Lazy version of allJust  . sequence. (allJust = mapM for the Maybe/ monad.) Only executes monadic effect while isJust.3!Precondition: list not empty.  allJustsOrNothings [Nothing, Nothing] = Just Nothing allJustsOrNothings [Just 0, Just 1] = Just $ Just [0,1] allJustsOrNothings [Just 0, Nothing] = Nothing %&'()*+,-./0123*v+X*w+i+l+g+m+k+n+o+p+j%&'()*+,-./0123%&'()*+,-./0123%&'()*+,-./0123Safe 29;<=LOT 4.Lazy monadic computation of a list of results.7The empty lazy list.8Consing a value to a lazy list.9Singleton lazy list.: Case distinction over lazy list.;+Folding a lazy list, effects left-to-right.<The join operation of the ListT m monad.=We can `run' a computation of a 4 as it is monadic itself.> Monadic cons.?Monadic singleton.@ Extending a monadic function to 4.A!Alternative implementation using ;.B Change from one monad to another456789:;<=>?@ABCDEFGHIJK456789:;<=>?@AB456789:;<=>?@ABKJIHGFEDC456789:;<=>?@ABCDEFGHIJKNoneMAll tests as collected by *z.+q+r+s+t+u+v+wMMM+q+r+s+t+u+v+wMSafeNRead +x+, modify it strictly, and return old value.N +y+z+{+|+}+~++++xNNNSafe+aConverts many character sequences which may be interpreted as line or paragraph separators into '\n'.OKReads a UTF8-encoded text file and converts all Unicode line endings into '\n'.PWrites UTF8-encoded text to the handle, which should be opened for writing and in text mode. The native convention for line endings is used.PThe handle's text encoding is not necessarily preserved, it is changed to UTF8.QQWrites a UTF8-encoded text file. The native convention for line endings is used.+OPQOPQOPQ+OPQSafeR+RRR+SafeSAReturns a close function for the file together with the contents.SSSS-Safe'+++++++++++++++++++++++++++++++++++++++SafeL T?A decoration is a functor that is traversable into any functor.The *nS superclass is given because of the limitations of the Haskell class system.  traverseF actually implies functoriality.Minimal complete definition:  traverseF or  distributeF.U traverseF is the defining property.V%Decorations commute into any functor.X?Composition: pure function after functorial (monadic) function.YThe true pure for loop. ./ is a misnomer, it should be forA.ZInfix version of Y.[#Any decoration is traversable with traverse = traverseF. Just like any +6 is a functor, so is any decoration, given by just  traverseF , a functor.\Any decoration is a lens. set is a special case of dmap.]0A typical decoration is pairing with some stuff.^3Decorations compose. (Thus, they form a category.)_%The identity functor is a decoration. TUVWXYZ[\]^_ TUVWXYZ[\ WXYZTUV[\_^] TUVWXYZ[\]^_W4X9 Z4SafeOT `GVan Laarhoven style homogeneous lenses. Mnemoic: "Lens inner outer".aGet inner part i of structure o as designated by  Lens' i o.bSet inner part i of structure o as designated by  Lens' i o.cModify inner part i of structure o using a function i -> i.dRead a part of the state.eWrite a part of the state.fModify a part of the state.g'Modify a part of the state monadically.h?Modify a part of the state monadically, and return some result.i Ask for part of read-only state.j/Modify a part of the state in a subcomputation. `abcdefghijk Z`abcdefghijk `abcdefghijkZ `abcdefghijka8e4f4g4h4SafeOTl"Simple, non-reentrant memoisation.mRRecursive memoisation, second argument is the value you get on recursive calls.lmlmlmlmSaferC(View source:) This is how you implement a lens for a record field.nopqrsnopqrsnopqrsnopqrsSafeLtRepeat a state transition f :: a -> (b, a) with output b while condition condY on the output is true. Return all intermediate results and the final result where cond is False.(Postconditions (when it terminates): (fst (last (iterWhile cond f a)) == False. $all fst (init (interWhile cond f a)).uRepeat something while a condition on some state is true. Return the last state (including the changes of the last transition, even if the condition became false then).vMonadic version of u.w%A version of the trampoline function.The usual function iterates f :: a -> Maybe a as long as Just{}, is returned, and returns the last value of a upon Nothing.IusualTrampoline f = trampolineWhile $ a -> maybe (False,a) (True,) (f a).trampolineWhile is very similar to  repeatWhileA, only that it discards the state on which the condition went False;, and returns the last state on which the condition was True.xMonadic version of w.yUMore general trampoline, which allows some final computation from iteration state a into result type b.zMonadic version of y.{Iteration to fixed-point.iterateUntil r f a0 iterates endofunction f, starting with a0 , until r( relates its result to its input, i.e., f a r a.9This is the generic pattern behind saturation algorithms.If f is monotone with regard to r , meaning a r b implies f a r f b , and f-chains starting with a09 are finite then iteration is guaranteed to terminate.*A typical instance will work on sets, and r could be set inclusion, and a0 the empty set, and f- the step function of a saturation algorithm.|Monadic version of {.}} n f x applies f to x n times and returns the result.)The applications are calculated strictly.~applyWhen b f a applies f to a when b.applyUnless b f a applies f to a unless b.Monadic version of  applyWhenMonadic version of  applyUnlesstuvwxyz{|}~tuvwxyz{|}~tuvwxyz{|}~tuvwxyz{|}~SafeM &Classification of identifier variants.Identifier ends in Int many primes.Identifier ends in number Int (ordinary digits).Identifier ends in number Int (subscript digits).'Is the character one of the subscripts ' '-' '? Converts '0'-'9' to ' '-' '.-Precondition: The digit needs to be in range. Converts ' '-' ' to '0'-'9'.-Precondition: The digit needs to be in range.?Increase the suffix by one. If no suffix yet, put a subscript 1. Parse suffix. Print suffix.Add first available Suffix to a name.  Is the given name already taken?+Name of which we want an available variant.2Name extended by suffix that is not taken already.  None0I%Paths which are known to be absolute.Note that the + and +WS instances do not check if different paths point to the same files or directories. Extract the  to be used as +.+WThe paths have to be absolute, valid and normalised, without trailing path separators. Constructs s.2Precondition: The path must be absolute and valid.maps blablabla foo.bar.xxx to foo.bar.Makes the path absolute.This function may raise an __IMPOSSIBLE__ error if +" does not return an absolute path.PTries to establish if the two file paths point to the same file (or directory).!Case-sensitive doesFileExist for Windows. This is case-sensitive only on the file name part, not on the directory part. (Ideally, path components coming from module name components should be checked case-sensitively and the other path components should be checked case insenstively.)++++++++++4None-Hashing a module name for unique identifiers.Safe9;AWe cannot define data constructors synonymous, so we define the  mkExceptT6 function to be used instead of the data constructor ExceptT. To simulate MaybeT by ExceptT.#A string can be thrown as an error.   Safe++++++++++!SafeC"Safe Loop while we have an exception.Monadic version of +$ with a different argument ordering.+ is a bifunctor.'Either _ b' is a functor.'Either a' is a functor.+ is bitraversable.Returns *x iff the argument is + x for some x. Note: from base >= 4.7.0.0 already present in  Data.Either.Returns *x iff the argument is + x for some x. Note: from base >= 4.7.0.0 already present in  Data.Either. Analogue of 01. Analogue of 01.Safe projection from +. G maybeLeft (Left a) = Just a maybeLeft Right{} = Nothing Safe projection from +. K maybeRight (Right b) = Just b maybeRight Left{} = Nothing Returns *w inputwith tags stripped if all elements are to the +, and otherwise +X.Returns *w inputwith tags stripped2 if all elements are to the right, and otherwise +X. d allRight xs == if all isRight xs then Just (map ((Right x) -> x) xs) else Nothing ++#None+Characteristic identifiers.Given a function f :: a -> (C,[C])6 which returns a non-empty list of characteristics C of a, partition a list of as into groups such that each element in a group shares at least one characteristic with at least one other element of the group.Partition a list of as paired with a non-empty list of characteristics $C$ into groups such that each element in a group shares at least one characteristic with at least one other element of the group.+9Not too many clusters. (Algorithm equated all it could.)iEach element in a cluster shares a characteristic with at least one other element in the same cluster.+;Not too few clusters. (Algorithm did not equate too much.)8Elements of different clusters share no characteristics.+ An example.."anabel" is related to "babel" (common letter aB in 2-letter prefix) which is related to "bond" (common letter b).:"hurz", "furz", and "kurz" are all related (common letter u).+5Modified example (considering only the first letter).++++++++++++++++++++++++++++++++$SafeUnicode characters are divided into letters, numbers, marks, punctuation, symbols, separators (including spaces) and others (including control characters).These are the tests that 23 offersConvert a character in '0'..'9' into the corresponding digit 0..9.Convert a character in '0'..'9','A'..'F','a'..'f'! into the corresponding digit 0..15.Convert a character in '0'..'7' into the corresponding digit 0..7.,Test names paired with their implementation.+Find out which tests a character satisfies.%None09;ILM Finite bijective map from a to b. There, and back again.Lookup. O(log n).Inverse lookup. O(log n).Empty bimap. O(1).Singleton bimap. O(1)..Insert. Overwrites existing value if present. Left-biased Union. O(Map.union).Construct from a list of pairs.@Does not check for actual bijectivity of constructed finite map.2Turn into list, sorted ascendingly by first value.&NoneT YA set with duplicates. Faithfully stores elements which are equal with regard to (==).bag ! a finds all elements equal to a.-Return the multiplicity of the given element. "insert a b = union b (singleton a) !fromList = unions . map singleton:Returns the elements of the bag, grouped by equality (==).!Returns the bag, with duplicates.#Returns the bag without duplicates.!Returns the bag, with duplicates.All tests as collected by *z.Using *z| is convenient and superior to the manual enumeration of tests, since the name of the property is added automatically.'     #     '     %     'NoneM, Result of 8.First list is prefix of second.First list is suffix of second.The lists are equal.The lists are incomparable.4Case distinction for lists, with list first. Cf. +4.+Case distinction for lists, with list last. Head function (safe).!5Head function (safe). Returns a value on empty lists. >headWithDefault 42 [] = 42 headWithDefault 42 [1,2,3] = 1"Last element (safe).#Opposite of cons (:), safe.$Maybe cons. "mcons ma as = maybeToList ma ++ as%+ and + in one go, safe.&!Lookup function (partially safe).'downFrom n = [n-1,..1,0](1Update the first element of a list, if it exists.+0Update the last element of a list, if it exists..OUpdate nth element of a list, if it exists. Precondition: the index is >= 0.1A generalized version of  partition . (Cf. mapMaybe vs. filter).3A generalized version of  takeWhile . (Cf. mapMaybe vs. filter).4A generalized version of span.5Partition a list into +Xs and *ws. +i f = snd . partitionMaybe f.6Sublist relation.7OCheck if a list has a given prefix. If so, return the list minus the prefix.83Compare lists with respect to prefix partial order.9FSplit a list into sublists. Generalisation of the prelude function words. words xs == wordsBy isSpace xs:+Chop up a list in chunks of a given length.;FChop a list at the positions when the predicate holds. Contrary to 9, consecutive separator elements will result in an empty segment in the result. > intercalate [x] (chopWhen (== x) xs) == xs=-All ways of removing one element from a list.>Check whether a list is sorted.Assumes that the +W% instance implements a partial order.?UCheck whether all elements in a list are distinct from each other. Assumes that the +. instance stands for an equivalence relation.@An optimised version of ?./Precondition: The list's length must fit in an +.BDChecks if all the elements in the list are equal. Assumes that the +- instance stands for an equivalence relation.CZReturns an (arbitrary) representative for each list element that occurs more than once.D A variant of +3 which applies the predicate to consecutive pairs.FF f = + ((+ ) `on` f) + + (+ `on` f).G#splitExactlyAt n xs = Just (ys, zs) iff  xs = ys ++ zs and genericLength ys = n.HI n xs gives the n-th element in xsD (counting from 0), plus the remaining elements (preserving order).KA generalised variant of +.M,Requires both lists to have the same length.OEfficient variant of + for finite lists.Specification: )nubOn f xs == 'nubBy' ((==) `'on'` f) xs.QEfficient variant of + for finite lists.Specification: For each list xs there is a list ys which is a permutation of xs such that *uniqOn f xs == 'nubBy' ((==) `'on'` f) ys. Furthermore 5sortBy (compare `on` f) (uniqOn f xs) == uniqOn f xs.T'Compute the common suffix of two lists.U'Compute the common prefix of two lists.E !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[E !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[E !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[A !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[None] Binary bind.^when_ is just Control.Monad.when with a more general type._unless_ is just Control.Monad.unless with a more general type.bMonadic if-then-else.c ifNotM mc = ifM (not  $ mc)dLazy monadic conjunction.gLazy monadic disjunction.jLazy monadic disjunction with Either truth values.kGeneralized version of .mapM_ :: Monad m => (a -> m ()) -> [a] -> m ()n Executes effects and collects results in left-to-right order. Works best with left-associative monoids.!Note that there is an alternative !mapM' f t = foldr mappend mempty  $ mapM f tthat collects results in right-to-left order (effects still left-to-right). It might be preferable for right associative monoids.lGeneralized version of .forM_ :: Monad m => [a] -> (a -> m ()) -> m ()m56- for the continuation monad. Terribly useful.n-Requires both lists to have the same lengths.oA monadic version of +i :: (a -> Maybe b) -> [a] -> [b].pThe for version of o.qA monadic version of + :: (a -> Bool) -> [a] -> [a].rFinally for the F class. Errors in the finally part take precedence over prior errors.s;Bracket without failure. Typically used to preserve state.t Restore state after computation.\]^_`abcdefghijklmnopqrsAcquires resource. Run first.Releases resource. Run last. Computes result. Run in-between.tu#\]^_`abcdefghijklmnopqrstu#]^_`abcdefghijkl\mnopqrstu\]^_`abcdefghijklmnopqrstu(None9:;<=OT vThe parser type.The parameters of the type Parser k r tok a have the following meanings: kType used for memoisation keys.rTThe type of memoised values. (Yes, all memoised values have to have the same type.)tokThe token type.aThe result type.+Memoised values.+Continuations.+State monad used by the parser.+ Positions.wRuns the parser.xParses a single token.y.Parses a token satisfying the given predicate.zParses a given token.{3Parses one or more things, separated by separators.0Combines the results in a right-associative way.|3Parses one or more things, separated by separators./Combines the results in a left-associative way.}Memoises the given parser./Every memoised parser must be annotated with a uniqueI key. (Parametrised parsers must use distinct keys for distinct inputs.)v+++++++++wxyz{Parser for a thing.Parser for a separator.|Parser for a thing.Parser for a separator.}~vwxyz{|}vwxzy|{}v+++++++++wxyz{|}~)NoneI adds double quotes around the string, replaces newline characters with nh, and escapes double quotes and backslashes within the string. This is different from the behaviour of +: > + $ + "\x2200" "\8704" > + $  "\x2200" """ V(The code examples above have been tested using version 4.2.0.0 of the base library.)FShows a non-negative integer using the characters - instead of 0-9.1Adds a final newline if there is not already one.-Indents every line the given number of steps.6Show a number using comma to separate powers of 1,000.Remove leading whitespace.Remove trailing whitespace.'Remove leading and trailing whitesapce.    *NoneI"CPU time in pico (10^-12) seconds. Timestamps.The current time.OMeasure the time of a computation. Of course, does not work with exceptions.(Print CPU time in milli (10^-3) seconds.+None6 Satisfying null empty == True.A *v is ' when it corresponds to the empty list. ,None4IT;Result of comparing a candidate with the current favorites.xGreat, you are dominating a possibly (empty list of favorites) but there is also a rest that is not dominated. If null dominated, then  notDominated2 is necessarily the complete list of favorites..Sorry, but you are dominated by that favorite.!A list of incomparable favorites.Gosh, got some pretty a here, compare with my current favorites! Discard it if there is already one that is better or equal. (Skewed conservatively: faithful to the old favorites.) If there is no match for it, add it, and dispose of all that are worse than a.FWe require a partial ordering. Less is better! (Maybe paradoxically.)Compare a new set of favorites to an old one and discard the new favorites that are dominated by the old ones and vice verse. (Skewed conservatively: faithful to the old favorites.) 'compareFavorites new old = (new', old'))After comparing, do the actual insertion.%Compare, then insert accordingly. :insert a l = insertCompared a l (compareWithFavorites a l)=Insert all the favorites from the first list into the second.Construct favorites from elements of a partial order. The result depends on the order of the list if it contains equal elements, since earlier seen elements are favored over later seen equals. The first element of the list is seen first.A second way to compute the  is to use . forms a + under  and 'union.LEquality checking is a bit expensive, since we need to sort! Maybe use a Set! of favorites in the first place?All tests as collected by *z.Using *z| is convenient and superior to the manual enumeration of tests, since the name of the property is added automatically.-None (29:;ILT5 SCC DAGs.0The maps map SCC indices to and from SCCs/nodes.For homogeneous graphs, (s = t)& we can compute a set of all nodes. Structure Nodes is for computing all nodes but also remembering which were incoming and which outgoing. This is mostly for efficiency reasons, to avoid recomputation when all three sets are needed.Outgoing node.Incoming node.Edge label (weight). Graph s t e- is a directed graph with source nodes in s target nodes in t and edges in e.nAdmits at most one edge between any two nodes. Several edges can be modeled by using a collection type for e.uRepresented as "adjacency list", or rather, adjacency map. This allows to get all outgoing edges for a node in O(log n) time where n% is the number of nodes of the graph.'Incoming edges can only be computed in O(n + e) time where e is the number of edges.Forward edges.Reverse an edge.$Turn a graph into a list of edges. O(n + e)\All edges originating in the given nodes. (I.e., all outgoing edges for the given nodes.)0Roughly linear in the length of the result list  O(result).WAll edges ending in the given nodes. (I.e., all incoming edges for the given nodes.) Expensive: O(n * |ts| * log n).Get all self-loops.Lookup label of an edge.)Get a list of outgoing edges with target.)Get a list of outgoing edges with target.,Returns all the nodes with outgoing edges. O(n).7Returns all the nodes with incoming edges. Expensive! O(e).-The set of all nodes (outgoing and incoming).JConstructs a completely disconnected graph containing the given nodes. O(n).4Constructs a graph from a list of edges. O(e log n)$Later edges overwrite earlier edges.4Constructs a graph from a list of edges. O(e log n)HLater edges are combined with earlier edges using the supplied function.*Convert a graph into a list of edges. O(e)vCheck whether the graph is discrete (no edges). This could be seen as an empty graph. Worst-case (is discrete): O(e).Removes  edges (and empty +s).!Empty graph (no nodes, no edges).4A graph with two nodes and a single connecting edge.Insert an edge into the graph.#Insert an edge, possibly combining old edge weight with new weight by given function f into  f new old.Left-biased union.+-The opposite graph (with all edges reversed).+*Auxiliary function to turn empty map into Nothing.+KRemoves the given source node, and all corresponding edges, from the graph. O(log n).+KRemoves the given target node, and all corresponding edges, from the graph. Expensive!  O(n log n)._Removes the given node, be it source or target, and all corresponding edges, from the graph. Expensive!  O(n log n).removeEdge s t g removes the edge going from s to t , if any. O((log n)^2).1Keep only the edges that satisfy the predicate. O(e).4Unzipping a graph (naive implementation using fmap).HMaps over a graph under availability of positional information, like +.IThe graph's strongly connected components, in reverse topological order.IThe graph's strongly connected components, in reverse topological order. invariant.The opposite DAG. 'The nodes reachable from the given SCC. GConstructs a DAG containing the graph's strongly connected components. GConstructs a DAG containing the graph's strongly connected components. Returns True iff the graph is acyclic. reachableFrom g n/ is a map containing all nodes reachable from n in g. For each node a simple path to the node is given, along with its length (the number of edges). The paths are as short as possible (in terms of the number of edges).Precondition: n must be a node in g<. The number of nodes in the graph must not be larger than + :: +.KAmortised time complexity (assuming that comparisons take constant time):  O(e log n)j, if the lists are not inspected. Inspection of a prefix of a list is linear in the length of the prefix.#walkSatisfying every some g from to% determines if there is a walk from from to to in g/, in which every edge satisfies the predicate every(, and some edge satisfies the predicate someg. If there are several such walks, then a shortest one (in terms of the number of edges) is returned.Precondition: from and to must be nodes in g<. The number of nodes in the graph must not be larger than + :: +.iAmortised time complexity (assuming that comparisons and the predicates take constant time to compute):  O(e log n).composeWith times plus g g' finds all edges s --c_i--> t_i --d_i--> u) and constructs the result graph from !edge(s,u) = sum_i (c_i times d_i).Complexity: for each edge s --> t in g, we lookup up all edges starting in with t in g'.Transitive closure ported from Agda.Termination.CallGraph.%Relatively efficient, see Issue 1560.+ Version of ~ that produces a list of intermediate results paired to the left with a difference that lead to the new intermediat result.TThe last element in the list is the transitive closure, paired with the empty graph. (complete g = snd $ last $ completeIter g-Computes the transitive closure of the graph.Uses the Gauss-Jordan-Floyd-Warshall-McNaughton-Yamada algorithm (as described by Russell O'Connor in "A Very General Method of Computing Shortest Paths"  'http://r6.ca/blog/20110808T035622Z.html), implemented using matrices.4The resulting graph does not contain any zero edges.JThis algorithm should be seen as a reference implementation. In practice ! is likely to be more efficient.-Computes the transitive closure of the graph.Uses the Gauss-Jordan-Floyd-Warshall-McNaughton-Yamada algorithm (as described by Russell O'Connor in "A Very General Method of Computing Shortest Paths"  'http://r6.ca/blog/20110808T035622Z.html), implemented using , and with some shortcuts:SZero edge differences are not added to the graph, thus avoiding some zero edges.MStrongly connected components are used to avoid computing some zero edges.yThe graph's strongly connected components (in reverse topological order) are returned along with the transitive closure.I++++  *The graph's strongly connected components.   +A     A     ;++++     +.None/05<= Analogous to 78 in  Data.Maybe.  Analogous to 79 in  Data.Maybe.! Analogous to 7: in  Data.Maybe." Analogous to 7; in  Data.Maybe.# unionWith for collections of size <= 1.$ Unzipping a list of length <= 1.%Filtering a singleton list. filterMaybe p a =  (+h p [a])& Version of "" with different argument ordering.' Version of +B with different argument ordering. Often, we want to case on a +%, do something interesting in the +( case, but only a default action in the +* case. Then, the argument ordering of  caseMaybe is preferable. (caseMaybe m err f = flip (maybe err) m f(Monadic version of +.)Monadic version of +.*Monadic version of '. That is, ($ with a different argument ordering.+* with flipped branches.,A more telling name for +< for the + collection type. Or: ' without the + case.-* without the + case. !"#$%&'()*+,-./012345++++++++ !"#$%&'()*+,-543210/. !"#$%&'()*+,- !"#$%&'()*+,-./012345/None8^Thing decorated with its size. The thing should fit into main memory, thus, the size is an Int.<,The size of a collection (i.e., its length).Should fit into an Int. TODO: change to Int.>Cache the size of an object.@Return the cached size.89:;<=>?@ABCDEFGH89:;<=><=89:;> 89:;<=>?@ABCDEFGH0NoneILMIFinite map from [k] to v.With the strict *v type, I is also strict in v.+"Helper function used to implement J and K.JSingleton trie.KeveryPrefix k v! is a trie where every prefix of k (including k itself) is mapped to v.LLeft biased union.#union = unionWith ( new old -> new).M/Pointwise union with merge function for values.N.Insert. Overwrites existing value if present. %insert = insertWith ( new old -> new)O6Insert with function merging new value with old value.P.Delete value at key, but leave subtree intact.Q*Adjust value at key, leave subtree intact.RConvert to ascending list.SConvert to ascending list.T8Returns the value associated with the given key, if any.U%Is the given key present in the trie?V&Collect all values along a given path.\ Empty trie.d All tests."++++++I++JKLMNOPQRSTUV++++,WXYZ[\dIJKLMNOPQRSTUVdIJKNOLMQPRSTUVd++++++I++JKLMNOPQRSTUV++++,WXYZ[\d1None9;<=?Le'Monad with access to benchmarking data.jEWe need to be able to terminate benchmarking in case of an exception.kqBenchmark structure is a trie, mapping accounts (phases and subphases) to CPU time spent on their performance.mAre we benchmarking at all?n!What are we billing to currently?o/The accounts and their accumulated timing bill.q3Record when we started billing the current account.r(Account we can bill computation time to.sSemantic editor combinator.tSemantic editor combinator.uSemantic editor combinator.v"Add to specified CPU time account.wTurn benchmarking on/off.xcBill current account with time up to now. Switch to new account. Return old account (if any).y.Resets the account and the timing information.zfBill a computation to a specific account. Works even if the computation is aborted by an exception.{.Bill a pure computation to a specific account.~0Print benchmark as two-column table with totals.$Initial benchmark structure (empty).efghijklmnopqrstuvwxMaybe new account.Maybe old account.yz{|}~ejfghiklmnopqrstuvwxyz{rqpklmnostuv~efghij}|wxyz{efghijklmnopqrstuvwxyz{|}~2NoneL ,A finite map, represented as a set of pairs.%Invariant: at most one value per key.O(n). Reexport ,.9O(n). Get the domain (list of keys) of the finite map.JO(1). Add a new binding. Assumes the binding is not yet in the list.O(n). Update the value at a key. The key must be in the domain of the finite map. Otherwise, an internal error is raised.O(n). Update the value at a key with a certain function. The key must be in the domain of the finite map. Otherwise, an internal error is raised.<O(n). Map over an association list, preserving the order.{O(n). If called with a effect-producing function, violation of the invariant could matter here (duplicating effects).O(n). Named in analogy to =>u. To preserve the invariant, it is sufficient that the key transformation is injective (rather than monotonic).    3None<=Semiring with idempotent , == dioid 4None 2349;<=?I4The flexibe variables contained in a pice of syntax.2The rigid variables contained in a pice of syntax.)Make offsets non-negative by rounding up.Offsets + n must be non-negativeExecuting a substitution.@Partial substitution from flexible variables to size expression.*Type of solution wanted for each flexible.,Assigning a polarity to a flexible variable.)What type of solution are we looking for?<Constraint: an inequation between size expressions, e.g. X < " or  i + 3 "d j..Comparison operator, e.g. for size expression.<."d.*Size expressions appearing in constraints.Constant number n.Variable plus offset i + n. Infinity ".Meta variable X + n.Size meta variables X to solve for.Fixed size variables i.Constant finite sizes n >= 0.Default polarity is .Returns +X' if we have a contradictory constraint. acts as *x,  as ,. Interpret  as relation on .Add offset to size expression.Comparison operator is ordered  < .P2R6 5None 9:;<=LMT#,Lower or upper bound for a flexible variable A graph forest. Going from Lt to Le is pred , going from Le to Lt is succ.X --(R,n)--> Y means  X (R) Y + n#. [ ... if n positive and X + (-n) (R) Y if n negative. ]Nodes not connected.4Test for negativity, used to detect negative cycles.$1Compute list of edges that start in a given node.%/Compute list of edges that target a given node.9Note: expensive for unidirectional graph representations.& Set.foldl* does not exist in legacy versions of the  containers package.'Floyd-Warshall algorithm.(5Convert a label to a weight, decrementing in case of ..Split a list of graphs gs into those that mention node n and those that do not. If n6 is zero or infinity, we regard it as "not mentioned"./TAdd an edge to a graph forest. Graphs that share a node with the edge are joined.0Reflexive closure. Add edges 0 -> n -> n -> oo for all nodes n.1h 1 g if any edge in gG between rigids and constants is implied by a corresponding edge in h", which means that the edge in g/ carries at most the information of the one in h.SApplication: Constraint implication: Constraints are compatible with hypotheses.42Build a graph from list of simplified constraints.52Build a graph from list of simplified constraints.;If we have an edge  X + n <= X (with n >= 0), we must set X = oo.=2Compute a lower bound for a flexible from an edge.>3Compute an upper bound for a flexible from an edge.?6Compute the lower bounds for all flexibles in a graph.@6Compute the upper bounds for all flexibles in a graph.A0Compute the bounds for all flexibles in a graph.BcCompute the relative minima in a set of nodes (those that do not have a predecessor in the set).CaCompute the relative maxima in a set of nodes (those that do not have a successor in the set).DGiven source nodes n1,n2,... find all target nodes m1,m2, such that for all j, there are edges n_i --l_ij--> m_j for all i. Return these edges as a map from target notes to a list of edges. We assume the graph is reflexive-transitive.EGiven target nodes m1,m2,... find all source nodes n1,n2, such that for all j, there are edges n_i --l_ij--> m_j for all i. Return these edges as a map from target notes to a list of edges. We assume the graph is reflexive-transitive.FBCompute the sup of two different rigids or a rigid and a constant.GBCompute the inf of two different rigids or a rigid and a constant.H$Compute the least upper bound (sup).I]Compute the greatest lower bound (inf) of size expressions relative to a hypotheses graph.LhSolve a forest of constraint graphs relative to a hypotheses graph. Concatenate individual solutions.MXCheck that after substitution of the solution, constraints are implied by hypotheses.W A graph is U if it contains a negative loop (diagonal edge). Makes sense on transitive graphs.[$An edge is negative if its label is.kPartial implementation of Num.u      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopT      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOu !"#$%&'ponmlkjihgf(edcba`_^]    \)*+,[ZYX -./0WV123456789:;UTSRQP<=>?@ABCDEFGHIJKLMNOe      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnop6NoneProperties of  class.Weight instance.Label instance.2Runs all tests starting with "prop_" in this file.!tuvwxyz{|}~tuvwxyz{|}~!vtuwxyz{|}~ tuvwxyz{|}~7Safe  Semirings. Addition.Multiplication.cZero. The one is never used in matrix multiplication , one :: a -- ^ One.HasZero is needed for sparse matrices, to tell which is the element that does not have to be stored. It is a cut-down version of SemiRing, which is definable without the implicit ?cutoff.lSemiRing type class. Additive monoid with multiplication operation. Inherit addition and zero from Monoid. Semiring invariant.The standard semiring on ,s.The standard semiring on +s.The standard semiring on ,s.,,, ,,,8None #2349;<=?LT9, #This matrix type is used for tests., Transposable things. m extracts the diagonal of m.fFor non-square matrices, the length of the diagonal is the minimum of the dimensions of the matrix.6Type of matrices, parameterised on the type of values.aSparse matrices are implemented as an ordered association list, mapping coordinates to values.Dimensions of the matrix., !Association of indices to values.%Type of matrix indices (row, column). Row index, 1 <= row <= rows. Column index 1 <= col <= cols.Size of a matrix.Number of rows, >= 0.Number of columns, >= 0.,  Convert a I to a set of bounds suitable for use with the matrices in this module.*x iff the matrix is square.Returns *x iff the matrix is empty., 5Compute the matrix size of the union of two matrices.,<Compute the matrix size of the intersection of two matrices.#Constructs a matrix from a list of (index, value) -pairs. O(n) where n is size of the list.!Precondition: indices are unique. sz rsL constructs a matrix from a list of lists of values (a list of rows). O(size) where size = rows cols.Precondition: , rs +  sz and , (( sz +) . ,) rs.,6Converts a sparse matrix to a sparse list of rows. O(n) where n1 is the number of non-zero entries of the matrix."Only non-empty rows are generated.,4Alternative implementation, serves as specification.,`Turn a sparse vector into a vector by inserting a fixed element at the missing positions. O(size) where size is the dimension of the vector.-Converts a matrix to a list of row lists. O(size) where size = rows cols.<Returns 'Just b' iff it is a 1x1 matrix with just one entry b. O(1).,AGeneral pointwise combination function for association lists.  O(n1 + n2) where ni- is the number of non-zero element in matrix i.In zipAssocWith fs gs f g h l l',fs* is possibly more efficient version of +i ( (i, a) -> (i,)  $ f a), and same for gs and g., Instance of ,$ which keeps longer assoc lists.  O(n1 + n2).?General pointwise combination function for sparse matrices.  O(n1 + n2). (+) m1 m2 adds m1 and m2, using (+) to add values.  O(n1 + n2).Returns a matrix of size ,  m1 m2. f m1 m2! build the pointwise conjunction m1 and m2 . Uses f to combine non-zero values.  O(n1 + n2).Returns a matrix of size  infSize m1 m2.,"Association list intersection.  O(n1 + n2). AinterAssocWith f l l' = { (i, f a b) | (i,a) " l and (i,b) " l' }HUsed to combine sparse matrices, it might introduce zero elements if f( can return zero for non-zero arguments. semiring m1 m2 multiplies matrices m1 and m2). Uses the operations of the semiring semiring" to perform the multiplication.0O(n1 + n2 log n2 + (i <= r1) (j <= c2) d(i,j)) where r1$ is the number of non-empty rows in m1 and c2' is the number of non-empty columns in m2 and d(i,j)Q is the bigger one of the following two quantifies: the length of sparse row i in m1$ and the length of sparse column j in m2.Given dimensions  m1 : r1 c1 and  m2 : r2 c2, a matrix of size r1 c2* is returned. It is not necessary that c1 == r2, the matrices are implicitly patched with zeros to match up for multiplication. For sparse matrices, this patching is a no-op. x m adds a new column to m`, after the columns already existing in the matrix. All elements in the new column get set to x. x m adds a new row to mY, after the rows already existing in the matrix. All elements in the new row get set to x.,Size invariant: dimensions are non-negative.Indices must be positive, >= 1.eMatrix indices are lexicographically sorted with no duplicates. All indices must be within bounds.,[Check whether an association list is ordered and deterministic, a partial function from i to b.VGenerates a matrix of the given size, using the given generator to generate the rows.%Generates a matrix of the given size.,, is identity on well-formed sparse matrices.,@Converting a matrix to a list of lists and back is the identity.,Any 1x1 matrix is a singleton.,]The length of the diagonal is the minimum of the number of rows and columns of the matrix.,"Transposing twice is the identity.,Old implementation of .,Verify  against older implementation,=Matrix addition is well-defined, associative and commutative., 0Verify addition against an older implementation.The older implementation did not fully preserve sparsity, i.e., introduced zeros. Thus, we need to convert to lists to obtain equal results.,!Specification of ,.,"Efficient implementation of , matches its specification.,#6Matrix multiplication is well-defined and associative.$Generate a matrix of arbitrary size.NPointwise comparison. Only matrices with the same dimension are comparable.Matrix transposition. O(n log n) where n2 is the number of non-zero elements in the matrix.Transposing coordinates.Size of transposed matrix.Diagonal of sparse matrix.O(n) where n2 is the number of non-zero elements in the matrix.Q, , ,$, , , ,,,,%,,&,Only left map remaining.Only right map remaining.!Element only present in left map."Element only present in right map.Element present in both maps.,!Element only present in left map."Element only present in right map.Element present in both maps.$Element only present in left matrix.%Element only present in right matrix.!Element present in both matrices.Result counts as zero?,,',(,),*,+,,,-,6The generator is parameterised on the size of the row.,.,/,,,,,,$Element only present in left matrix.%Element only present in right matrix.!Element present in both matrices.Result counts as zero?,,, ,!,",# F, , ,$, , , ,,,,%,,&,,,,',(,),*,+,,,-,,.,/,,,,,,,,, ,!,",#9SafeICut off structural order comparison at some depth in termination checker?c >= 0( means: record decrease up to including c+1.:None9;\A partial order, aimed at deciding whether a call graph gets worse during the completion.:In the paper referred to above, there is an order R with ,0 ,1 Le ,1 Lt.This is generalized to ,0 ,1 'Decr k' where Decr 1 replaces Lt and Decr 0 replaces Le. A negative decrease means an increase. The generalization allows the termination checker to record an increase by 1 which can be compensated by a following decrease by 2 which results in an overall decrease.However, the termination checker of the paper itself terminates because there are only finitely many different call-matrices. To maintain termination of the terminator we set a cutoff point which determines how high the termination checker can count. This value should be set by a global or file-wise option.See Call for more information.9TODO: document orders which are call-matrices themselves.,22Decrease of callee argument wrt. caller parameter.,0ENo relation, infinite increase, or increase beyond termination depth.&Matrix-shaped order, currently UNUSED.$Raw increase which does not cut off.$Raw decrease which does not cut off.Smart constructor for Decr k :: Order which cuts off too big values.Possible values for k:  - ?cutoff ,1 k ,1 ?cutoff + 1.RSmart constructor for matrix shaped orders, avoiding empty and singleton matrices.le, lt,  decreasing, unknown4: for backwards compatibility, and for external use.HMatrix-shaped order is decreasing if any diagonal element is decreasing.Multiplication of ,s. (Corresponds to sequential composition.)+The supremum of a (possibly empty) list of ;s. More information (i.e., more decrease) is bigger. ,0# is no information, thus, smallest.,3(, ,3, ) forms a semiring, with ,0 as zero and Le as one.%The infimum of a (non empty) list of s. ,0& is the least element, thus, dominant./We assume the matrices have the same dimension.It does not get worse then ` increase'C. If we are still decreasing, it can get worse: less decreasing.Information order: ,0M is least information. The more we decrease, the more information we have.When having comparable call-matrices, we keep the lesser one. Call graph completion works toward losing the good calls, tending towards Unknown (the least information).&,2,0,4,5,6,7,8,3,9,:",2,0,4,5,6,7,8,3,9,:;None /2349;<=IVSets of incomparable call matrices augmented with path information. Use overloaded , , f, ,;.,Call matrix augmented with path information."The matrix of the (composed call).Meta info, like call path.0Call matrix multiplication and call combination. Call matrices.A call matrix for a call f --> g has dimensions  ar(g) ar(f).9Each column corresponds to one formal argument of caller f9. Each row corresponds to one argument in the call to g.FIn the presence of dot patterns, a call argument can be related to several different formal arguments of f. See e.g. testsucceedDotPatternTermination.agda:  data D : Nat -> Set where cz : D zero c1 : forall n -> D n -> D (suc n) c2 : forall n -> D n -> D n f : forall n -> D n -> Nat f .zero cz = zero f .(suc n) (c1 n d) = f n (c2 n d) f n (c2 .n d) = f n d 'Call matrices (without guardedness) are  -1 -1 n < suc n and n < c1 n d ? = c2 n d <= c1 n d = -1 n <= n and n < c2 n d ? -1 d < c2 n d `Here is a part of the original documentation for call matrices (kept for historical reasons):This datatype encodes information about a single recursive function application. The columns of the call matrix stand for sourceD function arguments (patterns). The rows of the matrix stand for target function arguments. Element (i, j)0 in the matrix should be computed as follows: (less than) if the j-th argument to the target; function is structurally strictly smaller than the i-th pattern. (less than or equal) if the j-th argument to the target+ function is structurally smaller than the i-th pattern. otherwise.0Call matrix indices = function argument indices.Machine integer +^ is sufficient, since we cannot index more arguments than we have addresses on our machine.Non-augmented call matrix.Insert into a call matrix set.Union two call matrix sets./Convert into a list of augmented call matrices.*Generates a call matrix of the given size.1Call matrix set product is the Cartesian product.%Augmented call matrix multiplication. Call matrix multiplication.f --(m1)--> g --(m2)--> h is combined to f --(m2  m1)--> h9Note the reversed order of multiplication: The matrix c1 of the second call g-->h in the sequence  f-->g-->h is multiplied with the matrix c2 of the first call.Preconditions: m1 has dimensions  ar(g) ar(f). m2 has dimensions  ar(h) ar(g).Postcondition:  m1 >*< m2 has dimensions  ar(h) ar(f).!      !     !    !        !<None/IL3gA call graph is a set of calls. Every call also has some associated meta information, which should be +bal so that the meta information for different calls can be combined when the calls are combined.6Calls are edges in the call graph. It can be labelled with several call matrices if there are several pathes from one function to another.7Call graph nodes.Machine integer +T is sufficient, since we cannot index more than we have addresses on our machine.9!Make a call with a single matrix.:Make a call with empty cinfo.;@Returns all the nodes with incoming edges. Somewhat expensive. O(e).<MConverts a call graph to a list of calls with associated meta information.=MConverts a list of calls with associated meta information to a call graph.>#Takes the union of two call graphs.?!Inserts a call into a call graph.,<Call graph combination.Application of   to all pairs (c1,c2) for which  c1 =  c2.)@"Call graph comparison. A graph cs' is `worse' than csy if it has a new edge (call) or a call got worse, which means that one of its elements that was better or equal to Le moved a step towards Un.A call graph is complete if combining it with itself does not make it any worse. This is sound because of monotonicity: By combining a graph with itself, it can only get worse, but if it does not get worse after one such step, it gets never any worse.@ cs completes the call graph csB. A call graph is complete if it contains all indirect calls; if f -> g and g -> h are present in the graph, then f -> h should also be present.,=Generates a call graph.C?Displays the recursion behaviour corresponding to a call graph.F3 is a monoid under >.G: checks whether the call graph is completely disconnected.,>,?,@3456789:;<=>?,<@A,=BCDEFG 3456789:;<=>?@AB769:8 345;=<>?@AB,>,?,@3456789:;<=>?,<@A,=BCDEFG=None ,A8The call graph instantiation used by the examples below.J2TODO: This comment seems to be partly out of date.J cs( checks if the functions represented by cs terminate. The call graph cs should have one entry (6&) per recursive function application.+ perms: is returned if the functions are size-change terminating.,If termination can not be established, then + problems is returned instead. Here problemsG contains an indication of why termination cannot be established. See lexOrder for further details.KNote that this function assumes that all data types are strictly positive.The termination criterion is taken from Jones et al. In the completed call graph, each idempotent call-matrix from a function to itself must have a decreasing argument. Idempotency is wrt. matrix multiplication.This criterion is strictly more liberal than searching for a lexicographic order (and easier to implement, but harder to justify).MA call c! is idempotent if it is an endo ( == ) of order 1. (Endo-calls of higher orders are e.g. argument permutations). We can test idempotency by self-composition. Self-composition c >*< c: should not make any parameter-argument relation worse.,B'Constructs a call graph. No meta info.,C"The example from the JFP'02 paper.,DOAn example which is now handled by this algorithm: argument swapping addition. S x + y = S (y + x)  Z + y = y,EgA related example which is anyway handled: argument swapping addition using two alternating functions. S x + y = S (y +' x)  Z + y = y S x +' y = S (y + x)  Z +' y = y,FA contrived example. f (S x) y = f (S x) y + g x y  f Z y = y  g x y = f x ygTODO: This example checks that the meta information is reported properly when an error is encountered.,GThis should terminate. )f (S x) (S y) = g x (S y) + f (S (S x)) y )g (S x) (S y) = f (S x) (S y) + g x (S y),H"Another example which should fail. f (S x) = f x + f (S x)  f x = f xgTODO: This example checks that the meta information is reported properly when an error is encountered.,AJKL,I,JM,K,B,C,L,D,M,E,N,F,O,G,P,H,Q,R,SNJKLMNJKLMN,AJKL,I,JM,K,B,C,L,D,M,E,N,F,O,G,P,H,Q,R,SN>None 023459;IT<P=Killing the range of an object sets all range information to .R;If it is also possible to set the range, this is the class.Instances should satisfy U (S r x) == r.T5Things that have a range are instances of this class.V1Wrapper to indicate that range should be printed.YA range is a file name, plus a sequence of intervals, assumed to point to the given file. The intervals should be consecutive and separated.1Note the invariant which ranges have to satisfy: o.\An interval. The iEnd* position is not included in the interval.4Note the invariant which intervals have to satisfy: j.c Represents a point in the input.If two positions have the same e and f components, then the final two components should be the same as well, but since this can be hard to enforce the program should not rely too much on the last two components; they are mainly there to improve error messages for the user.4Note the invariant which positions have to satisfy: i.eFile.fPosition, counting from 1.gLine number, counting from 1.hColumn number, counting from 1.,T Sets the e components of the interval.k6Converts a file name and two positions to an interval.,UThe length of an interval.lTThe intervals that make up the range. The intervals are consecutive and separated (n).m8Turns a file name plus a list of intervals into a range.Precondition: n.n}Are the intervals consecutive and separated, do they all point to the same file, and do they satisfy the interval invariant?oRange invariant.p"The file the range is pointing to.q%Conflate a range to its right margin.r*Remove ranges in keys and values of a map.,V;The first position in a file: position 1, line 1, column 1.;The first position in a file: position 1, line 1, column 1.$Ranges between two unknown positions?Advance the position by one character. A newline character ('\n'~) moves the position to the first character in the next line. Any other character moves the position to the next column.!Advance the position by a string.  movePosByString = foldl' movePos%Backup the position by one character.(Precondition: The character must not be '\n'.Extracts the interval corresponding to the given string, assuming that the string starts at the beginning of the given interval.?Precondition: The string must not be too long for the interval.Removes the interval corresponding to the given string from the given interval, assuming that the string starts at the beginning of the interval.?Precondition: The string must not be too long for the interval.2Converts a file name and two positions to a range."Converts two positions to a range.;Precondition: The positions have to point to the same file.,W0Converts a file name and an interval to a range.,X-Converts a range to an interval, if possible.gConverts a range to an interval, if possible. Note that the information about the source file is lost.?Returns the shortest continuous range containing the given one.0Removes gaps between intervals on the same line.*The initial position in the range, if any.*The initial position in the range, if any.;The position after the final position in the range, if any.;The position after the final position in the range, if any.,Y4Finds the least interval which covers the arguments.8Precondition: The intervals must point to the same file.fuseRanges r r' unions the ranges r and r'.!Meaning it finds the least range r0 that covers r and r'.CPrecondition: The ranges must point to the same file (or be empty).DPrecondition: The ranges must point to the same file (or be empty). beginningOf rN is an empty range (a single, empty interval) positioned at the beginning of r. If r" does not have a beginning, then  is returned.beginningOfFile rC is an empty range (a single, empty interval) at the beginning of r\'s starting position's file. If there is no such position, then an empty range is returned.x `withRangeOf` y sets the range of x to the range of y.,ZThe positions corresponding to the interval. The positions do not refer to characters, but to the positions between characters, with zero pointing to the position before the first character.,[DThe positions corresponding to the range, including the end-points.,\FConstructs the least interval containing all the elements in the set.,]FGenerates an interval located in the same file as the given interval.,^MGenerates a range located in the same file as the given range (if possible).Overlaps with  KillRange [a].ZPrecondition: The ranges of the tuple elements must point to the same file (or be empty).ZPrecondition: The ranges of the tuple elements must point to the same file (or be empty).ZPrecondition: The ranges of the tuple elements must point to the same file (or be empty).ZPrecondition: The ranges of the tuple elements must point to the same file (or be empty).ZPrecondition: The ranges of the tuple elements must point to the same file (or be empty).ZPrecondition: The ranges of the tuple elements must point to the same file (or be empty).YPrecondition: The ranges of the list elements must point to the same file (or be empty). Test suite.OPQRSTUVWXY,_,`Z[\]^_`abcdefghi,aj,Tk,Ulmnopqrstuvwxyz{|}~,V,W,X,Y,Z,[,\,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,],s,^,t,u,v,wMOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~Ma`cdefghbi[Z\]^_jkXYonmlpqVWTURSPQOrstuvwxyz{|}~OPQRSTUVWXY,_,`Z[\]^_`abcdefghi,aj,Tk,Ulmnopqrstuvwxyz{|}~,V,W,X,Y,Z,[,\,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,],s,^,t,u,v,w?None0 wSubterm occurrences for positivity checking. The constructors are listed in increasing information they provide: 3Mixed <= JustPos <= StrictPos <= GuardPos <= Unused Mixed <= JustNeg <= Unused.-Arbitrary occurrence (positive and negative).Negative occurrence./Positive occurrence, but not strictly positive.Strictly positive occurrence.VGuarded strictly positive occurrence (i.e., under "). For checking recursive records.&The map contains bindings of the form  bound |-> es?, satisfying the following property: for every non-empty list w, ,x v w ,1 bound iff ,y [ , every w ,z ,{ some w | (every, some) <- ess ].+productOfEdgesInBoundedWalk occ g u v bound returns *w e iff there is a walk c (a list of edges) in g, from u to v, for which the product ,x v (,| occ c) ,1 bound#. In this case the returned value e is the product ,x v c for one such walk.Preconditions: u and v must belong to g, and bound must belong to the domain of boundToEverySome.,}#Is the given predicate satisfiable?* is a complete lattice with least element  and greatest element .&It forms a commutative semiring where u is meet (glb) and v0 is composition. Both operations are idempotent.For u,  is neutral (zero) and  is dominant. For v,  is neutral (one) and  is dominant.Tests.,~,,,,,,,,},,,  ,~,,,,,,,,},,,@None(9;I ,A can be used to check if any two nodes in a graph are connected.,4Sample node type used to test some graph algorithms.,4Sample edge type used to test some graph algorithms.,5Sample graph type used to test some graph algorithms.,=Generates a node from the graph. (Unless the graph is empty.),HGenerates an edge from the graph. (Unless the graph contains no edges.),isWalk g from to es is *x iff es is a walk from from to to in g.,A property for .,-Computes the transitive closure of the graph.aNote that this algorithm is not guaranteed to be correct (or terminate) for arbitrary semirings.3This function operates on the entire graph at once.,-Computes the transitive closure of the graph.aNote that this algorithm is not guaranteed to be correct (or terminate) for arbitrary semirings.3This function operates on the entire graph at once.,Equality modulo empty edges.All tests as collected by *z.Using *z| is convenient and superior to the manual enumeration of tests, since the name of the property is added automatically.%,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,",,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,ANone 02349;<=L%Things that support delayed dropping. )Delayed dropping which allows undropping. &Non-negative number of things to drop. Where to drop from. 3Invert a Permutation on a partial finite int map. inversePermute perm f = f' such that permute perm f' = f!Example, with map represented as  [Maybe a]: r f = [Nothing, Just a, Just b ] perm = Perm 4 [3,0,2] f' = [ Just a , Nothing , Just b , Nothing ]  Zipping perm with f gives  [(0,a),(2,b)], after compression with  catMaybes. This is an IntMap9 which can easily written out into a substitution again.Partial permutations. Examples:)permute [1,2,0] [x0,x1,x2] = [x1,x2,x0] (proper permutation).&permute [1,0] [x0,x1,x2] = [x1,x0] (partial permuation).,permute [1,0,1,2] [x0,x1,x2] = [x1,x0,x1,x2]- (not a permutation because not invertible).Agda typing would be: 9Perm : {m : Nat}(n : Nat) -> Vec (Fin n) m -> Permutation m is the = of the permutation.'permute [1,2,0] [x0,x1,x2] = [x1,x2,x0] More precisely, permute indices list = sublist , generates sublist from list1 by picking the elements of list as indicated by indices. *permute [1,3,0] [x0,x1,x2,x3] = [x1,x3,x0]Agda typing: ,permute (Perm {m} n is) : Vec A m -> Vec A nIdentity permutation."Restrict a permutation to work on n elements, discarding picks >=n.9Pick the elements that are not picked by the permutation.liftP k takes a  Perm {m} n to a Perm {m+k} (n+k). Analogous to ?@?, but Permutations operate on de Bruijn LEVELS, not indices. 2permute (compose p1 p2) == permute p1 . permute p2 invertP err p is the inverse of p) where defined, otherwise defaults to err. composeP p (invertP err p) == pITurn a possible non-surjective permutation into a surjective permutation. ?permute (reverseP p) xs == reverse $ permute p $ reverse xs Example: Q permute (reverseP (Perm 4 [1,3,0])) [x0,x1,x2,x3] == permute (Perm 4 $ map (3-) [0,3,1]) [x0,x1,x2,x3] == permute (Perm 4 [3,0,2]) [x0,x1,x2,x3] == [x3,x0,x2] == reverse [x2,x0,x3] == reverse $ permute (Perm 4 [1,3,0]) [x3,x2,x1,x0] == reverse $ permute (Perm 4 [1,3,0]) $ reverse [x0,x1,x2,x3] With reversePc, you can convert a permutation on de Bruijn indices to one on de Bruijn levels, and vice versa.8permPicks (flipP p) = permute p (downFrom (permRange p)) or Gpermute (flipP (Perm n xs)) [0..n-1] = permute (Perm n xs) (downFrom n)dCan be use to turn a permutation from (de Bruijn) levels to levels to one from levels to indices.See AB. expandP i n  in the domain of  replace the ith element by n elements.~Stable topologic sort. The first argument decides whether its first argument is an immediate parent to its second argument.'      !"#$%&'()*+     '+*)( '&%$    #"!       !"#$%&'()*+BNone0234 ,,Extend a list by indefinitely many elements.,wApply a permutation to a list which might be too short. Silently discard picks that go beyond the list's boundaries., perm([0..n-1]) == perm,  idP(xs) == xs, takeP n perm = perm . take n, #(droppedP perm)(xs) = xs \ perm(xs), (p1 " p2)(xs) = p1(p2(xs)), p " p { " p = p, "reverseP p = reverse . p . reverse, !permute p . inversePermute p = id6All tests as collected by *z.,,,,Stream function.Initial segment.'Default element, appended ad infinitum.,,,,,,,,,,,3666,,,,,,,,,,,,,,,36CNone0<=#7 The result of parsing something.:What you get if parsing fails.<%The file in which the error occurred.=Where the error occurred.>The remaining input.?The previous token.@*Hopefully an explanation of what happened.A,There aren't any parser flags at the moment.C/Should comment tokens be returned by the lexer?DWe need to keep track of the context to do layout. The context specifies the indentation (if any) of a layout block. See Agda.Syntax.Parser.Layout for more informaton.E no layoutFlayout at specified columnG<To do context sensitive lexing alex provides what is called  start codeso in the Alex documentation. It is really an integer representing the state of the lexer, so we call it LexState instead.HRThe parser state. Contains everything the parser and the lexer could ever need.K"position at current input locationLposition of last tokenMthe current inputNthe character before the inputOthe previous tokenPthe stack of layout contextsQCthe state of the lexer (states can be nested so we need a stack)Rcurrently there are no flagsSThe parse monad. Equivalent to StateT H (Either :)! except for the definition of fail, which builds a suitable : object.TConstructs the initial state of the parser. The string argument is the input string, the file path is only there because it's part of a position.UThe default flags.V.The most general way of parsing a string. The Agda.Syntax.Parser; will define more specialised functions that supply the A and the G.W.The even more general way of parsing a string.X,The most general way of parsing a file. The Agda.Syntax.Parser; will define more specialised functions that supply the A and the G.GNote that Agda source files always use the UTF-8 character encoding.\IThe parse interval is between the last position and the current position.a parseError = failbFake a parse error at the specified position. Used, for instance, when lexing nested comments, which when failing will always fail at the end of the file. A more informative position is the beginning of the failing comment.cUse b or a as appropriate.dFor lexical errors we want to report the current position as the site of the error, whereas for parse errors the previous position is the one we're interested in (since this will be the position of the token we just lexed). This function does b the current position.e"Return the current layout context.hShould only be used at the beginning of a file. When we start parsing we should be in layout mode. Instead of forcing zero indentation we use the indentation of the first token.B789:;<=>?@ABCDEFGHIJKLMNOPQRS,,,TUVWXYZ[,\],^_`abcd,,efghijklmnopq2789:;<=>?@ABCDFEGHIRJKLMNOPQSTUVWXYZ[\]^_`abcdefgh2S789HIJKLMNOPQR:;<=>?@GDEFABCTUVWXYZ\[`]^_efghabcd*789:;<=>?@ABCDEFGH IJKLMNOPQRS,,,TUVWXYZ[,\],^_`abcd,,efghijklmnopqDNoneuSometimes regular expressions aren't enough. Alex provides a way to do arbitrary computations to see if the input matches. This is done with a lex predicate.vnIn the lexer, regular expressions are associated with lex actions who's task it is to construct the tokens.z#This is what the lexer manipulates.|File.}Current position.~Current input.Previously read character. A lens for ~.,Get the previously lexed character. Same as L. Alex needs this to be defined to handle "patterns with a left-context".Lex a character. No surprises. This function is used by Alex 2. A variant of . This function is used by Alex 3.Conjunction of us.Disjunction of us. Negation of us.uvwxyz{|}~uvwxyz{|}~z{|}~vuyxwuvwxyz{|}~ENoneIOT IThe LookAhead monad is basically a state monad keeping with an extra z, wrapped around the S monad.$Get the current look-ahead position.Set the look-ahead position.Lift a computation in the S monad to the  monad.BLook at the next character. Fails if there are no more characters.AConsume all the characters up to the current look-ahead position.-Undo look-ahead. Restores the input from the H.!Consume the next character. Does  followed by .Do a case on the current input string. If any of the given strings match we move past it and execute the corresponding action. If no string matches, we execute a default action, advancing the input one character. This function only affects the look-ahead position.Same as  but takes the initial character from the first argument instead of reading it from the input. Consequently, in the default case the input is not advanced.Run a 7 computation. The first argument is the error function.,,,,,   ,,,,,GNone 023459;IH#Positivity check? (Default = True).0Termination check? (Default = TerminationCheck).Run the termination checker.#Skip termination checking (unsafe).Treat as non-terminating./Treat as terminating (unsafe). Same effect as .2Skip termination checking but use measure instead.Rename from this name.#To this one. Must be same kind as .CThe range of the "to" keyword. Retained for highlighting purposes.2An imported name can be a module or a defined nameYThe things you are allowed to say when you shuffle names between name spaces (i.e. in import,  namespace, or open declarations). Only for open3. Exports the opened names from the current module.@Placeholders are used to represent the underscores in a section.YThe second argument is used only (but not always) for name parts other than underscores.4The position of a name part or underscore in a name.;The following underscore is at the beginning of the name: _foo.8The following underscore is in the middle of the name: foo_bar.4The following underscore is at the end of the name: foo_.4A meta variable identifier is just a natural number.WThe unique identifier of a name. Second argument is the top-level module identifier.Is this a macro definition?0Is this definition eligible for instance search?Abstract or concreteAccess modifier.bVisible from outside, but not exported when opening the module Used for qualified constructors.@Functions can be defined in both infix and prefix style. See NC.Where does the ConP of come from?"Expanded from an implicit pattern.!User wrote a constructor pattern.User wrote a record pattern.String with range info.A RawName is some sort of string.Thing with range info.Only   arguments can have names.Standard naming.&Something potentially carrying a name. Similar to , but we need to distinguish an irrelevance annotation in a function domain (the domain itself is not irrelevant!) from an irrelevant argument.Dom is used in Pi of internal syntax, in Context and  Telescope.  is used for actual arguments (Var, Con, Def etc.) and in Abstract syntax and other situations.4A function argument can be hidden and/or irrelevant.A lens to access the : attribute in data structures. Minimal implementation:  getRelevance and one of  setRelevance or  mapRelevance.:A function argument can be relevant or irrelevant. See Agda.TypeChecking.Irrelevance.4The argument is (possibly) relevant at compile-time.The argument may never flow into evaluation position. Therefore, it is irrelevant at run-time. It is treated relevantly during equality checking.3The argument is irrelevant at compile- and runtime.The argument can be skipped during equality checking because its value is already determined by the type. If a constructor argument is big, it has to be regarded absent, otherwise we get into paradoxes.The polarity checker has determined that this argument is unused in the definition. It can be skipped during equality checking but should be mined for solutions of meta-variables with relevance An constructor argument is big if the sort of its type is bigger than the sort of the data type. Only parameters (and maybe forced arguments) are allowed to be big. = List : Set -> Set nil : (A : Set) -> List A  A is big in constructor nil as the sort Set1 of its type Set is bigger than the sort Set of the data type List.A lens to access the  : attribute in data structures. Minimal implementation:  getHiding and one of  setHiding or  mapHiding. Decorating something with   information.4Used to specify whether something should be delayed.Monoidal composition of   information in some data.isHidden does not apply to   , only to  . Visible () arguments are  notHidden. (DEPRECATED, use .) arguments are visible.  and   arguments are  notVisible. Information ordering. vRelevant `moreRelevant` UnusedArg `moreRelevant` Forced `moreRelevant` NonStrict `moreRelevant` Irrelevant"unusableRelevance rel == True! iff we cannot use a variable of rel.# composition.  is dominant,  is neutral.$inverseComposeRelevance r x returns the most irrelevant y such that forall x, y we have )x `moreRelevant` (r `composeRelevance` y) iff 0(r `inverseComposeRelevance` x) `moreRelevant` y (Galois connection).%For comparing  Relevance ignoring Forced and  UnusedArg.&KIrrelevant function arguments may appear non-strictly in the codomain type.*xs `withArgsFrom` args translates xs into a list of s, using the elements in args to fill in the non- fields.5Precondition: The two lists should have equal length.1Get the content of a .3The functor instance for 8 would be ambiguous, so we give it another name here.4Thing with no range info.7An abbreviation: noPlaceholder =  +.8Default is directive is private% (use everything, but do not export).>Ranges are not forced.@Ranges are not forced.Q(Show non-record version of this newtype.`Ranges are not forced. , is an idempotent partial monoid, with unit .   and  are incompatible.      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:      !"#$%&'(~}|{zyxw)*+vutsrqponm,-./0lkjihg1234fedcba`56_^]\[ZYXWVUTSRQP7ONMLKJ89:IHGFEDCBA@?>=<;      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~HNone/059;M+Check whether a name is the empty name "_".Number of holes in a $ (i.e., arity of a mixfix-operator).ATop-level module names. Used in connection with the file system.&Invariant: The list must not be empty.QNamee is a list of namespaces and the name of the constant. For the moment assumes namespaces are just Names and not explicitly applied modules. Also assumes namespaces are generative by just using derived equality. We will have to define an equality instance to non-generative namespaces (as well as having some sort of lookup table for namespace names).A.rest.x.<Mixfix identifiers are composed of words and holes, e.g. _+_ or  if_then_else_ or [_/_]._ part.Identifier part.*A name is a non-empty list of alternating s and js. A normal name is represented by a singleton list, and operators are represented by a list with /s where the arguments should go. For instance: [Hole,Id "+",Hole] is infix addition.Equality and ordering on NameQs are defined to ignore range so same names in different locations are equal. A (mixfix) identifier. _.+Parse a string to parts of a concrete name.Note: 5stringNameParts "_" == [Id "_"] == nameParts NoName{}Is the name an operator? qualify A.B x == A.B.x unqualify A.B.x == xThe range is preserved. qnameParts A.B.x = [A, B, x]Turns a qualified name into a F. The qualified name is assumed to represent a top-level module name.FTurns a top-level module name into a file name with the given suffix.pFinds the current project's "root" directory, given a project file and the corresponding top-level module name.8Example: If the module "A.B.C" is located in the file "fooABC.agda", then the root is "foo".2Precondition: The module name must be well-formed.  noName_ =  Ranges are not forced.=Define equality on NameC to ignore range so same names in different locations are equal.'Is there a reason not to do this? -JeffNo. But there are tons of reasons to do it. For instance, when using names as keys in maps you really don't want to have to get the range right to be able to do a lookup. -UlfD      !"#$%&'()*+,-./0123456789:;<=>"     D  >=<;:9   876543210/.-,+*)('&%$#"! :      !"#$%&'()*+,-./0123456789:;<=>JNone0TLClassification of notations.MEx:  _bla_blub_.NEx:  _bla_blub.OEx:  bla_blub_.PEx: bla_blub.RPart of a NotationSSArgument is the position of the hole (with binding) where the binding should occur.T+Argument is where the expression should go.U"An underscore in binding position.WNotation as provided by the syntax declaration.X8Data type constructed in the Happy parser; converted to R$ before it leaves the Happy code.Y x -> y2; 1st argument is the bound name (unused for now).ZSimple named hole with hiding.]Is the hole a binder?^2Get a flat list of identifier parts of a notation._ATarget argument position of a part (Nothing if it is not a hole).`eIs the part a hole? WildHoles don't count since they don't correspond to anything the user writes.aIs the part a normal hole?bIs the part a binder?c<Classify a notation by presence of leading and/or trailing normal holes.d2From notation with names to notation with indices. Example: n ids = ["for", "x", """, "xs", "return", "e"] holes = [ LambdaHole "x" "e", ExprHole "xs" ]  creates the notation  [ IdPart "for" , BindHole 0 , IdPart """ , NormalHole 1 , IdPart "return" , NormalHole 0 ] LMNOPQRSTUVWXYZ[\]^_`abcdefgLMNOPQRSTUVWXZY[\]^_`abcdeXYZ[\\]WRSTUVgf^_`abLMNOPQcdeLMNOPQRSTUVWXYZ[\\]^_`abcdefgKNoneIo e.g. x + 5pa number or infinityqbA solution assigns to each flexible variable a size expression which is either a constant or a v + n for a rigid variable v.r"A matrix with row descriptions in b and column descriptions in c.w6The Graph Monad, for constructing a graph iteratively.zScope for each flexible var.{Node labels to node numbers.|Node numbers to node labels.}Number of nodes n.~The edges (restrict to [0..n[).%A constraint is an edge in the graph.For  Arc v1 k v2 at least one of v1 or v2 is a MetaV+ (Flex), the other a MetaV or a Var (Rigid). If k <= 0 this means suc^(-k) v1 <= v2 otherwise v1 <= suc^k v3.3Which rigid variables a flex may be instatiated to.QNodes of the graph are either - flexible variables (with identifiers drawn from Int*), - rigid variables (also identified by Int<s), or - constants (like 0, infinity, or anything between)..Edge weight in the graph, forming a semi ring.AWarshall's algorithm on a graph represented as an adjacency list.isBelow r w r' checks, if r and r' are connected by w (meaning w not infinite), whether  r + w <= r'/. Precondition: not the same rigid variable.EThe empty graph: no nodes, edges are all undefined (infinity weight).Add a size meta node.BLookup identifier of a node. If not present, it is added first.addEdge n1 k n2 improves the weight of egde n1->n2 to be at most k(. Also adds nodes if not yet present. sizeRigid r n. returns the size expression corresponding to r + n7Check that no edges get longer when completing a graph.*Check that all transitive edges are added.1Check that no edges are added between components.Imnopqrstuvwxyz{|}~Bmnopqrstuvwxy~{z|}Ixyz{|}~wrstuvqnopm5mnopqrstuvwxyz{|}~LNone /02349:;IMake a  from some kind of string.The X sets the definition site of the name, not the use site.<Ambiguous qualified names. Used for overloaded constructors.Invariant: All the names in the list must have the same concrete, unqualified name. (This implies that they all have the same X).'A module name is just a qualified name.The RH instance for module names sets all individual ranges to the given one.(Something preceeded by a qualified name.Qualified names are non-empty lists of names. Equality on qualified names are just equality on the last name, i.e. the module part is just for show.The Rr instance for qualified names sets all individual ranges (including those of the module prefix) to the given one.A name is a unique identifier and a suggestion for a concrete name. The concrete name contains the source location (if any) of the name. The source location of the binding site is also recorded.FA module is anonymous if the qualification path ends in an underscore.Sets the ranges of the individual names in the module name to match those of the corresponding concrete names. If the concrete names are fewer than the number of module name name parts, then the initial name parts get the range .C.D.E `withRangesOf` [A, B] returns C.D.E! but with ranges set as follows:C: .D: the range of A.E: the range of B.jPrecondition: The number of module name name parts has to be at least as large as the length of the list.Like b, but uses the name parts (qualifier + name) of the qualified name as the list of concrete names.Turn a qualified name into a concrete name. This should only be used as a fallback when looking up the right concrete name in the scope fails. Computes the TopLevelModuleName` corresponding to the given module name, which is assumed to represent a top-level module name.2Precondition: The module name must be well-formed. Convert a  to a  (add no module name).Is the name an operator?9Get the next version of the concrete name. For instance, nextName "x" = "x ". The name must not be a NoName.The range is not forced.&The generated names all have the same : .The range of an AmbiguousQNameQ is the range of any of its disambiguations (they are the same concrete name). Only use this show3 function in debugging! To convert an abstract  into a string use  prettyShow. Only use this show3 function in debugging! To convert an abstract  into a string use  prettyShow. Only use this show3 function in debugging! To convert an abstract  into a string use  prettyShow. 8An abstract name is empty if its concrete name is empty.S         /U          B         FNone0234MgThe notation is handled as the fixity in the renamer. Hence, they are grouped together in this type. (Precedence is associated with a context. "Fixity of operators. 'Associativity. + Precedence levels for operators. .-Sections, as well as non-sectioned operators. 1>For non-sectioned operators this should match the notation's c. 2Effective precedence level. +X for closed notations. 3, for non-sectioned operators. 4/All the notation information related to a name. 7-The names the syntax and/or fixity belong to.AInvariant: The set is non-empty. Every name in the list matches  6. 83Associativity and precedence (fixity) of the names. 9!Syntax associated with the names. :PTrue if the notation comes from an operator (rather than a syntax declaration). ;Decorating something with Fixity'. @LIf an operator has no specific notation, then it is computed from its name. AReplace  F by  G. B Return the Vs of a notation, the first part qualified, the other parts unqualified. This allows for qualified use of operators, e.g., M.for x " xs return e, or x !.+ y. C Create a W# (without binders) from a concrete  . Does the obvious thing:  s become Ts,  s become IdParts. If  has no s, it returns e. DMerges  4Is that have the same precedence level and notation, with two exceptions:MOperators and notations coming from syntax declarations are kept separate.If all instances of a given  4 have the same precedence level or are "unrelated", then they are merged. They get the given precedence level, if any, and otherwise they become unrelated (but related to each other).If  4@s that are merged have distinct associativities, then they get  ( as their associativity.Precondition: No 1 may occur in more than one list element. Every  4 must have the same  6.Postcondition: No & occurs in more than one list element. E'Converts a notation to a (non-)section. H;The precedence corresponding to a possibly hidden argument. IlDo we need to bracket an operator application of the given fixity in a context with the given precedence. JDoes a lambda-like thing (lambda, let or pi) need brackets in the given context? A peculiar thing with lambdas is that they don't need brackets in certain right operand contexts. However, we insert brackets anyway, for the following reasons:Clarity.(Sometimes brackets are needed. Example: m >>= ( x ! x) >>= m  (here _>>=_ is left associative). K*Does a function application need brackets? L&Does a with application need brackets? M$Does a function space need brackets? RRanges are not forced.E          ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y= = > ?          ! " # % & $ ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < @ A B C D E F G H I J K L M N O P QE = > ? ; < 4 5 6 7 8 9 : @ A B C D . / 0 1 2 3 E + , - ' ( ) * " # $ % & Y X F G          ! H I J K L M N W V U T O P Q S R# = > ?          ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < @ A B C D E F G H I J K L M N O P Q R S T U V W X YMNone0 tRanges are not forced. k l m n o p q r s t u v w x y z { k l m n o p q r s k l m n o p q { z r s y x w v u t k l m n o p q r s t u v w x y z {NNone02349;r |The   is not an application. ~=Modules: Top-level pragmas plus other top-level declarations. :Invariant: The string must be a valid Haskell module name. &same as above, but for the UHC backend  tel. M args  M {{...}} ~The representation type of a declaration. The comments indicate which type in the intended family the constructor targets. DAxioms and functions can be irrelevant. (Hiding should be NotHidden) .Record field, can be hidden and/or irrelevant. #lone data signature in mutual block %lone record signature in mutual block 7The optional name is a name for the record constructor. notation declaration for a name (Just type signatures or instance blocks. Just type signatures. The "as" name. CThe range of the "as" keyword. Retained for highlighting purposes. 3An imported name can be a module or a defined name. YThe things you are allowed to say when you shuffle names between name spaces (i.e. in import,  namespace, or open declarations). vAn expression followed by a where clause. Currently only used to give better a better error message in interaction. No where clauses.  Ordinary where.  Named where: module M where. +No right hand side because of absurd match. 8Processed (scope-checked) intermediate form of the core f ps of  . Corresponds to  . f ps record projection identifier  side patterns  main branch  side patterns ;Left hand sides can be written in infix style. For example: +n + suc m = suc (n + m) (f " g) x = f (g x)@We use fixity information to see which name is actually defined. Goriginal pattern, with-patterns, rewrite equations and with-expressions 9new with-patterns, rewrite equations and with-expressions f ps | p (many)  rewrite e (many) with e (many) \A telescope is a sequence of typed bindings. Bound variables are in scope in later types. Binding (x1 ... xn : A).  Let binding (let Ds) or  (open M args). A typed binding. Hfor implicit function types the label matters and can't be alpha-renamed . (xs : e) or {xs : e} or something like  (x {y} _ : e). }A sequence of typed bindings with hiding information. Appears in dependent function spaces, typed lambdas, and telescopes.FIf the individual binding contains hiding information as well, the   in  TypedBindings must be the unit . . x or {x} or .x or .{x} or {.x} . (xs : e) or {xs : e} 0A lambda binding is either domain free or typed. 9Concrete patterns. No literals in patterns at the moment. c or x quote p p' or  p {x = p'} p1..pn before parsing operators eg: p => p' for operator _=>_ The Q is possibly ambiguous, but it must correspond to one of the names in the set. {p} or {x = p} {{p}} or  {{x = p}} (p) _ () x@p unused .e 0, 1, etc. record {x = p; y = q} CConcrete expressions. Should represent exactly what the user wrote. ex: x ex: 1 or "foo" ex: ? or  {! ... !} ex: _ or _A_5 before parsing operators ex: e e, e {e}, or  e {x = e} ex: e + e The S is possibly ambiguous, but it must correspond to one of the names in the set. ex: e | e1 | .. | en ex: {e} or {x=e} ex: {{e}} or {{x=e}} ex:  \x {y} -> e or \(x:A){y:B} -> e ex: \ () ex: .\ { p11 .. p1a -> e1 ; .. ; pn1 .. pnz -> en } ex: e -> e or .e -> e (NYI: {e} -> e) ex:  (xs:e) -> e or  {xs:e} -> e ex: Set ex: Prop ex: Set0, Set1, .. ex: record {x = a; y = b}, or record { x = a; M1; M2 } ex: record e {x = a; y = b} ex:  let Ds in e ex: (e) ex: () or {}, only in patterns ex: x@p, only in patterns ex: .p, only in patterns !only used for printing telescopes ex: quoteGoal x in e ex:  quoteContext ex: quote, should be applied to a name ex:  quoteTerm, should be applied to a term  'tactic solve | subgoal1 | .. | subgoalN ex: unquote&, should be applied to a term of type Term to print irrelevant things ex: a = b, used internally in the parser -\An abstraction inside a special syntax declaration (see Issue 358 why we introduce this). 5#Computes the top-level module name.Precondition: The  ~ has to be well-formed. This means that there are only allowed declarations before the first module declaration, typically import declarations. See  6. 6Splits off allowed (= import) declarations before the first non-allowed declaration. After successful parsing, the first non-allowed declaration should be a module declaration. 9<Get all the identifiers in a pattern in left-to-right order. :<Get all the identifiers in a pattern in left-to-right order. ARanges are not forced. BRanges are not forced. CRanges are not forced. DRanges are not forced. ERanges are not forced. FRanges are not forced. GRanges are not forced. HRanges are not forced. IRanges are not forced. JRanges are not forced. qA   is  when the whereG keyword is absent. An empty list of declarations does not count as  here. | } ~                            ! " # $ % & ' ( ) * + , - . / 0 1,,, 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q      ; < | } ~                            ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 :                           , - . / 8 | } ! ' ( ) * + 0 1 " # $ % & 2 3 4  ~ ; < 5 6 : 9 7l | } ~                "                           ! " # $ % & ' ( ) * + , - . / 0 1,,, 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p qONone9; ,Generic traversals for concrete expressions. Note: does not go into patterns! This corresponds to ,|. This corresponds to ,. This is a reduce.     PNone %&,5DRT A singleton type for L (except for the constructor Q). "Used to define the return type of  . Should sections be parsed? The O is possibly ambiguous, but it must correspond to one of the names in the set. Runs a parser. If sections should be parsed, then identifiers with at least two name parts are split up into multiple tokens, using O to record the tokens' original positions within their respective identifiers. )Parse a specific identifier as a NamePart KParses a split-up, unqualified name consisting of at least two name parts.The parser does not check that underscores and other name parts alternate. The range of the resulting name is the range of the first name part that is not an underscore. Either a wildcard (_E), or an unqualified name (possibly containing multiple name parts). 0Parse the "operator part" of the given notation.ENormal holes (but not binders) at the beginning and end are ignored.RIf the notation does not contain any binders, then a section notation is allowed.- ) -      QNone9:; prettyHiding info visible doc# puts the correct braces around doc according to info info and returns  visible doc% if the we deal with a visible thing.<                <                ;                RNone 09:;LMT+,Nicifier state.,4Lone type signatures that wait for their definition. Nicifier monad.,@The kind of the forward declaration, remembering the parameters.,name of a data with parameters, name of a record with parameters,name of a function,we are nicifying a mutual block,,we are nicifying decls not in a mutual block,QSeveral declarations expect only type signatures as sub-declarations. These are:,  postulate, primitive. Ensured by parser.,instanceE. Actually, here all kinds of sub-declarations are allowed a priori.,field. Ensured by parser.,data ... where=. Here we got a bad error message for Agda-2.5 (Issue 1698). The exception type. (7in a mutual block, a clause could belong to any of the [Name] type signatures *RIn a mutual block, all or none need a MEASURE pragma. Range is of mutual block. +Pragma {- NO_TERMINATION_CHECK -} has been replaced by {- TERMINATING  -} and {- NON_TERMINATING -}. 0DOne clause in a function definition. There is no guarantee that the   actually declares the #. We will have to check that later. 2Only  6s. 3Only  6s. 41Termination measure is, for now, a variable name. 5The nice declarations. No fixity declarations and function definitions are contained in a single constructor instead of spread out between type signatures and clauses. The private,  postulate, abstract and instanceD modifiers have been distributed to the individual declarations. 6MAxioms and functions can be declared irrelevant. (Hiding should be NotHidden) AAn uncategorized function clause, could be a function clause without type signature or a pattern lhs (e.g. for irrefutable let). The   is the actual  . CKBlock of function clauses (we have seen the type signature before). The  As are the original declarations that were processed into this  C and are only used in  K.,Check that declarations in a mutual block are consistently equipped with MEASURE pragmas, or whether there is a NO_TERMINATION_CHECK pragma.,Initial nicifier state.,Lens for field ,.,%Adding a lone signature to the state.,'Remove a lone signature from the state.,"Search for forward type signature.,4Check that no lone signatures are left in the state.,BEnsure that all forward declarations have been given a definition.,4Check whether name is not "_" and return its fixity.,GCompute visible parameters of a data or record signature or definition. JMain.,Add more fixities. Throw an exception for multiple fixity declarations. OR: Disjoint union of fixity maps. Throws exception if not disjoint.,Get the fixities from the current block. Doesn't go inside modules and where blocks. The reason for this is that fixity declarations have to appear at the same level (or possibly outside an abstract or mutual block) as its target declaration. K(Approximately) convert a  5 back to a  . LHas the  5 a field of type ? MWhile ,h is not a monoid under disjoint union (which might fail), we get the monoid instance for the monadic  Nice Fixities% which propagates the first error.k,,,,,,,,,, ,,,,,,,,,,,,,,           ! " # $ % & ' ( ) * + , - . / 0 1 2 3, 4, 5 6 7 8 9 : ; < = > ? @ A B C D E F G H,,,,,,,,,,,,,, I,, J,, K L M N O P Q R S8            ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L8 5 6 7 8 9 : ; < = > ? @ A B C D E F G H 3 2 0 1           ! " # $ % & ' ( ) * + , - . /  I J K L 4.,,,,,,,,,, ,,,,,,,,,,,,,,           ! " # $ % & ' ( ) * + , - . / 0 1 2 3, 4, 5 6 7 8 9 : ; < = > ? @ A B C D E F G H,,,,,,,,,,,,,, I,, J,, K L M N O P Q R SSNone A misplaced end-comment "-}".p ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~  o ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~  o ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~   ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~  H VNone  Should comment tokens be output?  Should comment tokens be output? ,Manually lexing a block comment. Assumes an  open comment< has been lexed. In the end the comment is discarded and  " is called to lex a real token.  Lex a hole ( {! ... !}#). Holes can be nested. Returns  b  s. Skip a block of text enclosed by the given open and close strings. Assumes the first open string has been consumed. Open-close pairs may be nested.    WNone ALex a string literal. Assumes that a double quote has been lexed. zLex a character literal. Assumes that a single quote has been lexed. A character literal is lexed in exactly the same way as a string literal. Only before returning the token do we check that the lexed string is of length 1. This is maybe not the most efficient way of doing things, but on the other hand it will only be inefficient if there is a lexical error.,Custom error function.,mThe general function to lex a string or character literal token. The character argument is the delimiter (" for strings and ' for characters).,oThis is where the work happens. The string argument is an accumulating parameter for the string being lexed.,A string gap consists of whitespace (possibly including line breaks) enclosed in backslashes. The gap is not part of the resulting string.,Lex a single character.,?Lex an escaped character. Assumes the backslash has been lexed.,$Read a number in the specified base.,Same as ,$ but with an accumulating parameter.,The escape codes. ,,,,,,,,,  ,,,,,,,,,XNoneB \This is the initial state for parsing a literate file. Code blocks should be enclosed in  \begin{code}  \end{code} pairs. CThis is the initial state for parsing a regular, non-literate file. 8The layout state. Entered when we see a layout keyword ( 3) and exited either when seeing an open brace ( openBrace) or at the next token ( )./Update: we don't use braces for layout anymore.,The state inside a pragma. We enter this state from   when the token following a layout keyword is to the left of (or at the same column as) the current layout context. Example: )data Empty : Set where foo : Empty -> Nat(Here the second line is not part of the where8 clause since it is has the same indentation as the dataD definition. What we have to do is insert an empty layout block {} after the where;. The only thing that can happen in this state is that  ] is executed, generating the closing brace. The open brace is generated when entering by  . This state is entered at the beginning of each line. You can't lex anything in this state, and to exit you have to check the layout rule. Done with  . ]This state can only be entered by the parser. In this state you can only lex the keywords using, hiding, renaming and to. Moreover they are only keywords in this particular state. The lexer will never enter this state by itself, that has to be done in the parser. HReturn the next token. This is the function used by Happy in the parser.  lexer k =   >>= k,&Do not use this function; it sets the A to -. 3This is the main lexing function generated by Alex.--------- - - - - ------ , - ------------ -!-"-#-$-%-&-'-(-)-*-+-,---.-/-0-1-2-3-4-5-6-7-8-9-:-;-<-=->-?-@-A-B-C-D-E-F-G-H-I-J-K-L-M-N-O-P-Q-R-S-T-U-V-W-X-Y-Z-[-\-]-^-_-`-a-b-c-d-e-f-g-h-i-j-k-l-m-n-o-p-q-r-s-t-u-v-w-x-y-z-{-|-}-~-------------, ------   --------- - -  - - ------ , - ------------ -!-"-#-$-%-&-'-(-)-*-+-,---.-/-0-1-2-3-4-5-6-7-8-9-:-;-<-=->-?-@-A-B-C-D-E-F-G-H-I-J-K-L-M-N-O-P-Q-R-S-T-U-V-W-X-Y-Z-[-\-]-^-_-`-a-b-c-d-e-f-g-h-i-j-k-l-m-n-o-p-q-r-s-t-u-v-w-x-y-z-{-|-}-~-------------, ------ UNone <True if the given state appears somewhere on the state stack &True if we are at the end of the file. HTrue when the given character is the next character of the input string. Parse a literal. 7Parse an identifier. Identifiers can be qualified (see Name). Example:  Foo.Bar.f Parse a  i token. Parse a   token, triggers layout for  . 8Exit the current state throwing away the current lexeme. 3Enter a new state throwing away the current lexeme. 4Exit the current state and perform the given action. .Enter a new state without consuming any input. )Executed for layout keywords. Enters the  ( state and performs the given action. Like  ', but applies a function to the string. Parse a token from an [ and the lexed string. (The most general way of parsing a token. -Scan the input to find the next token. Calls  L. This is the main lexing function where all the work happens. The function  B, used by the parser is the continuation version of this function.-%Called at the end of a file. Returns  h.-1Set the current input and lex a new token (calls  ).-Use the input string from the previous input (with the appropriate number of characters dropped) instead of the fake input string that was given to Alex (with unicode characters removed).-mAlex 2 can't handle unicode characters. To solve this we translate all Unicode (non-ASCII) identifiers to z(, all Unicode operator characters to +/, and all whitespace characters (except for t and n) to ' '. Further, non-printable Unicode characters are translated to an arbitrary, harmless ASCII non-printable character, '\1'.:It is important that there aren't any keywords containing z, + or  . 3Return a token without looking at the lexed string. 2Exit the current state without consuming any input- Parse a possibly qualified name. ----- -d  d  ----- -TNone &This action is only executed from the  / state. It will exit this state, enter the  \ state, and return a virtual close brace (closing the empty layout block started by  ). JStart a new layout context. This is one of two ways to get out of the   state (the other is  #). There are two possibilities:hThe current token is to the right of the current layout context (or we're in a no layout context).WThe current token is to the left of or in the same column as the current context.In the first case everything is fine and we enter a new layout context at the column of the current token. In the second case we have an empty layout block so we enter the  U state. In both cases we return a virtual open brace without consuming any input.@Entering a new state when we know we want to generate a virtual {} may seem a bit roundabout. The thing is that we can only generate one token at a time, so the way to generate two tokens is to generate the first one and then enter a state in which the only thing you can do is generate the second one. /Executed for the first token in each line (see  c). Checks the position of the token relative to the current layout context. If the token is to the leftZ : Exit the current context and a return virtual close brace (stay in the   state). same column : Exit the  / state and return a virtual semi colon. to the right : Exit the   state and continue lexing.DIf the current block doesn't use layout (i.e. it was started by  %) all positions are considered to be  to the right. $Executed upon lexing an open brace ('{'). Enters the E context. $Executed upon lexing a close brace ('}'). Exits the current layout context. This might look a bit funny--the lexer will happily use a close brace to close a context open by a virtual brace. This is not a problem since the parser will make sure the braces are appropriately matched.-MCompute the relative position of a location to the current layout context. -   -YNone" /023459:;<=?@ABCDFIJKLMNOQRT 1Parse the token stream. Used by the TeX compiler. 3Parse an expression. Could be used in interactions. NParse an expression followed by a where clause. Could be used in interactions. Parse a module.-Required by Happy.-Grab leading OPTIONS pragmas.-Insert a top-level module if there is none. Also fix-up for the case the declarations in the top-level module are not indented (this is allowed as a special case).-Create a name from a string.-.Create a qualified name from a list of strings-Match a particular name.-'Build a forall pi (forall x y z -> ...)- Build a telescoping let (let Ds)-+Converts lambda bindings to typed bindings.-=Check that an import directive doesn't contain repeated names-pBreaks up a string into substrings. Returns every maximal subsequence of zero or more characters distinct from +. splitOnDots "" == [""] splitOnDots "foo.bar" == ["foo", "bar"] splitOnDots ".foo.bar" == ["", "foo", "bar"] splitOnDots "foo.bar." == ["foo", "bar", ""] splitOnDots "foo..bar" == ["foo", "", "bar"]-Returns *x= iff the name is a valid Haskell (hierarchical) module name.-)Turn an expression into a left hand side.-UTurn an expression into a pattern. Fails if the expression is not a valid pattern.-UTurn an expression into a name. Fails if the expression is not a valid identifier.  Test suite.F----------------------------------------------------------------------------------------.......... . . . . ................... .!.".#.$.%.&.'.(.).*.+.,.-.../.0.1.2.3.4.5.6.7.8.9.:.;.<.=.>.?.@.A.B.C.D.E.F.G.H.I.J.K.L.M.N.O.P.Q.R.S.T.U.V.W.X.Y.Z.[.\.].^._.`.a.b.c.d.e.f.g.h.i.j.k.l.m.n.o.p.q.r.s.t.u.v.w.x.y.z.{.|.}.~.................................................................................................................................////////// / / / / /////////////////// /!/"/#/$/%/&/'/(/)/*/+/,/-/.///0/1/2/3/4/5/6/7/8/9/:/;/</=/>/?/@/A/B/C/D/E/F/G/H/I/J/K/L/M/N/O/P/Q/R/S/T/U/V/W/X/Y/Z/[/\/]/^/_/`/a/b/c/d/e/f/g/h/i/j/k/l/m/n/o/p/q/r/s/t/u/v/w/x/y/z/{/|/}/~/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////0000000000 0 0 0 0 0000000000000000000 0!0"0#0$0%0&0'0(0)0*0+0,0-0.0/000102030405060708090:0;0<0=0>0?0@0A0B0C0D0E0F0G0H0I0J0K0L0M0N0O0P0Q0R0S0T0U0V0W0X0Y0Z0[0\0]0^0_0`0a0b0c0d0e0f0g0h0i0j0k0l0m0n0o0p0q0r0s0t0u0v0w0x0y0z0{0|0}0~0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001111111111 1 1 1 1 1111111111111111111 1!1"1#1$1%1&1'1(1)1*1+1,1-1.1/101112131415161718191:1;1<1=1>1?1@1A1B1C1D1E1F1G1H1I1J1K1L1M1N1O1P1Q1R1S1T1U1V1W1X1Y1Z1[1\1]1^1_1`1a1b1c1d1e1f1g1h1i1j1k1l1m1n1o1p1q1r1s1t1u1v1w1x1y1z1{1|1}1~1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111112222222222 2 2 2 2 2222222222222222222 2!2"2#2$2%2&2'2(2)2*2+2,2-2.2/202122232425262728292:2;2<2=2>2?2@2A2B2C2D2E2F2G2H2I2J2K2L2M2N2O2P2Q2R2S2T2U2V2W2X2Y2Z2[2\2]2^2_2`2a2b2c2d2e2f2g2h2i2j2k2l2m2n2o2p2q2r2s2t2u2v2w2x2y2z2{2|2}2~222222222222222222222222222222222222222222222222222222    22-----22----2-2-2---2-22222222 22222222222222222222          =----------------------------------------------------------------------------------------.......... . . . . ................... .!.".#.$.%.&.'.(.).*.+.,.-.../.0.1.2.3.4.5.6.7.8.9.:.;.<.=.>.?.@.A.B.C.D.E.F.G.H.I.J.K.L.M.N.O.P.Q.R.S.T.U.V.W.X.Y.Z.[.\.].^._.`.a.b.c.d.e.f.g.h.i.j.k.l.m.n.o.p.q.r.s.t.u.v.w.x.y.z.{.|.}.~.................................................................................................................................////////// / / / / /////////////////// /!/"/#/$/%/&/'/(/)/*/+/,/-/.///0/1/2/3/4/5/6/7/8/9/:/;/</=/>/?/@/A/B/C/D/E/F/G/H/I/J/K/L/M/N/O/P/Q/R/S/T/U/V/W/X/Y/Z/[/\/]/^/_/`/a/b/c/d/e/f/g/h/i/j/k/l/m/n/o/p/q/r/s/t/u/v/w/x/y/z/{/|/}/~/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////0000000000 0 0 0 0 0000000000000000000 0!0"0#0$0%0&0'0(0)0*0+0,0-0.0/000102030405060708090:0;0<0=0>0?0@0A0B0C0D0E0F0G0H0I0J0K0L0M0N0O0P0Q0R0S0T0U0V0W0X0Y0Z0[0\0]0^0_0`0a0b0c0d0e0f0g0h0i0j0k0l0m0n0o0p0q0r0s0t0u0v0w0x0y0z0{0|0}0~0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001111111111 1 1 1 1 1111111111111111111 1!1"1#1$1%1&1'1(1)1*1+1,1-1.1/101112131415161718191:1;1<1=1>1?1@1A1B1C1D1E1F1G1H1I1J1K1L1M1N1O1P1Q1R1S1T1U1V1W1X1Y1Z1[1\1]1^1_1`1a1b1c1d1e1f1g1h1i1j1k1l1m1n1o1p1q1r1s1t1u1v1w1x1y1z1{1|1}1~1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111112222222222 2 2 2 2 2222222222222222222 2!2"2#2$2%2&2'2(2)2*2+2,2-2.2/202122232425262728292:2;2<2=2>2?2@2A2B2C2D2E2F2G2H2I2J2K2L2M2N2O2P2Q2R2S2T2U2V2W2X2Y2Z2[2\2]2^2_2`2a2b2c2d2e2f2g2h2i2j2k2l2m2n2o2p2q2r2s2t2u2v2w2x2y2z2{2|2}2~222222222222222222222222222222222222222222222222222222    22-----22----2-2-2---2-22222222 22222222222222222222-9 -9 ZNone Wrapped Parser type. Parses a module. Parses a module name. Parses an expression. 0Parses an expression followed by a where clause. 3Gives the parsed token stream (including comments).29Keep comments in the token stream generated by the lexer.2@Do not keep comments in the token stream generated by the lexer. 22222 2 2     22:;<=>?@          :;<=>?@ 22222 2 2     22[None)              ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ;)            !   # " $ % & ' ( ) * - + 2 3 . , 0 1 / 4 5 6 7 8 9 : ;) : 8 9 7 6 ; 4 5 ) * + , - . / 0 1 2 3 ( $ % & '    ! " #                        ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ;\None0M D5Checks if the given expression is unreachable or not. F Code which is unreachable. E.g. absurd branches or missing case defaults. Runtime behaviour of unreachable code is undefined, but preferably the program will exit with an error message. The compiler is free to assume that this code is unreachable and to remove it. HMatches on the given constructor. If the match succeeds, the pattern variables are prepended to the current environment (pushes all existing variables aArity steps further away) IBinds no variables UmCompiler-related primitives. This are NOT the same thing as primitives in Agda's surface or internal syntax! hintroduces a new local binding. The bound term MUST only be evaluated if it is used inside the body. Sharing may happen, but is optional. It is also perfectly valid to just inline the bound term in the body. iCase scrutinee (always variable), case type, default value, alternatives First, all TACon alternatives are tried; then all TAGuard alternatives in top to bottom order. TACon alternatives must not overlap. m,A runtime error, something bad has happened. uIntroduces a new binding> C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~  j C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a h b c d e f g i j k l m n o p q r s t u v w x y z { | }@ o p q r n ` a b c d e f g h i j k l m U V W X Y Z [ \ ] ^ _ s t u v w x y z { | } P Q R S T G H I J K L M N M O M E F C D  ~ C D E F G H I J K L M N M O M P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~  ]Safe     ^Safe!":AMT2.agda-lib file format .agda-lib parser -...and trailing, but not leading, whitespace.22222222222222 222222222   22222222222222 222222222 _NoneLM2222 222333 33 333 33 3   2222 222333 33 333 33 3 `None f :: Flag optsO is an action on the option record that results from parsing an option. f optsC produces either an error message or an updated options record The options from an OPTIONS pragma.In the future it might be nice to switch to a more structured representation. Note that, currently, there is not a one-to-one correspondence between list elements and options. %Options which can be set in a pragma. ICut off structural order comparison at some depth in termination checker? +irrelevant levels, irrelevant data matching (Allow definitions by copattern matching? 0Is pattern matching allowed in the current file? $Can rewrite rules be added and used? -Use this (if Just) instead of .agda/libraries Use ~.agda$defaults or look for .agda-lib file. 2In the absence of a path the project root is used. 'This should probably go somewhere else. Map a function over the long options. Also removes the short options. Will be used to add the plugin name to the plugin options. The default termination depth.3 'The default output directory for LaTeX.3 &The default output directory for HTML. -Checks that the given options are consistent. ;Check for unsafe pramas. Gives a list of used unsafe flags.3 5The default pragma options should be considered safe. Used for printing usage info. gSimple interface for System.Console.GetOpt Could be moved to Agda.Utils.Options (does not exist yet) Parse the standard options. %Parse options from an options pragma. Parse options for a plugin. LThe usage info message. The argument is the program name (probably agda). _Returns the absolute default lib dir. This directory is used to store the Primitive.agda file. 3 3 3 3 3 33333333333333333 3!3"3#3$3%3&3'3(3)3*3+3,3-3.3/303132333435363738393:3;3<3=3>3?3@3A3B3C3D3E3F3G3H3I3J3K3L3M3N3O3P 3Q command line argument wordsoptions handlers,handler of non-options (only one is allowed)(combined opts data structure transformer Pragma options.-Command-line options which should be updated. 3R Z Z b  ) 3 3 3 3 3 33333333333333333 3!3"3#3$3%3&3'3(3)3*3+3,3-3.3/303132333435363738393:3;3<3=3>3?3@3A3B3C3D3E3F3G3H3I3J3K3L3M3N3O3P 3Q 3R aNone0 .Zero or more consecutive and separated ranges. QCharacter ranges. The first character in the file has position 1. Note that the  4 position is considered to be outside of the range. Invariant:   ,1  . The   invariant. The   invariant. *x iff the ranges overlap.)The ranges are assumed to be well-formed. *x iff the range is empty. (Converts a range to a list of positions. /Converts several ranges to a list of positions.  Converts a X to a  .  minus xs ys! computes the difference between xs and ys<: the result contains those positions which are present in xs but not in ys.*Linear in the lengths of the input ranges. All the properties.         3S  3T                                   3S  3T    bNone0'  A compressed  0, in which consecutive positions with the same   are stored together.  Syntax highlighting information. A  6 is a mapping from file positions to meta information.,The first position in the file has number 1. KMeta information which can be associated with a character/character range. "This note, if present, can be displayed as a tool-tip or something like that. It should contain useful information about the range (like the module containing a certain identifier, or the fixity of an operator). #jThe definition site of the annotated thing, if applicable and known. File positions are counted from 1. $ZOther aspects, generated by type checking. (These can overlap with each other and with  8s.) (hUnsolved constraint not connected to meta-variable. This could for instance be an emptyness constraint. *GWhen this constructor is used it is probably a good idea to include a  "* explaining why the pattern is incomplete. +!Code which is being type-checked. ,NameKind(s are figured our during scope checking. -Bound variable. .%Inductive or coinductive constructor. 0 Record field. 2 Module name. 4 Primitive. 5 Record type. 6!Named argument, like x in {x = v} 7Macro. 8Syntactic aspects of the code. (These cannot overlap.) They can be obtained from the lexed tokens already, except for the  ,. = Symbols like forall, =, ->, etc. >Things like Set and Prop. ?Is the name an operator part? @ @ rs m( is a file whose positions are those in rs2, and in which every position is associated with m. ALike  @, but with several   instead of only one.3UMerges meta information.3V Merges files. B.Returns the smallest position, if any, in the  . C Convert the  E to a map from file positions (counting from 1) to meta information. DInvariant for compressed files.-Note that these files are not required to be  maximally? compressed, because ranges are allowed to be empty, and the  -s in adjacent ranges are allowed to be equal. EcCompresses a file by merging consecutive positions with equal meta information into longer ranges. FDecompresses a compressed file. GClear any highlighting info for the given ranges. Used to make sure unsolved meta highlighting overrides error highlighting. H H rs m( is a file whose positions are those in rs2, and in which every position is associated with m. ILike  singletonR, but with a list of   instead of a single one.3WMerges compressed files. J splitAtC p f splits the compressed file f into (f1, f2), where all the positions in f1 are < p, and all the positions in f2 are >= p. L.Returns the smallest position, if any, in the  . MAll the properties.O     3X3Y   ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A3U3V B C D E F3Z G H3[ I3\3W3] J3^ K L3_ M N O P Q R S T U V W X Y Z [ \5        ! " # $ % & ' ( ) * + , 2 / . 1 7 4 5 3 - 0 6 8 ? = ; < 9 : > @ A B C D E F G H I J K L M5 8 9 : ; < = > ? , - . / 0 1 2 3 4 5 6 7 $ % & ' ( ) * +   ! " #   @ A B C    D E F G H I J K L M-     3X3Y   ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A3U3V B C D E F3Z G H3[ I3\3W3] J3^ K L3_ M N O P Q R S T U V W X Y Z [ \cNone9; jYCallback fuction to call when there is a response to give to the interactive frontend.Note that the response is given in pieces and incrementally, so the user can have timely response even during long computations.Typical  j functions:Convert the response into a 3`g representation and print it on standard output (suitable for inter-process communication).LPut the response into a mutable variable stored in the closure of the  j< function. (suitable for intra-process communication). kGive action result"Comment derived from agda2-mode.elIf  k2 is 'Give_String s', then the goal is replaced by sM, and otherwise the text inside the goal is retained (parenthesised if  k is  m). oStatus information. q!Are implicit arguments displayed? r.Has the module been successfully type checked? s4Info to display at the end of an interactive command xTWhen an error message is displayed this constructor should be used, if appropriate. y yV denotes two different types of errors TODO: split these into separate constructors z z, denotes either an error or a success (when  < is present) TODO: split these into separate constructors ,There are two kinds of "make case" commands. 'Responses for any interactive interfaceNote that the response is given in pieces and incrementally, so the user can have timely response even during long computations. )The integer is the message's debug level.  The default  jS function prints certain things to stdout (other things generate internal errors).+ j k l m n o p q r s t u v w x y z { | } ~  + j k l m n o p q r s t u v w x y z { | } ~  + s t u v w x y z { | } ~  o p q r k l m n j  j k l m n o p q r s t u v w x y z { | } ~   dNone  Note that   only catches :s.    eNone9; Simple Emacs Lisp expressions. Atom. List. Formats a response command. Replaces '\n'= with spaces to ensure that each command is a single line. -Writes a response command to standard output. #display_info' append header content displays content (with header header) in some suitable way. If append is Truei, then the content is appended to previous content (if any), otherwise any previous content is deleted.3a$The name of the running info buffer. Clear the running info buffer. ADisplay running information about what the type-checker is up to. 3a  3a fSafe    gSafe/0CG3b 3c 3d ? ? E3b 3c 3d hSafe <name of a magic, differently translated datatype/constructor3e$Returns the name of the datatype or +X for the unit datatype. 3e3f     3e3f iSafe0  Magic name Arity       jNoneLM3g3h3i3j3k3l3m3n3o3p3q3r3s3t3u3v3w3x3g3h3i3j3k3l3m3n3o3p3q3r3s3t3u3v3w3xkNone0,      !"#$%&'()*+,-./0123#      "!'*#)$%&(, !"#$%&'()*    3210 /.-,+      !"#$%&'()*+,-./0123lNone@ABCDEFGHIJKLMNOPQ@ABCDEFGHIJKLMNOPQ@ABCDEFGHIJKLMNOPQ@ABCDEFGHIJKLMNOPQmNoneRSTUVWXYZ[\]^_`abcd RSTUVWXYZ[\VWXTUdRScba`_^YZ[\]RSTUVWXYZ[\]^_`abcdnNone"efghijklmnopqrstuvwxyz{|}~"efghijklmnopqrstuvwxyz{|}~"efghijklmnopqrstuvwxyz{|}~"efghijklmnopqrstuvwxyz{|}~oNonepNone<=?!Phases to allocate CPU time to.#Happy parsing and operator parsing.Import chasing.Reading interface files.2Scope checking and translation to abstract syntax.1Type checking and translation to internal syntax.Termination checking.-Positivity checking and polarity computation.Injectivity checking.!Checking for projection likeness.0Coverage checking and compilation to case trees.Generating highlighting info.Writing interface files.Deac code elimination. Subphase for . Subphase for . Subphase for . Subphase for . Subphase for . Subphase for . Subphase for . Subphase for  Serialize. Subphase for  Serialize. Subphase for  Serialize. Subphase for . Subphase for : free variable computation. Subphase for !: occurs check for solving metas. Subphase for : checking the LHS Subphase for : unification of the indicesPretty printing names..Global variable to store benchmark statistics.=Benchmark an IO computation and bill it to the given account.>Benchmark a pure computation and bill it to the given account.%#%qNone %&0LOT[V-A decoration of abstract syntax module names.The resolved module name.&Explanation where this name came from.A decoration of LD.The resolved qualified name.6The kind (definition, constructor, record field etc.).&Explanation where this name came from.Where does a name come from?=This information is solely for reporting to the user, see E.Defined in this module.Imported from another module.!Imported by a module application.qFor the sake of parsing left-hand sides, we distinguish constructor and record field names from defined names.Constructor name.Record field name.Ordinary defined name.Name of a pattern synonym.Name of a macroA name that can only be quoted.-Type class for some dependent-types trickery.#Set of types consisting of exactly  and ..A GADT just for some dependent-types trickery.A  NameSpace contains the mappings from concrete names that the user can write to the abstract fully qualified names that the type checker wants to read.0Maps concrete names to a list of abstract names.>Maps concrete module names to a list of abstract module names.A local variable can be shadowed by an import. In case of reference to a shadowed variable, we want to report a scope error.Unique ID of local variable.LThis local variable is shadowed by one or more imports. (List not empty).Local variables.The complete information about the scope at a particular program point includes the scope stack, the local variables, and the context precedence.See .#Things not exported by this module.+Things defined and exported by this module.1Things from open public, exported by this module.uVisible (as qualified) from outside, but not exported when opening the module. Used for qualified constructors.TA scope is a named collection of names partitioned into public and private names.Get a  from . A lens for  `Monadic' lens (Functor sufficient).3Shadow a local name by a non-empty list of imports.*Project name of unshadowed local variable.%Get all locals that are not shadowed  by imports. Lens for . inNameSpace> selects either the name map or the module name map from a X. What is selected is determined by result type (using the dependent-type trickery).!A list containing all name kinds.Van Laarhoven lens on .Van Laarhoven lens on .The empty name space.9Map functions over the names and modules in a name space.Zip together two name spaces.&Map monadic function over a namespace. The empty scope.!The empty scope info."4Map functions over the names and modules in a scope.#Same as "2 but applies the same function to all name spaces.$Same as "7 but applies the function only on the given name space.%<Map monadic functions over the names and modules in a scope.&Same as %M but applies the same function to both the public and private name spaces.'UZip together two scopes. The resulting scope has the same name as the first scope.(Same as 'M but applies the same function to both the public and private name spaces.)&Recompute the inScope sets of a scope.*Filter a scope keeping only concrete names matching the predicates. The first predicate is applied to the names and the second to the modules.+Return all names in a scope.-&Returns the scope's non-private names.1=Merge two scopes. The result has the name of the first scope.2\Merge a non-empty list of scopes. The result has the name of the first scope in the list.3aMove all names in a scope to the given name space (except never move from Imported to Public).4Update a particular name space.5Modify a particular name space.6Add names to a scope.7Add a name to a scope.8Remove a name from a scope. Caution: does not update the nsInScope set. This is only used by rebindName and in that case we add the name right back (but with a different kind).9Add a module to a scope.; Apply an  to a scope.<%Rename the abstract names in a scope.=%Remove private name space of a scope.Should be a right identity for -. >exportedNamesInScope . restrictPrivate == exportedNamesInScope.>9Remove private things from the given module from a scope.?CRemove names that can only be used qualified (when opening a scope)@.Add an explanation to why things are in scope.A5Get the public parts of the public modules of a scopeDoCompute a flattened scope. Only include unqualified names or names qualified by modules in the first argument.E:Get all concrete names in scope. Includes bound variables.FLook up a name in the scopeIhFind the concrete names that map (uniquely) to a given abstract name. Sort by length, shortest first.LrFind the concrete names that map (uniquely) to a given abstract qualified name. Sort by length, shortest first.NoFind the concrete names that map (uniquely) to a given abstract module name. Sort by length, shortest first.O+Add first string only if list is non-empty._AWe show shadowed variables as prefixed by a ".", as not in scope.      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`ab      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNO     ba`_^]\[ZY !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNXWVUTOSRQPj      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abrNone/0:ImConstructor pattern info.oEDoes this pattern come form the eta-expansion of an implicit pattern?q;For a general pattern we remember the source code position.UThe range of the "as" and "to" keywords, if any. Retained for highlighting purposes.AThe "as" module name, if any. Retained for highlighting purposes. Retained for abstractToConcrete of  .Same as  mkDefInfo but where we can also give the  IsInstanceEmpty range for patterns.Fmnopqrstuvwxyz{|}~/mnopqrstuvwxyz{|}~F~z{|}uvwxystqrmnop&mnopqrstuvwxyz{|}~sNone.Types which Geniplate should not descend into.A localised instance of 3y. The generated 3z. functions neither descend into the types in *, nor into the types in the list argument.A localised instance of 3{. The generated 3|. functions neither descend into the types in *, nor into the types in the list argument.tNone 02349;<=j*Check whether we are a projection pattern.,Parameterised over the type of dot patterns.%Defined pattern: function definition f ps or destructor pattern d p ps.\Underscore pattern entered by user. Or generated at type checking for implicit arguments.-Convert a focused lhs to spine view and back.The lhs minus withI-patterns in projection-application view. Parameterised over the type e of dot patterns.&The head applied to ordinary patterns. ProjectionHead f.Applied to patterns ps.Record projection identifier.-Indices of the projection. Currently none []', since we do not have indexed records. Main branch.Further applied to patterns.tThe lhs of a clause in focused (projection-application) view (outside-in). Projection patters are represented as s.Range. Copatterns.with patterns (after |).XThe lhs of a clause in spine view (inside-out). Projection patterns are contained in  spLhsPats, represented as  DefP d [].Range.!Name of function we are defining.Function parameters (patterns).with patterns (after |).The " is the name of the with function.The As are the names of the generated with functions. One for each J". The RHS shouldn't be another  RewriteRHS.We could throw away where0 clauses at this point and translate them to let,. It's not obvious how to remember that the let was really a where6 clause though, so for the time being we keep it here.A typed binding. Appears in dependent function spaces, typed lambdas, and telescopes. It might be tempting to simplify this to only bind a single name at a time, and translate, say,  (x y : A) to (x : A)(y : A)G before type-checking. However, this would be slightly problematic: $We would have to typecheck the type A several times.If AX contains a meta variable or hole, it would be duplicated by such a translation.SWhile 1. is only slightly inefficient, 2. would be an outright bug. Duplicating A~ could not be done naively, we would have to make sure that the metas of the copy are aliases of the metas of the original.As in telescope  (x y z : A) or type (x y z : A) -> B.E.g.  (let x = e) or  (let open M).'Typed bindings with hiding information.. (xs : e) or {xs : e} 0A lambda binding is either domain free or typed. . x or {x} or .x or .{x} . (xs:e) or {xs:e} or (let Ds)Only Cs.Bindings that are valid in a let. LetBind info rel name type defnIrrefutable pattern binding.8LetApply mi newM (oldM args) renaming moduleRenaming dir. The ImportDirective is for highlighting purposes.,only for highlighting and abstractToConcrete?Only used for highlighting. Refers to the first occurrence of x in let x : A; x = e.WBuiltins that do not come with a definition, but declare a name for an Agda concept.( tel. M args : applies M to args and abstracts tel.)  M {{...}}0>type signature (can be irrelevant and colored, but not hidden)1 record field2primitive function3)a bunch of mutually recursive definitions5The ImportDirective is for highlighting purposes.6The ImportDirective is for highlighting purposes.8'only retained for highlighting purposes9sequence of function clauses:lone data signature ^ the  s are  * and binds the parameters of the datatype.;the  s are  * and binds the parameters of the datatype.<lone record signature=The J' gives the constructor type telescope, (x1 : A1)..(xn : An) -> Prop5, and the optional name is the constructor's name.>Only for highlighting purposesAscope annotationBRenaming (generic).CIs a type signature a  postulate or a function signature?DA function signature.EyNot a function signature, i.e., a postulate (in user input) or another (e.g. data/record) type signature (internally).IRecord field assignment f = e.JDExpressions after scope checking (operators parsed, names resolved).KBound variable.L/Constant: axiom, function, data or record type.M Projection.N Constructor.OPattern synonym.PMacro.QLiteral.R&Meta variable for interaction. The " is usually identical with the  of B. However, if you want to print an interaction meta as just ? instead of ?n, you should set the  to +X while keeping the .S=Meta variable for hidden argument (must be inferred locally).TOrdinary (binary) application.UWith application.V bs ! e.W() or {}.YDependent function space  ! A.ZNon-dependent function space.[Set, Set1, Set2, ...\Prop+ (no longer supported, used as dummy type).] let bs in e.^#Only used when printing telescopes._Record construction.`Record update.aScope annotation.bBinds Name to current type in Expr.cReturns the current context.dQuote an identifier .e Quote a term.f#The splicing construct: unquote ...g  tactic e x1 .. xn | y1 | .. | ynh For printing DontCare from Syntax.Internal.l@Add applicative patterns (non-projection patterns) to the right.m5Add projection and applicative patterns to the right.n$Used for checking pattern linearity.oUsed in AbstractToConcrete.Does not compare  fields.Does not compare  fields. LHS instance.List instance (for clauses).Clause instance.Are we in an abstract block?)In that case some definition is abstract./Extracts all the names which are declared in a /. This does not include open public or let expressions, but it does include local modules, where clauses and the names of extended lambdas.$The name defined by the given axiom.3Precondition: The declaration has to be a (scoped) C.Turn an  to an expression.      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./7250831:6?@9;=4<>ABCDEFGHIJK[Z\PNQT]`SVLYhdfRUWX_^bcegOMaijklmnopiJKLMNOPQRSTUVWXYZ[\]^_`abcdefghIHGFCDEB/0123456789:;<=>?@A-.,+*'() !"#$%&     jklmnop~}|{zyxwvutsrq       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~uNone%&6LMIApply an expression rewriting to every subexpression, inside-out. See Agda.Syntax.Internal.Generic.EThe first expression is pre-traversal, the second one post-traversal.-Gather applications to expose head and spine.ENote: everything is an application, possibly of itself to 0 argumentsGather top-level %atterns to expose underlying pattern.-Check whether we are dealing with a universe. Remove top a wrappers.Remove a wrappers everywhere.!NB: Unless the implementation of F for clauses has been finished, this does not work for clauses yet.&     '     !     vNone/02349;<=ILkThe size of a term is roughly the number of nodes in its syntax tree. This number need not be precise for logical correctness of Agda, it is only used for reporting (and maybe decisions regarding performance).'Not counting towards the term size are:sort and color annotations, projections.!KPick the better name suggestion, i.e., the one that is not just underscore.##Constructing a singleton telescope.%View type as equality type.'reduced(Sort of this type.)Builtin EQUALITY.*Hidden+Hidden, NotHidden- NotHidden0Substitutions.1Identity substitution.   " IdS : 2{Empty substitution, lifts from the empty context. Apply this to closed terms you want to use in a non-empty context.  " EmptyS : ()3Substitution extension, `cons'. S  " u : A  "  :  ----------------------  " u :#  : , A 4/Strengthening substitution. First argument is  IMPOSSIBLEi. Apply this to a term which does not contain variable 0 to lower all de Bruijn indices by one. Y  "  :  ---------------------------  " Strengthen  : , A 58Weakning substitution, lifts to an extended context. I  "  :  ------------------- ,  " Wk ||  :  69Lifting substitution. Use this to go under a binder. Lift 1  == var 0 :# Wk 1 . X  "  :  ------------------------- ,  " Lift ||  : ,  7The ConPatternInfo= states whether the constructor belongs to a record type (Just) or data type (Nothing). In the former case, the Bool` says whether the record pattern orginates from the expansion of an implicit pattern. The Type is the type of the whole record pattern. The scope used for the type is given by any outer scope plus the clause's telescope (L).9Nothing if data constructor. Just if record constructor.:AThe type of the whole constructor pattern. Should be present (Just]) if constructor pattern is is generated ordinarily by type-checking. Could be absent (Nothing]) if pattern comes from some plugin (like Agsy). Needed e.g. for with-clause stripping.;+Type used when numbering pattern variables.=7Patterns are variables, constructors, or wildcards. QName is used in ConP rather than Name since a constructor might come from a particular namespace. This also meshes well with the fact that values (i.e. the arguments we are matching with) use QName.> x? .t@c ps= The subpatterns do not contain any projection copatterns.AE.g. 5, "hello".B1Projection copattern. Can only appear by itself.CPattern variables.Hfor absurd clauses.I:A clause is a list of patterns and the clause body should Bind. The telescope contains the types of the pattern variables and the de Bruijn indices say how to get from the order the variables occur in the patterns to the order they occur in the telescope. The body binds the variables in the order they appear in the patterns. <clauseTel ~ permute clausePerm (patternVars namedClausePats)8Terms in dot patterns are valid in the clause telescope.eFor the purpose of the permutation and the body dot patterns count as variables. TODO: Change this!L%: The types of the pattern variables.M #let  = patternVars namedClausePatsN .vO " t. The type of the rhs under  clauseTel. Used, e.g., by  TermCheck . Can be B if we encountered an irrelevant projection pattern on the lhs.QR t without the t.R4Something where a meta variable may block reduction.XEven if we are not stuck on a meta during reduction we can fail to reduce a definition by pattern matching for another reason.YThe ' is neutral and blocks a pattern match.Z<Not enough arguments were supplied to complete the matching.[2We matched an absurd clause, results in a neutral .\We ran out of clauses, all considered clauses produced an actual mismatch. This can happen when try to reduce a function application but we are still missing some function clauses. See  Agda.TypeChecking.Patterns.Match.]RReduction was not blocked, we reached a whnf which can be anything but a stuck .^An atomic term of type Level._A meta variable targeting Level under some eliminations.`A term of type Level& whose reduction is blocked by a meta.aA neutral term of type Level.bIntroduced by  instantiate , removed by reduce.dn, to represent Set .en + !.f(A level is a maximum expression of 0..n cC expressions each of which is a number or an atom plus a number.>The empty maximum is the canonical representation for level 0.hSorts.iSet !.j Dummy sort.kSet.lSizeUniv, a sort inhabited by type Size.mDependent least upper bound. If the free variable occurs in the second sort, the whole thing should reduce to Inf, otherwise it's the normal lub.oVSequence of types. An argument of the first type is bound in later types and so on.qz is never |.v'Types are terms with a sort annotation.z Binder. z2: The bound variable might appear in the body. |P is pseudo-binder, it does not introduce a fresh variable, similar to the const of Haskell.{6The body has (at least) one free variable. Danger: ~! doesn't shift variables properlyNames in binders and arguments.5Eliminations, subsuming applications and projections.name of a record projection Raw values.Def is used for both defined and undefined constants. Assume there is a type declaration and a definition for every constant, even if the definition is an empty list of clauses.x es neutral+Terms are beta normal. Relevance is ignoredf es, possibly a delta/iota-redex c vs)dependent or non-dependent function spaceIrrelevant stuff in relevant position, but created in an irrelevant context. Basically, an internal version of the irrelevance axiom .irrAx : .A -> A.Explicit sharingStore the names of the record fields in the constructor. This allows reduction of projection redexes outside of TCM. For instance, during substitution and application.The name of the constructor.'Record constructors can be coinductive.GThe name of the record fields. Empty list for data constructors. B is not needed here since it is stored in the constructor args.Type of argument lists.)A traversal for the names in a telescope.When trying to reduce f es(, on match failed on one elimination e " es that came with info r :: NotBlocked.  stuckOn e r produces the new  NotBlocked info.\i must be propagated, as this is blockage that can be lifted in the future (as more clauses are added).Y e0F is also propagated, since it provides more precise information as  StuckOn e (as e0L is the original reason why reduction got stuck and usually a subterm of e). An information like %StuckOn (Apply (Arg info (Var i [])))u (stuck on a variable) could be used by the lhs/coverage checker to trigger a split on that (pattern) variable.In the remaining cases for r$, we are terminally stuck due to  StuckOn e. Propagating [ does not seem useful.Z4 must not be propagated, as this would mean that f esD is underapplied, which is not the case (it is stuck). Note that Z\ can only arise when projection patterns were missing to complete the original match (in e/). (Missing ordinary pattern would mean the eQ is of function type, but we cannot match against something of function type.)7Extract pattern variables in left-to-right order. A ?+ is also treated as variable (see docu for I).1Does the pattern perform a match that could fail?QAbsurd lambdas are internally represented as identity with variable name "()".Remove top-level Shared data constructors.Introduce sharing.0Typically m would be TCM and f would be Blocked.An unapplied variable.Add  is it is not already a DontCare. A dummy type.Top sort (Setomega).Get the next higher sort.Removing a topmost  constructor.Doesn't do any reduction.!Make a name that is not in scope.>Convert top-level postfix projections into prefix projections.#A view distinguishing the neutrals Var, Def, and MetaV which can be projected.Drop  constructor. (Unsafe!)Drop  constructor. (Safe)Drop  constructors. (Safe)Split at first non-Discard Proj f entries. Discards Proj f entries.Drop  constructors. (Safe)2The size of a telescope is its length (as a list).A L clause is one with no patterns and no rhs. Should not exist in practice.Blocking by a meta is dominant.] is the unit. \ is dominant. Y{}1 should be propagated, if tied, we take the left. !"#$%&'()*+,-./0123456789:;<The  PatVarName is a name suggestion.=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~#eliminations ordered left-to-right. 123456789:;<=>?@A !"#$%&'()*+,-./0612345789:;<=A>@?BCDEFHGIJNPKLMOQRTSUVWXYZ[\]^_`abcedfghijklmnopqrstuvwyxz{|~} z{|}~}~vwxyurstopqnhijklmfgcde^_`abXYZ[\]RSTUVWVQIJKLMNOPEFGHDC=>?@AB<;789:0123456/.%&'()*+,-#$!" 123456A@?>=<;:987 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWVXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~}~  123456789:;<=>?@A34wNone0\<Filter a list using a list of Bools specifying what to keep.BCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_BCDEFGHIJKLMNOPQRSTUWVXYZ[\]^[XYZUVW\]^RSTQPLMNOBCDEFGHIJK_ B CDEFGHIJKLMNOPQRSTUVWXYZ[\]^_xNone@Smart constructor for let expressions to avoid unneceessary lets&Some things are pointless to make lazyTIf casing on the same expression in a sub-expression, we know what branch to pick>Smart constructor for applications to avoid empty applications Substitution'Get the free variables in an expression/klmnopqrstuvwxyz{|}~Substitute this ... with this ...in this./knlmopqrstu{xvy|z}w~4tuvwxyz{|}~klmnopqrsrrk lmnopqrsrrt uvwxyz{|}~ yNone9;Getting the used definitions.*What it takes to get the used definitions.Inputs to and outputs of getDefs' are organized as a monad.getDefs' lookup emb aF extracts all used definitions (functions, data/record types) from a, embedded into a monoid via emb7. Instantiations of meta variables are obtained via lookup."Typical monoid instances would be [QName] or  Set QName. Note that embV can also choose to discard a used definition by mapping to the unit of the monoid. zNone9;5Put it in a monad to make it possible to do strictly.{None 9:;<=?L yLabel the pattern variables from left to right using one label for each variable pattern and one for each dot pattern.JIntended, but unpractical due to the absence of type-level lambda, is: @labelPatVars :: f (Pattern' x) -> State [i] (f (Pattern' (i,x)))+Arity of a function, computed from clauses.\Translate the clause patterns to terms with free variables bound by the clause telescope.%Precondition: no projection patterns.kTranslate the clause patterns to an elimination spine with free variables bound by the clause telescope.5Augment pattern variables with their de Bruijn index.!Get the number of common initial  patterns in a list of clauses.Get the number of initial  patterns in a clause.Get the number of initial  patterns.|None0234 Case tree with bodies. Case n bs stands for a match on the n(-th argument (counting from zero) with bs as the case branches. If the n+-th argument is a projection, we have only  with arity 0. Done xs b stands for the body b where the xs contains hiding and name suggestions for the free variables. This is needed to build lambdas on the right hand side for partial applications which can still reduce. Absurd case.Branches in a case tree.3We are constructing a record here (copatterns).  lists projections.oMap from constructor (or projection) names to their arity and the case subtree. (Projections have arity 0.)!Map from literal to case subtree.'(Possibly additional) catch-all clause.1Check whether a case tree has a catch-all clause.               }None2MVariable blocking a match./De Bruijn index of variable blocking the match.Nothing means there is an overlapping match for this variable. This happens if one clause has a constructor pattern at this position, and another a variable. It is also used for "just variable". Just cons2 means that it is an non-overlapping match and cons" are the encountered constructors.If matching is inconclusive (Block<) we want to know which variables are blocking the match.Matches unconditionally.Definitely does not match.PCould match if non-empty list of blocking variables is instantiated properly. :Could match if split on possible projections is performed.!We use a special representation of the patterns we're trying to match against a clause. In particular we want to keep track of which variables are blocking a match."?De Bruijn index (usually, rightmost variable in patterns is 0).%0For keeping track of the original dot positions.&5For dot patterns that cannot be turned into patterns.'Projection copattern.(Given the function clauses cs the patterns psIwe want to compute a variable index of the split clause to split on next.First, we find the set cs': of all the clauses that are instances (via substitutions rhos) of the split clause.vIn these substitutions, we look for a column that has only constructor patterns. We try to split on this column first.2Match the given patterns against a list of clauses.%Left dominant merge of blocking vars./ choice m m' combines the match results m of a function clause with the (already combined) match results $m'$ of the later clauses. It is for skipping clauses that definitely do not match ()). It is left-strict, to be used with foldr,. If one clause unconditionally matches () we do not look further.2>Check if a clause could match given generously chosen literals3matchClause mlit qs i c checks whether clause c number i( covers a split clause with patterns qs.4matchPats mlit ps qs3 checks whether a function clause with patterns ps% covers a split clause with patterns qs.Issue 842: if in case of functions with varying arity, the split clause has proper patterns left, we refuse to match, because it would be troublesome to construct the split tree later. We would have to move bindings from the rhs to the lhs. For example, this is rejected: D F : Bool -> Set1 F true = Set F = x -> Set 5matchPat mlit p q* checks whether a function clause pattern p" covers a split clause pattern q. There are three results: Yes () means it covers, because p is a variable pattern or q is a wildcard. No means it does not cover.  Block [x] means p is a proper instance of q and could become a cover if q was split on variable x.6]Combine results of checking whether function clause patterns covers split clause patterns. is dominant: if one function clause pattern is disjoint to the corresponding split clause pattern, then the whole clauses are disjoint.5 is neutral: for a match, all patterns have to match. accumulates variables of the split clause that have to be instantiated to make the split clause an instance of the function clause.  yields to 8, since blocking vars can also block the result type.! !"#$%&'()*+,-./0123456  !"#$%&'()*+,-./012345!(!"#$%&')* +,-./0123465 !"#$%&'()*+,-./0123456~None >+X for root of split treeASplit tree branching. A finite map from constructor names to splittrees A list representation seems appropriate, since we are expecting not so many constructors per data type, and there is no need for random access.BAbstract case tree shape.C@No more splits coming. We are at a single, all-variable clause.DA split is necessary.E+The number of variables bound in the clauseFArg. no to split at.GSub split trees.JConvert a split tree into a 2F (for printing).:;<=>?@ABCDEFGHIJKLMNOPQ:;<=>?@ABCDEFGHIJKLIHBCDEFGA<=>?@QJKPO:;NML:;<=>?@ABCDEFGHIJKLMNOPQNone9:;<=R&Gather free variables in a collection.WThe current context.YIgnore free variables in sorts.Z'Under how many binders have we stepped?[Are we flexible or rigid?\What is the current relevance?]#Method to return a single variable.^5Where should we skip sorts in free variable analysis?_ Do not skip.`Skip when annotation to a type.aSkip unconditionally.cXOccurrence of free variables is classified by several dimensions. Currently, we have g and .gDepending on the surrounding context of a variable, it's occurrence can be classified as flexible or rigid, with finer distinctions.KThe constructors are listed in increasing order (wrt. information content).hIn arguments of metas.i*In arguments to variables and definitions.j=In top position, or only under inductive record constructors.k3Under at least one and only inductive constructors.lg: composition. For accumulating the context of a variable.hW is dominant. Once we are under a meta, we are flexible regardless what else comes.i0 is next in strength. Destroys strong rigidity.k is still dominant over j.j0 is the unit. It is the top (identity) context.mJWhen we extract information about occurrence, we care most about about k  occurrences.pThe initial context.qBase case: a variable.rGoing under a binder.s Changing the g context.t Changing the .u<What happens to the variables occurring under a constructor?8RSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~$RSTUVWXYZ[\]^a_`bcdefghijklmnopqrstu8ghijklcdefmnob^_`aWXYZ[\]VUpTqrstuRS~}|{zyxwv'RSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~None9;$3} Return type of fold over syntax.3~Ignore free variables in sorts.3'Under how many binders have we stepped?5Where should we skip sorts in free variable analysis? Do not skip.Skip when annotation to a type.Skip unconditionally.3Under at least one and only inductive constructors.=In top position, or only under inductive record constructors.*In arguments to variables and definitions.In arguments of metas.Free variables of a term, (disjointly) partitioned into strongly and and weakly rigid variables, flexible variables and irrelevant variables.?Variables under only and at least one inductive constructor(s).Variables at top or only under inductive record constructors s and s. The purpose of recording these separately is that they can still become strongly rigid if put under a constructor whereas weakly rigid ones stay weakly rigid.:Ordinary rigid variables, e.g., in arguments of variables.~Variables occuring in arguments of metas. These are only potentially free, depending how the meta variable is instantiated..Variables in irrelevant arguments and under a DontCare#, i.e., in irrelevant positions. Variables in uments.CRigid variables: either strongly rigid, unguarded, or weakly rigid.!All but the irrelevant variables. allVars fv includes irrelevant variables.3GMark variables as flexible. Useful when traversing arguments of metas.3UMark rigid variables as non-strongly. Useful when traversion arguments of variables.3hMark unguarded variables as strongly rigid. Useful when traversion arguments of inductive constructors.3<What happens to the variables occurring under a constructor?3&Mark all free variables as irrelevant.3>Mark all free variables as unused, except for irrelevant vars.3Pointwise union.3 delete x fv deletes variable x from variable set fv.3subtractFV n fv* subtracts $n$ from each free variable in fv.3A single unguarded variable.\Doesn't go inside solved metas, but collects the variables from a metavariable application X ts as  flexibleVars.3Base case: a variable.3Going under a binder.7Is the variable bound by the abstraction actually used?'Free variable sets form a monoid under 3.H33}333~3333333333333333!!333}333~3333333333333333None*9:;<=M 3Under at least one and only inductive constructors.=In top position, or only under inductive record constructors.*In arguments to variables and definitions.In arguments of metas.Free variables of a term, (disjointly) partitioned into strongly and and weakly rigid variables, flexible variables and irrelevant variables.?Variables under only and at least one inductive constructor(s).Variables at top or only under inductive record constructors s and s. The purpose of recording these separately is that they can still become strongly rigid if put under a constructor whereas weakly rigid ones stay weakly rigid.:Ordinary rigid variables, e.g., in arguments of variables.~Variables occuring in arguments of metas. These are only potentially free, depending how the meta variable is instantiated..Variables in irrelevant arguments and under a DontCare#, i.e., in irrelevant positions. Variables in uments.CRigid variables: either strongly rigid, unguarded, or weakly rigid.!All but the irrelevant variables. allVars fv includes irrelevant variables.ICompute an occurrence of a single variable in a piece of internal syntax.3EExtract occurrence of a single variable from computed free variables.3GMark variables as flexible. Useful when traversing arguments of metas.3UMark rigid variables as non-strongly. Useful when traversing arguments of variables.3hMark unguarded variables as strongly rigid. Useful when traversing arguments of inductive constructors.3<What happens to the variables occurring under a constructor?3&Mark all free variables as irrelevant.3>Mark all free variables as unused, except for irrelevant vars.3Pointwise union.3 delete x fv deletes variable x from variable set fv.\Doesn't go inside solved metas, but collects the variables from a metavariable application X ts as  flexibleVars.3 freeIn' = freeIn'' (const True)7Is the variable bound by the abstraction actually used?0Is the term entirely closed (no free variables)?Collect all free variables.=Collect all relevant free variables, possibly ignoring sorts.$Collect all relevant free variables.'Free variable sets form a monoid under 3.;3333333333333333333333'R^a_`'R^_`a-3333333333333333333333INone#02349:;<=AIOTEDMaps top-level module names to the corresponding source file names.Interaction monad. Environment of the reduce monad. Read only access to environment.0Read only access to state (signature, metas...).Type-checking errors.DDistinguish error message when parsing lhs or pattern synonym, resp. GThe target of a constructor isn't an application of its datatype. The u records what it does target.The target of a constructor isn't its datatype applied to something that isn't the parameters. First term is the correct target and the second term is the actual target.>Expected a type to be an application of a particular datatype.constructor, datatypeIndices.Variables, indices.mIndices (variables), index expressions (with constructors applied to reconstructed parameters), parameters.Datatype, constructors.constructor, type+Varying number of arguments for a function.eThe left hand side of a function definition has a hidden argument where a non-hidden was expected.9Expected a non-hidden function and found a hidden lambda.KA function is applied to a hidden argument where a non-hidden was expected.BA function is applied to a hidden named argument it does not have.<Expected a relevant function and found an irrelevant lambda.6A term is declared as an instance but it s not allowed<The given hiding does not correspond to the expected hiding.AThe given relevance does not correspond to the expected relevane.7The term does not correspond to an inductive data type.''The given type should have been a sort.(%The given type should have been a pi..#This sort is not a type expression./#This term is not a type expression.04This term, a function type constructor, lives in SizeUniv, which is not allowed.60The two function types have different relevance.7-The two function types have different hiding.:hWe ended up with an equality constraint where the terms have different types. This is not supported.<wThe arguments are the meta variable, the parameters it can depend on and the paratemeter that it wants to depend on.eMSome interaction points (holes) have not be filled by user. There are not c{ since unification solved them. This is an error, since interaction points are never filled without user interaction.lpModule name, file from which it was loaded, file which the include path says contains the module. Scope errors|hThe expr was used in the right hand side of an implicit module definition, but it wasn't of the form m Delta.KError when splitting a pattern variable into possible constructor patterns.Neither data type nor record.&Data type, but in irrelevant position.tSplit on codata not allowed. UNUSED, but keep! -- | NoRecordConstructor Type -- ^ record type, but no constructor Constructor.Context for indices.,Inferred indices (from type of constructor).)Expected indices (from checking pattern).MInformation about a mutual block which did not pass the termination checker.ZThe functions which failed to check. (May not include automatically generated functions.)The problematic call sites.Information about a call.Target function name.Range of the target function.+To be formatted representation of the call.A candidate solution for an instance meta is a term with its type. It may be the case that the candidate is not fully applied yet or of the wrong type, hence the need for the type.7Explicit arguments are considered as instance argumentsAAdd implicit arguments in the end until type is no longer hidden .!Do not append implicit arguments.6Abstract things in the current module can be accessed.#No abstract things can be accessed.$All abstract things can be accessed.The Context is a stack of s.=The path to the file that is currently being type-checked. +X9 if we do not have a file (like in interactive mode see  CommandLine).4anonymous modules and their number of free variablesto detect import cycles!the current (if any) mutual block/are we inside the scope of a termination pragma>Are we currently in the process of solving active constraints?OHave we stepped into the where-declarations of a clause? Everything under a where# will be checked with this flag on.Are we allowed to assign metas?When checking the typesignature of a public definition or the body of a non-abstract definition this is true. To prevent information about abstract things leaking outside the module.*Are we checking an irrelevant argument? (= IrrelevantE) Then top-level irrelevant declarations are enabled. Other value: Relevant&, then only relevant decls. are avail.+Sometimes we want to disable display forms.oshould we try to recover interaction points when reifying? disabled when generating types for with functionsit's safe to eta contract implicit lambdas as long as we're not going to reify and retypecheck (like when doing with abstraction)8Interactive highlighting uses this range rather than .what we're doing at the momentSet to + when imported modules are type-checked.JThis number indicates how far away from the top-level module Agda has come when chasing modules. The level of a given module is not necessarily the same as the length, in the module dependency graph, of the shortest path from the top-level module; it depends on in which order Agda chooses to chase dependencies. When True, allows destructively shared updating terms during evaluation or unification. This is disabled when doing speculative checking, like solve instance metas, or when updating might break abstraction, as is the case when checking abstract definitions.When type-checking an alias f=e, we do not want to insert hidden arguments in the end, because these will become unsolved metas.]We are reducing an application of this function. (For debugging of incomplete matches only.)YDid we encounter a simplification (proper match) during the current reduction process?`Can we compare blocked things during conversion? No by default. Yes for rewriting feature.PWhen True types will be omitted from printed pi types if they can be inferredUsed by the scope checker to make sure that certain forms of expressions are not used inside dot patterns: extended lambdas and let-expressions.6How should highlighting be sent to the user interface? Via stdout.Both via files and via stdout.;How much highlighting should be sent to the user interface?This includes both non-interactive highlighting and interactive highlighting of the expression that is currently being type-checked.-Builtin of any kind. Type can be checked (Just t) or inferred (NothingD). The second argument is the hook for the verification function.2When typechecking something of the following form:"instance x : _ x = y it's not yet known where to add xQ, so we add it to a list of unresolved instances and we'll deal with it later.The instance table is a Map' associating to every name of record data typepostulate its list of instances"*Interaction command: show module contents.#used by setCurrentRange5 Controlling reduce.6:(Projection and) projection-like functions may be reduced.7'Functions marked INLINE may be reduced.8%Copattern definitions may be reduced.93Functions which are not projections may be reduced.:Reduce f terms.;4Functions that have not passed termination checking.BNThree cases: 1. not reduced, 2. reduced, but blocked, 3. reduced, not blocked.H"Did we encounter a simplifying reduction? In terms of CIC, that would be a iota-reduction. In terms of Agda, this is a constructor or literal pattern that matched. Just beta-reduction (substitution) or delta-reduction (unfolding of definitions) does not count as simplifying?N Postulate.SPrimitive or builtin functions.U+X* while function is still type-checked. Just ccC after type and coverage checking and translation to case trees.V2Intermediate representation for compiler backends.XMutually recursive functions, datas and record%s. Does not include this function.Z+Are the clauses of this definition delayed?[(Is it a record projection? If yes, then return the name of the record type and index of the record argument. Start counting with 1, because 0 means that it is already applied to the record. (Can happen in module instantiation.) This information is used in the termination checker.\<Should calls to this function be normalised at compile-time?]9Should calls to this function be inlined by the compiler?^&Are we allowed to smash this function?_9Has this function been termination checked? Did it pass?`Is this function generated from an extended lambda? If yes, then return the number of hidden and non-hidden lambda-lifted argumentsaZIs this a generated with-function? If yes, then what's the name of the parent function.b)Is this a function defined by copatterns?cNumber of parameters.d Parameters that are maybe small.e"Parameters that appear in indices.fNumber of indices.gdata or codata (legacy).h(This might be in an instantiated module.iConstructor names.kMutually recursive functions, datas and record$s. Does not include this data type.mNumber of parameters.oConstructor name and fields.q<The record constructor's type. (Includes record parameters.)sCThe record field telescope. (Includes record parameters.) Note: $TelV recTel _ == telView' recConType . Thus, recTel is redundant.tMutually recursive functions, datas and record!s. Does not include this record.u!Eta-expand at this record type. False] for unguarded recursive records and coinductive records unless the user specifies otherwise.v or *? Matters only for recursive records. +XT means that the user did not specify it, which is an error for recursive records.wRecursive record. Infers recEtaEquality = False'. Projections are not size-preserving.yNumber of parameters.zPName of (original) constructor and fields. (This might be in a module instance.){ Name of datatype or record type.}Inductive or coinductive?3 for primitive functions, not null for builtin functions.+X for primitive functions, *w something for builtin functions.&Additional information for projection Os.Nothing if only projection-like, Just q if record projection, where qL is the original projection name (current name could be from module app).%Type projected from. Record type if projProper = Just{}.Index of the record argument. Start counting with 1, because 0 means that it is already applied to the record value. This can happen in module instantiation, but then either the record value is var 0, or funProjection == Nothing.Term t to be be applied to record parameters and record value. The parameters will be dropped. In case of a proper projection, a postfix projection application will be created: t = pars r -> r .p2 (Invariant: the number of abstractions equals X.) In case of a projection-like function, just the function symbol is returned as : t = pars -> f.,The info of the principal (record) argument.,Additional information for extended lambdas.+Polarity for equality and subtype checking.monotoneantitoneno information (mixed variance)constantCore code for functions.Core type for agda type.&Core constructor for agda constructor.Hiding should not be used.Type of the lifted definition.Variance information on arguments of the definition. Does not include info for dropped parameters to projection(-like) functions and constructors.Positivity information on arguments of the definition. Does not include info for dropped parameters to projection(-like) functions and constructors.Just q/ when this definition is an instance of class q:Has this function been created by a module instantiation??Rewrite rules can be added independently from function clauses.Name of rewrite rule q :  ! lhs "a rhs where "a is the rewrite relation..  " lhs : t.  " rhs : t. " t.1Non-linear (non-constructor) first-order pattern.(Matches anything (modulo non-linearity).)Matches anything (e.g. irrelevant terms).Matches f esMatches  x ! tMatches  (x : A) ! BMatches x es# where x is a lambda-bound variable'Matches the term modulo  (ideally ).A structured presentation of a  for reification into GH.(f vs | ws) us. The first  is the parent function f with its args vs. The list of s are the with expressions ws . The  are additional arguments us@ (possible in case the with-application is of function type).c vs.d vs..v.v.A  DisplayForm! is in essence a rewrite rule  q ts --> dt : for a defined symbol (could be a constructor as well) q. The right hand side is a  which is used to reify to a more readable GH. The patterns ts are just terms, but var 02 is interpreted as a hole. Each occurrence of var 0: is a new hole (pattern var). For each *occurrence* of var0 the rhs dt_ has a free variable. These are instantiated when matching a display form against a term q vs succeeds.Number n of free variables in .Left hand side patterns, where var 04 stands for a pattern variable. There should be n occurrences of var0 in .Right hand side, with n free variables.'The rewrite rules defined in this file./Data structure managing the interaction points.Interaction points are created by the scope checker who sets the range. The meta variable is created by the type checker and then hooked up to the interaction point.&The position of the interaction point.0The meta variable, if any, holding the type etc.8For printing, we couple a meta with its name suggestion.EName suggestion for meta variable. Empty string means no suggestion.MetaInfo4 is cloned from one meta to the next during pruning.7Run the extended occurs check that goes in definitions?Used for printing. Just x8 if meta-variable comes from omitted argument with name x.pMeta variable priority: When we have an equation between meta-variables, which one should be instantiated?6Higher value means higher priority to be instantiated.( (xs : t ) ! e) : t This is not an instance of T as the domain type has already been checked. For example, when checking '( (x y : Fin _) ! e) : (x : Fin n) ! ? we want to postpone ( (y : Fin n) ! e) : ? where Fin n is a u rather than an J.CFirst argument is computation and the others are hole and goal type4solved by term (abstracted over some free variables) solved by  Lam .. Sort sunsolved1open, to be instantiated as "implicit from scope"(solution blocked by unsolved constraintsFrozen meta variable cannot be instantiated by unification. This serves to prevent the completion of a definition by its use outside of the current block. (See issues 118, 288, 399).Do not instantiate.4some metavariables are more eager to be instantiated a metavariable doesn't have to depend on all variables in the context, this "permutation" will throw away the ones it does not depend on Bmeta variables scheduled for eta-expansion but blocked by this one Bare we past the point where we can instantiate this meta variable?FParametrized since it is used without MetaId when creating a new meta.-A thing tagged with the context it came from.An extension of  to >=.",the two types are for the error message only'+The range is the one of the absurd pattern.(Check that the . is either not a SIZELT or a non-empty SIZELT.)the first argument is the instance argument, the second one is the meta on which the constraint may be blocked on and the third one is the list of candidates (or Nothing if we haven t determined the list of candidates yet)7Hash of the source code.8"Imported modules and their hashes.9Module name of this interface.:Scope defined by this module.;1Scope after we loaded this interface. Used in I and J.nAndreas, AIM XX: For performance reason, this field is not serialized, so if you deserialize an interface,  iInsideScope; will be empty. You need to type-check the file to get  iInsideScope.=-Display forms added for imported identifiers.?RHaskell imports listed in (transitively) imported modules are not included here.@RHaskell imports listed in (transitively) imported modules are not included here.AInline Haskell codeCPragma options set in the file.J*x@ if warnings were encountered when the module was type checked.KDMaps source file names to the corresponding top-level module names.LCreate a fresh name from a.S0A complete log for a module will look like this:WT, entering the main module.$'Decl'/'EnterSection'/'LeaveSection'*, for declarations and nested modulesU, leaving the main module.VNever a Section or ScopeDeclXLike Yy, but storing the log for an ongoing type checking of a module. Stored in reverse order (last performed action first).YA log of what the type checker does and states after the action is completed. The cached version is stored first executed action first.^YA part of the state which is not reverted when an error is thrown or the state is reset.bwCallback function to call when there is a response to give to the interactive frontend. See the documentation of  j.cwStructure to track how much CPU time was spent on which Agda phase. Needs to be a strict field to avoid space leaks!dShould be strict field.e`Cached typechecking state from the last loaded file. Should be Nothing when checking imports.hHighlighting info.ijDisambiguation carried out by the type checker. Maps position of first name character to disambiguated  for each $ already passed by the type checker.nTDirty when a constraint is added, used to prevent pointer update. Currently unused.oDefinitions to be considered during occurs check. Initialized to the current mutual block before the check. During occurs check, we remove definitions from this set as soon we have checked them.peDeclared identifiers of the current file. These will be serialized after successful type checking.q-Display forms we add for imported identifiersr;Display forms added by someone else to imported identifierss@The current module is available after it has been type checked.uZCounters to collect various statistics about meta variables etc. Only for current file.UHighlighting info for tokens (but not those tokens for which highlighting exists in ).?Imported declared identifiers. Those most not be serialized!2Pattern synonyms of the current file. Serialized.3Imported pattern synonyms. Must not be serialized!&Options applying to the current file. OPTIONS! pragmas only affect this field.jImports that should be generated by the compiler / MAlonzo (this includes imports from imported modules).nImports that should be generated by the compiler / UHC backend (this includes imports from imported modules).>Inline Haskell code that should be inserted by the GHC backend/The state which is frozen after scope checking.1The state which is modified after scope checking.'State which is forever, like a diamond.Empty persistent state.Empty state of type checker. Creates a K map based on .GCombines the source hash and the (full) hashes of the imported modules.Embed  into .!Flip the direction of comparison.Turn a  function into a  function. Property:  dirToCmp f (fromCmp cmp) = f cmp$By default, we have no display form.+Create a definition with sensible defaults.A template for creating O% definitions, with sensible defaults.BChecking whether we are dealing with a function yet to be defined.:Not quite all reductions (skip non-terminating reductions)+Are the clauses of this definition delayed?2Has the definition failed the termination checker?%Beware when using this function on a def obtained with getConstInfo q! If the identifier q is abstract,  getConstInfo will turn its def into an N and you always get , paradoxically. Use it in , like this:  a  -#ignoreAbstractMode $ defAbstract <$ getConstInfo q $ifTopLevelAndHighlightingLevelIs l m runs mO when we're type-checking the top-level module and the highlighting level is at least l..Preserve the state of the failing computation.Execute a finalizer even when an exception is thrown. Does not catch any errors. In case both the regular computation and the finalizer throw an exception, the one of the finalizer is propagated.4Running the type checking monad (most general form).ARunning the type checking monad on toplevel (with initial state).   runs a safe F action (a F9 action which cannot fail) in the initial environment. 6Runs the given computation in a separate thread, with a copy' of the current state and environment.RNote that Agda sometimes uses actual, mutable state. If the computation given to forkTCM tries to modify\ this state, then bad things can happen, because accesses are not mutually exclusive. The forkTCM8 function has been added mainly to allow the thread to read7 (a snapshot of) the current state in a convenient way.Note also that exceptions which are raised in the thread are not propagated to the parent, so the thread should not do anything important. &Base name for extended lambda patterns !Name of absurdLambda definitions. :Check whether we have an definition from an absurd lambda.#)Short-cutting disjunction forms a monoid.%aWe store benchmark statistics in an IORef. This enables benchmarking pure computation, see Agda.Benchmarking.BWe only + the name of the callee.|EFGHIJK      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefg"EFGHIJK>`      !"#$%&'()*+,-./0123456789:;<=?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_abcdefghijklmnopqrstuvwxyz{|}~#      !"$%&'()*+,-./0123456789:;<=>?@ABDCEFGHIJKLMPROSQN]T[ciy{orpUVWXYZ\^_`abdefghjklmnqstuvwxz|}~     ' !"#$%&()*+,-./0213456987:;<=>?@ABCDEFGHIJKLMNOPQRSVWTUXYZ[\]^_a`bcdefghijklmnopqrstuvwxyz{|}~     Jg~fghijklmnopqrstuvwxyz{|}^_`abcdeZ[\]YXSTUVWPQRfedcbaNO`_^LM]\[ZEKGHIJFE56789:;<=>?@ABCDY/01234XW.*+,-V !"#$%&'()UTSRQ     PONMLKJIHMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~KLHIJGFEFGBCD>?@AE=<56789:;4/0123.+,-'()*%&$      !"#DCKBA@?>      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~=<;:98765GHI43F210/.-,+*)('&%$#     "! EEFGHIJK       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLM4NOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~        !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefgNone''%None: +Get the name of the current module, if any. #Set the name of the current module. 7Get the number of variables bound by anonymous modules. +Add variables bound by an anonymous module.(Set the current environment to the givenGet the current environmentDIncreases the module nesting level by one in the given computation.Set highlighting levelRestore setting for  to default.oIf the reduced did a proper match (constructor or literal pattern), then record this as simplification step. Lens for 4.Reduce Def f vs only if f is a projection.DAllow all reductions except for non-terminating functions (default).9Allow all reductions including non-terminating functions.                None9;<=? !"#$%&'()*+,-./01! "#$"#$ !10/.-,+*)('&% !"#$%&'()*+,-./01NoneBWAssumes that the first module in the import path is the module we are worried about.23456789:;<=>?@AB23456789:;<=>?@AB23456789:;<=>?@AB23456789:;<=>?@ABNoneAT%]Monad used by the decoder.TCMJ is not used because the associated overheads would make decoding slower.^Monad used by the encoder._State of the decoder.aObtained from interface file.bObtained from interface file.cObtained from interface file.dObtained from interface file.eObtained from interface file.fZCreated and modified by decoder. Used to introduce sharing while deserializing objects.g<Maps module names to file names. Constructed by the decoder.hThe include directories.j=Univeral memo structure, to introduce sharing during decodingk!Universal type, wraps everything.mState of the the encoder.oWritten to interface file.pWritten to interface file.qWritten to interface file.rWritten to interface file.svWritten to interface file. Dicitionaries which are not serialized, but provide short cuts to speed up serialization:t~Not written to interface file. Andreas, Makoto, AIM XXI Memoizing A.Name does not buy us much if we already memoize A.QName.uNot written to interface file.v@Not written to interface file. Fresh UIDs and reuse statistics:If True collect in stats the quantities of calls to icode for each  Typeable a.Not written to interface file.Two s are equal if their QNameId is equal.zStructure providing fresh identifiers for hash map and counting hash map hits (i.e. when no fresh identifier required).Number of hash map misses.Number of hash map hits.+The type of hashtables used in this module.0A very limited amount of testing indicates that 3 is somewhat slower than 3 , and that 3 and the hashtables from Data.Hashtable are much slower.5Constructor tag (maybe omitted) and argument indices.(Computing a qualified names composed ID.Creates an empty dictionary.EThrows an error which is suitable when the data stream is malformed.Increase entry for a in . Data.Binary.runGetState is deprecated in favour of runGetIncremental. Reimplementing it in terms of the new function. The new Decoder type contains strict byte strings so we need to be careful not to feed the entire lazy byte string to the decoder at once.icode# only if thing has not seen before.vcase value ix decodes thing represented by  ix :: Int32 via the valu function and stores it in f. If ix is present in f, valu, is not used, but the thing is read from f instead.nYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~Collect statistics for icode calls? Memo structure for thing of key a. Statistics.Key to the thing.)Fallback computation to encode the thing.Encoded thing.nY\[Z]^_`hbacdefgijklmnopqrstuvwxyz{|}~nmnopqrstuvwxyz{|}~klj_`abcdefghi^]YZ[\IYZ[\]^_ `abcdefghijklmnopqrstuvwxyz{|}~None /029:;<=?LM$Methods to retrieve the N.#Returns the properly raised clause F , and +X if H.zJust grabs the body, without raising the de Bruijn indices. This is useful if you want to consider the body in context L.Performs void (noAbs) abstraction over telescope.Apply a substitution.(abstract args v)  args --> v[args].mApply something to a bunch of arguments. Preserves blocking tags (application can never resolve blocking). Apply to some default arguments.#Apply to a single default argument.If $v$ is a record value, canProject f v returns its field f.Eliminate a constructed term.defApp f us vs applies Def f us to further arguments vs/, eliminating top projection redexes. If us` is not empty, we cannot have a projection redex, since the record argument is the first one.  (x:A)->B(x)  [u] = B(u)gPrecondition: The type must contain the right number of pis without having to perform any reduction.piApply$ is potentially unsafe, the monadic piApplyM is preferable.To replace index n by term u, do applySubst (singletonS n u).$Lift a substitution under k binders. applySubst ( & ) v == applySubst  (applySubst  v) " (strengthenS " ||) : ,Replace de Bruijn index i by a  in something.BReplace what is now de Bruijn index 0, but go under n binders. %substUnder n u == subst n (raise n u).Turn a typed binding (x1 .. xn : A) into a telescope.Turn a typed binding (x1 .. xn : A) into a telescope.lTakes off all exposed function domains from the given type. This means that it does not reduce to expose Pi-types.telView'UpTo n t takes off the first n exposed function types of t#. Takes off all (exposed ones) if n < 0. )mkPi dom t = telePi (telFromList [dom]) t )Uses free variable analysis to introduce noAbs bindings. Everything will be a z. FDependent least upper bound, to assign a level to expressions like forall i -> Set i.dLub s1 i.s2 = omega if i# appears in the rigid variables of s2. /Instantiate an abstraction. Strict in the term.FInstantiate an abstraction. Lazy in the term, which allow it to be  IMPOSSIBLEG in the case where the variable shouldn't be used but we cannot use . Used in Apply.9Instantiate an abstraction that doesn't use its argument.underAbs k a b applies k to a# and the content of abstraction b# and puts the abstraction back. aM is raised if abstraction was proper such that at point of application of k and the content of b. are at the same context. Precondition: a and b& are at the same context at call time.underLambdas n k a b drops n initial s from b, performs operation k on a and the body of b, and puts the  s back. a@ is raised correctly according to the number of abstractions.The `rule'B, if Agda is considered as a functional pure type system (pts).TODO: This needs to be properly implemented, requiring refactoring of Agda's handling of levels. Without impredicativity or l, Agda's pts rule is just the least upper bound, which is total and commutative. The handling of levels relies on this simplification.  Syntactic  equality, ignores stuff below DontCare and sharing." Syntactic u$ equality, ignores sort annotations.Ytel " ( " lhs ! rhs : t) becomes tel,  " lhs ! rhs : t)\ we do not need to change lhs, rhs, and t since they live in . See 'Abstract Clause'.      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz^/0612345     zyxwvutsrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONMLKJIHGFEDCBA@?>=<;:9876543210/.-,+*)   ('  &%$#"! 0123456/      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz4None<=INoneM33333333None3,Split alts into TAGuard alts and other alts.33NoneM33NonesimplifyLevelConstraint n c cs turns an cp into an equality constraint if it is an inequality constraint and the reverse inequality is contained in cs . Number n! is the length of the context c is defined in.333333NoneThe coinductive primitives.2Rewrite a literal to constructor form if possible.Builtins that come without a definition in Agda syntax. These are giving names to Agda internal concepts which cannot be assigned an Agda type.,An example would be a user-defined name for Set.{- BUILTIN TYPE Type -} The type of Type would be Type : Level ! Set which is not valid Agda.Tries to build a ."Get the name of the equality type.cCheck whether the type is actually an equality (lhs "a rhs) and extract lhs, rhs, and their type.Precondition: type is reduced. Revert the %.Postcondition: type is reduced.      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~  ! "#   4./0231+,-$%&'()*56789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~None:+Create an open term in the current context.$Create an open term which is closed. Check if an  is closed.rExtract the value from an open term. Must be done in an extension of the context in which the term was created.Try to use an ! the current context. Returns +XG if current context is not an extension of the context in which the  was created.None9:;<=None9:;<=?,Maximum size of the generated element. When Nothing' this value is initialized from the KL parameter.HWhen this is true no lambdas, literals, or constructors are generated-GOnly generates default configurations. Names and free variables varies.0ECheck that the generated terms don't have any out of scope variables.      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`a[      !"#$%&'()*+,-./0      !"#$%&'()*a`_^]\[ZYXW+,VUTSRQPO-NMLKJIHGFEDCBA@?>=<;.:987654321/0U        !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`aNone 0234:T3+Ensure the correct linear order is derived.iAll tests as collected by *z.333333333333333333333iii333333333333333333333iNonekIWhen verbosity is set or changes, we need to turn benchmarking on or off.3(Check whether benchmarking is activated.laPrints the accumulated benchmark results. Does nothing if profiling is not activated at level 7.33k3l*efyz{kleffkz{yl33k3lNone m9Errors which can arise when trying to find a source file."Invariant: All paths are absolute.nHThe file was not found. It should have had one of the given file names.o"Several matching files were found.AInvariant: The list of matching files has at least two elements.pEConverts an Agda file name to the corresponding interface file name.qKGiven the module name which the error applies to this function converts a m to a .rgFinds the source file corresponding to a given top-level module name. The returned paths are absolute.,Raises an error if the file cannot be found.sqTries to find the source file corresponding to a given top-level module name. The returned paths are absolute.SIDE EFFECT: Updates .t A variant of s which does not require F.ujFinds the interface file corresponding to a given top-level module name. The returned paths are absolute.ARaises an error if the source file cannot be found, and returns +X= if the source file can be found but not the interface file.vEnsures that the module name matches the file name. The file corresponding to the module name (according to the include path) has to be the same as the given file name.wCComputes the module name of the top-level module in the given file.IWarning! Parses the whole file to get the module name out. Use wisely!x A variant of wH which raises an error if the file name does not match the module name.`The file name is interpreted relative to the current working directory (unless it is absolute). mnopqrstInclude paths.Cached invocations of t. An updated copy is returned.uvThe name of the module."The file from which it was loaded.wx mnopqrstuvwx pmnoqrstuvwx mnopqrstuvwxNone 09:;AIT3*Ranges that should be serialised properly."Ranges are always deserialised as .;333yz{|}~9333yz{|}~NoneNone!:Resets the non-persistent part of the type checking state.&Resets all of the type checking state. Keep only  information.Restore J! after performing subcomputation.In contrast to M, the * info from the subcomputation is saved.Same as I but also returns the state in which we were just before reverting it. Lens for d.Get the current scope.Set the current scope.;Modify the current scope without updating the inverse maps.Modify the current scope.#Run a computation in a local scope.Same as -, but discard the scope from the computation.2Discard any changes to the scope by a computation. Scope error.Debug print the scope. Update a possibly imported definition. Warning: changes made to imported definitions (during type checking) will not persist outside the current module. This function is currently used to update the compiled representation of a function during compilation.JRun some computation in a different signature, restore original signature.ZSet the top-level module. This affects the global module id of freshly generated names.gUse a different top-level module for a computation. Used when generating names for imported modules.5Tell the compiler to import the given Haskell module.Get the Haskell imports.5Tell the compiler to import the given Haskell module.Get the Haskell imports. Lens for .Lens getter for  from J. Lens map for .Lens getter for  from F.Lens modify for .9Run a fresh instance of the TCM (with initial state).  info is preserved.>Look through the signature and reconstruct the instance table. Lens for .4Remove all instances whose type is still unresolved./Add an instance whose type is still unresolved.Add instance to some `class'.@Name of the instance.Name of the class.@@@None9      !"#$%&'()*+,-./)     9/.  -,   +*)('&%$#"! $      !"#$%&'()*+,-./None0000None3%Set the mutual block for a definition4Get all mutual blocks5RGet the current mutual block, if any, otherwise a fresh mutual block is returned.12345678123456781234567812345678None:D9Returns the pragma options which are currently in effect.E?Returns the command line options which are currently in effect.GConditionally render debug +N and print it.H#Conditionally println debug string.I<Run a computation if a certain verbosity level is activated.-Precondition: The level must be non-negative.J5Check whether a certain verbosity level is activated.-Precondition: The level must be non-negative.KGets the include directories.Precondition:   must be nonempty (i.e. = must have run).9?Which directory should form the base of relative include paths?:The root directory of the "project" containing the given file. The file needs to be syntactically correct, with a module name matching the file name.;The current working directory.<Sets the pragma options.=PSets the command line options (both persistent and pragma options are updated).Relative include directories are made absolute with respect to the current working directory. If the include directories have changed (thus, they are + now, and were previously + something>), then the state is reset (completely, see setIncludeDirs) ./An empty list of relative include directories (+ []) is interpreted as ["."].DDisable display forms.EDisable display forms.F#Check if display forms are enabled.GDon't eta contract implicitHDo eta contract implicitJDon't reify interaction pointsMMMakes the given directories absolute and stores them as include directories.pIf the include directories change, then the state is reset (completely, except for the include directories and b). An empty list is interpreted as ["."].OShould only be run if Q.P Return the   as  , if any.ZmSwitch on printing of implicit and irrelevant arguments. E.g. for reification in with-function generation._%Retrieve the current verbosity level.`+Displays a debug message in a suitable way.a!Conditionally print debug string.b=Print brackets around debug messages issued by a computation.4CDEFGHIJK9:;<=>?@ABCDEFGHIJKLMNew include directories.)How should relative paths be interpreted?NOPQRSTUVWXYZ[\]^_`The message's debug level.Message.abc3CEDFGHIJK9;:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`ab4<=>?@ABCDEcCDEFGHIJKK9:;LMNOPQRSTUVWXYZ[\]^_FJ`IaHGb0CDEFGHIJK9:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcNone:L[i@record fields names need to be distinguished to parse copatternsmTo simplify interaction between scope checking and type checking (in particular when chasing imports), we use the same monad.uQCreate a new module with an empty scope (Bool is True if it is a datatype module)v"Apply a function to the scope map.w$Apply a function to the given scope.y*Apply a monadic function to the top scope.z&Apply a function to the current scope.|5Apply a function to the public or private name space.7Run a computation without changing the local variables.2Create a fresh abstract name from a concrete name.MThis function is used when we translate a concrete name in a binder. The X) of the concrete name is saved as the  of the abstract name. 0freshAbstractName_ = freshAbstractName noFixity''Create a fresh abstract qualified name.?Look up the abstract name referred to by a given concrete name.VLook up the abstract name corresponding to a concrete name of a certain kind and/or from a given set of names. Sometimes we know already that we are dealing with a constructor or pattern synonym (e.g. when we have parsed a pattern). Then, we can ignore conflicting definitions of that name of a different kind. (See issue 822.)Look up a module in the scope.?Get the notation of a name. The name is assumed to be in scope.FBind a variable. The abstract name is supplied as the second argument..Bind a defined name. Must not shadow anything.}Rebind a name. Use with care! Ulf, 2014-06-29: Currently used to rebind the name defined by an unquoteDecl, which is a  in the body, but a h later on.Bind a module name.HBind a qualified module name. Adds it to the imports field of the scope. Clear the scope of any no names.Create a new scope with the given name from an old scope. Renames public names in the old scope to match the new name and returns the renamings.SApply an import directive and check that all the names mentioned actually exist.A finite map for  ImportedNames.Translation of ImportDirective.Translation of Using or Hiding.Translation of Renaming.Open a module.4defghijklmnopqrstuvwxyz{|}~9The name must correspond to one of the names in this set.Translation of imported names.,Translation of names defined by this import.Translation of names in using or hiding list.Translation of  names.Translation of rento names.4defghijklmnopqrstuvwxyz{|}~4mnopqrstuvwxyz{|}~fghijkled.defghijklmnopqrstuvwxyz{|}~None /29:;LMT34Alpha-Equivalence of patterns, ignoring dot patterns3+currently we only support variable patterns3A sequence of decisions b leading to a head a.3the list of choices3?This is a n^2 grouping algorithm which uses only alpha-equality3Expects a sorted list.3 Similar to 3.s are not renamed.63333333333333333333333333,3333333333333333333333333None%&,T3$Name sets for classifying a pattern.3name of defined symbol3valid constructor names3valid field names3Data structure filled in by  buildParsers. The top-level parser pTop is of primary interest, but pArgsK is used to convert module application from concrete to abstract syntax.3Bills the operator parser.3Compute all defined names in scope and their fixities/notations. Note that overloaded names (constructors) can have several fixities/notations. Then we  D. (See issue 1194.)3YCompute all names (first component) and operators/notations (second component) in scope.3`Builds a parser for operator applications from all the operators and function symbols in scope.When parsing a pattern we do not use bound names. The effect is that operator parts (that are not constructor parts) can be used as atomic names in the pattern (so they can be rebound). See testsucceed OpBind.agda for an example.When parsing a pattern we also disallow the use of sections, mainly because there is little need for sections in patterns. Note that sections are parsed by splitting up names into multiple tokens (_+_ is replaced by _, + and _), and if we were to support sections in patterns, then we would have to accept certain such sequences of tokens as single pattern variables.tThe list of names must include every name part in the expression/pattern to be parsed (excluding name parts inside things like parenthesised subexpressions that are treated as atoms). The list is used to optimise the parser. For instance, a given notation is only included in the generated grammar if all of the notation's name parts are present in the list of names.(The returned list contains all operators notations1sections that were used to generate the grammar.3View a pattern p as a list p0 .. pn where p04 is the identifier (in most cases a constructor).8Pattern needs to be parsed already (operators resolved).3$Returns the list of possible parses.3(The returned list contains all operators notations1sections that were used to generate the grammar.3(Returns zero or one classified patterns.JParses a left-hand side, and makes sure that it defined the expected name.Parses a pattern.3Helper function for  and .3Helper function for  and .3,Return all qualifiers occuring in a list of As. Each qualifier is returned as a list of names, e.g. for  Data.Nat._+_ we return the list  [Data,Nat].0Parse a list of expressions into an application.ZParse an expression into a module application (an identifier plus a list of arguments).&333333333333444443333333343334444 333333333333444443333333343334444 None9:;LPCheck if we are in a compatible context, i.e. an extension of the given context. Get the current context.Various specializations of addCtx. Modify the  field of a . Modify all s. Modify a  in a computation.Change the context.Change to top (=empty) context.Delete the last n bindings from the context.addCtx x arg cont add a variable to the context.Chooses an unused .:add a bunch of variables with the same type to the context8Turns the string into a name and adds it to the context.ITurns the string into a name and adds it to the context, with dummy type.4Context entries without a type have this dummy type.Go under an abstraction.KGo under an abstract without worrying about the type to add to the context.Add a telescope to the context.Add a let bound variable$Get the size of the current context. Generate [var (n - 1), ..., var 0]% for all declarations in the context. Generate [var (n - 1), ..., var 0]% for all declarations in the context.Get the current context as a n.1Get the names of all declarations in the context.0get type of bound variable (i.e. deBruijn index)Get the term corresponding to a named variable. If it is a lambda bound variable the deBruijn index is returned and if it is a let bound variable its definition is returned.*  * ) None 9:;<=?LM[ AWe put the translation into TCM in order to print debug messages.4 |Names in abstract syntax are fully qualified, but the concrete syntax requires non-qualified names in places. In theory (if all scopes are correct), we should get a non-qualified name when translating back to a concrete name, but I suspect the scope isn't always perfect. In these cases we just throw away the qualified part. It's just for pretty printing anyway...4 General bracketing function.4 Expression bracketing4 Pattern bracketing4|If a name is defined with a fixity that differs from the default, we have to generate a fixity declaration for that name.9Translate something in a context of the given precedence.49Translate something in a context of the given precedence.4'Translate something in the top context.4'Translate something in the top context.4.Translate something in a context indicated by   info.4.Translate something in a context indicated by   info.T4444444444444 4 4!4"4#4$4 the bracketing function?Should we bracket things which have the given precedence?4 4 44%444444&4'4(4)4*4+4,4-4.     I4444444444444 4 4!4"4#4$4 4 4 44%444444&4'4(4)4*4+4,4-4.     NoneM/To be called before any write or restore calls. Writes a S( to the current log, using the current f>Reads the next entry in the cached type check log, if present.CEmpties the "to read" CachedState. To be used when it gets invalid.Makes sure that the e is *w(, with a clean current log. Crashes is ee is already active with a dirty log. Should be called when we start typechecking the current file.cCaches the current type check log. Discardes the old cache. Does nothing if caching is inactive. 4/4041 4/4041None"Get the current problem#YSteal all constraints belonging to the given problem and add them to the current problem.(Get the awake constraints-Suspend constraints matching the predicate during the execution of the second argument. Caution: held sleeping constraints will not be woken up by events that would normally trigger a wakeup call.3Add new a constraint4Add already awake constraints5Start solving constraints !"#$%&'()*+,-./0123456789: !"#$%&'()*+,-./0123456789:"#$%&'()*+, !-./0123456789: !"#$%&'()*+,-./0123456789:None:=>?@=>?@=>?@=>?@NoneAGet the statistics.B)Modify the statistics via given function.CIncrease specified counter by 1.DIncrease specified counter by n.EBSet the specified counter to the maximum of its current value and n.42'Modify specified counter by a function f.F;Print the given statistics if verbosity "profile" is given.ABCDE42FABCDEFCDEABFABCDE42FNoneI$Record a function call in the trace.MSets the current range (for error messages etc.) to the range of the given object, if it has a range (i.e., its range is not ).GHIJKLMGHIJKLMGHIJKLMGHIJKLMNone9;LNcUnfreeze meta and its type if this is a meta again. Does not unfreeze deep occurrences of metas.PpCheck whether all metas are instantiated. Precondition: argument is a meta (in some form) or a list of metas.RSwitch off assignment of metas.SGet the meta store.ULookup a meta variable[=Given a meta, return the type applied to the current context.]Create  in the current environment.dfRegister an interaction point during scope checking. If there is no interaction id yet, create one.e+Hook up meta variable to interaction point.f@Move an interaction point from the current ones to the old ones.gGet a list of interaction ids.h1Get all metas that correspond to interaction ids.i1Get all metas that correspond to interaction ids.j:Does the meta variable correspond to an interaction point?Time: O(n) where n$ is the number of interaction metas.k7Get the information associated to an interaction point.lGet K for an interaction point. Precondition: interaction point is connected.mGenerate new meta variable.njGenerate a new meta variable with some instantiation given. For instance, the instantiation could be a .oGet the X for an interaction point.pGet the X for a meta variable.vlistenToMeta l m : register l as a listener to m3. This is done when the type of l is blocked by m.wUnregister a listener.xGet the listeners to a meta.zKFreeze all so far unfrozen metas for the duration of the given computation.{GFreeze all meta variables and return the list of metas that got frozen.|Thaw all meta variables.}6Thaw some metas, as indicated by the passed condition.Does not worry about raising.CNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~1NOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~CRSTUVWXYZ[PQ\]^_`abcdefghijklmnopqrstuvwxyz{|}~NOANOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~None(9:;M[.oLookup the definition of a name. The result is a closed thing, all free variables have been abstracted over.4Lookup the rewrite rules with the given head symbol.CAdd a constant to the signature. Lifts the definition to top level.2Set termination info of a defined function symbol.!Modify the clauses of a function.;Lifts clauses to the top-level and adds them to definition.Add a section to the signature.[The current context will be stored as the cumulative module parameters for this section.^Lookup a section. If it doesn't exist that just means that the module wasn't parameterised.>Module application (followed by module parameter abstraction).LAdd a display form to a definition (could be in this or imported signature).CFind all names used (recursively) by display forms of a given name.#Check if a display form is looping.NCan be called on either a (co)datatype, a record type or a (co)constructor.?Does the given constructor come from a single-constructor type?5Precondition: The name has to refer to a constructor.%Look up the polarity of a definition.MLook up polarity of a definition and compose with polarity represented by .!Set the polarity of a definition.*Get argument occurrence info for argument i of definition d (never fails).'Get the mutually recursive identifiers.'Set the mutually recursive identifiers.5Check whether two definitions are mutually recursive.Why Maybe? The reason is that we look up all prefixes of a module to compute number of parameters, and for hierarchical top-level modules, A.B.C say, A and A.B do not exist.3Get the number of parameters to the current module.Compute the number of free variables of a defined name. This is the sum of number of parameters shared with the current module and the number of anonymous variables (if the name comes from a let-bound module).7Compute the context variables to apply a definition to.We have to insert the module telescope of the common prefix of the current module and the module where the definition comes from. (Properly raised to the current context.) Example:  module M  where module M  where f = ... module M  where ... M .M .f [insert  raised by ] Unless all variables in the context are module parameters, create a fresh module to capture the non-module parameters. Used when unquoting to make sure generated definitions work properly.PInstantiate a closed definition with the correct part of the current context.'Give the abstract view of a definition.OEnter abstract mode. Abstract definition in the current module are transparent.:Not in abstract mode. All abstract definitions are opaque.?Ignore abstract mode. All abstract definitions are transparent.eEnter concrete or abstract mode depending on whether the given identifier is concrete or abstract.MCheck whether a name might have to be treated abstractly (either if we're d or it's not a local name). Returns true for things not declared abstract as well, but for those  will have no effect.Andreas, 2015-07-01: If the current~ module is a weak suffix of the identifier module, we can see through its abstract definition if we are abstract. (Then treatAbstractly' returns False).<If I am not mistaken, then we cannot see definitions in the where block of an abstract function from the perspective of the function, because then the current module is a strict prefix of the module of the local identifier. This problem is fixed by removing trailing anonymous module name parts (underscores) from both names.<Get type of a constant, instantiated to the current context.Get relevance of a constant.The name must be a datatype.)The number of parameters of a definition.pThe number of dropped parameters for a definition. 0 except for projection(-like) functions and constructors.&Is it the name of a record projection?Is it a function marked STATIC?Is it a function marked INLINE?Returns True if we are dealing with a proper projection, i.e., not a projection-like function nor a record field value (projection applied to argument).DNumber of dropped initial arguments of a projection(-like) function.+Check whether a definition uses copatterns.Apply a function fF to its first argument, producing the proper postfix projection if f is a projection.M/Name of new module defined by the module macro.Parameters of new module.(Name of old module applied to arguments. Arguments of module application.#Imported names (given as renaming).%Imported modules (given as renaming).KMKNone2LA deep view on sizes.A useful view on sizes.Check if a type is the  type. The argument should be reduced.)Result of querying whether size variable i is bounded by another size.yes  i : Size< tQTest whether OPTIONS --sized-types and whether the size built-ins are defined.$Add polarity info to a SIZE builtin.The sort of built-in types SIZE and SIZELT.The type of built-in types SIZE and SIZELT.The built-in type SIZE with user-given name.The built-in type SIZE. The name of SIZESUC.>Transform list of terms into a term build from binary maximum.sizeViewComparable v w checks whether v >= w (then Left) or v <= w (then Right ). If uncomparable, it returns  NotComparable.sizeViewPred k v decrements v by k (must be possible!).sizeViewOffset v8 returns the number of successors or Nothing when infty.'Remove successors common to both sides. Turn a size view into a term. maxViewCons v ws = max v ws. It only adds v to ws+ if it is not subsumed by an element of ws. sizeViewComparableWithMax v ws tries to find w in ws that compares with v+ and singles this out. Precondition:  v /= DSizeInv.2     0     2     %     NNoneEFGHIJK>`      !"#$%&'()*+,-./0123456789:;<=?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_abcdefghijklmnopqrstuvwxyz{|}~#      !"$%&'()*+,-./0123456789:;<=>?@ABDCEFGHIJKLMPROSQN]T[ciy{orpUVWXYZ\^_`abdefghjklmnqstuvwxz|}~     ' !"#$%&()*+,-./0213456987:;<=>?@ABCDEFGHIJKLMNOPQRSVWTUXYZ[\]^_a`bcdefghijklmnopqrstuvwxyz{|}~          23456789:;<=>?@ABCEDFGHIJK0123456789;:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`ab !"#$%&'()*+,-./0123456789:=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~     NoneCalls a compiler:Checks the exit code to see if the compiler exits successfully. If not, then an exception is raised, containing the text the compiler printed to stderr (if any).eUses the debug printout machinery to relay any progress information the compiler prints to stdout.Generalisation of  callCompiler) where the raised exception is returned.$Should we actually call the compilerThe path to the compilerCommand-line arguments.The path to the compilerCommand-line arguments.None!":M434445464748494:4;4<4=4>4?43 4445464748494:4;4<4=4>4?NoneNone4@4A4B4@4A4BNone0(Parse a COMPILED_DATA_UHC specification. Parse a COMPILED_UHC expression.4C0Check if the given name is a valid Magic entity.4DChecks if the given name is syntactically a Magic name. A syntactally correct magic name is NOT necessarily a valid magic name. 4C lookup tablename to lookup.-type of the entity. Used for errors messages.4D    4C4DNone$MRecords already processed modules and maps them to an internal identifier.%Supply of internal identifiers.&Edges of dependency graph.'AInternal module identifiers for construction of dependency graph.) Translate a  to an internal ' . Returns True if the d is new, i.e., has not been encountered before and is thus added to the map of processed modules.*%Add an arc from importer to imported.+4Recursively build import graph, starting from given 5. Modifies the state in ! and returns the ' of the 5.,EGenerate a .dot file for the import graph starting with the given 5B and write it to the file specified by the command line option. !"#$%&'()*+, !"#$%&'()*+, '"#$%&(!)*+,!"#$%&'()*+,None4E Converts the   and  !2 fields to atoms readable by the Emacs interface.4FJShows meta information in such a way that it can easily be read by Emacs.-DTurns syntax highlighting information into a list of S-expressions..All the properties.4E4F@Must contain a mapping for the definition site's module, if any.-:Must contain a mapping for every definition site's module..-.-.4E4F-.None/!The name of the default CSS file.0dGenerates HTML files from all the sources which have been visited during the type checking phase.VThis function should only be called after type checking has completed successfully.1-Prepare information for HTML page generation.The page generator receives the file path of the module, the top level module name of the module and the highlighting information of the module.4G;Converts module names to the corresponding HTML file names.2AGenerates a highlighted, hyperlinked version of the given module.3+Constructs the web page, including headers.4'Constructs token stream ready to print.5(Constructs the HTML displaying the code./01Page generator4G2 Page renderer#Directory in which to create files.Module to be highlighted.3URL to the CSS file.Module to be highlighted.4The contents of the module.Highlighting information.(position, contents, info)5/0123450/12345/014G2345None$4H\Is not used currently, but could potentially be used for hyperlinks as in the HTML output?4I,Column number, used for polytable alignment.4J&Indentation level, also for alignment.4K6Keeps track of whether we are in a code block or not.4L+Says what debug information should printed.4MThe LaTeX monad is a combination of ExceptT, RWST and IO . The error part is just used to keep track whether we finished or not, the reader part isn't used, the writer is where the output goes and the state is for keeping track of the tokens and some other useful info, and the I/O part is used for printing debugging info.4NRun function for the LaTeX monad.4OYields the next token, taking special care to begin/end code blocks. Junk occuring before and after the code blocks is separated into separate tokens, this makes it easier to keep track of whether we are in a code block or not.4PThe start state, nonCodeE, prints non-code (the LaTeX part of literate Agda) until it sees a  beginBlock.4QZDeals with code blocks. Every token, except spaces, is pretty printed as a LaTeX command.4RSFixity declarations need a special treatment. The operations in declarations like:infix num op1 op2 op3are treated as comments and thus grouped together with the newlines that follow, which results incorrect LaTeX output -- the following state remedies the problem by breaking on newlines.4SSpaces are grouped before processed, because multiple consecutive spaces determine the alignment of the code and consecutive newline characters need special treatment as well.62The only exported function. It's (only) called in Main.hs.4T&Transforms the source code into LaTeX.A4U4V4W4X4Y4Z4[4\4]4^4H4_4`4a4b4I4J4c4K4L4M4N4d4e4f4g4h4i4O4j4k4l4m4n4o4p4q4r4s4t4u4v4w4x4y4z4{4|4}4~4444444P4Q44R4S464T46614U4V4W4X4Y4Z4[4\4]4^4H4_4`4a4b4I4J4c4K4L4M4N4d4e4f4g4h4i4O4j4k4l4m4n4o4p4q4r4s4t4u4v4w4x4y4z4{4|4}4~4444444P4Q44R4S464T4None:;<=>?@A:;<=>?@A:;<=>?@A:;<=>?@ANoneBELine reader. The line reader history is not stored between sessions.BBBBNone:F Variant of C- which does not insert outermost parentheses.G Variant of D- which does not insert outermost parentheses.CDEFGCDEFGCDEFGCDEFGNone9;<=?TL.Adds a new unique name to the current context.M@Returns the name of the variable with the given de Bruijn index.N^Translate reflected syntax to abstract, using the names from the current typechecking context.O5Drop implicit arguments unless --show-implicit is on.HIJKLMNOPQRSTUVWXYZ[\]^ HIJKLMNOPQKJLMHINO^]\[ZYXWVPUTQSRHIJKLMNOPQRSTUVWXYZ[\]^None4=A graph is cyclic if it has any strongly connected component.4recDef names name returns all definitions from names! that are used in the body of name.`anysDef names a returns all definitions from names that are used in a._44`_`_`_44`None9;m:When making a function projection-like, we drop the first n arguments.oTo drop the first nL arguments in a compiled clause, we reduce the split argument indices by n and drop n arguments from the bodies. NOTE: this only works for non-recursive functions, we are not dropping arguments to recursive calls in bodies.q,NOTE: does not work for recursive functions.rJNOTE: does not go into the body, so does not work for recursive functions.t=NOTE: This creates telescopes with unbound de Bruijn indices. mnopqrstumn mnutsrqpomnopqrstuNonewZPrepare parts of a parameter telescope for abstraction in constructors and projections.x)Used to modify context when going into a rel argument.yrCompose two relevance flags. This function is used to update the relevance information on pattern variables a! after a match against something rel.zsModify the context whenever going from the l.h.s. (term side) of the typing judgement to the r.h.s. (type side).{-Call me if --experimental-irrelevance is set.|TInternal workhorse, expects value of --experimental-irrelevance flag as argument.}(Conditionally) wake up irrelevant variables and make them relevant. For instance, in an irrelevant function argument otherwise irrelevant variables may be used, so they are awoken before type checking the argument.~Wake up irrelevant variables and make them relevant. For instance, in an irrelevant function argument otherwise irrelevant variables may be used, so they are awoken before type checking the argument. wxyz{|}~ wxyz{|}~ wxyz{|}~ wxyz{|}~None9;None9;T7Expand away (deeply) all pattern synonyms in a pattern.BExpand literal integer pattern into suc/zero constructor patterns.  None:LOT4<Run a computation if a certain verbosity level is activated.-Precondition: The level must be non-negative.;Apply a function if a certain verbosity level is activated.-Precondition: The level must be non-negative.4444444444  4444444444None:M3Contracts all eta-redexes it sees without reducing.None9:;LM instantiateFull' 5s metas everywhere (and recursively) but does not .uOnly unfold definitions if this leads to simplification which means that a constructor/literal pattern is matched.Instantiate something. Results in an open meta variable or a non meta. Doesn't do any reduction, and preserves blocking tags (when blocking meta is uninstantiated).Case on whether a term is blocked on a meta (or is a meta). That means it can change its shape when the meta is instantiated.;Case on whether a type is blocked on a meta (or is a meta).If the first argument is *x0, then a single delayed clause may be unfolded.IReduce a non-primitive definition if it is a copy linking to another def.*Reduce simple (single clause) definitions.pApply a definition using the compiled clauses, or fall back to ordinary clauses if no compiled clauses exist.Apply a defined function to it's arguments, using the compiled clauses. The original term is the first argument applied to the third.GApply a defined function to it's arguments, using the original clauses.      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxy#yxwvutsrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONMLKJIHGFEDCBA@?>=<;:9876543210/.-,+*)('&%$#"!            !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyNone zCompiler monad{Stuff we need in our compilerThe initial (empty) state!When normal errors are not enough7Modify the state of the current module's Epic Interface4Get the state of the current module's Epic Interface/Returns the type of a definition given its name:Create a name which can be used in Epic code from a QName.9Copy pasted from MAlonzo, HAHA!!! Move somewhere else!+Bind an expression to a fresh variable name&z{|}~ replace at to replace replace withresult?&z{|}~&{|}~z z{|}~None"Run the case-opts on an expressionNone"Print a function to an Epic string#Print expression to Epic expression 444444444 4444444444645None Check which arguments are forced6Remove forced arguments from constructors and branchesNonejGet a list of all the datatypes that look like nats. The [QName] is on the form [zeroConstr, sucConstr]&Count the number of relevant arguments Check if argument n is recursiveNone WChange constructors and cases on builtins and natish datatypes to use primitive data,Map primitive constructors to primitive tags,Build transforms using the names of builtins*Translation to primitive integer functions)Corresponds to a case for natural numbers4Corresponds to a case with a zero and default branch'Translation to primitive bool functionsAChange all the primitives in the function using the PrimTransform>Change all the primitives in an expression using PrimTransformExpression that is cased onExpression for the zero branch$Variable that is bound in suc branchExpression used for suc branchResult?Expression that is cased on Zero branchDefault branchResult?NoneuRun before serialisation to remove any definitions that are not reachable from the public interface to the module.44NoneGet the 'primLevel as a  , if present.Get the  as a u.-Raises an error if no level kit is available. None9;Class Match for matching a term p, in the role of a pattern against a term v.The 0th variable in pP plays the role of a place holder (pattern variable). Each occurrence of var 0 in p) stands for a different pattern variable.sThe result of matching, if successful, is a list of solutions for the pattern variables, in left-to-right order.*The 0th variable is in scope in the input vC, but should not actually occur! In the output solution, the 0th@ variable is no longer in scope. (It has been substituted by  IMPOSSIBLE( which corresponds to a raise by -1). Convert a  into a .0Get the arities of all display forms for a name.!Find a matching display form for q vs'. In essence this tries to reqwrite q vs with any display form  q ps --> dt! and returns the instantiated dt" if successful. First match wins.Match a  q ps = v against q vs. Return the  v[us]' if the match was successful, i.e., vs / ps = Just us.   None   None                           None&                   ! " # $ % & ' ( ) * + , - . / 0 1& 1 0 / . - , + * ) ( ' & % $ # " !                   &                   ! " # $ % & ' ( ) * + , - . / 0 1None 2 2None 3dEncodes something. To ensure relocatability file paths in positions are replaced with module names. 4:Decodes something. The result depends on the include path.Returns +Xf if the input does not start with the right magic number or some other decoding error is encountered. 6dEncodes something. To ensure relocatability file paths in positions are replaced with module names. 7:Decodes something. The result depends on the include path.Returns +Xe if the file does not start with the right magic number or some other decoding error is encountered.4Store a K (map from  AbsolutePath to TopLevelModuleName) as map from  AbsolutePath to Int32t, in order to directly get the identifiers from absolute pathes rather than going through top level module names. 4 3 4 5 6 7 8 94{Maps file names to the corresponding module names. Must contain a mapping for every file name that is later encountered.Y 3 4 5 6 7 8 9 3 6 5 4 9 7 8Y 4 3 4 5 6 7 8 94None9:;LM :,Instantiate full as long as things are equal4%Monad for checking syntactic equality ;'Syntactic equality check for terms. t checkSyntacticEquality v v' = do (v,v') <- instantiateFull (v,v') return ((v,v'), v==v')  only that v,v'B are only fully instantiated to the depth where they are equal.4Return, flagging inequalty.40If inequality is flagged, return, else continue. B!Syntactic equality ignores sorts. G Syntactic term equality ignores  stuff. :444 ;44444 < = > ? @ A B C D E F G : ; : ; :444 ;44444 < = > ? @ A B C D E F GNone:TjA safe variant of piApply. HA telescope split in two. L;The permutation takes us from the original telescope to firstPart ++ secondPart. RAStrips all Pi's and return the head definition name, if possible. SPThe permutation should permute the corresponding telescope. (left-to-right list) TIf permute  : [a] -> [a], then *applySubst (renaming ) : Term  -> Term  UIf permute  : [a] -> [a], then +applySubst (renamingR ) : Term  -> Term  V(Flatten telescope: ( : Tel) -> [Type ] WYOrder a flattened telescope in the correct dependeny order:  -> Permutation ( -> ~)Since reorderTel tel( uses free variable analysis of type in tel, the telescope should be d. Y\Unflatten: turns a flattened telescope into a proper telescope. Must be properly ordered. Z(Get the suggested names from a telescope ^Permute telescope: permutes or drops the types in the telescope according to the given permutation. Assumes that the permutation preserves the dependencies in the telescope. _Recursively computes dependencies of a set of variables in a given telescope. Any dependencies outside of the telescope are ignored. `^Split a telescope into the part that defines the given variables and the part that doesn't.See  O. a|As splitTelescope, but fails if any additional variables or reordering would be needed to make the first part well-typed. bTry to instantiate one variable in the telescope (given by its de Bruijn level) with the given value, returning the new telescope and a substitution to the old one. Returns Nothing if the given value depends (directly or indirectly) on the variable. cQTry to eta-expand one variable in the telescope (given by its de Bruijn level) etelViewUpTo n t takes off the first n function types of t. Takes off all if n < 0. ftelViewUpTo' n p t takes off $t$ the first n (or arbitrary many if n < 0-) function domains as long as they satify p. gDecomposing a function type. hIf the given type is a Piu, pass its parts to the first continuation. If not (or blocked), pass the reduced type to the second continuation. iIf the given type is a Piu, pass its parts to the first continuation. If not (or blocked), pass the reduced type to the second continuation. j&If the given type is blocked or not a Pi;, pass it reduced to the first continuation. If it is a Pi,, pass its parts to the second continuation. k&If the given type is blocked or not a Pi;, pass it reduced to the first continuation. If it is a Pi,, pass its parts to the second continuation. m_Given a function type, introduce its domain into the context and continue with its codomain. pTry to solve the instance definitions whose type is not yet known, report an error if it doesn't work and return the instance table otherwise.*j H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ `A set of de Bruijn indices.Original telescope. firstPart mentions the given variables,  secondPart not. aA list of de Bruijn indicesThe telescope to split firstPart5 mentions the given variables in the given order,  secondPart contains all other variables b"   " var k : A  " u : A c d e f g h i j k l m n o p*j H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p* M N O P Q R S T U V W X Y Z [ \ ] ^ _ H I J K L ` a b c d e f g h i j kj l m n o p"j H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o pNone 9:;<=?ILT 4 dotVars ps3 gives all the variables inside of dot patterns of ps It is only invoked for patternish things. (Ulf O-tone!) Use it for printing l.h.sides: which of the implicit arguments have to be made explicit.4reifyDisplayForm f vs fallback tries to rewrite f vs with a display form for fK. If successful, reifies the resulting display term, otherwise, does fallback.4reifyDisplayFormP; tries to recursively rewrite a lhs with a display form.=Note: we are not necessarily in the empty context upon entry!4 ?nameFirstIfHidden n (a1->...an->{x:a}->b) ({e} es) = {x = e} es4Move dots on variables so that each variable is bound at its first non-hidden occurrence (if any). If all occurrences are hidden it's bound at the first occurrence.4Removes implicit arguments that are not needed, that is, that don't bind any variables that are actually used and doesn't do pattern matching.4If the record constructor is generated or the user wrote a record pattern, turn constructor pattern into record pattern. Otherwise, keep constructor pattern. Getting all(!) variables of an expression. It should only get free ones, but it does not matter to include the bound ones. BSkip reification of implicit and irrelevant args if option is off.P4444444444444444444 q r s t44444444444444444 u4 v w x y z { | } ~   q r s t u r s t q uA4444444444444444444 q r s t44444444444444444 u4 v w x y z { | } ~  None9:;L 2Pairing something with a node (for printing only). !Comma-separated list in brackets.   without the brackets. =Show a pattern, given a method how to show pattern variables.\ # \      Y   None Relevance "or" Relevance "and"!0Try to find as many unused variables as possible!!Initiate a function's relevancies!4Calculate if a variable is relevant in an expression!7Try to find a fixpoint for all the functions relevance. !!!!!!!! !!!!!!!! !!!!!!!!  !!!!!!!! 2 3None9;M!aAre two terms injectible? Tries to find a mapping between constructors that equates the terms.Precondition: t1 is normalised, t2 is in WHNF When reducing t2, it may become a literal, which makes this not work in some cases...!~If the pairs of constructor names have the same tags, the function is injective. If Nothing, the function is not injective.!Find potentially injective functions, solve constraints to fix some constructor tags and make functions whose constraints are fulfilled injections!'Turn NATURAL literal n into suc^n zero."!! ! ! ! ! !!!!!!!!Name of the function being testedThe function's clauses!!!!!Name of the function being testedThe current argument!!!!!!!! !!!"!#!$!%!&!'!(!)!! ! ! ! !! !!!!!!!!!!!!!!!!!! !!!"!#!$!%"!!!!!!!!!!!!!!!!!!)!(!'!&! ! !!! ! ! ! !!!"!#!$!%!! ! ! ! ! !!!!!!!!!!!!!!!!!!! !!!"!#!$!%!&!'!(!)None!,(Main function, smash as much as possible!.BCan a datatype be inferred? If so, return the only possible value.!0JFind the only possible value for a certain type. If we fail return Nothing!+!,!-!.!/!0!1!+!,!-!.!/!0!1!+!,!-!.!/!0!1!+!,!-!.!/!0!1None9; !2!3!4!5!6!7!8!9!:!;!2!3!4!5!6 !4!5!6!2!3!;!:!9!8!7 !2!3!4!5!6!7!8!9!:!;None!<AConvert from Agda's internal representation to our auxiliary AST.!=ATranslate an Agda definition to an Epic function where applicable!?xTranslate from Agda's desugared pattern matching (CompiledClauses) to our AuxAST. This is all done by magic. It uses !@ to translate the actual terms when the cases have been gone through. The case expressions that we get use de Bruijn indices that change after each case in the following way. Say we have this pattern: f (X x y) (Y z) = term,Initially, the variables have these indexes: f 0@(X x y) 1@(Y z) = termThe first case will be on 0%, and the variables bound inside the XH pattern will replace the outer index, so we get something like this: %f 0 2@(Y z) = case 0 of X 0 1 -> term Notice how (Y z) now has index 2:. Then the second pattern is desugared in the same way: 0f 0 2 = case 0 of X 0 1 -> case 2 of Y 2 -> term>This replacement is what is done using the replaceAt function.7CompiledClauses also have default branches for when all branches fail (even inner branches), the catchAllBranch. Epic does not support this, so we have to add the catchAllBranch to each inner case (here we are calling it omniDefault). To avoid code duplication it is first bound by a let expression.!@Translate the actual Agda terms, with an environment of all the bound variables from patternmatching. Agda terms are in de Bruijn so we just check the new names in the position.!A-Translate Agda literals to our AUX definition!<!=!>!?%Number of arguments in the definition!@!A!<!=!>!?!@!A!<!=!>!?!@!A!<!=!>!?!@!ANone!M Note that Inf a b, where Inf, is the INFINITY builtin, is translated to  translationof b7 (assuming that all coinductive builtins are defined). Note that if  haskellType] supported universe polymorphism then the special treatment of INFINITY might not be needed. !B!C!D!E!F!G!H!I!J!K!L!M !B!C!D!E!F!G!H!I!J!K!L!M !B!C!D!E!F!G!H!I!J!K!L!M !B!C!D!E!F!G!H!I!J!K!L!MPNoneNone:TmatchCompiledE c es% takes a function given by case tree c and and a spine es$ and tries to apply the function to es.!OA stack entry is a triple consisting of 1. the part of the case tree to continue matching, 2. the current argument vector, and 3. a patch function taking the current argument vector back to the original argument vector.!Pmatch'- tries to solve the matching problems on the Stack?. In each iteration, the top problem is removed and handled.If the top problem was a Done , we succeed.If the top problem was a Case n and the nXth argument of the problem is not a constructor or literal, we are stuck, thus, fail.If we have a branch for the constructor/literal, we put it on the stack to continue. If we do not have a branch, we fall through to the next problem, which should be the corresponding catch-all branch.\An empty stack is an exception that can come only from an incomplete function definition.!N!O!P!N!O!P!O!N!P!N!O!PNone9;L4Indefinite article.!Q Warnings.7Invariant: The fields are never empty at the same time.!S;Meta-variable problems are reported as type errors unless optAllowUnsolved is *x.!TSame as !S.!UXTurns warnings into an error. Even if several errors are possible only one is raised.43Drops the filename component of the qualified name.4Print two terms that are supposedly unequal. If they print to the same identifier, add some explanation why they are different nevertheless. 444444!Q!R!S!T!U4444!V44444!W!X!Y!Z![!\!]!^!_!`!Q!R!S!T!U!V!V!Q!R!S!T!U444444!Q!R!S!T!U4444!V44444!W!X!Y!Z![!\!]!^!_!`NoneM!b'this many implicits have to be inserted!c=hidden argument where there should have been a non-hidden arg!dbad named argument!fimplicitArgs n expand eti t generates up to n+ implicit arguments metas (unbounded if n<0), as long as t is a function type and expand, holds on the hiding info of its domain. If eti is ExplicitToInstanceB, then explicit arguments are considered as instance arguments.!g implicitNamedArgs n expand eti t generates up to n1 named implicit arguments metas (unbounded if n<0), as long as t is a function type and expand5 holds on the hiding and name info of its domain. If eti is ExplicitToInstanceB, then explicit arguments are considered as instance arguments.!iThe list should be non-empty. !a!b!c!d!e!f!g!h!i !a!b!c!d!e!f!g!h!i !f!g!a!b!c!d!e!h!i!a!b!c!d!e!f!g!h!iNone2TIf matching is inconclusive (DontKnowE) we want to know whether it is due to a particular meta variable.matchCopatterns ps es matches spine es against copattern spine ps.Returns ` and a substitution for the pattern variables (in form of [Term]) if matching was successful.Returns 3 if there was a constructor or projection mismatch.Returns b if an argument could not be evaluated to constructor form because of a blocking meta variable. In any case, also returns spine eso in reduced form (with all the weak head reductions performed that were necessary to come to a decision).!k Instead of zipWithMQ, we need to use this lazy version of combining pattern matching computations.!lMatch a single copattern.!mMatch a single pattern. !k!l!m!n!o !k!l!m!n !o!k!l!m!n!k!l!m!n!oNone9:;<=M !q"Raise (bound) variables in a NLPat!tOMatch a non-linear pattern against a neutral term, returning a substitution.!wMatching against a term produces a constraint which we have to verify after applying the substitution computed by matching.!y+Telescope of free variables in the equation!z-Term from pattern, living in pattern context.!{BTerm from scrutinee, living in context where matching was invoked.!~Monad for non-linear matching.!Turn a term into a non-linear pattern, treating the free variables as pattern variables. The first argument is the number of bound variables (from pattern lambdas).!Add substitution i |-> v to result of matching.!DUntyped -equality, does not handle things like empty record types.0!q!r!s!t!u!v!w!x!y!z!{!|!}!~!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!q!s!r!t!u!v!w!x!y!z!{!|!}!~!!!!!!!!!!!!0!!!!!!!!!!~!}!!!!!!!!|!w!x!y!z!{!v!t!u!!!!!!!!!!!!q!r!s!!!!!!!(!q!r!s!t!u!v!w!x!y!z!{!|!}!~!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!None2349;<=!7State worked on during the main loop of checking a lhs.!`Instantiations of a dot pattern with a term. `Maybe e` if the user wrote a dot pattern .e +XG if this is an instantiation of an implicit argument or an underscore _! Result of  splitProblem*: Determines position for the next split.!Split on constructor pattern.!Split on projection pattern.!BThe typed user patterns left of the split position. Invariant: ! == empty.!The as-bindings for the focus.!0How to split the variable at the split position.!4The typed user patterns right of the split position.!@The projection could be belonging to an irrelevant record field.!.Do we come from an implicit or record pattern?!<Type of variable we are splitting, kept for record patterns.!1User patterns that could not be given a type yet. Example:  f : (b : Bool) -> if b then Nat else Nat -> Nat f true = zero f false zero = zero f false (suc n) = n G In this sitation, for clause 2, we construct an initial problem  problemInPat = [false] problemTel = (b : Bool) problemRest.restPats = [zero] problemRest.restType = if b then Nat else Nat -> Nat  As we instantiate b to false, the ! reduces to  Nat -> Nat and we can move pattern zero over to  problemInPat.!3List of user patterns which could not yet be typed.!Type eliminated by ! . Can be x to indicate that we came by an irrelevant projection and, hence, the rhs must be type-checked in irrelevant mode.!The de Bruijn indices in the pattern refer to positions in the list of abstract patterns in the problem, counted from the back.!&State of typechecking a LHS; input to split!. [Ulf Norell's PhD, page. 35]In Problem ps p delta, ps( are the user patterns of supposed type delta. p- is the pattern resulting from the splitting.!User patterns.!Patterns after splitting.!Type of in patterns.!"Patterns that cannot be typed yet.!Flexible variables are equipped with information where they come from, in order to make a choice which one to assign when two flexibles are unified.!When we encounter a flexible variable in the unifier, where did it come from? The alternatives are ordered such that we will assign the higher one first, i.e., first we try to assign a DotFlex , then...!From a record pattern (@). Saves the ! of its subpatterns.!-From a hidden formal argument or underscore (WildP).!From a dot pattern (?).!*Put a typed pattern on the very left of a  SplitProblem.R!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!p A pattern.x* The name of the argument (from its type).t Its type.The split problem, containing ! ps;xs:ts.The result, now containing ! (p,ps);(x,xs):(t,ts).!!!!!!!!!!!!!!!C!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!R!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!None:4withExprClauses cl t asA generates a clause containing a fake call to with-expression a for each a in asF that is not a variable (and thus cannot contain a recursive call).Andreas, 2013-11-11: I guess "not a variable" could be generalized to "not containing a call to a mutually defined function".Note that the as) stem from the *unraised* clause body of cl and thus can be simply 4ped back there (under all the G abstractions).Precondition: we are .4inlinedClauses f cl t wf& inlines the clauses of with-function wf of type t into the clause cl!. The original function name is f.Precondition: we are .4The actual work horse. inline f pcl t wf wcl inlines with-clause wcl of with-function wf (of type t) into parent clause pcl (original function being f).!444!"!!"!!"!444!"None zGet the name of the datatype constructed by a given constructor. Precondition: The argument must refer to a constructor(Get true constructor with record fields." Get true constructor as term." TGet true constructor with fields, expanding literals to constructors if possible." sAugment constructor with record fields (preserve constructor name). The true constructor might only surface via reduce."  Analogous to " ."getConType c t/ computes the constructor parameters from type t5 and returns the instantiated type of constructor c. Nothing if t= is not a data/record type or does not have a constructor c. Precondition: t is reduced."rReturn the number of non-parameter arguments to a data constructor, or the field names of a record constructor.*For getting just the arity of constructor c , use either id size  $ getConstructorArity c."JCheck if a name refers to a datatype or a record with a named constructor."1Check if a name refers to a datatype or a record." Precodition:  is reduced.""""""""" " " " " """""""""""""""" " " " " """""""" " " " """" """"""""""""""""""""" " " " " """""""None4444444444444"444444""4444444444444"444444None:[ " *Compute a list of instance candidates. +XI if type is a meta, error if type is not eligible for instance search."!findInScope m (v,a)s& tries to instantiate on of the types as of the candidate terms vs to the type t of the metavariable m. If successful, meta m% is solved with the instantiation of v. If unsuccessful, the constraint is regenerated, with possibly reduced candidate set. The list of candidates is equal to Nothingz when the type of the meta wasn't known when the constraint was generated. In that case, try to find its type again.""Result says whether we need to add constraint, and if so, the set of remaining candidates and an eventual blocking metavariable."#?Precondition: type is spine reduced and ends in a Def or a Var."$A meta _M is rigidly constrained if there is a constraint _M us == D vs, for inert D. Such metas can safely be instantiated by recursive instance search, since the constraint limits the solution space."&(Returns True if one of the arguments of ty is a meta which isn t rigidly constrained. Note that level metas are never considered rigidly constrained (#1865)."'Apply the computation to every argument in turn by reseting the state every time. Return the list of the arguments giving the result True.If the resulting list contains exactly one element, then the state is the same as the one obtained after running the corresponding computation. In all the other cases, the state is reseted.") Given a meta m of type t and a list of candidates cands, checkCandidates m t cands, returns a refined list of valid candidates."+To preserve the invariant that a constructor is not applied to its parameter arguments, we explicitly check whether function term we are applying to arguments is a unapplied constructor. In this case we drop the first ya arguments. See Issue670a. Andreas, 2013-11-07 Also do this for projections, see Issue670b.""""" "!"""#"$"%"&"'"(")"*"+""""" "!"""#"$"%"&"'"(")"*"+" "!"""#"$"%"&"'"(""""")"*"+ """"" "!"""#"$"%"&"'"(")"*"+None9;ML/What is the polarity of a function composition?MMain function of this module.".polarities i a4 computes the list of polarities of de Bruijn index i in syntactic entity a."0'Infimum on the information lattice. " is bottom (dominant for inf),  is top (neutral for inf)."1* negation, swapping monotone and antitone."3#Get the next polarity from a list,  if empty."4Replace  by &. (Arbitrary bias, but better than , see issue 1596)."5|Data and record parameters are used as phantom arguments all over the test suite (and possibly in user developments). enablePhantomTypes turns  parameters to  to enable phantoms."6Make arguments  if the type of a not-K later argument depends on it. Also, enable phantom types by turning b into something else if it is a data/record parameter but not a size argument. [See issue 1596]SPrecondition: the "phantom" polarity list has the same length as the polarity list."7hCheck whether a variable is relevant in a type expression, ignoring domains of non-variant arguments."81Record information that an argument is unused in ."9Improve 3 information in a type by polarity information.  becomes .": Propagate   to  information in s of a defined symbol."<oHack for polarity of size indices. As a side effect, this sets the positivity of the size index. See testsucceed9PolaritySizeSucData.agda for a case where this is needed."=checkSizeIndex d np i a% checks that constructor target type a has form d ps (! i) idxs where  |ps| = np.Precondition: a is reduced and of form  d ps idxs0."> polarity i a* computes the polarity of de Bruijn index i in syntactic entity a by taking the infimum of all "/.LM"."/"0"1"2"3"4"5"6"7"8"9":";"<"=">"?"@"A"B"C"D"E"F"G"H"ILM"."/"0"1"2"3"4"5"6"7"8"9":";"<"=">"0"1L"2"3"4M"5"6"7"8"9":";"<"="."/">"I"H"G"F"E"D"C"B"A"@"?LM"."/"0"1"2"3"4"5"6"7"8"9":";"<"=">"?"@"A"B"C"D"E"F"G"H"INone9;MOT"J"K"L"M"N"O"P"Q"R"S"T"U"V"W"X"Y"Z"["\"J"K"L"M"N"O"P"Q"R"S"T"U"V"W"X"Y"Z"["\"J"K"L"M"N"O"P"Q"R"S"T"U"V"W"X"Y"Z"["\ "J"K"L"M"N"O"P"Q"R"S"T"U"V"W"X"Y"Z"["\NoneLM%TCheck if a name refers to a record constructor. If yes, return record definition.KCheck if a constructor name is the internally generated record constructor.,The fields should be eta contracted already."We can eta contract if all fields f = ...! are irrelevant or all fields f are the projection f v of the same value v?, but we need at least one relevant field to find the value v.oTODO: this can be moved out of TCM (but only if ConHead stores also the Arg-decoration of the record fields. Get the field names of a record.3Check if a name refers to an eta expandable record.HCheck if a name refers to a record. If yes, return record definition."]YOrder the fields of a record construction. Use the second argument for missing fields."^A record field assignment record{xs = es}+ might not mention all visible fields. insertMissingFields inserts placeholders for the missing visible fields and returns the values in order of the fields in the record declaration."_1The name of the module corresponding to a record."`yGet the definition for a record. Throws an exception if the name does not refer to a record or the record is abstract."a.Get the record name belonging to a field name."c0Find all records with at least the given fields."d Get the field types of a record."e/Get the field names belonging to a record type."f`Get the original name of the projection (the current one could be from a module application)."g'Get the type of the record constructor."hHReturns the given record type's constructor name (with an empty range)."iReduce a type and check whether it is a record type. Succeeds only if type is not blocked by a meta var. If yes, return its name, parameters, and definition."jReduce a type and check whether it is a record type. Succeeds only if type is not blocked by a meta var. If yes, return its name, parameters, and definition. If no, return the reduced type (unless it is blocked)."kgetDefType f t? computes the type of (possibly projection-(like)) function f whose first argument has type t . The  parameters for f are extracted from t. Nothing if f is projection(like) but t is not a datarecord axiom type.Precondition: t is reduced. See also: Q"lThe analogue of . If v is a value of record type t with field f, then projectTyped v t f returns the type of f v.+Works also for projection-like definitions f.Precondition: t is reduced."ndCheck if a name refers to a record which is not coinductive. (Projections are then size-preserving)"o`Check if a type is an eta expandable record and return the record identifier and the parameters."p]Mark record type as unguarded. No eta-expansion. Projections do not preserve guardedness."qJMark record type as recursive. Projections do not preserve guardedness."r1Check whether record type is marked as recursive.9Precondition: record type identifier exists in signature."s Version of  recRecursive with proper internal error."t etaExpandBoundVar i = (, , )%Precondition: The current context is  =  , x:R pars,   where | | = i and R4 is a eta-expandable record type with constructor c and fields '.Postcondition:  =  , ',  [c '] and   "  :  and   "  : ."u #expandRecordVar i  = (, , , ')Precondition:  =  , x:R pars,   where | | = i and R7 is a eta-expandable record type with constructor c and fields '.Postcondition:  =  , ',  [c '] and   "  :  and   "  : ."vCPrecondition: variable list is ordered descendingly. Can be empty."w curryAt v ( (y : R pars) -> B) n = ( v ->   ys ! v  (c ys) {- curry -} , v ->   y ! v  (p1 y) ... (pm y) {- uncurry -} ,  (ys : As) ! B[c ys / y] )where  n = size ."xetaExpand r pars u, computes the eta expansion of record value u at record type r pars.The first argument r+ should be the name of a record type. Given /record R : Set where field x : A; y : B; .z : Cand r : R, /etaExpand R [] r = (tel, [R.x r, R.y r, R.z r])where tel8 is the record telescope instantiated at the parameters pars."{VIs the type a hereditarily singleton record type? May return a blocking metavariable.nPrecondition: The name should refer to a record type, and the arguments should be the parameters to the type."}Return the unique (closed) inhabitant if exists. In case of counting irrelevance in, the returned inhabitant contains garbage."~[Check whether a type has a unique inhabitant and return it. Can be blocked by a metavar."hCheck whether a type has a unique inhabitant (irrelevant parts ignored). Can be blocked by a metavar."Auxiliary function.+"]"^*Name of record type (for error reporting).=Function to generate a placeholder for missing visible field. Given fields.All record field names with .BGiven fields enriched by placeholders for missing explicit fields."_"`"a"b"c"d"e"f"g"h"i"j"k"l"m"n"o"p"q"r"s"t"u"v"w"x"y"z"{"|"}"~"""+"]"^"_"`"a"b"c"d"e"f"g"h"i"j"k"l"m"n"o"p"q"r"s"t"u"v"w"x"y"z"{"|"}"~"""+"]"^"_"`"a"b"c"d"e"f"g"h"i"j"k"l"m"n"o"p"q"r"s"t"u"v"w"x"y"z"{"|"}"~"""+"]"^"_"`"a"b"c"d"e"f"g"h"i"j"k"l"m"n"o"p"q"r"s"t"u"v"w"x"y"z"{"|"}"~"""None 2349;<=I5"6The call information is stored as free monoid over _. As long as we never look at it, only accumulate it, it does not matter whether we use Set, (nub) list, or TreeC. Internally, due to lazyness, it is anyway a binary tree of ,;; nodes and singleton leafs. Since we define no order on ! (expensive), we cannot use a SetU or nub list. Performance-wise, I could not see a difference between Set and list."2True if thing not eligible for structural descent."Thing."Extract variables from ";s that could witness a decrease via a SIZELT constraint.These variables must be under an inductive constructor (with no record constructor in the way), or after a coinductive projection (with no inductive one in the way)."De Bruijn Index."^The name refers to either an ordinary constructor or the successor function on sized types."2Literal. Also abused to censor part of a pattern."<Part of dot pattern that cannot be converted into a pattern."Projection pattern."-Patterns with variables as de Bruijn indices."Termination monad." Termination monad service class."The termination environment."AAre we mining dot patterns to find evindence of structal descent?"LDo we assume that record and data type constructors preserve guardedness?"DDo we inline with functions to enhance termination checking of with?"#The name of size successor, if any."2The name of the delay constructor (sharp), if any."/Depth at which to cut off the structural order."3The name of the function we are currently checking."The names of the functions in the mutual block we are checking. This includes the internally generated functions (with, extendedlambda, coinduction)."rThe list of name actually appearing in the file (abstract syntax). Excludes the internally generated functions."_Target type of the function we are currently termination checking. Only the constructors of " are considered guarding."%Are we checking a delayed definition?"Only consider the " ,( arguments for establishing termination."Only consider guardedness if , (not masked)." How many SIZELTy relations do we have in the context (= clause telescope). Used to approximate termination for metas in call args."+The patterns of the clause we are checking."Number of additional binders we have gone under (and consequently need to raise the patterns to compare to terms). Updated during call graph extraction, hence strict."~The current guardedness status. Changes as we go deeper into the term. Updated during call graph extraction, hence strict."When extracting usable size variables during construction of the call matrix, can we take the variable for use with SIZELT constraints from the context? Yes, if we are under an inductive constructor. No, if we are under a record constructor."JPattern variables that can be compared to argument variables using SIZELT."The current guardedness level."+The target of the function we are checking."!The mutual block we are checking.RThe functions are numbered according to their order of appearance in this list."!An empty termination environment.Values are set to a safe default meaning that with these initial values the termination checker will not miss termination errors it would have seen with better settings of these values.5Values that do not have a safe default are set to  IMPOSSIBLE.")Generic run method for termination monad."CRun TerM computation in default environment (created from options)."AShould the codomain part of a function type preserve guardedness?" Lens for "." Lens for "." Lens for "."9Compute usable vars from patterns and run subcomputation."Set " when going under constructor c."Set "$ for arguments following projection qx. We disregard j<i after a non-coinductive projection. However, the projection need not be recursive (Issue 1470)."For termination checking purposes flat should not be considered a projection. That is, it flat doesn't preserve either structural order or guardedness like other projections do. Andreas, 2012-06-09: the same applies to projections of recursive records."Check whether a projection belongs to a coinductive record and is actually recursive. E.g. @ isCoinductiveProjection (Stream.head) = return False8isCoinductiveProjection (Stream.tail) = return True @"-How long is the path to the deepest variable?"UA dummy pattern used to mask a pattern that cannot be used for structural descent." raiseDBP n ps# increases each de Bruijn index in ps by n@. Needed when going under a binder during analysis of a term."#A very crude way of estimating the SIZELT chains  i > j > k: in context. Returns 3 in this case. Overapproximates."*Only show intermediate nodes. (Drop last )."*Print masked things in double parentheses.p""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""a"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""p""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""L""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""None9:;#the kill list is empty or only Falses#0there is no possible kill (because of type dep.)#%managed to kill some args in the list#$all prescribed kills where performed#rCollect the *definitely* rigid variables in a monoid. We need to successively reduce the expression to do this.#Extended occurs check.# >Distinguish relevant and irrelevant variables in occurs check.#we are in arguments of a meta#1we are not in arguments of a meta but a bound var#8we are at the start or in the arguments of a constructor#)we are at the term root (this turns into  StronglyRigid)# we are in an irrelevant argument#XSet the names of definitions to be looked at to the defs in the current mutual block.#,Is a def in the list of stuff to be checked?#3Remove a def from the list of defs to be looked at.#Leave the top position.#"Leave the strongly rigid position.#$When assigning  m xs := v , check that m does not occur in v# and that the free variables of v are contained in xs.#%prune m' vs xs' attempts to remove all arguments from vs. whose free variables are not contained in xs. If successful, m'= is solved by the new, pruned meta variable and we return True else False.'Issue 1147: If any of the meta args vs is matchable, e.g., is a constructor term, we cannot prune, because the offending variables could be removed by reduction for a suitable instantiation of the meta variable.#&hasBadRigid xs v = Just True# iff one of the rigid variables in v is not in xs. Actually we can only prune if a bad variable is in the head. See issue 458. Or in a non-eliminateable position (see succeed/PruningNonMillerPattern).hasBadRigid xs v = Nothing` means that we cannot prune at all as one of the meta args is matchable. (See issue 1147.)#'Check whether a term Def f esD is finally stuck. Currently, we give only a crude approximation.#(Check whether any of the variables (given as de Bruijn indices) occurs *definitely* in the term in a rigid position. Reduces the term successively to remove variables in dead subterms. This fixes issue 1386.#)killArgs [k1,...,kn] X prunes argument i from metavar X if ki==TrueA. Pruning is carried out whenever > 0 arguments can be pruned.#*/killedType [((x1,a1),k1)..((xn,an),kn)] b = ([k'1..k'n],t') (ignoring Dom). Let t' = (xs:as) -> b. Invariant:  k'i == True iff  ki == True and pruning the ith argument from type b4 is possible without creating unbound variables. t' is type t after pruning all  k'i==True.#+dInstantiate a meta variable with a new one that only takes the arguments which are not pruneable.F######### # # # # ################### #!#"###$#%#&#'#(#)#*#+9Arguments to old meta var in left to right order with Bool' indicating whether they can be pruned.$The old meta var to receive pruning.$The pruned type of the new meta var.#,#-#.#/#0#1#2#3#4#5#6#7#8#9#:#;#<#=#>#?#@#A#B#C#D#E#F+######### # # # # ################### #!#"###$#%#&#'#(#)#*#+F########### # ######### # #!#"#### # #$#F#E#D#C#B#A#@#?#>#=#<#;#:#9#8#%#&#'#(###7#6#5#4#3#2#1#0#/#.#-#,######)#*#+8######### # # # # ################### #!#"###$#%#&#'#(#)#*#+#,#-#.#/#0#1#2#3#4#5#6#7#8#9#:#;#<#=#>#?#@#A#B#C#D#E#FNone9:;L!#M%Edge labels for the positivity graph.#T Monad for computing occurrences.#U"Context for computing occurrences.#W*Items corresponding to the free variables.=Potential invariant: It seems as if the list has the form 4 n +X ++ ,| (*w . #g) is, for some n and is, where is! is decreasing (non-strictly).#XName for " builtin.#YA type used locally in #~.#\Used to build #e and occurrence graphs.#`Used to build #e and occurrence graphs.#dOnlyVarsUpTo n occs* discards occurrences of de Bruijn index >= n.#i-One part of the description of an occurrence.#k(in the nth argument of a define constant#l'in the principal argument of built-in "#m"as an argument to a bound variable#n as an argument of a metavariable#oin the type of a constructor#p$in a datatype index of a constructor#q'in the nth clause of a defined function#r1matched against in a clause of a defined function#sin the definition of a constant#tDescription of an occurrence.#u)an unknown position (treated as negative)#vXThe elements of the sequence, from left to right, explain how to get to the occurrence.#xhCheck that the datatypes in the mutual block containing the given declarations are strictly positive.UAlso add information about positivity and recursivity of records to the signature.#}Removes #d entries and adds #t entries.=WARNING: There can be lots of sharing between the generated #tD entries. Traversing all of these entries could be expensive. (See # for an example.)#~An interpreter for #`.=WARNING: There can be lots of sharing between the generated #tD entries. Traversing all of these entries could be expensive. (See # for an example.)#Running the monad#1Computes the occurrences in the given definition.2WARNING: There can be lots of sharing between the #tE entries. Traversing all of these entries could be expensive. (See # for an example.)#1Computes the occurrences in the given definition.#Eta expand a clause to have the given number of variables. Warning: doesn't put correct types in telescope! This is used instead of special treatment of lambdas (which was unsound: issue 121)#2WARNING: There can be lots of sharing between the #tR entries in the edges. Traversing all of these entries could be expensive. (See # for an example.)#Computes all non-s2 occurrence graph edges represented by the given #`.2WARNING: There can be lots of sharing between the #tl entries in the edges. Traversing all of these entries could be expensive. For instance, for the function F in  benchmarkmiscSlowOccurrences.agda, a large number of edges from the argument X to the function F* are computed. These edges have polarity ,  or , and contain the following #t elements:#v (4 [#s F, #q 0]),#v (4 [#s F, #q 0, #j]),#v (4 [#s F, #q 0, #j, #j]),#v (4 [#s F, #q 0, #j, #j, #j]), and so on.#As #t does not have an u. we cannot do something meaningful for the  OccursWhere here.E.g. 'ostar (Edge JustNeg w) = Edge Mixed (w u (w >*< w))1 would probably more sense, if we could do it.#FThese operations form a semiring if we quotient by the relation "the  components are equal".T#M#N#O#P#Q#R#S#T#U#V#W#X#Y#Z#[#\#]#^#_#`#a#b#c#d#e#f#g#h#i#j#k#l#m#n#o#p#q#r#s#t#u#v#w#x#y#z#{#|#}#~#######&The names in the current mutual block.The current name.###########################9#M#N#O#P#Q#R#S#T#U#V#W#X#Y#[#Z#\#]#^#_#`#a#b#c#d#e#f#g#h#i#j#k#l#m#n#o#p#q#r#s#t#u#v#w#x#y#z#{#|#}#~#######T#w#x#y#t#u#v#i#j#k#l#m#n#o#p#q#r#s#z###f#g#h#e#`#a#b#c#d#\#]#^#_#{#|#}#Y#Z#[#~#U#V#W#X#T###R#S#################O#P#Q####M#N###########6#M#N#O#P#Q#R#S#T#U#V#W#X#Y#Z#[#\#]#^#_#`#a#b#c#d#e#f#g#h#i #j#k#l#m#n#o#p#q#r#s#t#u#v#w#x#y#z#{#|#}#~##################################None#The u method for  Occurrence matches that for #M.#Tests.########None9:;M NWhich DefOtypes are eligible for the principle argument of a projection-like function?OBTurn a definition into a projection if it looks like a projection.# View for a Def f (Apply a : es) where isProjection f. Used for projection-like fs.#NA projection or projection-like function, applied to its principal argument#sJust a lone projection-like function, missing its principal argument (from which we could infer the parameters).#*Not a projection or projection-like thing.# Semantics of #.# Top-level # (no reduction).#Reduce away top-level projection like functions. (Also reduces projections, but they should not be there, since Internal is in lambda- and projection-beta-normal form.)#Turn prefix projection-like function application into postfix ones. This does just one layer, such that the top spine contains the projection-like functions as projections. Used in  compareElims in TypeChecking.Conversion and in Agda.TypeChecking.CheckInternal.If the , is *x{, a lone projection like function will be turned into a lambda-abstraction, expecting the principal argument. If the , is , , it will be returned unaltered.No precondition. Preserves constructorForm, since it really does only something on (applications of) projection-like functions. NO########### NO########### ###########NONO###########None9;ILM4Record pattern trees.4ICorresponds to variable and dot patterns; contains the original pattern.4 RecCon t args/ stands for a record constructor application: tl is the type of the application, and the list contains a projection function and a tree for every argument.4+ p6 means that a variable (corresponding to the pattern p7, a variable or dot pattern) should be kept unchanged. + (n, x, t) means that n 4 variables, and n 4E dot patterns, should be removed, and a new variable, with the name x5, inserted instead. The type of the new variable is t.4VarPat# stands for variable patterns, and DotPat for dot patterns.4*A monad used to translate record patterns.The state records the number of variables produced so far, the reader records the total number of variables produced by the entire computation. Functions using this monad need to be sufficiently lazy in the reader component.4 dropFrom i n drops arguments j with  j < i + n and j >= i . NOTE: n7 can be negative, in which case arguments are inserted.44Split tree annotated for record pattern translation.4Split tree annotation.5!Constructor name for this branch.5Arity of the constructor.5$Should we translate this split away?#Take a record pattern p_ and yield a list of projections corresponding to the pattern variables, from left to right. E.g. for  (x , (y , z)) we return [ fst, fst . snd, snd . snd ].%If it is not a record pattern, error * is raised.5]Take a matrix of booleans (at least one row!) and summarize the columns using conjunction.5insertColumn i a m inserts a column before the ith column in matrix m and fills it with value a.5#cutSublist i n xs = (xs', ys, xs'') cuts out a sublist ys of width n from xs, starting at column i.5replaceByProjections i projs cc replaces variables i..i+n-1' (counted from left) by projections projs_1 i .. projs_n i.If n==0, we matched on a zero-field record, which means that we are actually introduce a new variable, increasing split positions greater or equal to i' by one. Otherwise, we have to lower5RCheck if a split is on a record constructor, and return the projections if yes.5+Bottom-up procedure to annotate split tree.#;Bottom-up procedure to record-pattern-translate split tree.#Replaces pattern matching on record constructors with uses of projection functions. Does not remove record constructor patterns which have sub-patterns containing non-record constructor or literal patterns.5 Runs a computation in the 4 monad.5 >Returns the next pattern variable, and the corresponding term.5  projections t9 returns a projection for every non-dot leaf pattern in tU. The term is the composition of the projection functions from the leaf to the root.KEvery term is tagged with its origin: a variable pattern or a dot pattern.5 gConverts a record tree to a single pattern along with information about the deleted pattern variables.5 *Removes record constructors from patterns.Returns the following things:The new pattern.A substitution which maps the old pattern variables (in the order they occurred in the pattern; not including dot patterns) to terms (either the new name of the variable, or a projection applied to a new pattern variable).GA list explaining the changes to the variables bound in the pattern.rRecord patterns containing non-record constructor patterns are not translated (though their sub-patterns may be).Example: The pattern !rec1 (con1 a) (rec2 b c) (rec3 d) should yield the pattern rec1 (con1 x) y z(, along with a substitution similar to $[x, proj2-1 y, proj2-2 y, proj3-1 z].=This function assumes that literals are never of record type.52Traverses a pattern and returns one of two things:>If there is no non-record constructor in the pattern, then + ps is returned, where psk contains one projection for every variable in the input pattern (in the order they are encountered)._Otherwise the output is a computation returning the same kind of result as that coming from 5 x. (Computations are returned rather than values to ensure that variable numbers are allocated in the right order.)/Assumes that literals are never of record type.5Translates the telescope.5xTranslates the clause body. The substitution should take things in the context of the old RHS to the new RHS's context.5 dropBinds n b drops the initial n occurrences of G from b.Precondition: b has to start with n occurrences of G..4445444445455445555#5555#555##5 5 5 5 5 555iExplanation of how the telescope should be changed. Types should be in the context of the old telescope.:Old telescope, flattened, in textual left-to-right order.;New telescope, flattened, in textual left-to-right order. +X3 is used to indicate the locations of dot patterns.55##############$4445444445455445555#5555#555##5 5 5 5 5 55555######None #55555555 ## #55555555 NoneM#&Insert implicit patterns in a problem.#.Eta-expand implicit pattern if of record type.#/Try to eta-expand implicit pattern. Returns +XO unless dealing with a record type that has eta-expansion and a constructor c. In this case, it returns *w  c _ _ ... _R (record constructor applied to as many implicit patterns as there are fields).#;Insert implicit patterns in a list of patterns. Even if (, trailing SIZELT patterns are inserted.#(Insert trailing SizeLt patterns, if any.#;Insert implicit patterns in a list of patterns. Even if (, trailing SIZELT patterns are inserted.############################None#MInstantiate a telescope with a substitution. Might reorder the telescope. +instantiateTel ( : Tel)( :  --> ) = ~( Monadic only for debugging purposes.#2Produce a nice error message when splitting failed########NoneL#HRename the variables in a telescope using the names from a given pattern#)Are there any untyped user patterns left?#Construct an initial split !% from user patterns. Example: @dCase : {A : Set} ! Maybe A ! Set ! Set ! Set Case nothing B C = B Case (just _) B C = Csample : {A : Set} (m : Maybe A) ! Case m Bool (Maybe A ! Bool) sample (just a) (just b) = true sample (just a) nothing = false sample nothing = true 2 The problem generated for the first clause of sample with patterns just a, just b would be: > problemInPat = ["_", "just a"] problemOutPat = [A, "m"] problemTel = [A : Set, m : Maybe A] problemRest = restPats = ["just b"] restType = "Case m Bool (Maybe A -> Bool)" @#Try to move patterns from the problem rest into the problem. Possible if type of problem rest has been updated to a function type.###The user patterns.%The type the user patterns eliminate.7The initial problem constructed from the user patterns.#################NoneM#Size constraints we can solve.# Leq a +n b represents  a =< b + n.  Leq a -n b represents  a + n =< b.#Atomic size expressions.#)A size meta applied to de Bruijn indices.#A de Bruijn index.#JCheck whether a type is either not a SIZELT or a SIZELT that is non-empty.#;Precondition: Term is reduced and not blocked. Throws a  if undecided#-Checks that a size variable is ensured to be > 0. E.g. variable i cannot be zero in context 9(i : Size) (j : Size< ! ! i) (k : Size< j) (k' : Size< k). Throws a  if undecided.#OCheck whether a variable in the context is bounded by a size expression. If  x : Size< a, then a is returned.#XWhenever we create a bounded size meta, add a constraint expressing the bound. In boundedSizeMetaHook v tel a, tel includes the current context.##trySizeUniv cmp t m n x els1 y els28 is called as a last resort when conversion checking m cmp n : t failed for definitions  m = x els1 and  n = y els2, where the heads x and y are not equal. trySizeUniv9 accounts for subtyping between SIZELT and SIZE, like Size< i =< Size.>If it does not succeed it reports failure of conversion check.#OCompute the deep size view of a term. Precondition: sized types are enabled.#Compare two sizes.#Compare two sizes in max view.#compareBelowMax u vs checks  u <= max vs. Precondition:  size vs >= 2#3Checked whether a size constraint is trivial (like X <= X+1).#9Test whether a problem consists only of size constraints.#(Test is a constraint speaks about sizes.#Find the size constraints.#.Return a list of size metas and their context.#Compute a set of size constraints that all live in the same context from constraints over terms of type size that may live in different contexts.cf. R#@Turn a constraint over de Bruijn indices into a size constraint.#FTurn a term with de Bruijn indices into a size expression with offset. Throws a , if the term isn't a proper size expression.#UCompute list of size metavariables with their arguments appearing in a constraint.#KConvert size constraint into form where each meta is applied to indices  0,1,..,n-1 where n is the arity of that meta. X[] <= t becomes X[id] <= t[^-1] X[] "d Y[] becomes X[id] "d Y[[^-1]] or X[[^1]] "d Y[id]: whichever is defined. If none is defined, we give up.#AMain function. Uses the old solver for size constraints using Agda.Utils.Warshall6. This solver does not smartly use size hypotheses  j : Size< i<. It only checks that its computed solution is compatible#&Old solver for size constraints using Agda.Utils.Warshall6. This solver does not smartly use size hypotheses  j : Size< i.#############################Size metas and their arity.(Size constraints (in preprocessed form).Returns False if solver fails.#############################################################################################None #/9;ILM*5!lRemove all non-coinductive projections from an algebraic term (not going under binders). Also, remove s.5")Extract recursive calls from expressions.#:The result of termination checking a module. Must be a + and have e.5#-Call graph with call info for composed calls.#4Entry point: Termination check a single declaration.5$-Termination check a sequence of declarations.5%HTermination check a single declaration (without necessarily ignoring abstract).5&FTermination check a bunch of mutually inductive recursive definitions.5' termMutual'D checks all names of the current mutual block, henceforth called allNames, for termination.allNames is taken from Internal` syntax, it contains also the definitions created by the type checker (e.g., with-functions).5(Smart constructor for  . Removes  that are not mentioned in .5) reportCalls for debug printing.0Replays the call graph completion for debugging.5*termFunction name checks name for termination.5+To process the target type.5,3Termination check a definition by pattern matching.BTODO: Refactor! As this function may be called twice, once disregarding dot patterns, the second time regarding dot patterns, it is better if we separated bare call extraction from computing the change in structural order. Only the latter depends on the choice whether we consider dot patterns or not.5-Mask arguments and result for termination checking according to type of function. Only arguments of types ending in data/record or Size are counted in.5.0Is the current target type among the given ones?5/:Convert a term (from a dot pattern) to a DeBruijn pattern.MThe term is first normalized and stripped of all non-coinductive projections.503Masks coconstructor patterns in a deBruijn pattern.517Masks all non-data/record type patterns if --without-K.52cf. ST53(Extract recursive calls from one clause.54Rewrite a clause f ps =tel= {xs} -> v to f ps {xs} =(tel {xs})= v. The pupose is to move hidden size quantifications to the lhs such that the termination checker can make use of them. See, e.g., testsucceedSizedTypesExtendedLambda.agda.557Extract recursive calls from a constructor application.56/Handle guardedness preserving type constructor.57-Extract calls from with function application.58Handles function applications g es.59 Rewrite type tel -> Size< u to  tel -> Size.5: compareArgs es5Compare the list of de Bruijn patterns (=parameters) pats with a list of arguments esB and create a call maxtrix with |es| rows and |pats| columns.8The guardedness is the number of projection patterns in pats) minus the number of projections in es.5;Traverse patterns from left to right. When we come to a projection pattern, switch usage of SIZELT constraints: on, if coinductive, off, if inductive.UNUSED5< compareElim e dbpat5=In dependent records, the types of later fields may depend on the values of earlier fields. Thus when defining an inhabitant of a dependent record type such as  by copattern matching, a recursive call eliminated by an earlier projection (proj ) might occur in the definition at a later projection (proj ). Thus, earlier projections are considered "smaller" when comparing copattern spines. This is an ok approximation of the actual dependency order. See issues 906, 942.5>5> turns the result of 5: into a proper call matrix5?5?6 adds guardedness flag in the upper left corner (0,0).5@=Compose something with the upper-left corner of a call matrix5AStripping off a record constructor is not counted as decrease, in contrast to a data constructor. A record constructor increases/decreases by 0, a data constructor by 1.5B$Compute the proper subpatterns of a ".5C compareTerm' t dbpat(Precondition: top meta variable resolved5DsubTerm# computes a size difference (Order)5ECompare two variables.@The first variable comes from a term, the second from a pattern.$$Extract recursive calls from a term.$$Extract recursive calls from a type.$*Sorts can contain arbitrary terms of type Level<, so look for recursive calls also in sorts. Ideally, h; would not be its own datatype but just a subgrammar of *, then we would not need this boilerplate.>5!5F5"5G#5##5$5%5&5'5(5H5)5*5+5,5-5.5/505152535I5455Constructor name.>Should the constructor be treated as inductive or coinductive?@All the arguments, and for every argument a boolean which is *x@ iff the argument should be viewed as preserving guardedness.565758595:5;5<5=5>5?5@5A5B5J5C5D5K5L5M5E#$$$$$$$$$$ $ $ $ $ "####"<5!5F5"5G#5##5$5%5&5'5(5H5)5*5+5,5-5.5/505152535I5455565758595:5;5<5=5>5?5@5A5B5J5C5D5K5L5M5E#$$$$$$$$$$ $ $ $ $ NoneguardConstraint c blocker tries to solve blockerC first. If successful without constraints, it moves on to solve c, otherwise it adds a  Guarded c cs constraint to the blocker-generated constraints cs.4Don't allow the argument to produce any constraints.7Catches pattern violation errors and adds a constraint.$,Create a fresh problem for the given action.$4Wake up the constraints depending on the given meta.$Wake up all constraints.$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$None9:;LM)OReturns every meta-variable occurrence in the given type, except for those in hs.3Create a new value meta with specific dependencies.?Create a new metavariable, possibly -expanding in the process.newIFSMeta s t candsP creates a new "implicit from scope" metavariable of type the output type of t with name suggestion s. If tB is a function type, then insert enough lambdas in front of it.Miller pattern unification: assign x vs v solves problem x vs = v for meta x if vs1 are distinct variables (linearity check) and v9 depends only on these variables and does not contain x itself (occurs check).9This is the basic story, but we have added some features: Pruning.Benign cases of non-linearity.vs may contain record patterns.iFor a reference to some of these extensions, read Andreas Abel and Brigitte Pientka's TLCA 2011 paper.Assign to an open metavar which may not be frozen. First check that metavar args are in pattern fragment. Then do extended occurs check on given thing.$Assignment is aborted by throwing a  PatternErr via a call to patternViolation. This error is caught by catchConstraint during equality checking ( compareAtom:) and leads to restoration of the original constraints.!Do safe eta-expansions for meta (SingletonRecords,Levels).(Performing the meta variable assignment.#The instantiation should not be an  or  and the  should point to something  or a +. Further, the meta variable may not be .$7Exceptions raised when substitution cannot be inverted.$Cannot recover.$=A potentially neutral arg: can't invert, but can try pruning.$&Try to eta-expand var to remove projs.$!6Check whether one of the meta args is a projected var.$#Various kinds of metavariables.$$Meta variables of record type.$%7Meta variables of "hereditarily singleton" record type.$&;Meta variables of level type, if type-in-type is activated.$'aFind position of a value in a list. Used to change metavar argument indices during assignment.reverse@ is necessary because we are directly abstracting over the list.$(CCheck whether a meta variable is a place holder for a blocked term.$*8Skip frozen check. Used for eta expanding frozen metas.$1,Create a new value meta without -expanding.$23Create a new value meta with specific dependencies.$6ZCreate a metavariable of record type. This is actually one metavariable for each field.$96Construct a blocked constant if there are constraints.$<unblockedTester t returns False if t is a meta or a blocked term.?Auxiliary function to create a postponed type checking problem.$=)Create a postponed type checking problem e : t that waits for type tA to unblock (become instantiated or its constraints resolved).$>)Create a postponed type checking problem e : t that waits for conditon unblockv. A new meta is created in the current context that has as instantiation the postponed type checking problem. An %@ constraint is added for this meta, which links to this meta.$?1Type of the term that is produced by solving the .$@7Eta expand metavariables listening on the current meta.$A/Wake up a meta listener and let it do its thing$B All possible metavariable kinds.$CvEta expand a metavariable, if it is of the specified kind. Don't do anything if the metavariable is a blocked term.$DPEta expand blocking metavariables of record type, and reduce the blocked thing.$FassignMeta m x t ids u solves  x ids = u for meta x of type t, where term u lives in a context of length m. Precondition: ids is linear.$GassignMeta' m x t ids u solves  x = [ids]u for meta x of type t, where term u lives in a context of length m , and ids is a partial substitution.$HTurn the assignment problem _X args <= SizeLt u into _X args = SizeLt (_Y args) and constraint  _Y args <= u.$I Eta-expand bound variables like z in  X (fst z).$JJEta-expand a de Bruijn index of record type in context and passed term(s).$K_Turn non-det substitution into proper substitution, if possible. Otherwise, raise the error.$LCheck that arguments args to a metavar are in pattern fragment. Assumes all arguments already in whnf and eta-reduced. Parameters are represented as Vars so  checkArgs$ really checks that all args are Var^s and returns the "substitution" to be applied to the rhs of the equation to solve. (If args8 is considered a substitution, its inverse is returned.)The returned list might not be ordered. Linearity, i.e., whether the substitution is deterministic, has to be checked separately.$MUsed in U.E$$$$$$)a possibly non-deterministic substitution$$$ $!$"$#$$$%$&$'$($)$*$+$,$-$.$/$0$1$2$3$4$5$6$7$8$9$:$;$<$=$>$?$@$A$B$C$D$E$F$G$H dirThe meta variable x.Its associated information mvar <- lookupMeta x. Its type  t = jMetaType $ mvJudgement mvarIts arguments.Its to-be-assigned value v , such that x args dir v.0Continuation taking its possibly assigned value.$I$J$K$L$M$N$O$PB$$$$$$$$$ $!$"$#$$$%$&$'$($)$*$+$,$-$.$/$0$1$2$3$4$5$6$7$8$9$:$;$<$=$>$?$@$A$B$C$D$E$F$G$H$I$J$K$L$ME$'$($)$*$+$,$-$.$/$0$1$2$3$4$5$6$7$8$9$:$;$<$=$>$?$@$A$#$$$%$&$B$C$D$E$F$G$H$I$J$!$"$$ $P$O$N$$$K$$$$$$L$M=$$$$$$$$$ $!$"$#$$$%$&$'$($)$*$+$,$-$.$/$0$1$2$3$4$5$6$7$8$9$:$;$<$=$>$?$@$A$B$C$D$E$F$G$H$I$J$K$L$M$N$O$PNone:highlightAsTypeChecked rPre r m runs mG and returns its result. Additionally, some code may be highlighted:If r% is non-empty and not a sub-range of rPre (after  has been applied to both): r/ is highlighted as being type-checked while m0 is running (this highlighting is removed if m completes  successfully).'Otherwise: Highlighting is removed for rPre - r before m runs, and if m completes successfully, then rPre - r) is highlighted as being type-checked.5N<A function mapping names to the kind of name they stand for.$UHighlighting levels.$VXFull highlighting. Should only be used after typechecking has completed successfully.$WBHighlighting without disambiguation of overloaded constructors.$X5Lispify and print the given highlighting information.$YlGenerate syntax highlighting information for the given declaration, and (if appropriate) print it. If the  is $V, then the state is additionally updated with the new highlighting info (in case of a conflict new info takes precedence over old info).CThe procedure makes use of some of the token highlighting info in J (that corresponding to the interval covered by the declaration). If the  is $VC, then this token highlighting info is additionally removed from .$ZZGenerate and return the syntax highlighting information for the tokens in the given file.$[Same as $Z* but takes a string instead of a filename.5O1Compute syntax highlighting for the given tokens.5P Builds a 5N function.5QGenerates syntax highlighting information for all constructors occurring in patterns and expressions in the given declaration.This function should only be called after type checking. Constructors can be overloaded, and the overloading is resolved by the type checker.$]-Prints syntax highlighting info for an error.$^RGenerate highlighting for error. Does something special for termination errors.5R4Generate syntax highlighting for termination errors.$_sGenerates and prints syntax highlighting information for unsolved meta-variables and certain unsolved constraints.$`GGenerates syntax highlighting information for unsolved meta variables.$anGenerates syntax highlighting information for unsolved constraints that are not connected to a meta variable.5S8Generates a suitable file for a possibly ambiguous name.5TConverts names to suitable  s.5U A variant of 5T for qualified abstract names.$bfRemember a name disambiguation (during type checking). To be used later during syntax highlighting.$cAll the properties.5N$U$V$W$X$Y$ZThe module to highlight.$[5O5PThis should only be $V@ if type-checking completed successfully (without any errors).5Q'Maps source file paths to module names.The module to highlight.$\$]$^5R$_$`$a5S'Maps source file paths to module names.The module to highlight.5T'Maps source file paths to module names.DThe file name of the current module. Used for consistency checking."The name qualifier (may be empty).The base name.BMeta information to be associated with the name. The argument is *x iff the name is an operator.rThe definition site of the name. The calculated meta information is extended with this information, if possible.5U'Maps source file paths to module names.DThe file name of the current module. Used for consistency checking. The name.0Should the binding site be included in the file?DMeta information to be associated with the name. ^ The argument is *x iff the name is an operator.5V5W5X$b$c$U$W$V$X$Y$Z$[$\$]$^$_$`$a$b$c$U$V$W$Y$Z$[$\$]$^$_$X$`$a$b$c5N$U$V$W$X$Y$Z$[5O5P5Q$\$]$^5R$_$`$a5S5T5U5V5W5X$b$cNone9;IT$zbuildList A ts builds a list of type List A. Assumes that the terms ts all have type A.${Conceptually: 2redBind m f k = either (return . Left . f) k =<< m$Abbreviation: argN =  (.$Abbreviation: argH =   (.m$d$e$f$g$h$i$j$k$l$m$n$o$p$q$r$s$t$u$v$w$x$y$z${$|$}$~$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$D$d$e$f$g$h$i$j$k$l$m$n$o$p$q$r$s$t$u$v$w$x$y$z${$|$}$~$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$m$x$y$u$v$w$$$$r$s$t$$p$q$$$n$o$$$$$$$$$$$$$k$l$m$$$$$$$$$$$$$z$$j$h$i$$$$$$$$$$${$|$}$~$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$g$f$e$d$$$$$$$$c$d$e$f$g$h$i$j$k$l$m$n$o$p$q$r$s$t$u$v$w$x$y$z${$|$}$~$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$4$4$4$9 $9 None!"M%5Y5Z5[5\5]5^5_5`5a5b5c5d5e5f5g5h5i5j5k5l5m5n5o5p5q$5r5s5t5u5v5w5x5y5z5{5|$$5Y5Z5[5\5]5^5_5`5a5b5c5d5e5f5g5h5i5j5k5l5m5n5o5p5q$5r5s5t5u5v5w5x5y5z5{5|None(MT 5}*Environment for naming of local variables.5~;Maps case tree de-bruijn indices to TTerm de-bruijn indices5yTTerm de-bruijn index of the current catch all If an inner case has no catch-all clause, we use the one from its parent.$-Converts compiled clauses to treeless syntax.Note: Do not use any of the concrete names in the returned term for identification purposes! If you wish to do so, first apply the Agda.Compiler.Treeless.NormalizeNames transformation.5.Initial environment for expression generation.5%Term variables are de Bruijn indices.5$Case variables are de Bruijn levels.5<Compile a case tree into nested case and record expressions.5Replace de Bruijn Level x by n new variables.5Precondition: Map not empty.5eTranslate the actual Agda terms, with an environment of all the bound variables from patternmatching. Agda terms are in de Bruijn indices, but the expected TTerm de bruijn indexes may differ. This is due to additional let-bindings introduced by the catch-all machinery, so we need to lookup casetree de bruijn indices in the environment as well. 555}55~55$55$5555Case tree de bruijn index.TTerm de bruijn index.5case tree de bruijn levelTTerm de bruijn index5555555555555555$$$$555}55~55$55$555555555555555555555NoneL$,Argument should be in weak head normal form. $$$$$$$$$$ $$$$$$$$$$ $$$$$$$$$$$$$$$$$$$$None9:;Mb.Check that the first sort equal to the second.gcompareTel t1 t2 cmp tel1 tel1 checks whether pointwise tel1 `cmp` tel2 and complains that  t2 `cmp` t1 failed if not.hEquality on TypesicompareElims pols a v els1 els2: performs type-directed equality on eliminator spines. t is the type of the head v.j(Type-directed equality on argument listsk)Syntax directed equality on atomic valuesl!Type directed equality on values.$Try whether a computation runs without errors or new constraints (may create new metas, though). Restores state upon failure.$nTry whether a computation runs without errors or new constraints (may create new metas, though). Return *w$ the result upon success. Return +X and restore state upon failure.$qCheck if to lists of arguments are the same (and all variables). Precondition: the lists have the same length.$intersectVars us vs) checks whether all relevant elements in us and vs? are variables, and if yes, returns a prune list which says True8 for arguments which are different and can be pruned.$$Ignore errors in irrelevant context.$_Try to assign meta. If meta is projected, try to eta-expand and run conversion check again.$Raise 4 if there is no hope that by meta solving and subsequent eta-contraction these terms could become equal. Precondition: the terms are in reduced form (with no top-level pointer) and failed to be equal in the k check.QBy eta-contraction, a lambda or a record constructor term can become anything.$Compare two terms in irrelevant position. This always succeeds. However, we can dig for solutions of irrelevant metas in the terms we compare. (Certainly not the systematic solution, that'd be proof search...)$ coerce v a b coerces v : a to type b, returning a v' : b@ with maybe extra hidden applications or hidden abstractions.In principle, this function can host coercive subtyping, but currently it only tries to fix problems with hidden function types.$Account for situations like k : (Size< j) <= (Size< k + 1)Actually, the semantics is (Size<= k) ") (Size< j) " rhsJ which gives a disjunctive constraint. Mmmh, looks like stuff TODO."For now, we do a cheap heuristics.$9Check that the first sort is less or equal to the second. We can put SizeUniv below Inf;, but otherwise, it is unrelated to the other universes.$Precondition: levels are d.#abcdefghijkl$$$$$$$$$$$$$$$$$$$$$$$#abcdefghijkl$$$$$$$$$$$$$$$$$$$$$$$#$$$$d$c$l$$$$g$$k$i$$$jha$$ef$$$$b$#abcdefghijkl$$$$$$$$$$$$$$$$$$$$$$$None9;Infer type of a neutral term.Entry point for term checking./Entry point for e.g. checking WithFunctionType.5 Check a type and infer its sort.Necessary because of PTS rule (SizeUniv, Set i, Set i) but SizeUniv is not included in any Set i.This algorithm follows Abel, Coquand, Dybjer, MPC 08, Verifying a Semantic -Conversion Test for Martin-Lf Type Theory5checkArgInfo actual expected.5$Infer ordinary function application.53Infer possibly projection-like function application5inferSpine t self es checks that spine es eliminates value self of type t^ and returns the remaining type (target of elimination) and the final self (has that type).5Returns both the real term (first) and the transformed term (second). The transformed term is not necessarily a valid term, so it must not be used in types.5rType should either be a record type of a type eligible for the principal argument of projection-like functions.5Result is in reduced form.5Check if sort is well-formed.5Check if level is well-formed.5Type of a term or sort meta.5DUniverse subsumption and type equality (subtyping for sizes, resp.).$%%%55%%55555555555555555 $%%%%% %%$%%%$%%%55%%55555555555555555None9:;M% subst u . absTerm u == id%isPrefixOf u v = Just es if v == u  es.% )piAbstractTerm v a b[v] = (w : a) -> b[w]%  (piAbstract (v, a) b[v] = (w : a) -> b[w]For rewrite, it does something special: JpiAbstract (prf, Eq a v v') b[v,prf] = (w : a) (w' : Eq a w v') -> b[w,w']% This swaps var 0 and var 1.%%%%% % % % % %%%%%%%%%%%%%%%%%% %%%%% % % % % %% % % % %%%%%% %%%%%%%%%%%%%%%%%%%%%% % % % % %%%%%%%%%%%%%%%%%%None% %!%"%#%$% %!%"%#%$% %!%"%#%$% %!%"%#%$None9;%%;Compute the pattern variables of a term or term-like thing.%'Given the type of a constructor (excluding the parameters), decide which arguments are forced. Update the relevance info in the domains accordingly. Precondition: the type is of the form  ! D vs and the vs are in normal form.%( force s xs t marks the domains xs in function type t# as forced. Domains bigger than s are marked as  , others as  X. Counting left-to-right, starting with 0. Precondition: function type is exposed.%)(Assumes that the term is in normal form.%%%&%'%(%)%*%%%&%'%(%'%%%&%*%)%(%%%&%'%(%)%*None9;M P rewrite t! tries to rewrite a reduced term.Q{Check that the name given to the BUILTIN REWRITE is actually a relation symbol. I.e., its type should be of the form  ! (lhs rhs : A) ! Set !A. Note: we do not care about hiding/non-hiding of lhs and rhs.%+"Erase the CtxId's of rewrite rules%/Deconstructing a type into  ! t ! t' ! core.%1The whole telescope , t, t'.%2.%3t.%4t'.%5core.%7Deconstructing a type into  ! t ! t' ! core . Returns Nothing if not enough argument types.%8Add q :  ! rel us lhs rhs as rewrite rule   " lhs ! rhs : B  to the signature where  B = A[us/]. Remember that rel :  ! A ! A ! Set i, so $rel us : (lhs rhs : A[us/]) ! Set i.%9%Append rewrite rules to a definition.%:rewriteWith t v rew tries to rewrite v : t with rew%, returning the reduct if successful.PQ%+%,%-%.%/%0%1%2%3%4%5%6%7%8%9%:%;%<%=%>%?%@PQ%+%,%-%.%/%0%1%2%3%4%5%6%7%8%9%:%;%6Q%/%0%1%2%3%4%5%7%8%9%:P%-%.%@%?%;%+%,%>%=%<PQ%+%,%-%.%/%0%1%2%3%4%5%6%7%8%9%:%;%<%=%>%?%@None:%ATType check a datatype definition. Assumes that the type has already been checked.%B=A parameter is small if its sort fits into the data sort.  smallParams9 overapproximates the small parameters (in doubt: small).%CType check a constructor declaration. Checks that the constructor targets the datatype and that it fits inside the declared sort. Returns the non-linear parameters.%D"Bind the parameters of a datatype.%ECheck that the arguments to a constructor fits inside the sort of the datatype. The first argument is the type of the constructor.%FReturn the parameters that share variables with the indices nonLinearParameters :: Int -> Type -> TCM [Int] nonLinearParameters nPars t =Check that a type constructs something of the given datatype. The first argument is the number of parameters to the datatype.OAs a side effect, return the parameters that occur free in indices. E.g. in 9data Eq (A : Set)(a : A) : A -> Set where refl : Eq A a a! this would include parameter a , but not A."TODO: what if there's a meta here?%G!Is the type coinductive? Returns +X% if the answer cannot be determined.%A%B%CName of data type.Parameter telescope.#Number of indices of the data type.Sort of the data type.)Constructor declaration (type signature).Non-linear parameters.%D%E%F%G%A%B%C%D%E%F%G%A%B%C%D%E%F%G%A%B%C%D%E%F%GNoneMT%HWSplit a problem at the first constructor pattern which is actually of datatype type.Or, if there is no constructor pattern left and the rest type is a record type and the first rest pattern is a projection pattern, split the rest type.,Implicit patterns should have been inserted.5!checkParsIfUnambiguous [c] d pars, checks that the data/record type behind ch is has initial parameters (coming e.g. from a module instantiation) that coincide with an prefix of pars.%H-The definition we are checking at the moment.&The current state of the lhs patterns.5%H%H%H5None(/02349:;<=ILM%JUnification succeeded.%KTerms are not unifiable.%L1Some other error happened, unification got stuck.%M Result of %O.%NUnify indices.In unifyIndices_ flex a us vs,a is the type eliminated by us and vsC (usally the type of a constructor), need not be reduced,us and vs! are the argument lists to unify,flex3 is the set of flexible (instantiable) variabes in us and vs.*The result is the most general unifier of us and vs.54Get the type of the i'th variable in the given state5Get the k'th equality in the given state. The left- and right-hand sides of the equality live in the varTel telescope, and the type of the equality lives in the varTel++eqTel telescope5*As getEquality, but with the unraised type5>Add a list of equations to the front of the equation telescope5[Instantiate the k'th variable with the given value. Returns Nothing if there is a cycle.5{Solve the k'th equation with the given value, which can depend on regular variables but not on other equation variables.5Simplify the k'th equation with the given value (which can depend on other equation variables). Returns Nothing if there is a cycle.55Returns true if the variables 0..k-1 don't occur in x5Checks whether the given term (of the given type) is beta-eta-equivalent to a variable. Returns just the de Bruijn-index of the variable if it is, or nothing otherwise.555555555555555555555555555555555555555555555555555555555555555555555555666666%I%J%K%L%M%N%O6666 6 6 6 6 6566556565665566655666666666 6!6"6#6$6%6&6'%P%Q%R%S%T%I%L%J%K%M%N%O%M%I%J%K%L%O%N<5555555555575555555555555555555555555555555555555555555555555555555555555666666%I%J%K%L%M%N%O6666 6 6 6 6 6566556565665566655666666666 6!6"6#6$6%6&6'%P%Q%R%S%TNone:T%[*Returns how many parameters a datatype has%\*Returns how many parameters a datatype has%_winsertTele i xs t tele tpos tele := Gamma ; (i : T as) ; Delta n := parameters T xs' := xs  (take n as) becomes tpos ( Gamma ; xs' ; Delta[i := t] --note that Delta still reference Gamma correctly , T as ^ (size xs') )cwe raise the type since we have added xs' new bindings before Gamma, and as can only bind to Gamma.%c?Main function for removing pattern matching on forced variables%dqFor a given expression, in a certain telescope (the list of Var) is a mapping of variable name to the telescope.%e=replace the forcedVar with pattern matching from the outside.%feGiven a term containg the forced var, dig out the variable by inserting the proper case-expressions.%gFind the location where a certain Variable index is by searching the constructors aswell. i.e find a term that can be transformed into a pattern that contains the same value the index. This fails if no such term is present. %[%\%]%^%_ABS pos in telebIf Just, it is the type to insert patterns from is nothing if we only want to delete a binding.Term to replace at posThe telescope tele where everything is at%`%a%b%c%d%e%f%g %[%\%]%^%_%`%a%b%c%d%e%f%g %[%\%]%^%_%`%a%b%c%d%e%f%g %[%\%]%^%_%`%a%b%c%d%e%f%gNone:LM%hA Covering is the result of splitting a %l.%j@De Bruijn level (counting dot patterns) of argument we split on.%k=Covering clauses, indexed by constructor these clauses share.%nType of variables in scPats.%oMThe patterns leading to the currently considered branch of the split tree.%pSubstitution from %nQ to old context. Only needed directly after split on variable: * To update %qT * To rename other split variables when splitting on multiple variables. scSubst is not ` transitive'I, i.e., does not record the substitution from the original context to %nL over a series of splits. It is freshly computed after each split by computeNeighborhood ; also %xI, which does not split on a variable, should reset it to the identity , lest it be applied to %q again, leading to Issue 1294.%q'The type of the rhs, living in context %n.. This invariant is broken before calls to %u ; there, %q lives in the old context. %u moves %q0 to the new context by applying substitution %p.%r,Project the split clauses out of a covering.%s7Create a split clause from a clause in internal syntax.%t1Top-level function for checking pattern coverage.6(=cover f cs (SClause _ _ ps _) = return (splitTree, used, pss)%. checks that the list of clauses cs/ covers the given split clause. Returns the  splitTree, the used clauses, and missing cases pss.6)_Check that a type is a non-irrelevant datatype or a record with named constructor. Unless the  argument is " the data type must be inductive.%uUpdate the target type, add more patterns to split clause if target becomes a function type. Returns the domains of the function type (if any).6* 9computeNeighbourhood delta1 delta2 d pars ixs hix hps con z delta1 Telescope before split point n Name of pattern variable at split point delta2 Telescope after split point d Name of datatype to split at pars Data type parameters ixs Data type indices hix Index of split variable ps Patterns before doing the split con Constructor to fit into hole dtype == d pars ixs%vEntry point from Interaction.MakeCase.%wEntry point from TypeChecking.Empty and Interaction.BasicOps. splitLast CoInductive is used in the refine tactics.6+$split ind splitClause x = return res splits  splitClause at pattern var x (de Bruijn index).Possible results res are: Left err: Splitting failed.Right covering: A covering set of split clauses, one for each valid constructor. This could be the empty set (denoting an absurd clause).6,Convert a de Bruijn index relative to the clause telescope to a de Bruijn level. The result should be the argument position (counted from left, starting with 0) to split at (dot patterns included!).6-%split' ind splitClause x = return res splits  splitClause at pattern var x (de Bruijn index).Possible results res are: Left err: Splitting failed.Right (Left splitClause'): Absurd clause (type of x has 0 valid constructors).Right (Right covering)H: A covering set of split clauses, one for each valid constructor.%x splitResult f sc = return resIf the target type of scC is a record type, a covering set of split clauses is returned (sc: extended by all valid projection patterns), otherwise res == NothingV. Note that the empty set of split clauses is returned if the record has no fields.%yFor debugging only.6.%h%i%j%k%l%m%n%o%p%q%r%s%t6(6/6)%u6* Telescope before split point.(Name of pattern variable at split point.Telescope after split point.Name of datatype to split at.Data type parameters.Data type indices.Index of split variable. Patterns before doing the split.Constructor to fit into hole. New split clause if successful.%v%w6+:Coinductive constructors are allowed if this argument is .6,6-:Coinductive constructors are allowed if this argument is .If *x2, introduce new trailing variable patterns via %u.%x%y%h%i%j%k%l%m%n%o%p%q%r%s%t%u%v%w%x%l%m%n%o%p%q%s%u%h%i%j%k%r%t%v%w%x6.%h%i%j%k%l%m%n%o%p%q%r%s%t6(6/6)%u6*%v%w6+6,6-%x%yNoneL%Process function clauses into case tree. This involves: 1. Coverage checking, generating a split tree. 2. Translation of lhs record patterns into rhs uses of projection. Update the split tree. 3. Generating a case tree from the split tree. Phases 1. and 2. are skipped if Nothing.%{Stripped-down version of I used in clause compiler.%Get the index of the next argument we need to split on. This the number of the first pattern that does a match in the first clause.%DIs is not a variable pattern? And if yes, is it a record pattern?%Is this a variable pattern?Maintain invariant: isVar = isNothing . properSplit!%splitOn single n cs* will force expansion of catch-alls if single.%4Expand catch-alls that appear before actual matches.Example: % true y x false false y will expand the catch-all x to false.Catch-alls need also to be expanded if they come before/after a record pattern, otherwise we get into trouble when we want to eliminate splits on records later.#Another example (see Issue 1650): 8 f (x, (y, z)) true = a f _ false = b  Split tree:  0 (first argument of f) - 1 (second component of the pair) - 3 (last argument of f) -- true -> a - false -> b 1 We would like to get the following case tree:  case 0 of _,_ -> case 1 of _,_ -> case 3 of true -> a; false -> b _ -> case 3 of true -> a; false -> b _ -> case 3 of true -> a; false -> b =Translate record patterns and coverage check with given type?%z%{%|%}%~%%%%%%%%%%%z%{%|%}%~%%%%%%%%%%{%|%}%~%%z%%%%%%%%% %z%{%|%}%~%%%%%%%%%%NonevVCheck whether a type is empty. This check may be postponed as emptiness constraint.vvvv None9;LM%'Result of checking the LHS of a clause.%V : The types of the pattern variables, in internal dependency order. Corresponds to L.% The patterns in internal syntax.%The type of the body. Is b if  is defined. 8 to indicate the rhs must be checked in irrelevant mode.%%The permutation from pattern vars to . Corresponds to .%iA pattern is flexible if it is dotted or implicit, or a record pattern with only flexible subpatterns.%{Compute the set of flexible patterns in a list of patterns. The result is the deBruijn indices of the flexible patterns.%xUpdate the in patterns according to the given substitution, collecting new dot pattern instantiations in the process.%ICheck if a problem is solved. That is, if the patterns are all variables.%.For each user-defined pattern variable in the !, check that the corresponding data type (if any) does not contain a constructor of the same name (which is not in scope); this "shadowing" could indicate an error, and is not allowed.+Precondition: The problem has to be solved.%4Check that a dot pattern matches it's instantiation.%Checks whether the dot patterns left over after splitting can be covered by shuffling around the dots from implicit positions. Returns the updated user patterns (without dot patterns).%6Bind the variables in a left hand side and check that  8 of the patterns matches the hiding info in the type.,Precondition: the patterns should all be , , or \ and the telescope should have the same size as the pattern list. There could also be :s resulting from eta expanded implicit record patterns.%Bind as patterns%Check a LHS. Main function.checkLeftHandSide a ps a ret checks that user patterns ps eliminate the type a1 of the defined function, and calls continuation ret if successful.%UThe loop (tail-recursive): split at a variable in the problem until problem is solved%>Ensures that we are not performing pattern matching on codata.%Lists of flexible patterns are !.%%%%%%%%%%%Hthe types of the old pattern variables, relative to the new telescopeold in patterns:patterns to be substituted, living in the new telescope%% Trace, e.g., CheckPatternShadowing clause%%.Leftover patterns after splitting is completedHDe Bruijn indices of leftover variable patterns computed by splittingTypes of leftover patterns"Instantiations computed by unifier%%% Trace, e.g. CheckPatternShadowing clause+The name of the definition we are checking. The patterns.The expected type  a =  ! b. Continuation.%+The name of the definition we are checking.The current state.0The final state after all splitting is completed%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% None 9;<=LMT%'Size constraint with de Bruijn indices.% Living in Context.% Living in Context.%'Size expression with de Bruijn indices.%Size metas in size expressions.%De Bruijn indices.% Identifiers for rigid variables.%$Name for printing in debug messages.%De Bruijn index.%,Flag to control the behavior of size solver.%2Instantiate all unconstrained size variables to ".%,Leave unconstrained size variables unsolved.%,Solve size constraints involving hypotheses.%ICollect constraints from a typing context, looking for SIZELT hypotheses.%KConvert size constraint into form where each meta is applied to indices  n-1,...,1,0 where n is the arity of that meta. X[] <= t becomes X[id] <= t[^-1] X[] "d Y[] becomes X[id] "d Y[[^-1]] or X[[^1]] "d Y[id]: whichever is defined. If none is defined, we give up.Cf. (SizedTypes.oldCanonicalizeSizeConstraint.Fixes (the rather artificial) issue 300. But it is unsound when pruned metas occur and triggers issue 1914. Thus we deactivate it. This needs to be properly implemented, possibly using the metaPermuatation of each meta variable.%@Turn a constraint over de Bruijn indices into a size constraint.%#Turn a term into a size expression.Returns +X, if the term isn't a proper size expression.%&Turn a de size expression into a term.%$Assumes we are in the right context.% Only for .%*An order which ignores the meta arguments.%-An equality which ignores the meta arguments.)%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%)%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% None% telFromList . telToList == id%All elements of  V. are well-scoped under the original telescope.% unflattenTel . flattenTel == id% W is stable.%3The result of splitting a telescope is well-scoped.%GThe permutation generated when splitting a telescope preserves scoping.%%%%%%%%%%%%%%%%%%%%%%%%%%%% None9;M%"Argument should be a term of type  Term ! TCM A3 for some A. Returns the resulting term of type A. The second argument is the term for the hole, which will typically be a metavariable. This is passed to the computation (quoted).9%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%&&&&&&&&&& & & & & &&$%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%9%%%%%%%%%%%%%%%%%%%%%%%%%%%&&& & & & & %%%%%%&&&&&&&%&&%%%%%%%3%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%&&&&&&&&&& & & & & &&None #9:;<=LMT["S=Checking a lambda whose domain type has already been checked.T"checkArguments' exph r args t0 t k tries checkArguments exph args t0 t . If it succeeds, it continues k with the returned results. If it fails, it registers a postponed typechecking problem and returns the resulting new meta variable.Checks e := ((_ : t0) args) : t.UCheck a list of arguments: checkArgs args t0 t1 checks that t0 = Delta -> t0' and  args : DeltaT. Inserts hidden arguments to make this happen. Returns the evaluated arguments vs, the remaining type t0' (which should be a subtype of t1) and any constraints cs< that have to be solved for everything to be well-formed.VInfer the type of an expression. Implemented by checking against a meta variable. Except for neutrals, for them a polymorphic type is inferred.WType check an expression.X<Check that an expression is a type without knowing the sort.&(Flag to control resurrection on domains.&We are checking a module telescope. We pass into the type world to check the domain type. This resurrects the whole context.&We are checking a telescope in a Pi-type. We stay in the term world, but add resurrected domains to the context to check the remaining domains and codomain of the Pi-type.&#Check that an expression is a type.&?Ensure that a (freshly created) function type does not inhabit l. Precondition: When noFunctionsIntoSize t tBlame( is called, we are in the context of tBlame< in order to print it correctly. Not being in context of tK should not matter, as we are only checking whether its sort reduces to l.&BCheck that an expression is a type which is equal to a given type.&QType check a (module) telescope. Binds the variables defined by the telescope.&Type check the telescope of a dependent function type. Binds the resurrected variables defined by the telescope. The returned telescope is unmodified (not resurrected).&EType check a telescope. Binds the variables defined by the telescope.&Check a typed binding and extends the context with the bound variables. The telescope passed to the continuation is valid in the original context.fParametrized by a flag wether we check a typed lambda or a Pi. This flag is needed for irrelevance.&Type check a lambda expression.&mInsert hidden lambda until the hiding info of the domain type matches the expected hiding info. Throws & checkAbsurdLambda i h e t# checks absurd lambda against type t. Precondition: e = AbsurdLam i h&!%checkExtendedLambda i di qname cs e t/ check pattern matching lambda. Precondition: e = ExtendedLam i di qname cs&"Run a computation.If successful, return Nothing.If IlltypedPattern p a is thrown and type a is blocked on some meta x return Just xs. Note that the returned meta might only exists in the state where the error was thrown, thus, be an invalid  in the current state.(If another error was thrown or the type a# is not blocked, reraise the error.&$checkRecordExpression fs e t) checks record construction against type t. Precondition  e = Rec _ fs.&%#checkRecordUpdate ei recexpr fs e t Precondition e = RecUpdate ei recexpr fs.&)checkApplication hd args e t) checks an application. Precondition: Application hs args = appView echeckApplication1 disambiguates constructors (and continues to &2#) and resolves pattern synonyms.&**Unquote a TCM computation in a given hole.&+tTurn a domain-free binding (e.g. lambda) into a domain-full one, by inserting an underscore for the missing type.&.Type check a meta variable. If its type is not given, we return its type, or a fresh one, if it is a new meta. If its type is given, we check that the meta has this type, and we return the same type.&0Infer the type of a head thing (variable, function symbol, or constructor). We return a function that applies the head to arguments. This is because in case of a constructor we want to drop the parameters.&2Check the type of a constructor application. This is easier than a general application since the implicit arguments can be inserted without looking at the arguments to the constructor.&3 checkHeadApplication e t hd args checks that e has type t, assuming that e has the form hd args3. The corresponding type-checked term is returned.If the head term hd< is a coinductive constructor, then a top-level definition fresh tel = hd args0 (where the clause is delayed) is added, where tel= corresponds to the current telescope. The returned term is  fresh tel.Precondition: The head hdS has to be unambiguous, and there should not be any need to insert hidden lambdas.&5Check that a list of arguments fits a telescope. Inserts hidden arguments as necessary. Returns the type-checked arguments and the remaining telescope.&8Used to check aliases f = e. Switches off + for the checking of top-level application.&9?Check whether a de Bruijn index is bound by a module telescope.&:=Infer the type of an expression, and if it is of the form  {tel} -> D vs for some datatype DM then insert the hidden arguments. Otherwise, leave the type polymorphic.3RSTUVWX&&&&&&&&&&&&&&&Expected hiding.Expected to be a function type.Continuation on blocked type.QContinuation when expected hiding found. The continuation may assume that the Type is of the form (El _ (Pi _ _)).!Term with hidden lambda inserted.& &!&"&#&$&%&&&'&(&)&*&+&,&-&.&/&0&1&2&3&4&5)Eagerly insert trailing hidden arguments?Range of application.Arguments to check.%Telescope to check arguments against.8Checked arguments and remaining telescope if successful.&6&7&8&9&:&;&<3RSTUVWX&&&&&&&&&&&&&&&& &!&"&#&$&%&&&'&(&)&*&+&,&-&.&/&0&1&2&3&4&5&6&7&8&9&:&;&<3&X&&&&&&&&&&&&&S&& &!&"&#&$&%&&TW&'&(&)&*R&+&,&-&.&/&0&1&2&3&4U&5V&6&7&8&9&:&;&<1RSTUVWX&&&&&&&&&&&&&&&& &!&"&#&$&%&&&'&(&)&*&+&,&-&.&/&0&1&2&3&4&5&6&7&8&9&:&;&< None&? 'checkRecDef i name con ps contel fields nameRecord type identifier.con Maybe constructor name and info.psRecord parameters.contel!Approximate type of constructor (fields> -> Set). Does not include record parameters.fieldsList of field signatures.&@(checkRecordProjections m r q tel ftel fs. m name of the generated moduler name of the record typecon name of the record constructortel )parameters and record variable r ("self")ftel telescope of fieldsfs the fields to be checked&?Position and other info.Record type identifier.$Optional: (co)inductive declaration.Optional: constructor name.Record parameters.!Approximate type of constructor (fields0 -> Set). Does not include record parameters.Field signatures.&@&?&@&?&@&?&@NoneLM[&A6Split pattern variables according to with-expressions.&BAbstract with-expressions vs+ to generate type for with-helper function.Each  EqualityType, coming from a rewrite , will turn into 2 abstractions.&CFrom a list of with and rewrite; expressions and their types, compute the list of final with" expressions (after expanding the rewrites).&DFCompute the clauses for the with-function given the original patterns.&E 0stripWithClausePatterns parent f t qs  ps = ps' <context bound by lhs of original function (not an argument).fname of with -function.ttype of the original function.qs(internal patterns for original function.permutation taking vars(qs) to  support().ps*patterns in with clause (eliminating type t).ps'/patterns for with function (presumably of type ).Example: record Stream (A : Set) : Set where coinductive constructor delay field force : A Stream A record SEq (s t : Stream A) : Set where coinductive field ~force : let a , as = force s b , bs = force t in a "a b SEq as bs test : (s : Nat Stream Nat) (t : Stream Nat) ! SEq (delay s) t ! SEq t (delay s) ~force (test (a , as) t p) with force t ~force (test (suc n , as) t p) | b , bs = {!!} With function: @ f : (t : Stream Nat) (w : Nat Stream Nat) (a : Nat) (as : Stream Nat) (p : SEq (delay (a , as)) t) ! (fst w "a a) SEq (snd w) as  = t a as p -- reorder to bring with-relevant (= needed) vars first  = a as t p !  qs = (a , as) t p ~force ps = (suc n , as) t p ~force ps' = (suc n) as t p "Resulting with-function clause is:  f t (b , bs) (suc n) as t p &Note: stripWithClausePatterns factors ps through qs, thus  ps = qs[ps'] where [..]Q is to be understood as substitution. The projection patterns have vanished from ps' (as they are already in qs).&FConstruct the display form for a with function. It will display applications of the with function as applications to the original function. For instance,  aux a b c as  f (suc a) (suc b) | c &A, context of types and with-arguments. " t type of rhs. " as types of with arguments. " vs with arguments. Output:( , ,,t',as',vs') where  >part of context not needed for with arguments and their types. :part of context needed for with arguments and their types.*permutation from  to   as returned by  `.   " t'type of rhs under  " as',types with with-arguments depending only on  . " vs'with-arguments under .&B 7 context for types of with types. , " vs : raise  as with and rewrite-expressions. " as8 types of with and rewrite-expressions. "  = context extension to type with-expressions.  , " b type of rhs. ! wtel !  2 ! b 2 such that [vs/wtel]wtel = as and [vs/wtel] 2 =   and [vs/wtel]b 2 = b+. Plus the final number of with-arguments.&C&D Name of the parent function.Name of the with-function.Types of the parent function.Parent patterns.Final permutation.Number of needed vars.Number of with expressions. With-clauses.,With-clauses flattened wrt. parent patterns.&EName of the parent function.Name of with-function.t! type of the original function.qs* internal patterns for original function. permutation taking vars(qs) to  support().ps, patterns in with clause (eliminating type t).ps'0 patterns for with function (presumably of type ).&FThe name of parent function.The name of the with -function.  The arguments of the with function before the with expressions.  The arguments of the with function after the with expressions.n The number of with expressions.qs The parent patterns.perm7 Permutation to split into needed and unneeded vars.lhsPerm9 Permutation reordering the variables in parent patterns.&G&A&B&C&D&E&F&G&A&B&C&D&E&F&G&A&B&C&D&E&F&GNoneM[Set _" according to termination info in K4, which comes from a possible termination pragma.,Type check a definition by pattern matching.&HParameters for creating a with -function.&KParent function name.&LWith function name.&MType of the parent function.&NRTypes of arguments to the with function before the with expressions (needed vars).&OSTypes of arguments to the with function after the with expressions (unneeded vars).&PWith and rewrite expressions.&Q*Types of the with and rewrite expressions.&RType of the right hand side.&SParent patterns.&TQPermutation resulting from splitting the telescope into needed and unneeded vars.&U;Permutation reordering the variables in the parent pattern.&V@Final permutation (including permutation for the parent clause).&W'The given clauses for the with function&XIA single clause without arguments and without type signature is an alias.&Y'Check a trivial definition of the form f = e&Z@Insert some patterns in the in with-clauses LHS of the given RHS&[!Create a clause body from a term.As we have type checked the term in the clause telescope, but the final body should have bindings in the order of the pattern variables, we need to apply the permutation to the checked term.&\Type check a function clause.&]Type check the with and rewrite lhss and/or the rhs.&`Type check a where clause.&a=Check if a pattern contains an absurd pattern. For instance, suc ()'the type we expect the function to haveis it irrelevant (for instance)2are the clauses delayed (not unfolded willy-nilly)pdoes the definition come from an extended lambda (if so, we need to know some stuff about lambda-lifted args)Eis it a with function (if so, what's the name of the parent function) range infothe name of the functionthe clauses to check&H&I&J&K&L&M&N&O&P&Q&R&S&T&U&V&W&X&Y&Z&[&\(Type of function defined by this clause.Clause.Type-checked clause.&] Range of lhs.Name of function.Patterns in lhs.Type of function. Result of type-checking patterns Rhs to check.&^Name of function.Name of the with-function.Type of function. Result of type-checking patternsWith-expressions.Types of with-expressions.With-clauses to check.&_&` Type of rhs.Where-declarations to check. Continuation.&a&H&I&J&K&L&M&N&O&P&Q&R&S&T&U&V&W&X&Y&Z&[&\&]&^&_&`&a&X&Y&Z&H&I&J&K&L&M&N&O&P&Q&R&S&T&U&V&W&[&\&]&^&_&`&a&H&I&J&K&L&M&N&O&P&Q&R&S&T&U&V&W&X&Y&Z&[&\&]&^&_&`&aNoneLMT&bbindPostulatedName builtin e m checks that e is a postulated name q, and binds the builtin builtin to the term m q def , where def is the current  of q.&c&Bind a builtin thing to an expression.&f#Bind a builtin thing to a new name.606162&b63646566676869&c&d&e&f&b&c&d&e&f&c&f&b&d&e606162&b63646566676869&c&d&e&fNone (9;<=?LMT%6:,The with clauses haven't been translated yet6; rewrite e (many)6<with e (many)6=pthe subclauses spawned by a with (monadic because we need to reset the local vars before checking these clauses)&oas seen from inside the module&p*Temporary data type to scope check a file.&r/The file path from which we loaded this module.&sThe file content.6>$We for now disallow let-bindings in data and recordS telescopes. This due "nested datatypes"; there is no easy interpretation of Z data D (A : Set) (open M A) (b : B) : Set where c : D (A A) b ! D A b  where B is brought in scope by open M A.6?WIf a set is given, then the first name must correspond to one of the names in the set.6@WIf a set is given, then the first name must correspond to one of the names in the set.&~PThings that can be translated to abstract syntax are instances of this class.6A.Make sure that each variable occurs only once.6BFMake sure that there are no dot patterns (called on pattern synonyms).6CCCompute the type of the record constructor (with bogus target type)6D EcheckModuleApplication modapp m0 x dir = return (modapp', renD, renM)m0* is the new (abstract) module name and x- its concrete form (used for error messages).6E BcheckModuleMacro mkApply range access concreteName modapp open dirPreserves local variables.6FThe public) keyword must only be used together with open.6GJComputes the range of all the "to" keywords used in a renaming directive.6HScope check a  <.6I(This function should be used instead of &a for things that need to keep track of precedences to make sure that we don't forget about it.&aThis operation does not affect the scope, i.e. the original scope is restored upon completion.6JLike &F but returns the scope after the completion of the second argument.6K Peel off   and represent it as an .6L Peel off   and represent it as an , throwing away any name.6MBy default, arguments are Relevant.6NAParse a possibly dotted C.Expr as A.Expr. Bool = True if dotted.6OmTranslate concrete expression under at least one binder into nested lambda abstraction in abstract syntax.6P'Scope check extended lambda expression.6Q*Scope check a module (top level function).6RACheck whether a telescope has open declarations or module macros.6S,Returns the scope inside the checked module.&The top-level module name.6T@runs Syntax.Concrete.Definitions.niceDeclarations on main module6U An argument  OpApp C.ExprB to an operator can have binders, in case the operator is some syntaxG-notation. For these binders, we have to create lambda-abstractions.6VxTurn an operator application into abstract syntax. Make sure to record the right precedences for the various arguments.&%Top-level declarations are always  (import|open)* -- a bunch of possibly opened imports module ThisModule ... -- the top-level module of this file &g6W&h6X6:6Y6Z&i6[6;6<6=6\6]6^6_6`6a6b6c6d6e&j6f&k6g&l&m&n&o&p&q&r&s6>6h&t6i&u&v&w6j6k6l&x6m6n6o&y6?&z&{&|6@&}6p&~&6q6r6s6t6u6v6w6x6A6B6C6D6E6F6G6H Arguments of  < Arguments of 8&&6I6y6z6{6|&6J6}6~6K6L6M6N6O6P66Q6R6S The concrete name of the module. The abstract name of the module.The module telescope.*The code for checking the module contents.&6T66666666U6V&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&g&h&i&j&k&l&m&n&o&p&q&r&s&t&u&v&w&x&y&z&{&|&}&~&&&&&&~&&&&&u&v&z&{&p&q&r&s&l&m&n&o&&h&w&t&}&|&g&i&y&x&j&kr&g6W&h6X6:6Y6Z&i6[6;6<6=6\6]6^6_6`6a6b6c6d6e&j6f&k6g&l&m&n&o&p&q&r&s6>6h&t6i&u&v&w6j6k6l&x6m6n6o&y6?&z&{&|6@&}6p&~&6q6r6s6t6u6v6w6x6A6B6C6D6E6F6G6H&&6I6y6z6{6|&6J6}6~6K6L6M6N6O6P66Q6R6S&6T66666666U6V&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&None3Binds the FLAT builtin, and changes its definition.LBinds the SHARP builtin, and changes the definitions of INFINITY and SHARP.GBinds the INFINITY builtin, but does not change the type's definition.& The type of ".& The type of &o_.& The type of &m.&&&&&&&&&&&&None:L[@Check an application of a section (top-level function, includes I). Type check a single declaration.&Type check a sequence of declarations.&Cached checkDecl&NRun a reflected TCM computatation expected to define a given list of names.&Instantiate all metas in  associated to _. Makes sense after freezing metas. Some checks, like free variable analysis, are not in F, so they will be more precise (see issue 1099) after meta instantiation. Precondition: name has been added to signature already.&Highlight a declaration.& Termination check a declaration.&+Check a set of mutual names for positivity.&Check that all coinductive records are actually recursive. (Otherwise, one can implement invalid recursion schemes just like for the old coinduction.)&7Check a set of mutual names for constructor-headedness.&4Check a set of mutual names for projection likeness.Only a single, non-abstract function can be projection-like. Making an abstract function projection-like would break the invariant that the type of the principle argument of a projection-like function is always inferable.&Type check an axiom.&,Type check a primitive function declaration.&Check a pragma.&=Type check a bunch of mutual inductive recursive definitions.XAll definitions which have so far been assigned to the given mutual block are returned.&FType check the type signature of an inductive or recursive definition.&Type check a module.& Helper for .NMatches the arguments of the module application with the module parameters.dReturns the remaining module parameters as an open telescope. Warning: the returned telescope is notO the final result, an actual instantiation of the parameters does not occur.&"Check an application of a section.&rType check an import declaration. Actually doesn't do anything, since all the work is done when scope checking.Name m1' of module defined by the module macro.The module macro  tel ! m2 args.#Imported names (given as renaming).%Imported modules (given as renaming).&&&&&&&&&&&&&&&&&&&&&&&Name of applied module.The module parameters.(The arguments this module is applied to.>The remaining module parameters (has free de Bruijn indices!).&Name m1' of module defined by the module macro.The module macro  tel ! m2 args.#Imported names (given as renaming).%Imported modules (given as renaming).&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&VNoneVW&&VWNone 29:;<=LT & A subset of &.&Parses an expression.&Try to fill hole by expression.LReturns the given expression unchanged (for convenient generalization to &).&!Try to refine hole by expression e.)This amounts to successively try to give e, e ?, e ? ?3, ... Returns the successfully given expression.&9Evaluate the given expression in the current environment &getSolvedInteractionPoints TrueP returns all solutions, even if just solved by another, non-interaction meta. getSolvedInteractionPoints False5 only returns metas that are solved by a non-meta.&Returns the type of the expression in the current environment We wake up irrelevant variables just in case the user want to invoke that command in an irrelevant context.'\Runs the given computation as if in an anonymous goal at the end of the top-level module.+Sets up current module, scope, and context.' Parse a name.'8Check whether an expression is a (qualified) identifier.'3Returns the contents of the given module or record.'4Returns the contents of the given record identifier.' )Returns the contents of the given module.D&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&Hole.The expression to give.9If successful, the very expression is returned unchanged.&Hole.'The expression to refine the hole with."The successfully given expression.&&&&&&&&&&&&&&&''''''''"How should the types be presented?The range of the next argument.The module name.7Module names, names paired up with corresponding types.'!Amount of normalization in types.%Expression presumably of record type.7Module names, names paired up with corresponding types.' !Amount of normalization in types. Module name.7Module names, names paired up with corresponding types.' ' ' ' '''''<&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&'''''''''' ' D&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&''&'''' ' ' &&&&&&&&&&'''''''''' ' +&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&'''''''''' ' ' ' ' '''''None66666'''66666'None'The interaction loop.' Set  to  optInputFile.'0>The logo that prints when Agda is started in interactive mode.'1The help message'''''''''' '!'"'#'$'%'&'''(')'*'+','-'.'/'0'1'''''''''' '!'"'#'$'%'&'''(')'*'+','-'.'/'0'1'''''''''' '!'"'#'$'%'&'''(')'*'+','-'.'/'0'1'''''''''' '!'"'#'$'%'&'''(')'*'+','-'.'/'0'1None:LpScope checks the given module. A proper version of the module name (with correct definition sites) is returned.'5JAre we loading the interface for the user-loaded file or for an import?'6Interface for main file.'7Interface for imported file.'80Merge an interface into the current proof state.';If the module has already been visited (without warnings), then its interface is returned directly. Otherwise the computation is used to find the interface and the computed interface is stored for potential later use.'<Type checks the main file of the interaction. This could be the file loaded in the interacting editor (emacs), or the file passed on the command line.4First, the primitive modules are imported. Then,  getInterface' is called to do the main work.'=Tries to return the interface associated to the given (imported) module. The time stamp of the relevant interface file is also returned. Calls itself recursively for the imports of the given module. May type check the module. An error is raised if a warning is encountered.'Do not use this for the main file, use '< instead.'>See '=.'?A more precise variant of '=[. If warnings are encountered then they are returned instead of being turned into errors.'@EPrint the highlighting information contained in the given interface.'BbWrites the given interface to the given file. Returns the file's new modification time stamp, or +X if the write failed.'DTries to type check a module and write out its interface. The function only writes out an interface file if it does not encounter any warnings.IIf appropriate this function writes out syntax highlighting information.'FfBuilds an interface for the current module, which should already have been successfully type checked.'G Returns (iSourceHash, iFullHash)'IuTrue if the first file is newer than the second file. If a file doesn't exist it is considered to be infinitely old.'2'3'4'5'6'7'8'9':';'<'='>'?HIf type checking is necessary, should all state changes inflicted by 'D be preserved?'@The corresponding file.'A'B'C'DThe file to type check.The expected module name.'E'F&l for the current module.(Syntax highlighting info for the module.EMAlonzo: Haskell modules imported in imported modules (transitively).IUHC backend: Haskell modules imported in imported modules (transitively).Options set in OPTIONS pragmas.'G'H'I'2'3'4'5'6'7'8'9':';'<'='>'?'@'A'B'C'D'E'F'G'H'I'5'6'7'8'9'2'3'4':';'<'='>'?'@'A'B'C'D'E'F'G'H'I'2'3'4'5'6'7'8'9':';'<'='>'?'@'A'B'C'D'E'F'G'H'INone'Y4Copy pasted from MAlonzo.... Move somewhere else!'Z$Sets up the compilation environment.'L'M'N'O'P'Q'R'S'T'U'V'W'X'Y'Z'['L'M'N'O'P'Q'R'S'T'U'V'W'X'Y'Z'['L'M'N'O'P'Q'R'S'T'U'V'W'X'Y'Z'['L'M'N'O'P'Q'R'S'T'U'V'W'X'Y'Z'[None'g0Name for definition stripped of unused arguments0']'^'_'`'a'b'c'd'e'f'g'h'i'j'k'l'm'n'o'p'q'r's't'u'v'w'x'y'z'{'|'}'~''''''''''''''0']'^'_'`'a'b'c'd'e'f'g'h'i'j'k'l'm'n'o'p'q'r's't'u'v'w'x'y'z'{'|'}'~''''''''''''''0']'^'_'`'a'b'c'd'e'f'g'h'i'j'k'l'm'n'o'p'q'r's't'u'v'w'x'y'z'{'|'}'~''''''''''''''0']'^'_'`'a'b'c'd'e'f'g'h'i'j'k'l'm'n'o'p'q'r's't'u'v'w'x'y'z'{'|'}'~''''''''''''''None6 Agda module names. Used to test '.6:Can the character be used in a Haskell module name part (conidJ)? This function is more restrictive than what the Haskell report allows.'yHaskell module names have to satisfy the Haskell (including the hierarchical module namespace extension) lexical syntax: 4modid -> [modid.] large {small | large | digit | ' }'C is an injective function into the set of module names defined by modid. The function preserves .Ds, and it also preserves module names whose first name part is not 't.3Precondition: The input must not start or end with ., and no two .s may be adjacent.'All the properties. 666'666''''''666'666''None9:;<='.A wrapper type used to avoid orphan instances.'1Encodes module names just before pretty-printing.''''''''''''''''''''''''''''None''''None'7Check that the main function has type IO a, for some a.''''''''''''''''''''''''''''None9;<=I'Compiler monad6Stuff we need in our compiler6UHC core exports'MUsed to run the Agda-to-UHC Core transformation. During this transformation,'EReturns the CTag for a constructor. Not defined for Sharp and magic UNIT constructor.'QReturns the expression to use to build a value of the given datatype/constructor.6Returns the names inside a QName, with the module prefix stripped away. If the name is not module-qualified, returns the full name as left. (TODO investigate when this happens)#''666666'66666'The module to compile.6'6''''''''''''6'''''Y''''''''''''''''''''''''''''''''''Y'''666666'66666'6'6''''''''''''6''''None'pPrimitives defined for the UHC backend. Maps primitive names to the core expression to be used as function body.''''''''None(M'AConvert from Agda's internal representation to our auxiliary AST.'ETranslate an Agda definition to an UHC Core function where applicable'Translate the actual Agda terms, with an environment of all the bound variables from patternmatching. Agda terms are in de Bruijn so we just check the new names in the position.'RConstructs an alternative for all constructors not explicitly matched by a branch.''''''''''''''''equality functioncase scrutinee (in WHNF) default value''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''None'2Compile an interface into an executable using Epic6Before running the compiler, we need to store some things in the state, namely constructor tags, constructor irrelevancies and the delayed field in functions (for coinduction).6FPerform the chain of compilation stages, from definitions to epic code6VChange the current directory to Epic folder, create it if it doesn't already exist.6(Make a program from the given Epic code.#The program is written to the file ../m:, where m is the last component of the given module name.6=Create the Epic main file, which calls the Agda main function6kCall epic, with a given set of flags, if the |Bool| is True then include the command line flags at the end6hCall epic with a given set of flags, the argument function receives the flags given at the command line 6'66666666666'' 6'66666666666None#"''''''''''''''''''''''''''''''''''"''''''''''''''''''''''''''''''''''"''''''''''''''''''''''''''''''''''"''''''''''''''''''''''''''''''''''None:MT'9Environment for naming of local variables. Invariant: reverse ccCxt ++ ccNameSupply'Supply of fresh names'Names currently in scope(QNote that the INFINITY, SHARP and FLAT builtins are translated as follows (if a  is given): X type Infinity a b = b sharp :: a -> a sharp x = x flat :: a -> a flat x = x (.Initial environment for expression generation.(%Term variables are de Bruijn indices.( 'Introduce n variables into the context.( NExtract Agda term to Haskell expression. Erased arguments are extracted as (). Types are extracted as ().+'''''''(((((((((( ( ( ( ( ((((((((((%Is the type inductive or coinductive?((((((((( (!("+'''''''(((((((((( ( ( ( ( ((((((((((((((((((( (!("+(((((''''''(((('( ( ( ( ( ((((((((((((((((((( (!("('''''''(((((((((( ( ( ( ( ((((((((((((((((((( (!("None((#1Compile an interface into an executable using UHC6sCompiles a module and it's imports. Returns the module info of this module, and the accumulating module interface.6JPerform the chain of compilation stages, from definitions to UHC Core code6ACreate the UHC Core main file, which calls the Agda main function 6(#6666top level imports6666(#(# 6(#66666666 None(L(%Find the clause whose right hand side is the given meta BY SEARCHING THE WHOLE SIGNATURE. Returns the original clause, before record patterns have been translated away. Raises an error if there is no matching clause.Andreas, 2010-09-21: This looks like a SUPER UGLY HACK to me. You are walking through the WHOLE signature to find an information you have thrown away earlier. (shutter with disgust). This code fails for record rhs because they have been eta-expanded, so the MVar is gone.(&SParse variables (visible or hidden), returning their de Bruijn indices. Used in ('.('&Entry point for case splitting tactic.()*Make a clause with a question mark as rhs.($(%(&('((()(*($(%(&('((()(*($(%(&('((()(*($(%(&('((()(*!Safe 9;<=?AOT(WAgsy's meta variables.aE the type of the metavariable (what it can be instantiated with). blk= the search control information (e.g. the scope of the meta).(Y~Maybe an instantiation (refinement). It is usually shallow, i.e., just one construct(or) with arguments again being metas.(ZRDoes this meta block a principal constraint (i.e., a type-checking constraint).([:List of observers, i.e., constraints blocked by this meta.(\4Used for experiments with independence of subproofs.(] Experimental.(bResult of type-checking.(cSuccess.(dDefinite failure.(e Experimental.(f$Parallel conjunction of constraints.(gExperimental, related to (\. First arg is sidecondition.(hlForking proof on something that is not part of the term language. E.g. whether a term will reduce or not.(i Obsolete.l(+(,(-(.(/(0(1(2(3(4(5(6(7(8(9(:(;(<(=(>(?(@(A(B(C(D(E(F(G(H(I(J(K(L(M(N(O(P(Q(R(S(T(U(V(W(X(Y(Z([(\(](^(_(`(a(b(c(d(e(f(g(h(i(j(k(l(m(n(o(p(q(r(s(t(u(v(w(x(y(z({(|(}(~((((((((((((((((((((((((g(+(,(-(.(/(0(1(2(3(4(5(6(7(:(9(8(;(<(>(=(?(@(A(B(C(D(E(F(G(H(I(J(K(L(M(N(O(P(Q(R(S(T(U(V(W(X(Y(Z([(\(](^(_(`(a(b(d(c(e(f(g(h(i(j(k(l(m(n(o(p(q(r(s(t(u(v(w(x(y(z({(|(}(~(((((((((((((((((((l(n(l(m((j(k(b(c(d(e(f(g(h(i(`(a(_(^(W(X(Y(Z([(\(](o((p(q(Q(R(S(T(U(V(K(L(M(N(O(P(r(s(H(I(J((F(G(E(t(u(v(w(x(D(B(C(@(A(y(z({(?(<(=(>(;(7(8(9(:(3(4(5(6(0(1(2(|(}(~((((((((((/(.((((((((((+(,(-(((A(+(,(-(.(/(0(1(2(3(4(5(6(7(8(9(:(;(<(=(>(?(@(A(B(C(D(E(F(G(H(I(J(K(L(M(N(O(P(Q(R(S(T(U(V(W(X(Y(Z([(\(](^(_(`(a(b(c(d(e(f(g(h(i(j(k(l(m(n(o(p(q(r(s(t(u(v(w(x(y(z({(|(}(~(((((((((((((((((((((((("SafeAT&("Entry of an explicit substitution.&An explicit substitution is a list of CAction<s. This is isomorphic to the usual presentation where Skip and Weak& would be constructors of exp. substs.(Instantation of variable.('For going under a binder, often called Lift.(2Shifting substitution (going to a larger context).(An expression a in an explicit substitution  [CAction a].(BLazy concatenation of argument lists under explicit substitutions.(Head-normal form of (. First entry is exposed.,Q: Why are there no projection eliminations?(No more eliminations.(Application and tail.( proj pre args, projfcn idx, tail(Constructor parameter (missing in Agda). Agsy has monomorphic constructors. Inserted to cover glitch of polymorphic constructor applications coming from Agda(>"Maybe expression": Expression or reference to meta variable.(Agsy's internal syntax.(Lambda with hiding information.(True8 if possibly dependent (var not known to not occur). False if non-dependent.(&Absurd lambda with hiding information.(Unique identifier of the head.('This application has been type-checked.(Head.( Arguments.("Head of application (elimination).( Dot pattern.(Constant definitions.(Constant signatures.(For debug printing.(Reference to the Agda constant.(Type of constant.(Constant definition.(7Free vars of the module where the constant is defined..(Abstraction with maybe a name.NDifferent from Agda, where there is also info whether function is constant.(Hiding in Agda.(The concrete instance of the blk parameter in (W8. I.e., the information passed to the search control.([Nat - deffreevars (to make cost of using module parameters correspond to that of hints).(1Size of typing context in which meta was created.(!Head normal form of type of meta.(True if iota steps performed when normalising target type (used to put cost when traversing a definition by construction instantiation).) ;Unique identifiers for variable occurrences in unification.)Substituting for a variable.((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((()))))))))) ) ) ) ) ))))))))))))((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((()))))))))) ) ) ) ) ))))))))))))) )))(())))))((((((((((((((((((((((((((((((((((() ((((((((((((((((((((((((((((((((((((() ((((((((((((((((((((((((((((((() ) ))))))))))))0(((((((((((((((((((((((((((((((( ((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((()))))))))) ) ) ) ) ))))))))))))#Safe9;<==)))) )!)")#)$)%)&)')()))*)+),)-).)/)0)1)2)3)4)5)6)7)8)9):);)<)=)>)?)@)A)B)C)D)E)F)G)H)I)J)K)L)M)N)O)P)Q)R)S)T)U)V)W)X)Y4)))) )!)")#)$)%)&)')()))*)+),)-).)/)0)1)2)3)4)5)6)7)8)9):);)<)=)>)?)@)A)B)C)D)E)F)G)H)I)J)K)L)M)N)O)P=)Y)))) )!)")#)$)%)&)')()))X)*)W)V)+),)-).)/)0)1)2)3)4)5)6)7)8)9):);)<)=)>)?)@)A)B)C)D)E)F)G)L)H)I)J)K)M)N)O)P)U)T)S)R)Q4) ))) )!)")#)$)%)&)')()))*)+),)-).)/)0)1)2)3)4)5)6)7)8)9):);)<)=)>)?)@)A)B)C)D)E)F)G)H)I)J)K)L)M)N)O)P)Q)R)S)T)U)V)W)X)Y$Safe:AT)h)Typechecker drives the solution of metas.-)Z)[)\)])^)_)`)a)b)c)d)e)f)g)h)i)j)k)l)m)n)o)p)q)r)s)t)u)v)w)x)y)z){)|)})~))))))))-)Z)[)\)])^)_)`)a)b)c)d)e)f)g)h)i)j)k)l)m)n)o)p)q)r)s)t)u)v)w)x)y)z){)|)})~))))))))-)h)i)j)k)l)m)n)o)p)g)q)r)s)t)u)v)w)d)e)f)x)y)z){)a)b)c)|)})~)^)_)`)Z)[)\)]))))))))$)Z)[)\)])^)_)`)a)b)c)d)e)f)g)h)i)j)k)l)m)n)o)p)q)r)s)t)u)v)w)x)y)z){)|)})~))))))))%SafeOT+)))))))))))))))))))))))))))))))))))))))))))+)))))))))))))))))))))))))))))))))))))))))))+)))))))))))))))))))))))))))))))))))))))))))$)))))))))))))))))))))))))))))))))))))))))))&None:4))))))))))))))))))))))))))))))))))))))))))))))))))))4))))))))))))))))))))))))))))))))))))))))))))))))))))4))))))))))))))))))))))))))))))))))))))))))))))))))))-))))))))))))))))))))))))))))))))))))))))))))))))))))'None:L)#Entry point for Auto tactic (Agsy). "auto ii rng s = return (res, mmsg)If mmsg = Just msg, the message msg5 produced by Agsy should be displayed to the user. The result res6 of the Auto tactic can be one of the following three:  Left [(ii,s)] A list of solutions s for interaction ids ii. In particular, Left [] means Agsy found no solution.Right (Left cs)7 A list of clauses (the user allowed case-split).Right (Right s)+ A refinement for the interaction id ii in which Auto was invoked.6666666666)6666)) 6666666666)6666None 2349;<=LOT;Print open metas nicely.)Available backends.)The ) monad. 6! state holds the remaining input.)cmd_load m argv loads the module in file m , using argv as the command-line options.)cmd_compile b m argv compiles the module in file m using the backend b, using argv as the command-line options.)aShow unsolved metas. If there are no unsolved metas but unsolved constraints show those instead.)eShows all the top-level names in the given module, along with their types. Uses the top-level scope.)^Shows all the top-level names in scope which mention all the given identifiers in their type.)nParse the given expression (as if it were defined at the top-level of the current module) and infer its type.){Parse and type check the given expression (as if it were defined at the top-level of the current module) and normalise it.)!cmd_load_highlighting_info source: loads syntax highlighting information for the module in source<, and asks Emacs to apply highlighting info from this file.If the module does not exist, or its module name is malformed or cannot be determined, or the module has not already been visited, or the cached info is out of date, then no highlighting information is printed.RThis command is used to load syntax highlighting information when a new file is opened, and it would probably be annoying if jumping to the definition of an identifier reset the proof state, so this command tries not to do that. One result of this is that the command uses the current include directories, whatever they happen to be.*lTells Agda to compute highlighting information for the expression just spliced into an interaction point.*5Tells Agda whether or not to show implicit arguments.*%Toggle display of implicit arguments.* Goal commandsIf the range is B, then the string comes from the minibuffer rather than the goal.* &Displays the current goal and context.* &Displays the current goal and context and# infers the type of an expression.*mShows all the top-level names in the given module, along with their types. Uses the scope of the given goal.*$Displays version of the running Agda*An interactive computation.*4Monad for computing answers to interactive commands.* is F extended with state *.*.Auxiliary state of an interactive computation.*The interaction points of the buffer, in the order in which they appear in the buffer. The interaction points are recorded in  theTCState, but when new interaction points are added by give or refine Agda does not ensure that the ranges of later interaction points are updated.*The file which the state applies to. Only stored if the module was successfully type checked (potentially with warnings). The E is the modification time stamp of the file when it was last loaded.**Reset the options on each reload to these.*We remember (the scope of) old interaction points to make it possible to parse and compute highlighting information for the expression that it got replaced by.*#Initial auxiliary interaction state*Build an opposite action to 6 for state monads.* Opposite of 6 for *1. Use only if main errors are already catched.* ?Lift a TCM action transformer to a CommandM action transformer.*!1Put a response by the callback function given by b.*" A Lens for *.*# A Lens for *.*'*Do setup and error handling for a command.*)Run an )) value, catch the exceptions, emit output!If an error happens the state of *p does not change, but stPersistent may change (which contains successfully loaded interfaces for example).**Converter from the type of 6 to )O The first paramter is part of the error message in case the parse fails.*,Demand an exact string.*/TCan the command run even if the relevant file has not been loaded into the state?*0Interpret an interaction*1"cmd_load' file argv unsolvedOk cmd loads the module in file file , using argv as the command-line options.\If type checking completes without any exceptions having been encountered then the command cmd r is executed, where r is the result of '<.*2Set  to * , if any.*3)A "give"-like action (give, refine, etc).$give_gen ii rng s give_ref mk_newtxt acts on interaction point ii occupying range rng-, placing the new content given by string s, and replacing ii9 by the newly created interaction points in the state.*5/Sorts interaction points based on their ranges.*6,Pretty-prints the type of the meta-variable.*75Pretty-prints the context of the given meta-variable.*8LCreate type of application of new helper function that would solve the goal.*9HDisplays the current goal, the given document, and the current context.*:KShows all the top-level names in the given module, along with their types.*;^Shows all the top-level names in scope which mention all the given identifiers in their type.*<"Explain why something is in scope.*=ASets the command line options and updates the status information.*>!Computes some status information.*?$Displays/updates status information.*@ display_info does what  display_info' False? does, but additionally displays some status information (see *> and *?).*C-Kill meta numbers and ranges from all metas (? and _).*DParses and scope checks an expression (using the "inside scope" as the scope), performs the given command with the expression as input, and displays the result.*FLTell to highlight the code using the given highlighting info (unless it is Nothing).*G@Tells the Emacs mode to go to the first error position (if any).*KtNote that the grammar implemented by this instance does not necessarily match the current representation of ranges.f))))))))))))))))))))))))********** * * * * *****************runlift(reverse lift in double negative position** *!*"*#*$*%*&*'*(*)***+*,*-*.*/*0*1Allow unsolved meta-variables?*2*3*4*5*6*7 Normalise?$Print the elements in reverse order?*8*9*:*;*<*=*>*?*@*A*B*C*DThe command to perform.5The name to use for the buffer displaying the output.The expression to parse.*E*F*G*H*I*J*K*La))))))))))))))))))))))))********** * * * * ******************* *!*"*#*$*%*&*'*(*)***+*,*-*.*/*0*1*2*3*4*5*6*7*8*9*:*;*<*=*>*?*@*A*B*C*D*E*F*Gf************ *!*"*#*$*%*&*'*(*)*)))))))))))********** * * * * ******))))***+*,*-*.*L*K*J*I*H*/*0*1*2)))))))))*3*4*5*6*7*8*9*:*;*<*=*>*?*@*A*B*C*D*E*F*G;))))))))))))))))))))))))********** * * * * ******************* *!*"*#*$*%*&*'*(*)***+*,*-*.*/*0*1*2*3*4*5*6*7*8*9*:*;*<*=*>*?*@*A*B*C*D*E*F*G*H*I*J*K*L(None9;*Y*YP is a fake ghci interpreter for the Emacs frontend and for interaction tests.*Yc reads the Emacs frontend commands from stdin, interprets them and print the result into stdout.6FConvert Response to an elisp value for the interactive emacs frontend.6 Adds a "last" tag to a response.6;Show an iteraction point identifier as an elisp expression.*Y666*Y*Y*Y666)None*ZThe main function*[JRun Agda with parsed command line options and with a custom HTML generator*\Print usage information.*]Print version information.*^What to do for bad options.*_6Run a TCM action in IO; catch and pretty print errors.*`Main*Z*[HTML generating action program nameparsed command line options*\*]*^*_*`*Z*[*\*]*^*_*`*Z*[*\*]*^*_*`*Z*[*\*]*^*_*`6WXYW5ZW[\WX]WX^WX_WX`WXabcdbcebcfbcgbchbcibcjbckbclbcmbcnbcobcpqrsqrtqruqvwxyzxy{xy|}~  m                                                         !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqqrstuvwxyz{|}~E/E   !!!!!""" " " " " """"""""E###E$$$$$$$$$$ $!$"$#$$$%$&$'$($)$*$+$,$-$.$/%0%0%1%2%3%4%n%m%5%j%d%f%6%7%8%9%:%E&;&;&<&p&L&=&o&>&U&n&m&j&k&5&d&?&f&@&A&B&C&D&E&F&G&H&I&J&K&L&M&N&O&P&Q&R&S&T&U&V&E'W'X'Y'Z'[''\']'^'_'`'a'b'c'd'e'f'g'h'i'j'k'l'm'n'o' 'p'q'r's't'u'v'w'x'y'z'{'|'}'~'''''''''''''''''''''''''''EM((G((((c(d((((()))))))))))))**************++n+p+4+++++++++++++++++++,,,,,,,,,f,,,,,5,j,d,,,,,,,,,,,,,,E------------- - - - - - ------3--------d--f---n-m-5----j- -k-!-"-#-$-~-%-&-'-(-)-*-+-,---.-/-0-1-2-3-4-5-6-7-8-9-:-;-<-=.>.?.8.9.:.;............@.A.B.C.D.E.F..G.H/I/I/J/K/L/L/M/N/O/P/Q/R/S/T/U/V/W0X0m0Y0j0 0500l0Z0f0B030o0[0\0]0^0_0`0a0b0c0d0e0f0g0h0E1i1j1k1l1m11n1n1o1p1q1r1s1t1u1v1w1x1y1z1{1|1}1~1112232@2522m222>333333333333334444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444455555555555555555555555 5 5 5 5 5555555 5555555555555555 5!5"5#5$5%5&5'5(5)5*5+5,5-5.5/505152535455565758595:5;5<5=5>5?5@5A5B5C5D5E5F5G5H5I5J5K5L5M5N5O5P5Q5R5S5T5U5V5W5X5Y5Z5[5\5]5^5_5`5a5b5c5d5e5f6g6h6i6j6k6l6m6n6o6p6q6r6s6t6u6v6w6x6y6z6{6|6}6~666666666E77777777777777E7788888L88888888888888888888888888E8888888888888888888888888999999::::::::::::::::::::E::::::::::;;;;;;;;;;;;;;;;5;j;f;;E;;;;;;;;;;;;;;;;;;;;;; ; ; ; ; ;;;;<<<<<<<<<<f<d<j<5<1<<E<<<<<<<= =!="==E>#>$>%>&>'>(>)>*>*>+>,>->.>/>.>0>1>2>3>4>5>6>7>8>9>:>;><>=>>>?>@>A>B>C>D>E>F>G>H>I>J>K>L>M>N>O>P>Q>R>S>T>U>V>W>X>Y>Z>[>\>]>^>_>`>a>b>c>d>e>f>g>h>i>j>k>l>m>n>o>p>q>r>s>t>u>v>w>x>y>z>{>|>}>~>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>E??????????????????????E@@@@@@@@@EAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBBECCCCCCC C C C C C CCCCCCCCCCCCCCCCCCCCGC C!C"C#C$C%C&C'C(C)C*C+C,C-C.C/C0C1C2C3C4C5C6CCCC7C8C9C:D;D<D=D>D?D@D@DADBDCDDDEDFDGDHDIDJDKDLDMENEOEPEEQERESETEUEVEWEXEYEZF[F\G]G^G^G_G`GaGbGcGdGeGfGgGhGiGjGkGlGmGnGoGpGqGrGsGtGuGuGvGwGxGyGzG{G|G}G~G~GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG G G G G GGGGGGGGGGGGGGGGGGG G!G"G#G$G%G&G'G(G)G*G+G,G-G.G/G0G1G2G3G4G5G6G7G8G9G:G;G<G=G>G?G@GAGBGCGDGEGFGGGHGIGJGKGLGMGNGOGPGQGRGSGTGUGVGWGXGYGZG[G\G]G^G_G`GaGbGcGdGeGfGgGhGiGjGkGlGmGnGoGpGqGrGsGtGuGvGwGxGyGzG{G|G}G~GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGHHHHHHHHDHHDHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHIIIIIIIJJJ J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J K KK K !KK "K "KK #K $K %K K K &K 'K (K )K K *KK +K ,K -KKK .KK /K 0KKKK K 1K 2K 3KK 4K 5K 6K 7K 8K 9K :K ;K <K"K =K >K ?K @K AK BK CK DK EKKK FK GK HK IK JK KK LKEK MK NK OKOK PKbKcKdKKKKeKfL QL RL SL TL UL VL WL XL YL ZL ZL [L \LDLDL ]L ^LLL _L `L aL bL cL dL eL fL gL hL iL jL kL lL mL nL oLL pL qLL rLL sL tL uL vLLL wL xLLL yL zL {LL |LL }LLL ~LL LL L LL LLL LLLLL LLL LLL L L L L L L L L F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F[F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F 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 N2N NN NHN N NGN N N N N N N N N N N !N N "N #N $N $N %N &NjNdNmNoN 'N 'N (N )N *N +N ,N -N .N /N /N 0N 1N 2N 3N 4N 5N 6N 7N 8N 9N :NCNCN ;N <N =N >N ?N @N AN BN CN DN EN FN GN HN IN JN KN KN LN MN NN ON PN QN RN SN TN UN VN WN XN YN ZN [N \N ]N ^N _N `N aN bNN cN dN eN fN gN hN iN jN kN lN mN nN oN pN qN rN sN tN uN vN wN xN yN zN {N |N }N ~N N N N N N N N N N N N N N N eN 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 N N N N N N N N N N N N O O O O O O O O O O O O O O O O O O O O O O O O O O O O P P P P P P P P P P P P P P P P P P P P P P PP P P P P P P !P "P #P $PGP %P &P 'P (P )P *P +P ,P -P .P /P 0P 1P 2P 3Q 4Q 4Q 5Q 6Q 7Q 8Q 9Q :Q ;Q <Q =Q >Q ?Q @Q AQQ BQ CQ DQ EQ FQ GQ HQ IQ JQ KQ LQ MQ NQ OQ PQ QQ RQ SQ TQ UQ VQ WQ XQ YQ ZQ [Q \Q ]Q ^Q _Q `Q aQ bQ cQ dQ eQ fQ gQ hQ iQ jQ kQ lQ mR nR oR pR qR rR sR tR uR vR wR xR yR zR {R |R }R ~R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S !S "S #S $S %S &S 'S (SST )T *T +U ,U -U .U /U 0U 1U 2U 3U 4U 5U 6U 7U 8U 9UU :V ;V <V =V >V ?W @W AX BX CX DX EX FX GX HX IX JX KX LX MX NX OX PU QU RT ST TY UY VY WY XY YYEY ZY [Y \ZZGZ ]Z Z ^Z XZ YZ VZ WZ U[ _[ [ [ `[ a[ [ [ [ [ b[ P[ c[ \[ d[ ][ Z[ e[ f[ g[ h[ i[ j[ k[ l[ m[ n[ o[ i[ p[ m[ f[ a[ q[ r[ r[ s[ t[ u[ v[ w[ x[ y[ z[ k[ [ {[ |[ }\ ~\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ C\ \ \ \ \ \ w\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ ] ] ] ] ] ] ] ] ^ ^ ^ ^ _ _ _ _ _ ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` !` "` #` $` %` &` '` (` )` *` +` ,` -` .` /` 0`E` 1` 2` 3a 4a 4a+a+a 5a 6aAa 7a 8ana 9a :a ;a <a =aEa >a ?a @a Aa Ba Ca Da Eb Fb Fb Gb Hb Ib Jb Jb Kb Lb Mb Nb Obb Pb Qb Rb Sb Tb Ub Vbb Wb Xb b Yb b b bb Zb b [b \b b ]b ^b b _bbmb `b ab bb cb db eb fb gb hb ib jb kbEb lb mb nb ob pb qb rb sb tb ub vb wb xb yb zb {b |b }b ~b b b b b b b b b c c c c c c c c c c c c c c c c c c c c c c c c c c c c c Yc c c c c c c c c c c c c c c d d e e e ewe e e e e e e e f g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g gggggggggg g g g h hhhhhhhiiiiiiiiiiiii j!k"k#k$k%k k k&k'k(k(k)k*k+k+k,k,k-k-k.k/k0k1k2k ]k3k3k4k5k6k vk7k8k9k:kk;k<k=k>k?k@kAkBkCkDkEkFkGkHkIkJkKkLkMkNkOlClPlQlRllSlTlUlVl3lWlXlYlZl[ljl\l]m^m_mmm`mambmcmdmem'mfmgmhmimjmkmlm dnn 0nmnnnnonpnqnrnsntnunvnwnxnynzn{n|n}n]n~nnnnnnnnnnnnGoooooooooooo 9oooUoooooooooptpnppp pppppppppppp pppppp Wp fppppppppppppppppppqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq -q -qqqqqqqqqqqqqqq q q q q qqqqqqqqqqqqqqqqqqq q!q"q#q$q%q&q'q(q)q*q+q,q-q.q/q0q1q2q3q4q5q6q7q8q9q:q;q<q=q>q?q@qAqBqCqDqEqFqGqHqIqJqKqLqMqNqOqPqQqRqSqTqUqVqWqXqYqZq[q\q]q^q_q`rararbrcrdrerfrgrhrhrirjrkrlrlrmrnrororprqrrrsrtrurvrwrxrxryrzr{r|r}r~rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrssstttt Ptt dt ctt Yt [t \t Zt ]tt ^tttt 0tt 1t 2t 3t 4t 5t 6t 7t 8tCtCtttttttttt /t /t .tttt tt ttttt @t Dt Bt Ct Kt Kt Ot Mt Nt t Wt #ttttttt t t tt t t t t t t t t t t t t t t t t tjtdtottt t t t t tt vt t t t t t tt tt t !ttt t tttttt _t lt ntt mt t t at btt dt ft it jt kt mt lt nt ot st xt qt rtt yt zt {t |t ~t }t t wtttttttttttt ttt t t ttttttttt ttt t ttttttt t t t t ttttttttttttttttttt mt Qt t!t"t#t$t%t&t lt't(t)t*t+t,t Lt-t.t/t ft0t1t2t3t4t5t6t7t8t9t:t;t<t=t>t?t@tAtBtCtDtEtFtGtHt tItJtKtLtMtNtOtPtQtRtStTtUtVtWtXtYtZt[t\t]t^t_t`tatbtctdtetftgthtitju uku u u u ulu umunuoupuqurusu utuuu uvu uwuxuyuzu{u|u}u u~u u uu u u u u vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv Pvv dv \v cv ]v evvvvvvv v vvvvvvvvvvvvvvvvvvvvvvvvvvvvvv fv jv ovvvv @vvvvvvv jvvvvv rv rvvvvv sv tv uv vvv kv lv iv av nv mv mv fvvv vvvvvvvvvvvv wvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv v v v v vvvvvvvvvvvvvvvvvvvv v!v"v#v$v%v&v'v(v)v zv*v+v,v-v.v/v0v1v2v3v4v v5v6v7v8v9v:v;v<v=v>v?v@vAvBvCv yvDvEvFvGvHvIvJvKvLvMvNv {vOvPvQv |vRvSvTvUvVvWvXvYvZv[v\v]v^vvvvv v_v`vavbvcvdvevfvgvhvivjvkvlvmvnvovpvqvrvswtwtwuwvwwwxwywzw{w|w}w}w~wwwwwwwwwwwww lwwwwwwwwwwiw?whwwwxxxxxxxxxx _x lx ax ix mx dxx8x sx7xxx axxxxx lx lxxxxxxxxxx \xxxxxxxxxxxxxxxx mxx xxxyyyyyyyyyyyyyyyyyyyyyyyyyyyyzzzzzzzzzzzzzzzzzzzzzzzzzz{{{{{{{{B{{{{{{{{{{{{{||||||||| | | | || | ||||||||||||||||||||| |!}"}#}$}$}%}&}'}(})}*}+},}-}.}/}0}1}2}U}T}3}4}5} 8}6}S}7}8}9}:};}<}=}>}?}@~A~A~B~B~C~D~E~F~G~H~I~J~K~L~M~N~O~P~Q~R~S~T~U~VWXYZ[\\]^_`abcdefgghijklmnopqrstuvwxyz{|}~bcdenmlknmlkIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII I I I I IIIIIIIIIIIIIIIIIII I!I"I#I$I%I&I'I(I)I*I+I,I-I.I/I0I1I2I3I4I5I6I7I8I9I:I;I<I=I>I?I@IAIBICIDIEIFIGIHIIIJIKILIMINIOIPIQIRISITIUIVIWIXIYIZI[I\I]I^I_I`IaIbIcIdIeIfIgIhIiIjI0IkIlImInIoIpIqIrIsItItIuIvIwIwIxIyIzI{I|I}I~IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII&IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII I I I I I II I YI XII WI IIIIIIIIIIIIIIIIIII I!I"I#I$I%I&I'I(I)I*I+I,I-I.I/I0I1I2I3I4I5I6I7I8I9I:I;I<I=I>I?I?I@IAIBICIDIEIEIFIGIHIIIJIKILIMINIIOIPIQIRISITIUIVIWIXIYIZI[I\I]I^I_I _II`IaIbIcIdIeIfIgIsIhIiIjIjIkIlImInIoIpIqIrIsItIuIvIwIxIyIzI{I|I}I~IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII IIIIIIIIIIIIIIIIIIIIIIII IIIIIIIIIIIIIIIIIIIIIIIIIII *IIIIIIIIIIIIIIIIIIIIIIIIIxIxIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII I I I I IIIIIIIIIIIIIIIIIIII I!I"I#I$I%I&I'I(I)I*I+I,I-I.I/I0I1I2I3I4I5II6I7I8I9I:I;I<I=I>I?I@IAIBICIDIEIFIGIHIIIJIKILIMINIOIPIQIRISITIUIVIWIXIYIZI[I\I]I^I_I`IaIbIcIdIeIfIgIhIiIjIkIlImInIoIpIqIrIsItIuIvIwIxIyIzI{I|I}I~IIIIIIIIIIIwIIrIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII I I I III IIIIIIIIIIIIIIIIIII I!I"I#I$I%I&I'I(I)I*I+I,I-I.I/I0I1I2I3I4I5I6I7I8I9I:I;I<I=I }I>I?I@IAIBICIDIEIFIGIHIII OIJIKILIMINIOIPIQIRISITIUIVIWXYZ[[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ =y      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZZ[\]^_`abcGd vVefghijklmnopqrst@uvwxyz{|}~       !"#$%&'()*+,-./0123456789R:;<<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWWXYYZ[\]]^__`aabcdefghijkklmnnopqqrsttuvwxyz{|}~E      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYjmZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~~vy]      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPPQRSTUVW2XYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~E N 2UE'()    J8  d !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~a      !"#$%'U&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTU;VWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ 6      !"#$%&'()*+,-./01234556789:;<=>?@ABCCDEFGHIJKLMNOPQRST CU =VWXYZ[\]^_`abKcdefghijklmnopqrstuvwxyz{|}~V@'U                            ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5Q 6 7 8 9 : ; < = > ? @ A B C() D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n n o p q r s t u v w x y z { | } ~                       !!!!!!!!!! ! ! ! ! !!!!!!!!!!!!!!!!!!! !!!"!#!$!%!&!'!(!)!*!+!,n!-!.!/!0!1!2!3!4!5!6!7!8!9!:!;!<!=!>!?!@!A!B!C!D!E!F!G!H!I!J!K!L!M!N!O!P!Q!R!S!T!U!V!W!X!Y!Z![!\!]!^!_!`!a!b!c!d!e!f!g!h!i!j!k!k!l!m!n!o!p!q!r!s!t!u!v!w!x!y!z!{!|!}!~!!!!!!!!!! q! !!!!!!!!!!!!!56!!!!!!!!O!!!!!!!!!!!!!!!!!!!!!!!!ef:;=!E!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"""""""""" " " " " """"""""""""""""""" "!"""#"$"$"%"&"'"(")"*"+","-"."/"0"1"2"3"4"5"6"7"8"9":";"<"=">"?"@"A"B"C"D"E"F"G"H"I"J"K"L"M"N"O"P"Q"R"S"T"U"V"W"X"Y"Z"["\"]"^"_"`"a"b"c"d"eE"f l"g"h"i"j"k"l"m"n"o"p"q"r"r"s"t"u"v"w"x"y"z"{"|"}"~""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""########## # # # # ################### #!#"###$#%#&#'#(#)#*#+#+#,#-#.#/#0#1#2#3#4#5#6#7#8#9#:#;#<#=#>#?#@#A#B#C#D#E#F#G#H#I#J#K#L#M#N#O#P#Q#R#S#T#U#V#W#X#Y#Z#[#\#]#^#_#`#a#b#b#c#d#e#f#g#h#i#j#k#l#m#n#o#p#q#r#s#t#t#u#v#w#x#y#z#{#|#}#~### # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # ! ! # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # E # # #   ~ # # # # # # # # # # # # # # # # # # # # # # S # # # # # # # # # # # # # # # # # # # # # # # # # # # # # ###$$$$$$$$$$ $ $ $ $ $$$$$$$$$$$$$$$$$$$ $!$"$#$$$%$&$'$($)$*$+ $, $-$.$/$0$1$2$3$4$5$6$7$8$9$:$;$<$=$>$?$@$A$B$C$D$E$F$G$H$I$J$K$L$M$N$O$P$Q$R$S$T$U$V$W$X$Y$Y$Z$[$\$\$]$^$_$`$`$a$b$c$d$d$e$f$g$h$i $j$k$l$m$n$o$p$q$r$s$t$u$v$w$x$y$z${$|$}$~$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ $U$$$$$$$$$$$$$$$$$$$$$$$$$$E$$$$$$$$$$$$$$$$$$$J$$$$$$%%%%%% %#%%% % % % % %%%%%%%%%%%%%%%%%%%% %!%"%#%$%$%%%&%'%(%)%*%+%,%-%.%/%0%1 %2%3%4%5%6%7%8%9%:%;%<%=%>%?%@%A%B%C%D%E%F%G%H%I%J%K%L%M%N%O%P%Q%R%S%T%U%V%W%X%Y%Z%[%\%]%^%_%`%a%b%cE%d%e%f%f%g%h%i%j%k%l%m%n%o%p%q%r%s%t%u%v%w%x%y%z%{%|%}%~%%%%%%%%%%%%%%%%%%%%%%%%%%%r%%%%%%%%%%%%%%%%#x%%%%%%%%%%%%*%%%%%%%% [ /%%%.%%%%%%%%%%#x%v%%%%%%%%%%%% /% @%%%%%%%%%%%%%%%%% % % % % % % %!%!%!%!%!%!%!%!%!%!%!%!%!%!%!!%!%!%!%! o!%!%!%!%!%!%!%!%!%!%!%!%!%!%!&!&!&!&!&!&!&!&!&!&!& !& !& !& !& !& !&!&!&!&!&! o!&!!&!&!&!&!&! k! k!&!&!&!&!!&!&!&!&!& !&!!&"!&#!&$!&%!&&!&'!&(!&)!&*!&+!&,!&-!&.!&/!&0!&1!&2!&3!&4!&5!&6!&7!&8!&9!&:!&;!&<!&=!&>!&?!&@!&A"&B""&C""&D"&E"&F"&F"&G"&H"&H"&I"&J"&K"&L"&M"&N"&O"&P"&Q"&R"&S"&T"&U"&V"&W"&X"&Y"&Z"&["&\"." d" i" m" f"&]"&^"&_"&`"&a" f" n"&b" j"&c" l""&d"&e"&f"&g"&h" "&i" n" X" W" "&j"&j"&k"&l"&m"&n"&o" r" r"&p""&q"&r"""""&s"&t"&u"&v"&w"&x"&y"&z"&{"&|"&}"&~"&"&"&"&"&"&"&"&"&"&"&"&"&"&"&"&"&"&"&"&"&"&"&"&"&"&"&"&""&"&"&"&"&"&"&"&"&"&"&"&"&"&"&"&"&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&#&$&$&$&$&$&$&$&$&$&$&$&$&$&$&$&$&$&$&$&$&$&$&$&$&$&$&$'$'$'$'$'$'$'$'$'$' $' $' $' $' $'$'$'$'$'%'%'%'%'%'%'%'%'%'%'%'%'%'%'%' %'!%'"%'#%'$%'%%'&%''%'(%')%'*%'+%',%'-%'.%'/%'0%'1%'2%'3%'4%'5%'6%'7%'8%'9%':%';%'<&'=&&&'>&'?&'@&'A&'B&'C&'D&'E&&'F&'G&'H&'I&'J&'K&'L&'M&'N&'O&'P&'Q&'R&'S&'T&'U&'V&'W&'X&'Y&'Z&'[&'\&']&'^&'_&'`&'a&'b&'c&'d&'e&'f&'g&'h&'i&&'j&'k&'l&'m''n'o'p'q'r's't'u'v'w'x'y'z'z'{'|'}'~'''''''''''''''''''''''''''''''''''''''' ''''''''''''''''$'''''''''E''''''''''''''''''''''''''''(')')')')')')')'*'*}*'*'*'*'*'*'*'*'*'*'*'WX'''''''WX DWX'''''''''''''''''''''('(('(('(('(('(('(('(('(( '(( '( w'( w'(( '(( '(( '(('(('("'(('(('(('(('(('(('(('(('(('(('(('(('(('(('(('(( '(L'((!'(K'(("'((#'(($'((%'((&'((''((('(()'( '('((*'((+'((,'((-'((.'((/'((0'((1'((2'((3'((4'((5'((6'((7'((8'((8'(9(:'(9(:'(9(;'(9(<'(9(<'(9(='(9(>'(9(?'(9(@'(9(A'(9(B'(9(C'(9(D'(9(D'(9(E'(9(F'(9(F'(9(G'(9(H'(9(H'(9(I'(9(J'(9(J'(9(K'(9'(9'(9(L'(9(M'(9(M'(9(N'(9(O'(9(O'(9(P'(9(P'(9(Q'(9(R'(9(S'(T(U'(T(V'(T(W'(T(X'(T(Y'(T(Z'(T(['(T(\'(T(]'(T(^'(T(_'(T(`'(T(a'(T(b'(T(c'(T(d'(T(e'(T(f'(T(g'(T(h'(T(i'(T(j'(T(k'(T(l'(T(m'(T(n'(T(o'(T(p'(T(q'(r(s'(t(u'(t(v'(t(w'(t(x'(t(y'(t(z'(t({'(t(|'(t(}'(t(~'(t('(t('(t('(t('(t('(t&<'(t('(t('(t('(t('(t(W((W(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((O((((((((  ( ( ( \''('((WX(((y((("((( -1(W08W((W0;W0(W01W0:W09W0(W0(W0(((df(((W((W((W((W((W((W((W((W((W((W((((((((d((((((((;(((((C((((((( (((((((Z((((5((m((f((A((@((((((((((((((((((((h((i(((((k((j((l((=(((((3((o((L((p((n(((W.+'((W(((((((((   l  ( (W((W((W((W(("(#(#(#)#)#)#)##)#)#)#)#)#) #) #) #) W() W()'')W))'()WX)W))'()W))W))W()()(()()((()()()()W)) WX)!b)")#--)$-)%-)&b)'W)())-)*)+),()+), D)+),')+),()+),1)+),()+),()+),(0)-0).0).0)/0)/000X0)00)10)20 I0)3W(3W)4)5'')6'')7)8)937):7);7)<8)=8)>8)?8)@8)A8)BW)C)DW)C)E8)F8)G8)H8)I8)J8)K8)L8)M8)N8)O8)P8)Q8)R8)S8)T8)U8)V8)W8)X88)Y8)Z8)[8)\8)]8)^8)_8)`8)a8)b8)c: q'()d:)e:)f:)g:)h:)i:)j:)k:)l:)mWX)n<)o<)p<)q<)r<)s=)t=)u=)v=)w=)x=)y=)z=){=)|=)}=)~=)=)=)=)=)=)=)=)>)>)>)>)>)>)>)>)>)>)>)>)>+>)>)>)>)>)>)>)>)>)>)>)>)>)>)>)>)>)>)>)>)>)>)>)W)C)W)C)'()W)C)WXC?)?)?)?)?)?)?)?)?)?)?)?)@)@)@)@)@)@)@)@)@)@)@)@)@)@)@)@)@)@)@)@)@)@)@)@)@)@)@)@)@)@)@)@)@)B)B)B)B)B)B)B)B)B)B)B B)B)B)B)C(C)C)C)C)CC)E)E)EtENE)N)N)N)W.6R)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^RmR*R*R*R*R*W*W*W*W*W*W*W*W*W* X*!X*"W*#*$X*%X*&X*'X*&X*(X*%X*)X**X*+X**X*,X*-X*.X*/X*0X*1X*2X*3X*4X*5X*6X*7X*8X*9X*:X*;X*<X*=X*>X*?X*@X*AX*BX*CX*DX*EX*FX*GX*HX*IX*JX*KX*LX*MX*NX*OX*PX*QX*RX*SX*TX*UX*VX*WX*XX*YX*ZX*[X*\X*]X*^X*_X*`X*aX*bX*cX*dX*eX*fX*gX*hX*iX*jX*kX*lX*mX*nX*oX*pX*qX*rX*sX*tX*uX*vX*wX*xX*yX*zX*{X*|X*}X*~X*X*X*X*X*X*X*X*X*X*X*X*X*X*X*X*X*X*X*X*X*X*X*X*X*X*X*X*X*X*X*X*X*X*X*X*X*X*X*X*X*X*X*X*X*X*X*X*X*X*X*X*U*U*U*U*U*U*T*Y*Y*Y*Y RY*Y*Y*Y*Y*Y*Y*Y*Y*Y*Y*Y*Y*Y*Y*Y*Y*Y*Y*Y*Y*YY WY*Y*Y*Y*Y*Y*Y*Y*Y*Y*Y*Y*Y*Y*Y*Y*Y*Y*Y*Y*Y*Y*Y*Y*Y*Y*Y*Y*Y*Y*Y*Y*Y*Y*Y*Y*Y*Y*Y*Y*Y*Y*Y*Y*Y*Y*Y*Y*Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+ Y+ Y+ Y+ Y+ Y+Y+Y+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+0Y+1Y+2Y+3Y+4Y+5Y+6Y+7Y+8Y+9Y+:Y+;Y+<Y+=Y+>Y+?Y+@Y+AY+BY+CY+DY+EY+FY+GY+HY+IY+JY+KY+LY+MY+NY+OY+PY+QY+RY+SY+TY+UY+VY+WY+XY+YY+ZY+[Y+\Y+]Y+^Y+_Y+`Y+aY+bY+cY+dY+eY+fY+gY+hY+iY+jY+kY+lY+mY+nY+oY+pY+qY+rY+sY+tY+uY+vY+wY+xY+yY+zY+{Y+|Y+}Y+~Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y+Y,Y,Y,Y,Y,Y,Y,Y,Y,Y, Y, Y, Y, Y, Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y, Y,!Y,"Y,#Y,$Y,%Y,&Y,'Y,(Y,)Y,*Y,+Y,,Y,-Y,.Y,/Y,0Y,1Y,2Y,3Y,4Y,5Y,6Y,7Y,8Y,9Y,:Y,;Y,<Y,=Y,>Y,?Y,@Y,AY,BY,CY,DY,EY,FY,GY,HY,IY,JY,KY,LY,MY,NY,OY,PY,QY,RY,SY,TY,UY,VY,WY,XY,YY,ZY,[Y,\Y,]Y,^Y,_Y,`Y,aY,bY,cY,dY,eY,fY,gY,hY,iY,jY,kY,lY,mY,nY,oY,pY,qY,rY,sY,tY,uY,vY,wY,xY,yY,zY,{Y,|Y,}Y,~Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y,Y-Y-Y-Y-Y-Y-Y-Y-Y-Y- Y- Y- Y- Y- Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y- Y-!Y-"Y-#Y-$Y-%Y-&Y-'Y-(Y-)Y-*Y-+Y-,Y--Y-.Y-/Y-0Y-1Y-2Y-3Y-4Y-5Y-6Y-7Y-8Y-9Y-:Y-;Y-<Y-=Y->Y-?Y-@Y-AY-BY-CY-DY-EY-FY-GY-HY-IY-JY-KY-LY-MY-NY-OY-PY-QY-RY-SY-TY-UY-VY-WY-XY-YY-ZY-[Y-\Y-]Y-^Y-_Y-`Y-aY-bY-cY-dY-eY-fY-gY-hY-iY-jY-kY-lY-mY-nY-oY-pY-qY-rY-sY-tY-uY-vY-wY-xY-yY-zY-{Y-|Y-}Y-~Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y-Y.Y.Y.Y.Y.Y.Y.Y.Y.Y. Y. Y. Y. Y. Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y. Y.!Y."Y.#Y.$Y.%Y.&Y.'Y.(Y.)Y.*Y.+Y.,Y.-Y..Y./Y.0Y.1Y.2Y.3Y.4Y.5Y.6Y.7Y.8Y.9Y.:Y.;Y.<Y.=Y.>Y.?Y.@Y.AY.BY.CY.DY.EY.FY.GY.HY.IY.JY.KY.LY.MY.NY.OY.PY.QY.RY.SY.TY.UY.VY.WY.XY.YY.ZY.[Y.\Y.]Y.^Y._Y.`Y.aY.bY.cY.dY.eY.fY.gY.hY.iY.jY.kY.lY.mY.nY.oY.pY.qY.rY.sY.tY.uY.vY.wY.xY.yY.zY.{Y.|Y.}Y.~Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/ Y/ Y/ Y/ Y/ Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/ Y/!Y/"Y/#Y/$Y/%Y/&Y/'Y/(Y/)Y/*Y/+Y/,Y/-Y/.Y//Y/0Y/1Y/2Y/3Y/4Y/5Y/6Y/7Y/8Y/9Y/:Y/;Y/<Y/=Y/>Y/?Y/@Y/AY/BY/CY/DY/EY/FY/GY/HY/IY/JY/KY/LY/MY/NY/OY/PY/QY/RY/SY/TY/UY/VY/WY/XY/YY/ZY/[Y/\Y/]Y/^Y/_Y/`Y/aY/bY/cY/dY/eY/fY/gY/hY/iY/jY/kY/lY/mY/nY/oY/pY/qY/rY/sY/tY/uY/vY/wY/xY/yY/zY/{Y/|Y/}Y/~Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Z/Z/ZZ/ZZ/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/`00`01`02`03`04`05`06`07`08`09`0:`0;`0<`0=`0>`0?`0@`0A`0B`0C`0D`0E`0F`0G`0H`0I`0J`0K`0L`0M`0N`0O`0P`0Q`0R`0S`0T`0U`0V`0W`0X`0Y`0Z`0[`0\`0]`0^`0_`0``0a`0b`0c``0da0ea0fb0gb0hb0ib Ib%b0jb0kb0lb0mb0nb0oWX ]e0pg0qg0rg0sh0th0uj(j0vj0vj0wj0xj0yjj0zjj0{j0|j0}j0~j0j0jj0j00000000000000000!5!6x00jl0mtuX00kn000!5!6x00jl0~000000k00W)Cp000000000000000!000000000000000000000000000000000000000'60000000000000000000000000000 00000 0000000000000000000000111111QV11111 1 1 1 1 1111111111111%%111111 /1!%1"1#1$1%1&1'1(1)1*1+1,1-1.1/101112 N131415161718191:1;  1<1=1>1>(1?1@1A1B1C1D1E1F1G1H1I1J1K1L1M1N1O1P(1Q1R1S1T1U1V1W1X1Y1Z1[1\1]1^1_1`1a1b1c1d1e1f1g1h-17Y1i0|1j1k1l1m.1n1o1p1q1r1s1t1u1v1w1x1y1z1{1|1}1~11111111111111111111111111111111111111111111WX1111111)1111111111111W)1b1d1111111111111111111111111111111111111111111111111111111111111111~111112222"222222 2 2 2 2 2222(222222)2222222222 2 2!2"2#2$2%2&2'2(2)2*'2+2,2-2.2/201212223%%24%%25262728t%%%292:2;2<P2=2>2?2@2A2B2C2Di2E2F2G2H2I$2J2K2L2M2N2O2P2Q2R2S2T2U2V2W2X2Y2Z2[2\2]2^2_2`2a2b2c2d2e2e2f2g2h2i2j2k2l2m2n2o2p2q2r2s2t2u2v2w2x2y2z2{2|2}2~2222222222222222222222222B222222222222222222 22222222222222222222222222222222222Xo(' 8222222222222222222222$c$e2222222222222222222222$T2 -2$V2222222(:(:3$W$X3$_$a33333$f333 3 3 3 3 3333333333333333333 3!)3")3#3$3%3&3'%u3(3)%v3*3+3,3-3.3/30313233343536%37383938303:3;3<3=3>3?'3@'3A'3B'('3C'3D'3E'3F'3G'3H'3I'3J'3K'3Lx3M3Nx3O'/W3P3QW3R3S(3T(3U(3V3W#Agda-2.5.1.2-3WdVW2PMESgFNbFxv8zcP5Agda.Utils.MonadAgda.Utils.FunctorAgda.Utils.VarSetAgda.Utils.Except Agda.VersionAgda.Utils.TupleAgda.Utils.UpdateAgda.Utils.TestHelpersAgda.Utils.SingletonAgda.Utils.SemiRingAgda.Utils.QuickCheckAgda.Utils.PrettyAgda.Utils.PointerAgda.Utils.PartialOrdAgda.Utils.Parser.ReadPAgda.Utils.ImpossibleAgda.Utils.MapAgda.Utils.MaybeAgda.Utils.ListTAgda.Utils.ListT.TestsAgda.Utils.IORefAgda.Utils.IO.UTF8Agda.Utils.IO.DirectoryAgda.Utils.IO.BinaryAgda.Utils.LensAgda.Utils.MemoAgda.Utils.Lens.ExamplesAgda.Utils.FunctionAgda.Utils.SuffixAgda.Utils.FileNameAgda.Utils.HashAgda.Utils.EnvironmentAgda.Utils.EmptyAgda.Utils.EitherAgda.Utils.ClusterAgda.Utils.CharAgda.Utils.BiMapAgda.Utils.BagAgda.Utils.ListAgda.Utils.Parser.MemoisedCPSAgda.Utils.StringAgda.Utils.TimeAgda.Utils.NullAgda.Utils.Favorites,Agda.Utils.Graph.AdjacencyMap.UnidirectionalAgda.Utils.Maybe.StrictAgda.Utils.SizeAgda.Utils.TrieAgda.Utils.BenchmarkAgda.Utils.AssocList"Agda.TypeChecking.SizedTypes.Utils#Agda.TypeChecking.SizedTypes.Syntax+Agda.TypeChecking.SizedTypes.WarshallSolver"Agda.TypeChecking.SizedTypes.TestsAgda.Termination.SemiringAgda.Termination.SparseMatrixAgda.Termination.CutOffAgda.Termination.OrderAgda.Termination.CallMatrixAgda.Termination.CallGraphAgda.Termination.TerminationAgda.Syntax.Position'Agda.TypeChecking.Positivity.Occurrence2Agda.Utils.Graph.AdjacencyMap.Unidirectional.TestsAgda.Utils.PermutationAgda.Utils.Permutation.TestsAgda.Syntax.Parser.MonadAgda.Syntax.Parser.AlexAgda.Syntax.Parser.LookAheadAgda.Syntax.FixityAgda.Syntax.CommonAgda.Syntax.Concrete.NameAgda.TypeChecking.Monad.BaseAgda.Syntax.NotationAgda.Utils.WarshallAgda.Syntax.Abstract.NameAgda.Syntax.LiteralAgda.Syntax.ConcreteAgda.Syntax.Concrete.Generic%Agda.Syntax.Concrete.Operators.ParserAgda.Syntax.Concrete.Pretty Agda.Syntax.Concrete.DefinitionsAgda.Syntax.Parser.TokensAgda.Syntax.Parser.LayoutAgda.Syntax.Parser.LexActionsAgda.Syntax.Parser.Comments!Agda.Syntax.Parser.StringLiteralsAgda.Syntax.Parser.LexerAgda.Syntax.Parser.ParserAgda.Syntax.ParserAgda.Syntax.ReflectedAgda.Syntax.TreelessAgda.Interaction.Library.BaseAgda.Interaction.Library.ParseAgda.Interaction.LibraryAgda.Interaction.Options#Agda.Interaction.Highlighting.Range%Agda.Interaction.Highlighting.PreciseAgda.Interaction.ResponseAgda.Interaction.ExceptionsAgda.Interaction.EmacsCommandAgda.ImpossibleTestAgda.Compiler.UHC.BridgeAgda.Compiler.UHC.MagicTypesAgda.Compiler.UHC.Pragmas.BaseAgda.Compiler.Treeless.PrettyAgda.Compiler.JS.SyntaxAgda.Compiler.JS.SubstitutionAgda.Compiler.JS.PrettyAgda.Compiler.JS.ParserAgda.Compiler.JS.CaseAgda.BenchmarkingAgda.Syntax.Scope.BaseAgda.Syntax.InfoAgda.Utils.GeniplateAgda.Syntax.AbstractAgda.Syntax.Abstract.ViewsAgda.Syntax.InternalAgda.Compiler.Epic.InterfaceAgda.Compiler.Epic.AuxASTAgda.Syntax.Internal.DefsAgda.Syntax.Internal.GenericAgda.Syntax.Internal.Pattern Agda.TypeChecking.CompiledClause Agda.TypeChecking.Coverage.Match$Agda.TypeChecking.Coverage.SplitTreeAgda.TypeChecking.Free.LazyAgda.TypeChecking.Free.OldAgda.TypeChecking.Free&Agda.Interaction.Highlighting.GenerateAgda.Interaction.ImportsAgda.Interaction.InteractionTopAgda.Syntax.Internal.NamesAgda.TypeChecking.CheckInternal(Agda.TypeChecking.CompiledClause.Compile&Agda.TypeChecking.CompiledClause.MatchAgda.TypeChecking.ConstraintsAgda.TypeChecking.ErrorsAgda.TypeChecking.MetaVarsAgda.TypeChecking.Monad.ContextAgda.TypeChecking.Monad.Env!Agda.TypeChecking.Monad.ExceptionAgda.TypeChecking.Monad.ImportsAgda.TypeChecking.Monad.OptionsAgda.TypeChecking.Polarity Agda.TypeChecking.ProjectionLikeAgda.TypeChecking.RewritingAgda.TypeChecking.Rules.Term Agda.TypeChecking.Serialise.BaseAgda.TypeChecking.SubstituteAgda.Compiler.Treeless.SubstAgda.Compiler.Treeless.Compare$Agda.Compiler.Treeless.GuardsToPrimsAgda.Compiler.Treeless.Uncase"Agda.TypeChecking.LevelConstraintsAgda.TypeChecking.Monad.BuiltinAgda.TypeChecking.Monad.Open$Agda.TypeChecking.Substitute.Pattern!Agda.TypeChecking.Test.GeneratorsAgda.TypeChecking.Free.TestsAgda.TypeChecking.Telescope!Agda.TypeChecking.Monad.BenchmarkAgda.Interaction.FindFile,Agda.TypeChecking.Serialise.Instances.Common2Agda.TypeChecking.Serialise.Instances.HighlightingAgda.TypeChecking.Monad.StateAgda.Interaction.Options.LensesAgda.TypeChecking.Monad.ClosureAgda.TypeChecking.Monad.MutualAgda.Syntax.Scope.MonadAgda.Syntax.Abstract.CopatternsAgda.Syntax.Concrete.Operators*Agda.Syntax.Translation.AbstractToConcreteAgda.TypeChecking.Monad.Caching#Agda.TypeChecking.Monad.ConstraintsAgda.TypeChecking.Monad.Sharing"Agda.TypeChecking.Monad.StatisticsAgda.TypeChecking.Monad.Trace Agda.TypeChecking.Monad.MetaVars!Agda.TypeChecking.Monad.SignatureAgda.TypeChecking.Datatypes"Agda.TypeChecking.Monad.SizedTypesAgda.Compiler.CallCompilerAgda.Compiler.MAlonzo.CompilerAgda.Compiler.Treeless.Builtin%Agda.Compiler.Treeless.NormalizeNamesAgda.Compiler.Treeless.UnusedAgda.Compiler.UHC.Pragmas.Parse!Agda.Interaction.Highlighting.Dot#Agda.Interaction.Highlighting.Emacs"Agda.Interaction.Highlighting.HTML#Agda.Interaction.Highlighting.LaTeX!Agda.Interaction.Highlighting.VimAgda.Interaction.MonadAgda.Syntax.Abstract.Pretty+Agda.Syntax.Translation.ReflectedToAbstractAgda.Termination.RecCheckAgda.TypeChecking.ConversionAgda.TypeChecking.DropArgsAgda.TypeChecking.EmptyAgda.TypeChecking.Irrelevance"Agda.TypeChecking.MetaVars.Mention#Agda.TypeChecking.Patterns.Abstract Agda.TypeChecking.Patterns.MatchAgda.TypeChecking.PrettyAgda.TypeChecking.RecordsAgda.TypeChecking.Reduce.MonadAgda.TypeChecking.EtaContractAgda.TypeChecking.ReduceAgda.Compiler.Epic.CompileStateAgda.Compiler.Epic.CaseOptsAgda.Compiler.Epic.EpicAgda.Compiler.Epic.ForceConstrsAgda.Compiler.Epic.NatDetectionAgda.Compiler.Epic.PrimitiveAgda.TypeChecking.DeadCodeAgda.TypeChecking.LevelAgda.TypeChecking.DisplayForm+Agda.TypeChecking.Rules.Builtin.CoinductionAgda.TypeChecking.Rules.DeclAgda.TypeChecking.Rules.Def.Agda.TypeChecking.Serialise.Instances.Abstract/Agda.TypeChecking.Serialise.Instances.Compilers.Agda.TypeChecking.Serialise.Instances.Internal%Agda.TypeChecking.Serialise.InstancesAgda.TypeChecking.Serialise#Agda.TypeChecking.SyntacticEquality*Agda.Syntax.Translation.InternalToAbstractAgda.Compiler.Epic.ErasureAgda.Compiler.Epic.InjectionAgda.Compiler.Epic.SmashingAgda.Compiler.Epic.StaticAgda.Compiler.Epic.FromAgdaAgda.Compiler.HaskellTypesAgda.TypeChecking.Implicit'Agda.TypeChecking.Rewriting.NonLinMatch#Agda.TypeChecking.Rules.LHS.ProblemAgda.Termination.InliningAgda.Compiler.Treeless.Erase#Agda.TypeChecking.InstanceArgumentsAgda.TypeChecking.QuoteAgda.Termination.Monad!Agda.TypeChecking.MetaVars.OccursAgda.TypeChecking.Positivity"Agda.TypeChecking.Positivity.Tests Agda.TypeChecking.RecordPatternsAgda.TypeChecking.Rules.Display$Agda.TypeChecking.Rules.LHS.Implicit'Agda.TypeChecking.Rules.LHS.Instantiate'Agda.TypeChecking.Rules.LHS.ProblemRestAgda.TypeChecking.SizedTypesAgda.Termination.TermCheckAgda.TypeChecking.PrimitiveAgda.Compiler.Treeless.SimplifyAgda.Compiler.ToTreelessAgda.TypeChecking.InjectivityAgda.TypeChecking.Abstract'Agda.TypeChecking.ReconstructParametersAgda.TypeChecking.ForcingAgda.TypeChecking.Rules.Data!Agda.TypeChecking.Rules.LHS.Split!Agda.TypeChecking.Rules.LHS.UnifyAgda.Compiler.Epic.ForcingAgda.TypeChecking.CoverageAgda.TypeChecking.Rules.LHS"Agda.TypeChecking.SizedTypes.SolveAgda.TypeChecking.TestsAgda.TypeChecking.UnquoteAgda.TypeChecking.Rules.RecordAgda.TypeChecking.WithAgda.TypeChecking.Rules.Builtin*Agda.Syntax.Translation.ConcreteToAbstractAgda.Interaction.BasicOpsAgda.Interaction.SearchAboutAgda.Interaction.CommandLineAgda.Compiler.CommonAgda.Compiler.MAlonzo.MiscAgda.Compiler.MAlonzo.EncodeAgda.Compiler.MAlonzo.Pretty Agda.Tests Agda.Compiler.MAlonzo.PrimitivesAgda.Compiler.UHC.CompileStateAgda.Compiler.UHC.PrimitivesAgda.Compiler.UHC.FromAgdaAgda.Compiler.Epic.CompilerAgda.Compiler.JS.CompilerAgda.Compiler.UHC.CompilerAgda.Interaction.MakeCaseAgda.Auto.NarrowingSearchAgda.Auto.SyntaxAgda.Auto.SearchControlAgda.Auto.TypecheckAgda.Auto.CaseSplitAgda.Auto.ConvertAgda.Auto.AutoAgda.Interaction.EmacsTop Agda.Main Paths_Agda TraversableforM_Agda.Utils.HashMapData.Traversablefor Data.Maybe fromMaybeDataCharifNull Control.MonadmapMLazy listToMaybe maybeToList catMaybesmapMaybeforMData.MapmapKeysMonotonicAgda.TypeChecking.SubstitutionliftSAgda.Syntax.Internal.Patterns numberPatVarsLHSQName whyInScopeTreeAbstractSyntax AtTopLevelinteractionLoopTest.QuickChecksize localStateAgda.TypeChecking.Monadprop_splitTelescopeAgda.Compiler.UHC.Smashing getConTypesimplifyLevelConstraintTypeChecking.Coverage.MatchbuildMPatternsgiveExprAgda.TheTypeCheckerbaseGHC.Base<*>unless Data.Functor<$>when<$mplusmzero MonadPluscontainers-0.5.7.1Data.IntSet.BasefromList toDescListtoList isSubsetOf intersection differenceunionunionsdelete singletonemptymembernull mtl-2.2.1-6qsR1PHUy5lL47Hpoa4jCMControl.Monad.Error.Class catchError throwError MonadErrorControl.Monad.State.Classmodify'transformers-0.5.2.0Control.Monad.Trans.ExceptExceptT runExceptT mapExceptTversionVarSetsubtractList2list2-*-mapFstmapSnd/\swapfst3snd3thd3uncurry3uncurry4mapPairMmapFstMmapSndM$fApplicativeList2 $fEqList2$fFunctorList2$fFoldableList2$fTraversableList2Updater2updater2updates2update2Updater1updater1updates1update1ChangeUpdater MonadChange tellDirty listenDirty runChange runUpdaterdirtyifDirtysharing$fUpdater2Either $fUpdater2(,) $fUpdater1[]$fUpdater1Maybe$fMonadChangeChange$fMonadChangeIdentity$fMonadChangeChangeT$fFunctorChangeT$fApplicativeChangeT$fMonadChangeT$fMonadTransChangeT$fFunctorChange$fApplicativeChange $fMonadChange associative commutative idempotentisZeroidentityleftDistributiverightDistributive distributivenaturalpositivelistOfElementselementsUnlessEmptymaybeGen maybeCoGentwothreerunTests Singleton$fSingleton(,)HashMap$fSingletonaHashSet$fSingleton(,)IntMap$fSingleton(,)Map$fSingletonIntIntSet$fSingletonaSet$fSingletonaSeq$fSingletona[]$fSingletonaMaybe StarSemiRingostarSemiRingozeroooneoplusotimes$fStarSemiRingMaybe$fSemiRingMaybe isSuccess quickCheck'quickCheckWith'Prettypretty prettyPrec prettyShow prettyListpwordsfwordsmparensalign $fPretty[] $fPrettyDoc $fPrettyChar$fPrettyInteger $fPrettyInt32 $fPrettyInt $fPrettyBoolPtrnewPtrderefPtr updatePtrsetPtr updatePtrM $fNFDataPtr $fHashablePtr$fOrdPtr$fEqPtr$fTraversablePtr $fFoldablePtr $fFunctorPtr $fShowPtrISetiset Inclusion inclusion Pointwise pointwise PartialOrd comparable ComparablePartialOrderingPOLTPOLEPOEQPOGEPOGTPOAnyleqPOoppPOorPOseqPO fromOrdering fromOrderings toOrderings comparableOrdrelatedprop_comparable_related prop_oppPOsortUniqprop_leqPO_soundprop_orPO_soundprop_associative_orPOprop_commutative_orPOprop_idempotent_orPOprop_zero_orPOproperty_seqPO prop_seqPOprop_identity_seqPOprop_zero_seqPOprop_associative_seqPOprop_commutative_seqPOprop_idempotent_seqPOprop_distributive_seqPO_orPOprop_sorted_toOrderings#prop_toOrderings_after_fromOrdering$prop_fromOrderings_after_toOrderings$prop_toOrderings_after_fromOrderingsprop_related_pairprop_comparable_PartialOrdering$fArbitraryISet$fArbitraryPartialOrdering$fPartialOrdPartialOrdering$fPartialOrdInclusion$fPartialOrdInclusion0$fPartialOrdPointwise$fPartialOrd(,)$fPartialOrdEither$fPartialOrdMaybe$fPartialOrd()$fPartialOrdInteger$fPartialOrdInt$fMonoidPartialOrdering$fEqPartialOrdering$fShowPartialOrdering$fEnumPartialOrdering$fBoundedPartialOrdering $fEqPointwise$fShowPointwise$fFunctorPointwise $fEqInclusion$fOrdInclusion$fShowInclusion$fFunctorInclusion$fEqISet $fOrdISet$fPartialOrdISet $fShowISettestsReadPparsegetlookpfail+++<++gathersatisfycharstringmunchmunch1choice skipSpacescountbetweenoptionoptionalmanymany1skipMany skipMany1sepBysepBy1endByendBy1chainrchainlchainr1chainl1manyTillparse'$fMonadPlusReadP$fAlternativeReadP $fMonadReadP$fApplicativeReadP$fFunctorReadP $fMonadPlusP$fAlternativeP$fMonadP$fApplicativeP $fFunctorP ImpossiblethrowImpossiblecatchImpossible$fExceptionImpossible$fShowImpossible EitherOrBothLBR unionWithMinsertWithKeyM allWithKey filterKeysunzipunzip3unionMaybeWith unzipMaybe filterMaybeforMaybe caseMaybemaybeM fromMaybeM caseMaybeMifJustMwhenJust whenNothing whenJustM whenNothingMallJustMallJustsOrNothingsListTrunListTnilListT consListTsgListT caseListT foldListT concatListT runMListT consMListTsgMListT mapMListT mapMListT_alt liftListT$fMonadStatesListT$fMonadReaderrListT$fMonadIOListT$fMonadTransListT $fMonadListT$fApplicativeListT$fMonadPlusListT$fAlternativeListT $fMonoidListT$fFunctorListTreadModifyIORef' readTextFilehPutStr writeFilecopyDirContentreadBinaryFile' Decoration traverseF distributeF$><.><&>dmapdget$fDecoration(,)$fDecorationCompose$fDecorationIdentityLens'^.setoveruse.=%=%==%%=viewlocallykeymemomemoRecRecordfield1field2 lensField1 lensField2 iterWhile repeatWhile repeatWhileMtrampolineWhiletrampolineWhileM trampoline trampolineM iterateUntil iterateUntilMiterate' applyWhen applyUnless applyWhenM applyUnlessMSuffixNoSuffixPrimeIndex SubscriptisSubscriptDigittoSubscriptDigitfromSubscriptDigit nextSuffix suffixView addSuffix nameVariant AbsolutePathfilePath mkAbsoluterootNameabsolute===doesFileExistCaseSensitive$fCoArbitraryAbsolutePath$fArbitraryAbsolutePath$fPrettyAbsolutePath$fShowAbsolutePath$fEqAbsolutePath$fOrdAbsolutePath$fHashableAbsolutePathHashhashByteStringhashFile combineHashes hashStringErrornoMsgstrMsg mkExceptT $fError(,,) $fError() $fError[]expandEnvironmentVariables $fEqToken $fShowTokenEmptyabsurd $fShowEmpty $fOrdEmpty $fEqEmpty whileLeft caseEitherM mapEithermapLeftmapRighttraverseEitherisRightisLeftfromLeft fromRight maybeLeft maybeRightallLeftallRightclustercluster' UnicodeTest IsControlIsSpaceIsLowerIsUpperIsAlpha IsAlphaNumIsPrintIsDigit IsOctDigit IsHexDigitIsLetterIsMarkIsNumber IsPunctuationIsSymbol IsSeparatordecDigithexDigitoctDigit unicodeTeststestChar$fEqUnicodeTest$fOrdUnicodeTest$fShowUnicodeTestBiMap biMapThere biMapBacklookup invLookupinsertprop_BiMap_invariant$fArbitraryBiMap $fShowBiMap $fOrdBiMap $fEqBiMapBagbag! notMembergroupskeyselems toAscListmap traverse'prop_count_emptyprop_count_singletonprop_count_insertprop_size_unionprop_size_fromListprop_fromList_toListprop_toList_fromListprop_keys_fromListprop_nonempty_groups prop_map_idprop_map_composeprop_traverse_id$fArbitraryBag $fFoldableBag $fMonoidBag $fShowBag$fEqBag$fOrdBag PreOrSuffixIsPrefixIsSuffix IsBothfixIsNofixPrefixcaseListlistCase headMaybeheadWithDefault lastMaybeunconsmconsinitLast!!!downFrom updateHeadspec_updateHeadprop_updateHead updateLastspec_updateLastprop_updateLastupdateAt spec_updateAt prop_updateAtdeal takeWhileJustspanJustpartitionMaybe isSublistOfmaybePrefixMatch preOrSuffixwordsBychopchopWhenprop_chop_intercalateholessorteddistinct fastDistinctprop_distinct_fastDistinctallEqual duplicatesgroupBy' prop_groupBy'groupOnsplitExactlyAtextractNthElement'extractNthElementprop_extractNthElementgenericElemIndexprop_genericElemIndexzipWith' prop_zipWith'nubOn prop_nubOnuniqOn prop_uniqOn1 prop_uniqOn2 commonSuffix commonPrefixprop_commonPrefixprop_commonSuffixeditDistanceSpec editDistanceprop_editDistanceCont==<<when_unless_whenMunlessMifMifNotMand2MandMallMor2MorManyMaltM1mapM'forM'thread zipWithM' mapMaybeM forMaybeM dropWhileMfinallybracket_readMParsertokensattokmemoise$fAlternativeParser$fApplicativeParser$fFunctorParser $fMonadParserStrunStrquote showIndexaddFinalNewLineindentshowThousandSepltrimrtrimtrim $fShowStr$fEqStrCPUTime ClockTime getClockTime getCPUTime measureTime$fPrettyCPUTime $fEqCPUTime $fShowCPUTime $fOrdCPUTime $fNumCPUTime $fRealCPUTime $fEnumCPUTime$fIntegralCPUTimeNullifNullMwhenNull unlessNull whenNullM unlessNullM $fNullDoc $fNullMaybe $fNullSet $fNullSeq $fNullHashSet $fNullHashMap $fNullMap $fNullIntSet $fNullIntMap $fNullBag$fNull[]$fNullByteString $fNull(,)$fNull() CompareResult Dominates IsDominated dominated notDominated dominator FavoritescompareWithFavoritescompareFavorites unionComparedinsertComparedproperty_null_emptyproperty_not_null_singletonprop_compareWithFavoritesprop_fromList_after_toListprop_union_union2$fArbitraryFavorites$fMonoidFavorites $fEqFavorites$fFoldableFavorites$fShowFavorites$fCoArbitraryFavorites$fNullFavorites$fSingletonFavoritesDAGdagGraphdagComponentMap dagNodeMapNodessrcNodestgtNodesallNodesEdgesourcetargetlabelGraphgraph transposeEdgeedges edgesFromedgesTodiagonal neighbours neighboursMap sourceNodes targetNodes computeNodesnodes fromNodes fromListWithdiscreteclean insertEdge insertWithinsertEdgeWith unionWith unionsWith removeNode removeEdge filterEdges mapWithEdgesccs'sccs dagInvariant oppositeDAG reachablesccDAG'sccDAGacyclic reachableFromwalkSatisfying composeWithcomplete1gaussJordanFloydWarshallMcNaughtonYamadaReference(gaussJordanFloydWarshallMcNaughtonYamada$fArbitraryGraph$fCoArbitraryEdge$fArbitraryEdge $fEqGraph$fFunctorGraph $fShowGraph$fEqEdge $fOrdEdge $fFunctorEdge $fShowEdgetoStricttoLazy$fCoArbitraryMaybe$fArbitraryMaybe $fBinaryMaybe $fNFDataMaybe$fTraversableMaybe$fFoldableMaybe $fMonoidMaybe$fGenericMaybe $fDataMaybe SizedThingtheSize sizedThingSized sizeThing$fNullSizedThing$fSizedSizedThing $fSizedSeq$fSizedHashSet$fSizedHashMap $fSizedSet $fSizedMap $fSizedIntSet $fSizedIntMap $fSized[]Trie everyPrefixadjust lookupPath$fArbitraryModel$fArbitraryVal$fArbitraryKey $fShowVal $fShowKey $fNullTrie $fShowTrie$fEqTrie$fEqKey$fOrdKey$fEqVal $fEqModel $fShowModel MonadBench getBenchmark getsBenchmark putBenchmarkmodifyBenchmark Benchmark benchmarkOncurrentAccounttimingsTimingsCurrentAccountAccountmapBenchmarkOnmapCurrentAccount mapTimings addCPUTimesetBenchmarkingswitchBenchmarkingresetbillTo billPureTo$fMonadBenchaStateT$fMonadBenchaReaderT$fPrettyBenchmark$fNullBenchmark AssocListupdate mapWithKey mapWithKeyMDioidcompose unitComposeMeetSemiLatticemeetPlusplusToptopisTopdebugtracetraceM$fPlusIntIntIntFlexsflexsRigidsrigidsTruncateOffsettruncateOffset ValidOffset validOffsetCTrans SubstitutesubstSolution PolaritiesPolarityAssignmentPolarityLeastGreatest Constraint Constraint'leftExprcmp rightExprCmpLtLeSizeExpr SizeExpr'ConstRigidInftyFlexoffsetrigidflexFlexIdflexIdRigidIdrigidIdOffsetOemptyPolaritiespolaritiesFromAssignments getPolarity simplify1ifLe compareOffset$fFlexsflexConstraint'$fFlexsflexSizeExpr' $fFlexsflex[]$fRigidsrConstraint'$fRigidsrSizeExpr' $fRigidsr[]$fTruncateOffsetSizeExpr'$fTruncateOffsetOffset$fValidOffsetSizeExpr'$fValidOffsetOffset$fShowConstraint' $fShowCmp$fShowPolarityAssignment$fShowPolarity$fShowSizeExpr'$fPlusSizeExpr'OffsetSizeExpr'$fSubstituterf[]$fSubstituterfConstraint'$fSubstituterfSizeExpr'$fArbitraryCmp$fTopCmp$fMeetSemiLatticeCmp$fOrdCmp $fDioidCmp $fShowFlex $fShowRigid$fArbitraryOffset$fPlusOffsetOffsetOffset$fMeetSemiLatticeOffset $fShowOffset $fEqOffset $fOrdOffset $fNumOffset $fEnumOffset $fEqRigid $fOrdRigid$fEqFlex $fOrdFlex $fEqSizeExpr'$fOrdSizeExpr'$fFunctorSizeExpr'$fFoldableSizeExpr'$fTraversableSizeExpr'$fEqCmp $fBoundedCmp $fEnumCmp$fFunctorConstraint'$fFoldableConstraint'$fTraversableConstraint' $fEqPolarity $fOrdPolarityBounds lowerBounds upperBounds mustBeFiniteBound SetToInfty setToInfty ConGraphsConGraphHypGraphHyp'HypGraphsNodeNodeZero NodeInfty NodeRigidNodeFlexLabelLInflcmploffsetNegativenegativeWeightInfinity LabelledEdgeKeyEdge'srcdest lookupEdge graphToList graphFromListoutgoingincomingsetFoldl transClostoWeight isFlexNode isZeroNode isInftyNodenodeToSizeExpr emptyGraphsmentionsaddEdgereflClosimpliesnodeFromSizeExpredgeFromConstraintgraphFromConstraintsgraphsFromConstraintshypGraphhypConnsimplifyWithHypothesesconstraintGraphconstraintGraphs infinityFlexs emptyBoundedgeToLowerBoundedgeToUpperBoundgraphToLowerBoundsgraphToUpperBoundsboundssmallestlargest commonSuccs commonPredslub'glb'lubglbfindRigidBelow solveGraph solveGraphsverifySolution testSuccstestLub$fPlusSizeExpr'LabelSizeExpr'$fPlusSizeExpr'WeightSizeExpr'$fPlusOffsetWeightWeight$fSetToInftyfGraph$fSetToInftyfEdge$fSetToInftyfNode $fNegative[]$fNegativeGraph $fDioidEdge $fTopEdge$fMeetSemiLatticeEdge$fNegativeEdge $fShowNode $fDioidLabel $fDioidWeight$fArbitraryLabel $fTopLabel$fMeetSemiLatticeLabel $fShowLabel $fOrdLabel $fEqLabel$fNegativeLabel$fNegativeWeight$fNegativeOffset $fNegativeInt$fArbitraryWeight$fPlusWeightOffsetWeight $fNumWeight $fEnumWeight $fTopWeight$fMeetSemiLatticeWeight $fOrdWeight $fShowWeight $fEqWeight$fEqNode $fOrdNodeAsWeightRelationevalRelationprop_MeetSoundprop_MeetCompleteprop_ComposeSoundprop_ComposeCompletepropCommutativepropAssociativepropIdempotentpropUnitpropZero propDistL propDistRpropDistributivepropSemiLatticepropBoundedSemiLattice propMonoid propDioid propDioid_Genprop_Dioid_Weightprop_SemiLattice_Labelprop_Unit_Labelprop_BoundedSemiLattice_Labelprop_Monoid_Labelprop_DistL_Labelprop_DistR_Labelprop_Dist_Labelprop_Zero_Labelprop_Dioid_Label$fAsWeightRelationLabel$fAsWeightRelationCmpSemiringaddmulzeroHasZero zeroElementmultiplysemiringInvariantintegerSemiring intSemiring boolSemiring $fHasZeroInt$fHasZeroInteger transposeDiagonalMatrixMIxrowcolSizerowscolssquareisEmpty fromIndexList fromListstoLists isSingleton zipMatrices intersectWith addColumnaddRow sizeInvariant mIxInvariantmatrixInvariantmatrixUsingRowGenmatrix$fCoArbitraryMatrix$fArbitraryMatrix$fCoArbitraryMIx$fArbitraryMIx$fCoArbitrarySize$fArbitrarySize$fPrettyMatrix $fShowMatrix$fPartialOrdMatrix$fTransposeMatrix$fTransposeMIx$fTransposeSize$fDiagonalMatrixb$fEqSize $fOrdSize $fShowSize$fEqMIx$fOrdMIx $fShowMIx$fIxMIx $fEqMatrix $fOrdMatrix$fFunctorMatrix$fFoldableMatrix$fTraversableMatrixCutOff DontCutOff $fShowCutOff $fEqCutOff $fOrdCutOffNotWorsenotWorseOrderMatincreasedecreasedecrorderMatleltunknown nonIncreasing decreasingisDecr.*. collapseOsupremuminfimum orderSemiring$fCoArbitraryOrder$fArbitraryOrder $fPrettyOrder$fNotWorseMatrix$fNotWorseOrder$fPartialOrdOrder$fHasZeroOrder $fShowOrder $fEqOrder $fOrdOrderCMSetcmSet CallMatrixAug augCallMatrix augCallInfoCallComb>*< CallMatrix CallMatrix'mat ArgumentIndexnoAug callMatrix$fCoArbitraryCallMatrixAug$fArbitraryCallMatrixAug$fArbitraryCallMatrix' $fPrettyCMSet$fPrettyCallMatrixAug$fPrettyCallMatrix'$fCallCombCMSet$fCallCombCallMatrixAug$fNotWorseCallMatrixAug$fPartialOrdCallMatrixAug$fDiagonalCallMatrixAugOrder$fCallCombCallMatrix'$fDiagonalCallMatrix'a$fEqCallMatrix'$fOrdCallMatrix'$fShowCallMatrix'$fFunctorCallMatrix'$fFoldableCallMatrix'$fTraversableCallMatrix'$fCoArbitraryCallMatrix'$fPartialOrdCallMatrix'$fEqCallMatrixAug$fShowCallMatrixAug $fShowCMSet$fArbitraryCMSet$fCoArbitraryCMSet $fMonoidCMSet $fNullCMSet$fSingletonCMSet$fNotWorseCallMatrix' CallGraph theCallGraphCall callMatrixSetmkCallmkCall'completionStep$fPrettyCallGraph$fCombineNewOldGraph$fCombineNewOldFavorites$fMonoidCallGraph$fNullCallGraph$fShowCallGraph$fCombineNewOldCMSet terminatesterminatesFilterendos KillRangeT KillRange killRangeSetRangesetRangeHasRangegetRange PrintRangeRangeRange'IntervalWithoutFileInterval Interval'iStartiEndPositionWithoutFilePositionSrcFile Position'PnsrcFileposPosposLineposColpositionInvariantintervalInvariant posToIntervalrangeIntervalsintervalsToRangeconsecutiveAndSeparatedrangeInvariant rangeFile rightMargin killRangeMap killRange1 killRange2 killRange3 killRange4 killRange5 killRange6 killRange7 killRange8 killRange9 killRange10 killRange11 killRange12 killRange13 killRange14 killRange15 killRange16 killRange17 killRange18 killRange19startPosnoRangemovePosmovePosByString backupPostakeIdropI posToRange' posToRangerangeToInterval continuouscontinuousPerLinerStart'rStartrEnd'rEnd fuseRanges fuseRange beginningOfbeginningOfFile withRangeOf $fShowRange'$fShowInterval'$fShowPosition'$fCoArbitraryRange'$fCoArbitraryInterval'$fCoArbitraryPosition'$fArbitraryRange'$fArbitraryInterval'$fArbitraryPosition'$fPrettyPrintRange$fPrettyRange'$fPrettyInterval'$fPrettyInterval'0$fPrettyPosition'$fPrettyPosition'0 $fShowRange'0 $fShowRange'1$fShowInterval'0$fShowInterval'1$fShowPosition'0$fShowPosition'1$fKillRangeEither$fKillRangeMaybe$fKillRange(,,,)$fKillRange(,,)$fKillRange(,)$fKillRangeSet$fKillRangeMap $fKillRange[]$fKillRange[]0$fKillRangeInteger$fKillRangeInt$fKillRangeBool $fKillRange()$fKillRangeVoid$fKillRangeRange' $fSetRange[]$fSetRangeRange'$fHasRangeEither$fHasRangeMaybe$fHasRange(,,,,,,)$fHasRange(,,,,,)$fHasRange(,,,,)$fHasRange(,,,)$fHasRange(,,) $fHasRange(,) $fHasRange[]$fHasRangeBool$fHasRangeRange'$fHasRangeInterval' $fNullRange'$fOrdPosition' $fEqPosition'$fFunctorPosition'$fFoldablePosition'$fTraversablePosition'$fGenericPosition' $fEqInterval'$fOrdInterval'$fFunctorInterval'$fFoldableInterval'$fTraversableInterval'$fGenericInterval' $fEqRange' $fOrdRange'$fFunctorRange'$fFoldableRange'$fTraversableRange'$fGenericRange'$fEqPrintRange$fOrdPrintRange$fHasRangePrintRange$fSetRangePrintRange$fKillRangePrintRange OccurrenceMixedJustNegJustPos StrictPosGuardPosUnusedboundToEverySomeproductOfEdgesInBoundedWalk$fNullOccurrence$fStarSemiRingOccurrence$fSemiRingOccurrence$fCoArbitraryOccurrence$fArbitraryOccurrence$fKillRangeOccurrence$fNFDataOccurrence$fShowOccurrence$fEqOccurrence$fOrdOccurrence$fEnumOccurrence$fBoundedOccurrence$fStarSemiRingConnected$fSemiRingConnected$fShowN $fArbitraryN$fEqN$fOrdN $fEqConnected$fShowConnectedDoDropdoDropdropMoreunDropDropdropNdropFromInversePermuteinversePermute PermutationPerm permRange permPickspermute safePermuteidPtakePdroppedPliftPcomposePinvertPcompactPreversePflipPexpandPtopoSort$fArbitraryPermutation$fDoDropPermutation $fDoDrop[]$fKillRangeDrop$fInversePermute(->)[]$fInversePermute[][]$fInversePermute[]IntMap$fInversePermute[][]0$fKillRangePermutation$fNullPermutation$fSizedPermutation$fShowPermutation$fEqPermutation$fEqDrop $fOrdDrop $fShowDrop $fFunctorDrop$fFoldableDrop$fTraversableDrop!$fArbitraryComposablePermutations$fEqComposablePermutations$fShowComposablePermutations ParseResultParseOk ParseFailed ParseError errSrcFileerrPoserrInput errPrevTokenerrMsg ParseFlagsparseKeepComments LayoutContextNoLayoutLayoutLexState ParseStatePState parseSrcFileparsePos parseLastPosparseInp parsePrevCharparsePrevToken parseLayout parseLexState parseFlags initStatedefaultParseFlagsparsePosString parseFile setParsePos setLastPos setPrevTokengetParseInterval getLexState pushLexState popLexState getParseFlags parseError parseErrorAt parseError'lexError topContext popContext pushContextpushCurrentContext$fHasRangeParseError$fPrettyParseError$fShowParseError$fMonadStateParseStateParser$fMonadErrorParseErrorParser$fExceptionParseError$fShowLayoutContext$fShowParseFlags$fShowParseState LexPredicate LexAction TokenLength CurrentInput PreviousInput AlexInput lexSrcFilelexPoslexInput lexPrevChar lensLexInputalexInputPrevChar alexGetChar alexGetByte getLexInput setLexInput.&&..||.not' LookAheadgetInputsetInputnextCharsyncrollback eatNextCharmatchmatch' runLookAhead$fMonadLookAhead$fFunctorLookAhead$fApplicativeLookAheadFixity' noFixity'PositivityCheckTerminationCheckNoTerminationCheckNonTerminating TerminatingTerminationMeasure Renaming'RenamingrenFromrenTo renToRange ImportedName'ImportedModule ImportedNameUsing' UseEverythingUsingImportDirective'ImportDirectiveimportDirRangeusinghiding impRenaming publicOpen InteractionId interactionIdMaybePlaceholder Placeholder NoPlaceholderPositionInName BeginningMiddleEndConstrMetaIdmetaIdNameIdArityNatIsMacroMacroDef NotMacroDef IsInstance InstanceDefNotInstanceDef IsAbstract AbstractDef ConcreteDefAccess PrivateAccess PublicAccess OnlyQualifiedIsInfixInfixDef PrefixDef ConPOrigin ConPImplicitConPConConPRecRStringRawNameRangedrangeOf rangedThingNamedArgNamed_NamednameOf namedThingDomdomInfounDom Underscore underscore isUnderscoreArgargInfounArg LensArgInfo getArgInfo setArgInfo mapArgInfoArgInfo argInfoHidingargInfoRelevance LensRelevance getRelevance setRelevance mapRelevance RelevanceRelevant NonStrict IrrelevantForced UnusedArgBigSmall LensHiding getHiding setHiding mapHiding WithHidingHidingHiddenInstance NotHidden Induction Inductive CoInductiveDelayed NotDelayed mergeHidingisHidden notHiddenvisible notVisiblehidehideOrKeepInstance makeInstance allRelevances isRelevant isIrrelevant moreRelevantirrelevantOrUnusedunusableRelevancecomposeRelevanceinverseComposeRelevance ignoreForcedirrToNonStrictnonStrictToIrrdefaultArgInfo defaultArg withArgsFromwithNamedArgsFrom argFromDom domFromArg defaultDomunnamednamednamedArgdefaultNamedArgupdateNamedArgunrangedrawNameToStringstringToRawName noPlaceholderdefaultImportDirisDefaultImportDirsetImportedName$fNFDataTerminationCheck$fKillRangeTerminationCheck$fNFDataImportedName'$fNFDataRenaming'$fNFDataUsing'$fNFDataImportDirective'$fKillRangeImportedName'$fKillRangeRenaming'$fKillRangeUsing'$fKillRangeImportDirective'$fHasRangeImportedName'$fHasRangeRenaming'$fHasRangeUsing'$fHasRangeImportDirective'$fShowImportedName'$fMonoidUsing'$fKillRangeInteractionId$fShowInteractionId$fNFDataMaybePlaceholder$fKillRangeMaybePlaceholder$fHasRangeMaybePlaceholder$fNFDataMetaId $fShowMetaId$fPrettyMetaId$fCoArbitraryNameId$fArbitraryNameId$fHashableNameId$fNFDataNameId $fEnumNameId $fShowNameId$fKillRangeNameId$fHasRangeIsMacro$fKillRangeIsMacro$fNFDataIsInstance$fHasRangeIsInstance$fKillRangeIsInstance$fKillRangeIsAbstract$fNFDataRanged$fDecorationRanged$fKillRangeRanged$fHasRangeRanged $fOrdRanged $fEqRanged $fShowRanged $fNFDataNamed $fShowNamed$fKillRangeNamed$fSetRangeNamed$fHasRangeNamed$fDecorationNamed$fLensArgInfoDom$fLensRelevanceDom$fLensHidingDom $fShowDom$fKillRangeDom $fHasRangeDom$fDecorationDom$fUnderscoreDoc$fUnderscoreByteString$fUnderscore[]$fLensArgInfoArg$fLensRelevanceArg$fLensHidingArg $fNFDataArg $fShowArg$fEqArg$fKillRangeArg $fSetRangeArg $fHasRangeArg$fDecorationArg$fLensRelevanceArgInfo$fLensHidingArgInfo$fNFDataArgInfo$fLensArgInfoArgInfo$fKillRangeArgInfo$fLensRelevanceRelevance$fNFDataRelevance$fOrdRelevance$fArbitraryRelevance$fKillRangeRelevance $fNFDataBig$fOrdBig$fLensHidingWithHiding$fLensHidingHiding$fNFDataWithHiding$fKillRangeWithHiding$fSetRangeWithHiding$fHasRangeWithHiding$fApplicativeWithHiding$fDecorationWithHiding$fNFDataHiding$fKillRangeHiding$fMonoidHiding$fNFDataInduction$fCoArbitraryInduction$fArbitraryInduction$fKillRangeInduction$fHasRangeInduction$fShowInduction$fKillRangeDelayed $fShowDelayed $fEqDelayed $fOrdDelayed $fEqInduction$fOrdInduction $fShowHiding $fEqHiding $fOrdHiding$fEqWithHiding$fOrdWithHiding$fShowWithHiding$fFunctorWithHiding$fFoldableWithHiding$fTraversableWithHiding $fShowBig$fEqBig $fEnumBig $fBoundedBig$fShowRelevance $fEqRelevance $fEqArgInfo $fOrdArgInfo $fShowArgInfo$fOrdArg $fFunctorArg $fFoldableArg$fTraversableArg$fEqDom$fOrdDom $fFunctorDom $fFoldableDom$fTraversableDom $fEqNamed $fOrdNamed$fFunctorNamed$fFoldableNamed$fTraversableNamed$fFunctorRanged$fFoldableRanged$fTraversableRanged$fShowConPOrigin$fEqConPOrigin$fOrdConPOrigin$fEnumConPOrigin$fBoundedConPOrigin $fShowIsInfix $fEqIsInfix $fOrdIsInfix $fShowAccess $fEqAccess $fOrdAccess$fShowIsAbstract$fEqIsAbstract$fOrdIsAbstract$fShowIsInstance$fEqIsInstance$fOrdIsInstance $fShowIsMacro $fEqIsMacro $fOrdIsMacro $fEqNameId $fOrdNameId$fGenericNameId $fEqMetaId $fOrdMetaId $fNumMetaId $fRealMetaId $fEnumMetaId$fIntegralMetaId$fShowPositionInName$fEqPositionInName$fOrdPositionInName$fEqMaybePlaceholder$fOrdMaybePlaceholder$fFunctorMaybePlaceholder$fFoldableMaybePlaceholder$fTraversableMaybePlaceholder$fShowMaybePlaceholder$fEqInteractionId$fOrdInteractionId$fNumInteractionId$fIntegralInteractionId$fRealInteractionId$fEnumInteractionId$fEqImportedName'$fOrdImportedName' $fEqUsing' $fEqRenaming'$fEqImportDirective'$fShowTerminationCheck$fEqTerminationCheck$fFunctorTerminationCheckIsNoNameisNoNameNumHolesnumHolesTopLevelModuleNamemoduleNamePartsQualNamePartHoleIdNameNoName nameToRawName namePartsnameStringPartsstringNameParts isOperatorisHoleisPrefix isPostfixisInfixisNonfixqualify unqualify qnamePartstoTopLevelModuleNamemoduleNameToFileName projectRootnoName_noName $fNFDataQName$fNFDataNamePart $fNFDataName$fKillRangeName$fKillRangeQName$fSetRangeQName$fSetRangeName$fHasRangeQName$fHasRangeName$fCoArbitraryName$fCoArbitraryNamePart$fArbitraryName$fCoArbitraryTopLevelModuleName$fArbitraryTopLevelModuleName$fPrettyTopLevelModuleName $fPrettyQName$fPrettyNamePart $fPrettyName $fShowQName$fShowNamePart $fShowName$fIsNoNameQName$fIsNoNameName$fIsNoNameByteString $fIsNoName[]$fNumHolesQName$fNumHolesName $fNumHoles[]$fUnderscoreQName $fOrdNamePart $fEqNamePart $fOrdName$fEqName$fUnderscoreName$fGenericNamePart $fEqQName $fOrdQName$fShowTopLevelModuleName$fEqTopLevelModuleName$fOrdTopLevelModuleNameModuleToSourceTCMTCMTunTCMTCStateTCEnv NotationKind InfixNotationPrefixNotationPostfixNotationNonfixNotation NoNotationGenPartBindHole NormalHoleWildHoleIdPartNotationHoleName LambdaHoleExprHole _bindHoleNameholeName isLambdaHole stringParts holeTargetisAHole isNormalHole isBindingHole notationKind mkNotation noNotation$fNFDataGenPart$fKillRangeGenPart $fShowGenPart $fEqGenPart $fOrdGenPart$fEqNotationKind$fShowNotationKindDistanceSizeVar SizeConst LegendMatrixrowdescrcoldescrGM flexScopenodeMapintMapnextNode ConstraintsNewFlexArcScopeNodeIdRConstRVarFiniteInfiniteAdjListwarshall warshallGincinfiniteisBelowemptyConstraints initGraphaddFlexaddNode addConstraint buildGraphmkMatrix emptySolutionextendSolution sizeRigidsolvegenGraph genGraph_ prop_smallernewEdgegenPath prop_pathmapNodes prop_disjoint prop_stable$fShowSizeExpr$fShowLegendMatrix$fShowConstraint$fSemiRingWeightMkNamemkNamemkName_AmbiguousQNameAmbQunAmbQ ModuleNameMName mnameToListQNamedqnameqnamed qnameModule qnameNamenameId nameConcretenameBindingSite nameFixityisAnonymousModuleName withRangesOf withRangesOfQ mnameFromList noModuleNamecommonParentModule qnameToList qnameFromList qnameToMName mnameToQName showQNameIdqnameToConcretemnameToConcretequalifyMqualifyQqualify_ isSubModuleOf isInModulenextName$fNFDataModuleName$fCoArbitraryQName$fArbitraryQName$fSizedModuleName $fSizedQName$fKillRangeAmbiguousQName$fKillRangeModuleName$fSetRangeModuleName$fHasRangeAmbiguousQName$fHasRangeModuleName$fPrettyQNamed$fPrettyAmbiguousQName$fPrettyModuleName$fShowModuleName$fHashableQName$fHashableName $fMkName[]$fEqModuleName$fOrdModuleName$fFunctorQNamed$fFoldableQNamed$fTraversableQNamed$fEqAmbiguousQName$fShowAmbiguousQName $fShowQNamed PrecedenceTopCtxFunctionSpaceDomainCtxLeftOperandCtxRightOperandCtx FunctionCtx ArgumentCtxInsideOperandCtx WithFunCtx WithArgCtx DotPatternCtxFixity fixityRange fixityLevel fixityAssoc AssociativityNonAssoc LeftAssoc RightAssocPrecedenceLevel UnrelatedRelatedNotationSection sectNotationsectKind sectLevel sectIsSection NewNotationnotaName notaNames notaFixitynotationnotaIsOperatorThingWithFixity theFixity theNotationnamesToNotationuseDefaultFixity notationNamessyntaxOfmergeNotations noSectionnoFixity defaultFixityhiddenArgumentCtx opBrackets lamBrackets appBracketswithAppBrackets piBracketsroundFixBrackets _notaFixity _fixityAssoc _fixityLevel$fNFDataFixity$fNFDataFixity'$fKillRangeThingWithFixity$fKillRangeFixity'$fKillRangeFixity$fHasRangeFixity $fOrdFixity $fEqFixity$fEqPrecedenceLevel$fOrdPrecedenceLevel$fShowPrecedenceLevel$fEqAssociativity$fOrdAssociativity$fShowAssociativity $fShowFixity $fShowFixity' $fEqFixity'$fShowNewNotation$fShowNotationSection$fFunctorThingWithFixity$fFoldableThingWithFixity$fTraversableThingWithFixity$fShowThingWithFixity$fShowPrecedence$fEqPrecedenceLiteralLitNatLitFloat LitStringLitCharLitQNameLitMeta showString' showChar'$fNFDataLiteral$fKillRangeLiteral$fSetRangeLiteral$fHasRangeLiteral $fOrdLiteral $fEqLiteral$fPrettyLiteral $fShowLiteralAppViewModulePragma OptionsPragma BuiltinPragma RewritePragmaCompiledDataPragmaCompiledDeclareDataPragmaCompiledTypePragmaCompiledPragmaCompiledExportPragmaCompiledEpicPragmaCompiledJSPragmaCompiledUHCPragmaCompiledDataUHCPragmaHaskellCodePragmaNoSmashingPragma StaticPragma InlinePragma ImportPragmaImportUHCPragmaImpossiblePragmaTerminationCheckPragmaCatchallPragma DisplayPragmaNoPositivityCheckPragma OpenShortHandDoOpenDontOpenModuleApplication SectionAppRecordModuleIFS DeclarationTypeSigField FunClauseDataSig RecordSigInfix PatternSynMutualPrivate InstanceBMacro Postulate PrimitiveOpenImport ModuleMacro UnquoteDecl UnquoteDefTypeSignatureOrInstanceBlock TypeSignatureAsNameasNameasRange ExprWhere WhereClause'NoWhereAnyWhere SomeWhere WhereClauseRHS' AbsurdRHSRHSLHSCoreLHSHeadLHSProj lhsDefNamelhsPats lhsDestructor lhsPatsLeftlhsFocus lhsPatsRightWithExpr RewriteEqnEllipsislhsOriginalPatternlhsWithPattern lhsRewriteEqn lhsWithExpr Telescope TypedBinding'TBindTLet TypedBinding BoundNameBName boundName boundLabel bnameFixityTypedBindings' TypedBindings LamBinding' DomainFree DomainFull LamBindingPatternIdentPQuotePAppPRawAppPOpAppPHiddenP InstancePParenPWildPAbsurdPAsPDotPLitPRecPExprIdentLit QuestionMarkRawAppAppOpAppWithApp HiddenArg InstanceArgLam AbsurdLam ExtendedLamFunPiSetPropSetNRec RecUpdateLetParenAbsurdAsDotETel QuoteGoal QuoteContextQuote QuoteTermTacticUnquoteDontCareEqualRecordAssignmentsRecordAssignmentModuleAssignment _qnameModA _exprModA_importDirModAFieldAssignmentFieldAssignment' _nameFieldA _exprFieldASyntaxBindingLambdaOrdinary fromOrdinary nameFieldA exprFieldA mkBoundName_ mkBoundName countTelVarstopLevelModuleNamespanAllowedBeforeModulemapLhsOriginalPatternappView patternQNames patternNames $fNFDataRHS'$fNFDataBoundName$fNFDataLamBinding'$fNFDataWhereClause'$fNFDataModuleAssignment$fNFDataFieldAssignment' $fNFDataLHS $fNFDataOpApp$fNFDataModuleApplication$fNFDataTypedBinding'$fNFDataAsName$fNFDataTypedBindings'$fNFDataPragma$fNFDataDeclaration$fNFDataPattern $fNFDataExpr$fKillRangeWhereClause'$fKillRangeTypedBindings'$fKillRangeTypedBinding'$fKillRangeRHS'$fKillRangePragma$fKillRangePattern$fKillRangeOpApp$fKillRangeModuleApplication$fKillRangeLHS$fKillRangeLamBinding'$fKillRangeExpr$fKillRangeDeclaration$fKillRangeBoundName$fKillRangeAsName$fKillRangeModuleAssignment$fKillRangeFieldAssignment'$fSetRangePattern$fSetRangeTypedBindings'$fHasRangePattern$fHasRangeAsName$fHasRangePragma$fHasRangeRHS'$fHasRangeLHSCore $fHasRangeLHS$fHasRangeDeclaration$fHasRangeModuleAssignment$fHasRangeFieldAssignment'$fHasRangeModuleApplication$fHasRangeWhereClause'$fHasRangeBoundName$fHasRangeLamBinding'$fHasRangeTypedBinding'$fHasRangeTypedBindings'$fHasRangeExpr$fHasRangeOpApp$fLensHidingLamBinding'$fLensHidingTypedBindings'$fLensRelevanceTypedBindings'$fNullWhereClause'$fFunctorFieldAssignment'$fFoldableFieldAssignment'$fTraversableFieldAssignment'$fShowFieldAssignment'$fEqFieldAssignment'$fFunctorTypedBindings'$fFoldableTypedBindings'$fTraversableTypedBindings'$fFunctorLamBinding'$fFoldableLamBinding'$fTraversableLamBinding' $fFunctorRHS'$fFoldableRHS'$fTraversableRHS'$fFunctorWhereClause'$fFoldableWhereClause'$fTraversableWhereClause' $fShowAsName$fEqOpenShortHand$fShowOpenShortHand$fFunctorTypedBinding'$fFoldableTypedBinding'$fTraversableTypedBinding'$fFunctorOpApp$fFoldableOpApp$fTraversableOpAppExprLikemapExpr traverseExprfoldExpr$fExprLikeDeclaration$fExprLikeModuleApplication $fExprLikeLHS$fExprLikeTypedBindings'$fExprLikeLamBinding'$fExprLikeOpApp$fExprLikeModuleAssignment$fExprLikeFieldAssignment'$fExprLikeExpr$fExprLike(,,,)$fExprLike(,,) $fExprLike(,)$fExprLikeWhereClause'$fExprLikeRHS'$fExprLikeTypedBinding'$fExprLikeEither$fExprLikeMaybePlaceholder$fExprLikeMaybe $fExprLike[] $fExprLikeArg$fExprLikeNamed$fExprLikeBool$fExprLikeQName$fExprLikeNameNKInPrePostNon OperatorType ParseSectionsDoNotParseSectionsIsExprexprView unExprViewExprViewLocalVWildVOtherVAppVOpAppV HiddenArgV InstanceArgVLamVParenVMemoKeyNodeK PostLeftsKTopKAppKNonfixK placeholdermaybePlaceholdernotPlaceholdersat'partPatLeastTwoPartswildOrUnqualifiedNameopPargsPappPatomP$fIsExprPattern $fIsExprExpr$fHasRangeExprView$fHashableMemoKey $fEqMemoKey$fGenericMemoKey$fEqParseSections$fShowParseSectionsTelbraces'dbracesbracesAndSemicolonsarrowlambda prettyHidingprettyRelevancesmashTel prettyOpApp$fPrettyImportedName'$fPrettyUsing'$fPrettyImportDirective'$fPrettyPattern $fPrettyNamed $fPrettyArg$fPrettyFixity' $fPretty[]0$fPrettyGenPart$fPrettyFixity$fPrettyPragma$fPrettyOpenShortHand$fPrettyDeclaration$fPrettyModuleApplication$fShowModuleApplication $fPretty[]1$fPrettyLHSCore $fShowLHSCore $fPrettyLHS $fShowLHS$fPrettyWhereClause'$fShowWhereClause' $fPrettyRHS'$fPrettyTypedBinding' $fPrettyTel$fPrettyTypedBindings'$fPrettyLamBinding'$fPrettyBoundName$fPrettyModuleAssignment$fPrettyFieldAssignment'$fPrettyEither $fPrettyExpr$fPrettyMaybePlaceholder $fPrettyOpApp$fPrettyInduction$fPrettyRelevance$fPrettyWithHiding$fPrettyThingWithFixity $fPretty(,) $fShowRHS' $fShowPragma$fShowImportDirective'$fShowLamBinding'$fShowTypedBindings'$fShowTypedBinding' $fShowPattern$fShowDeclaration $fShowExprNiceDeclarationExceptionMultipleFixityDecls InvalidNameDuplicateDefinitionMissingDefinitionMissingWithClausesMissingTypeSignatureMissingDataSignatureWrongDefinitionWrongParametersNotAllowedInMutualUnknownNamesInFixityDeclCodataDeclarationPanicUselessPrivateUselessAbstractUselessInstanceWrongContentBlockAmbiguousFunClausesInvalidTerminationCheckPragmaInvalidMeasureMutualPragmaNoTerminationCheckInvalidCatchallPragmaUnquoteDefRequiresSignature BadMacroDefInvalidNoPositivityCheckPragmaClauseNiceTypeSignatureNiceConstructorMeasureNiceDeclarationAxiom NiceFieldPrimitiveFunction NiceMutual NiceModuleNiceModuleMacroNiceOpen NiceImport NicePragma NiceRecSig NiceDataSig NiceFunClauseFunSigFunDefDataDefRecDefNicePatternSynNiceUnquoteDeclNiceUnquoteDefrunNiceniceDeclarationsnotSoNiceDeclarationniceHasAbstract$fMonoidStateT$fShowDataRecOrFun$fEqDataRecOrFun$fPrettyDeclarationException$fErrorDeclarationException$fHasRangeNiceDeclaration$fHasRangeDeclarationException $fShowClause$fShowNiceDeclaration$fEqKindOfBlock$fOrdKindOfBlock$fShowKindOfBlock $fEqInMutual$fShowInMutual $fEqDeclKind$fShowDeclKindToken TokKeywordTokIdTokQId TokLiteral TokSymbol TokStringTokSetNTokTeX TokCommentTokDummyTokEOFSymbolSymDotSymSemiSymVirtualSemiSymBarSymColonSymArrowSymEqual SymLambda SymUnderscoreSymQuestionMarkSymAs SymOpenParen SymCloseParenSymDoubleOpenBraceSymDoubleCloseBrace SymOpenBrace SymCloseBraceSymOpenVirtualBraceSymCloseVirtualBrace SymOpenPragmaSymClosePragma SymEllipsis SymDotDot SymEndCommentKeywordKwLetKwInKwWhereKwDataKwCoData KwPostulateKwMutual KwAbstract KwPrivate KwInstanceKwOpenKwImportKwModule KwPrimitiveKwMacroKwInfixKwInfixLKwInfixRKwWith KwRewriteKwSetKwPropKwForallKwRecord KwConstructorKwField KwInductive KwCoInductiveKwEtaKwNoEtaKwHidingKwUsing KwRenamingKwToKwPublic KwOPTIONS KwBUILTINKwLINEKwCOMPILED_DATAKwCOMPILED_DECLARE_DATAKwCOMPILED_TYPE KwCOMPILEDKwCOMPILED_EXPORT KwHASKELLKwCOMPILED_EPIC KwCOMPILED_JSKwCOMPILED_UHCKwCOMPILED_DATA_UHCKwIMPORT KwIMPORT_UHC KwIMPOSSIBLEKwSTATICKwINLINE KwNO_SMASHINGKwNO_TERMINATION_CHECK KwTERMINATINGKwNON_TERMINATING KwMEASURE KwDISPLAY KwREWRITE KwQuoteGoalKwQuoteContextKwQuote KwQuoteTerm KwUnquote KwUnquoteDecl KwUnquoteDefKwSyntax KwPatternSynKwTactic KwCATCHALLKwNO_POSITIVITY_CHECKlayoutKeywords$fHasRangeToken $fEqKeyword $fShowKeyword $fEqSymbol $fShowSymbol emptyLayoutnewLayoutContext offsideRuleinStateeof followedByliteral identifiersymbolkeywordend_begin_endWithbegin withLayout withInterval' withIntervallexToken keepComments keepCommentsM nestedCommenthole skipBlock litStringlitChar AlexReturnAlexEOF AlexErrorAlexSkip AlexTokenliteratenormallayout empty_layoutbolimp_dirlexercode alexScanUser$fFunctorAlexLastAcc withInterval_end openBrace closeBrace tokensParser exprParserexprWhereParser moduleParsermoduleNameParser$fEqRecordDirective$fShowRecordDirective$fShowRHSOrTypeSigs parseLiterate parseFile' Definition RecordDefDataConstructor AbsurdClauseConPVarPProjPSortSetSLitSUnknownSTypeTermVarConDefMetaExtLamUnknownAbsElimsElimElim'ApplyArgs argsToElims $fShowElim' $fShowAbs $fShowTerm $fShowSort$fShowDefinition Unreachable isUnreachableTError TUnreachableTAltTAConTAGuardTALitaConaArityaBodyaGuardaLitCaseTypeCTDataCTCharCTStringCTQNameTPrimPAddPSubPMulPQuotPRemPGeqPLtPEqPIfPSeqTTermTVarTDefTAppTLamTLitTConTCaseTUnitTSortTErasedCompiled cTreeless cArgUsagemkTApptAppViewmkLettIntintViewtPlusK tNegPlusK plusKView negPlusKViewtOp tUnreachable$fKillRangeCompiled$fUnreachableTTerm$fUnreachableTAlt $fShowTPrim $fEqTPrim $fOrdTPrim$fShowCaseType $fEqCaseType $fOrdCaseType $fShowTError $fEqTError $fOrdTError $fShowTTerm $fEqTTerm $fOrdTTerm $fShowTAlt$fEqTAlt $fOrdTAlt$fShowCompiled $fEqCompiled $fOrdCompiled AgdaLibFileAgdaLiblibNamelibFile libIncludes libDependsLibName$fShowAgdaLibFile parseLibFile splitCommas stripComments$fShowGenericLineLibMgetDefaultLibrariesgetInstalledLibrarieslibraryIncludePaths$fShowLibErrorFlagOptM PragmaOptionsoptShowImplicitoptShowIrrelevant optVerboseoptProofIrrelevanceoptAllowUnsolvedoptDisablePositivityoptTerminationCheckoptTerminationDepthoptCompletenessCheckoptUniverseCheck optSizedTypesoptInjectiveTypeConstructorsoptGuardingTypeConstructorsoptUniversePolymorphismoptIrrelevantProjectionsoptExperimentalIrrelevance optWithoutK optCopatternsoptPatternMatching optExactSplitoptEta optRewritingCommandLineOptionsOptionsoptProgramName optInputFileoptIncludePathsoptAbsoluteIncludePaths optLibrariesoptOverrideLibrariesFileoptDefaultLibsoptShowVersion optShowHelpoptInteractive optRunTestsoptGHCiInteractionoptCompileNoMain optGhcCompile optGhcCallGhc optGhcFlagsoptEpicCompile optJSCompile optUHCCompile optUHCBinoptUHCTextualCore optUHCCallUHCoptUHCTraceLevel optUHCFlagsoptOptimSmashing optCompileDiroptGenerateVimFileoptGenerateLaTeXoptGenerateHTMLoptDependencyGraph optLaTeXDir optHTMLDir optCSSFileoptIgnoreInterfaces optForcingoptPragmaOptions optEpicFlagsoptSafe optSharing optCaching Verbosity isLiteratemapFlagdefaultVerbositydefaultInteractionOptionsdefaultOptions defaultCutOffrunOptM checkOptsunsafePragmaOptions inputFlagstandardOptionsstandardOptions_ getOptSimpleparseStandardOptionsparseStandardOptions'parsePragmaOptionsparsePluginOptionsusage defaultLibDir$fShowPragmaOptions$fEqPragmaOptions$fShowCommandLineOptionsRangesfromtorangesInvariant overlappingrangeToPositionsrangesToPositionsrToRrangeToEndPointsminus$fArbitraryRanges$fCoArbitraryRange$fArbitraryRange $fEqRange $fOrdRange $fShowRange $fEqRanges $fShowRangesCompressedFilerangesHighlightingInfoFileAspectsaspect otherAspectsnotedefinitionSite OtherAspect DottedPattern UnsolvedMetaUnsolvedConstraintTerminationProblemIncompletePattern TypeChecksNameKind ConstructorDatatypeFunctionArgumentAspectCommentStringNumber PrimitiveTypeseveral smallestPostoMapcompressedFileInvariantcompress decompressnoHighlightingInRange singletonCseveralCsplitAtCselectC smallestPosC$fArbitraryCompressedFile$fCoArbitraryFile$fArbitraryFile$fCoArbitraryAspects$fArbitraryAspects$fCoArbitraryOtherAspect$fArbitraryOtherAspect$fCoArbitraryNameKind$fArbitraryNameKind$fCoArbitraryAspect$fArbitraryAspect$fMonoidCompressedFile $fMonoidFile$fMonoidAspects $fEqAspects $fEqNameKind$fShowNameKind $fEqAspect $fShowAspect$fEqOtherAspect$fShowOtherAspect$fEnumOtherAspect$fBoundedOtherAspect $fShowAspects$fEqFile $fShowFile$fEqCompressedFile$fShowCompressedFileInteractionOutputCallback GiveResult Give_String Give_Paren Give_NoParenStatussShowImplicitArgumentssChecked DisplayInfoInfo_CompilationOkInfo_Constraints Info_AllGoals Info_Time Info_Error Info_Intro Info_AutoInfo_ModuleContentsInfo_SearchAboutInfo_WhyInScopeInfo_NormalForm Info_GoalTypeInfo_CurrentGoalInfo_InferredType Info_ContextInfo_HelperFunction Info_VersionMakeCaseVariantExtendedLambdaResponseResp_HighlightingInfo Resp_StatusResp_JumpToErrorResp_InteractionPointsResp_GiveAction Resp_MakeCase Resp_SolveAllResp_DisplayInfoResp_RunningInfoResp_ClearRunningInfoResp_ClearHighlighting defaultInteractionOutputCallback$fShowDisplayInfohandleParseExceptionfailOnExceptionLispAConsQresponse putResponse display_info'clearRunningInfodisplayRunningInfo $fShowLisp $fPrettyLispimpossibleTestCPatFldCPatCAltCBindCExprCDataCon CDeclMetaCExportCImportCModuleCTagHsNameEHCOpts SerializeppPP_Doc putPPFiledispputSerializeFile serialize unserializedefaultEHCOptsmkHsName mkHsName1mkUniqueHsNamemkUnitmkInt mkIntegermkCharmkStringmkError mkUndefinedmkVar mkLet1Plain mkLet1StrictmkLetRecmkLammkAppmkBind1 mkBind1Nm1mkCTag destructCTagctagUnitctagTrue ctagFalsectagConsctagNilmkCasemkAltmkPatConmkPatRestEmpty mkPatFldBindmkTagTupmkModulemkImportmkExport mkMetaData mkMetaDataConmkMetaDataConFromCTagmkMain parseExpr printModuleuhcBackendEnabled$fSerializeCExpr$fSerializeCModule$fSerializeCTag$fSerializeHsName $fPPCExpr $fEqCExpr $fOrdCExpr $fShowCExpr $fShowCTag $fOrdCTag$fEqCTag $fShowHsName $fOrdHsName $fEqHsName MagicTypeInfoMagicConstrInfo HsDataTypeHsUnit MagicName getMagicTypesbuiltinUnitCtor CoreConstrCCMagicCCNormalCoreExprCoreTypeCTMagicCTNormalsetTagcoreConstrToCTag $fEqCoreType$fShowCoreType$fEqCoreConstr$fShowCoreConstr $fPrettyTTermGlobalsglobalsUsesusesmodNameexportsExportexpNamedefnMemberIdGlobalIdLocalIdExpSelfLocalGlobal UndefinedIntegerDoubleLambdaObjectLookupIfBinOpPreOp$fGlobalsModule$fGlobalsExport $fGlobalsExp $fGlobalsMap $fGlobals[] $fUsesExport $fUsesExp $fUsesMap$fUses[] $fEqLocalId $fOrdLocalId $fShowLocalId $fEqGlobalId $fOrdGlobalId$fShowGlobalId $fEqMemberId $fOrdMemberId$fShowMemberId $fShowExp $fShowExport $fShowModuleshift shiftFromshifter substitutermap'subst'applyselffix curriedApply curriedLambdaempvineobjectPrettiesprettiesbrunescape unescapesblockblock'modname$fPrettyModule $fPrettyExp$fPrettyMemberId$fPrettyGlobalId$fPrettyLocalId $fPrettiesMap $fPretties[] wordBoundarypunctparenedbraced bracketedquoted stringLit stringStr stringChrescChrintLitundeflocalidglobalidpreopbinopfieldfunction bracedBlock returnBlockifBlockexp0exp1exp2exp2'exp3exp3'exptopLevelTagPattVarPattTaggedCasepatsbodynumVarsnumVars'lambda'poprefinevisittagstag $fShowTag $fPrettyPatt $fPrettyCase $fShowPatt $fShowCasePhaseParsingDeserializationScopingTyping Termination Positivity InjectivityProjectionLikenessCoverage Highlighting SerializationDeadCodeRecCheckReduceLevelCompareWith BinaryEncodeCompress OperatorsFree OccursCheckCheckLHS UnifyIndicesInverseScopeLookup benchmarksbillToIO billToPure$fMonadBenchPhaseIO $fPrettyPhase $fEqPhase $fOrdPhase $fShowPhase $fEnumPhase$fBoundedPhaseAllowAmbiguousNamesAmbiguousAnythingAmbiguousConstructorsAmbiguousNothing UsingOrHidingAbstractModule AbsModuleamodName amodLineage AbstractNameAbsName anameName anameKind anameLineage WhyInScopeDefinedOpenedApplied KindOfNameConNameFldNameDefNamePatternSynName MacroName QuotableNameInScope inScopeTag InScopeTagNameTag ModuleTag InScopeSetModulesInScope NamesInScope ThingsInScope NameSpacensNames nsModules nsInScopeLocalVar ShadowedVarlocalVarlocalShadowedBy LocalVars ScopeInfo scopeCurrent scopeModules scopeLocalsscopePrecedencescopeInverseNamescopeInverseModule scopeInScopeScopeNameSpaces NameSpaceId PrivateNSPublicNS ImportedNSOnlyQualifiedNS scopeName scopeParentsscopeNameSpaces scopeImportsscopeDatatypeModulelocalNameSpacenameSpaceAccessscopeNameSpaceupdateScopeNameSpacesupdateScopeNameSpacesM shadowLocalnotShadowedLocalnotShadowedLocalsupdateScopeLocalssetScopeLocals mapScopeInfo inNameSpaceallKindsOfNames lensAnameName lensAmodName mergeNamesemptyNameSpace mapNameSpace zipNameSpace mapNameSpaceM emptyScopeemptyScopeInfomapScope mapScope_ mapScope' mapScopeM mapScopeM_zipScope zipScope_recomputeInScopeSets filterScopeallNamesInScopeallNamesInScope'exportedNamesInScope namesInScopeallThingsInScope thingsInScope mergeScope mergeScopessetScopeAccess setNameSpacemodifyNameSpaceaddNamesToScopeaddNameToScoperemoveNameFromScopeaddModuleToScope usingOrHidingapplyImportDirectiverenameCanonicalNamesrestrictPrivaterestrictLocalPrivateremoveOnlyQualifiedinScopeBecause publicModules publicNameseverythingInScope flattenScopeconcreteNamesInScope scopeLookup scopeLookup' isNameInScopeinverseScopeLookupinverseScopeLookup'recomputeInverseScopeMapsinverseScopeLookupNameinverseScopeLookupName'inverseScopeLookupModule blockOfLines$fSetRangeAbstractName$fHasRangeAbstractName$fKillRangeScopeInfo$fShowScopeInfo $fShowScope$fShowNameSpace$fShowNameSpaceId$fShowAbstractModule$fShowAbstractName$fOrdAbstractModule$fEqAbstractModule$fOrdAbstractName$fEqAbstractName$fInScopeAbstractModule$fInScopeAbstractName$fShowLocalVar $fOrdLocalVar $fEqLocalVar $fEqScopeInfo$fEqNameSpaceId$fBoundedNameSpaceId$fEnumNameSpaceId$fEqKindOfName$fShowKindOfName$fEnumKindOfName$fBoundedKindOfName $fEqNameSpace $fEqScope$fEqAllowAmbiguousNames ConPatInfo patOriginpatInfoPatInfoPatRangeLHSInfoLHSRange MutualInfomutualTermCheckmutualPositivityCheck mutualRangeDeclInfodeclName declRangeDefInfo defFixity defAccess defAbstract defInstancedefMacrodefInfoLetInfoLetRange ModuleInfo minfoRange minfoAsTo minfoAsNameminfoOpenShortminfoDirectiveExprInfo ExprRangeMetaInfo metaRange metaScope metaNumbermetaNameSuggestion emptyMetaInfo exprNoRange mkDefInfomkDefInfoInstance patNoRange$fSetRangeConPatInfo$fKillRangeConPatInfo$fHasRangeConPatInfo$fShowConPatInfo$fKillRangeLHSInfo$fHasRangeLHSInfo$fKillRangeMutualInfo$fHasRangeMutualInfo$fKillRangeDeclInfo$fSetRangeDeclInfo$fHasRangeDeclInfo$fKillRangeDefInfo$fSetRangeDefInfo$fHasRangeDefInfo$fKillRangeLetInfo$fHasRangeLetInfo$fKillRangeModuleInfo$fSetRangeModuleInfo$fHasRangeModuleInfo$fKillRangeExprInfo$fHasRangeExprInfo$fKillRangeMetaInfo$fHasRangeMetaInfo$fShowMetaInfo $fEqMetaInfo$fShowExprInfo $fEqExprInfo$fNullExprInfo$fEqModuleInfo $fShowLetInfo $fEqLetInfo $fNullLetInfo$fShowDeclInfo $fEqDeclInfo $fShowDefInfo $fEqDefInfo$fShowMutualInfo$fEqMutualInfo $fShowLHSInfo $fEqLHSInfo $fNullLHSInfo $fEqPatInfo $fNullPatInfo $fShowPatInfo$fHasRangePatInfo$fKillRangePatInfo$fEqConPatInfo$fShowModuleInfodontDescendIntoinstanceUniverseBiT'instanceTransformBiMT'IsProjPisProjPPatternsPattern'DefP PatternSynP LHSToSpine lhsToSpine spineToLhsLHSCore'lhsInfolhsCore lhsWithPatsSpineLHS spLhsInfo spLhsDefName spLhsPats spLhsWithPatsWithRHS RewriteRHS SpineClauseClause' clauseLHS clauseRHSclauseWhereDeclsclauseCatchall LetBindingLetBind LetPatBindLetApplyLetOpenLetDeclaredVariableBuiltinNoDefPragma GetDefInfo getDefInfoSectionRecSig PatternSynDef ScopedDeclRenNoFunSig RecordAssigns RecordAssignAssignsAssignProj ScopedExprlhsCoreToSpinespineToLhsCore lhsCoreApplhsCoreAddSpinelhsCoreAllPatternslhsCoreToPattern mapLHSHead$fKillRangeLetBinding$fKillRangeRHS$fKillRangeClause'$fKillRangeLHSCore'$fKillRangeSpineLHS$fKillRangePattern'$fKillRangeTypedBinding$fKillRangeTypedBindings$fKillRangeLamBinding$fSetRangePattern'$fHasRangeLetBinding $fHasRangeRHS$fHasRangeClause'$fHasRangeLHSCore'$fHasRangeSpineLHS$fHasRangePattern'$fHasRangeTypedBinding$fHasRangeTypedBindings$fHasRangeLamBinding$fLensHidingLamBinding$fLensHidingTypedBindings$fUnderscoreExpr$fEqDeclaration$fEqExpr$fIsProjPNamed $fIsProjPArg$fIsProjPPattern'$fLHSToSpineLHSSpineLHS$fLHSToSpine[][]$fLHSToSpineClause'Clause'$fEqLHS$fGetDefInfoDeclaration $fEqAxiom $fOrdAxiom $fShowAxiom$fShowPattern'$fFunctorPattern'$fFoldablePattern'$fTraversablePattern' $fEqPattern'$fShowLHSCore'$fFunctorLHSCore'$fFoldableLHSCore'$fTraversableLHSCore' $fEqLHSCore' $fShowClause'$fFunctorClause'$fFoldableClause'$fTraversableClause' $fEqClause' $fShowRHS$fEqRHS$fShowTypedBindings$fEqTypedBindings$fShowTypedBinding$fEqTypedBinding$fShowLetBinding$fEqLetBinding$fEqModuleApplication$fShowLamBinding$fEqLamBinding $fEqPragma$fShowSpineLHS $fEqSpineLHS$fUniverseBiDeclarationQName%$fUniverseBiDeclarationAmbiguousQName$fUniverseBiDeclarationExpr!$fUniverseBiDeclarationLetBinding!$fUniverseBiDeclarationLamBinding#$fUniverseBiDeclarationTypedBinding$fUniverseBiDeclarationPattern' $fUniverseBiDeclarationPattern'0"$fUniverseBiDeclarationDeclaration!$fUniverseBiDeclarationModuleName!$fUniverseBiDeclarationModuleInfo SubstExpr substExprPatternSynDefnsPatternSynDefn AnyAbstract anyAbstractAllNamesallNames axiomNamenameExprapp patternToExprlambdaLiftExpr substPatterninsertImplicitPatSynArgs$fSubstExprTypedBinding$fSubstExprTypedBindings$fSubstExprLetBinding$fSubstExprExpr$fSubstExprFieldAssignment'$fSubstExprModuleName$fSubstExprName$fSubstExprEither$fSubstExpr(,)$fSubstExprNamed$fSubstExprArg $fSubstExpr[]$fAnyAbstractDeclaration$fAnyAbstract[]$fAllNamesModuleApplication$fAllNamesLetBinding$fAllNamesTypedBinding$fAllNamesTypedBindings$fAllNamesLamBinding$fAllNamesExpr $fAllNamesRHS$fAllNamesClause'$fAllNamesDeclaration$fAllNamesQName $fAllNames(,)$fAllNamesNamed $fAllNamesArg$fAllNamesMaybe $fAllNames[]$fUniverseBiDeclarationRanged recurseExpr Application unAppViewasViewisSetunScope deepUnscopedeepUnscopeDeclsdeepUnscopeDecl$fExprLikeSpineLHS$fExprLikeLHSCore'$fExprLikePragma $fExprLikeRHS$fExprLikeClause'$fExprLikePattern'$fExprLikeLetBinding$fExprLikeTypedBinding$fExprLikeTypedBindings$fExprLikeLamBinding$fExprLikeModuleName$fExprLikeVoidTermSizetermSizetsize IsProjElim isProjElimSuggestsuggestSgTelsgTel EqualityView EqualityType OtherTypeeqtSorteqtNameeqtLeveleqtTypeeqtLhseqtRhsPatternSubstitution Substitution Substitution'IdSEmptyS:# StrengthenWkLiftConPatternInfo conPRecordconPTypeDeBruijnPattern PatVarName ClauseBody ClauseBodyFBodyBindNoBody clauseRange clauseTelnamedClausePats clauseBody clauseTypeBlocked_Blocked NotBlockedtheBlockingMetaignoreBlockingblockingStatusStuckOn Underapplied AbsurdMatchMissingClausesReallyNotBlocked LevelAtom MetaLevel BlockedLevel NeutralLevelUnreducedLevel PlusLevel ClosedLevelMaxInfSizeUnivDLubTeleEmptyTel ExtendTelLensSortlensSortgetSortType'El_getSortunElNoAbsabsNameunAbsArgNameMetaVShared LensConName getConName setConName mapConNameConHeadconName conInductive conFields NamedArgsargNameToStringstringToArgNameappendArgNames nameToArgName mapAbsNamesM mapAbsNamesreplaceEmptyNamestuckOn clausePatsimapClauseBodypatVarNameToStringnameToPatVarName namedVarP namedDBVarPnoConPatternInfo patternVarsproperlyMatchingisEqualityType absurdBody isAbsurdBodyabsurdPatternNameisAbsurdPatternName ignoreSharingignoreSharingTypeshared_updateSharedFM updateSharedM updateShared pointerChaincompressPointerChainvardontCare typeDontCaretopSortsortvarSortsSuclevelSucmkTypeimpossibleTermhackReifyToMetaisHackReifyToMeta blockingMetablocked notBlocked stripDontCarearitynotInScopeNameunSpinehasElims argFromElim isApplyElim allApplyElimssplitApplyElims dropProjElims argsFromElims allProjElims$fKillRangeElim'$fKillRangeAbs$fKillRangeBlocked$fKillRangeTele$fKillRangeClauseBodyF$fKillRangeClause$fKillRangeConPatternInfo$fKillRangeSubstitution'$fKillRangeSort$fKillRangeType'$fKillRangeLevelAtom$fKillRangePlusLevel$fKillRangeLevel$fKillRangeTerm$fKillRangeConHead$fTermSizeSubstitution'$fTermSizeLevelAtom$fTermSizePlusLevel$fTermSizeLevel$fTermSizeSort$fTermSizeTerm $fTermSizet $fSizedAbs $fSizedTele $fNullClause$fNullClauseBodyF $fNullTele$fIsProjElimElim'$fSuggestNameAbs$fSuggest[]Abs$fSuggestAbsAbs $fSuggest[][] $fSgTelDom $fSgTelDom0 $fSgTel(,)$fHasRangeClause$fMonoidBlocked$fApplicativeBlocked$fMonoidNotBlocked $fLensSortAbs $fLensSortDom$fLensSortType'$fDecorationType'$fDecorationAbs$fLensConNameConHead$fSetRangeConHead$fHasRangeConHead $fShowConHead $fOrdConHead $fEqConHead$fFunctorElim'$fFoldableElim'$fTraversableElim' $fFunctorAbs $fFoldableAbs$fTraversableAbs $fShowTele $fFunctorTele$fFoldableTele$fTraversableTele$fShowNotBlocked $fShowLevel$fShowPlusLevel$fShowLevelAtom $fShowType'$fFunctorType'$fFoldableType'$fTraversableType' $fShowBlocked$fFunctorBlocked$fFoldableBlocked$fTraversableBlocked$fShowClauseBodyF$fFunctorClauseBodyF$fFoldableClauseBodyF$fTraversableClauseBodyF$fShowConPatternInfo$fShowSubstitution'$fFunctorSubstitution'$fFoldableSubstitution'$fTraversableSubstitution'$fUniverseBi(,)Pattern'$fUniverseBi[]Pattern'$fUniverseBi[]Pattern'0$fUniverseBi(,)Term$fUniverseBi[]Term$fUniverseBi[]Term0$fPrettyClauseBodyF$fPrettyPattern' $fPrettyElim' $fPrettyType' $fPrettySort$fPrettyLevelAtom$fPrettyPlusLevel $fPrettyLevel $fPrettyTerm$fPrettySubstitution'$fUniverseBi[]Term1 EInterface constrTags definitions defDelayedconAritymainName relevantArgs forcedArgs injectiveFuns InjectiveFuninjArginjArity RelevantArgs ForcedArgsIrrRel NotForcedPrimTagpairwiseFilter notForcedforced$fMonoidEInterface$fEqTag$fOrdTag $fShowForced $fEqForced$fShowInjectiveFun$fEqInjectiveFun$fShowEInterfaceBranchBrIntDefaultbrTagbrNamebrVarsbrExprbrIntUNIT IMPOSSIBLELIntLCharLStringLFloatEpicFun funInlinefunNamefunQName funCommentfunArgsfunExpr funEpicCodeInline getBrVarslettlazycaseeappssubsts substBranchfv $fShowLit$fOrdLit$fEqLit $fShowBranch $fOrdBranch $fEqBranch $fOrdExpr$fEqFun$fOrdFun $fShowFunGetDefsgetDefs MonadGetDefsdoDefdoMeta GetDefsEnv lookupMetaembDefGetDefsMgetDefs' $fGetDefs(,) $fGetDefsAbs $fGetDefsDom $fGetDefsArg$fGetDefsElim' $fGetDefs[]$fGetDefsMaybe$fGetDefsLevelAtom$fGetDefsPlusLevel$fGetDefsLevel $fGetDefsSort$fGetDefsType'$fGetDefsMetaId $fGetDefsTerm$fGetDefsClauseBodyF$fGetDefsClause$fMonadGetDefsReaderTTermLike traverseTerm traverseTermMfoldTermcopyTerm$fTermLikeEqualityView$fTermLikeType'$fTermLikeLevelAtom$fTermLikePlusLevel$fTermLikeLevel$fTermLikeTerm $fTermLikePtr $fTermLikeAbs$fTermLike(,,,)$fTermLike(,,) $fTermLike(,)$fTermLikeMaybe $fTermLike[] $fTermLikeDom $fTermLikeArg$fTermLikeElim'$fTermLikeQName$fTermLikeChar$fTermLikeInteger $fTermLikeInt$fTermLikeBool LabelPatVars labelPatVarsunlabelPatVarsFunArityfunArity clauseArgs clauseElimsunnumberPatVars dbPatPerm clausePerm patternToElimpatternsToElims patternToTerm$fLabelPatVarsPattern'Pattern'i$fLabelPatVars[][]i$fLabelPatVarsNamedNamedi$fLabelPatVarsArgArgi $fFunArity[]$fFunArityClause $fFunArity[]0CompiledClausesDoneFailBranches projPatterns conBranches litBranchescatchAllBranch WithAritycontentlitCaseconCaseprojCasecatchAll hasCatchAll prettyMap$fKillRangeCompiledClauses$fKillRangeCase$fKillRangeWithArity$fPrettyCompiledClauses$fPrettyWithArity$fShowCompiledClauses $fNullCase $fMonoidCase$fMonoidWithArity$fFunctorWithArity$fFoldableWithArity$fTraversableWithArity $fFunctorCase$fFoldableCase$fTraversableCaseMatchLit BlockingVars BlockingVar blockingVarNoblockingVarConsMatchYesNoBlockBlockPMPatVarMPConMPLitMPDotMPWildMPProjMPisTrivialMPatternmapBlockingVarConsclearBlockingVarConszipBlockingVars noMatchLit yesMatchLit matchLits matchClause matchPatsmatchPat $fMonoidMatch $fShowMPat$fShowBlockingVar$fFunctorMatchCNameSplitTreeLabellblConstructorName lblSplitArg lblBindings SplitTrees' SplitTree' SplittingDoneSplitAt splitBindingssplitArg splitTrees SplitTrees SplitTreetoTreetoTreestestSplitTreePrinting$fArbitraryCName $fShowCName$fArbitrarySplitTree'$fShowSplitTree'$fShowSplitTreeLabelFree' freeVars'FreeM SingleVarVariableFreeEnv feIgnoreSorts feBinders feFlexRig feRelevance feSingleton IgnoreSorts IgnoreNotIgnoreInAnnotations IgnoreAllVarMapVarOcc varFlexRig varRelevanceFlexRigFlexible WeaklyRigid Unguarded StronglyRigidcomposeFlexRig maxVarOcc topVarOcc botVarOcc initFreeEnvvariablebindgogoRelunderConstructor$fArbitraryVarOcc$fArbitraryFlexRig$fFree'EqualityViewc$fFree'Clausec$fFree'ClauseBodyFc $fFree'Telec $fFree'Absc $fFree'Domc $fFree'Argc $fFree'Elim'c $fFree'(,)c $fFree'Maybec $fFree'[]c$fFree'LevelAtomc$fFree'PlusLevelc $fFree'Levelc $fFree'Sortc $fFree'Type'c $fFree'Termc$fMonoidReaderT $fEqFlexRig $fOrdFlexRig $fShowFlexRig $fEqVarOcc $fShowVarOcc$fEqIgnoreSorts$fShowIgnoreSorts NoOccurrence IrrelevantlyFreeVarsFVstronglyRigidVars unguardedVarsweaklyRigidVars flexibleVarsirrelevantVars unusedVars rigidVars relevantVarsallVars occurrencefreeVarsfreeVarsIgnorefreeInfreeInIgnoringSortsfreeInIgnoringSortAnnrelevantInIgnoringSortAnn relevantIn isBinderUsed $fFreeClause$fFreeClauseBodyF $fFreeTele $fFreeAbs $fFreeDom $fFreeArg $fFreeElim' $fFree(,) $fFreeMaybe$fFree[]$fFreeLevelAtom$fFreePlusLevel $fFreeLevel $fFreeSort $fFreeType' $fFreeTerm$fMonoidFreeVars $fEqFreeVars$fShowFreeVarsFreeVSFreeVrunFreeclosed allFreeVarsallRelevantVarsIgnoringallRelevantVars$fSingleton(,)FreeVars$fNullFreeVarsIMMonadTCMliftTCMReduceM unReduceM ReduceEnvredEnvredStTCErr TypeError Exception IOException PatternErr LHSOrPatSynIsLHSIsPatSyn InternalErrorNotImplemented NotSupportedCompilationErrorTerminationCheckFailedPropMustBeSingletonDataMustEndInSort#ShouldEndInApplicationOfTheDatatype&ShouldBeAppliedToTheDatatypeParametersShouldBeApplicationOf!ConstructorPatternInWrongDatatype!IndicesNotConstructorApplicationsIndexVariablesNotDistinctIndicesFreeInParameters6CantResolveOverloadedConstructorsTargetingSameDatatypeDoesNotConstructAnElementOfDifferentAritiesWrongHidingInLHSWrongHidingInLambdaWrongHidingInApplicationWrongNamedArgumentWrongIrrelevanceInLambdaWrongInstanceDeclarationHidingMismatchRelevanceMismatch NotInductiveUninstantiatedDotPatternIlltypedPatternIllformedProjectionPatternCannotEliminateWithPatternTooManyArgumentsInLHS!WrongNumberOfConstructorArguments ShouldBeEmpty ShouldBeASort ShouldBePiShouldBeRecordTypeShouldBeRecordPatternNotAProjectionPatternNotAProperTermSetOmegaNotValidTypeInvalidTypeSort InvalidTypeFunctionTypeInSizeUnivSplitOnIrrelevantDefinitionIsIrrelevantVariableIsIrrelevant UnequalTerms UnequalTypesUnequalRelevance UnequalHiding UnequalSorts UnequalBecauseOfUniverseConflictHeterogeneousEquality NotLeqSortMetaCannotDependOnMetaOccursInItself GenericErrorGenericDocErrorBuiltinMustBeConstructorNoSuchBuiltinNameDuplicateBuiltinBindingNoBindingForBuiltinNoSuchPrimitiveFunctionShadowedModuleBuiltinInParameterisedModuleIllegalLetInTelescopeNoRHSRequiresAbsurdPatternAbsurdPatternRequiresNoRHS TooFewFields TooManyFieldsDuplicateFieldsDuplicateConstructorsWithOnFreeVariableUnexpectedWithPatternsWithClausePatternMismatchFieldOutsideRecordModuleArityMismatchIncompletePatternMatchingCoverageFailureUnreachableClausesCoverageCantSplitOnCoverageCantSplitIrrelevantTypeCoverageCantSplitTypeCoverageNoExactSplit WithoutKError UnifyConflict UnifyCycleUnifyIndicesNotVarsUnificationRecursiveEqUnificationStuck SplitErrorNotStrictlyPositiveLocalVsImportedModuleClash UnsolvedMetasUnsolvedConstraintsSolvedButOpenHolesCyclicModuleDependency FileNotFoundOverlappingProjectsAmbiguousTopLevelModuleNameModuleNameDoesntMatchFileNameClashingFileNamesForModuleDefinedInOtherFileBothWithAndRHS NotInScope NoSuchModule AmbiguousNameAmbiguousModuleUninstantiatedModuleClashingDefinitionClashingModuleClashingImportClashingModuleImportPatternShadowsConstructorModuleDoesntExportDuplicateImportsInvalidPatternRepeatedVariablesInPatternNotAModuleExprNotAnExpressionNotAValidLetBindingNothingAppliedToHiddenArgNothingAppliedToInstanceArgBadArgumentsToPatternSynonymTooFewArgumentsToPatternSynonymUnusedVariableInPatternSynonymNoParseForApplicationAmbiguousParseForApplication NoParseForLHSAmbiguousParseForLHSOperatorInformationOperatorChangeMessageIFSNoCandidateInScope UnquoteFailedSafeFlagPostulateSafeFlagPragmaSafeFlagNonTerminatingSafeFlagTerminatingSafeFlagPrimTrustMeSafeFlagNoPositivityCheckNeedOptionCopatternsNeedOptionRewriting UnquoteError BadVisibilityConInsteadOfDefDefInsteadOfCon NonCanonical BlockedOnMeta UnquotePanic NotADatatypeIrrelevantDatatypeCoinductiveDatatype CantSplitGenericSplitErrorcantSplitConName cantSplitTelcantSplitConIdxcantSplitGivenIdxTerminationErrortermErrFunctions termErrCallsCallInfocallInfoTarget callInfoRange callInfoCallOccPos NonPositively ArgumentToOccOccCon OccClause occDatatypeoccConstructor occPosition occFunction occClause Candidate candidateTerm candidateType candidateEtiExplicitToInstanceExplicitStayExplicit ExpandHidden ExpandLastDontExpandLast AbstractMode ConcreteModeIgnoreAbstractMode LetBindingsCtxId ContextEntryCtxctxIdctxEntryContext envContextenvLetBindingsenvCurrentModuleenvCurrentPathenvAnonymousModules envImportPathenvMutualBlockenvTerminationCheckenvSolvingConstraintsenvCheckingWhereenvAssignMetasenvActiveProblemsenvAbstractMode envRelevanceenvDisplayFormsEnabledenvReifyInteractionPointsenvEtaContractImplicitenvRangeenvHighlightingRangeenvCallenvHighlightingLevelenvHighlightingMethodenvModuleNestingLevelenvAllowDestructiveUpdate envExpandLast envAppDefenvSimplificationenvAllowedReductionsenvCompareBlockedenvPrintDomainFreePienvInsideDotPatternHighlightingMethodDirectIndirectHighlightingLevelNoneNonInteractive InteractiveBuiltinPrim BuiltinThings BuiltinInfo builtinName builtinDescBuiltinDescriptor BuiltinDataBuiltinDataCons BuiltinPrimBuiltinPostulateBuiltinUnknownTempInstanceTable InstanceTable CheckClause CheckPatternCheckLetBinding InferExpr CheckExprCallCheckDotPatternCheckPatternShadowingCheckProjection IsTypeCallIsType_InferVarInferDefCheckArguments CheckDataDef CheckRecDefCheckConstructor CheckFunDef CheckPragmaCheckPrimitive CheckIsEmptyCheckWithFunctionTypeCheckSectionApplicationScopeCheckExprScopeCheckDeclaration ScopeCheckLHSNoHighlightingModuleContents StatisticsMutualIdMutIdTermHeadSortHeadPiHeadConsHeadFunctionInverse' NotInjectiveInverseFunctionInversePrimFun primFunName primFunArityprimFunImplementationAllowedReductionsAllowedReductionProjectionReductionsInlineReductionsCopatternReductionsFunctionReductionsLevelReductionsNonTerminatingReductionsMaybeReducedElimsMaybeReducedArgs MaybeReducedMaybeRed isReduced ignoreReduced IsReduced NotReducedReduced NoReduction YesReductionSimplificationYesSimplificationNoSimplificationFieldsDefn funClauses funCompiled funTreelessfunInv funMutualfunAbstr funDelayed funProjection funStatic funSmashable funTerminates funExtLamfunWithfunCopatternLHSdataPars dataSmallParsdataNonLinParsdataIxs dataInduction dataClausedataConsdataSort dataMutual dataAbstrrecPars recClause recConHead recNamedCon recConType recFieldsrecTel recMutualrecEtaEquality' recInduction recRecursiverecAbstrconPars conSrcConconDataconAbstrconInd primAbstrprimName primClauses primCompiled EtaEquality SpecifiedInferred Projection projProper projFromType projIndex projDropPars projArgInfo ExtLamInfoextLamNumHiddenextLamNumNonHidCompiledRepresentation CompiledRepcompiledHaskell exportHaskell compiledEpic compiledJS compiledCore Covariant Contravariant Invariant NonvariantCoreRepresentationCrDefnCrTypeCrConstr HaskellExportHsExportHaskellRepresentationHsDefnHsTypeJSCodeEpicCode HaskellType HaskellCode defArgInfodefNamedefType defPolaritydefArgOccurrences defDisplay defMutualdefCompiledRepdefCopytheDef RewriteRulerewName rewContextrewLHSrewRHSrewType RewriteRulesPElimsNLPatPVarPWildPDefPLamPPi PBoundVarPTerm DisplayTermDWithAppDConDDefDDotDTerm DisplayFormDisplay dfFreeVarsdfPatsdfRHS _secTelescope DisplayFormsRewriteRuleMap DefinitionsSections SignatureSig _sigSections_sigDefinitions_sigRewriteRulesInteractionPointsInteractionPointipRangeipMeta MetaStore NamedMeta nmSuggestionnmidMetaNameSuggestion miClosRangemiMetaOccursCheckmiNameSuggestionRunMetaOccursCheckDontRunMetaOccursCheck MetaPriorityTypeCheckingProblem CheckExpr CheckArgs CheckLambda UnquoteTacticMetaInstantiationInstVInstSOpenIFS BlockedConstPostponedTypeCheckingProblemFrozen InstantiableListener EtaExpandCheckConstraint MetaVariableMetaVarmvInfo mvPriority mvPermutation mvJudgementmvInstantiation mvListenersmvFrozen JudgementHasTypeIsSortjMetaId jMetaType OpenThingopenThingCtxIds openThingCompareDirectionDirEqDirLeqDirGeq ComparisonCmpEqCmpLeqValueCmpElimCmpTypeCmpTelCmpSortCmpLevelCmpUnBlockGuardedIsEmptyCheckSizeLtSat FindInScopeProblemConstraintPConstrconstraintProblems theConstraintClosure clSignatureclEnvclScopeclValue Interface iSourceHashiImportedModules iModuleNameiScope iInsideScope iSignature iDisplayFormsiBuiltiniHaskellImportsiHaskellImportsUHC iHaskellCode iHighlightingiPragmaOptions iPatternSynsDecodedModulesVisitedModules miInterface miWarningsSourceToModule FreshName freshName_ ProblemIdHasFresh freshLens nextFresh'TypeCheckAction EnterSection LeaveSectionDeclPragmasCurrentTypeCheckLogCachedTypeCheckLogLoadedFileCache lfcCached lfcCurrentPersistentTCStatePersistentTCStstDecodedModulesstPersistentOptionsstInteractionOutputCallback stBenchmarkstAccumStatisticsstLoadedFileCachePostScopeStatestPostSyntaxInfostPostDisambiguatedNamesstPostMetaStorestPostInteractionPointsstPostAwakeConstraintsstPostSleepingConstraints stPostDirtystPostOccursCheckDefsstPostSignaturestPostImportsDisplayFormsstPostImportedDisplayFormsstPostCurrentModulestPostInstanceDefsstPostStatisticsstPostMutualBlocksstPostLocalBuiltinsstPostFreshMetaIdstPostFreshMutualIdstPostFreshCtxIdstPostFreshProblemIdstPostFreshIntstPostFreshNameIdDisambiguatedNames PreScopeState stPreTokens stPreImportsstPreImportedModulesstPreModuleToSourcestPreVisitedModules stPreScopestPrePatternSynsstPrePatternSynImportsstPrePragmaOptionsstPreImportedBuiltinsstPreHaskellImportsstPreHaskellImportsUHCstPreHaskellCodestPreFreshInteractionId ReadTCState getTCStateTCStstPreScopeStatestPostScopeStatestPersistentStateinitPersistentStateinitPreScopeStateinitPostScopeStatestTokens stImportsstImportedModulesstModuleToSourcestVisitedModulesstScope stPatternSynsstPatternSynImportsstPragmaOptionsstImportedBuiltinsstHaskellImportsstHaskellImportsUHC stHaskellCodestFreshInteractionId stFreshNameId stSyntaxInfostDisambiguatedNames stMetaStorestInteractionPointsstAwakeConstraintsstSleepingConstraintsstDirtystOccursCheckDefs stSignaturestImportsDisplayFormsstImportedDisplayFormsstCurrentModulestInstanceDefs stStatisticsstMutualBlocksstLocalBuiltins stFreshMetaIdstFreshMutualId stFreshCtxIdstFreshProblemId stFreshIntstBuiltinThings nextFreshfresh freshName freshNoName freshNoName_sourceToModule iFullHash buildClosurefromCmpflipCmpdirToCmpnormalMetaPrioritylowMetaPriorityhighMetaPriority getMetaInfo getMetaScope getMetaEnv getMetaSiggetMetaRelevance sigSectionssigDefinitionssigRewriteRules secTelescopeemptySignaturedefaultDisplayForm defRelevance defaultDefn noCompiledRepetaEqualityToBoolsetEtaEqualityrecEtaEquality emptyFunctionisEmptyFunctionisCopatternLHSrecCon defIsRecorddefIsDataOrRecord notReducedreduced allReductions defClauses defCompiled defParametersdefJSDef defEpicDef defCoreDefdefNonterminating ifTopLevelAndHighlightingLevelIsinitEnvdisableDestructiveUpdate mapRedEnvmapRedSt mapRedEnvSt runReduceM runReduceFrunIM catchError_finally_mapTCMTpureTCM returnTCMTbindTCMTthenTCMTfmapTCMTapTCMTpatternViolation internalError genericError typeError typeError_runTCM runTCMTop runTCMTop' runSafeTCMforkTCMextendedLambdaNameabsurdLambdaNameisAbsurdLambdaName$fKillRangeDisplayTerm$fKillRangePolarity$fKillRangeDisplayForm$fKillRangeOpen$fKillRangeProjection$fKillRangeTermHead$fKillRangeFunctionInverse'$fKillRangeMutualId$fKillRangeDefn$fKillRangeExtLamInfo$fKillRangeEtaEquality!$fKillRangeCompiledRepresentation$fKillRangeRewriteRule$fKillRangeNLPat$fKillRangeCtxId$fKillRangeDefinition$fKillRangeSection$fKillRangeHashMap$fKillRangeHashMap0$fKillRangeSignature $fMonoidTCMT $fNullTCMT$fMonadBenchPhaseTCMT $fMonadIOTCMT$fApplicativeTCMT $fFunctorTCMT $fMonadTCMT$fMonadTransTCMT$fMonadTCMWriterT$fMonadTCMExceptT$fMonadTCMListT$fMonadTCMMaybeT$fMonadTCMTCMT$fMonadErrorTCErrTCMT$fMonadErrorTCErrTCMT0$fReadTCStateTCMT$fMonadStateTCStateTCMT$fMonadReaderTCEnvTCMT$fMonadReaderTCEnvReduceM$fReadTCStateReduceM$fMonadReduceM$fApplicativeReduceM$fFunctorReduceM$fExceptionTCErr$fHasRangeTCErr $fShowTCErr $fErrorTCErr$fErrorUnquoteError$fErrorSplitError$fAllNamesCallInfo$fPrettyCallInfo$fShowCallInfo$fHasRangeCall $fPrettyCall$fIsProjElimMaybeReduced$fMonoidSimplification$fNullSimplification$fEqInteractionPoint$fSetRangeMetaVariable$fSetRangeMetaInfo$fHasRangeMetaVariable$fPrettyNamedMeta$fShowMetaInstantiation $fOrdListener $fEqListener$fShowJudgement$fShowCompareDirection$fPrettyComparison$fShowComparison$fHasRangeConstraint$fHasRangeProblemConstraint$fHasRangeClosure $fShowClosure$fPrettyInterface $fFreshName()$fFreshNameRange' $fFreshName[]$fFreshName(,)$fHasFreshProblemId$fPrettyProblemId$fShowProblemId $fHasFreshInt$fHasFreshCtxId$fHasFreshNameId$fHasFreshInteractionId$fHasFreshMutualId$fHasFreshMetaId $fShowTCState$fEqComparison$fEqCompareDirection $fEqFrozen $fShowFrozen$fEqMetaPriority$fOrdMetaPriority$fShowMetaPriority$fEqRunMetaOccursCheck$fOrdRunMetaOccursCheck$fShowRunMetaOccursCheck$fShowHaskellRepresentation$fShowHaskellExport$fEqExtLamInfo$fOrdExtLamInfo$fShowExtLamInfo$fShowEtaEquality$fEqSimplification$fShowSimplification$fFunctorReduced$fShowAllowedReduction$fEqAllowedReduction$fOrdAllowedReduction$fEnumAllowedReduction$fBoundedAllowedReduction $fEqMutualId $fOrdMutualId$fShowMutualId $fNumMutualId$fEnumMutualId$fEqHighlightingLevel$fOrdHighlightingLevel$fShowHighlightingLevel$fReadHighlightingLevel$fEqHighlightingMethod$fShowHighlightingMethod$fReadHighlightingMethod$fShowAbstractMode$fEqExpandHidden$fEqExplicitToInstance$fShowExplicitToInstance$fEqLHSOrPatSyn$fShowLHSOrPatSyn $fShowOpen $fFunctorOpen $fEqCtxId $fOrdCtxId $fShowCtxId $fEnumCtxId $fRealCtxId$fIntegralCtxId $fNumCtxId$fShowInterface $fShowBuiltin$fFunctorBuiltin$fFoldableBuiltin$fTraversableBuiltin$fShowDisplayForm$fShowDisplayTerm$fShowSignature$fShowRewriteRule $fShowNLPat $fShowDefn$fShowFunctionInverse'$fFunctorFunctionInverse' $fEqTermHead $fOrdTermHead$fShowTermHead$fShowProjection$fShowCompiledRepresentation$fShowCoreRepresentation $fShowSection$fFunctorMaybeReduced$fShowProblemConstraint$fShowCandidate $fEqProblemId$fOrdProblemId$fEnumProblemId$fRealProblemId$fIntegralProblemId$fNumProblemId$fShowUnquoteError $fShowOccPos $fShowOcc $fNullFields$fShowSplitError$fShowTerminationError$fShowTypeErrorhighlightAsTypeCheckedscopeCheckImport showOpenMetasPSynNamesInnamesInnamesInFoldable$fNamesInAmbiguousQName$fNamesInPattern' $fNamesInPSyn$fNamesInDisplayTerm$fNamesInDisplayForm $fNamesInOpen$fNamesInConHead$fNamesInQName$fNamesInElim'$fNamesInLiteral$fNamesInLevelAtom$fNamesInPlusLevel$fNamesInLevel $fNamesInTerm $fNamesInSort$fNamesInType'$fNamesInPattern'0 $fNamesInCase$fNamesInCompiledClauses$fNamesInClause $fNamesInDefn$fNamesInDefinition $fNamesIn(,,) $fNamesIn(,)$fNamesInFieldAssignment'$fNamesInClauseBodyF $fNamesInTele$fNamesInWithArity $fNamesInAbs$fNamesInNamed $fNamesInDom $fNamesInArg $fNamesIn[]$fNamesInMaybeinfer checkInternal checkTypecompileClausesmatchCompiledE matchCompileddebugConstraintsguardConstraintifNoConstraints_ noConstraintssolveAwakeConstraints'solveConstraintcatchConstraint prettyError ConditionallMetas newTelMetanewNamedValueMeta newValueMeta newIFSMetaassignassignVetaExpandMetaSafe assignTerm newArgsMeta newArgsMeta' getContextId getContext currentModulewithCurrentModulegetAnonymousVariableswithAnonymousModulewithEnvgetEnvwithIncreasedModuleNestingLevelwithHighlightingLevel doExpandLastdontExpandLastperformedSimplificationperformedSimplification'getSimplificationupdateAllowedReductionsmodifyAllowedReductionsputAllowedReductionsonlyReduceProjectionsallowAllReductionsallowNonTerminatingReductionsinsideDotPatternisInsideDotPatternMonadExceptionthrowExceptioncatchException ExceptionT runExceptionT$fMonadTCMExceptionT$fMonadIOExceptionT$fMonadErrorerr'ExceptionT$fMonadReaderrExceptionT$fMonadStatesExceptionT$fApplicativeExceptionT$fFunctorExceptionT$fMonadTransExceptionT$fMonadExceptionerrStateT$fMonadExceptionerrWriterT$fMonadExceptionerrReaderT$fMonadExceptionerrExceptionT$fMonadExceptionT addImportaddImportCycleCheck getImports isImported getImportPath visitModulesetVisitedModulesgetVisitedModules isVisitedgetVisitedModulegetDecodedModulessetDecodedModulesgetDecodedModulestoreDecodedModuledropDecodedModulewithImportPathcheckForImportCycle HasOptions pragmaOptionscommandLineOptions VerboseKey reportSDoc reportSLnverboseS hasVerbositygetIncludeDirs composePolcomputePolarityeligibleForProjectionLikemakeProjectionrewriteverifyBuiltinRewrite unquoteTacticcheckPostponedLambdacheckArguments'checkArguments inferExpr checkExprisType_EmbPrjicodeicod_valueSStnodeEstringEbstringEintegerEdoubleEnodeMemomodFileincludesmkSharedMemoUDictnodeDstringDbstringDintegerDdoubleDtermDnameDqnameDnodeCstringCbstringCintegerCdoubleCtermCnameCqnameCstats collectStatsabsPathDQNameId FreshAndReusefarFreshfarReuse HashTablefarEmpty lensFresh lensReuseqnameId emptyDict malformed tickICode runGetStateicodeX icodeInteger icodeDouble icodeStringicodeN icodeMemovcaseicode0icode1icode2icode3icode4icode5icode6icode7icode8icode9icode10icode11icode12icode13icode14icode15icode0'icode1'icode2'icode3'icode4'icode5'icode6'icode7'icode8'icode9'icode10'icode11'icode12'icode13'icode14'valu0valu1valu2valu3valu4valu5valu6valu7valu8valu9valu10valu11valu12valu13valu14valu15GetBodygetBodygetBodyUnraised TeleNoAbs teleNoAbsListTelListTel'TelVtheTeltheCoreTelViewSubst applySubstDeBruijn debruijnVardebruijnNamedVar debruijnViewabstractapplyEapplysapply1 canProjectconAppdefApp argToDontCarepiApplytelVars namedTelVars abstractArgsidSwkSraiseSconsS singletonSdropScomposeSsplitS++#prependS parallelScompactS strengthenSlookupSraise raiseFrom strengthen substUnder telFromList' telFromList telToList telToArgs bindsToTel' bindsToTelbindsWithHidingToTel'bindsWithHidingToTeltelView' telView'UpTomkPitelePi'telePitelePi_teleLamdLubabsApp lazyAbsAppnoabsAppabsBodymkAbsreAbsunderAbs underLambdasptssLublvlViewlevelMaxsortTm levelSortlevelTm unLevelAtom$fOrdAbs$fEqAbs $fOrdTerm$fEqTerm $fOrdType' $fEqType' $fEqLevelAtom$fOrdPlusLevel$fGetBodyClause$fGetBodyClauseBodyF$fTeleNoAbsTele $fTeleNoAbs[]$fSubstTermEqualityView$fSubstTermCandidate$fSubstTermClauseBodyF $fSubstt(,,,) $fSubstt(,,) $fSubstt(,) $fSubstTerm() $fSubstt[] $fSubsttMaybe $fSubsttDom $fSubsttNamed $fSubsttArg $fSubsttAbs $fSubsttElim'$fSubstTermConstraint $fSubsttTele$fSubstTermDisplayTerm$fSubstTermDisplayForm$fSubsttBlocked$fSubstTermRewriteRule$fSubstTermNLPat$fSubstTermPattern'$fSubstTermConPatternInfo $fSubstTerm[]$fSubstTermName$fSubstTermLevelAtom$fSubstTermPlusLevel$fSubstTermLevel$fSubstTermSort$fSubstTermType' $fSubsttPtr$fSubstTermTerm$fSubstaSubstitution'$fDeBruijnTerm $fAbstractMap$fAbstractMaybe $fAbstract[]$fAbstractClauseBodyF$fAbstractFunctionInverse'$fAbstractCase$fAbstractWithArity$fAbstractCompiledClauses$fAbstractClause$fAbstractPrimFun$fAbstractDefn$fAbstractProjection $fAbstract[]0 $fAbstract[]1$fAbstractRewriteRule$fAbstractDefinition$fAbstractTele$fAbstractSort$fAbstractType'$fAbstractTerm$fAbstractPermutation$fApplyPermutation$fAbstractDrop $fApplyDrop $fApply(,,) $fApply(,) $fApplyMap $fApplyMaybe$fApplyBlocked $fApply[]$fApplyDisplayTerm$fApplyClauseBodyF$fApplyFunctionInverse' $fApplyCase$fApplyWithArity$fApplyCompiledClauses $fApplyClause$fApplyPrimFun $fApplyDefn$fApplyProjection $fApply[]0 $fApply[]1$fApplyRewriteRule$fApplyDefinition $fApplyTele $fApplyPtr $fApplySort $fApplyTerm $fShowTelV $fFunctorTelV $fEqSection$fEqConstraint $fOrdTele$fEqTele $fOrdElim' $fEqElim' $fEqCandidate $fOrdBlocked $fEqBlocked$fOrdNotBlocked$fEqNotBlocked$fOrdLevelAtom $fEqPlusLevel $fOrdLevel $fEqLevel $fOrdSort$fEqSort$fOrdSubstitution'$fEqSubstitution' $fOrdTelV$fEqTelVInSeqBinderHasFreeOccursSeqArg UnderLambdaonceinSeq underLambdaoccursIn $fHasFreeTAlt$fHasFreeTTerm$fHasFreeInSeq$fHasFreeBinder $fHasFree(,) $fHasFree[] $fHasFreeInt$fMonoidOccurs$fSubstTTermTAlt$fSubstTTermTTerm$fDeBruijnTTerm$fEqUnderLambda$fOrdUnderLambda$fShowUnderLambda$fMonoidUnderLambda $fEqSeqArg $fOrdSeqArg $fShowSeqArg$fMonoidSeqArg $fEqOccurs $fOrdOccurs $fShowOccurs equalTerms convertGuards caseToSeq $fShowLeq$fEqLeqCoinductionKit nameOfInf nameOfSharp nameOfFlat HasBuiltinsgetBuiltinThinglitTypesetBuiltinThingsbindBuiltinName bindPrimitive getBuiltin getBuiltin' getPrimitive' getPrimitiveconstructorFormconstructorForm' primIntegerprimIntegerPosprimIntegerNegSuc primFloatprimChar primStringprimBoolprimUnit primUnitUnitprimTrue primFalseprimListprimNilprimConsprimIOprimNatprimSucprimZero primNatPlus primNatMinus primNatTimesprimNatDivSucAuxprimNatModSucAuxprimNatEquality primNatLess primSizeUnivprimSize primSizeLt primSizeSuc primSizeInf primSizeMaxprimInf primSharpprimFlat primEqualityprimRefl primRewrite primLevel primLevelZero primLevelSuc primLevelMax primFromNat primFromNegprimFromString primQNameprimArg primArgArgprimAbs primAbsAbs primAgdaSort primHiding primHidden primInstance primVisible primRelevance primRelevantprimIrrelevant primArgInfoprimArgArgInfoprimAgdaSortSetprimAgdaSortLitprimAgdaSortUnsupported primAgdaTermprimAgdaTermVarprimAgdaTermLamprimAgdaTermExtLamprimAgdaTermDefprimAgdaTermConprimAgdaTermPiprimAgdaTermSortprimAgdaTermLitprimAgdaTermUnsupportedprimAgdaTermMetaprimAgdaErrorPartprimAgdaErrorPartStringprimAgdaErrorPartTermprimAgdaErrorPartNameprimAgdaLiteralprimAgdaLitNatprimAgdaLitFloatprimAgdaLitCharprimAgdaLitStringprimAgdaLitQNameprimAgdaLitMetaprimAgdaPatternprimAgdaPatConprimAgdaPatVarprimAgdaPatDotprimAgdaPatLitprimAgdaPatProjprimAgdaPatAbsurdprimAgdaClauseprimAgdaClauseClauseprimAgdaClauseAbsurdprimAgdaDefinitionFunDefprimAgdaDefinitionDataDefprimAgdaDefinitionRecordDef!primAgdaDefinitionDataConstructorprimAgdaDefinitionPostulateprimAgdaDefinitionPrimitiveprimAgdaDefinition primAgdaMeta primAgdaTCMprimAgdaTCMReturnprimAgdaTCMBindprimAgdaTCMUnifyprimAgdaTCMTypeErrorprimAgdaTCMInferTypeprimAgdaTCMCheckTypeprimAgdaTCMNormaliseprimAgdaTCMCatchErrorprimAgdaTCMGetContextprimAgdaTCMExtendContextprimAgdaTCMInContextprimAgdaTCMFreshNameprimAgdaTCMDeclareDefprimAgdaTCMDefineFunprimAgdaTCMGetTypeprimAgdaTCMGetDefinitionprimAgdaTCMQuoteTermprimAgdaTCMUnquoteTermprimAgdaTCMBlockOnMetaprimAgdaTCMCommit builtinNat builtinSuc builtinZerobuiltinNatPlusbuiltinNatMinusbuiltinNatTimesbuiltinNatDivSucAuxbuiltinNatModSucAuxbuiltinNatEqualsbuiltinNatLessbuiltinIntegerbuiltinIntegerPosbuiltinIntegerNegSuc builtinFloat builtinChar builtinString builtinUnitbuiltinUnitUnit builtinBool builtinTrue builtinFalse builtinList builtinNil builtinCons builtinIObuiltinSizeUniv builtinSize builtinSizeLtbuiltinSizeSucbuiltinSizeInfbuiltinSizeMax builtinInf builtinSharp builtinFlatbuiltinEquality builtinReflbuiltinRewritebuiltinLevelMax builtinLevelbuiltinLevelZerobuiltinLevelSucbuiltinFromNatbuiltinFromNegbuiltinFromString builtinQNamebuiltinAgdaSortbuiltinAgdaSortSetbuiltinAgdaSortLitbuiltinAgdaSortUnsupported builtinHiding builtinHiddenbuiltinInstancebuiltinVisiblebuiltinRelevancebuiltinRelevantbuiltinIrrelevant builtinArgbuiltinArgInfobuiltinArgArgInfo builtinArgArg builtinAbs builtinAbsAbsbuiltinAgdaTermbuiltinAgdaTermVarbuiltinAgdaTermLambuiltinAgdaTermExtLambuiltinAgdaTermDefbuiltinAgdaTermConbuiltinAgdaTermPibuiltinAgdaTermSortbuiltinAgdaTermLitbuiltinAgdaTermUnsupportedbuiltinAgdaTermMetabuiltinAgdaErrorPartbuiltinAgdaErrorPartStringbuiltinAgdaErrorPartTermbuiltinAgdaErrorPartNamebuiltinAgdaLiteralbuiltinAgdaLitNatbuiltinAgdaLitFloatbuiltinAgdaLitCharbuiltinAgdaLitStringbuiltinAgdaLitQNamebuiltinAgdaLitMetabuiltinAgdaClausebuiltinAgdaClauseClausebuiltinAgdaClauseAbsurdbuiltinAgdaPatternbuiltinAgdaPatVarbuiltinAgdaPatConbuiltinAgdaPatDotbuiltinAgdaPatLitbuiltinAgdaPatProjbuiltinAgdaPatAbsurdbuiltinAgdaDefinitionFunDefbuiltinAgdaDefinitionDataDefbuiltinAgdaDefinitionRecordDef$builtinAgdaDefinitionDataConstructorbuiltinAgdaDefinitionPostulatebuiltinAgdaDefinitionPrimitivebuiltinAgdaDefinitionbuiltinAgdaMetabuiltinAgdaTCMbuiltinAgdaTCMReturnbuiltinAgdaTCMBindbuiltinAgdaTCMUnifybuiltinAgdaTCMTypeErrorbuiltinAgdaTCMInferTypebuiltinAgdaTCMCheckTypebuiltinAgdaTCMNormalisebuiltinAgdaTCMCatchErrorbuiltinAgdaTCMGetContextbuiltinAgdaTCMExtendContextbuiltinAgdaTCMInContextbuiltinAgdaTCMFreshNamebuiltinAgdaTCMDeclareDefbuiltinAgdaTCMDefineFunbuiltinAgdaTCMGetTypebuiltinAgdaTCMGetDefinitionbuiltinAgdaTCMBlockOnMetabuiltinAgdaTCMCommitbuiltinAgdaTCMQuoteTermbuiltinAgdaTCMUnquoteTerm builtinsNoDefcoinductionKit'coinductionKitprimEqualityName equalityViewequalityUnview$fHasBuiltinsTCMTmakeOpen makeClosedisClosedgetOpentryOpenfromPatternSubstitution applyPatSubst$fSubstPattern'Pattern'$fDeBruijnPattern'KillVarkillVarShrinkCshrinkCnoShrink SizedList unSizedListProjName unProjName unConName unDefNameVarName unVarNameNoTypeunNoTypeYesType unYesTypeGenCgenC UseLiteralsUseLit useLitInt useLitFloat useLitString useLitChar SortFreqssetFreqspropFreq HiddenFreqs hiddenFreq notHiddenFreq ElimFreqs applyFreqprojFreq TermFreqsvarFreqdefFreqconFreqlitFreqsortFreqlamFreqpiFreqfunFreq FrequenciesFreqs hiddenFreqs elimFreqs sortFreqs termFreqsTermConfigurationTermConftcDefinedNamestcConstructorNamestcProjectionNamestcFreeVariables tcLiterals tcFrequencies tcFixSizetcIsTypedefaultFrequenciesnoProp noLiterals fixSizeConf resizeConfdecrConfdivConf isTypeConf isntTypeConf extendConfextendWithTelConfmakeConfigurationfixSizegenArgsgenElimsgenConfkillAbs isWellScopedprop_wellScopedVars $fKillVar(,)$fKillVarMaybe $fKillVar[] $fKillVarAbs $fKillVarDom $fKillVarArg$fKillVarElim' $fKillVarTele$fKillVarType' $fKillVarTerm$fShrinkCTermTerm$fShrinkCType'Type'$fShrinkCTeleTele$fShrinkCSortSort$fShrinkCElim'Elim'$fShrinkCBlockedBlocked$fShrinkCDomDom$fShrinkCArgArg$fShrinkCAbsAbs$fShrinkCHidingHiding$fShrinkCCharChar$fShrinkCLiteralLiteral$fShrinkCConNameConHead$fShrinkCDefNameQName$fShrinkCVarNameInt$fShrinkC(,)(,) $fShrinkC[][]$fShrinkCNoTypeb$fShrinkCYesTypeb$fArbitraryTermConfiguration $fGenCTerm $fGenCType' $fGenCTele $fGenCLiteral $fGenCInteger $fGenCDouble $fGenCChar $fGenCSort$fGenCProjName $fGenCDefName $fGenCElim' $fGenCAbs $fGenCDom $fGenCArg $fGenCHiding $fGenCRange' $fGenC(,)$fGenC[]$fGenCSizedList$fShowTermFreqs$fShowElimFreqs$fShowHiddenFreqs$fShowSortFreqs$fShowFrequencies$fShowUseLiterals$fShowTermConfigurationpiApplyMupdateBenchmarkingStatusprint FindErrorNotFound AmbiguoustoIFilefindErrorToTypeErrorfindFile findFile' findFile''findInterfaceFilecheckModuleName moduleName' moduleName$fEmbPrjDelayed$fEmbPrjIsAbstract$fEmbPrjLiteral$fEmbPrjConPOrigin$fEmbPrjRelevance$fEmbPrjHiding$fEmbPrjInduction $fEmbPrjDom $fEmbPrjArg$fEmbPrjWithHiding$fEmbPrjHashMap$fEmbPrjNameId$fEmbPrjArgInfo$fEmbPrjRanged $fEmbPrjNamed$fEmbPrjFieldAssignment' $fEmbPrjName$fEmbPrjModuleName$fEmbPrjAmbiguousQName $fEmbPrjQName$fEmbPrjMetaId$fEmbPrjGenPart$fEmbPrjFixity'$fEmbPrjFixity$fEmbPrjPrecedenceLevel$fEmbPrjAssociativity$fEmbPrjQName0$fEmbPrjNamePart $fEmbPrjName0$fEmbPrjSerialisedRange$fEmbPrjRange'$fEmbPrjInterval' $fEmbPrjSeq $fEmbPrjSet $fEmbPrjMap $fEmbPrjBiMap $fEmbPrj[]$fEmbPrjTopLevelModuleName$fEmbPrjPosition'$fEmbPrjAbsolutePath $fEmbPrjBool $fEmbPrjMaybe$fEmbPrjMaybe0$fEmbPrjEither $fEmbPrj(,,) $fEmbPrj(,) $fEmbPrj() $fEmbPrjVoid$fEmbPrjDouble $fEmbPrjChar $fEmbPrjInt $fEmbPrjInt32$fEmbPrjWord64$fEmbPrjInteger$fEmbPrjByteString $fEmbPrj[]0$fEmbPrjCompressedFile$fEmbPrjAspects$fEmbPrjOtherAspect$fEmbPrjAspect$fEmbPrjNameKind $fEmbPrjRange resetState resetAllState localTCStatelocalTCStateSavinglensPersistentStateupdatePersistentStatemodifyPersistentStatelensAccumStatisticsPlensAccumStatisticsgetScopesetScope modifyScope_ modifyScope withScope withScope_ localScope notInScope printScopemodifySignaturemodifyImportedSignature getSignaturegetImportedSignaturemodifyGlobalDefinition setSignaturesetImportedSignature withSignatureaddRewriteRulesForlookupDefinitionupdateDefinitionsupdateDefinition updateTheDef updateDefTypeupdateDefArgOccurrencesupdateDefPolarityupdateDefCompiledRepupdateFunClausessetTopLevelModulewithTopLevelModuleaddHaskellImportgetHaskellImportsaddHaskellImportUHCgetHaskellImportsUHCaddInlineHaskellgetInteractionOutputCallbackappInteractionOutputCallbacksetInteractionOutputCallbackgetPatternSynssetPatternSynsmodifyPatternSynsgetPatternSynImportslookupPatternSyn theBenchmarkupdateBenchmarkfreshTCMaddSignatureInstancesupdateInstanceDefsmodifyInstanceDefsgetAllInstanceDefsgetAnonInstanceDefsclearAnonInstanceDefsaddUnknownInstanceaddNamedInstanceLensPersistentVerbositygetPersistentVerbositysetPersistentVerbositymapPersistentVerbosityPersistentVerbosityLensIncludePathsgetIncludePathssetIncludePathsmapIncludePathsgetAbsoluteIncludePathssetAbsoluteIncludePathsmapAbsoluteIncludePaths LensSafeMode getSafeMode setSafeMode mapSafeModeSafeModeLensCommandLineOptionsgetCommandLineOptionssetCommandLineOptionsmapCommandLineOptions LensVerbosity getVerbosity setVerbosity mapVerbosityLensPragmaOptionsgetPragmaOptionssetPragmaOptionsmapPragmaOptionsmodifyPragmaOptionsmodifyVerbosity putVerbositymodifyCommandLineOptionsmodifySafeMode putSafeModemodifyIncludePathsputIncludePathsmodifyAbsoluteIncludePathsputAbsoluteIncludePathsmodifyPersistentVerbosityputPersistentVerbosity $fLensPersistentVerbosityTCState*$fLensPersistentVerbosityPersistentTCState+$fLensPersistentVerbosityCommandLineOptions&$fLensPersistentVerbosityPragmaOptions$fLensIncludePathsTCState#$fLensIncludePathsPersistentTCState$$fLensIncludePathsCommandLineOptions$fLensSafeModeTCState$fLensSafeModePersistentTCState $fLensSafeModeCommandLineOptions$fLensCommandLineOptionsTCState)$fLensCommandLineOptionsPersistentTCState$fLensVerbosityTCState$fLensVerbosityPragmaOptions$fLensPragmaOptionsTCState%$fLensPragmaOptionsCommandLineOptions enterClosure noMutualBlock inMutualBlocksetMutualBlockgetMutualBlockscurrentOrFreshMutualBlocklookupMutualBlock mutualBlockOffindMutualBlock RelativeTo ProjectRoot CurrentDirsetCommandLineOptions'libToTCMsetLibraryPathssetLibraryIncludesaddDefaultLibrariessetOptionsFromPragmaenableDisplayFormsdisableDisplayFormsdisplayFormsEnableddontEtaContractImplicitdoEtaContractImplicitshouldEtaContractImplicitdontReifyInteractionPointsshouldReifyInteractionPointsgetProjectRootsetIncludeDirs setInputFile getInputFile getInputFile' hasInputFileproofIrrelevancehasUniversePolymorphism sharedFunshared sharedType enableCachingshowImplicitArgumentsshowIrrelevantArgumentswithShowAllArgumentsignoreInterfacespositivityCheckEnabled typeInType etaEnableddisplayDebugMessagereportSverboseBracket$fHasOptionsTCMTWSMOut ResolvedName DefinedName FieldNameConstructorNamePatternSynResName UnknownNameScopeMisDatatypeModulegetCurrentModulesetCurrentModulewithCurrentModule' getNamedScopegetCurrentScope createModule modifyScopesmodifyNamedScope setNamedScopemodifyNamedScopeMmodifyCurrentScopemodifyCurrentScopeMmodifyCurrentNameSpacesetContextPrecedencegetContextPrecedencewithContextPrecedence getLocalVarsmodifyLocalVars setLocalVars withLocalVarsfreshAbstractNamefreshAbstractName_freshAbstractQName resolveName resolveName' resolveModule getNotation bindVariablebindName rebindName bindModule bindQModule stripNoNames copyScopeapplyImportDirectiveMlookupImportedName mapImportDirmapUsing mapRenaming openModule_$fShowResolvedName$fEqResolvedNametranslateCopatternClauses $fAlpha[] $fAlphaNamed $fAlphaArg $fAlphaLHS$fAlphaLHSCore'$fAlphaPattern' $fAlphaName $fRename(,)$fRenameEither $fRename[] $fRenameNamed $fRenameArg$fRenameDeclaration$fRenamePattern'$fRenameLHSCore' $fRenameLHS $fRenameRHS$fRenameClause'$fRenameTypedBinding$fRenameTypedBindings$fRenameLamBinding$fRenameLetBinding$fRenameFieldAssignment'$fRenameModuleName $fRenameExpr $fRenameName $fRenameQName$fHasRangeProjEntry $fFunctorPath $fEqProjEntry$fOrdProjEntryparseLHS parsePatternparsePatternSynparseApplicationparseModuleApplication $fEqExprKind$fShowExprKind AddContext addContextmodifyContextEntrymodifyContextEntries modifyContextmkContextEntry inContext inTopContext escapeContextaddCtxaddCtxs addCtxString addCtxString_addCtxStrings_dummyDomunderAbstractionunderAbstraction_ addCtxTel addLetBindinggetContextSizegetContextArgsgetContextTermsgetContextTelescopegetContextNameslookupBV typeOfBV'typeOfBVnameOfBV getVarInfo$fAddContextTele$fAddContext[]$fAddContextName$fAddContextDom$fAddContextDom0$fAddContext(,)$fAddContext(,)0$fAddContext(,)1$fAddContextDom1$fAddContext(,)2$fAddContext[]0RangeAndPragma DontTouchMe ToConcrete toConcretebindToConcreteAbsToConEnvmakeEnv noTakenNames runAbsToConabstractToConcreteEnvabstractToConcreteCtxabstractToConcrete_ toConcreteCtx$fToConcreteNamedMetaExpr$fToConcreteInteractionIdExpr$fToConcretePattern'Pattern$fToConcreteLHSCore'Pattern$fToConcreteLHSLHS$fToConcreteSpineLHSLHS $fToConcreteRangeAndPragmaPragma$fToConcreteDeclaration[].$fToConcreteModuleApplicationModuleApplication$fToConcreteClause'[]$fToConcreteConstrDeclaration$fToConcreteMaybeMaybe$fToConcreteRHS(,,,)$$fToConcreteAsWhereDeclsWhereClause'$fToConcreteLetBinding[]%$fToConcreteTypedBindingTypedBinding'$fToConcreteTypedBindings[]$fToConcreteLamBinding[],$fToConcreteFieldAssignment'FieldAssignment'$fToConcreteExprExpr$fToConcreteModuleNameQName$fToConcreteQNameQName$fToConcreteNameName$fToConcreteDontTouchMea$fToConcreteNamedNamed $fToConcreteWithHidingWithHiding$fToConcreteArgArg$fToConcrete(,,)(,,)$fToConcrete(,)(,)$fToConcreteEitherEither$fToConcrete[][] cachingStartswriteToCurrentLogrestorePostScopeStatereadFromCachedLogcleanCachedLogactivateLoadedFileCachecacheCurrentLogConstraintStatusAwakeConstraintSleepingConstraintcurrentProblemstealConstraintssolvingProblemsolvingProblemsisProblemSolvedgetConstraintsForProblemgetAwakeConstraintswakeConstraints partitionMdropConstraintsputAllConstraintsToSleepholdConstraintstakeAwakeConstraintgetAllConstraintswithConstraintbuildProblemConstraintbuildConstraintaddConstraint'addAwakeConstraintsnowSolvingConstraintsisSolvingConstraintsmapAwakeConstraintsmapSleepingConstraintsmodifyAwakeConstraintsmodifySleepingConstraints$fEqConstraintStatus$fShowConstraintStatusupdateSharedTermupdateSharedTermFupdateSharedTermTforceEqualTerms getStatisticsmodifyStatisticsticktickNtickMaxprintStatisticsinterestingCall traceCallM traceCall traceCallCPS traceCallCPS_getCurrentRangesetCurrentRange UnFreezeMeta unfreezeMetaIsInstantiatedMetaisInstantiatedMetadontAssignMetas getMetaStoremodifyMetaStore updateMetaVargetMetaPriority isSortMeta isSortMeta_ getMetaTypegetMetaTypeInContextisInstantiatedMeta'createMetaInfocreateMetaInfo'setValueMetaNamegetMetaNameSuggestionsetMetaNameSuggestionupdateMetaVarRangemodifyInteractionPointsregisterInteractionPointconnectInteractionPointremoveInteractionPointgetInteractionPointsgetInteractionMetasgetInteractionIdsAndMetasisInteractionMetalookupInteractionPointlookupInteractionIdnewMetanewMeta'getInteractionRange getMetaRangegetInteractionScope withMetaInfo' withMetaInfogetInstantiatedMetas getOpenMetas listenToMetaunlistenToMetagetMetaListenersclearMetaListenerswithFreezeMetas freezeMetas unfreezeMetasunfreezeMetas'isFrozen$fUnFreezeMetaAbs$fUnFreezeMeta[]$fUnFreezeMetaLevelAtom$fUnFreezeMetaPlusLevel$fUnFreezeMetaLevel$fUnFreezeMetaSort$fUnFreezeMetaTerm$fUnFreezeMetaType'$fUnFreezeMetaMetaId$fIsInstantiatedMetaAbs$fIsInstantiatedMetaArg$fIsInstantiatedMetaMaybe$fIsInstantiatedMeta[]$fIsInstantiatedMetaLevelAtom$fIsInstantiatedMetaPlusLevel$fIsInstantiatedMetaLevel$fIsInstantiatedMetaTerm$fIsInstantiatedMetaMetaId HasConstInfo getConstInfogetRewriteRulesFor addConstant setTerminatesmodifyFunClauses addClausesensureNoCompiledHaskelladdHaskellCodeaddHaskellExportaddHaskellType addEpicCode addJSCode addCoreCode addCoreConstr addCoreTypemarkNoSmashing markStatic markInlineunionSignatures addSection lookupSectionaddDisplayForms applySection applySection'addDisplayFormgetDisplayFormschaseDisplayFormshasLoopingDisplayForm canonicalNamesameDef whatInductionsingleConstructorTypedefaultGetRewriteRulesFor getConInfo getPolarity' setPolaritygetArgOccurrencesetArgOccurrencesmodifyArgOccurrences setTreelesssetCompiledArgUse getCompiled getTreelessgetCompiledArgUse getMutual setMutualmutuallyRecursive getSectiongetCurrentModuleFreeVarsgetDefFreeVarsfreeVarsToApplyinFreshModuleIfFreeParamsinstantiateDef makeAbstractinAbstractModeinConcreteModeignoreAbstractModeinConcreteOrAbstractModetreatAbstractlytreatAbstractly' typeOfConst relOfConst sortOfConstdefPars droppedPars isProjection isProjection_ isStaticFun isInlineFunisProperProjectionprojectionArgsusesCopatternsapplyDef$fHasConstInfoExceptionT$fHasConstInfoTCMTgetConstructorData getConHead SizeMaxViewSizeViewComparable NotComparableYesAboveYesBelow DeepSizeViewDSizeInfDSizeVar DSizeMeta DOtherSizeSizeViewSizeInfSizeSuc OtherSize IsSizeType isSizeType BoundedSize BoundedLt BoundedNoisSizeTypeTestgetBuiltinDefNamegetBuiltinSizeisSizeNameTestisSizeNameTestRawhaveSizedTypesbuiltinSizeHooksizeSortsizeUniv sizeType_sizeType sizeSucNamesizeSucsizeSuc_sizeMaxsizeViewsizeViewComparable sizeViewSuc_ sizeViewPredsizeViewOffset removeSucs unSizeViewunDeepSizeView maxViewMax maxViewConssizeViewComparableWithMax maxViewSuc_ unMaxView$fIsSizeTypeTerm$fIsSizeTypeType'$fEqBoundedSize$fShowBoundedSize$fShowDeepSizeView$fFunctorSizeViewComparable callCompiler callCompiler' closedTermtranslateBuiltinsnormalizeNames usedArgumentsstripUnusedArguments parseCoreDataparseCoreConstrs parseCoreExprcoreExprToCExprDotMDotState dsModules dsNameSupply dsConnectionModuleIdinitialDotState addModule addConnectiondottify generateDotlispifyHighlightingInfodefaultCSSFile generateHTMLgenerateHTMLWithPageGen generatePagepage tokenStream generateLaTeX $fEqDebug $fShowDebugvimFileescape wordBoundedmatchestoVimgenerateVimFilereadlineshowAprettyAprettyAsshowATop prettyATop ToAbstract toAbstract WithNamesNameswithNameaskName toAbstract_toAbstractWithoutImplicitmkSettoAbstractPats$fToAbstract[][]$fToAbstractQNamedClause'$fToAbstractPattern(,)$fToAbstractSortExpr$fToAbstractTermExpr$fToAbstractLiteralExpr$fToAbstractAbs(,)$fToAbstract(,)Expr$fToAbstract(,)Expr0$fToAbstract(,)TypedBindings$fToAbstract[][]0$fToAbstractArgArg$fToAbstractNamedNamed recursiveanyDefsleqType equalSort equalType equalTerm compareLevel compareSort compareTel compareType compareElims compareArgs compareAtom compareTermDropArgsdropArgs$fDropArgsCompiledClauses$fDropArgsFunctionInverse'$fDropArgsClause$fDropArgsClauseBodyF$fDropArgsPermutation$fDropArgsTele$fDropArgsMaybe isEmptyTypehideAndRelParamsinverseApplyRelevanceapplyRelevance workOnTypes doWorkOnTypes workOnTypes'applyRelevanceToContextwakeIrrelevantVars prop_galois MentionsMeta mentionsMeta$fMentionsMetaConstraint$fMentionsMetaProblemConstraint$fMentionsMetaTele$fMentionsMetaElim'$fMentionsMetaClosure$fMentionsMeta(,,)$fMentionsMeta(,)$fMentionsMetaMaybe$fMentionsMeta[]$fMentionsMetaDom$fMentionsMetaArg$fMentionsMetaAbs$fMentionsMetaSort$fMentionsMetaType'$fMentionsMetaLevelAtom$fMentionsMetaPlusLevel$fMentionsMetaLevel$fMentionsMetaTermExpandPatternSynonymsexpandPatternSynonymsexpandLitPattern$fExpandPatternSynonymsPattern''$fExpandPatternSynonymsFieldAssignment'$fExpandPatternSynonymsNamed$fExpandPatternSynonymsArg$fExpandPatternSynonyms[]$fExpandPatternSynonymsMaybeDontKnowmatchCopatterns matchPatterns PrettyTCM prettyTCM$$<><+>sepfsephsepvcattextisRecordConstructorisGeneratedRecordConstructoretaContractRecordgetRecordFieldNames isEtaRecordisRecordaskRapplyWhenVerboseS traceSDoctraceSLn$fHasConstInfoReduceM$fHasBuiltinsReduceM$fHasOptionsReduceM BinAppViewNoApp binAppView etaContractetaOnceInstantiateFullinstantiateFull' Normalise normalise'Simplify simplify'reduce'reduceB' Instantiate instantiate' instantiateinstantiateFullreducereduceB normalisesimplify ifBlocked ifBlockedType rewriteAfterunfoldCorecursionEunfoldCorecursionunfoldDefinitionunfoldDefinitionEunfoldDefinition' reduceDefCopy reduceHead reduceHead'appDef_appDefE_appDefappDefEappDef'appDefE'simplifyBlocked'$fInstantiateFullEqualityView$fInstantiateFullCandidate$fInstantiateFullMaybe$fInstantiateFullQName$fInstantiateFullBuiltin$fInstantiateFullInterface$fInstantiateFullClause $fInstantiateFullCompiledClauses$fInstantiateFullCase$fInstantiateFullWithArity!$fInstantiateFullFunctionInverse'$fInstantiateFullDefn$fInstantiateFullDisplayTerm$fInstantiateFullDisplayForm$fInstantiateFullOpen$fInstantiateFullRewriteRule$fInstantiateFullNLPat$fInstantiateFullDefinition$fInstantiateFullChar$fInstantiateFullTele$fInstantiateFullSection$fInstantiateFullSignature$fInstantiateFullScope$fInstantiateFullModuleName$fInstantiateFullHashMap$fInstantiateFullMap$fInstantiateFullElim'$fInstantiateFullConstraint"$fInstantiateFullProblemConstraint$fInstantiateFullClosure$fInstantiateFull(,,)$fInstantiateFull(,)$fInstantiateFull[]$fInstantiateFullDom$fInstantiateFullNamed$fInstantiateFullArg$fInstantiateFullAbs$fInstantiateFullClauseBodyF$fInstantiateFullPattern'$fInstantiateFullConPatternInfo$fInstantiateFullInt$fInstantiateFullBool$fInstantiateFullSubstitution'$fInstantiateFullLevelAtom$fInstantiateFullPlusLevel$fInstantiateFullLevel$fInstantiateFullTerm$fInstantiateFullType'$fInstantiateFullSort$fInstantiateFullName$fNormaliseEqualityView$fNormaliseCandidate$fNormaliseMaybe$fNormaliseMap$fNormaliseDisplayForm$fNormalisePattern'$fNormaliseConPatternInfo$fNormaliseChar$fNormaliseInt$fNormaliseBool$fNormaliseConstraint$fNormaliseProblemConstraint$fNormaliseTele$fNormaliseClosure$fNormalise(,,)$fNormalise(,) $fNormalise[]$fNormaliseDom$fNormaliseNamed$fNormaliseArg$fNormaliseAbs$fNormaliseClauseBodyF$fNormaliseLevelAtom$fNormalisePlusLevel$fNormaliseLevel$fNormaliseElim'$fNormaliseTerm$fNormaliseType'$fNormaliseSort$fSimplifyEqualityView$fSimplifyCandidate$fSimplifyDisplayForm$fSimplifyClauseBodyF$fSimplifyBool$fSimplifyConstraint$fSimplifyProblemConstraint$fSimplifyTele$fSimplifyClosure$fSimplify(,,) $fSimplify(,)$fSimplifyMaybe $fSimplifyMap $fSimplify[] $fSimplifyDom$fSimplifyNamed $fSimplifyArg $fSimplifyAbs$fSimplifyLevelAtom$fSimplifyPlusLevel$fSimplifyLevel$fSimplifySort$fSimplifyElim'$fSimplifyType'$fSimplifyTerm$fReduceEqualityView$fReduceCandidate $fReduceMap$fReduceConstraint $fReduceTele$fReduceClosure $fReduceTerm $fReduce(,,) $fReduce(,) $fReduceDom $fReduceArg $fReduce[] $fReduceAbs$fReduceLevelAtom$fReducePlusLevel $fReduceLevel $fReduceElim' $fReduceSort $fReduceType'$fInstantiateEqualityView$fInstantiateCandidate$fInstantiateMap$fInstantiateConstraint$fInstantiateTele$fInstantiateClosure$fInstantiate(,,)$fInstantiate(,)$fInstantiate[]$fInstantiateDom$fInstantiateArg$fInstantiateAbs$fInstantiateElim'$fInstantiateSort$fInstantiateType'$fInstantiateBlocked$fInstantiateLevelAtom$fInstantiatePlusLevel$fInstantiateLevel$fInstantiateTermCompile CompileState nameSupplycompiledModules curModuleimportedModulescurFuninitCompileState epicErrormodifyEIgetsEIgetTypeunqnameresetNameSupply getDelayed putDelayednewName putConstrTagassignConstrTagassignConstrTag' getConData getDataCon getConstrTag getConstrTag' addDefName topBindings getConArity putConArityputMaingetMain lookInterface constrInScope getForcedArgs putForcedArgs replaceAtconstructorAritybindExpr$fShowCompileStatecaseOpts caseOptsExpr prettyEpicFun prettyEpicmakeForcedArgs forceConstrsforceFun getNatishisNatishnrRelisRecargIsDef PrimTransformPrimTFmapCon translateCaseprZeroprSucprTrueprFalseprPred prNatEquality primitivise initialPrims getBuiltins natPrimTF primNatCaseZS primNatCaseZD boolPrimTFprimFunprimExpreliminateDeadCodeLevelKitlvlTypelvlSuclvlMaxlvlZerotypeNamesucNamemaxNamezeroNamemlevel levelTypelevelSucFunctionbuiltinLevelKit requireLevelsunLevelreallyUnLevelViewunlevelWithKitunPlusV maybePrimCon maybePrimDef levelView levelView'levelLub dtermToTermdisplayFormArities displayFormmatchDisplayForm $fMatchLevel $fMatchSort $fMatchTerm $fMatchElim' $fMatchArg $fMatch[]bindBuiltinFlatbindBuiltinSharpbindBuiltinInfcheckSectionApplication checkDecl checkDecls useTerPragma checkFunDef' checkFunDef$fEmbPrjScopeInfo$fEmbPrjPrecedence$fEmbPrjPattern'$fEmbPrjConPatInfo$fEmbPrjLocalVar$fEmbPrjKindOfName$fEmbPrjAbstractModule$fEmbPrjAbstractName$fEmbPrjWhyInScope$fEmbPrjNameSpace$fEmbPrjAccess$fEmbPrjNameSpaceId $fEmbPrjScope $fEmbPrjTag$fEmbPrjForced$fEmbPrjInjectiveFun$fEmbPrjEInterface$fEmbPrjHsName$fEmbPrjCoreConstr$fEmbPrjCoreType$fEmbPrjCoreRepresentation$fEmbPrjMemberId$fEmbPrjGlobalId$fEmbPrjLocalId $fEmbPrjExp$fEmbPrjCompiledRepresentation$fEmbPrjHaskellRepresentation$fEmbPrjHaskellExport$fEmbPrjBuiltin$fEmbPrjConPatternInfo$fEmbPrjClauseBodyF$fEmbPrjClause$fEmbPrjTermHead$fEmbPrjFunctionInverse'$fEmbPrjCompiledClauses $fEmbPrjCase$fEmbPrjWithArity $fEmbPrjDefn$fEmbPrjEtaEquality$fEmbPrjOccurrence$fEmbPrjPolarity$fEmbPrjExtLamInfo$fEmbPrjProjection$fEmbPrjRewriteRule $fEmbPrjNLPat$fEmbPrjDefinition$fEmbPrjMutualId$fEmbPrjDisplayTerm $fEmbPrjCtxId $fEmbPrjOpen$fEmbPrjDisplayForm $fEmbPrjSort$fEmbPrjLevelAtom$fEmbPrjPlusLevel $fEmbPrjLevel $fEmbPrjTerm $fEmbPrjAbs $fEmbPrjType'$fEmbPrjConHead $fEmbPrjElim' $fEmbPrjDrop$fEmbPrjPermutation $fEmbPrjTele$fEmbPrjSection$fEmbPrjSignature$fEmbPrjInterfaceencodedecodeencodeInterface encodeFiledecodeInterface decodeHashes decodeFileSynEqcheckSyntacticEquality$fSynEqArgInfo $fSynEqDom $fSynEqArg $fSynEqAbs $fSynEqElim' $fSynEq[] $fSynEqType' $fSynEqSort$fSynEqLevelAtom$fSynEqPlusLevel $fSynEqLevel $fSynEqTermSplitTel firstPart secondPart splitPermOutputTypeName OutputTypeVarOutputTypeNameNotYetKnownNoOutputTypeNamegetOutputTypeNamerenamePrenaming renamingR flattenTel reorderTel reorderTel_ unflattenTel teleNames teleArgNamesteleArgs teleNamedArgs permuteTelvarDependenciessplitTelescopesplitTelescopeExactinstantiateTelescopeexpandTelescopeVartelView telViewUpTo telViewUpTo'mustBePiifPiifPiTypeifNotPi ifNotPiTypepiApply1intro1addTypedInstanceresolveUnknownInstanceDefsgetInstanceDefs NamedClauseReifyreify reifyWhen reifyPatterns$fReify(,,,)(,,,)$fReify(,,)(,,) $fReify(,)(,) $fReify[][] $fReifyDomArg $fReifyTele[] $fReifyAbs(,)$fReifyLevelExpr$fReifySortExpr$fReifyType'Expr$fReifyQNamedClause'$fMonadTCMTickT$fMonadStatesTickT$fMonadTickTickT$fDotVarsTypedBinding$fDotVarsTypedBindings $fDotVarsRHS$fDotVarsModuleName$fDotVarsFieldAssignment' $fDotVarsExpr$fDotVarsPattern'$fDotVarsClause'$fDotVarsEither $fDotVars(,) $fDotVars[]$fDotVarsNamed $fDotVarsArg$fMonoidMonoidMap$fReifyClauseBodyFRHS$fReifyElim'Expr $fReifyArgArg$fReifyNamedNamed$fReifyTermExpr$fReifyLiteralExpr$fReifyDisplayTermExpr$fReifyMetaIdExpr$fReifyExprExpr$fReifyNameName $fShowDotBind $fEqDoBind $fShowDoBind$fFunctorTickT$fApplicativeTickT $fMonadTickT$fMonadReaderTickT$fMonadTransTickT$fMonadIOTickTWithNode PrettyContextDoccommacolonequalshcat$+$nestbracesbracketsparens prettyList_ punctuateshowPat' raisePatVars$fPrettyTCMGraph$fPrettyTCMWithNode$fPrettyTCMOccurrence$fPrettyTCMRewriteRule$fPrettyTCMType'$fPrettyTCMElim'$fPrettyTCMNLPat$fPrettyTCMElim'0$fPrettyTCMPattern'$fPrettyTCMPattern'0$fPrettyTCMCtxId $fPrettyTCM[]$fPrettyTCMPrettyContext$fPrettyTCMTele$fPrettyTCMConHead$fPrettyTCMModuleName$fPrettyTCMQName$fPrettyTCMName$fPrettyTCMWithHiding$fPrettyTCMTypeCheckingProblem$fPrettyTCMConstraint$fPrettyTCMProblemConstraint$fPrettyTCMRelevance$fPrettyTCMExpr$fPrettyTCMEqualityView$fPrettyTCMMaybeReduced$fPrettyTCMElim'1$fPrettyTCMDom$fPrettyTCMArg$fPrettyTCMNamed$fPrettyTCMBlocked$fPrettyTCMMetaId$fPrettyTCMJudgement$fPrettyTCMClauseBodyF$fPrettyTCMClause$fPrettyTCMSubstitution'$fPrettyTCMTerm$fPrettyTCMPolarity$fPrettyTCMPermutation$fPrettyTCMLevel$fPrettyTCMQNamed$fPrettyTCMDisplayTerm$fPrettyTCMSort$fPrettyTCMType'0$fPrettyTCMTerm0$fPrettyTCM(,,)$fPrettyTCM(,)$fPrettyTCM[]0$fPrettyTCMClosure$fPrettyTCMRange'$fPrettyTCMProblemId$fPrettyTCMInt$fPrettyTCMLiteral$fPrettyTCMComparison$fPrettyTCMQName0$fPrettyTCMName0$fPrettyTCMBoolErasure ErasureState relevanciesfunsisIrrisRel||-&&-erasure removeUnusedinitiate initialRelsrelevantstepdiffTagseqGroups constrGroupTagEqSameIsTag Injectible<:InjConstraints findInjection replaceFunCC isInjectivenrBinds substForDotisInjectiveHerelitToConlitIntinsertAtemptyCunionConstraints initialTagsunify mergeGroups unifiable!!!!$fInjectibleTerm$fInjectibleElim'$fInjectible[]$fInjectibleArg $fEqTagEqdefnParssmash'em inferable inferableTerm smashable buildLambdaEvaluateevaluatenormaliseStatic evaluateCC etaExpand$fEvaluateTerm$fEvaluateElim' $fEvaluateAbs $fEvaluateArg $fEvaluate[]fromAgda translateDefn reverseCCBody substTermsubstLit HaskellKindhsStarhsKFunhsFunhsUnithsVarhsApphsForallnotAHaskellType getHsTypegetHsVar haskellTypeStackFrameWarningsunsolvedMetaVariablesunsolvedConstraintswarningsToError tcErrString$fVerbalizeIndefinite$fVerbalizeRelevance$fVerbalizeHiding$fPrettyTCMCall$fPrettyTCMSplitError$fPrettyUnequalType'$fPrettyUnequalTerm$fPrettyTCMTypeError$fPrettyTCMCallInfo$fPrettyTCMTCErrImplicitInsertion ImpInsert BadImplicits NoSuchNameNoInsertNeeded implicitArgsimplicitNamedArgs impInsertinsertImplicit$fShowImplicitInsertion foldMatchmatchCopattern matchPatternyesSimplification $fNullMatchRaiseNLP raiseNLPFromraiseNLPPostponedEquationsPostponedEquation eqFreeVarseqLhseqRhsSubNLMStateNLM PatternFrom patternFromliftRedrunNLM traceSDocNLMmatchingBlockedtellSubtellEqmakeSubstitutioncheckPostponedEquations nonLinMatchequal$fRaiseNLPNLPat $fRaiseNLPAbs$fRaiseNLPType' $fRaiseNLPDom$fRaiseNLPElim' $fRaiseNLPArg $fRaiseNLP[]$fMatchNLPatTerm $fMatchAbsAbs$fMatchType'Type' $fMatchDomDom$fMatchElim'Elim' $fMatchArgArg $fMatch[][]$fHasOptionsExceptT$fPatternFromAbsAbs$fPatternFromTermNLPat$fPatternFromType'Type'$fPatternFromDomDom$fPatternFromElim'Elim'$fPatternFromArgArg$fPatternFrom[][]LHSState lhsProblemlhsSubstlhsDPIlhsAsB AsBindingAsBDotPatternInstDPIdotPatternUserExprdotPatternInstdotPatternType SplitProblemSplit SplitRest splitLPats splitAsNames splitFocus splitRPatssplitProjection splitRestTypeFocusLitFocusfocusConfocusPatOrigin focusConArgs focusRange focusOutPat focusDatatype focusParams focusIndices focusType ProblemRestrestPatsrestType ProblemPartProblemProblem' problemInPat problemOutPat problemTel problemRest ChooseFlex chooseFlex FlexChoice ChooseLeft ChooseRight ChooseEither ExpandBoth FlexibleVar flexHidingflexKindflexVarFlexibleVarKind RecordFlex ImplicitFlexDotFlex FlexibleVarsdefaultFlexibleVarflexibleVarFromHidingconsSplitProblem$fNullProblem'$fNullProblemRest$fPrettyTCMAsBinding$fPrettyTCMDotPatternInst$fSubstTermAsBinding$fSubstTermDotPatternInst$fSubstTermProblem'$fSubstTermProblemRest$fChooseFlexFlexibleVar$fChooseFlexInt$fChooseFlexHiding$fChooseFlex[]$fChooseFlexFlexibleVarKind$fMonoidFlexChoice$fLensHidingFlexibleVar$fEqFlexibleVarKind$fShowFlexibleVarKind$fEqFlexibleVar$fShowFlexibleVar$fFunctorFlexibleVar$fFoldableFlexibleVar$fTraversableFlexibleVar$fEqFlexChoice$fShowFlexChoice$fShowProblemRest$fShowProblem'inlineWithClausesisWithFunctionexpandWithFunctionCall DataOrRecordIsDataIsRecordConstructorInfoDataCon RecordConHasEtaNoEtaYesEta getConTerm getConFormgetOrigConHeadgetOrigConTermgetConstructorInfogetConstructorArity isDatatypeisDataOrRecordTypeisDataOrRecordgetNumberOfParameters $fEqHasEta$fEqDataOrRecord$fOrdDataOrRecord$fShowDataOrRecord eraseTerms $fEqTypeInfo$fShowTypeInfo YesNoMaybeMaybeinitialIFSCandidates findInScope findInScope'insidePirigidlyConstrainedMetasisRigidareThereNonRigidMetaArgumentsfilterResetingStatedropSameCandidatescheckCandidatesisIFSConstraintapplyDroppingParameters$fShowYesNoMaybe$fEqYesNoMaybe HasPolarity polaritiesneg polFromOcc nextPolaritypurgeNonvariantenablePhantomTypesdependentPolarityrelevantInIgnoringNonvariantmkUnusednonvariantToUnusedArgnonvariantToUnusedArgInDefnonvariantToUnusedArgInClause sizePolaritycheckSizeIndexpolarity$fHasPolarityLevelAtom$fHasPolarityPlusLevel$fHasPolarityLevel$fHasPolarityTerm$fHasPolarityElim'$fHasPolarityType'$fHasPolarity(,)$fHasPolarity[]$fHasPolarityAbs$fHasPolarityDom$fHasPolarityArg QuotingKitquoteTermWithKitquoteTypeWithKitquoteClauseWithKitquoteDomWithKitquoteDefnWithKitquoteListWithKit quotingKit quoteString quoteNamequoteNat quoteConName quoteMeta quoteTerm quoteTypequoteDom quoteDefn quoteList orderFieldsinsertMissingFields recordModule getRecordDefgetRecordOfFieldrecordFieldNamesfindPossibleRecordsgetRecordFieldTypesgetRecordTypeFieldsgetOriginalProjectiongetRecordConstructorTypegetRecordConstructor isRecordType tryRecordType getDefType projectTypedisEtaConisInductiveRecordisEtaRecordTypeunguardedRecordrecursiveRecordisRecursiveRecord recRecursive_etaExpandBoundVarexpandRecordVarexpandRecordVarsRecursivelycurryAtetaExpandRecordetaExpandRecord_etaExpandAtRecordTypeisSingletonRecord isSingletonRecordModuloRelevanceisSingletonRecord'isSingletonTypeisSingletonTypeModuloRelevanceisSingletonType'emapCallPath callInfosMaskedgetMask getMaskedMaskedDeBruijnPatsUsableSizeVarsusableSizeVars DeBruijnPat'VarDBPConDBPLitDBPTermDBPProjDBP DeBruijnPat DeBruijnPatsTerMterMMonadTerterAskterLocalterAsksTerEnvterUseDotPatternsterGuardingTypeConstructorsterInlineWithFunctions terSizeSucterSharp terCutOff terCurrent terMutual terUserNames terTarget terDelayed terMaskArgs terMaskResult _terSizeDepth terPatternsterPatternsRaise terGuarded terUseSizeLt terUsableVarsTarget MutualNames defaultTerEnvrunTer runTerDefaultterGetGuardingTypeConstructorsterGetInlineWithFunctionsterGetUseDotPatternsterSetUseDotPatterns terGetSizeSuc terGetCurrent terSetCurrent terGetSharp terGetCutOff terGetMutualterGetUserNames terGetTarget terSetTarget terGetDelayed terSetDelayedterGetMaskArgsterSetMaskArgsterGetMaskResultterSetMaskResultterGetPatternsterSetPatternsterRaise terGetGuardedterModifyGuarded terSetGuarded terUnguarded terPiGuarded terSizeDepthterGetUsableVarsterModifyUsableVarsterSetUsableVarsterGetUseSizeLtterModifyUseSizeLtterSetUseSizeLtwithUsableVars conUseSizeLt projUseSizeLtisProjectionButNotCoinductiveisCoinductiveProjection patternDepth unusedVarraiseDBPmasked notMaskedterSetSizeDepth$fPrettyCallPath$fPrettyTCMMasked$fDecorationMasked$fUsableSizeVars[]$fUsableSizeVarsMasked$fUsableSizeVars[]0$fUsableSizeVarsDeBruijnPat'$fPrettyTCMDeBruijnPat'$fIsProjPDeBruijnPat'$fMonadErrorTCErrTerM$fMonadTCMTerM $fMonadIOTerM$fMonadStateTCStateTerM$fMonadReaderTCEnvTerM$fMonadTerTerM$fFunctorDeBruijnPat'$fShowDeBruijnPat' $fEqMasked $fOrdMasked $fShowMasked$fFunctorMasked$fFoldableMasked$fTraversableMasked $fFunctorTerM$fApplicativeTerM $fMonadTerM$fMonadBenchTerM$fShowCallPath$fMonoidCallPath$fAllNamesCallPath PruneResultNothingToPrune PrunedNothingPrunedSomethingPrunedEverything FoldRigid foldRigidoccurs metaOccursVarsUnfoldStrategy YesUnfoldNoUnfold OccursCtxIrrelmodifyOccursCheckDefsinitOccursCheckdefNeedsCheckingtallyDefdefArgsunfoldleaveTopweaklystronglypatternViolation'abort goIrrelevant allowedVar takeRelevant liftUnderAbs occursCheckprune hasBadRigid isNeutralrigidVarsNotContainedInkillArgs killedType performKill$fFoldRigid(,) $fFoldRigid[]$fFoldRigidElim'$fFoldRigidDom$fFoldRigidArg$fFoldRigidAbs$fFoldRigidLevelAtom$fFoldRigidPlusLevel$fFoldRigidLevel$fFoldRigidSort$fFoldRigidType'$fFoldRigidTerm $fOccurs[] $fOccurs(,) $fOccursDom $fOccursArg $fOccursAbs $fOccursElim' $fOccursSort $fOccursType'$fOccursLevelAtom$fOccursPlusLevel $fOccursLevel$fOccursClause $fOccursDefn $fOccursQName $fOccursTerm $fEqOccursCtx$fShowOccursCtx$fEqUnfoldStrategy$fShowUnfoldStrategy$fEqPruneResult$fShowPruneResultDefNodeArgNodeComputeOccurrences occurrencesOccMOccEnvvarsinf OccursWheres:++OccurrencesBuilder'Concat' OccursAs' OccursHere'OccurrencesBuilderConcatOccursAs OccursHere OnlyVarsUpTo OccurrencesItemAnArgADefWhere LeftOfArrowDefArgUnderInfVarArgMetaArg ConArgType IndArgTypeInClauseMatchedInDefOf OccursWhereKnowncheckStrictlyPositive getDefArityemptyOB>+< preprocessflattenwithExtendedOccEnvgetOccurrencescomputeOccurrencescomputeOccurrences'etaExpandClausebuildOccurrenceGraph computeEdges$fCoArbitraryWhere$fCoArbitraryOccursWhere$fArbitraryWhere$fArbitraryOccursWhere$fStarSemiRingEdge$fSemiRingEdge $fNullEdge$fPrettyTCMNode$fComputeOccurrences(,)$fComputeOccurrences[]$fComputeOccurrencesDom$fComputeOccurrencesArg$fComputeOccurrencesElim'$fComputeOccurrencesAbs$fComputeOccurrencesTele$fComputeOccurrencesType'$fComputeOccurrencesLevelAtom$fComputeOccurrencesPlusLevel$fComputeOccurrencesLevel$fComputeOccurrencesTerm$fComputeOccurrencesClause$fSizedOccursWhere$fPrettyTCMOccursWhere $fShowWhere $fEqWhere $fOrdWhere$fShowOccursWhere$fEqOccursWhere$fOrdOccursWhere$fEqItem $fOrdItem $fShowItemprop_oplus_Occurrence_EdgeProjectionViewLoneProjectionLike NoProjection projViewProj projViewSelf projViewSpine unProjViewprojViewreduceProjectionLikeelimViewrecordPatternToProjectionstranslateCompiledClausestranslateSplitTreetranslateRecordPatterns$fPrettyTCMEither$fPrettyTCM(->) $fPretty(->) $fDropFrom[] $fDropFrom(,)$fDropFromSplitTree'$fFunctorRecPatM$fApplicativeRecPatM$fMonadRecPatM$fMonadIORecPatM$fMonadTCMRecPatM$fMonadReaderRecPatM$fMonadStateRecPatM$fEqKindcheckDisplayPragmainsertImplicitProblemexpandImplicitPatternexpandImplicitPattern' implicitPinsertImplicitPatternsinsertImplicitSizeLtPatternsinsertImplicitPatternsTinstantiateTelnothingToSplitErroruseNamesFromPattern noProblemRestproblemFromPatsupdateProblemRest_updateProblemRestOldSizeConstraintLeq OldSizeExprSizeMetacheckSizeLtSatcheckSizeNeverZerocheckSizeVarNeverZero isBoundedboundedSizeMetaHook trySizeUniv deepSizeView sizeMaxView compareSizescompareMaxViewscompareBelowMaxcompareSizeViewstrivial isSizeProblemisSizeConstraintgetSizeConstraints getSizeMetasoldComputeSizeConstraintsoldComputeSizeConstraint oldSizeExprflexibleVariablesoldCanonicalizeSizeConstraintoldSolveSizeConstraints oldSolver$fShowOldSizeConstraint$fShowOldSizeExpr$fEqOldSizeExprResulttermDecl$fStripAllProjectionsTerm$fStripAllProjections[]$fStripAllProjections[]0$fStripAllProjectionsArg$fExtractCallsLevelAtom$fExtractCallsPlusLevel$fExtractCallsTerm$fExtractCallsType'$fExtractCallsSort$fExtractCalls(,)$fExtractCalls[]$fExtractCallsElim'$fExtractCallsDom$fExtractCallsArg$fExtractCallsAbs$fExtractCallsLevel newProblem newProblem_ifNoConstraintswhenConstraintswakeupConstraintswakeupConstraints_solveAwakeConstraintssolveConstraint_checkTypeCheckingProblem InvertExcept CantInvert NeutralArg ProjectedVarRes SubstCandFVs ProjVarExcNoProjectedVarnoProjectedVarMetaKindRecordsSingletonRecordsLevelsfindIdx isBlockedTermisEtaExpandable assignTerm' newSortMetanewSortMetaCtx newTypeMeta newTypeMeta_ newIFSMetaCtxnewValueMetaCtx newValueMeta'newValueMetaCtx' trueConditionnewArgsMetaCtxnewArgsMetaCtx' newRecordMetanewRecordMetaCtxnewQuestionMark blockTermblockTermOnProblemblockTypeOnProblemunblockedTesterpostponeTypeCheckingProblem_postponeTypeCheckingProblem problemTypeetaExpandListenerswakeupListener allMetaKinds etaExpandMetaetaExpandBlocked assignWrapper assignMeta assignMeta'subtypingForSizeLtexpandProjectedVarsetaExpandProjectedVarcheckLinearity inverseSubst updateMeta$fNoProjectedVar[]$fNoProjectedVarArg$fNoProjectedVarTerm $fEqMetaKind$fEnumMetaKind$fBoundedMetaKind$fShowMetaKindFullPartialprintHighlightingInfogenerateAndPrintSyntaxInfogenerateTokenInfogenerateTokenInfoFromStringprintSyntaxInfoprintErrorInfoerrorHighlightingprintUnsolvedInfocomputeUnsolvedMetaWarningscomputeUnsolvedConstraintsstoreDisambiguatedNamePredOpFromTermfromTermFromTermFunctionToTermtoTermtoTermRPrimTermprimTermPrimTypeprimTypeLvlunLvlunNat PrimitiveImplPrimImpl buildListredBind redReturnfromReducedTerm fromLiteral primTrustMe genPrimForce primForceprimForceLemmamkPrimLevelZeromkPrimLevelSucmkPrimLevelMax mkPrimFun1TCM mkPrimFun1 mkPrimFun2 mkPrimFun4-->.-->..-->garrgpihPinPivarMgApply<@><#>listioeltset tSetOmega sSizeUniv tSizeUnivargNdomNargHdomHprimitiveFunctionsfloatEqfloatLt floatShowlookupPrimitiveFunctionlookupPrimitiveFunctionQgetBuiltinName isBuiltin $fFromTerm[]$fFromTermBool$fFromTermMetaId$fFromTermQName $fFromTermStr$fFromTermChar$fFromTermDouble $fFromTermLvl $fFromTermNat$fFromTermInteger $fToTerm[]$fToTermArgInfo $fToTermType' $fToTermTerm $fToTermBool$fToTermInteger$fToTermMetaId $fToTermQName $fToTermStr $fToTermChar$fToTermDouble $fToTermLvl $fToTermNat $fPrimTermIO $fPrimTerm[]$fPrimTermType'$fPrimTermMetaId$fPrimTermQName $fPrimTermLvl $fPrimTermNat $fPrimTermStr$fPrimTermDouble$fPrimTermChar$fPrimTermBool$fPrimTermInteger $fPrimTypea$fPrimTerm(->) $fShowLvl $fShowNat $fTermLikeNat $fIntegralNat$fEqNat$fOrdNat$fNumNat $fEnumNat $fRealNat$fEqLvl$fOrdLvl simplifyTTerm $fShowAtom$fEqAtom $fOrdAtom toTreelessclosedTermToTreeless MaybeAbortAbort KeepGoingInvViewInvNoInv headSymbolcheckInjectivityfunctionInverseuseInjectivity tryConversiontryConversion'sameVars intersectVars equalAtom convError unifyPointersassignEcompareTermDir compareTerm' etaInequalcompareAtomDircompareRelevancecompareIrrelevantcompareWithPol polFromCmpcoerce coerceSizeleqSortleqLevel equalLevel equalLevel' bothAbsurdAction preAction postAction defaultActioncheckInternal'AbsTermabsTerm IsPrefixOf isPrefixOftypeOf abstractTypepiAbstractTerm piAbstract abstractTermswap01 $fAbsTerm(,) $fAbsTermAbs$fAbsTermMaybe $fAbsTerm[] $fAbsTermDom $fAbsTermArg$fAbsTermElim'$fAbsTermLevelAtom$fAbsTermPlusLevel$fAbsTermLevel $fAbsTermSort$fAbsTermType' $fAbsTermPtr $fAbsTermTerm$fIsPrefixOfTerm$fIsPrefixOf[]$fIsPrefixOf[]0reconstructParametersInTypereconstructParametersInTelreconstructParametersInEqViewreconstructParametersdropParametersForcedVariablesforcedVariablesaddForcingAnnotationsforce$fForcedVariablesTerm$fForcedVariablest KillCtxId killCtxId NLPatVars nlPatVarsRelView relViewTel relViewDelta relViewType relViewType' relViewCorerequireOptionRewritingrelViewaddRewriteRuleaddRewriteRules rewriteWithrewArity$fKillCtxIdNLPat$fKillCtxIdRewriteRule $fKillCtxIdf$fNLPatVarsNLPat $fNLPatVarsf checkDataDef smallParamscheckConstructorbindParametersfitsIn constructs isCoinductive splitProblemUnificationResult'UnifiesNoUnifyUnificationResult unifyIndices_ unifyIndices$fMonoidUnifyOutput$fPrettyTCMUnifyState$fNormaliseUnifyState$fReduceUnifyState$fReduceEquality$fShowUnificationResult'$fFunctorUnificationResult'$fFoldableUnificationResult'$fTraversableUnificationResult'$fShowUnifyState$fShowUnifyStepdataParametersdataParametersTCMreport piApplyM' insertTelemkConunifyItakeTele remForced forcedExpr replaceForced buildTerm findPositionCovering covSplitArgcovSplitClauses SplitClauseSClausescTelscPatsscSubstscTarget splitClausesclauseToSplitClause coverageCheck fixTargetsplitClauseWithAbsurd splitLast splitResult$fPrettyTCMSplitClauseClsClclPatsclBodycompileWithSplitTreecompile nextSplit properSplitisVarsplitOnsplitCexpandCatchAlls substBody $fPrettyCl$fShowCl LHSResult lhsVarTele lhsPatterns lhsBodyTypelhsPermutationIsFlexiblePatternmaybeFlexiblePatternisFlexiblePatternflexiblePatternsupdateInPatternsisSolvedProblemnoShadowingOfConstructorscheckDotPatterncheckLeftoverDotPatterns bindLHSVarsbindAsPatternscheckLeftHandSidecheckLHSnoPatternMatchingOnCodata$fInstantiateFullLHSResult$fIsFlexiblePatternNamed$fIsFlexiblePatternArg$fIsFlexiblePattern[]$fIsFlexiblePatternPattern'$fIsFlexiblePatternPattern'0HypSizeConstraint sizeContext sizeHypIdssizeHypothesessizeConstraintSizeConstraint DBSizeExpr sizeMetaId sizeMetaArgs NamedRigid rigidName rigidIndexDefaultToInftyDontDefaultToInftysolveSizeConstraintssolveSizeConstraints_ solveClustergetSizeHypothesescanonicalizeSizeConstraintcomputeSizeConstraintsizeExpr unSizeExpr$fPrettyTCMHypSizeConstraint $fFlexsSizeMetaHypSizeConstraint$fPrettyTCMConstraint'$fSubstTermConstraint'$fSubstTermSizeExpr'$fSubstTermSizeMeta$fPrettyTCMSizeMeta$fShowSizeMeta $fOrdSizeMeta $fEqSizeMeta$fPlusNamedRigidIntNamedRigid$fShowNamedRigid$fOrdNamedRigid$fEqNamedRigid$fEqDefaultToInfty$fOrdDefaultToInfty$fShowDefaultToInftyprop_telToListInvprop_flattenTelScopeprop_flattenTelInvprop_reorderTelStableprop_splitTelescopeScopeprop_splitTelescopePermScope ErrorPartStrPartTermPartunquote UnquoteResUnquoteM UnquoteStateDirtyClean agdaTermType agdaTypeType qNameTypeunpackUnquoteM packUnquoteM runUnquoteMliftUliftU1liftU2inOriginalContextisConisDefreduceQuotedTermunquoteHunquoteN ensureDef ensureConpickName unquoteStringunquoteNStringgetCurrentPath unquoteTCMevalTCM$fUnquoteClause$fUnquotePattern $fUnquoteTerm$fUnquoteLiteral $fUnquoteSort $fUnquoteDom$fUnquoteMetaId $fUnquoteAbs$fUnquoteQName$fUnquoteRelevance$fUnquoteHiding $fUnquote[]$fUnquoteErrorPart$fPrettyTCMErrorPart $fUnquoteStr $fUnquoteChar$fUnquoteDouble$fUnquoteInteger$fUnquoteElim' $fUnquoteArg$fUnquoteArgInfo $fEqDirtyLamOrPiLamNotPiPiNotLamisTypeptsRulenoFunctionsIntoSize isTypeEqualToleqType_checkTelescopecheckPiTelescopecheckTelescope'checkTypedBindingscheckTypedBinding checkLambdainsertHiddenLambdascheckAbsurdLambdacheckExtendedLambda!catchIlltypedPatternBlockedOnMetaexpandModuleAssignscheckRecordExpressioncheckRecordUpdate checkLiteral quoteGoal quoteContextcheckApplicationunquoteM domainFree checkMeta inferMetacheckOrInferMeta inferHeadDef inferHeadinferDefcheckConstructorApplicationcheckHeadApplication traceCallEcheckArguments_ inferExpr'defOrVarcheckDontExpandLastisModuleFreeVarinferExprForWithcheckLetBindingscheckLetBinding $fEqLamOrPi $fShowLamOrPi checkRecDefcheckRecordProjectionssplitTelForWithwithFunctionType withArgumentsbuildWithFunctionstripWithClausePatternswithDisplayForm patsToElimsWithFunctionProblemNoWithFunction WithFunction wfParentNamewfName wfParentType wfBeforeTel wfAfterTelwfExprs wfExprTypes wfRHSType wfParentPats wfPermSplit wfPermParent wfPermFinal wfClausesisAlias checkAliasinsertPatternsmkBody checkClausecheckRHS checkWithRHScheckWithFunction checkWherecontainsAbsurdPatternbindPostulatedName bindBuiltinisUntypedBuiltinbindUntypedBuiltinbindBuiltinNoDef LeftHandSide AbstractRHS RightHandSideLetDefLetDefs TopLevelInfo topLevelDecls topLevelScopeTopLevel topLevelPathtopLevelTheThing OldModuleNameNewModuleQName NewModuleNameAPatNamePatNameOldNameOldQNameNewNameconcreteToAbstract_concreteToAbstractlocalToAbstract$fToAbstractPatternPattern'$fToAbstractPattern'Pattern'$fToAbstractLHSCore'LHSCore' $fToAbstractWithHidingWithHiding$fToAbstractLHSCoreLHSCore'$fToAbstractLeftHandSideLHS$fToAbstractRHS'AbstractRHS$$fToAbstractRightHandSideAbstractRHS$fToAbstractAbstractRHSRHS$fToAbstractClauseClause'$fToAbstractPragma[]!$fToAbstractConstrDeclDeclaration&$fToAbstractNiceDeclarationDeclaration$fToAbstractBlindBlind$fToAbstractLetDef[]$fToAbstractLetDefs[] $fToAbstractTopLevelTopLevelInfo$fEnsureNoLetStms[]$fEnsureNoLetStmsTypedBindings'$fEnsureNoLetStmsLamBinding'$fEnsureNoLetStmsTypedBinding'%$fToAbstractTypedBinding'TypedBinding'$fToAbstractTypedBindings'TypedBindings!$fToAbstractLamBinding'LamBinding,$fToAbstractFieldAssignment'FieldAssignment'$fToAbstractModuleAssignment(,)$fToAbstractExprExpr#$fToAbstractOldModuleNameModuleName$$fToAbstractNewModuleQNameModuleName#$fToAbstractNewModuleNameModuleName$fToAbstractOldNameQName$fToQNameQName $fToQNameName$fToAbstractPatNameAPatName$fToAbstractOldQNameExpr$fToAbstractNewNameName$fToAbstractNewNameName0$fToAbstractMaybeMaybe$fToAbstractEitherEither$fToAbstract(,,)(,,)$fToAbstract(,)(,) typeOfInf typeOfSharp typeOfFlatShowHeadshowHead FinalCheckscheckDeclCached mutualCheckscheckUnquoteDeclcheckUnquoteDef unquoteTopinstantiateDefinitionType highlight_checkTermination_checkPositivity_checkCoinductiveRecordscheckInjectivity_checkProjectionLikeness_ checkAxiomcheckPrimitiveassertCurrentModule checkPragma checkMutualcheckTypeSignature checkSectioncheckModuleAritycheckSectionApplication' checkImportdebugPrintDecl$fShowHeadDeclarationOutputConstraint'OfType'ofNameofExprOutputConstraintOfType CmpInTypeCmpElimJustTypeCmpTypes CmpLevelsCmpTelesJustSortCmpSortsGuard TypedAssignPostponedCheckArgs IsEmptyType SizeLtSat FindInScopeOF OutputFormRewriteAsIs Instantiated HeadNormal Simplified Normalised parseExprIngive evalInCurrent evalInMeta normalForm outputFormIdshowComparisongetConstraintsgetSolvedInteractionPoints typeOfMetaMI typeOfMeta typeOfMeta'typesOfVisibleMetastypesOfHiddenMetasmetaHelperType contextOfMeta typeInCurrent typeInMetawithInteractionId withMetaId introTactic atTopLevel parseNameisQNamemoduleContentsgetRecordContentsgetModuleContents.$fToConcreteOutputConstraint'OutputConstraint'$fPrettyOutputConstraint',$fToConcreteOutputConstraintOutputConstraint $fToConcreteOutputFormOutputForm$fShowOutputConstraint$fShowOutputForm!$fReifyConstraintOutputConstraint$fReifyProblemConstraintClosure $fReadRewrite$fFunctorOutputConstraint$fFunctorOutputForm findMentionsCommandExitCodeContinue ContinueInReturn matchCommand interaction continueAfterwithCurrentFileloadFileshowConstraints showMetas showScope metaParseExpr actOnMetagiveMeta refineMetaretryConstraintsevalInevalTermtypeIn showContext splashScreenhelp MaybeWarnings NoWarnings SomeWarnings MainInterfaceNotMainInterfacemergeInterfaceaddImportedThings hasWarningsalreadyVisited typeCheckMain getInterface getInterface_ getInterface'highlightFromInterface readInterfacewriteInterfaceremovePrivatescreateInterfaceconstructIScopebuildInterfacegetInterfaceFileHashes moduleHash isNewerThan$fEqMainInterface$fShowMainInterfaceIsMainNotMain doCompile setInterfacecurIFcurSigcurMNamecurDefssortDefssigMName compileDirreplconArityAndPars inCompilerEnv $fEqIsMaincurHsModihnameunqhnametlmodOfxqualxhqnhsNameconhqnbltQualdnamedunamehsPrimOp hsPrimOpApphsInt hsTypedInthspLethsLethsVarUQ hsAppView hsOpToExphsLambdahsMapAlthsMapRHSmazstrmazNamemazMod'mazModmazerror mazCoerceName mazErasedName mazCoercemazIncompleteMatchrtmIncompleteMatchmazUnreachableErrorrtmUnreachableErrormazRTErtmQualrtmVarrtmErrorunsafeCoerceModfakeDfakeDSfakeDQfakeTypefakeExpfakeDecldummy emptyBindsencodeModuleName $fArbitraryM$fShowMWrapunwrap prettyPrint$fTransformBiModuleNameWrap$fTransformBiModuleNameWrap0$fTransformBiModuleNameWrap1$fTransformBiModuleNameWrap2 testSuitecheckTypeOfMainimportsForPrimxForPrimprimBody noCheckCoverpconNamebltQual'CompileTCoreMeta runCompileT addExports addMetaCon addMetaData getExports getDeclMetasfreshLocalName getConstrCTag getConstrFun dataRecConsmoduleNameToCoreNamePartsmoduleNameToCoreName getCoreName getCoreName1$fMonadTCMCompileT$fMonadStatesCompileT$fMonadReaderrCompileT$fMonoidCoreMeta$fMonadCompileT$fMonadIOCompileT$fMonadTransCompileT$fApplicativeCompileT$fFunctorCompileT primFunNm primFunctions BuiltinKitisNatisIntTTTTEnvnmEnvoptsfromAgdaModulerunTTaddToEnv builtinKit compileTermbuildPrimCases mkIfThenElse compileConAlt makeConAltdefaultBranches litToCore getCTagArity coreError compilePrimcreateMainModule compilerMainprefixjsMod jsFileNamejsMemberglobal'globalreorderreorder'isTopLevelValue isEmptyObject insertAfter definitionnumParsclausemappingmapping'pattern visitorNametermargs dummyLambda writeModuleoutFileoutFile_CC CCContext NameSupplyCCEnv ccNameSupplyccCxtimports mapNameSupply mapContext initCCEnv lookupIndex freshNamesintroscheckConstructorType checkCoveralthslitlitqname litqnamepatcondeclcdecltvaldeclinfodeclhsCasthsCast' hsCastApphsCoercecopyRTEModulesoutFile'callGHC CaseContext findClauseparseVariablesmakeCasemakeAbsurdClausemakeAbstractClause deBruijnIndexChoice LeftDisjunct RightDisjunctSRes HandleSolQPB QPBlockedQPDoubleBlockedPBNotPBPBlockedPDoubleBlockedMBNotBFailedMetaEnvMMNotMBlkInfo Refinable refinementsPair RefCreateEnvUndoRestorePrioMetaNoPrioSubConstraintsscflip sccomcountscsub1scsub2CTree ctpriometactsubctparent cthandlesMetavarmbindmprincipalpresentmobs mcompoint mextrarefsOKMetaOKHandleOKValOK AddExtraRefAnd SideconditionOr ConnectHandleTravtravPrio hequalMetavarinitMetanewCTreenewSubConstraints ureadIORef uwriteIORef umodifyIORefureadmodifyIORefrunUndonewPlaceholder newOKHandledryInstantiatemmcasemmmcasemmpcase doubleblockmbcasembpcasemmbpcasewaitokmbretmbfailedmpret expandbind topSearchextractblkinfosrecalcsseqcrecalcreccalccalcchoosePrioMeta propagatePriochoose$fRefinableOKValblk$fRefinableChoiceblk $fEqPrioMeta $fEqMetavar $fTravMMblkEECActionSkipWeakTrBrCExpClosICExp ICArgListCALNil CALConcat HNArgListHNALNilHNALCons HNALConParHNExpHNAppHNLamHNPiHNSortMArgListArgListALNilALConsALProjALConParMExp AbsurdLambdaappUIdappOKappHeadappElims UnknownSortElrConstRefPat PatConAppPatVarPatExpDeclContConstDefcdnamecdorigincdtypecdcont cddeffreevarsMIdNoIdFModeMyMBMyPBRefInfoRIEnv RIMainInfo RIUnifInfo RICopyInfo RIIotaStepRIInferredTypeUnknownRINotConstructor RIUsedVars RIPickSubsvar RIEqRState RICheckElimRICheckProjIndexrieHintsrieDefFreeVarsrieEqReasoningConstsriMainCxtLength riMainType riMainIotaEqReasoningStateEqRSNone EqRSChainEqRSPrf1EqRSPrf2EqRSPrf3EqReasoningConstseqrcId eqrcBegineqrcStepeqrcEndeqrcSymeqrcCongHintModeHMNormal HMRecCallUId stringToMyIddetecteliminanddetectsemiflexcategorizedecl metaliseokh expandExpaddtrailingargsclosifysubsubiweakweaki weakarglistweakelrdoclos$fEqEqReasoningState$fShowEqReasoningState $fEqFMode ExpRefInfoeriMaineriUnifseriInfTypeUnknowneriIsEliminand eriUsedVars eriIotaSteperiPickSubsVar eriEqRStategetinfounivarsubsvarsextraref costIncreasecostUnificationOccurscostUnification costAppVarcostAppVarUsed costAppHintcostAppHintUsedcostAppRecCallcostAppRecCallUsedcostAppConstructorcostAppConstructorSinglecostAppExtraRefcostLam costLamUnfoldcostPicostSort costIotaStepcostInferredTypeUnkown costAbsurdLam costEqStep costEqEnd costEqSym costEqCongprioNoprioTypeUnknownprioTypecheckArgListprioInferredTypeUnknown prioCompBetaprioCompBetaStructured prioCompIotaprioCompChoice prioCompUnif prioCompCopyprioCompareArgList prioNoIotaprioAbsurdLambda prioProjIndex prioTypecheck$fTravArgListRefInfo$fTravExpRefInfo$fTravTrBrRefInfo$fTrav(,)RefInfo $fTrav[]blk$fRefinableIORefRefInfo$fRefinableClosRefInfo$fRefinableExpRefInfo$fRefinableArgListRefInfoCMFlexCMFFlexCMFSemi CMFBlockedCModeCMRigidPEvalPENoPEConAppHNResHNDoneHNMetaHNNBlkstcExp getDatatypeconstructorImpossibleunequalsunequal traversePitcargsaddendcopyargnoblksaddblkhnnhnn_blks hnn_checkstephnn'hnbhnc hnarglistgetNArgs getAllArgsiotastep noiotastepnoiotastep_termcomp'checkeliminandmaybeor iotapossmetameta_not_constructor calcEqRStatepickidtcSearchSolCSPatI CSPatConAppCSPatVarCSPatExpCSWithCSAbsurd CSOmittedArgCSCtxCSPatHI abspatvarnamecostCaseSplitVeryHighcostCaseSplitHighcostCaseSplitLowcostAddVarDepthdrophidcaseSplitSearchcaseSplitSearch' infertypevarreplace betareduce concatargseqelrreplaceprmmmunifyexplift removevarnotequalfindpermfreevars applypermrenrenamerenamepseqctx depthofvarlocalTerminationEnvlocalTerminationSidecondgetblksTOMsConstssMetassEqssCurMeta sMainMetaMapSTModeTMAllnorminitMapSpopMapStomygetConstgetdfvgetMetagetEqscopatternsNotImplemented tomyClauses tomyClausetomyPattomyBodyweakenweakenstomyTypetomyExptomyExpstomyIneqfmTypefmExpfmExpsfmLevelcnvhicnvhfrommy frommyType frommyExp frommyExps abslamvarnamemodifyAbstractExprmodifyAbstractClause constructPats frommyClausecontains_constructoretaContractBodynegtypefindClauseDeep matchType $fEqTModeauto GiveRefineGiveRefineIntroBackendMAlonzo MAlonzoNoMainEpicJSParseIOTCM'IOTCM Interaction'Cmd_load Cmd_compileCmd_constraints Cmd_metas!Cmd_show_module_contents_toplevelCmd_search_about_toplevel Cmd_solveAllCmd_infer_toplevelCmd_compute_toplevelCmd_load_highlighting_info Cmd_highlightShowImplicitArgsToggleImplicitArgsCmd_give Cmd_refine Cmd_introCmd_refine_or_introCmd_auto Cmd_contextCmd_helper_function Cmd_infer Cmd_goal_typeCmd_goal_type_contextCmd_goal_type_context_inferCmd_show_module_contents Cmd_make_case Cmd_computeCmd_why_in_scopeCmd_why_in_scope_toplevelCmd_show_version InteractionCommandMOldInteractionScopes CommandStatetheInteractionPointstheCurrentFileoptionsOnReloadoldInteractionScopesinitCommandStaterevLift commandMToIO liftCommandMTmodifyTheInteractionPointsmodifyOldInteractionScopesinsertOldInteractionScoperemoveOldInteractionScopegetOldInteractionScopehandleCommand_ handleCommandrunInteraction readsToParseparseToReadsPrecexact readParseparens' independent interpret cmd_load'give_gen highlightExprsortInteractionPointsprettyTypeOfMeta prettyContextcmd_helper_functioncmd_goal_type_context_andshowModuleContents searchAboutsetCommandLineOptsstatus displayStatus display_info refreshStr nameModifiers lowerMetaparseAndDoAtToplevel maybeTimedtellToUpdateHighlightingtellEmacsToJumpToError$fReadPosition'$fReadAbsolutePath$fReadInterval' $fReadRange'$fReadInteractionId $fShowBackend $fReadBackend$fReadInteraction'$fFunctorInteraction'$fFoldableInteraction'$fTraversableInteraction' $fReadIOTCM'$fFunctorIOTCM'$fFoldableIOTCM'$fTraversableIOTCM'$fEqGiveRefine$fShowGiveRefine mimicGHCirunAgdarunAgdaWithOptions printUsage printVersion optionErrorrunTCMPrettyErrorsmaincatchIObindirlibdirdatadir libexecdir sysconfdir getBinDir getLibDir getDataDir getLibexecDir getSysconfDirgetDataFileNameFunctorChangeT evalUpdater fromChangeEndoFun fromChangeTJustghc-prim GHC.TypesTrue'QuickCheck-2.8.2-KPm3V9n9OMa9urRrdeE4gmTest.QuickCheck.AllverboseCheckAll quickCheckAllforAllProperties monomorphicpolyVerboseCheckpolyQuickCheckTest.QuickCheck.TestverboseCheckWithResultverboseCheckResultverboseCheckWith verboseCheckquickCheckWithResultquickCheckResultquickCheckWith quickCheckstdArgsreplay maxSuccessmaxDiscardRatiomaxSizechattySuccessGaveUpFailureNoExpectedFailureInsufficientCoveragelabelsreason theExceptionnumTestsoutput numShrinksnumShrinkTriesnumShrinkFinalusedSeedusedSizeTest.QuickCheck.Propertydisjoinconjoin.&. forAllShrinkforAllwithin==>coverclassifycollect expectFailureverbose whenFail'whenFail printTestCasecounterexample noShrinking shrinkingmapSize ioPropertyPropertyTestableproperty exhaustiveDiscardTest.QuickCheck.ModifiersBlindgetBlindFixedgetFixed OrderedListOrdered getOrdered NonEmptyListNonEmpty getNonEmptyPositive getPositiveNonZero getNonZero NonNegativegetNonNegativeLargegetLargegetSmallShrink2 getShrink2Smart Shrinking ShrinkState shrinkInit shrinkStateTest.QuickCheck.Arbitrary infiniteList orderedListvectorcoarbitraryEnumcoarbitraryShowcoarbitraryRealcoarbitraryIntegral><genericCoarbitraryshrinkRealFracshrinkRealFracToIntegershrinkIntegral shrinkNothingarbitrarySizedBoundedIntegralarbitraryBoundedEnumarbitraryBoundedRandomarbitraryBoundedIntegralarbitrarySizedFractionalarbitrarySizedNaturalarbitrarySizedIntegral shrinkListsubtermsrecursivelyShrink genericShrink Arbitrary arbitraryshrink CoArbitrary coarbitraryTest.QuickCheck.ExceptiondiscardTest.QuickCheck.GeninfiniteListOfvectorOflistOf1listOfgrowingElementsshuffle sublistOfelements frequencyoneof suchThatMaybesuchThatsamplesample'generatescaleresizesizedvariantGenGHC.ShowShowshowpretty-1.1.3.3#Text.PrettyPrint.Annotated.HughesPJMode OneLineModeLeftMode ZigZagModePageModeStyleribbonsPerLine lineLengthmodestyleText.PrettyPrint.HughesPJ fullRender renderStylerenderfcatcathang doubleQuotesquotesrationaldoublefloatintegerintrbracelbracerbracklbrackrparenlparenspacesemi zeroWidthText sizedTextptextChrPStrptrTagptrReffreshVarOrdering GHC.ClassesOrdNothing readP_to_S readS_to_PPGetLookFinalfinalrunrun'GHC.ListfiltermaybefromJust isNothingisJustListfoldList prop_concat prop_idiomprop_concatMap GHC.IORefIORef Data.IORefatomicWriteIORefatomicModifyIORef'atomicModifyIORef modifyIORef' modifyIORef mkWeakIORef writeIORef readIORefnewIORefconvertLineEndings copyIfChanged2unordered-containers-0.2.7.1-5INwdG7O5Jdakf1CqKoOBData.HashMap.StrictintersectionWithKeyintersectionWithmapMaybeWithKey unionWithKeyalterData.HashMap.Base filterWithKey foldrWithKeyfoldr foldlWithKey'foldl'traverseWithKey lookupDefaultHashMapEqGHC.IOFilePathabsolutePathInvariantdirectory-1.2.6.2System.DirectorycanonicalizePathbyteStringPathprop_mkAbsoluterootPath expandVarstokens Data.EithereitherEitherRightLeft prop_allRightCprop_cluster_completeprop_cluster_soundtesttest1neToList exactlyTwo atLeastTwoprop_cluster_emptyprop_cluster_permutationprop_cluster_singleprop_cluster_idemprop_two_clusters prop_test prop_test1initlastInt Data.OldListgroupBy==.sortBycompare elemIndexnubBy dropWhileValueMPosunPresults continuations System.IOputStrLnMonoid Data.Map.BaseMap discardEmptyremoveSourceNoderemoveTargetNodeData.Map.StrictGHC.EnummaxBound completeIter#strict-0.3.2-HHI2FPLqQto28EK1aExOvfData.Strict.MaybesingletonOrEveryPrefixModelVal modelToTrie prop_lookup modelPathprop_everyPrefixGHC.Num+FalseBool integer-gmpGHC.Integer.Typeprop_integerSemiringprop_intSemiringprop_boolSemiringTM TransposeunMtoBoundssupSizeinfSize Data.Foldablelengthall toSparseRows toSparseRows'blowUpSparseVec zipAssocWithunionAssocWithinterAssocWithstrictlySortedprop_fromIndexListprop_fromLists_toListsprop_isSingleton prop_diagonalprop_transpose zipMatrices'prop_zipMatrices_correctprop_addprop_add_correctinterAssocWith'prop_interAssocWith_correctprop_mulprop_toSparseRowsblowUpSparseVec'interAssocWith2prop_interAssocWith_correct2prop_addColumn prop_addRowprop_Arbitrary_Size prop_sizeprop_Arbitrary_MIx prop_matrixprop_Arbitrary_Matrix<=DecrmaxO withinCutOffisOrder prop_decrcollapseokMminOprop_orderSemiringmappendcombineNewOldCallGraph callGraph CombineNewOld combineNewOldCombineNewOldTCGbuildCallGraphexample1example2example3example4example5example6 checkIdems checkIdem hasDecreaseprop_terminates_example1prop_terminates_example2prop_terminates_example3prop_terminates_example4prop_terminates_example5prop_terminates_example6example7prop_terminates_example7setIntervalFileiLength startPos'intervalToRangerangeToIntervalWithFile fuseIntervals iPositions rPositions makeIntervalintervalInSameFileAsrangeInSameFileAsNoRange importantPart prop_iLengthprop_startPos' prop_startPos prop_noRangeprop_takeI_dropIprop_posToRange'prop_posToRangeprop_intervalToRangerangeToIntervalPropertyTemplateprop_rangeToIntervalWithFileprop_rangeToIntervalprop_continuousprop_continuousPerLineprop_fuseIntervalsprop_fuseRangesprop_beginningOfprop_beginningOfFileprop_intervalInSameFileAsprop_rangeInSameFileAsprop_positionInvariantprop_intervalInvariantprop_rangeInvariantfoldr1or&&any satisfiable!prop_Occurrence_oplus_associativeprop_Occurrence_oplus_ozero!prop_Occurrence_oplus_commutative"prop_Occurrence_otimes_associativeprop_Occurrence_otimes_ooneprop_Occurrence_distributiveprop_Occurrence_otimes_ozeroprop_Occurrence_ostarprop_boundToEverySome0prop_boundToEverySome1prop_boundToEverySome2 ConnectedNEGnodeInedgeInisWalk prop_productOfEdgesInBoundedWalktransitiveClosure1completeUntilWith~~ DisconnectednconnectivityGraph connectedprop_neighboursprop_nodes_fromNodesprop_clean_discreteprop_insertWith prop_sccs' prop_sccDAGprop_oppositeDAGprop_reachableFromprop_walkSatisfying6prop_gaussJordanFloydWarshallMcNaughtonYamadaReference-prop_gaussJordanFloydWarshallMcNaughtonYamada prop_completeg1g2g3g4 withStreampermutePartialprop_permute_id_rprop_permute_id_l prop_takeP prop_droppedP prop_composePprop_invertP_left prop_reversePprop_inversePermuteComposablePermutations prop_flipPprop_inversePermute_invertP initStatePos getLastPos setLexState setContext ErrorFunctionErrorFun unLookAhead qnameModAexprModA importDirModANiceEnv _loneSigs DataRecOrFunDataNameRecNameFunNameInMutual NotInMutual KindOfBlockPostulateBlockPrimitiveBlock InstanceBlock FieldBlock DataBlockcombineTermChecks initNiceEnvloneSigs addLoneSig removeLoneSiggetSig noLoneSigs checkLoneSigs getFixity parameters plusFixitiesfixitiesFixitiesDeclKindLoneSigLoneDefs OtherDeclLoneSigsfixsParamsCatchall isFunNamesameKindterminationCheckpositivityCheckdeclKindlitError stringToken lexString lexStringGaplexChar lexEscapereadNum readNumAccsillyEscapeCharspragmaalexScanGHC.Err undefined AlexAccPredAlexAcc AlexAccNone AlexAccSkipAlexAccSkipPred AlexLastAccAlexNone AlexLastSkipAlexAddrAlexA# alex_tab_size alex_base alex_table alex_check alex_deflt alex_acceptbol_ empty_layout_imp_dir_layout_pragma_tex alex_action_0 alex_action_1 alex_action_4 alex_action_5 alex_action_8 alex_action_9alex_action_10alex_action_11alex_action_12alex_action_13alex_action_14alex_action_15alex_action_16alex_action_17alex_action_18alex_action_19alex_action_20alex_action_21alex_action_22alex_action_23alex_action_24alex_action_25alex_action_26alex_action_27alex_action_28alex_action_29alex_action_30alex_action_31alex_action_32alex_action_33alex_action_34alex_action_35alex_action_36alex_action_37alex_action_38alex_action_39alex_action_40alex_action_41alex_action_42alex_action_44alex_action_46alex_action_48alex_action_49alex_action_50alex_action_51alex_action_52alex_action_53alex_action_54alex_action_55alex_action_56alex_action_57alex_action_58alex_action_59alex_action_60alex_action_61alex_action_62alex_action_63alex_action_64alex_action_65alex_action_66alex_action_67alex_action_68alex_action_69alex_action_70alex_action_71alex_action_72alex_action_73alex_action_74alex_action_75alex_action_76alex_action_77alex_action_78alex_action_79alex_action_80alex_action_81alex_action_82alex_action_83alex_action_84alex_action_85alex_action_86alex_action_87alex_action_88alex_action_89alex_action_90alex_action_91alex_action_92alex_action_93alex_action_94alex_action_95alex_action_96alex_action_97alex_action_98alex_action_99alex_action_100alex_action_101alex_action_102alex_action_103alex_action_104alex_action_105alex_action_106alex_action_107alex_action_108alex_action_109alex_action_110alex_action_111alex_action_112alex_action_113alex_action_114alex_action_115alex_action_116alex_action_117alexIndexInt16OffAddralexIndexInt32OffAddr quickIndex alex_scan_tkn alexAndPredalexPrevCharIsalexPrevCharMatchesalexPrevCharIsOneOfalexRightContext returnEOFskipTonewInputfoolAlex qualified postToken getOffside happyErrortakeOptionsPragmasfigureOutTopLevelModulemkQNameisNameforallPitLetaddTypeverifyImportDirective splitOnDotsvalidHaskellModuleName exprToLHS exprToPattern exprToName HappyAddrHappyA#HappyStk Happy_IntList HappyCons RHSOrTypeSigsJustRHS TypeSigsRHSRecordDirectiveEtaHappyAny HappyAbsSynhappyIn9 happyOut9 happyIn10 happyOut10 happyIn11 happyOut11 happyIn12 happyOut12 happyIn13 happyOut13 happyIn14 happyOut14 happyIn15 happyOut15 happyIn16 happyOut16 happyIn17 happyOut17 happyIn18 happyOut18 happyIn19 happyOut19 happyIn20 happyOut20 happyIn21 happyOut21 happyIn22 happyOut22 happyIn23 happyOut23 happyIn24 happyOut24 happyIn25 happyOut25 happyIn26 happyOut26 happyIn27 happyOut27 happyIn28 happyOut28 happyIn29 happyOut29 happyIn30 happyOut30 happyIn31 happyOut31 happyIn32 happyOut32 happyIn33 happyOut33 happyIn34 happyOut34 happyIn35 happyOut35 happyIn36 happyOut36 happyIn37 happyOut37 happyIn38 happyOut38 happyIn39 happyOut39 happyIn40 happyOut40 happyIn41 happyOut41 happyIn42 happyOut42 happyIn43 happyOut43 happyIn44 happyOut44 happyIn45 happyOut45 happyIn46 happyOut46 happyIn47 happyOut47 happyIn48 happyOut48 happyIn49 happyOut49 happyIn50 happyOut50 happyIn51 happyOut51 happyIn52 happyOut52 happyIn53 happyOut53 happyIn54 happyOut54 happyIn55 happyOut55 happyIn56 happyOut56 happyIn57 happyOut57 happyIn58 happyOut58 happyIn59 happyOut59 happyIn60 happyOut60 happyIn61 happyOut61 happyIn62 happyOut62 happyIn63 happyOut63 happyIn64 happyOut64 happyIn65 happyOut65 happyIn66 happyOut66 happyIn67 happyOut67 happyIn68 happyOut68 happyIn69 happyOut69 happyIn70 happyOut70 happyIn71 happyOut71 happyIn72 happyOut72 happyIn73 happyOut73 happyIn74 happyOut74 happyIn75 happyOut75 happyIn76 happyOut76 happyIn77 happyOut77 happyIn78 happyOut78 happyIn79 happyOut79 happyIn80 happyOut80 happyIn81 happyOut81 happyIn82 happyOut82 happyIn83 happyOut83 happyIn84 happyOut84 happyIn85 happyOut85 happyIn86 happyOut86 happyIn87 happyOut87 happyIn88 happyOut88 happyIn89 happyOut89 happyIn90 happyOut90 happyIn91 happyOut91 happyIn92 happyOut92 happyIn93 happyOut93 happyIn94 happyOut94 happyIn95 happyOut95 happyIn96 happyOut96 happyIn97 happyOut97 happyIn98 happyOut98 happyIn99 happyOut99 happyIn100 happyOut100 happyIn101 happyOut101 happyIn102 happyOut102 happyIn103 happyOut103 happyIn104 happyOut104 happyIn105 happyOut105 happyIn106 happyOut106 happyIn107 happyOut107 happyIn108 happyOut108 happyIn109 happyOut109 happyIn110 happyOut110 happyIn111 happyOut111 happyIn112 happyOut112 happyIn113 happyOut113 happyIn114 happyOut114 happyIn115 happyOut115 happyIn116 happyOut116 happyIn117 happyOut117 happyIn118 happyOut118 happyIn119 happyOut119 happyIn120 happyOut120 happyIn121 happyOut121 happyIn122 happyOut122 happyIn123 happyOut123 happyIn124 happyOut124 happyIn125 happyOut125 happyIn126 happyOut126 happyIn127 happyOut127 happyIn128 happyOut128 happyIn129 happyOut129 happyIn130 happyOut130 happyIn131 happyOut131 happyIn132 happyOut132 happyIn133 happyOut133 happyIn134 happyOut134 happyIn135 happyOut135 happyIn136 happyOut136 happyIn137 happyOut137 happyIn138 happyOut138 happyIn139 happyOut139 happyIn140 happyOut140 happyIn141 happyOut141 happyIn142 happyOut142 happyIn143 happyOut143 happyIn144 happyOut144 happyIn145 happyOut145 happyIn146 happyOut146 happyIn147 happyOut147 happyIn148 happyOut148 happyIn149 happyOut149 happyIn150 happyOut150 happyIn151 happyOut151 happyIn152 happyOut152 happyIn153 happyOut153 happyIn154 happyOut154 happyIn155 happyOut155 happyIn156 happyOut156 happyIn157 happyOut157 happyIn158 happyOut158 happyIn159 happyOut159 happyIn160 happyOut160 happyIn161 happyOut161 happyIn162 happyOut162 happyIn163 happyOut163 happyIn164 happyOut164 happyIn165 happyOut165 happyIn166 happyOut166 happyIn167 happyOut167 happyInTok happyOutTokhappyActOffsetshappyGotoOffsetshappyDefActions happyCheck happyTablehappyReduceArr happy_n_termshappy_n_nonterms happyReduce_6happyReduction_6 happyReduce_7happyReduction_7 happyReduce_8happyReduction_8 happyReduce_9happyReduction_9happyReduce_10happyReduction_10happyReduce_11happyReduction_11happyReduce_12happyReduction_12happyReduce_13happyReduction_13happyReduce_14happyReduction_14happyReduce_15happyReduction_15happyReduce_16happyReduction_16happyReduce_17happyReduction_17happyReduce_18happyReduction_18happyReduce_19happyReduction_19happyReduce_20happyReduction_20happyReduce_21happyReduction_21happyReduce_22happyReduction_22happyReduce_23happyReduction_23happyReduce_24happyReduction_24happyReduce_25happyReduction_25happyReduce_26happyReduction_26happyReduce_27happyReduction_27happyReduce_28happyReduction_28happyReduce_29happyReduction_29happyReduce_30happyReduction_30happyReduce_31happyReduction_31happyReduce_32happyReduction_32happyReduce_33happyReduction_33happyReduce_34happyReduction_34happyReduce_35happyReduction_35happyReduce_36happyReduction_36happyReduce_37happyReduction_37happyReduce_38happyReduction_38happyReduce_39happyReduction_39happyReduce_40happyReduction_40happyReduce_41happyReduction_41happyReduce_42happyReduction_42happyReduce_43happyReduction_43happyReduce_44happyReduction_44happyReduce_45happyReduction_45happyReduce_46happyReduction_46happyReduce_47happyReduction_47happyReduce_48happyReduction_48happyReduce_49happyReduction_49happyReduce_50happyReduction_50happyReduce_51happyReduction_51happyReduce_52happyReduction_52happyReduce_53happyReduction_53happyReduce_54happyReduction_54happyReduce_55happyReduction_55happyReduce_56happyReduction_56happyReduce_57happyReduction_57happyReduce_58happyReduction_58happyReduce_59happyReduction_59happyReduce_60happyReduction_60happyReduce_61happyReduction_61happyReduce_62happyReduction_62happyReduce_63happyReduction_63happyReduce_64happyReduction_64happyReduce_65happyReduction_65happyReduce_66happyReduction_66happyReduce_67happyReduction_67happyReduce_68happyReduction_68happyReduce_69happyReduction_69happyReduce_70happyReduction_70happyReduce_71happyReduction_71happyReduce_72happyReduction_72happyReduce_73happyReduction_73happyReduce_74happyReduction_74happyReduce_75happyReduction_75happyReduce_76happyReduction_76happyReduce_77happyReduction_77happyReduce_78happyReduction_78happyReduce_79happyReduction_79happyReduce_80happyReduction_80happyReduce_81happyReduction_81happyReduce_82happyReduction_82happyReduce_83happyReduction_83happyReduce_84happyReduction_84happyReduce_85happyReduction_85happyReduce_86happyReduction_86happyReduce_87happyReduction_87happyReduce_88happyReduction_88happyReduce_89happyReduction_89happyReduce_90happyReduction_90happyReduce_91happyReduction_91happyReduce_92happyReduction_92happyReduce_93happyReduction_93happyReduce_94happyReduction_94happyReduce_95happyReduction_95happyReduce_96happyReduction_96happyReduce_97happyReduction_97happyReduce_98happyReduction_98happyReduce_99happyReduction_99happyReduce_100happyReduction_100happyReduce_101happyReduction_101happyReduce_102happyReduction_102happyReduce_103happyReduction_103happyReduce_104happyReduction_104happyReduce_105happyReduction_105happyReduce_106happyReduction_106happyReduce_107happyReduction_107happyReduce_108happyReduction_108happyReduce_109happyReduction_109happyReduce_110happyReduction_110happyReduce_111happyReduction_111happyReduce_112happyReduction_112happyReduce_113happyReduction_113happyReduce_114happyReduction_114happyReduce_115happyReduction_115happyReduce_116happyReduction_116happyReduce_117happyReduction_117happyReduce_118happyReduction_118happyReduce_119happyReduction_119happyReduce_120happyReduction_120happyReduce_121happyReduction_121happyReduce_122happyReduction_122happyReduce_123happyReduction_123happyReduce_124happyReduction_124happyReduce_125happyReduction_125happyReduce_126happyReduction_126happyReduce_127happyReduction_127happyReduce_128happyReduction_128happyReduce_129happyReduction_129happyReduce_130happyReduction_130happyReduce_131happyReduction_131happyReduce_132happyReduction_132happyReduce_133happyReduction_133happyReduce_134happyReduction_134happyReduce_135happyReduction_135happyReduce_136happyReduction_136happyReduce_137happyReduction_137happyReduce_138happyReduction_138happyReduce_139happyReduction_139happyReduce_140happyReduction_140happyReduce_141happyReduction_141happyReduce_142happyReduction_142happyReduce_143happyReduction_143happyReduce_144happyReduction_144happyReduce_145happyReduction_145happyReduce_146happyReduction_146happyReduce_147happyReduction_147happyReduce_148happyReduction_148happyReduce_149happyReduction_149happyReduce_150happyReduction_150happyReduce_151happyReduction_151happyReduce_152happyReduction_152happyReduce_153happyReduction_153happyReduce_154happyReduction_154happyReduce_155happyReduction_155happyReduce_156happyReduction_156happyReduce_157happyReduction_157happyReduce_158happyReduction_158happyReduce_159happyReduction_159happyReduce_160happyReduction_160happyReduce_161happyReduction_161happyReduce_162happyReduction_162happyReduce_163happyReduction_163happyReduce_164happyReduction_164happyReduce_165happyReduction_165happyReduce_166happyReduction_166happyReduce_167happyReduction_167happyReduce_168happyReduction_168happyReduce_169happyReduction_169happyReduce_170happyReduction_170happyReduce_171happyReduction_171happyReduce_172happyReduction_172happyReduce_173happyReduction_173happyReduce_174happyReduction_174happyReduce_175happyReduction_175happyReduce_176happyReduction_176happyReduce_177happyReduction_177happyReduce_178happyReduction_178happyReduce_179happyReduction_179happyReduce_180happyReduction_180happyReduce_181happyReduction_181happyReduce_182happyReduction_182happyReduce_183happyReduction_183happyReduce_184happyReduction_184happyReduce_185happyReduction_185happyReduce_186happyReduction_186happyReduce_187happyReduction_187happyReduce_188happyReduction_188happyReduce_189happyReduction_189happyReduce_190happyReduction_190happyReduce_191happyReduction_191happyReduce_192happyReduction_192happyReduce_193happyReduction_193happyReduce_194happyReduction_194happyReduce_195happyReduction_195happyReduce_196happyReduction_196happyReduce_197happyReduction_197happyReduce_198happyReduction_198happyReduce_199happyReduction_199happyReduce_200happyReduction_200happyReduce_201happyReduction_201happyReduce_202happyReduction_202happyReduce_203happyReduction_203happyReduce_204happyReduction_204happyReduce_205happyReduction_205happyReduce_206happyReduction_206happyReduce_207happyReduction_207happyReduce_208happyReduction_208happyReduce_209happyReduction_209happyReduce_210happyReduction_210happyReduce_211happyReduction_211happyReduce_212happyReduction_212happyReduce_213happyReduction_213happyReduce_214happyReduction_214happyReduce_215happyReduction_215happyReduce_216happyReduction_216happyReduce_217happyReduction_217happyReduce_218happyReduction_218happyReduce_219happyReduction_219happyReduce_220happyReduction_220happyReduce_221happyReduction_221happyReduce_222happyReduction_222happyReduce_223happyReduction_223happyReduce_224happyReduction_224happyReduce_225happyReduction_225happyReduce_226happyReduction_226happyReduce_227happyReduction_227happyReduce_228happyReduction_228happyReduce_229happyReduction_229happyReduce_230happyReduction_230happyReduce_231happyReduction_231happyReduce_232happyReduction_232happyReduce_233happyReduction_233happyReduce_234happyReduction_234happyReduce_235happyReduction_235happyReduce_236happyReduction_236happyReduce_237happyReduction_237happyReduce_238happyReduction_238happyReduce_239happyReduction_239happyReduce_240happyReduction_240happyReduce_241happyReduction_241happyReduce_242happyReduction_242happyReduce_243happyReduction_243happyReduce_244happyReduction_244happyReduce_245happyReduction_245happyReduce_246happyReduction_246happyReduce_247happyReduction_247happyReduce_248happyReduction_248happyReduce_249happyReduction_249happyReduce_250happyReduction_250happyReduce_251happyReduction_251happyReduce_252happyReduction_252happyReduce_253happyReduction_253happyReduce_254happyReduction_254happyReduce_255happyReduction_255happyReduce_256happyReduction_256happyReduce_257happyReduction_257happyReduce_258happyReduction_258happyReduce_259happyReduction_259happyReduce_260happyReduction_260happyReduce_261happyReduction_261happyReduce_262happyReduction_262happyReduce_263happyReduction_263happyReduce_264happyReduction_264happyReduce_265happyReduction_265happyReduce_266happyReduction_266happyReduce_267happyReduction_267happyReduce_268happyReduction_268happyReduce_269happyReduction_269happyReduce_270happyReduction_270happyReduce_271happyReduction_271happyReduce_272happyReduction_272happyReduce_273happyReduction_273happyReduce_274happyReduction_274happyReduce_275happyReduction_275happyReduce_276happyReduction_276happyReduce_277happyReduction_277happyReduce_278happyReduction_278happyReduce_279happyReduction_279happyReduce_280happyReduction_280happyReduce_281happyReduction_281happyReduce_282happyReduction_282happyReduce_283happyReduction_283happyReduce_284happyReduction_284happyReduce_285happyReduction_285happyReduce_286happyReduction_286happyReduce_287happyReduction_287happyReduce_288happyReduction_288happyReduce_289happyReduction_289happyReduce_290happyReduction_290happyReduce_291happyReduction_291happyReduce_292happyReduction_292happyReduce_293happyReduction_293happyReduce_294happyReduction_294happyReduce_295happyReduction_295happyReduce_296happyReduction_296happyReduce_297happyReduction_297happyReduce_298happyReduction_298happyReduce_299happyReduction_299happyReduce_300happyReduction_300happyReduce_301happyReduction_301happyReduce_302happyReduction_302happyReduce_303happyReduction_303happyReduce_304happyReduction_304happyReduce_305happyReduction_305happyReduce_306happyReduction_306happyReduce_307happyReduction_307happyReduce_308happyReduction_308happyReduce_309happyReduction_309happyReduce_310happyReduction_310happyReduce_311happyReduction_311happyReduce_312happyReduction_312happyReduce_313happyReduction_313happyReduce_314happyReduction_314happyReduce_315happyReduction_315happyReduce_316happyReduction_316happyReduce_317happyReduction_317happyReduce_318happyReduction_318happyReduce_319happyReduction_319happyReduce_320happyReduction_320happyReduce_321happyReduction_321happyReduce_322happyReduction_322happyReduce_323happyReduction_323happyReduce_324happyReduction_324happyReduce_325happyReduction_325happyReduce_326happyReduction_326happyReduce_327happyReduction_327happyReduce_328happyReduction_328happyReduce_329happyReduction_329happyReduce_330happyReduction_330happyReduce_331happyReduction_331happyReduce_332happyReduction_332happyReduce_333happyReduction_333happyReduce_334happyReduction_334happyReduce_335happyReduction_335happyReduce_336happyReduction_336happyReduce_337happyReduction_337happyReduce_338happyReduction_338happyReduce_339happyReduction_339happyReduce_340happyReduction_340happyReduce_341happyReduction_341happyReduce_342happyReduction_342happyReduce_343happyReduction_343happyReduce_344happyReduction_344happyReduce_345happyReduction_345happyReduce_346happyReduction_346happyReduce_347happyReduction_347happyReduce_348happyReduction_348happyReduce_349happyReduction_349happyReduce_350happyReduction_350happyReduce_351happyReduction_351happyReduce_352happyReduction_352happyReduce_353happyReduction_353happyReduce_354happyReduction_354happyReduce_355happyReduction_355happyReduce_356happyReduction_356happyReduce_357happyReduction_357happyReduce_358happyReduction_358happyReduce_359happyReduction_359happyReduce_360happyReduction_360happyReduce_361happyReduction_361happyReduce_362happyReduction_362happyReduce_363happyReduction_363happyReduce_364happyReduction_364happyReduce_365happyReduction_365happyReduce_366happyReduction_366happyReduce_367happyReduction_367happyReduce_368happyReduction_368happyReduce_369happyReduction_369happyReduce_370happyReduction_370happyReduce_371happyReduction_371happyReduce_372happyReduction_372happyReduce_373happyReduction_373happyReduce_374happyReduction_374happyReduce_375happyReduction_375happyReduce_376happyReduction_376happyReduce_377happyReduction_377happyReduce_378happyReduction_378happyReduce_379happyReduction_379happyReduce_380happyReduction_380happyReduce_381happyReduction_381happyReduce_382happyReduction_382happyReduce_383happyReduction_383happyReduce_384happyReduction_384happyReduce_385happyReduction_385happyReduce_386happyReduction_386happyReduce_387happyReduction_387happyReduce_388happyReduction_388happyReduce_389happyReduction_389happyReduce_390happyReduction_390happyReduce_391happyReduction_391happyReduce_392happyReduction_392happyReduce_393happyReduction_393happyReduce_394happyReduction_394happyReduce_395happyReduction_395happyReduce_396happyReduction_396happyReduce_397happyReduction_397happyReduce_398happyReduction_398happyReduce_399happyReduction_399happyReduce_400happyReduction_400happyReduce_401happyReduction_401happyReduce_402happyReduction_402happyReduce_403happyReduction_403happyReduce_404happyReduction_404happyReduce_405happyReduction_405happyReduce_406happyReduction_406happyReduce_407happyReduction_407happyReduce_408happyReduction_408happyReduce_409happyReduction_409happyReduce_410happyReduction_410happyReduce_411happyReduction_411happyReduce_412happyReduction_412happyReduce_413happyReduction_413happyReduce_414happyReduction_414happyReduce_415happyReduction_415happyReduce_416happyReduction_416happyReduce_417happyReduction_417happyReduce_418happyReduction_418happyReduce_419happyReduction_419happyReduce_420happyReduction_420happyReduce_421happyReduction_421happyReduce_422happyReduction_422happyReduce_423happyReduction_423happyReduce_424happyReduction_424happyReduce_425happyReduction_425happyReduce_426happyReduction_426happyReduce_427happyReduction_427happyReduce_428happyReduction_428happyReduce_429happyReduction_429happyReduce_430happyReduction_430happyReduce_431happyReduction_431happyReduce_432happyReduction_432happyReduce_433happyReduction_433happyReduce_434happyReduction_434happyReduce_435happyReduction_435happyReduce_436happyReduction_436happyReduce_437happyReduction_437happyReduce_438happyReduction_438happyReduce_439happyReduction_439happyReduce_440happyReduction_440happyReduce_441happyReduction_441happyReduce_442happyReduction_442happyReduce_443happyReduction_443happyReduce_444happyReduction_444happyReduce_445happyReduction_445happyReduce_446happyReduction_446happyReduce_447happyReduction_447happyReduce_448happyReduction_448happyReduce_449happyReduction_449happyReduce_450happyReduction_450happyReduce_451happyReduction_451happyReduce_452happyReduction_452happyReduce_453happyReduction_453happyReduce_454happyReduction_454happyReduce_455happyReduction_455happyReduce_456happyReduction_456happyReduce_457happyReduction_457happyReduce_458happyReduction_458happyReduce_459happyReduction_459happyReduce_460happyReduction_460happyReduce_461happyReduction_461happyReduce_462happyReduction_462happyReduce_463happyReduction_463happyReduce_464happyReduction_464happyReduce_465happyReduction_465happyReduce_466happyReduction_466happyReduce_467happyReduction_467happyReduce_468happyReduction_468happyReduce_469happyReduction_469happyReduce_470happyReduction_470happyReduce_471happyReduction_471happyReduce_472happyReduction_472happyReduce_473happyReduction_473happyReduce_474happyReduction_474happyReduce_475happyReduction_475happyReduce_476happyReduction_476 happyNewToken happyError_ happyThen happyReturn happyThen1 happyReturn1 happyError'funclauseParserhappySeq recoverLayout ensureUnqualmergeImportDirectivesverifyRecordDirectivesprop_splitOnDotsopAppExprToPatternstripSingletonRawAppisEqual maybeNamedpatternSynArgs parsePanicpatternToNamesfunClauseOrTypeSigsparseDisplayPragma happyParse happyAccept happyDoActionindexShortOffAddr happyShifthappySpecReduce_0happySpecReduce_1happySpecReduce_2happySpecReduce_3 happyReducehappyMonadReducehappyMonad2Reduce happyDrop happyDropStk happyGoto happyFail notHappyAtAll happyTcHack happyDoSeq happyDontSeq withCommentswithoutCommentsparserwrapwrapMparseLiterateFile agdaLibFields GenericLineHeaderContentfName fOptionalfParsefSet GenericFiledefaultLibFileparseLib findField fromGeneric fromGeneric' checkFields parseGeneric parseLine groupLinesLibError LibNotFound AmbiguousLib OtherError getAgdaAppDirdefaultLibraryFiles defaultsFilemkLibMfindAgdaLibFilesreadDefaultsFilegetLibrariesFile parseLibFilesstripCommentLinesformatLibErrorfindLibmatchLib versionViewdefaultLaTeXDirdefaultHTMLDirdefaultPragmaOptionsSafedefaultPragmaOptionsprop_defaultOptions versionFlaghelpFlagsafeFlag sharingFlag cachingFlagproofIrrelevanceFlagexperimentalIrrelevanceFlagnoIrrelevantProjectionsFlagignoreInterfacesFlagallowUnsolvedFlagshowImplicitFlagshowIrrelevantFlag runTestsFlagghciInteractionFlagvimFlag latexFlag latexDirFlagnoPositivityFlagdontTerminationCheckFlagdontCompletenessCheckFlagdontUniverseCheckFlagetaFlag noEtaFlag sizedTypes noSizedTypesinjectiveTypeConstructorFlagguardingTypeConstructorFlaguniversePolymorphismFlagnoUniversePolymorphismFlag noForcingFlag withKFlag withoutKFlagcopatternsFlagnoCopatternsFlagnoPatternMatchingFlagexactSplitFlagnoExactSplitFlag rewritingFlaginteractiveFlagcompileFlagNoMaincompileGhcFlagghcDontCallGhcFlagghcFlagcompileEpicFlag compileJSFlagcompileUHCFlagcompileDirFlag epicFlagsFlag uhcBinFlaguhcTextualCoreFlaguhcDontCallUHCFlaguhcTraceLevelFlag uhcFlagsFlagoptimNoSmashinghtmlFlagdependencyGraphFlag htmlDirFlagcssFlag includeFlag libraryFlagoverrideLibrariesFileFlagnoDefaultLibsFlag verboseFlagterminationDepthFlagintegerArgumentstripRTSprop_rangesToPositions prop_minus mergeAspectsmergemergeC prop_compressprop_singleton prop_several prop_merge prop_splitAtCprop_smallestPosrunningInfoBufferNameCPatRest CExpr_DUMMYPP ctagDataTyNm primCrTys1PEnvpPrecpFreshpBound withNames bindNamesparenprecnamerunPopNamepTerm'pTerm-geniplate-mirror-0.7.4-CR8Csdo4hCP8b8iXdHXrlgData.Generics.GeniplateinstanceUniverseBiT universeBiinstanceTransformBiMT transformBiMFreeT fcIgnoreSorts fcContextflexible irrelevantlyunused subtractFVFreeConf initFreeConf occurrenceFVfreeIn'mapSRVmapUGVmapWRVmapIRVmapUUVmapFXVbenchfreeIn'')hashtables-1.2.1.0-5KfyleD814C26mncEt1Ul2Data.HashTable.IOCuckooHashTableBasicHashTableLinearHashTable equalAltseqList evalPrims applyPrim splitAltsuncase:=< inequalitiesprop_FlexRig_orderstrictlyAscendingprop_composeFlexRig_associativeprop_composeFlexRig_commutativeprop_composeFlexRig_idempotentprop_composeFlexRig_zeroprop_composeFlexRig_unitprop_FlexRig_distributiveprop_maxVarOcc_topprop_maxVarOcc_bot prop_freeInprop_old_freeVars_Pi same_freeVars old_to_new_FV new_to_old_FVty new_fv_ty old_fv_typrop_old_freeVars_Termprop_old_freeIn_Termprop_old_freeIn_Type benchmarking benchmarkKeybenchmarkLevelSerialisedRangeunderlyingRangeAlphapatsPEPaththePath groupClauses pathToRecord groupPathesalphaalpha'Renamerename'NameMapProjPath ProjEntryprojPE theContent mapContent clauseToPath lhsToPath pathHeads pathSplittell1PatternCheckConfigtopNameconNamesfldNamesParsers billToParsergetDefinedNames localNames buildParserspatternAppViewparsePat parseLHS'classifyPatternvalidConPatternqualifierModulesParseLHSExprKind IsPatternpToppApppArgspNonfixpAtom FlatScopeparsePatternOrSynparseModuleIdentifierparseRawModuleApplication fullParen fullParen'unsafeQNameToNamebracket'bracket bracketP_ withInfixDeclbindToConcreteCtx toConcreteTopbindToConcreteToptoConcreteHidingbindToConcreteHidingHdHdVarHdConHdDef AsWhereDecls takenNames currentScope defaultEnvcurrentPrecedencewithPrecedence lookupName lookupQName lookupModulewithAbstractPrivatemakeDomainFreemergeSigAndDef openModule'declsToConcrete appBrackets'cOpApptryToRecoverOpApptryToRecoverOpAppP recoverOpApp modifyCachegetCacheputCache modifyCounterisSucisPosisNegSucisPlusisTimesisLessisForce transform computeUnusedlamView unlamView isMagicEntityisMagictoAtoms showAspects modToFilepositioncolumninCodedebugsLaTeXrunLaTeX nextToken'nonCodefixityspacestoLaTeXDebug MoveColumnNonCodeCodeSpacesOutputinfoTokensState indentPrev emptyState isInfixOf' isInfixOfRevisSpacesisActualSpaces nextToken resetColumn moveColumn setIndent resetIndent setIndentPrevresetIndentPrev setInCode unsetInCode logHelperloglog'nl beginCodeendCodeptOpenptOpen'ptCloseptClose'ptNL cmdPrefixcmdArg cmdIndentinfixl'infix'infixr'defaultStyFile processTokenscyclicrecDefgetsuseRlocalR withFreshR withFreshNamewithFreshName_many'curly prettyEpicBr prettyEpicLittypVar icodeFileModcurrentInterfaceVersionSynEqMinequalifEqualsynEqsynEq'<$$>pure2<**>DotVarsreifyDisplayFormreifyDisplayFormPnameFirstIfHidden shuffleDotsstripImplicitstryRecPFromConPTickTunTickT MonadTickdotVarsisConPat MonoidMap unMonoidMapDoBindYesBindNoBind DontTouchDotBindBindFirstExplicitBindFirstImplicit AlreadyBoundnappsreifyApp reifyIArg reifyIArgselims reifyIElim reifyIElimsexprInfo reifyWhenE reifyTermrunTickT IndefinitedropTopLevelModule prettyInEqual Verbalize verbalize PrettyUnequal prettyUnequalsayWheresayWhenpanicnameWithBinding errorStringnotCmp singPluralwithExprClausesfmapinlinedClausesinlineFunInfoTypeInfoErasable NotErasableESt_funMap_typeMapfunMaptypeMaprunE erasableRerasable getFunInfo telListViewtypeWithoutParams getTypeInfogenericReplicate Data.Sequence RecordTreeLeafRecConVarPatDotPatKindRecPatMDropFromRecordSplitTreeRecordSplitNodesplitCon splitAritysplitRecordPattern conjColumns insertColumn cutSublistreplaceByProjections isRecordCaserecordSplitTree runRecPatMnextVar projections removeTreetranslatePattern recordTree translateTel translateBody dropBindsChangesRecordSplitTreesgetEtaAndAritytranslatePatterns displayLHSpatternsToTerms inheritHiding pappToTermbindWildbindVar exprToTermStripAllProjections ExtractCallsCalls termDecls termDecl' termMutual termMutual'terminationError reportCalls termFunction typeEndsInDeftermDefsetMasks targetElem termToDBPstripCoConstructorsmaskNonDataArgs openClause termClauseintroHiddenLambdas constructorguardPresTyCon withFunction maskSizeLtannotatePatsWithUseSizeLt compareElim compareProjmakeCMaddGuardednesscomposeGuardednessoffsetFromConstructor subPatternssubTerm compareVarVarstripAllProjectionsextractbillToTerGraph termClause' isSubTermcompareConArgs compareVar NameKindstokenHighlighting nameKindsgenerateConstructorInfoterminationErrorHighlighting nameToFile nameToFileA concreteBaseconcreteQualifier bindingSiteAtomNegArith FunctionKitmodAuxdivAuxnatMinustruefalseSEnvenvSubst envRewriterunS lookupVaronSubst onRewrite addRewrite underLamsunderLamunderLetaNegaCancelsortRaAddaSub fromArithaddAtomtoArith simplArith ccCatchAll lookupLevel casetreeTop replaceVarmkRecord prettyPure toTreeless' ccToTreeless alwaysInlinecasetree commonArityupdateCatchAll lambdasUpToconAltslitAltsbranchrecConFromProjmaybeInlineDef substArgssubstArg checkType' checkArgInfo inferDef' inferSpine inferSpine'shouldBeProjectible shouldBeSort checkSort checkLevelmetaTypesubtypecheckTypeSpine checkSpine checkArgs checkHidingcheckRelevance shouldBePiifIsSortcheckParsIfUnambiguous getVarType getEqualitygetEqualityUnraisedaddEqssolveVarsolveEq simplifyEqisHomisEtaVarUnifyM UnifyOutput unifySubstunifyLogUnifyLog UnifyLogEntryUnificationDoneUnificationStep UnifyStrategy UnifyStepDeletionConflictCycle EtaExpandVarEtaExpandEquation LitConflict StripSizeSucSkipIrrelevantEquationTypeConInjectivitydeleteAt deleteType deleteLeft deleteRight solutionAt solutionType solutionVar solutionTerminjectAt injectTypeinjectDatatypeinjectParameters injectIndicesinjectConstructorinjectArgsLeftinjectArgsRight conflictAtconflictDatatypeconflictParametersconflictConLeftconflictConRightcycleAt cycleDatatypecycleParameterscycleVar cycleOccursIn expandVarexpandVarRecordTypeexpandVarParametersexpandAtexpandRecordTypeexpandParameters litConflictAtlitConflictLeftlitConflictRightstripAt stripArgLeft stripArgRightskipIrrelevantAttypeConInjectAttypeConstructortypeConArgsLefttypeConArgsRight UnifyStateUStatevarTelflexVarseqTeleqLHSeqRHSEqualityeqTypeeqLefteqRighteqConstructorForm eqUnLevel reduceVarTel reduceEqTelnormaliseVarTelnormaliseEqTelinitUnifyStateisUnifyStateSolvedvarCountgetVarTypeUnraisedeqCount getEqInfoaddEq applyUnderdropAtleftToRightStrategyrightToLeftStrategycompleteStrategyAt findFlexiblebasicUnifyStrategy dataStrategycheckEqualityStrategyliteralStrategyetaExpandVarStrategyetaExpandEquationStrategysimplifySizesStrategyinjectiveTypeConStrategyskipIrrelevantStrategytellUnifySubst writeUnifyLog runUnifyM unifyStepcomputeNeighbourhoodsplitlookupPatternVarsplit'CoverM splitStrategybuiltinPostulate coreBuiltinsinductiveCheckgetDefbindAndSetHaskellTypebindBuiltinBoolbindBuiltinIntbindBuiltinNatbindBuiltinUnitbindBuiltinInfoWithRHS' rhsRewriteEqn rhsWithExpr rhsSubclausesEnsureNoLetStmscheckPatternLinearity noDotPatternrecordConstructorTypecheckModuleApplicationcheckModuleMacronotPublicWithoutOpen renamingRange checkOpen toAbstractCtxlocalToAbstract' mkNamedArgmkArg'mkArg toAbstractDot toAbstractLamscopeCheckExtendedLamscopeCheckNiceModuletelHasOpenStmsOrModuleMacrosscopeCheckModule niceDeclstoAbstractOpArgtoAbstractOpApp AbsurdRHS' RewriteRHS'rhs rhsWhereDecls ConstrDecl IsRecordConYesRecNoRecunBlindensureNoLetStmsToQNametoQName VarPatName ConPatNamePatternSynPatNamenotAnExpressionnothingAppliedToHiddenArgnothingAppliedToInstanceArgnotAValidLetBinding printLocals annotateDecl annotateDecls annotateExprtoAbstractTopCtxtoAbstractHiding setContextCPSlocalToAbstractCtx freshQModulecheckForModuleClashmakeDomainFull aDefToMode aModeToDefbindConstructorNamewhereToAbstract qualifyName_withFunctionNameresolvePatternIdentifiercollectNamesInTypecollectNamesInTermcollectNamesInElimscollectNamesInElimcollectNamesInArgs isModCharprop_encodeModuleName_injectiveprop_encodeModuleName_OKprop_encodeModuleName_preserved coreExports unqualifyQ unCompileTcoreMeta coreMetaData coreMetaCongetTimeappendCoreMeta addExports'initialAnalysis compileDefns setEpicDirrunEpic runEpicMaincallEpic callEpic'compilePreludereadEInterface compileModuleidPrint runUHCMaincopyUHCAgdaBasecorePath writeCoreFilecallUHC1 getUhcBin AutoHintModeAHMNone AHMModuleMNormal MCaseSplitMRefineinsertAbsurdPatterngetNamedispmsg autohints insuffsols insuffcands parseargsControl.Monad.Trans.State.LazyStateTControl.Monad.Trans.ClassControl.Monad.IO.ClassliftIO Text.ReadreadslispifyResponselastTag showNumIId