!' #ۥ7               ! " # $ % & ' ( ) * +,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcd e f g hijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGH I J K L MNOPQRSTUVWXYZ[\]^_`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-{-|-}-~---------------------------------------------..........////00000000001111111111111111111111111112222222222222222222222222222222222233333333 3 3 3 3 3333333333333333333 3!3"3#3$3%3&3'3(3)3*3+3,3-3.3/303142434445465758595:5;5<5=5>5?5@5A5B5C5D5E5F6G6H6I6J6K6L6M6N6O6P6Q7R7S7T7U7V7W7X7Y7Z7[7\7]7^7_8`8a8b9c9d9e9f9g9h9i9j9k9l9m9n9o9p9q9r9stuvwxyz{|}~:::::::::::::::::::::::::::::;;;;;;;;;;;;;;<<<<<<=========================================================================== = = = = =================== =!="=#=$=%=&='=(=)=*=+=,=-=.=/0123456789:;<=>?@ABCDEFGHIJ>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@{@|@}@~@@@@@                    AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBCCCCCCCCCCCCCCCDDDDDDDDDDDDDDEEEEE      !"#$%&'()*+,-./0123456789:;F<F=F>F?F@FAFBFCFDFEFFFGFHFIFJFKFLFMFNFOFPFQFRFSFTFUFVFWFXFYFZF[F\G]G^G_G`GaGbGcGdGeGfGgGhGiGjGkGlGmGnGoGpGqGrGsGtGuGvGwGxGyGzG{G|G}G~GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGHHHHHHHHHHHHHHHH H H H H HHHHHHHHHHHHHHHHHHH H!H"H#H$H%H&H'H(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~IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I !I "I #I $I %I &I 'I (I )I *I +I ,I -I .I /I 0I 1I 2I 3I 4I 5I 6I 7I 8I 9I :I ;I <I =I >I ?I @I AI BI CI DI EI FI GI HI II JI KI LI MI NI OI PI QI RI SI TI UI VI WI XI YI ZI [I \I ]I ^I _I `I aI bI cI dI eI fI gI hI iI jI kI lI mI nI oI pI qI rI sI tI uI vI wI xI yI zI {I |I }I ~I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I !I "I #I $I %I &I 'I (I )I *I +I ,I -I .I /I 0I 1I 2I 3I 4I 5I 6I 7I 8I 9I :I ;I <I =I >I ?I @I AI BI CI DI EI FI GI HI II JI KI LI MI NI OI PI QI RI SI TI UI VI WI XI YI ZI [I \I ]I ^I _I `I aI bI cI dI eI fI gI hI iI jI kI lI mI nI oI pI qI rI sI tI uI vJ wJ xJ yJ zJ {J |J }J ~J J J J J J J J J J J J J J J J J J K K K K K K K K K K K K K K K K K K K K L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L M 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 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 \O ]O ^O _O `O aO bO cO dO eO fO gO hO iO jO kO lO mO nP oP pP qP rP sP tP uP vP wP xP yP zP {P |P }P ~P P P P P Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q !Q "Q #Q $Q %Q &Q 'Q (Q )Q *Q +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 ]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 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 T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T U U U U U U U U U U U U U U U U U U U U V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V !V "V #V $V %V &V 'V (V )V *V +V ,V -V .V /V 0V 1V 2V 3V 4V 5V 6V 7V 8V 9V :V ;V <V =V >V ?V @V AV BV CV DV EV FV GV HV IV JV KV LV MV NW OW PW QW RW SW TW UW VW WW XW YW ZW [W \W ]W ^W _W `W aW bW cW dW eW fW gW hW iW jW kW lW mW nW oW pW qW rW sW tW uW vW wW xW yW zW {W |W }W ~W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y YYYYYYYYYY Y Y Y Y YYYYYYYYYYYYYYYYZZZ Z!Z"Z#Z$Z%Z&Z'Z(Z)Z*Z+Z,Z-Z.Z/Z0Z1[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[{[|[}[~[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[\]]^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^ ^ ^ ^^^^^^^^^^^^^^^^^^^ ^!^"^#^$^%^&^'^(^)^*^+_,_-_.`/a0a1a2a3a4a5a6a7a8a9b:b;b<b=b>b?b@bAbBbCbDbEbFbGbHbIbJbKbLbMbNbObPbQbRbSbTbUbVbWbXbYbZb[b\b]b^b_b`babbbcbdbebfbgbhbibjbkblbmbnbobpbqbrbsbtbubvbwbxbybzb{b|b}b~bbbbbbbbbbbbcddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddeeee e e e e eeeeeeeeeeeeeeeeeee e!e"e#e$e%e&e'e(e)e*e+e,e-e.e/e0e1e2e3f4f5f6f7f8f9f:f;f<f=f>f?f@fAfBfCfDfEfFfGfHfIfJfKfLfMfNfOfPfQfRfSfTfUfVfWfXfYfZf[f\f]f^f_f`fafbfcfdfefffgfhfifjfkflfmfnfofpfqfrfsftfufvfwfxfyfzf{f|f}f~fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff f f f f fffffffffffffffffff f!f"f#f$f%f&f'f(f)f*f+f,f-f.f/f0f1f2f3f4f5f6f7f8f9f:f;f<f=f>f?f@fAfBfCfDfEfFfGfHfIfJfKfLfMfNfOfPfQfRfSfTfUfVfWfXfYfZf[f\f]f^f_f`fafbfcfdfefffgfhfifjfkflfmfnfofpfqfrfsftfufvfwfxfyfzf{f|f}f~ffffffffffffffffffffffffgggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggghhhhhhhhhhhhhhhhhhh h h h h hhhhhhhhhhhhhhhhhii i!i"i#i$i%i&i'i(i)i*i+i,i-i.i/i0i1i2i3i4i5i6i7i8i9i:i;i<i=i>i?i@iAiBiCiDiEiFiGiHiIiJiKiLiMiNiOiPiQiRjSjTjUjVjWjXjYjZj[j\j]j^j_j`jajbjcjdjejfjgjhjijjjkjljmjnjojpjqjrjsjtjujvjwjxjyjzj{j|j}j~jjkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkllllllllllllllllllllllllllllllllmmmmmmmmmmmmmmmmmmmnnnnnnnnnnnnnnnnnnnnnnnnnnnnnoooooooooooooooooo o o o o ooooooooooooooooooo o!o"o#o$o%o&o'o(o)o*o+o,o-o.o/o0o1o2o3o4o5o6o7o8o9o:o;o<o=o>o?o@oAoBoCoDoEoFoGoHoIoJoKoLoMoNoOoPoQoRoSoToUoVoWoXoYoZo[o\o]o^o_o`papbpcpdpepfpgphpipjpkplpmpnpopppqprpsptpuqvqwqxqyqzq{q|q}q~qqqqqqqqqqqqqq          rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr r r r r rrrrrrrrrrrrrrrrrrr r!r"r#r$r%r&r'r(r)r*r+r,r-r.r/r0r1r2r3r4r5r6r7r8r9r:r;r<r=r>r?r@rArBrCrDrErFrGrHrIrJrKrLrMrNrOrPrQrRrSrTrUrVrWrXrYrZr[r\r]r^r_r`rarbrcrdrerfrgrhrirjrkrlrmrnrorprqrrrsrtrurvrwrxryrzr{r|r}r~rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrssstttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttt t t t t ttttttttttttttttttt t!t"t#t$t%t&t't(t)t*u+u,u-u.u/u0u1u2u3u4u5u6u7u8u9u:u;u<u=u>u?u@uAuBuCuDuEuFuGuHuIuJuKuLuMuNuOuPuQuRuSuTuUuVuWuXuYuZu[u\v]v^v_v`vavbvcvdvevfvgvhvivjvkvlvmvnvovpvqvrvsvtvuvvvwvxvyvzv{w|w}w~wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwxxxxxxxxxxxxxxxxxxxxxxxyyyyzzzzzzzzzzzzzzzzzzzz{{{{{{{{{{{{{{{||}}}}}}}}}}}}}}}}}}}~~~     }}~~ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHI J KLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?M@MAMBMCMDMEMFMGMHMIMJMKMLMMMNMOMPMQMRMSMTMUMVMWMXMYMZM[M\M]M^M_M`MaMbMcMdMeMfMgMhMiMjMkMlMmMnMoMpMqMrMsMtMuMvMwMxMyMzM{M|M}M~MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM M M M M MMMMMMMMMMMMMMMMMMM M!M"M#M$M%M&M'M(M)M*M+M,M-M.M/M0M1M2M3M4M5M6M7M8M9M:M;M<M=M>M?M@MAMBMCMDMEMFMGMHMIMJMKMLMMMNMOMPMQMRMSMTMUMVMWMXMYMZM[M\M]M^M_M`MaMbMcMdMeMfMgMhMiMjMkMlMmMnMoMpMqMrMsMtMuMvMwMxMyMzM{M|M}M~MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM M M M M MMMMMMMMMMMMMMMMMMM M!M"M#M$M%M&M'M(M)M*M+M,M-M.M/M0M1M2M3M4M5M6M7M8M9M:M;M<M=M>M?M@MAMBMCMDMEMFMGMHMIMJMKMLMMMNMOMPMQMRMSMTMUMVMWMXMYMZM[M\M]M^M_M`MaMbMcMdMeMfMgMhMiMjMkMlMmMnMoMpMqMrMsMtMuMvMwMxMyMzM{M|M}M~MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M !M "M #M $M %M &M 'M (M )M *M +M ,M -M .M /M 0M 1M 2M 3M 4M 5M 6M 7M 8M 9M :M ;M <M =M >M ?M @M AM BM CM DM EM FM GM HM IM JM KM LM MM NM OM PM QM RM SM TM UM VM WM XM YM ZM [M \M ]M ^M _M `M aM bM cM dM eM fM gM hM iM jM kM lM mM nM oM pM qM rM sM tM uM vM wM xM yM zM {M |M }M ~M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M!M!M!M!M!M!M!M!M!M! M! M! M! M! M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M! M!!M!"M!#M!$M!%M!&M!'M!(M!)M!*M!+M!,M!-M!.M!/M!0M!1M!2M!3M!4M!5M!6M!7M!8M!9M!:M!;M!<M!=M!>M!?M!@M!AM!BM!CM!DM!EM!FM!GM!HM!IM!JM!KM!LM!MM!NM!OM!PM!QM!RM!SM!TM!UM!VM!WM!XM!YM!ZM![M!\M!]M!^M!_M!`M!aM!bM!cM!dM!eM!fM!gM!hM!iM!jM!kM!lM!mM!nM!oM!pM!qM!rM!sM!tM!uM!vM!wM!xM!yM!zM!{M!|M!}M!~M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M"M"M"M"M"M"M"M"M"M" M" M" M" M" M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M" M"!M""M"#M"$M"%M"&M"'M"(M")M"*M"+M",M"-M".M"/M"0M"1M"2M"3M"4M"5M"6M"7M"8M"9M":M";M"<M"=M">M"?M"@M"AM"BM"CM"DM"EM"FM"GM"HM"IM"JM"KM"LM"MM"NM"OM"PM"QM"RM"SM"TM"UM"VM"WM"XM"YM"ZM"[M"\M"]M"^M"_M"`M"aM"bM"cM"dM"eM"fM"gM"hM"iM"jM"kM"lM"mM"nM"oM"pM"qM"rM"sM"tM"uM"vM"wM"xM"yM"zM"{M"|M"}M"~M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M"M#M#M#M#M###### # # # # ################### #!#"###$#%#&#'#(#)#*#+#,#-#.#/#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%vp%wp%xp%yp%zp%{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%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%&&&&&&&&&& & & & & &&&&&&&&&&&&&&&&&&& &!&"&#&$&%&&&'&(&)&*&+&,&-&.&/&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/{/|/}/~/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////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~0000000000000000000000000000000000000000000 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1  1  1  1  1  1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1  1! 1" 1# 1$ 1% 1& 1' 1( 1) 1* 1+ 1, 1- 1. 1/ 10 11 12 13 14 15 16 17 18 19 1: 1; 1< 1= 1> 1? 1@ 1A 1B 1C 1D 1E 1F 1G1H1I1J1K1L1M1N1O1P1Q1R1S1T1U1V 1W 1X 1Y 1Z 1[1\1]1^1_1`1a1b1c1d1e1f1g1h1i1j1k 1l 1m 1n 1o 1p 1q 1r 1s 1t 1u 1v 1w 1x 1y 1z 1{ 1| 1} 1~ 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 11111111111111111111111111111111111111111111111111111111111111111 1 1 1 1 2 2 2 2 2 2 2 2 2 2  2  2  2  2  2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2  2! 2" 2# 2$ 2% 2& 2' 2( 2) 2* 2+ 2,2-2.2/202122232425262728292:2;2<2=2>2?2@2A2B2C2D2E2F2G2H2I2J2K2L2M2N2O2P2Q2R2S2T2U2V2W2X2Y2Z2[2\2]2^2_2`2a2b2c2d2e2f2g2h2i2j2k2l2m2n2o2p2q2r2s2t2u2v2w2x2y2z2{2|2}2~2222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222223333333333 3 3 3 3 3333333333333333333 3!3"3#3$3%3&3'3(3)3*3+3,3-3.3/303132333435363738393:3;3<3=3>3?3@3A3B3C3D3E3F3G3H3I3J3K3L3M3N3O3P3Q3R3S3T3U3V3W3X3Y3Z3[3\3]3^3_3`3a3b3c3d3e3f3g3h3i3j3k3l3m3n3o3p3q3r3s3t3u3v3w3x3y3z3{3|3}3~3333333 3 3!3!3!3!3"3#3#33333$3$3$3$3$3$3%3&3'3(3(3)3)3*3*3*33333333333333333+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+33333333333333333333333333333333333333333333333333333,3,3,3,4,4,4-4-4-4-4-4-4-4 -4 -4 -4 -4 -4-4-4-4-4-4-4-4-4-4-4-4-4-4-4-4-4-4-4 -4!-4"-4#-4$-4%-4&-4'-4(-4)-4*-4+-4,-4--4.-4/-40-41-42-43-44-45-46-47-48-49-4:-4;-4<-4=-4>-4?-4@-4A-4B-4C-4D-4E-4F-4G-4H-4I-4J-4K-4L-4M-4N-4O-4P-4Q-4R-4S-4T-4U-4V.4W.4X.4Y.4Z.4[.4\.4].4^.4_.4`.4a.4b.4c.4d.4e.4f.4g.4h.4i.4j.4k.4l.4m.4n4o4p4q4r4s4t4u4v4w4x4y4z4{4|4}4~4444444444/4/4/4/4/4444444444444444444444444444444444444040444444444444444444444444444444444444141424242424242424242424242424242424242424242424242424242424242424242424242424242425252525252525252525 25 25 25 25 25252535454545454545454545455555555555 55!55"55#55$55%55&55'55(55)55*55+55,55-55.55/55055155255355455555655755855955:55;55<55=55>55?55@55A55B55C55D55E55F55G55H55I55J55K55L55M55N55O55P55Q55R55S55T55U5V5W5X5Y5Z5[5\5]5^5_5`5a5b5c5d5e5f5g5h5i5j5k5l5m5n5o5p5q5r5s5t5u5v5w5x5y5z5{5|5}5~55555555555565656565656565656565656565656565656565656565656565656575757575757575757585858585858585858585858585858585858585959595959595959595959595959595959595959595959595:5:5:5:5:5:5:5:5:5:5:5:5:5:5:5:5:5:5:5:5:5:5:5:5:5:5:5:5:5:5:5:5:5:5:5:5:5:5:6:6:6:6:6:6:6:6:6:6 :6 :6 ;6 <6 <6<6<6<6<6<6<6<6<6<6<6<6<6<6<6<6<6<6<6 <6!<6"<6#<6$<6%<6&<6'=6(=6)=6*=6+=6,=6-=6.=6/=60=61>62>63>64>65>66_67_68_69_6:_6;_6<_6=_6>_6?_6@_6A_6B_6C_6D_6E_6F_6G_6H_6I_6J_6K_6L?6M?6N?6O?6P?6Q?6R?6S?6T@6U@6V@6W@6X@6Y@6Z@6[@6\@6]@6^@6_@6`@6a@6b@6c@6d@6e@6f@6g@6h@6i@6j@6k@6l@6m@6n@6o@6p@6q@6r@6s@6t@6u@6v@6w@6x@6y@6z@6{@6|@6}@6~@6@6@6@6A6B6B6B6B6C6C6C6C6C6C6C6C6C6C6C6C6C6C6C6C6C6C6C6C6C6C6C6C6C6C6C6C6C6C6D6D6D6D6D6D6D6'6'6'6'6'6'6'6'6'6'6'6'6'6'6'6'6'6'6'6'6'6'6'6'6'6'6'6'6'6'6'6'6'6'6'6'6'6'6'6'6'6'6'6'6'6'6'6'6'6'6'6'6'6'6'6'6E6E6E6E6E6E6E6E6E6E6E6E6E6E6E6E6E6E6E6E6E6E6E6E6E6E6E6E7E7E7E7E7E7E7E7E7E7 E7 E7 E7 E7 E7E7E7`7`7`7`7`7`7`7`7`7`H None"#$,14568=>?@ACEPSX_`dAgdaIn fF and GHM we want to know whether we are allowed to insert unicode characters or not.defgdefgSafe"#$,14568=>?@ACEPSX_`AgdaBuiltins 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.hijklmnopqrstuvwxyz{|}~     hijklmnopqsturvwxyz{|}~     Safe"#$,14568=>?@ACEPSX_`zAgdaICut off structural order comparison at some depth in termination checker?Agdac >= 0( means: record decrease up to including c+1.Safe"#$,14568=>?@ACEPSX_`"Agda Semirings.$Agda Addition.%AgdaMultiplication.&AgdaWZero. The one is never used in matrix multiplication , one :: a -- ^ One.'AgdaHasZero 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.+AgdaThe standard semiring on 7s.,AgdaThe standard semiring on 7s.-AgdaThe standard semiring on 7s. "#&%$'()*+ '("#&%$)*+Safe"#$,14568=>?@ACEPSX_`/AgdaA constant term.0Agda,A term with one hole and the (old) contents.1Agda%A term with many holes (error value)..10/.10/Safe"#$,14568=>?@ACEPSX_`4AgdaGuard: return the action f only if the boolean is True5AgdaGuard: return the value a only if the boolean is True4545Safe"#$,14568=>?@ACEPSX_` 6AgdaFinite bijective map from a to b. There, and back again.:AgdaLookup. O(log n).;AgdaInverse lookup. O(log n).<AgdaEmpty bimap. O(1).=AgdaSingleton bimap. O(1).>Agda=Insert. Overwrites existing value if present. O(Map.insert).?Agda Left-biased Union. O(Map.union).@AgdaConstruct from a list of pairs.KDoes not check for actual bijectivity of constructed finite map. O(n log n)AAgdaATurn into list, sorted ascendingly by first value. O(Map.toList) 6798:;<=>?@A 6798:;<=>?@ASafe"#$,14568=>?@ACEPSX_`]EE Safe"#$,14568=>?@ACEPSX_`HAgdaaError class for backward compatibility (from Control.Monad.Trans.Error in transformers 0.3.0.0).KAgdaAWe cannot define data constructors synonymous, so we define the  mkExceptT6 function to be used instead of the data constructor ExceptT.LAgda#A string can be thrown as an error. '%&()*HIJK HIJ(*K'%&)None"#$,14568=>?@ACEMPSX_`%MNOPMNOPSafe"#$,14568=>?@ACEPSX_`UAgdaRepeat 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)).VAgdaRepeat 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).WAgdaMonadic version of V.XAgda%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.YAgdaMonadic version of X.ZAgdaUMore general trampoline, which allows some final computation from iteration state a into result type b.[AgdaMonadic version of Z.\AgdaIteration 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.]AgdaMonadic version of \.^Agda^ n f x applies f to x n times and returns the result.)The applications are calculated strictly._AgdaapplyWhen b f a applies f to a when b.`AgdaapplyUnless b f a applies f to a unless b.aAgdaMonadic version of  applyWhenbAgdaMonadic version of  applyUnlessUVWXYZ[\]^_`abUVWXYZ[\]^_`abNone"#$,14568=>?@ACEPSX_`cAgdaSemiring with idempotent 7 == dioiddAgdaE.g. +eAgdaneutral element of compose , e.g. zerocedfghijlkmnopmnopjlkhifgcedSafe"#$,14568=>?@ACEPSX_`/ rAgda?A decoration is a functor that is traversable into any functor.The 7S superclass is given because of the limitations of the Haskell class system.  traverseF actually implies functoriality.Minimal complete definition:  traverseF or  distributeF.sAgda traverseF is the defining property.tAgda%Decorations commute into any functor.uAgda?Composition: pure function after functorial (monadic) function.vAgdaThe true pure for loop. IJ is a misnomer, it should be forA.wAgdaInfix version of v.xAgda#Any decoration is traversable with traverse = traverseF. Just like any 76 is a functor, so is any decoration, given by just  traverseF , a functor.yAgdaAny decoration is a lens. set is a special case of dmap.zAgda0A typical decoration is pairing with some stuff.{Agda3Decorations compose. (Thus, they form a category.)|Agda%The identity functor is a decoration. rstuvwxy uvrstxywu9 w1Safe"#$,14568=>?@ACEPSX_`1xAgda7Unstructured pragma (Andreas, 2017-08-23, issue #2712).Y}~Y}~Safe"#$,14568=>?@ACEPSX_`6AgdaCatch 7 s.Agda+Upon exception, the written output is lost.Agda Alias of 7! for the IO monad.Safe"#$,14568=>?@ACEPSX_`8AgdaAReturns a close function for the file together with the contents.Safe"#$,14568=>?@ACEPSX_`D;7"Agda=Action to be carried out for copying a directory recursively.7#AgdaCreate directory if missing.7$AgdaCopy file if changed.AgdacopyDirContent src dest recursively copies directory src onto dest.WFirst, a to-do list of copy actions is created. Then, the to-do list is carried out.MThis avoids copying files we have just created again, which can happen if src and dest( are not disjoint. (See issue #2705.)7%AgdaPerform scheduled 7".7&AgdacopyDirContentDryRun src dest; creates a to-do list for recursively copying directory src onto dest.7'AgdacopyIfChanged src dst makes sure that dst' exists and has the same content as dst.Safe"#$,14568=>?@ACEPSX_`M 7(AgdaaConverts many character sequences which may be interpreted as line or paragraph separators into '\n'. Note that '\r\n'. is assumed to have already been converted to '\n'.AgdaReads a UTF8-encoded text file and converts many character sequences which may be interpreted as line or paragraph separators into '\n'.AgdaQWrites a UTF8-encoded text file. The native convention for line endings is used.AgdaQWrites a UTF8-encoded text file. The native convention for line endings is used.Safe"#$,14568=>?@ACEPSX_`O=AgdaECreates a temporary file, writes some stuff, and returns the filepathSafe"#$,14568=>?@ACEPSX_`QAgdaRead 7)+, modify it strictly, and return old value. 7*7+7,7-7.7/7071727)Safe"#$,14568=>?@ACEPSX_`eAgda@Monads in which we can catch an "impossible" error, if possible.Agda Catch any  exception.Agda Catch only # exceptions selected by the filter.Agda Version of , with argument order suiting short handlers.Agda Version of , with argument order suiting short handlers.Agdaz"Impossible" errors, annotated with a file name and a line number corresponding to the source code location of the error.Agda7We reached a program point which should be unreachable.Agda Impossible with a different error message. Used when we reach a program point which can in principle be reached, but not for a certain run.Agda`We reached a program point without all the required primitives or BUILTIN to proceed forward. (ImpMissingDefinitions neededDefs forThisAgdaaAbort by throwing an "impossible" error. You should not use this function directly. Instead use  IMPOSSIBLEAgda8Create something with a callstack's file and line numberAgda:Create something with the call site's file and line numberAgda Throw an  Impossible* error reporting the *caller's* call site.Agda Throw an  Unreachable error reporting the *caller's* call site. Note that this call to "withFileAndLine" will be filtered out due its filter on the srcLocModule. Safe"#$,124568=>?@ACEPSX_`kAgdatoImpossible e extracts the  Impossible value raised via  IMPOSSIBLE to create the element e of type Empty. It proceeds by evaluating e^ to weak head normal form and catching the exception. We are forced to wrap things in a Maybe because of catchImpossible's type.!Safe"#$,14568=>?@ACEPSX_`yE AgdaYA set with duplicates. Faithfully stores elements which are equal with regard to (==).Agda%The list contains all occurrences of aN (not just the duplicates!). Hence, the invariant: the list is never empty.AgdaIs the bag empty?Agda7Number of elements in the bag. Duplicates count. O(n).Agda (bag ! a) finds all elements equal to a(. O(log n). Total function, returns [] if none are.Agda O(log n).Agda O(log n).AgdaCReturn the multiplicity of the given element. O(log n + count _ _).AgdaO(1)AgdaO(1)Agda "insert a b = union b (singleton a)Agda !fromList = unions . map singletonAgda:Returns the elements of the bag, grouped by equality (==).Agda!Returns the bag, with duplicates.Agda#Returns the bag without duplicates.Agda!Returns the bag, with duplicates.  !"  !""Safe"#$,14568=>?@ACEPSX_`z))#None"#$,14568=>?@ACEMPSX_`9]AgdaAgsy'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)._Agda~Maybe an instantiation (refinement). It is usually shallow, i.e., just one construct(or) with arguments again being metas.`AgdaRDoes this meta block a principal constraint (i.e., a type-checking constraint).aAgda:List of observers, i.e., constraints blocked by this meta.bAgda4Used for experiments with independence of subproofs.cAgda Experimental.hAgdaResult of type-checking.iAgdaSuccess.jAgdaDefinite failure.kAgda Experimental.lAgda$Parallel conjunction of constraints.mAgdaExperimental, related to b. First arg is sidecondition.nAgdalForking proof on something that is not part of the term language. E.g. whether a term will reduce or not.oAgda Obsolete.q*,+-./1025436987:;<=>?@ABDCEFGHIJKLMNPOQRVUTSWX\[ZY]^cba`_defghonmlkijpqrstuvwxyz{|}~qtuvrspqhonmlkijfged]^cba`_wxyWX\[ZYQRVUTSz{NPOLMK|}~HIJEFGABDC?@>;<=:69872543/10.-*,+$Safe"#$,14568=>?@ACEPSX_`; AgdaRRepresents a set of integers. Invariants: - All cannot be the argument to 73 or 74 - at most one  IntsBelow - at most one  IntsAbove - if `Below lo` and `Below hi`, then `lo < hi` - if `Below lo .. (Some xs)` then `all (> lo) xs` - if `Above hi .. (Some xs)` then `all (< hi - 1) xs`Agda MembershipAgdaAll integers `< n`AgdaAll integers `>= n`AgdaA single integer.75AgdaFrom a list of integers.Agda No integers.Agda All integers.Agda'If finite, return the list of elements.Agda Invariant.  %Safe"#$,14568=>?@ACEPSX_`j AgdaGVan Laarhoven style homogeneous lenses. Mnemoic: "Lens inner outer".AgdaGet inner part i of structure o as designated by  Lens' i o.AgdaSet inner part i of structure o as designated by  Lens' i o.AgdaModify inner part i of structure o using a function i -> i.Agda8Focus on a part of the state for a stateful computation.AgdaRead a part of the state.AgdaWrite a part of the state.AgdaModify a part of the state.Agda'Modify a part of the state monadically.Agda?Modify a part of the state monadically, and return some result.Agda#Modify a part of the state locally.Agda Ask for part of read-only state.Agda/Modify a part of the state in a subcomputation.ww84444&Safe"#$&',-.14568=>?@ACEHPSUVX_` Agda An index into a type-level list.Agda4Lists indexed by a type-level list. A value of type All p [x ..x ]% is a sequence of values of types p x , .., p x .Agda&Existential wrapper for indexed types.AgdaUnpacking a wrapped value.Agda/Constructing an indexed list from a plain list.Agda/Turning an indexed list back into a plain list.Agda!Indices are just natural numbers.AgdaMapping over an indexed list.Agda>If you have an index you can get a lens for the given element.Agda)Looking up an element in an indexed list.Agda!All indices into an indexed list.'Safe"#$,14568=>?@ACEPSX_`-Agda Content of a  .agda-lib file.Agda!The symbolic name of the library.Agda Path to this  .agda-lib file (not content of the file).Agda3Roots where to look for the modules of the library.Agda Dependencies.AgdaA symbolic library name.AgdaThe special name "."S is used to indicated that the current directory should count as a project root.AgdaLenses for AgdaLibFile  (Safe"#$,14568=>?@ACEPSX_`AgdaTokenising the input (makes   cleaner)Agda*Options for Auto, default value and lenses$    $    )Safe"#$,14568=>?@ACEPSX_`0AgdaC(View source:) This is how you implement a lens for a record field.*Safe"#$,14568=>?@ACEPSX_`AgdaFilter a map based on the keys.Agda>O(n log n). Rebuilds the map from scratch. Not worse than 76.+Safe"#$,14568=>?@ACEPSX_`AgdaRetain object when tag is 77.Agda unionWith for collections of size <= 1.Agda unionsWith for collections of size <= 1.Agda Unzipping a list of length <= 1.AgdaFiltering a singleton list. filterMaybe p a = 78 (79 p [a])Agda Version of 7:" with different argument ordering.Agda Version of 7;B with different argument ordering. Often, we want to case on a 7<%, do something interesting in the 7=( case, but only a default action in the 7>* case. Then, the argument ordering of  caseMaybe is preferable. $caseMaybe m d f = flip (maybe d) m fAgda with flipped branches.AgdaMonadic version of 7;.AgdaMonadic version of 7?. AgdaMonadic version of . That is, $ with a different argument ordering.!Agda  with flipped branches."AgdaA more telling name for KL for the 7< collection type. Or:  without the 7> case.#Agda without the 7= case.$Agda  without the 7> case.%Agda  without the 7= case.&AgdaLazy version of allJust  . sequence. (allJust = mapM for the Maybe/ monad.) Only executes monadic effect while isJust.7<7>7=7:7@787A7?7B7C7D7; !"#$%& !"#$%&,Safe"#$,14568=>?@ACEPSX_`ۢ'Agda.Lazy monadic computation of a list of results.*AgdaBoilerplate function to lift 7E through the ' transformer.+AgdaThe empty lazy list.,AgdaConsing a value to a lazy list.-AgdaSingleton lazy list..Agda Case distinction over lazy list./Agda+Folding a lazy list, effects left-to-right.0Agda8Force all values in the lazy list, effects left-to-right1AgdaThe join operation of the ListT m monad.2AgdaWe can `run' a computation of a ' as it is monadic itself.3Agda Monadic cons.4AgdaMonadic singleton.5Agda Extending a monadic function to '.6Agda!Alternative implementation using /.7Agda Change from one monad to another'()*+,-./01234567'()*+,-./01234567-Safe"#$,14568=>?@ACEPSX_`ODAgdaThe  WarningNamee data enumeration is meant to have a one-to-one correspondance to existing warnings in the codebase.AgdaA  WarningMode has two components: a set of warnings to be displayed and a flag stating whether warnings should be turned into fatal errors.AgdaThe defaultWarningModeY is a curated set of warnings covering non-fatal errors and disabling style-related onesAgdawarningModeUpdate str computes the action of str over the current  WarningModeu: it may reset the set of warnings, add or remove a specific flag or demand that any warning be turned into an errorAgdaCommon sets of warningsAgdalThe flag corresponding to a warning is precisely the name of the constructor minus the trailing underscore.Agda warningUsage generated using warningNameDescription7FAgda WarningNameZ descriptions used for generating usage information Leave String empty to skip that name._DgkVWtE[|}~yz{xw^h]FGHIJKLMNOPQRSTUXYZ\_`abcdefijlmnopqrsuv_DgkVWtE[|}~yz{xw^h]FGHIJKLMNOPQRSTUXYZ\_`abcdefijlmnopqrsuv.Safe"#$,14568=>?@ACEPSX_`7GAgdaZList of Help Topics NOTA BENE: You need to add each new topic together with its name to  allHelpTopicsAgdaInterface to the help functionAgdaGeneral usage informationAgda)Specialised usage information about TOPICAgdaUsage information generationAgdaConversion functions to strings/None"#$,14568=>?@ACEPSX_`Agda"Simple, non-reentrant memoisation.AgdaRRecursive memoisation, second argument is the value you get on recursive calls.0None"#$,14568=>?@ACEMPSX_`Agda/Maximum of on-negative (small) natural numbers.1Safe"#$,14568=>?@ACEPSX_`qAgda Satisfying null empty == True.AgdaA 7< is ' when it corresponds to the empty list.  2Safe"#$,1245678=>?@ACEPSX_`Agda Analogous to MN in  Data.Maybe.Agda Analogous to MO in  Data.Maybe.Agda Analogous to MP in  Data.Maybe.Agda Analogous to MQ in  Data.Maybe.Agda unionWith for collections of size <= 1.Agda Unzipping a list of length <= 1.AgdaFiltering a singleton list. filterMaybe p a =  (79 p [a])Agda Version of " with different argument ordering.Agda 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 fAgdaMonadic version of .AgdaMonadic version of .AgdaMonadic version of . That is, $ with a different argument ordering.Agda with flipped branches.AgdaA more telling name for KR for the  collection type. Or:  without the  case.Agda without the  case.AgdaNote that strict Maybe is an 7HO only modulo strictness. The laws only hold in the strict semantics. Eg. pure f  * pure _|_ = _|_#, but according to the laws for 7H it should be  pure (f _|_)3. We ignore this issue here, it applies also to 7I and 7.3Safe"#$,14568=>?@ACEPSX_`-AgdaInclusion comparison wrapper.AgdaPointwise comparison wrapper.AgdaDecidable partial orderings. Agda6The result of comparing two things (of the same type). Agda Less than. AgdaLess or equal than. AgdaEqualAgdaGreater or equal.Agda Greater than.AgdaNo information (incomparable).Agda8Comparing the information content of two elements of  '. More precise information is smaller.Includes equality: x  x == True.Agda Opposites.related a po b iff related b (oppPO po) a.AgdarCombining 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.AgdaChains (transitivity)  x R y S z.seqPO1 is associative, commutative, and idempotent. seqPO has dominant element POAny and neutral element (unit) POEQ.AgdaEmbed 7J.Agda%Represent a non-empty disjunction of 7Js as  .AgdaA  ! information is a disjunction of 7J informations.AgdaAny 7K is a .Agda+Are two elements related in a specific way? related a o b holds iff comparable a b is contained in o.Agda1Partial ordering forms a monoid under sequencing.Agda.Less is ``less general'' (i.e., more precise).Agda&Pointwise partial ordering for tuples.related (x1,x2) o (y1,y2) iff related x1 o x2 and related y1 o y2.Agda$Partial ordering for disjoint sums: Left _ and Right _ are unrelated.Agda7> and 7= _ are unrelated.Partial ordering for Maybe a is the same as for  Either () a.#Agda4The pointwise ordering for lists of the same length.qThere are other partial orderings for lists, e.g., prefix, sublist, subset, lexicographic, simultaneous order.$Agda(Sets are partially ordered by inclusion.%AgdaSublist for ordered lists.          4Safe"#$,14568=>?@ACEPSX_`91Agda?Completing POMonoids with inverses to form a Galois connection.BLaw: composition and inverse composition form a Galois connection. & related (inverseCompose p x) POLE y  == related x POLE (p <> y) 3AgdaPartially ordered monoid."Law: composition must be monotone. P related x POLE x' && related y POLE y' ==> related (x <> y) POLE (x' <> y') 4AgdaPartially ordered semigroup."Law: composition must be monotone. P related x POLE x' && related y POLE y' ==> related (x <> y) POLE (x' <> y') 5AgdahasLeftAdjoint x checks whether  x^-1 := x 2 mempty is such that x 2 y == x^-1 <> y for any y.12345431255None"#$,124568=>?@ACEPSX_`=N;AgdaIf 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).6789:;678:9;6Safe"#$,14568=>?@ACEPSX_`@FAgdaStar semirings ( 5https://en.wikipedia.org/wiki/Semiring#Star_semirings).HAgda Semirings ( &https://en.wikipedia.org/wiki/Semiring).FGHLKJIHLKJIFG7Safe"#$,14568=>?@ACEPSX_`AQRQR8None"#$,14568=>?@ACEPSX_`J_AgdaCharacteristic identifiers.`AgdaGiven a function f :: a -> NonEmpty C6 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.aAgdaPartition a list of a5s 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._`a_`a9Safe"#$,14568=>?@ACEPSX_`O[bAgda^Thing decorated with its size. The thing should fit into main memory, thus, the size is an Int.fAgda,The size of a collection (i.e., its length).hAgdaCache the size of an object.rAgdaReturn the cached size.bcdefghfgbcdehSafe"#$,14568=>?@ACEPSX_`\ sAgdaWhile 7L- is for rendering data in Haskell syntax, sL is for displaying data to the world, i.e., the user and the environment.BAtomic data has no inner document structure, so just implement t as pretty a = text $ ... a ....wAgdaUse instead of 7M when printing to world.zAgda+Comma separated list, without the brackets.{AgdaApply = to V if boolean is true.|Agdaalign 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.}Agda?Handles strings with newlines properly (preserving indentation)~Agda a  ? b = hang a 2 bAgda pshow = text . prettyAgdaUsed for with-like  telescopesI+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWYX^]\[Zcba`_stuvwxyz{|}~Istuvwxyz{|}~+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWYX^]\[Zcba`_~6:Safe"#$,14568=>?@ACEPSX_`v7NAgdamThe extended parser type computes one top-level document, plus one document per encountered memoisation key.7>u is used to mark that a given memoisation key has been seen, but that no corresponding document has yet been stored.Agda(Documents paired with precedence levels.Agda@An extended parser type, with some support for printing parsers.7OAgdaInvariant: If the boolean is 77, then the result must be 7P something, and if the boolean is 7Q, then the result must be 7R something.AgdaRuns the parser.Agda&Tries to print the parser, or returns 7SF, depending on the implementation. This function might not terminate.AgdaOParses a token satisfying the given predicate. The computed value is returned.Agda[Uses the given function to modify the printed representation (if any) of the given parser.AgdaMemoises the given parser./Every memoised parser must be annotated with a uniqueJ key. (Parametrised parsers must use distinct keys for distinct inputs.)AgdaAMemoises the given parser, but only if printing, not if parsing./Every memoised parser must be annotated with a uniqueJ key. (Parametrised parsers must use distinct keys for distinct inputs.)AgdaThe 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.7TAgdaMemoised values.7UAgdaContinuations.7VAgdaState monad used by the parser.7WAgda Positions.AgdauUses the given document as the printed representation of the given parser. The document's precedence is taken to be .Agda.Parses a token satisfying the given predicate.AgdaParses a single token.AgdaParses a given token.AgdaPrecedence of >>=.AgdaPrecedence of  |.AgdaPrecedence of  *.AgdaPrecedence of " and +.AgdaPrecedence of atoms.7XAgdaA smart constructor.7YAgdaExtracts the parser.7ZAgdaExtracts the documents.7[AgdaA helper function.7\Agda Pretty-prints a memoisation key.7]AgdaA helper function.;None"#$,124568=>?@ACEMPSX_`Agda%Paths which are known to be absolute.Note that the 7^ and 7KS instances do not check if different paths point to the same files or directories.Agda Extract the  to be used as 7_.Agda Constructs s.2Precondition: The path must be absolute and valid.AgdaMakes the path absolute.This function may raise an __IMPOSSIBLE__ error if 7`" does not return an absolute path.AgdaPTries to establish if the two file paths point to the same file (or directory).AgdaCase-sensitive 7a 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 insensitively.)4<None"#$,14568=>?@ACEPSX_``AgdaHashes a piece of 7b.Agda-Hashing a module name for unique identifiers.=None"#$,14568=>?@ACEMPSX_`=Agda4The flexibe variables contained in a pice of syntax.Agda2The rigid variables contained in a pice of syntax.Agda)Make offsets non-negative by rounding up.AgdaOffsets + n must be non-negativeAgdaExecuting a substitution.Agda@Partial substitution from flexible variables to size expression.Agda*Type of solution wanted for each flexible.Agda,Assigning a polarity to a flexible variable.Agda)What type of solution are we looking for?Agda<Constraint: an inequation between size expressions, e.g. X < " or  i + 3 "d j.Agda.Comparison operator, e.g. for size expression.Agda<.Agda"d.Agda*Size expressions appearing in constraints.AgdaConstant number n.AgdaVariable plus offset i + n.Agda Infinity ".AgdaMeta variable X + n.AgdaSize meta variables X to solve for.AgdaFixed size variables i.AgdaConstant finite sizes n >= 0.AgdaDefault polarity is .Agda?Returns an error message if we have a contradictory constraint.Agda acts as 77,  as 7Q.Agda Interpret  as relation on .AgdaAdd offset to size expression.AgdaComparison operator is ordered  < .55None"#$,124568=>?@ACEMPSX_`Y7cAgdaLet n be the size of type a.0Agda Time O(n)!1Agda Time O(1).2Agdanot . member a . Time O(1).3Agda Time O(n).4AgdaThe empty set. Time O(n).5AgdaThe full set. Time O(n).6AgdaA singleton set. Time O(n).7Agda Time O(n).8Agda Time O(n).9Agda Time O(n).:Agda Time O(n).;Agda Time O(n).<Agda Time O(n).=Agda Time O(n).>Agda Time O(n).?Agda Time O(n).@Agda Time O(n).AAgda Time O(n).BAgda Time O(n).CAgda Time O(n).DAgda Time O(n).EAgda Time O(n).7dAgdaTime O(n). Assumes Bool-vector of length n.7eAgdaTime O(n). Produces Bool-vector of length n.7fAgdaTime O(n). Produces Bool-vector of length n.7gAgdaTime O(n). Bulk insert/delete./0123456789:;<=>?@ABCDE/;98:@4CDE7<3>1206AB5=?>None"#$,14568=>?@ACEPSX_`4 JAgda&Classification of identifier variants.LAgdaIdentifier ends in Int many primes.MAgdaIdentifier ends in number Int (ordinary digits).NAgdaIdentifier ends in number Int (subscript digits).OAgda3Are we allowed to use unicode supscript characters?PAgda'Is the character one of the subscripts ' '-' '?QAgda Converts '0'-'9' to ' '-' '-Precondition: The digit needs to be in range.RAgda Converts ' '-' ' to '0'-'9'.-Precondition: The digit needs to be in range.SAgda?Increase the suffix by one. If no suffix yet, put a subscript 13 unless users do not want us to use any unicode.TAgda Parse suffix.UAgda Print suffix. JNLKMOPQRSTU OPQRJNLKMSTU?Safe"#$,14568=>?@ACEPSX_`VAgdaDisjoint sum of three.ZAgdaEnum type with 3 elements.^AgdaPartition a list into 3 groups.)Preserves the relative order or elements._AgdaPartition a list into 3 groups.)Preserves the relative order or elements. VYXWZ]\[^_`a Z]\[^VYXW_`a@Safe"#$,14568=>?@ACEPSX_`jAgdaFinite map from [k] to v.With the strict 7< type, j is also strict in v.7hAgda"Helper function used to implement l and m.lAgdaSingleton trie.mAgdaeveryPrefix k v! is a trie where every prefix of k (including k itself) is mapped to v.nAgdaLeft biased union.#union = unionWith ( new old -> new).oAgda/Pointwise union with merge function for values.pAgda.Insert. Overwrites existing value if present. %insert = insertWith ( new old -> new)qAgda6Insert with function merging new value with old value.rAgda.Delete value at key, but leave subtree intact.sAgda*Adjust value at key, leave subtree intact.tAgdaConvert to ascending list.uAgdaConvert to ascending list.vAgda]Convert to list where nodes at the same level are ordered according to the given ordering.wAgdaWCreate new values based on the entire subtrie. Almost, but not quite comonad extend.xAgda8Returns the value associated with the given key, if any.yAgda%Is the given key present in the trie?zAgda&Collect all values along a given path.{Agda(Get the subtrie rooted at the given key.|AgdaFilter a trie.}Agda Key lens.~Agda Empty trie.jklmnopqrstuvwxyz{|}jklmpqnosrtuvxyz{w|} None"#$,14568=>?@ACEMPSX_`GAgdaBifunctoriality for pairs.Agda mapFst f = f -*- idAgda mapSnd g = id -*- gAgdaLifted pairing.AgdaMonadic version of .AgdaMonadic .AgdaMonadic .23ANone"#$,14568=>?@ACEPSX_`4;Agda$Internal state for stripping suffix.AgdaError.Agda8"Negative string" to remove from end. List may be empty.Agda+"Positive string" (result). Non-empty list.AgdaPAppend a single element at the end. Time: O(length); use only on small lists.Agda5Case distinction for lists, with list first. O(1).Cf. 1S.Agda5Case distinction for lists, with list first. O(1).Cf. 1S.Agda4Case distinction for lists, with list last. O(1).AgdaFHead function (safe). Returns a default value on empty lists. O(1). >headWithDefault 42 [] = 42 headWithDefault 42 [1,2,3] = 1AgdaTail function (safe). O(1).AgdaFTail function (safe). Returns a default list on empty lists. O(1).AgdaLast element (safe). O(n).Agda"Last two elements (safe). O(n).AgdaOpposite of cons (:), safe. O(1).AgdaMaybe cons. O(1). "mcons ma as = maybeToList ma ++ asAgda7i and 7j in one go, safe. O(n).Agdainit, safe. O(n).Agda4Lookup function (partially safe). O(min n index).AgdaMLookup function with default value for index out of range. O(min n index).The name is chosen akin to TU.AgdaeFind an element satisfying a predicate and return it with its index. O(n) in the worst case, e.g. findWithIndex f xs = Nothing.%TODO: more efficient implementation!?AgdaA generalised variant of  elemIndex. O(n).AgdadownFrom n = [n-1,..1,0] . O(n).Agda:Update the first element of a list, if it exists. O(1).Agda9Update the last element of a list, if it exists. O(n).Agda/Update nth element of a list, if it exists. O(min index n). Precondition: the index is >= 0.Agda#splitExactlyAt n xs = Just (ys, zs) iff  xs = ys ++ zs and genericLength ys = n.Agda*Drop from the end of a list. O(length). &dropEnd n = reverse . drop n . reverseForces the whole list even for n==0.AgdaISplit off the largest suffix whose elements satisfy a predicate. O(n).spanEnd p xs = (ys, zs) where  xs = ys ++ zs and all p zs and #maybe True (not . p) (lastMaybe yz).AgdaA generalized version of  takeWhile . (Cf. mapMaybe vs. filter#). @O(length . takeWhileJust f)."takeWhileJust f = fst . spanJust f.AgdaA generalized version of span. O(length . fst . spanJust f).AgdaPartition a list into 7>s and 7= s. O(n). LpartitionMaybe f = partitionEithers . map ( a -> maybe (Left a) Right (f a))Note: 7: f = snd . partitionMaybe f.AgdaLike 79S, but additionally return the last partition of the list where the predicate is False everywhere. O(n).AgdaLike 7:^, but additionally return the last partition of the list where the function always returns Nothing . O(n).AgdaSublist relation.Agda7All ways of removing one element from a list. O(n).Agda6Compute the common prefix of two lists. O(min n m).AgdaLDrops from both lists simultaneously until one list is empty. O(min n m).AgdadCheck if a list has a given prefix. If so, return the list minus the prefix. O(length prefix).Agda4Compute the common suffix of two lists. O(n + m).AgdastripSuffix suf xs = Just pre iff xs = pre ++ suf. O(n).Agda&stripReversedSuffix rsuf xs = Just pre iff xs = pre ++ reverse suf . O(n).Agda f = groupBy ((7k ) `on` f) 7l 7m (7n `on` f). O(n log n).Agda A variant of 7o: which applies the predicate to consecutive pairs. O(n).AgdaFSplit a list into sublists. Generalisation of the prelude function words . O(n). words xs == wordsBy isSpace xsAgda2Chop up a list in chunks of a given length. O(n).AgdaFChop a list at the positions when the predicate holds. Contrary to [, consecutive separator elements will result in an empty segment in the result. O(n). *intercalate [x] (chopWhen (== x) xs) == xsAgdaeCheck membership for the same list often. Use partially applied to create membership predicate hasElem xs :: a -> Bool. First time:  O(n log n) in the worst case.Subsequently: O(log n).Specification: hasElem xs == (7p xs).Agda&Check whether a list is sorted. O(n).Assumes that the 7K% instance implements a partial order.AgdaWCheck whether all elements in a list are distinct from each other. Assumes that the 7^- instance stands for an equivalence relation.O(n) in the worst case distinct xs == True.AgdaAn optimised version of . O(n log n)./Precondition: The list's length must fit in an 7.AgdaiReturns an (arbitrary) representative for each list element that occurs more than once. O(n log n).AgdalRemove the first representative for each list element. Thus, returns all duplicate copies. O(n log n).&allDuplicates xs == sort $ xs \ nub xs.AgdaEfficient variant of nubByC for lists, using a set to store already seen elements. O(n log n)Specification: )nubOn f xs == 'nubBy' ((==) `'on'` f) xs.AgdaEfficient variant of nubBy for finite lists. O(n log n).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: cList.sortBy (compare `on` f) (uniqOn f xs) == uniqOn f xs uniqOn id == Set.toAscList . Set.fromListAgdaFChecks if all the elements in the list are equal. Assumes that the 7^6 instance stands for an equivalence relation. O(n).Agda5Requires both lists to have the same length. O(n). Otherwise, Nothing is returned.AgdaLike 7qZ but keep the rest of the second list as-is (in case the second list is longer). O(n). D zipWithKeepRest f as bs == zipWith f as bs ++ drop (length as) bs AgdaJImplemented using tree recursion, don't run me at home! O(3^(min n m)).Agda*Implemented using dynamic programming and  Data.Array . O(n*m).AgdaThe list after the split point.Agda The list before the split point.??BNone"#$,14568=>?@ACEPSX_`F AgdaI 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 7M: > 7r $ 7M "\x2200" "\8704" > 7r $  "\x2200" """ V(The code examples above have been tested using version 4.2.0.0 of the base library.)AgdaGTurns the string into a Haskell string literal, avoiding escape codes.Agda$Adds hyphens around the given stringputStrLn $ delimiter "Title"<     Title                                                 AgdaShows a non-negative integer using the characters - instead of 0-9 unless the user explicitly asked us to not use any unicode characters.Agda1Adds a final newline if there is not already one.Agda-Indents every line the given number of steps.Agda6Show a number using comma to separate powers of 1,000.AgdaRemove leading whitespace.AgdaRemove trailing whitespace.Agda'Remove leading and trailing whitesapce.  CNone"#$,14568=>?@ACEMPSX_`JAgda"CPU time in pico (10^-12) seconds.Agda Timestamps.AgdaThe current time.AgdaOMeasure the time of a computation. Of course, does not work with exceptions.Agda(Print CPU time in milli (10^-3) seconds.DNone"#$,14568=>?@ACEPSX_`Vr AgdaSimple Emacs Lisp expressions.AgdaAtom.AgdaList.AgdaFormats a response command. Replaces '\n'= with spaces to ensure that each command is a single line.Agda-Writes a response command to standard output.7sAgda0displayInBuffer buffername append header content displays content (with header header%) in some suitable way in the buffer  buffername. If append is Trueh, then the content is appended to previous content (if any), otherwise any previous content is deleted.7tAgda$The name of the running info buffer.AgdaClear the running info buffer.AgdaClear the warning bufferAgdaADisplay running information about what the type-checker is up to.  ENone"#$,14568=>?@ACEPSX_`XAgdaRemove suffix .0$ from printed floating point number.None"#$,14568=>?@ACEPSX_`g Agda Loop while we have an exception. AgdaMonadic version of 7u$ with a different argument ordering. Agda'Either _ b' is a functor. Agda'Either a' is a functor. Agda7v is bitraversable. Note: From base >= 4.10.0.0 already present in VW.Agda Analogue of XY.Agda Analogue of XY.Agda Analogue of +Z.Agda Analogue of +Z.AgdaSafe projection from 7P. 8maybeLeft (Left a) = Just a maybeLeft Right{} = NothingAgdaSafe projection from 7R. <maybeRight (Right b) = Just b maybeRight Left{} = NothingAgdaReturns 7= input_with_tags_stripped if all elements are to the 7P, and otherwise 7>.AgdaReturns 7= input_with_tags_stripped2 if all elements are to the right, and otherwise 7>. d allRight xs == if all isRight xs then Just (map ((Right x) -> x) xs) else Nothing Agda)Groups a list into alternating chunks of 7P and 7R valuesAgdaConvert 7< to 7v ().            None"#$,14568=>?@ACEPSX_``Agda Binary bind.AgdaMonadic guard.AgdaMonadic if-then-else.Agda ifNotM mc = ifM (not  $ mc)AgdaLazy monadic conjunction.!AgdaLazy monadic disjunction.$AgdaLazy monadic disjunction with Either> truth values. Returns the last error message if all fail.%AgdahLazy monadic disjunction with accumulation of errors in a monoid. Errors are discarded if we succeed.&AgdaGeneralized version of 8traverse_ :: Applicative 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.'AgdaGeneralized version of 3for_ :: Applicative m => [a] -> (a -> m ()) -> m (),AgdaA monadic version of 7: :: (a -> Maybe b) -> [a] -> [b].-Agda A version of ,' with a computation for the input list..AgdaThe for version of ,./AgdaThe for version of -.0AgdaA monadic version of 7w :: (a -> Bool) -> [a] -> [a].1AgdaA monadic version of  dropWhileEnd :: (a -> Bool) -> [a] -> m [a]:. Effects happen starting at the end of the list until p becomes false.2AgdaA `monadic' version of @ partition# :: (a -> Bool) -> [a] -> ([a],[a])3Agda Translates 7< to .4AgdaGeneralises the 7@& function from lists to an arbitrary .5AgdaFinally for the HF class. Errors in the finally part take precedence over prior errors.6AgdaTry a computation, return 7> if an H occurs.7Agda1Run a command, catch the exception and return it.8Agda;Bracket without failure. Typically used to preserve state.9Agda Restore state after computation.8AgdaAcquires resource. Run first.AgdaReleases resource. Run last.Agda Computes result. Run in-between.+  !"#$%&'()*+,-./0123456789:+ !"#$%&'()*+,-./0123456789: FNone"#$,14568=>?@ACEPSX_`;Agda'Monad with access to benchmarking data.@AgdaEWe need to be able to terminate benchmarking in case of an exception.AAgdaqBenchmark structure is a trie, mapping accounts (phases and subphases) to CPU time spent on their performance.CAgdaAre we benchmarking at all?DAgda!What are we billing to currently?EAgda/The accounts and their accumulated timing bill.KAgda3Record when we started billing the current account.LAgda(Account we can bill computation time to.NAgdaSemantic editor combinator.OAgdaSemantic editor combinator.PAgdaSemantic editor combinator.QAgda"Add to specified CPU time account.RAgdaTurn benchmarking on/off.SAgdacBill current account with time up to now. Switch to new account. Return old account (if any).TAgda.Resets the account and the timing information.UAgdafBill a computation to a specific account. Works even if the computation is aborted by an exception.VAgda;Bill a CPS function to an account. Can't handle exceptions.WAgda.Bill a pure computation to a specific account.XAgda2Print benchmark as three-column table with totals.YAgda$Initial benchmark structure (empty).SAgdaMaybe new account.AgdaMaybe old account.;?>=<@ABEDCFIGHJKLMNOPQRSTUVWLKJFIGHMABEDCNOPQ;?>=<@RSTUVWGNone"#$,1245678=>?@ACEMPSX_`z7]Agda=Killing the range of an object sets all range information to ._Agda;If it is also possible to set the range, this is the class.Instances should satisfy b (` r x) == r.aAgda5Things that have a range are instances of this class.cAgda1Wrapper to indicate that range should be printed.fAgdaA 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: .kAgdaAn interval. The iEnd* position is not included in the interval.4Note the invariant which intervals have to satisfy: y.rAgda Represents a point in the input.If two positions have the same t and u 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: x.tAgdaFile.uAgdaPosition, counting from 1.vAgdaLine number, counting from 1.wAgdaColumn number, counting from 1.zAgda Sets the t components of the interval.{Agda Gets the tP component of the interval. Because of the invariant, they are both the same.|Agda6Converts a file name and two positions to an interval.}AgdaThe length of an interval.~AgdaTThe intervals that make up the range. The intervals are consecutive and separated ().Agda8Turns a file name plus a list of intervals into a range.Precondition: .Agda}Are the intervals consecutive and separated, do they all point to the same file, and do they satisfy the interval invariant?AgdaRange invariant.Agda"The file the range is pointing to.Agda%Conflate a range to its right margin.Agda*Remove ranges in keys and values of a map.Agda;The first position in a file: position 1, line 1, column 1.Agda;The first position in a file: position 1, line 1, column 1.Agda$Ranges between two unknown positionsAgda?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.Agda!Advance the position by a string.  movePosByString = foldl' movePosAgda%Backup the position by one character.(Precondition: The character must not be '\n'.Agda2Converts a file name and two positions to a range.Agda"Converts two positions to a range.;Precondition: The positions have to point to the same file.Agda0Converts a file name and an interval to a range.Agda-Converts a range to an interval, if possible.AgdagConverts a range to an interval, if possible. Note that the information about the source file is lost.Agda?Returns the shortest continuous range containing the given one.Agda0Removes gaps between intervals on the same line.Agda*The initial position in the range, if any.Agda*The initial position in the range, if any.Agda;The position after the final position in the range, if any.Agda;The position after the final position in the range, if any.Agda4Finds the least interval which covers the arguments.8Precondition: The intervals must point to the same file.AgdafuseRanges 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).AgdaDPrecondition: The ranges must point to the same file (or be empty).Agda 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.AgdabeginningOfFile 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.Agdax `withRangeOf` y sets the range of x to the range of y.Agda*Interleaves two streams of ranged elements*It will report the conflicts as a list of conflicting pairs. In case of conflict, the element with the earliest start position is placed first. In case of a tie, the element with the earliest ending position is placed first. If both tie, the element from the first list is placed first.AgdaZPrecondition: The ranges of the tuple elements must point to the same file (or be empty).AgdaZPrecondition: The ranges of the tuple elements must point to the same file (or be empty).AgdaZPrecondition: The ranges of the tuple elements must point to the same file (or be empty).AgdaZPrecondition: The ranges of the tuple elements must point to the same file (or be empty).AgdaZPrecondition: The ranges of the tuple elements must point to the same file (or be empty).AgdaZPrecondition: The ranges of the tuple elements must point to the same file (or be empty).AgdaYPrecondition: The ranges of the list elements must point to the same file (or be empty).AgdaYPrecondition: The ranges of the list elements must point to the same file (or be empty).AgdaOverlaps with  KillRange [a].T\]^_`abcdefhgijklnmopqrstuvwxyz{|}~Tporstuvwqxjiklnmy|{}zefhg~cdab_`]^\HNone"#$,124568=>?@ACEPSX_`6Agda%Things that support delayed dropping.Agda)Delayed dropping which allows undropping.Agda&Non-negative number of things to drop.AgdaWhere to drop from.Agda3Invert 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.AgdaPartial 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 g of the permutation.Agda'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 n AgdaIdentity permutation. Agda"Restrict a permutation to work on n elements, discarding picks >=n. Agda9Pick the elements that are not picked by the permutation. AgdaliftP k takes a  Perm {m} n to a Perm {m+k} (n+k). Analogous to [\?, but Permutations operate on de Bruijn LEVELS, not indices. Agda 2permute (compose p1 p2) == permute p1 . permute p2Agda invertP err p is the inverse of p) where defined, otherwise defaults to err. composeP p (invertP err p) == pAgdaITurn a possible non-surjective permutation into a surjective permutation.Agda ?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.Agda8permPicks (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 ]^.Agda expandP i n  in the domain of  replace the ith element by n elements.Agda~Stable topologic sort. The first argument decides whether its first argument is an immediate parent to its second argument.AgdaPerform the dropping.Agda Drop more.AgdaPick up dropped stuff.          INone "#$,1245678=>?@ACEHMPSVX_`U(AgdaPart of a Notation)AgdaArgument is the position of the hole (with binding) where the binding should occur. First range is the rhs range and second is the binder.*Agda+Argument is where the expression should go.+Agda"An underscore in binding position.-AgdaNotation as provided by the syntax declaration.3AgdaRewriteEqn' qn p e represents the rewrite and irrefutable with clauses of the LHS. qnV stands for the QName of the auxiliary function generated to implement the feature p is the type of patterns e is the type of expressions4Agda  rewrite e5Agda  with p <- e6Agda!Coverage check? (Default is yes).9Agda!Universe check? (Default is yes).<Agda#Positivity check? (Default = True).?Agda0Termination check? (Default = TerminationCheck).@AgdaRun the termination checker.AAgda#Skip termination checking (unsafe).BAgdaTreat as non-terminating.CAgda/Treat as terminating (unsafe). Same effect as A.DAgda2Skip termination checking but use measure instead.GAgdaRename from this name.HAgda#To this one. Must be same kind as G.IAgdaNew fixity of H (optional).JAgdaCThe range of the "to" keyword. Retained for highlighting purposes.KAgda3An imported name can be a module or a defined name.LAgdaImported module name of type m.MAgdaImported name of type n.NAgdaThe using clause of import directive.OAgdaNo using clause given.PAgdausing the specified names.QAgdaYThe things you are allowed to say when you shuffle names between name spaces (i.e. in import,  namespace, or open declarations).WAgda Only for open3. Exports the opened names from the current module.\AgdagThe notation is handled as the fixity in the renamer. Hence, they are grouped together in this type.`Agda`Range of the name in the fixity declaration (used for correct highlighting, see issue #2140).aAgdaFixity of operators.cAgda&Range of the whole fixity declaration.fAgdaAssociativity.kAgdaNo fixity declared.lAgda$Fixity level declared as the number.mAgda Precedence levels for operators.qAgda@Placeholders are used to represent the underscores in a section.sAgdaYThe second argument is used only (but not always) for name parts other than underscores.tAgda4The position of a name part or underscore in a name.uAgda;The following underscore is at the beginning of the name: _foo.vAgda8The following underscore is in the middle of the name: foo_bar.wAgda4The following underscore is at the end of the name: foo_.zAgda4A meta variable identifier is just a natural number.}AgdaWThe unique identifier of a name. Second argument is the top-level module identifier.AgdaIs this a macro definition?Agda0Is this definition eligible for instance search?Agda Range of the instance keyword.Agda"Is any element of a collection an .AgdaAbstract or concrete.AgdaAccess modifier.Agda Store the p of the private block that lead to this qualifier. This is needed for more faithful printing of declarations.Agda@Functions can be defined in both infix and prefix style. See f_.Agda"Where does a projection come from?AgdaUser wrote a prefix projection.Agda User wrote a postfix projection.Agda'Projection was generated by the system.AgdaWhere does the ConP or Con come from?Agda8Inserted by system or expanded from an implicit pattern.Agda#User wrote a constructor (pattern).AgdaUser wrote a record (pattern).Agda(Generated by interactive case splitting.AgdaString with range info.AgdaA RawName is some sort of string.AgdaThing with range info.AgdaNames in binders and arguments.AgdaOnly   arguments can have names.AgdaAccessor/editor for the  component.AgdaStandard argument names.AgdaStandard naming.Agda&Something potentially carrying a name.Agda4A function argument can be hidden and/or irrelevant.AgdaA lens to access the : attribute in data structures. Minimal implementation: getFreeVariables and mapFreeVariables or  LensArgInfo.AgdaA lens to access the : attribute in data structures. Minimal implementation:  getOrigin and  mapOrigin or  LensArgInfo.AgdaDecorating something with  information.AgdaOrigin of arguments.Agda/From the source file / user input. (Preserve!)AgdaE.g. inserted hidden arguments.Agda%Produced by the reflection machinery.Agda&Produced by an interactive case split.Agda[Named application produced to represent a substitution. E.g. "?0 (x = n)" instead of "?0 n"AgdaA lens to access the : attribute in data structures. Minimal implementation:  getCohesion and  mapCohesion or  LensModality.AgdaCohesion modalities see "Brouwer's fixed-point theorem in real-cohesive homotopy type theory" (arXiv:1509.07584) types are now given an additional topological layer which the modalities interact with.Agda=same points, discrete topology, idempotent comonad, box-like.Agdaeidentity modality. | Sharp -- ^ same points, codiscrete topology, idempotent monad, diamond-like.AgdaAsingle point space, artificially added for Flat left-composition.AgdaA lens to access the : attribute in data structures. Minimal implementation:  getRelevance and  mapRelevance or  LensModality.Agda:A function argument can be relevant or irrelevant. See Agda.TypeChecking.Irrelevance.Agda4The argument is (possibly) relevant at compile-time.AgdaThe argument may never flow into evaluation position. Therefore, it is irrelevant at run-time. It is treated relevantly during equality checking.Agda3The argument is irrelevant at compile- and runtime.AgdaQuantity for linearity.mA quantity is a set of natural numbers, indicating possible semantic uses of a variable. A singleton set {n}= requires that the corresponding variable is used exactly n times.Agda Zero uses {0}, erased at runtime.Agda Linear use {1}s (could be updated destructively). Mostly TODO (needs postponable constraints between quantities to compute uses).AgdaUnrestricted use !.Agda Origin of .AgdaUser wrote nothing.AgdaUser wrote "@".AgdaUser wrote "@plenty".Agda Origin of .AgdaUser wrote nothing.AgdaUser wrote "@1".AgdaUser wrote "@linear".Agda Origin of .AgdaUser wrote nothing.AgdaUser wrote "@0".AgdaUser wrote "@erased".AgdaWe have a tuple of modalities, which might not be fully orthogonal. For instance, irrelevant stuff is also run-time irrelevant.Agda4Legacy irrelevance. See Pfenning, LiCS 2001; AbelVezzosiWinterhalter, ICFP 2017.AgdaCardinality / runtime erasure. See Conor McBride, I got plenty o' nutting, Wadlerfest 2016. See Bob Atkey, Syntax and Semantics of Quantitative Type Theory, LiCS 2018.AgdaCohesion/what was in Agda-flat. see "Brouwer's fixed-point theorem in real-cohesive homotopy type theory" (arXiv:1509.07584) Currently only the comonad is implemented.AgdaA lens to access the  : attribute in data structures. Minimal implementation:  getHiding and  mapHiding or  LensArgInfo.AgdaDecorating something with   information.Agda4Used to specify whether something should be delayed.!AgdaMonoidal composition of   information in some data."Agda  arguments are visible.#Agda  and   arguments are  notVisible.$Agda  arguments are hidden.+AgdaIgnores  .-Agdam - m' means that an m can be used where ever an m' is required./Agda(Multiplicative monoid (standard monoid).0AgdaCompose with modality flag from the left. This function is e.g. used to update the modality information on pattern variables a- after a match against something of modality q.1AgdainverseComposeModality r x returns the least modality y such that forall x, y we have .x `moreUsableModality` (r `composeModality` y) iff 5(r `inverseComposeModality` x) `moreUsableModality` y (Galois connection).2AgdaLeft division by a 3. Used e.g. to modify context when going into a m argument.3Agda# forms a pointwise additive monoid.5Agda"Absorptive element under addition.6AgdaEquality ignoring origin.DAgdaEquality ignoring origin.EAgda. forms an additive monoid with zero Quantity0.GAgdaAbsorptive element is .HAgdam moreUsableQuantity m' means that an m can be used where ever an m' is required.JAgdaCompose with quantity flag from the left. This function is e.g. used to update the quantity information on pattern variables a- after a match against something of quantity q.KAgdainverseComposeQuantity r x returns the least quantity y such that forall x, y we have (x `moreQuantity` (r `composeQuantity` y) iff /(r `inverseComposeQuantity` x) `moreQuantity` y (Galois connection).LAgdaLeft division by a 3. Used e.g. to modify context when going into a q argument.MAgda Check for .NAgda Check for .OAgda Check for .PAgda*Did the user supply a quantity annotation?QAgda9A thing of quantity 0 is unusable, all others are usable.WAgdaInformation ordering. @Relevant `moreRelevant` NonStrict `moreRelevant` IrrelevantXAgdaEquality ignoring origin.YAgdausableRelevance rel == False! iff we cannot use a variable of rel.ZAgda composition.  is dominant, + is neutral. Composition coincides with 7x.[AgdaCompose with relevance flag from the left. This function is e.g. used to update the relevance information on pattern variables a! after a match against something rel.\AgdainverseComposeRelevance 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).]AgdaLeft division by a 3. Used e.g. to modify context when going into a rel argument.^AgdaCombine inferred . The unit is ._Agda4 forms a monoid under addition, and even a semiring.`Agda"Absorptive element under addition.aAgdaKIrrelevant function arguments may appear non-strictly in the codomain type.bAgdaBApplied when working on types (unless --experimental-irrelevance).fAgdaInformation ordering. PFlat `moreCohesion` Continuous `moreCohesion` Sharp `moreCohesion` SquashgAgdaEquality ignoring origin.hAgdausableCohesion rel == False! iff we cannot use a variable of rel.iAgda composition.  is dominant,  is neutral.jAgdaCompose with cohesion flag from the left. This function is e.g. used to update the cohesion information on pattern variables a- after a match against something of cohesion rel.kAgdainverseComposeCohesion r x returns the least y such that forall x, y we have (x `moreCohesion` (r `composeCohesion` y) iff /(r `inverseComposeCohesion` x) `moreCohesion` y1 (Galois connection). The above law fails for  r = Squash.lAgdaLeft division by a 3. Used e.g. to modify context when going into a rel argument.mAgdaCombine inferred . The unit is .nAgda4 forms a monoid under addition, and even a semiring.oAgda"Absorptive element under addition.Agdaxs `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.Agda,Equality of argument names of things modulo f and .Agda,Equality of argument names of things modulo f and .AgdaDoes an argument arg fit the shape dom of the next expected argument?cThe hiding has to match, and if the argument has a name, it should match the name of the domain.7> should be , so use as @ fromMaybe  IMPOSSIBLE $ fittingNamedArg arg dom @AgdaGet the content of a .AgdaThe functor instance for 8 would be ambiguous, so we give it another name here.Agda ,setNamedArg a b = updateNamedArg (const b) aAgdaThing with no range info.Agda)Prefer user-written over system-inserted.AgdaAn abbreviation: noPlaceholder = s .AgdaDefault is directive is private% (use everything, but do not export).AgdaisDefaultImportDir implies null, but not the other way round.Agda Just for the  9 instance. Should never combine different overlapping.Agda , is an idempotent partial monoid, with unit  .   and   are incompatible.AgdahRight-biased composition, because the left quantity acts as context, and the right one as occurrence.AgdahRight-biased composition, because the left quantity acts as context, and the right one as occurrence.AgdahRight-biased composition, because the left quantity acts as context, and the right one as occurrence.AgdaNote that the order is  "d 0,1, more options is smaller.AgdaZIn the absense of finite quantities besides 0,  is the unit. Otherwise, 1 is the unit.Agda+Composition of quantities (multiplication). is dominant.  is neutral.Right-biased for origin.Agda is the unit.Agda% forms a semigroup under composition.AgdaMore relevant is smaller.AgdaMore relevant is smaller.Agda Continous is the unit.Agda% forms a semigroup under composition.AgdaFlatter is smaller.Agda2Order is given by implication: flatter is smaller.AgdaDominance ordering.AgdaPointwise unit.AgdaPointwise composition. 6AgdaRanges are not forced. DAgda Default is . EAgda+Semigroup computes if any of several is an . VAgda(Show non-record version of this newtype. nAgdaRanges are not forced. qAgdaRanges are not forced. tAgdanullg for import directives holds when everything is imported unchanged (no names are hidden or renamed).(,+*)-.0/213546879;:<>=?DCBA@EFJIHGKLMNOPQRWVSTUXYZ[\]`_^abedcfihgjlkmnopqsrtvuwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~}~z{|xytvuwqsrnopmjlkfihgabedc\]`_^Z[XYQRWVSTUNOPKLMEFJIHG?DCBA@<>=9;:687354.0/21-(,+*)JNone"#$%,14568=>?@ACEPSX_`4 vAgda/Type of a literate preprocessor: Invariants:  f : Processor f pos s /= []f pos s >>= layerContent == s wAgdaA list of contiguous layers. xAgda9A sequence of characters in a file playing the same role. }Agda Role of a character in the file.7yAgda7Annotates a tokenized string with position information. Agda[List of valid extensions for literate Agda files, and their corresponding preprocessors.yIf you add new extensions, remember to update test/Utils.hs so that test cases ending in the new extensions are found. AgdaReturns True& if the role corresponds to Agda code. AgdaReturns True! if the layer contains Agda code. AgdaBlanks the non-code parts of a given file, preserving positions of characters corresponding to code. This way, there is a direct correspondence between source positions and positions in the processed result.7zAgda6Replaces non-space characters in a string with spaces.7{Agda*Check if a character is a blank character. AgdaJShort list of extensions for literate Agda files. For display purposes.7|AgdaBreaks a list just after1 an element satisfying the predicate is found.break1 even [1,3,5,2,4,7,8]([1,3,5,2],[4,7,8])7}AgdaXReturns a tuple consisting of the first line of the input, and the rest of the input.7~Agda2Canonical decomposition of an empty literate file.7AgdadCreate a regular expression that: - Must match the whole string - Works across line boundaries AgdaPreprocessor for literate TeX. AgdaPreprocessor for Markdown. Agda"Preprocessor for reStructuredText. Agda$Preprocessor for Org mode documents. v w x y z { | } ~   v w x y z { | } ~  KNone"#$,145678=>?@ACEPSX_`% AgdaThe parser monad. AgdaMemoisation keys. AgdaRuns the parser. AgdaOParses a token satisfying the given predicate. The computed value is returned. Agda.Parses a token satisfying the given predicate. AgdauUses the given document as the printed representation of the given parser. The document's precedence is taken to be atomP. AgdaMemoises the given parser./Every memoised parser must be annotated with a uniqueI key. (Parametrised parsers must use distinct keys for distinct inputs.) Agda@Memoises the given parser, but only if printing, not if parsing./Every memoised parser must be annotated with a uniqueI key. (Parametrised parsers must use distinct keys for distinct inputs.) Agda&Tries to print the parser, or returns 7SF, depending on the implementation. This function might not terminate.  LNone"#$,1245678=>?@ACEHPSVX_`R Agda+Check whether a name is the empty name "_". AgdaNumber of holes in a  $ (i.e., arity of a mixfix-operator). AgdaATop-level module names. Used in connection with the file system.&Invariant: The list must not be empty. AgdaQNamee 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). AgdaA.rest. Agdax. Agda<Mixfix identifiers are composed of words and holes, e.g. _+_ or  if_then_else_ or [_/_]. Agda_ part. AgdaIdentifier part. Agda*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. AgdaA (mixfix) identifier. Agda_. AgdavAn open mixfix identifier is either prefix, infix, or suffix. That is to say: at least one of its extremities is a Hole Agda+Parse a string to parts of a concrete name.Note: 5stringNameParts "_" == [Id "_"] == nameParts NoName{} AgdaIs the name an operator? Agda<Get the next version of the concrete name. For instance, nextName "x" = "x ". The name must not be a  . AgdaXGet the first version of the concrete name that does not satisfy the given predicate. AgdaJGet a raw version of the name with all suffixes removed. For instance, nameRoot "x " = "x". The name must not be a  . Agda qualify A.B x == A.B.x Agda unqualify A.B.x == xThe range is preserved. Agda qnameParts A.B.x = [A, B, x] AgdaIs the name (un)qualified? AgdaTurns a qualified name into a  F. The qualified name is assumed to represent a top-level module name. AgdaFTurns a top-level module name into a file name with the given suffix. AgdapFinds 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. Agda  noName_ =    AgdaRanges are not forced. AgdaDefine 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. -Ulf8 8 NNone"#$,14568=>?@ACEPSX_`U FAgdaArbitrary JS code.% " # $ % & ' * ) ( + , . - / 0 1 2 3 4 5 D F C A @ ? > 9 8 7 6 E B : < = ;% 5 D F C A @ ? > 9 8 7 6 E B : < = ; 3 4 1 2 / 0 + , . - & ' * ) ( $ % " #ONone"#$,14568=>?@ACEPSX_`W \ ] ^ _ ` a b c d e f g h i j k l m \ ] ^ _ ` a b c d e f g h i j k l mPNone"#$,14568=>?@ACEPSX_`\  zAgdaCheck if a string is a valid JS identifier. The check ignores keywords as we prepend z_ to our identifiers. The check is conservative and may not admit all valid JS identifiers. n o p q r s t u v w x y z r s t p q n o u v w x y zQNone"#$,14568=>?@ACEPSX_`' Agda"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. AgdaInstantation of variable. Agda'For going under a binder, often called Lift. Agda2Shifting substitution (going to a larger context). AgdaAn expression a in an explicit substitution  [CAction a]. AgdaBLazy concatenation of argument lists under explicit substitutions. AgdaHead-normal form of  . First entry is exposed.,Q: Why are there no projection eliminations? AgdaNo more eliminations. AgdaApplication and tail. Agda proj pre args, projfcn idx, tail AgdaConstructor parameter (missing in Agda). Agsy has monomorphic constructors. Inserted to cover glitch of polymorphic constructor applications coming from Agda Agda>"Maybe expression": Expression or reference to meta variable. AgdaAgsy's internal syntax. AgdaLambda with hiding information. AgdaTrue8 if possibly dependent (var not known to not occur). False if non-dependent. Agda&Absurd lambda with hiding information. AgdaUnique identifier of the head. Agda'This application has been type-checked. AgdaHead. Agda Arguments. Agda"Head of application (elimination). Agda Dot pattern. AgdaConstant definitions. AgdaConstant signatures. AgdaFor debug printing. AgdaReference to the Agda constant. AgdaType of constant. AgdaConstant definition. Agda7Free vars of the module where the constant is defined.. AgdaAbstraction with maybe a name.NDifferent from Agda, where there is also info whether function is constant. AgdaThe concrete instance of the blk parameter in ]8. I.e., the information passed to the search control. Agda[Nat - deffreevars (to make cost of using module parameters correspond to that of hints). Agda1Size of typing context in which meta was created. Agda!Head normal form of type of meta. AgdaTrue if iota steps performed when normalising target type (used to put cost when traversing a definition by construction instantiation). Agda;Unique identifiers for variable occurrences in unification. AgdaSubstituting for a variable. AgdaFreeVars class and instances Agda Renaming Typeclass and instances                     RNone"#$,14568=>?@ACEPSX_` +Agda!Moves A move is composed of a Cost: together with an action computing the refined problem. 8Agda univar sub v figures out what the name of v" "outside" of the substitution sub ought to be, if anything. 9Agda6List of the variables instantiated by the substitution :AgdaNew constructors Taking a step towards a solution consists in picking a constructor and filling in the missing parts with placeholders to be discharged later on. >Agda5New spine of arguments potentially using placeholders @AgdaNew App?lication node using a new spine of arguments respecting the Hiding annotation BAgdaEquality reasoning steps The begin token is accompanied by two steps because it does not make sense to have a derivation any shorter than that. GAgdakPick the first unused UId amongst the ones you have seen (GA: ??) Defaults to the head of the seen ones.E + , - 5 4 3 2 1 0 / . 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 oE , - 5 4 3 2 1 0 / . 6 7 8 9 + : ; < = > ? @ A B C D E F G H J K L M N O P Q R S T U V W X Y Z [ \ I ] ^ _ ` a b c d e f k g h i j l m n oSNone"#$,14568=>?@ACEPSX_` Agda)Typechecker drives the solution of metas.- y | { z }  ~ - }  ~ y | { z TNone"#$,14568=>?@ACEPSX_` AgdadSpeculation: Type class computing the size (?) of a pattern and collecting the vars it introduces AgdaITake a list of patterns and returns (is, size, vars) where (speculation):2 2 UNone"#$,14568=>?@ACEPSX_`O Agda.Zero or more consecutive and separated ranges. AgdaQCharacter ranges. The first character in the file has position 1. Note that the  4 position is considered to be outside of the range. Invariant:   7  . AgdaThe   invariant. AgdaThe   invariant. Agda77 iff the ranges overlap.)The ranges are assumed to be well-formed. Agda77 iff the range is empty. Agda(Converts a range to a list of positions. Agda/Converts several ranges to a list of positions. Agda Converts a f to a  . Agda 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.  VNone"#$,124568=>?@ACEMPSX_`g- Agda The result of parsing something. AgdaWarnings for parsing. Agda,Parse errors that concern a range in a file. Agda)The range of the bigger overlapping token Agda,Parse errors: what you get if parsing fails. Agda4Errors that arise at a specific position in the file Agda,Parse errors that concern a range in a file. Agda'Parse errors that concern a whole file. Agda%The file in which the error occurred. AgdaWhere the error occurred. AgdaThe remaining input. AgdaThe previous token. Agda*Hopefully an explanation of what happened. Agda)The range of the bigger overlapping token Agda"The file which the error concerns. Agda Parser flags. Agda/Should comment tokens be returned by the lexer? AgdaWe 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. Agda no layout Agdalayout at specified column Agda:For context sensitive lexing alex provides what is called  start codesp in the Alex documentation. It is really an integer representing the state of the lexer, so we call it LexState instead. AgdaRThe parser state. Contains everything the parser and the lexer could ever need. Agda"position at current input location Agdaposition of last token Agdathe current input !Agdathe character before the input "Agdathe previous token #Agdathe stack of layout contexts $AgdaCthe state of the lexer (states can be nested so we need a stack) %Agdaparametrization of the parser &AgdaThe parse monad.7AgdaOld interface to parser. (Agda,Throw a parse error at the current position. )AgdaConstructs 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. *AgdaThe default flags. +Agda.The most general way of parsing a string. The Agda.Syntax.Parser; will define more specialised functions that supply the   and the  . ,Agda.The even more general way of parsing a string. -AgdaeParses a string as if it were the contents of the given file Useful for integrating preprocessors. 1AgdaIThe parse interval is between the last position and the current position. 6AgdaFake 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. 7AgdaUse  6 or  ( as appropriate. 8Agda3Report a parse error at the beginning of the given f. 9AgdaFor 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  6 the current position. :Agda"Return the current layout context. =AgdaShould 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.>                        %    ! " # $ & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < => &     %    ! " # $                    ) * + , - . / 1 0 5 2 3 4 : ; < = ' ( 6 7 8 9WNone"#$,124568=>?@ACEPSX_`" NAgdaMake a  a from some kind of string. OAgdaThe f sets the definition site of the name, not the use site. QAgda*Check whether we are a projection pattern. SAgda<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 f). VAgda'A module name is just a qualified name.The _H instance for module names sets all individual ranges to the given one. YAgda(Something preceeded by a qualified name. ]AgdaQualified 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 _r instance for qualified names sets all individual ranges (including those of the module prefix) to the given one. aAgdaA 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. gAgda2Is this the name of the invisible record variable selfH? Should not be printed or displayed in the context, see issue #3584. hAgda%Useful for debugging scoping problems iAgdaA singleton "ambiguous" name. jAgda%Get the first of the ambiguous names. kAgdaIs a name ambiguous. lAgdaGet the name if unambiguous. mAgdaFA module is anonymous if the qualification path ends in an underscore. nAgdaSets 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. oAgdaLike  nb, but uses the name parts (qualifier + name) of the qualified name as the list of concrete names. xAgdaTurn 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. zAgda 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. ~Agda Convert a  a to a  ] (add no module name). AgdaIs the name an operator? Agda0Is the first module a weak parent of the second? Agda2Is the first module a proper parent of the second? Agda/Is the first module a weak child of the second? Agda1Is the first module a proper child of the second? Agda9Get the next version of the concrete name. For instance, nextName "x" = "x ". The name must not be a NoName. AgdaThe range is not forced. AgdaOnly use this show3 function in debugging! To convert an abstract  a into a string use  prettyShow. Agda8An abstract name is empty if its concrete name is empty. AgdaOnly use this show3 function in debugging! To convert an abstract  V into a string use  prettyShow. AgdaOnly use this show3 function in debugging! To convert an abstract  ] into a string use  prettyShow. AgdaThe range of an AmbiguousQNameQ is the range of any of its disambiguations (they are the same concrete name). AgdaPWe can have an instance for ambiguous names as all share a common concrete name. AgdaUse w to print names to the user.> N O P Q R S T U V W X Y Z [ \ ] ^ ` _ a b c f d e g h i j k l m n o p q r s t u v w x y z { | } ~  > N O P Q R S T U V W X Y Z [ \ ] ^ ` _ a b c f d e g h i j k l m n o p q r s t u v w x y z { | } ~  XNone"#$,124568=>?@ACEPSX_`B Agda-Sections, as well as non-sectioned operators. Agda>For non-sectioned operators this should match the notation's  . AgdaEffective precedence level. 7> for closed notations. Agda7Q for non-sectioned operators. Agda/All the notation information related to a name. Agda-The names the syntax and/or fixity belong to.AInvariant: The set is non-empty. Every name in the list matches  . Agda3Associativity and precedence (fixity) of the names. Agda!Syntax associated with the names. AgdaPTrue if the notation comes from an operator (rather than a syntax declaration). AgdaClassification of notations. AgdaEx:  _bla_blub_. AgdaEx:  _bla_blub. AgdaEx:  bla_blub_. AgdaEx: bla_blub. Agda8Data type constructed in the Happy parser; converted to ($ before it leaves the Happy code. Agda x -> y2; 1st argument is the bound name (unused for now). AgdaSimple named hole with hiding. AgdaIs the hole a binder? Agda2Get a flat list of identifier parts of a notation. AgdaATarget argument position of a part (Nothing if it is not a hole). AgdaeIs the part a hole? WildHoles don't count since they don't correspond to anything the user writes. AgdaIs the part a normal hole? AgdaIs the part a binder? Agda<Classify a notation by presence of leading and/or trailing normal holes. Agda2From 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 ] AgdaLIf an operator has no specific notation, then it is computed from its name. AgdaReplace  by . Agda Return the ,s 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. Agda Create a -# (without binders) from a concrete   . Does the obvious thing:   s become *s,   s become IdParts. If   has no  s, it returns . AgdaMerges  Is 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   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  @s that are merged have distinct associativities, then they get g as their associativity.Precondition: No  a1 may occur in more than one list element. Every   must have the same  .Postcondition: No  a& occurs in more than one list element. Agda Lens for a in  . Agda'Converts a notation to a (non-)section.' ' YNone"#$,124568=>?@ACEPSX_`Wt AgdaWhen printing we keep track of a stack of precedences in order to be able to decide whether it's safe to leave out parens around lambdas. An empty stack is equivalent to  . Invariant: `notElem TopCtx`. Agda(Precedence is associated with a context. Agda*Do we prefer parens around arguments like  x ! x or not? See . AgdaDecorating something with Fixity'.Agda#Argument context preferring parens.AgdalDo we need to bracket an operator application of the given fixity in a context with the given precedence.AgdalDo we need to bracket an operator application of the given fixity in a context with the given precedence.AgdaDoes 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. To decide we need to look at the stack of precedences and not just the current precedence. Example: m >>= ( x ! x) >>= m  (for _>>=_ left associative).Agda*Does a function application need brackets? Agda*Does a function application need brackets? Agda&Does a with application need brackets? Agda$Does a function space need brackets?           ZNone"#$,124568=>?@ACEPSX_`Y(AgdaRanges are not forced. $#"! %&' $#"! %&'[None"#$,124568=>?@ACEPSX_`gx' 2Agda5Checks if the given expression is unreachable or not.4Agda 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.6AgdaMatches 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)7AgdaBinds no variablesJAgdaCCompiler-related primitives. This are NOT the same thing as primitives in Agda's surface or internal syntax! Some of the primitives have a suffix indicating which type of arguments they take, using the following naming convention: Char | Type C | Character F | Float I | Integer Q | QName S | StringjAgdaintroduces 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.kAgdaCase 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.oAgdaUsed by the GHC backendpAgda,A runtime error, something bad has happened.rAgdaThe treeless compiler can behave differently depending on the target language evaluation strategy. For instance, more aggressive erasure for lazy targets.|Agda=Strip leading coercions and indicate whether there were some.AgdaExpose the format  coerce f args.wWe fuse coercions, even if interleaving with applications. We assume that coercion is powerful enough to satisfy / coerce (coerce f a) b = coerce f a b AgdaIntroduces a new binding N O P Q R S T U V W X Y Z [ \ ] ^ ` _ a b c f d e g h i j k l m n o p q r s t u v w x y z { | } ~  123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~]123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~\None"#$,14568=>?@ACEPSX_`}7Agda,Split alts into TAGuard alts and other alts.]None"#$,14568=>?@ACEPSX_`AgdaPWe lose track of @-patterns in the internal syntax. This pass puts them back.^None"#$,14568=>?@ACEPSX_`AgdaA misplaced end-comment "-}".r      !"#r      !"#aNone"#$,124568=>?@ACEPSX_`7AgdaLines with line numbers.7AgdaJHeader line, like a field name, e.g. "include :". Cannot be indented. String is trimmed.7Agda"Other line. Must be indented. String is trimmed.7Agda(Library file field format format [sic!].7AgdaName of the field.7AgdaIs it optional?7AgdaContent parser for this field.7AgdaSets parsed content in  structure.7AgdaE.g. field name. trimmed.7AgdaE.g. field content. trimmed.7AgdaIThe config files we parse have the generic structure of a sequence of field : content entries.0AgdaLibrary Warnings.7AgdaParser monad: Can throw String error messages, and collects  LibWarning's library warnings.7Agda .agda-lib& file format with parsers and setters.3AgdaParse  .agda-lib file.Sets W name and turn mentioned include directories into absolute pathes (provided the given 7_ is absolute).7AgdaParse file contents.7AgdaParse 7 with 7 descriptors.7AgdaGiven a list of 75 descriptors (with their custom parsers), parse a 7 into the  structure.OChecks mandatory fields are present; no duplicate fields, no unknown fields.7AgdaNEnsure that there are no duplicate fields and no mandatory fields are missing.7AgdaFind 7 with given 7, throw error if unknown.7AgdaExample:  parseGeneric "name:Main--BLAndepend:--BLAn standard-library--BLAninclude : . --BLAn src more-src n" == Right [("name",[MainE]),("depend",["standard-library"]),("include",[".","src more-src"])] 7AgdaParse line into 7 and 7 components.LPrecondition: line comments and trailing whitespace have been stripped away. Example file: V name: Main depend: standard-library include: . src more-src This should give ' [ Header 1 "name" , Content 1 Main , Header 2 "depend" , Content 3 "standard-library" , Header 4 "include" , Content 4 "." , Content 5 "src more-src" ] 7AgdaCollect 7 and subsequent 7s into 7.Tailing 7s? That's an error.4Agda+Remove leading whitespace and line comment.5Agda4Break a comma-separated string. Result strings are trimmed.7Agda-...and trailing, but not leading, whitespace./012345354/201bNone"#$,14568=>?@ACEPSX_` /uB9Agda SCC DAGs.0The maps map SCC indices to and from SCCs/nodes.>AgdaVarious kinds of nodes.@AgdaNodes with outgoing edges.AAgdaNodes with incoming edges.BAgda!All nodes, with or without edges.CAgdaEdges.EAgdaOutgoing node.FAgdaIncoming node.GAgdaEdge label (weight).HAgda Graph n e, is a type of directed graphs with nodes in n and edges in e.lAt most one edge is allowed between any two nodes. Multigraphs can be simulated by letting the edge type e be a collection type.The graphs are represented as adjacency maps (adjacency lists, but using finite maps instead of arrays and lists). This makes it possible to compute a node's outgoing edges in logarithmic time (O(log n)B). However, computing the incoming edges may be more expensive.LNote that neither the number of nodes nor the number of edges may exceed 7 :: 7.JAgdaForward edges.KAgdaInternal invariant.LAgdaIf there is an edge from s to t, then  lookup s t g is 7= e, where e is the edge's label. O(log n).MAgdaThe graph's edges. O(n + e).NAgdaneighbours u g consists of all nodes v" for which there is an edge from u to v in g-, along with the corresponding edge labels.  O(log n + |neighbours u g|).OAgdaneighboursMap u g consists of all nodes v" for which there is an edge from u to v in g-, along with the corresponding edge labels. O(log n).PAgdaedgesFrom g nst is a list containing all edges originating in the given nodes (i.e., all outgoing edges for the given nodes). If nsT does not contain duplicates, then the resulting list does not contain duplicates. O(|ns| log |n| + |edgesFrom g ns|).QAgda edgesTo g nsn is a list containing all edges ending in the given nodes (i.e., all incoming edges for the given nodes). If nsU does not contain duplicates, then the resulting list does not contain duplicates. O(|ns | n log n).RAgdaAll self-loops.  O(n log n).SAgda All nodes. O(n).TAgdaNodes with outgoing edges. O(n).UAgdaNodes with incoming edges. O(n + e log n).VAgda Constructs a > structure. O(n + e log n).WAgda*Nodes without incoming or outgoing edges. O(n + e log n).XAgdaFChecks whether the graph is discrete (containing no edges other than  edges). O(n + e).YAgdaReturns True iff the graph is acyclic.ZAgdaJConstructs a completely disconnected graph containing the given nodes.  O(n log n).[AgdaJConstructs a completely disconnected graph containing the given nodes. O(n).\Agda fromEdges es$ is a graph containing the edges in es=, with the caveat that later edges overwrite earlier edges. O(|es| log n).]AgdafromEdgesWith f es$ is a graph containing the edges in esM. Later edges are combined with earlier edges using the supplied function. O(|es| log n).^Agda"Empty graph (no nodes, no edges). O(1)._Agda5A graph with two nodes and a single connecting edge. O(1).`Agda Inserts an edge into the graph. O(log n).aAgda Inserts an edge into the graph. O(log n).bAgdainsertWith f s t new inserts an edge from s to t3 into the graph. If there is already an edge from s to t with label old6, then this edge gets replaced by an edge with label  f new old%, and otherwise the edge's label is new. O(log n).cAgda A variant of b. O(log n).dAgdaLeft-biased union.Time complexity: See e.eAgdaUnion. The function is used to combine edge labels for edges that occur in both graphs (labels from the first graph are given as the first argument to the function).Time complexity:  O(n log (n n + 1) + e log e , where Pn / is the number of nodes in the graph with the smallest number of nodes and n 0 is the number of nodes in the other graph, and e M is the number of edges in the graph with the smallest number of edges and e + is the number of edges in the other graph."Less complicated time complexity: O((n + e) log n (where n and e refer to the resulting graph).fAgdaUnion. O((n + e) log n (where n and e refer to the resulting graph).gAgda\Union. The function is used to combine edge labels for edges that occur in several graphs. O((n + e) log n (where n and e refer to the resulting graph).hAgda A variant of 7< that provides extra information to the function argument. O(n + e).iAgdaReverses an edge. O(1).jAgda.The opposite graph (with all edges reversed). O((n + e) log n).kAgdaRemoves  edges. O(n + e).lAgdaremoveNodes ns g removes the nodes in ns% (and all corresponding edges) from g. O((n + e) log |ns|).mAgdaremoveNode n g removes the node n% (and all corresponding edges) from g. O(n + e).nAgdaremoveEdge s t g removes the edge going from s to t , if any. O(log n).oAgda0Keep only the edges that satisfy the predicate. O(n + e).pAgdaUnzips the graph. O(n + e).qAgdacomposeWith 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 look up all edges starting with t in g'.>Precondition: The two graphs must have exactly the same nodes.rAgdaIThe graph's strongly connected components, in reverse topological order.sAgdaIThe graph's strongly connected components, in reverse topological order.tAgda9 invariant.uAgdaThe opposite DAG.vAgda'The nodes reachable from the given SCC.wAgdaGConstructs a DAG containing the graph's strongly connected components.xAgdaGConstructs a DAG containing the graph's strongly connected components.yAgdareachableFrom 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 7 :: 7.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.zAgdareachableFromSet g ns/ is a set containing all nodes reachable from ns in g.Precondition: Every node in ns must be a node in g<. The number of nodes in the graph must not be larger than 7 :: 7.KAmortised time complexity (assuming that comparisons take constant time): O((|ns | + e) log n).7AgdaUsed to implement y and z.{Agda#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 7 :: 7.iAmortised time complexity (assuming that comparisons and the predicates take constant time to compute): O(n + e log n).|AgdaTransitive closure ported from Agda.Termination.CallGraph.%Relatively efficient, see Issue 1560.}Agda 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~Agda-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.Agda-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 H, 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.AgdaThe transitive closure. Using . NOTE: DO NOT USE () AS EDGE LABEL SINCE THIS MEANS EVERY EDGE IS CONSIDERED A ZERO EDGE AND NO NEW EDGES WILL BE ADDED! Use 'Maybe ()' instead.wAgda*The graph's strongly connected components.H9:;<=>?@ABCDGEFHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~HHIJKCDGEFLMNOPQRSTUW>?@ABVXYZ[\]^_`bacdefghijkmlnopqrs9:;<=tuvwxyz{~|}cNone"#$%,14568=>?@ACEPSX_` 8Agdaytopoligical sort with smallest-numbered available vertex first | input: nodes, edges | output is Nothing if the graph is not a DAG Note: should be stable to preserve order of generalizable variables. Algorithm due to Richard Eisenberg, and works by walking over the list left-to-right and moving each node the minimum distance left to guarantee topological ordering.dNone"#$,14568=>?@ACEPSX_` r%AgdaThese metas are < ".Agda,Lower or upper bound for a flexible variableAgdaA graph forest.Agda 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. ]AgdaNodes not connected.Agda4Test for negativity, used to detect negative cycles.Agda1Compute list of edges that start in a given node.Agda/Compute list of edges that target a given node.9Note: expensive for unidirectional graph representations.Agda Set.foldl* does not exist in legacy versions of the  containers package.AgdaFloyd-Warshall algorithm.Agda5Convert a label to a weight, decrementing in case of .AgdaSplit 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".AgdaTAdd an edge to a graph forest. Graphs that share a node with the edge are joined.AgdaReflexive closure. Add edges 0 -> n -> n -> oo for all nodes n.Agdah  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.Agda2Build a graph from list of simplified constraints.Agda2Build a graph from list of simplified constraints.AgdaIf we have an edge  X + n <= X (with n >= 0), we must set X = oo.Agda2Compute a lower bound for a flexible from an edge.Agda3Compute an upper bound for a flexible from an edge.Agda6Compute the lower bounds for all flexibles in a graph.Agda6Compute the upper bounds for all flexibles in a graph.Agda0Compute the bounds for all flexibles in a graph.AgdacCompute the relative minima in a set of nodes (those that do not have a predecessor in the set).AgdaaCompute the relative maxima in a set of nodes (those that do not have a successor in the set).AgdaGiven 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.AgdaGiven 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.AgdaBCompute the sup of two different rigids or a rigid and a constant.AgdaBCompute the inf of two different rigids or a rigid and a constant.Agda$Compute the least upper bound (sup).Agda]Compute the greatest lower bound (inf) of size expressions relative to a hypotheses graph.AgdahSolve a forest of constraint graphs relative to a hypotheses graph. Concatenate individual solutions.AgdaXCheck that after substitution of the solution, constraints are implied by hypotheses.Agda1Iterate solver until no more metas can be solved.sThis might trigger a (wanted) error on the second iteration (see Issue 2096) which would otherwise go unnoticed.AgdaPartial implementation of Num.Agda$An edge is negative if its label is.Agda A graph is U if it contains a negative loop (diagonal edge). Makes sense on transitive graphs.Agda;Meta variable polarities (prefer lower or upper solution?).AgdaBHypotheses (assumed to have no metas, so, fixed during iteration).AgdaConstraints to solve.Agda7Previous substitution (already applied to constraints).AgdaAccumulated substition.UUeNone"#$,124568=>?@ACEPSX_` AgdawSubterm occurrences for positivity checking. The constructors are listed in increasing information they provide: 3Mixed <= JustPos <= StrictPos <= GuardPos <= Unused Mixed <= JustNeg <= Unused.Agda-Arbitrary occurrence (positive and negative).AgdaNegative occurrence.Agda/Positive occurrence, but not strictly positive. AgdaStrictly positive occurrence. AgdaVGuarded strictly positive occurrence (i.e., under "). For checking recursive records. Agda-One part of the description of an occurrence.Agda(in the nth argument of a define constantAgda'in the principal argument of built-in "Agda"as an argument to a bound variableAgda as an argument of a metavariableAgdain the type of a constructorAgda$in a datatype index of a constructorAgda'in the nth clause of a defined functionAgda1matched against in a clause of a defined functionAgda"is an index of an inductive familyAgdain the definition of a constantAgdaDescription of an occurrence.AgdaThe elements of the sequences, read from left to right, explain how to get to the occurrence. The second sequence includes the main information, and if the first sequence is non-empty, then it includes information about the context of the second sequence.Agda&The map contains bindings of the form  bound |-> ess?, satisfying the following property: for every non-empty list w, 7 L w 7 bound iff 7 [ 7 every w 7 7 some w | (every, some) <- ess ].Agda+productOfEdgesInBoundedWalk occ g u v bound returns a value distinct from 7> iff there is a walk c (a list of edges) in g, from u to v, for which the product 7 L (7 occ c) 7 bound&. In this case the returned value is 7= (7 L c) for one such walk c.Preconditions: u and v must belong to g, and bound must belong to the domain of boundToEverySome.!Agda* is a complete lattice with least element  and greatest element  .&It forms a commutative semiring where K is meet (glb) and L0 is composition. Both operations are idempotent.For K,   is neutral (zero) and  is dominant. For L,   is neutral (one) and   is dominant.          fNone"#$,124568=>?@ACEPSX_` 3AgdaThe  is not an application.6Agda(Extended content of an interaction hole.7Agda e8Agda  (rewrite | invert) e0 | ... | en9Agda=Modules: Top-level pragmas plus other top-level declarations.=Agda$Second Range is for REWRITE keyword.>Agdafirst string is backend name?Agdafirst string is backend nameAAgdaINLINE or NOINLINEBAgda.Throws an internal error in the scope checker.CAgda:For coinductive records, use pragma instead of regular  eta-equality, definition (as it is might make Agda loop).DAgdaApplies to the named functionEAgdaApplies to the current moduleFAgda@Mark a definition as injective for the pattern matching unifier.GAgda*Display lhs as rhs (modifies the printer).HAgda)Applies to the following function clause.IAgdaApplies to the following function (and all that are mutually recursive with it) or to the functions in the following mutual block.JAgdaApplies to the following function (and all that are mutually recursive with it) or to the functions in the following mutual block.KAgda:Applies to the following data/record type or mutual block.MAgda*Applies to the following data/record type.RAgda  tel. M argsSAgda  M {{...}}TAgda~The representation type of a declaration. The comments indicate which type in the intended family the constructor targets.VAgdaDAxioms and functions can be irrelevant. (Hiding should be NotHidden)WAgda=Variables to be generalized, can be hidden and/or irrelevant.ZAgda#lone data signature in mutual block]Agda%lone record signature in mutual block_Agda7The optional name is a name for the record constructor.aAgdanotation declaration for a nameeAgdaIn  Agda.Syntax.Concrete.Definitions~ we generate private blocks temporarily, which should be treated different that user-declared private blocks. Thus the .fAgdaThe f9 here (exceptionally) only refers to the range of the instance( keyword. The range of the whole block InstanceB r ds is fuseRange r ds.qAgda(Just type signatures or instance blocks.7AgdaJust field signaturesrAgdaJust type signatures.sAgda.From the parser, we get an expression for the as- #, which we have to parse into a  .tAgdaThe content of the as -clause of the import statement.vAgdaThe "as" name.wAgdaCThe range of the "as" keyword. Retained for highlighting purposes.xAgda3An imported name can be a module or a defined name.{AgdaYThe things you are allowed to say when you shuffle names between name spaces (i.e. in import,  namespace, or open declarations).|AgdavAn expression followed by a where clause. Currently only used to give better a better error message in interaction.Agdaalways  (see parser)AgdaNo where clauses.Agda Ordinary where.Agda Named where: module M where . The  flag applies to the  J (not the module contents!) and is propagated from the parent function.Agda+No right hand side because of absurd match.Agda:Processed (operator-parsed) intermediate form of the core f ps of . Corresponds to .Agda fAgda psAgdaRecord projection.Agda-Patterns for record indices (currently none).AgdaMain argument.AgdaNon-empty; at least one (| p).Agda;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.AgdaSOriginal pattern (including with-patterns), rewrite equations and with-expressions.Agdae.g.  f ps | wpsAgda(rewrite e | with p <- e) (many)Agdawith e1 | {e2} | ... (many)AgdaDid we expand an ellipsis?Agda\A telescope is a sequence of typed bindings. Bound variables are in scope in later types.AgdaBinding (x1@p1 ... xn@pn : A).Agda Let binding (let Ds) or  (open M args).AgdaA typed binding.Agda. x or {x} or .x or .{x} or {.x} or x@p or (p)Agda. (xs : e) or {xs : e}Agda0A lambda binding is either domain free or typed.Agda A Binder x@p, the pattern is optionalAgda p ! e where csAgda9Concrete patterns. No literals in patterns at the moment.Agdac or xAgda quoteAgdap p' or  p {x = p'}Agdap1..pn before parsing operatorsAgdaeg: p => p' for operator _=>_ The  Q is possibly ambiguous, but it must correspond to one of the names in the set.Agda{p} or {x = p}Agda{{p}} or  {{x = p}}Agda (p)Agda _Agda ()Agdax@p unusedAgda .eAgda0, 1, etc.Agda record {x = p; y = q}Agdai = i1$ i.e. cubical face lattice generatorAgda..., only as left-most pattern.Agda| p, for with-patterns.AgdaCConcrete expressions. Should represent exactly what the user wrote.Agdaex: xAgdaex: 1 or "foo"Agdaex: ? or  {! ... !}Agdaex: _ or _A_5Agdabefore parsing operatorsAgdaex: e e, e {e}, or  e {x = e}Agdaex: e + e The  S is possibly ambiguous, but it must correspond to one of the names in the set.Agdaex: e | e1 | .. | enAgdaex: {e} or {x=e}Agdaex: {{e}} or {{x=e}}Agdaex:  \x {y} -> e or \(x:A){y:B} -> eAgdaex: \ ()Agdaex: .\ { p11 .. p1a -> e1 ; .. ; pn1 .. pnz -> en }Agdaex: e -> e or .e -> e (NYI: {e} -> e)Agdaex:  (xs:e) -> e or  {xs:e} -> eAgdaex: SetAgdaex: PropAgdaex: Set0, Set1, ..Agdaex: Prop0, Prop1, ..Agdaex: record {x = a; y = b}, or record { x = a; M1; M2 }Agdaex: record e {x = a; y = b}Agdaex:  let Ds in e+, missing body when parsing do-notation letAgdaex: (e)Agdaex: (| e1 | e2 | .. | en |) or (|)Agdaex: do x <- m1; m2Agdaex: () or {}, only in patternsAgdaex: x@p, only in patternsAgdaex: .p, only in patternsAgdaex: ..A, used for parsing ..A -> BAgda!only used for printing telescopesAgdaex: quote, should be applied to a nameAgdaex:  quoteTerm, should be applied to a termAgdaex:  @(tactic t)", used to declare tactic argumentsAgdaex: unquote&, should be applied to a term of type TermAgdato print irrelevant thingsAgdaex: a = b, used internally in the parserAgda...$, used internally to parse patterns.Agda\An abstraction inside a special syntax declaration (see Issue 358 why we introduce this).AgdaWe can try to get a  Telescope from a  [LamBinding]}. If we have a type annotation already, we're happy. Otherwise we manufacture a binder with an underscore for the type. AgdaSmart constructor for Pi: check whether the  Telescope is empty Agda#Computes the top-level module name.Precondition: The T has to be well-formed. This means that there are only allowed declarations before the first module declaration, typically import declarations. See  . AgdaSplits off allowed (= import) declarations before the first non-allowed declaration. After successful parsing, the first non-allowed declaration should be a module declaration.Agda*Observe the hiding status of an expressionAgdaUTurn an expression into a pattern. Fails if the expression is not a valid pattern.AgdaA  is  when the whereG keyword is absent. An empty list of declarations does not count as  here.AgdaRanges are not forced. AgdaRanges are not forced.!AgdaRanges are not forced."AgdaRanges are not forced.#AgdaRanges are not forced.$AgdaRanges are not forced.%AgdaRanges are not forced.&AgdaRanges are not forced.'AgdaRanges are not forced. 3456789:;<=>?@ABCDEFGHIJKLMNOPQRSTm[`pdaij_hWcUXVYZ\]^befgklnoqrstuvwxyz{|}~      34  Tm[`pdaij_hWcUXVYZ\]^befgklnoQRSrq{zxytuvwsNOP~|}:;<=>?@ABCDEFGHIJKLM9 5678  gNone"#$,14568=>?@ACEPSX_` AgdaPicking the appropriate set of special characters depending on whether we are allowed to use unicode or have to limit ourselves to ascii.AgdaprettyHiding 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.##hNone"#$,124568=>?@ACEPSX_` &h Agda7> for root of split treeAgdaTag for labeling branches of a split tree. Each branch is associated to either a constructor or a literal, or is a catchall branch (currently only used for splitting on a literal type).AgdaSplit 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.AgdaAbstract case tree shape.Agda@No more splits coming. We are at a single, all-variable clause.AgdaA split is necessary.Agda+The number of variables bound in the clauseAgdaArg. no to split at. AgdaSub split trees. AgdaConvert a split tree into a V` (for printing).          iNone"#$,14568=>?@ACEPSX_` ?3( AgdaPhases to allocate CPU time to.!Agda#Happy parsing and operator parsing."AgdaImport chasing.#AgdaReading interface files.$Agda2Scope checking and translation to abstract syntax.%Agda1Type checking and translation to internal syntax.&AgdaTermination checking.'Agda-Positivity checking and polarity computation.(AgdaInjectivity checking.)Agda!Checking for projection likeness.*Agda0Coverage checking and compilation to case trees.+AgdaGenerating highlighting info.,AgdaWriting interface files.-AgdaDeac code elimination..Agda Subphase for &./Agda Subphase for &.0Agda Subphase for &.1Agda Subphase for &.2Agda Subphase for &.3Agda Subphase for &.4Agda Subphase for ".5Agda Subphase for #: compacting interfaces.6Agda Subphase for ,.7Agda Subphase for ,.8Agda Subphase for ,.9Agda Subphase for ,.:Agda Subphase for !.;Agda Subphase for !.<Agda Subphase for %: free variable computation.=Agda Subphase for %!: occurs check for solving metas.>Agda Subphase for %: checking the LHS?Agda Subphase for %: checking the RHS@Agda Subphase for %: checking a type signatureAAgda Subphase for %: generalizing over variablesBAgda Subphase for %: solving instance goalsCAgda Subphase for >: unification of the indicesDAgdaPretty printing names.JAgda.Global variable to store benchmark statistics.KAgda=Benchmark an IO computation and bill it to the given account.LAgda>Benchmark a pure computation and bill it to the given account./ EDCB?>=;:9865,)$#!"@F+'%A(7&/-324<10.*GHIJKL/ EDCB?>=;:9865,)$#!"@F+'%A(7&/-324<10.*GHIJKLjNone"#$,14568=>?@ACEHPSVX_` cpRAgdaGeneric pattern traversal.See a.SAgda Fold pattern.TAgda<Traverse pattern with option of post-traversal modification.UAgdaTraverse pattern.VAgdaThe next patterns are ...(This view discards PatInfo.)WAgda&Application patterns (non-empty list).XAgdaHWith patterns (non-empty list). These patterns are not prefixed with .YAgdaCheck for with-pattern | p.[Agda*Has the lhs an occurrence of the ellipsis ...?]AgdaCheck for ellipsis ...._AgdaConstruct the V" of the given list (if not empty).+Return the view and the remaining patterns.`AgdaKAdd applicative patterns (non-projection / non-with patterns) to the right.aAgdaAdd with-patterns to the right.bAgdaAppend patterns to ), separating with patterns from the rest.cAgda Modify the  component in .dAgdaEffectfully modify the  component in .eAgda)Does the LHS contain projection patterns?fAgdaHCompute a value from each subpattern and collect all values in a monoid.gAgdaETraverse pattern(s) with a modification before the recursive descent.hAgdaDTraverse pattern(s) with a modification after the recursive descent.iAgda?Map pattern(s) with a modification after the recursive descent.jAgda<Get all the identifiers in a pattern in left-to-right order.#Implemented using difference lists.kAgda<Get all the identifiers in a pattern in left-to-right order.lAgda9Does the pattern contain a with-pattern? (Shortcutting.)mAgdaIs ?nAgda2Count the number of with-subpatterns in a pattern?oAgdasCompute the context in which the ellipsis occurs, if at all. If there are several occurrences, this is an error.rAgdaView 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).sAgdaIs the pattern just ...?tAgda!Does the lhs contain an ellipsis?SAgda>Combine a pattern and the value computed from its subpatterns.TAgda;Combine a pattern and the its recursively computed version.UAgdapre : Modification before recursion.Agdapost: Modification after recursion.gAgdapre : Modification before recursion.hAgdapost: Modification after recursion.!RUTSVXWYZ[\]^_`abcdefghijklmnopqr!]^[\YZVXW_`abcdeRUTSfghijklmnopqrkNone"#$&',.14568=>?@ACEHPSVX_` uq AgdaA singleton type for   (except for the constructor  ).Agda"Used to define the return type of .AgdaShould sections be parsed?AgdaThe  O is possibly ambiguous, but it must correspond to one of the names in the set.AgdaRuns a parser. If sections should be parsed, then identifiers with at least two name parts are split up into multiple tokens, using tO to record the tokens' original positions within their respective identifiers.Agda)Parse a specific identifier as a NamePartAgdaKParses 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.Agda,Parses a potentially pattern-matching binderAgda0Parse 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.""lNone"#$,14568=>?@ACEPSX_` z Agda,Generic traversals for concrete expressions. Note: does not go into patterns!AgdaThis corresponds to 7.AgdaThis corresponds to 7.AgdaThis is a reduce.mNone"#$,14568=>?@ACEPSX_` 7AgdaWhile ~ and Polarities are not semigroups under disjoint union (which might fail), we get a semigroup instance for the monadic m (Fixities, Polarities)% which propagates the first error.7AgdaAdd more fixities. Throw an exception for multiple fixity declarations. OR: Disjoint union of fixity maps. Throws exception if not disjoint.AgdaGet the fixities and polarity pragmas from the current block. Doesn't go inside modules and where blocks. The reason for this is that these declarations have to appear at the same level (or possibly outside an abstract or mutual block) as their target declaration.7AgdajCompute the names defined in a declaration. We stay in the current scope, i.e., do not go into modules.  nNone"#$,14568=>?@ACEPSX_` ]Agda(Conjunctive constraint.)AgdaAn attribute is a modifier for .AgdaModifiers for .AgdaModifiers for .Agda#Concrete syntax for all attributes.Agda#Parsing a string into an attribute.Agda(Parsing an expression into an attribute.Agda!Setting an attribute (in e.g. an ). Overwrites previous value.AgdaXSetting some attributes in left-to-right order. Blindly overwrites previous settings.AgdaSetting  if unset.AgdaSetting  if unset.AgdaSetting  if unset.Agda'Setting an unset attribute (to e.g. an ).Agda#Setting a list of unset attributes.oNone"#$,14568=>?@ACEPSX_` !4Agda A compressed 0, in which consecutive positions with the same  are stored together.Agda Syntax highlighting information.AgdaA 6 is a mapping from file positions to meta information.,The first position in the file has number 1.AgdaRIs the highlighting "token-based", i.e. based only on information from the lexer?AgdaThe defining module.AgdaEThe file position in that module. File positions are counted from 1.Agda Has this DefinitionSite/ been created at the defining site of the name?Agda#A pretty name for the HTML linking.AgdaKMeta information which can be associated with a character/character range. AgdaThis 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). AgdaGThe definition site of the annotated thing, if applicable and known. AgdaIs this entry token-based?AgdaZOther aspects, generated by type checking. (These can overlap with each other and with *s.)AgdahUnsolved constraint not connected to meta-variable. This could for instance be an emptyness constraint.Agda`Used for highlighting unreachable clauses, unreachable RHS (because of an absurd pattern), etc.Agda8Used for shadowed repeated variable names in telescopes.AgdaGWhen this constructor is used it is probably a good idea to include a  * explaining why the pattern is incomplete.Agda!Code which is being type-checked.AgdaFunction declaration without matching definition NB: We put CatchallClause last so that it is overwritten by other, more important, aspects in the emacs mode.AgdaNameKind(s are figured out during scope checking.AgdaBound variable.AgdadGeneralizable variable. (This includes generalizable variables that have been generalized). Agda%Inductive or coinductive constructor."Agda Record field.$Agda Module name.&Agda Primitive.'Agda Record type.(Agda!Named argument, like x in {x = v})AgdaMacro.*Agda6Syntactic aspects of the code. (These cannot overlap.)/Agda Symbols like forall, =, ->, etc.0AgdaThings like Set and Prop.1AgdaIs the name an operator part?2AgdaJText occurring in pragmas that does not have a more specific aspect.3Agda"Non-code contents in literate Agda4AgdaZDelimiters used to separate the Agda code blocks from the other contents in literate Agda5Agda A variant of 7 with   set to .6Agda6 rs m( is a file whose positions are those in rs2, and in which every position is associated with m.7AgdaLike 6, but with several   instead of only one.7AgdaMerges meta information.8Agda Merges files.9Agda.Returns the smallest position, if any, in the .:Agda Convert the E to a map from file positions (counting from 1) to meta information.;AgdaInvariant 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.<AgdacCompresses a file by merging consecutive positions with equal meta information into longer ranges.=AgdaDecompresses a compressed file.>AgdaClear any highlighting info for the given ranges. Used to make sure unsolved meta highlighting overrides error highlighting.?Agda? rs m( is a file whose positions are those in rs2, and in which every position is associated with m.@AgdaLike  singletonR, but with a list of   instead of a single one.AAgdaMerges compressed files.BAgda 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.DAgda.Returns the smallest position, if any, in the .N     $! #&'%")(*1/-.2,4+0356789:;<=>?@ABCDN*1/-.2,4+03$! #&'%")(     56789:;<=>?@BCDAqNone"#$,14568=>?@ACEMPSX_` r uAgda;Result of comparing a candidate with the current favorites.vAgdaxGreat, 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.wAgda.Sorry, but you are dominated by that favorite.{Agda!A list of incomparable favorites.~AgdaGosh, 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.)AgdaCompare 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')Agda)After comparing, do the actual insertion.Agda%Compare, then insert accordingly. :insert a l = insertCompared a l (compareWithFavorites a l)Agda=Insert all the favorites from the first list into the second.AgdaConstruct 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.Agda{ forms a 7 under  and 'union.AgdaLEquality checking is a bit expensive, since we need to sort! Maybe use a Set! of favorites in the first place?uwvzyx{|}~{|}uwvzyx~ None"#$,14568=>?@ACEPSX_` h Agda,A finite map, represented as a set of pairs.%Invariant: at most one value per key.AgdagLookup keys in the same association list often. Use partially applied to create partial function apply m :: k -> Maybe v. First time:  O(n log n) in the worst case.Subsequently: O(log n).Specification:  apply m == ( m).Agda9O(n). Get the domain (list of keys) of the finite map.AgdaJO(1). Add a new binding. Assumes the binding is not yet in the list.AgdaO(n). Update the value at a key. The key must be in the domain of the finite map. Otherwise, an internal error is raised.AgdayO(n). Delete a binding. The key must be in the domain of the finite map. Otherwise, an internal error is raised.AgdaO(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.Agda<O(n). Map over an association list, preserving the order.Agda{O(n). If called with a effect-producing function, violation of the invariant could matter here (duplicating effects).AgdaO(n). Named in analogy to bcu. To preserve the invariant, it is sufficient that the key transformation is injective (rather than monotonic).  rNone"#$&',124568=>?@ACEPSX_` x!wAgdaSet the  e in an abstract name.AgdanUsed for instance arguments to check whether a name is in scope, but we do not care whether is is ambiguousAgda9Ambiguous constructors, projections, or pattern synonyms.Agda%When we get here we cannot have both using and hiding.Agda9Local variable bound by , , module telescope, pattern, let.Agda&Function, data/record type, postulate.AgdaBRecord field name. Needs to be distinguished to parse copatterns.Agda Data or record constructor name.AgdaName of pattern synonym.Agda Unbound name.AgdaWhat kind of binder?Agda-A decoration of abstract syntax module names.AgdaThe resolved module name.Agda&Explanation where this name came from.AgdaA decoration of Wd.AgdaThe resolved qualified name.Agda6The kind (definition, constructor, record field etc.).Agda&Explanation where this name came from.AgdajAdditional information needed during scope checking. Currently used for generalized data/record params.AgdaWhere does a name come from?=This information is solely for reporting to the user, see @e.AgdaDefined in this module.AgdaImported from another module.Agda!Imported by a module application.Agda A set of , for the sake of .AgdaOnly these kinds.AgdaAll but these Kinds.AgdaqFor the sake of parsing left-hand sides, we distinguish constructor and record field names from defined names.AgdaConstructor name.AgdaRecord field name.AgdaName of a pattern synonym.AgdaName to be generalizedAgda&Generalizable variable from a let openAgdaName of a macroAgda3A name that can only be quoted. Previous category DefNameE: (Refined in a flat manner as Enum and Bounded are not hereditary.)Agda Name of a data.Agda Name of a record.AgdaName of a defined function.Agda Name of a  postulate.Agda Name of a  primitive.AgdaA DefName7, but either other kind or don't know which kind. End DefName0. Keep these together in sequence, for sake of  isDefName!Agda%Non-dependent tag for name or module.Agda-Type class for some dependent-types trickery.Agda#Set of types consisting of exactly  and ..A GADT just for some dependent-types trickery.AgdaA  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.Agda0Maps concrete names to a list of abstract names.Agda>Maps concrete module names to a list of abstract module names.AgdaHAll abstract names targeted by a concrete name in scope. Computed by 0.AgdaA local variable can be shadowed by an import. In case of reference to a shadowed variable, we want to report a scope error.AgdaUnique ID of local variable.Agda/Kind of binder used to introduce the variable (, let, ...).AgdaTIf this list is not empty, the local variable is shadowed by one or more imports.AgdajFor each bound variable, we want to know whether it was bound by a , , module telescope, pattern, or let.Agda (currently also used for  and module parameters)Agda f ... =Agda  let ... inAgdaLocal variables.AgdaThe complete information about the scope at a particular program point includes the scope stack, the local variables, and the context precedence.Agda&Maps concrete names C.Name to fixitiesAgda(Maps concrete names C.Name to polaritiesAgdaSee .Agda#Things not exported by this module.Agda+Things defined and exported by this module.Agda1Things from open public, exported by this module.AgdaTA scope is a named collection of names partitioned into public and private names.AgdaGet a  from .Agda A lens for Agda`Monadic' lens (Functor sufficient).Agda3Shadow a local name by a non-empty list of imports.Agda1Treat patternBound variable as a module parameterAgda*Project name of unshadowed local variable. Agda%Get all locals that are not shadowed  by imports. AgdaLenses for ScopeInfo componentsAgda Lens for  .Agda Lens for  .Agda 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).AgdaVan Laarhoven lens on . AgdaVan Laarhoven lens on .#AgdaThe empty name space.$Agda9Map functions over the names and modules in a name space.%AgdaZip together two name spaces.&Agda&Map monadic function over a namespace.'AgdaThe empty scope.(AgdaThe empty scope info.)Agda4Map functions over the names and modules in a scope.*AgdaSame as )2 but applies the same function to all name spaces.+AgdaSame as )7 but applies the function only on the given name space.,Agda<Map monadic functions over the names and modules in a scope.-AgdaSame as ,M but applies the same function to both the public and private name spaces..AgdaUZip together two scopes. The resulting scope has the same name as the first scope./AgdaSame as .M but applies the same function to both the public and private name spaces.0Agda&Recompute the inScope sets of a scope.1AgdaFilter a scope keeping only concrete names matching the predicates. The first predicate is applied to the names and the second to the modules.2AgdaReturn all names in a scope.4Agda&Returns the scope's non-private names.8Agda=Merge two scopes. The result has the name of the first scope.9Agda\Merge a non-empty list of scopes. The result has the name of the first scope in the list.:AgdaaMove all names in a scope to the given name space (except never move from Imported to Public).;AgdaUpdate a particular name space.<AgdaModify a particular name space.=AgdaAdd a name to a scope.>AgdaRemove 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).?AgdaAdd a module to a scope.AAgda Apply an R to a scope: "rename keys (C.Name) according to renaming;for untouched keys, either ofa) remove keys according to hiding', or b) filter keys according to using.TBoth steps could be done in one pass, by first preparing key-filtering functions C.Name -> Maybe C.Name for defined names and module names. However, the penalty of doing it in two passes should not be too high. (Doubling the run time.)BAgda Version of AI that also returns sets of name and module name clashes introduced by renaming0 to identifiers that are already imported by using or lack of hiding.CAgda%Rename the abstract names in a scope.DAgda%Remove private name space of a scope.Should be a right identity for 4. >exportedNamesInScope . restrictPrivate == exportedNamesInScope.EAgda9Remove private things from the given module from a scope.FAgda3Disallow using generalized variables from the scopeGAgda.Add an explanation to why things are in scope.HAgda5Get the public parts of the public modules of a scopeLAgdaoCompute a flattened scope. Only include unqualified names or names qualified by modules in the first argument.MAgda:Get all concrete names in scope. Includes bound variables.NAgdaLook up a name in the scopeQAgdahFind the concrete names that map (uniquely) to a given abstract name. Sort by length, shortest first.TAgdarFind the concrete names that map (uniquely) to a given abstract qualified name. Sort by length, shortest first.VAgdaoFind the concrete names that map (uniquely) to a given abstract module name. Sort by length, shortest first.XAgda+Add first string only if list is non-empty.`AgdaAWe show shadowed variables as prefixed by a ".", as not in scope.pAgda/Sets the binding site of all names in the path.BAgda4Merged scope, clashing names, clashing module names.      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWX      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXsNone"#$,14568=>?@ACEPSX_` {Agda.Types which Geniplate should not descend into.AgdaA localised instance of 7. The generated 7. functions neither descend into the types in *, nor into the types in the list argument.AgdaA localised instance of 7. The generated 7. functions neither descend into the types in *, nor into the types in the list argument.tNone"#$,124568=>?@ACEMPSX_` 7Agda:Has the constructor pattern a dotted (forced) constructor?AgdaDotted constructor.AgdaOrdinary constructor.AgdaConstructor pattern info.AgdaEDoes this pattern come form the eta-expansion of an implicit pattern?Agda;For a general pattern we remember the source code position.AgdaUThe range of the "as" and "to" keywords, if any. Retained for highlighting purposes.AgdaAThe "as" module name, if any. Retained for highlighting purposes.Agda Retained for abstractToConcrete of l.AgdaInformation about applicationAgda6Do we prefer a appbda argument with or without parens?Agda-Default is system inserted and prefer parens.Agda with no range information.AgdaSame as  mkDefInfo but where we can also give the  IsInstanceAgdaEmpty range for patterns.AgdaDefault value for .>>uNone"#$,14568=>?@ACEPSX_` ]#7AgdaTransposable things.+Agda, m extracts the diagonal of m.fFor non-square matrices, the length of the diagonal is the minimum of the dimensions of the matrix.-Agda6Type of matrices, parameterised on the type of values.aSparse matrices are implemented as an ordered association list, mapping coordinates to values./AgdaDimensions of the matrix.0Agda!Association of indices to values.1Agda%Type of matrix indices (row, column).3Agda Row index, 1 <= row <= rows.4Agda Column index 1 <= col <= cols.5AgdaSize of a matrix.7AgdaNumber of rows, >= 0.8AgdaNumber of columns, >= 0.9Agda77 iff the matrix is square.:AgdaReturns 77 iff the matrix is empty.;Agda5Compute the matrix size of the union of two matrices.7Agda<Compute the matrix size of the intersection of two matrices.<Agda#Constructs a matrix from a list of (index, value) -pairs. O(n) where n is size of the list.!Precondition: indices are unique.=Agda= sz rsL constructs a matrix from a list of lists of values (a list of rows). O(size) where size = rows cols.Precondition: 7 rs 7k 7 sz and 7 ((8 sz 7k) . 7) rs.>Agda6Converts 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.7Agda`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.?Agda-Converts a matrix to a list of row lists. O(size) where size = rows cols.@Agda<Returns 'Just b' iff it is a 1x1 matrix with just one entry b. O(1).AAgdaAGeneral 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 7: ( (i, a) -> (i,)  $ f a), and same for gs and g.7Agda Instance of A$ which keeps longer assoc lists.  O(n1 + n2).BAgda?General pointwise combination function for sparse matrices.  O(n1 + n2).CAgdaC (+) m1 m2 adds m1 and m2, using (+) to add values.  O(n1 + n2).Returns a matrix of size ; m1 m2.DAgdaD 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.EAgda"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.FAgdaF 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.GAgdaG 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.HAgdaH 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.JAgdaNPointwise comparison. Only matrices with the same dimension are comparable.KAgdaDiagonal of sparse matrix.O(n) where n2 is the number of non-zero elements in the matrix.MAgdaMatrix transposition. O(n log n) where n2 is the number of non-zero elements in the matrix.NAgdaTransposing coordinates.OAgdaSize of transposed matrix.AAgdaOnly left map remaining.AgdaOnly right map remaining.Agda!Element only present in left map.Agda"Element only present in right map.AgdaElement present in both maps.7Agda!Element only present in left map.Agda"Element only present in right map.AgdaElement present in both maps.BAgda$Element only present in left matrix.Agda%Element only present in right matrix.Agda!Element present in both matrices.AgdaResult counts as zero?*+,-./0123456789:;<=>?@ABCDEFGH-.056781234=<?/9:@BCDEF*+,>;AHGvNone"#$,14568=>?@ACEPSX_` \Agda\A partial order, aimed at deciding whether a call graph gets worse during the completion.^Agda:In the paper referred to above, there is an order R with ` 7 Le 7 Lt.This is generalized to ` 7 '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._Agda2Decrease of callee argument wrt. caller parameter.The Bool indicates whether the decrease (if any) is usable. In any chain, there needs to be one usable decrease. Unusable decreases come from SIZELT constraints which are not in inductive pattern match or a coinductive copattern match. See issue #2331.UPDATE: Andreas, 2017-07-26: Feature #2331 is unsound due to size quantification in terms. While the infrastructure for usable/unusable decrease remains in place, no unusable decreases are generated by TermCheck.`AgdaENo relation, infinite increase, or increase beyond termination depth.aAgda&Matrix-shaped order, currently UNUSED.bAgda$Raw increase which does not cut off.cAgda$Raw decrease which does not cut off.eAgdaSmart constructor for Decr k :: Order which cuts off too big values.Possible values for k:  - ?cutoff 7 k 7 ?cutoff + 1.fAgdaRSmart constructor for matrix shaped orders, avoiding empty and singleton matrices.hAgdale, lt,  decreasing, unknown4: for backwards compatibility, and for external use.iAgdaUsable decrease.lAgdaDecreasing and usable?mAgdaHMatrix-shaped order is decreasing if any diagonal element is decreasing.nAgdaMultiplication of ^.s. (Corresponds to sequential composition.)7Agda collapse mWe assume that mD codes a permutation: each row has at most one column that is not Unknown.To collapse a matrix into a single value, we take the best value of each column and multiply them. That means if one column is all UnknownR, i.e., no argument relates to that parameter, then the collapsed value is also Unknown.,This makes order multiplication associative.7Agda'Can two matrices be multplied together?pAgda+The supremum of a (possibly empty) list of ^;s. More information (i.e., more decrease) is bigger. `# is no information, thus, smallest.7Agda(^, 7, n) forms a semiring, with ` as zero and Le as one.qAgda%The infimum of a (non empty) list of ^$s. Gets the worst information. `& is the least element, thus, dominant.7AgdaPick the worst information.rAgdaWe use a record for semiring instead of a type class since implicit arguments cannot occur in instance constraints, like +instance (?cutoff :: Int) => SemiRing Order.tAgdaInformation order: `M 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).vAgda/We assume the matrices have the same dimension.wAgdaIt does not get worse then ` increase'C. If we are still decreasing, it can get worse: less decreasing.\]^`_abcdefghijklmnopqr^`_aebcdnpqrhijfoklm\]gwNone"#$,14568=>?@ACEMPSX_` ?^{AgdaVSets of incomparable call matrices augmented with path information. Use overloaded , , R, 7.~Agda,Call matrix augmented with path information.Agda"The matrix of the (composed call).AgdaMeta info, like call path.Agda0Call matrix multiplication and call combination.AgdaCall 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:i (less than) if the j-th argument to the target; function is structurally strictly smaller than the i-th pattern.h (less than or equal) if the j-th argument to the target+ function is structurally smaller than the i-th pattern.j otherwise.Agda0Call matrix indices = function argument indices.Machine integer 7^ is sufficient, since we cannot index more arguments than we have addresses on our machine.AgdaNon-augmented call matrix.AgdaInsert into a call matrix set.AgdaUnion two call matrix sets.Agda/Convert into a list of augmented call matrices.AgdaCall matrix multiplication.f --(m1)--> g --(m2)--> h is combined to f --(m2 F 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).Agda%Augmented call matrix multiplication.Agda1Call matrix set product is the Cartesian product.{|}~~{|}xNone"#$,14568=>?@ACEMPSX_` ]~AgdagA call graph is a set of calls. Every call also has some associated meta information, which should be 7bal so that the meta information for different calls can be combined when the calls are combined.AgdaCalls are edges in the call graph. It can be labelled with several call matrices if there are several pathes from one function to another.AgdaCall graph nodes.Machine integer 7T is sufficient, since we cannot index more than we have addresses on our machine.Agda!Make a call with a single matrix.AgdaMake a call with empty cinfo.Agda@Returns all the nodes with incoming edges. Somewhat expensive. O(e).AgdaMConverts a call graph to a list of calls with associated meta information.AgdaMConverts a list of calls with associated meta information to a call graph.Agda#Takes the union of two call graphs.Agda!Inserts a call into a call graph.7AgdaCall graph combination.Application of  to all pairs (c1,c2) for which E c1 = F c2.)Agda"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.Agda?Displays the recursion behaviour corresponding to a call graph.Agda is a monoid under .Agda: checks whether the call graph is completely disconnected.FEEFyNone"#$,14568=>?@ACEPSX_` q;Agda2TODO: This comment seems to be partly out of date. cs( checks if the functions represented by cs terminate. The call graph cs should have one entry (&) per recursive function application.7R perms: is returned if the functions are size-change terminating.,If termination can not be established, then 7P 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).AgdaA call c! is idempotent if it is an endo (E == F) 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.zNone"#$,14568=>?@ACEPSX_` AgdaSometimes 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.AgdanIn the lexer, regular expressions are associated with lex actions who's task it is to construct the tokens.Agda#This is what the lexer manipulates.AgdaFile.AgdaCurrent position.AgdaCurrent input.AgdaPreviously read character.Agda A lens for .Agda,Get the previously lexed character. Same as L. Alex needs this to be defined to handle "patterns with a left-context".Agda,Returns the next character, and updates the  value.]This function is not suitable for use by Alex 2, because it can return non-ASCII characters.Agda'Returns the next byte, and updates the  value.A trick is used to handle the fact that there are more than 256 Unicode code points. The function translates characters to bytes in the following way:HWhitespace characters other than '\t' and '\n' are translated to ' '.8Non-ASCII alphabetical characters are translated to 'z'.;Other non-ASCII printable characters are translated to '+'.&Everything else is translated to '\1'.WNote that it is important that there are no keywords containing 'z', '+', ' ' or '\1'.*This function is used by Alex (version 3).AgdaConjunction of s.AgdaDisjunction of s.Agda Negation of s.{None"#$,14568=>?@ACEMPSX_` R AgdaIThe LookAhead monad is basically a state monad keeping with an extra , wrapped around the  & monad.Agda8Throw an error message according to the supplied method.Agda$Get the current look-ahead position.AgdaSet the look-ahead position.AgdaLift a computation in the  & monad to the  monad.AgdaBLook at the next character. Fails if there are no more characters.AgdaAConsume all the characters up to the current look-ahead position.Agda-Undo look-ahead. Restores the input from the  .Agda!Consume the next character. Does  followed by .AgdaDo 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.AgdaSame 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.AgdaRun a 7 computation. The first argument is the error function.  |None"#$,14568=>?@ACEPSX_` 9 AgdaALex a string literal. Assumes that a double quote has been lexed.AgdazLex 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.7AgdaCustom error function.7AgdamThe general function to lex a string or character literal token. The character argument is the delimiter (" for strings and ' for characters).7AgdaoThis is where the work happens. The string argument is an accumulating parameter for the string being lexed.7AgdaA string gap consists of whitespace (possibly including line breaks) enclosed in backslashes. The gap is not part of the resulting string.7AgdaLex a single character.7Agda?Lex an escaped character. Assumes the backslash has been lexed.7Agda$Read a number in the specified base.7AgdaSame as 7$ but with an accumulating parameter.7AgdaThe escape codes.None"#$,14568=>?@ACEPSX_` {Agda Should comment tokens be output?Agda Should comment tokens be output?Agda,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.Agda Lex a hole ( {! ... !}#). Holes can be nested. Returns  .AgdaSkip 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.None"#$,14568=>?@ACEFPSX_` Щ AgdaCThis is the initial state for parsing a regular, non-literate file.Agda8The 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.7AgdaThe state inside a pragma.7AgdayThe state inside a FOREIGN pragma. This needs to be different so that we don't lex further strings as pragma keywords.AgdaWe 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 . AgdaThis 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 . Agda]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. AgdaHReturn the next token. This is the function used by Happy in the parser.  lexer k =  >>= k7Agda&Do not use this function; it sets the   to 7. Agda3This is the main lexing function generated by Alex.           None"#$,14568=>?@ACEFPSX_`h (7AgdaParsed attribute.7AgdaRange includes the @.7Agda5Concrete, user written attribute for error reporting.7AgdaParsed attribute.Agda1Parse the token stream. Used by the TeX compiler.Agda3Parse an expression. Could be used in interactions.AgdaNParse an expression followed by a where clause. Could be used in interactions.AgdaParse a module.7AgdaRequired by Happy.7AgdaGrab leading OPTIONS pragmas.7AgdaInsert 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).7AgdaCreate a name from a string.7Agda.Create a qualified name from a list of strings7Agda'Create a DomainFree binding from a name7AgdaCreate a qualified name from a string (used in pragmas). Range of each name component is range of whole string. TODO: precise ranges!7AgdaPolarity parser.7AgdaMatch a particular name.7Agda'Build a forall pi (forall x y z -> ...)7Agda Builds a  from f and N list, unless the list is a single expression. In the latter case, just the  is returned.7Agda+Converts lambda bindings to typed bindings.7AgdaKInterpret an expression as a list of names and (not parsed yet) as-patterns7Agda0Match a pattern-matching "assignment" statement p <- e7AgdaBuild a with-block7AgdaBuild a with-statement7AgdaBuild a do-statement7Agda=Check that an import directive doesn't contain repeated namesAgdapBreaks up a string into substrings. Returns every maximal subsequence of zero or more characters distinct from 7l. splitOnDots "" == [""] splitOnDots "foo.bar" == ["foo", "bar"] splitOnDots ".foo.bar" == ["", "foo", "bar"] splitOnDots "foo.bar." == ["foo", "bar", ""] splitOnDots "foo..bar" == ["foo", "", "bar"]7AgdaReturns 77= iff the name is a valid Haskell (hierarchical) module name.7Agda)Turn an expression into a left hand side.7AgdaUTurn an expression into a pattern. Fails if the expression is not a valid pattern.7AgdaUTurn an expression into a name. Fails if the expression is not a valid identifier.7AgdaWhen given expression is e1 = e2L, turn it into a named expression. Call this inside an implicit argument {e} or {{e}}V, where an equality must be a named argument (rather than a cubical partial match).7AgdaParse an attribute.7Agda%Apply an attribute to thing (usually v). This will fail if one of the attributes is already set in the thing to something else than the default value.7Agda#Apply attributes to thing (usually ). Expects a reversed list of attributes. This will fail if one of the attributes is already set in the thing to something else than the default value.7Agda$Set the tactic attribute of a binder7Agda$Get the tactic attribute if present.7AgdarReport a parse error if two attributes in the list are of the same kind, thus, present conflicting information.7AgdaEReport an attribute as conflicting (e.g., with an already set value).7AgdaZReport attributes as conflicting (e.g., with each other). Precondition: List not emtpy.79 79 }None"#$,14568=>?@ACEPSX_` Agda<True if the given state appears somewhere on the state stackAgda&True if we are at the end of the file.AgdaHTrue when the given character is the next character of the input string.AgdaParse a literal.Agda7Parse an identifier. Identifiers can be qualified (see Name). Example:  Foo.Bar.fAgdaParse a  token.AgdaParse a  token, triggers layout for #.Agda8Exit the current state throwing away the current lexeme.Agda3Enter a new state throwing away the current lexeme.Agda4Exit the current state and perform the given action.Agda/Enter a new state and perform the given action.Agda.Enter a new state without consuming any input.Agda)Executed for layout keywords. Enters the ( state and performs the given action.AgdaLike ', but applies a function to the string.AgdaParse a token from an k and the lexed string.Agda(The most general way of parsing a token.Agda-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.7Agda%Called at the end of a file. Returns .7Agda1Set the current input and lex a new token (calls ).Agda3Return a token without looking at the lexed string.Agda2Exit the current state without consuming any input7AgdaParse a number.7Agda Parse a possibly qualified name. 9 9~None"#$,14568=>?@ACEPSX_` ;cAgda&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 ).AgdaJStart 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.Agda/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.Agda$Executed upon lexing an open brace ('{'). Enters the   context.Agda$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.7AgdaMCompute the relative position of a location to the current layout context.None"#$,14568=>?@ACEMPSX_` H" AgdaWrapped Parser type.Agda"A monad for handling parse results$Agda'Returns the contents of the given file.&AgdaExtensions supported by '.(AgdaParses a module.)AgdaParses a module name.*AgdaParses an expression.+Agda0Parses an expression followed by a where clause.,AgdaBParses an expression or some other content of an interaction hole.-Agda3Gives the parsed token stream (including comments).7Agda9Keep comments in the token stream generated by the lexer.7Agda@Do not keep comments in the token stream generated by the lexer.7AgdaThe path to the file.Agda)The file contents. Note that the file is not read from disk.'AgdaThe path to the file.Agda)The file contents. Note that the file is not read from disk.!             !"#$%&'()*+,-!#%'()&*+,-$             !"None"#$,124568=>?@ACEMPSX_`g3AgdaThe 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.:Agda2Suggest a name if available (i.e. name is not "_")<Agda#Constructing a singleton telescope.>Agda Drop the types from a telescope.AAgdaTelescope as list.IAgdaView type as path type.KAgdareducedLAgdaSort of this type.MAgda Builtin PATH.NAgdaHiddenOAgdaHiddenPAgda NotHiddenQAgda NotHiddenRAgdaView type as equality type.TAgdareducedUAgdaSort of this type.VAgdaBuiltin EQUALITY.WAgdaHidden. Empty or Level.XAgdaHiddenYAgda NotHiddenZAgda NotHidden]AgdaSubstitutions.^AgdaIdentity substitution.   " IdS : _AgdaDEmpty substitution, lifts from the empty context. First argument is  IMPOSSIBLEK. Apply this to closed terms you want to use in a non-empty context.  " EmptyS : ()`AgdaSubstitution extension, `cons'. S  " u : A  "  :  ----------------------  " u :#  : , A aAgda/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 bAgda9Weakening substitution, lifts to an extended context. I  "  :  ------------------- ,  " Wk ||  :  cAgda9Lifting substitution. Use this to go under a binder. Lift 1  == var 0 :# Wk 1 . X  "  :  ------------------------- ,  " Lift ||  : ,  dAgda7Extract pattern variables in left-to-right order. A u+ is also treated as variable (see docu for ).fAgdaThe ConPatternInfo= states whether the constructor belongs to a record type (True) or data type (False). In the former case, the  PatOrigin of the conPInfoc 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 ().hAgda)Information on the origin of the pattern.iAgdaFalse if data constructor. True if record constructor.jAgda[Should the match block on non-canonical terms or can it proceed to the catch-all clause?kAgdaAThe 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.lAgdaJLazy patterns are generated by the forcing translation in the unifier (f@) and are dropped by the clause compiler (TODO: not yet) (g) when the variables they bind are unused. The GHC backend compiles lazy matches to lazy patterns in Haskell (TODO: not yet).nAgda+Type used when numbering pattern variables.sAgda7Patterns 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.tAgda xuAgda .tvAgdac ps= The subpatterns do not contain any projection copatterns.wAgdaE.g. 5, "hello".xAgda1Projection copattern. Can only appear by itself.yAgdaPath elimination pattern, like VarP but keeps track of endpoints.zAgda:Used for HITs, the QName should be the one from primHComp.{Agda@Origin of the pattern: what did the user write in this position?|AgdaPattern inserted by the system}AgdaPattern generated by case split~AgdaUser wrote a variable patternAgdaUser wrote a dot patternAgdaUser wrote a wildcard patternAgda User wrote a constructor patternAgdaUser wrote a record patternAgdaUser wrote a literal patternAgdaUser wrote an absurd patternAgdaPattern variables.Agda3A clause is a list of patterns and the clause body. 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 telescope. <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!Agda9: The types of the pattern variables in dependency order.Agda " ps". The de Bruijn indices refer to .AgdaJust v with  " v for a regular clause, or Nothing for an absurd one.Agda " 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.Agda%Clause has been labelled as CATCHALL.Agda clauseBody? contains recursive calls; computed by termination checker. Nothing< means that termination checker has not run yet, or that  clauseBodyR contains meta-variables; these could be filled with recursive calls later!  Just False( means definitely no recursive call.  Just True# means definitely a recursive call.AgdaDClause has been labelled as unreachable by the coverage checker. NothingH means coverage checker has not run yet (clause may be unreachable).  Just False% means clause is not unreachable.  Just True means clause is unreachable.Agda4Was this clause created by expansion of an ellipsis?AgdaNamed pattern arguments.Agda t without the t.Agda4Something where a meta variable may block reduction.AgdaEven if we are not stuck on a meta during reduction we can fail to reduce a definition by pattern matching for another reason.AgdaThe ' is neutral and blocks a pattern match.Agda<Not enough arguments were supplied to complete the matching.Agda2We matched an absurd clause, results in a neutral .AgdaWe 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.AgdaRReduction was not blocked, we reached a whnf which can be anything but a stuck .AgdaiNewtypes for terms that produce a dummy, rather than crash, when applied to incompatible eliminations.AgdaAn atomic term of type Level.AgdaA meta variable targeting Level under some eliminations.AgdaA term of type Level& whose reduction is blocked by a meta.AgdaA neutral term of type Level.AgdaIntroduced by  instantiate , removed by reduce.Agdan + !.Agda>A level is a maximum expression of a closed level and 0..n 4 expressions each of which is an atom plus a number.AgdaSorts.AgdaSet !.AgdaProp !.AgdaSet.AgdaSizeUniv, a sort inhabited by type Size.AgdaSort of the pi type.Agda(Sort of a (non-dependent) function type.AgdaSort of another sort.AgdaA postulated sort.Agda^A (part of a) term or type which is only used for internal purposes. Replaces the abuse of Prop for a dummy sort. The Stringk typically describes the location where we create this dummy, but can contain other information as well.AgdaVSequence of types. An argument of the first type is bound in later types and so on.Agda is never .Agda'Types are terms with a sort annotation.AgdaBinder.2: 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.Agda6The body has (at least) one free variable. Danger: ! doesn't shift variables properlyAgda5Eliminations, subsuming applications and projections.Agda Application.Agda Projection.  ] is name of a record projection.Agda'IApply x y r, x and y are the endpointsAgda 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.Agdax es neutralAgda+Terms are beta normal. Relevance is ignoredAgdaf es, possibly a delta/iota-redexAgdac es or record { fs = es } esU allows only Apply and IApply eliminations, and IApply only for data constructors.Agda)dependent or non-dependent function spaceAgdaIrrelevant stuff in relevant position, but created in an irrelevant context. Basically, an internal version of the irrelevance axiom .irrAx : .A -> A.AgdaUA (part of a) term or type which is only used for internal purposes. Replaces the  Sort Prop hack. The String typically describes the location where we create this dummy, but can contain other information as well. The second field accumulates eliminations in case we apply a dummy term to more of them.AgdaStore the names of the record fields in the constructor. This allows reduction of projection redexes outside of TCM. For instance, during substitution and application.AgdaThe name of the constructor.Agda'Record constructors can be coinductive.AgdaGThe name of the record fields. Empty list for data constructors. n is stored since the info in the constructor args might not be accurate because of subtyping (issue #2170).AgdaType of argument lists.Agda 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  of internal syntax, in Context and .  is used for actual arguments (, ,  etc.) and in Abstract syntax and other situations.  cubical When domFinite = True for the domain of a  type, the elements should be compared by tabulating the domain type. Only supported in case the domain type is primIsOne, to obtain the correct equality for partial elements.Agdae.g. x in {x = y : A} -> B.Agda "@tactic e".AgdaConstant level nAgdaWhen 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). 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.4 must not be propagated, as this would mean that f esD is underapplied, which is not the case (it is stuck). Note that \ 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.) Agda6Make an absurd pattern with the given de Bruijn index. AgdaBuild partial f from  AgdaBuild  from f. Agda'Retrieve the PatternInfo from a patternAgda Retrieve the origin of a patternAgda1Does the pattern perform a match that could fail?AgdaQAbsurd lambdas are internally represented as identity with variable name "()".AgdaAn unapplied variable.AgdaAdd  is it is not already a DontCare.Agda,Aux: A dummy term to constitute a dummy termlevel sort/type.Agda.Aux: A dummy level to constitute a level/sort.Agda5A dummy term created at location. Note: use macro  DUMMY_TERM !Agda6A dummy level created at location. Note: use macro  DUMMY_LEVEL ! Agda5A dummy sort created at location. Note: use macro  DUMMY_SORT !"Agda5A dummy type created at location. Note: use macro  DUMMY_TYPE !$AgdaHContext entries without a type have this dummy type. Note: use macro  DUMMY_DOM !(AgdaTop sort (Setomega).,AgdaGiven a constant m and level l , compute m + l2Agda)A traversal for the names in a telescope.6Agda(Convert a list telescope to a telescope.7Agda%Convert a telescope to its list form.8AgdaLens to edit a  as a list.>AgdaRemoving a topmost  constructor.?AgdaDoesn't do any reduction.AAgda>Convert top-level postfix projections into prefix projections.BAgdaConvert / projection eliminations according to their  into  projection applications.CAgda#A view distinguishing the neutrals Var, Def, and MetaV which can be projected.DAgdaDrop  constructor. (Safe)FAgdaDrop  constructors. (Safe)GAgdaSplit at first non-HAgda Discards Proj f entries.IAgdaDrop  constructors. (Safe)VAgdaIgnores  and  and tactic.dAgdaThis instance cheats on , use with care. s are always assumed to be , since they have no . Same for IApplyjAgda2The size of a telescope is its length (as a list).{Agda is the unit.  is dominant. {}1 should be propagated, if tied, we take the left.AgdaBlocking by a meta is dominant.AgdaA L clause is one with no patterns and no rhs. Should not exist in practice.rAgdaThe  PatVarName is a name suggestion.Agda#eliminations ordered left-to-right.Agda-Should absurd patterns count as proper match?Agda1Should projection patterns count as proper match?Agda The pattern.Zz{| N O P Q R S T U V W X Y Z [ \ ] ^ ` _ a b c f d e g h i j k l m n o p q r s t u v w x y z { | } ~  3456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]c^_`abdefghijklmnopqrswtvuxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJK3456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]c^_`abdefghijklmnopqrswtvuxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKz{|`4None"#$,14568=>?@ACEPSX_`.AgdayThings we can substitute for a variable. Needs to be able to represent variables, e.g. for substituting under binders.Agda+Produce a variable without name suggestion.Agda(Produce a variable with name suggestion.Agda=Are we dealing with a variable? If yes, what is its index?AgdaWe can substitute Terms for variables.None"#$,14568=>?@ACEHPSVX_`0None"#$,14568=>?@ACEHMPSVX_`$. Agda&Gather free variables in a collection.AgdaThe current context.AgdaDAdditional context, e.g., whether to ignore free variables in sorts.AgdaAre we flexible or rigid?Agda+What is the current relevance and quantity?Agda#Method to return a single variable.Agda5Where should we skip sorts in free variable analysis?Agda Do not skip.AgdaSkip when annotation to a type.AgdaSkip unconditionally. AgdaKeep track of 07 for every variable, but forget the involved meta vars.&AgdaERepresentation of a variable set as map from de Bruijn indices to *.'AgdaAny representation c of a set of variables need to be able to be modified by a variable occurrence. This is to ensure that free variable analysis is compositional. For instance, it should be possible to compute `fv (v [u/x])` from `fv v` and `fv u`.)In algebraic terminology, a variable set a; needs to be (almost) a left semimodule to the semiring *.(Agda\Laws * Respects monoid operations: ``` withVarOcc o mempty == mempty withVarOcc o (x <> y) == withVarOcc o x <> withVarOcc o y ``` * Respects VarOcc composition: ``` withVarOcc oneVarOcc = id withVarOcc (composeVarOcc o1 o2) = withVarOcc o1 . withVarOcc o2 ``` * Respects VarOcc aggregation: ``` withVarOcc (o1 <> o2) x = withVarOcc o1 x <> withVarOcc o2 x ``` Since the corresponding unit law may fail, ``` withVarOcc mempty x = mempty ``` it is not quite a semimodule.*AgdaXOccurrence of free variables is classified by several dimensions. Currently, we have 0 and .1AgdaDepending 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).2Agda7In arguments of metas. The set of metas is used by 'h to generate the right blocking information. The semantics is that the status of a variable occurrence may change if one of the metas in the set gets solved. We may say the occurrence is tainted by the meta variables in the set.3Agda*In arguments to variables and definitions.4AgdaDIn top position, or only under inductive record constructors (unit).5Agda3Under at least one and only inductive constructors.6Agda5A set of meta variables. Forms a monoid under union.?Agda0 aggregation (additive operation of the semiring). For combining occurrences of the same variable in subterms. This is a refinement of the 7x operation for 0 which would work if 2 did not have the 6* as an argument. Now, to aggregate two 2$ occurrences, we union the involved 6s.@Agda Unit for ?.AAgdaAbsorptive for ?.BAgda0g composition (multiplicative operation of the semiring). For accumulating the context of a variable.2 is dominant. Once we are under a meta, we are flexible regardless what else comes. We taint all variable occurrences under a meta by this meta.30 is next in strength. Destroys strong rigidity.5 is still dominant over 4.40 is the unit. It is the top (identity) context.CAgda Unit for B.DAgda]The absorptive element of variable occurrence under aggregation: strongly rigid, relevant.EAgdaFirst argument is the outer occurrence (context) and second is the inner. This multiplicative operation is to modify an occurrence under a context.JAgdaIgnore free variables in sorts.KAgdaThe initial context.LAgdaRun function for FreeM.MAgdaBase case: a variable.NAgda3Subtract, but return Nothing if result is negative.OAgdaGoing under a binder.PAgda Going under n binders.QAgda Changing the .RAgda Changing the .SAgda Changing the 0 context.TAgda<What happens to the variables occurring under a constructor?XAgdaThe neutral element for variable occurrence aggregation is least serious occurrence: flexible, irrelevant. This is also the absorptive element for E, if we ignore the 6 in 2.YAgdaThe default way of aggregating free variable info from subterms is by adding the variable occurrences. For instance, if we have a pair (t ,t ) then and t  has o  the occurrences of a variable x and t  has o / the occurrences of the same variable, then (t ,t ) has  mappend o o  occurrences of that variable.From counting , we extrapolate this to 0 and : we care most about about 5  occurrences. E.g., if t  has a 5 occurrence and t  a 2 occurrence, then (t ,t ) still has a 5 occurrence. Analogously, Relevant{ occurrences count most, as we wish e.g. to forbid relevant occurrences of variables that are declared to be irrelevant.*C forms a semiring, and this monoid is the addition of the semiring.ZAgda Access to , in *.^AgdaEquality up to origin.aAgdaProper monoid instance for VarMapf rather than inheriting the broken one from IntMap. We combine two occurrences of a variable using 7.bAgdaA "set"-style Q3 instance with default/initial variable occurrence.gAgdaCompose everything with the , part of the *.I   !"#$%&'()*+-,./0154326789:;<=>?@ABCDEFGHIJKLMNOPQRSTI6789:154320./;<=>?@ABC*+-,)DEF'(&#$%"!GH IJKLMNOPQRST  None"#$,14568=>?@ACEMPSX_`)7Agda Collection? just keeping track of the occurrence of a single variable. 7>& means variable does not occur freely.7Agda Collection? just keeping track of the occurrence of a single variable. 7>& means variable does not occur freely.AgdaLCollect all free variables together with information about their occurrence.\Doesn't go inside solved metas, but collects the variables from a metavariable application X ts as  flexibleVars.AgdaCompute free variables.Agda7Get the full occurrence information of a free variable.Agda7Get the full occurrence information of a free variable.7Agda5Check if a variable is free, possibly ignoring sorts.Agda7Is the variable bound by the abstraction actually used?Agda0Is the term entirely closed (no free variables)?AgdaCollect all free variables.Agda=Collect all relevant free variables, possibly ignoring sorts.AgdaACollect all relevant free variables, excluding the "unused" ones.Agda?Variables under only and at least one inductive constructor(s).AgdaVariables 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.AgdaCRigid variables: either strongly rigid, unguarded, or weakly rigid.AgdaVariables occuring in arguments of metas. These are only potentially free, depending how the meta variable is instantiated. The set contains the id's of the meta variables that this variable is an argument to. flexibleVars :: VarMap -> IntMap MetaSet flexibleVars (VarMap m) = (7= m) $ case VarOcc (Flexible ms) _ -> Just ms _ -> NothingAgda"Hereditary Semigroup instance for 7<. (The default instance for 7< may not be the hereditary one.)Agda"Hereditary Semigroup instance for 7<. (The default instance for 7< may not be the hereditary one.)2  '()*+,-./01234569:;<=>2 '( 123450./;<>=*+,-)69:None"#$,14568=>?@ACEHPSVX_`ŐAgdaApply a substitution.Agda(abstract args v)  args --> v[args].AgdamApply something to a bunch of arguments. Preserves blocking tags (application can never resolve blocking).Agda Apply to some default arguments.Agda#Apply to a single default argument.Agda%Raise de Bruijn index, i.e. weakeningAgdaReplace de Bruijn index i by a  in something.AgdaBReplace what is now de Bruijn index 0, but go under n binders. %substUnder n u == subst n (raise n u).AgdaTo replace index n by term u, do applySubst (singletonS n u). l ,  " u : A --------------------------------- ,  " singletonS || u : , A,  Agda@Single substitution without disturbing any deBruijn indices. m , A,  " u : A --------------------------------- , A,  " inplace || u : , A,  Agda$Lift a substitution under k binders.Agda I  "  : ,  -------------------  " dropS ||  :  Agda applySubst ( & ) v == applySubst  (applySubst  v)Agda   "  :   " reverse vs :  ----------------------------- (treating Nothing as having any type)  " prependS vs  : ,  Agda " (strengthenS " ||) : ,AgdaBlookupS (listS [(x0,t0)..(xn,tn)]) xi = ti, assuming x0 < .. < xn.Agda/Instantiate an abstraction. Strict in the term.AgdaFInstantiate 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.Agda9Instantiate an abstraction that doesn't use its argument.AgdaunderAbs 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.AgdaunderLambdas 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.''4None"#$,14568=>?@ACEPSX_`))None"#$,14568=>?@ACEHPSVX_`o AgdaGeneric term traversal.ONote: ignores sorts in terms! (Does not traverse into or collect from them.)Agda?Generic traversal with post-traversal action. Ignores sorts.AgdaGeneric fold, ignoring sorts.Agda5Put it in a monad to make it possible to do strictly.  None"#$,124568=>?@ACEPSX_`*AgdaCase tree with bodies.+Agda 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 1 with arity 0.,Agda 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.-Agda Absurd case..AgdaBranches in a case tree.0Agda3We are constructing a record here (copatterns). 1 lists projections.1AgdaoMap from constructor (or projection) names to their arity and the case subtree. (Projections have arity 0.)2Agda~Eta-expand with the given (eta record) constructor. If this is present, there should not be any conBranches or litBranches.3Agda!Map from literal to case subtree.4Agda'(Possibly additional) catch-all clause.5Agda?(if True) In case of non-canonical argument use catchAllBranch.6AgdadLazy pattern match. Requires single (non-copattern) branch with no lit branches and no catch-all.@AgdaqCheck that the requirements on lazy matching (single inductive case) are met, and set lazy to False otherwise.AAgda1Check whether a case tree has a catch-all clause.BAgda5Check whether a case tree has any projection patterns)*+,-./654321078:9;<=>?@ABC78:9./6543210*+,-);<=>?@ABCNone"#$,14568=>?@ACEPSX_`aAgdaOReturns every meta-variable occurrence in the given type, except for those in s.bAgdaReturns a in a list. allMetasList = allMetas (:[]).Note: this resulting list is computed via difference lists. Thus, use this function if you actually need the whole list of metas. Otherwise, use a with a suitable monoid.cAgda77 if thing contains no metas. noMetas = null . allMetasList.dAgda8Returns the first meta it find in the thing, if any. 'firstMeta == listToMaybe . allMetasList.abcdabcdNone"#$,14568=>?@ACEHPSVX_`eAgdaGetting the used definitions.Note: in contrast to i getDefsF also collects from sorts in terms. Thus, this is not an instance of foldTerm.gAgda*What it takes to get the used definitions.nAgdaInputs to and outputs of getDefs' are organized as a monad.oAgdagetDefs' 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. efgihjkmlno onjkmlgihefNone"#$,124568=>?@ACEMPSX_`wsAgda,Parameterised over the type of dot patterns.AgdaDestructor pattern d.Agda%Defined pattern: function definition f psw. It is also abused to convert destructor patterns into concrete syntax thus, we put AmbiguousQName here as well.Agda\Underscore pattern entered by user. Or generated at type checking for implicit arguments.Agda Dot pattern .eAgda| p, for with-patterns.AgdaXThe lhs in projection-application and with-pattern view. Parameterised over the type e of dot patterns.Agda&The head applied to ordinary patterns.Agda Projection.AgdaWith patterns.AgdaHead f.AgdaApplied to patterns ps.AgdaRecord projection identifier.AgdaMain argument of projection.Agda E.g. the .AgdaApplied to with patterns | p1 | ... | pn*. These patterns are not prefixed with WithP!AgdatThe lhs of a clause in focused (projection-application) view (outside-in). Projection patters are represented as s.AgdaRange.Agda Copatterns.AgdaXThe lhs of a clause in spine view (inside-out). Projection patterns are contained in  spLhsPats, represented as ProjP d.AgdaRange.Agda!Name of function we are defining.Agda3Elimination by pattern, projections, with-patterns.AgdaThe  ]" is the name of the with function.AgdasWe store the original concrete expression in case we have to reproduce it during interactive case splitting. 7> for internally generated rhss.AgdaThe  ]As are the names of the generated with functions, one for each .AgdacThe patterns stripped by with-desugaring. These are only present if this rewrite follows a with.AgdaThe RHS should not be another  RewriteRHS.Agda&The where clauses are attached to the  RewriteRHS byAgdaWe 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.AgdaOnly in with-clauses where we inherit some already checked patterns from the parent. These live in the context of the parent clause left-hand side.AgdaA user pattern together with an internal term that it should be equal to after splitting is complete. Special cases: * User pattern is a variable but internal term isn't: this will be turned into an as pattern. * User pattern is a dot pattern: this pattern won't trigger any splitting but will be checked for equality after all splitting is complete and as patterns have been bound. * User pattern is an absurd pattern: emptiness of the type will be checked after splitting is complete.AgdauWe don't yet know the position of generalized parameters from the data sig, so we keep these in a set on the side.AgdajMaps generalize variables to the corresponding bound variable (to be introduced by the generalisation).AgdaA 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.AgdaAs in telescope  (x y z : A) or type (x y z : A) -> B.AgdaE.g.  (let x = e) or  (let open M).Agda0A lambda binding is either domain free or typed.Agda. x or {x} or .x or {x = y} or x@p or (p)Agda. (xs:e) or {xs:e} or (let Ds)AgdaOnly  s.AgdaBindings that are valid in a let.Agda LetBind info rel name type defnAgdaIrrefutable pattern binding.Agda*LetApply mi newM (oldM args) renamings dir. The ImportDirective is for highlighting purposes.Agda,only for highlighting and abstractToConcreteAgda?Only used for highlighting. Refers to the first occurrence of x in let x : A; x = e(. | LetGeneralize DefInfo ArgInfo ExprAgda is not :. Name can be ambiguous e.g. for built-in constructors.AgdaWBuiltins that do not come with a definition, but declare a name for an Agda concept.Agda"Range is range of REWRITE keyword.Agda:For coinductive records, use pragma instead of regular  eta-equality, definition (as it is might make Agda loop).Agda tel. M args : applies M to args and abstracts tel.Agda  M {{...}}Agda3Type signature (can be irrelevant, but not hidden).PThe fourth argument contains an optional assignment of polarities to arguments.AgdaBFirst argument is set of generalizable variables used in the type.Agda record fieldAgdaprimitive functionAgda)a bunch of mutually recursive definitionsAgdaThe ImportDirective is for highlighting purposes.AgdaThe ImportDirective is for highlighting purposes.Agda'only retained for highlighting purposesAgdasequence of function clausesAgdalone data signatureAgdathe s are ) and bind the parameters of the datatype.Agdalone record signatureAgdaThe s are 1 and bind the parameters of the datatype. The ' gives the constructor type telescope, (x1 : A1)..(xn : An) -> Prop5, and the optional name is the constructor's name.AgdaOnly for highlighting purposesAgdascope annotation AgdaRenaming (generic). AgdaIs a type signature a  postulate or a function signature?AgdaA function signature.AgdayNot a function signature, i.e., a postulate (in user input) or another (e.g. data/record) type signature (internally).AgdaRecord field assignment f = e.AgdaDExpressions after scope checking (operators parsed, names resolved).AgdaBound variable.Agda/Constant: axiom, function, data or record type.AgdaProjection (overloaded).AgdaConstructor (overloaded).AgdaPattern synonym.AgdaMacro.AgdaLiteral.Agda&Meta variable for interaction. The n" 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 7> while keeping the n.Agda=Meta variable for hidden argument (must be inferred locally).Agda.e, for postfix projection.AgdaOrdinary (binary) application. AgdaWith application.!Agda bs ! e."Agda() or {}.$AgdaDependent function space  ! A.%Agda(Like a Pi, but the ordering is not known&AgdaNon-dependent function space.'AgdaSet, Set1, Set2, ...(AgdaProp, Prop1, Prop2, ...)Agda let bs in e.*Agda#Only used when printing telescopes.+AgdaRecord construction.,AgdaRecord update.-AgdaScope annotation..AgdaQuote an identifier  ]./Agda Quote a term.0Agda#The splicing construct: unquote ...1Agda tactic e x1 .. xn2Agda For printing DontCare from Syntax.Internal.4AgdahA name in a binding position: we also compare the nameConcrete when comparing the binders for equality.With  --caching on we compare abstract syntax to determine if we can reuse previous typechecking results: during that comparison two names can have the same nameId but be semantically different, e.g. in  {_ : A} -> .. vs.  {r : A} -> ...8Agda!Smart constructor for GeneralizedfAgdaDoes not compare  fields.gAgdaDoes not compare H fields. Does not distinguish between prefix and postfix projections.iAgdaIgnore f when comparing s.jAgdaIgnore  when comparing s.AgdaTurn a name into an expression.AgdaAre we in an abstract block?)In that case some definition is abstract.Agda/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.Agda$The name defined by the given axiom.3Precondition: The declaration has to be a (scoped)  .AgdaTurn a  into an expression.Assumes name is not .AgdaTurn an  into an expression. N O P Q R S T U V W X Y Z [ \ ] ^ ` _ a b c f d e g h i j k l m n o p q r s t u v w x y z { | } ~       &'.0)(!$ "#+,*/12%-3456789:;<=>?@     &'.0)(!$ "#+,*/12%-3456789:;<=>?@ N O P Q R S T U V W X Y Z [ \ ] ^ ` _ a b c f d e g h i j k l m n o p q r s t u v w x y z { | } ~  None"#$,14568=>?@ACEHPSVX_`Agda<Get the list of pattern variables annotated with modalities.AgdaGeneric pattern traversal.KPre-applies a pattern modification, recurses, and post-applies another one.Agda Fold pattern.AgdaTraverse pattern.AgdayLabel the pattern variables from left to right using one label for each variable pattern and one for each dot pattern.AgdaJIntended, but unpractical due to the absence of type-level lambda, is: @labelPatVars :: f (Pattern' x) -> State [i] (f (Pattern' (i,x)))Agda+Arity of a function, computed from clauses.Agda\Translate the clause patterns to terms with free variables bound by the clause telescope.%Precondition: no projection patterns.AgdakTranslate the clause patterns to an elimination spine with free variables bound by the clause telescope.Agda5Augment pattern variables with their de Bruijn index. AgdaOComputes the permutation from the clause telescope to the pattern variables.Use as  fromMaybe  IMPOSSIBLE . dbPatPermK to crash in a controlled way if a de Bruijn index is out of scope here.OThe first argument controls whether dot patterns counts as variables or not. AgdaOComputes the permutation from the clause telescope to the pattern variables.Use as  fromMaybe  IMPOSSIBLE . clausePermK to crash in a controlled way if a de Bruijn index is out of scope here. AgdaTurn a pattern into a term. Projection patterns are turned into projection eliminations, other patterns into apply elimination.AgdaFCompute from each subpattern a value and collect them all in a monoid.AgdaETraverse pattern(s) with a modification before the recursive descent.AgdaDTraverse pattern(s) with a modification after the recursive descent.Agda!Get the number of common initial  patterns in a list of clauses.AgdaGet the number of initial  patterns in a clause.AgdaGet the number of initial  patterns.AgdaModify the content of VarP, and the closest surrounding NamedArg. Note: the  mapNamedArg for Pattern'! is not expressible simply by fmap or traverse etc., since ConP has NamedArg1 subpatterns, which are taken into account by  mapNamedArg.Agda>Combine a pattern and the value computed from its subpatterns.Agdapre : Modification before recursion.Agdapost: Modification after recursion.Agdapre : Modification before recursion.Agdapost: Modification after recursion.          None"#$&',14568=>?@ACEPSX_`b(AgdaIApply an expression rewriting to every subexpression, inside-out. See Agda.Syntax.Internal.Generic.)AgdaEThe first expression is pre-traversal, the second one post-traversal.-AgdaCollects plain lambdas.2Agda-Gather applications to expose head and spine.ENote: everything is an application, possibly of itself to 0 arguments7AgdaGather top-level %atterns to expose underlying pattern.8Agda-Check whether we are dealing with a universe.9Agda Remove top - wrappers.:AgdaRemove - wrappers everywhere.!NB: Unless the implementation of (F for clauses has been finished, this does not work for clauses yet.()*+,-./0123456789:;<01/2345-.6789:;<()*+,None"#$,14568=>?@ACEPSX_`2ZAgdaMerge a list of pattern synonym definitions. Fails unless all definitions have the same shape (i.e. equal up to renaming of variables and constructor names).[Agda.Match an expression against a pattern synonym.\Agda*Match a pattern against a pattern synonym.Z[\[\ZNone"#$,14568=>?@ACEHPSVX_`]Agda-Convert a focused lhs to spine view and back.`AgdaThe next patterns are ...(This view discards .)aAgda&Application patterns (non-empty list).bAgda6A projection pattern. Is also stored unmodified here.cAgdaHWith patterns (non-empty list). These patterns are not prefixed with .dAgdaGeneric pattern traversal.eAgda Fold pattern.fAgdaTraverse pattern.jAgdaFCompute from each subpattern a value and collect them all in a monoid.kAgdaETraverse pattern(s) with a modification before the recursive descent.lAgdaDTraverse pattern(s) with a modification after the recursive descent.mAgda?Map pattern(s) with a modification after the recursive descent.nAgda9Collect pattern variables in left-to-right textual order.oAgda4Check if a pattern contains a specific (sub)pattern.pAgda@Check if a pattern contains an absurd pattern. For instance, suc () , does so.+Precondition: contains no pattern synonyms.qAgda)Check if a pattern contains an @-pattern.+Precondition: contains no pattern synonyms.rAgdajCheck if any user-written pattern variables occur more than once, and throw the given error if they do.sAgdaPattern substitution.gFor the embedded expression, the given pattern substitution is turned into an expression substitution.tAgdaUPattern substitution, parametrized by substitution function for embedded expressions.uAgda7Split patterns into (patterns, trailing with-patterns).vAgda1Get the tail of with-patterns of a pattern spine.wAgdaConstruct the `" of the given list (if not empty).+Return the view and the remaining patterns.zAgdaKAdd applicative patterns (non-projection / non-with patterns) to the right.{AgdaAdd with-patterns to the right.}Agda<Add projection, with, and applicative patterns to the right.~Agda$Used for checking pattern linearity.Agda Used in 'jk. Returns a .AgdaCheck for with-pattern.Agda LHS instance.AgdaList instance (for clauses).AgdaClause instance.eAgda>Combine a pattern and the value computed from its subpatterns.fAgdapre : Modification before recursion.Agdapost: Modification after recursion.kAgdapre : Modification before recursion.lAgdapost: Modification after recursion.tAgda&Substitution function for expressions.Agda(Parallel) substitution.AgdaInput pattern.$]_^`bcadfeghijklmnopqrstuvwxyz{|}~$ighdfejklmnopqrstuv`bcaw]_^xyz{|}~None!"#$&',-.14568=>?@ACEHPSUVX_`Agda Currying as b# witnesses the isomorphism between  Arrows as b and Products as -> bO. It is defined as a type class rather than by recursion on a singleton for asX so all of that these conversions are inlined at compile time for concrete arguments.AgdaUsing IsBase we can define notions of Domains and  CoDomains. which *reduce* under positive information IsBase t ~ 'True even though the shape of t is not formally exposedAgdaIsBase t is 'True whenever t is *not* a function space.AgdaArrows [a1,..,an] r corresponds to a1 -> .. -> an -> r | Products [a1,..,an] corresponds to (a1, (..,( an, ())..))Agda Version of FoldrV taking a defunctionalised argument so that we can use partially applied functions.AgdaOn ListsAgda On BooleansAgdaAll p as ensures that the constraint p is satisfied by all the types in asZ. (Types is between scare-quotes here because the code is actually kind polymorphic)Safe"#$&',.14568=>?@ACEHPSX_`Agda]A known boolean is one we can obtain a singleton for. Concrete values are trivially known.Agda"Singleton for type level booleans.None"#$,14568=>?@ACEMPSX_`HAgdaLike  Bifunctor, but preserving sharing.AgdaLike 7, but preserving sharing.AgdaThe ChangeT monad transformer.AgdaThe class of change monads.AgdaRun a 0 computation, returning result plus change flag.7AgdaRun a % computation, but ignore change flag.AgdaMap a ( computation (monad transformer action).AgdaBlindly run an updater.AgdaRun a 0 computation, returning result plus change flag.AgdaBlindly run an updater.AgdaMark a computation as dirty.AgdaFReplace result of updating with original input if nothing has changed.7AgdaEval an updater (using ).Agda8A mock change monad. Always assume change has happened.Agda = sharing . updater1Agda-Mark computation as having changed something.None"#$&',124568=>?@ACEMPSX_`fuQ7AgdaMake a declaration private.*Andreas, 2012-11-17: Mark computation as v if there was a declaration that could be privatized. If no privatization is taking place, we want to complain about ."Alternatively, we could only flag 6 if a non-private thing was privatized. Then, nested private+s would sometimes also be complained about.7AgdaMake a declaration abstract.Mark computation as w if there was a declaration that could be made abstract. If no abstraction is taking place, we want to complain about ."Alternatively, we could only flag 7 if a non-abstract thing was abstracted. Then, nested abstract+s would sometimes also be complained about.7AgdaNicifier state.7Agda4Lone type signatures that wait for their definition.7Agda5Termination checking pragma waiting for a definition.7Agda4Positivity checking pragma waiting for a definition.8AgdaHUniverse checking pragma waiting for a data/rec signature or definition.8Agda.Catchall pragma waiting for a function clause.8Agda)Coverage pragma waiting for a definition.8Agda(Stack of warnings. Head is last warning.AgdaANicifier monad. Preserve the state when throwing an exception.8Agda$The kind of the forward declaration.8AgdaName of a data type8AgdaName of a record type8AgdaName of a function.8Agdawe are nicifying a mutual block8 Agda,we are nicifying decls not in a mutual block8 AgdaQSeveral declarations expect only type signatures as sub-declarations. These are:8 Agda  postulate8 Agda primitive. Ensured by parser.8 AgdainstanceE. Actually, here all kinds of sub-declarations are allowed a priori.8Agdafield. Ensured by parser.8Agdadata ... where=. Here we got a bad error message for Agda-2.5 (Issue 1698).Agda-Non-fatal errors encountered in the Nicifier.AgdaEmpty abstract block.AgdaEmpty field block.AgdaEmpty variable block.AgdaEmpty instance blockAgdaEmpty macro block.AgdaEmpty mutual block.AgdaEmpty  postulate block.AgdaEmpty private block.AgdaEmpty  primitive block.AgdaEA {-# CATCHALL #-} pragma that does not precede a function clause.AgdaBA {-# NON_COVERING #-} pragma that does not apply to any function.AgdaWA {-# NO_POSITIVITY_CHECK #-} pragma that does not apply to any data or record type.AgdaSA {-# NO_UNIVERSE_CHECK #-} pragma that does not apply to a data or record type.Agda`A {-# TERMINATING #-} and {-# NON_TERMINATING #-} pragma that does not apply to any function.Agda9Declarations (e.g. type signatures) without a definition.Agdaprivate has no effect on  open public!. (But the user might think so.)Agdaabstract has no effect on  open public!. (But the user might think so.)AgdaPragma {-# NO_TERMINATION_CHECK #-} has been replaced by {-# TERMINATING #-} and {-# NON_TERMINATING #-}.AgdaCOMPILE% pragmas are not allowed in safe modeAgdaabstract6 block with nothing that can (newly) be made abstract.Agdainstance8 block with nothing that can (newly) become an instance.Agdaprivate5 block with nothing that can (newly) be made private.AgdaThe exception type.Agda7in a mutual block, a clause could belong to any of the [Name] type signaturesAgdaRIn a mutual block, all or none need a MEASURE pragma. Range is of mutual block.AgdaDOne clause in a function definition. There is no guarantee that the  actually declares the  #. We will have to check that later.AgdaOnly s.AgdaOnly s.Agda1Termination measure is, for now, a variable name.AgdaThe 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. Observe the order of components:oRange Fixity' Access IsAbstract IsInstance TerminationCheck PositivityCheckfurther attributes(Q)Namecontent (Expr, Declaration ...)Agda: argument: We record whether a declaration was made in an abstract block.@ argument: Axioms and functions can be declared irrelevant. (  should be  .)AgdaAn uncategorized function clause, could be a function clause without type signature or a pattern lhs (e.g. for irrefutable let). The T is the actual Y.AgdaKBlock of function clauses (we have seen the type signature before). The TAs are the original declarations that were processed into this  and are only used in notSoNiceDeclaration9. Andreas, 2017-01-01: Because of issue #2372, we add 6 here. An alias should know that it is an instance.Agda(Nicifier warnings turned into errors in --safe mode.8AgdaCheck that declarations in a mutual block are consistently equipped with MEASURE pragmas, or whether there is a NO_TERMINATION_CHECK pragma.AgdaSRun a Nicifier computation, return result and warnings (in chronological order).8AgdaInitial nicifier state.8AgdaLens for field 7.8Agda%Adding a lone signature to the state.8Agda'Remove a lone signature from the state.8Agda"Search for forward type signature.8Agda4Check that no lone signatures are left in the state.8AgdaBEnsure that all forward declarations have been given a definition.8Agda&Get names of lone function signatures.8Agda Create a 8 map from an association list.8AgdaLens for field 7.8AgdaLens for field 7.8AgdaLens for field 8.8AgdaDGet universe check pragma from a data/rec signature. Defaults to :.8AgdaLens for field 8.8 Agda>Get current catchall pragma, and reset it for the next clause.8!AgdaAdd a new warning.8"Agda Replace (DataRecYFun)Sigs with Axioms for postulated names The first argument is a list of axioms only.AgdadMain. Fixities (or more precisely syntax declarations) are needed when grouping function clauses.Agda(Approximately) convert a  back to a list of Ts. AgdaHas the  a field of type ?)AgdaContents of a where& clause are abstract if the parent is.8#Agda(Stack of warnings. Head is last warning.8AgdaWe retain the   also in the codomain since   as a key is up to Eq Name which ignores the range. However, without range names are not unique in case the user gives a second definition of the same name. This causes then problems in 8", which might replace the wrong signature.8"Agda(Lone signatures to be turned into AxiomsAgdaDeclarations containing themAgda+In the output, everything should be definedJ      J       Safe"#$,14568=>?@ACEPSX_`i !"#$IJI#" !$JNone"#$,14568=>?@ACEPSX_`5LAgda e.g. x + 5MAgdaa number or infinityNAgdabA solution assigns to each flexible variable a size expression which is either a constant or a v + n for a rigid variable v.OAgda"A matrix with row descriptions in b and column descriptions in c.TAgda6The Graph Monad, for constructing a graph iteratively.WAgdaScope for each flexible var.XAgdaNode labels to node numbers.YAgdaNode numbers to node labels.ZAgdaNumber of nodes n.[AgdaThe edges (restrict to [0..n[).]Agda%A constraint is an edge in the graph._AgdaFor  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.`Agda3Which rigid variables a flex may be instatiated to.gAgdaQNodes 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).jAgda.Edge weight in the graph, forming a semi ring.pAgdaAWarshall's algorithm on a graph represented as an adjacency list.sAgdaisBelow 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.uAgdaEThe empty graph: no nodes, edges are all undefined (infinity weight).vAgdaAdd a size meta node.wAgdaBLookup identifier of a node. If not present, it is added first.xAgdaaddEdge n1 k n2 improves the weight of egde n1->n2 to be at most k(. Also adds nodes if not yet present.~Agda sizeRigid r n. returns the size expression corresponding to r + n5KMLNOPSRQTUVZYWX[\]_^`abcdfegihjklmnopqrstuvwxyz{|}~5nompjklqgihdfecba`rs]_^\tUVZYWX[uTvwxyz{OPSRQN|}KML~Safe"#$,.14568=>?@ACEHPSX_`Safe"#$,14568=>?@ACEHPSVX_`  lSafe"#$,14568=>?@ACEPSX_`W8$8%8&8'8(8)8*8+Safe"#$,14568=>?@ACEPSX_`AgdaThe version of Agda.None"#$,14568=>?@ACEPSX_`Agda?Information about current git commit, generated at compile timeNone"#$,124568=>?@ACEPSX_`9"AgdaThrows V exceptions, still collects s.8,Agda Collects 8-s and s.8.Agda0Collected errors while processing library files.8/AgdaFRaised when a library name could no successfully be resolved to an  .agda-lib file.80Agda1Raised when a library name is defined in several .agda-lib files.81AgdaGeneric error.AgdaName of  libraries fileAgdaLine number in  libraries file.Agda Library fileAgdaYLibrary names are structured into the base name and a suffix of version numbers, e.g.  mylib-1.2.3". The version suffix is optional.AgdaActual library name.AgdaMajor version, minor version, subminor version, etc., all non-negative. Note: a priori, there is no reason why the version numbers should be Ints.82AgdaE.g. ~.agda libraries.83Agda_The libraries file might not exist, but we may print its assumed location in error messages.84AgdaRaise collected  LibErrors as exception.85AgdaGet the path to ~/.agda1 (system-specific). Can be overwritten by the AGDA_DIR environment variable.s(This is not to be confused with the directory for the data files that Agda needs (e.g. the primitive modules).)86AgdaThe ~.agda librariesD file lists the libraries Agda should know about. The content of  libraries is is a list of pathes to  .agda-lib files."Agda honors also version specific  libraries files, e.g. libraries-2.6.0.defaultLibraryFiles gives a list of all  libraries) files Agda should process by default.87AgdaThe  defaultsFileA contains a list of library names relevant for each Agda project.88Agda!Find project root by looking for  .agda-lib files.EIf there are none, look in the parent directories until one is found.AgdaGet project root89AgdaGet pathes of  .agda-lib files in given project root.Agda:Get dependencies and include paths for given project root: Look for  .agda-lib files according to 89?. If none are found, use default dependencies (according to defaults/ file) and current directory (project root).8:Agda/Return list of libraries to be used by default. None if the defaults file does not exist.8;AgdaReturns the path of the  libraries1 file which lists the libraries Agda knows about.Note: file may not exist.Agda9Parse the descriptions of the libraries Agda knows about.Returns none if there is no  libraries file.8<AgdaParse the given library files.8=Agda.Remove trailing white space and line comments.Agda6Get all include pathes for a list of libraries to use.8>AgdafindLib x libs retrieves the matches for x from list libs. Case x is unversioned: If x is contained in libsi, then that match is returned. Otherwise, the matches with the highest version number are returned.Case xH is versioned: the matches with the highest version number are returned.Examples, see .AgdaGeneralized version of 8> for testing. DfindLib' id "a" [ "a-1", "a-02", "a-2", "b" ] == [ "a-02", "a-2" ] findLib' id "a" [ "a", "a-1", "a-01", "a-2", "b" ] == [ "a" ] findLib' id "a-1" [ "a", "a-1", "a-01", "a-2", "b" ] == [ "a-1", "a-01" ] findLib' id "a-2" [ "a", "a-1", "a-01", "a-2", "b" ] == [ "a-2" ] findLib' id "c" [ "a", "a-1", "a-01", "a-2", "b" ] == []8?Agdax 8? y if x and y have the same vvBase and either x5 has no version qualifier or the versions also match.AgdaASplit a library name into basename and a list of version numbers. sversionView "foo-1.2.3" == VersionView "foo" [1, 2, 3] versionView "foo-01.002.3" == VersionView "foo" [1, 2, 3]$Note that because of leading zeros,  versionView is not injective. (unVersionView . versionView would produce a normal form.)AgdaPrint a  VersionView , inverse of  versionView (modulo leading zeros).8@Agda Pretty-print 8-.88Agda2Candidate (init: the directory Agda was called in)AgdaActual root and  .agda-lib files for this project89Agda Project root.Agda Pathes of  .agda-lib! files for this project (if any).Agda Project root.AgdaUse defaults if no  .agda-lib file exists for this project?Agda The returned LibNames are all non-empty strings.8;AgdaOverride the default  libraries file?AgdaOverride the default  libraries file?Agda-Content of library files. (Might have empty LibNames.)8<AgdaName of  libraries file for error reporting.Agda/Library files paired with their line number in  libraries.Agda-Content of library files. (Might have empty LibNames.)Agda libraries file (error reporting only).AgdaLibraries Agda knows about.Agda>(Non-empty) library names to be resolved to (lists of) pathes.Agda2Resolved pathes (no duplicates). Contains "." if  [LibName] does.None"#$,.14568=>?@ACEPSX_`,Agdaf :: 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 recordAgdaThe 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.Agda%Options which can be set in a pragma.AgdaICut off structural order comparison at some depth in termination checker?Agda+irrelevant levels, irrelevant data matchingAgda(Allow definitions by copattern matching?Agda0Is pattern matching allowed in the current file?Agda2Perform the forcing analysis on data constructors?Agda6Perform the projection-likeness analysis on functions?Agda$Can rewrite rules be added and used?Agda$Should system generated projections  ProjSystem0 be printed postfix (True) or prefix (False).AgdafShould case splitting replace variables with dot patterns (False) or keep them as variables (True).Agda:Should conversion checker use syntactic equality shortcut?Agda1Should conversion checker compare sorts of types?AgdaPCount extended grapheme clusters rather than code points when generating LaTeX.AgdaSAutomatic compile-time inlining for simple definitions (unless marked NOINLINE).Agda+Use the Agda abstract machine (fastReduce)?Agda"Check confluence of rewrite rules?Agda)Can we split on a (x :{flat} A) argument?Agda-Use this (if Just) instead of .agda/librariesAgdaUse ~.agdadefaultsAgdalook for .agda-lib files Agda2In the absence of a path the project root is used.AgdaKShould the top-level module only be scope-checked, and not type-checked?Agda(Use the compiler at PATH instead of ghc  js  etc."AgdaMap a function over the long options. Also removes the short options. Will be used to add the plugin name to the plugin options.'AgdaThe default termination depth.8AAgda'The default output directory for LaTeX.8BAgda&The default output directory for HTML.)Agda-Checks that the given options are consistent.*Agda<Check for unsafe pragmas. Gives a list of used unsafe flags.+AgdaIf any these options have changed, then the file will be rechecked. Boolean options are negated to mention non-default options, where possible.,AgdawAn infective option is an option that if used in one module, must be used in all modules that depend on this module.-AgdayA coinfective option is an option that if used in one module, must be used in all modules that this module depends on.8CAgda#Defined locally here since module 'm has cyclic dependency.1AgdaCommand line options of previous versions of Agda. Should not be listed in the usage info, put parsed by GetOpt for good error messaging.8DAgdaPragma options of previous versions of Agda. Should not be listed in the usage info, put parsed by GetOpt for good error messaging.2AgdaCUsed for printing usage info. Does not include the dead options.3AgdagSimple interface for System.Console.GetOpt Could be moved to Agda.Utils.Options (does not exist yet)4Agda%Parse options from an options pragma.5AgdaParse options for a plugin.6AgdaLThe usage info message. The argument is the program name (probably agda).7Agda+Removes RTS options from a list of options.8Agda_Returns the absolute default lib dir. This directory is used to store the Primitive.agda file.3Agdacommand line argument wordsAgdaoptions handlersAgda,handler of non-options (only one is allowed)Agda(combined opts data structure transformer4AgdaPragma options.Agda-Command-line options which should be updated.|       !"#$%&'()*+,-./012345678|     ( ! )457%$#'&2*+,-/"68.013MNone"#$,124568=>?@ACEHMPSVX_`\W Agda+Polarity for equality and subtype checking. AgdaDMaps top-level module names to the corresponding source file names. AgdaType checking monad. Agda4The type checking monad transformer. Adds readonly   and mutable  . Agda;How much highlighting should be sent to the user interface? Agda6How should highlighting be sent to the user interface? Agda8For printing, we couple a meta with its name suggestion. AgdaType-checking errors. !AgdazA non-fatal error is an error which does not prevent us from checking the document further and interacting with the user.?AgdaEmbedding a TCM computation.AAgdaInteraction monad.BAgda MonadTCStateE made into its own dedicated service class. This allows us to use 8E for 8F extensions of TCM.FAgda MonadTCEnvE made into its own dedicated service class. This allows us to use 7E for 8G extensions of TCM.NAgda Environment of the reduce monad.PAgda Read only access to environment.QAgda0Read only access to state (signature, metas...).SAgda9Returns the pragma options which are currently in effect.TAgda?Returns the command line options which are currently in effect.WAgda?The first argument is the state in which the error was raised.XAgda\The exception which is usually caught. Raised for pattern violations during unification (assignV=) but also in other situations where we want to backtrack.YAgda(The state in which the error was raised.ZAgda<The environment in which the error as raised plus the error.[AgdaDDistinguish error message when parsing lhs or pattern synonym, resp.eAgdaGThe target of a constructor isn't an application of its datatype. The  records what it does target.fAgdaThe 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.gAgda>Expected a type to be an application of a particular datatype.hAgdaconstructor, datatypeiAgdaDatatype, constructors.jAgdaconstructor, typekAgdaeThe left hand side of a function definition has a hidden argument where a non-hidden was expected.lAgda9Expected a non-hidden function and found a hidden lambda.mAgdaKA function is applied to a hidden argument where a non-hidden was expected.nAgdaA function is applied to a hidden named argument it does not have. The list contains names of possible hidden arguments at this point.oAgda0Wrong user-given relevance annotation in lambda.pAgda/Wrong user-given quantity annotation in lambda.qAgda/Wrong user-given cohesion annotation in lambda.rAgda@The given quantity does not correspond to the expected quantity.sAgda<The given hiding does not correspond to the expected hiding.tAgdaAThe given relevance does not correspond to the expected relevane.|Agda'The given type should have been a sort.}Agda%The given type should have been a pi.Agda#This sort is not a type expression.Agda#This term is not a type expression.Agda4This term, a function type constructor, lives in SizeUniv, which is not allowed.Agda0The two function types have different relevance.Agda0The two function types have different relevance.Agda/The two function types have different cohesion.Agda-The two function types have different hiding.AgdaQThe arguments are the meta variable and the parameter that it wants to depend on.AgdaBRecord type, fields not supplied by user, non-fields not supplied.AgdaOSome interaction points (holes) have not been filled by user. There are not  UnsolvedMetas{ since unification solved them. This is an error, since interaction points are never filled without user interaction.Agda(Found module name, expected module name.AgdapModule name, file from which it was loaded, file which the include path says contains the module. Scope errorsAgdahThe expr was used in the right hand side of an implicit module definition, but it wasn't of the form m Delta.Agda>Failed to apply injectivity to constructor of indexed datatypeAgda=Can't solve equation because variable occurs in (type of) lhsAgda=Can't solve reflexive equation because --without-K is enabledAgda?Can't solve equation because solution modality is less "usable"AgdaKError when splitting a pattern variable into possible constructor patterns.AgdaNeither data type nor record.Agda&Data type, but in irrelevant position.Agda8Data type, but in erased position. If the boolean is 77J, then the reason for the error is that the K rule is turned off.AgdatSplit on codata not allowed. UNUSED, but keep! -- | NoRecordConstructor Type -- ^ record type, but no constructorAgdaCopattern split with a catchallAgda-We do not know the target type of the clause.Agda!Target type is not a record type.Agda Constructor.AgdaContext for indices.Agda,Inferred indices (from type of constructor).Agda)Expected indices (from checking pattern).Agda$Reason(s) why unification got stuck.AgdaMInformation about a mutual block which did not pass the termination checker. AgdaZThe functions which failed to check. (May not include automatically generated functions.) AgdaThe problematic call sites. AgdaInformation about a call.AgdaTarget function name.AgdaRange of the target function.Agda+To be formatted representation of the call.Agda"Range where the warning was raisedAgdaThe warning itselfAgdaDThe warning printed in the state and environment where it was raisedAgda*Should the warning be affected by caching.Agda4`UnreachableClauses f rs` means that the clauses in f' whose ranges are rs are unreachableAgda!`CoverageIssue f pss` means that pss are not covered in fAgdaDo not use directly with warningAgdaDo not use directly with warningAgdaDo not use directly with warning!AgdaAIn `OldBuiltin old new`, the BUILTIN old has been replaced by new"AgdaIf the user wrote just {-# REWRITE #-}.#AgdaEIf the user wrote something other than an unqualified name in the as clause of an import statement. The 8H$ gives optionally extra explanation.$AgdaIf a renamingt import directive introduces a name or module name clash in the exported names of a module. (See issue #4154.)%AgdaQIf the user opens a module public before the module header. (See issue #2377.)(Agda{An instance was declared with an implicit argument, which means it will never actually be considered by instance search.)Agda}The type of an instance argument doesn't end in a named or variable type, so it will never be considered by instance search.*AgdaVAs InstanceWithExplicitArg, but for local bindings rather than top-level instances.+AgdaKThe --inversion-max-depth was reached. Generic warnings for one-off things,Agda'Harmless generic warning (not an error)-AgdaOGeneric error which doesn't abort proceedings (not a warning) Safe flag errors/AgdaUnsafe OPTIONS.9AgdaETA pragma is unsafe.<Agda)`DeprecationWarning old new version`: old is deprecated, use new( instead. This will be an error in Agda version.=Agda@User-defined warning (e.g. to mention that a name is deprecated)>AgdaPFixity of modules cannot be changed via renaming (since modules have no fixity).?AgdaBSome imported names are not actually exported by the source module@AgdaAImporting a file using an infective option into one which doesn'tAAgdaCImporting a file not using a coinfective option from one which doesBAgdaXConfluence checker found critical pair and equality checking resulted in a type errorCAgdaNConfluence checker got stuck on computing overlap between two rewrite rulesDAgda&COMPILE directive for an erased symbolEAgda&Out of scope error we can recover fromFAgdaA 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.LAgdaAAdd implicit arguments in the end until type is no longer hidden .MAgda!Do not append implicit arguments.NAgdaMakes  doExpandLastP have no effect. Used to avoid implicit insertion of arguments to metavariables.PAgda6Abstract things in the current module can be accessed.QAgda#No abstract things can be accessed.RAgda$All abstract things can be accessed.UAgdaThe Context is a stack of Ts._Agda=The path to the file that is currently being type-checked. 7>9 if we do not have a file (like in interactive mode see  CommandLine).`Agda4anonymous modules and their number of free variablesaAgdato detect import cyclesbAgda!the current (if any) mutual blockcAgda/are we inside the scope of a termination pragmadAgda,are we inside the scope of a coverage pragmaeAgdaEare we inside a make-case (if so, ignore forcing analysis in unifier)fAgda>Are we currently in the process of solving active constraints?gAgdaOHave we stepped into the where-declarations of a clause? Everything under a where# will be checked with this flag on.hAgda&Are we working on types? Turned on by  workOnTypes.iAgdaAre we allowed to assign metas?kAgdaWhen 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.lAgda7 component: Are we checking an irrelevant argument? (= IrrelevantE) Then top-level irrelevant declarations are enabled. Other value: Relevant*, then only relevant decls. are available.; component: Are we checking a runtime-irrelevant thing? (=<) Then runtime-irrelevant things are usable. Other value:  Quantity1, runtime relevant.  Quantity/ is not allowed here, see Bob Atkey, LiCS 2018.mAgda+Sometimes we want to disable display forms.oAgda8Interactive highlighting uses this range rather than n.pAgdajWhat is the current clause we are type-checking? Will be recorded in interaction points in this clause.qAgdawhat we're doing at the momentrAgdaSet to + when imported modules are type-checked.tAgdaJThis 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.uAgdaWhen type-checking an alias f=e, we do not want to insert hidden arguments in the end, because these will become unsolved metas.vAgda]We are reducing an application of this function. (For debugging of incomplete matches only.)wAgdaYDid we encounter a simplification (proper match) during the current reduction process?yAgdaDInjectivity can cause non-termination for unsolvable contraints (431, @3067). Keep a limit on the nesting depth of injectivity uses.zAgdaWhen True, the conversion checker will consider all term constructors as injective, including blocked function applications and metas. Warning: this should only be used when not assigning any metas (e.g. when envAssignMetas is False or when running pureEqualTerms.) or else we get non-unique meta solutions.{AgdaWhen TrueI, types will be omitted from printed pi types if they can be inferred.|AgdaWhen True, throw away meta numbers and meta elims. This is used for reifying terms for feeding into the user's source code, e.g., for the interaction tactics solveAll.}AgdaUsed by the scope checker to make sure that certain forms of expressions are not used inside dot patterns: extended lambdas and let-expressions.AgdarUntil we get a termination checker for instance search (#1743) we limit the search depth to ensure termination.Agda#3004: pattern lambdas with copatterns may refer to themselves. We don't have a good story for what to do in this case, but at least printing shouldn't loop. Here we keep track of which pattern lambdas we are currently in the process of printing.Agda+Use call-by-need evaluation for reductions.AgdahCheckpoints track the evolution of the context as we go under binders or refine it by pattern matching.AgdaOKeeps the substitution from each previous checkpoint to the current context.Agda"Should new metas generalized over.Agda(Values for used generalizable variables.AgdaMDo we check that options in imported files are consistent with each other?AgdaRIs some backend active at the moment, and if yes, which? NB: we only store the   here, otherwise instance Data TCEnvK is not derivable. The actual backend can be obtained from the name via  .Agda Via stdout.AgdaBoth via files and via stdout.AgdaThis includes both non-interactive highlighting and interactive highlighting of the expression that is currently being type-checked.Agda-Builtin of any kind. Type can be checked (Just t) or inferred (NothingD). The second argument is the hook for the verification function.Agda2When 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.AgdaThe instance table is a Map' associating to every name of record data typepostulate its list of instancesAgda*Interaction command: show module contents.Agdaused by setCurrentRangeAgda PrimitivesAgda Controlling reduce.Agda:(Projection and) projection-like functions may be reduced.Agda'Functions marked INLINE may be reduced.Agda%Copattern definitions may be reduced.Agda6Non-recursive functions and primitives may be reduced.Agda(Even recursive functions may be reduced.AgdaReduce  terms.AgdaAllow  allReductionsO in types, even if not allowed at term level (used by confluence checker)Agda9Functions whose termination has not (yet) been confirmed.Agda0Functions that have failed termination checking.AgdaNThree cases: 1. not reduced, 2. reduced, but blocked, 3. reduced, not blocked.Agda"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?Agda PostulateAgda@Data or record type signature that doesn't yet have a definitionAgda&Generalizable variable (introduced in  generalize block)Agda Returned by  getConstInfo if definition is abstract.AgdaPrimitive or builtin functions.Agda7>* while function is still type-checked. Just ccC after type and coverage checking and translation to case trees.AgdauThe split tree constructed by the coverage checker. Needed to re-compile the clauses after forcing translation.Agda2Intermediate representation for compiler backends.Agda\Covering clauses computed by coverage checking. Erased by (IApply) confluence checking(?)AgdaMutually recursive functions, datas and recordEs. Does include this function. Empty list if not recursive. Nothing- if not yet computed (by positivity checker).Agda+Are the clauses of this definition delayed?Agda(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.Agda9Has this function been termination checked? Did it pass?AgdaIs this function generated from an extended lambda? If yes, then return the number of hidden and non-hidden lambda-lifted arguments AgdaZIs this a generated with-function? If yes, then what's the name of the parent function. AgdaNumber of parameters. AgdaNumber of indices. Agda(This might be in an instantiated module. AgdaGConstructor names , ordered according to the order of their definition.AgdaMutually recursive functions, datas and recordAs. Does include this data type. Empty if not recursive. Nothing- if not yet computed (by positivity checker).Agda+Path constructor names (subset of dataCons)AgdaNumber of parameters.AgdaWas this record type created by a module application? If yes, the clause is its definition (linking back to the original record type).AgdaConstructor name and fields.AgdaDoes this record have a  constructor?AgdaThe record field names.AgdaCThe record field telescope. (Includes record parameters.) Note: $TelV recTel _ == telView' recConType . Thus, recTel is redundant.AgdaMutually recursive functions, datas and record>s. Does include this record. Empty if not recursive. Nothing- if not yet computed (by positivity checker).Agda#Eta-expand at this record type? False` for unguarded recursive records and coinductive records unless the user specifies otherwise.Agda or *? Matters only for recursive records. 7>T means that the user did not specify it, which is an error for recursive records.AgdaNumber of parameters.Agda+Number of arguments (excluding parameters).AgdaPName of (original) constructor and fields. (This might be in a module instance.) Agda Name of datatype or record type."AgdaInductive or coinductive?#AgdaCubical composition.$Agda Projections. 7> if not yet computed.%AgdaWhich arguments are forced (i.e. determined by the type of the constructor)? Either this list is empty (if the forcing analysis isn't run), or its length is conArity.&AgdaTWhich arguments are erased at runtime (computed during compilation to treeless)? 77 means erased, 7Q means retained. 7>M if no erasure analysis has been performed yet. The length of the list is conArity.)Agda for primitive functions, not null for builtin functions.*AgdaKBuiltin functions can have inverses. For instance, natural number addition.+Agda7> for primitive functions, 7= something for builtin functions.1Agda<Should calls to this function be normalised at compile-time?2Agda9Should calls to this function be inlined by the compiler?3AgdaIs this function a macro?4Agda(Should a record type admit eta-equality?5AgdaUser specifed 'eta-equality' or 'no-eta-equality'.6Agda0Positivity checker inferred whether eta is safe.8Agda@Abstractions to build projection function (dropping parameters).;Agda&Additional information for projection s.=AgdaNothing if only projection-like, Just r if record projection. The r_ is the name of the record type projected from. This field is updated by module application.>AgdaPThe original projection name (current name could be from module application).?Agda-Type projected from. Original record type if projProper = Just{}. Also stores ArgInfoM of the principal argument. This field is unchanged by module application.@AgdaIndex 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.AAgdaTerm 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.BAgda,Additional information for extended lambdas.DAgda.For complicated reasons the scope checker decides the QName of a pattern lambda, and thus its module. We really need to decide the module during type checking though, since if the lambda appears in a refined context the module picked by the scope checker has very much the wrong parameters.FAgdaAn alternative representation of partial elements in a telescope:  "  . [ u , ... ,  u ] :  ! PartialP ("(_b b) T see cubicaltt paper (however we do not store the type T).HAgda4the telescope , binding vars for the clauses,  " IAgda?a system [ u , ... ,  u ] where ,  " b and , , b " ubLAgda;The backends are responsible for parsing their own pragmas.NAgdaJInformation about whether an argument is forced by the type of a function.QAgdamonotoneRAgdaantitoneSAgdano information (mixed variance)TAgdaconstantWAgda5When lambda-lifting new args are generalizable if W, also when the number is zero.ZAgdaHiding should not be used.[Agda-The canonical name, used e.g. in compilation.\AgdaType of the lifted definition.]AgdaVariance information on arguments of the definition. Does not include info for dropped parameters to projection(-like) functions and constructors.^AgdaPositivity information on arguments of the definition. Does not include info for dropped parameters to projection(-like) functions and constructors._Agda)How many arguments should be generalised.`AgdaGives the name of the (bound variable) parameter for named generalized parameters. This is needed to bring it into scope when type checking the data/record definition corresponding to a type with generalized parameters.dAgdaJust q/ when this definition is an instance of class qeAgda:Has this function been created by a module instantiation?fAgdaDThe set of symbols with rewrite rules that match against this symbolgAgda8should compilers skip this? Used for e.g. cubical's comphAgdaGShould the def be treated as injective by the pattern matching unifier?iAgda)Is this a function defined by copatterns?jAgdaWhat blocking tag to use when we cannot reduce this def? Used when checking a function definition is blocked on a meta in the type.lAgda?Rewrite rules can be added independently from function clauses.nAgdaName of rewrite rule q :  ! f ps "a rhs where "a is the rewrite relation.oAgda.pAgdaf.qAgda  " f ps : t.rAgda  " rhs : t.sAgda " t.Agda1Non-linear (non-constructor) first-order pattern.AgdapMatches anything (modulo non-linearity) that only contains bound variables that occur in the given arguments.AgdaMatches f esAgdaMatches  x ! tAgdaMatches  (x : A) ! BAgda"Matches a sort of the given shape.AgdaMatches x es# where x is a lambda-bound variableAgda'Matches the term modulo  (ideally ).AgdaA structured presentation of a  for reification into no.Agda(f vs | ws) es. The first  is the parent function f with its args vs. The list of s are the with expressions ws . The  are additional arguments esl (possible in case the with-application is of function type) or projections (if it is of record type).Agdac vs.Agdad vs.Agda.v.Agdav.AgdaA  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 no. 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.AgdaNumber n of free variables in .AgdaLeft hand side patterns, where var 04 stands for a pattern variable. There should be n occurrences of var0 in  . The  is ignored in these patterns.AgdaRight hand side, with n free variables.Agda'The rewrite rules defined in this file.Agda0Which clause is an interaction point located in?Agda4The interaction point is not in the rhs of a clause.AgdaThe name of the function.Agda*The number of the clause of this function.AgdaThe type of the functionAgdaModule parameter substitutionAgdaThe original AST clause.Agda&Environment for rechecking the clause.Agda The boundary imposed by the LHS.Agda[Datatype representing a single boundary condition: x_0 = u_0, ... ,x_n = u_n " t = ?n esAgda x_0 = u_0, ... ,x_n = u_nAgda tAgda ?n esAgdaIs ?n overapplied in ?n es ?AgdaFlag to indicate whether the meta is overapplied in the constraint. A meta is overapplied if it has more arguments than the size of the telescope in its creation environment (as stored in MetaInfo).Agda/Data structure managing the interaction points.DWe never remove interaction points from this map, only set their  to True. (Issue #2368)AgdaInteraction 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.Agda&The position of the interaction point.Agda0The meta variable, if any, holding the type etc.Agda/Has this interaction point already been solved?AgdaIThe clause of the interaction point (if any). Used for case splitting.AgdaEName suggestion for meta variable. Empty string means no suggestion.AgdaMetaInfo4 is cloned from one meta to the next during pruning.Agda7Run the extended occurs check that goes in definitions?AgdaUsed for printing. Just x8 if meta-variable comes from omitted argument with name x.AgdaDShould this meta be generalized if unsolved? If so, at what ArgInfo?AgdapMeta variable priority: When we have an equation between meta-variables, which one should be instantiated?6Higher value means higher priority to be instantiated.Agda( (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  rather than an .Agda,Quote the given term and check type against Agda Solving a p constraint may or may not check the target type. If it did, it returns a handle to any unsolved constraints.Agda4solved by term (abstracted over some free variables)AgdaunsolvedAgda+open, to be instantiated by instance searchAgda(solution blocked by unsolved constraintsAgdaFrozen 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).AgdaDo not instantiate.Agda4some metavariables are more eager to be instantiatedAgdaa metavariable doesn't have to depend on all variables in the context, this "permutation" will throw away the ones it does not depend onAgdaBmeta variables scheduled for eta-expansion but blocked by this oneAgdaBare we past the point where we can instantiate this meta variable?AgdaJust m$ means this meta will be equated to m# when the latter is unblocked. See blockedTermOnProblem.AgdaThe value of a generalizable variable. This is created to be a generalizable meta before checking the type to be generalized.AgdaFParametrized since it is used without MetaId when creating a new meta.Agdaare we checking (CmpLeq) or inferring (CmpEq ) the type?Agda-A thing tagged with the context it came from.AgdawWe can either compare two terms at a given type, or compare two types without knowing (or caring about) their sorts.AgdaType should not be Size5. But currently, we do not rely on this invariant.Agda Replaces AsTermsOf Size.AgdaAn extension of   to >=. Agda,the two types are for the error message only Agda+The range is the one of the absurd pattern. AgdaCheck that the . is either not a SIZELT or a non-empty SIZELT. Agdathe 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) AgdaCFirst argument is computation and the others are hole and goal type &AgdaHash of the source code. 'AgdaThe source code. The source code is stored so that the HTML and LaTeX backends can generate their output without having to re-read the (possibly out of date) source code. (Agda4Source file type, determined from the file extension )Agda"Imported modules and their hashes. *AgdaModule name of this interface. +AgdaScope defined by this module.yAndreas, AIM XX: Too avoid duplicate serialization, this field is not serialized, so if you deserialize an interface, iScope will be empty. But constructIScope constructs  + from  ,. ,Agda1Scope after we loaded this interface. Used in 2p and 6q. .Agda-Display forms added for imported identifiers. /Agda&User warnings for imported identifiers 0Agda8Whether this module should raise a warning when imported 4AgdaPragma options set in the file. 5AgdaiOptions/features used when checking the file (can be different from options set directly in the file). @Agda77@ if warnings were encountered when the module was type checked. AAgda77I if the module is a primitive module, which should always be importable. BAgdaA monad that has read and write access to the stConcreteNames part of the TCState. Basically, this is a synonym for `MonadState ConcreteNames m` (which cannot be used directly because of the limitations of Haskell's typeclass system). FAgdaDMaps source file names to the corresponding top-level module names. GAgdaCreate a fresh name from a. PAgda0A complete log for a module will look like this: T Q, entering the main module.$'Decl'/'EnterSection'/'LeaveSection'*, for declarations and nested modules R, leaving the main module. SAgdaNever a Section or ScopeDecl UAgdaLike  Vy, but storing the log for an ongoing type checking of a module. Stored in reverse order (last performed action first). VAgdaA log of what the type checker does and states after the action is completed. The cached version is stored first executed action first. [AgdaYA part of the state which is not reverted when an error is thrown or the state is reset. _AgdawCallback function to call when there is a response to give to the interactive frontend. See the documentation of `. `AgdawStructure to track how much CPU time was spent on which Agda phase. Needs to be a strict field to avoid space leaks! aAgdaShould be strict field. bAgdaBCached typechecking state from the last loaded file. Should be Nothing when checking imports. cAgda#Current backends with their options dAgda)A mutual block of names in the signature. fAgda&The original info of the mutual block. jAgdaHighlighting info. kAgdajDisambiguation carried out by the type checker. Maps position of first name character to disambiguated  ] for each  S$ already passed by the type checker. pAgdaTDirty when a constraint is added, used to prevent pointer update. Currently unused. qAgdaDefinitions 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. rAgdaeDeclared identifiers of the current file. These will be serialized after successful type checking. sAgdaiFor each module remember the checkpoint corresponding to the orignal context of the module parameters. tAgda-Display forms we add for imported identifiers uAgda@The current module is available after it has been type checked. wAgdaMap keeping track of concrete names assigned to each abstract name (can be more than one name in case the first one is shadowed) xAgdaMap keeping track for each name root (= name w/o numeric suffixes) what names with the same root have been used during a TC computation. This information is used to build the ShadowingNames map. yAgdakMap keeping track for each (abstract) name the list of all (raw) names that it could maybe be shadowed by. zAgdaZCounters to collect various statistics about meta variables etc. Only for current file. AgdaShould we instantiate away blocking metas? This can produce ill-typed terms but they are often more readable. See issue #3606. Best set to True only for calls to pretty*/reify to limit unwanted reductions. Agda/Local partial definitions, to be stored in the  Interface AgdaUHighlighting info for tokens (but not those tokens for which highlighting exists in  ). Agda?Imported declared identifiers. Those most not be serialized! Agda2Pattern synonyms of the current file. Serialized. Agda3Imported pattern synonyms. Must not be serialized! AgdaFCollected generalizable variables; used during scope checking of terms Agda&Options applying to the current file. OPTIONS! pragmas only affect this field. Agda;Display forms added by someone else to imported identifiers Agda{-# FOREIGN #-}b code that should be included in the compiled output. Does not include code for imported modules. Agda Imported  UserWarnings, not to be stored in the  Interface AgdaLocally defined  UserWarnings, to be stored in the  Interface Agda=Whether the current module should raise a warning when opened Agda6Imported partial definitions, not to be stored in the  Interface Agda/The state which is frozen after scope checking. Agda1The state which is modified after scope checking. Agda'State which is forever, like a diamond. AgdaEmpty persistent state. AgdaEmpty state of type checker. Agda Creates a  F map based on  . O(n log n).For a single reverse lookup in  , rather use lookupModuleFromSourse. Agda Lookup an  in  .O(n). AgdaGCombines the source hash and the (full) hashes of the imported modules. AgdaEmbed   into . Agda!Flip the direction of comparison. AgdaTurn a   function into a  function. Property:  dirToCmp f (fromCmp cmp) = f cmp Agda$By default, we have no display form.!Agda+Create a definition with sensible defaults.!Agda>Building the projection function (which drops the parameters).!Agda,The info of the principal (record) argument.!Agda3Make sure we do not overwrite a user specification.! AgdaIs the record type recursive?! AgdaA template for creating % definitions, with sensible defaults.!AgdaBChecking whether we are dealing with a function yet to be defined.!AgdaConceptually: 2redBind m f k = either (return . Left . f) k =<< m!Agda:Not quite all reductions (skip non-terminating reductions)!$Agda+Are the clauses of this definition delayed?!%Agda2Has the definition failed the termination checker?!&AgdaAHas the definition not termination checked or did the check fail?!)Agda&ifTopLevelAndHighlightingLevelIs l b m runs mV when we're type-checking the top-level module and either the highlighting level is at least l or b is 77.!*Agda$ifTopLevelAndHighlightingLevelIs l m runs mO when we're type-checking the top-level module and the highlighting level is at least l.!cAgdaGets the include directories.Precondition:  must be nonempty (i.e. setCommandLineOptions must have run).!uAgda&Modify the lens-indicated part of the TCEnv in a subcomputation.!wAgda A variant of E6 in which the computation is strict in the new state.!yAgdaOverwrite the part of the   focused on by the lens.!zAgdaModify the part of the   focused on by the lens.!{Agda'Modify a part of the state monadically.!|AgdaModify the part of the  0 focused on by the lens, and return some result.!}Agda?Modify a part of the state monadically, and return some result.!Agda.Preserve the state of the failing computation.!AgdaExecute 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.!Agda4Running the type checking monad (most general form).!AgdaARunning the type checking monad on toplevel (with initial state).!Agda! runs a safe   action (a  9 action which cannot fail) in the initial environment.!Agda6Runs 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.!Agda$Base name for patterns in telescopes!Agda&Base name for extended lambda patterns!Agda<Check whether we have an definition from an extended lambda.!Agda!Name of absurdLambda definitions.!Agda:Check whether we have an definition from an absurd lambda.!Agda.Base name for generalized variable projections!Agda2Check whether we have a generalized variable field!AgdaWe only 7M the name of the callee." AgdaaWe store benchmark statistics in an IORef. This enables benchmarking pure computation, see Agda.Benchmarking." AgdaStrict (non-shortcut) monoid."Agda Strict (non-shortcut) semigroup.PNote that there might be a lazy alternative, e.g., for TCM All we might want F as concatenation, to shortcut conjunction in case we already have 7Q."AgdaLike %i, but resets the state completely before running the handler. This means it also loses changes to the  .}The intended use is to catch internal errors during debug printing. In debug printing, we are not expecting state changes.m TSQR             [~}|{zyxwvusqponmljihgfedcba`_^]rtk\     XWUVZY !EDCBA@?>=<;9876543210/.-,+*)('&%$#"! :?@ABEDCFHGIJKLMNOQPRTS[]\^~}|{zyxwvutsrqponmlkjihgfedcba`_     FGJIHKNMLORQPSTUVWXYZ+*)('&%$#"!      ,-/.0321465789:;<A@?>=BCEDFGIHJKLMNPOUWVXYkjihgfecba`_^]\[Zdlmsrqpontuyxwvz{}|~                        # " !  $ % 8 7 6 5 4 3 2 1 0 / . - , + * ) ( ' & 9 : ; < = > A @ ? B E D C F G H I J K L M O N P R Q S T U V W X Z Y [ \ c b a ` _ ^ ] d e g f h i  ~ } | { z y x w v u t s r q p o n m l k 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!c!d!e!f!g!h!i!j!k!l!m!n!o!p!q!r!s!t!u!v!w!x!y!z!{!|!}!~!!!!!!!!!!!!!!!!!!!!!!!!!!!m  h i  ~ } | { z y x w v u t s r q p o n m l k j d e g f [ \ c b a ` _ ^ ] W X Z Y V U P R Q S T M O N K L   I J G H  F B E D C = > A @ ? < ; 9 : $ % 8 7 6 5 4 3 2 1 0 / . - , + * ) ( ' &   # " !                               ~z{}|uyxwvtlmsrqponXYkjihgfecba`_^]\[ZdUWV!! TSQRNPOLM !!K!JFGIHBCED!;<A@?>=89:!!4657!0321,-/.! +*)('&%$#"!      ! ! ! ! !!!!!!!!!!!!!!!!!!! !!!"!#!$!%!&!'!(  !)!* [~}|{zyxwvusqponmljihgfedcba`_^]rtk\!+YZVWX!,!-!.!/!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!ZUTSORQP![!\KNML!]FGJIH !EDCBA@?>=<;9876543210/.-,+*)('&%$#"! :!^ !_     ^~}|{zyxwvutsrqponmlkjihgfedcba`_[]\ XWUVZYRTS!`!a!b!c!dNOQP!e!f!g!h!iKLM!j!k!l!m!n!o!p!q!rIJFHG!s!t!uBEDC!v!w!x!y!z!{!|!}    !~!!!!!!A!!!?@!!!!!!!!!!!!!!!!!!!y4None"#$,.14568=>?@ACEHPSUVX_`j'#AgdaicodeArgs proxy (a1, ..., an) maps icode over a1, ..., an* and returns the corresponding list of Int32.# AgdaMonad used by the decoder.TCMJ is not used because the associated overheads would make decoding slower.#AgdaMonad used by the encoder.#AgdaState of the decoder.#AgdaObtained from interface file.#AgdaObtained from interface file.#AgdaObtained from interface file.#AgdaObtained from interface file.#AgdaObtained from interface file.#AgdaZCreated and modified by decoder. Used to introduce sharing while deserializing objects.#Agda<Maps module names to file names. Constructed by the decoder.#AgdaThe include directories.#Agda=Univeral memo structure, to introduce sharing during decoding#Agda!Universal type, wraps everything.#AgdaState of the the encoder.#AgdaWritten to interface file.#AgdaWritten to interface file.# AgdaWritten to interface file.#!AgdaWritten to interface file.#"AgdavWritten to interface file. Dicitionaries which are not serialized, but provide short cuts to speed up serialization:##Agda~Not written to interface file. Andreas, Makoto, AIM XXI Memoizing A.Name does not buy us much if we already memoize A.QName.#$AgdaNot written to interface file.#%Agda@Not written to interface file. Fresh UIDs and reuse statistics:#/AgdaIf True collect in stats the quantities of calls to icode for each  Typeable a.#0AgdaNot written to interface file.#1AgdaTwo  ]s are equal if their QNameId is equal.#2AgdazStructure providing fresh identifiers for hash map and counting hash map hits (i.e. when no fresh identifier required).#4AgdaNumber of hash map misses.#5Agda+The type of hashtables used in this module.0A very limited amount of testing indicates that 8I is somewhat slower than 8J , and that 8K and the hashtables from Data.Hashtable are much slower.#6Agda5Constructor tag (maybe omitted) and argument indices.#9Agda(Computing a qualified names composed ID.#:AgdaCreates an empty dictionary.#;AgdaEThrows an error which is suitable when the data stream is malformed.#<AgdaIncrease entry for a in #..#=Agda 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.#CAgdaicode# only if thing has not seen before.#DAgdavcase value ix decodes thing represented by  ix :: Int32 via the valu function and stores it in #. If ix is present in #, valu, is not used, but the thing is read from # instead.#EAgdaicodeN tag t a1 ... an serialises the arguments a1, ..., an of the constructor t together with a tag tagP picked to disambiguate between different constructors. It corresponds to 0icodeNode . (tag :) =<< mapM icode [a1, ..., an]#FAgdaicodeN' is the same as icodeN except that there is no tag# AgdaSerialization (wrapper).# AgdaSerialization (worker).# AgdaDeserialization.#:AgdaCollect statistics for icode calls?#CAgda Memo structure for thing of key a.Agda Statistics.AgdaKey to the thing.Agda)Fallback computation to encode the thing.AgdaEncoded thing.E###### # # # # #################0#/#.#-#,#+#*#)#(#'#&#%#$###"#!# ###1#2#3#4#5#6#7#8#9#:#;#<#=#>#?#@#A#B#C#D#E#F#G#HE#6#5#2#3#4#7#8#1#9###0#/#.#-#,#+#*#)#(#'#&#%#$###"#!# ###:############### #;# # # # #<#=#>#?#@#A#B#C#D###E#F####G#HNone"#$,14568=>?@ACEPSX_`#wAgdaWAssumes that the first module in the import path is the module we are worried about.#f#g#h#i#j#k#l#m#n#o#p#q#r#s#t#u#v#w#f#g#h#i#j#k#l#m#n#o#p#q#r#s#t#u#v#wNone"#$,14568=>?@ACEPSX_`Ȑ#xAgda+Get the name of the current module, if any.#yAgda#Set the name of the current module.#zAgda*Get the path of the currently checked file#{Agda7Get the number of variables bound by anonymous modules.#|Agda+Add variables bound by an anonymous module.#}Agda(Set the current environment to the given#~AgdaGet the current environment#AgdaDIncreases the module nesting level by one in the given computation.#AgdaSet highlighting level#AgdaRestore setting for L to default.#AgdaoIf the reduced did a proper match (constructor or literal pattern), then record this as simplification step.#Agda Lens for .#AgdaReduce Def f vs only if f is a projection.#AgdaDAllow all reductions except for non-terminating functions (default).#Agda9Allow all reductions including non-terminating functions.#Agda(Allow all reductions when reducing types#Agda/Update allowed reductions when working on types#Agda<Don't use call-by-need evaluation for the given computation.#x#y#z#{#|#}#~#####################x#y#z#{#|#}#~####################None"#$,14568=>?@ACEPSX_`#Agda?Debug print some lines if the verbosity level for the given ! is at least  .Note: In the presence of OverloadedStrings , just @( traceS key level "Literate string"  gives an Ambiguous type variable error in  GHC@. Use the legacy functions # and # instead then.#Agda?Debug print some lines if the verbosity level for the given ! is at least  .Note: In the presence of OverloadedStrings , just @) reportS key level "Literate string"  gives an Ambiguous type variable error in  GHC@. Use the legacy functions # and # instead then.#Agda=Print brackets around debug messages issued by a computation.#Agda/During printing, catch internal errors of kind  and print them.#Agda#Conditionally println debug string.#AgdaConditionally render debug V and print it.#Agda(Debug print the result of a computation.#AgdaConditionally render debug V, print it, and then continue.#Agda5Check whether a certain verbosity level is activated.-Precondition: The level must be non-negative.#AgdaCCheck whether a certain verbosity level is activated (exact match).#AgdaJRun a computation if a certain verbosity level is activated (exact match).#Agda<Run a computation if a certain verbosity level is activated.-Precondition: The level must be non-negative.#Agda;Apply a function if a certain verbosity level is activated.-Precondition: The level must be non-negative.#AgdaVerbosity lens.! !##############################!##############################! None"#$,14568=>?@ACEHPSVX_`R#AgdaGet the statistics.#Agda)Modify the statistics via given function.#AgdaIncrease specified counter by 1.#AgdaIncrease specified counter by n.#AgdaBSet the specified counter to the maximum of its current value and n.#AgdaAPrint the given statistics if verbosity "profile.ticks" is given.################None"#$,14568=>?@ACEPSX_`b#Agda/To be called before any write or restore calls.#Agda Writes a  P( to the current log, using the current  h#Agda@Runs the action and restores the current cache at the end of it.$AgdaORuns the action without cache and restores the current cache at the end of it.$Agda>Reads the next entry in the cached type check log, if present.$AgdaCEmpties the "to read" CachedState. To be used when it gets invalid.$AgdaMakes sure that the   is 7=(, with a clean current log. Crashes is  e is already active with a dirty log. Should be called when we start typechecking the current file.$AgdacCaches the current type check log. Discardes the old cache. Does nothing if caching is inactive. #####$$$$$ #$$$$###$#None"#$,14568=>?@ACEPSX_`6$AgdaIWhen verbosity is set or changes, we need to turn benchmarking on or off.8LAgda(Check whether benchmarking is activated.$AgdaaPrints the accumulated benchmark results. Does nothing if profiling is not activated at level 2.7;<TUVW *.01<423-/&7(A%'+F@"!#$),5689:;=>?BCDEGHIJKL$$;<$UWVT$None"#$,14568=>?@ACEHPSVX_`@$ $ $$$$$ $ None"#$,14568=>?@ACEPSX_`$5Agda8Assorted warnings and errors to be displayed to the user$8AgdaDClassifying warnings: some are benign, others are (non-fatal) errors$9Agda(warnings that will be turned into errors$:Agdauall warnings, including errors and benign ones Note: order of constructors is important for the derived Ord instance$<AgdaRender the warning8MAgda;Should we only emit a single warning with this constructor.$GAgda;The only way to construct a empty WarningsAndNonFatalErrors$IAgdarunning the Parse monad$5$7$6$8$9$:$;$<$=$>$?$@$A$B$C$D$E$F$G$H$I$;$<$=$>$?$A$@$B$C$D$E$8$9$:$F$5$6$7$G$H$INone"#$,14568=>?@ACEPSX_`$]AgdaGMark a definition to be inlined if it satisfies the inlining criterion.$]$]None"#$,14568=>?@ACEPSX_`+$^Agda9Errors which can arise when trying to find a source file."Invariant: All paths are absolute.$_AgdaHThe file was not found. It should have had one of the given file names.$`Agda"Several matching files were found.AInvariant: The list of matching files has at least two elements.$cAgdaType aliases for source files and interface files. We may only produce one of these if we know for sure that the file does exist. We can always output an  AbsolutePath if we are not sure.$fAgdanMakes an interface file from an AbsolutePath candidate. If the file does not exist, then fail by returning Nothing.$gAgda{Converts an Agda file name to the corresponding interface file name. Note that we do not guarantee that the file exists.$iAgdaKGiven the module name which the error applies to this function converts a $^ to a ^.$jAgdagFinds 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.$kAgdaqTries to find the source file corresponding to a given top-level module name. The returned paths are absolute.SIDE EFFECT: Updates  .$lAgda A variant of $k which does not require  .$mAgdajFinds the interface file corresponding to a given top-level module file. The returned paths are absolute.Raises 7>+ if the the interface file cannot be found.$nAgdajFinds the interface file corresponding to a given top-level module file. The returned paths are absolute.ARaises an error if the source file cannot be found, and returns 7>= if the source file can be found but not the interface file.$oAgdaEnsures 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.$pAgdaDComputes the module name of the top-level module in the given file.eIf no top-level module name is given, then an attempt is made to use the file name as a module name.$fAgda$Path to the candidate interface fileAgdaInterface file iff it exists$lAgdaInclude paths.AgdaCached invocations of $l. An updated copy is returned.$mAgdaPath to the source fileAgda Maybe path to the interface file$oAgdaThe name of the module.Agda"The file from which it was loaded.Agda3The expected name, coming from an import statement.$pAgdaThe path to the file.AgdaThe parsed module.$^$_$`$a$b$c$d$e$f$g$h$i$j$k$l$m$n$o$p$q$c$d$e$a$b$g$f$^$_$`$i$j$k$l$m$n$o$p$q$hNone"#$,14568=>?@ACEPSX_`.$tAgda*Ranges that should be serialised properly.$Agda"Ranges are always deserialised as .$t$u$v$t$u$vNone"#$,14568=>?@ACEPSX_`/None"#$,14568=>?@ACEPSX_`0$$$$$$$$None"#$,14568=>?@ACEPSX_`1$Agda A subset of $.%Agda8Ignore additional checks, like termination/positivity...%AgdaDon't ignore any checks.% AgdaAvailable backends.%AgdaThe % monad. 8F! state holds the remaining input.%Agda<Used to indicate whether something should be removed or not.%Agdacmd_load m argv loads the module in file m , using argv as the command-line options.%Agdacmd_compile b m argv compiles the module in file m using the backend b, using argv as the command-line options.%AgdaaShow unsolved metas. If there are no unsolved metas but unsolved constraints show those instead.%AgdaeShows all the top-level names in the given module, along with their types. Uses the top-level scope.%Agda^Shows all the top-level names in scope which mention all the given identifiers in their type.%AgdaVSolve (all goals / the goal at point) whose values are determined by the constraints.%!Agda4Solve (all goals / the goal at point) by using Auto.%#AgdanParse the given expression (as if it were defined at the top-level of the current module) and infer its type.%$Agda{Parse and type check the given expression (as if it were defined at the top-level of the current module) and normalise it.%%Agda!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.%&AgdaITells Agda to compute token-based highlighting information for the file.KThis command works even if the file's module name does not match its location in the file system, or if the file is not scope-correct. Furthermore no file names are put in the generated output. Thus it is fine to put source code into a temporary file before calling this command. However, the file extension should be correct.If the second argument is %J, then the (presumably temporary) file is removed after it has been read.%'AgdalTells Agda to compute highlighting information for the expression just spliced into an interaction point.%(Agda5Tells Agda whether or not to show implicit arguments.%)Agda%Toggle display of implicit arguments.%*Agda Goal commandsIf the range is B, then the string comes from the minibuffer rather than the goal.%2AgdamGrabs the current goal's type and checks the expression in the hole against it. Returns the elaborated term.%3Agda&Displays the current goal and context.%4Agda&Displays the current goal and context and# infers the type of an expression.%5AgdaPGrabs the current goal's type and checks the expression in the hole against it.%6AgdamShows all the top-level names in the given module, along with their types. Uses the scope of the given goal.%;Agda$Displays version of the running Agda%<AgdaAbort the current computation..Does nothing if no computation is in progress.%=AgdaExit the program.%>AgdaAn interactive computation.%?AgdaCommand queues.%AAgdaCommands that should be processed, in the order in which they should be processed. Each command is associated with a number, and the numbers are strictly increasing. Abort commands are not put on this queue.%BAgdaWhen this variable is set to Just nQ an attempt is made to abort all commands with a command number that is at most n.%CAgdaIOTCM commands.%DAgdaA generalised command type.%EAgda A command.%FAgdaStop processing commands.%GAgda8An error message for a command that could not be parsed.%HAgda4Monad for computing answers to interactive commands.%H is   extended with state %J.%JAgda.Auxiliary state of an interactive computation.%LAgdaThe 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.%MAgdaThe 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.%NAgda*Reset the options on each reload to these.%OAgdaWe 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.%PAgdaThe command queue.*This queue should only be manipulated by initialiseCommandQueue and  maybeAbort.%QAgda#Initial auxiliary interaction state%RAgdaConverter from the type of 8N to %O The first paramter is part of the error message in case the parse fails.%TAgdaDemand an exact string.%ZAgdatNote that the grammar implemented by this instance does not necessarily match the current representation of ranges.s$$$$$$$$$$$$$$$$$$$$$$$$$$$$%%%%%%%%% % % % %% %%%%%%%%%%%%=%<%;%:%9%8%7%6%5%4%3%2%1%0%/%.%-%,%+%*%)%(%'%&%%%$%#%"%!% %%%%%%%%>%?%@%B%A%C%D%G%E%F%H%I%J%K%P%O%N%M%L%Q%R%S%T%U%Vs%J%K%P%O%N%M%L%I%Q%H%D%G%E%F%C%?%@%B%A%>%%=%<%;%:%9%8%7%6%5%4%3%2%1%0%/%.%-%,%+%*%)%(%'%&%%%$%#%"%!% %%%%%%%%%%%%%%%R%S%T%U%V% %%%%% % % % %%%%%%%%$$$$$$$$$$$$$$$$$$$$$$$$$$$$pNone"#$,14568=>?@ACEPSX_``AgdaYCallback 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 ` functions:Convert the response into a *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 `< function. (suitable for intra-process communication).aAgdaStatus information.bAgdaGive action result"Comment derived from agda2-mode.elIf b2 is 'Give_String s', then the goal is replaced by sM, and otherwise the text inside the goal is retained (parenthesised if b is %w).cAgdaShould token-based highlighting be removed in conjunction with the application of new highlighting (in order to reduce the risk of flicker)?dAgda4Info to display at the end of an interactive commandeAgda,There are two kinds of "make case" commands.fAgda'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.lAgda$Response is list of printed clauses.mAgda(Solution for one or more meta-variables.oAgda)The integer is the message's debug level.qAgda%Clear highlighting of the given kind.rAgdaAA command sent when an abort command has completed successfully.sAgda>A command sent when an exit command is about to be completed.tAgda The default `S function prints certain things to stdout (other things generate internal errors).%zAgda!Are implicit arguments displayed?%{Agda.Has the module been successfully type checked?%|AgdaEntry in context.%~AgdaThe original concrete name.%Agda&The name reified from abstract syntax.%Agda The type.%Agda)The value (if it is a let-bound variable)%Agda Whether the % is in scope.%Agda/Auxiliary information that comes with Goal Type%Agda Errors that goes into Info_ErrorVWhen an error message is displayed this constructor should be used, if appropriate.%AgdaGoals & Warnings%AgdaTWhen an error message is displayed this constructor should be used, if appropriate.%Agda%, denotes either an error or a success (when k< is present) TODO: split these into separate constructors%Agda7Yes, remove all token-based highlighting from the file.%AgdaNo.G`a%y%z%{b%v%w%xc%%d%%%%%%%%%%%%%%%%e%%fghijklmnopqrst$5%|%}%~%%%%%%%%%%%%%%%%%%%%Gfghijklmnopqrsc%%e%%d%%%%%%%%%%%%%%%%%%%%%%%$5%%%%%%%%%%|%}%~%%%%a%y%z%{b%v%w%x`tNone"#$,14568=>?@ACEPSX_`6"%Agda:Resets the non-persistent part of the type checking state.%Agda&Resets all of the type checking state. Keep only  and backend information.%AgdaRestore  ! after performing subcomputation.In contrast to r, the * info from the subcomputation is saved.%AgdaSame as %I but also returns the state in which we were just before reverting it.%AgdaSame as % but keep all warnings.%Agda:Allow rolling back the state changes of a TCM computation.%AgdaA fresh TCM instance.OThe computation is run in a fresh state, with the exception that the persistent state is preserved. If the computation changes the state, then these changes are ignored, except for changes to the persistent state. (Changes to the persistent state are also ignored if errors other than type errors or IO exceptions are encountered.)%Agda Lens for  a.%AgdaGet the current scope.%AgdaSet the current scope.%Agda;Modify the current scope without updating the inverse maps.%AgdaModify the current scope.%Agda Get a part of the current scope.%Agda&Run a computation in a modified scope.%Agda#Run a computation in a local scope.%AgdaSame as %-, but discard the scope from the computation.%Agda2Discard any changes to the scope by a computation.%Agda Scope error.%AgdaDebug print the scope.%Agda 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.%AgdaJRun some computation in a different signature, restore original signature.%AgdaZSet the top-level module. This affects the global module id of freshly generated names.%AgdagUse a different top-level module for a computation. Used when generating names for imported modules.%Agda Lens for  .%Agda,Get both local and imported pattern synonyms%AgdaLens getter for  from  .%Agda Lens map for .%AgdaLens getter for  from  .%AgdaLens modify for .%Agda>Look through the signature and reconstruct the instance table.%Agda Lens for  .%Agda4Remove all instances whose type is still unresolved.%Agda/Add an instance whose type is still unresolved.%AgdaAdd instance to some `class'.%AgdaName of the instance.AgdaName of the class.K%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%K%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%None"#$,14568=>?@ACEPSX_`<%AgdaReset q' to previous value in the continuation.Caveat: if the last % did not set an %, for example, only set the f with /, we will revert to the last interesting call.%Agda$Record a function call in the trace.%AgdaSets 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 ).%AgdahighlightAsTypeChecked 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.%Agda5Lispify and print the given highlighting information.%Agda rPreAgda r %%%%%%%%% %%%%%%%%%None"#$,14568=>?@ACEPSX_`J%AgdaaPass the current mutual block id or create a new mutual block if we are not already inside on.%AgdaPSet the mutual block info for a block, possibly overwriting the existing one.%Agda6Set the mutual block info for a block if non-existing.%Agda&Set the mutual block for a definition.&AgdaRGet the current mutual block, if any, otherwise a fresh mutual block is returned.&Agda0Reverse lookup of a mutual block id for a names.%%%%%&&&%%%%%&&&None"#$,14568=>?@ACEPSX_`x&&&&&&None"#$,14568=>?@ACEPSX_` &AgdaLMonad service class containing methods for adding and solving constraints&Agda#Unconditionally add the constraint.&Agda#Add constraint as awake constraint.& AgdaH`catchPatternErr handle m` runs m, handling pattern violations with handle (doesn't roll back the state)& AgdatSolve awake constraints matching the predicate. If the second argument is True solve constraints even if already &(.&AgdaGet the awake constraints&AgdaTakes out all constraints matching given filter. Danger! The taken constraints need to be solved or put back at some point.&AgdaSuspend 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.&$AgdaAdd new a constraint&'AgdaStart solving constraints&)Agda7Add constraint if the action raises a pattern violation&&& & & & &&&& &&&&&&&&&&&&&&&&&& &!&"&#&$&%&&&'&(&)&*&+&&&&&&&&&&&&&&&&&& &!&"&#&& & & & &&&& &&$&%&&&'&(&)&*&+None"#$,14568=>?@ACEPSX\_`@(&7AgdaA finite map for  ImportedNames.&>AgdaBool: did we copy recursively? We need to track this because we don't copy recursively when creating new modules for reexported functions (issue1985), but we might need to copy recursively later.&@AgdaTo simplify interaction between scope checking and type checking (in particular when chasing imports), we use the same monad.&IAgda-Create a new module with an empty scope. (Just' if it is a datatype or record module.)&JAgda"Apply a function to the scope map.&KAgda$Apply a function to the given scope.&MAgda*Apply a monadic function to the top scope.&NAgda&Apply a function to the current scope.&PAgda5Apply a function to the public or private name space.&VAgda7Run a computation without changing the local variables.&WAgdaRun a computation outside some number of local variables and add them back afterwards. This lets you bind variables in the middle of the context and is used when binding generalizable variables (#3735).&XAgda6Check that the newly added variable have unique names.&\Agda]After collecting some variable names in the scopeVarsToBind, bind them all simultaneously.&]Agda2Create a fresh abstract name from a concrete name.MThis function is used when we translate a concrete name in a binder. The f) of the concrete name is saved as the  e of the abstract name.&^Agda 0freshAbstractName_ = freshAbstractName noFixity'&_Agda'Create a fresh abstract qualified name.&aAgda0Create a concrete name that is not yet in scope.&bAgda?Look up the abstract name referred to by a given concrete name.&cAgdaVLook 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.)&eAgdaLook up a module in the scope.&fAgda'Get the fixity of a not yet bound name.&gAgda+Get the polarities of a not yet bound name.&hAgdayCollect the fixity/syntax declarations and polarity pragmas from the list of declarations and store them in the scope.&iAgda?Get the notation of a name. The name is assumed to be in scope.&jAgdaBind a variable.&kAgda;Temporarily unbind a variable. Used for non-recursive lets.&lAgda.Bind a defined name. Must not shadow anything.&nAgda}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  later on.&oAgdaBind a module name.&pAgdaHBind a qualified module name. Adds it to the imports field of the scope.&qAgda Clear the scope of any no names.&sAgdaCreate 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.&tAgda*Warn about useless fixity declarations in renaming directives.&uAgdaSApply an import directive and check that all the names mentioned actually exist.&vAgdaTranslation of ImportDirective.&wAgda Create a &7.&xAgdaApply a &7.&yAgdaTranslation of Renaming.&{AgdaOpen a module.&|Agda>Open a module, possibly given an already resolved module name.&YAgdaOld local scopeAgdaNew local scope&dAgda(Restrict search to these kinds of names.AgdaUnless 7>., restrict search to match any of these names.AgdaName to be resolvedAgda<If illegally ambiguous, throw error with the ambiguous name.&iAgda9The name must correspond to one of the names in this set.&jAgda, , let, ...?AgdaConcrete name.AgdaAbstract name.&uAgda,Name of the scope, only for error reporting.Agda+Description of how scope is to be modified.Agda Input scope.Agda(Scope-checked description, output scope.&vAgdaTranslation of imported names.Agda,Translation of names defined by this import.&yAgdaTranslation of G names and module names.AgdaTranslation of rento names and module names.Agda Renaming before translation (1).Agda Renaming after translation (2).I&4&6&5&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&{&|I&@&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&7&8&:&9&w&x&y&4&6&5&z&{&|None"#$&',14568=>?@ACEPSX_`s8OAgda$Name sets for classifying a pattern.8PAgdaName of defined symbol.8QAgdaValid constructor names.8RAgdaValid field names.8SAgdaThe result of &~ is either a pattern (7P ) or a lhs (7R).8TAgdaThe data returned by 8U.8VAgda8A parser for expressions or patterns (depending on the 8W argument given to 8U).8XAgda$A parser for sequences of arguments.8YAgda All operators notations1sections that were used to generate the grammar.8ZAgdaA flattened scope that only contains those names that are unqualified or qualified by qualifiers that occur in the list of names given to  buildParser.8WAgda*Expression kinds: Expressions or patterns.8[Agda$A data structure used internally by 8U.8\AgdaBills the operator parser.8]AgdaCompute all defined names in scope and their fixities/notations. Note that overloaded names (constructors) can have several fixities/notations. Then we  . (See issue 1194.)8^AgdaYCompute all names (first component) and operators/notations (second component) in scope.8UAgda_Builds parsers 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 unqualified 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.8_Agda$Returns the list of possible parses.8`Agda'Parses a left-hand side, workhorse for &~.8aAgda(Returns zero or one classified patterns.&~AgdaJParses a left-hand side, and makes sure that it defined the expected name.&AgdaParses a pattern.8bAgdaHelper function for &~ and &.8cAgdaHelper function for &~ and &.8dAgda,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].&Agda0Parse a list of expressions into an application.&AgdaZParse an expression into a module application (an identifier plus a list of arguments).8UAgda)Should expressions or patterns be parsed?AgdamThis list 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.8`AgdaOAre we trying to parse a lhs or a pattern synonym? For error reporting only!Agda=Name of the function/patSyn definition if we parse a lhs. 7> if we parse a pattern.AgdaThing to parse.Agda(The returned list contains all operators notations1sections that were used to generate the grammar.&~&&&&&&&~&&None"#$,14568=>?@ACEPSX_`w&AgdaBThese builtins may use postulates, and are still considered --safe&AgdaThese builtins may not use postulates under --safe. They are not automatically unsafe, but will be if they use an unsafe feature.0&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&0&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&None"#$,14568=>?@ACEPSX_` &AgdaSets the pragma options.&AgdaPSets 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 7P now, and were previously 7R something>), then the state is reset (completely, see setIncludeDirs) ./An empty list of relative include directories (7P []) is interpreted as ["."].&AgdaDisable display forms.&AgdaDisable display forms.&Agda#Check if display forms are enabled.&AgdaMMakes 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  _). An empty list is interpreted as ["."].&AgdaShould only be run if &.&Agda Return the  as  , if any.&AgdamSwitch on printing of implicit and irrelevant arguments. E.g. for reification in with-function generation. Restores all > after completion. Thus, do not attempt to make persistent  changes in a & bracket.&AgdaChange * for a computation and restore afterwards.&Agda%The base directory of relative paths.&Agda%The base directory of relative paths.&Agda%The base directory of relative paths.&AgdaNew include directories.Agda%The base directory of relative paths.&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&None"#$,14568=>?@ACEPSX_`k,&AgdaPerforms void (noAbs) abstraction over telescope.&AgdaApply ElimsW while using the given function to report ill-typed redexes. Recursive calls for applyE and  applySubst happen at type t/ to propagate the same strategy to subtrees.&AgdaIf $v$ is a record value, canProject f v returns its field f.&AgdaEliminate a constructed term.&AgdadefApp 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.&Agda  (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.&AgdaIf permute  : [a] -> [a], then ,applySubst (renaming _ ) : Term  -> Term &AgdaIf permute  : [a] -> [a], then +applySubst (renamingR ) : Term  -> Term &AgdaNThe permutation should permute the corresponding context. (right-to-left list)&Agda  projDropParsApply proj o args = ! proj o `apply' argssThis function is an optimization, saving us from construction lambdas we immediately remove through application.'AgdalTakes off all exposed function domains from the given type. This means that it does not reduce to expose Pi-types.'AgdatelView'UpTo n t takes off the first n exposed function types of t#. Takes off all (exposed ones) if n < 0.'AgdaTurn a typed binding (x1 .. xn : A) into a telescope.'AgdaTurn a typed binding (x1 .. xn : A) into a telescope.'Agda )mkPi dom t = telePi (telFromList [dom]) t' Agda)Uses free variable analysis to introduce  bindings.' AgdaEverything will be an .' AgdanOnly abstract the visible components of the telescope, and all that bind variables. Everything will be an ! Caution: quadratic time!' Agda]Abstract over a telescope in a term, producing lambdas. Dumb abstraction: Always produces , never .$The implementation is sound because  does not use .' AgdaGiven arguments vs : tel= (vector typing), extract their individual types. Returns Nothing is tel is not long enough.'AgdaIn compiled clauses, the variables in the clause body are relative to the pattern variables (including dot patterns) instead of the clause telescope.'AgdaunivSort' univInf s gets the next higher sort of s), if it is known (i.e. it is not just  UnivSort s). univInf is returned as the sort of Inf.Precondition: s is reduced'AgdaQCompute the sort of a function type from the sorts of its domain and codomain.'AgdaKCompute the sort of a pi type from the sorts of its domain and codomain.'AgdaGiven two levels a and b , compute a " b" and return its canonical form.'AgdazEquality of binders relies on weakening which is a special case of renaming which is a special case of substitution.' Agda Syntactic  equality, ignores stuff below DontCare and sharing.'"Agda Syntactic $ equality, ignores sort annotations.'bAgdatel " ( " 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'.'Agda)Make sure we only drop variable patterns.i\]c^_`ab&&&&&&&&&&&&&&&&&&&&&&&&&&&&'''''''''' ' ' ' ' ''''''''''''>&&&&&&&&&&&&&&&&&&&&&&&&&&&&'''''''''' ' ' ' ' '''''''''''']c^_`ab\None"#$,14568=>?@ACEPSX_`̜'Agda+Create an open term in the current context.'Agda`Extract the value from an open term. The checkpoint at which it was created must be in scope.'Agda-Extract the value from an open term. Returns 7>> if the checkpoint at which it was created is not in scope.'AgdaAn " is closed if it has checkpoint 0.''''''''None"#$,14568=>?@ACEPSX_`#AgdaaddCtx x arg cont add a variable to the context.Chooses an unused  a.7Warning: Does not update module parameter substitution!#Agda'Add a let bound variable to the context#AgdanUpdate the context. Requires a substitution that transports things living in the old context to the new.#AgdaSGet the substitution from the context at a given checkpoint to the current context.'AgdaWrapper to tell ' not to mark names as ^Z. Used when adding a user-provided, but already type checked, telescope to the context.'AgdaVarious specializations of addCtx.'Agda Modify a UE in a computation. Warning: does not update the checkpoints. Use  updateContext instead.'Agda Modify the  part of context entries.'Agda7Change to top (=empty) context. Resets the checkpoints.'AgdaVChange to top (=empty) context, but don't update the checkpoints. Totally not safe!'AgdaDelete the last n bindings from the context. Doesn't update checkpoints! Use 'M or `updateContext rho (drop n)` instead, for an appropriate substitution rho.'AgdaDelete the last n\ bindings from the context. Any occurrences of these variables are replaced with the given err.'Agda*Add a new checkpoint. Do not use directly!'AgdaSGet the substitution from the context at a given checkpoint to the current context.'AgdaGet substitution   "  : m where  is the current context and m- is the module parameter telescope of module m.Returns Nothing, in case the we don't have a checkpoint for m.'Agda:Default implementation of addCtx in terms of updateContext'AgdaRun the given TCM action, and register the given variable as being shadowed by all the names with the same root that are added to the context during this TCM action.'Agda;Go under an abstraction. Do not extend context in case of .'Agda"Go under an abstraction, treating  as .'AgdaKGo under an abstract without worrying about the type to add to the context.'AgdalMap a monadic function on the thing under the abstraction, adding the abstracted variable to the context.'AgdaAdd a let bound variable'AgdaAdd a let bound variable'AgdaGet the current context.'Agda$Get the size of the current context.'Agda Generate [var (n - 1), ..., var 0]% for all declarations in the context.'Agda Generate [var (n - 1), ..., var 0]% for all declarations in the context.'AgdaGet the current context as a .'Agda1Get the names of all declarations in the context.'Agda0get type of bound variable (i.e. deBruijn index)'AgdaGet 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"#$,14568=>?@ACEPSX_`U 'AgdaThe coinductive primitives.'AgdagetTerm use name looks up nameA as a primitive or builtin, and throws an error otherwise. The useL argument describes how the name is used for the sake of the error message.'Agda2Rewrite a literal to constructor form if possible.(AgdaTries to build a '.(Agda_Check whether the type is actually an path (lhs "a rhs) and extract lhs, rhs, and their type.Precondition: type is reduced.(AgdaNon dependent Path(Agda Revert the I.Postcondition: type is reduced.(Agda"Get the name of the equality type.(AgdacCheck whether the type is actually an equality (lhs "a rhs) and extract lhs, rhs, and their type.Precondition: type is reduced.(Agda Revert the R.Postcondition: type is reduced.(Agda(Primitives with typechecking constrants.hijklmnopqrstuvwxyz{|}~     ##''''''''''''''''''''''''''''(((((((((( ( ( ( ( ((((((((((((((((((( (!("(#($(%(&('((()(*(+(,(-(.(/(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({(|(}(~(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((None"#$,14568=>?@ACEPSX_`&((AgdaA deep view on sizes.(AgdaA useful view on sizes.(AgdaCheck if a type is the (5 type. The argument should be reduced.(Agda)Result of querying whether size variable i is bounded by another size.(Agdayes  i : Size< t(AgdaQTest whether OPTIONS --sized-types and whether the size built-ins are defined.(Agda+Test whether the SIZELT builtin is defined.(Agda$Add polarity info to a SIZE builtin.(AgdaThe sort of built-in types SIZE and SIZELT.(AgdaThe type of built-in types SIZE and SIZELT.(AgdaThe built-in type SIZE with user-given name.(AgdaThe built-in type SIZE.(Agda The name of SIZESUC.(Agda>Transform list of terms into a term build from binary maximum.(AgdaExpects argument to be reduced.(AgdasizeViewComparable v w checks whether v >= w (then Left) or v <= w (then Right ). If uncomparable, it returns  NotComparable.(AgdasizeViewPred k v decrements v by k (must be possible!).(AgdasizeViewOffset v8 returns the number of successors or Nothing when infty.(Agda'Remove successors common to both sides.(AgdaTurn a size view into a term.(AgdamaxViewCons v ws = max v ws. It only adds v to ws+ if it is not subsumed by an element of ws.(AgdasizeViewComparableWithMax v ws tries to find w in ws that compares with v+ and singles this out. Precondition:  v /= DSizeInv.2((((((((((((((((((((((((((((((((((((((((((((((((((2((((((((((((((((((((((((((((((((((((((((((((((((((None"#$,14568=>?@ACEPSX_`V`!)Agda We need: - Read access to the AbsToCon environment - Read access to the TC environment - Read access to the TC state - Read and write access to the stConcreteNames part of the TC state - Read access to the options - Permission to print debug messages8eAgdaAbstract names currently in scope. Unlike the ScopeInfo, this includes names for hidden arguments inserted by the system.8fAgda*Concrete names of all definitions in scope8gAgdaCertain builtins (like fromNat) have special printing8hAgdaPreserve interaction point ids8iAgdaCBind a concrete name to an abstract in the translation environment.8jAgdaJGet a function to check if a name refers to a particular builtin function.8kAgdaNResolve a concrete name. If illegally ambiguous fail with the ambiguous names.8lAgda0Treat illegally ambiguous names as UnknownNames.8mAgda|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...8nAgda]Is this concrete name currently in use by a particular abstract name in the current scope?8oAgdauHave we already committed to a specific concrete name for this abstract name? If yes, return the concrete name(s).8pAgdawCommit to a specific concrete name for printing the given abstract name. If the abstract name already has associated8qAgdaCFor the given abstract name, return the names that could shadow it.8rAgda8Choose a new unshadowed name for the given abstract name8sAgdaQAdd a abstract name to the scope and produce an available concrete version of it.8tAgdaLike 8s0, but do not care whether name is already taken.8uAgdaGeneral bracketing function.8vAgdaExpression bracketing8wAgdaPattern bracketing8xAgdarApplications where the argument is a lambda without parentheses need parens more often than other applications.8yAgda|If a name is defined with a fixity that differs from the default, we have to generate a fixity declaration for that name.8zAgdaAdd abstract, private, instance modifiers.)Agda9Translate something in a context of the given precedence.8{Agda9Translate something in a context of the given precedence.8|Agda'Translate something in the top context.8}Agda'Translate something in the top context.8~Agda.Translate something in a context indicated by   info.8Agda.Translate something in a context indicated by   info.8Agda)Recover pattern synonyms for expressions.8Agda%Recover pattern synonyms in patterns.8AgdaCGeneral pattern synonym recovery parameterised over expression type)-AgdaAssumes name is not .8uAgdathe bracketing functionAgda?Should we bracket things which have the given precedence?8AgdaCheck for lambdas)))))))))) ) ) ) ) ))))))))) )) ))) ) ))))) None"#$,14568=>?@ACEPSX_`Y)OAgda Variant of )L- which does not insert outermost parentheses.)PAgda Variant of )M- which does not insert outermost parentheses.)L)M)N)O)P)L)M)N)O)PNone"#$,14568=>?@ACEPSX_`d)QAgda:When making a function projection-like, we drop the first n arguments.)TAgdaTo 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.)UAgdamUse for dropping initial lambdas in clause bodies. NOTE: does not reduce term, need lambdas to be present.)WAgda,NOTE: does not work for recursive functions.)YAgda=NOTE: This creates telescopes with unbound de Bruijn indices.)Q)R)Q)RNone"#$,14568=>?@ACEHPSVX\_`-=#AgdaoLookup the definition of a name. The result is a closed thing, all free variables have been abstracted over.#Agda Version that reports exceptions:#Agda4Lookup the rewrite rules with the given head symbol.#AgdaSignature lookup errors.#Agda8The name is not in the signature; default error message.#Agda0The name is not available, since it is abstract.#AgdaLookup a section telescope._If it doesn't exist, like in hierarchical top-level modules, the section telescope is empty.#AgdaUnless 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.)[AgdaCAdd a constant to the signature. Lifts the definition to top level.)\Agda2Set termination info of a defined function symbol.)]Agda1Set CompiledClauses of a defined function symbol.)^Agda+Set SplitTree of a defined function symbol.)_Agda!Modify the clauses of a function.)`AgdaPLifts clauses to the top-level and adds them to definition. Also adjusts the funCopatternLHS field if necessary.)bAgda#Add a compiler pragma `{-# COMPILE  backend  name  text #-}`)iAgdaAdd a section to the signature.[The current context will be stored as the cumulative module parameters for this section.)jAgdaCSets the checkpoint for the given module to the current checkpoint.)kAgdaGet a section.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.)mAgda>Module application (followed by module parameter abstraction).)oAgdaLAdd a display form to a definition (could be in this or imported signature).)rAgdaCFind all names used (recursively) by display forms of a given name.)sAgda#Check if a display form is looping.)vAgdaNCan be called on either a (co)datatype, a record type or a (co)constructor.)wAgda?Does the given constructor come from a single-constructor type?5Precondition: The name has to refer to a constructor.)xAgdaStandard eliminator for #.)zAgda`Get the original name of the projection (the current one could be from a module application).)}Agda%Look up the polarity of a definition.)~AgdaMLook up polarity of a definition and compose with polarity represented by  .)Agda!Set the polarity of a definition.)Agda-Look up the forced arguments of a definition.)Agda*Get argument occurrence info for argument i of definition d (never fails).)Agda Sets the ^I for the given identifier (which should already exist in the signature).)AgdaReturns a list of length K. If no erasure analysis has been performed yet, this will be a list of 7Qs.)Agda#add data constructors to a datatype)AgdaFGet the mutually recursive identifiers of a symbol from the signature.)Agda.Get the mutually recursive identifiers from a X.)Agda'Set the mutually recursive identifiers.)Agda5Check whether two definitions are mutually recursive.)Agda A functiondataVrecord definition is nonRecursive if it is not even mutually recursive with itself.)Agda3Get the number of parameters to the current module.)AgdaCompute 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).)Agda7Compute 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 ] )AgdaPInstantiate a closed definition with the correct part of the current context.)Agda'Give the abstract view of a definition.)AgdaOEnter abstract mode. Abstract definition in the current module are transparent.)Agda:Not in abstract mode. All abstract definitions are opaque.)Agda?Ignore abstract mode. All abstract definitions are transparent.)AgdaeEnter concrete or abstract mode depending on whether the given identifier is concrete or abstract.)AgdaMCheck 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.)AgdaAndreas, 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.)Agda<Get type of a constant, instantiated to the current context.)AgdaGet relevance of a constant.)AgdaGet modality of a constant.)AgdapThe number of dropped parameters for a definition. 0 except for projection(-like) functions and constructors.)Agda&Is it the name of a record projection?)AgdaIs it a function marked STATIC?)AgdaIs it a function marked INLINE?)AgdaReturns 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).)AgdaDNumber of dropped initial arguments of a projection(-like) function.)Agda+Check whether a definition uses copatterns.)AgdaApply a function fF to its first argument, producing the proper postfix projection if f is a projection.)mAgda/Name of new module defined by the module macro.AgdaParameters of new module.Agda(Name of old module applied to arguments.Agda Arguments of module application.AgdaImported names and modules[#########)[)\)])^)_)`)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"#$,14568=>?@ACEPSX\_`$2)AgdacUnfreeze meta and its type if this is a meta again. Does not unfreeze deep occurrences of metas.)AgdapCheck whether all metas are instantiated. Precondition: argument is a meta (in some form) or a list of metas.)AgdaPMonad service class for creating, solving and eta-expanding of metavariables.)AgdajGenerate a new meta variable with some instantiation given. For instance, the instantiation could be a .)AgdaAssign 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.)AgdaDirectly instantiate the metavariable. Skip pattern check, occurs check and frozen check. Used for eta expanding frozen metas.)AgdavEta expand a metavariable, if it is of the specified kind. Don't do anything if the metavariable is a blocked term.)Agda%Update the status of the metavariable)Agda/'speculateMetas fallback m' speculatively runs m, but if the result is )6 any changes to metavariables are rolled back and fallback is run instead.)AgdaVarious kinds of metavariables.)AgdaMeta variables of record type.)Agda7Meta variables of "hereditarily singleton" record type.)Agda;Meta variables of level type, if type-in-type is activated.)Agda All possible metavariable kinds.)AgdaSwitch off assignment of metas.)AgdaGet the meta store.)Agda8Run a computation and record which new metas it created.)AgdaLookup a meta variable.)AgdaType of a term or sort meta.)Agda7Update the information associated with a meta variable.)AgdaKInsert a new meta variable with associated information into the meta store.)AgdaZCompute the context variables that a meta should be applied to, accounting for pruning.)Agda=Given a meta, return the type applied to the current context.)Agda'Is it a meta that might be generalized?)AgdaReturns all metavariables in a constraint. Slightly complicated by the fact that blocked terms are represented by two meta variables. To find the second one we need to look up the meta listeners for the one in the UnBlock constraint.)AgdaCreate  in the current environment.)AgdafRegister an interaction point during scope checking. If there is no interaction id yet, create one.)AgdaFind an interaction point by f by searching the whole map.<O(n): linear in the number of registered interaction points.)Agda+Hook up meta variable to interaction point.)Agda$Mark an interaction point as solved.)AgdaGet a list of interaction ids.)Agda:Get all metas that correspond to unsolved interaction ids.)Agda:Get all metas that correspond to unsolved interaction ids.)Agda:Does the meta variable correspond to an interaction point?Time: O(n) where n$ is the number of interaction metas.)Agda7Get the information associated to an interaction point.)AgdaGet zK for an interaction point. Precondition: interaction point is connected.)AgdaKCheck whether an interaction id is already associated with a meta variable.)AgdaGenerate new meta variable.)AgdajGenerate a new meta variable with some instantiation given. For instance, the instantiation could be a .)AgdaGet the f for an interaction point.)AgdaGet the f for a meta variable.)AgdalistenToMeta l m : register l as a listener to m3. This is done when the type of l is blocked by m.)AgdaUnregister a listener.)AgdaGet the listeners to a meta.)AgdaKFreeze all so far unfrozen metas for the duration of the given computation.*AgdaGFreeze all meta variables and return the list of metas that got frozen.*AgdaHFreeze some meta variables and return the list of metas that got frozen.*AgdaThaw all meta variables.*Agda6Thaw some metas, as indicated by the passed condition.*AgdaDoes not worry about raising.R#c#e#d))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))*****R)))))))))))))))))))))))))))))))))))))))))))#c#e#d)))))))))))))))))))))))))))))*****))None"#$,14568=>?@ACEMPSX_`*>AgdaStrenghtening.*-*.*/*0*1*2*3*4*5*6*7*8*9*:*;*<*=*>*7*8*5*6*3*4*9*:*;*1*2*<*=*/*0*-*.*>None"#$,14568=>?@ACEPSX_` T8Agda0Don't generate fresh names for unused variables.None"#$,14568=>?@ACEPSX_` B*Y*YNone"#$,14568=>?@ACEPSX_` 8*Z*ZsNone"#$,14568=>?@ACEPSX_` .hijklmnopqrstuvwxyz{|}~      RQST             [\ktr]^_`abcdefghijlmnopqsuvwxyz{|}~     VUWXYZ !: !"#$%&'()*+,-./0123456789;<=>?@ABCDE !?@ABCDEFGHIJKLMNOPQRST[\]^_`abcdefghijklmnopqrstuvwxyz{|}~     FGHIJKLMNOPQRSTUVWXYZ      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPUVWXYdZ[\]^_`abcefghijklmnopqrstuvwxyz{|}~                         ! " # $ % & ' ( ) * + , - . / 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 T S Q R 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!{!|!}!~!!!!!!!!!!!!!!!!!!!!!!!!!!!#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({(|(}(~((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((()[)\)])^)_)`)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"#$,14568=>?@ACEPSX_`.\None"#$,14568=>?@ACEPSX_`/JNone"#$,14568=>?@ACEPSX_`08None"#$,14568=>?@ACEPSX_`1&None"#$,14568=>?@ACEPSX_`C8AgdaThe result of * and *.8AgdaGThe uncompressed bytestring, without hashes and the interface version.8AgdaThe compressed bytestring.*AgdadEncodes something. To ensure relocatability file paths in positions are replaced with module names.*AgdatDecodes an uncompressed bytestring (without extra hashes or magic numbers). The result depends on the include path.Returns 7>$ if a decoding error is encountered.*AgdagEncodes an interface. To ensure relocatability file paths in positions are replaced with module names.OAn uncompressed bytestring corresponding to the encoded interface is returned.*Agda=Decodes an interface. The result depends on the include path.Returns 7>e if the file does not start with the right magic number or some other decoding error is encountered.8AgdaStore a  F (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.8Agda{Maps file names to the corresponding module names. Must contain a mapping for every file name that is later encountered.# **************# None"#$,14568=>?@ACEHPSVX_`J*AgdaIGet all the clauses of a definition and convert them to rewrite rules.*Agda-Generate a sensible name for the given clause*AgdaclauseToRewriteRule f q cl converts the clause cl of the function f to a rewrite rule with name q . Returns Nothing if  clauseBody cl is Nothing. Precondition:  clauseType cl is not Nothing.**********None"#$,14568=>?@ACEPSX_`K!q##****#!q#None"#$,14568=>?@ACEHPSVX_`O*AgdaBExpand literal integer pattern into suc/zero constructor patterns.*Agda7Expand away (deeply) all pattern synonyms in a pattern.********None"#$,14568=>?@ACEMPSX_`P2************************************None"#$,14568=>?@ACEPSX_`Q******None"#$,14568=>?@ACEPSX_`[#+Agda3Contracts all eta-redexes it sees without reducing.+Agda5If record constructor, call eta-contraction function.+Agda%Try to contract a lambda-abstraction Lam i (Abs x b).+AgdaConstructor name c.AgdaConstructor info ci.AgdaConstructor arguments args.Agda9Eta-contraction workhorse, gets also name of record type.AgdaReturns  Con c ci args or its eta-contraction.+AgdaInfo i of the .AgdaName x of the abstraction.AgdaBody () b of the .AgdaLam i (Abs x b), eta-contracted if possible.++++++++++++++++None"#$,14568=>?@ACEHPSVX\_`pf +AgdainstantiateFull' +(5s metas everywhere (and recursively) but does not +*.+AgdauOnly unfold definitions if this leads to simplification which means that a constructor/literal pattern is matched.+&AgdaInstantiate 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).+-AgdamNormalise the given term but also preserve blocking tags TODO: implement a more efficient version of this.+/Agda+Meaning no metas left in the instantiation.+0AgdaCase 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.+:AgdaIf the first argument is 770, then a single delayed clause may be unfolded.+>AgdaIReduce a non-primitive definition if it is a copy linking to another def.+?Agda*Reduce simple (single clause) definitions.+@Agda!Unfold a single inlined function.+AAgdapApply a definition using the compiled clauses, or fall back to ordinary clauses if no compiled clauses exist.+CAgdaApply a defined function to it's arguments, using the compiled clauses. The original term is the first argument applied to the third.+EAgdaGApply a defined function to it's arguments, using the original clauses..++++++ +!+#+"+$+%+&+'+(+)+*+++,+-+.+/+0+1+2+3+4+5+6+7+8+9+:+;+<+=+>+?+@+A+B+C+D+E+F+G+H.+(+)+*+++,+-+.+/+&+'+$+%+0+1+!+#+"+2+3+4+5+6+7+8+9+:+;+<+=+>+?+@+A+B+C+D+E+F++ +G+++H++None"#$,14568=>?@ACEPSX_`ˠ$'AgdaA safe variant of &.'Agda+Gather leading s of a type in a telescope.+Agda  [ (i,(x,y)) ] = [(i=0) -> x, (i=1) -> y]+AgdaA telescope split in two.+Agda;The permutation takes us from the original telescope to firstPart ++ secondPart.+Agda(Flatten telescope: ( : Tel) -> [Type ]+AgdaYOrder 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.,Agda\Unflatten: turns a flattened telescope into a proper telescope. Must be properly ordered.,AgdaJRename the variables in the telescope to the given names Precondition: size xs == size tel.,Agda(Get the suggested names from a telescope,Agda A variant of , which takes the argument names (and the argument info) from the first telescope and the variable names from the second telescope.6Precondition: the two telescopes have the same length., Agda.Split the telescope at the specified position., AgdaPermute telescope: permutes or drops the types in the telescope according to the given permutation. Assumes that the permutation preserves the dependencies in the telescope.3For example (Andreas, 2016-12-18, issue #2344): x tel = (A : Set) (X : _18 A) (i : Fin (_m_23 A X)) tel (de Bruijn) = 2:Set, 1:_18 0, 0:Fin(_m_23 1 /0) flattenTel tel = 2:Set, 1:_18 0, 0:Fin(_m_23 1 0) |- [ Set, _18 2, Fin (_m_23 2 1) ] perm = 0,1,2 -> 0,1 (picks the first two) renaming _ perm = [var 0, var 1, error] -- THE WRONG RENAMING! renaming _ (flipP perm) = [error, var 1, var 0] -- The correct renaming! apply to flattened tel = ... |- [ Set, _18 1, Fin (_m_23 1 60) ] permute perm it = ... |- [ Set, _18 11 ] unflatten (de Bruijn) = 1:Set, 0: _18 90 unflatten = (A : Set) (X : _18 A) , AgdaRecursively computes dependencies of a set of variables in a given telescope. Any dependencies outside of the telescope are ignored., AgdaComputes the set of variables in a telescope whose type depend on one of the variables in the given set (including recursive dependencies). Any dependencies outside of the telescope are ignored., Agda^Split a telescope into the part that defines the given variables and the part that doesn't.See tu.,Agda|As splitTelescope, but fails if any additional variables or reordering would be needed to make the first part well-typed.,AgdaTry 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.,AgdaQTry to eta-expand one variable in the telescope (given by its de Bruijn level),AgdatelViewUpTo n t takes off the first n function types of t. Takes off all if n < 0.,AgdatelViewUpTo' n p t takes off $t$ the first n (or arbitrary many if n < 0-) function domains as long as they satify p.,AgdatelViewUpToPath n t takes off $t$ the first n (or arbitrary many if n < 0!) function domains or Path types.,AgdaLike telViewUpToPath but also returns the Boundarya expected by the Path types encountered. The boundary terms live in the telescope given by the TelViewc. Each point of the boundary has the type of the codomain of the Path type it got taken from, see  fullBoundary.,Agda8(TelV  b, [(i,t_i,u_i)]) <- telViewUpToPathBoundary n ah Input:  " a Output:  " b  " i : I  " [ (i=0) -> t_i; (i=1) -> u_i ] : b,Agda9(TelV  b, [(i,t_i,u_i)]) <- telViewUpToPathBoundaryP n a Input:  " a Output: . " b . " T is the codomain of the PathP at variable i . " i : I . " [ (i=0) -> t_i; (i=1) -> u_i ] : T Useful to reconstruct IApplyP patterns after teleNamedArgs .,AgdateleElimsB args bs = es Input: . " args :  . " T is the codomain of the PathP at variable i . " i : I . " bs = [ (i=0) -> t_i; (i=1) -> u_i ] : T Output: . | PiPath  bs A " es : A,Agda'returns Left (a,b) in case the type is Pi a b or  PathP b _ _ assumes the type is in whnf.,$AgdaDecomposing a function type.,%AgdaIf 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.,&AgdaIf 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.,'Agda&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.,(Agda&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.,*AgdaCompute type arity,+AgdaoStrips all hidden and instance Pi's and return the argument telescope and head definition name, if possible.,,Agda:Register the definition with the given type as an instance,.AgdaTry 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., AgdaA set of de Bruijn indices.AgdaOriginal telescope.Agda firstPart mentions the given variables,  secondPart not.,AgdaA list of de Bruijn indicesAgdaThe telescope to splitAgda firstPart5 mentions the given variables in the given order,  secondPart contains all other variables,Agda" Agda! " var k : A de Bruijn _level_Agda  " u : AA'''+++++++++++++++,,,,,,,,,, , , , , ,,,,,,,,,,,,,,,,,,, ,!,",#,$,%,&,',(,),*,+,,,-,.A++,,,,,,,,,, , , , +++++, ,,,',,,,++,,,,,,,,,,,, ,!,",#,$,%,&,',(,)'',*++++++,+,,,-,.None"#$,14568=>?@ACEPSX_`A,3Agda,Instantiate full as long as things are equal8Agda%Monad for checking syntactic equality,4Agda'Syntactic equality check for terms. w 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.+This means in particular that the returned v,v' cannot be MetaVs that are instantiated.8AgdaReturn, flagging inequalty.8Agda0If inequality is flagged, return, else continue.,;Agda!Syntactic equality ignores sorts.,@Agda Syntactic term equality ignores  stuff.,3,4,3,4None"#$,14568=>?@ACEPSX_`d,cAgdaAbbreviation: argN =  u.,eAgdaAbbreviation: argH = %  u.*,B,C,G,F,E,D,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*,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,B,C,G,F,E,D,k,H4,I4,J4,X9 ,Y9 None"#$,14568=>?@ACEPSX\_`,Agda;Define a "ghcomp" version of gcomp. Normal comp looks like:Scomp^i A [ phi -> u ] u0 = hcomp^i A(1/i) [ phi -> forward A i u ] (forward A 0 u0)So for "gcomp" we compute:mgcomp^i A [ phi -> u ] u0 = hcomp^i A(1/i) [ phi -> forward A i u, ~ phi -> forward A 0 u0 ] (forward A 0 u0)rThe point of this is that gcomp does not produce any empty systems (if phi = 0 it will reduce to "forward A 0 u".,Agda Tries to  primTranspx a whole telescope of arguments, following the rule for  types. If a type in the telescope does not support transp,  transpTel throws it as an exception.,AgdaLike  transpTel but performing a transpFill..,n,p,o,q,s,r,t,u,w,v,x,y,z,{,|,},~,,,,,,,,,,,,,,,,,,,,,,,,,,,,,.,x,y,z,{,|,},~,,,,,,,,,,,,u,w,v,,q,s,r,t,,,n,p,o,,,,,,,,,,,,,,,None"#$&',14568=>?@ACEPSX_`x,Agda:Convert a term (from a dot pattern) to a DeBruijn pattern.,,,,,,None"#$,14568=>?@ACEPSX_` ,AgdaA  SingleLevel is a Level3 that cannot be further decomposed as a maximum a " b.,AgdaGet the (@ as a .,Agda-Raises an error if no level kit is available.,Agda,Checks whether level kit is fully available.,AgdaGiven a level l, find the maximum constant n such that  l = n + l',AgdaGiven a level l, find the biggest constant n such that n <= l,AgdaGiven a constant n and a level l, find the level l' such that  l = n + l'Q (or Nothing if there is no such level). Operates on levels in canonical form.,AgdaGiven two levels a and b%, try to decompose the first one as  a = a' " b (for the minimal value of a').,Agda Return the maximum of the given  SingleLevels$(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,$,,,,,,,,,,,,,,,,,(,,,,,,,,,,,,,,,,,,None"#$,14568=>?@ACEPSX_`,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,None"#$,14568=>?@ACEMPSX\_`,AgdabuildList A ts builds a list of type List A. Assumes that the terms ts all have type A.,AgdamkPrimInjective takes two Set0 a and b and a function f of type a -> b5 and outputs a primitive internalizing the fact that f is injective.-Agda GprimEraseEquality : {a : Level} {A : Set a} {x y : A} -> x "a y -> x "a y-AgdaGet the + of the principal argument of BUILTIN REFL.Returns Nothing for e.g. P data Eq {a} {A : Set a} (x : A) : A ! Set a where refl : Eq x x Returns Just ... for e.g. V data Eq {a} {A : Set a} : (x y : A) ! Set a where refl : " x ! Eq x x -AgdaUsed for both  primForce and primForceLemma.#`,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,n,o,p,q,r,s,t,u,v,w,x,y,z,{,|,},~,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,---------- - - - - ------#`,,,,,,,,,,,,,,,,,,,,,,,,,---------- - - - - -----None"#$,14568=>?@ACEPSX_`-MAgdasimplifyLevelConstraint c cs turns an cp into an equality constraint if it is an inequality constraint and the reverse inequality is contained in cs.The constraints don't necessarily have to live in the same context, but they do need to be universally quanitfied over the context. This function takes care of renaming variables when checking for matches.8AgdaICheck if two inequality constraints are the same up to variable renaming.8AgdaZTurn a level constraint into a list of inequalities between single levels, if possible.-MAgda Constraint c to simplify.Agda)Other constraints, enable simplification.AgdaJust,: list of constraints equal to the original c. Nothing: no simplification possible.-M-MNone"#$,14568=>?@ACEPSX_` -PAgdaRun the given action. At the end take all new metavariables of type level for which the only constraints are upper bounds on the level, and instantiate them to the lowest level.-P-Q-P-QNone"#$,14568=>?@ACEPSX_`-SAgda!A variable can either not occur (-U) or it does occur (-Tl). In the latter case, the occurrence may disappear depending on the instantiation of some set of metas.-VAgdaTry to enforce a set of variables not occurring in a given type. Returns a possibly reduced version of the type and for each of the given variables whether it is either not free, or maybe free depending on some metavariables.-R-S-T-U-V-R-V-S-T-UNone"#$,14568=>?@ACEPSX_`5-hAgdaaSubstitute terms with origin into display terms, replacing variables along with their origins.The purpose is to replace the pattern variables in a with-display form, and only on the top level of the lhs. Thus, we are happy to fall back to ordinary substitution where it does not matter. This fixes issue #2590.-jAgdaClass 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).-mAgda Convert a  into a .-nAgda0Get the arities of all display forms for a name.-oAgda!Find a matching display form for q es&. In essence this tries to rewrite q es with any display form  q ps --> dt! and returns the instantiated dt" if successful. First match wins.-pAgdaMatch a  q ps = v against q es. Return the  v[us]' if the match was successful, i.e., es / ps = Just us. -h-i-j-k-l-m-n-o-p -m-n-l-o-p-j-k-h-iNone"#$,14568=>?@ACEPSX_`8-}AgdauRun before serialisation to remove any definitions that are not reachable from the public interface to the module.-}-}None"#$,14568=>?@ACEPSX_`I$ AgdamatchCompiledE c es% takes a function given by case tree c and and a spine es$ and tries to apply the function to es.-AgdaA 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.-Agdamatch'- 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.$ $ ---$ $ ---None"#$,14568=>?@ACEPSX_`U8AgdaBWe compute for each clause the set of potentially recursive names.-AgdaGiven a list of formally mutually recursive functions, check for actual recursive calls in the bodies of these functions. Returns the actually recursive functions as strongly connected components.As a side effect, update the : field in the clauses belonging to the given functions.8AgdaDMark a function as terminating and all its clauses as non-recursive.8Agda=Mark all clauses of a function as recursive or non-recursive.8AgdarecDef names name returns all definitions from names* that are used in the type and body of name.-AgdaanysDef names a returns all definitions from names that are used in a.8AgdaWhich clauses are recursive?----None"#$,14568=>?@ACEPSX_`[1-Agda.Adds a new unique name to the current context.-Agda@Returns the name of the variable with the given de Bruijn index.-Agda^Translate reflected syntax to abstract, using the names from the current typechecking context.-Agda5Drop implicit arguments unless --show-implicit is on. ----------- -----------None"#$,14568=>?@ACEHPSVX\_`}u8Agda0Collect the binders in some abstract syntax lhs.8Agda blank bound e& replaces all variables in expression e that are not in bound by an underscore _. It is used for printing dot patterns: we don't want to make implicit variables explicit, so we blank them out in the dot patterns instead (this is fine since dot patterns can be inferred anyway).-AgdaJAlso tracks whether module parameters should be dropped from the patterns.-AgdaLike reify7 but instantiates blocking metas, useful for reporting.8Agda.Drops hidden arguments unless --show-implicit.8Agda.Drops hidden arguments unless --show-implicit.8Agda_If we are referencing the record from inside the record definition, we don't insert an | A.App8Agda.Drops hidden arguments unless --show-implicit.8AgdareifyDisplayForm f vs fallback tries to rewrite f vs with a display form for fK. If successful, reifies the resulting display term, otherwise, does fallback.-AgdareifyDisplayFormP; tries to recursively rewrite a lhs with a display form.=Note: we are not necessarily in the empty context upon entry!8Agda -nameFirstIfHidden (x:a) ({e} es) = {x = e} es8Agda?Removes argument names. Preserves names present in the source.8AgdaRemoves implicit arguments that are not needed, that is, that don't bind any variables that are actually used and doesn't do pattern matching. Doesn't strip any arguments that were written explicitly by the user.-AgdablankNotInScope e" replaces variables in expression e with _% if they are currently not in scope.-AgdatAssumes that pattern variables have been added to the context already. Picks pattern variable names from context.8AgdaIf the record constructor is generated or the user wrote a record pattern, turn constructor pattern into record pattern. Otherwise, keep constructor pattern.-AgdaBSkip reification of implicit and irrelevant args if option is off.-AgdaLHS head symbolAgda7Patterns to be taken into account to find display form.Agda.Remaining trailing patterns ("with patterns").Agda!New head symbol and new patterns. ---------- ----------None"#$,14568=>?@ACEPSX_`##Agda.  without the brackets.-Agda2Pairing something with a node (for printing only).. Agda!Comma-separated list in brackets.. Agda,Pretty print with a given context precedence.Agda#Proper pretty printing of patterns:+#################-------.......... . . . . ...+#################-------.......... . . . . ...#5#6#6.5None"#$,14568=>?@ACEPSX_`.RAgdaIn an ambient context , telePiPath f  t bs builds a type that can be telViewPathBoundaryP'ed into (TelV  t, bs'). . " t bs = [(i,u_i)]  = 0,(i : I),1 " b " {0,1}. .0 | u_i .b : (telePiPath f 1 t bs)(i = b)  " telePiPath f  t bs.R.S.R.SNone"#$,14568=>?@ACEPSX\_`.TAgdaSize constraints we can solve..UAgda Leq a +n b represents  a =< b + n.  Leq a -n b represents  a + n =< b..VAgdaAtomic size expressions..WAgda)A size meta applied to de Bruijn indices..XAgdaA de Bruijn index..YAgdaJCheck whether a type is either not a SIZELT or a SIZELT that is non-empty..ZAgda;Precondition: Term is reduced and not blocked. Throws a ! if undecided.[Agda-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..\AgdaOCheck whether a variable in the context is bounded by a size expression. If  x : Size< a, then a is returned..]AgdaXWhenever we create a bounded size meta, add a constraint expressing the bound. In boundedSizeMetaHook v tel a, tel includes the current context..^Agda#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.._AgdaOCompute the deep size view of a term. Precondition: sized types are enabled..aAgdaCompare two sizes..bAgdaCompare two sizes in max view..cAgdacompareBelowMax u vs checks  u <= max vs. Precondition:  size vs >= 2.eAgdaIf iy then postpone as constraint, otherwise, fail hard. Failing is required if we speculatively test several alternatives..fAgda3Checked whether a size constraint is trivial (like X <= X+1)..gAgda9Test whether a problem consists only of size constraints..hAgda-Test whether a constraint speaks about sizes..kAgda?Take out all size constraints of the given direction (DANGER!)..lAgda4Find the size constraints of the matching direction..mAgda.Return a list of size metas and their context..nAgdaCompute 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. v.oAgda@Turn a constraint over de Bruijn indices into a size constraint..pAgdaFTurn a term with de Bruijn indices into a size expression with offset. Throws a !, if the term isn't a proper size expression..qAgdaUCompute list of size metavariables with their arguments appearing in a constraint..rAgdaKConvert 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..sAgdaAMain 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.tAgda&Old solver for size constraints using Agda.Utils.Warshall6. This solver does not smartly use size hypotheses  j : Size< i..jAgdaTest for being a sized typeAgda Restriction to these directions..tAgdaSize metas and their arity.Agda(Size constraints (in preprocessed form).AgdaReturns False if solver fails.!.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!.Y.Z.[.\.].^._.`.a.b.c.d.e.f.g.h.i.j.k.l.m.V.W.X.T.U.n.o.p.q.r.s.tNone"#$,14568=>?@ACEPSX_`.z.zNone"#$,14568=>?@ACEPSX_`#.{.{#None"#$,14568=>?@ACEPSX\_`$Agda,Is a type a proposition? (Needs reduction.)$AgdasModify the context whenever going from the l.h.s. (term side) of the typing judgement to the r.h.s. (type side)..~AgdaHCheck whether something can be used in a position of the given modality.jThis is a substitute for double-checking that only makes sure modalities are correct. See issue #2640.Used in unifier ( unifyStep Solution{}).This uses McBride-style modality checking. It does not differ from Pfenning-style if we are only interested in the modality of the free variables, used meta-variables, and used definitions..AgdaICheck whether something can be used in a position of the given relevance.jThis is a substitute for double-checking that only makes sure relevances are correct. See issue #2640.Used in unifier ( unifyStep Solution{}).=At the moment, this implements McBride-style irrelevance, where Pfenning-style would be the most accurate thing. However, these two notions only differ how they handle bound variables in a term. Here, we are only concerned in the free variables, used meta-variables, and used (irrelevant) definitions..AgdaZPrepare parts of a parameter telescope for abstraction in constructors and projections..AgdaTInternal workhorse, expects value of --experimental-irrelevance flag as argument..Agda(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.-Also allow the use of irrelevant definitions..Agda(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.Precondition: Relevance /= Relevant.AgdaApply relevance relv the the relevance annotation of the (typing/equality) judgement. This is part of the work done when going into a rel -context.Precondition: Relevance /= Relevant.AgdaLike . , but only act on context if --irrelevant-projections. See issue #2170..Agda(Conditionally) wake up erased variables and make them unrestricted. For instance, in an erased function argument otherwise erased variables may be used, so they are awoken before type checking the argument.)Also allow the use of erased definitions..Agda(Conditionally) wake up erased variables and make them unrestricted. For instance, in an erased function argument otherwise erased variables may be used, so they are awoken before type checking the argument.Precondition: Quantity /= Quantity1.AgdaApply quantity qu the the quantity annotation of the (typing/equality) judgement. This is part of the work done when going into a q -context.Precondition: Quantity /= Quantity1.AgdaHApply inverse composition with the given cohesion to the typing context..Agda0Can we split on arguments of the given cohesion?.Agda(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.-Also allow the use of irrelevant definitions..Agda(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.Precondition: Modality /= Relevant.AgdaApply modality mu the the modality annotation of the (typing/equality) judgement. This is part of the work done when going into a m -context.Precondition: Modality /= Relevant.AgdaLike .0, but only act on context (for Relevance) if --irrelevant-projections. See issue #2170..Agda Wake up irrelevant variables and make them relevant. This is used when type checking terms in a hole, in which case you want to be able to (for instance) infer the type of an irrelevant variable. In the course of type checking an irrelevant function argument .> is used instead, which also sets the context relevance to . This is not the right thing to do when type checking interactively in a hole since it also marks all metas created during type checking as irrelevant (issue #2568).$$.~......................$...................~.$.None"#$,14568=>?@ACEPSX\_`eD-*AgdaTCheck if a name refers to a record constructor. If yes, return record definition.*AgdaKCheck if a constructor name is the internally generated record constructor.%Works also for abstract constructors.*Agda,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.1If all fields are erased, we cannot eta-contract.*Agda3Check if a name refers to an eta expandable record.*AgdaHCheck if a name refers to a record. If yes, return record definition..Agda8Replace projection patterns by the original projections..AgdaTyping of an elimination..AgdaType of the argument..Agda+The type of the record which is eliminated..AgdaThe type of the field..Agda*Order the fields of a record construction..AgdaA 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..Agda1The name of the module corresponding to a record..AgdayGet the definition for a record. Throws an exception if the name does not refer to a record or the record is abstract..Agda.Get the record name belonging to a field name..Agda Get the field names of a record..Agda0Find all records with at least the given fields..Agda Get the field types of a record..Agda/Get the field names belonging to a record type..AgdaHReturns the given record type's constructor name (with an empty range)..AgdaReduce 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..AgdaReduce 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)..Agda*Get the original projection info for name..AgdagetDefType 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: w.AgdaThe analogue of &. If v is a value of record type t with field f, then projectTyped v t f returns the type of f v0. And also the record type (as first result).+Works also for projection-like definitions f9. In this case, the first result is not a record type.Precondition: t is reduced..AgdaAGiven a head and its type, compute the types of the eliminations..AgdaZGoing under one of these does not count as a decrease in size for the termination checker..AgdadCheck if a name refers to a record which is not coinductive. (Projections are then size-preserving).Agda`Check if a type is an eta expandable record and return the record identifier and the parameters..AgdaYTurn off eta for unguarded recursive records. Projections do not preserve guardedness..Agda`Turn on eta for inductive guarded recursive records. Projections do not preserve guardedness..AgdaETurn on eta for non-recursive record, unless user declared otherwise..Agda1Check whether record type is marked as recursive.9Precondition: record type identifier exists in signature..Agda 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   "  : ..Agda #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   "  : ..AgdaCPrecondition: variable list is ordered descendingly. Can be empty..Agda 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 ..AgdaetaExpand 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 an eta-expandable 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..AgdaDEta expand a record regardless of whether it's an eta-record or not..AgdaVIs 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..AgdaReturn the unique (closed) inhabitant if exists. In case of counting irrelevance in, the returned inhabitant contains dummy terms..Agda[Check whether a type has a unique inhabitant and return it. Can be blocked by a metavar..AgdahCheck whether a type has a unique inhabitant (irrelevant parts ignored). Can be blocked by a metavar..AgdaChecks 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..AgdaAuxiliary function..Agda(Name of record type (for error message).AgdaHow to fill a missing field.AgdaField names of the record type.Agda6Provided fields with content in the record expression.Agda#Content arranged in official order..Agda*Name of record type (for error reporting).Agda=Function to generate a placeholder for missing visible field.Agda Given fields.AgdaAll record field names with .AgdaBGiven fields enriched by placeholders for missing explicit fields..Agda"Record type. Need not be reduced..AgdaHead (record value).Agda Its type.Agda Projection.9******...................................................9.......*.....*...........*....**..............*..........None"#$,14568=>?@ACEPSX_`.AgdaWState worked on during the main loop of checking a lhs. [Ulf Norell's PhD, page. 35].Agda#The types of the pattern variables..AgdaPatterns after splitting. The de Bruijn indices refer to positions in the list of abstract syntax patterns in the problem, counted from the back (right-to-left)..AgdaUser patterns of supposed type delta..AgdaType eliminated by / in the problem. Can be x to indicate that we came by an irrelevant projection and, hence, the rhs must be type-checked in irrelevant mode..Agda%have we splitted with a PartialFocus?.Agda,The user patterns we still have to split on..AgdaXUser patterns which are typed (including the ones generated from implicit arguments)..AgdaCList of user patterns which could not yet be typed. 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 G problemEqs = [false = b] problemRestPats = [zero]  As we instantiate b to false, the  targetType reduces to  Nat -> Nat and we can move pattern zero over to  problemEqs..AgdaThe code that checks the RHS./AgdaFlexible variables are equipped with information where they come from, in order to make a choice which one to assign when two flexibles are unified./ AgdaWhen 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.../ AgdaFrom a record pattern (v). Saves the /  of its subpatterns./ Agda-From a hidden formal argument or underscore (WildP)./ AgdaFrom a dot pattern (u)./Agda*From a non-record constructor or literal (v or w)./AgdaClassify remaining patterns after splitting is complete into pattern variables, as patterns, dot patterns, and absurd patterns. Precondition: there are no more constructor patterns./AgdaBuild a renaming for the internal patterns using variable names from the user patterns. If there are multiple user names for the same internal variable, the unused ones are returned as as-bindings. Names that are not also module parameters are preferred over those that are./Agda"The telescope of pattern variablesAgda0The list of user names for each pattern variable=.............................////////// / / / / /////////////=// / / / //////// /..///.......////.............////.......//None"#$,14568=>?@ACEPSX\_`*AgdaIf matching is inconclusive (DontKnowE) we want to know whether it is due to a particular meta variable.*AgdamatchCopatterns ps es matches spine es against copattern spine ps.Returns *e and a substitution for the pattern variables (in form of IntMap 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).*AgdaIBuilds a proper substitution from an IntMap produced by match(Co)patterns/EAgda Instead of 8Q, we need to use this lazy version of combining pattern matching computations./HAgdaMatch a single copattern./IAgdaMatch a single pattern./KAgdaMatch a single pattern.*******/D/E/F/G/H/I/J/K/L****/D*/E/F/G*/H*/I/J/K/LNone"#$,14568=>?@ACEPSX_`g /QAgdaPossible results of /Z./RAgdaESuccess: this many implicits have to be inserted (list can be empty)./SAgdaJError: hidden argument where there should have been a non-hidden argument./TAgdaError: bad named argument./VAgdaimplicitArgs n expand t generates up to n* implicit argument metas (unbounded if n<0), as long as t is a function type and expand( holds on the hiding info of its domain./WAgdaimplicitNamedArgs n expand t generates up to n1 named implicit arguments metas (unbounded if n<0), as long as t is a function type and expand1 holds on the hiding and name info of its domain./XAgda'Create a metavariable according to the   info./YAgda'Create a questionmark according to the   info./ZAgdaIf the next given argument is a and the expected arguments are ts insertImplicit' a ts returns the prefix of ts that precedes a.If a+ is named but this name does not appear in ts, the /T exception is thrown./[AgdaIf the next given argument is a and the expected arguments are ts insertImplicit' a ts returns the prefix of ts that precedes a.If a+ is named but this name does not appear in ts, the /T exception is thrown./VAgdan0, the maximum number of implicts to be inserted.Agdaexpand9, the predicate to test whether we should keep inserting.AgdaThe (function) type t we are eliminating.Agda1The eliminating arguments and the remaining type./WAgdan0, the maximum number of implicts to be inserted.Agdaexpand9, the predicate to test whether we should keep inserting.AgdaThe (function) type t we are eliminating.Agda1The eliminating arguments and the remaining type./XAgdaKind/relevance of meta.AgdaName suggestion for meta.AgdaCheck (CmpLeq ) or infer (CmpEq ) the type.Agda Type of meta.Agda#The created meta as id and as term./YAgdaKind/relevance of meta.AgdaName suggestion for meta.AgdaCheck (CmpLeq ) or infer (CmpEq ) the type.Agda Type of meta.Agda#The created meta as id and as term./ZAgdaNext given argument a.AgdaExpected arguments ts./[AgdaNext given argument a.AgdaExpected arguments ts. /Q/T/S/R/U/V/W/X/Y/Z/[ /V/W/X/Y/Q/T/S/R/U/Z/[None"#$,14568=>?@ACEPSX_`/^Agda;Insert implicit patterns in a list of patterns. Even if M(, trailing SIZELT patterns are inserted./_Agda(Insert trailing SizeLt patterns, if any./`Agda;Insert implicit patterns in a list of patterns. Even if M(, trailing SIZELT patterns are inserted./]/^/_/`/]/^/_/`None"#$,14568=>?@ACEPSX_`/aAgdaIRename the variables in a telescope using the names from a given pattern.If there are not at least as many patterns as entries as in the telescope, the names of the remaining entries in the telescope are unchanged. If there are too many patterns, there should be a type error later./dAgda)Are there any untyped user patterns left?/eAgdaConstruct an initial .% 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: E lhsTel = [A : Set, m : Maybe A] lhsOutPat = [A&, "m"] lhsProblem = Problem [A = _, "just a" = "a"] ["_", "just a"] ["just b"] [] lhsTarget = "Case m Bool (Maybe A -> Bool)" @/fAgdaTry to move patterns from the problem rest into the problem. Possible if type of problem rest has been updated to a function type./eAgdaThe initial telescope delta of parameters.AgdaBThe problem equations inherited from the parent clause (living in delta).AgdaThe user patterns.Agda0The type the user patterns eliminate (living in delta).Agda8Continuation for when checking the patterns is complete.Agda9The initial LHS state constructed from the user patterns./a/b/c/d/e/f/a/b/c/d/e/fNone"#$,14568=>?@ACEPSX_`G/gAgdakExpand a clause to the maximal arity, by inserting variable patterns and applying the body to variables./hAgdaMGet the name of defined symbol of the head normal form of a term. Returns 7> if no such head exists./g/h/g/hNone"#$,14568=>?@ACEHPSVX_`!8Agda;Compute the pattern variables of a term or term-like thing./iAgdaGiven the type of a constructor (excluding the parameters), decide which arguments are forced. Precondition: the type is of the form  ! D vs and the vs are in normal form./lAgda(Assumes that the term is in normal form./i/j/k/i/j/kNone"#$,14568=>?@ACEPSX_`*+AgdazGet the name of the datatype constructed by a given constructor. Precondition: The argument must refer to a constructor*,Agda(Get true constructor with record fields./qAgdaArity./rAgdaList of field names./sAgdaTGet true constructor with fields, expanding literals to constructors if possible./tAgdasAugment constructor with record fields (preserve constructor name). The true constructor might only surface via reduce./uAgdaIs the datatype of this constructor a Higher Inductive Type? Precondition: The argument must refer to a constructor of a datatype or record./vAgdagetConType c t/ computes the constructor parameters from type t? and returns them plus the instantiated type of constructor c. This works also if tI is a function type ending in a data/record type; the term from which c comes need not be fully appliedNothing if t= is not a data/record type or does not have a constructor c./wAgdagetFullyAppliedConType c t7 computes the constructor parameters from data type t? and returns them plus 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./xAgdarReturn 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./yAgdaJCheck if a name refers to a datatype or a record with a named constructor./zAgda1Check if a name refers to a datatype or a record./{Agda Precodition:  is reduced./}Agda,Precondition: Name is a data or record type./~Agda7>! if not data or record type name./Agda7>" if not data or record definition./Agda,Precondition: Name is a data or record type./Agda7>! if not data or record type name./AgdaFills in the fields./vAgda Constructor.AgdaEnding in data/record type.AgdaNothing$ if not ends in data or record type.Just ((d, dt, pars), ct) otherwise, where d* is the data or record type name, dt0 is the type of the data or record name, pars( are the reconstructed parameters, ctA is the type of the constructor instantiated to the parameters./wAgda Constructor.Agda.Reduced type of the fully applied constructor.AgdaNothing if not data or record type.Just ((d, dt, pars), ct) otherwise, where d* is the data or record type name, dt0 is the type of the data or record name, pars( are the reconstructed parameters, ctA is the type of the constructor instantiated to the parameters.*+*,/p/r/q/s/t/u/v/w/x/y/z/{/|/}/~////*,/s/t*+/u/v/w/p/r/q/x/y/z/{/|/}/~////None"#$,14568=>?@ACEHPSVX\_` d/Agda9Get all symbols that a non-linear pattern matches against/Agda;Gather the set of pattern variables of a non-linear pattern/Agda,Convert from a non-linear pattern to a term./AgdaoTurn a term into a non-linear pattern, treating the free variables as pattern variables. The first argument indicates the relevance we are working under: if this is Irrelevant, then we construct a pattern that never fails to match. The second argument is the number of bound variables (from pattern lambdas). The third argument is the type of the term./Agda5Only computes free variables that are not bound (see /), i.e., those in a . ///////// /////////None"#$,14568=>?@ACEMPSX_`a@8AgdaRecord pattern trees.8AgdaICorresponds to variable and dot patterns; contains the original pattern.8Agda 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.8Agda7P p6 means that a variable (corresponding to the pattern p7, a variable or dot pattern) should be kept unchanged. 7R (n, x, t) means that n 8 variables, and n 8E dot patterns, should be removed, and a new variable, with the name x5, inserted instead. The type of the new variable is t.8AgdaVarPat# stands for variable patterns, and DotPat for dot patterns.8Agda*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.8Agda dropFrom i n drops arguments j with  j < i + n and j >= i . NOTE: n7 can be negative, in which case arguments are inserted./AgdaTake 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.8Agda]Take a matrix of booleans (at least one row!) and summarize the columns using conjunction.8AgdaTransform definitions returning record expressions to use copatterns instead. This prevents terms from blowing up when reduced./AgdaSplit tree annotated for record pattern translation. type RecordSplitTree = SplitTree' RecordSplitNode type RecordSplitTrees = SplitTrees' RecordSplitNode;Bottom-up procedure to record-pattern-translate split tree./AgdaReplaces 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.8AgdaRuns a computation in the 8 monad.8Agda>Returns the next pattern variable, and the corresponding term.8Agda 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.8AgdagConverts a record tree to a single pattern along with information about the deleted pattern variables.8Agda*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.8Agda2Traverses a pattern and returns one of two things:>If there is no non-record constructor in the pattern, then 7R 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 8x. (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.8AgdaTranslates the telescope.8AgdaiExplanation of how the telescope should be changed. Types should be in the context of the old telescope.Agda:Old telescope, flattened, in textual left-to-right order.Agda;New telescope, flattened, in textual left-to-right order. 7>3 is used to indicate the locations of dot patterns.////////None"#$,14568=>?@ACEHPSVX_`F/Agda%Edge labels for the positivity graph./Agda Monad for computing occurrences./Agda"Context for computing occurrences./Agda*Items corresponding to the free variables.=Potential invariant: It seems as if the list has the form genericReplicate n 7> ++ 7 (7= . /) is, for some n and is, where is! is decreasing (non-strictly)./AgdaName for " builtin./AgdaUsed to build / and occurrence graphs./AgdaUsed to build / and occurrence graphs./AgdaOnlyVarsUpTo n occs* discards occurrences of de Bruijn index >= n./AgdahCheck 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./AgdaRemoves / entries./AgdaAn interpreter for /.=WARNING: There can be lots of sharing between the generated D entries. Traversing all of these entries could be expensive. (See / for an example.)/AgdaRunning the monad/Agda0Computes the number of occurrences of different /s in the given definition.2WARNING: There can be lots of sharing between the E entries. Traversing all of these entries could be expensive. (See / for an example.)/Agda1Computes the occurrences in the given definition./Agda4Merges two edges between the same source and target./Agda2WARNING: There can be lots of sharing between the R entries in the edges. Traversing all of these entries could be expensive. (See / for an example.)/AgdaComputes all non-I2 occurrence graph edges represented by the given /.2WARNING: There can be lots of sharing between the l 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  elements: _ 8 (8 [ F,  0]), _ 8 (8 [ F,  0,  ]), _ 8 (8 [ F,  0,  ,  ]), _ 8 (8 [ F,  0,  ,  ,  ]), and so on./Agda.The monoid laws only hold up to flattening of /./Agda1The semigroup laws only hold up to flattening of /.0AgdaFThese operations form a semiring if we quotient by the relation "the  components are equal"./AgdaExtension of the /#, usually a local variable context./Agda&The names in the current mutual block.AgdaThe current name.&//////////////////////////////////////&//////////////////////////////////////None"#$,14568=>?@ACEPSX_` #AgdaWhich DefOtypes are eligible for the principle argument of a projection-like function?#AgdaBTurn a definition into a projection if it looks like a projection.&Conditions for projection-likeness of f:  The type of f must be of the shape   ! D  ! C for D a name (Def ) which is #: data  record   postulate.iThe application of f should only get stuck if the principal argument is inferable (neutral). Thus:a. fg cannot have absurd clauses (which are stuck even if the principal argument is a constructor).b. fZ cannot be abstract as it does not reduce outside abstract blocks (always stuck).c. f= cannot match on other arguments than the principal argument.d. f cannot match deeply.e. f&s body may not mention the parameters. f. A rhs of f cannot be a record expression, since this will be translated to copatterns by recordExpressionsToCopatterns. Thus, an application of fb waiting for a projection can be stuck even when the principal argument is a constructor.For internal reasons: f cannot be constructor headedfj cannot be recursive, since we have not implemented a function which goes through the bodies of the f^ and the mutually recursive functions and drops the parameters from all applications of f.$Examples for these reasons: see testSucceedNotProjectionLike.agda0 Agda View for a Def f (Apply a : es) where isProjection f. Used for projection-like fs.0 AgdaNA projection or projection-like function, applied to its principal argument0 AgdasJust a lone projection-like function, missing its principal argument (from which we could infer the parameters).0Agda*Not a projection or projection-like thing.0Agda Semantics of 0 .0Agda Top-level 0  (no reduction).0AgdaReduce 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.)0AgdaTurn 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 7 is 77{, a lone projection like function will be turned into a lambda-abstraction, expecting the principal argument. If the 7 is 7Q , it will be returned unaltered.No precondition. Preserves constructorForm, since it really does only something on (applications of) projection-like functions. ##0 00 0 0000000 0 00 0 0000000##None"#$,14568=>?@ACEPSX_`20AgdasInfer the sort of another sort. If we can compute the bigger sort straight away, return that. Otherwise, return  UnivSort sF and add a constraint to ensure we can compute the sort eventually.0AgdaiInfer the sort of a pi type. If we can compute the sort straight away, return that. Otherwise, return  PiSort a s2F and add a constraint to ensure we can compute the sort eventually.0AgdaAs  inferPiSort', but for a nondependent function type.0Agda Non-dependent version of ptsRule0Agda@Recursively check that an iterated function type constructed by telePi is well-sorted.0 AgdaResult is in reduced form.0!AgdaReconstruct the sort of a type./Precondition: given term is a well-sorted type. 00000000000 0! 00000000000 0!None"#$,14568=>?@ACEPSX_`R0(Agda}If there are several warnings, remove the unsolved-constraints warning in case there are no interesting constraints to list.0)AgdaTurns all warnings into errors.0*AgdaEDepending which flags are set, one may happily ignore some warnings. 0"0#0$0%0&0'0(0)0*0+ 0"0#0$0%0&0'0(0)0*0+None"#$,14568=>?@ACEPSX_`O#aAgda/What is the polarity of a function composition?#bAgdaMain function of this module.0.Agdapolarities i a4 computes the list of polarities of de Bruijn index i in syntactic entity a.00Agda'Infimum on the information lattice. S" is bottom (dominant for inf), T is top (neutral for inf).01Agda * negation, swapping monotone and antitone.03Agda#Get the next polarity from a list, S if empty.04AgdaReplace T by Q&. (Arbitrary bias, but better than S, see issue 1596).05Agda6A quick transliterations of occurrences to polarities.06Agda|Data and record parameters are used as phantom arguments all over the test suite (and possibly in user developments). enablePhantomTypes turns T parameters to Q to enable phantoms.07AgdaMake arguments S if the type of a not-TK later argument depends on it. Also, enable phantom types by turning Tb 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.08AgdahCheck whether a variable is relevant in a type expression, ignoring domains of non-variant arguments.09AgdaoHack 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.0:AgdacheckSizeIndex d i a% checks that constructor target type a has form d ps (!  i) idxs where  |ps| = np(d).Precondition: a is reduced and of form  d ps idxs0.0;Agda polarity i a* computes the polarity of de Bruijn index i in syntactic entity a by taking the infimum of all 0/.#a#b0.0/000102030405060708090:0;0001#a02030405#b060708090:0.0/0;None"#$,14568=>?@ACEPSX_` 0KAgdaDo a full whnf and treat neutral terms as rigid. Used on the arguments to an injective functions and to the right-hand side.0LAgdajDoes deBruijn variable i correspond to a top-level argument, and if so which one (index from the left).0MAgdaJoin a list of inversion maps.0NAgda%Update the heads of an inversion map.0PAgdaNPrecondition: all the given clauses are non-absurd and contain a proper match.0QAgdaIf a clause is over-applied we can't trust the head (Issue 2944). For instance, the clause might be `f ps = u , v` and the actual call `f vs .fst`. In this case the head will be the head of u rather than `_,_`.0RAgdakTurn variable heads, referring to top-level argument positions, into proper heads. These might still be {, but in that case they refer to deBruijn variables. Checks that the instantiated heads are still rigid and distinct.0SAgda,Argument should be in weak head normal form.0TAgdaaPrecondition: The first argument must be blocked and the second must be neutral.0UAgdarThe second argument should be a blocked application and the third argument the inverse of the applied function.0G0H0I0J0K0L0M0N0O0P0Q0R0S0T0U0V0J0K0L0M0N0O0P0Q0R0S0G0H0I0T0U0VNone"#$,14568=>?@ACEPSX_`4t8Agda|If matching succeeds, we return the instantiation of the clause pattern vector to obtain the split clause pattern vector.0XAgdaFor each variable in the patterns of a split clause, we remember the de Bruijn-index and the literals excluded by previous matches.8AgdaSubstitution of 0W7s for de Bruijn indices in covering clause to match  SplitClause.0^AgdaVariable blocking a match.0`Agda/De Bruijn index of variable blocking the match.0aAgdaConstructors in this position.0bAgdaLiterals in this position.0cAgdaGTrue if at least one clause has a variable pattern in this position.0dAgda@True if at least one clause has a lazy pattern in this position.0hAgda%Missing elimination blocking a match.0iAgdaBlocked on unsplit projection.0jAgda!Blocked on unintroduced argument.0lAgdaFTrue if there are also matching clauses without an unsplit copattern.0mAgda Is the unintroduced argument an  pattern?0nAgdaIf matching is inconclusive (BlockK) we want to know which variables or projections are blocking the match.0oAgdaMatches unconditionally.0pAgdaDefinitely does not match.0rAgdaBlockedOnProj o" if the clause has a result split.0sAgdaBlockingVar i cs ls o means variable i is blocked on constructors cs and literals ls.0tAgda3Match the given patterns against a list of clauses.7If successful, return the index of the covering clause.0yAgda-A pattern that matches anything (modulo eta).8Agda%Left dominant merge of blocking vars.8AgdaLeft dominant merge of 0h.8Agda 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 (0p)). It is left-strict, to be used with foldr,. If one clause unconditionally matches (0o) we do not look further.0{AgdamatchClause qs i c checks whether clause c( covers a split clause with patterns qs.8AgdamatchPats ps qs3 checks whether a function clause with patterns ps% covers a split clause with patterns qs.Issue 842 / 1986: This is accepted: D F : Bool -> Set1 F true = Set F = x -> Set / For the second clause, the split clause is F false, so there are more patterns in the split clause than in the considered clause. These additional patterns are simply dropped by zipWith. This will result in  mconcat [] which is Yes [].8Agda]Combine results of checking whether function clause patterns covers split clause patterns.0p is dominant: if one function clause pattern is disjoint to the corresponding split clause pattern, then the whole clauses are disjoint.0o5 is neutral: for a match, all patterns have to match.0q accumulates variables of the split clause that have to be instantiated (an projection names of copattern matches) to make the split clause an instance of the function clause.8Agda matchPat p q* checks whether a function clause pattern p" covers a split clause pattern q. There are three results: Yes rs means it covers, because p is a variable pattern. rs7 collects the instantiations of the variables in p s.t.  p[rs] = q.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.8AgdaBUnfold one level of a dot pattern to a proper pattern if possible.0tAgda+Search for clause that covers the patterns.AgdaPatterns of the current  SplitClause.0{AgdaSplit clause patterns qs.AgdaClause c to cover split clause.AgdaResult. If 0o the instantiation rs such that (namedClausePats c)[rs] == qs.8AgdaClause pattern vector ps( (to cover split clause pattern vector).AgdaSplit clause pattern vector qs* (to be covered by clause pattern vector).AgdaResult. If 0o the instantiation rs such that  ps[rs] == qs.8AgdaClause pattern p! (to cover split clause pattern).AgdaSplit clause pattern q# (to be covered by clause pattern).AgdaResult. If 0o, also the instantiation rsI of the clause pattern variables to produce the split clause pattern,  p[rs] = q.%0W0X0Y0Z0[0\0]0^0_0`0a0b0c0d0e0f0g0h0i0j0k0l0m0n0q0o0p0r0s0t0u0v0w0x0y0z0{%0n0q0o0p0r0s0t0{0W0X0Y0Z0[0\0v0u0w0x0y0^0_0`0a0b0c0d0]0h0i0j0k0l0m0z0e0f0gNone"#$,14568=>?@ACEMPSX_`6 00000000000 00000000000 None"#$,14568=>?@ACEPSX\_`G 0AgdaOMatch a non-linear pattern against a neutral term, returning a substitution.0AgdaMatching against a term produces a constraint which we have to verify after applying the substitution computed by matching.0Agda+Telescope of free variables in the equation0Agda8Type of the equation, living in same context as the rhs.0Agda-Term from pattern, living in pattern context.0AgdaBTerm from scrutinee, living in context where matching was invoked.0AgdaMonad for non-linear matching.0AgdaAdd substitution  i |-> v : a to result of matching.0Agda?Typed -equality, also handles empty record types. Returns 7> if the terms are equal, or `Just b` if the terms are not (where b contains information about possible metas blocking the comparison)0Agda3Are we currently matching in an irrelevant context?Agda"The telescope of pattern variablesAgda'The telescope of lambda-bound variablesAgdaThe type of the patternAgdaThe pattern to matchAgda*The term to be matched against the pattern0000000000000000000000000000000000000000000000000000 None"#$,14568=>?@ACEMPSX_`w,0Agda6The 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 7; 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.0Agda2True if thing not eligible for structural descent.0AgdaThing.0AgdaExtract variables from m;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).0AgdaTermination monad.0Agda Termination monad service class.0AgdaThe termination environment.0AgdaAAre we mining dot patterns to find evindence of structal descent?0Agda#The name of size successor, if any.0Agda2The name of the delay constructor (sharp), if any.0Agda/Depth at which to cut off the structural order.0Agda3The name of the function we are currently checking.0AgdaThe names of the functions in the mutual block we are checking. This includes the internally generated functions (with, extendedlambda, coinduction).0AgdarThe list of name actually appearing in the file (abstract syntax). Excludes the internally generated functions.0AgdaSDoes the actual clause result from with-inlining? (If yes, it may be ill-typed.)0Agda_Target type of the function we are currently termination checking. Only the constructors of 0 are considered guarding.0Agda%Are we checking a delayed definition?0AgdaOnly consider the 1 7Q< arguments for establishing termination. See issue #1023.0AgdaOnly consider guardedness if 7Q (not masked).0Agda How many SIZELTy relations do we have in the context (= clause telescope). Used to approximate termination for metas in call args.0Agda+The patterns of the clause we are checking.0AgdaNumber 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.0Agda~The current guardedness status. Changes as we go deeper into the term. Updated during call graph extraction, hence strict.0AgdaWhen 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. (See issue #1015).0AgdaJPattern variables that can be compared to argument variables using SIZELT.0AgdaThe current guardedness level.0Agda+The target of the function we are checking.0Agda!The mutual block we are checking.RThe functions are numbered according to their order of appearance in this list.0Agda!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.0Agda)Generic run method for termination monad.0AgdaCRun TerM computation in default environment (created from options).1Agda Lens for 0.1Agda Lens for 0.1Agda Lens for 0.1Agda9Compute usable vars from patterns and run subcomputation.1AgdaSet 0 when going under constructor c.1AgdaSet 0$ for arguments following projection qx. We disregard j<i after a non-coinductive projection. However, the projection need not be recursive (Issue 1470).1AgdaFor 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.1AgdaCheck whether a projection belongs to a coinductive record and is actually recursive. E.g. @ isCoinductiveProjection (Stream.head) = return False8isCoinductiveProjection (Stream.tail) = return True @1Agda3How long is the path to the deepest atomic pattern?1AgdaUA dummy pattern used to mask a pattern that cannot be used for structural descent.1 Agda#A very crude way of estimating the SIZELT chains  i > j > k: in context. Returns 3 in this case. Overapproximates.1!Agda*Print masked things in double parentheses.1*Agda*Only show intermediate nodes. (Drop last  ).V000000000000000000000000000000000000000000000000000001111111111 1 1 1 1 1111111111111111111 V00000000000000000000000000000000000000000001111111111 1 1 1 1 11111111111111110000000110001 None"#$,14568=>?@ACEPSX\_`/#AgdaMProduces a function which drops the filename component of the qualified name.8AgdaIndefinite article.8Agda?Drops given amount of leading components of the qualified name.1IAgda3Drops the filename component of the qualified name.8AgdaPrint two terms that are supposedly unequal. If they print to the same identifier, add some explanation why they are different nevertheless. ##0%0&0'0)0*0+1G1H1I #0%1G0'0&0)0*0+1I#1H None"#$,14568=>?@ACEPSX\_`f8Agda*Compute a list of instance candidates. 7>d if target type or any context type is a meta, error if type is not eligible for instance search.1VAgdafindInstance 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.8AgdaResult says whether we need to add constraint, and if so, the set of remaining candidates and an eventual blocking metavariable.8Agda?Precondition: type is spine reduced and ends in a Def or a Var.8AgdaApply 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 reset.Also returns the candidates that pass type checking but fails constraints, so that the error messages can be reported if there are no successful candidates.8Agda Given a meta m of type t and a list of candidates cands, checkCandidates m t candsY returns a refined list of valid candidates and candidates that failed some constraints.8AgdaTo 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 a arguments. See Issue670a. Andreas, 2013-11-07 Also do this for projections, see Issue670b.1V1W1X1Y1V1W1X1YNone"#$,14568=>?@ACEPSX\_`&/AgdaguardConstraint 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.&2Agda=Don't allow the argument to produce any blocking constraints.1^AgdaMAdd all constraints belonging to the given problem to the current problem(s).1_Agda,Create a fresh problem for the given action.1bAgdaUWake constraints matching the given predicate (and aren't instance constraints if 1X).1cAgda4Wake up the constraints depending on the given meta.1dAgdaWake up all constraints.1fAgdatSolve awake constraints matching the predicate. If the second argument is True solve constraints even if already &(.&.&/&0&1&2&31[1\1]1^1_1`1a1b1c1d1e1f1g1h1i1[1\1]1^&21_1`&0&1&/1a1b1c1d1e&31f1g1h1i&. None"#$,14568=>?@ACEHPSVX\_`L1lAgdathe kill list is empty or only Falses1mAgda0there is no possible kill (because of type dep.)1nAgda%managed to kill some args in the list1oAgda$all prescribed kills where performed1pAgdarCollect the *definitely* rigid variables in a monoid. We need to successively reduce the expression to do this.1rAgdaExtended occurs check.1uAgdaeUnfold definitions during occurs check? This effectively runs the occurs check on the normal form.1xAgda6The passed modality is the one of the current context.1{Agda6Extra environment for the occurs check. (Complements .)1~Agda*The allowed variables with their variance.1AgdaThe meta we want to solve.1Agda/The size of the typing context upon invocation.1AgdaXSet the names of definitions to be looked at to the defs in the current mutual block.1Agda,Is a def in the list of stuff to be checked?1Agda3Remove a def from the list of defs to be looked at.1AgdaXCheck whether a free variable is allowed in the context as specified by the modality.1AgdaoOccurs check fails if a defined name is not available since it was declared in irrelevant or erased context.1AgdaOConstruct a test whether a de Bruijn index is allowed or needs to be pruned.1Agda"Leave the strongly rigid position.1AgdaWhen assigning  m xs := v , check that m does not occur in v# and that the free variables of v are contained in xs.1Agdaprune 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.1AgdahasBadRigid 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.)1AgdaCheck whether a term Def f esD is finally stuck. Currently, we give only a crude approximation.1AgdaCheck 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.1AgdakillArgs [k1,...,kn] X prunes argument i from metavar X if ki==TrueA. Pruning is carried out whenever > 0 arguments can be pruned.1Agda/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.1AgdadInstantiate a meta variable with a new one that only takes the arguments which are not pruneable.1AgdaMeta to prune.AgdaArguments to meta variable.Agda,Test for allowed variable (de Bruijn index).1Agda,Test for allowed variable (de Bruijn index).AgdaArgument of meta variable.Agda#Exception if argument is matchable.1Agda,Test for allowed variable (de Bruijn index).1Agda9Arguments to old meta var in left to right order with Bool' indicating whether they can be pruned.Agda$The old meta var to receive pruning.Agda$The pruned type of the new meta var./1k1n1l1m1o1p1q1r1t1s1u1w1v1x1y1z1{1|111~1}1111111111111111111111111/11111{1|111~1}1z1y1x1111u1w1v111111111r1t1s1111111p1q1k1n1l1m1o1111None"#$&',14568=>?@ACEPSX\_`Sq**AgdaCheck that the instantiation of the given metavariable fits the type of the metavariable. If the metavariable is not yet instantiated, add a constraint to check the instantiation later.* Agda1Create a sort meta that may be instantiated with  (Set).*"AgdaGCreate a new value meta with specific dependencies without -expanding.*#AgdaXCreate a new value meta with specific dependencies, possibly -expanding in the process.*$Agda?Create a new metavariable, possibly -expanding in the process.*%AgdanewInstanceMeta s t candsC creates a new instance metavariable of type the output type of t with name suggestion s.*&AgdaMiller pattern unification:assign dir x vs v a solves problem x vs <=(dir) v : a 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.*'Agda!Do safe eta-expansions for meta (SingletonRecords,Levels).*(Agda(Performing the meta variable assignment.#The instantiation should not be an  and the z should point to something  or a +. Further, the meta variable may not be .1Agda7Exceptions raised when substitution cannot be inverted.1AgdaCannot recover.1Agda=A potentially neutral arg: can't invert, but can try pruning.1Agda&Try to eta-expand var to remove projs.1Agda?Normalize just far enough to be able to eta-contract maximally.1Agda6Check whether one of the meta args is a projected var.1AgdaaFind 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.1AgdaCCheck whether a meta variable is a place holder for a blocked term.1Agda8Skip frozen check. Used for eta expanding frozen metas.1Agda4Create a sort meta that cannot be instantiated with  (Set).1Agda1Create a sort meta that may be instantiated with  (Set).1Agda,Create a new value meta without -expanding.1AgdaZCreate a metavariable of record type. This is actually one metavariable for each field.1Agda6Construct a blocked constant if there are constraints.1AgdaunblockedTester t returns False if t is a meta or a blocked term.?Auxiliary function to create a postponed type checking problem.1Agda)Create a postponed type checking problem e : t that waits for type tA to unblock (become instantiated or its constraints resolved).1Agda)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.1Agda1Type of the term that is produced by solving the .1Agda7Eta expand metavariables listening on the current meta.1Agda/Wake up a meta listener and let it do its thing1AgdavEta expand a metavariable, if it is of the specified kind. Don't do anything if the metavariable is a blocked term.1AgdaPEta expand blocking metavariables of record type, and reduce the blocked thing.1AgdaassignMeta 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.1AgdaassignMeta' 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.1AgdaVCheck that the instantiation of the metavariable with the given term is well-typed.1AgdaGiven two types a and b with a <: b , check that a == b.1AgdaTurn the assignment problem _X args <= SizeLt u into _X args = SizeLt (_Y args) and constraint  _Y args <= u.1Agda Eta-expand bound variables like z in  X (fst z).1AgdaJEta-expand a de Bruijn index of record type in context and passed term(s).1Agda_Turn non-det substitution into proper substitution, if possible. Otherwise, raise the error.1AgdaCheck 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.1Agda Turn open metas into postulates.Preconditions: We are '.^ is set to the top-level module.1AgdaSort metas in dependency order.1Agda)a possibly non-deterministic substitution1Agda"Should the meta be created frozen?AgdaName of record typeAgdaParameters of record type.1Agda dirAgdaThe meta variable x.AgdaIts associated information mvar <- lookupMeta x.Agda Its type  t = jMetaType $ mvJudgement mvarAgdaIts arguments.AgdaIts to-be-assigned value v , such that x args dir v.Agda0Continuation taking its possibly assigned value.1AgdaMeta variable arguments.AgdaRight hand side.F*** *!*"*#*$*%*&*'*(*)**111111111111111111111111111111111111111111111111111111111F111*(11* 11111*%1*#*"*$111*!*1*)**111111111111111*'111*&11*1111111111111111111111 None"#$,14568=>?@ACEPSX\_`^1Agda'Size constraint with de Bruijn indices.1AgdaDeBruijn indices1Agda Living in Context.2Agda Living in Context.2Agda'Size expression with de Bruijn indices.2AgdaSize metas in size expressions.2AgdaDe Bruijn indices.2Agda Identifiers for rigid variables.2 Agda$Name for printing in debug messages.2 AgdaDe Bruijn index.2 Agda,Flag to control the behavior of size solver.2 Agda2Instantiate all unconstrained size variables to ".2 Agda,Leave unconstrained size variables unsolved.2Agda,Solve size constraints involving hypotheses.2Agda"TODO: this does not actually work!"We would like to use a constraint c created in context  from module N in the current context  and current module M. is module tel   of N! extended by some local bindings  . K is the current context. The module parameter substitution from current M to N be   "  :  .If M == N=, we do not need the parameter substitution. We try raising.We first strengthen  " c to live in   and obtain c = strengthen  c. We then transport c  to  and obtain c = applySubst  c .)This works for different modules, but if M == N we should not strengthen and then weaken, because strengthening is a partial operation. We should rather lift the substitution  by   and then raise by  -  0. This "raising" might be a strengthening if   is shorter than  .:(TODO: If the module substitution does not exist, because N is not a parent of MS, we cannot use the constraint, as it has been created in an unrelated context.)2Agda0A hazardous hack, may the Gods have mercy on us.STo cast to the current context, we match the context of the given constraint by CtxId,, and as fallback, by variable name (douh!).%This hack lets issue 2046 go through.2AgdaTReturn the size metas occurring in the simplified constraints. A constraint like ! _j =< " : Size simplifies to nothing, so _j would not be in this set.2Agda2Solve a cluster of constraints sharing some metas.2AgdaICollect constraints from a typing context, looking for SIZELT hypotheses.2AgdaKConvert 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.2Agda@Turn a constraint over de Bruijn indices into a size constraint.2Agda#Turn a term into a size expression.Returns 7>, if the term isn't a proper size expression.2Agda&Turn a de size expression into a term.2Agda Only for .2!Agda*An order which ignores the meta arguments.2"Agda-An equality which ignores the meta arguments.2#Agda$Assumes we are in the right context.112111222222222 2 2 2 2 2222222222222 2 2 2222222222 2 222222112111222None"#$,14568=>?@ACEPSX\_`@-Agda9Check 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.-Agda.Check that the first sort equal to the second.-Agda+equalTermOnFace  A u v = _ ,  " u = v : A-AgdacompareTel t1 t2 cmp tel1 tel1 checks whether pointwise tel1 `cmp` tel2 and complains that  t2 `cmp` t1 failed if not.-AgdaEquality on Types-AgdacompareElims pols a v els1 els2: performs type-directed equality on eliminator spines. t is the type of the head v.-Agda(Type-directed equality on argument lists-Agda)Syntax directed equality on atomic values-Agda)Type directed equality on terms or types.-Agda!Type directed equality on values.2-AgdaTry whether a computation runs without errors or new constraints (may create new metas, though). Restores state upon failure.2.AgdanTry whether a computation runs without errors or new constraints (may create new metas, though). Return 7=$ the result upon success. Return 7> and restore state upon failure.2/AgdaqCheck if to lists of arguments are the same (and all variables). Precondition: the lists have the same length.20AgdaintersectVars 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.22Agda$Ignore errors in irrelevant context.23Agda_Try to assign meta. If meta is projected, try to eta-expand and run conversion check again.28AgdaCompute the head type of an elimination. For projection-like functions this requires inferring the type of the principal argument.29AgdaCheck whether a1 cmp a2% and continue in context extended by a1.2=AgdaWhen comparing argument spines (in compareElims) where the first arguments don't match, we keep going, substituting the anti-unification of the two terms in the telescope. More precisely:@ (u = v : A)[pid] w = antiUnify pid A u v us = vs : [w/x] ------------------------------------------------------------- u us = v vs : (x : A)  @The simplest case of anti-unification is to return a fresh metavariable (created by blockTermOnProblem), but if there's shared structure between the two terms we can expose that.This is really a crutch that lets us get away with things that otherwise would require heterogenous conversion checking. See for instance issue #2384.2AAgdaCompare 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...)2DAgda 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.2EAgdaAccount 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.2FAgdaPrecondition: levels are +,d.2JAgdaVleqInterval r q = r "d q in the I lattice. ("( r_i) "d ("( q_j) iff " i. " j. r_i "d q_j2KAgdaleqConj r q = r "d q in the I lattice, when r and q are conjuctions. ' ("' r_i) "d ("' q_j) iff ' ("' r_i) "' ("' q_j) = ("' r_i) iff ' {r_i | i} "* {q_j | j} = {r_i | i} iff ' {q_j | j} " {r_i | i}29 Agdacmp The comparison directionAgdaa1 The smaller domain.Agdaa2 The other domain.Agdab1 The smaller codomain.Agdab2 The bigger codomain.AgdaContinuation if mismatch in  .AgdaContinuation if mismatch in .AgdaContinuation if mismatch in .AgdaContinuation if mismatch in . Agda)Continuation if comparison is successful.5-~------------------2,2-2.2/202122232425262728292:2;2<2=2>2?2@2A2B2C2D2E2F2G2H2I2J2K2L2M5-~2-2.2/20-21-22--23242526-2728-292:2;2<2=2>2?2@-2A2B2C---2D2E-----2F-2G2H2,2I2J2K--2L2MNone"#$,14568=>?@ACEPSX_`˪2mAgda"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).!2N2P2O2Q2R2S2T2U2V2W2Y2X2Z2[2\2]2^2_2`2a2b2c2d2e2f2g2h2i2j2k2l2m2n!2Z2[2\2W2Y2X2V2U2T2]2^2_2`2a2b2c2d2e2R2S2f2g2h2i2j2k2l2N2P2O2Q2m2nNone"#$,14568=>?@ACEPSX\_`i8Agda Don't reduce!8AgdaCan be reduced eagerly.8Agda8Ends up in dot patterns (should not be reduced eagerly).8Agda8Ends up in dot patterns (should not be reduced eagerly).2AgdaUnification succeeded.2AgdaTerms are not unifiable.2Agda1Some other error happened, unification got stuck.2Agda Result of 2.2AgdaUnify indices.In unifyIndices gamma flex a us vs,us and vs3 are the argument lists to unify, eliminating type a.gamma' is the telescope of free variables in us and vs.flex3 is the set of flexible (instantiable) variabes in us and vs.*The result is the most general unifier of us and vs.8Agda4Get the type of the i'th variable in the given state8AgdaGet 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 telescope8Agda*As getEquality, but with the unraised type8Agda[Instantiate the k'th variable with the given value. Returns Nothing if there is a cycle.8Agda{Solve the k'th equation with the given value, which can depend on regular variables but not on other equation variables.8Agda isHom n xA returns x lowered by n if the variables 0..n-1 don't occur in x.-This is naturally sensitive to normalization.8AgdarTurn a term into a pattern binding as many of the given forced variables as possible (in non-forced positions).2AgdaDon't ever reduce the whole 8, as it will destroy readability of the context in interactive editing! To make sure this insight is not lost, the following dummy instance should prevent a proper +! instance for 8.2Agda gammaAgda flexAgda aAgda usAgda vs8AgdaIndex kAgda Solution u222222222222None"#$,14568=>?@ACEHPSVX\_`8AgdaRConvert metavariables to normal variables. Warning: doesn't convert sort metas.2Agda^Check confluence of the given clause wrt rewrite rules of the constructors it matches againsteCheck confluence of the given rewrite rules wrt all other rewrite rules (also amongst themselves).8AgdaA  OneHole p is a p with a subpattern f ps singled out.xGiven metavariables ms and some x, construct a telescope  and replace all occurrences of the given metavariables in x( by normal variables from . Returns Nothing& if metas have cyclic dependencies.8AgdaThe trivial hole8AgdaPlug a hole with another hole8AgdaGiven a p : a,  allHoles p* lists all the possible decompositions p = p'[(f ps)/x].8AgdaInstances for AllHoles Given a term v : a and eliminations es, force eta-expansion of v9 to match the structure (Apply/Proj) of the eliminations. Examples: v : _A and  es = [$ w]: this will instantiate _A := (x : _A1) ! _A2 and return the  OneHole Term   x ! [v x].v : _A and  es = [.fst]: this will instantiate _A := _A1 _A2 and return the  OneHole Term ([v .fst]) , (v .snd).2222None"#$&',14568=>?@ACEPSX\_` d #\Agdarewrite b v rules es tries to rewrite v applied to es with the rewrite rules rules. b is the default blocking tag.#]Agda{Check that the name given to the BUILTIN REWRITE is actually a relation symbol. I.e., its type should be of the form  ! (lhs : A) (rhs : B) ! Set !A. Note: we do not care about hiding/non-hiding of lhs and rhs.2AgdaDeconstructing a type into  ! t ! t' ! core.2AgdaThe whole telescope , t, t'.2Agda.2Agdat.2Agdat'.2Agdacore.2AgdaDeconstructing a type into  ! t ! t' ! core . Returns Nothing if not enough argument types.2Agda<Check the given rewrite rules and add them to the signature.2AgdaCheck the validity of q :  ! rel us lhs rhs as rewrite rule   " lhs ! rhs : B  where  B = A[us/]. Remember that rel :  ! A ! A ! Set i, so $rel us : (lhs rhs : A[us/]) ! Set iC. Returns the checked rewrite rule to be added to the signature.2AgdarewriteWith t f es rew where f : t tries to rewrite f es with rew%, returning the reduct if successful.#\#]2222222222222#]22222222222#\None"#$,14568=>?@ACEHPSVX_`g;#_Agda)The entry point to the reduction machine.8Agda<Control frames are continuations that act on value closures.8Agda CaseK f i bs spine0 spine1 stack/. Pattern match on the focus (with arg info i ) using the bs case tree. f8 is the name of the function doing the matching, and spine0 and spine1 are the values bound to the pattern variables to the left and right (respectively) of the focus. The match stack contains catch-all cases we need to consider if this match fails.8Agda ArgK cl cxt. Used when computing full normal forms. The closure is the head and the context is the spine with the current focus removed.8AgdaAIndicates that the focus should be evaluated to full normal form.8AgdaForceK f spine0 spine1 . Evaluating  primForce of the focus. f is the name of  primForce> and is used to build the result if evaluation gets stuck. spine0& are the level and type arguments and spine1P contains (if not empty) the continuation and any additional eliminations.8Agda$EraseK f spine0 spine1 spine2 spine3 . Evaluating  primErase6. The first contains the level and type arguments. spine1 and spine25 contain at most one argument between them. If in spine1J it's the value closure of the first argument to be compared and if in spine2< it's the unevaluated closure of the second argument. spine3d contains the proof of equality we are erasing. It is passed around but never actually inspected.8Agda NatSucK n. Add nx to the focus. If the focus computes to a natural number literal this returns a new literal, otherwise it constructs n calls to suc.8AgdaPrimOpK f op lits es cc". Evaluate the primitive function f using the Haskell function op. opH gets a list of literal values in reverse order for the arguments of f] and computes the result as a term. The already computed arguments (in reverse order) are lits and es are the arguments that should be computed after the current focus. In case of built-in functions with corresponding Agda implementations, cc contains the case tree.8AgdaUpdateThunk ps. Update the pointers ps( with the value of the current focus.8Agda ApplyK spine1. Apply the current focus to the eliminations in spine_. This is used when a thunk needs to be updated with a partial application of a function.8Agda)A spine with a single hole for a pointer.8AgdaCatchAll cc spine. Case trees are not fully expanded, that is, inner matches can be partial and covered by a catch-all at a higher level. This catch-all is represented on the match stack as a CatchAll. cc, is the case tree in the catch-all case and spineH is the value of the pattern variables at the point of the catch-all.8AgdayThe control stack for matching. Contains a list of CatchAllFrame's and the closure to return in case of a stuck match.8AgdalThe control stack contains a list of continuations, i.e. what to do with the result of the current focus.8Agda*The abstract machine state has two states 8 and 8 that determine what the machine is currently working on: evaluating a closure in the Eval state and matching a spine against a case tree in the Match state. Both states contain a 8R of continuations for what to do next. The heap is maintained implicitly using 8 s, hence the s parameter.8AgdaHEvaluate the given closure (the focus) to weak-head normal form. If the 8 field of the closure is 8 we look at the control stack for what to do. Being strict in the control stack is important! We can spend a lot of steps with unevaluated closures (where we update, but don't look at the control stack). For instance, long chains of suc constructors.8AgdaMatch f cc spine stack ctrl Match the arguments spine against the case tree cc6. The match stack contains a (possibly empty) list of 8< frames and a closure to return in case of a stuck match.8AgdaAThe environment of a closure binds pointers to deBruijn indicies.8Agda3A thunk is either a black hole or contains a value.8AgdaWSpines and environments contain pointers to closures to enable call-by-need evaluation.8Agda_Not a pointer. Used for closures that do not need to be shared to avoid unnecessary updates.8AgdaAn actual pointer is an 8 to a 8. The thunk is set to 8I during the evaluation of its contents to make debugging loops easier.8AgdaOThe spine is a list of eliminations. Application eliminations contain pointers.8AgdaUsed to track if a closure is  Unevaluated or a ValueG (in weak-head normal form), and if so why it cannot reduce further.8Agda?The abstract machine represents terms as closures containing a , an environment, and a spine of eliminations. Note that the environment doesn't necessarily bind all variables in the term. The variables in the context in which the abstract machine is started are free in closures. The 8A argument tracks whether the closure is in weak-head normal form.8AgdaThe environment applies to the F argument. The spine contains closures with their own environments.8AgdaCase tree with bodies.8Agda 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 1 with arity 0.8AgdaxMatch on record constructor. Can still have a catch-all though. Just contains the fields, not the actual constructor.8Agda 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.8Agda Absurd case.8Agda3We are constructing a record here (copatterns). 1 lists projections.8AgdaoMap from constructor (or projection) names to their arity and the case subtree. (Projections have arity 0.)8Agda!Map from literal to case subtree.8Agda'(Possibly additional) catch-all clause.8Agda?(if True) In case of non-canonical argument use catchAllBranch.8Agda primForce8Agda primErase9Agda9Datatype or record type. Need to know this for primForce.9AgdaAxiom or abstract defn9Agda"Literals in reverse argument order9Agda+In this case we fall back to slow reduction9Agda Compute a 9 from a regular definition.9AgdaQApply a closure to a spine of eliminations. Note that this does not preserve the 8 field.9Agda+Apply a closure to a spine, preserving the 8V field. Use with care, since usually eliminations do not preserve the value status.9AgdaFIn most cases pointers that we dereference do not contain black holes.9 AgdaOnly use for debug printing!9 AgdaCreate a thunk. If the closure is a naked variable we can reuse the pointer from the environment to avoid creating long pointer chains.9 Agda-Create a thunk that is not shared or updated.9 AgdaUnsafe.9 AgdaThe initial abstract machine state. Wrap the term to be evaluated in an empty closure. Note that free variables of the term are treated as constants by the abstract machine. If computing full normal form we start off the control stack with a 8 continuation.9AgdagThe abstract machine treats uninstantiated meta-variables as blocked, but the rest of Agda does not.9AgdaYNote: it's important to be lazy in the spine and environment when decoding. Hence the 9 here and in 9, and the special version of  in 9.9AgdaUTurning an abstract machine closure back into a term. This happens in three cases: * when reduction is finished and we return the weak-head normal term to the outside world. * when the abstract machine encounters something it cannot handle and falls back to the slow reduction engine * when there are rewrite rules to apply9AgdasTurn a list of internal syntax eliminations into a spine. This builds closures and allocates thunks for all the  elims.9AgdafTrim unused entries from an environment. Currently only trims closed terms for performance reasons.9Agda Build an environment for a body with some given free variables from a spine of arguments. Returns a triple containing * the left-over variable names (in case of partial application) * the environment * the remaining spine (in case of over-application)9AgdaeEvaluating a term in the abstract machine. It gets the type checking state and environment in the N1 argument, some precomputed built-in mappings in 9, the memoised # function, a couple of flags (allow non-terminating function unfolding, and whether rewriting is enabled), and a term to reduce. The result is the weak-head normal form of the term with an attached blocking tag.#^#_#_#^9292None"#$,14568=>?@ACEPSX\_`2Agda+addClause f (Clause {namedClausePats = ps}) checks that f ps$ reduces in a way that agrees with IApply reductions.2Agda"current context is of the form .2AgdaLike  unifyElims but  is from the the meta's MetaInfo and the context extension  is taken from the Closure.2Agda&variables to keep  " x_n .. x_0 : Agda variables to solve . " ts : 22222222None"#$,14568=>?@ACEPSX_` 2Agda=Generalize a telescope over a set of generalizable variables.2Agda?Generalize a type over a set of (used) generalizable variables.2AgdaEAllow returning additional information from the type checking action.9AgdaKCreate metas for the generalizable variables and run the type check action.9AgdatAdd a placeholder variable that will be substituted with a record value packing up all the generalized variables.9AgdaECompute the generalized telescope from metas created when checking the type/telescope to be generalized. Called in the context extended with the telescope record variable (whose type is the first argument). Returns the telescope of generalized variables and a substitution from this telescope to the current context.9AgdaPrune unsolved metas (#3672). The input includes also the generalized metas and is sorted in dependency order. The telescope is the generalized telescope.9AgdaCreate a substition from a context where the i first record fields are variables to a context where you have a single variable of the record type. Packs up the field variables in a record constructor and pads with  DUMMY_TERM-s for the missing fields. Important that you apply this to terms that only projects the defined fields from the record variable. Used with partial record values when building the telescope of generalized variables in which case we have done the dependency analysis that guarantees it is safe.9AgdaTakes the list of types A [] A [r.f ] A [r.f , r.f ] ... And builds the telescope (x : A [ r := c _ .. _ ]) (x : A [ r := c x _ .. _ ]) (x : A [ r := c x x _ .. _ ]) ...9 AgdaICreate metas for all used generalizable variables and their dependencies.9!Agda9Create a generalisable meta for a generalisable variable.9"AgdaCreate a not-yet correct record type for the generalized telescope. It's not yet correct since we haven't computed the telescope yet, and we need the record type to do it.9#Agda]Once we have the generalized telescope we can fill in the missing details of the record type.222222None"#$,14568=>?@ACEPSX\_` 2AgdaReturn the parameters that share variables with the indices nonLinearParameters :: Int -> Type -> TCM [Int] nonLinearParameters nPars t =2AgdaA Type that either has sort Type l or is a closed definition. Such a type supports some version of transp. In particular we want to allow the Interval as a  ClosedType.2AgdaA Type with sort Type l/ Such a type supports both hcomp and transp.2AgdaTType check a datatype definition. Assumes that the type has already been checked.2AgdaQEnsure that the type is a sort. If it is not directly a sort, compare it to a 1.2AgdaType check a constructor declaration. Checks that the constructor targets the datatype and that it fits inside the declared sort. Returns the non-linear parameters.2AgdaDefine projections for non-indexed data types (families don't work yet). Of course, these projections are partial functions in general.BPrecondition: we are in the context  of the data type parameters.2Agda&Bind the named generalized parameters.2Agda"Bind the parameters of a datatype.NWe allow omission of hidden parameters at the definition site. Example: P data D {a} (A : Set a) : Set a data D A where c : A -> D A 2AgdaCheck that the arguments to a constructor fits inside the sort of the datatype. The third argument is the type of the constructor.6As a side effect, return the arity of the constructor.2AgdatWhen --without-K is enabled, we should check that the sorts of the index types fit into the sort of the datatype.2AgdaCheck that a type constructs something of the given datatype. The first argument is the number of parameters to the datatype and the second the number of additional non-parameters in the context (1 when generalizing, 0 otherwise).2Agda!Is the type coinductive? Returns 7>% if the answer cannot be determined.2AgdaName of data type.AgdaCheck universes?AgdaParameter telescope.Agda#Number of indices of the data type.AgdaSort of the data type.Agda)Constructor declaration (type signature).2AgdaPathCons, . " u : R Agda%how to apply a "projection" to a termAgdasome name, e.g. record nameAgda param types Agdafields' types  " Agda fields' namesAgdarecord type  " T2AgdaPathCons, . " u : R Agda%how to apply a "projection" to a termAgdasome name, e.g. record nameAgda param types Agdafields' types  " Agda fields' namesAgdarecord type  " T2Agda%how to apply a "projection" to a termAgdasome name, e.g. record nameAgda param types Agdafields' types  " Agda fields' namesAgdarecord type ( : ) " R[]2AgdaNumber of parametersAgdaBindings from definition site.Agda/Pi-type of bindings coming from signature site.AgdaContinuation, accepting parameter telescope and rest of type. The parameters are part of the context when the continutation is invoked.222222222222222222222222222222222222222222222222222222222222None"#$,14568=>?@ACEPSX_`-Agda- traverses the whole 6, and we can use this traversal to modify the term.-AgdaInfer type of a neutral term.-AgdaEntry point for term checking.-AgdaCheck if sort is well-formed.-Agda 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 Theory-Agda/Entry point for e.g. checking WithFunctionType.-Agda(The default action is to not change the  at all.3Agda/Called on each subterm before the checker runs.3Agda/Called on each subterm after the type checking.3AgdaCalled for each ArgInfo. The first / is from the type, the second from the term.9$AgdaMake sure a constructor is fully applied and infer the type of the constructor. Raises a type error if the constructor does not belong to the given type.9%AgdacheckArgInfo actual expected.The expected  comes from the type. The actual 8 comes from the term and can be updated by an action.9&AgdacheckRelevance action term type.The term  can be updated by the action.9'Agda$Infer ordinary function application.9(Agda3Infer possibly projection-like function application9)AgdainferSpine 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).9*AgdaReturns 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.9+AgdarType should either be a record type of a type eligible for the principal argument of projection-like functions.9,AgdaCheck if level is well-formed.9-AgdaDUniverse subsumption and type equality (subtyping for sizes, resp.).3 AgdaCompute the sort of a type.9.Agdaeliminate t self es eliminates value self of type t by spine es1 and returns the remaining value and its type.9$Agda Constructor.AgdaConstructor arguments.Agda$Type of the constructor application.Agda Name of the data/record type, type of the data/record type, reconstructed parameters, type of the constructor (applied to parameters), full application arguments, types of missing arguments (already added to context), type of the full application.9/AgdaType of the head self.Agda The head self.AgdaThe eliminations es.AgdaCheck (CmpLeq ) or infer (CmpEq) the final type.Agda!Expected type of the application self es.Agda*The application after modification by the Action.-3333---------0 3 -------3333---3 0 None"#$,14568=>?@ACEPSX_`3 3 3 3 33 3 3 3 3None"#$,14568=>?@ACEPSX_`3AgdaGEta-expand a term if its type is a function type or an eta-record type.3AgdaKEta-expand functions and expressions of eta-record type wherever possible.333333None"#$,14568=>?@ACEPSX_`( 3Agda subst u . absTerm u == id3AgdaisPrefixOf u v = Just es if v == u  es.3AgdaabstractType a v b[v] = b where a : v.3Agda3piAbstractTerm NotHidden v a b[v] = (w : a) -> b[w] 3piAbstractTerm Hidden v a b[v] = {w : a} -> b[w]3Agda (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']3Agda This swaps var 0 and var 1.3*AgdaZIgnores irrelevant arguments and modality. (And, of course, origin and free variables).3+AgdaIgnore the tactic.3,Agda!Ignore origin and free variables.3-AgdaIgnores .3/AgdaIgnores sorts. 33333333333 33333333333None"#$,14568=>?@ACEPSX\_`k39Agda6Split pattern variables according to with-expressions.3:AgdaAbstract with-expressions vs+ to generate type for with-helper function.Each  EqualityType, coming from a rewrite , will turn into 2 abstractions.3<AgdaFrom a list of with and rewrite; expressions and their types, compute the list of final with" expressions (after expanding the rewrites).3=AgdaFCompute the clauses for the with-function given the original patterns.3>Agda >stripWithClausePatterns cxtNames parent f t  qs np  ps = ps'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).3?AgdaConstruct 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 39Agda1 context of types and with-arguments.Agda " t type of rhs.Agda  " vs : as+ with arguments and their types. Output:Agda( , ,,t',vtys') where  :part of context needed for with arguments and their types. >part of context not needed for with arguments and their types.*permutation from  to   as returned by , .   " t'type of rhs under   " vtys'%with-arguments and their types under .3:Agda 8 context for types of with types.Agda , " vs : raise  as. with and rewrite-expressions and their type.Agda "  > context extension to type with-expressions.Agda  , " b type of rhs.Agda ! 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.3= Agda6Names of the module parameters of the parent function.AgdaName of the parent function.AgdaName of the with-function.AgdaTypes of the parent function.AgdaContext of parent patterns.AgdaParent patterns.Agda.Number of module parameters in parent patternsAgda1Substitution from parent lhs to with function lhsAgdaFinal permutation. AgdaNumber of needed vars. AgdaNumber of with expressions. Agda With-clauses. Agda,With-clauses flattened wrt. parent patterns.3> AgdacxtNames6 names of the module parameters of the parent functionAgdaparent name of the parent function.Agdaf name of with-function.Agdat+ top-level type of the original function.Agda* context of patterns of parent function.Agdaqs* internal patterns for original function.Agdanpars number of module parameters in qs.Agda permutation taking vars(qs) to  support().Agdaps, patterns in with clause (eliminating type t). Agdaps'0 patterns for with function (presumably of type ).3?AgdaThe name of parent function.AgdaThe name of the with -function.Agda  The arguments of the with function before the with expressions.Agda  The arguments of the with function after the with expressions.Agdan The number of with expressions.Agdaqs The parent patterns.Agdaperm7 Permutation to split into needed and unneeded vars.AgdalhsPerm9 Permutation reordering the variables in parent patterns.393:3;3<3=3>3?3@393:3;3<3=3>3?3@None"#$&',14568=>?@ACEMPSX\_`'90AgdalRemove all non-coinductive projections from an algebraic term (not going under binders). Also, remove s.91Agda)Extract recursive calls from expressions.92Agda]Convert a term (from a dot pattern) to a pattern for the purposes of the termination checker.SIZESUC is treated as a constructor.3AAgda:The result of termination checking a module. Must be a 7 and have Q.93Agda-Call graph with call info for composed calls.3BAgda4Entry point: Termination check a single declaration.Precondition: b must be set correctly.94AgdaHTermination check a single declaration (without necessarily ignoring abstract).3CAgda8Entry point: Termination check the current mutual block.95Agda 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).96AgdaSmart constructor for  . Removes   that are not mentioned in  .97Agda reportCalls for debug printing.0Replays the call graph completion for debugging.98AgdatermFunction name checks name for termination.99AgdaTo process the target type.9:Agda3Termination 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.9;Agda Collect calls in type signature f : (x1:A1)...(xn:An) -> BI. It is treated as if there were the additional function clauses. @T f = A1 f x1 = A2 f x1 x2 = A3 ... f x1 ... xn = B @9<AgdaMask arguments and result for termination checking according to type of function. Only arguments of types ending in data/record or Size are counted in.9=Agda0Is the current target type among the given ones?9>Agda:Convert a term (from a dot pattern) to a DeBruijn pattern.MThe term is first normalized and stripped of all non-coinductive projections.9?AgdaKMasks all non-data/record type patterns if --without-K. See issue #1023.9@Agda(Extract recursive calls from one clause.9AAgda7Extract recursive calls from a constructor application.9BAgdaHandles function applications g es.9CAgda\Try to get rid of a function call targeting the current SCC using a non-recursive clause.9This can help copattern definitions of dependent records.9DAgda Rewrite type tel -> Size< u to  tel -> Size.9EAgda 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.9FAgdaTraverse patterns from left to right. When we come to a projection pattern, switch usage of SIZELT constraints: on, if coinductive, off, if inductive.UNUSED annotatePatsWithUseSizeLt :: [DeBruijnPattern] -> TerM [(Bool,DeBruijnPattern)] annotatePatsWithUseSizeLt = loop where loop [] = return [] loop (p@(ProjP _ q) : pats) = ((False,p) :)  $J do projUseSizeLt q $ loop pats loop (p : pats) = ( b ps -> (b,p) : ps)  $ terGetUseSizeLt  * loop pats compareElim e dbpat9GAgdaIn 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.9HAgda9H turns the result of 9E into a proper call matrix9IAgda9I7 adds guardedness flag in the upper left corner (0,0).9JAgda=Compose something with the upper-left corner of a call matrix9KAgdaStripping 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.9LAgda2Normalize outermost constructor name in a pattern.9MAgda compareTerm' t dbpat9NAgdasubTerm# computes a size difference (Order)9OAgdaCompare two variables.@The first variable comes from a term, the second from a pattern.3JAgda/Extract recursive calls from level expressions.3KAgda$Extract recursive calls from a term.3LAgda$Extract recursive calls from a type.3MAgda*Sorts can contain arbitrary terms of type Level<, so look for recursive calls also in sorts. Ideally, ; would not be its own datatype but just a subgrammar of *, then we would not need this boilerplate.3CAgdaUThe function names defined in this block on top-level. (For error-reporting only.)9AAgdaConstructor name.Agda>Should the constructor be treated as inductive or coinductive?Agda@All the arguments, and for every argument a boolean which is 77@ iff the argument should be viewed as preserving guardedness.9CAgdaFunctionAgda ArgumentsAgda&Continue here if we managed to reduce.AgdaOtherwise, continue here.3A3B3C3B3C3ANone"#$,14568=>?@ACEPSX_`"3YAgda Check that   "  : .3X3Y3X3YNone"#$,14568=>?@ACEPSX_` 3Z3ZNone"#$,14568=>?@ACEPSX_`3[3[None"#$,14568=>?@ACEPSX_`:3\AgdaELine reader. The line reader history is not stored between sessions.A!3\A!3\None"#$,14568=>?@ACEPSX_`ʳ3]AgdaThe JSON version of# , for encoding JSON value in TCM3_AgdaTCM monadic version of object3`Agda'Pairs a key with a value wrapped in TCM3aAgda"Abbreviation of `_ #= encodeTCM _`3bAgdaA handy alternative of 3_ with kind specified3cAgdaA handy alternative of 9P with kind specified 3]3^3_3`3a3b3c 3]3^3_3b3c3a3` None"#$,14568=>?@ACEPSX_`3o3p3q3r3s3t3u3v3o3p3q3r3s3t3u3vNone"#$,14568=>?@ACEPSX_` 3zAgdaMRecords already processed modules and maps them to an internal identifier.3{AgdaSupply of internal identifiers.3|AgdaEdges of dependency graph.3}AgdaAInternal module identifiers for construction of dependency graph.3Agda Translate a  V to an internal 3} . Returns True if the  Vd is new, i.e., has not been encountered before and is thus added to the map of processed modules.3Agda%Add an arc from importer to imported.3Agda4Recursively build import graph, starting from given  $. Modifies the state in 3w and returns the 3} of the  $.3AgdaEGenerate a .dot file for the import graph starting with the given  $B and write it to the file specified by the command line option. 3w3x3y3|3{3z3}3~3333 3}3x3y3|3{3z3~3w3333None"#$,14568=>?@ACEPSX_`3Agda Converts the   and  1 fields to strings that are friendly to editors.3AgdaKChoose which method to use based on HighlightingInfo and HighlightingMethod3333 None"#$,14568=>?@ACEPSX_`3333!None"#$,14568=>?@ACEPSX_`33"None"#$,14568=>?@ACEPSX_`33#None"#$,14568=>?@ACEPSX_`߾33None"#$,14568=>?@ACEPSX_`gM9QAgda Eraser monad.9RAgdaState of the eraser.9SAgdaMemoize computed 9T for functions constructors...  ].9UAgdaMemoize computed 9V for data/record types  ].3Agda'Takes the name of the data/record type.9WAgdaDoesn't have any type information (other than the name of the data type), so we can't do better than checking if all constructors are present.9XAgdazStrip unreachable clauses (replace by tUnreachable for the default). Fourth argument is the set of ints covered so far.$\3333$\$None"#$,14568=>?@ACEPSX_`S333333333333%None"#$,14568=>?@ACEPSX_`q33&None"#$,14568=>?@ACEPSX_`g33(None"#$,14568=>?@ACEPSX_`3Agda$Insert unsafeCoerce (in the form of oC) everywhere it's needed in the right-hand side of a definition.3Agda/The number of retained arguments after erasure.3333)None"#$,14568=>?@ACEPSX_`l3AgdaCalls 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.3AgdaGeneralisation of  callCompiler) where the raised exception is returned.3Agda$Should we actually call the compilerAgdaThe path to the compilerAgdaCommand-line arguments.3AgdaThe path to the compilerAgdaCommand-line arguments.3333*None"#$,14568=>?@ACEPSX_`L9YAgda)Encode meta information into a JSON Value3Agda7Turns syntax highlighting information into a JSON value9YAgda@Must contain a mapping for the definition site's module, if any.3Agda:Must contain a mapping for every definition site's module.33None"#$,14568=>?@ACEPSX_`8O$4AgdaHighlight a warning.9ZAgda<A function mapping names to the kind of name they stand for.3AgdaHighlighting levels.3AgdaXFull highlighting. Should only be used after typechecking has completed successfully.3AgdaBHighlighting without disambiguation of overloaded constructors.3AgdawGenerate syntax highlighting information for the given declaration, and (if appropriate) print it. If the boolean is 77, 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  U (that corresponding to the interval covered by the declaration). If the boolean is 77B, then this token highlighting info is additionally removed from  .3AgdaZGenerate and return the syntax highlighting information for the tokens in the given file.3AgdaZGenerate and return the syntax highlighting information for the tokens in the given file.3AgdaGenerate and return the syntax highlighting information for the tokens in the given string, which is assumed to correspond to the given range.9[Agda1Compute syntax highlighting for the given tokens.9\Agda Builds a 9Z function.9]AgdaGenerates 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.3Agda-Prints syntax highlighting info for an error.3Agda Generate highlighting for error.3Agda*Generate syntax highlighting for warnings.9^Agda4Generate syntax highlighting for termination errors.9_AgdaNGenerate syntax highlighting for not-strictly-positive inductive definitions.3AgdasGenerates and prints syntax highlighting information for unsolved meta-variables and certain unsolved constraints.3AgdaGGenerates syntax highlighting information for unsolved meta variables.3Agda{Generates syntax highlighting information for unsolved constraints (ideally: that are not connected to a meta variable).9`Agda8Generates a suitable file for a possibly ambiguous name.9aAgdaConverts names to suitable s.9bAgda A variant of 9a for qualified abstract names.3AgdafRemember a name disambiguation (during type checking). To be used later during syntax highlighting.3AgdaLStore a disambiguation of record field tags for the purpose of highlighting.3AgdaUpdate the state?3AgdaThe module to highlight.Agda)The file contents. Note that the file is not read from disk.9\AgdaThis should only be 3@ if type-checking completed successfully (without any errors).9]Agda'Maps source file paths to module names.AgdaThe module to highlight.9`Agda'Maps source file paths to module names.AgdaThe module to highlight.9aAgda'Maps source file paths to module names.AgdaDThe file name of the current module. Used for consistency checking.Agda"The name qualifier (may be empty).AgdaThe base name.AgdaThe e0 of the name in its fixity declaration (if any).AgdaBMeta information to be associated with the name. The argument is 77 iff the name is an operator.AgdarThe definition site of the name. The calculated meta information is extended with this information, if possible.9bAgda'Maps source file paths to module names.AgdaDThe file name of the current module. Used for consistency checking.Agda The name.Agda0Should the binding site be included in the file?AgdaDMeta information to be associated with the name. ^ The argument is 77 iff the name is an operator.3Agda*Record field names in a record expression.Agda>Record field names in the corresponding record type definition$4%%333333333333333333333333333%%$433333+None"#$,14568=>?@ACEPSX\_`#3Agda'Result of checking the LHS of a clause.3AgdaQThe number of original module parameters. These are present in the the patterns.3AgdaV : The types of the pattern variables, in internal dependency order. Corresponds to .3Agda The patterns in internal syntax.3Agda0Whether the LHS has at least one absurd pattern.3AgdaThe type of the body. Is b if  is defined. 8 to indicate the rhs must be checked in irrelevant mode.3AgdaSubstitution version of  lhsPatterns,, only up to the first projection pattern.  |- lhsPatSubst : . Where u is the argument telescope of the function. This is used to update inherited dot patterns in with-function clauses.3AgdaAs-bindings from the left-hand side. Return instead of bound since we want them in where's and right-hand sides, but not in with-clauses (Issue 2303).3Agdahave we done a partial split?3AgdaiA pattern is flexible if it is dotted or implicit, or a record pattern with only flexible subpatterns.9cAgdaUpdate the given LHS state: 1. simplify problem equations 2. rename telescope variables 3. introduce trailing patterns9dAgdalUpdate the user patterns in the given problem, simplifying equations between constructors where possible.9eAgda`Check if a problem is solved. That is, if the patterns are all variables, and there is no  problemRest.9fAgdaHCheck if a problem consists only of variable patterns. (Includes the  problemRest).9gAgda.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.9hAgda4Check that a dot pattern matches it's instantiation.9iAgdaAfter splitting is complete, we transfer the origins We also transfer the locations of absurd patterns, since these haven't been introduced yet in the internal pattern.9jAgdaIf a user-written variable occurs more than once, it should be bound to the same internal variable (or term) in all positions. Returns the list of patterns with the duplicate user patterns removed.9kAgdabConstruct the context for a left hand side, making up out-of-scope names for unnamed variables.3AgdaBind as patterns9lAgdaSince with-abstraction can change the type of a variable, we have to recheck the stripped with patterns when checking a with function.3AgdaCheck 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.9mAgda'Determine which splits should be tried.9nAgdaUThe loop (tail-recursive): split at a variable in the problem until problem is solved9oAgda>Ensures that we are not performing pattern matching on codata.9pAgdaWhen working with a monad m implementing MonadTCM and MonadError TCErr, suspendErrors f performs the TCM action f8 but catches any errors and throws them in the monad m instead.9qAgda5A more direct implementation of the specification 2softTypeError err == suspendErrors (typeError err)9rAgdaA convenient alias for liftTCM . typeErrord. Throws the error directly in the TCM even if there is a surrounding monad also implementing MonadError TCErr.9sAgdaCheck if the type is a data or record type and return its name, definition, parameters, and indices. Fails softly if the type could become a data'record type by instantiating a variable(metavariable, or fail hard otherwise.9tAgdayGet the constructor of the given record type together with its type. Throws an error if the type is not a record type.9uAgdaDisambiguate a projection based on the record type it is supposed to be projecting from. Returns the unambiguous projection name and its type. Throws an error if the type is not a record type.9vAgdaDisambiguate a constructor based on the data type it is supposed to be constructing. Returns the unambiguous constructor name and its type. Precondition: type should be a data/record type.9wAgda#checkConstructorParameters 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.9xAgda[Check that given parameters match the parameters of the inferred constructor/projection.3AgdaLists of flexible patterns are / .3Agda Trace, e.g.  or .Agda+The name of the definition we are checking.Agda The patterns.AgdaThe expected type  a =  ! b.Agda4Module parameter substitution from with-abstraction.AgdaiPatterns that have been stripped away by with-desugaring. ^ These should not contain any proper matches.Agda Continuation.9nAgda+The name of the definition we are checking.AgdaThe current state.9tAgdaName d of the record typeAgda Parameters pars of the record typeAgdaThe record type  Def d pars (for error reporting)9uAgda7Hiding info of the projection's principal argument. Nothing if Postfix projection.Agda+Name of the projection to be disambiguated.Agda#Record type we are projecting from.9vAgda0The name of the constructor to be disambiguated.AgdaName of the datatype.AgdaParameters of the datatype9xAgda The record(data type name of the chosen constructor projection.Agda<The record/data type name as supplied by the type signature.AgdaThe parameters.33333333333333333333333333333333None"#$,14568=>?@ACEPSX\_`,#MAgdaRun a tactic `tac : Term ! TC "` in a hole (second argument) of the type given by the third argument. Runs the continuation if successful.#OAgda=Checking a lambda whose domain type has already been checked.#PAgdaInfer the type of an expression. Implemented by checking against a meta variable. Except for neutrals, for them a polymorphic type is inferred.#RAgdaType check an expression.#SAgda@Check that an expression is a type and infer its (minimal) sort.3Agda(Flag to control resurrection on domains.3AgdaWe are checking a module telescope. We pass into the type world to check the domain type. This resurrects the whole context.3AgdaWe 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.3Agda#Check that an expression is a type.3Agda,Check that an expression is a type. * If  c == CmpEq3, the given sort must be the minimal sort. * If  c == CmpLeq(, the given sort may be any bigger sort.3Agda?Ensure that a (freshly created) function type does not inhabit . 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 .3AgdaBCheck that an expression is a type which is equal to a given type.3AgdaQType check a (module) telescope. Binds the variables defined by the telescope.3AgdaType check the telescope of a dependent function type. Binds the resurrected variables defined by the telescope. The returned telescope is unmodified (not resurrected).3AgdaEType check a telescope. Binds the variables defined by the telescope.3AgdaCheck 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.3AgdaAAfter a typed binding has been checked, add the patterns it binds3Agda7Check a tactic attribute. Should have type Term ! TC ".3AgdaPType check a lambda expression. "checkLambda bs e ty" means ( bs -> e) : ty3AgdaCheck that modality info in lambda is compatible with modality coming from the function type. If lambda has no user-given modality, copy that of function type.3AgdaCheck that irrelevance info in lambda is compatible with irrelevance coming from the function type. If lambda has no user-given relevance, copy that of function type.3AgdaCheck that quantity info in lambda is compatible with quantity coming from the function type. If lambda has no user-given quantity, copy that of function type.3AgdaCheck that cohesion info in lambda is compatible with cohesion coming from the function type. If lambda has no user-given cohesion, copy that of function type.3AgdamInsert hidden lambda until the hiding info of the domain type matches the expected hiding info. Throws l3AgdacheckAbsurdLambda i h e t# checks absurd lambda against type t. Precondition: e = AbsurdLam i h3Agda%checkExtendedLambda i di qname cs e t/ check pattern matching lambda. Precondition: e = ExtendedLam i di qname cs3AgdaRun a computation.&If successful, that's it, we are done.If IlltypedPattern p a, NotADatatype a or CannotEliminateWithPattern p a is thrown and type a is blocked on some meta x?, reset any changes to the state and pass (the error and) x to the handler.If +SplitError (UnificationStuck c tel us vs _), is thrown and the unification problem us =?= vs : tel is blocked on some meta x pass x to the handler.(If another error was thrown or the type a# is not blocked, reraise the error.nNote that the returned meta might only exists in the state where the error was thrown, thus, be an invalid z in the current state.3AgdawPicks up record field assignments from modules that export a definition that has the same name as the missing field.3AgdacheckRecordExpression fs e t) checks record construction against type t. Precondition  e = Rec _ fs.3Agda 'checkRecordUpdate cmp ei recexpr fs e tPreconditions: e = RecUpdate ei recexpr fs and t is reduced.3AgdaVRemove top layers of scope info of expression and set the scope accordingly in the  .3Agda*Unquote a TCM computation in a given hole.3Agda-Check an interaction point without arguments.3Agda&Check an underscore without arguments.3AgdaType check a meta variable.3Agda\Infer the type of a meta variable. If it is a new one, we create a new meta for its type.3AgdaType 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.3AgdatTurn a domain-free binding (e.g. lambda) into a domain-full one, by inserting an underscore for the missing type.3Agda,Check arguments whose value we already know.eThis function can be used to check user-supplied parameters we have already computed by inference.Precondition: The type t of the head has enough domains.3Agda.Check an argument whose value we already know.3AgdaCheck a single argument.3AgdaUsed to check aliases f = e. Switches off L+ for the checking of top-level application.3Agda?Check whether a de Bruijn index is bound by a module telescope.3Agda=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.#QAgda Unreduced!3AgdaExpected hiding.AgdaExpected to be a function type.AgdaContinuation on blocked type.AgdaQContinuation when expected hiding found. The continuation may assume that the Type is of the form (El _ (Pi _ _)).Agda!Term with hidden lambda inserted.3AgdaModules and field assignments.Agda#Names of fields of the record type.Agda)Completed field assignments from modules.3AgdamHow do we related the inferred type of the record expression to the expected type? Subtype or equal type?Agdamfs : modules and field assignments.AgdaMust be  A.Rec _ mfs.Agda#Expected type of record expression.Agda Record value in internal syntax.3Agda cmpAgda eiAgda recexprAgda fsAgda e = RecUpdate ei recexpr fsAgdaReduced.3Agda Not reduced!3Agda5User-supplied arguments (hidden ones may be missing).Agda+Inferred arguments (including hidden ones).Agda7Type of the head (must be Pi-type with enough domains).Agda-Remaining inferred arguments, remaining type.3AgdaUser-supplied argument.Agda+Inferred arguments (including hidden ones).Agda7Type of the head (must be Pi-type with enough domains).Agda-Remaining inferred arguments, remaining type.9#M#N#O#P#Q#R#S33333333333333333333333333333333333333333333333333933#S3333333333333333333333#O333333333#R#Q#N3#M333333333#P3333333,None"#$,14568=>?@ACEPSX\_` 9yAgdaChecks that builtin with name  b : String of type t : Term, is a data type or inductive record with n : Int; constructors. Returns the name of the data/record type.3AgdabindPostulatedName builtin q m checks that q. is a postulated name, and binds the builtin builtin to the term m q def , where def is the current X of q.9zAgdaLCheck that we're not trying to bind true and false to the same constructor.9{AgdasOnly use for datatypes with distinct arities of constructors. Binds the constructors together with the datatype.9|Agda'Bind BUILTIN EQUALITY and BUILTIN REFL.3Agda&Bind a builtin thing to an expression.4Agda#Bind a builtin thing to a new name.Since their type is closed, it does not matter whether we are in a parameterized module when we declare them. We simply ignore the parameters.333344344333None"#$,14568=>?@ACEPSX_` *Agda3Binds the FLAT builtin, and changes its definition.*AgdaLBinds the SHARP builtin, and changes the definitions of INFINITY and SHARP.*AgdaGBinds the INFINITY builtin, but does not change the type's definition.*Agda The type of &m.*Agda The type of &o_.*Agda The type of ".************-None"#$,14568=>?@ACEHPSVX_` _.9}Agda,The with clauses haven't been translated yet9~Agdarewrite e | with p <- e (many)9Agdawith e (many)9Agdapthe subclauses spawned by a with (monadic because we need to reset the local vars before checking these clauses)9AgdaThe name of the where module (if any).9AgdaThe contents of the where module.9Agda4Make sure definition is in same module as signature.4Agdaas seen from inside the module4Agda*Temporary data type to scope check a file.4 Agda/The file path from which we loaded this module.4 AgdagThe expected module name (coming from the import statement that triggered scope checking this file).4 AgdaThe file content.9Agda$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.9AgdaWIf a set is given, then the first name must correspond to one of the names in the set.9AgdaWrapper to resolve a name to a  (rather than an ).9AgdaWe sometimes do not want to fail hard if the name is not actually in scope because we have a strategy to recover from this problem (e.g. drop the offending COMPILE pragma)4AgdaPThings that can be translated to abstract syntax are instances of this class.9AgdaFMake sure that there are no dot patterns (called on pattern synonyms).9AgdaCCompute the type of the record constructor (with bogus target type)9Agda BcheckModuleMacro mkApply range access concreteName modapp open dirPreserves local variables.9AgdaThe public) keyword must only be used together with open.9AgdaJComputes the range of all the "to" keywords used in a renaming directive.9AgdaScope check a  .9Agda(This function should be used instead of 4a for things that need to keep track of precedences to make sure that we don't forget about it.4AgdaaThis operation does not affect the scope, i.e. the original scope is restored upon completion.9AgdaLike 4F but returns the scope after the completion of the second argument.9AgdalTranslate and possibly bind a pattern variable (which could have been bound before due to non-linearity).9Agda Peel off  and represent it as an , throwing away any name.9AgdaParse a possibly dotted C.Expr as A.Expr!, interpreting dots as relevance.9AgdamTranslate concrete expression under at least one binder into nested lambda abstraction in abstract syntax.9Agda'Scope check extended lambda expression.9Agda*Scope check a module (top level function).9AgdaACheck whether a telescope has open declarations or module macros.9Agda,Returns the scope inside the checked module.4AgdaThe top-level module name.9Agda@runs Syntax.Concrete.Definitions.niceDeclarations on main module9AgdacBind generalizable variables if data or record decl was split by the system (origin == Inserted)9AgdaUnless the resolved  has the given , report a  for the  .9AgdaIf a (data/record) module with the given name is already present in the current module, we take this as evidence that a data/record with that name is already defined.9AgdaRecord constructors do not live in the record module (as it is parameterized). Abstract constructors are bound privately, so that they are not exported.9Agda;Apply an abstract syntax pattern head to pattern arguments. Fails with P if head is not a constructor pattern (or similar) that can accept arguments.9Agda 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.9AgdaxTurn an operator application into abstract syntax. Make sure to record the right precedences for the various arguments.4AgdaContent of interaction hole.4DAgda%Top-level declarations are always  (import|open)* -- a bunch of possibly opened imports module ThisModule ... -- the top-level module of this file 4FAgdaScope check an expression.9AgdaConcrete name to be resolvedAgdaYIf a set is given, then the first name must correspond to one of the names in the set.9Agda Range of open statement.Agda9Resolution of concrete module name (if already resolved).AgdaModule to open.AgdaScope modifier.Agda Arguments of 9Agda The concrete name of the module.Agda The abstract name of the module.AgdaThe module telescope.Agda*The code for checking the module contents.9AgdaName of data/record module.AgdaConstructor name.9AgdaThe range of the where-block.AgdaThe name of the where module (if any).AgdaThe contents of the where module.Agda8The scope-checking task to be run in the context of the where module.Agda6Additionally return the scope-checked contents of the where module.9Agda+The application pattern in concrete syntax.AgdaHead of application.AgdaArguments of application.44444444 4 4 4 4 44444444444444444444 444444 4 4 44444444 4444.None"#$,14568=>?@ACEPSX\_` ‘9Agda!Allow partial covering for split?9Agda%Introduce trailing pattern variables?9Agda"The set of patterns used as cover.4VAgdaA Covering is the result of splitting a 4Z.4XAgda@De Bruijn level (counting dot patterns) of argument we split on.4YAgdaECovering clauses, indexed by constructor/literal these clauses share.4\AgdaType of variables in scPats.4]AgdaMThe patterns leading to the currently considered branch of the split tree.4^AgdaSubstitution from 4\Q to old context. Only needed directly after split on variable: * To update 4`T * 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 4\L over a series of splits. It is freshly computed after each split by computeNeighborhood ; also 4hI, which does not split on a variable, should reset it to the identity , lest it be applied to 4` again, leading to Issue 1294.4_AgdaWe need to keep track of the module parameter checkpoints for the clause for the purpose of inferring missing instance clauses.4`Agda'The type of the rhs, living in context 4\. 9 computes the new 4` by applying substitution 4^.4aAgda,Project the split clauses out of a covering.4bAgdaJCreate a split clause from a clause in internal syntax. Used by make-case.4cAgda1Top-level function for checking pattern coverage.Effects:3Marks unreachable clauses as such in the signature.0Adds missing instances clauses to the signature.4dAgdaXTop-level function for eliminating redundant clauses in the interactive case splitter9Agda=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.*Effect: adds missing instance clauses for f to signature.9Agda4Append an hcomp clause to the clauses of a function.9Agda6Append a instance clause to the clauses of a function.9Agda_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.9Agda>Update the target type of the split clause after a case split.4eAgda~Add more patterns to split clause if the target type is a function type. Returns the domains of the function type (if any).9Agda <computeNeighbourhood delta1 delta2 d pars ixs hix tel ps con  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 tel Telescope for patterns ps ps Patterns before doing the split cps Current module parameter checkpoints con Constructor to fit into hole dtype == d pars ixs4fAgdaEntry point from Interaction.MakeCase.4gAgdaEntry point from TypeChecking.Empty and Interaction.BasicOps. splitLast CoInductive is used in the refine tactics.9Agda$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).9AgdaConvert 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!).9Agda+split' ind pc ft 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.4hAgdaGsplitResult for MakeCase, tries to introduce IApply or ProjP copatterns9Agda9Tries to split the result to introduce an IApply pattern.9Agda #splitResultRecord 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 == Left _V. Note that the empty set of split clauses is returned if the record has no fields.4iAgdaFor debugging only.4cAgdaName f of definition.Agda7Absolute type (including the full parameter telescope).Agda Clauses of f!. These are the very clauses of f in the signature.9AgdaFunction name.Agdaindex of hcomp patternAgda&Blocking var that lead to hcomp split.AgdaClause before the hcomp splitAgdaClause to add.9AgdaFunction name.Agda"Clause to add. Clause hiding (in  ) must be  .9 AgdaTelescope before split point.Agda(Name of pattern variable at split point.AgdaTelescope after split point.AgdaName of datatype to split at.AgdaData type parameters.AgdaData type indices.AgdaIndex of split variable.AgdaTelescope for the patterns.Agda Patterns before doing the split. AgdaWCurrent checkpoints -> QName -- ^ Constructor to fit into hole. AgdaNew split clause if successful.9 AgdaTelescope before split point.Agda(Name of pattern variable at split point.AgdaTelescope after split point.AgdaName of datatype to split at.AgdaData type parameters.AgdaData type indices.AgdaIndex of split variable.AgdaTelescope for the patterns.Agda Patterns before doing the split. AgdaCurrent checkpoints AgdaConstructor to fit into hole. AgdaNew split clause if successful.9Agda:Coinductive constructors are allowed if this argument is .AgdaDon't fail if computed 4V! does not cover all constructors.9AgdaUse isEmptyType to check whether the type of the variable to split on is empty. This switch is necessary to break the cycle between split' and isEmptyType.Agda:Coinductive constructors are allowed if this argument is .AgdaDon't fail if computed 4V! does not cover all constructors.AgdaIf 9+, introduce new trailing variable patterns..4V4W4X4Y4Z4[4\4]4^4_4`4a4b4c4d4e4f4g4h4Z4[4\4]4^4_4`4b4e4V4W4X4Y4a4c4d4f4g4h.None"#$,14568=>?@ACEPSX_` f-dAgdaCheck whether one of the types in the given telescope is constructor-less and if yes, return its index in the telescope (0 = leftmost).-eAgdaTEnsure that a type is empty. This check may be postponed as emptiness constraint.-fAgda0Check whether some type in a telescope is empty.-gAgdaCheck whether a type is empty.9AgdaGeneric failure9AgdaFailure with informative error9AgdaEmptyness check blocked-eAgdaRange of the absurd pattern.AgdaHType that should be empty (empty data type or iterated product of such).-d-e-f-g-g-f-e-dNone"#$,14568=>?@ACEPSX_` $ Agda%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.4qAgdaStripped-down version of  used in clause compiler.4sAgda8Pattern variables are considered in left-to-right order.4yAgdaSStrip down a clause. Don't forget to apply the substitution to the dot patterns!4|AgdaGet the index of the next argument we need to split on. This the number of the first pattern that does a (non-lazy) match in the first clause. Or the first lazy match where all clauses agree on the constructor, if there are no non-lazy matches.4}Agda]Is is not a variable pattern? And if yes, is it a record pattern and/or a fallThrough one?4~AgdaIs this a variable pattern?Maintain invariant: isVar = isNothing . properSplit!4AgdasplitOn single n cs* will force expansion of catch-alls if single.4Agda4Expand 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 Example from issue #2168: G f x false = a f false = _ -> b f x true = c  case tree: c f x y = case y of true -> case x of true -> c false -> b false -> a Example from issue #3628: H f i j k (i = i0)(k = i1) = base f i j k (j = i1) = base  case tree:  f i j k o = case i of i0 -> case k of i1 -> base _ -> case j of i1 -> base _ -> case j of i1 -> base 4Agda<Make sure (by eta-expansion) that clause has arity at least n where n) is also the length of the provided list.$ Agda=Translate record patterns and coverage check with given type?AgdaThe 7H indicates whether we turned a record expression into a copattern match.$ 4p4q4r4t4s4u4w4v4x4y4z4{4|4}4~444444u4w4v4x$ 4q4r4t4s4p4y4z4{4|4}4~44444/None"#$,14568=>?@ACEPSX\_`! 4Agda '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.4Agda(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 checked4 AgdaPosition and other info.AgdaRecord type identifier.AgdaCheck universes?Agda$Optional: (co)inductive declaration.Agda#Optional: user specified eta/no-etaAgdaOptional: constructor name.AgdaRecord parameters.Agda!Approximate type of constructor (fields0 -> Set). Does not include record parameters.AgdaField signatures.4AgdaDatatype name.Agda parameters.AgdaProjection names.Agda "  field types.Agda " T target type.4Agdasome name, e.g. record nameAgda param types Agdafields' types  " Agda fields' namesAgdarecord type  " T4Agdasome name, e.g. record nameAgda param types Agdafields' types  " Agda fields' namesAgdarecord type  " T4444444444None"#$,14568=>?@ACEPSX\_`!>*AgdaSet " according to termination info in  4, which comes from a possible termination pragma.*Agda)Enter a new section during type-checking.*Agda,Type check a definition by pattern matching.4Agda,Which argument indexes have a partial split.4AgdaParameters for creating a with -function.4AgdaParent function name.4AgdaWith function name.4AgdaType of the parent function.4AgdaContext of the parent patterns.4AgdaRTypes of arguments to the with function before the with expressions (needed vars).4AgdaSTypes of arguments to the with function after the with expressions (unneeded vars).4Agda-With and rewrite expressions and their types.4AgdaType of the right hand side.4AgdaParent patterns.4Agda.Number of module parameters in parent patterns4AgdaQPermutation resulting from splitting the telescope into needed and unneeded vars.4Agda;Permutation reordering the variables in the parent pattern.4Agda@Final permutation (including permutation for the parent clause).4Agda'The given clauses for the with function4AgdaIA single clause without arguments and without type signature is an alias.4Agda'Check a trivial definition of the form f = e4Agda,Type check a definition by pattern matching.4AgdaQInsert some with-patterns into the with-clauses LHS of the given RHS. (Used for rewrite.)4AgdaeInsert with-patterns before the trailing with patterns. If there are none, append the with-patterns.4AgdaThe LHS part of checkClause.4AgdaType check a function clause.4AgdaType check the with and rewrite lhss and/or the rhs.4AgdaInvoked in empty context.4AgdaType check a where clause.4AgdaSet the current clause number.*Agda'the type we expect the function to haveAgdais it irrelevant (for instance)Agda2are the clauses delayed (not unfolded willy-nilly)Agdapdoes the definition come from an extended lambda (if so, we need to know some stuff about lambda-lifted args)AgdaEis it a with function (if so, what's the name of the parent function)Agda range infoAgdathe name of the functionAgdathe clauses to check4 Agda'the type we expect the function to haveAgdais it irrelevant (for instance)Agda2are the clauses delayed (not unfolded willy-nilly)Agdapdoes the definition come from an extended lambda (if so, we need to know some stuff about lambda-lifted args)AgdaEis it a with function (if so, what's the name of the parent function)Agda range infoAgdathe name of the functionAgdaRsubstitution (from with abstraction) that needs to be applied to module parametersAgdathe clauses to check4Agda(Type of function defined by this clause.Agda<Module parameter substitution arising from with-abstraction.AgdaClause.AgdaType-checked clause4Agda Range of lhs.AgdaName of function.AgdaPatterns in lhs.AgdaTop-level type of function.Agda Result of type-checking patternsAgda Rhs to check.4AgdaName of function.AgdaName of the with-function.AgdaType of function.Agda Result of type-checking patternsAgda*Expressions and types of with-expressions.AgdaWith-clauses to check.4AgdaWhere-declarations to check.Agda Continuation.&****4444444444444444444444444444444444&*444*4*44444444444444444444444444444*40None"#$,14568=>?@ACEPSX_`!f9Agda*Environment for naming of local variables.9Agda;Maps case tree de-bruijn indices to TTerm de-bruijn indices9AgdayTTerm de-bruijn index of the current catch all If an inner case has no catch-all clause, we use the one from its parent.9Agda5Recompile clauses with forcing translation turned on.4Agda-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.9Agda1Does not require the name to refer to a function.9Agda.Initial environment for expression generation.9Agda%Term variables are de Bruijn indices.9Agda$Case variables are de Bruijn levels.9Agda<Compile a case tree into nested case and record expressions.9AgdaShrinks or grows the context to the given size. Does not update the catchAll expression, the catchAll expression MUST NOT be used inside cont.9AgdaAdds lambdas until the context has at least the given size. Updates the catchAll expression to take the additional lambdas into account.9AgdaReplace de Bruijn Level x by n new variables.9AgdaPrecondition: Map not empty.9AgdaeTranslate 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.9AgdaEta-contract erased lambdas.(Should also be fine for strict backends:Ieta-contraction is semantics-preserving for total, effect-free languages.Fshould a user rely on thunking, better not used an erased abstraction!;A live-or-death issue for the GHC 8.0 backend. Consider: 5 foldl : " {A} (B : Nat ! Set) ! (f : " {?0 n} ! B n ! A ! B (suc n)) ! (z : B 0) ! " {J0 n} ! Vec A n ! B n foldl B f z (x "7 xs) = foldl ( n ! B (suc n)) ({40 x} ! f {suc x}) (f z x) xs foldl B f z [] = z  The hidden composition of f with suc, term ({0 x} ! f {suc x})!, can be eta-contracted to just f/ by the compiler, since the first argument of f is erased.HGHC >= 8.2 seems to be able to do the optimization himself, but not 8.0.9AgdaCase tree de bruijn index.AgdaTTerm de bruijn index.9Agdacase tree de bruijn levelAgdaTTerm de bruijn index4444None"#$,14568=>?@ACEPSX\_`!.#WAgdaBChecking the type of an overloaded projection application. See 9.#XAgdaPrecondition: Application hd args = appView e.#YAgdacheckApplication hd args e t) checks an application. Precondition: Application hs args = appView echeckApplication1 disambiguates constructors (and continues to 9#) and resolves pattern synonyms.#ZAgdaCheck that a list of arguments fits a telescope. Inserts hidden arguments as necessary. Returns the type-checked arguments and the remaining telescope.#[Agda!checkArguments exph r args t0 t k tries checkArgumentsE 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.9Agda+Ranges of checked arguments, where present.9AgdaInfer 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.9Agda?The second argument is the definition of the first. Returns 7>$ if ok, otherwise the error message.9Agda?The second argument is the definition of the first. Returns 7>$ if ok, otherwise the error message.9Agda3The second argument is the definition of the first.9Agda3The second argument is the definition of the first.9Agda 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.9AgdaFIf we've already checked the target type we don't have to call coerce.9AgdaCheck 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.9AgdaCheck 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.9Agda0Returns an unblocking action in case of failure.9AgdaCInferring the type of an overloaded projection application. See 9.9AgdaBChecking the type of an overloaded projection application. See 9.9Agda;Inferring or Checking an overloaded projection application.The overloaded projection is disambiguated by inferring the type of its principal argument, which is the first visible argument.9AgdaSame arguments 9O above but also gets the position, value and type of the principal argument.9Agdav"pathAbs (PathView s _ l a x y) t" builds "( t) : pv" Preconditions: PathView is PathType, and t[i0] = x, t[i1] = y9Agda `primComp : " {!} (A : (i : I) ! Set (! i)) ( : I) (u : " i ! Partial  (A i)) (a : A i0) ! A i1Check: #u i0 = ( _ ! a) : Partial  (A i0).9Agda IprimHComp : " {!} {A : Set !} { : I} (u : " i ! Partial  A) (a : A) ! ACheck: u i0 = ( _ ! a) : Partial  A.9Agda Btransp : "{!} (A : (i : I) ! Set (! i)) ( : I) (a0 : A i0) ! A i1Check: If , then A i = A i0 : Set (! i) must hold for all i : I.9Agda prim^glue : " {! !'} {A : Set !} { : I} ! {T : Partial  (Set !')} ! {e : PartialP  ( o ! T o "C A)} ! (t : PartialP  T) ! (a : A) ! primGlue A T eCheck  " a = e 1=1 (t 1=1) or actually the equivalent: +( _ ! a) = ( o -> e o (t o)) : PartialP  A9Agda prim^glueU : " {!} { : I} ! {T : I ! Partial  (Set !)} ! {A : Set ! [  ! T i0 ]} ! (t : PartialP  (T i1)) ! (a : outS A) ! hcomp T (outS A)Check - " a = transp ( i -> T 1=1 (~ i)) i0 (t 1=1)) or actually the equivalent: G( _ ! a) = (o -> transp ( i -> T o (~ i)) i0 (t o)) : PartialP  (T i0)#ZAgda)Eagerly insert trailing hidden arguments?AgdaRange of application.AgdaArguments to check.Agda%Telescope to check arguments against.Agda8Checked arguments and remaining telescope if successful.9Agda#Have we already checked the target?Agda!Insert trailing hidden arguments?AgdaRange of the function.Agda Arguments.AgdaType of the function.AgdaType of the application.9Agda7The whole expression which constitutes the application.AgdaEThe origin of the projection involved in this projection application.Agda,The projection name (potentially ambiguous).Agda The arguments to the projection.Agda(The expected type of the expression (if 7> , infer it).Agda9The type-checked expression and its type (if successful).#W#X#Y#Z#[#[#Z#Y#X#WNone"#$,14568=>?@ACEPSX\_`!#TAgda@Check an application of a section (top-level function, includes %).#UAgda Type check a single declaration.#VAgda&Type check a sequence of declarations.4AgdaCached checkDecl4AgdaICheck if there is a inferred eta record type in the mutual block. If yes, repeat the record pattern translation for all function definitions in the block. This is necessary since the original record pattern translation will have skipped record patterns of the new record types (as eta was off for them). See issue  2308 (and 2197).4AgdaNRun a reflected TCM computatation expected to define a given list of names.4AgdaInstantiate all metas in X associated to  ]_. Makes sense after freezing metas. Some checks, like free variable analysis, are not in  , so they will be more precise (see issue 1099) after meta instantiation. Precondition: name has been added to signature already.4AgdaHighlight a declaration. Called after checking a mutual block (to ensure we have the right definitions for all names). For modules inside mutual blocks we haven't highlighted their contents, but for modules not in a mutual block we have. Hence the flag.4Agda Termination check a declaration.4Agda+Check a set of mutual names for positivity.4AgdaCheck that all coinductive records are actually recursive. (Otherwise, one can implement invalid recursion schemes just like for the old coinduction.)4Agda7Check a set of mutual names for constructor-headedness.4Agda4Check 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.4Agda>Freeze metas created by given computation if in abstract mode.4AgdaType check an axiom.4AgdaData and record type signatures need to remember the generalized parameters for when checking the corresponding definition, so for these we pass in the parameter telescope separately.4Agda,Type check a primitive function declaration.4AgdaCheck a pragma.4Agda=Type check a bunch of mutual inductive recursive definitions.XAll definitions which have so far been assigned to the given mutual block are returned.4AgdaFType check the type signature of an inductive or recursive definition.4AgdaType check a module.4Agda Helper for #T.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.4Agda"Check an application of a section.4AgdarType check an import declaration. Actually doesn't do anything, since all the work is done when scope checking.#TAgdaName m1' of module defined by the module macro.AgdaThe module macro  tel ! m2 args.AgdaImported names and modules4AgdaName of applied module.AgdaThe module parameters.Agda(The arguments this module is applied to.Agda>The remaining module parameters (has free de Bruijn indices!).4AgdaName m1' of module defined by the module macro.AgdaThe module macro  tel ! m2 args.AgdaImported names and modules$#T#U#V444444444444444444444444444444444$4#V#U444444444444444444444444444#T44444xNone"#$,14568=>?@ACEPSX_`!#P#R#U#V4#V#U4#P#R1None"#$,14568=>?@ACEPSX_`!o9AgdaJShows meta information in such a way that it can easily be read by Emacs.4Agda Formats the 1 tag for the Emacs backend. No quotes are added.4AgdaDTurns syntax highlighting information into a list of S-expressions.9Agda@Must contain a mapping for the definition site's module, if any.4Agda:Must contain a mapping for every definition site's module.44442None"#$,14568=>?@ACEPSX\_`" ;4AgdaParses an expression.4AgdaOAfter a give, redo termination etc. checks for function which was complemented.4AgdaTry to fill hole by expression.LReturns the given expression unchanged (for convenient generalization to 4).4Agda!Try to refine hole by expression e.)This amounts to successively try to give e, e ?, e ? ?3, ... Returns the successfully given expression.4Agda9Evaluate the given expression in the current environment 4Agda[Modifier for interactive commands, specifying the amount of normalization in the output.4AgdakModifier for the interactive computation command, specifying the mode of computation and result display.4AgdaYModifier for interactive commands, specifying whether safety checks should be ignored.4AgdaGoals and Warnings4AgdaPrint open metas nicely.4Agda2Collecting the context of the given meta-variable.4AgdagetSolvedInteractionPoints 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.4AgdaLCreate type of application of new helper function that would solve the goal.4AgdaGives a list of names and corresponding types. This list includes not only the local variables in scope, but also the let-bindings.4AgdaReturns 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.4AgdaThe intro tactic.Returns the terms (as strings) that can be used to refine the goal. Uses the coverage checker to find out which constructors are possible.4Agda\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.4Agda Parse a name.5Agda8Check whether an expression is a (qualified) identifier.5Agda3Returns the contents of the given module or record.5Agda4Returns the contents of the given record identifier.5Agda)Returns the contents of the given module.4AgdaSkip safety checks?AgdaHole.AgdaThe expression to give.Agda9If successful, the very expression is returned unchanged.4AgdaSkip safety checks when giving?AgdaHole.Agda'The expression to refine the hole with.Agda"The successfully given expression.4Agda Normalise?5Agda"How should the types be presented?AgdaThe range of the next argument.AgdaThe module name.AgdafModule names, context extension needed to print types, names paired up with corresponding types.5Agda!Amount of normalization in types.Agda%Expression presumably of record type.AgdaPModule names, context extension, names paired up with corresponding types.5Agda!Amount of normalization in types.Agda Module name.AgdaPModule names, context extension, names paired up with corresponding types.-444444444444444444444444444444444444444455555-4444444444444444444444444444444444444444555553None"#$,14568=>?@ACEPSX_`""554None"#$,14568=>?@ACEPSX\_`"1d5AgdaLookup the clause for an interaction point in the signature. Returns the CaseContext, the previous clauses, the clause itself, and a list of the remaining ones.5AgdaSParse variables (visible or hidden), returning their de Bruijn indices. Used in 5.5Agda&Entry point for case splitting tactic.5AgdaGMake the given pattern variables visible by marking their origin as  and pattern origin as } in the 4Z.5Agda2Make clause with no rhs (because of absurd match).5Agda*Make a clause with a question mark as rhs.5AgdaThe function name.Agda-The telescope of the clause we are splitting.Agda,The hole of this function we are working on.AgdaThe range of this hole.Agda9The words the user entered in this hole (variable names).AgdayThe computed de Bruijn indices of the variables to split on, with information about whether each variable is in scope. 5555555555 55555555555None"#$,14568=>?@ACEPSX_`"2.555555 5%5$5#5"5!5&5'5(5)5*5+5-5,5.5/505152535455565758595:5;5<5=5>5?5@5A5B5C5D5E5F5G5H.5*5+5-5,5)5'5(5&5.5/55 5%5$5#5"5!5550515253545556575558595:5;5<5=5>5?5@5A5B5C5D5E5F5G5HNone"#$,14568=>?@ACEPSX_`"4!$RAgdaJAre we loading the interface for the user-loaded file or for an import?$SAgdaFor the main file.+In this case state changes inflicted by 5s are preserved.$TAgdaFor an imported file.+In this case state changes inflicted by 5s are not preserved.$UAgdaJIs the aim to type-check the top-level module, or only to scope-check it?$[AgdapScope checks the given module. A proper version of the module name (with correct definition sites) is returned.5WAgda'Some information about the source code.5YAgda Source code.5ZAgdaSource file type5[AgdaThe parsed module.5\AgdaThe top-level module name.5]Agda Computes a 5W record for the given file.5^Agda"Should state changes inflicted by 5s be preserved?5_Agda0Merge an interface into the current proof state.5cAgdaIf 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 (unless the $R is $R 5U).5dAgdaType 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.If the $U is 5U, then type-checking is not performed, only scope-checking. (This may include type-checking of imported modules.) In this case the generated, partial interface is not stored in the state ( ]n). Note, however, that if the file has already been type-checked, then a complete interface is returned.5eAgdaTries 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 5d instead.5fAgdaSee 5e.5gAgdaA more precise variant of 5e[. If warnings are encountered then they are returned instead of being turned into errors.5hAgdaCheck if the options used for checking an imported module are compatible with the current options. Raises Non-fatal errors if not.5iAgdaxCheck whether interface file exists and is in cache in the correct version (as testified by the interface file hash).5jAgda6Try to get the interface from interface file or cache.5kAgda7Run the type checker on a file and create an interface.Mostly, this function calls 5s. But if it is not the main module we check, we do it in a fresh state, suitably initialize, in order to forget some state changes after successful type checking.5lAgdaFormats and outputs the Checking, Finished and "Loading " messages.5mAgdaDPrint the highlighting information contained in the given interface.5nAgda.Read interface file corresponding to a module.5pAgda-Writes the given interface to the given file..The written interface is decoded and returned.5sAgdaTries 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.5wAgda8Collect all warnings that have accumulated in the state.5xAgdaExpert version of 5w; if isMain is a $R:, the warnings definitely include also unsolved warnings.5{AgdaReconstruct the  + (not serialized) from the  , (serialized).5|AgdafBuilds an interface for the current module, which should already have been successfully type checked.5}AgdajReturns (iSourceHash, iFullHash) We do not need to check that the file exist because we only accept  InterfaceFile as an input and not arbitrary  AbsolutePath!5AgdauTrue if the first file is newer than the second file. If a file doesn't exist it is considered to be infinitely old. 5`AgdaImported user warningsAgda.Name of imported definitions which are partial5dAgdaThe path to the file.Agda7Should the file be type-checked, or only scope-checked?Agda"Information about the source code.5fAgda+Optional information about the source code.5gAgda+Optional information about the source code.5iAgdaModule name of file we process.AgdaFile we process.5jAgdaModule name of file we process.AgdaFile we process.Agda+Optional information about the source code.AgdaBool' is: do we have to merge the interface?5kAgdaModule name of file we process.AgdaFile we process.Agda+Optional information about the source code.AgdaBool' is: do we have to merge the interface?5lAgdaThe prefix, like Checking, Finished, Loading .AgdaThe module name.AgdaOptionally: the file name.5mAgdaThe corresponding file.5sAgdaThe file to type check.AgdaThe expected module name.Agda$Are we dealing with the main module?Agda+Optional information about the source code.5|Agda Source code.AgdaAgda file? Literate Agda file?Agda4 for the current module.AgdaOptions set in OPTIONS pragmas.6$R$T$S$U5V5U$V$W$Y$X$Z$[5W5X5\5[5Z5Y5]5^5_5`5a5b5c5d5e5f5g5h5i5j5k5l5m5n5o5p5q5r5s5t5u5v5w5x5y5z5{5|5}5~5565W5X5\5[5Z5Y5]$U5V5U$R$T$S5^5_5`$[$W$Y$X$V5a5b5c5d5e5f5g5h5i5j5k5l5m5n5o5p5q5r5s5t5u5v5w5x$Z5y5z5{5|5}5~556None"#$,14568=>?@ACEPSX_`"*5AgdaThe interaction loop.5AgdaSet _ to  optInputFile.5Agda>The logo that prints when Agda is started in interactive mode.5AgdaThe help message5555555555555555555555555555555555555555555555555555557None"#$,14568=>?@ACEPSX_`"05Agda6Result type: Progress & potential Message for the user:The of the Auto tactic can be one of the following three: Solutions [(ii,s)] A list of solutions s for interaction ids ii. In particular,  Solutions [] means Agsy found no solution. FunClauses cs0 A list of clauses for the interaction id ii? in which Auto was invoked with case-splitting turned on. Refinement s+ A refinement for the interaction id ii in which Auto was invoked.5Agda#Entry point for Auto tactic (Agsy).If the  autoMessage part of the result is set to Just msg, the message msg2 produced by Agsy should be displayed to the user.9Agda[Names for the equality reasoning combinators Empty if any of these names is not defined.9AgdaTemplates for error messages 555555555 5555555558None"#$,14568=>?@ACEPSX_`"5Agda$Sets up the compilation environment.5AgdaConjunctive semigroup (5 is absorbing).5555555555555555555555555555559None"#$,14568=>?@ACEPSX_`" 5Agda Classify FOREIGN Haskell code.5Agda3A pragma that must appear before the module header.5Agda@An import statement. Must appear right after the module header.5Agda1The rest. To appear after the import statements.5Agda GHC backend translation pragmas.5Agda'@COMPILE GHC X = data D (c | ... | c )5Agda COMPILE GHC x as f5AgdaGet content of  FOREIGN GHC pragmas, sorted by 52: file header pragmas, import statements, rest.5Agda Classify a  FOREIGN GHC declaration.5AgdaIClassify a Haskell pragma into whether it is a file header pragma or not.5AgdaPartition a list by 5 attribute.5555555555555555555555555555555555555555:None"#$,14568=>?@ACEPSX_`"C5Agda0Name for definition stripped of unused arguments6 Agda:Can the character be used in a Haskell module name part (conidJ)? This function is more restrictive than what the Haskell report allows.25555555555555555555555555555555555555556666666666 6 25555555555555555555555555555555555555556666666666 6 ;None"#$,14568=>?@ACEPSX_`"6 AgdayHaskell module names have to satisfy the Haskell (including the hierarchical module namespace extension) lexical syntax: 4modid -> [modid.] large {small | large | digit | ' }6 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 5.3Precondition: The input must not start or end with ., and no two .s may be adjacent.6 6 <None"#$,14568=>?@ACEPSX_`"6 6 66666 6 6666=None"#$,14568=>?@ACEPSX_`"6(Agda7Check for "main" function, but only in the main module.6)Agda7Check that the main function has type IO a, for some a.6+Agda,Haskell modules to be imported for BUILT-INs6-Agda)Definition bodies for primitive functions6(Agda"Are we looking at the main module?Agda The module.AgdaDid we find a "main" function? 6'6(6)6*6+6,6-6.6/60 6'6(6)6*6+6,6-6.6/60>None"#$,14568=>?@ACEPSX_`"6162636461626364_None"#$&',-14568=>?@ACEHPSUVX_`",Agda%Look for a backend of the given name.-AgdaHAsk the active backend whether a type may be erased. See issue #3732.6<Agda0Optional version information to be printed with  --version.6=AgdaDefault options6>Agda_Backend-specific command-line flags. Should at minimum contain a flag to enable the backend.6?Agda%Unless the backend has been enabled, runAgda- will fall back to vanilla Agda behaviour.6@AgdaDCalled after type checking completes, but before compilation starts.6AAgda3Called after module compilation has completed. The IsMain argument is NotMain if the  --no-main flag is present.6BAgdaBCalled before compilation of each module. Gets the path to the .agdai_ file to allow up-to-date checking of previously written compilation results. Should return Skip m# if compilation is not required.6CAgda<Called after all definitions of a module have been compiled.6DAgdaCompile a single definition.6EAgdaTrue if the backend works if --only-scope-checking is used.6FAgdazThe treeless compiler may ask the Backend if elements of the given type maybe possibly erased. The answer should be 7QS if the compilation of the type is used by a third party, e.g. in a FFI binding.6HAgda Call the 9 function of the given backend.9AgdaPBackends that are not included in the state, but still available to the user.6IAgda*Get the currently active backend (if any).hijklmnopqrstuvwxyz{|}~      RQST             [\ktr]^_`abcdefghijlmnopqsuvwxyz{|}~     VUWXYZ !: !"#$%&'()*+,-./0123456789;<=>?@ABCDE N O P Q R S T U V W X Y Z [ \ ] ^ ` _ a b c f d e g h i j k l m n o p q r s t u v w x y z { | } ~  123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~+6G,- !?@ABCDEFGHIJKLMNOPQRST[\]^_`abcdefghijklmnopqrstuvwxyz{|}~     FGHIJKLMNOPQRSTUVWXYZ      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPUVWXYdZ[\]^_`abcefghijklmnopqrstuvwxyz{|}~                         ! " # $ % & ' ( ) * + , - . / 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 T S Q R 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!{!|!}!~!!!!!!!!!!!!!!!!!!!!!!!!!!!#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({(|(}(~((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((()[)\)])^)_)`)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){)|)})~))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))*****4555666867696:6=6;6<6>6?6@6A6B6C6D6E6F6H6I6J6K,+6G696:6=6;6<6>6?6@6A6B6C6D6E6F6668675554hijklmnopqrstuvwxyz{|}~      RQST             [\ktr]^_`abcdefghijlmnopqsuvwxyz{|}~     VUWXYZ !: !"#$%&'()*+,-./0123456789;<=>?@ABCDE !?@ABCDEFGHIJKLMNOPQRST[\]^_`abcdefghijklmnopqrstuvwxyz{|}~     FGHIJKLMNOPQRSTUVWXYZ      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPUVWXYdZ[\]^_`abcefghijklmnopqrstuvwxyz{|}~                         ! " # $ % & ' ( ) * + , - . / 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 T S Q R 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!{!|!}!~!!!!!!!!!!!!!!!!!!!!!!!!!!!#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({(|(}(~((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((()[)\)])^)_)`)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){)|)})~))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))*****-6K6J6H,6I?None"#$%,14568=>?@ACEPSX_`#Uq/9Agda%The number of the current code block.9AgdaThe current column number.9AgdaQAll alignment columns found on the current line (so far), in reverse order.9AgdajAll alignment columns found in previous lines (in any code block), with larger columns coming first.9Agda(The next indentation column identifier.9Agda5Indentation columns that have actually been used.9Agda!Count extended grapheme clusters?9Agda"Alignment and indentation columns.9AgdaThe column's code block.9AgdaThe column number.9AgdaThe column kind. 7> for alignment columns and 7= i for indentation columns, where i$ is the column's unique identifier.9Agda+Unique identifiers for indentation columns.9Agda Column kinds.9AgdanUsed only for indentation (the placement of the first token on a line, relative to tokens on previous lines).9Agda,Used both for indentation and for alignment.9Agda Output items.9AgdaA piece of text.9AgdaA column. If it turns out to be an indentation column that is not used to indent or align something, then no column will be generated, only whitespace (9).9AgdaThe 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.9Agda+Says what debug information should printed.9AgdaRun function for the LaTeX monad.9AgdaGives the size of the string. If cluster counting is enabled, then the number of extended grapheme clusters is computed (the root locale is used), and otherwise the number of code points.9Agda-Does the string consist solely of whitespace?9Agda6Is the character a whitespace character distinct from '\n'?9AgdaOReplaces all forms of whitespace, except for new-line characters, with spaces.9AgdaIf the 9g consists of spaces, the internal column counter is advanced by the length of the token. Otherwise, 9 is a no-op.9AgdaMerges 9 into 9 , resets 9 and 99Agda=Registers a column of the given kind. The column is returned.9AgdaERegisters the given column as used (if it is an indentation column).9Agda0Alignment column zero in the current code block.:Agda-Registers column zero as an alignment column.:AgdaFChanges to the state that are performed at the start of a code block.:AgdaDChanges to the state that are performed at the end of a code block.9AgdaVA command that is used when two tokens are put next to each other in the same column.:AgdaThe column's name.QIndentation columns have unique names, distinct from all alignment column names.:Agda#Opens a column with the given name.:AgdaOpens the given column.:AgdaDOpens a special column that is only used at the beginning of lines.:AgdaiOpens the given column, and inserts an indentation instruction with the given argument at the end of it.:Agda,Deals with markup, which is output verbatim.: Agda2Deals with literate text, which is output verbatim: AgdaZDeals with code blocks. Every token, except spaces, is pretty printed as a LaTeX command.: AgdaEscapes special characters.: AgdaEvery element in the list should consist of either one or more newline characters, or one or more space characters. Two adjacent list elements must not contain the same character.rIf the final element of the list consists of spaces, then these spaces are assumed to not be trailing whitespace.: AgdaSplit multi-lines string literals into multiple string literals Isolating leading spaces for the alignment machinery to work properly6LAgda/Generates a LaTeX file for the given interface.The underlying source file is assumed to match the interface, but this is not checked. TODO: Fix this problem, perhaps by storing the source code in the interface.:Agda&Transforms the source code into LaTeX.:Agda!Count extended grapheme clusters?:Agda!Indentation instruction argument.:Agda!Count extended grapheme clusters?:Agda!Count extended grapheme clusters?6L6L@None"#$,14568=>?@ACEPSX_`# 6YAgda Restore both   and %J.6ZAgdaRestore  , do not touch %J.6[AgdaBuild an opposite action to : for state monads.6]Agda Opposite of : for %H1. Use only if main errors are already catched.6^Agda?Lift a TCM action transformer to a CommandM action transformer.6_AgdaDitto, but restore state.6`Agda1Put a response by the callback function given by  _.6aAgda A Lens for %L.6bAgda A Lens for %O.6fAgda*Do setup and error handling for a command.6hAgdaRun an %) value, catch the exceptions, emit output!If an error happens the state of %Hp does not change, but stPersistent may change (which contains successfully loaded interfaces for example).6iAgdalIf the next command from the command queue is anything but an actual command, then the command is returned.If the command is an %f command, then the following happens: The given computation is applied to the command and executed. If an abort command is encountered (and acted upon), then the computation is interrupted, the persistent state and all options are restored, and some commands are sent to the frontend. If the computation was not interrupted, then its result is returned.6jAgdafCreates a command queue, and forks a thread that writes commands to the queue. The queue is returned.6kAgdaTCan the command run even if the relevant file has not been loaded into the state?6lAgdaShould j& be issued after the command has run?6mAgdaInterpret an interaction6nAgdamSolved goals already instantiated internally The second argument potentially limits it to one specific goal.6oAgda"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 5d.6pAgdaSet _ to %M , if any.6qAgda)A "give"-like action (give, refine, etc).*give_gen force 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 iiW by the newly created interaction points in the state if safety checks pass (unless force is applied).6sAgda/Sorts interaction points based on their ranges.6tAgdaJDisplays the current goal, the given document, and the current context.Should not modify the state.6uAgdaKShows all the top-level names in the given module, along with their types.6vAgda^Shows all the top-level names in scope which mention all the given identifiers in their type.6wAgda"Explain why something is in scope.6xAgdaASets the command line options and updates the status information.6yAgda!Computes some status information.Does not change the state.6zAgda'Displays or updates status information.Does not change the state.6{Agda display_info does what  display_info' FalseA does, but additionally displays some status information (see 6y and 6z).6|AgdaParses and scope checks an expression (using the "inside scope" as the scope), performs the given command with the expression as input, and returns the result and the time it takes.6~AgdaLTell to highlight the code using the given highlighting info (unless it is Nothing).6Agda@Tells the Emacs mode to go to the first error position (if any).6[AgdarunAgdaliftAgda(reverse lift in double negative position6\AgdarunAgdaliftAgda(reverse lift in double negative position6jAgdaReturns the next command.6oAgdaAllow unsolved meta-variables?Agda.Full type-checking, or only scope-checking?6qAgda Should safety checks be skipped?6|AgdaThe command to perform.AgdaThe expression to parse.,6T6V6U6W6X6Y6Z6[6\6]6^6_6`6a6b6c6d6e6f6g6h6i6j6k6l6m6n6o6p6q6r6s6t6u6v6w6x6y6z6{6|6}6~6,6T6V6U6W6X6Y6Z6[6\6]6^6_6`6a6b6c6d6e6f6g6h6i6j6k6l6m6n6o6p6q6r6s6t6u6v6w6x6y6z6{6|6}6~6ANone"#$,14568=>?@ACEPSX_`#o6Agda6@ is a fake ghci interpreter for both the Emacs the JSON frontend66BNone"#$,14568=>?@ACEPSX_`# 6Agda6P is a fake ghci interpreter for the Emacs frontend and for interaction tests.6c reads the Emacs frontend commands from stdin, interprets them and print the result into stdout.:AgdaFConvert Response to an elisp value for the interactive emacs frontend.:AgdaFormat responses of DisplayInfo:Agda Adds a "last" tag to a response.:Agda;Show an iteraction point identifier as an elisp expression.:AgdakGiven strings of goals, warnings and errors, return a pair of the body and the title for the info buffer6AgdaSerializing Info_Error:Agda5Pretty-prints the context of the given meta-variable.6Agda,Pretty-prints the type of the meta-variable.:Agda&Prefix prettified CPUTime with "Time:":AgdaContext of this meta-variable.Agda$Print the elements in reverse order?446666644666CNone"#$,14568=>?@ACEPSX_`#6Agda6 is a interpreter like 6#, but outputs JSON-encoded strings.6( reads Haskell values (that starts from IOTCMT ...) from stdin, interprets them, and outputs JSON-encoded strings. into stdout.:AgdaCConvert Response to an JSON value for interactive editor frontends.66DNone"#$,14568=>?@ACEPSX_`#7 :AgdaPosition, Contents, Infomation:AgdadGenerates 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.6Agda!The name of the default CSS file.:Agda6The directive inserted before the rendered code blocks:Agda#Determine how to highlight the file:Agda&Determine the generated file extension6Agda-Prepare information for HTML page generation.The page generator receives the output directory as well as the module's top level module name, its source code, and its highlighting information.: Agda;Converts module names to the corresponding HTML file names.6AgdaAGenerates a highlighted, hyperlinked version of the given module.:!AgdaAttach multiple Attributes6Agda+Constructs the web page, including headers.6Agda'Constructs token stream ready to print.6Agda(Constructs the HTML displaying the code.:AgdaOutput directoryAgdaSource file typeAgdaReturn value of :Agda*Output file extension (return value of :)AgdaHighlighting information6AgdaPage generator.6AgdaPage renderer.AgdaOutput file extension.Agda&Directory in which to create files.AgdaModule to be highlighted.6AgdaURL to the CSS file.AgdaWhether to reserve literateAgdaModule to be highlighted.6AgdaThe contents of the module.AgdaHighlighting information.6Agda+Whether to generate non-code contents as-isAgdaSource file type66666666666666'None"#$,14568=>?@ACEPSX_`#ͤ 6Agda9Environment for naming of local variables. Invariant: reverse ccCxt ++ ccNameSupply6AgdaSupply of fresh names6AgdaNames currently in scope6Agda0This environment is no longer used for anything.6Agda"We do not erase types that have a 5E pragma. This is to ensure a stable interface to third-party code.6Agda.Initial environment for expression generation.6Agda%Term variables are de Bruijn indices.6Agda'Introduce n variables into the context.6AgdaNExtract Agda term to Haskell expression. Erased arguments are extracted as (). Types are extracted as ().6AgdaPTranslate a non-application, non-coercion, non-constructor, non-definition term.6Agda"Are we looking at the main module?Agda Path to the .agdai file.Agda2Could we confirm the existence of a main function?6Agda"Are we looking at the main module?AgdaCompiled module content.Agda2Could we confirm the existence of a main function?6Agda%Is the type inductive or coinductive?93666666666666666666666666666666666666666666666666666666669666666666666666666666666666666666636666666666666666666666ENone"#$,14568=>?@ACEPSX_`#6Agda3Ensure that there is at most one pragma for a name.7Agda*Primitives implemented in the JS Agda RTS.,66666666666666666666666666667777777777 7 7 7 7 77,66666666666666666666666666667777777777 7 7 7 7 77`None"#$,14568=>?@ACEPSX_`#I7AgdaThe main function7AgdaJRun Agda with parsed command line options and with a custom HTML generator7AgdaPrint usage information.7AgdaPrint version information.7AgdaWhat to do for bad options.7Agda6Run a TCM action in IO; catch and pretty print errors.7AgdaMain7Agda8Backends only for printing usage and version informationAgdaHTML generating actionAgdaBackend interactionAgda program nameAgdaparsed command line options .7777777777 .7777777777:"yz{yz|y}~yzyyyyyyyyyyyyyyyyzyzyzyzyz          !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~     Jd H      !"#$%&'()*++,,-./0123M4556789:;<=>?@ABBCDEFGHIIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnoopqrstuvwxy z { | } ~  !!!!!!!!!!!!!!!!!!!!!!!!!!!!"###############################################################################################################################$$$$ $ $$$ $ $ $$$$%%%%%%%%%%%%%%% %!%"%#%$%%&&&'&(&)&*&+&,&,&-&.&/&0&1&2&3&4'5'5'6'7'8'9':';'<'='>'?'@'A(B(C(D(E(F(G(H(I(J(K(K(L(M(N(O(P(Q(Q(R(S(T(U(V((W(X(Y(Z([(\(](^(_(`(a(b(c)d)d)e)f)g)h*i*j+k+l+m+n+o+p+q+r+s+Z+t+u+v+w+x+y+z,{,{,|,},~,,,,,,,,,,,,,,,,,,,,,,,,-------------------------------------------------------------------------------------------------------........../// / 0 0 0 0 0000001111S111111111111 1!1"1#1$1%1&1'1(1)1*1+,-.,-Y,-/,-0,-1,-2,-3,-425262N2O2P2Q2l2n2o2p2q2s2Z2t2u2v2x2728292:2;2<2=22>2?3@3@3A3B3B3C3D3E3F3G3H3I3J3K3L3M3N3O3P3Q3R3S3T3U3V3W3X3Y3Z3[3\3]3^3_3`3a3b3c3d3e3f3g3h3i3j3k3l3m4n4o4p4q4r5s5t5u5v5w5x5y5z5{5|5}5~555566666666666777777777777778D8899999999999999999F:::::::::::::::::::::::::::::;;;;;;;;;;;;;;<<<<<<======================== = = = = ===================== =!="=#=$=%=&='=(=)=*=+=,=-=.=/=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=[=\=]=^=_=`abcdefghijkl>m>n>o>&>p>q>r>s>t>u>v>w?x?y?z?{?|?}?~?|????????????@@@@@@@@@@@@@@@@@@@@@@@@@                    AAAAAAmAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBCCCCCCCCCCCCCCC D D D+DGD D DDDDDDDDEEEEE !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJrKFLFMFNFOFPFGFQFQFRFSFTFUFVFUFWFXFYFZF[F\F]F^F_F`FaFbFcFdFeFfFgFhFiGjGkGlGmGnGoGpGqGqGrGsGtGrGuGvGwGvGxGyGzG{G|G}G~GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGHHHHHHH H H H H HHHHHHHHHHHHHHHHHHH H!H"H#H$H%H&H'H(H)H*H+H,H-H.H/H0H1I2I3I4I5I6I7I8I8I9I:I;I<I=I>I?I@IAIBICIDIEIFIGIHIHIIIJIKILIMINIOIPIQIRISITIUIVIWIXIYIZI[I\I]I^I_I`IaIbIcIdIdIeIfIgIhIhIiIjIkIlImInIoIpIqIrIsItItIuIvIwIxIyIzI{I|I}I}I~I~IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I !I "I #I $I %I &I 'I (I )I *I +I ,I -I .I /I 0I 1I 2I 3I 4I 5I 6I 7I 8I 9I :I ;I <I =I >I ?I @I AI BI CI DI EI FI GI HI II JI KI LI MI NI OI PI QI RI SI TI UI VI WI XI YI ZI [I \I ]I ^I _I `I aI bI cI dI eI fI gI hI iI jI kI lI mI nI oI pI qI rI sI tI uI vI wI xI yI zI {I |I }I ~I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I !I "I #I $I %I &I 'I (I )I *I +I ,I -I .I /I 0I 1I 2I 3I 4I 5I 6I 7I 8I 9I :I ;I <I =I >I ?I @I AI BI CI DI EI FI GI HI II JI KI LI MI NI OI PI QI RI SI TI UI VI WI XI YI ZI [I \I ]I ^I _I `I aI bI cI dI eI fI gI hI iI jI kI lI mI nI oI pI qI rI sI tI uI vI wI xI yI zI {I |I }I ~I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I !I "I #I $I %I &I 'I (I )I *I +I ,I -I .I /I 0I 1I 2I 3I 4I 5I 6I 7I 8I 9I :I ;I <I =I >I ?I @I AI BI CI DI EI FI GI HI II JI KI LI MI NI OI PI QI RI SI TI UI VI WI XI YI ZI [I \I ]I ^I _I `I aI bI cI dI eI fI gI hI iI jI kI lI mI nI oJ pJ qJ rJ rJ sJ tJ uJ vJ wJ xJ yJ zJ {J |J }J ~J J J J J J J J J J KK K K K K K K K KKKKKKKK K K K L L L L L L L L L L L L L L L L L LdLLdL L L LLL L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L LPL L L L L L L L L L L L L L L L L L L L L L L L L L L LQL MM M M M M M M M M M M M M M M M M N N N N NININ N N N N N N N N N N N N N N N N N NHN N N NN N N NN N NN N !N "N #N $N %N &N 'N (N )N *N +N ,N -N .N /N 0N 1N 2N 3N 4N 5OO 6O 7O 8OO 9O :O ;O <OO =O >O ?O @O AOO BO CP DP EPFPP FP GP HP IP JP KP P LP MP NP OP PP QP RP SP TP UQNQ VQ WQ XQ YQ ZQ [Q \Q ]Q ^Q _Q `Q aQ bQ cQ dQ eQ eQ fQ gQ gQ hQ iQ jQ kQ lQ mQ nQ oQ pQ qQ rQ sQ tQ uQ vQ vQ wQ xQ yQ zQ {Q |Q }Q ~Q Q QQ Q Q Q Q Q Q Q Q Q Q Q$Q Q QQ QQ Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q RR R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R !R "R #R $R %R &R 'R (R )R *R +R ,R -R .R /R 0R 1R 2R 3R 4R 5R 6R 7R 8R 9S :S ;S <S =S >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 aS bS cS dS eT fT gT hT iT jT kT lT mT nT oT pT qT rT sT tT uT vT wT xT yT zT zT {T |T }T ~T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T U U UrUrU U UU U UU U U U U U U U U U V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V VV V V V VV V V V V V V V V V V V V V V V V V V V V V V V V V V VVVV V V VWWWWWWWWWW W W W W W WdWdWWWWW WWWWWWWWWWWWWWWWW W!W"W#W$W%W W&W'W W(W W)W*W+W,W-W W W.W/W0W W W W W W W W1W2W W W3W WPW4W5W6W7W8W9W:W W;W W W W W W W<W=W W>W WQW?W@WAWBWCWDWEWFWGW WNWOWHW WIWJWKWLWMWNWOWPXQXQXRXSXTXUXVXVXWXXXYXZX[X\X]X^X_X`XaXbXcXdXeXfXgXhXiXjXkXlXmXnXoXpXqXrXsXtXuXvXwXxXyXzY{Y|Y}Y~YYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYZZZZZZZZZZZZZZZZZMZZZ[p[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[ [ [ [ [ [[[[[[[[[[[[[[[[[[[ [!["[#[$[%[&['[([)[*[+[,[-[.[/[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^{^|^}^~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^___`aaaaaaaaaabbbbbbbbbbbbbbbbbbb bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbcdddddddddddd d d d d ddddddddddddddddddddddd dd!d"d#d$d%d&d'd(d)d*d+d,d-d.d/d0d1d2d3d4d5d6d7d8d9d:d;d<d=d>d?d@dAdBdCdDdEdFdGdHdIdJdKdLdMdNdOdPdQdRdSdTdUdVdWdXdYdZd[d\d]d^d_d`dadbdcdddedfdgdhdidjdkdldmdndodpdqdreseteuevewexeyeze{e|e}e~eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeefffffffIffffffffffffffffffffffffffff<ffffffVffffdffofffnffff fffffIfffffffffffUfNfXfZfffffffffffffffffffffffffffffff_f_fffffffffffffffffffffff f f f f fffffffffffffffffff f!fff"ff#ff$f%f&f'f f(f)f*f f ff+f,f-f.ff/f0f1f2f3f4f5f6f7f8f9f:f;f<f=f>f?f@fAfAfBfCfDfEfFfEfGfHf$fIfJfKfLfMfNfOfPfQfRfSfTfUfVfWfXfYfZf[f\f]f^f_f`fafbfcfdfefffgfhfifjfkflfmfnfofpfqfrfsftfufvfwfxfyfzf{f|f}f~ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffgggggggggggggggggggggggggggggggggggggggggggg g g g g ggggggggggggggggggg g!g"g#g Rg$g%g&g'g(g)g*g+g,g-g.g/g0g1g2g3g4g5g6g7g8g9g:g;g<h=h=h>h?h@hAhBhChDhEhFhGhGhHhIhJhKhLhMhNhOhPhQhRhShThUhVhWhXhYhZh[h\h]h^h_h`hahbiZiQicidiieifigihiiijikiliminioiipiqirisitiiuivi iwixiyizi{i|i}i~i<iiiiiiiiiiiiiiiiijjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkllllllllllllllllllllllllllllllllmmmmmmmmmm mm m m m mmmmnnnnnnnnnnnnnnnn n!n"n#n$n%n&n'n(n)n*n+n,n-o.o.o/o0o1o1o2o3o3o4o5o5o6o7o8o9o:o:o;o<o=o>o?o@ooAoBoCoDoEoFoGoHoIoJoKoLoMoNooOo o ooPoIo oodoQooRo xo_oHoSooToooUo woVooWoXoYoZo[o\o]o^o_o`oaobocodoeofogohoiojokolomonooopoqorosotouovowoxoyozo{o|o}o~opppppppppppppppppppppqqqqqqqqqqqqqqqqqqqqqqq  <        crrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr r r r r r rrrrrrrrrrrrrrrrrrr r!r"r#r$r%r&r'r(r)r*r+r,r-r.r/r0r1r2r3r4r5r6r7r8r9r:r;r<r=r>r?r@rArBrCrDrErFrGrHrIrJrKrLrMrNrOrPrQrRrSrTrUrVrWrXrYrZr[r\r]r^r_r`rarbrcrdrerfrgrhrirjrkrlrmrnrorprqrrrsrtrurvrwrxryrzr{r|r}r~rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrsssttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttt t t t t ttttttttttttttttttt t!t"t#t$t%t&t't(t)t*t+t,t-t.t/t0t1uu2uu3u3uu4u5u5u6u7u8u8u9u:u;uu<u=u>u?u@uAuBuCuuDuEuuFuGuHuIuJuKuLuMuNuOuPuQuRuSuTuUuVuWuXuYuZv[v\v]v^v_v`vavbvcvdvevfvgvhvivjvkvlvmvnvovpvqvrvsvtvuvvvwvxvywzwzw{w|w|w}w~wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwxxxxx xxxxxxxxxxxxxxxxxxyyyyzzzzzzzzzzzzzzzzzzzz{{{{{{{{{{{{{{{||}}}}}}}}}}}}}}}}}}}~~~}}~ ~       !"#$%&'()*+,-./0123456789:;<=>?@ABC hDEFFGHIJKLMMNOPQRSTUVWXYZ[\]^_``abc  defghijklmnopqrsptuvwxyyz{|}~r $$         r;       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~{      !"#$%&'()*+,-./0123456789:;<=>?@ABCCD EFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghinj  <klmnopqrstuvw\xyz{|}~  RQS $      _   p"9inPQRSU __       j !!"#$%&'  ( )*+,-./UNZ0 1234556789:;<=>!   "4% () >* 6-.?78:9;@@ABCDONEFGHIJKLMKNOLPQRSTUV|y~WXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{<.|}~:8*0^      W !"#$%&'()*+,-a./01234E56789:;<=>?@ABCDEFGHIJKLMNOPQRS TUPVWXYZ[\]^_`abcde)fghijklmnopqrstuvwxyz{|}~G  9         3, !!"#$Vnp%&'mKL*qr()*+,-./0123456789:;<=>?@ABCDEEFFGHIJJKLMNOPQRSTUVWXYZ[\]^_`aabcdefghijklmnopqrstuvwxyz{|}~MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM M M M M MMMMMMMMMMMMMMMMMMM M!M"M#M$M%M&M'M(M)M*M+M,M-M.M/M0M1M2M3M4M5M6M7M8M9M:M;M<M=M>M?M@MAMBMCMDMEMFMGMHMIMJMKMLMMMNMOMPMQMRMSMTM MUMVMWMXMYMZM[M\M]M^M_M`MaMbMcMdMeMfMgMhMiMjMkMlMmMnMoMpMqMrMsMtMuMvMwMxMyMzM{M|M}M~MMMMMMMMMMMMFMMMMMMMMMMMMMMMMMMMMMMMMM MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM M M M M MMMMMMMMMMMMMMMMMMMMM M!M"M#M$MM%M}M&M'M(M)M*M+M,M-M.M/M0M1M2M3M4M5M6M7M8M9M:M;M<M=M>M?M@MAMBMCMmMDMEMFMGMHMIMJMKMLMMMNMOMPMQMRMRMSMTMUMVMWMXMYMZM[M\M]M^M_M`MaMbMcMdMeMfMgMhMiMjMkMkMlMmMnMoMpMqMqMrMMsMtMuMPM MdM MMvMwMxMyMzM{M|M}M~MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMrMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM0M0MMMMMMMM M M M M M MMMMMMMMMMMMMMMMMMMMMM M!M"M#M M$M%M&MMM'M(M)M*M+M+M,M-M-M.M/M0M1M2M3M4M4M5M6M7MM8M9M:M;M;M<M=M>M?M@MAMBMCMDMEMFMGMHMIMJMJMKMLMMMNMOMPMQMRMSMTMUMVMMWMXMYMZM[M\M]M^M_M`MaMbMcMMdMeMfMgMhMiMjMkMlMmMnMoMpMqMrMsMtMuMvMwM MxMyMzMzM{M|M}M~MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM9MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM MMMMMMMMMMMMM M M M M MMMMMMMMMMMMMMMMMMM M!M"M#M$M%M&M'M(M)M*M+M,M-M.M/M0M1M2M3M4M5M6M7M8M9M:M;M<M=M>M?M@MAMBMCMDMEMFMGMHMIMJMKMLMMMNMOMPMQMRMSMTMUMVMWMXMYMZM[M\M]M^M_M`MaMbMcMdMeMfMgMhMiMjMkMlMmMnMoMpMqMrMsMtMuMvMwMMxMyMzM{M|M}M~MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM M MM M M M M M M M M M M M M5M M M M M M M M M M M M M M M M M M M M !M "M #M $M %M &M 'M (M )M *M +M ,M -M .M /M 0M 1M 2M 3M 4M 5M 6M 7M 8MM 9M :M ;M <M =M >M ?M @M AM BM CM DM EM FM GM HM IM JM KM LM MM NM OM PM QM RM SM TM UM VM WM XM YM ZM [M \M ]M ^M _M `M aM bM cM dM eM fM gM hM iM jM kM lM mM nM oM pM qM rM sM tM uM vM wM xM yM zM {M |M }M ~M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M M]M M M M M M M M M M M M M M M M M M M M M M M M M M!M!M!M!M!M!M!M!M!M! M! M! M! M! M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!M!MM!M! M!!M!"M!#M!$M!%M!&M!'M!(M!)M!*M!+M!,M!-M!.M!/M!0M!1M!2M!3M!4M!5M!6M!7M!8M!9M!:M!;M!<M%M!=M!>M!?M!@M!AM!BM!CM!DM!EM!FM!GM!HM!IM!JM!KM!LM!M!N!O!P!Q!R!S!T!U!VEI!W!W!X!Y!Z![!\!]!^!_!`!a!a!b!b!c!d!e!f!g!h!i!j!k!l!m!n!o!p!q!r!s!t!u!v!w!w!x!y !z!{!|!}!~!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"""""""""" " " " " """"""""""""""""""" "!"""#"$"%"&"'"(")"*"+",","-"."/"0"1"2"3"4"5"6"7"8"9":";"<"=">"?"@g"A"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#g#h#i#j#k#j#l#m#n#n#o#p#q#r#s#t#u#v#w#x#y#z#{#|#}#~##########################p#p#p#pp#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#pPp#p#p###########################################################$$$$$$$MP$$$ $ $ $ $ $$$$$$$$$$$$$$$$$$$ $!$"$#$$$%$&$'$($)$*$+$,$-$.$/$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$S$T$U$V$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%3u%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(8(9 (:(:(;(;(<(<(=(>(?H(@(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({(|(}(~((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((&$ ((((((((((+(((((((((((((((((((((((((((((((((((((((((((((((((((((((()))))))))) ) ) ) ) ))))))))))))))))q))) )!)")#)$)%)&)')()))*)+),)-).)/)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+:+;+<+=+>+?v+@+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,{,|,},~,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,2,4,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,---------- - - - - ------------------- -!-"-#-$-%-&-'-(-)-*-+-,---.-/-0-1-2-3-4-5-6-7-8-9-:-;-<-=->-?-@-A-B-C-D-E-F-G-Hw-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-{-|-}-~----------------------- -------------------------------------- ---------------c,+----qr---------------------------------------------------.......... . . . . ..................... .!.".#.$.%.&.'.(.).*.+.,+((.-.../.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 .a .b .c .d .e  b .f .f .g .h .i .j .k .l .m .n .o .p .q .r .s .t .u .v .w .x .y .z .{ .| .} .} .~ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . n . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ............./// / / / / /// / / / / ////////// / / / / / / / (: / /  /! /" /# /$ /% /& /' /' /( /) /* /+ /, /- /. // /0 /1 /2 /3 /4 /5 /6 /7 /8 /9 #i /: /; /< /= /> /? /@ /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/{/|/}/~///////////// /////////////////////// / / / / / / / / ,1 ,1 / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / ////////////////////////////////////// ://///////////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@0A0B0C0D0E0F0G0H0I0J0K0L0M0N0O0P0Q0R0S0T0U0V0W0X0Y0Y0Z0[0\0]0^0_0`0a0b0c0d0e0f0g0h0i0j0k0l0m0n0o0p0q0r0s0t0u0v0w0x0y0z0{0|0}0~000000000000000000000000000000000000+00000000000000000000000000000000000000000000000000000000000000****000000000000000000000000000000001111111111 1 1 1 1 1111111111111 1 1!1!1!1!1"1 #1!#1"1#1$1%1&$1'$1'$1($$1)$1*%1+&1,'1-(1.(1/)10)11*12*13*14r15161718191:1;1<1=1>1?1@1A1B1C+1D+1D+1E+1F+1G+1H+1I+1J+1K+1L+1M+1N+1O+1P+1Q+1R+1S+1T+1U+1V+1W+1X1Y1Z1[1\1]1^1_1`1a1b1c1d1e1f1g1h1i1j1k1l1m1n1o1p1q1r1s1t1u1v1w1x1y1z1{1|1}1~11111111111111,1,1,1,1,1,1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-+-+-1-1-1-U-1-1-1-+-+-1-1-1-+-1-1-1-+-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.11111111111111112222222222 2 /2 /2 /2 /2/222222222222222222 2!2"2#2$2%2&2'2(2)2*2+2,2-2.2/20212223024025262728292:2;2<2=2>2?2@2A2B2C2D2E2F2G2H2I2J2K2L2M2N2O2P2Q2R2S2T2U2V2W2X12Y12Z22[22\22]22^22_22`22a22b22c22d22e22f22g22h22i22j22k22l22m22n22o22p22q22r22s22t22u22v22w22x22y22z22{22|22}22~22222222222222222e22222222222222222222223242424242424242424242525252525I5I52525252525252525525252525252525 525252525252525252525252525252525252525H525252525252525252525252525252222222222222222222222222222222222222222222222222333336#j6363636363 63 6q63 63 63 63636363636363636362[6363636363637373737373 73!73"73#73$83%83%83&83'83(83)83*83+83,83-83.83/8308318U83283383483593693793893993:93;93<93=93>93?93@93A93B93C93D93E93F93G93H93I93J93K93L93M:3N:3O:3P:3Q:3R:3S:3T:3U:3V:3W:3X:3Y:3Z:3[:3\:3]:3^:3_:3`:3a:3b:3c:3d:3e:3f:3g:3h:3i:3j:3k:3l:3m:3n:3o:3p:3q:3r:3s:3t:3u:3v:3w:3x:3y:3z:3{:3|:3}:3~:3;3<3<3<3<3< <3<3< < <9<3< S<<3<3<3<3<3<3<3<3<3<3<3<3<3< N=3=3=3=3=3=3=3=3=3=3>3>3>3>3>3_3_3_ c_3_3_3_3_3_3_3_3_3_3_3_3_3_3__3_3_3_3?3?-?3?3?3??3?3@3@3@3@3@3@3@3@3@3@3@3@3@@3@3@3@3@3@3@3@3@3@3@3@3@3@3@3@3 @3@3@3@3@3@3@e@3@3@3@3@3@3@3@3@3@3A30B3B3B3B3C3C3C3C3C3C3C3C3C3C3C3C3C3C3C3C3C3C3C3C3C3C4C4C4C4C4C4C4C4C4D4 D4 D4 D4 D4 D4D'/'4'4'4'4'4'4'4'4'4'4'4'4'4'4'4'4'4'4'4'4 '4!'4"'4#'4$'4%'4&'4''4('3'4)'4*'4+'4,'4-'4.'4/'40'41'42''43''44'45'46'47'48'49'4:'4;'4<'4='4>'4?'4@E4AE4BE4BE4CE4DE4EE4FE4GE4HE4IE4JE4KE4LE4ME4NE4OE4PE4QE4RE4SE4TE4UE4VE4WE4XE4$E4YE4ZE4[E4\E4]E41E4^E4_E4`E4aE EE44E4<E4>E4?E4;E4b`4c`4d`4e`4f`4g`4h`4i`4j`4k`4l4m4n4o4m4n4p4q y4r4syz4tyIKy4uy4v4w4x4y4z4{4|4}4~y44y44y44y44y44y44y44y44y44y44$4$4$444m4n4yXNyyXQyX1y42y43y44yXYyXPyXOyX.yX0yX/44-4.4yz4y444m4n44m44y44y44:4:4y44m4n4y4:*:4:C:4:4:4:4:4:4:44m44y4v44444444444444@4y4y44m44yz4y444m44y44y44y4y44D4D4y4y4y44m44J4J4J4J4J4J4J44m44V4\4a4a4a4aa4a4a4a4a4a4a4a4a4a4a4a4a4a4a4a4a4a4a4y44yz4b4y44y44y444m44y44yzf4yI4m4m4m4yz4o4yz4444444445445u5u5y45u5u5v5v5v5 v5 yz5 x5 |5 |5|5|5|5|5|5|5|5555y55555555 5!5"5#5$-5%5&5'5(5)5*5+5,5-5.5/505152535455565758595:5;5<5<}5=}5>}5?}5@~5A5B5C5D5E5F5G5HQ5I5J5K5L5M5N5O5P5Q5R5S5T5U5V5W5X5Y5Z5[5\5]5^5_5`5a5b5c5d5e5f5g5h5i5j5k5l5m5n5o5p5qlAl5rl5sl5tl5ul5vl5wl5x5y5z5{5|5}5~55555555555555555$5555555yzH55555555555y5555555554555555555555W5555555${5555555$$555555555555555555555555555555555555555y55555z5555555555555555555506666666 6 6 6  6  6  6 6 6666666666666666666 6!6"6#6$6%6&6'6(6)6*6+6,6-6.+y6/6061*'626364636566zz6768696:6;6<6=6>6?6@6A6B6C6D6E6F6G6H6I6J6K6L6M6N6O16P6Qy6R6S6T6U6V6W6X6Y6Z6[6\6]6^6_6`6a6b6c6d6e6f6g6h6i6j6k6l6m6n1^6o6p6q6r6s*6t6u6v6w6x6y6z6{6|6}6~6666666+|6666666/6666 C66666666*6666666666+6+6+6+6+6+6+6+8+6+6+6+6+6+6+6+6+-L+,+6+6+6+6,6,6,6,6-6-6-6-6-6-6-6-6-1-6-6-6-6-6-6-6-6-6-6-6-6-6-6-6-6-6-6-6-6-6-6-6-6-6-6-1-6-6.6.6.6.6.6.6.6.-K.6.6.6.6.6.6.6.66(040606060604(03060606060606060666666677777677777 7 7 7 7 7167777_7_7?7?7?7?7?7?7?7?7?7?7?7?7?5?7?7 ?7!?4?7"?7#?#8?7$?7%??7&?7'?7(?7)?6?7*?7+?7,?7-?7.?7/?70?71?72?73?74?75?76?77?78?1?79?7:?7;?7<?7=7> y7?7@B7AB7BB7CB7DB7EB7FB7GC7HD7ID7JD7KD7LD7MD7ND7O7P!Agda-2.6.1-Ke6FVv47igUCZO5m5m8wR9Agda.Utils.PrettyAgda.Utils.MonadAgda.Utils.SmallSetAgda.TypeChecking.PrettyAgda.Interaction.OptionsAgda.Interaction.JSONAgda.Utils.EitherAgda.Utils.FunctorAgda.Utils.AssocListAgda.Utils.TupleAgda.Utils.VarSetAgda.Utils.ExceptAgda.Interaction.Options.IORefsAgda.Syntax.BuiltinAgda.Termination.CutOffAgda.Termination.SemiringAgda.Utils.AffineHoleAgda.Utils.ApplicativeAgda.Utils.BiMapAgda.Utils.EnvironmentAgda.Utils.FailAgda.Utils.Function"Agda.TypeChecking.SizedTypes.UtilsAgda.Utils.Haskell.Syntax Agda.Utils.IOAgda.Utils.IO.BinaryAgda.Utils.IO.DirectoryAgda.Utils.IO.UTF8Agda.Utils.IO.TempFileAgda.Utils.IORefAgda.Utils.ImpossibleAgda.Utils.EmptyAgda.Utils.BagAgda.ImpossibleTestAgda.Auto.NarrowingSearchAgda.Utils.IntSet.InfiniteAgda.Utils.LensAgda.Utils.IndexedListAgda.Interaction.Library.BaseAgda.Auto.OptionsAgda.Utils.Lens.ExamplesAgda.Utils.MapAgda.Utils.MaybeAgda.Utils.ListT!Agda.Interaction.Options.WarningsAgda.Interaction.Options.HelpAgda.Utils.MemoAgda.Utils.MonoidAgda.Utils.NullAgda.Utils.Maybe.StrictAgda.Utils.PartialOrdAgda.Utils.POMonoidAgda.Utils.PointerAgda.Utils.SemiRingAgda.Utils.SingletonAgda.Utils.ClusterAgda.Utils.SizeAgda.Utils.Parser.MemoisedCPSAgda.Utils.FileNameAgda.Utils.Hash#Agda.TypeChecking.SizedTypes.SyntaxAgda.Utils.SuffixAgda.Utils.ThreeAgda.Utils.TrieAgda.Utils.ListAgda.Utils.StringAgda.Utils.TimeAgda.Interaction.EmacsCommandAgda.Utils.FloatAgda.Utils.BenchmarkAgda.Syntax.PositionAgda.Utils.PermutationAgda.Syntax.CommonAgda.Syntax.Parser.Literate+Agda.Syntax.Concrete.Operators.Parser.MonadAgda.Syntax.Concrete.NameAgda.TypeChecking.Monad.BaseAgda.Compiler.JS.SyntaxAgda.Compiler.JS.SubstitutionAgda.Compiler.JS.PrettyAgda.Auto.SyntaxAgda.Auto.SearchControlAgda.Auto.TypecheckAgda.Auto.CaseSplit#Agda.Interaction.Highlighting.RangeAgda.Syntax.Parser.MonadAgda.Syntax.Abstract.NameAgda.Syntax.NotationAgda.Syntax.FixityAgda.Syntax.LiteralAgda.Syntax.Treeless$Agda.Compiler.Treeless.GuardsToPrims!Agda.Compiler.Treeless.AsPatternsAgda.Syntax.Parser.TokensAgda.Compiler.Backend Agda.MainAgda.Interaction.Library.Parse,Agda.Utils.Graph.AdjacencyMap.UnidirectionalAgda.Utils.Graph.TopSort+Agda.TypeChecking.SizedTypes.WarshallSolver'Agda.TypeChecking.Positivity.OccurrenceAgda.Syntax.ConcreteAgda.Syntax.Concrete.Pretty$Agda.TypeChecking.Coverage.SplitTreeAgda.BenchmarkingAgda.Syntax.Concrete.Pattern%Agda.Syntax.Concrete.Operators.ParserAgda.Syntax.Concrete.GenericAgda.Syntax.Concrete.FixityAgda.Syntax.Concrete.Attribute%Agda.Interaction.Highlighting.PreciseAgda.Interaction.ResponseAgda.Utils.FavoritesAgda.Syntax.Scope.BaseAgda.Utils.GeniplateAgda.Syntax.InfoAgda.Termination.SparseMatrixAgda.Termination.OrderAgda.Termination.CallMatrixAgda.Termination.CallGraphAgda.Termination.TerminationAgda.Syntax.Parser.AlexAgda.Syntax.Parser.LookAhead!Agda.Syntax.Parser.StringLiteralsAgda.Syntax.Parser.LexActionsAgda.Syntax.Parser.LayoutAgda.Syntax.Parser.CommentsAgda.Syntax.Parser.LexerAgda.Syntax.Parser.ParserAgda.Syntax.ParserAgda.Syntax.Internal%Agda.TypeChecking.Substitute.DeBruijn!Agda.TypeChecking.Free.PrecomputeAgda.TypeChecking.Free.LazyAgda.TypeChecking.Free"Agda.TypeChecking.Substitute.ClassAgda.Syntax.ReflectedAgda.Syntax.Internal.Generic Agda.TypeChecking.CompiledClauseAgda.Syntax.Internal.MetaVarsAgda.Syntax.Internal.DefsAgda.Syntax.AbstractAgda.Syntax.Internal.PatternAgda.Syntax.Abstract.Views$Agda.Syntax.Abstract.PatternSynonymsAgda.Syntax.Abstract.PatternAgda.Utils.TypeLevelAgda.Utils.TypeLitsAgda.Utils.Update Agda.Syntax.Concrete.DefinitionsAgda.Utils.WarshallAgda.Utils.WithDefaultAgda.Utils.Zipper Agda.VersionAgda.VersionCommitAgda.Interaction.Library Agda.TypeChecking.Serialise.BaseAgda.TypeChecking.Rules.TermAgda.TypeChecking.Rules.Decl#Agda.TypeChecking.Rules.ApplicationAgda.TypeChecking.RewritingAgda.TypeChecking.Reduce.FastAgda.TypeChecking.PrimitiveAgda.TypeChecking.Polarity Agda.TypeChecking.Monad.MetaVarsAgda.TypeChecking.Monad.ImportsAgda.TypeChecking.Monad.EnvAgda.TypeChecking.Monad.ContextAgda.TypeChecking.Monad.BuiltinAgda.TypeChecking.ErrorsAgda.TypeChecking.Monad.Debug"Agda.TypeChecking.Monad.Statistics!Agda.TypeChecking.Monad.Signature Agda.TypeChecking.ProjectionLikeAgda.TypeChecking.Pretty.CallAgda.TypeChecking.Monad.Caching!Agda.TypeChecking.Monad.BenchmarkAgda.TypeChecking.Irrelevance&Agda.TypeChecking.CompiledClause.Match(Agda.TypeChecking.CompiledClause.CompileAgda.Syntax.Internal.Names&Agda.Interaction.Highlighting.GenerateAgda.TypeChecking.WarningsAgda.Interaction.ImportsAgda.Compiler.Treeless.EraseAgda.TypeChecking.InliningAgda.Interaction.FindFile,Agda.TypeChecking.Serialise.Instances.Common2Agda.TypeChecking.Serialise.Instances.Highlighting.Agda.TypeChecking.Serialise.Instances.AbstractAgda.Interaction.BaseAgda.TypeChecking.Monad.StateAgda.TypeChecking.Monad.TraceAgda.TypeChecking.Monad.MutualAgda.TypeChecking.Monad.Closure#Agda.TypeChecking.Monad.ConstraintsAgda.TypeChecking.ConstraintsAgda.Syntax.Scope.MonadAgda.Syntax.Concrete.OperatorsAgda.Interaction.Options.LensesAgda.TypeChecking.Monad.OptionsAgda.TypeChecking.SubstituteAgda.TypeChecking.Monad.OpenAgda.TypeChecking.Telescope"Agda.TypeChecking.Monad.SizedTypesAgda.TypeChecking.Level*Agda.Syntax.Translation.AbstractToConcreteAgda.Syntax.Abstract.PrettyAgda.TypeChecking.DropArgsAgda.TypeChecking.MetaVarsAgda.TypeChecking.DatatypesAgda.Compiler.Treeless.SubstAgda.Compiler.Treeless.PrettyAgda.Compiler.Treeless.CompareAgda.Compiler.Treeless.Uncase/Agda.TypeChecking.Serialise.Instances.Compilers.Agda.TypeChecking.Serialise.Instances.Internal,Agda.TypeChecking.Serialise.Instances.Errors%Agda.TypeChecking.Serialise.InstancesAgda.TypeChecking.SerialiseAgda.TypeChecking.Rules.Def+Agda.TypeChecking.Rules.Builtin.Coinduction"Agda.TypeChecking.Rewriting.ClauseAgda.TypeChecking.Reduce.MonadAgda.TypeChecking.Records Agda.TypeChecking.Patterns.Match#Agda.TypeChecking.Patterns.AbstractAgda.TypeChecking.Names"Agda.TypeChecking.MetaVars.MentionAgda.TypeChecking.EtaContractAgda.TypeChecking.Reduce#Agda.TypeChecking.SyntacticEquality Agda.TypeChecking.Primitive.Base#Agda.TypeChecking.Primitive.Cubical#Agda.TypeChecking.Patterns.InternalAgda.TypeChecking.Quote"Agda.TypeChecking.LevelConstraintsAgda.TypeChecking.Level.SolveAgda.TypeChecking.Free.ReduceAgda.TypeChecking.EmptyAgda.TypeChecking.DisplayFormAgda.TypeChecking.DeadCodeAgda.TypeChecking.ConversionAgda.TypeChecking.CheckInternalAgda.Termination.RecCheck+Agda.Syntax.Translation.ReflectedToAbstract*Agda.Syntax.Translation.InternalToAbstract Agda.TypeChecking.Telescope.PathAgda.TypeChecking.SizedTypesAgda.TypeChecking.Rules.Display#Agda.TypeChecking.Rules.LHS.ProblemAgda.TypeChecking.Implicit$Agda.TypeChecking.Rules.LHS.Implicit'Agda.TypeChecking.Rules.LHS.ProblemRestAgda.TypeChecking.FunctionsAgda.TypeChecking.Forcing)Agda.TypeChecking.Rewriting.NonLinPattern Agda.TypeChecking.RecordPatternsAgda.TypeChecking.PositivityAgda.TypeChecking.Sort Agda.TypeChecking.Pretty.WarningAgda.TypeChecking.Injectivity Agda.TypeChecking.Coverage.Match!Agda.TypeChecking.Conversion.Pure'Agda.TypeChecking.Rewriting.NonLinMatchAgda.Termination.Monad#Agda.TypeChecking.InstanceArguments!Agda.TypeChecking.MetaVars.Occurs"Agda.TypeChecking.SizedTypes.SolveAgda.TypeChecking.Unquote!Agda.TypeChecking.Rules.LHS.Unify&Agda.TypeChecking.Rewriting.Confluence"Agda.TypeChecking.IApplyConfluenceAgda.TypeChecking.GeneralizeAgda.TypeChecking.Rules.Data'Agda.TypeChecking.ReconstructParametersAgda.TypeChecking.EtaExpandAgda.TypeChecking.AbstractAgda.TypeChecking.WithAgda.Termination.TermCheck Agda.Syntax.Internal.SanityCheckAgda.Syntax.IdiomBracketsAgda.Syntax.DoNotationAgda.Interaction.Monad!Agda.Interaction.Highlighting.Vim!Agda.Interaction.Highlighting.Dot$Agda.Interaction.Highlighting.CommonAgda.Compiler.Treeless.UnusedAgda.Compiler.Treeless.Simplify%Agda.Compiler.Treeless.NormalizeNamesAgda.Compiler.Treeless.Identity/Agda.Compiler.Treeless.EliminateLiteralPatterns(Agda.Compiler.Treeless.EliminateDefaultsAgda.Compiler.Treeless.BuiltinAgda.Compiler.MAlonzo.CompilerAgda.Compiler.MAlonzo.CoerceAgda.Compiler.CallCompiler"Agda.Interaction.Highlighting.JSONAgda.TypeChecking.Rules.LHSAgda.TypeChecking.Rules.Builtin*Agda.Syntax.Translation.ConcreteToAbstractAgda.TypeChecking.CoverageAgda.TypeChecking.Rules.RecordAgda.Compiler.ToTreeless#Agda.Interaction.Highlighting.EmacsAgda.Interaction.BasicOpsAgda.Interaction.SearchAboutAgda.Interaction.MakeCaseAgda.Auto.ConvertAgda.Interaction.CommandLineAgda.Auto.AutoAgda.Compiler.CommonAgda.Compiler.MAlonzo.PragmasAgda.Compiler.MAlonzo.MiscAgda.Compiler.MAlonzo.EncodeAgda.Compiler.MAlonzo.Pretty Agda.Compiler.MAlonzo.Primitives"Agda.Compiler.MAlonzo.HaskellTypes#Agda.Interaction.Highlighting.LaTeXAgda.Interaction.InteractionTopAgda.Interaction.AgdaTopAgda.Interaction.EmacsTopAgda.Interaction.JSONTop"Agda.Interaction.Highlighting.HTMLAgda.Compiler.JS.CompilerPretty Agda.UtilsStringData.Traversablefor TraversableforM_Lazy listToMaybe maybeToList catMaybesmapMaybeforMifNull Data.List genericIndexData Bitraversable Data.Maybe fromMaybe fromMaybeMAgda.TypeChecking.SubstitutionliftSAgda.Syntax.Internal.Patterns numberPatVarsLHSTree APatternLikeData.MapmapKeysMonotonicQName whyInScope unifyStepcompileClauses NonLinMatch'foldTermAgda.Syntax.TranslationAbstractToConcrete' Paths_AgdaLenses'AbstractSyntax AtTopLevelinteractionLoop localStateAgda.TypeChecking.MonadAgda.TypeChecking.Testsprop_splitTelescopesimplifyLevelConstraint getConTypeAgda.TheTypeCheckerbaseGHC.Base<><*>GHC.ArrIx SemigroupSystem.Console.GetOptOptionOptDescrOptArgReqArgNoArgArgDescr Control.Monadunless<=<>=> Data.EitherisRightisLeft Data.Functor$><$>GHC.Listlookup Data.Tupleswapwhen<$mplusmzero MonadPluscontainers-0.6.0.1Data.IntSet.InternalfromList toDescListtoList isSubsetOf intersection differenceunionunionsdelete singletonemptymembernull mtl-2.2.2Control.Monad.Error.Class catchError throwError MonadErrortransformers-0.5.6.2Control.Monad.Trans.ExceptExceptT runExceptT mapExceptTpretty-1.1.3.6Text.PrettyPrint.HughesPJ fullRender renderStylerenderfsepfcatcatsep<+>$+$$$ punctuatehangnestvcathsephcatbracesbracketsparens doubleQuotesquotesrationaldoublefloatintegerintrbracelbracerbracklbrackrparenlparenequalsspacecoloncommasemiisEmpty zeroWidthText sizedTextptexttextcharDoc#Text.PrettyPrint.Annotated.HughesPJstylePStrChrribbonsPerLine lineLengthmodeStyle OneLineModeLeftMode ZigZagModePageModeModeUnicodeOrAscii UnicodeOk AsciiOnlyunicodeOrAscii builtinNat builtinSuc builtinZerobuiltinNatPlusbuiltinNatMinusbuiltinNatTimesbuiltinNatDivSucAuxbuiltinNatModSucAuxbuiltinNatEqualsbuiltinNatLess builtinWord64builtinIntegerbuiltinIntegerPosbuiltinIntegerNegSuc builtinFloat builtinChar builtinString builtinUnitbuiltinUnitUnit builtinSigma builtinBool builtinTrue builtinFalse builtinList builtinNil builtinCons builtinIO builtinId builtinConId builtinIdElim builtinPath builtinPathPbuiltinInterval builtinIMin builtinIMax builtinINeg builtinIZero builtinIOnebuiltinPartialbuiltinPartialP builtinIsOnebuiltinItIsOne builtinEquivbuiltinEquivFunbuiltinEquivProofbuiltinTranspProof builtinGlue builtin_gluebuiltin_unglue builtin_glueUbuiltin_unglueUbuiltinFaceForall builtinIsOne1 builtinIsOne2builtinIsOneEmpty builtinComp builtinPOr builtinTrans builtinHComp builtinSub builtinSubIn builtinSubOutbuiltinSizeUniv builtinSize builtinSizeLtbuiltinSizeSucbuiltinSizeInfbuiltinSizeMax builtinInf builtinSharp builtinFlatbuiltinEquality builtinReflbuiltinRewritebuiltinLevelMax builtinLevelbuiltinLevelZerobuiltinLevelSucbuiltinSetOmegabuiltinFromNatbuiltinFromNegbuiltinFromString builtinQNamebuiltinAgdaSortbuiltinAgdaSortSetbuiltinAgdaSortLitbuiltinAgdaSortUnsupported builtinHiding builtinHiddenbuiltinInstancebuiltinVisiblebuiltinRelevancebuiltinRelevantbuiltinIrrelevant builtinAssocbuiltinAssocLeftbuiltinAssocRightbuiltinAssocNonbuiltinPrecedencebuiltinPrecRelatedbuiltinPrecUnrelated builtinFixitybuiltinFixityFixity builtinArgbuiltinArgInfobuiltinArgArgInfo builtinArgArg builtinAbs builtinAbsAbsbuiltinAgdaTermbuiltinAgdaTermVarbuiltinAgdaTermLambuiltinAgdaTermExtLambuiltinAgdaTermDefbuiltinAgdaTermConbuiltinAgdaTermPibuiltinAgdaTermSortbuiltinAgdaTermLitbuiltinAgdaTermUnsupportedbuiltinAgdaTermMetabuiltinAgdaErrorPartbuiltinAgdaErrorPartStringbuiltinAgdaErrorPartTermbuiltinAgdaErrorPartNamebuiltinAgdaLiteralbuiltinAgdaLitNatbuiltinAgdaLitWord64builtinAgdaLitFloatbuiltinAgdaLitCharbuiltinAgdaLitStringbuiltinAgdaLitQNamebuiltinAgdaLitMetabuiltinAgdaClausebuiltinAgdaClauseClausebuiltinAgdaClauseAbsurdbuiltinAgdaPatternbuiltinAgdaPatVarbuiltinAgdaPatConbuiltinAgdaPatDotbuiltinAgdaPatLitbuiltinAgdaPatProjbuiltinAgdaPatAbsurdbuiltinAgdaDefinitionFunDefbuiltinAgdaDefinitionDataDefbuiltinAgdaDefinitionRecordDef$builtinAgdaDefinitionDataConstructorbuiltinAgdaDefinitionPostulatebuiltinAgdaDefinitionPrimitivebuiltinAgdaDefinitionbuiltinAgdaMetabuiltinAgdaTCMbuiltinAgdaTCMReturnbuiltinAgdaTCMBindbuiltinAgdaTCMUnifybuiltinAgdaTCMTypeErrorbuiltinAgdaTCMInferTypebuiltinAgdaTCMCheckTypebuiltinAgdaTCMNormalisebuiltinAgdaTCMReducebuiltinAgdaTCMCatchErrorbuiltinAgdaTCMGetContextbuiltinAgdaTCMExtendContextbuiltinAgdaTCMInContextbuiltinAgdaTCMFreshNamebuiltinAgdaTCMDeclareDefbuiltinAgdaTCMDeclarePostulatebuiltinAgdaTCMDefineFunbuiltinAgdaTCMGetTypebuiltinAgdaTCMGetDefinitionbuiltinAgdaTCMBlockOnMetabuiltinAgdaTCMCommitbuiltinAgdaTCMQuoteTermbuiltinAgdaTCMUnquoteTermbuiltinAgdaTCMIsMacrobuiltinAgdaTCMWithNormalisationbuiltinAgdaTCMDebugPrintbuiltinAgdaTCMNoConstraintsbuiltinAgdaTCMRunSpeculative builtinsNoDef sizeBuiltinsCutOff DontCutOff $fShowCutOff $fEqCutOff $fOrdCutOffSemiringaddmulzeroHasZero zeroElementintegerSemiring intSemiring boolSemiring $fHasZeroInt$fHasZeroInteger AffineHole ZeroHolesOneHole ManyHoles$fApplicativeAffineHole$fFunctorAffineHole?*>?$>BiMap biMapThere biMapBack invLookupinsert $fShowBiMap $fOrdBiMap $fEqBiMapexpandEnvironmentVariables $fEqToken $fShowTokenErrornoMsgstrMsg mkExceptT $fError[]FailrunFailrunFail_$fMonadFailFail $fFunctorFail$fApplicativeFail $fMonadFail iterWhile repeatWhile repeatWhileMtrampolineWhiletrampolineWhileM trampoline trampolineM iterateUntil iterateUntilMiterate' applyWhen applyUnless applyWhenM applyUnlessMDioidcompose unitComposeMeetSemiLatticemeetPlusplusToptopisTopdebug setDebuggingtracetraceM$fPlusIntIntInt Decoration traverseF distributeF<.><&>dmapdget$fDecoration(,)$fDecorationCompose$fDecorationIdentity TyVarBind UnkindedVarQOpQVarOpNameIdentSymbolQualUnQual ModuleNameLiteralIntFracCharAltExpVarConLitInfixAppAppLambdaLetIfCase ExpTypeSigNegAppFakeExpStmt Qualifier GeneratorPatPVarPLitPAsPat PWildCardPBangPatPApp PatTypeSigPIrrPatTypeTyForallTyFunTyConTyVarTyAppFakeTypeMatch GuardedRhsRhs UnGuardedRhs GuardedRhssBindsBDeclsDeriving StrictnessStrictConDecl DataOrNewDataTypeNewTypeDeclTypeDeclDataDeclTypeSigFunBindPatSynFakeDecl ImportSpecIVar ImportDecl importModuleimportQualified importSpecs ModulePragmaLanguagePragma OtherPragmaModuleunit_con $fEqDataOrNew$fEqStrictness $fEqLiteral$fEqModuleName$fOrdModuleName$fEqName $fEqQName$fEqQOp $fEqTyVarBind$fEqType$fEqPat $fEqConDecl$fEqDecl $fEqMatch$fEqRhs$fEqExp$fEqAlt $fEqBinds$fEqGuardedRhs$fEqStmtCatchIOcatchIO$fCatchIOWriterT $fCatchIOIOreadBinaryFile'copyDirContent readTextFile writeFilewriteTextToFilewriteToTempFilereadModifyIORef'CatchImpossiblecatchImpossiblecatchImpossibleJusthandleImpossiblehandleImpossibleJust Impossible UnreachableImpMissingDefinitionsthrowImpossiblewithFileAndLine'withFileAndLine__IMPOSSIBLE____UNREACHABLE__$fExceptionImpossible$fShowImpossible$fCatchImpossibleIOEmptyabsurd toImpossible $fShowEmpty $fOrdEmpty $fEqEmpty $fDataEmptyBagbagsize! notMembercountgroupskeyselems toAscListmap traverse' $fFoldableBag $fMonoidBag$fSemigroupBag $fShowBag$fEqBag$fOrdBagimpossibleTestChoice LeftDisjunct RightDisjunctSRes HandleSolQPB QPBlockedQPDoubleBlockedPBNotPBPBlockedPDoubleBlockedMBNotBBlockedFailedMetaEnvMMNotMMetaBlkInfo Refinable refinementsMove'MovemoveCostmoveNextCostgetCost RefCreateEnvrunRefCreateEnvUndoRestorePrioMetaNoPrioSubConstraintsscflip sccomcountscsub1scsub2CTree ctpriometactsubctparent cthandlesMetavarmbindmprincipalpresentmobs mcompoint mextrarefsOKMetaOKHandleOKValPropOK AddExtraRefAnd SideconditionOr ConnectHandleTermTravtravPriogetPrio hequalMetavarnewMetainitMetanewCTreenewSubConstraints ureadIORef uwriteIORef umodifyIORefureadmodifyIORefrunUndonewPlaceholder newOKHandledryInstantiatermmmcasemmmcasemmpcase doubleblockmbcasembpcasemmbpcasewaitokmbretmbfailedmpret expandbind topSearchextractblkinfosrecalcsseqcrecalcreccalccalcchoosePrioMeta propagatePriochoose$fRefinableOKValblk$fMonadRefCreateEnv$fApplicativeRefCreateEnv$fFunctorRefCreateEnv $fEqPrioMeta $fEqMetavar $fTravMMblk$fRefinableChoiceblk$fEqPrio $fOrdPrio $fNumPrio $fNumCost$fEqCost $fOrdCostIntSetbelowabovefull toFiniteList invariant$fMonoidIntSet$fSemigroupIntSet $fEqIntSet $fShowIntSetLensMapLensSetLensGetLens'lFstlSnd^.setoverfocususe.=%=%==%%= locallyStateviewlocallylocally'keyIndexZeroSucAllNilConsSomewithSomemakeAll forgetAll forgetIndex mapWithIndexlIndex lookupIndex allIndices AgdaLibFile_libName_libFile _libIncludes _libDependsLibNamelibNameForCurrentDir emptyLibFilelibNamelibFile libIncludes libDepends$fShowAgdaLibFile AutoTokenMCRDLTSH AutoOptions autoHints autoTimeOutautoPickautoMode autoHintModeTimeOut getTimeOutHints AutoHintModeAHMNone AHMModuleMNormal MCaseSplitMRefineinitAutoOptionsaoHints aoTimeOutaoPickaoMode aoHintMode autoTokens parseTime parseArgs $fShowTimeOutRecordfield1field2 lensField1 lensField2 filterKeys mapMaybeKeys boolToMaybeunionMaybeWithunionsMaybeWith unzipMaybe filterMaybeforMaybe caseMaybeifJustmaybeM caseMaybeMifJustMwhenJust whenNothing whenJustM whenNothingMallJustMListTrunListTmapListTnilListT consListTsgListT caseListT foldListT sequenceListT concatListT runMListT consMListTsgMListT mapMListT mapMListT_alt liftListT$fMonadFailListT$fMonadStatesListT$fMonadReaderrListT$fMonadIOListT$fMonadTransListT $fMonadListT$fApplicativeListT$fMonadPlusListT$fAlternativeListT $fMonoidListT$fSemigroupListT$fFunctorListT WarningNameOverlappingTokensWarning_LibUnknownField_EmptyAbstract_ EmptyField_EmptyGeneralize_EmptyInstance_ EmptyMacro_ EmptyMutual_EmptyPostulate_EmptyPrimitive_ EmptyPrivate_EmptyRewritePragma_InvalidCatchallPragma_InvalidCoverageCheckPragma_InvalidNoPositivityCheckPragma_InvalidNoUniverseCheckPragma_InvalidTerminationCheckPragma_MissingDefinitions_NotAllowedInMutual_OpenPublicAbstract_OpenPublicPrivate_ PolarityPragmasButNotPostulates_PragmaCompiled_PragmaNoTerminationCheck_ShadowingInTelescope_UnknownFixityInMixfixDecl_UnknownNamesInFixityDecl_UnknownNamesInPolarityPragmas_UselessAbstract_UselessInstance_UselessPrivate_AbsurdPatternRequiresNoRHS_CantGeneralizeOverSorts_ClashesViaRenaming_CoverageIssue_CoverageNoExactSplit_DeprecationWarning_FixityInRenamingModule_GenericNonFatalError_GenericWarning_IllformedAsClause_InstanceArgWithExplicitArg_InstanceWithExplicitArg_InstanceNoOutputTypeName_InversionDepthReached_ModuleDoesntExport_ NotInScope_NotStrictlyPositive_ OldBuiltin_PragmaCompileErased_RewriteMaybeNonConfluent_RewriteNonConfluent_ SafeFlagEta_SafeFlagInjective_SafeFlagNoCoverageCheck_SafeFlagNonTerminating_SafeFlagNoPositivityCheck_SafeFlagNoUniverseCheck_SafeFlagPolarity_SafeFlagPostulate_SafeFlagPragma_SafeFlagTerminating_&SafeFlagWithoutKFlagPrimEraseEquality_TerminationIssue_UnreachableClauses_UnsolvedConstraints_UnsolvedInteractionMetas_UnsolvedMetaVariables_UselessInline_UselessPublic_ UserWarning_WithoutKFlagPrimEraseEquality_WrongInstanceDeclaration_CoInfectiveImport_InfectiveImport_ WarningMode _warningSet _warn2Error warningSet warn2ErrordefaultWarningSetdefaultWarningModewarningModeUpdate warningSets noWarningsunsolvedWarningsincompleteMatchWarnings errorWarnings allWarnings usualWarningsstring2WarningNamewarningName2String usageWarning$fEqWarningName$fOrdWarningName$fShowWarningName$fReadWarningName$fEnumWarningName$fBoundedWarningName$fEqWarningMode$fShowWarningModeHelp GeneralHelpHelpFor allHelpTopicshelpTopicUsagestring2HelpTopic $fEqHelpTopic$fShowHelpTopic$fEqHelp $fShowHelpmemomemoRec memoUnsafe memoUnsafeHMaxNat getMaxNat$fMonoidMaxNat$fSemigroupMaxNat $fNumMaxNat $fEqMaxNat $fOrdMaxNat $fShowMaxNat $fEnumMaxNatNull ifNotNullifNullM ifNotNullMwhenNull unlessNull whenNullM unlessNullM $fNullStateT $fNullReaderT $fNullDoc $fNullMaybe $fNullSet $fNullSeq $fNullHashSet $fNullHashMap $fNullMap $fNullIntSet $fNullIntMap $fNullBag$fNull[]$fNullByteString $fNull(,)$fNull()#strict-0.3.2-2aeC0uPBzhhHpNCyMYHGTDData.Strict.MaybefromJustisJust isNothingmaybeMaybeJustNothingtoStricttoLazy $fBinaryMaybe $fNFDataMaybe$fTraversableMaybe$fFoldableMaybe$fApplicativeMaybe $fMonoidMaybe$fSemigroupMaybe$fGenericMaybe $fDataMaybe Inclusion inclusion Pointwise pointwise PartialOrd comparable ComparablePartialOrderingPOLTPOLEPOEQPOGEPOGTPOAnyleqPOoppPOorPOseqPO fromOrdering fromOrderings toOrderings comparableOrdrelated$fMonoidPartialOrdering$fSemigroupPartialOrdering$fPartialOrdPartialOrdering$fPartialOrd(,)$fPartialOrdEither$fPartialOrdMaybe$fPartialOrd()$fPartialOrdInteger$fPartialOrdInt$fPartialOrdPointwise$fPartialOrdInclusion$fPartialOrdInclusion0$fEqPartialOrdering$fShowPartialOrdering$fEnumPartialOrdering$fBoundedPartialOrdering $fEqPointwise$fShowPointwise$fFunctorPointwise $fEqInclusion$fOrdInclusion$fShowInclusion$fFunctorInclusionLeftClosedPOMonoidinverseComposePOMonoid POSemigrouphasLeftAdjointPtrnewPtrderefPtr updatePtrsetPtr updatePtrM $fDataIORef $fNFDataPtr $fHashablePtr$fOrdPtr$fEqPtr$fTraversablePtr $fFoldablePtr $fFunctorPtr $fShowPtr $fDataPtr StarSemiRingostarSemiRingozeroooneoplusotimes$fSemiRingMaybe $fSemiRing()$fStarSemiRingMaybe$fStarSemiRing() Singleton$fSingleton(,)HashMap$fSingletonaHashSet$fSingleton(,)IntMap$fSingleton(,)Map$fSingletonIntIntSet$fSingletonaSet$fSingletonaSeq$fSingletonaNonEmpty$fSingletonaEndo$fSingletona->$fSingletona[]$fSingletonaMaybeclustercluster' SizedThingtheSize sizedThingSized sizeThing $fSizedSeq$fSizedHashSet$fSizedHashMap $fSizedSet $fSizedMap $fSizedIntSet $fSizedIntMap $fSized[]$fNullSizedThing$fSizedSizedThingpretty prettyPrec prettyList prettyShowpwordsfwords prettyList_mparensalign multiLineTextpshow singPluralprefixedThings $fDataDoc$fPrettyNonEmpty $fPretty[] $fPrettyMaybe $fPretty() $fPrettyDoc $fPrettyChar$fPrettyInteger $fPrettyInt32 $fPrettyInt $fPrettyBoolDocPParserWithGrammar ParserClassparsegrammarsat'annotatememoisememoiseIfPrintingParserdocsattokentokbindPchoicePseqPstarPatomP$fAlternativeParser$fApplicativeParser$fFunctorParser $fMonadParser$fParserClassParserkrtok#$fParserClassParserWithGrammarkrtok$fAlternativeParserWithGrammar$fApplicativeParserWithGrammar$fFunctorParserWithGrammar$fMonadParserWithGrammar AbsolutePathfilePath mkAbsoluterootPathabsolute===doesFileExistCaseSensitive$fPrettyAbsolutePath$fShowAbsolutePath$fEqAbsolutePath$fOrdAbsolutePath$fDataAbsolutePath$fHashableAbsolutePathHashhashByteString hashTextFilehashText combineHashes hashStringFlexsflexsRigidsrigidsTruncateOffsettruncateOffset ValidOffset validOffsetCTrans SubstitutesubstSolution theSolution PolaritiesPolarityAssignmentPolarityLeastGreatest Constraint Constraint'leftExprcmp rightExprCmpLtLeSizeExpr SizeExpr'ConstRigidInftyFlexoffsetrigidflexFlexIdflexIdRigidIdrigidIdOffsetOemptyPolaritiespolaritiesFromAssignments getPolarity emptySolution simplify1ifLe compareOffset$fPlusOffsetOffsetOffset$fMeetSemiLatticeOffset$fPrettyOffset $fShowOffset $fPrettyRigid $fShowRigid $fPrettyFlex $fShowFlex$fPrettySizeExpr'$fPlusSizeExpr'OffsetSizeExpr' $fPrettyCmp$fTopCmp$fMeetSemiLatticeCmp$fOrdCmp $fDioidCmp$fPrettyConstraint'$fPrettyPolarity$fPrettyPolarityAssignment$fPrettySolution$fSubstituterfSolution$fSubstituterfMap$fSubstituterf[]$fSubstituterfConstraint'$fSubstituterfSizeExpr'$fValidOffsetSizeExpr'$fValidOffsetOffset$fTruncateOffsetSizeExpr'$fTruncateOffsetOffset$fRigidsrConstraint'$fRigidsrSizeExpr' $fRigidsr[]$fFlexsflexConstraint'$fFlexsflexSizeExpr' $fFlexsflex[] $fEqOffset $fOrdOffset $fNumOffset $fEnumOffset $fEqRigid $fOrdRigid$fEqFlex $fOrdFlex$fShowSizeExpr' $fEqSizeExpr'$fOrdSizeExpr'$fFunctorSizeExpr'$fFoldableSizeExpr'$fTraversableSizeExpr' $fShowCmp$fEqCmp $fBoundedCmp $fEnumCmp$fShowConstraint'$fFunctorConstraint'$fFoldableConstraint'$fTraversableConstraint' $fEqPolarity $fOrdPolarity$fShowSolution$fNullSolutionSmallSettotal complement\\ mapMemberShipzipMemberShipWith fromAscListfromDistinctAscList $fEqSmallSet $fOrdSmallSet$fShowSmallSet$fDataSmallSetSuffixNoSuffixPrime SubscriptsubscriptAllowedisSubscriptDigittoSubscriptDigitfromSubscriptDigit nextSuffix suffixView addSuffixEither3In1In2In3ThreeOneTwo partition3partitionEithers3 mapEither3M forEither3M $fEqThree $fOrdThree $fShowThree$fBoundedThree $fEnumThree $fEqEither3 $fOrdEither3 $fShowEither3Trie everyPrefix unionWith insertWithadjusttoListOrderedBy mapSubTries lookupPath lookupTriefiltervalueAt $fNullTrie $fShowTrie$fEqTrie $fFunctorTrie$fFoldableTrieList2list2-*-mapFstmapSnd/\fst3snd3thd3uncurry3uncurry4mapPairMmapFstMmapSndM$fApplicativeList2 $fEqList2$fFunctorList2$fFoldableList2$fTraversableList2StrSufSt SSSMismatchSSSStrip SSSResultReversedSuffixPrefixsnoccaseList caseListMlistCaseheadWithDefault tailMaybetailWithDefault lastMaybelast2unconsmconsinitLast initMaybe!!!indexWithDefault findWithIndexgenericElemIndexdownFrom updateHead updateLastupdateAtsplitExactlyAtdropEndspanEnd takeWhileJustspanJustpartitionMaybe filterAndRestmapMaybeAndRest isSublistOfholes commonPrefix dropCommon stripPrefixBy commonSuffix stripSuffixstripReversedSuffixgroupOngroupBy'wordsBychopchopWhenhasElemsorteddistinct fastDistinct duplicates allDuplicatesnubOnuniqOnallEqualzipWith'zipWithKeepRest unzipWitheditDistanceSpec editDistanceStrunStrquotehaskellStringLiteral delimiter showIndexaddFinalNewLineindentshowThousandSepltrimrtrimtrim$fIsStringStateT$fIsStringReaderT $fShowStr$fEqStrCPUTime ClockTime getClockTimefromMilliseconds getCPUTime measureTime$fPrettyCPUTime $fEqCPUTime $fShowCPUTime $fOrdCPUTime $fNumCPUTime $fRealCPUTime $fEnumCPUTime$fIntegralCPUTimeLispAQresponse putResponse display_info'clearRunningInfo clearWarningdisplayRunningInfo $fShowLisp $fPrettyLisp$fEqLisp normaliseNaNdoubleToWord64floatEqfloatLttoStringWithoutDotZero whileLeft caseEitherMmapLeftmapRighttraverseEitherfromLeft fromRight fromLeftM fromRightM maybeLeft maybeRightallLeftallRight groupByEither maybeToEither==<<whenMunlessMguardMifMifNotMand2MandMallMor2MorManyMaltM1 orEitherMmapM'forM'mapMMforMMmapMM_forMM_ mapMaybeM mapMaybeMM forMaybeM forMaybeMM dropWhileM dropWhileEndM partitionM fromMaybeMP catMaybesMPfinallytryMaybetryCatchbracket_readM MonadBench getBenchmark getsBenchmark putBenchmarkmodifyBenchmark Benchmark benchmarkOncurrentAccounttimings BenchmarkOn BenchmarkOff BenchmarkSomeTimingsCurrentAccountAccount isBenchmarkOnmapBenchmarkOnmapCurrentAccount mapTimings addCPUTimesetBenchmarkingswitchBenchmarkingresetbillTo billToCPS billPureTo$fPrettyBenchmark$fNullBenchmark$fMonadBenchaStateT$fMonadBenchaReaderT KillRangeT KillRange killRangeSetRangesetRangeHasRangegetRange PrintRangeRangeRange'NoRangeIntervalWithoutFileInterval Interval'iStartiEndPositionWithoutFilePositionSrcFile Position'PnsrcFileposPosposLineposColpositionInvariantintervalInvariantsetIntervalFilegetIntervalFile posToIntervaliLengthrangeIntervalsintervalsToRangeconsecutiveAndSeparatedrangeInvariant rangeFile rightMargin killRangeMap killRange1 killRange2 killRange3 killRange4 killRange5 killRange6 killRange7 killRange8 killRange9 killRange10 killRange11 killRange12 killRange13 killRange14 killRange15 killRange16 killRange17 killRange18 killRange19 startPos'startPosnoRangemovePosmovePosByString backupPos posToRange' posToRangeintervalToRangerangeToIntervalWithFilerangeToInterval continuouscontinuousPerLinerStart'rStartrEnd'rEnd fuseIntervals fuseRanges fuseRange beginningOfbeginningOfFile withRangeOfinterleaveRanges$fPrettyPosition'$fShowPosition'$fOrdPosition' $fEqPosition'$fPrettyPosition'0$fShowPosition'0$fPrettyInterval'$fShowInterval'$fPrettyInterval'0$fShowInterval'0$fPrettyRange' $fShowRange' $fShowRange'0 $fNullRange'$fHasRangeEither$fHasRangeMaybe$fHasRange(,,,,,,)$fHasRange(,,,,,)$fHasRange(,,,,)$fHasRange(,,,)$fHasRange(,,) $fHasRange(,)$fHasRangeNonEmpty $fHasRange[]$fHasRangeBool $fHasRange()$fHasRangeRange'$fHasRangeInterval'$fSetRangeMaybe $fSetRange[]$fSetRangeRange'$fKillRangeEither$fKillRangeMaybe$fKillRangeMaybe0$fKillRange(,,,)$fKillRange(,,)$fKillRange(,)$fKillRangeSet$fKillRangeMap $fKillRange[]$fKillRangeNonEmpty$fKillRange[]0$fKillRangeInteger$fKillRangeInt$fKillRangeBool $fKillRange()$fKillRangeVoid$fKillRangeRange'$fPrettyPrintRange$fDataPosition'$fFunctorPosition'$fFoldablePosition'$fTraversablePosition'$fGenericPosition'$fDataInterval' $fEqInterval'$fOrdInterval'$fFunctorInterval'$fFoldableInterval'$fTraversableInterval'$fGenericInterval' $fDataRange' $fEqRange' $fOrdRange'$fFunctorRange'$fFoldableRange'$fTraversableRange'$fGenericRange'$fEqPrintRange$fOrdPrintRange$fHasRangePrintRange$fSetRangePrintRange$fKillRangePrintRangeDoDropdoDropdropMoreunDropDropdropNdropFromInversePermuteinversePermute PermutationPerm permRange permPickspermute safePermuteidPtakePdroppedPliftPcomposePinvertPcompactPreversePflipPexpandPtopoSort$fKillRangePermutation$fNullPermutation$fSizedPermutation$fShowPermutation$fInversePermute->[]$fInversePermute[][]$fInversePermute[]IntMap$fInversePermute[][]0$fKillRangeDrop$fDoDropPermutation $fDoDrop[]$fEqPermutation$fDataPermutation$fEqDrop $fOrdDrop $fShowDrop $fDataDrop $fFunctorDrop$fFoldableDrop$fTraversableDropGenPartBindHole NormalHoleWildHoleIdPartNotationExpandedEllipsis NoEllipsis ellipsisRangeellipsisWithArgs RewriteEqn'RewriteInvert CoverageCheckYesCoverageCheckNoCoverageCheck UniverseCheckYesUniverseCheckNoUniverseCheckPositivityCheckYesPositivityCheckNoPositivityCheckTerminationCheckNoTerminationCheckNonTerminating TerminatingTerminationMeasure Renaming'RenamingrenFromrenTo renFixity renToRange ImportedName'ImportedModule ImportedNameUsing' UseEverythingUsingImportDirective'ImportDirectiveimportDirRangeusinghiding impRenaming publicOpen LensFixity' lensFixity' LensFixity lensFixityFixity' theFixity theNotation theNameRangeFixity fixityRange fixityLevel fixityAssoc AssociativityNonAssoc LeftAssoc RightAssoc FixityLevel UnrelatedRelatedPrecedenceLevel InteractionId interactionIdMaybePlaceholder Placeholder NoPlaceholderPositionInName BeginningMiddleEndConstrMetaIdmetaIdNameIdIsMacroMacroDef NotMacroDef IsInstance InstanceDefNotInstanceDef AnyIsAbstract anyIsAbstractLensIsAbstractlensIsAbstract IsAbstract AbstractDef ConcreteDefAccess PrivateAccess PublicAccessIsInfixInfixDef PrefixDef DataOrRecordIsDataIsRecord ProjOrigin ProjPrefix ProjPostfix ProjSystem ConOrigin ConOSystemConOConConORec ConOSplitRStringRawNameRangedrangeOf rangedThingArgNameNamedArg LensNamed lensNamed NamedNameNamed_NamednameOf namedThing Underscore underscore isUnderscoreArgargInfounArg LensArgInfo getArgInfo setArgInfo mapArgInfoArgInfo argInfoHidingargInfoModality argInfoOriginargInfoFreeVariablesLensFreeVariablesgetFreeVariablessetFreeVariablesmapFreeVariables FreeVariables UnknownFVsKnownFVs LensOrigin getOrigin setOrigin mapOrigin WithOriginwoOriginwoThingOrigin UserWrittenInserted Reflected CaseSplit Substitution LensCohesion getCohesion setCohesion mapCohesionCohesionFlat ContinuousSquash LensRelevance getRelevance setRelevance mapRelevance RelevanceRelevant NonStrict Irrelevant LensQuantity getQuantity setQuantity mapQuantityQuantity Quantity0 Quantity1 Quantityω QωOrigin QωInferredQω QωPlentyQ1Origin Q1InferredQ1Q1LinearQ0Origin Q0InferredQ0Q0Erased LensModality getModality setModality mapModalityModality modRelevance modQuantity modCohesion LensHiding getHiding setHiding mapHiding WithHidingwhHidingwhThingHidingHiddenInstance NotHidden Overlappable YesOverlap NoOverlap Induction Inductive CoInductiveHasEtaNoEtaYesEtaFileType AgdaFileType MdFileType RstFileType TexFileType OrgFileTypeDelayed NotDelayedArityNat mergeHidingvisible notVisiblehiddenhidehideOrKeepInstance makeInstance makeInstance'isOverlappable isInstance sameHidingdefaultModalitymoreUsableModalityusableModalitycomposeModality applyModalityinverseComposeModalityinverseApplyModality addModality zeroModality topModality sameModality lModRelevance lModQuantity lModCohesiongetRelevanceModsetRelevanceModmapRelevanceModgetQuantityModsetQuantityModmapQuantityModgetCohesionModsetCohesionModmapCohesionModdefaultQuantity sameQuantity addQuantity zeroQuantity topQuantity moreQuantitycomposeQuantity applyQuantityinverseComposeQuantityinverseApplyQuantity hasQuantity0 hasQuantity1 hasQuantityωnoUserQuantityusableQuantity allRelevancesdefaultRelevance isRelevant isIrrelevant isNonStrict moreRelevant sameRelevanceusableRelevancecomposeRelevanceapplyRelevanceinverseComposeRelevanceinverseApplyRelevance addRelevance zeroRelevance topRelevanceirrToNonStrictnonStrictToRelnonStrictToIrr allCohesionsdefaultCohesion moreCohesion sameCohesionusableCohesioncomposeCohesion applyCohesioninverseComposeCohesioninverseApplyCohesion addCohesion zeroCohesion topCohesionunknownFreeVariablesnoFreeVariablesoneFreeVariablefreeVariablesFromListhasNoFreeVariablesdefaultArgInfogetHidingArgInfosetHidingArgInfomapHidingArgInfogetModalityArgInfosetModalityArgInfomapModalityArgInfogetOriginArgInfosetOriginArgInfomapOriginArgInfogetFreeVariablesArgInfosetFreeVariablesArgInfomapFreeVariablesArgInfoisInsertedHidden defaultArg withArgsFromwithNamedArgsFromsameNameunnamednamed userNamed getNameOf setNameOf mapNameOf bareNameOfbareNameWithDefault namedSamefittingNamedArgnamedArgdefaultNamedArg unnamedArgupdateNamedArgupdateNamedArgA setNamedArgargNameToStringstringToArgNameappendArgNamesunrangedrawNameToStringstringToRawName bestConInfo noPlaceholdernoFixity defaultFixity noFixity' _fixityAssoc _fixityLeveldefaultImportDirisDefaultImportDirmapUsingsetImportedName noNotation$fKillRangeDelayed$fPrettyFileType$fNFDataHasEta$fKillRangeHasEta$fHasRangeHasEta$fNFDataInduction$fKillRangeInduction$fHasRangeInduction$fPrettyInduction$fNFDataOverlappable$fMonoidOverlappable$fSemigroupOverlappable$fNFDataHiding$fKillRangeHiding$fMonoidHiding$fSemigroupHiding$fPrettyHiding$fNFDataWithHiding$fKillRangeWithHiding$fSetRangeWithHiding$fHasRangeWithHiding$fApplicativeWithHiding$fDecorationWithHiding$fNFDataQ0Origin$fKillRangeQ0Origin$fSetRangeQ0Origin$fHasRangeQ0Origin$fNullQ0Origin$fMonoidQ0Origin$fSemigroupQ0Origin$fNFDataQ1Origin$fKillRangeQ1Origin$fSetRangeQ1Origin$fHasRangeQ1Origin$fNullQ1Origin$fMonoidQ1Origin$fSemigroupQ1Origin$fNFDataQωOrigin$fKillRangeQωOrigin$fSetRangeQωOrigin$fHasRangeQωOrigin$fNullQωOrigin$fMonoidQωOrigin$fSemigroupQωOrigin$fNFDataQuantity$fKillRangeQuantity$fSetRangeQuantity$fHasRangeQuantity$fLeftClosedPOMonoidQuantity$fPOMonoidQuantity$fPOSemigroupQuantity$fPartialOrdQuantity$fMonoidQuantity$fSemigroupQuantity$fLeftClosedPOMonoidRelevance$fPOMonoidRelevance$fPOSemigroupRelevance$fMonoidRelevance$fSemigroupRelevance$fPartialOrdRelevance$fOrdRelevance$fNFDataRelevance$fKillRangeRelevance$fSetRangeRelevance$fHasRangeRelevance$fLeftClosedPOMonoidCohesion$fPOMonoidCohesion$fPOSemigroupCohesion$fMonoidCohesion$fSemigroupCohesion$fPartialOrdCohesion $fOrdCohesion$fNFDataCohesion$fKillRangeCohesion$fSetRangeCohesion$fHasRangeCohesion$fNFDataModality$fKillRangeModality$fLeftClosedPOMonoidModality$fPOMonoidModality$fPOSemigroupModality$fPartialOrdModality$fMonoidModality$fSemigroupModality$fNFDataOrigin$fKillRangeOrigin$fNFDataWithOrigin$fKillRangeWithOrigin$fSetRangeWithOrigin$fHasRangeWithOrigin$fPrettyWithOrigin$fDecorationWithOrigin$fNFDataFreeVariables$fMonoidFreeVariables$fSemigroupFreeVariables$fNFDataArgInfo$fKillRangeArgInfo$fLensArgInfoArgInfo$fLensFreeVariablesArgInfo $fLensFreeVariablesFreeVariables$fLensOriginArgInfo$fLensOriginWithOrigin$fLensOriginOrigin$fLensModalityArgInfo$fLensModalityModality$fLensCohesionArgInfo$fLensCohesionCohesion$fLensCohesionModality$fLensRelevanceArgInfo$fLensRelevanceRelevance$fLensRelevanceModality$fLensQuantityArgInfo$fLensQuantityQuantity$fLensQuantityModality$fLensHidingArgInfo$fLensHidingWithHiding$fLensHidingHiding$fLensCohesionArg$fLensQuantityArg$fLensRelevanceArg$fLensFreeVariablesArg$fLensOriginArg$fLensModalityArg$fLensHidingArg$fLensArgInfoArg $fNFDataArg$fKillRangeArg $fSetRangeArg $fHasRangeArg$fDecorationArg$fUnderscoreDoc$fUnderscoreByteString$fUnderscore[] $fNFDataNamed$fKillRangeNamed$fSetRangeNamed$fHasRangeNamed$fDecorationNamed$fLensNamednameNamed$fLensNamednameMaybe$fLensNamednameArg$fNFDataRanged$fDecorationRanged$fKillRangeRanged$fHasRangeRanged $fOrdRanged $fEqRanged$fPrettyRanged$fKillRangeConOrigin$fKillRangeProjOrigin$fKillRangeAccess$fHasRangeAccess$fNFDataAccess$fPrettyAccess$fKillRangeIsAbstract$fMonoidIsAbstract$fSemigroupIsAbstract$fLensIsAbstractIsAbstract$fAnyIsAbstractMaybe$fAnyIsAbstract[]$fAnyIsAbstractIsAbstract$fNFDataIsInstance$fHasRangeIsInstance$fKillRangeIsInstance$fHasRangeIsMacro$fKillRangeIsMacro$fHashableNameId$fNFDataNameId $fEnumNameId$fPrettyNameId$fKillRangeNameId$fHashableMetaId$fNFDataMetaId $fShowMetaId$fPrettyMetaId$fNFDataMaybePlaceholder$fKillRangeMaybePlaceholder$fHasRangeMaybePlaceholder$fKillRangeInteractionId$fPrettyInteractionId$fNullFixityLevel$fNFDataFixity$fKillRangeFixity$fHasRangeFixity $fNullFixity $fOrdFixity $fEqFixity$fLensFixityFixity$fNFDataImportedName'$fKillRangeImportedName'$fHasRangeImportedName'$fNFDataUsing'$fKillRangeUsing'$fHasRangeUsing' $fNullUsing'$fMonoidUsing'$fSemigroupUsing'$fNFDataRenaming'$fKillRangeRenaming'$fHasRangeRenaming'$fNFDataImportDirective'$fKillRangeImportDirective'$fHasRangeImportDirective'$fNullImportDirective'$fNFDataTerminationCheck$fKillRangeTerminationCheck$fMonoidPositivityCheck$fSemigroupPositivityCheck$fKillRangePositivityCheck$fKillRangeUniverseCheck$fMonoidCoverageCheck$fSemigroupCoverageCheck$fKillRangeCoverageCheck$fKillRangeRewriteEqn'$fHasRangeRewriteEqn'$fPrettyRewriteEqn'$fNFDataRewriteEqn'$fNFDataExpandedEllipsis$fKillRangeExpandedEllipsis$fNullExpandedEllipsis$fNFDataGenPart$fKillRangeGenPart$fSetRangeGenPart$fHasRangeGenPart $fOrdGenPart $fEqGenPart$fLensFixityFixity'$fKillRangeFixity'$fNFDataFixity' $fNullFixity' $fEqFixity'$fLensFixity'Fixity' $fDataDelayed $fShowDelayed $fEqDelayed $fOrdDelayed$fDataFileType $fEqFileType $fOrdFileType$fShowFileType $fDataHasEta $fShowHasEta $fEqHasEta $fOrdHasEta$fDataInduction $fEqInduction$fOrdInduction$fShowInduction$fDataOverlappable$fShowOverlappable$fEqOverlappable$fOrdOverlappable $fDataHiding $fShowHiding $fEqHiding $fOrdHiding$fDataWithHiding$fEqWithHiding$fOrdWithHiding$fShowWithHiding$fFunctorWithHiding$fFoldableWithHiding$fTraversableWithHiding$fDataQ0Origin$fShowQ0Origin$fGenericQ0Origin $fEqQ0Origin $fOrdQ0Origin$fDataQ1Origin$fShowQ1Origin$fGenericQ1Origin $fEqQ1Origin $fOrdQ1Origin$fDataQωOrigin$fShowQωOrigin$fGenericQωOrigin $fEqQωOrigin$fOrdQωOrigin$fDataQuantity$fShowQuantity$fGenericQuantity $fEqQuantity $fOrdQuantity$fDataRelevance$fShowRelevance $fEqRelevance$fEnumRelevance$fBoundedRelevance$fGenericRelevance$fDataCohesion$fShowCohesion $fEqCohesion$fEnumCohesion$fBoundedCohesion$fGenericCohesion$fDataModality $fEqModality $fOrdModality$fShowModality$fGenericModality $fDataOrigin $fShowOrigin $fEqOrigin $fOrdOrigin$fDataWithOrigin$fEqWithOrigin$fOrdWithOrigin$fShowWithOrigin$fFunctorWithOrigin$fFoldableWithOrigin$fTraversableWithOrigin$fDataFreeVariables$fEqFreeVariables$fOrdFreeVariables$fShowFreeVariables $fDataArgInfo $fEqArgInfo $fOrdArgInfo $fShowArgInfo $fDataArg$fEqArg$fOrdArg $fShowArg $fFunctorArg $fFoldableArg$fTraversableArg $fEqNamed $fOrdNamed $fShowNamed $fDataNamed$fFunctorNamed$fFoldableNamed$fTraversableNamed $fDataRanged $fShowRanged$fFunctorRanged$fFoldableRanged$fTraversableRanged$fDataConOrigin$fShowConOrigin $fEqConOrigin$fOrdConOrigin$fEnumConOrigin$fBoundedConOrigin$fDataProjOrigin$fShowProjOrigin$fEqProjOrigin$fOrdProjOrigin$fEnumProjOrigin$fBoundedProjOrigin$fDataDataOrRecord$fEqDataOrRecord$fOrdDataOrRecord$fShowDataOrRecord $fDataIsInfix $fShowIsInfix $fEqIsInfix $fOrdIsInfix $fDataAccess $fShowAccess $fEqAccess $fOrdAccess$fDataIsAbstract$fShowIsAbstract$fEqIsAbstract$fOrdIsAbstract$fDataIsInstance$fShowIsInstance$fEqIsInstance$fOrdIsInstance $fDataIsMacro $fShowIsMacro $fEqIsMacro $fOrdIsMacro $fEqNameId $fOrdNameId $fDataNameId$fGenericNameId $fShowNameId $fEqMetaId $fOrdMetaId $fNumMetaId $fRealMetaId $fEnumMetaId$fIntegralMetaId $fDataMetaId$fGenericMetaId$fShowPositionInName$fEqPositionInName$fOrdPositionInName$fDataPositionInName$fDataMaybePlaceholder$fEqMaybePlaceholder$fOrdMaybePlaceholder$fFunctorMaybePlaceholder$fFoldableMaybePlaceholder$fTraversableMaybePlaceholder$fShowMaybePlaceholder$fEqInteractionId$fOrdInteractionId$fShowInteractionId$fNumInteractionId$fIntegralInteractionId$fRealInteractionId$fEnumInteractionId$fDataInteractionId$fEqFixityLevel$fOrdFixityLevel$fShowFixityLevel$fDataFixityLevel$fEqAssociativity$fOrdAssociativity$fShowAssociativity$fDataAssociativity $fDataFixity $fShowFixity$fDataImportedName'$fEqImportedName'$fOrdImportedName'$fShowImportedName' $fDataUsing' $fEqUsing'$fDataRenaming' $fEqRenaming'$fDataImportDirective'$fEqImportDirective'$fDataTerminationCheck$fShowTerminationCheck$fEqTerminationCheck$fFunctorTerminationCheck$fEqPositivityCheck$fOrdPositivityCheck$fShowPositivityCheck$fBoundedPositivityCheck$fEnumPositivityCheck$fDataPositivityCheck$fEqUniverseCheck$fOrdUniverseCheck$fShowUniverseCheck$fBoundedUniverseCheck$fEnumUniverseCheck$fDataUniverseCheck$fEqCoverageCheck$fOrdCoverageCheck$fShowCoverageCheck$fBoundedCoverageCheck$fEnumCoverageCheck$fDataCoverageCheck$fDataRewriteEqn'$fEqRewriteEqn'$fShowRewriteEqn'$fFunctorRewriteEqn'$fFoldableRewriteEqn'$fTraversableRewriteEqn'$fDataExpandedEllipsis$fShowExpandedEllipsis$fEqExpandedEllipsis $fDataGenPart $fShowGenPart $fDataFixity' $fShowFixity' ProcessorLayersLayer layerRoleinterval layerContent LayerRoleMarkupCommentCode atomizeLayersliterateSrcFileliterateProcessorsisCode isCodeLayer illiterateliterateExtsShortList literateTeX literateMd literateRsT literateOrg$fHasRangeLayer$fShowLayerRole $fEqLayerRole $fShowLayer PrecedenceKeyMemoKeyNodeK PostLeftsK PreRightsKTopKAppKNonfixK$fHashableMemoKey $fEqMemoKey $fShowMemoKey$fGenericMemoKeyIsNoNameisNoName LensInScope lensInScope isInScope mapInScope setInScope setNotInScope NameInScopeInScope NotInScopeNumHolesnumHolesTopLevelModuleNamemoduleNameRangemoduleNamePartsNamePartHoleIdNoName nameRange nameInScope nameNamePartsnameId isOpenMixfix nameToRawName namePartsnameStringPartsstringNameParts isOperatorisHoleisPrefix isPostfixisInfixisNonfixnextStrnextNamefirstNonTakenNamenameRootsameRootqualify unqualify qnameParts isQualified isUnqualifiedtoTopLevelModuleNamemoduleNameToFileName projectRootnoName_noName$fNFDataNamePart$fPrettyNamePart$fShowNamePart $fOrdNamePart $fEqNamePart$fKillRangeTopLevelModuleName$fSetRangeTopLevelModuleName$fHasRangeTopLevelModuleName$fPrettyTopLevelModuleName$fSizedTopLevelModuleName$fOrdTopLevelModuleName$fEqTopLevelModuleName $fNumHoles[]$fNFDataNameInScope $fNFDataName$fKillRangeName$fSetRangeName$fHasRangeName $fPrettyName $fShowName$fNumHolesName $fOrdName$fUnderscoreName $fNFDataQName$fKillRangeQName$fSetRangeQName$fHasRangeQName $fPrettyQName $fShowQName$fNumHolesQName$fUnderscoreQName$fLensInScopeQName$fLensInScopeName$fLensInScopeNameInScope$fIsNoNameWithOrigin$fIsNoNameRanged$fIsNoNameQName$fIsNoNameName$fIsNoNameByteString $fIsNoName[]$fDataNamePart$fGenericNamePart$fShowTopLevelModuleName$fDataTopLevelModuleName$fEqNameInScope$fShowNameInScope$fDataNameInScope $fDataName $fDataQName $fOrdQName ProblemId Comparison BackendNameModuleToSourceTCMTCMTunTCMTCStateTCEnvHighlightingLevelHighlightingMethod NamedMeta TCWarningTCErrWarningGlobalsglobalsUsesusesmodNameexports postscriptExportexpNamedefnMemberIdGlobalIdLocalIdSelfLocalGlobal UndefinedIntegerDoubleObjectApplyLookupBinOpPreOpPlainJS $fUsesExport $fUsesExp $fUsesMap$fUses[]$fGlobalsModule$fGlobalsExport $fGlobalsExp $fGlobalsMap $fGlobals[] $fEqLocalId $fOrdLocalId $fShowLocalId $fEqGlobalId $fOrdGlobalId$fShowGlobalId $fEqMemberId $fOrdMemberId$fShowMemberId $fShowExp $fShowExport $fShowModuleshift shiftFromshifter substitutermap'subst'applyselffix curriedApply curriedLambdaempvineobjectPrettiesprettiesbrunescape unescapesblockblock'modname variableNameisValidJSIdent$fPrettyModule$fPrettyMemberId$fPrettyGlobalId$fPrettyLocalId $fPretty(,) $fPrettyExp $fPrettiesMap $fPretties[] renameOffsetFreeVarsfreeVarsOffset Weakeningweak' ExpandMetas expandMetas MetaliseOKH metaliseOKHEECtxCActionSubSkipWeakTrBrCExpClosICExp ICArgListCALNil CALConcat HNArgListHNALNilHNALCons HNALConParHNExp'HNAppHNLamHNPiHNSortHNExp WithSeenUIdsseenUIdsrawValueMArgListArgListALNilALConsALProjALConParMExpLamPiSort AbsurdLambdaappUIdappOKappHeadappElimsSet UnknownSortElrConstRef PatConAppPatVarPatExpClauseDeclContDefDatatype Constructor PostulateConstDefcdnamecdorigincdtypecdcont cddeffreevarsAbsMIdNoIdMyMBMyPBRefInfoRIEnv RIMainInfo RIUnifInfo RICopyInfo RIIotaStepRIInferredTypeUnknownRINotConstructor RIUsedVars RIPickSubsvar RIEqRState RICheckElimRICheckProjIndexrieHintsrieDefFreeVarsrieEqReasoningConstsriMainCxtLength riMainType riMainIotaEqReasoningStateEqRSNone EqRSChainEqRSPrf1EqRSPrf2EqRSPrf3EqReasoningConstseqrcId eqrcBegineqrcStepeqrcEndeqrcSymeqrcCongHintModeHMNormal HMRecCallUIdgetVargetConstdontCaredetecteliminanddetectsemiflexcategorizedecl metaliseokhaddtrailingargsclosifysubsubiweakdoclosfreeVarsrename$fMetaliseOKHArgList$fMetaliseOKHExp$fMetaliseOKHAbs$fMetaliseOKHMM$fExpandMetasArgList$fExpandMetasExp$fExpandMetasAbs$fExpandMetasMM$fWeakeningElr$fWeakeningICArgList$fWeakeningClos$fWeakeningTrBr$fFreeVarsArgList $fFreeVarsExp $fFreeVarsElr $fFreeVarsAbs $fFreeVarsMM $fFreeVars(,)$fRenamingArgList $fRenamingExp $fRenamingElr $fRenamingAbs $fRenamingMM $fRenaming(,)$fEqEqReasoningState$fShowEqReasoningState$fEqElr ExpRefInfoeriMaineriUnifseriInfTypeUnknowneriIsEliminand eriUsedVars eriIotaSteperiPickSubsVar eriEqRStateinitExpRefInfogetinfounivarsubsvarsnewAbsnewLamnewPifoldArgsnewArgs'newArgsnewApp'newAppeqStepeqEndeqCongeqSym eqBeginStep2pickUidextrarefcostUnificationIf 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$fRefinableArgListRefInfo$fRefinableExpRefInfoCMFlexCMFFlexCMFSemi CMFBlockedCModeCMRigidPEvalPENoPEConAppHNResHNDoneHNMetaHNNBlkstcExp getDatatypeconstructorImpossibleunequalsunequal traversePitcargsaddendcopyargnoblksaddblkhnnhnn_blks hnn_checkstephnn'hnbhnc hnarglistgetNArgs getAllArgsiotastep noiotastepnoiotastep_termcomp'checkeliminandmaybeor iotapossmetameta_not_constructor calcEqRStatepickidtcSearchLocalTerminationEnvsizeAndBoundVarsLiftlift'Unifyunify' notequal' AssignmentsReplacereplace'SolCSPatI CSPatConAppCSPatVarCSPatExpCSWithCSAbsurd CSOmittedArgCSCtxCSPatHI abspatvarnamecostCaseSplitVeryHighcostCaseSplitHighcostCaseSplitLowcostAddVarDepthdrophidcaseSplitSearchcaseSplitSearch' infertypevarreplace betareduce concatargsreplacepunifynotequalunifyVarunifyexplift removevarfindpermfreevars applypermrenseqctx depthofvarlocalTerminationEnvlocalTerminationSidecondgetblks $fRenamingHI$fRenamingCSPatI$fReplaceoArgListArgList $fReplaceoMMu$fReplaceoExpMM$fReplaceoAbsAbs$fUnifyoArgList $fUnifyoExp $fUnifyoAbs $fUnifyoMM $fLiftArgList $fLiftExp$fLiftMM $fLiftAbs$fLocalTerminationEnvMM$fLocalTerminationEnv(,)$fLocalTerminationEnvMM0$fLocalTerminationEnv[]$fLocalTerminationEnvCSPatI$fLocalTerminationEnvHIRangesfromtorangesInvariant overlappingrangeToPositionsrangesToPositionsrToRrangeToEndPointsminus $fEqRange $fOrdRange $fShowRange $fEqRanges $fShowRanges ParseResultParseOk ParseFailed ParseWarningOverlappingTokensWarning warnRange ParseErrorOverlappingTokensErrorInvalidExtensionError ReadFileError errSrcFileerrPoserrInput errPrevTokenerrMsgerrRangeerrPath errValidExts errIOError ParseFlagsparseKeepComments LayoutContextNoLayoutLayoutLexState ParseStatePState parseSrcFileparsePos parseLastPosparseInp parsePrevCharparsePrevToken parseLayout parseLexState parseFlagsparseWarningName parseError initStatedefaultParseFlagsparsePosString parseFromSrc setParsePos setLastPos setPrevTokengetParseInterval getLexState pushLexState popLexState getParseFlags parseErrorAt parseError'parseErrorRangelexError topContext popContext pushContextpushCurrentContext$fHasRangeParseError$fPrettyParseError$fShowParseError$fHasRangeParseWarning$fPrettyParseWarning$fShowParseWarning$fShowLayoutContext$fShowParseFlags$fShowParseState$fMonadStateParser$fMonadErrorParser$fDataParseWarning$fShowParseResultMkNamemkNamemkName_IsProjPisProjPAmbiguousQNameAmbQunAmbQMName mnameToListQNamedqnameqnamed qnameModule qnameName nameConcretenameBindingSite nameFixitynameIsRecordName uglyShowName unambiguousheadAmbQ isAmbiguousgetUnambiguousisAnonymousModuleName withRangesOf withRangesOfQ mnameFromList noModuleNamecommonParentModule qnameToList qnameFromList qnameToMName mnameToQName showQNameIdqnameToConcretemnameToConcretequalifyMqualifyQqualify_isLeParentModuleOfisLtParentModuleOfisLeChildModuleOfisLtChildModuleOf isInModule lensQNameName nameToArgName namedArgName$fLensFixityName$fLensFixity'Name$fHashableName$fNFDataModuleName$fSizedModuleName$fKillRangeModuleName$fSetRangeModuleName$fHasRangeModuleName$fPrettyModuleName$fShowModuleName $fSizedQName$fLensFixityQName$fLensFixity'QName$fHashableQName$fPrettyQNamed$fKillRangeAmbiguousQName$fHasRangeAmbiguousQName$fPrettyAmbiguousQName$fNumHolesAmbiguousQName $fIsProjPVoid$fIsProjPNamed $fIsProjPArg $fMkName[]$fDataModuleName$fFunctorQNamed$fFoldableQNamed$fTraversableQNamed$fEqAmbiguousQName$fOrdAmbiguousQName$fDataAmbiguousQName$fShowAmbiguousQName $fShowQNamedNotationSection sectNotationsectKind sectLevel sectIsSection NewNotationnotaName notaNames notaFixitynotationnotaIsOperator NotationKind InfixNotationPrefixNotationPostfixNotationNonfixNotation NoNotationHoleName LambdaHoleExprHole _bindHoleNameholeName isLambdaHole stringParts holeTargetisAHole isNormalHole isBindingHole notationKind mkNotationnamesToNotationuseDefaultFixity notationNamessyntaxOfmergeNotations _notaFixity noSection$fLensFixityNewNotation$fEqNotationKind$fShowNotationKind$fShowNewNotation$fShowNotationSectionPrecedenceStack PrecedenceTopCtxFunctionSpaceDomainCtxLeftOperandCtxRightOperandCtx FunctionCtx ArgumentCtxInsideOperandCtx WithFunCtx WithArgCtx DotPatternCtxParenPreference PreferParenPreferParenlessThingWithFixity preferParenpreferParenlesspushPrecedenceheadPrecedence argumentCtx_ opBrackets opBrackets' lamBrackets appBrackets appBrackets'withAppBrackets piBracketsroundFixBrackets$fKillRangeThingWithFixity$fLensFixityThingWithFixity$fLensFixity'ThingWithFixity$fPrettyPrecedence$fFunctorThingWithFixity$fFoldableThingWithFixity$fTraversableThingWithFixity$fDataThingWithFixity$fShowThingWithFixity$fEqParenPreference$fOrdParenPreference$fShowParenPreference$fDataParenPreference$fShowPrecedence$fDataPrecedence$fEqPrecedenceLitNat LitWord64LitFloat LitStringLitCharLitQNameLitMeta showString' showChar' compareFloat$fNFDataLiteral$fKillRangeLiteral$fSetRangeLiteral$fHasRangeLiteral $fOrdLiteral$fPrettyLiteral $fShowLiteral $fDataLiteral isUnreachableTError TUnreachableTAltTAConTAGuardTALitaConaArityaBodyaGuardaLitCaseInfocaseLazycaseTypeCaseTypeCTDataCTNatCTIntCTCharCTStringCTFloatCTQNameTPrimPAddPAdd64PSubPSub64PMulPMul64PQuotPQuot64PRemPRem64PGeqPLtPLt64PEqIPEq64PEqFPEqSPEqCPEqQPIfPSeqPITo64P64ToITTermTVarTDefTAppTLamTLitTConTLetTCaseTUnitTSortTErasedTCoerceArgsEvaluationStrategyLazyEvaluationEagerEvaluationCompiled cTreeless cArgUsageTPFnTPOpisPrimEq coerceViewmkTApptAppView coerceAppViewtLetViewtLamViewmkTLammkLettIntintView word64ViewtPlusK tNegPlusK plusKView negPlusKViewtOp tUnreachable tIfThenElse$fKillRangeCompiled$fUnreachableTTerm$fUnreachableTAlt$fEqEvaluationStrategy$fShowEvaluationStrategy $fDataTPrim $fShowTPrim $fEqTPrim $fOrdTPrim$fDataCaseType$fShowCaseType $fEqCaseType $fOrdCaseType$fDataCaseInfo$fShowCaseInfo $fEqCaseInfo $fOrdCaseInfo $fDataTError $fShowTError $fEqTError $fOrdTError $fDataTTerm $fShowTTerm $fEqTTerm $fOrdTTerm $fDataTAlt $fShowTAlt$fEqTAlt $fOrdTAlt$fDataCompiled$fShowCompiled $fEqCompiled $fOrdCompiled convertGuardsrecoverAsPatterns $fShowAsPatToken TokKeywordTokIdTokQId TokLiteral TokSymbol TokStringTokSetNTokPropNTokTeX TokMarkup TokCommentTokDummyTokEOFSymDotSymSemiSymVirtualSemiSymBarSymColonSymArrowSymEqual SymLambda SymUnderscoreSymQuestionMarkSymAs SymOpenParen SymCloseParenSymOpenIdiomBracketSymCloseIdiomBracketSymEmptyIdiomBracketSymDoubleOpenBraceSymDoubleCloseBrace SymOpenBrace SymCloseBraceSymOpenVirtualBraceSymCloseVirtualBrace SymOpenPragmaSymClosePragma SymEllipsis SymDotDot SymEndCommentKeywordKwLetKwInKwWhereKwDataKwCoDataKwDo KwPostulateKwMutual KwAbstract KwPrivate KwInstance KwOverlapKwOpenKwImportKwModule KwPrimitiveKwMacroKwInfixKwInfixLKwInfixRKwWith KwRewriteKwSetKwPropKwForallKwRecord KwConstructorKwField KwInductive KwCoInductiveKwEtaKwNoEtaKwHidingKwUsing KwRenamingKwToKwPublic KwOPTIONS KwBUILTINKwLINE KwFOREIGN KwCOMPILE KwIMPOSSIBLEKwSTATIC KwINJECTIVEKwINLINE KwNOINLINEKwETAKwNO_TERMINATION_CHECK KwTERMINATINGKwNON_TERMINATINGKwNON_COVERINGKwWARNING_ON_USAGEKwWARNING_ON_IMPORT KwMEASURE KwDISPLAY KwREWRITEKwQuote KwQuoteTerm KwUnquote KwUnquoteDecl KwUnquoteDefKwSyntax KwPatternSynKwTactic KwCATCHALL KwVariableKwNO_POSITIVITY_CHECK KwPOLARITYKwNO_UNIVERSE_CHECKlayoutKeywords$fHasRangeToken $fEqKeyword $fShowKeyword $fEqSymbol $fShowSymbolBackend lookupBackendactiveBackendMayEraseTypebuiltinBackends LineNumber LibWarning' UnknownFieldrunP parseLibFiletrimLineComment splitCommas$fShowLibWarning'$fDataLibWarning'$fShowGenericLineDAGdagGraphdagComponentMap dagNodeMapNodessrcNodestgtNodesallNodesEdgesourcetargetlabelGraphgraphedges neighbours neighboursMap edgesFromedgesTodiagonalnodes sourceNodes targetNodes computeNodes isolatedNodesdiscreteacyclic fromNodes fromNodeSet fromEdges fromEdgesWith insertEdgeinsertEdgeWith unionsWith mapWithEdge transposeEdge transposeclean removeNodes removeNode removeEdge filterEdgesunzip composeWithsccs'sccs dagInvariant oppositeDAG reachablesccDAG'sccDAG reachableFromreachableFromSetwalkSatisfyingcomplete completeIter1gaussJordanFloydWarshallMcNaughtonYamadaReference(gaussJordanFloydWarshallMcNaughtonYamadatransitiveClosure $fShowGraph $fPrettyGraph$fFunctorGraph $fPrettyEdge $fEqGraph$fEqEdge $fOrdEdge $fFunctorEdge $fShowEdgetopSortBounds 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 iterateSolver testSuccstestLub$fPlusSizeExpr'WeightSizeExpr'$fPlusOffsetWeightWeight $fDioidWeight$fPlusWeightOffsetWeight $fNumWeight $fEnumWeight $fTopWeight$fMeetSemiLatticeWeight $fOrdWeight$fPrettyWeight$fNegativeWeight$fNegativeOffset $fNegativeInt$fPlusSizeExpr'LabelSizeExpr' $fDioidLabel $fTopLabel$fMeetSemiLatticeLabel $fPrettyLabel $fOrdLabel $fEqLabel$fNegativeLabel $fPrettyNode $fDioidEdge $fTopEdge$fMeetSemiLatticeEdge$fNegativeEdge$fNegativeGraph $fNegative[]$fSetToInftyfGraph$fSetToInftyfEdge$fSetToInftyfNode $fEqWeight $fShowWeight $fShowLabel $fShowNode$fEqNode $fOrdNode OccurrenceMixedJustNegJustPos StrictPosGuardPosUnusedWhere LeftOfArrowDefArgUnderInfVarArgMetaArg ConArgType IndArgTypeInClauseMatchedIsIndexInDefOf OccursWhereboundToEverySomeproductOfEdgesInBoundedWalk $fPrettyWhere$fSizedOccursWhere$fPrettyOccursWhere$fNullOccurrence$fStarSemiRingOccurrence$fSemiRingOccurrence$fKillRangeOccurrence$fNFDataOccurrence$fPrettyOccurrence $fShowWhere $fEqWhere $fOrdWhere $fDataWhere$fShowOccursWhere$fEqOccursWhere$fOrdOccursWhere$fDataOccursWhere$fDataOccurrence$fShowOccurrence$fEqOccurrence$fOrdOccurrence$fEnumOccurrence$fBoundedOccurrenceAppView HoleContent HoleContent'HoleContentExprHoleContentRewritePragma OptionsPragma BuiltinPragma RewritePragma ForeignPragma CompilePragma StaticPragma InlinePragmaImpossiblePragma EtaPragmaWarningOnUsageWarningOnImportInjectivePragma DisplayPragmaCatchallPragmaTerminationCheckPragmaNoCoverageCheckPragmaNoPositivityCheckPragmaPolarityPragmaNoUniverseCheckPragma OpenShortHandDoOpenDontOpenModuleApplication SectionAppRecordModuleInstance DeclarationFieldSig GeneralizeField FunClauseDataSigDataDef RecordSig RecordDefInfix PatternSynMutualPrivate InstanceBMacro PrimitiveOpenImport ModuleMacro UnquoteDecl UnquoteDefTypeSignatureOrInstanceBlock TypeSignatureAsNameAsName'asNameasRange ExprWhere LamClauselamLHSlamRHSlamWhere lamCatchAll WhereClause'NoWhereAnyWhere SomeWhere WhereClauseRHS' AbsurdRHSRHSLHSCoreLHSHeadLHSProjLHSWith lhsDefNamelhsPats lhsDestructor lhsPatsLeftlhsFocuslhsHeadlhsWithPatternsWithExpr RewriteEqnlhsOriginalPattern lhsRewriteEqn lhsWithExprlhsExpandedEllipsis Telescope TypedBinding'TBind TypedBindingTacticAttribute BoundNameBName boundName bnameFixity bnameTactic LamBinding' DomainFree DomainFull LamBindingBinderBinder' binderPattern binderNameDoStmtDoBindDoThenDoLetPatternIdentPQuotePAppPRawAppPOpAppPHiddenP InstancePParenPWildPAbsurdPAsPDotPLitPRecPEqualP EllipsisPWithPExpr QuestionMarkRawAppOpAppWithApp HiddenArg InstanceArg AbsurdLam ExtendedLamFunSetNPropNRec RecUpdateParen IdiomBracketsDoBlockAbsurdAsDot DoubleDotETelQuote QuoteTermTacticUnquoteDontCareEqualEllipsis GeneralizedRecordAssignmentsRecordAssignmentModuleAssignment _qnameModA _exprModA_importDirModAFieldAssignmentFieldAssignment' _nameFieldA _exprFieldASyntaxBindingLambdaOrdinary fromOrdinary nameFieldA exprFieldA mkBinder_mkBinder mkBoundName_ mkBoundName countTelVarslamBindingsToTelescopemakePitopLevelModuleNamespanAllowedBeforeModuleappViewisSingleIdentifierPremoveSingletonRawAppP observeHiding isPattern isAbsurdP isBinderP$fNFDataFieldAssignment'$fKillRangeFieldAssignment'$fHasRangeFieldAssignment' $fNFDataRHS'$fNFDataWhereClause'$fNullWhereClause'$fNFDataDoStmt$fNFDataBoundName$fNFDataBinder'$fNFDataLamBinding'$fNFDataLamClause$fNFDataModuleAssignment $fNFDataLHS $fNFDataOpApp$fNFDataModuleApplication$fNFDataTypedBinding'$fNFDataAsName'$fNFDataPragma$fNFDataDeclaration$fNFDataPattern $fNFDataExpr$fKillRangeWhereClause'$fKillRangeTypedBinding'$fKillRangeRHS'$fKillRangePragma$fKillRangePattern$fKillRangeOpApp$fKillRangeModuleApplication$fKillRangeDoStmt$fKillRangeLamClause$fKillRangeLHS$fKillRangeLamBinding'$fKillRangeExpr$fKillRangeDeclaration$fKillRangeBoundName$fKillRangeBinder'$fKillRangeAsName'$fKillRangeModuleAssignment$fSetRangeTypedBinding'$fSetRangePattern$fHasRangePattern$fHasRangeAsName'$fHasRangePragma$fHasRangeDoStmt$fHasRangeLamClause$fHasRangeRHS' $fHasRangeLHS$fHasRangeDeclaration$fHasRangeModuleAssignment$fHasRangeModuleApplication$fHasRangeWhereClause'$fHasRangeBoundName$fHasRangeLamBinding'$fHasRangeTypedBinding'$fHasRangeBinder'$fHasRangeExpr$fHasRangeOpApp$fLensRelevanceTypedBinding'$fLensHidingTypedBinding'$fLensHidingLamBinding'$fHasRangeLHSCore$fDataFieldAssignment'$fFunctorFieldAssignment'$fFoldableFieldAssignment'$fTraversableFieldAssignment'$fShowFieldAssignment'$fEqFieldAssignment' $fDataRHS' $fFunctorRHS'$fFoldableRHS'$fTraversableRHS'$fEqRHS'$fDataWhereClause'$fFunctorWhereClause'$fFoldableWhereClause'$fTraversableWhereClause'$fEqWhereClause' $fDataAsName' $fShowAsName'$fFunctorAsName'$fFoldableAsName'$fTraversableAsName' $fEqAsName'$fDataOpenShortHand$fEqOpenShortHand$fShowOpenShortHand $fDataPragma $fEqPragma $fDataPattern $fEqPattern $fDataExpr$fEqExpr$fDataDeclaration$fEqDeclaration$fDataModuleApplication$fEqModuleApplication$fDataTypedBinding'$fFunctorTypedBinding'$fFoldableTypedBinding'$fTraversableTypedBinding'$fEqTypedBinding'$fDataBoundName $fEqBoundName $fDataBinder' $fEqBinder'$fFunctorBinder'$fFoldableBinder'$fTraversableBinder' $fDataLHS$fEqLHS$fDataLamBinding'$fFunctorLamBinding'$fFoldableLamBinding'$fTraversableLamBinding'$fEqLamBinding'$fDataLamClause $fEqLamClause $fDataDoStmt $fEqDoStmt$fDataModuleAssignment$fEqModuleAssignment $fDataOpApp$fFunctorOpApp$fFoldableOpApp$fTraversableOpApp $fEqOpApp $fDataLHSCore $fEqLHSCore$fFunctorHoleContent'$fFoldableHoleContent'$fTraversableHoleContent'Tel NamedBinding withHiding namedBindingSpecialCharacters_dbraces_lambda_arrow_forallQ_leftIdiomBrkt_rightIdiomBrkt_emptyIdiomBrktspecialCharactersbraces'dbracesforallQ leftIdiomBrktrightIdiomBrktemptyIdiomBrktbracesAndSemicolonsarrowlambda prettyHidingprettyRelevanceprettyQuantityprettyCohesion prettyTactic prettyTactic' isLabeledsmashTelpRecord prettyOpApp$fPrettyImportedName'$fPrettyRenaming'$fPrettyUsing'$fPrettyImportDirective'$fPrettyPattern $fPrettyNamed $fPrettyArg$fPrettyFixity'$fPrettyGenPart$fPrettyFixity$fPrettyPragma$fPrettyOpenShortHand$fPrettyDeclaration$fPrettyDoStmt$fPrettyModuleApplication$fPrettyLHSCore $fPrettyLHS$fPrettyWhereClause' $fPrettyRHS'$fPrettyBinder'$fPrettyBoundName$fPrettyLamClause$fPrettyModuleAssignment$fPrettyFieldAssignment'$fPrettyEither$fPrettyMaybePlaceholder $fPrettyOpApp$fPrettyCohesion$fPrettyQuantity$fPrettyQωOrigin$fPrettyQ1Origin$fPrettyQ0Origin$fPrettyRelevance$fPrettyWithHiding$fPrettyThingWithFixity$fPrettyTypedBinding'$fPrettyLamBinding'$fPrettyNamedBinding $fPrettyTel $fPrettyExpr $fShowDoStmt$fShowModuleApplication$fShowWhereClause'$fShowLamClause $fShowLHSCore $fShowLHS $fShowRHS' $fShowPragma$fShowRenaming' $fShowUsing'$fShowImportDirective'$fShowModuleAssignment$fShowBoundName$fShowLamBinding'$fShowTypedBinding' $fShowBinder' $fShowPattern$fShowDeclaration $fShowOpApp $fShowExprSplitTreeLabellblConstructorName lblSplitArglblLazy lblBindingsSplitTagSplitConSplitLit SplitCatchall SplitTrees' LazySplit StrictSplit SplitTree' SplittingDoneSplitAt splitBindingssplitArg splitLazy splitTrees SplitTrees SplitTreetoTreetoTrees$fKillRangeSplitTree'$fPrettySplitTree'$fKillRangeSplitTag$fPrettySplitTag$fPrettySplitTreeLabel$fDataLazySplit$fShowLazySplit $fEqLazySplit$fOrdLazySplit$fDataSplitTree'$fShowSplitTree'$fShowSplitTag $fEqSplitTag $fOrdSplitTag$fDataSplitTagPhaseParsingDeserializationScopingTyping Termination Positivity InjectivityProjectionLikenessCoverage Highlighting SerializationDeadCodeRecCheckReduceLevelCompareWith CompactionBuildInterface BinaryEncodeCompress OperatorsExprOperatorsPatternFree OccursCheckCheckLHSCheckRHSInstanceSearch UnifyIndicesInverseScopeLookup TopModule DefinitionisModuleAccount isDefAccountisInternalAccount benchmarksbillToIO billToPure$fMonadBenchPhaseIO $fPrettyPhase $fEqPhase $fOrdPhase $fShowPhase CPatternLike foldrCPatterntraverseCPatternAtraverseCPatternMLHSPatternViewLHSAppPLHSWithPIsWithPisWithP HasEllipsis hasEllipsis IsEllipsis isEllipsislhsPatternView lhsCoreApp lhsCoreWithlhsCoreAddSpinemapLhsOriginalPatternmapLhsOriginalPatternM hasCopatterns foldCPatternpreTraverseCPatternMpostTraverseCPatternM mapCPattern patternQNames patternNameshasWithPatterns isWithPatternnumberOfWithPatterns hasEllipsis'reintroduceEllipsis splitEllipsispatternAppView$fIsEllipsisPattern$fHasEllipsisLHS$fHasEllipsisPattern$fIsWithPNamed $fIsWithPArg$fIsWithPPattern$fCPatternLikeFieldAssignment'$fCPatternLikeMaybe$fCPatternLike[]$fCPatternLikeNamed$fCPatternLikeArg$fCPatternLike(,)$fCPatternLikePatternNKInPrePostNon OperatorType ParseSectionsDoNotParseSectionsIsExprexprView unExprView patternViewExprViewLocalVWildVOtherVAppVOpAppV HiddenArgV InstanceArgVLamVParenV placeholdermaybePlaceholdersatNoPlaceholderpartPatLeastTwoParts patternBinderopPargsPappP$fIsExprPattern $fIsExprExpr$fHasRangeExprView$fEqParseSections$fShowParseSectionsExprLikemapExpr traverseExprfoldExpr$fExprLikeDeclaration$fExprLikeModuleApplication$fExprLikeDoStmt$fExprLikeLamClause$fExprLikeRewriteEqn' $fExprLikeLHS$fExprLikeLamBinding'$fExprLikeOpApp$fExprLikeModuleAssignment$fExprLikeFieldAssignment'$fExprLikeExpr$fExprLike(,,,)$fExprLike(,,) $fExprLike(,)$fExprLikeWhereClause'$fExprLikeRHS'$fExprLikeTypedBinding'$fExprLikeEither$fExprLikeMaybePlaceholder$fExprLikeMaybe $fExprLike[] $fExprLikeArg$fExprLikeNamed$fExprLikeWithHiding$fExprLikeBool$fExprLikeQName$fExprLikeName $fExprLike()DoWarnNoWarnMonadFixityErrorthrowMultipleFixityDeclsthrowMultiplePolarityPragmaswarnUnknownNamesInFixityDecl!warnUnknownNamesInPolarityPragmaswarnUnknownFixityInMixfixDecl#warnPolarityPragmasButNotPostulatesFixitiesfixitiesAndPolarities$fMonoidMonadicFixPol$fSemigroupMonadicFixPol$fMonoidDeclaredNames$fSemigroupDeclaredNames $fEqDoWarn $fShowDoWarn LensAttribute AttributeRelevanceAttributeQuantityAttributeCohesionAttributerelevanceAttributeTablequantityAttributeTablecohesionAttributeTable attributesMapstringToAttributeexprToAttribute setAttribute setAttributessetPristineRelevancesetPristineQuantitysetPristineCohesionsetPristineAttributesetPristineAttributesisRelevanceAttributeisQuantityAttributeisTacticAttributerelevanceAttributesquantityAttributestacticAttributes$fKillRangeAttribute$fSetRangeAttribute$fHasRangeAttribute$fShowAttributeCompressedFilerangesHighlightingInfoFilemapping TokenBasedNotOnlyTokenBasedDefinitionSite defSiteModule defSitePos defSiteHere defSiteAnchorAspectsaspect otherAspectsnotedefinitionSite tokenBased OtherAspect DottedPattern UnsolvedMetaUnsolvedConstraintTerminationProblemPositivityProblemDeadcodeShadowingInTelescopeCoverageProblemIncompletePattern TypeChecksMissingDefinitionCatchallClauseConfluenceProblemNameKind GeneralizableFunctionArgumentAspectNumber PrimitiveType Background parserBasedseveralmerge smallestPostoMapcompressedFileInvariantcompress decompressnoHighlightingInRange singletonCseveralCmergeCsplitAtCselectC smallestPosC$fEqDefinitionSite$fMonoidTokenBased$fSemigroupTokenBased$fMonoidAspects$fSemigroupAspects $fEqAspects $fMonoidFile$fSemigroupFile$fMonoidCompressedFile$fSemigroupCompressedFile $fEqNameKind$fShowNameKind $fEqAspect $fShowAspect$fEqOtherAspect$fOrdOtherAspect$fShowOtherAspect$fEnumOtherAspect$fBoundedOtherAspect$fShowDefinitionSite$fEqTokenBased$fShowTokenBased $fShowAspects$fEqFile $fShowFile$fEqCompressedFile$fShowCompressedFileInteractionOutputCallbackStatus GiveResultRemoveTokenBasedHighlighting DisplayInfoMakeCaseVariantResponseResp_HighlightingInfo Resp_StatusResp_JumpToErrorResp_InteractionPointsResp_GiveAction Resp_MakeCase Resp_SolveAllResp_DisplayInfoResp_RunningInfoResp_ClearRunningInfoResp_ClearHighlightingResp_DoneAbortingResp_DoneExiting defaultInteractionOutputCallback CompareResult Dominates IsDominated dominated notDominated dominator FavoritescompareWithFavoritescompareFavorites unionComparedinsertCompared$fMonoidFavorites$fSemigroupFavorites $fEqFavorites$fFoldableFavorites$fShowFavorites$fNullFavorites$fSingletonFavorites AssocListupdate mapWithKey mapWithKeyMSetBindingSitesetBindingSiteAllowAmbiguousNamesAmbiguousAnythingAmbiguousConProjsAmbiguousNothing UsingOrHiding UsingOnly HidingOnly ResolvedNameVarName DefinedName FieldNameConstructorNamePatternSynResName UnknownName resolvedVarresolvedBindingSourceAbstractModule AbsModuleamodName amodLineage NameMetadata NoMetadataGeneralizedVarsMetadata AbstractNameAbsName anameName anameKind anameLineage anameMetadata WhyInScopeDefinedOpenedApplied KindsOfNamesAllKindsOfNamesSomeKindsOfNamesExceptKindsOfNames KindOfNameConNameFldNamePatternSynNameGeneralizeNameDisallowedGeneralizeName MacroName QuotableNameDataNameRecNameFunName AxiomNamePrimName OtherDefName NameOrModule NameNotModule ModuleNotName inScopeTag InScopeTagNameTag ModuleTag InScopeSetModulesInScope NamesInScope ThingsInScope NameSpacensNames nsModules nsInScopeLocalVarlocalVarlocalBindingSourcelocalShadowedBy BindingSource LambdaBound PatternBoundLetBound LocalVars ModuleMapNameMap ScopeInfo _scopeCurrent _scopeModules_scopeVarsToBind _scopeLocals_scopePrecedence_scopeInverseName_scopeInverseModule _scopeInScope_scopeFixities_scopePolaritiesScopeNameSpaces NameSpaceId PrivateNSPublicNS ImportedNSScope scopeName scopeParentsscopeNameSpaces scopeImportsscopeDatatypeModule allNameSpaceslocalNameSpacenameSpaceAccessscopeNameSpaceupdateScopeNameSpacesupdateScopeNameSpacesM shadowLocalpatternToModuleBoundnotShadowedLocalnotShadowedLocals scopeCurrent scopeModulesscopeVarsToBind scopeLocalsscopePrecedencescopeInverseNamescopeInverseModule scopeInScope scopeFixitiesscopePolaritiesscopeFixitiesAndPolaritiesupdateVarsToBind setVarsToBindupdateScopeLocalssetScopeLocals inNameSpace isDefNameelemKindsOfNamesallKindsOfNamessomeKindsOfNamesexceptKindsOfNames lensAnameName lensAmodName mergeNamesmergeNamesManyemptyNameSpace mapNameSpace zipNameSpace mapNameSpaceM emptyScopeemptyScopeInfomapScope mapScope_ mapScopeNS mapScopeM mapScopeM_zipScope zipScope_recomputeInScopeSets filterScopeallNamesInScopeallNamesInScope'exportedNamesInScope namesInScopeallThingsInScope thingsInScope mergeScope mergeScopessetScopeAccess setNameSpacemodifyNameSpaceaddNameToScoperemoveNameFromScopeaddModuleToScope usingOrHidingapplyImportDirectiveapplyImportDirective_renameCanonicalNamesrestrictPrivaterestrictLocalPrivatedisallowGeneralizedVarsinScopeBecause publicModules publicNameseverythingInScopeeverythingInScopeQualified flattenScopeconcreteNamesInScope scopeLookup scopeLookup' isNameInScopeinverseScopeLookupinverseScopeLookup'recomputeInverseScopeMapsinverseScopeLookupNameinverseScopeLookupName'inverseScopeLookupModuleprettyNameSpace blockOfLines$fPrettyNameSpaceId$fSetRangeAbstractName$fHasRangeAbstractName$fPrettyAbstractName$fLensFixityAbstractName$fOrdAbstractName$fEqAbstractName$fPrettyLocalVar $fOrdLocalVar $fEqLocalVar$fPrettyAbstractModule$fOrdAbstractModule$fEqAbstractModule$fInScopeAbstractModule$fInScopeAbstractName$fPrettyNameSpace $fPrettyScope$fKillRangeScopeInfo$fPrettyScopeInfo $fEqScopeInfo$fPrettyResolvedName$fSetBindingSiteAbstractModule$fSetBindingSiteAbstractName$fSetBindingSiteModuleName$fSetBindingSiteQName$fSetBindingSiteName$fSetBindingSite[]$fDataNameSpaceId$fEqNameSpaceId$fBoundedNameSpaceId$fEnumNameSpaceId$fShowNameSpaceId$fDataBindingSource$fShowBindingSource$fEqBindingSource$fDataNameOrModule$fEqNameOrModule$fOrdNameOrModule$fShowNameOrModule$fEnumNameOrModule$fBoundedNameOrModule$fEqKindOfName$fOrdKindOfName$fShowKindOfName$fDataKindOfName$fEnumKindOfName$fBoundedKindOfName$fDataWhyInScope$fShowWhyInScope$fDataNameMetadata$fShowNameMetadata$fDataAbstractName$fShowAbstractName$fDataLocalVar$fShowLocalVar$fDataAbstractModule$fShowAbstractModule$fDataNameSpace $fEqNameSpace$fShowNameSpace $fDataScope $fEqScope $fShowScope$fDataScopeInfo$fShowScopeInfo$fDataResolvedName$fShowResolvedName$fEqResolvedName$fEqAllowAmbiguousNamesdontDescendIntoinstanceUniverseBiT'instanceTransformBiMT' ConPatLazy ConPatEager ConPatInfo conPatOrigin conPatInfo conPatLazyPatInfoPatRangeLHSInfolhsRange lhsEllipsis MutualInfomutualTerminationCheckmutualCoverageCheckmutualPositivityCheck mutualRangeDeclInfodeclName declRangeDefInfo'DefInfo defFixity defAccess defAbstract defInstancedefMacrodefInfo defTacticLetInfoLetRange ModuleInfo minfoRange minfoAsTo minfoAsNameminfoOpenShortminfoDirectiveAppInfoappRange appOrigin appParensExprInfo ExprRangeMetaInfo metaRange metaScope metaNumbermetaNameSuggestion emptyMetaInfo exprNoRangedefaultAppInfodefaultAppInfo_ mkDefInfomkDefInfoInstance patNoRange$fKillRangeMetaInfo$fHasRangeMetaInfo$fKillRangeExprInfo$fHasRangeExprInfo$fLensOriginAppInfo$fKillRangeAppInfo$fHasRangeAppInfo$fKillRangeModuleInfo$fSetRangeModuleInfo$fHasRangeModuleInfo$fKillRangeLetInfo$fHasRangeLetInfo$fKillRangeDeclInfo$fSetRangeDeclInfo$fHasRangeDeclInfo$fAnyIsAbstractDefInfo'$fLensIsAbstractDefInfo'$fKillRangeDefInfo'$fSetRangeDefInfo'$fHasRangeDefInfo'$fKillRangeMutualInfo$fHasRangeMutualInfo$fNullMutualInfo $fNullLHSInfo$fKillRangeLHSInfo$fHasRangeLHSInfo$fSetRangeConPatInfo$fKillRangeConPatInfo$fHasRangeConPatInfo$fDataMetaInfo$fShowMetaInfo $fEqMetaInfo$fDataExprInfo$fShowExprInfo $fEqExprInfo$fNullExprInfo $fDataAppInfo $fShowAppInfo $fEqAppInfo $fOrdAppInfo$fDataModuleInfo$fEqModuleInfo$fShowModuleInfo $fDataLetInfo $fShowLetInfo $fEqLetInfo $fNullLetInfo$fDataDeclInfo$fShowDeclInfo $fEqDeclInfo$fDataDefInfo'$fShowDefInfo' $fEqDefInfo'$fDataMutualInfo$fShowMutualInfo$fEqMutualInfo $fDataLHSInfo $fShowLHSInfo $fEqLHSInfo $fDataPatInfo $fEqPatInfo $fNullPatInfo $fShowPatInfo$fSetRangePatInfo$fHasRangePatInfo$fKillRangePatInfo$fDataConPatLazy$fEqConPatLazy$fOrdConPatLazy$fShowConPatLazy$fBoundedConPatLazy$fEnumConPatLazy$fDataConPatInfo$fEqConPatInfo$fShowConPatInfoDiagonalMatrixunMMIxrowcolSizerowscolssquaresupSize fromIndexList fromLists toSparseRowstoLists isSingleton zipAssocWith zipMatrices intersectWithinterAssocWith addColumnaddRow $fShowMatrix$fPartialOrdMatrix$fDiagonalMatrixb$fPrettyMatrix$fTransposeMatrix$fTransposeMIx$fTransposeSize$fEqSize $fOrdSize $fShowSize$fEqMIx$fOrdMIx $fShowMIx$fIxMIx $fEqMatrix $fOrdMatrix$fFunctorMatrix$fFoldableMatrix$fTraversableMatrixNotWorsenotWorseOrderDecrUnknownMatincreasedecrease setUsabilitydecrorderMatisOrderleltunknown nonIncreasing decreasingisDecr.*. collapseOsupremuminfimum orderSemiring $fPrettyOrder$fPartialOrdOrder$fHasZeroOrder$fNotWorseMatrix$fNotWorseOrder $fEqOrder $fOrdOrder $fShowOrderCMSetcmSet CallMatrixAug augCallMatrix augCallInfoCallComb>*< CallMatrix CallMatrix'mat ArgumentIndexnoAug$fDiagonalCallMatrix'a$fPrettyCallMatrix'$fCallCombCallMatrix'$fPrettyCallMatrixAug$fCallCombCallMatrixAug$fNotWorseCallMatrixAug$fPartialOrdCallMatrixAug$fDiagonalCallMatrixAugOrder $fPrettyCMSet$fCallCombCMSet$fEqCallMatrix'$fOrdCallMatrix'$fShowCallMatrix'$fFunctorCallMatrix'$fFoldableCallMatrix'$fTraversableCallMatrix'$fPartialOrdCallMatrix'$fEqCallMatrixAug$fShowCallMatrixAug $fShowCMSet$fSemigroupCMSet $fMonoidCMSet $fNullCMSet$fSingletonCMSet$fNotWorseCallMatrix' CallGraph theCallGraphCall callMatrixSetmkCallmkCall'completionStep$fPrettyCallGraph$fMonoidCallGraph$fSemigroupCallGraph$fNullCallGraph$fCombineNewOldGraph$fCombineNewOldFavorites$fShowCallGraph$fCombineNewOldCMSet terminatesterminatesFilterendos idempotent LexPredicate LexAction TokenLength CurrentInput PreviousInput AlexInput lexSrcFilelexPoslexInput lexPrevChar lensLexInputalexInputPrevChar alexGetChar alexGetByte getLexInput setLexInput.&&..||.not' LookAheadlookAheadErrorgetInputsetInputnextCharsyncrollback eatNextCharmatchmatch' runLookAhead$fFunctorLookAhead$fApplicativeLookAhead$fMonadLookAhead litStringlitCharinStateeof followedByliteral'literal identifiersymbolkeywordend_begin_endWith beginWithbegin withLayout withInterval' withIntervallexToken emptyLayoutnewLayoutContext offsideRule keepComments keepCommentsM nestedCommenthole skipBlock AlexReturnAlexEOF AlexErrorAlexSkip AlexTokennormallayout empty_layoutbolimp_dirlexercode alexScanUser tokensParser exprParserexprWhereParser moduleParsermoduleNameParserholeContentParser splitOnDots$fSetRangeAttr$fHasRangeAttr$fEqRecordDirective$fShowRecordDirective$fShowRHSOrTypeSigs withInterval_end openBrace closeBracePMunPMrunPMIO readFilePMacceptableFileExts parseFile $fFunctorPM$fApplicativePM $fMonadPM$fMonadErrorPM $fMonadIOPMTermSizetermSizetsize IsProjElim isProjElim SuggestionSuggest suggestNameSgTelsgTel TelToArgs telToArgsListTelListTel' IntervalViewIZeroIOneIMinIMaxINegOTermPathViewPathTypeOTypepathSortpathName pathLevelpathTypepathLhspathRhs EqualityView EqualityType OtherTypeeqtSorteqtName eqtParamseqtTypeeqtLhseqtRhsPatternSubstitution Substitution'IdSEmptyS:# StrengthenWk PatternVars patternVarsConPatternInfoconPInfo conPRecordconPFallThroughconPTypeconPLazyDeBruijnPatternDBPatVar dbPatVarName dbPatVarIndexPattern'VarPConPProjPIApplyPDefP PatOrigin PatOSystem PatOSplitPatOVarPatODotPatOWildPatOConPatORecPatOLit PatOAbsurd PatternInfo patOrigin patAsNames PatVarNameclauseLHSRangeclauseFullRange clauseTelnamedClausePats clauseBody clauseTypeclauseCatchallclauseRecursiveclauseUnreachableclauseEllipsisNAPsBlocked_ NotBlockedtheBlockingMetaignoreBlockingblockingStatusStuckOn Underapplied AbsurdMatchMissingClausesReallyNotBlocked BraveTermunBrave LevelAtom LevelAtom' MetaLevel BlockedLevel NeutralLevelUnreducedLevel PlusLevel PlusLevel'Level'MaxSort'InfSizeUnivPiSortFunSortUnivSortMetaSDefSDummySTeleEmptyTel ExtendTelLensSortlensSortgetSortType'Type''El_getSortunElNoAbsabsNameunAbsElimsElimElim'ProjIApplyConInfoMetaVDummy LensConName getConName setConName mapConNameConHeadconName conInductive conFields NamedArgsDomDom'domInfo domFinitedomName domTacticunDom ClosedLevel argFromDomnamedArgFromDom domFromArgdomFromNamedArg defaultDom defaultArgDomdefaultNamedArgDomstuckOn clausePatspatVarNameToStringnameToPatVarNamedefaultPatternInfovarPdotPlitP namedVarP namedDBVarPabsurdPnoConPatternInfotoConPatternInfofromConPatternInfo patternInfo patternOriginproperlyMatchingproperlyMatching'isEqualityType isPathTypeisIOne absurdBody isAbsurdBodyabsurdPatternNameisAbsurdPatternNamevar dummyTerm' dummyLevel' dummyTerm__DUMMY_TERM__ dummyLevel__DUMMY_LEVEL__ dummySort__DUMMY_SORT__ dummyType__DUMMY_TYPE__dummyDom __DUMMY_DOM__ atomicLevelunreducedLevelsortvarSorttmSort levelPluslevelSucmkTypemkPropisSortimpossibleTerm mapAbsNamesM mapAbsNamesreplaceEmptyName telFromList' telFromList telToListlistTel blockingMetablocked notBlockedblocked_ notBlocked_ stripDontCarearitysuggestsunSpineunSpine'hasElims isApplyElim isApplyElim' allApplyElimssplitApplyElims argsFromElims allProjElimspDomprettyPrecLevelSucs $fPrettyDom'$fLensCohesionDom'$fLensQuantityDom'$fLensRelevanceDom'$fLensFreeVariablesDom'$fLensOriginDom'$fLensModalityDom'$fLensHidingDom'$fLensArgInfoDom'$fLensNamedWithOriginDom'$fEqDom'$fKillRangeDom'$fHasRangeDom'$fDecorationDom'$fKillRangeConHead$fHasRangeConHead$fPrettyConHead $fOrdConHead $fEqConHead$fLensConNameConHead$fSetRangeConHead $fNFDataElim' $fPrettyElim'$fKillRangeElim'$fLensOriginElim'$fKillRangeAbs $fSizedAbs $fShowAbs$fDecorationAbs$fKillRangeTele $fSizedTele $fNullTele $fNFDataDom'$fNFDataLevel' $fNFDataSort'$fNFDataType'' $fNFDataTerm$fPrettyType'' $fPrettySort'$fPrettyLevel' $fPrettyTele $fPrettyTerm$fKillRangeSort'$fKillRangeType''$fKillRangeLevel'$fKillRangeTerm$fMonoidNotBlocked$fSemigroupNotBlocked$fDecorationType''$fNFDataLevelAtom'$fPrettyLevelAtom'$fKillRangeLevelAtom'$fNFDataPlusLevel'$fPrettyPlusLevel'$fKillRangePlusLevel' $fLensSortArg$fLensSortDom'$fLensSortType''$fKillRangeBlocked$fApplicativeBlocked$fMonoidBlocked$fSemigroupBlocked$fKillRangePatOrigin$fKillRangePatternInfo$fPrettyDBPatVar$fKillRangeDBPatVar$fKillRangeConPatternInfo$fPrettyPattern'$fKillRangePattern'$fIsProjPPattern'$fPrettyClause$fKillRangeClause $fNullClause$fHasRangeClause$fPatternVarsa[]$fPatternVarsaArg$fPatternVarsaArg0$fPrettySubstitution'$fNullSubstitution'$fKillRangeSubstitution'$fTelToArgsTele $fTelToArgs[] $fSgTelDom' $fSgTelDom'0 $fSgTel(,) $fSuggestTerm $fSuggestName $fSuggestAbs $fSuggest[]$fIsProjElimElim'$fTermSizeSubstitution'$fTermSizeLevelAtom'$fTermSizePlusLevel'$fTermSizeLevel'$fTermSizeSort'$fTermSizeTerm $fTermSizet $fDataDom' $fShowDom' $fFunctorDom'$fFoldableDom'$fTraversableDom' $fDataConHead $fShowConHead $fDataElim' $fShowElim'$fFunctorElim'$fFoldableElim'$fTraversableElim' $fDataAbs $fFunctorAbs $fFoldableAbs$fTraversableAbs $fDataTele $fShowTele $fFunctorTele$fFoldableTele$fTraversableTele$fShowNotBlocked$fDataNotBlocked $fDataTerm $fShowTerm $fShowLevel' $fDataLevel'$fShowPlusLevel'$fDataPlusLevel'$fShowLevelAtom'$fDataLevelAtom' $fDataSort' $fShowSort' $fDataType'' $fShowType''$fFunctorType''$fFoldableType''$fTraversableType''$fDataBraveTerm$fShowBraveTerm $fDataBlocked $fShowBlocked$fFunctorBlocked$fFoldableBlocked$fTraversableBlocked$fDataPatOrigin$fShowPatOrigin $fEqPatOrigin$fDataPatternInfo$fShowPatternInfo$fEqPatternInfo$fDataDBPatVar$fShowDBPatVar $fEqDBPatVar$fDataConPatternInfo$fShowConPatternInfo$fDataPattern'$fShowPattern'$fFunctorPattern'$fFoldablePattern'$fTraversablePattern' $fDataClause $fShowClause$fShowSubstitution'$fFunctorSubstitution'$fFoldableSubstitution'$fTraversableSubstitution'$fDataSubstitution'$fShowIntervalViewDeBruijn deBruijnVardebruijnNamedVar deBruijnView$fDeBruijnDBPatVar$fDeBruijnLevel'$fDeBruijnPlusLevel'$fDeBruijnLevelAtom'$fDeBruijnTermPrecomputeFreeVarsprecomputeFreeVarsprecomputeFreeVars_precomputedFreeVars$fPrecomputeFreeVars(,)$fPrecomputeFreeVarsMaybe$fPrecomputeFreeVars[]$fPrecomputeFreeVarsElim'$fPrecomputeFreeVarsType''$fPrecomputeFreeVarsLevelAtom'$fPrecomputeFreeVarsPlusLevel'$fPrecomputeFreeVarsLevel'$fPrecomputeFreeVarsSort'$fPrecomputeFreeVarsTerm$fPrecomputeFreeVarsAbs$fPrecomputeFreeVarsDom'$fPrecomputeFreeVarsArg freeVars'FreeMFreeTFreeEnv SingleVarVariableFreeEnv'feExtra feFlexRig feModality feSingleton IgnoreSorts IgnoreNotIgnoreInAnnotations IgnoreAll FlexRigMap theFlexRigMap TheFlexRigMapVarMap TheVarMapVarMap' theVarMap TheVarMap'IsVarSet withVarOccVarOccVarOcc' varFlexRig varModality LensFlexRig lensFlexRigFlexRigFlexRig'Flexible WeaklyRigid Unguarded StronglyRigidMetaSet theMetaSet insertMetaSet foldrMetaSet isFlexible isUnguarded isWeaklyRigidisStronglyRigid addFlexRig zeroFlexRig omegaFlexRigcomposeFlexRig oneFlexRig topVarOcc composeVarOcc oneVarOcc mapVarMap lookupVarMap mapFlexRigMap feIgnoreSorts initFreeEnvrunFreeMvariablesubVar underBinder underBinder' underModalityunderRelevance underFlexRigunderConstructor$fSingletonMetaId()$fSingletonMetaIdMetaSet$fLensFlexRigaFlexRig'$fMonoidVarOcc'$fSemigroupVarOcc'$fLensFlexRigaVarOcc'$fLensQuantityVarOcc'$fLensRelevanceVarOcc'$fLensModalityVarOcc' $fEqVarOcc'$fIsVarSetaVarMap'$fMonoidVarMap'$fSemigroupVarMap'$fSingletonIntVarMap'$fLensQuantityFreeEnv'$fLensRelevanceFreeEnv'$fLensModalityFreeEnv'$fLensFlexRigaFreeEnv'$fIsVarSet()FlexRigMap$fMonoidFlexRigMap$fSemigroupFlexRigMap$fMonoidReaderT$fSemigroupReaderT$fFreeEqualityView $fFreeClause $fFreeTele $fFreeAbs $fFreeDom' $fFreeArg $fFreeElim' $fFree(,,) $fFree(,)$fFreeWithHiding $fFreeMaybe$fFree[]$fFreeLevelAtom'$fFreePlusLevel' $fFreeLevel' $fFreeSort' $fFreeType'' $fFreeTerm $fEqMetaSet $fShowMetaSet $fNullMetaSet$fSemigroupMetaSet$fMonoidMetaSet $fEqFlexRig'$fShowFlexRig'$fFunctorFlexRig'$fFoldableFlexRig' $fShowVarOcc' $fEqVarMap' $fShowVarMap'$fEqIgnoreSorts$fShowIgnoreSorts$fShowFlexRigMap$fSingletonFlexRigMap VarCounts varCountsrunFreevarOccurrenceInflexRigOccurrenceInfreeInfreeInIgnoringSorts isBinderUsedrelevantInIgnoringSortAnn relevantInclosed allFreeVarsallRelevantVarsIgnoringallRelevantVars filterVarMapfilterVarMapToListstronglyRigidVars unguardedVars rigidVarsallVars$fIsVarSet()All$fIsVarSet()Any$fIsVarSet()[]$fIsVarSet()IntSet$fSingletonIntVarCounts$fIsVarSet()VarCounts$fMonoidVarCounts$fSemigroupVarCounts$fIsVarSetMetaSetSingleVarOcc$fMonoidSingleVarOcc$fSemigroupSingleVarOcc$fIsVarSet()SingleFlexRig$fMonoidSingleFlexRig$fSemigroupSingleFlexRig$fIsVarSetaRelevantIn$fSemigroupRelevantIn$fMonoidRelevantInSubst applySubstabstractapplyEapplysapply1raise raiseFrom strengthen substUnderidSwkSraiseSconsS singletonSinplaceSdropScomposeSsplitS++#prependS parallelScompactS strengthenSlookupSlistSabsApp lazyAbsAppnoabsAppabsBodymkAbsreAbsunderAbs underLambdas$fSubstTermQNameFunDefDataConstructorAxiom AbsurdClauseSetSLitSUnknownSExtLam argsToElims $fShowSort$fShowDefinitionTermLike traverseTermMcopyTerm$fTermLikeEqualityView$fTermLikeSort'$fTermLikeType''$fTermLikeLevelAtom'$fTermLikePlusLevel'$fTermLikeLevel'$fTermLikeTerm$fTermLike(,,,)$fTermLike(,,) $fTermLike(,)$fTermLikeWithHiding$fTermLikeTele$fTermLikeBlocked $fTermLikeAbs$fTermLikeMaybe $fTermLike[]$fTermLikeDom' $fTermLikeArg$fTermLikeElim'$fTermLikeQName$fTermLikeChar$fTermLikeInteger $fTermLikeInt$fTermLikeBoolCompiledClausesCompiledClauses'DoneBranches projPatterns conBranches etaBranch litBranchescatchAllBranch fallThrough lazyMatch WithAritycontentlitCaseconCaseetaCaseprojCasecatchAllcheckLazyMatch hasCatchAllhasProjectionPatterns prettyMap$fTermLikeWithArity$fKillRangeWithArity$fPrettyWithArity$fMonoidWithArity$fSemigroupWithArity$fTermLikeCase$fKillRangeCase $fPrettyCase $fNullCase $fMonoidCase$fSemigroupCase$fTermLikeCompiledClauses'$fKillRangeCompiledClauses'$fPrettyCompiledClauses'$fDataWithArity$fFunctorWithArity$fFoldableWithArity$fTraversableWithArity$fShowWithArity $fDataCase $fFunctorCase$fFoldableCase$fTraversableCase $fShowCase$fDataCompiledClauses'$fFunctorCompiledClauses'$fTraversableCompiledClauses'$fFoldableCompiledClauses'$fShowCompiledClauses'allMetas allMetasListnoMetas firstMetaGetDefsgetDefs MonadGetDefsdoDefdoMeta GetDefsEnv lookupMetaembDefGetDefsMgetDefs' $fGetDefs(,) $fGetDefsAbs $fGetDefsDom' $fGetDefsArg$fGetDefsElim' $fGetDefs[]$fGetDefsMaybe$fGetDefsLevelAtom'$fGetDefsPlusLevel'$fGetDefsLevel'$fGetDefsSort'$fGetDefsType''$fGetDefsMetaId $fGetDefsTerm$fGetDefsClause$fMonadGetDefsReaderTPatterns PatternSynPLHSCore'lhsInfolhsCoreSpineLHS spLhsInfo spLhsDefName spLhsPatsWithRHS RewriteRHSrhsExpr rhsConcrete rewriteExprsrewriteStrippedPats rewriteRHSrewriteWhereDecls SpineClauseWhereDeclarations WhereDecls whereModule whereDeclsClause' clauseLHSclauseStrippedPats clauseRHSclauseWhereDecls ProblemEq problemInPat problemInst problemType DataDefParamsdataDefGeneralizedParams dataDefParamsGeneralizeTelescope GeneralizeTelgeneralizeTelVars generalizeTel TacticAttr LetBindingLetBind LetPatBindLetApplyLetOpenLetDeclaredVariableBuiltinNoDefPragmaSectionRecSigRecDef PatternSynDef ScopedDecl ScopeCopyInfo renModulesrenNamesRenFunSigNoFunSig RecordAssigns RecordAssignAssignsAssign ScopedExprBindNameunBind mkBindName generalized initCopyInfoextractPattern mkDomainFreemkTBindnoDataDefParams noWhereDecls $fOrdBindName $fEqBindName$fKillRangeScopeCopyInfo$fPrettyScopeCopyInfo$fSetRangePattern'$fHasRangePattern'$fKillRangeLHSCore'$fHasRangeLHSCore'$fKillRangeLetBinding$fKillRangeWhereDeclarations$fKillRangeRHS$fKillRangeProblemEq$fKillRangeClause'$fKillRangeTypedBinding$fKillRangeDataDefParams$fKillRangeGeneralizeTelescope$fKillRangeLamBinding$fHasRangeLetBinding$fHasRangeWhereDeclarations $fHasRangeRHS$fHasRangeClause'$fHasRangeTypedBinding$fHasRangeLamBinding$fLensHidingTypedBinding$fLensHidingLamBinding$fUnderscoreExpr $fIsProjPExpr$fEqRHS $fEqProblemEq$fKillRangeSpineLHS$fHasRangeSpineLHS$fShowBindName$fDataBindName$fHasRangeBindName$fKillRangeBindName$fSetRangeBindName $fDataAxiom $fEqAxiom $fOrdAxiom $fShowAxiom$fEqScopeCopyInfo$fShowScopeCopyInfo$fDataScopeCopyInfo $fEqPattern'$fDataLHSCore'$fShowLHSCore'$fFunctorLHSCore'$fFoldableLHSCore'$fTraversableLHSCore' $fEqLHSCore' $fDataClause' $fShowClause'$fFunctorClause'$fFoldableClause'$fTraversableClause' $fEqClause' $fDataRHS $fShowRHS$fDataWhereDeclarations$fShowWhereDeclarations$fEqWhereDeclarations$fDataDataDefParams$fShowDataDefParams$fEqDataDefParams$fDataLamBinding$fShowLamBinding$fEqLamBinding$fDataTypedBinding$fShowTypedBinding$fEqTypedBinding$fDataLetBinding$fShowLetBinding$fEqLetBinding$fDataGeneralizeTelescope$fShowGeneralizeTelescope$fEqGeneralizeTelescope$fDataProblemEq$fShowProblemEq$fDataSpineLHS$fShowSpineLHS $fEqSpineLHS$fUniverseBiDeclarationQName%$fUniverseBiDeclarationAmbiguousQName$fUniverseBiDeclarationExpr!$fUniverseBiDeclarationLetBinding!$fUniverseBiDeclarationLamBinding#$fUniverseBiDeclarationTypedBinding$fUniverseBiDeclarationPattern' $fUniverseBiDeclarationPattern'0"$fUniverseBiDeclarationDeclaration!$fUniverseBiDeclarationModuleName!$fUniverseBiDeclarationModuleInfo$fUniverseBiDeclarationArg$fUniverseBiDeclarationArg0$fUniverseBiDeclarationArg1$fUniverseBiDeclarationArg2 SubstExpr substExprPatternSynDefnsPatternSynDefn NameToExpr nameToExpr AnyAbstract anyAbstractAllNamesallNames axiomNameapp patternToExprlambdaLiftExprinsertImplicitPatSynArgs$fUniverseBiDeclarationQuantity$fAllNamesModuleApplication$fAllNamesLetBinding$fAllNamesTypedBinding$fAllNamesLamBinding$fAllNamesExpr$fAllNamesWhereDeclarations $fAllNamesRHS$fAllNamesRewriteEqn'$fAllNamesClause'$fAllNamesDeclaration$fAllNamesQName$fAllNames(,,) $fAllNames(,)$fAllNamesNamed $fAllNamesArg$fAllNamesMaybe $fAllNames[]$fAnyAbstractDeclaration$fAnyAbstract[]$fNameToExprResolvedName$fNameToExprAbstractName$fSubstExprTypedBinding$fSubstExprLetBinding$fSubstExprExpr$fSubstExprFieldAssignment'$fSubstExprModuleName$fSubstExprName$fSubstExprEither$fSubstExpr(,)$fSubstExprNamed$fSubstExprArg $fSubstExpr[]$fSubstExprMaybePatternVarModalitiespatternVarModalitiesCountPatternVarscountPatternVars PatternLike foldrPatterntraversePatternMMapNamedArgPatternmapNamedArgPattern LabelPatVars labelPatVarsunlabelPatVarsFunArityfunArity clauseArgs clauseElimsunnumberPatVars dbPatPerm dbPatPerm' clausePerm patternToElimpatternsToElims patternToTerm foldPatternpreTraversePatternMpostTraversePatternM $fFunArity[]$fFunArityClause $fFunArity[]0!$fLabelPatVarsPattern'Pattern'Int$fLabelPatVars[][]i$fLabelPatVarsNamedNamedi$fLabelPatVarsArgArgi$fMapNamedArgPatterna[]$fMapNamedArgPatternaArg$fPatternLikeaNamed$fPatternLikeaArg$fPatternLikea[]$fPatternLikeaPattern'$fCountPatternVarsPattern'$fCountPatternVarsNamed$fCountPatternVarsArg$fCountPatternVars[]$fPatternVarModalitiesPattern'x$fPatternVarModalitiesArgx$fPatternVarModalitiesNamedx$fPatternVarModalities[]x recurseExprLamViewAppView' ApplicationappView'maybeProjTurnPostfix unAppViewlamViewasViewisSetunScope deepUnscopedeepUnscopeDeclsdeepUnscopeDecl$fExprLikeSpineLHS$fExprLikeLHSCore'$fExprLikePragma$fExprLikeWhereDeclarations $fExprLikeRHS$fExprLikeClause'$fExprLikePattern'$fExprLikeLetBinding$fExprLikeTypedBinding$fExprLikeDataDefParams$fExprLikeGeneralizeTelescope$fExprLikeLamBinding$fExprLikeModuleName$fExprLikeVoid$fFunctorAppView'mergePatternSynDefsmatchPatternSynmatchPatternSynP LHSToSpine lhsToSpine spineToLhsLHSProjP foldrAPatterntraverseAPatternMNAP foldAPatternpreTraverseAPatternMpostTraverseAPatternM mapAPatterncontainsAPatterncontainsAbsurdPatterncontainsAsPatterncheckPatternLinearity substPattern substPattern'splitOffTrailingWithPatternstrailingWithPatternslhsCoreToSpinespineToLhsCorelhsCoreAddChunklhsCoreAllPatternslhsCoreToPattern mapLHSHead$fIsWithPPattern'$fMapNamedArgPattern(,)$fMapNamedArgPatternMaybe$$fMapNamedArgPatternFieldAssignment'$fMapNamedArgPattern[]$fMapNamedArgPatternArg$fAPatternLikea(,)$fAPatternLikeaFieldAssignment'$fAPatternLikeaMaybe$fAPatternLikea[]$fAPatternLikeaNamed$fAPatternLikeaArg$fAPatternLikeaPattern'$fLHSToSpineLHSSpineLHS$fLHSToSpine[][]$fLHSToSpineClause'Clause'$fShowLHSPatternView Constant1 Constant0Curryinguncurryscurrys CoDomain'CoDomainDomains'DomainsIsBaseProductsArrowsConstantConsMap1ConsMap0MapFoldr'Foldr $fCurrying:b $fCurrying[]b KnownBoolboolSingSBoolSTrueSFalse eraseSBoolboolVal$fKnownBoolFalse$fKnownBoolTrueUpdater2updater2updates2update2Updater1updater1updates1update1UpdaterChangeUpdaterTChangeT MonadChange tellDirty listenDirty runChangeT mapChangeT runUpdaterT runChange runUpdaterdirtyifDirtysharing$fMonadChangeIdentityT$fMonadChangeIdentity$fMonadChangeChangeT $fUpdater1[]$fUpdater1Maybe$fUpdater2Either $fUpdater2(,)$fFunctorChangeT$fApplicativeChangeT$fMonadChangeT$fMonadTransChangeT$fMonadFailChangeT$fMonadIOChangeTNiceDeclarationWarning EmptyAbstract EmptyFieldEmptyGeneralize EmptyInstance EmptyMacro EmptyMutualEmptyPostulate EmptyPrivateEmptyPrimitiveInvalidCatchallPragmaInvalidCoverageCheckPragmaInvalidNoPositivityCheckPragmaInvalidNoUniverseCheckPragmaInvalidTerminationCheckPragmaMissingDefinitionsNotAllowedInMutualOpenPublicPrivateOpenPublicAbstractPolarityPragmasButNotPostulatesPragmaNoTerminationCheckPragmaCompiledUnknownFixityInMixfixDeclUnknownNamesInFixityDeclUnknownNamesInPolarityPragmasUselessAbstractUselessInstanceUselessPrivateDeclarationExceptionMultipleEllipses InvalidNameDuplicateDefinitionMissingWithClausesWrongDefinitionDeclarationPanicWrongContentBlockAmbiguousFunClausesInvalidMeasureMutualUnquoteDefRequiresSignature BadMacroDefNiceTypeSignatureNiceConstructorMeasureNiceDeclaration NiceFieldPrimitiveFunction NiceMutual NiceModuleNiceModuleMacroNiceOpen NiceImport NicePragma NiceRecSig NiceDataSig NiceFunClause NiceDataDef NiceRecDefNicePatternSynNiceGeneralizeNiceUnquoteDeclNiceUnquoteDefdeclarationWarningNameunsafeDeclarationWarningrunNiceniceDeclarationsnotSoNiceDeclarationsniceHasAbstract$fPrettyNiceDeclaration$fHasRangeNiceDeclaration$fPrettyDeclarationWarning$fHasRangeDeclarationWarning$fShowDataRecOrFun$fEqDataRecOrFun$fPrettyDeclarationException$fHasRangeDeclarationException$fMakeAbstractWhereClause'$fMakeAbstractClause$fMakeAbstractNiceDeclaration$fMakeAbstractIsAbstract$fMakeAbstract[]$fMakePrivateWhereClause'$fMakePrivateClause$fMakePrivateNiceDeclaration$fMakePrivateAccess$fMakePrivate[]$fDataNiceDeclaration$fShowNiceDeclaration$fDataDeclarationWarning$fShowDeclarationWarning$fDataKindOfBlock$fEqKindOfBlock$fOrdKindOfBlock$fShowKindOfBlock $fEqInMutual$fShowInMutual$fDataDataRecOrFun$fDataDeclarationException$fShowDeclarationException $fFunctorNice$fApplicativeNice $fMonadNice$fMonadStateNice$fMonadErrorNice $fEqDeclKind$fShowDeclKindVarSetsubtractSizeVar SizeConst LegendMatrixmatrixrowdescrcoldescrGM flexScopenodeMapintMapnextNode ConstraintsNewFlexArcNodeIdRConstRVarFiniteInfiniteAdjListwarshall warshallGincinfiniteisBelowemptyConstraints initGraphaddFlexaddNode addConstraint buildGraphmkMatrixextendSolution sizeRigidsolve$fSemiRingWeight$fShowConstraint$fShowLegendMatrix$fShowSizeExpr WithDefaultDefaultValue setDefaultcollapseDefault$fEqWithDefault$fShowWithDefault ComposeZipper ComposeZip ListZipperListZipZipperCarrierElement firstHoleplugHolenextHole$fZipperListZipper$fZipperComposeZipper$fEqListZipper$fOrdListZipper$fShowListZipper$fFunctorListZipper$fFoldableListZipper$fTraversableListZipperversionversionWithCommitInfo commitInfoLibM LibWarningLibPositionInfo libFilePos lineNumPosfilePos VersionViewvvBase vvNumberslibraryWarningNamefindProjectRootgetDefaultLibrariesgetInstalledLibrarieslibraryIncludePathsfindLib' versionView unVersionView$fPrettyLibWarning'$fPrettyLibWarning$fShowLibrariesFile$fEqVersionView$fShowVersionView$fShowLibPositionInfo$fDataLibPositionInfo$fShowLibWarning$fDataLibWarning$fShowLibError'FlagOptM PragmaOptionsoptShowImplicitoptShowIrrelevant optUseUnicode optVerboseoptPropoptAllowUnsolvedoptAllowIncompleteMatchoptDisablePositivityoptTerminationCheckoptTerminationDepthoptCompletenessCheckoptUniverseCheckoptOmegaInOmega optSubtypingoptCumulativity optSizedTypesoptGuardednessoptInjectiveTypeConstructorsoptUniversePolymorphismoptIrrelevantProjectionsoptExperimentalIrrelevance optWithoutK optCopatternsoptPatternMatching optExactSplitoptEta optForcingoptProjectionLike optRewriting optCubicaloptPostfixProjectionsoptKeepPatternVariablesoptInstanceSearchDepthoptOverlappingInstancesoptInversionMaxDepthoptSafeoptDoubleCheckoptSyntacticEqualityoptCompareSortsoptWarningModeoptCompileNoMain optCachingoptCountClusters optAutoInlineoptPrintPatternSynonyms optFastReduceoptConfluenceCheck optFlatSplitCommandLineOptionsOptionsoptProgramName optInputFileoptIncludePathsoptAbsoluteIncludePaths optLibrariesoptOverrideLibrariesFileoptDefaultLibs optUseLibsoptShowVersion optShowHelpoptInteractiveoptGHCiInteractionoptJSONInteractionoptOptimSmashing optCompileDiroptGenerateVimFileoptGenerateLaTeXoptGenerateHTMLoptHTMLHighlightoptDependencyGraph optLaTeXDir optHTMLDir optCSSFileoptIgnoreInterfacesoptIgnoreAllInterfacesoptLocalInterfacesoptPragmaOptionsoptOnlyScopeCheckingoptWithCompiler HtmlHighlight HighlightAll HighlightCode HighlightAuto Verbosity VerboseLevel VerboseKeymapFlagdefaultVerbositydefaultInteractionOptionsdefaultOptionsdefaultPragmaOptions defaultCutOffrunOptM checkOptsunsafePragmaOptionsrestartOptionsinfectiveOptionscoinfectiveOptions inputFlagsafeFlagstandardOptionsdeadStandardOptionsstandardOptions_ getOptSimpleparsePragmaOptionsparsePluginOptionsusagestripRTS defaultLibDir$fShowHtmlHighlight$fEqHtmlHighlight$fShowPragmaOptions$fEqPragmaOptions$fShowCommandLineOptions$fEqRestartCodomainMonadTCMliftTCMIM MonadTCStategetTCputTCmodifyTC MonadTCEnvaskTClocalTC MonadReduce liftReduceReduceM unReduceM ReduceEnvredEnvredSt HasOptions pragmaOptionscommandLineOptions TypeError Exception IOException PatternErr tcErrState tcErrClosErr LHSOrPatSynIsLHSIsPatSyn InternalErrorNotImplemented NotSupportedCompilationErrorPropMustBeSingletonDataMustEndInSort#ShouldEndInApplicationOfTheDatatype&ShouldBeAppliedToTheDatatypeParametersShouldBeApplicationOf!ConstructorPatternInWrongDatatype6CantResolveOverloadedConstructorsTargetingSameDatatypeDoesNotConstructAnElementOfWrongHidingInLHSWrongHidingInLambdaWrongHidingInApplicationWrongNamedArgumentWrongIrrelevanceInLambdaWrongQuantityInLambdaWrongCohesionInLambdaQuantityMismatchHidingMismatchRelevanceMismatchUninstantiatedDotPattern ForcedConstructorNotInstantiatedIlltypedPatternIllformedProjectionPatternCannotEliminateWithPattern!WrongNumberOfConstructorArguments ShouldBeEmpty ShouldBeASort ShouldBePi ShouldBePathShouldBeRecordTypeShouldBeRecordPatternNotAProjectionPatternNotAProperTermInvalidTypeSort InvalidTypeFunctionTypeInSizeUnivSplitOnIrrelevantSplitOnUnusableCohesionSplitOnNonVariableDefinitionIsIrrelevantDefinitionIsErasedVariableIsIrrelevantVariableIsErasedVariableIsOfUnusableCohesion UnequalLevel UnequalTerms UnequalTypesUnequalRelevanceUnequalQuantityUnequalCohesion UnequalHiding UnequalSorts UnequalBecauseOfUniverseConflict NotLeqSortMetaCannotDependOnMetaOccursInItselfMetaIrrelevantSolutionMetaErasedSolution GenericErrorGenericDocErrorBuiltinMustBeConstructorNoSuchBuiltinNameDuplicateBuiltinBindingNoBindingForBuiltinNoSuchPrimitiveFunctionDuplicatePrimitiveBindingShadowedModuleBuiltinInParameterisedModuleIllegalLetInTelescopeIllegalPatternInTelescopeNoRHSRequiresAbsurdPattern TooManyFieldsDuplicateFieldsDuplicateConstructorsWithOnFreeVariableUnexpectedWithPatternsWithClausePatternMismatchFieldOutsideRecordModuleArityMismatchGeneralizeCyclicDependencyGeneralizeUnsolvedMeta SplitErrorImpossibleConstructorTooManyPolaritiesLocalVsImportedModuleClashSolvedButOpenHolesCyclicModuleDependency FileNotFoundOverlappingProjectsAmbiguousTopLevelModuleNameModuleNameUnexpectedModuleNameDoesntMatchFileNameClashingFileNamesForModuleDefinedInOtherFileBothWithAndRHSAbstractConstructorNotInScope NoSuchModule AmbiguousNameAmbiguousModuleClashingDefinitionClashingModuleClashingImportClashingModuleImportPatternShadowsConstructorDuplicateImportsInvalidPatternRepeatedVariablesInPatternGeneralizeNotSupportedHereMultipleFixityDeclsMultiplePolarityPragmasNotAModuleExprNotAnExpressionNotAValidLetBindingNotValidBeforeFieldNothingAppliedToHiddenArgNothingAppliedToInstanceArgBadArgumentsToPatternSynonymTooFewArgumentsToPatternSynonym$CannotResolveAmbiguousPatternSynonymUnusedVariableInPatternSynonymNoParseForApplicationAmbiguousParseForApplication NoParseForLHSAmbiguousParseForLHSOperatorInformationInstanceNoCandidate UnquoteFailedDeBruijnIndexOutOfScopeNeedOptionCopatternsNeedOptionRewritingNeedOptionPropNonFatalErrorsInstanceSearchDepthExhaustedTriedToCopyConstrainedPrim UnquoteError BadVisibilityConInsteadOfDefDefInsteadOfCon NonCanonical BlockedOnMeta UnquotePanicUnificationFailureUnifyIndicesNotVarsUnifyRecursiveEqUnifyReflexiveEqUnifyUnusableModalityNegativeUnification UnifyConflict UnifyCycle NotADatatypeIrrelevantDatatypeErasedDatatypeCoinductiveDatatypeUnificationStuckCosplitCatchallCosplitNoTargetCosplitNoRecordTypeCannotCreateMissingClauseGenericSplitErrorcantSplitConName cantSplitTelcantSplitConIdxcantSplitGivenIdxcantSplitFailuresTerminationErrortermErrFunctions termErrCallsCallInfocallInfoTarget callInfoRange callInfoCalltcWarningRange tcWarningtcWarningPrintedWarningtcWarningCached NicifierIssueTerminationIssueUnreachableClauses CoverageIssueCoverageNoExactSplitNotStrictlyPositiveUnsolvedMetaVariablesUnsolvedInteractionMetasUnsolvedConstraintsCantGeneralizeOverSortsAbsurdPatternRequiresNoRHS OldBuiltinEmptyRewritePragmaIllformedAsClauseClashesViaRenaming UselessPublic UselessInlineWrongInstanceDeclarationInstanceWithExplicitArgInstanceNoOutputTypeNameInstanceArgWithExplicitArgInversionDepthReachedGenericWarningGenericNonFatalErrorSafeFlagPostulateSafeFlagPragmaSafeFlagNonTerminatingSafeFlagTerminating%SafeFlagWithoutKFlagPrimEraseEqualityWithoutKFlagPrimEraseEqualitySafeFlagNoPositivityCheckSafeFlagPolaritySafeFlagNoUniverseCheckSafeFlagNoCoverageCheckSafeFlagInjective SafeFlagEtaLibraryWarningDeprecationWarning UserWarningFixityInRenamingModuleModuleDoesntExportInfectiveImportCoInfectiveImportRewriteNonConfluentRewriteMaybeNonConfluentPragmaCompileErased NotInScopeW Candidate candidateTerm candidateTypecandidateOverlappable ExpandHidden ExpandLastDontExpandLastReallyDontExpandLast AbstractMode ConcreteModeIgnoreAbstractMode LetBindings ContextEntryContext UnquoteFlags_unquoteNormalise LensTCEnv lensTCEnv envContextenvLetBindingsenvCurrentModuleenvCurrentPathenvAnonymousModules envImportPathenvMutualBlockenvTerminationCheckenvCoverageCheck envMakeCaseenvSolvingConstraintsenvCheckingWhereenvWorkingOnTypesenvAssignMetasenvActiveProblemsenvAbstractMode envModalityenvDisplayFormsEnabledenvRangeenvHighlightingRange envClauseenvCallenvHighlightingLevelenvHighlightingMethodenvModuleNestingLevel envExpandLast envAppDefenvSimplificationenvAllowedReductionsenvInjectivityDepthenvCompareBlockedenvPrintDomainFreePienvPrintMetasBareenvInsideDotPatternenvUnquoteFlagsenvInstanceDepthenvIsDebugPrintingenvPrintingPatternLambdas envCallByNeedenvCurrentCheckpointenvCheckpointsenvGeneralizeMetasenvGeneralizedVarsenvCheckOptionConsistencyenvActiveBackendNameDirectIndirectNoneNonInteractive InteractiveBuiltinPrim BuiltinThings BuiltinInfo builtinName builtinDescBuiltinDescriptor BuiltinDataBuiltinDataCons BuiltinPrimBuiltinPostulateBuiltinUnknownTempInstanceTable InstanceTable CheckClause CheckPatternCheckLetBinding InferExpr CheckExprCallCheckDotPatternCheckProjection IsTypeCallIsType_InferVarInferDefCheckArgumentsCheckMetaSolutionCheckTargetType CheckDataDef CheckRecDefCheckConstructorCheckConstructorFitsInCheckFunDefCall CheckPragmaCheckPrimitive CheckIsEmptyCheckConfluenceCheckWithFunctionTypeCheckSectionApplicationCheckNamedWhereScopeCheckExprScopeCheckDeclaration ScopeCheckLHSNoHighlightingModuleContents StatisticsMutualIdMutIdTermHeadSortHeadPiHeadConsHeadVarHead UnknownHeadFunctionInverse' NotInjectiveInverse InversionMapFunctionInversePrimFun primFunName primFunArityprimFunImplementation PrimitiveImplPrimImplAllowedReductionsAllowedReductionProjectionReductionsInlineReductionsCopatternReductionsFunctionReductionsRecursiveReductionsLevelReductionsTypeLevelReductionsUnconfirmedReductionsNonTerminatingReductionsMaybeReducedElimsMaybeReducedArgs MaybeReducedMaybeRed isReduced ignoreReduced IsReduced NotReducedReduced NoReduction YesReductionSimplificationYesSimplificationNoSimplificationFieldsDefn DataOrRecSigGeneralizableVar AbstractDefn datarecPars funClauses funCompiled funSplitTree funTreeless funCoveringfunInv funMutualfunAbstr funDelayed funProjectionfunFlags funTerminates funExtLamfunWithdataParsdataIxs dataClausedataConsdataSort dataMutual dataAbstr dataPathConsrecPars recClause recConHead recNamedCon recFieldsrecTel recMutualrecEtaEquality' recInductionrecAbstrrecCompconParsconArity conSrcConconDataconAbstrconIndconCompconProj conForced conErased primAbstrprimName primClausesprimInv primCompiledCompKit nameOfHComp nameOfTransp FunctionFlag FunStatic FunInlineFunMacro EtaEquality SpecifiedInferredtheEtaEqualityProjLams getProjLams Projection projProperprojOrig projFromType projIndexprojLams ExtLamInfo extLamModule extLamSysSystem systemTel systemClausesFaceCompiledRepresentationCompilerPragmaIsForcedForced NotForced Covariant Contravariant Invariant NonvariantNumGeneralizableArgsNoGeneralizableArgsSomeGeneralizableArgs defArgInfodefNamedefType defPolaritydefArgOccurrencesdefArgGeneralizabledefGeneralizedParams defDisplay defMutualdefCompiledRepdefCopy defMatchabledefNoCompilation defInjectivedefCopatternLHS defBlockedtheDef RewriteRulerewName rewContextrewHeadrewPatsrewRHSrewType RewriteRulesNLPSortPTypePPropPInf PSizeUnivNLPType nlpTypeSort nlpTypeUnElPElimsNLPatPDefPLamPPiPSort PBoundVarPTerm DisplayTermDWithAppDConDDefDDotDTermLocalDisplayForm DisplayFormDisplay dfFreeVarsdfPatsdfRHS _secTelescope DisplayFormsRewriteRuleMap DefinitionsSections SignatureSig _sigSections_sigDefinitions_sigRewriteRulesIPClause IPNoClauseipcQName ipcClauseNoipcType ipcWithSub ipcClause ipcClosure ipcBoundary IPBoundary IPBoundary' ipbEquationsipbValue ipbMetaAppipbOverapplied OverappliedNotOverappliedInteractionPointsInteractionPointipRangeipMetaipSolvedipClause MetaStore nmSuggestionnmidMetaNameSuggestion miClosRangemiMetaOccursCheckmiNameSuggestionmiGeneralizableRunMetaOccursCheckDontRunMetaOccursCheck MetaPriorityTypeCheckingProblem CheckExpr CheckArgsCheckProjAppToKnownPrincipalArg CheckLambda DoQuoteTerm CheckedTargetNotCheckedTargetMetaInstantiationInstV OpenInstance BlockedConstPostponedTypeCheckingProblemFrozen InstantiableListener EtaExpandCheckConstraint MetaVariableMetaVarmvInfo mvPriority mvPermutation mvJudgementmvInstantiation mvListenersmvFrozenmvTwinGeneralizedValuegenvalCheckpoint genvalTerm genvalType DoGeneralize YesGeneralize NoGeneralize JudgementHasTypeIsSortjMetaId jComparison jMetaType OpenThingopenThingCheckpoint openThing CompareAs AsTermsOfAsSizesAsTypesCompareDirectionDirEqDirLeqDirGeqCmpEqCmpLeqValueCmpValueCmpOnFaceElimCmpTelCmpSortCmpLevelCmp HasBiggerSort HasPTSRule CheckMetaInstUnBlockGuardedIsEmptyCheckSizeLtSat FindInstance CheckFunDef UnquoteTacticProblemConstraintPConstrconstraintProblems theConstraint LensClosure lensClosureClosure clSignatureclEnvclScopeclModuleCheckpointsclValue Interface iSourceHashiSource iFileTypeiImportedModules iModuleNameiScope iInsideScope iSignature iDisplayForms iUserWarningsiImportWarningiBuiltin iForeignCode iHighlightingiPragmaOptions iOptionsUsed iPatternSyns iWarnings iPartialDefs ForeignCodeDecodedModulesVisitedModules miInterface miWarnings miPrimitiveMonadStConcreteNamesrunStConcreteNamesuseConcreteNamesmodifyConcreteNamesSourceToModule FreshName freshName_ CheckpointId MonadFreshfreshHasFresh freshLens nextFresh'TypeCheckAction EnterSection LeaveSectionPragmasCurrentTypeCheckLogCachedTypeCheckLogLoadedFileCache lfcCached lfcCurrentPersistentTCStatePersistentTCStstDecodedModulesstPersistentOptionsstInteractionOutputCallback stBenchmarkstAccumStatisticsstPersistLoadedFileCachestPersistBackends MutualBlock mutualInfo mutualNamesPostScopeStatestPostSyntaxInfostPostDisambiguatedNamesstPostMetaStorestPostInteractionPointsstPostAwakeConstraintsstPostSleepingConstraints stPostDirtystPostOccursCheckDefsstPostSignaturestPostModuleCheckpointsstPostImportsDisplayFormsstPostCurrentModulestPostInstanceDefsstPostConcreteNamesstPostUsedNamesstPostShadowingNamesstPostStatisticsstPostTCWarningsstPostMutualBlocksstPostLocalBuiltinsstPostFreshMetaIdstPostFreshMutualIdstPostFreshProblemIdstPostFreshCheckpointIdstPostFreshIntstPostFreshNameIdstPostAreWeCachingstPostPostponeInstanceSearchstPostConsideringInstancestPostInstantiateBlockingstPostLocalPartialDefs ConcreteNamesDisambiguatedNames PreScopeState stPreTokens stPreImportsstPreImportedModulesstPreModuleToSourcestPreVisitedModules stPreScopestPrePatternSynsstPrePatternSynImportsstPreGeneralizedVarsstPrePragmaOptionsstPreImportedBuiltinsstPreImportedDisplayFormsstPreImportedInstanceDefsstPreForeignCodestPreFreshInteractionIdstPreImportedUserWarningsstPreLocalUserWarningsstPreWarningOnImportstPreImportedPartialDefs ReadTCState getTCStatelocallyTCState withTCStateTCStstPreScopeStatestPostScopeStatestPersistentStateinitPersistentStateinitPreScopeStateinitPostScopeStatestTokens stImportsstImportedModulesstModuleToSourcestVisitedModulesstScope stPatternSynsstPatternSynImportsstGeneralizedVarsstPragmaOptionsstImportedBuiltins stForeignCodestFreshInteractionIdstImportedUserWarningsstLocalUserWarningsgetUserWarningsstWarningOnImportstImportedPartialDefsstLocalPartialDefsgetPartialDefsstLoadedFileCache stBackends stFreshNameId stSyntaxInfostDisambiguatedNames stMetaStorestInteractionPointsstAwakeConstraintsstSleepingConstraintsstDirtystOccursCheckDefs stSignaturestModuleCheckpointsstImportsDisplayFormsstImportedDisplayFormsstCurrentModulestImportedInstanceDefsstInstanceDefsstConcreteNames stUsedNamesstShadowingNames stStatistics stTCWarningsstMutualBlocksstLocalBuiltins stFreshMetaIdstFreshMutualIdstFreshProblemIdstFreshCheckpointId stFreshIntstAreWeCachingstPostponeInstanceSearchstConsideringInstancestInstantiateBlockingstBuiltinThings nextFresh freshName freshNoName freshNoName_freshRecordNamesourceToModulelookupModuleFromSource iFullHash buildClosurefromCmpflipCmpdirToCmpnormalMetaPrioritylowMetaPriorityhighMetaPriority getMetaInfo getMetaScope getMetaEnv getMetaSiggetMetaRelevancegetMetaModality metaFrozen_mvInfo sigSectionssigDefinitionssigRewriteRules secTelescopeemptySignaturedefaultDisplayForm theDefLens defaultDefn jsBackendNameghcBackendName noCompiledRep modifySystem projDropPars projArgInfosetEtaEquality emptyCompKit recRecursiverecEtaEquality emptyFunctionfunFlag funStatic funInlinefunMacroisMacroisEmptyFunctionisCopatternLHSrecCon defIsRecorddefIsDataOrRecorddefConstructors redReturnredBind notReducedreduced allReductionsreallyAllReductionsprimFun defClauses defCompiled defParameters defInversedefCompilerPragmas defDelayeddefNonterminatingdefTerminationUnconfirmed defForced"ifTopLevelAndHighlightingLevelIsOr ifTopLevelAndHighlightingLevelIsinitEnvdefaultUnquoteFlagsunquoteNormaliseeUnquoteNormaliseeContext eLetBindingseCurrentModule eCurrentPatheAnonymousModules eImportPath eMutualBlockeTerminationCheckeCoverageCheck eMakeCaseeSolvingConstraintseCheckingWhereeWorkingOnTypes eAssignMetaseActiveProblems eAbstractMode eModality eRelevance eQuantityeDisplayFormsEnabledeRangeeHighlightingRangeeCalleHighlightingLeveleHighlightingMethodeModuleNestingLevel eExpandLasteAppDefeSimplificationeAllowedReductionseInjectivityDeptheCompareBlockedePrintDomainFreePieInsideDotPattern eUnquoteFlagseInstanceDeptheIsDebugPrintingePrintingPatternLambdas eCallByNeedeCurrentCheckpoint eCheckpointseGeneralizeMetaseGeneralizedVarseActiveBackendName aDefToMode aModeToDefisDontExpandLast warningNametcWarningOriginsizedTypesOptionguardednessOptionwithoutKOptiongetIncludeDirs enableCaching mapRedEnvmapRedSt mapRedEnvSt reduceEnvreduceSt onReduceEnv fmapReduceapReduce bindReduce runReduceM runReduceFuseRaskRlocalRasksTCviewTC locallyTCgetsTC modifyTC'useTC setTCLens modifyTCLens modifyTCLensM stateTCLens stateTCLensMmapTCMTpureTCM returnTCMTbindTCMTthenTCMTfmapTCMTapTCMTrunIM catchError_finally_patternViolation internalError genericErrorgenericDocError typeError typeError_runTCM runTCMTop runTCMTop' runSafeTCMforkTCMpatternInTeleNameextendedLambdaNameisExtendedLambdaNameabsurdLambdaNameisAbsurdLambdaNamegeneralizedFieldNamegetGeneralizedFieldName$fNullMutualBlock$fMonadFreshiStateT$fMonadFreshiReaderT$fPrettyProblemId$fShowProblemId$fPrettyCheckpointId$fShowCheckpointId $fFreshName()$fFreshNameRange' $fFreshName[]$fFreshName(,)$fMonadStConcreteNamesStateT$fMonadStConcreteNamesReaderT$fPrettyComparison$fPrettyCompareDirection$fTermLikeCompareAs$fFreeCompareAs$fKillRangeOpen$fDecorationOpen$fShowJudgement$fKillRangeDoGeneralize$fPrettyNamedMeta$fKillRangeSection$fPrettySection$fKillRangeDisplayTerm$fPrettyDisplayTerm$fFreeDisplayTerm$fKillRangeDisplayForm$fFreeDisplayForm$fKillRangeNLPSort$fKillRangeNLPType$fKillRangeNLPat$fKillRangeRewriteRule$fKillRangeHashMap$fKillRangeNumGeneralizableArgs$fKillRangePolarity$fKillRangeIsForced$fHasRangeCompilerPragma$fKillRangeMap0$fKillRangeSystem$fKillRangeExtLamInfo$fKillRangeProjLams$fKillRangeProjection$fKillRangeEtaEquality$fKillRangeFunctionFlag$fKillRangeCompKit$fMonoidSimplification$fSemigroupSimplification$fNullSimplification$fIsProjElimMaybeReduced$fKillRangeTermHead$fPrettyTermHead$fKillRangeFunctionInverse'$fKillRangeDefn $fPrettyDefn$fKillRangeMutualId$fKillRangeDefinition$fPrettyDefinition$fLensRelevanceDefinition$fLensQuantityDefinition$fLensModalityDefinition$fLensArgInfoDefinition$fKillRangeHashMap0$fKillRangeSignature$fHasRangeCall $fPrettyCall$fKillRangeClosure$fLensQuantityTCEnv$fLensRelevanceTCEnv$fLensModalityTCEnv $fEqIPClause$fLensIsAbstractTCEnv$fHasRangeClosure $fShowClosure$fLensTCEnvTCEnv$fLensIsAbstractClosure$fLensTCEnvClosure$fEqInteractionPoint$fSetRangeMetaInfo$fLensIsAbstractMetaInfo$fLensClosureRange'MetaInfo$fLensClosureaClosure$fFreeCandidate$fTermLikeConstraint$fFreeConstraint$fHasRangeConstraint$fHasRangeProblemConstraint $fOrdListener $fEqListener$fAllNamesCallInfo$fPrettyCallInfo $fEqTCWarning$fHasRangeTCWarning$fPrettyInterface$fHasOptionsWriterT$fHasOptionsStateT$fHasOptionsReaderT$fHasOptionsMaybeT$fHasOptionsListT$fHasOptionsIdentityT$fHasOptionsExceptT$fHasOptionsChangeT$fMonadTCEnvIdentityT$fMonadTCEnvChangeT$fMonadTCEnvStateT$fMonadTCEnvWriterT$fMonadTCEnvReaderT$fMonadTCEnvExceptT$fMonadTCEnvListT$fMonadTCEnvMaybeT $fNullTCMT$fMonadBenchPhaseTCMT $fMonoidTCMT$fSemigroupTCMT$fIsStringTCMT$fCatchImpossibleTCMT$fMonadTCEnvTCMT$fMonadFailTCMT $fMonadTCMT$fMonadTransTCMT$fApplicativeTCMT $fFunctorTCMT$fMonadTCEnvReduceM$fMonadFailReduceM$fMonadReduceM$fApplicativeReduceM$fFunctorReduceM$fLensClosureRange'MetaVariable$fSetRangeMetaVariable$fHasRangeMetaVariable$fShowMetaInstantiation$fMonadStConcreteNamesTCMT $fShowTCState$fMonadTCStateTCMT$fMonadTCStateIdentityT$fMonadTCStateChangeT$fMonadTCStateStateT$fMonadTCStateWriterT$fMonadTCStateReaderT$fMonadTCStateExceptT$fMonadTCStateListT$fMonadTCStateMaybeT$fHasOptionsTCMT$fMonadErrorTCErrTCMT $fMonadIOTCMT$fExceptionTCErr$fHasRangeTCErr $fShowTCErr $fErrorTCErr$fHasFreshCheckpointId$fHasFreshProblemId $fHasFreshInt$fHasFreshNameId$fHasFreshInteractionId$fHasFreshMutualId$fHasFreshMetaId$fMonadFreshiTCMT$fReadTCStateTCMT$fHasOptionsReduceM$fReadTCStateReduceM$fReadTCStateStateT$fReadTCStateWriterT$fReadTCStateReaderT$fReadTCStateExceptT$fReadTCStateListT$fReadTCStateMaybeT$fMonadReduceReduceM$fMonadReduceStateT$fMonadReduceWriterT$fMonadReduceReaderT$fMonadReduceExceptT$fMonadReduceListT$fMonadReduceMaybeT$fMonadTCMWriterT$fMonadTCMStateT$fMonadTCMReaderT$fMonadTCMMaybeT$fMonadTCMListT$fMonadTCMIdentityT$fMonadTCMExceptT$fMonadTCMChangeT$fMonadTCMTCMT$fMonadErrorTCErrTCMT0$fMonadReduceTCMT$fShowMutualBlock$fEqMutualBlock$fDataProblemId $fEqProblemId$fOrdProblemId$fEnumProblemId$fRealProblemId$fIntegralProblemId$fNumProblemId$fDataCheckpointId$fEqCheckpointId$fOrdCheckpointId$fEnumCheckpointId$fRealCheckpointId$fIntegralCheckpointId$fNumCheckpointId$fShowForeignCode$fEqComparison$fDataComparison$fShowComparison$fEqCompareDirection$fShowCompareDirection$fDataCompareAs$fShowCompareAs $fDataOpen $fShowOpen $fFunctorOpen$fFoldableOpen$fTraversableOpen$fEqDoGeneralize$fOrdDoGeneralize$fShowDoGeneralize$fDataDoGeneralize$fShowGeneralizedValue$fDataGeneralizedValue $fEqFrozen $fShowFrozen$fEqMetaPriority$fOrdMetaPriority$fShowMetaPriority$fEqRunMetaOccursCheck$fOrdRunMetaOccursCheck$fShowRunMetaOccursCheck$fEqOverapplied$fShowOverapplied$fDataOverapplied$fShowIPBoundary'$fDataIPBoundary'$fFunctorIPBoundary'$fFoldableIPBoundary'$fTraversableIPBoundary' $fDataSection $fShowSection$fDataDisplayTerm$fShowDisplayTerm$fDataDisplayForm$fShowDisplayForm $fDataNLPSort $fShowNLPSort $fDataNLPat $fShowNLPat $fDataNLPType $fShowNLPType$fDataRewriteRule$fShowRewriteRule$fDataNumGeneralizableArgs$fShowNumGeneralizableArgs$fDataPolarity$fShowPolarity$fDataIsForced$fShowIsForced $fEqIsForced$fDataCompilerPragma$fShowCompilerPragma$fEqCompilerPragma $fDataSystem $fShowSystem$fDataExtLamInfo$fShowExtLamInfo$fDataProjLams$fShowProjLams$fNullProjLams$fDataProjection$fShowProjection$fDataEtaEquality$fShowEtaEquality$fEqEtaEquality$fDataFunctionFlag$fEqFunctionFlag$fOrdFunctionFlag$fEnumFunctionFlag$fShowFunctionFlag $fDataCompKit $fEqCompKit $fOrdCompKit $fShowCompKit $fNullFields$fDataSimplification$fEqSimplification$fShowSimplification$fFunctorReduced$fFunctorMaybeReduced$fShowAllowedReduction$fEqAllowedReduction$fOrdAllowedReduction$fEnumAllowedReduction$fBoundedAllowedReduction$fIxAllowedReduction$fDataAllowedReduction$fDataTermHead $fEqTermHead $fOrdTermHead$fShowTermHead$fDataFunctionInverse'$fShowFunctionInverse'$fFunctorFunctionInverse' $fDataDefn $fShowDefn$fDataMutualId $fEqMutualId $fOrdMutualId$fShowMutualId $fNumMutualId$fEnumMutualId$fDataDefinition$fDataSignature$fShowSignature $fDataCall $fShowBuiltin$fFunctorBuiltin$fFoldableBuiltin$fTraversableBuiltin$fEqHighlightingLevel$fOrdHighlightingLevel$fShowHighlightingLevel$fReadHighlightingLevel$fDataHighlightingLevel$fEqHighlightingMethod$fShowHighlightingMethod$fReadHighlightingMethod$fDataHighlightingMethod$fDataUnquoteFlags$fDataAbstractMode$fShowAbstractMode$fEqAbstractMode$fEqExpandHidden$fDataExpandHidden $fDataTCEnv$fDataIPClause $fDataClosure$fFunctorClosure$fFoldableClosure$fShowCandidate$fDataCandidate$fDataConstraint$fDataProblemConstraint$fShowProblemConstraint$fDataCallInfo$fShowCallInfo$fDataTerminationError$fShowTerminationError $fShowWarning $fDataWarning$fShowTCWarning$fShowInterface$fShowNegativeUnification$fShowUnificationFailure$fShowSplitError$fEqLHSOrPatSyn$fShowLHSOrPatSyn$fShowUnquoteError$fShowTypeErrorVALUvaluN' valueArgsICODE icodeArgsEmbPrjicodeicod_valueStnodeEstringEtextEintegerEdoubleEnodeMemomodFileincludesMemoUDictnodeDstringDtextDintegerDdoubleDtermDnameDqnameDnodeCstringCtextCintegerCdoubleCtermCnameCqnameCstats collectStatsabsPathDQNameId FreshAndReusefarFresh HashTablefarEmpty lensFreshqnameId emptyDict malformed tickICode runGetStateicodeX icodeInteger icodeDouble icodeString icodeNode icodeMemovcaseicodeNicodeN'valuNvalueN$fICODE->False $fICODEtTrue $fVALU->False $fVALUtTrue unquoteTactic doQuoteTermcheckPostponedLambda inferExpr checkExpr' checkExprisType_checkSectionApplication checkDecl checkDeclscheckProjAppToKnownPrincipalArginferApplicationcheckApplicationcheckArguments_checkArgumentsrewriteverifyBuiltinRewrite fastNormalise fastReduceprimitiveFunctions composePolcomputePolarityMonadInteractionPointsfreshInteractionIdmodifyInteractionPoints addImportaddImportCycleCheck getImports isImported getImportPath visitModulesetVisitedModulesgetVisitedModules isVisitedgetVisitedModulemapVisitedModulegetDecodedModulessetDecodedModulesgetDecodedModulestoreDecodedModuledropDecodedModulewithImportPathcheckForImportCycle currentModulewithCurrentModulegetCurrentPathgetAnonymousVariableswithAnonymousModulewithEnvgetEnvwithIncreasedModuleNestingLevelwithHighlightingLevelwithoutOptionsChecking doExpandLastdontExpandLastreallyDontExpandLastperformedSimplificationperformedSimplification'getSimplificationupdateAllowedReductionsmodifyAllowedReductionsputAllowedReductionsonlyReduceProjectionsallowAllReductionsallowNonTerminatingReductionsonlyReduceTypestypeLevelReductionsinsideDotPatternisInsideDotPattern callByNameMonadAddContextaddCtxaddLetBinding' updateContext withFreshNamecheckpointSubstitution HasBuiltinsgetBuiltinThingtopLevelModuleDropper prettyErrorTraceStraceSReportSreportS MonadDebugdisplayDebugMessagetraceDebugMessageformatDebugMessage getVerbosityisDebugPrintingnowDebugPrintingverboseBracketcatchAndPrintImpossible reportSLn__IMPOSSIBLE_VERBOSE__ reportSDoc reportResultunlessDebugPrintingtraceSLn traceSDocopenVerboseBracketcloseVerboseBracketparseVerboseKey hasVerbosityhasExactVerbositywhenExactVerbosity__CRASH_WHEN__verboseSapplyWhenVerboseS verbosity$fMonadDebugIdentityT$fMonadDebugChangeT$fMonadDebugWriterT$fMonadDebugStateT$fMonadDebugReaderT$fMonadDebugMaybeT$fMonadDebugListT$fMonadDebugExceptT$fMonadDebugTCMT $fReportSDoc $fReportS[] $fReportS[]0 $fReportS[]1 $fReportS[]2 $fReportSTCMT $fTraceSDoc $fTraceS[] $fTraceS[]0 $fTraceS[]1 $fTraceS[]2 $fTraceSTCMTMonadStatistics modifyCounter getStatisticsmodifyStatisticsticktickNtickMaxprintStatistics$fMonadStatisticsTCMT$fMonadStatisticsWriterT$fMonadStatisticsStateT$fMonadStatisticsReaderT$fMonadStatisticsMaybeT$fMonadStatisticsExceptT HasConstInfo getConstInfo getConstInfo'getRewriteRulesForSigError SigUnknown SigAbstract lookupSectioninFreshModuleIfFreeParamseligibleForProjectionLikemakeProjection PrettyContext PrettyTCM prettyTCM MonadPrettysayWhen cachingStarts areWeCachingwriteToCurrentLogrestorePostScopeState localCache withoutCachereadFromCachedLogcleanCachedLogactivateLoadedFileCachecacheCurrentLogupdateBenchmarkingStatusprintisPropM workOnTypesmatchCompiledE matchCompiledPSynNamesInnamesIn$fNamesInAmbiguousQName$fNamesInPattern'$fNamesInDisplayTerm$fNamesInDisplayForm $fNamesInOpen$fNamesInConHead$fNamesInQName$fNamesInElim'$fNamesInLiteral$fNamesInLevelAtom'$fNamesInPlusLevel'$fNamesInLevel' $fNamesInTerm$fNamesInSort'$fNamesInType''$fNamesInPattern'0 $fNamesInCase$fNamesInCompiledClauses'$fNamesInClause $fNamesInDefn$fNamesInDefinition$fNamesInCompKit$fNamesIn(,,,) $fNamesIn(,,) $fNamesIn(,)$fNamesInFieldAssignment' $fNamesInTele$fNamesInWithArity $fNamesInAbs$fNamesInNamed $fNamesInDom' $fNamesInArg$fNamesInNonEmpty $fNamesIn[]$fNamesInMaybe $fNamesInPSynhighlightWarningWarningsAndNonFatalErrors tcWarningsnonFatalErrors WhichWarnings ErrorWarnings AllWarnings MonadWarning addWarninggenericWarninggenericNonFatalErrorwarning_warningswarningisUnsolvedWarning isMetaWarningisMetaTCWarningonlyShowIfUnsolvedclassifyWarningemptyWarningsAndNonFatalErrorsclassifyWarningsrunPM$fSemigroupStateT$fMonadWarningTCMT$fMonadWarningStateT$fMonadWarningReaderT$fEqWhichWarnings$fOrdWhichWarnings MainInterfaceNotMainInterface MaybeWarningsMaybeWarnings' NoWarnings SomeWarningsgetMaybeWarningsscopeCheckImport isErasable autoInline FindErrorNotFound Ambiguous InterfaceFile intFilePath SourceFile srcFilePathmkInterfaceFiletoIFilereplaceModuleExtensionfindErrorToTypeErrorfindFile findFile' findFile''findInterfaceFile'findInterfaceFilecheckModuleName moduleNamerootNameModule$fEqSourceFile$fOrdSourceFileSerialisedRangeunderlyingRange$fEmbPrjExpandedEllipsis $fEmbPrjEmpty$fEmbPrjImpossible$fEmbPrjDelayed$fEmbPrjIsAbstract$fEmbPrjLiteral$fEmbPrjProjOrigin$fEmbPrjConOrigin$fEmbPrjFreeVariables$fEmbPrjWithOrigin$fEmbPrjOrigin$fEmbPrjRelevance$fEmbPrjModality$fEmbPrjCohesion$fEmbPrjQuantity$fEmbPrjQωOrigin$fEmbPrjQ1Origin$fEmbPrjQ0Origin$fEmbPrjHiding$fEmbPrjInduction$fEmbPrjHasEta $fEmbPrjArg$fEmbPrjWithHiding$fEmbPrjHashMap$fEmbPrjNameId$fEmbPrjArgInfo$fEmbPrjRanged $fEmbPrjNamed$fEmbPrjFieldAssignment'$fEmbPrjModuleName$fEmbPrjAmbiguousQName $fEmbPrjQName$fEmbPrjMetaId$fEmbPrjGenPart$fEmbPrjFixity'$fEmbPrjFixity$fEmbPrjFixityLevel$fEmbPrjAssociativity$fEmbPrjImportedName'$fEmbPrjQName0$fEmbPrjNameInScope$fEmbPrjNamePart $fEmbPrjName$fEmbPrjRange'$fEmbPrjInterval' $fEmbPrjSeq $fEmbPrjTrie$fEmbPrjIntSet $fEmbPrjSet $fEmbPrjMap $fEmbPrjBiMap$fEmbPrjNonEmpty $fEmbPrj[]$fEmbPrjTopLevelModuleName$fEmbPrjWithDefault$fEmbPrjPosition'$fEmbPrjAbsolutePath$fEmbPrjDataOrRecord$fEmbPrjFileType $fEmbPrjBool $fEmbPrjMaybe$fEmbPrjMaybe0$fEmbPrjEither $fEmbPrj(,,) $fEmbPrj(,) $fEmbPrj() $fEmbPrjVoid$fEmbPrjDouble $fEmbPrjChar $fEmbPrjInt $fEmbPrjInt32$fEmbPrjWord64$fEmbPrjInteger $fEmbPrjText $fEmbPrj[]0 $fEmbPrjName0$fEmbPrjSerialisedRange$fEmbPrjTokenBased$fEmbPrjCompressedFile$fEmbPrjDefinitionSite$fEmbPrjAspects$fEmbPrjOtherAspect$fEmbPrjAspect$fEmbPrjNameKind $fEmbPrjRangeAbsNameWithFixity toAbsName fromAbsName$fEmbPrjNameOrModule$fEmbPrjScopeInfo$fEmbPrjPrecedence$fEmbPrjParenPreference$fEmbPrjPattern'$fEmbPrjConPatLazy$fEmbPrjConPatInfo$fEmbPrjLocalVar$fEmbPrjBindingSource$fEmbPrjKindOfName$fEmbPrjAbstractModule$fEmbPrjNameMetadata$fEmbPrjAbstractName$fEmbPrjWhyInScope$fEmbPrjNameSpace$fEmbPrjAccess$fEmbPrjNameSpaceId $fEmbPrjScope$fEmbPrjBindName$fEmbPrjAbsNameWithFixityOutputContextEntry ContextVar ContextLetOutputConstraint'OfType'ofNameofExprOutputConstraintOfType CmpInTypeCmpElimJustTypeCmpTypes CmpLevelsCmpTelesJustSortCmpSortsGuard TypedAssignPostponedCheckArgs IsEmptyType SizeLtSatFindInstanceOF PTSInstancePostponedCheckFunDef OutputFormUseForce WithForce WithoutForce ComputeModeDefaultComputeIgnoreAbstractUseShowInstanceAsIs Instantiated HeadNormal Simplified NormalisedCompilerBackendLaTeX QuickLaTeX OtherBackendParseRemoveKeepIOTCM'IOTCM Interaction'Cmd_load Cmd_compileCmd_constraints Cmd_metas!Cmd_show_module_contents_toplevelCmd_search_about_toplevel Cmd_solveAll Cmd_solveOne Cmd_autoOne Cmd_autoAllCmd_infer_toplevelCmd_compute_toplevelCmd_load_highlighting_infoCmd_tokenHighlighting Cmd_highlightShowImplicitArgsToggleImplicitArgsCmd_give Cmd_refine Cmd_introCmd_refine_or_intro Cmd_contextCmd_helper_function Cmd_infer Cmd_goal_typeCmd_elaborate_giveCmd_goal_type_contextCmd_goal_type_context_inferCmd_goal_type_context_checkCmd_show_module_contents Cmd_make_case Cmd_computeCmd_why_in_scopeCmd_why_in_scope_toplevelCmd_show_version Cmd_abortCmd_exit Interaction CommandQueuecommandsabortCommandCommand'CommandMOldInteractionScopes CommandStatetheInteractionPointstheCurrentFileoptionsOnReloadoldInteractionScopes commandQueueinitCommandState readsToParseparseToReadsPrecexact readParseparens'$fReadPosition'$fReadAbsolutePath$fReadInterval' $fReadRange'$fReadInteractionId$fReadCompilerBackend$fShowCompilerBackend$fShowCommand' $fShowRemove $fReadRemove$fEqCompilerBackend $fShowRewrite $fReadRewrite$fShowComputeMode$fReadComputeMode$fEqComputeMode $fEqUseForce$fReadUseForce$fShowUseForce$fShowInteraction'$fReadInteraction'$fFunctorInteraction'$fFoldableInteraction'$fTraversableInteraction' $fShowIOTCM' $fReadIOTCM'$fFunctorIOTCM'$fFoldableIOTCM'$fTraversableIOTCM'$fFunctorOutputConstraint$fFunctorOutputForm Give_String Give_Paren Give_NoParensShowImplicitArgumentssCheckedResponseContextEntry respOrigName respReifNamerespType respLetValue respInScope GoalTypeAuxGoalOnly GoalAndHaveGoalAndElaboration Info_ErrorInfo_GenericErrorInfo_CompilationErrorInfo_HighlightingParseError Info_HighlightingScopeCheckErrorGoalsGoalDisplayInfoGoal_HelperFunctionGoal_NormalForm Goal_GoalTypeGoal_CurrentGoalGoal_InferredTypeInfo_CompilationOkInfo_ConstraintsInfo_AllGoalsWarnings Info_TimeInfo_Intro_NotFoundInfo_Intro_ConstructorUnknown Info_AutoInfo_ModuleContentsInfo_SearchAboutInfo_WhyInScopeInfo_NormalFormInfo_InferredType Info_Context Info_VersionInfo_GoalSpecificExtendedLambdaRemoveHighlightingKeepHighlightingSpeculateResultSpeculateAbortSpeculateCommit resetState resetAllState localTCStatelocalTCStateSavinglocalTCStateSavingWarningsspeculateTCStatespeculateTCState_freshTCMlensPersistentStateupdatePersistentStatemodifyPersistentStatelensAccumStatisticsPlensAccumStatisticsgetScopesetScope modifyScope_ modifyScopeuseScope locallyScope withScope withScope_ localScopenotInScopeErrornotInScopeWarning printScopemodifySignaturemodifyImportedSignature getSignaturemodifyGlobalDefinition setSignature withSignatureaddRewriteRulesForsetMatchableSymbolslookupDefinitionupdateDefinitionsupdateDefinition updateTheDef updateDefTypeupdateDefArgOccurrencesupdateDefPolarityupdateDefCompiledRepaddCompilerPragmaupdateFunClausesupdateCoveringupdateCompiledClausesupdateDefCopatternLHSupdateDefBlockedsetTopLevelModulewithTopLevelModuleaddForeignCodegetInteractionOutputCallbackappInteractionOutputCallbacksetInteractionOutputCallbackgetPatternSynssetPatternSynsmodifyPatternSynsgetPatternSynImportsgetAllPatternSynslookupPatternSynlookupSinglePatternSyn theBenchmarkupdateBenchmarkaddImportedInstancesupdateInstanceDefsmodifyInstanceDefsgetAllInstanceDefsgetAnonInstanceDefsclearAnonInstanceDefsaddUnknownInstanceaddNamedInstanceinterestingCall traceCallM traceCallCPS traceCalltraceClosureCallgetCurrentRangesetCurrentRangehighlightAsTypeCheckedprintHighlightingInfo noMutualBlock inMutualBlocksetMutualBlockInfoinsertMutualBlockInfosetMutualBlockcurrentOrFreshMutualBlocklookupMutualBlock mutualBlockOf enterClosure withClosure mapClosureMonadConstraintaddAwakeConstraintcatchPatternErrsolveConstraintsolveSomeAwakeConstraintswakeConstraintsstealConstraintsmodifyAwakeConstraintsmodifySleepingConstraintsConstraintStatusAwakeConstraintSleepingConstraintsolvingProblemsolvingProblemsisProblemSolvedgetConstraintsForProblemgetAwakeConstraintsdropConstraintstakeConstraintsputConstraintsToSleepputAllConstraintsToSleepholdConstraintstakeAwakeConstrainttakeAwakeConstraint'getAllConstraintswithConstraintbuildProblemConstraintbuildProblemConstraint_buildConstraintaddConstraint'addAwakeConstraint'addConstraintTonowSolvingConstraintsisSolvingConstraintscatchConstraintmapAwakeConstraintsmapSleepingConstraints$fEqConstraintStatus$fShowConstraintStatusdebugConstraintsguardConstraintifNoConstraintsifNoConstraints_ noConstraintssolveAwakeConstraints'OpenKind LetOpenModule TopOpenModuleImportedNameMapinameMap imoduleMap ScopeMemo memoNames memoModulesWSMScopeM printLocalsisDatatypeModulegetCurrentModulesetCurrentModulewithCurrentModule' getNamedScopegetCurrentScope createModule modifyScopesmodifyNamedScope setNamedScopemodifyNamedScopeMmodifyCurrentScopemodifyCurrentScopeMmodifyCurrentNameSpacesetContextPrecedencewithContextPrecedence getLocalVarsmodifyLocalVars setLocalVars withLocalVarsoutsideLocalVarswithCheckNoShadowingcheckNoShadowing getVarsToBind addVarToBindbindVarsToBindfreshAbstractNamefreshAbstractName_freshAbstractQNamefreshAbstractQName'freshConcreteName resolveName resolveName'tryResolveName resolveModulegetConcreteFixitygetConcretePolaritycomputeFixitiesAndPolarities getNotation bindVariableunbindVariablebindName bindName' rebindName bindModule bindQModule stripNoNamesmemoToScopeInfo copyScopecheckNoFixityInRenamingModuleapplyImportDirectiveM mapImportDirimportedNameMapFromListlookupImportedName mapRenamingnoGeneralizedVarsIfLetOpen openModule_ openModule$fMonadFixityErrorTCMTparseLHS parsePatternparsePatternSynparseApplicationparseModuleApplication $fEqExprKind$fShowExprKindLensPersistentVerbositygetPersistentVerbositysetPersistentVerbositymapPersistentVerbosityPersistentVerbosityLensIncludePathsgetIncludePathssetIncludePathsmapIncludePathsgetAbsoluteIncludePathssetAbsoluteIncludePathsmapAbsoluteIncludePaths LensSafeMode getSafeMode setSafeMode mapSafeModeSafeModeLensCommandLineOptionsgetCommandLineOptionssetCommandLineOptionsmapCommandLineOptions LensVerbosity setVerbosity mapVerbosityLensPragmaOptionsgetPragmaOptionssetPragmaOptionsmapPragmaOptionslensPragmaOptionsmodifyPragmaOptionsmodifyVerbosity putVerbositymodifyCommandLineOptionsmodifySafeMode putSafeMode builtinModulesWithSafePostulates"builtinModulesWithUnsafePostulatesprimitiveModulesbuiltinModulesisBuiltinModule!isBuiltinModuleWithSafePostulatesmodifyIncludePathsputIncludePathsmodifyAbsoluteIncludePathsputAbsoluteIncludePathsmodifyPersistentVerbosityputPersistentVerbosity$fLensPragmaOptionsTCState%$fLensPragmaOptionsCommandLineOptions$fLensVerbosityTCState$fLensVerbosityPragmaOptions$fLensCommandLineOptionsTCState)$fLensCommandLineOptionsPersistentTCState$fLensSafeModeTCState$fLensSafeModePersistentTCState $fLensSafeModeCommandLineOptions$fLensSafeModePragmaOptions$fLensIncludePathsTCState#$fLensIncludePathsPersistentTCState$$fLensIncludePathsCommandLineOptions $fLensPersistentVerbosityTCState*$fLensPersistentVerbosityPersistentTCState+$fLensPersistentVerbosityCommandLineOptions&$fLensPersistentVerbosityPragmaOptionssetCommandLineOptions'libToTCMsetLibraryPathssetLibraryIncludesaddDefaultLibrariessetOptionsFromPragmaenableDisplayFormsdisableDisplayFormsdisplayFormsEnabledsetIncludeDirs setInputFile getInputFile getInputFile' hasInputFile isPropEnabledhasUniversePolymorphismshowImplicitArgumentsshowIrrelevantArgumentswithShowAllArgumentswithShowAllArguments'withPragmaOptionsignoreInterfacesignoreAllInterfacespositivityCheckEnabled typeInType etaEnabledmaxInstanceSearchDepthmaxInversionDepth TeleNoAbs teleNoAbsTelVtheTeltheCoreTelView applyTermE canProjectconAppdefApp argToDontCare relToDontCarepiApplytelVars namedTelVars abstractArgsrenaming renamingRrenamePapplySubstTermapplyNLPatSubstapplyNLSubstToDomfromPatternSubstitution applyPatSubst usePatOriginusePatternInfoprojDropParsApplytelView' telView'UpTo bindsToTel' bindsToTelnamedBindsToTeldomFromNamedArgNamemkPimkLamtelePi'telePitelePi_ telePiVisibleteleLamtypeArgsWithTelcompiledClauseBody univSort'univSortunivInffunSort'funSortpiSort'piSortlevelMaxlevelLublevelTm unLevelAtom $fOrdElim' $fEqElim'$fOrdAbs$fEqAbs $fOrdTerm$fEqTerm $fOrdType'' $fEqType''$fOrdLevelAtom'$fEqLevelAtom'$fOrdPlusLevel'$fSubstTermRange'$fSubstPattern'Pattern'$fDeBruijnPattern'$fSubstTermEqualityView$fSubstTermCandidate $fSubstt(,,,) $fSubstt(,,) $fSubstt(,) $fSubstTerm()$fSubsttWithHiding $fSubsttMap $fSubstt[] $fSubsttMaybe $fSubsttDom' $fSubsttNamed $fSubsttArg $fSubsttAbs $fSubsttElim'$fSubstTermCompareAs$fSubstTermConstraint $fSubsttTele$fSubstTermDisplayTerm$fSubstTermDisplayForm$fSubsttBlocked$fSubstNLPatRewriteRule$fSubstNLPatNLPSort$fSubstNLPatNLPType$fSubstNLPatNLPat$fDeBruijnNLPat$fDeBruijnBraveTerm$fSubstTermProblemEq$fSubstTermPattern'$fSubstTermConPatternInfo $fSubstTerm[]$fSubstTermName$fSubsttLevelAtom'$fSubsttPlusLevel'$fSubsttLevel' $fSubsttSort'$fSubsttType''$fSubstBraveTermBraveTerm$fSubstTermTerm$fSubstaSubstitution'$fAbstractHashMap $fAbstractMap$fAbstractMaybe $fAbstract[]$fAbstractFunctionInverse'$fAbstractCase$fAbstractWithArity$fAbstractCompiledClauses'$fAbstractClause$fAbstractPrimFun$fAbstractDefn$fAbstractSystem$fAbstractProjLams$fAbstractProjection$fAbstractNumGeneralizableArgs $fAbstract[]0 $fAbstract[]1$fAbstractRewriteRule$fAbstractDefinition$fAbstractTele$fAbstractSort'$fAbstractType''$fAbstractTerm$fAbstractPermutation$fApplyPermutation$fAbstractDrop $fApplyDrop $fApply(,,) $fApply(,)$fApplyHashMap $fApplyMap $fApplyMaybe $fApplyMaybe0$fApplyBlocked $fApply[]$fApplyDisplayTerm$fApplyFunctionInverse' $fApplyCase$fApplyWithArity $fApplySystem$fApplyExtLamInfo$fApplyCompiledClauses' $fApplyClause$fApplyPrimFun $fApplyDefn$fApplyProjLams$fApplyProjection $fApply[]0$fApplyNumGeneralizableArgs $fApply[]1 $fApply[]2$fApplyRewriteRule$fApplyDefinition $fApplyTele $fApplySort'$fApplyBraveTerm $fApplyTerm$fTeleNoAbsTele $fTeleNoAbs[] $fShowTelV $fFunctorTelV $fOrdDom' $fEqSection $fEqCompareAs $fOrdTele$fEqTele $fEqCandidate $fEqBlocked$fEqNotBlocked$fEqPlusLevel' $fOrdLevel' $fEqLevel' $fOrdSort' $fEqSort'$fOrdSubstitution'$fEqSubstitution' $fOrdTelV$fEqTelVmakeOpengetOpen tryGetOpenisClosed KeepNames AddContext addContext contextSizeunsafeModifyContextmodifyContextInfo inTopContextunsafeInTopContextunsafeEscapeContext escapeContext checkpointcheckpointSubstitution'getModuleParameterSub defaultAddCtxwithFreshName_withShadowingNameTCMaddRecordNameContextunderAbstractionunderAbstraction'underAbstractionAbsunderAbstractionAbs'underAbstraction_mapAbstractiongetLetBindingsdefaultAddLetBinding' addLetBinding getContextgetContextSizegetContextArgsgetContextTermsgetContextTelescopegetContextNames lookupBV'lookupBVdomOfBVtypeOfBV nameOfBV'nameOfBV getVarInfo$fMonadAddContextTCMT$fMonadAddContextListT$fMonadAddContextStateT$fMonadAddContextWriterT$fMonadAddContextReaderT$fMonadAddContextExceptT$fMonadAddContextMaybeT$fAddContextTele$fAddContext[]$fAddContextName$fAddContextDom'$fAddContext(,)$fAddContext(,)0$fAddContext(,)1$fAddContext(,)2$fAddContext(,)3$fAddContextDom'0$fAddContextDom'1$fAddContext(,)4$fAddContext[]0$fAddContextKeepNames$fAddContext(,)5PiApplyMpiApplyMtelViewCoinductionKit nameOfInf nameOfSharp nameOfFlatlitTypesetBuiltinThingsbindBuiltinName bindPrimitive getBuiltin getBuiltin' getPrimitive' getPrimitivegetPrimitiveTermgetPrimitiveTerm'getTerm'getName'getTermconstructorFormconstructorForm' primIntegerprimIntegerPosprimIntegerNegSuc primFloatprimChar primStringprimBool primSigmaprimUnit primUnitUnitprimTrue primFalseprimListprimNilprimConsprimIOprimId primConId primIdElimprimPath primPathP primInterval primIZeroprimIOneprimIMinprimIMaxprimINeg primPartial primPartialP primIsOne primItIsOne primTrans primHComp primEquiv primEquivFunprimEquivProofprimTranspProof prim_glueU prim_unglueUprimGlue prim_glue prim_unglueprimFaceForall primIsOne1 primIsOne2primIsOneEmptyprimSub primSubIn primSubOutprimNatprimSucprimZero primNatPlus primNatMinus primNatTimesprimNatDivSucAuxprimNatModSucAuxprimNatEquality primNatLess primWord64 primSizeUnivprimSize primSizeLt primSizeSuc primSizeInf primSizeMaxprimInf primSharpprimFlat primEqualityprimRefl primRewrite primLevel primLevelZero primLevelSuc primLevelMax primSetOmega primFromNat primFromNegprimFromString primQNameprimArg primArgArgprimAbs primAbsAbs primAgdaSort primHiding primHidden primInstance primVisible primRelevance primRelevantprimIrrelevant primAssoc primAssocLeftprimAssocRight primAssocNonprimPrecedenceprimPrecRelatedprimPrecUnrelated primFixityprimFixityFixity primArgInfoprimArgArgInfoprimAgdaSortSetprimAgdaSortLitprimAgdaSortUnsupported primAgdaTermprimAgdaTermVarprimAgdaTermLamprimAgdaTermExtLamprimAgdaTermDefprimAgdaTermConprimAgdaTermPiprimAgdaTermSortprimAgdaTermLitprimAgdaTermUnsupportedprimAgdaTermMetaprimAgdaErrorPartprimAgdaErrorPartStringprimAgdaErrorPartTermprimAgdaErrorPartNameprimAgdaLiteralprimAgdaLitNatprimAgdaLitWord64primAgdaLitFloatprimAgdaLitCharprimAgdaLitStringprimAgdaLitQNameprimAgdaLitMetaprimAgdaPatternprimAgdaPatConprimAgdaPatVarprimAgdaPatDotprimAgdaPatLitprimAgdaPatProjprimAgdaPatAbsurdprimAgdaClauseprimAgdaClauseClauseprimAgdaClauseAbsurdprimAgdaDefinitionFunDefprimAgdaDefinitionDataDefprimAgdaDefinitionRecordDef!primAgdaDefinitionDataConstructorprimAgdaDefinitionPostulateprimAgdaDefinitionPrimitiveprimAgdaDefinition primAgdaMeta primAgdaTCMprimAgdaTCMReturnprimAgdaTCMBindprimAgdaTCMUnifyprimAgdaTCMTypeErrorprimAgdaTCMInferTypeprimAgdaTCMCheckTypeprimAgdaTCMNormaliseprimAgdaTCMReduceprimAgdaTCMCatchErrorprimAgdaTCMGetContextprimAgdaTCMExtendContextprimAgdaTCMInContextprimAgdaTCMFreshNameprimAgdaTCMDeclareDefprimAgdaTCMDeclarePostulateprimAgdaTCMDefineFunprimAgdaTCMGetTypeprimAgdaTCMGetDefinitionprimAgdaTCMQuoteTermprimAgdaTCMUnquoteTermprimAgdaTCMBlockOnMetaprimAgdaTCMCommitprimAgdaTCMIsMacroprimAgdaTCMWithNormalisationprimAgdaTCMDebugPrintprimAgdaTCMNoConstraintsprimAgdaTCMRunSpeculativecoinductionKit'coinductionKit getPrimNamegetBuiltinName'getPrimitiveName' isPrimitive intervalView' intervalViewintervalUnviewintervalUnview'pathView pathView' idViewAsPath boldPathView pathUnviewprimEqualityName equalityViewequalityUnviewconstrainedPrimsgetNameOfConstrained$fHasBuiltinsTCMT$fHasBuiltinsWriterT$fHasBuiltinsStateT$fHasBuiltinsReaderT$fHasBuiltinsListT$fHasBuiltinsExceptT$fHasBuiltinsMaybeT SizeMaxView' SizeMaxViewSizeViewComparable NotComparableYesAboveYesBelow DeepSizeViewDSizeInfDSizeVar DSizeMeta DOtherSizeSizeViewSizeInfSizeSuc OtherSize IsSizeType isSizeType BoundedSize BoundedLt BoundedNoisSizeTypeTestgetBuiltinDefNamegetBuiltinSizeisSizeNameTestisSizeNameTestRawhaveSizedTypes haveSizeLtbuiltinSizeHooksizeSortsizeUniv sizeType_sizeType sizeSucNamesizeSucsizeSuc_sizeMaxsizeViewsizeViewComparable sizeViewSuc_ sizeViewPredsizeViewOffset removeSucs unSizeViewunDeepSizeView maxViewMax maxViewConssizeViewComparableWithMax maxViewSuc_ unMaxView$fIsSizeTypeCompareAs$fIsSizeTypeTerm$fIsSizeTypeType''$fIsSizeType(,)$fIsSizeTypeDom'$fPrettyDeepSizeView$fEqBoundedSize$fShowBoundedSize$fShowDeepSizeView$fFunctorSizeViewComparablereallyUnLevelViewRangeAndPragma ToConcrete toConcretebindToConcreteAbsToCon MonadAbsToConEnvpreserveInteractionIds noTakenNames runAbsToConabstractToConcreteScopeabstractToConcreteCtxabstractToConcrete_abstractToConcreteHiding toConcreteCtx$fMonadDebugAbsToCon$fHasOptionsAbsToCon$fMonadStConcreteNamesAbsToCon$fReadTCStateAbsToCon$fMonadTCEnvAbsToCon$fMonadReaderEnvAbsToCon$fMonadFailAbsToCon$fMonadAbsToCon$fApplicativeAbsToCon$fFunctorAbsToCon$fToConcreteNamedMetaExpr$fToConcreteInteractionIdExpr$fToConcreteMaybeMaybe$fToConcreteLHSCore'Pattern$fToConcreteLHSLHS$fToConcreteSpineLHSLHS.$fToConcreteModuleApplicationModuleApplication$fToConcreteClause'[]$fToConcreteConstrDeclaration$fToConcreteMaybeMaybe0"$fToConcreteRewriteEqn'RewriteEqn'$fToConcreteRHS(,,,))$fToConcreteWhereDeclarationsWhereClause'$fToConcreteLetBinding[]%$fToConcreteTypedBindingTypedBinding'!$fToConcreteLamBindingLamBinding'$fToConcreteBinder'Binder',$fToConcreteFieldAssignment'FieldAssignment'$fToConcreteResolvedNameQName$fToConcreteAbstractNameQName$fToConcreteModuleNameQName$fToConcreteQNameQName$fToConcreteBindNameBoundName$fToConcreteNameName$fToConcreteNamedNamed $fToConcreteWithHidingWithHiding$fToConcreteArgArg$fToConcrete(,,)(,,)$fToConcrete(,)(,)$fToConcreteEitherEither$fToConcrete[][]$fToConcreteBoolBool$fToConcrete()() $fToConcreteRangeAndPragmaPragma$fToConcreteDeclaration[]$fToConcreteUserPatternArg$fToConcreteUserPatternPattern'$fToConcretePattern'Pattern$fToConcreteSplitPatternArg $fToConcreteSplitPatternPattern'"$fToConcreteBindingPatternPattern'$fToConcreteFreshenNameName$fToConcreteExprExpr$fHasRangeMaybeSection$fEqMaybeSection$fShowMaybeSection$fFunctorMaybeSection$fFoldableMaybeSection$fTraversableMaybeSectionshowAprettyAprettyAsshowATop prettyATopDropArgsdropArgs$fDropArgsSplitTree'$fDropArgsCompiledClauses'$fDropArgsTerm$fDropArgsFunctionInverse'$fDropArgsClause$fDropArgsPermutation$fDropArgsTele$fDropArgsMaybe addConstant setTerminatessetCompiledClauses setSplitTreemodifyFunClauses addClausesmkPragma addPragmagetUniqueCompilerPragmasetFunctionFlag markStatic markInline markInjectiveunionSignatures addSectionsetModuleCheckpoint getSectionaddDisplayForms applySection applySection'addDisplayFormisLocalgetDisplayFormschaseDisplayFormshasLoopingDisplayForm canonicalNamesameDef whatInductionsingleConstructorTypesigErrordefaultGetRewriteRulesForgetOriginalProjectiondefaultGetConstInfo getConInfo getPolarity' setPolarity getForcedArgsgetArgOccurrencesetArgOccurrencesmodifyArgOccurrences setTreelesssetCompiledArgUse getCompiledgetErasedConArgssetErasedConArgs getTreelessgetCompiledArgUse addDataCons getMutual getMutual_ setMutualmutuallyRecursivedefinitelyNonRecursive_getCurrentModuleFreeVars getDefModulegetDefFreeVarsfreeVarsToApplygetModuleFreeVarsmoduleParamsToApplyinstantiateDefinstantiateRewriteRuleinstantiateRewriteRules makeAbstractinAbstractModeinConcreteModeignoreAbstractModeinConcreteOrAbstractModetreatAbstractlytreatAbstractly' typeOfConst relOfConstmodalityOfConst droppedPars isProjection isProjection_ isStaticFun isInlineFunisProperProjectionprojectionArgsusesCopatternsapplyDef$fHasConstInfoWriterT$fHasConstInfoStateT$fHasConstInfoReaderT$fHasConstInfoMaybeT$fHasConstInfoListT$fHasConstInfoIdentityT$fHasConstInfoExceptT$fHasConstInfoChangeT$fHasConstInfoTCMT UnFreezeMeta unfreezeMetaIsInstantiatedMetaisInstantiatedMetaMonadMetaSolvernewMeta'assignV assignTerm' etaExpandMeta updateMetaVarspeculateMetas KeepMetas RollBackMetasMetaKindRecordsSingletonRecordsLevels allMetaKindsdontAssignMetas getMetaStoremodifyMetaStoremetasCreatedBy lookupMeta'metaTypeupdateMetaVarTCM insertMetaVargetMetaPriority isSortMeta isSortMeta_ getMetaTypegetMetaContextArgsgetMetaTypeInContextisGeneralizableMetaisInstantiatedMeta'constraintMetascreateMetaInfocreateMetaInfo'setValueMetaNamegetMetaNameSuggestionsetMetaNameSuggestionsetMetaArgInfoupdateMetaVarRangesetMetaOccursCheckregisterInteractionPointfindInteractionPoint_connectInteractionPointremoveInteractionPointgetInteractionPointsgetInteractionMetasgetInteractionIdsAndMetasisInteractionMetalookupInteractionPointlookupInteractionIdlookupInteractionMetalookupInteractionMeta_ newMetaTCM'getInteractionRange getMetaRangegetInteractionScope withMetaInfo' withMetaInfogetMetaVariableSetgetMetaVariablesgetInstantiatedMetas getOpenMetas isOpenMeta listenToMetaunlistenToMetagetMetaListenersclearMetaListenerswithFreezeMetas freezeMetas freezeMetas' unfreezeMetasunfreezeMetas'isFrozen$fIsInstantiatedMetaAbs$fIsInstantiatedMetaArg$fIsInstantiatedMetaMaybe$fIsInstantiatedMeta[]$fIsInstantiatedMetaLevelAtom'$fIsInstantiatedMetaPlusLevel'$fIsInstantiatedMetaLevel'$fIsInstantiatedMetaTerm$fIsInstantiatedMetaMetaId$fMonadInteractionPointsTCMT$fMonadInteractionPointsStateT$fMonadInteractionPointsReaderT$fUnFreezeMetaAbs$fUnFreezeMeta[]$fUnFreezeMetaLevelAtom'$fUnFreezeMetaPlusLevel'$fUnFreezeMetaLevel'$fUnFreezeMetaSort'$fUnFreezeMetaTerm$fUnFreezeMetaType''$fUnFreezeMetaMetaId $fEqMetaKind$fEnumMetaKind$fBoundedMetaKind$fShowMetaKind Condition checkMetaInst newSortMeta newTelMetanewNamedValueMeta'newNamedValueMeta newValueMetanewInstanceMetaassignetaExpandMetaSafe assignTerm newArgsMeta newArgsMeta'getConstructorData getConHeadInSeqHasFreeOccursSeqArg UnderLambdaonceinSeq underLambdaoccursIn tryStrengthen$fSubstTTermTAlt$fSubstTTermTTerm$fDeBruijnTTerm$fMonoidOccurs$fSemigroupOccurs $fHasFree(,) $fHasFree[] $fHasFreeInt $fHasFreeTAlt$fHasFreeBinder$fHasFreeTTerm$fHasFreeInSeq$fEqUnderLambda$fOrdUnderLambda$fShowUnderLambda$fSemigroupUnderLambda$fMonoidUnderLambda $fEqSeqArg $fOrdSeqArg $fShowSeqArg$fSemigroupSeqArg$fMonoidSeqArg $fEqOccurs $fOrdOccurs $fShowOccurs $fPrettyTTerm equalTerms caseToSeq$fEmbPrjForeignCode$fEmbPrjCompilerPragma$fEmbPrjSubstitution'$fEmbPrjBuiltin$fEmbPrjPatOrigin$fEmbPrjPatternInfo$fEmbPrjDBPatVar$fEmbPrjConPatternInfo$fEmbPrjClause$fEmbPrjTermHead$fEmbPrjFunctionInverse'$fEmbPrjCompiledClauses' $fEmbPrjCase$fEmbPrjWithArity$fEmbPrjFunctionFlag$fEmbPrjSplitTree'$fEmbPrjSplitTag$fEmbPrjLazySplit $fEmbPrjDefn$fEmbPrjEtaEquality$fEmbPrjOccurrence$fEmbPrjDoGeneralize$fEmbPrjNumGeneralizableArgs$fEmbPrjIsForced$fEmbPrjPolarity$fEmbPrjExtLamInfo$fEmbPrjSystem$fEmbPrjProjLams$fEmbPrjProjection$fEmbPrjRewriteRule$fEmbPrjNLPSort$fEmbPrjNLPType $fEmbPrjNLPat$fEmbPrjBlocked$fEmbPrjNotBlocked$fEmbPrjDefinition$fEmbPrjCompKit$fEmbPrjMutualId$fEmbPrjDisplayTerm$fEmbPrjCheckpointId $fEmbPrjOpen$fEmbPrjDisplayForm $fEmbPrjSort'$fEmbPrjLevelAtom'$fEmbPrjPlusLevel'$fEmbPrjLevel' $fEmbPrjTerm $fEmbPrjAbs$fEmbPrjType''$fEmbPrjConHead $fEmbPrjElim' $fEmbPrjDrop$fEmbPrjPermutation $fEmbPrjTele$fEmbPrjSection$fEmbPrjSignature $fEmbPrjDom'$fEmbPrjCutOff$fEmbPrjWarningName$fEmbPrjWarningMode$fEmbPrjPragmaOptions $fEmbPrjDoc$fEmbPrjLibPositionInfo$fEmbPrjLibWarning'$fEmbPrjLibWarning$fEmbPrjDeclarationWarning$fEmbPrjWarning$fEmbPrjTCWarning$fEmbPrjInterfaceencodedecodeencodeInterface encodeFiledecodeInterface decodeHashes decodeFile useTerPragma newSection checkFunDef' checkFunDefbindBuiltinFlatbindBuiltinSharpbindBuiltinInf typeOfFlat typeOfSharp typeOfInfToNLPattoNLPatgetClausesAsRewriteRules clauseQNameclauseToRewriteRule$fToNLPatArgElim'$fToNLPatArgElim'0$fToNLPatAbsAbs$fToNLPatElim'Elim'$fToNLPatDom'Dom' $fToNLPat[][]$fHasConstInfoReduceM$fMonadDebugReduceM$fMonadAddContextReduceM$fHasBuiltinsReduceMisRecordConstructorisGeneratedRecordConstructoretaContractRecordgetRecordFieldNames_ isEtaRecordisRecordYesNoDontKnowmatchCopatterns matchPatternsbuildSubstitutionExpandPatternSynonymsexpandPatternSynonymsexpandLitPatternexpandPatternSynonyms'$fExpandPatternSynonymsPattern''$fExpandPatternSynonymsFieldAssignment'$fExpandPatternSynonymsNamed$fExpandPatternSynonymsArg$fExpandPatternSynonyms[]$fExpandPatternSynonymsMaybeNamesNamesTunName runNamesTrunNames currentCxtcxtSubstinCxtcl'clopenbind'bindglamglamNlamilam$fHasBuiltinsNamesT$fFunctorNamesT$fApplicativeNamesT $fMonadNamesT$fMonadFailNamesT$fMonadTransNamesT$fMonadStateNamesT$fMonadIONamesT$fHasOptionsNamesT$fMonadDebugNamesT$fMonadTCEnvNamesT$fMonadTCStateNamesT$fMonadTCMNamesT$fReadTCStateNamesT$fMonadReduceNamesT$fMonadErrorNamesT$fMonadAddContextNamesT MentionsMeta mentionsMetas mentionsMeta$fMentionsMetaCompareAs$fMentionsMetaConstraint$fMentionsMetaProblemConstraint$fMentionsMetaTele$fMentionsMetaElim'$fMentionsMetaClosure$fMentionsMeta(,,)$fMentionsMeta(,)$fMentionsMetaMaybe$fMentionsMeta[]$fMentionsMetaDom'$fMentionsMetaArg$fMentionsMetaAbs$fMentionsMetaSort'$fMentionsMetaType''$fMentionsMetaLevelAtom'$fMentionsMetaPlusLevel'$fMentionsMetaLevel'$fMentionsMetaTerm BinAppViewNoApp binAppView etaContractetaOnceetaConetaLamInstantiateFullinstantiateFull' Normalise normalise'Simplify simplify'reduce'reduceB'IsMetaisMeta Instantiate instantiate' instantiateinstantiateFullreducereduceB normalise normaliseBsimplifyisFullyInstantiatedMeta ifBlocked isBlocked reduceIApply blockedOrMeta reduceIApply'shouldTryFastReducemaybeFastReduceTermslowReduceTermunfoldCorecursionEunfoldCorecursionunfoldDefinitionunfoldDefinitionEunfoldDefinition'unfoldDefinitionStep reduceDefCopy reduceHead unfoldInlinedappDef_appDefE_appDefappDefEappDef'appDefE'simplifyBlocked'slowNormaliseArgs$fInstantiateEqualityView$fInstantiateCandidate$fInstantiateCompareAs$fInstantiateConstraint$fInstantiateClosure$fInstantiateDom'$fInstantiateSort'$fInstantiateBlocked$fInstantiateLevelAtom'$fInstantiatePlusLevel'$fInstantiateLevel'$fInstantiateType''$fInstantiateTerm$fInstantiate(,,)$fInstantiate(,)$fInstantiateTele$fInstantiateElim'$fInstantiateArg$fInstantiateAbs$fInstantiateMaybe$fInstantiateMaybe0$fInstantiateMap$fInstantiate[]$fIsMetaCompareAs $fIsMetaSort'$fIsMetaLevel'$fIsMetaType'' $fIsMetaTerm$fReduceIPBoundary'$fReduceEqualityView$fReduceCandidate $fReduceMap$fReduceCompareAs$fReduceConstraint $fReduceTele$fReduceClosure $fReduceTerm$fReducePattern' $fReduce(,,) $fReduce(,) $fReduceDom' $fReduceArg $fReduce[] $fReduceAbs$fReduceLevelAtom'$fReducePlusLevel'$fReduceLevel' $fReduceElim' $fReduceSort'$fReduceType''$fSimplifyEqualityView$fSimplifyCandidate$fSimplifyDisplayForm$fSimplifyCompareAs$fSimplifyConstraint$fSimplifyProblemConstraint$fSimplifyTele$fSimplifyClosure$fSimplifyDom' $fSimplifyAbs$fSimplifyLevelAtom'$fSimplifyPlusLevel'$fSimplifyLevel'$fSimplifySort'$fSimplifyType''$fSimplifyTerm$fSimplifyBool$fSimplify(,,) $fSimplify(,)$fSimplifyIPBoundary'$fSimplifyNamed$fSimplifyElim' $fSimplifyArg$fSimplifyMaybe$fSimplifyMaybe0 $fSimplifyMap $fSimplify[]$fNormaliseEqualityView$fNormaliseCandidate$fNormaliseDisplayForm$fNormalisePattern'$fNormaliseConPatternInfo$fNormaliseCompareAs$fNormaliseConstraint$fNormaliseProblemConstraint$fNormaliseTele$fNormaliseClosure$fNormaliseDom'$fNormaliseArg$fNormaliseAbs$fNormaliseLevelAtom'$fNormalisePlusLevel'$fNormaliseLevel'$fNormaliseElim'$fNormaliseTerm$fNormaliseType''$fNormaliseSort'$fNormaliseDBPatVar$fNormaliseInt$fNormaliseChar$fNormaliseBool$fNormalise(,,)$fNormalise(,)$fNormaliseWithHiding$fNormaliseIPBoundary'$fNormaliseNamed$fNormaliseMaybe$fNormaliseMaybe0$fNormaliseMap $fNormalise[]$fInstantiateFullEqualityView$fInstantiateFullCandidate$fInstantiateFullBuiltin$fInstantiateFullInterface$fInstantiateFullClause!$fInstantiateFullCompiledClauses'$fInstantiateFullCase!$fInstantiateFullFunctionInverse'$fInstantiateFullSystem$fInstantiateFullExtLamInfo$fInstantiateFullDefn$fInstantiateFullDisplayTerm$fInstantiateFullDisplayForm$fInstantiateFullRewriteRule$fInstantiateFullNLPSort$fInstantiateFullNLPType$fInstantiateFullNLPat$fInstantiateFullDefinition$fInstantiateFullTele$fInstantiateFullSection$fInstantiateFullSignature$fInstantiateFullCompareAs$fInstantiateFullConstraint"$fInstantiateFullProblemConstraint$fInstantiateFullClosure$fInstantiateFullDom'$fInstantiateFullAbs$fInstantiateFullPattern'$fInstantiateFullConPatternInfo$fInstantiateFullSubstitution'$fInstantiateFullLevelAtom'$fInstantiateFullPlusLevel'$fInstantiateFullLevel'$fInstantiateFullTerm$fInstantiateFullType''$fInstantiateFullSort'$fInstantiateFullDBPatVar$fInstantiateFullConHead$fInstantiateFullScope$fInstantiateFullQName$fInstantiateFullName$fInstantiateFullModuleName$fInstantiateFullInt$fInstantiateFullChar$fInstantiateFullBool$fInstantiateFull(,,,)$fInstantiateFull(,,)$fInstantiateFull(,)$fInstantiateFullWithArity$fInstantiateFullOpen$fInstantiateFullNamed$fInstantiateFullElim'$fInstantiateFullArg$fInstantiateFullMaybe$fInstantiateFullMaybe0$fInstantiateFullMap$fInstantiateFullHashMap$fInstantiateFull[]OutputTypeName OutputTypeVarOutputTypeVisiblePiOutputTypeNameNotYetKnownNoOutputTypeName Boundary'BoundarySplitTel firstPart secondPart splitPerm flattenTel reorderTel reorderTel_ unflattenTel renameTel teleNames teleArgNamesteleArgsteleDoms teleNamedArgstele2NamedArgssplitTelescopeAt permuteTelvarDependencies varDependentssplitTelescopesplitTelescopeExactinstantiateTelescopeexpandTelescopeVar telViewUpTo telViewUpTo' telViewPathtelViewUpToPathtelViewUpToPathBoundary' fullBoundarytelViewUpToPathBoundarytelViewUpToPathBoundaryPtelViewPathBoundaryP teleElims pathViewAsPi pathViewAsPi'pathViewAsPi'whnfpiOrPathtelView'UpToPath telView'PathisPath telePatterns telePatterns'mustBePiifPiifPiTypeifNotPi ifNotPiTypeifNotPiOrPathType typeAritygetOutputTypeNameaddTypedInstanceresolveUnknownInstanceDefsgetInstanceDefs $fPiApplyM[]$fPiApplyMNamed $fPiApplyMArg$fPiApplyMTermSynEqcheckSyntacticEquality$fSynEqArgInfo $fSynEqDom' $fSynEqArg $fSynEqAbs $fSynEqElim' $fSynEq[] $fSynEqType'' $fSynEqSort'$fSynEqLevelAtom'$fSynEqPlusLevel' $fSynEqLevel' $fSynEqTerm $fSynEqBoolSigmaKit sigmaNamesigmaConsigmaFstsigmaSnd-->.-->..-->garrgpihPinPihPi'nPi'pPi'el'elInfnolamvarMgApplygApply'<@><#><..><@@>listiopatheltset sSizeUniv tSizeUnivargNdomNargHdomHlookupPrimitiveFunctionlookupPrimitiveFunctionQgetBuiltinName isBuiltin getSigmaKit $fEqSigmaKit$fShowSigmaKit TermPositionHead Eliminated FamilyOrNotIsFamIsNotfamThing TranspOrHCompDoTranspDoHComprequireCubical primINeg' primDepIMin'primIBin primIMin' primIMax'imaximinprimIdJ primIdElim'primPOr primPartial' primPartialP' primSubOut' primIdFace' primIdPath' primTrans' primHComp' cmdToNamemkGCompunglueTranspGlueheadStopcompGlue compHCompUprimTransHCompprimComp prim_glueU' prim_unglueU' primGlue' prim_glue' prim_unglue'primFaceForall'decomposeIntervaldecomposeInterval' transpTel trFillTel$fReduceFamilyOrNot$fEqTranspOrHComp$fShowTranspOrHComp$fEqFamilyOrNot$fShowFamilyOrNot$fFunctorFamilyOrNot$fFoldableFamilyOrNot$fTraversableFamilyOrNot$fEqTermPosition$fShowTermPosition TermToPattern termToPatterndotPatternsToPatterns$fTermToPatternTermPattern'$fTermToPatternNamedNamed$fTermToPatternArgArg$fTermToPattern[][] SingleLevel SingleClosed SinglePlusLevelKitlvlTypelvlSuclvlMaxlvlZerotypeNamesucNamemaxNamezeroName levelType isLevelTypelevelSucFunctionbuiltinLevelKit requireLevels haveLevelsunLevelunlevelWithKitunConstVunPlusV maybePrimCon maybePrimDef levelView levelView' levelPlusViewlevelLowerBoundsubLevel levelMaxDiff unSingleLevelunSingleLevels levelMaxViewsingleLevelView$fFreeSingleLevel$fSubstTermSingleLevel$fEqSingleLevel$fShowSingleLevel QuotingKitquoteTermWithKitquoteTypeWithKitquoteClauseWithKitquoteDomWithKitquoteDefnWithKitquoteListWithKit quotingKit quoteString quoteNamequoteNat quoteConName quoteMeta quoteTerm quoteTypequoteDom quoteDefn quoteListPredRelOpFromTermfromTermFromTermFunctionToTermtoTermtoTermRPrimTermprimTermPrimTypeprimTypeLvlunLvlunNat buildListfromReducedTerm fromLiteralmkPrimInjectiveprimMetaToNatInjectiveprimCharToNatInjectiveprimStringToListInjectiveprimWord64ToNatInjectiveprimFloatToWord64InjectiveprimQNameToWord64sInjectivegetReflprimEraseEqualitygetReflArgInfo genPrimForce primForceprimForceLemmamkPrimLevelZeromkPrimLevelSucmkPrimLevelMaxmkPrimSetOmega mkPrimFun1TCM mkPrimFun1 mkPrimFun2 mkPrimFun4 $fShowNat $fTermLikeNat $fIntegralNat $fShowLvl $fPrimTermIO $fPrimTerm[]$fPrimTermFixity'$fPrimTermType''$fPrimTermMetaId$fPrimTermQName $fPrimTermLvl $fPrimTermNat $fPrimTermStr$fPrimTermDouble$fPrimTermChar$fPrimTermBool$fPrimTermWord64$fPrimTermInteger $fPrimTypea $fPrimTerm(,) $fPrimTerm-> $fToTerm[] $fToTerm(,)$fToTermFixityLevel$fToTermAssociativity$fToTermFixity$fToTermFixity'$fToTermArgInfo$fToTermType'' $fToTermTerm $fToTermBool$fToTermInteger$fToTermMetaId $fToTermQName $fToTermStr $fToTermChar$fToTermDouble $fToTermLvl$fToTermWord64 $fToTermNat $fFromTerm[]$fFromTermBool$fFromTermMetaId$fFromTermQName $fFromTermStr$fFromTermChar$fFromTermDouble $fFromTermLvl$fFromTermWord64 $fFromTermNat$fFromTermInteger$fEqNat$fOrdNat$fNumNat $fEnumNat $fRealNat$fEqLvl$fOrdLvl $fShowLeq$fEqLeqdefaultOpenLevelsToZerodefaultLevelsToZero ForceNotFreeIsFree MaybeFreeNotFree forceNotFree$fForceNotFreeSort'$fForceNotFreeLevelAtom'$fForceNotFreePlusLevel'$fForceNotFreeLevel'$fForceNotFreeTerm$fForceNotFreeType''$fForceNotFreeElim'$fForceNotFree[]$fForceNotFreeAbs$fForceNotFreeDom'$fForceNotFreeArg $fEqIsFree $fShowIsFree checkEmptyTelensureEmptyType isEmptyTel isEmptyTypeSubstWithOriginsubstWithOriginMonadDisplayForm dtermToTermdisplayFormArities displayFormmatchDisplayForm $fMatchLevel' $fMatchSort' $fMatchTerm $fMatchElim' $fMatchArg $fMatch[]$fSubstWithOriginArg$fSubstWithOriginDisplayTerm$fSubstWithOriginTerm$fSubstWithOriginArg0$fSubstWithOriginElim'$fSubstWithOrigin[]eliminateDeadCodeMonadConversionleqSortleqLevelleqType equalLevel equalSort equalTypeequalTermOnFace equalTerm compareLevel compareSort compareTel compareType compareElims compareArgs compareAtomcompareTermOnFace compareAs compareTermStackFrameActionMonadCheckInternalinfercheckInternal' checkInternal checkSort checkType' checkTypeeraseUnusedAction defaultAction recursiveanyDefs ToAbstract toAbstractMonadReflectedToAbstractwithNameaskName toAbstract_toAbstractWithoutImplicitmkDefmkSettoAbstractPats$fToAbstract[][]$fToAbstractQNamedClause'$fToAbstractPattern(,)$fToAbstractSortExpr$fToAbstractTermExpr$fToAbstractLiteralExpr$fToAbstractAbs(,)$fToAbstract(,)Expr$fToAbstract(,)Expr0$fToAbstract(,)TypedBinding$fToAbstract[][]0$fToAbstractArgArg$fToAbstractNamedNamed NamedClauseReifyreify reifyWhen MonadReifyreifyUnblockedreifyDisplayFormPblankNotInScope reifyPatterns$fReify(,,,)(,,,)$fReify(,,)(,,) $fReify(,)(,) $fReify[][]$fReifyElim'Elim'$fReifyDom'Arg $fReifyTele[] $fReifyAbs(,)$fReifyLevel'Expr$fReifySort'Expr$fReifyType''Expr$fReifyQNamed[] $fReifyArgArg$fReifyNamedNamed$fReifyTermExpr$fReifyLiteralExpr$fReifyDisplayTermExpr$fReifyMetaIdExpr$fReifyExprExpr$fReifyNameName$fReifyBoolBool$fReifyNamedClauseClause'$fReifyQNamedClause'$fMonoidMonoidMap$fSemigroupMonoidMap$fBlankVarsTypedBinding$fBlankVarsLamBinding$fBlankVarsRHS$fBlankVarsModuleName$fBlankVarsPattern'$fBlankVarsLHSCore'$fBlankVarsLHS$fBlankVarsProblemEq$fBlankVarsEither$fBlankVars(,)$fBlankVarsFieldAssignment' $fBlankVars[]$fBlankVarsNamed$fBlankVarsArg $fBinder(,) $fBinderMaybe $fBinder[] $fBinderNamed $fBinderArg$fBinderFieldAssignment'$fBinderLetBinding$fBinderBindName$fBinderTypedBinding$fBinderLamBinding$fBinderBinder'$fBinderPattern'$fBinderLHSCore' $fBinderLHS$fBlankVarsExpr$fBlankVarsClause'WithNode prettyTCMCtxprettyRprettyTCMPatternsprettyTCMPatternList$fPrettyTCMSplitTag$fPrettyTCMOccurrence$fPrettyTCMRewriteRule$fPrettyTCMType''$fPrettyTCMElim'$fPrettyTCMNLPSort$fPrettyTCMNLPType$fPrettyTCMNLPat$fPrettyTCMElim'0$fPrettyTCMPattern'$fPrettyTCMDBPatVar$fPrettyTCMTele$fPrettyTCMConHead$fPrettyTCMModuleName$fPrettyTCMQName$fPrettyTCMName$fPrettyTCMWithHiding$fPrettyTCMTypeCheckingProblem$fPrettyTCMCompareAs$fPrettyTCMConstraint$fPrettyTCMProblemConstraint$fPrettyTCMModality$fPrettyTCMQuantity$fPrettyTCMRelevance$fPrettyTCMTypedBinding$fPrettyTCMExpr$fPrettyTCMEqualityView$fPrettyTCMMaybeReduced$fPrettyTCMElim'1 $fPrettyTCM[]$fPrettyTCMMap$fPrettyTCMDom'$fPrettyTCMArg$fPrettyTCMNamed$fPrettyTCMBlocked$fPrettyTCMMetaId$fPrettyTCMJudgement$fPrettyTCMClause$fPrettyTCMSubstitution'$fPrettyTCMIsForced$fPrettyTCMPolarity$fPrettyTCMPermutation$fPrettyTCMLevel'$fPrettyTCMQNamed$fPrettyTCMNamedClause$fPrettyTCMDisplayTerm$fPrettyTCMSort'$fPrettyTCMType''0$fPrettyTCMTerm$fPrettyTCM(,,)$fPrettyTCM(,)$fPrettyTCM[]0$fPrettyTCMClosure$fPrettyTCMCheckpointId$fPrettyTCMRange'$fPrettyTCMProblemId$fPrettyTCMInt$fPrettyTCMLiteral$fPrettyTCMComparison$fPrettyTCMQName0$fPrettyTCMName0$fPrettyTCMBool$fPrettyTCMPrettyContext$fPrettyTCMGraph$fPrettyTCMWithNode telePiPath iApplyVarsOldSizeConstraintLeq OldSizeExprSizeMetacheckSizeLtSatcheckSizeNeverZerocheckSizeVarNeverZero isBoundedboundedSizeMetaHook trySizeUniv deepSizeView sizeMaxView compareSizescompareMaxViewscompareBelowMaxcompareSizeViewsgiveUptrivial isSizeProblemisSizeConstraintmkIsSizeConstraintisSizeConstraint_takeSizeConstraintsgetSizeConstraints getSizeMetasoldComputeSizeConstraintsoldComputeSizeConstraint oldSizeExprflexibleVariablesoldCanonicalizeSizeConstraintoldSolveSizeConstraints oldSolver$fPrettyOldSizeExpr$fPrettyOldSizeConstraint$fEqOldSizeExpr$fShowOldSizeExpr$fShowOldSizeConstraintcheckDisplayPragmasayWhere$fPrettyTCMCall$fPrettyTCMCallInfoUsableModality usableModUsableRelevance usableRelhideAndRelParams workOnTypes'applyRelevanceToContextapplyRelevanceToContextOnlyapplyRelevanceToJudgementOnlyapplyRelevanceToContextFunBodyapplyQuantityToContextapplyQuantityToContextOnlyapplyQuantityToJudgementOnlyapplyCohesionToContextapplyCohesionToContextOnlysplittableCohesionapplyModalityToContextapplyModalityToContextOnlyapplyModalityToJudgementOnlyapplyModalityToContextFunBodywakeIrrelevantVarsisIrrelevantOrPropM$fUsableRelevanceAbs$fUsableRelevanceDom'$fUsableRelevanceArg$fUsableRelevanceElim'$fUsableRelevance(,)$fUsableRelevance[]$fUsableRelevanceLevelAtom'$fUsableRelevancePlusLevel'$fUsableRelevanceLevel'$fUsableRelevanceSort'$fUsableRelevanceType''$fUsableRelevanceTerm$fUsableModalityAbs$fUsableModalityDom'$fUsableModalityArg$fUsableModalityElim'$fUsableModality(,)$fUsableModality[]$fUsableModalityLevel'$fUsableModalitySort'$fUsableModalityType''$fUsableModalityTermNormaliseProjPnormaliseProjPElimTypeArgTProjTprojTRec projTFieldmkCon orderFieldsinsertMissingFields recordModule getRecordDefgetRecordOfFieldgetRecordFieldNamesrecordFieldNamesfindPossibleRecordsgetRecordFieldTypesgetRecordTypeFieldsgetRecordConstructor isRecordType tryRecordTypeorigProjection getDefType projectTyped typeElimsisEtaCon#isEtaOrCoinductiveRecordConstructorisInductiveRecordisEtaRecordTypeunguardedRecordrecursiveRecordnonRecursiveRecordisRecursiveRecordetaExpandBoundVarexpandRecordVarexpandRecordVarsRecursivelycurryAtetaExpandRecordforceEtaExpandRecordetaExpandRecord'etaExpandRecord_etaExpandRecord'_etaExpandAtRecordTypeisSingletonRecord isSingletonRecordModuloRelevanceisSingletonRecord'isSingletonTypeisSingletonTypeModuloRelevanceisSingletonType'isEtaVaremap$fPrettyTCMElimType$fNormaliseProjPPattern'$fNormaliseProjPNamed$fNormaliseProjPArg$fNormaliseProjP[]$fNormaliseProjPClauseLeftoverPatternspatternVariables asPatterns dotPatternsabsurdPatterns otherPatternsLHSState_lhsTel _lhsOutPat _lhsProblem _lhsTarget_lhsPartialSplit AbsurdPattern DotPattern AsBindingAsBProblem _problemEqs_problemRestPats _problemCont ChooseFlex chooseFlex FlexChoice ChooseLeft ChooseRight ChooseEither ExpandBoth FlexibleVar flexArgInfo flexForcedflexKindflexPosflexVarFlexibleVarKind RecordFlex ImplicitFlexDotFlex OtherFlex FlexibleVars allFlexVars problemEqsproblemRestPats problemCont problemInPatslhsTel lhsOutPat lhsProblem lhsTargetgetLeftoverPatternsgetUserVariableNames$fPrettyTCMProblemEq$fLensModalityFlexibleVar$fLensOriginFlexibleVar$fLensHidingFlexibleVar$fLensArgInfoFlexibleVar$fMonoidFlexChoice$fSemigroupFlexChoice$fChooseFlexFlexibleVar$fChooseFlexInt$fChooseFlexOrigin$fChooseFlexHiding$fChooseFlexIsForced$fChooseFlexArgInfo$fChooseFlexMaybe$fChooseFlex[]$fChooseFlexFlexibleVarKind$fInstantiateFullAsBinding$fPrettyAsBinding$fPrettyTCMAsBinding$fSubstTermAsBinding$fPrettyTCMDotPattern$fSubstTermDotPattern$fPrettyTCMAbsurdPattern$fSubstTermAbsurdPattern$fPrettyTCMLHSState$fSubstTermProblem$fPrettyTCMLeftoverPatterns$fMonoidLeftoverPatterns$fSemigroupLeftoverPatterns$fEqFlexibleVarKind$fShowFlexibleVarKind$fEqFlexibleVar$fShowFlexibleVar$fFunctorFlexibleVar$fFoldableFlexibleVar$fTraversableFlexibleVar$fEqFlexChoice$fShowFlexChoice $fShowProblem$fShowPatVarPosition$fEqPatVarPosition matchedArgs foldMatch mergeElim mergeElimsmatchCopattern matchPatternyesSimplification matchPatternPmatchPatternsP $fMonoidMatch$fSemigroupMatch $fNullMatch$fFunctorMatchImplicitInsertion ImpInsert BadImplicits NoSuchNameNoInsertNeeded implicitArgsimplicitNamedArgs newMetaArgnewInteractionMetaArginsertImplicitinsertImplicit'$fShowImplicitInsertion implicitPinsertImplicitPatternsinsertImplicitSizeLtPatternsinsertImplicitPatternsTuseNamesFromPatternuseNamesFromProblemEqs useOriginFrom noProblemRest initLHSStateupdateProblemRestetaExpandClausegetDefcomputeForcingAnnotationsisForced nextIsForced$fForcedVariablesTerm$fForcedVariablesArg$fForcedVariablesElim'$fForcedVariables[]ConstructorInfoDataCon RecordCon getConFormgetOrigConHead consOfHITgetFullyAppliedConTypegetConstructorInfo isDatatypeisDataOrRecordTypeisDataOrRecordgetNumberOfParametersgetConstructorsgetConstructors'getConstructors_ getConHeads getConHeads' makeConHead GetMatchables getMatchables NLPatVarsnlPatVarsUnder nlPatVars NLPatToTerm nlPatToTerm PatternFrom patternFrom $fFreeNLPSort $fFreeNLPType $fFreeNLPat$fPatternFromType''TermNLPat$fPatternFrom()Level'NLPat$fPatternFrom()Sort'NLPSort$fPatternFrom()Type''NLPType$fPatternFromtDom'Dom'$fPatternFrom(,)[][]$fPatternFromDom'ArgArg$fNLPatToTermNLPSortSort'$fNLPatToTermNLPTypeType''$fNLPatToTermNLPatLevel'$fNLPatToTermNLPatTerm$fNLPatToTermIntTerm$fNLPatToTermAbsAbs$fNLPatToTermElim'Elim'$fNLPatToTermDom'Dom'$fNLPatToTermArgArg$fNLPatToTerm[][]$fNLPatVarsAbs$fNLPatVars(,)$fNLPatVarsNLPat$fNLPatVarsNLPSort$fNLPatVarsNLPType $fNLPatVarsf$fGetMatchablesRewriteRule$fGetMatchablesTerm$fGetMatchablesNLPSort$fGetMatchablesNLPType$fGetMatchablesNLPat$fGetMatchables(,)$fGetMatchablesAbs$fGetMatchablesElim'$fGetMatchablesDom'$fGetMatchablesArg$fGetMatchables[]recordPatternToProjectionstranslateCompiledClausestranslateSplitTreetranslateRecordPatterns $fDropFrom[] $fDropFrom(,)$fDropFromSplitTree' $fPrettyTCM-> $fPretty->$fPrettyTCMEither$fFunctorRecPatM$fApplicativeRecPatM$fMonadRecPatM$fMonadIORecPatM$fMonadTCMRecPatM$fHasOptionsRecPatM$fMonadTCEnvRecPatM$fMonadTCStateRecPatM$fEqKindDefNodeArgNodeComputeOccurrences occurrencesOccMOccEnvvarsinfOccurrencesBuilder'Concat' OccursAs' OccursHere'OccurrencesBuilderConcatOccursAs OccursHere OnlyVarsUpTo OccurrencesItemAnArgADefcheckStrictlyPositive getDefArity preprocessflattenwithExtendedOccEnvwithExtendedOccEnv'getOccurrencescomputeOccurrencescomputeOccurrences' mergeEdgesbuildOccurrenceGraph computeEdges$fPrettyTCMSeq$fHasRangeItem$fMonoidOccurrencesBuilder$fSemigroupOccurrencesBuilder$fComputeOccurrences(,)$fComputeOccurrencesMaybe$fComputeOccurrences[]$fComputeOccurrencesDom'$fComputeOccurrencesArg$fComputeOccurrencesElim'$fComputeOccurrencesAbs$fComputeOccurrencesTele$fComputeOccurrencesType''$fComputeOccurrencesLevelAtom'$fComputeOccurrencesPlusLevel'$fComputeOccurrencesLevel'$fComputeOccurrencesTerm$fComputeOccurrencesClause$fPrettyTCMNode$fSemiRingEdge$fEqItem $fOrdItem $fShowItemProjectionViewLoneProjectionLike NoProjection projViewProj projViewSelf projViewSpine unProjViewprojViewreduceProjectionLikeelimView inferUnivSort sortFitsIn hasBiggerSort inferPiSort inferFunSortptsRuleptsRule' hasPTSRulecheckTelePiSortifIsSort shouldBeSortsortOfprettyConstraintinterestingConstraintprettyInterestingConstraints prettyWarningprettyTCWarningsprettyTCWarnings'filterTCWarningstcWarningsToErrorapplyFlagsToTCWarnings'applyFlagsToTCWarnings$fPrettyTCMWarning$fPrettyTCMTCWarning HasPolarity polaritiesneg polFromOcc nextPolaritypurgeNonvariantpolarityFromPositivityenablePhantomTypesdependentPolarityrelevantInIgnoringNonvariant sizePolaritycheckSizeIndexpolarity$fHasPolarityLevelAtom'$fHasPolarityPlusLevel'$fHasPolarityLevel'$fHasPolarityTerm$fHasPolarityElim'$fHasPolarityType''$fHasPolarity(,)$fHasPolarity[]$fHasPolarityAbs$fHasPolarityDom'$fHasPolarityArgInvViewInvNoInv headSymbol headSymbol' topLevelArg joinHeadMaps updateHeadscheckInjectivitycheckInjectivity'checkOverapplicationinstantiateVarHeadsfunctionInverseuseInjectivityinvertFunctionforcePiUsingInjectivity SplitPattern SplitPatVarsplitPatVarNamesplitPatVarIndexsplitExcludedLits BlockingVars BlockingVar blockingVarNoblockingVarConsblockingVarLitsblockingVarOverlapblockingVarLazy ApplyOrIApplyIsApplyIsIApplyBlockedOnResult BlockedOnProjBlockedOnApplyNotBlockedOnResultblockedOnResultOverlapblockedOnResultIApplyBlockblockedOnResult blockedOnVarstoSplitPatternsfromSplitPatterns toSplitPSubstapplySplitPSubstisTrivialPatternsetBlockingVarOverlap matchClause$fPrettyBlockingVar$fDeBruijnSplitPatVar$fPrettyTCMSplitPatVar$fPrettySplitPatVar$fShowBlockingVar$fShowSplitPatVarPureConversionTunPureConversionT FreshThingsfreshIntfreshProblemId freshNameId pureEqualTerm pureCompareAsrunPureConversion$fMonadFreshIntPureConversionT!$fMonadFreshNameIdPureConversionT$$fMonadFreshProblemIdPureConversionT $fMonadStatisticsPureConversionT$fMonadWarningPureConversionT%$fMonadStConcreteNamesPureConversionT'$fMonadInteractionPointsPureConversionT $fMonadMetaSolverPureConversionT $fMonadConstraintPureConversionT$fNullPureConversionT$fIsStringPureConversionT$fSemigroupPureConversionT$fFunctorPureConversionT$fApplicativePureConversionT$fMonadPureConversionT$fMonadErrorPureConversionT$fMonadStatePureConversionT$fMonadDebugPureConversionT $fMonadAddContextPureConversionT$fMonadReducePureConversionT$fReadTCStatePureConversionT$fMonadTCEnvPureConversionT$fHasOptionsPureConversionT$fHasConstInfoPureConversionT$fHasBuiltinsPureConversionT$fMonadFailPureConversionTPostponedEquationsPostponedEquation eqFreeVarseqTypeeqLhseqRhsNLMState_nlmSub_nlmEqsNLMnlmSubnlmEqsrunNLMmatchingBlockedtellSubtellEq reallyFreemakeSubstitutioncheckPostponedEquations nonLinMatchequal$fNullNLMState$fMatchType''NLPatTerm$fMatch()NLPatLevel'$fMatch()NLPSortSort'$fMatch()NLPTypeType''$fMatchtDom'Dom'$fMatch(,)[][]$fMatchDom'ArgArgCallPath callInfosMaskedgetMask getMaskedMaskedDeBruijnPatternsUsableSizeVarsusableSizeVarsTerMterMMonadTerterAskterLocalterAsksTerEnvterUseDotPatterns terSizeSucterSharp terCutOff terCurrent terMutual terUserNamesterHaveInlinedWith terTarget terDelayed terMaskArgs terMaskResult _terSizeDepth terPatternsterPatternsRaise terGuarded terUseSizeLt terUsableVarsTarget MutualNames defaultTerEnvrunTer runTerDefaultterGetUseDotPatternsterSetUseDotPatterns terGetSizeSuc terGetCurrent terSetCurrent terGetSharp terGetCutOff terGetMutualterGetUserNames terGetTarget terSetTargetterGetHaveInlinedWithterSetHaveInlinedWith terGetDelayed terSetDelayedterGetMaskArgsterSetMaskArgsterGetMaskResultterSetMaskResultterGetPatternsterSetPatternsterRaise terGetGuardedterModifyGuarded terSetGuarded terUnguarded terSizeDepthterGetUsableVarsterModifyUsableVarsterSetUsableVarsterGetUseSizeLtterModifyUseSizeLtterSetUseSizeLtwithUsableVars conUseSizeLt projUseSizeLtisProjectionButNotCoinductiveisCoinductiveProjection patternDepth unusedVarmasked notMaskedterSetSizeDepth$fPrettyTCMMasked$fDecorationMasked $fMonoidTerM$fSemigroupTerM$fUsableSizeVars[]$fUsableSizeVarsMasked$fUsableSizeVars[]0$fUsableSizeVarsPattern'$fMonadTerTerM$fPrettyCallPath $fEqMasked $fOrdMasked $fShowMasked$fFunctorMasked$fFoldableMasked$fTraversableMasked $fFunctorTerM$fApplicativeTerM $fMonadTerM$fMonadFailTerM$fMonadErrorTerM$fMonadBenchTerM$fMonadStatisticsTerM$fHasOptionsTerM$fHasBuiltinsTerM$fMonadDebugTerM$fHasConstInfoTerM $fMonadIOTerM$fMonadTCEnvTerM$fMonadTCStateTerM$fMonadTCMTerM$fReadTCStateTerM$fMonadReduceTerM$fMonadAddContextTerM$fShowCallPath$fSemigroupCallPath$fMonoidCallPath$fAllNamesCallPath tcErrString stringTCErrdropTopLevelModule$fPrettyTCMNegativeUnification$fPrettyTCMSplitError$fPrettyTCMTCErr$fPrettyUnequalType''$fPrettyUnequalTerm$fVerbalizeCohesion$fVerbalizeQuantity$fVerbalizeRelevance$fVerbalizeHiding$fPrettyTCMUnificationFailure$fVerbalizeIndefinite$fPrettyTCMTypeError findInstanceisInstanceConstraintshouldPostponeInstanceSearchpostponeInstanceConstraints$fShowYesNoMaybecatchPatternErrTCMaddConstraintTCMwakeConstraintsTCMstealConstraintsTCM newProblem newProblem_whenConstraintswakeConstraints'wakeupConstraintswakeupConstraints_solveAwakeConstraintssolveSomeAwakeConstraintsTCMsolveConstraintTCMsolveConstraint_checkTypeCheckingProblem$fMonadConstraintTCMT PruneResultNothingToPrune PrunedNothingPrunedSomethingPrunedEverythingAnyRigidanyRigidoccurs metaOccursUnfoldStrategy YesUnfoldNoUnfold AllowedVarOccursM OccursCtx OccursExtra occUnfoldoccVarsoccMeta occCxtSizemodifyOccursCheckDefsinitOccursCheckdefNeedsCheckingtallyDef variableCheckdefinitionCheck allowedVarsdefArgsunfoldBunfoldweaklystronglyflexiblypatternViolation' occursCheckmetaOccursQNameprune hasBadRigid isNeutralrigidVarsNotContainedInkillArgs killedTypereallyNotFreeIn performKill$fIsVarSet()-> $fOccurs(,) $fOccursMaybe $fOccurs[] $fOccursDom' $fOccursArg $fOccursAbs $fOccursElim' $fOccursSort'$fOccursType''$fOccursLevelAtom'$fOccursPlusLevel'$fOccursLevel'$fOccursClause $fOccursDefn $fOccursQName $fAnyRigid(,) $fAnyRigid[]$fAnyRigidElim'$fAnyRigidDom' $fAnyRigidArg $fAnyRigidAbs$fAnyRigidLevelAtom'$fAnyRigidPlusLevel'$fAnyRigidLevel'$fAnyRigidSort'$fAnyRigidType''$fAnyRigidTerm $fOccursTerm$fEqUnfoldStrategy$fShowUnfoldStrategy$fEqPruneResult$fShowPruneResult InvertExcept CantInvert NeutralArg ProjectedVarRes SubstCandFVsReduceAndEtaContractreduceAndEtaContract ProjVarExcNoProjectedVarnoProjectedVarfindIdx isBlockedTermisEtaExpandableassignTermTCM'newSortMetaBelowInfnewSortMetaCtx newTypeMeta' newTypeMeta newTypeMeta_ newLevelMetanewInstanceMetaCtxnewValueMetaCtx newValueMeta'newValueMetaCtx' trueConditionnewArgsMetaCtxnewArgsMetaCtx' newRecordMetanewRecordMetaCtxnewQuestionMarknewQuestionMark' blockTermblockTermOnProblemblockTypeOnProblemunblockedTesterpostponeTypeCheckingProblem_postponeTypeCheckingProblemetaExpandListenerswakeupListeneretaExpandMetaTCMetaExpandBlocked assignWrapper assignMeta assignMeta'checkSolutionForMetacheckSubtypeIsEqualsubtypingForSizeLtexpandProjectedVarsetaExpandProjectedVarcheckLinearity inverseSubstopenMetasToPostulatesdependencySortMetas$fMonadMetaSolverTCMT$fNoProjectedVar[]$fNoProjectedVarArg$fNoProjectedVarTerm$fReduceAndEtaContractTerm$fReduceAndEtaContractArg$fReduceAndEtaContract[]HypSizeConstraint sizeContext sizeHypIdssizeHypothesessizeConstraintSizeConstraint DBSizeExpr sizeMetaId sizeMetaArgs NamedRigid rigidName rigidIndexDefaultToInftyDontDefaultToInftyCCsolveSizeConstraintscastConstraintToCurrentContext'castConstraintToCurrentContextsolveSizeConstraints_ solveClustergetSizeHypothesescanonicalizeSizeConstraintcomputeSizeConstraintsizeExpr unSizeExpr$fPlusNamedRigidIntNamedRigid$fPrettyNamedRigid$fOrdNamedRigid$fEqNamedRigid$fSubstTermSizeExpr'$fSubstTermSizeMeta$fPrettyTCMSizeMeta$fPrettySizeMeta $fOrdSizeMeta $fEqSizeMeta$fPrettyTCMConstraint'$fSubstTermConstraint'$fPrettyTCMHypSizeConstraint $fFlexsSizeMetaHypSizeConstraint$fEqDefaultToInfty$fOrdDefaultToInfty$fShowDefaultToInfty$fShowNamedRigid$fShowSizeMetaConj tryConversiontryConversion'sameVars intersectVars equalAtom convErrorassignE compareAsDir compareAs' compareTerm'compareAtomDircomputeElimHeadType compareDomcompareRelevancecompareQuantitycompareCohesion antiUnify antiUnifyArgs antiUnifyTypeantiUnifyElimscompareIrrelevantcompareWithPol polFromCmpcoerce coerceSize equalLevel'forallFaceMapscompareInterval isCanonical leqIntervalleqConjcompareTermOnFace' bothAbsurd ErrorPartStrPartTermPartunquote UnquoteResUnquoteM UnquoteStateDirtyClean agdaTermType agdaTypeType qNameTypeunpackUnquoteM packUnquoteM runUnquoteMliftU1liftU2inOriginalContextisConisDefreduceQuotedTermunquoteNchoice ensureDef ensureConpickName unquoteStringunquoteNString unquoteTCMevalTCM$fUnquoteClause$fUnquotePattern $fUnquoteTerm$fUnquoteLiteral $fUnquoteSort $fUnquoteDom'$fUnquoteMetaId $fUnquoteAbs$fUnquoteQName$fUnquoteRelevance$fUnquoteHiding $fUnquote[] $fUnquoteStr $fUnquoteChar$fUnquoteDouble$fUnquoteWord64$fUnquoteInteger $fUnquoteBool$fUnquoteElim' $fUnquoteArg$fUnquoteArgInfo$fUnquoteModality$fUnquoteErrorPart$fPrettyTCMErrorPart $fEqDirtyUnificationResult'UnifiesNoUnifyUnificationResult unifyIndices$fReduceEquality$fPrettyTCMUnifyState$fReduceUnifyState$fPrettyTCMUnifyStep$fMonoidUnifyOutput$fSemigroupUnifyOutput$fShowUnificationResult'$fFunctorUnificationResult'$fFoldableUnificationResult'$fTraversableUnificationResult'$fShowUnifyState$fShowUnifyStep$fEqRetryNormalised$fShowRetryNormalisedcheckConfluenceOfRulescheckConfluenceOfClause$fAllHolesLevelAtom'$fAllHolesPlusLevel' $fAllHoles[]$fAllHolesLevel'$fAllHolesSort'$fAllHolesTerm$fAllHolesType'' $fAllHoles[]0 $fAllHolesAbs$fAllHolesAbs0$fAllHolesDom' $fAllHolesArg$fMetasToVars(,,,)$fMetasToVars(,,)$fMetasToVars(,)$fMetasToVarsTele$fMetasToVarsLevelAtom'$fMetasToVarsPlusLevel'$fMetasToVarsLevel'$fMetasToVarsSort'$fMetasToVarsType''$fMetasToVarsTerm$fMetasToVarsAbs$fMetasToVarsElim'$fMetasToVarsDom'$fMetasToVarsArg$fMetasToVars[]$fFunctorOneHoleRelView relViewTel relViewDelta relViewType relViewType' relViewCorerequireOptionRewritingrelViewaddRewriteRulescheckRewriteRule rewriteWith$fPrettyFastCase$fPrettyFastCompiledClauses $fPrettyThunk$fPrettyClosure$fPrettyPointer$fPrettyCatchAllFrame$fPrettyMatchStack$fZipperElimZipper$fPrettyControlFrame $fPrettyAM$fEqNormalisation$fFunctorThunk$fEqElimZipper$fOrdElimZipper$fShowElimZipper$fFunctorElimZipper$fFoldableElimZipper$fTraversableElimZippercheckIApplyConfluence_checkIApplyConfluence unifyElimsunifyElimsMetageneralizeTelescopegeneralizeTypegeneralizeType' IsPathConsPathCons PointConsCType ClosedTypeLTypeLEl checkDataDef forceSortcheckConstructordefineCompDatadefineProjectionsfreshAbstractQName'_ fromLType lTypeLeveltoLType fromCTypetoCTypedefineTranspOrHCompForFieldsdefineTranspForFieldsdefineHCompForFieldsgetGeneralizedParametersbindGeneralizedParametersbindParameters bindParameterfitsIncheckIndexSorts constructs isCoinductive$fSubstTermLType$fSubstTermCType $fEqLType $fShowLType $fEqCType $fShowCType$fEqIsPathCons$fShowIsPathCons preAction postActionrelevanceAction inferSortreconstructParametersInTypereconstructParametersInTelreconstructParametersInEqViewreconstructParametersdropParameters etaExpandOnce deepEtaExpandetaExpandActionEqualSyequalSyAbsTermabsTerm IsPrefixOf isPrefixOf abstractTypepiAbstractTerm piAbstract abstractTermswap01 $fAbsTerm(,) $fAbsTermAbs$fAbsTermMaybe $fAbsTerm[] $fAbsTermDom' $fAbsTermArg$fAbsTermElim'$fAbsTermLevelAtom'$fAbsTermPlusLevel'$fAbsTermLevel'$fAbsTermSort'$fAbsTermType'' $fAbsTermTerm $fEqualSyArg $fEqualSyDom'$fEqualSyArgInfo $fEqualSyAbs$fEqualSyElim'$fEqualSyType''$fEqualSySort'$fEqualSyLevelAtom'$fEqualSyPlusLevel'$fEqualSyLevel' $fEqualSyTerm $fEqualSy[]$fIsPrefixOfTerm$fIsPrefixOf[]$fIsPrefixOf[]0splitTelForWithwithFunctionType countWithArgs withArgumentsbuildWithFunctionstripWithClausePatternswithDisplayForm patsToElimsResulttermDecl termMutual$fExtractCallsLevelAtom'$fExtractCallsPlusLevel'$fExtractCallsLevel'$fExtractCallsTerm$fExtractCallsType''$fExtractCallsSort'$fExtractCalls(,)$fExtractCalls[]$fExtractCallsElim'$fExtractCallsDom'$fExtractCallsArg$fExtractCallsAbs$fStripAllProjectionsTerm$fStripAllProjections[]$fStripAllProjections[]0$fStripAllProjectionsArgsanityCheckVarssanityCheckSubstparseIdiomBracketsSeqdesugarDoNotationreadline EncodeTCM encodeTCMobj#=@=kindkind' $fToJSONMaybe$fToJSONAbsolutePath $fToJSONDoc$fEncodeTCMMaybe$fEncodeTCMDoc$fEncodeTCMValue$fEncodeTCMInt32$fEncodeTCMInt$fEncodeTCMBool $fEncodeTCM[]$fEncodeTCM[]0vimFileescape wordBoundedmatchestoVimgenerateVimFileDotMDotState dsModules dsNameSupply dsConnectionModuleIdinitialDotState addModule addConnectiondottify generateDottoAtomschooseHighlightingMethod usedArgumentsstripUnusedArguments simplifyTTerm $fShowAtom$fEqAtom $fOrdAtomnormalizeNamesdetectIdentityFunctions$fSemigroupIdentityIncomputeErasedConstructorArgs eraseTerms $fEqTypeInfo$fShowTypeInfo BuiltinKitnateliminateLiteralPatterns transformeliminateCaseDefaultstranslateBuiltins closedTerm addCoercions erasedArity callCompiler callCompiler'jsonifyHighlightingInfo$fToJSONTokenBased$fEncodeTCMTokenBasedFullPartialgenerateAndPrintSyntaxInfogenerateTokenInfogenerateTokenInfoFromSourcegenerateTokenInfoFromStringprintSyntaxInfoprintErrorInfoerrorHighlightingwarningHighlightingprintUnsolvedInfocomputeUnsolvedMetaWarningscomputeUnsolvedConstraintsstoreDisambiguatedNamedisambiguateRecordFields LHSResult lhsParameters lhsVarTele lhsPatterns lhsHasAbsurd lhsBodyType lhsPatSubst lhsAsBindingslhsPartialSplitIsFlexiblePatternmaybeFlexiblePatternisFlexiblePatternbindAsPatternscheckLeftHandSidecheckSortOfSplitVar$fIsFlexiblePatternNamed$fIsFlexiblePatternArg$fIsFlexiblePattern[]$fIsFlexiblePatternPattern'$fIsFlexiblePatternPattern'0$fInstantiateFullLHSResultLamOrPiLamNotPiPiNotLamisTypeisType' checkLevelnoFunctionsIntoSize isTypeEqualToleqType_checkGeneralizeTelescopecheckTelescopecheckPiTelescopecheckTelescope'checkTypedBindingsaddTypedPatternscheckTacticAttributeifPath checkPath checkLambdalambdaModalityChecklambdaIrrelevanceChecklambdaQuantityChecklambdaCohesionChecklambdaAddContextinsertHiddenLambdascheckAbsurdLambdacheckExtendedLambda!catchIlltypedPatternBlockedOnMetaexpandModuleAssignscheckRecordExpressioncheckRecordUpdate checkLiteral scopedExprunquoteMcheckQuestionMarkcheckUnderscore checkMeta inferMetacheckOrInferMeta domainFreecheckKnownArgumentscheckKnownArgument checkNamedArg inferExpr'defOrVarcheckDontExpandLastisModuleFreeVarinferExprForWithcheckLetBindingscheckLetBinding $fEqLamOrPi $fShowLamOrPibindPostulatedName bindBuiltinisUntypedBuiltinbindUntypedBuiltinbindBuiltinNoDefbuiltinKindOfName AbstractRHS TopLevelInfo topLevelDecls topLevelScopeTopLevel topLevelPathtopLevelExpectedNametopLevelTheThing OldModuleNameNewModuleQName NewModuleNameAPatNamePatNameOldNameOldQNameNewNameconcreteToAbstract_concreteToAbstractlocalToAbstract$$fToAbstractHoleContent'HoleContent'$fToAbstractPattern'Pattern'$fToAbstractLHSCore'LHSCore' $fToAbstractWithHidingWithHiding"$fToAbstractRewriteEqn'RewriteEqn'#$fToAbstractRewriteEqn'RewriteEqn'0,$fToAbstractFieldAssignment'FieldAssignment'$fToAbstractMaybeMaybe$fToAbstractEitherEither$fToAbstract(,,)(,,)$fToAbstract(,)(,)$fToAbstract()()%$fToAbstractRecordConstructorTypeExpr!$fToAbstractLamBinding'LamBinding$fToAbstractBinder'Binder'$fToAbstractNewNameBindName$fToAbstractNewNameName$fToAbstractPatternPattern'$fToAbstractMaybeOldQNameMaybe$fToAbstractOldQNameExpr$fToAbstractLHSCoreLHSCore'$$fToAbstractResolveQNameResolvedName$fToAbstractPatNameAPatName$fToAbstractOldNameQName$fToQNameQName $fToQNameName#$fToAbstractNewModuleNameModuleName$$fToAbstractNewModuleQNameModuleName$fToAbstractModuleAssignment(,)#$fToAbstractOldModuleNameModuleName$fEnsureNoLetStms[]$fEnsureNoLetStmsArg$fEnsureNoLetStmsNamed$fEnsureNoLetStmsLamBinding'$fEnsureNoLetStmsTypedBinding'$fEnsureNoLetStmsBinder' $fToAbstractTopLevelTopLevelInfo%$fToAbstractTypedBinding'TypedBinding$fToAbstractExprExpr$fToAbstractLetDef[]$fToAbstractLetDefs[]%$fToAbstractGenTelGeneralizeTelescope$fToAbstractGenTelAndType(,)$fLivesInCurrentModuleQName"$fLivesInCurrentModuleAbstractName!$fToAbstractConstrDeclDeclaration&$fToAbstractNiceDeclarationDeclaration$fToAbstractRHS'AbstractRHS$$fToAbstractRightHandSideAbstractRHS$fToAbstractAbstractRHSRHS$fToAbstractLeftHandSideLHS$fToAbstractClauseClause'$fToAbstractPragma[]$fFunctorNewNameCovering covSplitArgcovSplitClauses SplitClauseSClausescTelscPatsscSubst scCheckpointsscTarget splitClausesclauseToSplitClause coverageCheck isCoveredinsertTrailingArgssplitClauseWithAbsurd splitLast splitResult$fPrettyTCMSplitClause$fEqInsertTrailing$fShowInsertTrailing$fEqAllowPartialCover$fShowAllowPartialCover$fMonoidErrorNonEmpty$fSemigroupErrorNonEmptyClsClclPatsclBodyRunRecordPatternTranslationDontRunRecordPatternTranslationcompileClauses'unBruijncompileWithSplitTreecompile nextSplit properSplitisVarsplitOnsplitCexpandCatchAllsensureNPatterns substBody$$fPrecomputeFreeVarsCompiledClauses' $fPrettyCl$fEqRunRecordPatternTranslation$fShowCl checkRecDefaddCompositionForRecorddefineCompKitRdefineTranspOrHCompRcheckRecordProjectionsClausesPostChecksCPCcpcPartialSplitsWithFunctionProblemNoWithFunction WithFunction wfParentNamewfName wfParentType wfParentTel wfBeforeTel wfAfterTelwfExprs wfRHSType wfParentPatswfParentParams wfPermSplit wfPermParent wfPermFinal wfClausescheckMacroTypeisAlias checkAlias checkFunDefSinsertPatternsinsertPatternsLHSCorecheckSystemCoveragecheckClauseLHS checkClausecheckRHS checkWithRHScheckWithFunction checkWhereatClause$fMonoidClausesPostChecks$fSemigroupClausesPostChecks toTreelessclosedTermToTreelessShowHeadshowHeadHighlightModuleContentsDontHightlightModuleContentsDoHighlightModuleContents FinalCheckscheckDeclCached mutualChecksrevisitRecordPatternTranslationcheckUnquoteDeclcheckUnquoteDef unquoteTopinstantiateDefinitionType highlight_checkTermination_checkPositivity_checkCoinductiveRecordscheckInjectivity_checkProjectionLikeness_whenAbstractFreezeMetasAftercheckGeneralize checkAxiom checkAxiom'checkPrimitive checkPragma checkMutualcheckTypeSignaturecheckTypeSignature' checkSectioncheckModuleAritycheckSectionApplication' checkImportdebugPrintDecl$fShowHeadDeclaration$fEqHighlightModuleContentslispifyTokenBasedlispifyHighlightingInfo parseExpr parseExprIngiveExpr redoChecksgiverefine evalInCurrent evalInMeta normalFormcomputeIgnoreAbstractcomputeWrapInput showComputed outputFormIdreifyElimToExprprettyConstraintsgetConstraints namedMetaOfgetConstraintsMentioningstripConstraintPidsgetConstraints' getIPBoundarygetGoals showGoalsgetWarningsAndNonFatalErrorsgetResponseContextgetSolvedInteractionPoints typeOfMetaMI typeOfMeta typeOfMeta'typesOfVisibleMetastypesOfHiddenMetasmetaHelperType contextOfMeta typeInCurrent typeInMetawithInteractionId withMetaId introTactic atTopLevel parseNameisQNamemoduleContentsgetRecordContentsgetModuleContents$fPrettyIPBoundary'"$fToConcreteIPBoundary'IPBoundary'$fReifyIPBoundary'IPBoundary'.$fToConcreteOutputConstraint'OutputConstraint'$fPrettyOutputConstraint',$fToConcreteOutputConstraintOutputConstraint $fToConcreteOutputFormOutputForm$fPrettyOutputConstraint$fPrettyOutputForm!$fReifyConstraintOutputConstraint$fReifyProblemConstraintClosure findMentions ClauseZipper CaseContextparseVariablesgetClauseZipperForIPrecheckAbstractClausemakeCasemakePatternVarsVisiblemakeAbsurdClausemakeAbstractClauseanyEllipsisVar ConversionconvertMOTTOMsConstssMetassEqssCurMeta sMainMetaMapSTModeTMAllHinthintIsConstructor hintQNameinitMapSpopMapStomygetdfvgetMetagetEqscopatternsNotImplementedliteralsNotImplementedhitsNotImplementedtomyIneqfmTypefmExpfmExpsfmLevelicnvh frommyExps abslamvarnamemodifyAbstractExprmodifyAbstractClause constructPats frommyClausecontains_constructornegtypefindClauseDeep matchType$fConversionExceptTExpTerm$fConversionExceptTExpType''$fConversionExceptTAbsAbs$fConversionExceptTMMb$fConversionStateT[]MM$fConversionStateTArg(,)$fConversionStateTTermMM$fConversionStateTType''MM$fConversionStateTArgPat$fConversionStateTClauseMaybe$fConversionStateT[][] $fEqTMode ScopeCheck TypeCheck SourceInfosiSource siFileTypesiModule siModuleName sourceInfoincludeStateChangesmergeInterfaceaddImportedThingsapplyFlagsToMaybeWarnings hasWarningsalreadyVisited typeCheckMain getInterface getInterface_ getInterface'checkOptionsCompatibleisCachedgetStoredInterface typeCheckchaseMsghighlightFromInterface readInterfacereadInterface'writeInterfaceremovePrivatesconcreteOptionsToOptionPragmascreateInterfacegetUniqueMetasRangesgetUnsolvedMetasgetAllUnsolvedgetAllWarningsgetAllWarnings'getMaybeWarnings'getAllWarningsOfTCErrconstructIScopebuildInterfacegetInterfaceFileHashesgetInterfaceFileHashes' moduleHash isNewerThan$fNullMaybeWarnings'$fEqMode $fShowMode$fEqMainInterface$fShowMainInterface$fShowMaybeWarnings'$fFunctorMaybeWarnings'$fFoldableMaybeWarnings'$fTraversableMaybeWarnings'ExitCodeContinue ContinueInReturn matchCommand interaction continueAfterwithCurrentFileloadFileshowConstraints showMetas showScope metaParseExpr actOnMetagiveMeta refineMetaretryConstraintsevalInevalTermtypeOftypeIn showContext splashScreenhelp AutoResult autoProgress autoMessage AutoProgress Solutions FunClauses RefinementautoIsMainNotMain doCompile setInterfacecurIFcurSigcurMNamecurDefssortDefssigMName compileDirrepl inCompilerEnv$fMonoidIsMain$fSemigroupIsMain $fEqIsMain $fShowIsMainKindOfForeignCodeForeignFileHeaderPragma ForeignImport ForeignOther HaskellPragmaHsDefnHsTypeHsDataHsExport HaskellType HaskellCode parsePragmaparseHaskellPragmagetHaskellPragmasanityCheckPragmagetHaskellConstructorforeignHaskellclassifyForeignclassifyPragmapartitionByKindOfForeignCode$fPrettyHaskellPragma$fHasRangeHaskellPragma$fShowHaskellPragma$fEqHaskellPragmacurHsModihnameunqhnametlmodOfxqualxhqnhsNameconhqnbltQualdnamedunamehsPrimOp hsPrimOpApphsInt hsTypedInt hsTypedDoublehsLethsVarUQ hsAppView hsOpToExphsLambdahsMapAlthsMapRHSmazstrmazNamemazMod'mazModmazerror mazCoerceName mazErasedNamemazAnyTypeName mazCoercemazIncompleteMatchrtmIncompleteMatchmazUnreachableErrorrtmUnreachableError mazAnyTypemazRTErtmQualrtmVarrtmErrorunsafeCoerceModfakeDfakeDSfakeDQfakeTypefakeExpfakeDecl emptyBinds isModCharencodeModuleName prettyPrint prettyWhere prettyRhsprettyGuardedRhs prettyQName $fPrettyQOp $fPrettyAlt $fPrettyStmt $fPrettyType$fPrettyTyVarBind$fPrettyDataOrNew $fPrettyBinds $fPrettyPat $fPrettyMatch$fPrettyStrictness$fPrettyConDecl $fPrettyDecl$fPrettyImportSpec$fPrettyImportDecl$fPrettyModulePragmaisMainFunctionhasMainFunctioncheckTypeOfMaintreelessPrimNameimportsForPrimxForPrimprimBody noCheckCoverpconNamebltQual' haskellTypecheckConstructorCounthsTelApproximationhsTelApproximation'$fEqPolyApprox RecompileBackend' backendNamebackendVersionoptionscommandLineFlags isEnabled preCompile postCompile preModule postModule compileDefscopeCheckingSuffices mayEraseType callBackend activeBackendparseBackendOptionsbackendInteraction generateLaTeX $fShowKind$fShowAlignmentColumn $fShowOutput $fEqDebug $fShowDebug GiveRefineGiveRefineIntro ElaborateGivelocalStateCommandMliftLocalStaterevLift revLiftTC commandMToIO liftCommandMTliftCommandMTLocalStatemodifyTheInteractionPointsmodifyOldInteractionScopesinsertOldInteractionScoperemoveOldInteractionScopegetOldInteractionScopehandleCommand_ handleCommandrunInteraction maybeAbortinitialiseCommandQueue independentupdateInteractionPointsAfter interpretsolveInstantiatedGoals cmd_load'give_gen highlightExprsortInteractionPointscmd_goal_type_context_andshowModuleContents searchAboutsetCommandLineOptsstatus displayStatus display_infoparseAndDoAtToplevel maybeTimedtellToUpdateHighlightingtellEmacsToJumpToError$fEqGiveRefine$fShowGiveRefine mimicGHCi showInfoErrorexplainWhyInScopeprettyTypeOfMetajsonREPL$fEncodeTCMResponse$fEncodeTCMGoalTypeAux$fEncodeTCMDisplayInfo$fEncodeTCMOutputForm$fToJSONComputeMode$fEncodeTCMComputeMode$fToJSONCPUTime$fEncodeTCMCPUTime$fToJSONRewrite$fEncodeTCMRewrite$fToJSONMakeCaseVariant$fEncodeTCMMakeCaseVariant$fToJSONGiveResult$fEncodeTCMGiveResult$fToJSONInteractionId$fEncodeTCMInteractionId$fToJSONProblemId$fEncodeTCMProblemId$fToJSONRange'$fEncodeTCMRange'$fToJSONPosition'$fEncodeTCMPosition'$fEncodeTCMResponseContextEntry$fToJSONCommandState$fEncodeTCMCommandState$fToJSONStatus$fEncodeTCMStatus$fToJSONNameInScope$fEncodeTCMNameInScopedefaultCSSFile generateHTMLgenerateHTMLWithPageGen generatePagepage tokenStream CCContext NameSupplyCCEnv _ccNameSupply _ccContext GHCModuleEnv GHCOptions optGhcCompile optGhcCallGhc optGhcFlags ghcBackend ghcBackend'defaultGHCOptionsghcCommandLineFlags ghcPreCompileghcPostCompile ghcPreModule ghcPostModule ghcCompileDefghcMayEraseTypeimports definitionconstructorCoverageCode ccNameSupply ccContext initCCEnv freshNamesintroscheckConstructorType checkCovermkIfterm noApplicationhsCoerce compilePrimalthslitlitqname litqnamepatcondeclcompiledcondeclcompiledTypeSynonymtvaldeclinfodeclcopyRTEModules writeModuleoutFile'outFileoutFile_callGHC JSModuleEnv JSOptions optJSCompile jsBackend jsBackend'defaultJSOptionsjsCommandLineFlags jsPreCompile jsPostCompile jsPreModule jsPostModule jsCompileDefprefixjsMod jsFileNamejsMemberglobal'globalreorderreorder'isTopLevelValue isEmptyObject insertAfter curModulecheckCompilerPragmasdefJSDef definition' compileTerm compileTerm' compileAlt visitorNameflatNamelocal primitivesrunAgdarunAgda'defaultInteractionrunAgdaWithOptions printUsage backendUsage printVersion optionErrorrunTCMPrettyErrorsmainghc-prim GHC.TypesBool integer-gmpGHC.Integer.TypeGHC.Num+FunctorGHC.IO.ExceptionGHC.IOcatch CopyDirActionMkDirCopyFile performActioncopyDirContentDryRun copyIfChangedconvertLineEndings GHC.IORefIORef Data.IORefatomicWriteIORefatomicModifyIORef'atomicModifyIORef modifyIORef' modifyIORef mkWeakIORef writeIORef readIORefnewIORefBelowAboveData.Map.InternalmapKeysTrue GHC.MaybeControl.Monad.Reader.Class MonadReaderwarningNameDescription HelpTopic Applicative Data.FoldableFoldableOrdering GHC.ClassesOrdGHC.ShowShowshowDocsPGLeftFalseRightContPospgparserdocsstarDocs prettyKey memoiseDocsEqFilePathdirectory-1.3.3.0System.DirectorycanonicalizePath doesFileExist text-1.2.3.1Data.Text.Internal.LazyTextSmallSetElement fromBoolList toBoolListtoBoolListZipWithsingletonOrEveryPrefixinitlast==. Data.OldListsortBycomparegroupByelemzipWith System.IOputStrLndisplayInBufferrunningInfoBufferNameeitherEither dropWhilemaxmkLayersbleachisBlankbreak1getLine emptyLiteraterex<=unP splitAlts GenericLineHeaderContentfName fOptionalfParsefSetgeHeader _geContent GenericFileP agdaLibFieldsparseLib fromGeneric fromGeneric' checkFields findField parseGeneric parseLine groupLines GenericEntry stripCommentsGHC.EnummaxBoundfmapreachableFromInternalfoldr1orall&&anyFieldSignaturemapM MonadicFixPol plusFixities declaredNamesmempty mergeAspectsMonoid-geniplate-mirror-0.7.6-EIfUrB4KSUw39sxaK8HtlFData.Generics.GeniplateinstanceUniverseBiT universeBiinstanceTransformBiMT transformBiM TransposeinfSizelengthblowUpSparseVecunionAssocWithcollapseokMmaxOminOmappendcombineNewOldCallGraphlitError stringToken lexString lexStringGaplexChar lexEscapereadNum readNumAccsillyEscapeCharspragmafpragmaalexScanGHC.Err undefinedAttr attrRangeattrNametheAttr happyErrortakeOptionsPragmasfigureOutTopLevelModulemkQName mkDomainFree_ pragmaQNameisNameforallPirawAppUnlessSingletonaddType exprAsTeleexprToAssignmentbuildWithBlock buildWithStmtdefaultBuildDoStmtverifyImportDirectivevalidHaskellModuleName exprToLHS exprToPattern exprToName maybeNamed toAttribute applyAttr applyAttrs setTacticAttr getTacticAttrcheckForUniqueAttributeerrorConflictingAttributeerrorConflictingAttributesHappyStk returnEOFskipTonumber qualified getOffside withCommentswithoutCommentsparseLiterateFile SingleFlexRig SingleVarOccfreeIn'Data.IntMap.Internal execChangeT evalUpdater MakePrivate MakeAbstractNiceEnv _loneSigs_termChk_posChk_uniChk _catchall_covChkniceWarn DataRecOrFunInMutual NotInMutual KindOfBlockPostulateBlockPrimitiveBlock InstanceBlock FieldBlock DataBlockcombineTerminationChecks initNiceEnvloneSigs addLoneSig removeLoneSiggetSig noLoneSigsforgetLoneSigsloneFunsloneSigsFromLoneNamesLoneSigsterminationCheckPragmapositivityCheckPragmauniverseCheckPragmagetUniverseCheckFromSigcatchallPragmapopCatchallPragma niceWarning replaceSigs NiceWarnings getBinDir getLibDir getDynLibDir getDataDir getLibexecDir getSysconfDirgetDataFileName LibErrorIOLibError LibError' LibNotFound AmbiguousLib OtherErrorlfPathlfExistsmkLibM getAgdaAppDirdefaultLibraryFiles defaultsFilefindProjectConfigfindAgdaLibFilesreadDefaultsFilegetLibrariesFile parseLibFilesstripCommentLinesfindLibhasMatchformatLibErrordefaultLaTeXDirdefaultHTMLDirdeadPragmaOptionsControl.Monad.State.Class MonadStateControl.Monad.Trans.State.LazyStateTControl.Monad.Trans.ReaderReaderT)hashtables-1.2.3.4-HwgKsbBEpQn4f8xE5igDrFData.HashTable.IOCuckooHashTableBasicHashTableLinearHashTable benchmarkingonlyOnce Text.ReadreadsPatternCheckConfigtopNameconNamesfldNamesParseLHSParsers buildParsersExprKind argsParser operatorsflattenedScopeInternalParsers billToParsergetDefinedNames localNamesparsePat parseLHS'classifyPatternvalidConPatternqualifierModules takenVarNames takenDefNamesbuiltins preserveIIds addBinding isBuiltinFun resolveName_unsafeQNameToNamelookupNameInScopehasConcreteNamespickConcreteNameshadowingNames chooseNamebracket'bracket bracketP_isLambda withInfixDeclwithAbstractPrivatebindToConcreteCtx toConcreteTopbindToConcreteToptoConcreteHidingbindToConcreteHidingtryToRecoverPatternSyntryToRecoverPatternSynPrecoverPatternSyn recoverOpApp withNames'Encoded uncompressed compressed icodeFileModSynEqMinequalifEqualmatchLeq inequalitiesNamesPerClausemarkNonRecursive markRecursiverecDef BlankVarsappsnelimsisSelfelimsreifyDisplayFormnameFirstIfHiddenremoveNameUnlessUserWrittenstripImplicitstryRecPFromConPzipWithMForcedVariables RecordTreeLeafRecConVarPatDotPatKindRecPatMDropFrom conjColumnsrecordExpressionsToCopatterns runRecPatMnextVar projections removeTreetranslatePattern recordTree translateTelData.Sequence.Internal MatchResultSplitInstantiationzipBlockingVarschoiceBlockedOnResult matchPatscombinematchPatunDotP IndefinitedropTopLevelModule' prettyInEqualinitialInstanceCandidates findInstance'insidePifilterResetingStatecheckCandidatesapplyDroppingParametersvarTeleqTeleqLHSeqRHS getVarType getEqualitygetEqualityUnraisedsolveVarsolveEqisHompatternBindingForcedVars UnifyState MetasToVarsabstractOverMetasidHole composeHoleohAddBVforceEtaExpansion ControlFrameCaseKArgK NormaliseKForceKEraseKNatSucKPrimOpK UpdateThunkApplyK SpineContextCatchAll MatchStack ControlStackAMEval GHC.STRefSTRefIsValueThunkPointerPure BlackHoleSpineFastCompiledClausesFCaseFEtaFDoneFFail fprojPatterns fconBranches flitBranchesfcatchAllBranch ffallThroughCForceCEraseCTyConCAxiomCPrimOpCOther compactDef CompactDefclApplyclApply_ derefPointer_unsafeDerefPointer createThunk pureThunk lookupEnv_topMetaIsNotBlocked decodeSpineGHC.STunsafeInterleaveST decodeEnv decodeClosure elimsToSpinetrimEnvironmentbuildEnvreduceTm BuiltinEnv:>>:createMetasAndTypeCheck withGenRecVarcomputeGeneralizationpruneUnsolvedMetas unpackSubbuildGeneralizeTelcreateGenValuescreateGenValuecreateGenRecordTypefillInGenRecordDetails fullyApplyCon checkArgInfocheckRelevanceinferDef inferDef' inferSpine inferSpine'shouldBeProjectiblecmptype eliminate checkSpineStripAllProjections ExtractCallsCalls termDecl' termMutual'terminationError reportCalls termFunction typeEndsInDeftermDeftermTypesetMasks targetElem termToDBPmaskNonDataArgs termClause constructorfunctiontryReduceNonRecursiveClause maskSizeLt compareElim compareProjmakeCMaddGuardednesscomposeGuardednessoffsetFromConstructorreduceConPatternsubTerm compareVarVar$aeson-1.4.6.0-LcSYXcfnqPGJn2oypd2CJoData.Aeson.Types.InternalEESt_funMapFunInfo_typeMapTypeInfopruneUnreachable pruneIntCase showAspects NameKindstokenHighlighting nameKindsgenerateConstructorInfoterminationErrorHighlightingpositivityErrorHighlightinggenerate nameToFile nameToFileAupdateLHSStateupdateProblemEqsisSolvedProblemproblemAllVariablesnoShadowingOfConstructorscheckDotPatterntransferOriginscomputeLHSContextrecheckStrippedWithPattern splitStrategycheckLHSnoPatternMatchingOnCodata suspendErrors softTypeError hardTypeErrordisambiguateProjectiondisambiguateConstructorcheckConstructorParameterscheckParametersinductiveCheckcheckBuiltinBoolbindBuiltinDatabindBuiltinEqualityWithRHS'_rhsRewriteEqn _rhsWithExpr_rhsSubclauses _rhsWhereName_rhsWhereDeclsLivesInCurrentModuleEnsureNoLetStms ResolveQName MaybeOldQNamenoDotorEqPatternrecordConstructorTypecheckModuleMacronotPublicWithoutOpen renamingRange checkOpen toAbstractCtxlocalToAbstract'bindPatternVariablemkArg' toAbstractDot toAbstractLamscopeCheckExtendedLamscopeCheckNiceModuletelHasOpenStmsOrModuleMacrosscopeCheckModule niceDeclsbindGeneralizablesIfInserted clashUnless*clashIfModuleAlreadyDefinedInCurrentModulebindRecordConstructorName applyAPatterntoAbstractOpArgtoAbstractOpAppbindConstructorNamewhereToAbstractAllowPartialCoverInsertTrailing coverPatterns fixTargetTypecovercreateMissingHCompClauseinferMissingClausecomputeNeighbourhoodsplitlookupPatternVarsplit'splitResultPathsplitResultRecordcomputeHCompSplitDoInsertTrailing FailBecauseccCxt ccCatchAllgetCompiledClauses cacheTreeless lookupLevel casetreeTopwithContextSize lambdasUpTo replaceVarmkRecord substTermetaContractErased&inferOrCheckProjAppToKnownPrincipalArgcheckConstructorApplication MaybeRanges inferHeadcheckRelevance'checkQuantity'checkModality' checkModalitycheckHeadApplicationcoerce'checkArgumentsE inferProjAppinferOrCheckProjApp checkProjApppathAbs checkPrimCompcheckPrimHCompcheckPrimTrans check_glue check_glueUcheckArgumentsE'getEqCombinatorsgenericNotEnough compilerMain otherBackends codeBlockcolumncolumns columnsPrevnextId usedColumns countClustersAlignmentColumncolumnCodeBlock columnColumn columnKindIndentationColumnId Indentation AlignmentOutput MaybeColumn agdaSpacedebugsrunLaTeXisSpacesisSpaceNotNewline replaceSpacesmoveColumnForToken resetColumnregisterColumn useColumn columnZeroregisterColumnZero enterCode leaveCode columnNameptOpen'ptOpenptOpenBeginningOfLine ptOpenIndent processMarkupprocessComment processCodespaces stringLiteraltoLaTeX emptyState processTokensControl.Monad.Trans.ClassControl.Monad.IO.ClassliftIOlispifyResponseformatlastTag showNumIIdformatWarningsAndErrorsprettyResponseContext prettyTimedjsonifyResponse TokenInfoPageGen rstDelimiterhighlightOnlyCodehighlightedFileExt modToFile!!